commit b2de756280b5070a9a5bb441bfd624b12ab40df2
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Sat May 13 11:16:04 2023 +0200

    Progress with BandagedObject.

diff --git a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
index 3af2e630..ee40e2de 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
@@ -138,7 +138,7 @@ public class BandagedCreatorTouchControl
         float az = mFaceAxis[mLastTouchedFace].get2();
 
         convertTo2Dcoords(mTouch, ax,ay,az, mPoint2D);
-        mObject.stretchPoint(mLastTouchedFace,mPoint2D);
+
         if( mObject.isInsideFace(mLastTouchedFace,mPoint2D) ) return true;
         }
       }
diff --git a/src/main/java/org/distorted/bandaged/BandagedObject.java b/src/main/java/org/distorted/bandaged/BandagedObject.java
index 2d69de47..c11130ea 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObject.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObject.java
@@ -22,10 +22,12 @@ public abstract class BandagedObject
 {
     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;
 
@@ -36,7 +38,7 @@ public abstract class BandagedObject
      mScreen = screen;
      mSize = new int[3];
      mDist2D = getDist2D();
-
+     mTmp = new float[3];
      Static3D[] axis = getFaceAxis();
      int numAxis = axis.length;
      mFaceAxis = new float[numAxis][];
@@ -49,12 +51,11 @@ public abstract class BandagedObject
    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);
@@ -66,6 +67,15 @@ public abstract class BandagedObject
      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)
@@ -223,4 +233,44 @@ public abstract class BandagedObject
     {
     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;
+     }
 }
diff --git a/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java b/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
index 3fa36168..fe9cf01d 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
@@ -12,7 +12,6 @@ package org.distorted.bandaged;
 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;
@@ -24,48 +23,55 @@ import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;
 
 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 )
        {
@@ -82,7 +88,7 @@ public class BandagedObjectCuboid extends BandagedObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   int computeProjectionAngle()
+  int computeProjectionAngle()
      {
      float quot1 = mSize[2]/ (float)mSize[0];
      float quot2 = mSize[2]/ (float)mSize[1];
@@ -101,89 +107,32 @@ public class BandagedObjectCuboid extends BandagedObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   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];
@@ -191,50 +140,64 @@ public class BandagedObjectCuboid extends BandagedObject
 
     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 );
+     }
 }