/ - Diff - TwistyPuzzleLib - Distorted Android

« Previous | Next »

Revision e28ba324

Added by Leszek Koltunski 9 months ago

ID e28ba324b50bb9926a54167de10f01b50f97253a
Parent da5c1cc1
Child 2fa926c8

Cleanup

         mErrorString = null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public abstract int getTouchControlType();
       public abstract int getTouchControlSplit();
       public abstract boolean[][] getLayerRotatable(int[] numLayers);
       public abstract int[][][] getEnabled();
       public abstract int[][] getScrambleEdges();
       public abstract float getStickerRadius();
       public abstract float getStickerStroke();
       public abstract float[][][] getStickerAngles();
       public abstract float getScreenRatio();
       public abstract int[] getColorTable();
       public abstract String getShortName();
       public abstract String printColor(int color);
       public abstract int getNumPuzzleFaces();
       public abstract int getFOV();
       public abstract String[][] getTutorials();
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void initialize(int iconMode, Static4D quat, Static3D move, float scale, InitAssets asset, boolean fromJSON)
-...
         mNode = new DistortedNode(mTexture,mEffects,mMesh);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private TablebasesAbstract getTablebase(OperatingSystemInterface os)
+        {
         String shortName = getShortName();
         return ImplementedTablebasesList.createPacked(os,shortName);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][] getSolvedQuats()
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int[][] getOldSolvedQuats()
+        {
         return mSolved.getSolvedQuats(mNumLayers);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // 0: old, groups-of-quaternions based function.
     // Still used by: Masterball, Mirror Skewb, Mirror Jing, Mirror Pyraminx & the Penrose Cubes.
     //
     // 1: specific function only for the Dino4.
     //
     // 2: the new default; automatic way based on automatic detection of monochromatic puzzle surfaces.
       public int getSolvedFunctionIndex()
+        {
         return 2;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean isSolved()
+        {
         for(int c=0; c<mNumCubits; c++) mCubitQuats[c] = getCubitQuatIndex(c);
         boolean solved = mSolved.isSolved(mCubitQuats);
         return mRotation.isSolved(solved);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // LATER
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public void recreateFaceColors()
-...
         return 0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private TablebasesAbstract getTablebase(OperatingSystemInterface os)
+        {
         String shortName = getShortName();
         return ImplementedTablebasesList.createPacked(os,shortName);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void figureOutBitmapDimensions(int numTextures)
-...
         return ScrambleEdgeGenerator.getScramblingAlgorithms(mBasicAngles);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int[][] getSolvedQuats()
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       protected int[][] getOldSolvedQuats()
+        {
         return mSolved.getSolvedQuats(mNumLayers,mNumCubitFaces);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // 0: old, groups-of-quaternions based function.
     // Still used by: Masterball, Mirror Skewb, Mirror Jing, Mirror Pyraminx & the Penrose Cubes.
     //
     // 1: specific function only for the Dino4.
     //
     // 2: the new default; automatic way based on automatic detection of monochromatic puzzle surfaces.
       public int getSolvedFunctionIndex()
+        {
         return 2;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public int getScrambleType()
-...
         final float ratioH = 1.0f/mNumTexRows;
         final Static4D[] maps = new Static4D[1];
         maps[0] = new Static4D(col*ratioW, row*ratioH, ratioW, ratioH);
         mMesh.setTextureMap(maps,mNumCubitFaces*cubit+face);
         mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit+face);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         for(int cubit=0; cubit<mNumCubits; cubit++)
+          {
           final Static4D[] maps = new Static4D[mNumCubitFaces];
           final Static4D[] maps = new Static4D[mMaxNumCubitFaces];
           variant = getCubitVariant(cubit,mNumLayers);
           for(int face=0; face<mNumCubitFaces; face++)
           for( int face=0; face<mMaxNumCubitFaces; face++)
+            {
             cubColor = getDefaultCubitFaceColor(cubit,face);
             stiShape = getVariantStickerShape(variant,face);
-...
             maps[face] = new Static4D( col*ratioW, row*ratioH, ratioW, ratioH);
+            }
           mMesh.setTextureMap(maps,mNumCubitFaces*cubit);
           mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit);
+          }
         overrideCubitFaceColor();
-...
             int cubit = cubitFaces[2*j];
             int face  = cubitFaces[2*j+1];
             maps[0] = new Static4D(col*ratioW, row*ratioH, ratioW, ratioH);
             mMesh.setTextureMap(maps,mNumCubitFaces*cubit+face);
             mMesh.setTextureMap(maps, mMaxNumCubitFaces*cubit+face);
+            }
+          }
+        }
-...
         return mObjectScreenRatio*mInitScreenRatio;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean isSolved()
+        {
         for(int c=0; c<mNumCubits; c++) mCubitQuats[c] = getCubitQuatIndex(c);
         boolean solved = mSolved.isSolved(mCubitQuats);
         return mRotation.isSolved(solved);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // INTERNAL API - those are called from 'effects' package
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       public int getCubitFaceStickerIndex(int cubit, int face)
+        {
         Static4D texMap = mMesh.getTextureMap(mNumCubitFaces*cubit + face);
         Static4D texMap = mMesh.getTextureMap(mMaxNumCubitFaces*cubit + face);
         int x = (int)(texMap.get0()/texMap.get2());
         int y = (int)(texMap.get1()/texMap.get3());
-...
       public ObjectSignature getSignature()       { return mMetadata.getSignature(); }
       public int getCategory()                    { return mMetadata!=null ? mMetadata.getCategory() : 0; }
       public boolean isSubmittable()              { return mCurrentColorSchemeSubmittable; }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       public abstract int getTouchControlType();
       public abstract int getTouchControlSplit();
       public abstract boolean[][] getLayerRotatable(int[] numLayers);
       public abstract int[][][] getEnabled();
       public abstract int[][] getScrambleEdges();
       public abstract float getStickerRadius();
       public abstract float getStickerStroke();
       public abstract float[][][] getStickerAngles();
       public abstract float getScreenRatio();
       public abstract int[] getColorTable();
       public abstract String getShortName();
       public abstract String printColor(int color);
       public abstract int getNumPuzzleFaces();
       public abstract int getFOV();
       public abstract String[][] getTutorials();
+      }

     // Color index, i.e. the index into the 'FACE_COLORS' table.
     // else (edge or corner cubit, more than one non-black face): return -2.
       private int retCubitSolvedStatus(int cubit, int[] numLayers, int numCubitFaces)
       private int retCubitSolvedStatus(int cubit, int[] numLayers)
+        {
         int numNonBlack=0, nonBlackIndex=-1, stiShape, cubColor;
         int numNonBlack=0, nonBlackIndex=-1;
         int variant = mParent.getCubitVariant(cubit,numLayers);
         ObjectShape shape = mParent.getObjectShape(variant);
         int numFaces = shape.getNumFaces();
         for(int face=0; face<numCubitFaces; face++)
+          {
           stiShape = mParent.getVariantStickerShape(variant,face);
           cubColor = mParent.getCubitFaceMap(cubit,face);
           if( stiShape>=0 && cubColor>=0 )
         for(int face=0; face<numFaces; face++)
           if( mParent.faceIsOuter(cubit,face) )
+            {
             numNonBlack++;
             nonBlackIndex = cubColor;
             nonBlackIndex = mParent.getCubitFaceMap(cubit,face);
+            }
+          }
         if( numNonBlack==0 ) return -1;
         if( numNonBlack>=2 ) return -2;
-...
     // Called from TwistyObject
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int[][] getSolvedQuats(int[] numLayers, int numCubitFaces)
       int[][] getSolvedQuats(int[] numLayers)
+        {
         int[] groups = new int[mNumCubits];
         int numGroups = 1;
-...
         for(int cubit=0; cubit<mNumCubits; cubit++)
+          {
           groups[cubit] = retCubitSolvedStatus(cubit,numLayers,numCubitFaces);
           groups[cubit] = retCubitSolvedStatus(cubit,numLayers);
           if( groups[cubit]>=0 ) numGroups++;
           else                   numFirst++;
+          }

       protected int[] mNumLayers;
       protected MeshBase mMesh;
       protected DistortedEffects mEffects;
       protected int mNumCubitFaces;
       protected int mMaxNumCubitFaces;
       private Static4D[] mCubitOrigQuat;
       private MeshBase[] mMeshes;
-...
     // it is possible to provide some artificial surfaces - for example, in case of the Penrose, the
     // three surfaces can be only the single 'middle' plane [the one on the bend].
       public float[] getMonochromaticSurface(int variant, int cubitIndex, int faceIndex, float px, float py, float pz)
       public float[] getMonochromaticSurface(int variant, int cubit, int face, float px, float py, float pz)
+        {
         if( !faceIsOuter(cubitIndex,faceIndex) ) return null;
         if( !faceIsOuter(cubit,face) ) return null;
         Static4D cubitQuat = getCubitQuats(cubitIndex,mNumLayers);
         Static4D cubitQuat = getCubitQuats(cubit,mNumLayers);
         float[] normal   = new float[4];
         float[] intPoint = new float[3];
-...
         float[] surface  = new float[4];
         ObjectShape objShape = mShapes[variant];
         objShape.getFacePoint(faceIndex,intPoint);
         objShape.getFaceNormal(faceIndex,normal);
         objShape.getFacePoint(face,intPoint);
         objShape.getFaceNormal(face,normal);
         QuatHelper.rotateVectorByQuat(rotPoint,intPoint[0],intPoint[1],intPoint[2],1,cubitQuat);
         QuatHelper.rotateVectorByQuat(surface,normal[0],normal[1],normal[2],0,cubitQuat);
-...
+        {
         mNumCubitVariants = getNumCubitVariants(mNumLayers);
         if( fromJSON ) mNumCubitFaces = getNumCubitFaces();
         if( fromJSON ) mMaxNumCubitFaces= getNumCubitFaces();
         if( !fromDMESH || !fromJSON )
+          {
-...
           mShapes = new ObjectShape[mNumCubitVariants];
           for(int v=0; v<mNumCubitVariants; v++) mShapes[v] = getObjectShape(v);
           mNumCubitFaces = ObjectShape.computeNumComponents(mShapes);
           mMaxNumCubitFaces= ObjectShape.computeNumComponents(mShapes);
           mVariantFaceIsOuter = new int[mNumCubitVariants][];
           if( !fromJSON )
-...
           for(int i=0; i<mNumCubits; i++)
+            {
             cubitMesh[i] = createSingleCubitMesh(i,mNumLayers,mNumCubitFaces);
             cubitMesh[i] = createSingleCubitMesh(i,mNumLayers,mMaxNumCubitFaces);
             Static3D pos = getPos(mCubitPos[i]);
             cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);
+            }

Also available in: Unified diff

Project

General

Profile

TwistyPuzzleLib

Revision e28ba324

Added by Leszek Koltunski 9 months ago