/ - Diff - Distorted Android

« Previous | Next »

Revision 4d883a92

Added by Leszek Koltunski about 3 years ago

ID 4d883a926fa41e31ddac23347fe163f476a2129c
Parent 28f4aba0
Child f4b59207

Cubit creation: bugfixes. Cube, Tetrahedron, Dino cubits - all work.

     class FactoryCubit
+      {
       private static final float[] mBuffer = new float[3];
       private static final float[] mQuat1  = new float[4];
       private static final float[] mQuat2  = new float[4];
       private static final float[] mQuat3  = new float[4];
       private static final double[] mBuffer = new double[3];
       private static final double[] mQuat1  = new double[4];
       private static final double[] mQuat2  = new double[4];
       private static final double[] mQuat3  = new double[4];
       private static final Static1D RADIUS = new Static1D(1);
-...
       private static class StickerInfo
+        {
         float[] vertices;
         double[] vertices;
+        }
       private static class FaceInfo
+        {
         int sticker;
         float vx,vy,vz;
         float scale;
         float qx,qy,qz,qw;
         double vx,vy,vz;
         double scale;
         double qx,qy,qz,qw;
         boolean flip;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean areColinear(float[][] vertices, int index1, int index2, int index3)
       private boolean areColinear(double[][] vertices, int index1, int index2, int index3)
+        {
         float x1 = vertices[index1][0];
         float y1 = vertices[index1][1];
         float z1 = vertices[index1][2];
         float x2 = vertices[index2][0];
         float y2 = vertices[index2][1];
         float z2 = vertices[index2][2];
         float x3 = vertices[index3][0];
         float y3 = vertices[index3][1];
         float z3 = vertices[index3][2];
         float v1x = x2-x1;
         float v1y = y2-y1;
         float v1z = z2-z1;
         float v2x = x3-x1;
         float v2y = y3-y1;
         float v2z = z3-z1;
         float A = (float)Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) );
         double x1 = vertices[index1][0];
         double y1 = vertices[index1][1];
         double z1 = vertices[index1][2];
         double x2 = vertices[index2][0];
         double y2 = vertices[index2][1];
         double z2 = vertices[index2][2];
         double x3 = vertices[index3][0];
         double y3 = vertices[index3][1];
         double z3 = vertices[index3][2];
         double v1x = x2-x1;
         double v1y = y2-y1;
         double v1z = z2-z1;
         double v2x = x3-x1;
         double v2y = y3-y1;
         double v2z = z3-z1;
         double A = Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) );
         return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void computeNormalVector(float[][] vertices, int index1, int index2, int index3)
       private void computeNormalVector(double[][] vertices, int index1, int index2, int index3)
+        {
         float x1 = vertices[index1][0];
         float y1 = vertices[index1][1];
         float z1 = vertices[index1][2];
         float x2 = vertices[index2][0];
         float y2 = vertices[index2][1];
         float z2 = vertices[index2][2];
         float x3 = vertices[index3][0];
         float y3 = vertices[index3][1];
         float z3 = vertices[index3][2];
         float v1x = x2-x1;
         float v1y = y2-y1;
         float v1z = z2-z1;
         float v2x = x3-x1;
         float v2y = y3-y1;
         float v2z = z3-z1;
         double x1 = vertices[index1][0];
         double y1 = vertices[index1][1];
         double z1 = vertices[index1][2];
         double x2 = vertices[index2][0];
         double y2 = vertices[index2][1];
         double z2 = vertices[index2][2];
         double x3 = vertices[index3][0];
         double y3 = vertices[index3][1];
         double z3 = vertices[index3][2];
         double v1x = x2-x1;
         double v1y = y2-y1;
         double v1z = z2-z1;
         double v2x = x3-x1;
         double v2y = y3-y1;
         double v2z = z3-z1;
         mBuffer[0] = v1y*v2z - v2y*v1z;
         mBuffer[1] = v1z*v2x - v2z*v1x;
         mBuffer[2] = v1x*v2y - v2x*v1y;
         float len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2];
         len = (float)Math.sqrt(len);
         double len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2];
         len = Math.sqrt(len);
         mBuffer[0] /= len;
         mBuffer[1] /= len;
         mBuffer[2] /= len;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // return quat1*quat2
       private static void quatMultiply( float[] quat1, float[] quat2, float[] result )
       private static void quatMultiply( double[] quat1, double[] quat2, double[] result )
