Magic Cube

import org.distorted.effects.sizechange.SizeChangeEffect;

    SIZECHANGE  ( 20, 1, R.string.sizechange_effect , SizeChangeEffect.class),

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.effects.BaseEffect;

import org.distorted.library.effect.Effect;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.main.RubikPostRender;

import org.distorted.objects.RubikObject;

import java.lang.reflect.Method;

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

public abstract class SizeChangeEffect extends BaseEffect implements EffectListener

{

  public enum Type

    {

    NONE         (SizeChangeEffectNone.class        ),

    TRANSPARENCY (SizeChangeEffectTransparency.class),

    MOVE         (SizeChangeEffectMove.class        ),

    ROUND        (SizeChangeEffectRound.class       ),

    SCALE        (SizeChangeEffectScale.class       ),

    ;

    final Class<? extends SizeChangeEffect> effect;

    Type(Class<? extends SizeChangeEffect> effect)

      {

      this.effect= effect;

      }

    }

  private static int NUM_EFFECTS = Type.values().length;

  private static final int NUM_PHASES  = 2;

  private static final int FAKE_EFFECT_ID  = -1;

  private static final Type[] types;

  static

    {

    int i=0;

    types = new Type[NUM_EFFECTS];

    for(Type type: Type.values())

      {

      types[i++] = type;

      }

    }

  private EffectListener mListener;

  private int mDuration;

  private int[] mEffectReturned;

  private int[] mCubeEffectNumber, mNodeEffectNumber;

  private int[] mEffectFinished;

  private boolean[] mPhaseActive;

  private RubikObject[] mObject;

  DistortedScreen mScreen;

  Effect[][] mCubeEffects;

  int[][] mCubeEffectPosition;

  Effect[][] mNodeEffects;

  int[][] mNodeEffectPosition;

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

  SizeChangeEffect()

    {

    mPhaseActive        = new boolean[NUM_PHASES];

    mEffectReturned     = new int[NUM_PHASES];

    mCubeEffectNumber   = new int[NUM_PHASES];

    mNodeEffectNumber   = new int[NUM_PHASES];

    mEffectFinished     = new int[NUM_PHASES];

    mCubeEffectPosition = new int[NUM_PHASES][];

    mNodeEffectPosition = new int[NUM_PHASES][];

    mCubeEffects        = new Effect[NUM_PHASES][];

    mNodeEffects        = new Effect[NUM_PHASES][];

    mObject             = new RubikObject[NUM_PHASES];

    }

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

  abstract int createEffectsPhase0(int duration);

  abstract int createEffectsPhase1(int duration);

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

  private void effectFinishedPhase(final long effectID, int phase)

    {

    for(int i=0; i<mCubeEffectNumber[phase]; i++)

      {

      long id = mCubeEffects[phase][i].getID();

      if( effectID == id )

        {

        effectReturned(phase);

        mObject[phase].remove(id);

        return;

        }

      }

    for(int i=0; i<mNodeEffectNumber[phase]; i++)

      {

      long id = mNodeEffects[phase][i].getID();

      if( effectID == id )

        {

        effectReturned(phase);

        mObject[phase].getEffects().abortById(id);

        return;

        }

      }

    }

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

  private void effectReturned(int phase)

    {

    mEffectReturned[phase]++;

    if( mEffectReturned[phase] == mEffectFinished[phase] )

      {

      switch(phase)

        {

        case 0: mPhaseActive[1] = true;

                mEffectFinished[1] = createEffectsPhase1(mDuration);

                assignEffects(1);

                mScreen.attach(mObject[1]);

                break;

        case 1: mListener.effectFinished(FAKE_EFFECT_ID);

                break;

        }

      }

    if( mEffectReturned[phase] == mCubeEffectNumber[phase]+mNodeEffectNumber[phase] )

      {

      switch(phase)

        {

        case 0: mPhaseActive[0] = false;

                mScreen.detach(mObject[0]);

                break;

        case 1: mPhaseActive[1] = false;

                break;

        }

      }

    }

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

  private void assignEffects(int phase)

    {

    mCubeEffectNumber[phase] = ( mCubeEffects[phase]!=null ) ? mCubeEffects[phase].length : 0;

    mNodeEffectNumber[phase] = ( mNodeEffects[phase]!=null ) ? mNodeEffects[phase].length : 0;

    if( mCubeEffectNumber[phase]==0 && mNodeEffectNumber[phase]==0 )

      {

      throw new RuntimeException("Cube and Node Effects ("+phase+" phase) both not created!");

      }

    for(int i=0; i<mCubeEffectNumber[phase]; i++)

      {

      mObject[phase].apply(mCubeEffects[phase][i],mCubeEffectPosition[phase][i]);

      mCubeEffects[phase][i].notifyWhenFinished(this);

      }

    DistortedEffects nodeEffects = mObject[phase].getEffects();

    for(int i=0; i<mNodeEffectNumber[phase]; i++)

      {

      nodeEffects.apply(mNodeEffects[phase][i],mNodeEffectPosition[phase][i]);

      mNodeEffects[phase][i].notifyWhenFinished(this);

      }

    }

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

// PUBLIC API

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

