Android - Fade-out " bitmap-Bild auf Leinwand

Ich bin Zeichnung eine bitmap skaliert auf eine Leinwand und möchte zu verblassen, mein Bild zu einem bestimmten Zeitpunkt.

Grundsätzlich, wenn mein Charakter Bild geht über einen bestimmten Abschnitt der Leinwand, ich verlange, dass das Zeichen, langsam zu verblassen (3 Sekunden), bevor die Seite automatisch re-leitet, um die nächste java-Klasse.

Derzeit ist mein Bild einfach nur Weiterleitungen auf die neue java-Klasse, bitte sehen Sie unten einige code-wie erstelle ich mein Bild.

Resources res = getResources();
float px = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 20, res.getDisplayMetrics());
imgSpacing = (int) px / 2;
int size = (int) ((PhoneWidth / 5) - px);

chrImg = BitmapFactory.decodeResource(getResources(), R.drawable.character);
chrImg = Bitmap.createScaledBitmap(chrImg, size, size, true);

Dann innerhalb der Leinwand onDraw:

if(indexX == mazeFinishX && indexY == mazeFinishY)
{
    canvas.drawBitmap(finish, j * totalCellWidth, i * totalCellHeight, null);
    //As soon as the character moves over this square they are automatically re-directed to new page
    //This is where I want to fade the character image out before the re-direct
}

Ich habe online geschaut, aber nicht so Recht geklappt, wie man das ausbleichen zu arbeiten, für meine drawable Bild geholt von meinen spielen, die Ressourcen-drawable-Ordner. Dank

InformationsquelleAutor SingleWave Games | 2013-08-14

Wenn Sie denken, es ist eine Möglichkeit, Sie wollen, ändern Sie die fade-animation die Straße hinunter, wie skalieren und/oder drehen, dann sollten Sie gehen mit einer animation in XML.

Aber nur für eine schnelle bitmap fade, können Sie immer wieder post verzögert Aufhebungs-Nachrichten. Sie wollen wahrscheinlich begrenzen Sie Ihre für ungültig erklärt Gegend, wo dein Charakter bitmap:

private static final int FADE_MILLISECONDS = 3000; //3 second fade effect
private static final int FADE_STEP = 120;          //120ms refresh

//Calculate our alpha step from our fade parameters
private static final int ALPHA_STEP = 255 / (FADE_MILLISECONDS / FADE_STEP);

//Initializes the alpha to 255
private Paint alphaPaint = new Paint();

//Need to keep track of the current alpha value
private int currentAlpha = 255;

@Override
protected void onDraw(Canvas canvas) {
    ...
    if(indexX == mazeFinishX && indexY == mazeFinishY) {

        //Drawing your wormhole?
        int x = j * totalCellWidth;
        int y = i * totalCellHeight;
        canvas.drawBitmap(finish, x, y, null);

        if (currentAlpha > 0) {

           //Draw your character at the current alpha value
           canvas.drawBitmap(chrImg, x, y, alphaPaint);

           //Update your alpha by a step
           alphaPaint.setAlpha(currentAlpha);
           currentAlpha -= ALPHA_STEP;

           //Assuming you hold on to the size from your createScaledBitmap call
           postInvalidateDelayed(FADE_STEP, x, y, x + size, y + size);

        } else {
           //No character draw, just reset your alpha paint
           currentAlpha = 255;
           alphaPaint.setAlpha(currentAlpha);

           //Now do your redirect
        }
    }
    ...
}

Ich würde empfehlen, die Konstanten FADE_MILLISECONDS und FADE_STEP in res/integers.xml nur, damit Sie nicht hart codiert.

Ich habe Erfahrung in deinem obigen Codes und das ausbleichen ist korrekt arbeitet. Aber das Problem hier ist die Tatsache, dass meine re-direct funktioniert nicht. Es hat die Funktion, mit der redirect-code, jedoch scheint es zu ignorieren, irgendwelche Ideen?
Ich habe eine "currentAlpha" - Feld, mit setAlpha/getAlpha wohl nicht funktioniert mit alles andere als ein alpha-Schritt 1.

InformationsquelleAutor Dane White

Den besten Weg für mich zu erklären, das ist eine vollständige benutzerdefinierte Ansicht, dass Sie beispielsweise ziehen die Stücke aus, die Sie benötigen. Unten ist eine Ansicht, die das leistet dieses.

public class CharacterView extends View {

    private Paint mCharacterPaint;
    private Bitmap mCharacterBitmap;
    private Transformation mTransformation;
    private AlphaAnimation mFadeOut;

    public CharacterView(Context context) {
        super(context);
        init(context);
    }

    public CharacterView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public CharacterView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    private void init(Context context) {
        //This would be your character image instead
        mCharacterBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);

        //We need a paint to efficiently modify the alpha
        mCharacterPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //This is needed to house the current value during the animation
        mTransformation = new Transformation();
        //Construct an animation that will do all the timing math for you
        mFadeOut = new AlphaAnimation(1f, 0f);
        mFadeOut.setDuration(500);
        //Use a listener to trigger the end action
        mFadeOut.setAnimationListener(new Animation.AnimationListener() {
            @Override
            public void onAnimationStart(Animation animation) { }

            @Override
            public void onAnimationEnd(Animation animation) {
                //Trigger your action to change screens here.
            }

            @Override
            public void onAnimationRepeat(Animation animation) { }
        });
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            //In this example, touching the view triggers the animation
            //your code would run this sequence when the character reaches the
            //appropriate coordinates (P.S. I would not advocate putting this code
            //inside of onDraw()
            mFadeOut.start();
            mFadeOut.getTransformation(System.currentTimeMillis(), mTransformation);
            invalidate();
        }
        return true;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        //...existing drawing code...

        canvas.drawBitmap(mCharacterBitmap, 0, 0, mCharacterPaint);
        if (mFadeOut.hasStarted() && !mFadeOut.hasEnded()) {
            mFadeOut.getTransformation(System.currentTimeMillis(), mTransformation);
            //Keep drawing until we are done
            mCharacterPaint.setAlpha((int)(255 * mTransformation.getAlpha()));
            invalidate();
        } else {
            //Reset the alpha if animation is canceled
            mCharacterPaint.setAlpha(255);
        }
    }
}

