TwistyPuzzleLib

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

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

import java.io.DataInputStream;

import android.graphics.Bitmap;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.mesh.MeshBase;

import org.distorted.objectlib.helpers.FactoryCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectLibInterface;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.metadata.Metadata;

import org.distorted.objectlib.signature.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ObjectStickerOverride;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.helpers.OperatingSystemInterface;

import org.distorted.objectlib.helpers.QuatGroupGenerator;

import org.distorted.objectlib.scrambling.ObjectScrambler;

import org.distorted.objectlib.json.JsonReader;

import org.distorted.objectlib.scrambling.ScrambleEdgeGenerator;

import org.distorted.objectlib.tablebases.ImplementedTablebasesList;

import org.distorted.objectlib.touchcontrol.*;

import static org.distorted.objectlib.touchcontrol.TouchControl.*;

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

public abstract class TwistyObject

  {

  public static final int MODE_ICON = 0;

  public static final int COLOR_STROKE   = 0xff000000;

  public static final int COLOR_INTERNAL = 0xff000000;

  private static final int DEFAULT_TEXTURE_HEIGHT = 256;

  private static final int DEFAULT_TEXTURE_ROWS   = 8;

  protected float[][][][] mStickerCoords;

  protected Static4D[] mObjectQuats;

  private int[][] mStickerVariants;

  private TwistyObjectCubit[] mCubits;

  private MeshBase[] mMeshes;

  private int mNumCubits, mNumQuats, mNumFaceColors, mNumTextures, mNumOverrides;

  private int mNumCubitFaces, mNumStickerTypes;

  private Static3D[] mAxis;

  private int[][] mMinimalCubiesInRow;

  private int[] mNumCuts;

  private Static4D[] mOrigQuat;

  private Static4D[] mMixupModeQuats;

  private Static4D mQuat;

  private int[] mNumLayers;

  private DistortedEffects mEffects;

  private float mObjectScreenRatio;

  private int mNumTexRows, mNumTexCols, mTexHeight;

  private MeshBase mMesh;

  private ObjectScrambler mScrambler;

  private TouchControl mTouchControl;

  private DistortedNode mNode;

  private ObjectLibInterface mInterface;

  private Bitmap mBitmap;

  private ObjectSticker[] mStickers;

  private ObjectShape[] mShapes;

  private int[][] mCubitFaceColors;

  private int[][] mVariantFaceIsOuter;

  private int[][] mBasicAngles;

  private int mIconMode;

  private Metadata mMetadata;

  private float[][] mRowOffsets;

  private int mNumPuzzleFaces;

  private ObjectStickerOverride[] mStickerOverrides;

  private boolean mError;

  private int mMaxNumLayers;

  private boolean mThereAreDeciders;

  private TwistyLayerRotations mRotation;

  private int[] mColorTable;

  private int[] mOriginalColorTable;

  private float mTextureBorderMultiplier, mTextureCornerMultiplier;

  TwistyObject(int iconMode, Static4D quat, Static3D move, float scale, InitAssets asset)

    {

    try

      InputStream jsonStream = asset!=null ? asset.getJsonStream(): null;

      JsonReader reader = new JsonReader();

      reader.parseJsonFile(jsonStream);

      mMetadata  = null;

      initialize(iconMode,quat,move,scale,asset,true);

      if( asset!=null ) asset.close();

      mError = false;

    }

  public TwistyObject(int iconMode, float size, Static4D quat, Static3D move, float scale, Metadata meta, InitAssets asset)

    {

    mNumLayers = meta.getNumLayers();

    mSize      = size;

    mMetadata  = meta;

    initialize(iconMode,quat,move,scale,asset,false);

    if( asset!=null ) asset.close();

    mError = false;

    }

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

    if( tracking!=null )

      problem += (" "+axisX+" "+axisY+" "+axisZ);

      mInterface.reportProblem(problem, true);

    }

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

  private void initialize(int iconMode, Static4D quat, Static3D move, float scale, InitAssets asset, boolean fromJSON)

    {

    mIconMode = iconMode;

    mQuat = quat;

    mAxis = getRotationAxis();

    mBasicAngles = getBasicAngles();

    mObjectQuats = getQuats();

    mNumPuzzleFaces = getNumPuzzleFaces();

    mRowOffsets = new float[mNumPuzzleFaces][3];

    mTmp = new float[4];

    mNumAxis = mAxis.length;

    mCuts = getCuts(mNumLayers);

    mNumCuts = new int[mNumAxis];

      {

      if( mMaxNumLayers<mNumLayers[i] ) mMaxNumLayers = mNumLayers[i];

      mNumCuts[i] = (mCuts==null || mCuts[i]==null ? 0 : mCuts[i].length);

    mOriginalColorTable = getColorTable();

    recreateFaceColors();

    mTextureBorderMultiplier = 1.0f;

    mMinimalCubiesInRow = getMinimalCubiesInRow();

    mNumCubits = mOrigPos.length;

    mBelongs = new boolean[mNumCubits];

    int scramblingType = getScrambleType();

    int[][] edges = getScrambleEdges();

    OperatingSystemInterface os = asset==null ? null : asset.getOS();

    mScrambler = new ObjectScrambler(scramblingType,mNumAxis,mNumLayers,algorithms,edges,tablebase);

    for( int c=0; c<mNumCubits; c++)

      {

    mQuatDebug = new int[mNumCubits];

    mObjectScale = new Static3D(scale,scale,scale);

    mEffects = new DistortedEffects();

    mRotation = new TwistyLayerRotations(this,mAxis,mNumLayers,getGhostAngle(),mEffects);

    MatrixEffectScale scaleEffect = new MatrixEffectScale(mObjectScale);

    MatrixEffectQuaternion quatEffect = new MatrixEffectQuaternion(mQuat, CENTER);

    MatrixEffectMove moveEffect = new MatrixEffectMove(move);

    InputStream meshStream = asset!=null ? asset.getMeshStream(): null;

    boolean fromDMESH = (meshStream!=null);

    getQuatsAndShapes(fromDMESH,fromJSON);

    createMeshAndCubits(meshStream,fromDMESH);

    setUpTextures(fromDMESH,fromJSON);

    mSolved.setupSolvedQuats(getSolvedQuats());

    mSolved.setPuzzleFaceColor(mColorTable);

    mEffects.apply(moveEffect);

    mNode = new DistortedNode(mTexture,mEffects,mMesh);

    }

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

    for(int i=0; i<mNumFaceColors; i++) mColorTable[i] = mOriginalColorTable[i];

    }

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

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

  private TablebasesAbstract getTablebase(OperatingSystemInterface os)

    {

    String shortName = getShortName();

    }

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

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

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

      int numFaces = mShapes[v].getNumFaces();

      }

    for( int cubit=0; cubit<mNumCubits; cubit++)

      {

      int numFaces = mShapes[variant].getNumFaces();

        if( getCubitFaceColor(cubit,face)>=0 )

          {

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

      for(int v=0; v<mNumCubitVariants; v++) mShapes[v] = getObjectShape(v);

      mNumCubitFaces = ObjectShape.computeNumComponents(mShapes);

      mVariantFaceIsOuter = new int[mNumCubitVariants][];

      mOrigQuat = new Static4D[mNumCubits];

      if( !fromJSON )

        {

        mCubitFaceColors = ObjectShape.computeColors(mShapes,mOrigPos,mOrigQuat,this);

        }

      if( fromDMESH )

        {

        for(int i=0; i<mNumCubitVariants; i++) factory.createNewFaceTransform(mShapes[i], mVariantFaceIsOuter[i]);

        }

      }

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

  private void createMeshAndCubits(InputStream stream, boolean fromDMESH)

    {

    mCubits = new TwistyObjectCubit[mNumCubits];

    if( fromDMESH )

      {

      DataInputStream dos = new DataInputStream(stream);

      mMesh = new MeshFile(dos);

        stream.close();

        }

        android.util.Log.e("meshFile", "Error closing InputStream: "+e);

        }

      MeshBase[] cubitMesh = new MeshBase[mNumCubits];

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

        {

        cubitMesh[i] = createCubitMesh(i,mNumLayers,mNumCubitFaces);

        Static3D pos = getPos(mOrigPos[i]);

      }

      mCubits[i] = new TwistyObjectCubit(this,mOrigPos[i],mNumAxis,mMaxNumLayers,i);

      setCubitQuat(i,0);

      }

    }

  private MeshBase createCubitMesh(int cubit, int[] numLayers, int numComponents)

    {

    if( mMeshes==null ) mMeshes = new MeshBase[mNumCubitVariants];

      ObjectFaceShape faceShape = getObjectFaceShape(variant);

      ObjectVertexEffects effects = getVertexEffects(variant);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(mShapes[variant],mVariantFaceIsOuter[variant]);

      mMeshes[variant] = factory.createRoundedSolid(mShapes[variant],faceShape,effects,numComponents);

      }

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( mOrigQuat[cubit], CENTER );

    mesh.apply(quat,0xffffffff,0);

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

      mNumTexCols = DEFAULT_TEXTURE_ROWS;

      mNumTexRows = numTextures/mNumTexCols + 1;

      if( mNumTexRows*mTexHeight <= maxSize &&

      }

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

      mStickerCoords   = factory.getStickerCoords();

      mStickerVariants = factory.getStickerVariants();

      mStickerScales   = factory.getStickerScales();

      adjustStickerCoords();

      mNumStickerTypes = (mStickerCoords==null ? 0 : mStickerCoords.length);

      }

    mStickerOverrides = getStickerOverrides();

    figureOutBitmapDimensions(mNumTextures);

    if( mNumTexCols*mNumTexRows < mNumTextures+1 ) mNumTexRows++;

    else overrideCubitFaceColor();

    setTexture();

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

  public Metadata getMetadata()

    {

    return mMetadata;

    }

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

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

  public int getVariantStickerShape(int variant, int face)

    {

    if( variant <mStickerVariants.length )

    }

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

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

    return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngles);

    }

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

      if( len>mSize*dist[i]+MAXERR ) return true;

      }

  private boolean doesNotStickOut(int variant, float px, float py, float pz, float[] tmp, Static4D quat)

    {

    float[][] vertices = mShapes[variant].getVertices();

    Static3D[] axis = getFaceAxis();

      float mx = tmp[0] + px;

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

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

    float ERR = 0.01f;

      builder.append(cubit);