  public void effectFinished(final long effectID)

    {

    if( mPhaseActive[0] ) effectFinishedPhase(effectID,0);

    if( mPhaseActive[1] ) effectFinishedPhase(effectID,1);

    }

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

  @SuppressWarnings("unused")

  public static String[] getNames()

    {

    String[] names = new String[NUM_EFFECTS];

    for( int i=0; i<NUM_EFFECTS; i++)

      {

      names[i] = types[i].name();

      }

    return names;

    }

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

  @SuppressWarnings("unused")

  public static SizeChangeEffect create(int ordinal) throws InstantiationException, IllegalAccessException

    {

    return types[ordinal].effect.newInstance();

    }

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

  @SuppressWarnings("unused")

  public long start(int duration, DistortedScreen screen, RubikPostRender post)

    {

    mScreen   = screen;

    mObject[0]= post.getOldObject();

    mObject[1]= post.getObject();

    mListener = post;

    mDuration = duration;

    if( mObject[0]!=null )

      {

      mPhaseActive[0] = true;

      mEffectFinished[0] = createEffectsPhase0(mDuration);

      assignEffects(0);

      }

    else

      {

      mPhaseActive[1] = true;

      mEffectFinished[1] = createEffectsPhase1(mDuration);

      assignEffects(1);

      mScreen.attach(mObject[1]);

      }

    return FAKE_EFFECT_ID;

    }

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

  @SuppressWarnings("unused")

  public static void enableEffects()

    {

    Method method;

    for(Type type: Type.values())

      {

      try

        {

        method = type.effect.getDeclaredMethod("enable");  // enable not public, thus getDeclaredMethod

        }

      catch(NoSuchMethodException ex)

        {

        android.util.Log.e("SizeChangeEffect", type.effect.getSimpleName()+": exception getting method: "+ex.getMessage());

        method = null;

        }

      try

        {

        if( method!=null ) method.invoke(null);

        }

      catch(Exception ex)

        {

        android.util.Log.e("SizeChangeEffect", type.effect.getSimpleName()+": exception invoking method: "+ex.getMessage());

        }

      }

    }

}

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

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

