/ - Diff - Magic Cube - Distorted Android

       private final float[] mPoint2D;
       private float mObjectRatio;
       private final Static3D[] mFaceAxis;
       private final int mNumFaces;
       private float[] mDist3D;
       private int mLastTouchedFace;
-...
         mCamera[1] = rotatedCamera.get1()/mObjectRatio;
         mCamera[2] = rotatedCamera.get2()/mObjectRatio;
         for( mLastTouchedFace=0; mLastTouchedFace<6; mLastTouchedFace++)
         for( mLastTouchedFace=0; mLastTouchedFace<mNumFaces; mLastTouchedFace++)
+          {
           if( faceIsVisible(mLastTouchedFace) )
+            {
-...
         mDist3D  = new float[6];
         mFaceAxis = mObject.getFaceAxis();
         mObjectRatio = ratio;
         mNumFaces = mFaceAxis.length;
         double halfFOV = fov * (Math.PI/360);
         float tanHalf = (float)Math.tan(halfFOV);

         private final DistortedEffects mEffects;
         private final DistortedTexture mTexture;
         private final Static3D mMove;
         private final int mVariant;
         private final boolean mRoundCorners;
         private float mUnscaledX, mUnscaledY, mUnscaledZ;
-...
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public BandagedCubit(BandagedObject object, float[] position, Static4D quat1,
         public BandagedCubit(BandagedObject object, float[] position, int variant, Static4D quat1,
                              Static4D quat2, Static3D scale, boolean roundCorners)
+          {
           mObject = object;
-...
           mPosition = position;
           mIsAttached = true;
           mMarkedEffectID = -1;
           mVariant = variant;
           computeMove(mPosition);
           mMove = new Static3D(0,0,0);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           MeshBase mesh = mObject.createMesh(mVariant,mPosition,mRoundCorners);
           mTexture = new DistortedTexture();
           if( mBitmap==null ) createBitmap(mObject.getColors());
-...
+          {
           int len1 = mPosition.length;
           int len2 = position.length;
           float[] tmpPosition = new float[len1+len2];
           System.arraycopy(mPosition, 0, tmpPosition,    0, len1);
           System.arraycopy(position , 0, tmpPosition, len1, len2);
           computeMove(tmpPosition);
           mPosition = tmpPosition;
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           computeMove(mPosition);
           MeshBase mesh = mObject.createMesh(mVariant,mPosition,mRoundCorners);
           resetTextureMaps(mesh);
           mNode.setMesh(mesh);
           mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-...
           mPosition[2] = z;
           computeMove(mPosition);
           MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
           MeshBase mesh = mObject.createMesh(mVariant,mPosition,mRoundCorners);
           resetTextureMaps(mesh);
           mNode.setMesh(mesh);
           mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);

        abstract float[] getDist3D();
        abstract int[] getColors();
        abstract Static3D[] getFaceAxis();
        abstract float[][] getPositions();
        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 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);
        abstract MeshBase createMesh(int variant, float[] pos, boolean round);
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
        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);
          float[][][] pos = getPositions();
          int c=0,numVariants = pos.length;
          for(int v=0; v<numVariants; v++)
+           {
            int numCubits = pos[v].length;
            for(int vi=0; vi<numCubits; vi++)
              mCubits[c++] = new BandagedCubit(this,pos[v][vi],v,quatT,quatA,scale,false);
+           }
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
             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;
+              {
               float dx = pos[3*p  ]-mTmp[0];
               float dy = pos[3*p+1]-mTmp[1];
               float dz = pos[3*p+2]-mTmp[2];
               if( dx*dx + dy*dy + dz*dz < 0.01f ) return c;
+              }
+            }
         android.util.Log.e("D", "whichCubitTouched: IMPOSSIBLE!!");

     ///////////////////////////////////////////////////////////////////////////////////////////////////
       float[][] getPositions()
       float[][][] getPositions()
+        {
         float[][] pos = new float[mNumCubits][];
         float[][][] pos = new float[1][mNumCubits][];
         int c=0;
         int sx = mSize[0];
         int sy = mSize[1];
-...
              for(int z=0; z<sz; z++)
                if( x==0 || x==sx-1 || y==0 || y==sy-1 || z==0 || z==sz-1 )
+                  {
                   pos[c++] = new float[] { begX+x,begY+y,begZ+z };
                   pos[0][c++] = new float[] { begX+x,begY+y,begZ+z };
+                  }
         return pos;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createMesh(float[] pos, boolean round)
       MeshBase createMesh(int variant, float[] pos, boolean round)
+         {
          FactoryBandagedCuboid factory = FactoryBandagedCuboid.getInstance();
          return factory.createMesh(pos,mSize[0],mSize[1],mSize[2],false,round);

     package org.distorted.bandaged;
     import static org.distorted.objectlib.main.TwistyObject.SQ2;
     import static org.distorted.objectlib.main.TwistyObject.SQ3;
     import static org.distorted.objectlib.main.TwistyObject.SQ6;
-...
          super(screen);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private boolean isFaceInverted(int face)
+        {
         return face>1;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void addTetrahedralLattice(int size, float[][] pos)
+        {
         final float DX = 1.0f;
         final float DY = SQ2/2;
         final float DZ = 1.0f;
         float startX = 0.0f;
         float startY =-DY*(size-1)/2;
         float startZ = DZ*(size-1)/2;
         int index = 0;
         for(int layer=0; layer<size; layer++)
+          {
           float currX = startX;
           float currY = startY;
           for(int x=0; x<layer+1; x++)
+            {
             float currZ = startZ;
             for(int z=0; z<size-layer; z++)
+              {
               pos[index] = new float[] {currX,currY,currZ};
               index++;
               currZ -= DZ;
+              }
             currX += DX;
+            }
           startX-=DX/2;
           startY+=DY;
           startZ-=DZ/2;
+          }
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        float[] getDist3D()
-...
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
       boolean isAdjacent(float dx, float dy, float dz)
+        {
         return false;
         return dx*dx + dy*dy + dz*dz < (SQ3/4)*1.01f;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
       float[][] getPositions()
       void getTouchedPosition(float[] output, int face, float pointX, float pointY)
+        {
         return null;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
       void getTouchedPosition(float[] output, int face, float pointX, float pointY)
       float[][][] getPositions()
+        {
         int num = mSize[0];
         int numO= (num-1)*num*(num+1)/6;
         int numT= (num+1)*num*(num+2)/6;
         float[][] retO = new float[numO][];
         float[][] retT = new float[numT][];
         addTetrahedralLattice(num-1,retO);
         addTetrahedralLattice(num  ,retT);
         return new float[][][] { retO,retT };
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // TODO
       boolean isInsideFace(int face, float[] p)
+        {
         return false;
         float y = (isFaceInverted(face) ? p[1] : -p[1]);
         float x = p[0];
         return (y >= -mDist2D) && (y <= mDist2D*(2-6*x)) && (y <= mDist2D*(2+6*x));
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       MeshBase createMesh(float[] pos, boolean round)
       MeshBase createMesh(int variant, float[] pos, boolean round)
+         {
          FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();
          return factory.createMesh(pos,mSize[0],false,round);
          return factory.createMesh(variant,pos,mSize[0],false,round);
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////

Project

General

Profile

Magic Cube

Revision 6c295be1

Added by Leszek Koltunski over 2 years ago