/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision 2fcfce81

Added by Leszek Koltunski about 4 years ago

ID 2fcfce813a08e359576a4cc54b9ab2e540e36cf0
Parent 456780f1
Child 8a494f47

CubitFactory: unify creating MeshPolygon bands.

         return mThis;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // H - height of the band in the middle
     // alpha - angle of the edge  [0,90]
     // dist - often in a polygon the distance from edge to center is not 1, but something else.
     // This is the distance.
     // K - where to begin the second, much more flat part of the band. [0,1]
     // N - number of bands. N>=3
     //
     // theory: two distinct parts to the band:
     // 1) (0,B) - steep
     // 2) (B,1) - flat
     //
     // In first part, we have y = g(x) ; in second - y = g(f(x)) where
     //
     // g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha)
     // f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B)
     // h(x) = R*(sin(alpha) - sin(x))
     // R = H/(1-cos(alpha))
     // D = H*sin(alpha)
     // B = h(K*alpha)
     //
     // The N points are taken at:
     //
     // 1) in the second part, there are K2 = (N-3)/3 such points
     // 2) in the first - K1 = (N-3) - K2
     // 3) also, the 3 points 0,B,1
     //
     // so we have the sequence A[i] of N points
     //
     // 0
     // h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1)
     // B
     // (1-B)*(i+1)/(K2+1) + B   (i=0,i,...,K2-1)
     // 1
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float f(float D, float B, float x)
+        {
         return ((D-B)*x + B*(1-D))/(1-B);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float g(float R, float D, float x, float cosAlpha)
+        {
         float d = x-D;
         return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float h(float R, float sinAlpha, float x)
+        {
         return R*(sinAlpha-(float)Math.sin(x));
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[] computeBands(float H, int alpha, float dist, float K, int N)
+        {
         float[] bands = new float[2*N];
         bands[0] = 1.0f;
         bands[1] = 0.0f;
         float beta = (float)Math.atan(dist*Math.tan(Math.PI*alpha/180));
         float sinBeta = (float)Math.sin(beta);
         float cosBeta = (float)Math.cos(beta);
         float R = cosBeta<1.0f ? H/(1.0f-cosBeta) : 0.0f;
         float D = R*sinBeta;
         float B = h(R,sinBeta,K*beta);
         if( D>1.0f )
+          {
           for(int i=1; i<N; i++)
+            {
             bands[2*i  ] = (float)(N-1-i)/(N-1);
             bands[2*i+1] = H*(1-bands[2*i]);
+            }
+          }
         else
+          {
           int K2 = (int)((N-3)*K);
           int K1 = (N-3)-K2;
           for(int i=0; i<=K1; i++)
+            {
             float angle = K*beta + (1-K)*beta*(K1-i)/(K1+1);
             float x = h(R,sinBeta,angle);
             bands[2*i+2] = 1.0f - x;
             bands[2*i+3] = g(R,D,x,cosBeta);
+            }
           for(int i=0; i<=K2; i++)
+            {
             float x = (1-B)*(i+1)/(K2+1) + B;
             bands[2*K1+2 + 2*i+2] = 1.0f - x;
             bands[2*K1+2 + 2*i+3] = g(R,D,f(D,B,x),cosBeta);
+            }
+          }
         bands[2*N-2] = 0.0f;
         bands[2*N-1] =    H;
         return bands;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void roundCorners(MeshBase mesh, Static3D center, Static3D[] vertices, float strength, float regionRadius)
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createFacesCube(int index)
       MeshBase createFacesCube(int sizeIndex)
+        {
         final int MESHES=6;
         MeshBase[] meshes = new MeshPolygon[MESHES];
         int association = 1;
         MeshBase[] meshes = new MeshPolygon[6];
         float[] bands;
         float D = 0.027f;
         float E = 0.5f-D;
         float[] vertices = { -E,-E, +E,-E, +E,+E, -E,+E };
         int extraI, extraV;
         float E = 0.5f;
         int extraI, extraV, num;
         switch(index)
         switch(sizeIndex)
+          {
           case 0 : bands = new float[] { 1.0f    ,-D,
 .0f-D/2,-D*0.55f,
 .0f-D  ,-D*0.25f,
 .0f-2*D, 0.0f,
 .50f   , 0.040f,
 .0f    , 0.048f };
                    extraI = 2;
                    extraV = 2;
                    break;
           case 1 : bands = new float[] { 1.0f       ,-D,
 .0f-D*1.2f,-D*0.55f,
 .0f-2*D   , 0.0f,
 .50f      , 0.040f,
 .0f       , 0.048f };
                    extraI = 2;
                    extraV = 2;
                    break;
           case 2 : bands = new float[] { 1.0f       ,-D,
 .0f-D*1.2f,-D*0.55f,
 .0f-2*D   , 0.0f,
 .50f      , 0.040f,
 .0f       , 0.048f };
                    extraI = 1;
                    extraV = 2;
                    break;
           default: bands = new float[] { 1.0f    ,-D,
 .0f-2*D, 0.0f,
 .50f   , 0.025f,
 .0f    , 0.030f };
                    extraI = 1;
                    extraV = 1;
                    break;
           case 0 : num = 6; extraI = 2; extraV = 2; break;
           case 1 : num = 5; extraI = 2; extraV = 2; break;
           case 2 : num = 5; extraI = 1; extraV = 2; break;
           default: num = 4; extraI = 1; extraV = 1; break;
+          }
         meshes[0] = new MeshPolygon(vertices,bands,extraI,extraV);
         meshes[0].setEffectAssociation(0,association,0);
         float[] vertices = { -E,-E, +E,-E, +E,+E, -E,+E };
         float[] bands = computeBands(0.048f,35,E,0.7f,num);
         for(int i=1; i<MESHES; i++)
+          {
           association <<=1;
           meshes[i] = meshes[0].copy(true);
           meshes[i].setEffectAssociation(0,association,0);
+          }
         meshes[0] = new MeshPolygon(vertices,bands,extraI,extraV);
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         meshes[3] = meshes[0].copy(true);
         meshes[3].setEffectAssociation(0,8,0);
         meshes[4] = meshes[0].copy(true);
         meshes[4].setEffectAssociation(0,16,0);
         meshes[5] = meshes[0].copy(true);
         meshes[5].setEffectAssociation(0,32,0);
         return new MeshJoined(meshes);
+        }
-...
       MeshBase createFacesSkewbCorner()
+        {
         float D = 0.02f;
         MeshBase[] meshes = new MeshBase[6];
         float E = 0.5f;
         float F = SQ2/2;
         float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
         float[] bands0 = { 1.0f    , 0,
 .0f-2*D, D*0.25f,
 .0f-4*D, D*0.35f,
 .0f-8*D, D*0.6f,
 .60f   , D*1.0f,
 .30f   , D*1.375f,
 .0f    , D*1.4f };
         MeshBase[] meshes = new MeshBase[6];
         float[] bands0 = computeBands(0.028f,35,E/3,0.7f,7);
         meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
         meshes[0].setEffectAssociation(0,1,0);
-...
         meshes[2].setEffectAssociation(0,4,0);
         float[] vertices1 = { 0,0, F,0, F/2,(SQ3/2)*F };
         float[] bands1 = { 1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f };
         float[] bands1 = computeBands(0,0,1,0,3);
         meshes[3] = new MeshPolygon(vertices1,bands1,1,5);
         meshes[3].setEffectAssociation(0,8,0);
-...
       MeshBase createFacesSkewbFace()
+        {
         float D = 0.03f;
         MeshBase[] meshes = new MeshBase[5];
         float E = SQ2/4;
         float[] vertices0 = { -E,-E, +E,-E, +E,+E, -E,+E };
         float[] bands0 = computeBands(0.051f,35,E/2,0.9f,7);
         float[] bands0 = { 1.0f    , 0,
 .0f-D/2, D*0.30f,
 .0f- D , D*0.50f,
 .0f-2*D, D*0.80f,
 .60f   , D*1.40f,
 .30f   , D*1.60f,
 .0f    , D*1.70f };
         MeshBase[] meshes = new MeshBase[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[] bands1 = { 1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f };
         float[] bands1 = computeBands(0,0,1,0,3);
         meshes[1] = new MeshPolygon(vertices1,bands1,0,0);
         meshes[1].setEffectAssociation(0,2,0);
-...
       MeshBase createFacesOcta()
+        {
         int association = 1;
         MeshBase[] meshes = new MeshPolygon[8];
         float C = 0.06f;
         float D = 0.031f;
         float E = SQ3/2;
         float F = 0.5f;
         float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};
         float[] bands = computeBands(0.05f,35,F,0.8f,6);
         float[] bands = new float[] { 1.0f    , 0,
 .0f  -C, D*0.55f,
 .0f-2*C, D*0.85f,
 .0f-4*C, D*1.20f,
 .5f    , D*1.40f,
 .0f    , D*1.50f };
         MeshBase[] meshes = new MeshPolygon[8];
         meshes[0] = new MeshPolygon(vertices, bands, 2,2);
         meshes[0].setEffectAssociation(0,association,0);
         for(int i=1; i<8; i++)
+          {
           association <<= 1;
           meshes[i] = meshes[0].copy(true);
           meshes[i].setEffectAssociation(0,association,0);
+          }
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         meshes[3] = meshes[0].copy(true);
         meshes[3].setEffectAssociation(0,8,0);
         meshes[4] = meshes[0].copy(true);
         meshes[4].setEffectAssociation(0,16,0);
         meshes[5] = meshes[0].copy(true);
         meshes[5].setEffectAssociation(0,32,0);
         meshes[6] = meshes[0].copy(true);
         meshes[6].setEffectAssociation(0,64,0);
         meshes[7] = meshes[0].copy(true);
         meshes[7].setEffectAssociation(0,128,0);
         return new MeshJoined(meshes);
+        }
-...
       MeshBase createFacesTetra()
+        {
         MeshBase[] meshes = new MeshBase[4];
         int association = 1;
         float C = 0.06f;
         float D = 0.035f;
         float E = SQ3/2;
         float F = 0.5f;
         float[] vertices = { -F,-E/3, +F,-E/3, 0.0f,2*E/3};
         float[] bands = new float[] { 1.0f    , 0,
 .0f  -C, D*0.50f,
 .0f-2*C, D*0.80f,
 .0f-4*C, D*1.10f,
 .5f    , D*1.30f,
 .0f    , D*1.35f };
         float[] bands = computeBands(0.05f,35,F,0.8f,6);
         meshes[0] = new MeshPolygon(vertices, bands, 2,2);
         meshes[0].setEffectAssociation(0,association,0);
         for(int i=1; i<4; i++)
+          {
           association <<= 1;
           meshes[i] = meshes[0].copy(true);
           meshes[i].setEffectAssociation(0,association,0);
+          }
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         meshes[3] = meshes[0].copy(true);
         meshes[3].setEffectAssociation(0,8,0);
         return new MeshJoined(meshes);
+        }
-...
       MeshBase createFacesDino()
+        {
         final int MESHES=4;
         MeshBase[] meshes = new MeshPolygon[4];
         float D = 0.02f;
         float E = 0.5f*SQ2;
         float F = 0.5f;
         float[] bands0 = { 1.0f    , 0,
 .0f-2*D, D*0.25f,
 .0f-4*D, D*0.35f,
 .0f-8*D, D*0.6f,
 .60f   , D*1.0f,
 .30f   , D*1.375f,
 .0f    , D*1.4f };
         float[] vertices0 = { -F,F/3, 0,-2*F/3, +F,F/3 };
         float[] bands0 = computeBands(0.028f,30,F/3,0.8f,7);
         MeshBase[] meshes = new MeshPolygon[MESHES];
         meshes[0] = new MeshPolygon(vertices0, bands0, 2, 5);
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         float[] bands1 = { 1.0f    , 0,
 .50f   , 0.10f,
 .0f    , 0.20f };
         float[] vertices1 = { -E/2,-E*(SQ3/6), E/2,-E*(SQ3/6), 0,E*(SQ3/3) };
         float[] bands1 = computeBands(0.02f,45,F/3,0.2f,3);
         meshes[2] = new MeshPolygon(vertices1, bands1, 1, 2);
         meshes[2].setEffectAssociation(0,4,0);
-...
       MeshBase createFacesHelicopterCorner()
+        {
         float D = 0.02f;
         MeshBase[] meshes = new MeshBase[6];
         float E = 0.5f;
         float F = SQ2/4;
         float G = 1.0f/12;
         float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
         float[] bands0 = { 1.0f    , 0,
 .0f-2*D, D*0.25f,
 .0f-4*D, D*0.35f,
 .0f-8*D, D*0.6f,
 .60f   , D*1.0f,
 .30f   , D*1.375f,
 .0f    , D*1.4f };
         MeshBase[] meshes = new MeshBase[6];
         float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);
         meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
         meshes[0].setEffectAssociation(0,1,0);
-...
         meshes[2] = meshes[0].copy(true);
         meshes[2].setEffectAssociation(0,4,0);
         float[] vertices1 = { -F,-1.0f/12, +F,-1.0f/12, 0,1.0f/6 };
         float[] bands1 = { 1.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f };
         float[] vertices1 = { -F,-G, 0,-G, +F,-G, 0,2*G };
         float[] bands1 = computeBands(0.00f,0,0,0.0f,3);
         meshes[3] = new MeshPolygon(vertices1,bands1,1,5);
         meshes[3].setEffectAssociation(0,8,0);
         meshes[4] = meshes[3].copy(true);
-...
+        {
         MeshBase[] meshes = new MeshBase[4];
         float D = 0.02f;
         float E = 0.5f;
         float F = SQ2/4;
         float G = 1.0f/12;
         float[] vertices0 = { -E+E/4,E/4, E/4,-E+E/4, E/4,E/4};
         float[] bands0 = { 1.0f    , 0,
 .0f-2*D, D*0.25f,
 .0f-4*D, D*0.35f,
 .0f-8*D, D*0.6f,
 .60f   , D*1.0f,
 .30f   , D*1.375f,
 .0f    , D*1.4f };
         float[] bands0 = computeBands(0.028f,35,E/4,0.7f,7);
         meshes[0] = new MeshPolygon(vertices0, bands0, 3, 3);
         meshes[0].setEffectAssociation(0,1,0);
         float[] vertices1 = { -F,-G, +F,-G, 0,2*G};
         float[] bands1 = { 1.0f   , 0.0f,
 .5f   , 0.01f,
 .0f   , 0.01f };
         float[] bands1 = computeBands(0.01f,45,F,0.0f,3);
         meshes[1] = new MeshPolygon(vertices1, bands1, 1, 3);
         meshes[1].setEffectAssociation(0,2,0);
         float[] vertices2 = { -E/2,-F/3, +E/2,-F/3, 0,2*F/3};
         float[] bands2 = { 1.0f   , 0.0f,
 .5f   , 0.01f,
 .0f   , 0.01f };
         meshes[2] = new MeshPolygon(vertices2, bands2, 1, 3);
         meshes[2] = new MeshPolygon(vertices2, bands1, 1, 3);
         meshes[2].setEffectAssociation(0,4,0);
         meshes[3] = meshes[2].copy(true);
         meshes[3].setEffectAssociation(0,8,0);
-...
       MeshBase createFacesRediEdge()
+        {
         final int MESHES=6;
         MeshBase[] meshes = new MeshPolygon[6];
         float C = 0.02f;
         float D = 0.02f;
         float F = 0.25f;
         float[] bands0 = { 1.0f    , 0,
 .0f-2*C, D*0.25f,
 .0f-4*C, D*0.35f,
 .0f-8*C, D*0.6f,
 .60f   , D*1.0f,
 .30f   , D*1.375f,
 .0f    , D*1.4f };
         float[] vertices0 = { -F,+F, -F,-F, 0, -2*F, +F,-F, +F,+F };
         float[] bands0 = computeBands(0.038f,35,F,0.7f,7);
         MeshBase[] meshes = new MeshPolygon[MESHES];
         meshes[0] = new MeshPolygon(vertices0, bands0, 2, 2);
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
         float[] bands1 = { 1.0f    , 0,
 .90f   , D,
 .0f    , D };
         float[] bands1 = computeBands(0.02f,35,F/2,0.2f,3);
         float[] vertices1 = { -F/2, +F/2, -F/2, -1.5f*F, 1.5f*F, +F/2 };
         meshes[2] = new MeshPolygon(vertices1, bands1, 1, 2);
-...
         meshes[3] = meshes[2].copy(true);
         meshes[3].setEffectAssociation(0,8,0);
         float[] bands2 = { 1.0f    , 0,
 .90f   , D,
 .0f    , D };
         float X = 0.25f*SQ2;
         float Y = SQ6/16;
         float[] vertices2 = { -X, Y, -1.5f*X, -Y, +1.5f*X, -Y, +X, Y };
         meshes[4] = new MeshPolygon(vertices2, bands2, 1, 1);
         meshes[4] = new MeshPolygon(vertices2, bands1, 1, 1);
         meshes[4].setEffectAssociation(0,16,0);
         meshes[5] = meshes[4].copy(true);
         meshes[5].setEffectAssociation(0,32,0);
-...
       MeshBase createFacesRediCorner()
+        {
         final int MESHES=6;
         MeshBase[] meshes = new MeshBase[MESHES];
         MeshBase[] meshes = new MeshBase[6];
         float C = 0.027f;
         float D = 0.027f;
         float E = 0.5f;
         float[] vertices1 = { -E,-E, +E,-E, +E,+E, -E,+E };
         float[] bands1 = new float[] { 1.0f   ,-D,
 .0f-C/2,-D*0.55f,
 .0f-C  ,-D*0.25f,
 .0f-2*C, 0.0f,
 .50f   , D*1.5f,
 .0f    , D*1.75f };
         float[] vertices0 = { -E,-E, +E,-E, +E,+E, -E,+E };
         float[] bands0 = computeBands(0.06f,35,E,0.7f,6);
         meshes[0] = new MeshPolygon(vertices1,bands1,2,2);
         meshes[0] = new MeshPolygon(vertices0,bands0,2,2);
         meshes[0].setEffectAssociation(0,1,0);
         meshes[1] = meshes[0].copy(true);
         meshes[1].setEffectAssociation(0,2,0);
-...
         float F = SQ2/2;
         float X = 0.5f;
         float G = 0.72f;
         float[] vertices1 = { -E,+F, -E+X,0, -E,-F, -E*G,-F, +E*G,-F, +E,-F, +E-X,0, +E,+F, +E*G,+F, -E*G,+F };
         float[] bands1 = computeBands(0.0f,0,1.0f,0.0f,2);
         float[] vertices2 = { -E,+F, -E+X,0, -E,-F, +E,-F, +E-X,0, +E,+F };
         float[] bands2 = new float[] { 1.0f,0.0f,
 .0f,0.0f };
         meshes[3] = new MeshPolygon(vertices2,bands2,0,0);
         meshes[3] = new MeshPolygon(vertices1,bands1,0,0);
         meshes[3].setEffectAssociation(0,8,0);
         meshes[4] = meshes[3].copy(true);
         meshes[4].setEffectAssociation(0,16,0);
-...
         return new MeshJoined(meshes);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // EFFECTS
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       VertexEffect[] createVertexEffectsCube()
-...
         float F = 0.5f;
         final float ANGLE = (float)((180/Math.PI)*(Math.atan(SQ2)));
         Static1D angle1 = new Static1D(+ANGLE);
         Static1D angle2 = new Static1D(-ANGLE);
         Static1D angle1 = new Static1D(-ANGLE);
         Static1D angle2 = new Static1D(+ANGLE);
         Static3D axisX  = new Static3D(1,0,0);
         Static3D axisY  = new Static3D(0,1,0);
         Static3D axisZ  = new Static3D(0,-1,1);
-...
         verticesType2[0] = new Static3D(-E, 0, 0);
         verticesType2[1] = new Static3D( 0,-E, 0);
         verticesType2[2] = new Static3D( 0, 0,-E);
         roundCorners(mesh,roundingCenter,verticesType2,0.10f,0.20f);
         roundCorners(mesh,roundingCenter,verticesType2,0.08f,0.20f);
         mesh.mergeEffComponents();
-...
         Static3D[] verticesType2 = new Static3D[2];
         verticesType2[0] = new Static3D(-E+E/3, E/3  , 0);
         verticesType2[1] = new Static3D( E/3  ,-E+E/3, 0);
         roundCorners(mesh,roundingCenter,verticesType2,0.10f,0.20f);
         roundCorners(mesh,roundingCenter,verticesType2,0.08f,0.20f);
         mesh.mergeEffComponents();
         mesh.addEmptyTexComponent();
-...
         for( VertexEffect effect : effects ) mesh.apply(effect);
         Static3D center = new Static3D(0.0f,-0.75f,-0.75f);
         Static3D[] vertices = new Static3D[4];
         Static3D[] vertices = new Static3D[2];
         vertices[0] = new Static3D( 0.5f, 0.0f, 0.0f);
         vertices[1] = new Static3D(-0.5f, 0.0f, 0.0f);
         vertices[2] = new Static3D(0.0f, 0.0f,-1.5f);
         vertices[3] = new Static3D(0.0f,-1.5f, 0.0f);
         roundCorners(mesh,center,vertices,0.06f,0.20f);
         mesh.mergeEffComponents();

+        {
         float F =  0.5f;
         float R = 0.10f;
         float S = 0.10f;
         float S = 0.08f;
         float[] vertices = { -F,-F, +F,-F, +F,+F, -F,+F};
         drawRoundedPolygon(canvas, paint, left, vertices, S, FACE_COLORS[face], R);

       void createFaceTexture(Canvas canvas, Paint paint, int face, int left)
+        {
         float F = 0.5f;
         float R = 0.032f;
         float R = 0.025f;
         float S = 0.05f;
         float[] vertices = { -F,F/3, 0,-2*F/3, +F,F/3 };

       private static final float MAX_SIZE_CHANGE = 1.35f;
       private static final float MIN_SIZE_CHANGE = 0.8f;
       private static boolean mCreateFromDMesh = true;
       private static boolean mCreateFromDMesh = false;
       private static final Static3D CENTER = new Static3D(0,0,0);
       private static final int POST_ROTATION_MILLISEC = 500;

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision 2fcfce81

Added by Leszek Koltunski about 4 years ago