Magic Cube

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

// 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.FragmentEffectAlpha;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.library.message.EffectMessage;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.magic.RubikCube;

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

class TransitionEffectDisappear extends TransitionEffect implements EffectListener

  {

  private static final int DURATION_IN_MILLIS = 1000;

  private EffectListener mListener;

  private FragmentEffectAlpha mDisappear, mAppear;

  private DistortedScreen mScreen;

  private RubikCube mOld, mNew;

  private long mDisappearID;

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

  TransitionEffectDisappear()

    {

    }

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

// enable all effects we are using in this Transition.

// called by reflection from the parent class.

  @SuppressWarnings("unused")

  static void enable()

    {

    FragmentEffectAlpha.enable();

    }

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

  public long prepare(EffectListener listener)

    {

    mListener = listener;

    Dynamic1D disappearDyn = new Dynamic1D(DURATION_IN_MILLIS, 0.5f);  // this means - linearily change the

    disappearDyn.add(new Static1D(1.0f));                              // alpha of the old cube from 1.0 (100%)

    disappearDyn.add(new Static1D(0.0f));                              // to 0.0 (0%) within DURATION millisecs.

    mDisappear = new FragmentEffectAlpha(disappearDyn);

    Dynamic1D appearDyn = new Dynamic1D(DURATION_IN_MILLIS, 0.5f);     // the opposite - make the new cube

    appearDyn.add(new Static1D(0.0f));                                 // more and more opaque.

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

    mAppear = new FragmentEffectAlpha(appearDyn);

    mDisappearID = mDisappear.getID();

    return mAppear.getID();

    }

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

// At the start, oldCube is attached to the screen, new is not.

// Gradually make the old cube disappear and wait for the message that this is done.

  public void start(DistortedScreen screen, RubikCube oldCube, RubikCube newCube)

    {

    mScreen = screen;

    mNew    = newCube;

    mOld    = oldCube;

    mOld.apply(mDisappear);

    mOld.registerForMessages(this);

    }

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

// 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.detachAll();

      mNew.attachToScreen(mScreen);

      mNew.apply(mAppear);

      mOld.deregisterForMessages(this);

      mNew.registerForMessages(mListener);

      }

    }

  }