Magic Cube

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

// Copyright 2020 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.object;

import android.content.SharedPreferences;

import org.distorted.library.effect.Effect;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedNode;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

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

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

public abstract class RubikObject extends DistortedNode

  {

  static final float OBJECT_SCREEN_RATIO = 0.5f;

  final float[] LEGAL_QUATS;

  private static final int POST_ROTATION_MILLISEC = 500;

  private final int NUM_CUBITS;

  private int mRotRow;

  private Static3D mRotAxis;

  private Static3D mScale, mNodeScale;

  private Static4D mQuatAccumulated;

  private Cubit[] mCubits;

  int mSize;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  DistortedTexture mTexture;

  VertexEffectSink mSinkEffect;

  MatrixEffectScale mScaleEffect;

  MatrixEffectQuaternion mQuatCEffect;

  MatrixEffectQuaternion mQuatAEffect;

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

  RubikObject(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshRectangles mesh, DistortedEffects effects)

    {

    super(texture,effects,mesh);

    resizeFBO(NODE_FBO_SIZE, NODE_FBO_SIZE);

    LEGAL_QUATS = getLegalQuats();

    NUM_CUBITS  = getNumCubits(size);

    mSize = size;

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

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

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

    mQuatAccumulated = quatAcc;

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

    Static4D region = new Static4D(0,0,0,0.72f);

    mSinkEffect = new VertexEffectSink( new Static1D(getSinkStrength()), center, region );

    mScaleEffect = new MatrixEffectScale(mScale);

    mQuatCEffect = new MatrixEffectQuaternion(quatCur, center);

    mQuatAEffect = new MatrixEffectQuaternion(quatAcc, center);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    effects.apply(nodeScaleEffect);

    mCubits = new Cubit[NUM_CUBITS];

    mTexture = new DistortedTexture();

    int vertices = (int)(24.0f/mSize + 2.0f);

    int[][] positions = getCubitPositions(size);

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

      {

      int x = positions[i][0];

      int y = positions[i][1];

      int z = positions[i][2];

      mCubits[i] = new Cubit( this ,createCubitMesh(vertices,x,y,z), new Static3D(x,y,z) );

      attach(mCubits[i].mNode);

      }

    }

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

  private void resetRotationAngle(Dynamic1D rotationAngle)

    {

    rotationAngle.setDuration(POST_ROTATION_MILLISEC);

    rotationAngle.resetToBeginning();

    rotationAngle.removeAll();

    rotationAngle.add(mRotationAngleStatic);

    rotationAngle.add(mRotationAngleMiddle);

    rotationAngle.add(mRotationAngleFinal);

    }

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

  private float getSinkStrength()

    {

    switch(mSize)

      {

      case 1 : return 1.1f;

      case 2 : return 1.5f;

      case 3 : return 1.8f;

      case 4 : return 2.0f;

      default: return 3.0f - 4.0f/mSize;

      }

    }

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

  public int getSize()

    {

    return mSize;

    }

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

  public void continueRotation(float angleInDegrees)

    {

    mRotationAngleStatic.set0(angleInDegrees);

    }

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

  public Static4D getRotationQuat()

      {

      return mQuatAccumulated;

      }

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

  public void recomputeScaleFactor(int scrWidth, int scrHeight)

    {

    float factor = scrWidth>scrHeight ? scrHeight : scrWidth;

    float scaleFactor = OBJECT_SCREEN_RATIO*NODE_FBO_SIZE/mSize;

    mNodeScale.set(factor,factor,factor);

    mScale.set(scaleFactor,scaleFactor,scaleFactor);

    }

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

  public void savePreferences(SharedPreferences.Editor editor)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].savePreferences(editor);

    }

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

  public void restorePreferences(SharedPreferences preferences)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].restorePreferences(preferences);

    }

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

  public long finishRotationNow(EffectListener listener)

    {

    boolean first = true;

    long effectID=0;

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

      {

      if( belongsToRotation(mCubits[i].mCurrentPosition,mRotAxis,mRotRow) )

        {

        if( first )

          {

          first=false;

          effectID = mCubits[i].finishRotationNow(listener);

          }

        resetRotationAngle(mCubits[i].mRotationAngle);

        }

      }

    return effectID;

    }

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

  public void releaseResources()

    {

    mTexture.markForDeletion();

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].releaseResources();

    }

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

  public void apply(Effect effect, int position)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].mEffect.apply(effect, position);

    }

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

  public void remove(long effectID)

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].mEffect.abortById(effectID);

    }

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

  public void solve()

    {

    for(int i=0; i<NUM_CUBITS; i++) mCubits[i].solve();

    }

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

  public boolean isSolved()

    {

    Static4D q = mCubits[0].mQuatScramble;

    float x = q.get0();

    float y = q.get1();

    float z = q.get2();

    float w = q.get3();

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

      {

      q = mCubits[i].mQuatScramble;

      if( q.get0()!=x || q.get1()!=y || q.get2()!=z || q.get3()!=w ) return false;

      }

    return true;

    }

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

  public void beginNewRotation(Static3D axis, int row )

    {

    mRotAxis = axis;

    mRotRow  = row;

    mRotationAngleStatic.set0(0.0f);

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

      if( belongsToRotation( mCubits[i].mCurrentPosition,axis,mRotRow) )

        {

        mCubits[i].beginNewRotation(axis);

        }

     }

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

  public long addNewRotation( Static3D axis, int row, int angle, long durationMillis, EffectListener listener )

     {

     long effectID=0;

     boolean first = true;

     mRotAxis = axis;

     mRotRow  = row;

     mRotationAngleStatic.set0(0.0f);

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

       if( belongsToRotation(mCubits[i].mCurrentPosition,axis,mRotRow) )

         {

         mCubits[i].addNewRotation(axis,durationMillis,angle);

         if( first )

           {

           first = false;

           effectID = mCubits[i].setUpCallback(listener);

           }

         }

     return effectID;

     }

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

  public void removeRotationNow()

     {

     boolean first = true;

     Static4D quat = null;

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

       if( belongsToRotation(mCubits[i].mCurrentPosition,mRotAxis,mRotRow) )

         {

         if( first )

           {

           first = false;

           quat = mCubits[i].returnRotationQuat(mRotAxis);

           }

         mCubits[i].removeRotationNow(quat);

         }

     mRotationAngleStatic.set0(0);

     }

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

  abstract int getNumCubits(int size);

  abstract int[][] getCubitPositions(int size);

  abstract float[] getLegalQuats();

  abstract boolean belongsToRotation(Static3D position, Static3D axis, int row);

  abstract MeshBase createCubitMesh(int vertices, int x, int y, int z);

  public abstract void createTexture();

  }