/ - Diff - Magic Cube - Distorted Android

« Previous | Next »

Revision b2de7562

Added by Leszek Koltunski over 2 years ago

ID b2de756280b5070a9a5bb441bfd624b12ab40df2
Parent 86308421
Child 462b983d

Progress with BandagedObject.

src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
138	138	float az = mFaceAxis[mLastTouchedFace].get2();
139	139
140	140	convertTo2Dcoords(mTouch, ax,ay,az, mPoint2D);
141		mObject.stretchPoint(mLastTouchedFace,mPoint2D);
	141
142	142	if( mObject.isInsideFace(mLastTouchedFace,mPoint2D) ) return true;
143	143	}
144	144	}

+    {
         private final DistortedScreen mScreen;
         private final float[][] mFaceAxis;
         private final float[] mTmp;
         private BandagedCubit[] mCubits;
         final int[] mSize;
         final float mDist2D;
         BandagedCubit[] mCubits;
         int mMax;
         int mNumCubits;
-...
          mScreen = screen;
          mSize = new int[3];
          mDist2D = getDist2D();
          mTmp = new float[3];
          Static3D[] axis = getFaceAxis();
          int numAxis = axis.length;
          mFaceAxis = new float[numAxis][];
-...
        abstract float[] getDist3D();
        abstract int[] getColors();
        abstract Static3D[] getFaceAxis();
        abstract void createCubits(Static4D quatT, Static4D quatA, Static3D scale);
        abstract boolean isAdjacent(float[] pos1, float[] pos2);
        abstract float[][] getPositions();
        abstract boolean isAdjacent(float dx, float dy, float dz);
        abstract int computeProjectionAngle();
        abstract boolean tryChangeObject(int x, int y, int z);
        abstract void stretchPoint(int face, float[] output);
        abstract int whichCubitTouched(int face, float pointX, float pointY);
        abstract void getTouchedPosition(float[] output, int face, float pointX, float pointY);
        abstract boolean isInsideFace(int face, float[] p);
        abstract TwistyObject createObject(int mode, float scale );
        abstract MeshBase createMesh(float[] pos, boolean round);
-...
          return mSize;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        void createCubits(Static4D quatT, Static4D quatA, Static3D scale)
+         {
          mCubits = new BandagedCubit[mNumCubits];
          int c=0;
          for(float[] p : getPositions() ) mCubits[c++] = new BandagedCubit(this,p,quatT,quatA,scale,false);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        int computeMapsIndex(float[] faceAx)
-...
+        {
         if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setUnmarked();
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       int whichCubitTouched(int face, float pointX, float pointY)
+        {
         getTouchedPosition(mTmp, face, pointX, pointY);
         for(int c=0; c<mNumCubits; c++)
           if( mCubits[c].isAttached() )
+            {
             float[] pos = mCubits[c].getPosition();
             int len = pos.length/3;
             for(int p=0; p<len; p++)
               if( pos[3*p]==mTmp[0] && pos[3*p+1]==mTmp[1] && pos[3*p+2]==mTmp[2] ) return c;
+            }
         android.util.Log.e("D", "whichCubitTouched: IMPOSSIBLE!!");
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean isAdjacent(float[] pos1, float[] pos2)
+         {
          int len1 = pos1.length/3;
          int len2 = pos2.length/3;
          for(int i=0; i<len1; i++)
            for(int j=0; j<len2; j++)
+             {
              float dx = pos1[3*i  ] - pos2[3*j  ];
              float dy = pos1[3*i+1] - pos2[3*j+1];
              float dz = pos1[3*i+2] - pos2[3*j+2];
              if( isAdjacent(dx,dy,dz) ) return true;
+             }
          return false;
+         }
+    }

     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;
-...
     public class BandagedObjectCuboid extends BandagedObject
+    {
        private final float[] mPos;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        BandagedObjectCuboid(DistortedScreen screen)
+         {
          super(screen);
          mPos = new float[3];
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        boolean isAdjacent(float[] pos1, float[] pos2)
        float[] getDist3D()
+         {
          int len1 = pos1.length/3;
          int len2 = pos2.length/3;
          float max = mMax;
          for(int i=0; i<len1; i++)
            for(int j=0; j<len2; j++)
+             {
              float d0 = pos1[3*i  ] - pos2[3*j  ];
              float d1 = pos1[3*i+1] - pos2[3*j+1];
              float d2 = pos1[3*i+2] - pos2[3*j+2];
          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};
+         }
              if( d0*d0 + d1*d1 + d2*d2 == 1 ) return true;
+             }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
          return false;
        float getDist2D()
+         {
          return 0.5f;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        TwistyObject createObject(int mode, float size)
        int[] getColors()
+         {
          float[][] pos = getCubitPositions();
          InitData data = new InitData( mSize,pos);
          return new TwistyBandagedCuboid( TwistyObject.MESH_NICE, mode, ShapeHexahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );
          return ShapeHexahedron.FACE_COLORS;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        boolean tryChangeObject(int x, int y, int z)
       Static3D[] getFaceAxis()
+        {
         return TouchControlHexahedron.FACE_AXIS;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean isAdjacent(float dx, float dy, float dz)
+        {
         return dx*dx + dy*dy + dz*dz == 1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean tryChangeObject(int x, int y, int z)
+         {
          if( mSize[0]!=x || mSize[1]!=y || mSize[2]!=z )
+           {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        int computeProjectionAngle()
       int computeProjectionAngle()
+         {
          float quot1 = mSize[2]/ (float)mSize[0];
          float quot2 = mSize[2]/ (float)mSize[1];
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        float[] getDist3D()
+         {
          float max = mMax;
          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;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        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 ShapeHexahedron.FACE_COLORS;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        void createCubits(Static4D quatT, Static4D quatA, Static3D scale)
+         {
          mCubits = new BandagedCubit[mNumCubits];
          int c=0;
          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[][] getPositions()
+        {
         float[][] pos = new float[mNumCubits][];
         int c=0;
         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(this,pos,quatT,quatA,scale,false);
                   c++;
                   pos[c++] = new float[] { begX+x,begY+y,begZ+z };
+                  }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       Static3D[] getFaceAxis()
+        {
         return TouchControlHexahedron.FACE_AXIS;
         return pos;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       void stretchPoint(int face, float[] output)
+        {
         float max = getMaxSize();
         switch(face/2)
+          {
           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)
       void getTouchedPosition(float[] output, int face, float pointX, float pointY)
+        {
         float x = mSize[0];
         float y = mSize[1];
-...
         switch(face)
+          {
           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;
           case 0: output[0] = (x-1)/2;
                   output[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   output[2] = (int)(-z*pointX-z/2)+(z-1)/2;
                   break;
           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;
           case 1: output[0] =-(x-1)/2;
                   output[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   output[2] = (int)( z*pointX+z/2)-(z-1)/2;
                   break;
           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;
           case 2: output[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   output[1] = (y-1)/2;
                   output[2] = (int)(-z*pointY-z/2)+(z-1)/2;
                   break;
           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;
           case 3: output[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   output[1] =-(y-1)/2;
                   output[2] = (int)( z*pointY+z/2)-(z-1)/2;
                   break;
           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;
           case 4: output[0] = (int)( x*pointX+x/2)-(x-1)/2;
                   output[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   output[2] = (z-1)/2;
                   break;
           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;
           case 5: output[0] = (int)(-x*pointX-x/2)+(x-1)/2;
                   output[1] = (int)( y*pointY+y/2)-(y-1)/2;
                   output[2] =-(z-1)/2;
                   break;
+          }
         for(int c=0; c<mNumCubits; c++)
           if( mCubits[c].isAttached() )
+            {
             float[] pos = mCubits[c].getPosition();
             int len = pos.length/3;
             for(int p=0; p<len; p++)
               if( pos[3*p]==mPos[0] && pos[3*p+1]==mPos[1] && pos[3*p+2]==mPos[2] ) return c;
+            }
         android.util.Log.e("D", "whichCubitTouched: IMPOSSIBLE!!");
         return -1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       boolean isInsideFace(int face, float[] p)
+        {
         float max = mMax;
         switch(face/2)
+          {
           case 0: p[0] *= (max/mSize[2]); p[1] *= (max/mSize[1]); break;
           case 1: p[0] *= (max/mSize[0]); p[1] *= (max/mSize[2]); break;
           case 2: p[0] *= (max/mSize[0]); p[1] *= (max/mSize[1]); break;
+          }
         return ( p[0]<=mDist2D && p[0]>=-mDist2D && p[1]<=mDist2D && p[1]>=-mDist2D );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       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);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       TwistyObject createObject(int mode, float size)
+         {
          float[][] pos = getCubitPositions();
          InitData data = new InitData( mSize,pos);
          return new TwistyBandagedCuboid( TwistyObject.MESH_NICE, mode, ShapeHexahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );
+         }
+    }

Also available in: Unified diff

Project

General

Profile

Magic Cube

Revision b2de7562

Added by Leszek Koltunski over 2 years ago