Der effizienteste Weg, um dynamisch ändern Sie die Transparenz von dem, was Sie zeichnen, wird es auch anwenden mit einem Paint Zeichnung bis zu Ihrer Canvas. Sie müssen ständig invalidate() die Ansicht, die mit jedem Bild Umschalten, um die animation anzuzeigen, bis das Zeichen Weg ist. Das Beispiel verwendet eine Animation Objekt und ein Transformation Objekt mit all den timing-Mathematik, um die animation wirklich gut Aussehen.

Die Kernaussage hier ist, dass Sie starten Sie die animation durch einen externen trigger (ich würde nicht empfehlen, tun das überprüfen, denn wenn fade out in onDraw() wahrscheinlich besser in den Ort, wo diese Zeichen Standorte aktualisiert werden. In meinem Beispiel, der Einfachheit halber, ich habe diese, wenn die Ansicht berührt.

Dieser trigger startet die animation und erhält die Initiale transformation Wert, dann invalidate() löst eine neue onDraw(). Während die animation läuft, onDraw() wiederholt aufgrund der invalidate() und jede iteration der alpha auf den Lack leicht abnimmt.

Wenn die animation fertig ist, wird Sie rufen den AnimationListener für Sie, so können Sie auslösen des screen-übergang innerhalb der onAnimationEnd().

Sie sollten nur dann zum erlöschen der Bereich, wo die Figur ist neu gezeichnet wird.
Dies kann eine schöne Optimierung, wenn das Gesamtbild ist groß. Obwohl in vielen gemeinsamen Fällen (wie mit hardware-Beschleunigung aktiviert) dirty rects sind eigentlich ignoriert; so ist es in der Regel nicht Wert die Mühe, es sei denn, einschließlich Leistung garantiert.
Diese Antwort aus einem der Android-Entwickler scheint dem zu widersprechen deiner Behauptung, dass die hardware-Beschleunigung ignoriert dirty Regionen: stackoverflow.com/questions/7233830/...
Ich würde auf jeden Fall Vertrauen Romain, ist das Wort auf das Thema vor allem. In der Tat, der Fall Tätigkeit fortsetzen, die er beschreibt, ist das, was ich dachte. Cheers.

InformationsquelleAutor Devunwired

        if(indexX == mazeFinishX && indexY == mazeFinishY)
        {
            canvas.drawBitmap(finish, j * totalCellWidth, i * totalCellHeight, null);
            //As soon as the character moves over this square they are automtically re-directs to new page
            new CountDownTimer(0500, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {}
                @Override
                public void onFinish() {
Paint paint = new Paint();
paint.setAlpha(25);
canvas.drawBitmap(chrImg, 0, 0, paint);
                }
            }.start();
            new CountDownTimer(0500, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {}
                @Override
                public void onFinish() {
Paint paint = new Paint();
paint.setAlpha(45);
canvas.drawBitmap(chrImg, 0, 0, paint);             }
            }.start();
            new CountDownTimer(0500, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {}
                @Override
                public void onFinish() {
Paint paint = new Paint();
paint.setAlpha(70);
canvas.drawBitmap(chrImg, 0, 0, paint);             }
            }.start();
            new CountDownTimer(0500, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {}
                @Override
                public void onFinish() {
Paint paint = new Paint();
paint.setAlpha(100);
canvas.drawBitmap(chrImg, 0, 0, paint);             }
            }.start();
            //This is where I want to fade the character image out before the re-direct
            new CountDownTimer(3000, 1000) {

            @Override
            public void onTick(long millisUntilFinished) {
                //TODO Auto-generated method stub

            }

            @Override
            public void onFinish() {
                //TODO Auto-generated method stub

                    Intent i = new Intent(currentclass.this, nextClass.class);
                    startActivity(i);
            }
        }.start();

    }

dadurch wird die bitmap transparent wird ( die alpha 100 ) .. und dann umleiten auf die nächste Klasse nach 3 Sekunden.

Update:
für das bitmap, das Sie nicht verwenden können .setAlpha also wir müssen eine Farbe, so haben wir eine neue Farbe jedes mal, wenn dann die bitmap mit der Farbe. aber wenn Sie eine Bildansicht, die Sie verwenden können .setalpha

Dies funktioniert in der Verzögerung der Weiterleitung, jedoch möchte ich es so machen das Bild langsam verblasst. Esentially, ich habe ein Wurm-Loch-Bild und möchte das Zeichen zu verschwinden, die über irgendeine Art animation (ich dachte verblassen das Bild entfernt).
Habe gerade versucht deinen code, jedoch realisiert, dass, wie es ist, ein bitmap aus dem drawable-Ressourcen verwenden können Sie setAlpha. Gibt es einen anderen Weg, finden Sie in meinem orginal code zu replizieren das Bild.
Ich aktualisierte den code, überprüfen Sie es jetzt.

InformationsquelleAutor Ahmed Ekri

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.