Magic Cube

import org.distorted.library.effect.Effect;

import org.distorted.library.message.EffectMessage;

public abstract class TransitionEffect implements EffectListener

    DISAPPEAR  (TransitionEffectDisappear.class),

    /**

     * Move the old cube to the right and the new one from the left.

     */

    MOVE       (TransitionEffectMove.class);

  private final int MOVE_POSITION;

  private long mDisappearID, mAppearID;

  private EffectListener mListener;

  private DistortedScreen mScreen;

  private RubikCube mOld, mNew;

  Effect mDisappear, mAppear;

///////////////////////////////////////////////////////////////////////////////////////////////////

  TransitionEffect(int position)

    {

    MOVE_POSITION = position;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// whenever we get the message that the old cube completely disappeared, make the new one appear

// The calling RubikRenderer will get the message that this (final) transition is over and do whatever

// it wants to do with this.

  public void effectMessage(final EffectMessage em, final long effectID, final long objectID)

    {

    if( effectID == mDisappearID )

      {

      mScreen.detach(mOld);

      mOld.remove(mDisappearID);

      mOld.deregisterForMessages(this);

      mNew.apply(mAppear,MOVE_POSITION);

      mNew.registerForMessages(mListener);

      mScreen.attach(mNew);

      }

    }

  public long start(DistortedScreen screen, RubikCube oldCube, RubikCube newCube,EffectListener listener)

    {

    mScreen   = screen;

    mNew      = newCube;

    mOld      = oldCube;

    mListener = listener;

    mDisappearID = mDisappear.getID();

    mAppearID    = mAppear.getID();

    mOld.apply(mDisappear,MOVE_POSITION);

    mOld.registerForMessages(this);

    return mAppearID;

    }

  public static TransitionEffect create(Type type) throws InstantiationException, IllegalAccessException

class TransitionEffectDisappear extends TransitionEffect

    super(-1);

    final int DURATION_IN_MILLIS = 1000;

    Dynamic1D disappearDyn = new Dynamic1D(DURATION_IN_MILLIS, 0.5f);

    disappearDyn.add(new Static1D(1.0f));

    disappearDyn.add(new Static1D(0.0f));

    Dynamic1D appearDyn = new Dynamic1D(DURATION_IN_MILLIS, 0.5f);

    appearDyn.add(new Static1D(0.0f));

    appearDyn.add(new Static1D(1.0f));

// enable all effects used in this Transition.

// called by reflection from the parent class.

  @SuppressWarnings("unused")

  static void enable()

    FragmentEffectAlpha.enable();

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

    super(-1);

    final int DURATION_IN_MILLIS = 1;

    Dynamic3D disappearDyn = new Dynamic3D(DURATION_IN_MILLIS, 0.5f);

    disappearDyn.add(new Static3D(0,0,0));

    mDisappear = new MatrixEffectMove(disappearDyn);

    Dynamic3D appearDyn = new Dynamic3D(DURATION_IN_MILLIS, 0.5f);

    appearDyn.add(new Static3D(0,0,0));

    mAppear = new MatrixEffectMove(appearDyn);

// enable all effects used in this Transition (here: none).

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

import static org.distorted.magic.RubikRenderer.TEXTURE_SIZE;

///////////////////////////////////////////////////////////////////////////////////////////////////

class TransitionEffectMove extends TransitionEffect

  {

  TransitionEffectMove()

    {

    super(2);

    final int DURATION_IN_MILLIS = 1000;

    Dynamic3D disappearDyn = new Dynamic3D(DURATION_IN_MILLIS, 0.5f);

    disappearDyn.add(new Static3D(0,0,0));

    disappearDyn.add(new Static3D(TEXTURE_SIZE,0,0));

    mDisappear = new MatrixEffectMove(disappearDyn);

    Dynamic3D appearDyn = new Dynamic3D(DURATION_IN_MILLIS, 0.5f);

    appearDyn.add(new Static3D(-TEXTURE_SIZE,0,0));

    appearDyn.add(new Static3D(0,0,0));

    mAppear = new MatrixEffectMove(appearDyn);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// enable all effects used in this Transition. Called by reflection from the parent class.

// Matrix Effects do not have to be enabled.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }

import org.distorted.library.mesh.MeshQuad;

public class RubikCube extends DistortedNode

    private Static3D mMove, mScale, mNodeMove, mNodeScale;

    private DistortedTexture mNodeTexture;

    RubikCube(int size, Static4D quatC, Static4D quatA, DistortedTexture texture, MeshQuad mesh, DistortedEffects effects)

      super(texture,effects,mesh);

      mNodeTexture = texture;

      mMove     = new Static3D(0,0,0);

      mScale    = new Static3D(1,1,1);

      mNodeMove = new Static3D(0,0,0);

      mNodeScale= new Static3D(1,1,1);

      MatrixEffectMove       nodeMoveEffect  = new MatrixEffectMove(mNodeMove);

      MatrixEffectScale      nodeScaleEffect = new MatrixEffectScale(mNodeScale);

      effects.apply(nodeMoveEffect);

      effects.apply(nodeScaleEffect);

              mNodes[x][y][z] = new DistortedNode(mTexture,mEffects[x][y][z],mCubes[x][y][z]);

              attach(mNodes[x][y][z]);

    public void apply(Effect effect)

              mEffects[x][y][z].apply(effect);

    public void apply(Effect effect, int position)

              mEffects[x][y][z].apply(effect, position);

              }

            }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void remove(long effectID)

      {

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            {

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mEffects[x][y][z].abortById(effectID);

     int texW = mNodeTexture.getWidth();

     int texH = mNodeTexture.getHeight();

     if( (float)texH/texW > (float)screenHeight/screenWidth )

       {

       int w = (screenHeight*texW)/texH;

       float factor = (float)screenHeight/texH;

       mNodeMove.set((screenWidth-w)*0.5f ,0, 0);

       mNodeScale.set(factor,factor,factor);

       }

     else

       {

       int h = (screenWidth*texH)/texW;

       float factor = (float)screenWidth/texW;

       mNodeMove.set(0,(screenHeight-h)*0.5f,0);

       mNodeScale.set(factor,factor,factor);

       }

     float scaleFactor = (size/(TEXTURE_SIZE*mSize)) * (float)texW/(screenWidth>screenHeight ? screenHeight:screenWidth);

     mMove.set( (texW-scaleFactor*TEXTURE_SIZE)/2 , (texH-scaleFactor*TEXTURE_SIZE)/2 , -scaleFactor*TEXTURE_SIZE/2 );

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshQuad;

public class RubikRenderer implements GLSurfaceView.Renderer, EffectListener

    public  static final int TEXTURE_SIZE = 600;

    private MeshQuad mMesh;

      mMesh= new MeshQuad();

          TransitionEffect effect = TransitionEffect.create(TransitionEffect.Type.EMPTY);

          mTransitionEffectID = effect.start(mScreen,mOldCube,mNewCube,this);

       mNewCube.remove(mTransitionEffectID);

       mNewCube.deregisterForMessages(this);

      mScreen.attach(mNewCube);

       DistortedTexture texture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);

       DistortedEffects effects = new DistortedEffects();

       mNewCube = new RubikCube(newSize, mQuatCurrent, mQuatAccumulated, texture, mMesh, effects);