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.MatrixEffectMove;

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

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

public abstract class RubikObject extends DistortedNode

  {

  static final float OBJECT_SCREEN_RATIO = 0.5f;

  static final int TEXTURE_SIZE = 100;

  private static final int POST_ROTATION_MILLISEC = 500;

  final float[] LEGAL_QUATS;

  private Static3D mMove, mScale, mNodeMove, mNodeScale;

  private Static4D mQuatAccumulated;

  private DistortedTexture mNodeTexture;

  int mSize, mRotAxis, mRotRow;

  Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;

  DistortedTexture mTexture;

  VertexEffectSink mSinkEffect;

  MatrixEffectMove mMoveEffect;

  MatrixEffectScale mScaleEffect;

  MatrixEffectQuaternion mQuatCEffect;

  MatrixEffectQuaternion mQuatAEffect;

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

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

    {

    super(texture,effects,mesh);

    LEGAL_QUATS = getLegalQuats();

    mNodeTexture = texture;

    mSize = size;

    mRotationAngleStatic = new Static1D(0);

    mRotationAngleMiddle = new Static1D(0);

    mRotationAngleFinal  = new Static1D(0);

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

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

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

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

    mQuatAccumulated = quatAcc;

    Static3D sinkCenter = new Static3D(TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f, TEXTURE_SIZE*0.5f);

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

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

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

    mMoveEffect = new MatrixEffectMove(mMove);

    mScaleEffect = new MatrixEffectScale(mScale);

    mQuatCEffect = new MatrixEffectQuaternion(quatCur, matrCenter);

    mQuatAEffect = new MatrixEffectQuaternion(quatAcc, matrCenter);

    MatrixEffectMove  nodeMoveEffect  = new MatrixEffectMove(mNodeMove);

    MatrixEffectScale nodeScaleEffect = new MatrixEffectScale(mNodeScale);

    effects.apply(nodeScaleEffect);

    effects.apply(nodeMoveEffect);

    }

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

  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 screenWidth, int screenHeight)

    {

    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 = (OBJECT_SCREEN_RATIO*texW/(TEXTURE_SIZE*mSize));

    mMove.set( texW*0.5f , texH*0.5f , 0.0f );

    mScale.set(scaleFactor,scaleFactor,scaleFactor);

    }

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

  abstract float[] getLegalQuats();

  public abstract void savePreferences(SharedPreferences.Editor editor);

  public abstract void restorePreferences(SharedPreferences preferences);

  public abstract void beginNewRotation(int vector, int row );

  public abstract long addNewRotation(int vector, int row, int angle, long durationMillis, EffectListener listener );

  public abstract long finishRotationNow(EffectListener listener);

  public abstract void removeRotationNow();

  public abstract void apply(Effect effect, int position);

  public abstract void remove(long effectID);

  public abstract void releaseResources();

  public abstract void createTexture();

  public abstract void solve();

  public abstract boolean isSolved();

  }