TwistyPuzzleLib

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

// Copyright 2021 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.objectlib.automator;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.ObjectPreRender;

import org.distorted.objectlib.helpers.BlockController;

import org.distorted.objectlib.helpers.TwistyActivity;

import org.distorted.objectlib.main.TwistyObject;

import java.lang.ref.WeakReference;

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

public class ObjectAutomator implements EffectListener

  {

  private static ObjectAutomator mControl;

  private ObjectControl mObjectControl;

  WeakReference<TwistyActivity> mRefAct;

  boolean mWholeReturned, mRotateReturned;

  ObjectAutomatorWhole mWhole;

  ObjectAutomatorRotate mRotate;

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

  DistortedScreen getScreen()

    {

    TwistyActivity act = mRefAct.get();

    return act!=null ? act.getScreen() : null;

    }

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

  ObjectControl getObjectControl()

    {

    return mObjectControl;

    }

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

  Static4D getQuat()

    {

    ObjectControl control = getObjectControl();

    return control.getQuat();

    }

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

  TwistyObject getObject()

    {

    ObjectControl control = getObjectControl();

    ObjectPreRender pre =  control.getPreRender();

    return pre.getObject();

    }

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

  private void addWholeObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] nodes = mWhole.getNodes();

    if( screen!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) screen.attach(node);

      }

    }

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

  private void removeWholeObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] nodes = mWhole.returnNodes();

    if( screen!=null && nodes!=null )

      {

      for (DistortedNode node : nodes) screen.detach(node);

      }

    }

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

  private void addRotateObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] screenNodes = mRotate.getScreenNodes();

    if( screen!=null && screenNodes!=null )

      {

      for (DistortedNode node : screenNodes) screen.attach(node);

      }

    ObjectControl control = getObjectControl();

    ObjectPreRender pre =  control.getPreRender();

    DistortedNode object = pre.getObject();

    DistortedNode[] objectNodes = mRotate.getObjectNodes();

    if( object!=null && objectNodes!=null )

      {

      for (DistortedNode node : objectNodes) object.attach(node);

      }

    }

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

  private void removeRotateObjects()

    {

    DistortedScreen screen = getScreen();

    DistortedNode[] screenNodes = mRotate.returnScreenNodes();

    if( screen!=null && screenNodes!=null )

      {

      for (DistortedNode node : screenNodes) screen.detach(node);

      }

    ObjectControl control = getObjectControl();

    ObjectPreRender pre =  control.getPreRender();

    DistortedNode object = pre.getObject();

    DistortedNode[] objectNodes = mRotate.returnObjectNodes();

    if( object!=null && objectNodes!=null )

      {

      for (DistortedNode node : objectNodes) object.detach(node);

      }

    }

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

  private void finishWhole()

    {

    removeWholeObjects();

    mWholeReturned = true;

    if( !mRotateReturned ) addRotateObjects();

    }

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

  private void finishRotate()

    {

    removeRotateObjects();

    mRotateReturned= true;

    mObjectControl.getPreRender().unblockEverything();

    }

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

  TwistyActivity getActivity()

    {

    return mRefAct.get();

    }

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

  private ObjectAutomator(ObjectControl control)

    {

    mObjectControl = control;

    mWhole = new ObjectAutomatorWhole(this);

    mRotate= new ObjectAutomatorRotate(this);

    }

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

// PUBLIC

  public static ObjectAutomator getInstance(ObjectControl control)

    {

    if( mControl==null ) mControl = new ObjectAutomator(control);

    return mControl;

    }

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

  public void postDrawFrame(long time)

    {

    mWhole.postDrawFrame(time);

    }

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

  public void effectFinished(long effectID)

    {

    if( effectID==mWhole.getEffectID()  ) finishWhole();

    if( effectID==mRotate.getEffectID() ) finishRotate();

    }

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

  public void animateAll(TwistyActivity act)

    {

    mObjectControl.getPreRender().blockEverything(BlockController.CONTROL_PLACE_0);

    mRefAct = new WeakReference<>(act);

    mWholeReturned = false;

    mRotateReturned= false;

    addWholeObjects();

    }

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

  public void animateRotate(TwistyActivity act)

    {

    mObjectControl.getPreRender().blockEverything(BlockController.CONTROL_PLACE_1);

    mRefAct = new WeakReference<>(act);

    mWholeReturned = true;

    mRotateReturned= false;

    addRotateObjects();

    }

  }