+        {
         float qx = quat1[0];
         float qy = quat1[1];
         float qz = quat1[2];
         float qw = quat1[3];
         double qx = quat1[0];
         double qy = quat1[1];
         double qz = quat1[2];
         double qw = quat1[3];
         float rx = quat2[0];
         float ry = quat2[1];
         float rz = quat2[2];
         float rw = quat2[3];
         double rx = quat2[0];
         double ry = quat2[1];
         double rz = quat2[2];
         double rw = quat2[3];
         result[0] = rw*qx - rz*qy + ry*qz + rx*qw;
         result[1] = rw*qy + rz*qx + ry*qw - rx*qz;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void fitInSquare(FaceInfo info, float[][] vert3D)
       private void fitInSquare(FaceInfo info, double[][] vert3D)
+        {
         float minX = Float.MAX_VALUE;
         float maxX =-Float.MAX_VALUE;
         float minY = Float.MAX_VALUE;
         float maxY =-Float.MAX_VALUE;
         double minX = Double.MAX_VALUE;
         double maxX =-Double.MAX_VALUE;
         double minY = Double.MAX_VALUE;
         double maxY =-Double.MAX_VALUE;
         for (float[] vert : vert3D)
         for (double[] vert : vert3D)
+          {
           float x = vert[0];
           float y = vert[1];
           double x = vert[0];
           double y = vert[1];
           if (x > maxX) maxX = x;
           if (x < minX) minX = x;
-...
         int len = vert3D.length;
         StickerInfo sInfo = new StickerInfo();
         sInfo.vertices = new float[2*len];
         sInfo.vertices = new double[2*len];
         for( int vertex=0; vertex<len; vertex++ )
+          {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void constructNew(FaceInfo info, final float[][] vert3D)
       private void constructNew(FaceInfo info, final double[][] vert3D)
+        {
         // compute center of gravity
         info.vx = 0.0f;
-...
         info.vz = 0.0f;
         int len = vert3D.length;
         for (float[] vert : vert3D)
         for (double[] vert : vert3D)
+          {
           info.vx += vert[0];
           info.vy += vert[1];
-...
         computeNormalVector(vert3D,0,1,foundIndex);
         // rotate so that the normal vector becomes (0,0,1)
         float axisX, axisY, axisZ;
         double axisX, axisY, axisZ;
         if( mBuffer[0]!=0.0f || mBuffer[1]!=0.0f )
+          {
-...
           axisY =  mBuffer[0];
           axisZ = 0.0f;
           float axiLen = axisX*axisX + axisY*axisY;
           axiLen = (float)Math.sqrt(axiLen);
           double axiLen = axisX*axisX + axisY*axisY;
           axiLen = Math.sqrt(axiLen);
           axisX /= axiLen;
           axisY /= axiLen;
           axisZ /= axiLen;
-...
           axisZ = 0.0f;
+          }
         float cosTheta = mBuffer[2];
         float sinHalfTheta = (float)Math.sqrt(0.5f*(1-cosTheta));
         float cosHalfTheta = (float)Math.sqrt(0.5f*(1+cosTheta));
         double cosTheta = mBuffer[2];
         double sinTheta = Math.sqrt(1-cosTheta*cosTheta);
         double sinHalfTheta = computeSinHalf(cosTheta);
         double cosHalfTheta = computeCosHalf(sinTheta,cosTheta);
         mQuat1[0] = axisX*sinHalfTheta;
         mQuat1[1] = axisY*sinHalfTheta;
-...
         mQuat2[2] =-axisZ*sinHalfTheta;
         mQuat2[3] = cosHalfTheta;
         for (float[] vert : vert3D)
         for (double[] vert : vert3D)
+          {
           quatMultiply(mQuat1, vert  , mQuat3);
           quatMultiply(mQuat3, mQuat2, vert  );
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float computeCos(float x1, float y1, float x2, float y2, float len1, float len2)
       private double computeCos(double oldX, double oldY, double newX, double newY, double len1, double len2)
+        {
         float ret =  (x1*x2+y1*y2) / (len1*len2);
         double ret =  (oldX*newX+oldY*newY) / (len1*len2);
         if( ret> 1.0f ) return  1.0f;
         if( ret<-1.0f ) return -1.0f;
         if( ret> 1.0f ) return  1.0;
         if( ret<-1.0f ) return -1.0;
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // sin of (signed!) angle between vectors (x1,y1) and (x2,y2), counterclockwise!
     // sin of (signed!) angle between vectors 'old' and 'new', counterclockwise!
       private float computeSin(float x1, float y1, float x2, float y2, float len1, float len2)
       private double computeSin(double oldX, double oldY, double newX, double newY, double len1, double len2)
+        {
         float ret = (x2*y1-x1*y2) / (len1*len2);
         double ret = (newX*oldY-oldX*newY) / (len1*len2);
         if( ret> 1.0f ) return  1.0f;
         if( ret<-1.0f ) return -1.0f;
         if( ret> 1.0f ) return  1.0;
         if( ret<-1.0f ) return -1.0;
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void rotateAllVertices(float[] result, int len, float[] vertices, float sin, float cos)
       private void rotateAllVertices(double[] result, int len, double[] vertices, double sin, double cos)
+        {
         for(int i=0; i<len; i++)
+          {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isScaledVersionOf(float[] v1, float[] v2, int len)
       private double computeScale(double[] v1, double[] v2)
+        {
         float EPSILON = 0.001f;
         float scale = v1[0]!=0.0f ? v2[0]/v1[0] : v2[1]/v1[1];
         double lenSq1 = v1[0]*v1[0] + v1[1]*v1[1];
         double lenSq2 = v2[0]*v2[0] + v2[1]*v2[1];
         return Math.sqrt(lenSq2/lenSq1);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private double computeSinHalf(double cos)
+        {
         return Math.sqrt((1-cos)/2);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private double computeCosHalf(double sin, double cos)
+        {
         double cosHalf = Math.sqrt((1+cos)/2);
         return sin<0 ? -cosHalf : cosHalf;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len)
+        {
         double EPSILON = 0.001;
         double scale = computeScale(newVert,oldVert);
         for(int i=1; i<len; i++)
+          {
           float horz = v2[2*i  ] - scale*v1[2*i  ];
           float vert = v2[2*i+1] - scale*v1[2*i+1];
           double horz = oldVert[2*i  ] - scale*newVert[2*i  ];
           double vert = oldVert[2*i+1] - scale*newVert[2*i+1];
           if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void mirrorAllVertices(float[] output, int len, float[] input)
       private void mirrorAllVertices(double[] output, int len, double[] input)
+        {
         for(int vertex=0; vertex<len; vertex++)
+          {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void correctInfo(FaceInfo info, float scale, float cos, int oldSticker, boolean flip)
       private void correctInfo(FaceInfo info, double scale, double sin, double cos, int oldSticker, boolean flip)
+        {
         mStickerInfo.remove(info.sticker);
-...
         mQuat1[2] = info.qz;
         mQuat1[3] = info.qw;
         float sinHalf = (float)Math.sqrt(0.5f*(1-cos));
         float cosHalf = (float)Math.sqrt(0.5f*(1+cos));
         double sinHalf = computeSinHalf(cos);
         double cosHalf = computeCosHalf(sin,cos);
         mQuat2[0] = 0.0f;
         mQuat2[1] = 0.0f;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean foundVertex(FaceInfo info, float[] buffer, int len, float[] preVert,
                                   float[] newVert, float lenVert, int oldSticker, boolean inverted)
       private boolean foundVertex(FaceInfo info, double[] buffer, int len, double[] newVert,
                                   double[] oldVert, double lenFirstOld, int oldSticker, boolean inverted)
+        {
         for(int vertex=0; vertex<len; vertex++)
+          {
           float xR = preVert[2*vertex  ];
           float yR = preVert[2*vertex+1];
           float lenRotV = (float)Math.sqrt(xR*xR+yR*yR);
           float cos = computeCos(xR,yR,newVert[0],newVert[1], lenRotV, lenVert);
           float sin = computeSin(xR,yR,newVert[0],newVert[1], lenRotV, lenVert);
           double newX = newVert[2*vertex  ];
           double newY = newVert[2*vertex+1];
           double lenIthNew = Math.sqrt(newX*newX + newY*newY);
           double cos = computeCos( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);
           double sin = computeSin( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);
           rotateAllVertices(buffer,len,newVert,sin,cos);
           if( isScaledVersionOf(buffer,preVert,len) )
           if( isScaledVersionOf(buffer,oldVert,len) )
+            {
             float scale = preVert[0]!=0.0f ? buffer[0]/preVert[0] : buffer[1]/preVert[1];
             correctInfo(info,scale,cos,oldSticker,inverted);
             double scale = computeScale(oldVert,newVert);
             correctInfo(info,scale,sin,cos,oldSticker,inverted);
             return true;
+            }
+          }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean successfullyCollapsedStickers(final FaceInfo newInfo, final FaceInfo preInfo)
       private boolean successfullyCollapsedStickers(final FaceInfo newInfo, final FaceInfo oldInfo)
+        {
         StickerInfo sNewInfo = mStickerInfo.get(newInfo.sticker);
         StickerInfo sPreInfo = mStickerInfo.get(preInfo.sticker);
         int len = sPreInfo.vertices.length;
         float[] newVert = sNewInfo.vertices;
         StickerInfo sOldInfo = mStickerInfo.get(oldInfo.sticker);
         double[] newVert = sNewInfo.vertices;
         double[] oldVert = sOldInfo.vertices;
         int oldLen = oldVert.length;
         int newLen = newVert.length;
         if( len == newVert.length )
         if( oldLen == newLen )
+          {
           int oldSticker = preInfo.sticker;
           float[] tmp1 = new float[len];
           float lenVert = (float)Math.sqrt(newVert[0]*newVert[0] + newVert[1]*newVert[1]);
           if( foundVertex(newInfo, tmp1, len/2, sPreInfo.vertices, newVert, lenVert, oldSticker, false) ) return true;
           float[] tmp2 = new float[len];
           mirrorAllVertices(tmp2,len/2,sPreInfo.vertices);
           if( foundVertex(newInfo, tmp1, len/2, tmp2             , newVert, lenVert, oldSticker, true ) ) return true;
           int oldSticker = oldInfo.sticker;
           double[] buffer1 = new double[oldLen];
           double lenFirstOld = Math.sqrt(newVert[0]*newVert[0] + newVert[1]*newVert[1]);
           if( foundVertex(newInfo, buffer1, oldLen/2, newVert, oldVert, lenFirstOld, oldSticker, false) ) return true;
           double[] buffer2 = new double[oldLen];
           mirrorAllVertices(buffer2, newLen/2, newVert);
           if( foundVertex(newInfo, buffer1, oldLen/2, buffer2, oldVert, lenFirstOld, oldSticker, true ) ) return true;
+          }
         return false;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private float[][] constructVert(float[][] vertices, int[] index)
       private double[][] constructVert(double[][] vertices, int[] index)
+        {
         int len = index.length;
         float[][] ret = new float[len][4];
         double[][] ret = new double[len][4];
         for(int i=0; i<len; i++)
+          {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void prepareFaceInfo( final float[][] vertices, final int[][] indexes)
       private void prepareFaceInfo( final double[][] vertices, final int[][] indexes)
+        {
         mFaceInfo.clear();
         mStickerInfo.clear();
         int numFaces = indexes.length;
         FaceInfo preInfo;
         FaceInfo oldInfo;
         for(int face=0; face<numFaces; face++)
+          {
           FaceInfo newInfo = new FaceInfo();
           int[] index = indexes[face];
           float[][] vert = constructVert(vertices,index);
           double[][] vert = constructVert(vertices,index);
           constructNew(newInfo,vert);
           for(int previous=0; previous<face; previous++)
+            {
             preInfo = mFaceInfo.get(previous);
             if( successfullyCollapsedStickers(newInfo,preInfo) ) break;
             oldInfo = mFaceInfo.get(previous);
             if( successfullyCollapsedStickers(newInfo,oldInfo) ) break;
+            }
           mFaceInfo.add(newInfo);
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void prepareAndRoundCorners(MeshBase mesh, float[][] vertices, int[][] vertIndexes,
       private void prepareAndRoundCorners(MeshBase mesh, double[][] vertices, int[][] vertIndexes,
                                           float[][] corners, int[] cornerIndexes )
+        {
         int numNeig, lenFV;
-...
         int[] verts = new int[2*(lenV-1)];
         Static3D[] staticVert = new Static3D[1];
         Static3D center = new Static3D(0,0,0);
         float cx, cy, cz;
         float[] singleV;
         double cx, cy, cz;
         double[] singleV;
         for(int v=0; v<lenV; v++)
+          {
-...
             cy += singleV[1];
             cz += singleV[2];
+            }
           center.set(cx/numNeig - vertices[v][0],cy/numNeig - vertices[v][1],cz/numNeig - vertices[v][2]);
           center.set( (float)(cx/numNeig - vertices[v][0]),
                       (float)(cy/numNeig - vertices[v][1]),
                       (float)(cz/numNeig - vertices[v][2]));
           // round Corners
           staticVert[0] = new Static3D(vertices[v][0], vertices[v][1], vertices[v][2]);
           staticVert[0] = new Static3D( (float)vertices[v][0], (float)vertices[v][1], (float)vertices[v][2]);
           int corn = cornerIndexes[v];
           float strength = corners[corn][0];
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createRoundedSolid(final float[][] vertices, final int[][] vertIndexes,
                                   final float[][] bands   , final int[]   bandIndexes,
                                   final float[][] corners , final int[]   cornerIndexes)
       MeshBase createRoundedSolid(final double[][] vertices, final int[][] vertIndexes,
                                   final float[][] bands    , final int[]   bandIndexes,
                                   final float[][] corners  , final int[]   cornerIndexes)
+        {
         int EFFECTS_PER_FACE = 3;
-...
           fInfo = mFaceInfo.get(face);
           sInfo = mStickerInfo.get(fInfo.sticker);
           double[] verts = sInfo.vertices;
           int lenVerts = verts.length;
           float[] vertsFloat = new float[lenVerts];
           for(int i=0; i<lenVerts; i++) vertsFloat[i] = (float)verts[i];
           band = bands[bandIndexes[face]];
           bandsComputed = computeBands( band[0], (int)band[1], band[2], band[3], (int)band[4]);
           meshes[face] = new MeshPolygon(sInfo.vertices,bandsComputed,(int)band[5],(int)band[6]);
           meshes[face] = new MeshPolygon(vertsFloat,bandsComputed,(int)band[5],(int)band[6]);
           meshes[face].setEffectAssociation(0,(1<<face),0);
+          }
-...
           int assoc = (1<<face);
           fInfo = mFaceInfo.get(face);
           Static3D move3D= new Static3D(fInfo.vx,fInfo.vy,fInfo.vz);
           Static3D scale = new Static3D(fInfo.scale,fInfo.scale, fInfo.flip ? -fInfo.scale : fInfo.scale);
           Static4D quat  = new Static4D(fInfo.qx,fInfo.qy,fInfo.qz,fInfo.qw);
           float vx = (float)fInfo.vx;
           float vy = (float)fInfo.vy;
           float vz = (float)fInfo.vz;
           float sc = (float)fInfo.scale;
           float qx = (float)fInfo.qx;
           float qy = (float)fInfo.qy;
           float qz = (float)fInfo.qz;
           float qw = (float)fInfo.qw;
           Static3D move3D= new Static3D(vx,vy,vz);
           Static3D scale = new Static3D(sc,sc, fInfo.flip ? -sc : sc);
           Static4D quat  = new Static4D(qx,qy,qz,qw);
           effects[EFFECTS_PER_FACE*face  ] = new MatrixEffectScale(scale);
           effects[EFFECTS_PER_FACE*face+1] = new MatrixEffectQuaternion(quat,center);

     import org.distorted.library.main.DistortedTexture;
     import org.distorted.library.mesh.MeshBase;
     import org.distorted.library.mesh.MeshFile;
     import org.distorted.library.mesh.MeshPolygon;
     import org.distorted.library.type.DynamicQuat;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
-...
           return bitmap;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private MeshBase createStaticMesh()
+        {
         final float IVY_D = 0.10f;
         final int   IVY_N = 8;
         final float angle = (float)Math.PI/(2*IVY_N);
         final float CORR  = 1.0f - IVY_D*SQ2;
         final float DIST  = 0.4f;
         final float CORR2 = 0.5f;
         float[] vertices = new float[2*(IVY_N+1)+6];
         vertices[0] = ( 0.5f      -DIST)*CORR2;
         vertices[1] = (-0.5f+IVY_D-DIST)*CORR2;
         vertices[2] = ( 0.5f      -DIST)*CORR2;
         vertices[3] = ( 0.5f      -DIST)*CORR2;
         vertices[4] = (-0.5f+IVY_D-DIST)*CORR2;
         vertices[5] = ( 0.5f      -DIST)*CORR2;
         for(int i=0; i<=IVY_N; i++)
+          {
           float ang = (IVY_N-i)*angle;
           float sin = (float)Math.sin(ang);
           float cos = (float)Math.cos(ang);
           vertices[2*i+6] = (CORR*(cos-0.5f)-DIST)*CORR2;
           vertices[2*i+7] = (CORR*(sin-0.5f)-DIST)*CORR2;
+          }
         float[] bands = new float[] {1.0f, 0.0f, 0.5f, 0.03f, 0.0f, 0.05f};
         MeshBase mesh = new MeshPolygon(vertices,bands,0,0);
         mesh.setShowNormals(true);
         return mesh;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void createMesh()
+          {
           int mode = 2;
           float[][] vertices  = null;
           double[][] vertices = null;
           int[][] vertIndexes = null;
           float[][] bands     = null;
           int[] bandIndexes   = null;
           float[][] corners   = null;
           int[] cornerIndexes = null;
           if( mode==0 ) // CUBE
           ///// CUBE ////////////////////////////////////////////////////////////////////////////////
           if( mode==0 )
+            {
             vertices = new float[][]
             vertices = new double[][]
+              {
                   { 0.5f, 0.5f, 0.5f },
                   { 0.5f, 0.5f,-0.5f },
                   { 0.5f,-0.5f, 0.5f },
                   { 0.5f,-0.5f,-0.5f },
                   {-0.5f, 0.5f, 0.5f },
                   {-0.5f, 0.5f,-0.5f },
                   {-0.5f,-0.5f, 0.5f },
                   {-0.5f,-0.5f,-0.5f },
                   { 0.5, 0.5, 0.5 },
                   { 0.5, 0.5,-0.5 },
                   { 0.5,-0.5, 0.5 },
                   { 0.5,-0.5,-0.5 },
                   {-0.5, 0.5, 0.5 },
                   {-0.5, 0.5,-0.5 },
                   {-0.5,-0.5, 0.5 },
                   {-0.5,-0.5,-0.5 },
               };
             vertIndexes = new int[][]
-...
             cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
+            }
           else if( mode==1 ) // TETRAHEDRON
           ///// TETRAHEDRON //////////////////////////////////////////////////////////////////////////
           else if( mode==1 )
+            {
             vertices = new float[][]
             vertices = new double[][]
+              {
                   {-0.5f, SQ2/4, 0.0f},
                   { 0.5f, SQ2/4, 0.0f},
                   { 0.0f,-SQ2/4, 0.5f},
                   { 0.0f,-SQ2/4,-0.5f}
                   {-0.5, SQ2/4, 0.0},
                   { 0.5, SQ2/4, 0.0},
                   { 0.0,-SQ2/4, 0.5},
                   { 0.0,-SQ2/4,-0.5}
               };
             vertIndexes = new int[][]
-...
             cornerIndexes = new int[] { 0,0,0,0 };
+            }
           else if( mode==2 )  // DINO
           ///// DINO ////////////////////////////////////////////////////////////////////////////////
           else if( mode==2 )
+            {
             vertices = new float[][]
             vertices = new double[][]
+              {
                   {-0.5f, 0.0f, 0.0f},
                   { 0.5f, 0.0f, 0.0f},
                   { 0.0f,-0.5f, 0.0f},
                   { 0.0f, 0.0f,-0.5f}
                   {-0.5, 0.0, 0.0},
                   { 0.5, 0.0, 0.0},
                   { 0.0,-0.5, 0.0},
                   { 0.0, 0.0,-0.5}
               };
             vertIndexes = new int[][]

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 4d883a92

Added by Leszek Koltunski about 3 years ago