class SizeChangeEffectMove extends SizeChangeEffect

  {

  public int createEffectsPhase0(int duration)

    {

    int w = mScreen.getWidth();

    int h = mScreen.getHeight();

    int xmove = w/2 + (w<h?w:h)/2;

    mNodeEffectPosition[0] = new int[] {1};

    mNodeEffects[0]        = new Effect[mNodeEffectPosition[0].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

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

    d0.add(new Static3D(xmove,0,0));

    mNodeEffects[0][0] = new MatrixEffectMove(d0);

    return 1;

    }

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

  public int createEffectsPhase1(int duration)

    {

    int w = mScreen.getWidth();

    int h = mScreen.getHeight();

    int xmove = w/2 + (w<h?w:h)/2;

    mNodeEffectPosition[1] = new int[] {1};

    mNodeEffects[1]        = new Effect[mNodeEffectPosition[1].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

    d0.add(new Static3D(-xmove,0,0));

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

    mNodeEffects[1][0] = new MatrixEffectMove(d0);

    return 1;

    }

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

// Enable all effects used in this Effect. Called by reflection from the parent class.

// Matrix Effects do not have to be enabled.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

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

class SizeChangeEffectNone extends SizeChangeEffect

  {

  public int createEffectsPhase0(int duration)

    {

    mCubeEffectPosition[0] = new int[] {-1};

    mCubeEffects[0]        = new Effect[mCubeEffectPosition[0].length];

    Dynamic3D d0 = new Dynamic3D(1,0.5f);

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

    mCubeEffects[0][0] = new MatrixEffectMove(d0);

    return 1;

    }

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

  public int createEffectsPhase1(int duration)

    {

    mCubeEffectPosition[1] = new int[] {-1};

    mCubeEffects[1]        = new Effect[mCubeEffectPosition[1].length];

    Dynamic3D d0 = new Dynamic3D(1,0.5f);

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

    mCubeEffects[1][0] = new MatrixEffectMove(d0);

    return 1;

    }

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

// enable all effects used in this Effect (here: none).  Called by reflection from the parent class.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

import static org.distorted.objects.RubikObject.NODE_FBO_SIZE;

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

class SizeChangeEffectRound extends SizeChangeEffect

  {

  public int createEffectsPhase0(int duration)

    {

    float X = NODE_FBO_SIZE /3;

    mCubeEffectPosition[0] = new int[] {6,7};

    mCubeEffects[0]        = new Effect[mCubeEffectPosition[0].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

    d0.add(new Static3D( 1.00f, 1.00f, 1.00f));

    d0.add(new Static3D( 0.01f, 0.01f, 0.01f));

    mCubeEffects[0][0] = new MatrixEffectScale(d0);

    Dynamic3D d1 = new Dynamic3D(duration/2, 0.5f);

    d1.setMode(Dynamic.MODE_PATH);

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

    d1.add(new Static3D(+X, 0, 0));

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

    mCubeEffects[0][1] = new MatrixEffectMove(d1);

    return 2;

    }

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

  public int createEffectsPhase1(int duration)

    {

    float X = NODE_FBO_SIZE /3;

    mCubeEffectPosition[1] = new int[] {6,7};

    mCubeEffects[1]        = new Effect[mCubeEffectPosition[1].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

    d0.add(new Static3D( 0.01f, 0.01f, 0.01f));

    d0.add(new Static3D( 1.00f, 1.00f, 1.00f));

    mCubeEffects[1][0] = new MatrixEffectScale(d0);

    Dynamic3D d1 = new Dynamic3D(duration/2, 0.5f);

    d1.setMode(Dynamic.MODE_PATH);

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

    d1.add(new Static3D(-X, 0, 0));

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

    mCubeEffects[1][1] = new MatrixEffectMove(d1);

    return 2;

    }

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

// Enable all effects used in this Effect. Called by reflection from the parent class.

// Matrix Effects do not have to be enabled.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Static3D;

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

class SizeChangeEffectScale extends SizeChangeEffect

  {

  public int createEffectsPhase0(int duration)

    {

    mCubeEffectPosition[0] = new int[] {6};

    mCubeEffects[0]        = new Effect[mCubeEffectPosition[0].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

    d0.add(new Static3D(1.00f, 1.00f, 1.00f));

    d0.add(new Static3D(0.01f, 0.01f, 0.01f));

    mCubeEffects[0][0] = new MatrixEffectScale(d0);

    return 1;

    }

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

  public int createEffectsPhase1(int duration)

    {

    mCubeEffectPosition[1] = new int[] {6};

    mCubeEffects[1]        = new Effect[mCubeEffectPosition[1].length];

    Dynamic3D d0 = new Dynamic3D(duration/2, 0.5f);

    d0.add(new Static3D(0.01f, 0.01f, 0.01f));

    d0.add(new Static3D(1.00f, 1.00f, 1.00f));

    mCubeEffects[1][0] = new MatrixEffectScale(d0);

    return 1;

    }

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

// Enable all effects used in this Effect. Called by reflection from the parent class.

// Matrix Effects do not have to be enabled.

  @SuppressWarnings("unused")

  static void enable()

    {

    }

  }

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.effects.sizechange;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.FragmentEffectAlpha;

import org.distorted.library.effect.VertexEffectWave;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic5D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static5D;

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

class SizeChangeEffectTransparency extends SizeChangeEffect

  {

  public int createEffectsPhase0(int duration)

    {

    mNodeEffectPosition[0] = new int[] {-1,-1};

    mNodeEffects[0]        = new Effect[mNodeEffectPosition[0].length];

    float init_amplitude = 0.0f;

    float end_amplitude  = 1/8.0f;

    float length         = 1/8.0f;

    float init_phase     = 360.0f;

    float end_phase      = 0.0f;

    float alpha          = 30.0f;

    float beta           = 90.0f;

    Dynamic5D d1 = new Dynamic5D(duration/2, 0.5f);

    d1.add(new Static5D( init_amplitude, length, init_phase, alpha, beta) );

    d1.add(new Static5D( end_amplitude , length, end_phase , alpha, beta) );

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

    mNodeEffects[0][0] = new VertexEffectWave(d1, center, null);

    Dynamic1D d0 = new Dynamic1D(duration/2, 0.5f);

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

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

    mNodeEffects[0][1] = new FragmentEffectAlpha(d0);

    return 2;

    }

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

  public int createEffectsPhase1(int duration)

    {

    mNodeEffectPosition[1] = new int[] {-1,-1};

    mNodeEffects[1]        = new Effect[mNodeEffectPosition[1].length];

    float init_amplitude = 1/8.0f;

    float end_amplitude  = 0.0f;

    float length         = 1/8.0f;

    float init_phase     = 0.0f;

    float end_phase      = 360.0f;

    float alpha          = 30.0f;

    float beta           = 90.0f;

    Dynamic5D d1 = new Dynamic5D(duration/2, 0.5f);

    d1.add(new Static5D( init_amplitude, length, init_phase, alpha, beta) );

    d1.add(new Static5D( end_amplitude , length, end_phase , alpha, beta) );

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

    mNodeEffects[1][0] = new VertexEffectWave(d1, center, null);

    Dynamic1D d0 = new Dynamic1D(duration/2, 0.5f);

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

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

    mNodeEffects[1][1] = new FragmentEffectAlpha(d0);

    return 2;

    }

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

// Enable all effects used in this Effect. Called by reflection from the parent class.

  @SuppressWarnings("unused")

  static void enable()

    {

    FragmentEffectAlpha.enable();

    VertexEffectWave.enable();

    }

  }

    mCubeEffectPosition[phase] = new int[] {3};

    <string name="sizechange_effect">Effekt Größenänderung</string>

    <string name="sizechange_effect">Efecto de cambio de tamaño</string>