/ - Diff - Distorted Android

« Previous | Next »

Revision 3083fab8

Added by Leszek Koltunski over 3 years ago

ID 3083fab8550aa83058bd85068e54b89ebd5197de
Parent 6a96e571
Child 6983badf

Cubit creation: properly cener the textures. Add Kilominx edge.

       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 double[] mQuat4  = new double[4];
       private static final Static1D RADIUS = new Static1D(1);
-...
       private static class StickerInfo
+        {
         double[] vertices;
         double dx,dy;
+        }
       private static class FaceInfo
-...
           if (y < minY) minY = y;
+          }
         info.scale = Math.max(maxX-minX,maxY-minY);
         minX = minX<0 ? -minX:minX;
         maxX = maxX<0 ? -maxX:maxX;
         minY = minY<0 ? -minY:minY;
         maxY = maxY<0 ? -maxY:maxY;
         double max1 = Math.max(minX,minY);
         double max2 = Math.max(maxX,maxY);
         double max3 = Math.max(max1,max2);
         info.scale = max3/0.5;
         int len = vert3D.length;
         StickerInfo sInfo = new StickerInfo();
-...
       private double computeCos(double oldX, double oldY, double newX, double newY, double len1, double len2)
+        {
         return (oldX*newX+oldY*newY) / (len1*len2);
         double ret= (oldX*newX+oldY*newY) / (len1*len2);
         if( ret<-1.0 ) return -1.0;
         if( ret> 1.0 ) return  1.0;
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
       private double computeSin(double oldX, double oldY, double newX, double newY, double len1, double len2)
+        {
         return (newX*oldY-oldX*newY) / (len1*len2);
         double ret= (newX*oldY-oldX*newY) / (len1*len2);
         if( ret<-1.0 ) return -1.0;
         if( ret> 1.0 ) return  1.0;
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len)
       private int computeRotatedIndex(int oldVertex, int len, int rotatedVertex, boolean inverted)
+        {
         int v = (rotatedVertex + (inverted? -oldVertex : oldVertex));
         if( v>=len ) v-=len;
         if( v< 0   ) v+=len;
         return v;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted)
+        {
         double EPSILON = 0.001;
         double scale = computeScale(newVert,oldVert);
         for(int i=1; i<len; i++)
+          {
           double horz = oldVert[2*i  ] - scale*newVert[2*i  ];
           double vert = oldVert[2*i+1] - scale*newVert[2*i+1];
           int index = computeRotatedIndex(i,len,vertex,inverted);
           double horz = oldVert[2*i  ] - scale*newVert[2*index  ];
           double vert = oldVert[2*i+1] - scale*newVert[2*index+1];
           if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;
+          }
-...
         double sinHalf = computeSinHalf(cos);
         double cosHalf = computeCosHalf(sin,cos);
         mQuat2[0] = 0.0f;
         mQuat2[1] = 0.0f;
         mQuat2[2] = sinHalf;
         mQuat2[3] = cosHalf;
         if( flip )
+          {
           mQuat3[0] = 0.0f;
           mQuat3[1] = 0.0f;
           mQuat3[2] = sinHalf;
           mQuat3[3] = cosHalf;
           mQuat4[0] = 1.0;
           mQuat4[1] = 0.0;
           mQuat4[2] = 0.0;
           mQuat4[3] = 0.0;
           quatMultiply( mQuat3, mQuat4, mQuat2 );
+          }
         else
+          {
           mQuat2[0] = 0.0f;
           mQuat2[1] = 0.0f;
           mQuat2[2] = sinHalf;
           mQuat2[3] = cosHalf;
+          }
         quatMultiply( mQuat1, mQuat2, mQuat3 );
-...
         info.qw = mQuat3[3];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void printVert(double[] buffer)
+        {
         int len = buffer.length/2;
         String str = "";
         for(int i=0; i<len; i++)
+          {
           str += (" ("+buffer[2*i]+" , "+buffer[2*i+1]+" ) ");
+          }
         android.util.Log.d("D", str);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean foundVertex(FaceInfo info, double[] buffer, int len, double[] newVert,
-...
           rotateAllVertices(buffer,len,newVert,sin,cos);
           if( isScaledVersionOf(buffer,oldVert,len) )
           if( isScaledVersionOf(buffer,oldVert,len,vertex,inverted) )
+            {
             double scale = computeScale(oldVert,newVert);
             correctInfo(info,scale,sin,cos,oldSticker,inverted);
-...
         return ret;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void centerTextures()
+        {
         int numStickers = mStickerInfo.size();
         StickerInfo info;
         for(int sticker=0; sticker<numStickers; sticker++)
+          {
           double minX = Double.MAX_VALUE;
           double minY = Double.MAX_VALUE;
           double maxX =-Double.MAX_VALUE;
           double maxY =-Double.MAX_VALUE;
           info = mStickerInfo.get(sticker);
           double[] vert = info.vertices;
           int numVert = vert.length/2;
           for ( int v=0; v<numVert; v++)
+            {
             double x = vert[2*v  ];
             double y = vert[2*v+1];
             if (x < minX) minX = x;
             if (y < minY) minY = y;
             if (x > maxX) maxX = x;
             if (y > maxY) maxY = y;
+            }
           info.dx = info.dy = 0.0;
           if( minX<-0.5 ) info.dx = minX + 0.5;
           if( minY<-0.5 ) info.dy = minY + 0.5;
           if( maxX> 0.5 ) info.dx = maxX - 0.5;
           if( maxY> 0.5 ) info.dy = maxY - 0.5;
           for ( int v=0; v<numVert; v++)
+            {
             vert[2*v  ] -= info.dx;
             vert[2*v+1] -= info.dy;
+            }
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void prepareFaceInfo( final double[][] vertices, final int[][] indexes)
-...
           mFaceInfo.add(newInfo);
+          }
         centerTextures();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+          {
           int assoc = (1<<face);
           fInfo = mFaceInfo.get(face);
           sInfo = mStickerInfo.get(fInfo.sticker);
           float dx = (float)sInfo.dx;
           float dy = (float)sInfo.dy;
           float vx = (float)fInfo.vx;
           float vy = (float)fInfo.vy;
           float vz = (float)fInfo.vz;
-...
           float qz = (float)fInfo.qz;
           float qw = (float)fInfo.qw;
           Static3D move2D= new Static3D(dx,dy,0.0f);
           Static3D move3D= new Static3D(vx,vy,vz);
           Static3D scale = new Static3D(sc,sc, fInfo.flip ? -sc : sc);
           Static3D move3D= new Static3D(vx,vy,vz);
           Static4D quat  = new Static4D(qx,qy,qz,qw);
           mesh.apply(new MatrixEffectMove(move2D)           ,assoc,-1);
           mesh.apply(new MatrixEffectScale(scale)           ,assoc,-1);
           mesh.apply(new MatrixEffectQuaternion(quat,center),assoc,-1);
           mesh.apply(new MatrixEffectMove(move3D)           ,assoc,-1);

         private void createMesh()
+          {
           int mode = 0;
           int mode = 4;
           double[][] vertices = null;
           int[][] vertIndexes = null;
           float[][] bands     = null;
-...
             cornerIndexes = new int[] { 0,0,0,0,0,0 };
+            }
           ///// KILOMINX EDGE ////////////////////////////////////////////////////////////////////////
           else if( mode==4 )
+            {
             double SQ5  = Math.sqrt(5);
             double SIN18= (SQ5-1)/4;
             double COS18= 0.25*Math.sqrt(10.0+2.0*SQ5);
             double H = 1.0;
             double L = 2.0;
             double X = H*Math.sqrt((5+SQ5)/10);
             double Y = H*Math.sqrt((5-SQ5)/10);
             double D = H*SIN18/COS18;
             vertices = new double[][]
+              {
                   { 0.0,   Y, L/2},
                   {   X, 0.0, L/2},
                   { 0.0,  -Y, L/2},
                   {  -X, 0.0, L/2},
                   { 0.0,  Y, -L/2 +D},
                   {   X, 0.0,-L/2   },
                   { 0.0, -Y, -L/2-D },
                   {  -X, 0.0,-L/2   }
               };
             vertIndexes = new int[][]
+              {
                   {3,2,1,0},   // counterclockwise!
                   {0,1,5,4},
                   {3,0,4,7},
                   {2,1,5,6},
                   {3,2,6,7},
                   {4,5,6,7}
               };
             bands = new float[][]
+              {
                  {0.04f,13,(float)(L/3),(float)L/8, 5,2,3},
                  {0.00f, 0,(float)(L/2),(float)L/4, 5,2,3}
               };
             bandIndexes = new int[] { 1,0,0,1,1,1 };
             corners = new float[][]
+              {
                   { 0.01f, 0.12f },
                   { 0.00f, 0.00f }
               };
             cornerIndexes = new int[] { 0,1,1,1,0,1,1,1 };
+            }
           FactoryCubit factory = FactoryCubit.getInstance();
           mMesh = factory.createRoundedSolid(vertices, vertIndexes, bands, bandIndexes, corners, cornerIndexes);

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision 3083fab8

Added by Leszek Koltunski over 3 years ago