/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision afd7e804

Added by Leszek Koltunski 12 months 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 12 months ago