From 7ed703fcbbbeb98bcc9a10a6eac141c9288dbad7 Mon Sep 17 00:00:00 2001 From: Jorge Ruesga Date: Thu, 8 Aug 2013 16:56:30 +0200 Subject: Flip transition (#3) Signed-off-by: Jorge Ruesga --- res/values/arrays.xml | 2 + res/values/strings.xml | 1 + .../photophase/transitions/FlipTransition.java | 254 +++++++++++++++++++++ .../photophase/transitions/Transition.java | 2 +- .../photophase/transitions/Transitions.java | 12 +- 5 files changed, 268 insertions(+), 3 deletions(-) create mode 100644 src/org/cyanogenmod/wallpapers/photophase/transitions/FlipTransition.java diff --git a/res/values/arrays.xml b/res/values/arrays.xml index b905587..e3ae649 100644 --- a/res/values/arrays.xml +++ b/res/values/arrays.xml @@ -52,12 +52,14 @@ @string/transitions_swap @string/transitions_fade @string/transitions_translation + @string/transitions_flip 1 2 3 + 4 diff --git a/res/values/strings.xml b/res/values/strings.xml index 49f527c..5796885 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -106,6 +106,7 @@ Swap Fade Translation + Flip Autofix diff --git a/src/org/cyanogenmod/wallpapers/photophase/transitions/FlipTransition.java b/src/org/cyanogenmod/wallpapers/photophase/transitions/FlipTransition.java new file mode 100644 index 0000000..70f9a6f --- /dev/null +++ b/src/org/cyanogenmod/wallpapers/photophase/transitions/FlipTransition.java @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2013 The CyanogenMod Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.cyanogenmod.wallpapers.photophase.transitions; + +import android.content.Context; +import android.opengl.GLES20; +import android.opengl.GLException; +import android.opengl.Matrix; +import android.os.SystemClock; + +import org.cyanogenmod.wallpapers.photophase.GLESUtil; +import org.cyanogenmod.wallpapers.photophase.PhotoFrame; +import org.cyanogenmod.wallpapers.photophase.R; +import org.cyanogenmod.wallpapers.photophase.TextureManager; +import org.cyanogenmod.wallpapers.photophase.transitions.Transitions.TRANSITIONS; + +import java.nio.FloatBuffer; + +/** + * A transition that applies a translation transition to the picture. + */ +public class FlipTransition extends Transition { + + /** + * The enumeration of all possibles translations movements + */ + public enum FLIP_MODES { + /** + * Flip the picture horizontally + */ + HORIZONTAL, + /** + * Flip the picture vertically + */ + VERTICAL + } + + private static final int[] VERTEX_SHADER = {R.raw.default_vertex_shader, R.raw.default_vertex_shader}; + private static final int[] FRAGMENT_SHADER = {R.raw.default_fragment_shader, R.raw.default_fragment_shader}; + + private static final float TRANSITION_TIME = 6000.0f; + + private FLIP_MODES mMode; + + private boolean mRunning; + private long mTime; + + /** + * Constructor of FlipTransition + * + * @param ctx The current context + * @param tm The texture manager + */ + public FlipTransition(Context ctx, TextureManager tm) { + super(ctx, tm, VERTEX_SHADER, FRAGMENT_SHADER); + + // Initialized + reset(); + } + + /** + * {@inheritDoc} + */ + @Override + public TRANSITIONS getType() { + return TRANSITIONS.FLIP; + } + + /** + * {@inheritDoc} + */ + @Override + public boolean hasTransitionTarget() { + return true; + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isRunning() { + return mRunning; + } + + /** + * {@inheritDoc} + */ + @Override + public void select(PhotoFrame target) { + super.select(target); + + // Random mode + FLIP_MODES[] modes = FLIP_MODES.values(); + int low = 0; + int hight = modes.length - 1; + mMode = modes[(low + (int)(Math.random() * ((hight - low) + 1)))]; + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isSelectable(PhotoFrame frame) { + return true; + } + + /** + * {@inheritDoc} + */ + @Override + public void reset() { + mTime = -1; + mRunning = true; + } + + /** + * {@inheritDoc} + */ + @Override + public void apply(float[] matrix) throws GLException { + // Check internal vars + if (mTarget == null || + mTarget.getPositionBuffer() == null || + mTarget.getTextureBuffer() == null) { + return; + } + if (mTransitionTarget == null || + mTransitionTarget.getPositionBuffer() == null || + mTransitionTarget.getTextureBuffer() == null) { + return; + } + + // Set the time the first time + if (mTime == -1) { + mTime = SystemClock.uptimeMillis(); + } + + // Calculate the delta time + final float delta = Math.min(SystemClock.uptimeMillis() - mTime, TRANSITION_TIME) / TRANSITION_TIME; + + // Apply the transition + applyTransition(delta, matrix, delta <= 0.5 ? mTarget : mTransitionTarget); + + // Transition ending + if (delta == 1) { + mRunning = false; + } + } + + /** + * Apply the transition + * + * @param delta The delta time + * @param matrix The model-view-projection matrix + * @param target The photo frame target + */ + private void applyTransition(float delta, float[] matrix, PhotoFrame target) { + // Retrieve the index of the structures + int index = delta <= 0.5f ? 0 : 1; + + // Bind default FBO + GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0); + GLESUtil.glesCheckError("glBindFramebuffer"); + + // Set the program + useProgram(index); + + // Disable blending + GLES20.glDisable(GLES20.GL_BLEND); + GLESUtil.glesCheckError("glDisable"); + + // Set the input texture + int textureHandle = target.getTextureHandle(); + GLES20.glActiveTexture(GLES20.GL_TEXTURE0); + GLESUtil.glesCheckError("glActiveTexture"); + GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle); + GLESUtil.glesCheckError("glBindTexture"); + GLES20.glUniform1i(mTextureHandlers[index], 0); + GLESUtil.glesCheckError("glBindTexture"); + + // Texture + FloatBuffer textureBuffer = target.getTextureBuffer(); + textureBuffer.position(0); + GLES20.glVertexAttribPointer(mTextureCoordHandlers[index], 2, GLES20.GL_FLOAT, false, 0, textureBuffer); + GLESUtil.glesCheckError("glVertexAttribPointer"); + GLES20.glEnableVertexAttribArray(mTextureCoordHandlers[index]); + GLESUtil.glesCheckError("glEnableVertexAttribArray"); + + // Position + FloatBuffer positionBuffer = target.getPositionBuffer(); + positionBuffer.position(0); + GLES20.glVertexAttribPointer(mPositionHandlers[index], 2, GLES20.GL_FLOAT, false, 0, positionBuffer); + GLESUtil.glesCheckError("glVertexAttribPointer"); + GLES20.glEnableVertexAttribArray(mPositionHandlers[index]); + GLESUtil.glesCheckError("glEnableVertexAttribArray"); + + // Calculate the delta angle and the translation and rotate parameters + float angle = (delta * 90) / 0.5f; + if (index == 1) { + angle = 90 - ((delta - 0.5f) * 90) / 0.5f; + } + float translateX = 0.0f; + float translateY = 0.0f; + float rotateX = 0.0f; + float rotateY = 0.0f; + switch (mMode) { + case HORIZONTAL: + rotateY = -1.0f; + translateX = (mTarget.getFrameVertex()[2] - ((mTarget.getFrameVertex()[2] - mTarget.getFrameVertex()[0]) / 2)) * -1; + break; + case VERTICAL: + rotateX = -1.0f; + translateY = (mTarget.getFrameVertex()[5] - ((mTarget.getFrameVertex()[5] - mTarget.getFrameVertex()[1]) / 2)) * -1; + break; + + default: + break; + } + + // Apply the projection and view transformation + float[] translationMatrix = new float[16]; + Matrix.setIdentityM(matrix, 0); + Matrix.translateM(translationMatrix, 0, matrix, 0, -translateX, -translateY, 0.0f); + Matrix.rotateM(translationMatrix, 0, translationMatrix, 0, angle, rotateX, rotateY, 0.0f); + Matrix.translateM(translationMatrix, 0, translationMatrix, 0, translateX, translateY, 0.0f); + GLES20.glUniformMatrix4fv(mMVPMatrixHandlers[index], 1, false, translationMatrix, 0); + GLESUtil.glesCheckError("glUniformMatrix4fv"); + + // Draw + GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4); + GLESUtil.glesCheckError("glDrawElements"); + + // Disable attributes + GLES20.glDisableVertexAttribArray(mPositionHandlers[index]); + GLESUtil.glesCheckError("glDisableVertexAttribArray"); + GLES20.glDisableVertexAttribArray(mTextureCoordHandlers[index]); + GLESUtil.glesCheckError("glDisableVertexAttribArray"); + } + +} diff --git a/src/org/cyanogenmod/wallpapers/photophase/transitions/Transition.java b/src/org/cyanogenmod/wallpapers/photophase/transitions/Transition.java index 82a8eea..36a5ea6 100644 --- a/src/org/cyanogenmod/wallpapers/photophase/transitions/Transition.java +++ b/src/org/cyanogenmod/wallpapers/photophase/transitions/Transition.java @@ -29,7 +29,7 @@ import org.cyanogenmod.wallpapers.photophase.transitions.Transitions.TRANSITIONS */ public abstract class Transition { - public static final long MAX_TRANSTION_TIME = 1500L; + public static final long MAX_TRANSTION_TIME = 15000L/* FIXME 1500L*/; protected final Context mContext; private final TextureManager mTextureManager; diff --git a/src/org/cyanogenmod/wallpapers/photophase/transitions/Transitions.java b/src/org/cyanogenmod/wallpapers/photophase/transitions/Transitions.java index 37c2e93..6aac3ce 100644 --- a/src/org/cyanogenmod/wallpapers/photophase/transitions/Transitions.java +++ b/src/org/cyanogenmod/wallpapers/photophase/transitions/Transitions.java @@ -50,7 +50,11 @@ public class Transitions { /** * @see TranslateTransition */ - TRANSLATION; + TRANSLATION, + /** + * @see FlipTransition + */ + FLIP; /** * Method that returns the transition from its ordinal position @@ -60,7 +64,7 @@ public class Transitions { */ public static TRANSITIONS fromOrdinal(int ordinal) { for (TRANSITIONS transition : TRANSITIONS.values()) { - if (transition.ordinal() == ordinal){ + if (transition.ordinal() == ordinal) { return transition; } } @@ -109,6 +113,8 @@ public class Transitions { return TRANSITIONS.FADE; } else if (nextTransition.compareTo(TRANSITIONS.TRANSLATION) == 0) { return TRANSITIONS.TRANSLATION; + } else if (nextTransition.compareTo(TRANSITIONS.FLIP) == 0) { + return TRANSITIONS.FLIP; } return TRANSITIONS.NO_TRANSITION; } @@ -130,6 +136,8 @@ public class Transitions { return new FadeTransition(ctx, tm); } else if (type.compareTo(TRANSITIONS.TRANSLATION) == 0) { return new TranslateTransition(ctx, tm); + } else if (type.compareTo(TRANSITIONS.FLIP) == 0) { + return new FlipTransition(ctx, tm); } return new NullTransition(ctx, tm); } -- cgit v1.2.3