/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision a97e02b7

Added by Leszek Koltunski about 5 years ago

ID a97e02b7c1be5a995807477bf1e1f0c95e01c1b5
Parent eb389a97
Child d99f3a48

Objects must explicitly provide a list of offsets specifying where the cut planes are (rather than just a BASIC_STEP - the width of the layer - which is insufficient in case of objects which have layers of vastly different width, like the Master Skewb)

         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         float[] vertices1 = { 0,0, F,0, F/2,(SQ3/2)*F };
         float[] vertices1 = { 0,0, F,0, 7*F/8,(SQ3/8)*F, 5*F/8,(3*SQ3/8)*F, F/2,(SQ3/2)*F };
         float[] bands1 = computeBands(0,0,1,0,3);
         meshes[3] = new MeshPolygon(vertices1,bands1,1,5);
-...
         meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
         meshes[0].setEffectAssociation(0,1,0);
         float[] vertices1 = { -E,-SQ3*E, +E,-SQ3*E, 0,0 };
         float[] vertices1 = { -E,-SQ3*E, -E*0.7f,-SQ3*E, +E*0.7f,-SQ3*E, +E,-SQ3*E, 0,0 };
         float[] bands1 = computeBands(0,0,1,0,3);
         meshes[1] = new MeshPolygon(vertices1,bands1,0,0);

src/main/java/org/distorted/objects/MovementSkewb.java
46	46
47	47	int computeRowFromOffset(int face, int size, float offset)
48	48	{
49		return offset<DIST2D ? 0:1;
	49	return offset<DIST2D ? 0:size-1;
50	50	}
51	51
52	52	///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return 1.0f;
         float[] cuts = new float[size-1];
         for(int i=0; i<size-1; i++)
+          {
           cuts[i] = (2-size)*0.5f + i;
+          }
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ6/4;
         float[] cuts = new float[1];
         cuts[0] = 0.0f;
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ3;
         float[] cuts = new float[2];
         cuts[0] = -SQ3/3;
         cuts[1] = +SQ3/3;
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ2/2;
         float[] cuts = new float[2];
         cuts[0] = -SQ2/4;
         cuts[1] = +SQ2/4;
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

       final int NUM_CUBIT_FACES;
       final int NUM_AXIS;
       final int NUM_CUBITS;
       final float BASIC_STEP;
       final float[] CUTS;
       final int NUM_CUTS;
       private static float mInitScreenRatio;
       private static float mObjectScreenRatio = 1.0f;
-...
       private Dynamic1D mRotationAngle;
       private Static3D mRotationAxis;
       private Static3D mObjectScale;
       private float mStart, mStep;
       float[] mRowChances;
       Static1D mRotationAngleStatic, mRotationAngleMiddle, mRotationAngleFinal;
-...
         NUM_FACES = getNumFaces();
         NUM_CUBIT_FACES = getNumCubitFaces();
         NUM_TEXTURES = getNumStickerTypes()*NUM_FACES;
         BASIC_STEP = getBasicStep();
         CUTS = getCuts(mSize);
         NUM_CUTS = CUTS.length;
         if( mObjectScreenRatio>MAX_SIZE_CHANGE) mObjectScreenRatio = MAX_SIZE_CHANGE;
         if( mObjectScreenRatio<MIN_SIZE_CHANGE) mObjectScreenRatio = MIN_SIZE_CHANGE;
         computeStartAndStep(mOrigPos);
         mNodeScale= new Static3D(1,NODE_RATIO,1);
         mQuat = quat;
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Cast centers of all Cubits on the first rotation Axis and compute the leftmost and rightmost
     // one. From there compute the 'start' (i.e. the leftmost) and 'step' (i.e. distance between two
     // consecutive).
     // it is assumed that other rotation axis have the same 'start' and 'step' - this is the case with
     // the Cube and the Pyraminx.
     // Start and Step are then needed to compute which rotation row (with respect to a given axis) a
     // given Cubit belongs to.
       private void computeStartAndStep(Static3D[] pos)
       int computeRow(float x, float y, float z, int rotIndex)
+        {
         float min = Float.MAX_VALUE;
         float max = Float.MIN_VALUE;
         float axisX = ROTATION_AXIS[0].get0();
         float axisY = ROTATION_AXIS[0].get1();
         float axisZ = ROTATION_AXIS[0].get2();
         float tmp;
         Static3D axis = ROTATION_AXIS[rotIndex];
         float tmp = x*axis.get0() + y*axis.get1() + z*axis.get2();
         for(int i=0; i<NUM_CUBITS; i++)
         for(int i=0; i<NUM_CUTS; i++)
+          {
           tmp = pos[i].get0()*axisX + pos[i].get1()*axisY + pos[i].get2()*axisZ;
           if( tmp<min ) min=tmp;
           if( tmp>max ) max=tmp;
           if( tmp<CUTS[i] ) return i;
+          }
         mStart = min;
         mStep  = (max-min+BASIC_STEP)/mSize;
         return NUM_CUTS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         return ((1<<cubitRow)&rowBitmap)!=0;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int computeRow(float x, float y, float z, int rotIndex)
+        {
         Static3D axis = ROTATION_AXIS[rotIndex];
         float tmp = x*axis.get0() + y*axis.get1() + z*axis.get2();
         return (int)((tmp-mStart)/mStep +0.5f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // note the minus in front of the sin() - we rotate counterclockwise
     // when looking towards the direction where the axis increases in values.
-...
       abstract int getFaceColor(int cubit, int cubitface, int size);
       abstract float returnMultiplier();
       abstract float[] getRowChances();
       abstract float getBasicStep();
       abstract float[] getCuts(int size);
       abstract boolean shouldResetTextureMaps();
       public abstract boolean isSolved();

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ6/3;
         float[] cuts = new float[size-1];
         for(int i=0; i<size-1; i++)
+          {
           cuts[i] = (1.0f-0.25f*size+i)*(SQ6/3);
+          }
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ3;
         float[] cuts = new float[2];
         cuts[0] = -SQ3/3 -0.05f;
         cuts[1] = +SQ3/3 +0.05f;
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float getBasicStep()
       float[] getCuts(int size)
+        {
         return SQ3;
         float[] cuts = new float[size-1];
         switch(size)
+          {
           case 2: cuts[0] = 0;
                   break;
           case 3: cuts[0] = -SQ3/12;
                   cuts[1] = +SQ3/12;
                   break;
+          }
         return cuts;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision a97e02b7

Added by Leszek Koltunski about 5 years ago