/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision afd7e804

Added by Leszek Koltunski over 2 years ago

ID afd7e8040a6c41d2788818db7d0a9549a283b4eb
Parent f404152d
Child 86308421

Everything about the nature of an object being bandaged should now hopefully be abstracted out in the single class - 'BandagedObject'

        private void rescaleObject()
+         {
          float size = mObject.getSize();
          float size = mObject.getMaxSize();
          final float Q = mObjectScreenRatio/size;
          mScaleValue = mWidth<mHeight ? Q*mWidth : Q*mHeight;
          mScale.set( mScaleValue,mScaleValue,mScaleValue );

     import org.distorted.library.type.Static1D;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.helpers.FactoryBandagedCubit;
     import org.distorted.objectlib.helpers.FactoryCubit;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_BLUE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_GREEN;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_ORANGE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_RED;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_WHITE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_YELLOW;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     public class BandagedCubit
-...
         private static Bitmap mBitmap;
         private static Static4D[] mTextureMaps;
         private final BandagedObject mObject;
         private final DistortedNode mNode;
         private final DistortedEffects mEffects;
         private final DistortedTexture mTexture;
         private final Static3D mMove;
         private final boolean mRoundCorners;
         private final int mX, mY, mZ;
         private float mUnscaledX, mUnscaledY, mUnscaledZ;
         private float[] mPosition;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private static void createBitmap()
         private static void createBitmap(int[] colors)
+          {
           final int[] FACE_COLORS = new int[]
+             {
                COLOR_YELLOW, COLOR_WHITE,
                COLOR_BLUE  , COLOR_GREEN,
                COLOR_RED   , COLOR_ORANGE
              };
           final int NUM = FACE_COLORS.length;
           final int NUM = colors.length;
           final int SIZE= 32;
           mTextureMaps = new Static4D[NUM];
-...
           for(int color=0; color<NUM; color++)
+            {
             paint.setColor(FACE_COLORS[color]);
             paint.setColor(colors[color]);
             canvas.drawRect(color*SIZE, 0, (color+1)*SIZE, SIZE, paint);
             mTextureMaps[color] = new Static4D( ((float)color)/NUM, 0.0f, 1.0f/NUM, 1.0f );
+            }
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // (x,y,z) ==
     //
     // ( 1,0,0) --> 0
     // (-1,0,0) --> 1
     // (0, 1,0) --> 2
     // (0,-1,0) --> 3
     // (0,0, 1) --> 4
     // (0,0,-1) --> 5
         private int computeMapsIndex(float x, float y, float z)
+          {
           int ix = x>0 ? (int)(x+0.5f) : (int)(x-0.5f);
           int iy = y>0 ? (int)(y+0.5f) : (int)(y-0.5f);
           int iz = z>0 ? (int)(z+0.5f) : (int)(z-0.5f);
           if( ix== 1 ) return 0;
           if( ix==-1 ) return 1;
           if( iy== 1 ) return 2;
           if( iy==-1 ) return 3;
           if( iz== 1 ) return 4;
           if( iz==-1 ) return 5;
           return 0;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         private void resetTextureMaps(MeshBase mesh)
-...
+            {
             Static4D q = fact.getQuaternion(i);
             QuatHelper.rotateVectorByQuat(mTmp,0,0,1,0,q);
             int index = computeMapsIndex(mTmp[0], mTmp[1], mTmp[2]);
             int index = mObject.computeMapsIndex(mTmp);
             maps[i] = mTextureMaps[index];
+            }
-...
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public BandagedCubit(float[] position, int x, int y, int z, Static4D quat1,
         public BandagedCubit(BandagedObject object, float[] position, Static4D quat1,
                              Static4D quat2, Static3D scale, boolean roundCorners)
+          {
           mX = x;
           mY = y;
           mZ = z;
           mObject = object;
           mRoundCorners = roundCorners;
           mPosition = position;
           mIsAttached = true;
-...
           computeMove(mPosition);
           mMove = new Static3D(0,0,0);
           FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();
           MeshBase mesh = factory.createMesh(mPosition,mX,mY,mZ,false,mRoundCorners);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           mTexture = new DistortedTexture();
           if( mBitmap==null ) createBitmap();
           if( mBitmap==null ) createBitmap(mObject.getColors());
           mTexture.setTextureAlreadyInverted(mBitmap);
           resetTextureMaps(mesh);
-...
           computeMove(tmpPosition);
           mPosition = tmpPosition;
           FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();
           MeshBase mesh = factory.createMesh(mPosition,mX,mY,mZ,false,mRoundCorners);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           resetTextureMaps(mesh);
           mNode.setMesh(mesh);
           mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-...
           mPosition[2] = z;
           computeMove(mPosition);
           FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();
           MeshBase mesh = factory.createMesh(mPosition,mX,mY,mZ,false,mRoundCorners);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           resetTextureMaps(mesh);
           mNode.setMesh(mesh);
           mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-...
         public void recreateBitmap()
+          {
           if( mBitmap==null ) createBitmap();
           if( mBitmap==null ) createBitmap(mObject.getColors());
           mTexture.setTextureAlreadyInverted(mBitmap);
+          }

     package org.distorted.bandaged;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_BLUE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_GREEN;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_ORANGE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_RED;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_WHITE;
     import static org.distorted.objectlib.main.TwistyObject.COLOR_YELLOW;
     import org.distorted.library.main.DistortedNode;
     import org.distorted.library.main.DistortedScreen;
     import org.distorted.library.mesh.MeshBase;
     import org.distorted.library.type.Static3D;
     import org.distorted.library.type.Static4D;
     import org.distorted.objectlib.helpers.FactoryBandagedCubit;
     import org.distorted.objectlib.main.InitData;
     import org.distorted.objectlib.main.TwistyObject;
     import org.distorted.objectlib.objects.TwistyBandagedCuboid;
-...
     public class BandagedObject
+    {
         private static final float DIST2D = 0.5f;
         private final DistortedScreen mScreen;
         private final float[] mPos;
         private final int[] mSize;
         private final float mDist2D;
         private BandagedCubit[] mCubits;
         private int mX, mY, mZ;
         private int mMax;
         private int mNumCubits;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+         {
          mScreen = screen;
          mPos = new float[3];
          mSize = new int[3];
          mDist2D = getDist2D();
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        int[] getSize()
+         {
          return mSize;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        float getSize()
        float getMaxSize()
+         {
          return mX>mY ? Math.max(mX, mZ) : Math.max(mY, mZ);
          return mMax;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
        TwistyObject createObject(int mode, float size)
+         {
          float[][] pos = getCubitPositions();
          InitData data = new InitData( new int[] {mX,mY,mZ},pos);
          InitData data = new InitData( mSize,pos);
          return new TwistyBandagedCuboid( TwistyObject.MESH_NICE, mode, ShapeHexahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );
+         }
-...
        boolean tryChangeObject(int x, int y, int z)
+         {
          if( mX!=x || mY!=y || mZ!=z )
          if( mSize[0]!=x || mSize[1]!=y || mSize[2]!=z )
+           {
            mX = x;
            mY = y;
            mZ = z;
            mNumCubits = computeNumCubits(mX,mY,mZ);
            mSize[0] = x;
            mSize[1] = y;
            mSize[2] = z;
            mMax = x>y ? Math.max(x,z) : Math.max(y,z);
            mNumCubits = computeNumCubits(x,y,z);
            return true;
+           }
-...
        int computeProjectionAngle()
+         {
          float quot1 = mZ/ (float)mX;
          float quot2 = mZ/ (float)mY;
          float quot3 = mX/ (float)mZ;
          float quot4 = mX/ (float)mY;
          float quot1 = mSize[2]/ (float)mSize[0];
          float quot2 = mSize[2]/ (float)mSize[1];
          float quot3 = mSize[0]/ (float)mSize[2];
          float quot4 = mSize[0]/ (float)mSize[1];
          float quot5 = Math.max(quot1,quot2);
          float quot6 = Math.max(quot3,quot4);
-...
        float[] getDist3D()
+         {
          float max = getSize();
          float max = getMaxSize();
          float x = 0.5f*(mX/max);
          float y = 0.5f*(mY/max);
          float z = 0.5f*(mZ/max);
          float x = 0.5f*(mSize[0]/max);
          float y = 0.5f*(mSize[1]/max);
          float z = 0.5f*(mSize[2]/max);
          return new float[] {x,x,y,y,z,z};
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        float getDist2D()
+         {
          return 0.5f;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // (x,y,z) ==
     //
     // ( 1,0,0) --> 0
     // (-1,0,0) --> 1
     // (0, 1,0) --> 2
     // (0,-1,0) --> 3
     // (0,0, 1) --> 4
     // (0,0,-1) --> 5
        int computeMapsIndex(float[] faceAxis)
+          {
           float x = faceAxis[0];
           float y = faceAxis[1];
           float z = faceAxis[2];
           int ix = x>0 ? (int)(x+0.5f) : (int)(x-0.5f);
           int iy = y>0 ? (int)(y+0.5f) : (int)(y-0.5f);
           int iz = z>0 ? (int)(z+0.5f) : (int)(z-0.5f);
           if( ix== 1 ) return 0;
           if( ix==-1 ) return 1;
           if( iy== 1 ) return 2;
           if( iy==-1 ) return 3;
           if( iz== 1 ) return 4;
           if( iz==-1 ) return 5;
           return 0;
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        MeshBase createMesh(float[] pos, boolean round)
+          {
           FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();
           int[] size = getSize();
           return factory.createMesh(pos,size[0],size[1],size[2],false,round);
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        int[] getColors()
+         {
          return new int[]
+             {
                COLOR_YELLOW, COLOR_WHITE,
                COLOR_BLUE  , COLOR_GREEN,
                COLOR_RED   , COLOR_ORANGE
              };
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        void createCubits(Static4D quatT, Static4D quatA, Static3D scale)
+         {
          mCubits = new BandagedCubit[mNumCubits];
          int c=0;
          float begX = 0.5f*(1-mX);
          float begY = 0.5f*(1-mY);
          float begZ = 0.5f*(1-mZ);
          for(int x=0; x<mX; x++)
            for(int y=0; y<mY; y++)
               for(int z=0; z<mZ; z++)
                 if( x==0 || x==mX-1 || y==0 || y==mY-1 || z==0 || z==mZ-1 )
          int sx = mSize[0];
          int sy = mSize[1];
          int sz = mSize[2];
          float begX = 0.5f*(1-sx);
          float begY = 0.5f*(1-sy);
          float begZ = 0.5f*(1-sz);
          for(int x=0; x<sx; x++)
            for(int y=0; y<sy; y++)
               for(int z=0; z<sz; z++)
                 if( x==0 || x==sx-1 || y==0 || y==sy-1 || z==0 || z==sz-1 )
+                  {
                   float[] pos = new float[] { begX+x,begY+y,begZ+z };
                   mCubits[c] = new BandagedCubit(pos,mX,mY,mZ,quatT,quatA,scale,false);
                   mCubits[c] = new BandagedCubit(this,pos,quatT,quatA,scale,false);
                   c++;
+                  }
+        }
-...
       void stretchPoint(int face, float[] output)
+        {
         float max = getSize();
         float max = getMaxSize();
         switch(face/2)
+          {
           case 0: output[0] *= (max/mZ); output[1] *= (max/mY); break;
           case 1: output[0] *= (max/mX); output[1] *= (max/mZ); break;
           case 2: output[0] *= (max/mX); output[1] *= (max/mY); break;
           case 0: output[0] *= (max/mSize[2]); output[1] *= (max/mSize[1]); break;
           case 1: output[0] *= (max/mSize[0]); output[1] *= (max/mSize[2]); break;
           case 2: output[0] *= (max/mSize[0]); output[1] *= (max/mSize[1]); break;
+          }
+        }
-...
       int whichCubitTouched(int face, float pointX, float pointY)
+        {
         float x = mSize[0];
         float y = mSize[1];
         float z = mSize[2];
         switch(face)
+          {
           case 0: mPos[0] = (mX-1)/2.0f;
                   mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;
                   mPos[2] = (int)(-mZ*pointX-mZ/2.0f)+(mZ-1)/2.0f;
           case 0: mPos[0] = (x-1)/2;
                   mPos[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   mPos[2] = (int)(-z*pointX-z/2)+(z-1)/2;
                   break;
           case 1: mPos[0] =-(mX-1)/2.0f;
                   mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;
                   mPos[2] = (int)( mZ*pointX+mZ/2.0f)-(mZ-1)/2.0f;
           case 1: mPos[0] =-(x-1)/2;
                   mPos[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   mPos[2] = (int)( z*pointX+z/2)-(z-1)/2;
                   break;
           case 2: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;
                   mPos[1] = (mY-1)/2.0f;
                   mPos[2] = (int)(-mZ*pointY-mZ/2.0f)+(mZ-1)/2.0f;
           case 2: mPos[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   mPos[1] = (y-1)/2;
                   mPos[2] = (int)(-z*pointY-z/2)+(z-1)/2;
                   break;
           case 3: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;
                   mPos[1] =-(mY-1)/2.0f;
                   mPos[2] = (int)( mZ*pointY+mZ/2.0f)-(mZ-1)/2.0f;
           case 3: mPos[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   mPos[1] =-(y-1)/2;
                   mPos[2] = (int)( z*pointY+z/2)-(z-1)/2;
                   break;
           case 4: mPos[0] = (int)( mX*pointX+mX/2.0f)-(mX-1)/2.0f;
                   mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;
                   mPos[2] = (mZ-1)/2.0f;
           case 4: mPos[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   mPos[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   mPos[2] = (z-1)/2;
                   break;
           case 5: mPos[0] = (int)(-mX*pointX-mX/2.0f)+(mX-1)/2.0f;
                   mPos[1] = (int)( mY*pointY+mY/2.0f)-(mY-1)/2.0f;
                   mPos[2] =-(mZ-1)/2.0f;
           case 5: mPos[0] = (int)(-x*pointX-x/2)+(x-1)/2;
                   mPos[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   mPos[2] =-(z-1)/2;
                   break;
+          }
-...
       boolean isInsideFace(int face, float[] p)
+        {
         return ( p[0]<=DIST2D && p[0]>=-DIST2D && p[1]<=DIST2D && p[1]>=-DIST2D );
         return ( p[0]<=mDist2D && p[0]>=-mDist2D && p[1]<=mDist2D && p[1]>=-mDist2D );
+        }
+    }

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision afd7e804

Added by Leszek Koltunski over 2 years ago