commit afd7e8040a6c41d2788818db7d0a9549a283b4eb
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Fri May 12 16:19:34 2023 +0200

    Everything about the nature of an object being bandaged should now hopefully be abstracted out in the single class - 'BandagedObject'

diff --git a/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java b/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
index cd67589b..fb2e99ba 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
@@ -429,7 +429,7 @@ public class BandagedCreatorRenderer implements GLSurfaceView.Renderer, Distorte
 
    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 );
diff --git a/src/main/java/org/distorted/bandaged/BandagedCubit.java b/src/main/java/org/distorted/bandaged/BandagedCubit.java
index 9e532d7e..8d58f669 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCubit.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCubit.java
@@ -26,16 +26,8 @@ import org.distorted.library.mesh.MeshBase;
 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
@@ -46,12 +38,12 @@ 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;
@@ -60,15 +52,9 @@ public class BandagedCubit
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-    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];
@@ -80,38 +66,12 @@ public class BandagedCubit
 
       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)
@@ -124,7 +84,7 @@ public class BandagedCubit
         {
         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];
         }
 
@@ -156,12 +116,10 @@ public class BandagedCubit
 // 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;
@@ -169,12 +127,10 @@ public class BandagedCubit
 
       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);
@@ -207,9 +163,7 @@ public class BandagedCubit
 
       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);
@@ -229,9 +183,7 @@ public class BandagedCubit
       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);
@@ -241,7 +193,7 @@ public class BandagedCubit
 
     public void recreateBitmap()
       {
-      if( mBitmap==null ) createBitmap();
+      if( mBitmap==null ) createBitmap(mObject.getColors());
       mTexture.setTextureAlreadyInverted(mBitmap);
       }
 
diff --git a/src/main/java/org/distorted/bandaged/BandagedObject.java b/src/main/java/org/distorted/bandaged/BandagedObject.java
index 69729f79..ad82f7a8 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObject.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObject.java
@@ -9,10 +9,19 @@
 
 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;
@@ -23,13 +32,13 @@ import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;
 
 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;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -38,6 +47,15 @@ public class BandagedObject
      {
      mScreen = screen;
      mPos = new float[3];
+     mSize = new int[3];
+     mDist2D = getDist2D();
+     }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+   int[] getSize()
+     {
+     return mSize;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -88,9 +106,9 @@ public class BandagedObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-   float getSize()
+   float getMaxSize()
      {
-     return mX>mY ? Math.max(mX, mZ) : Math.max(mY, mZ);
+     return mMax;
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -119,7 +137,7 @@ public class BandagedObject
    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 );
      }
 
@@ -174,12 +192,13 @@ public class BandagedObject
 
    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;
        }
 
@@ -190,10 +209,10 @@ public class BandagedObject
 
    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);
@@ -230,33 +249,95 @@ public class BandagedObject
 
    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++;
               }
     }
@@ -286,13 +367,13 @@ public class BandagedObject
 
   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;
       }
     }
 
@@ -300,31 +381,35 @@ public class BandagedObject
 
   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;
       }
 
@@ -346,6 +431,6 @@ public class BandagedObject
 
   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 );
     }
 }