/src/main/java/org/distorted/bandaged/BandagedObject.java - 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'

     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