commit 6c295be1b480deeeb7f6cec666c58a2f81c10fa8
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Tue May 16 02:01:36 2023 +0200

    Progress with BandagedObjectPyraminx.

diff --git a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
index ee40e2de..73a67306 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
@@ -23,6 +23,7 @@ public class BandagedCreatorTouchControl
   private final float[] mPoint2D;
   private float mObjectRatio;
   private final Static3D[] mFaceAxis;
+  private final int mNumFaces;
 
   private float[] mDist3D;
   private int mLastTouchedFace;
@@ -127,7 +128,7 @@ public class BandagedCreatorTouchControl
     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) )
         {
@@ -160,6 +161,7 @@ public class BandagedCreatorTouchControl
     mDist3D  = new float[6];
     mFaceAxis = mObject.getFaceAxis();
     mObjectRatio = ratio;
+    mNumFaces = mFaceAxis.length;
 
     double halfFOV = fov * (Math.PI/360);
     float tanHalf = (float)Math.tan(halfFOV);
diff --git a/src/main/java/org/distorted/bandaged/BandagedCubit.java b/src/main/java/org/distorted/bandaged/BandagedCubit.java
index 8d58f669..a2f4fd23 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCubit.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCubit.java
@@ -43,6 +43,7 @@ public class BandagedCubit
     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;
@@ -116,7 +117,7 @@ public class BandagedCubit
 // 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;
@@ -124,10 +125,11 @@ public class BandagedCubit
       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());
@@ -155,15 +157,13 @@ public class BandagedCubit
       {
       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);
@@ -183,7 +183,7 @@ public class BandagedCubit
       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);
diff --git a/src/main/java/org/distorted/bandaged/BandagedObject.java b/src/main/java/org/distorted/bandaged/BandagedObject.java
index c11130ea..aef41f57 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObject.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObject.java
@@ -51,14 +51,14 @@ public abstract class BandagedObject
    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);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -72,8 +72,16 @@ public abstract class BandagedObject
    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);
+       }
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -247,7 +255,13 @@ public abstract class BandagedObject
         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!!");
diff --git a/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java b/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
index fac0be95..ac9fd9cb 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
@@ -71,9 +71,9 @@ public class BandagedObjectCuboid extends BandagedObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  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];
@@ -88,7 +88,7 @@ public class BandagedObjectCuboid extends BandagedObject
          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;
@@ -185,7 +185,7 @@ public class BandagedObjectCuboid extends BandagedObject
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  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);
diff --git a/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java b/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java
index 74f5d2d7..7ca15162 100644
--- a/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java
+++ b/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java
@@ -9,6 +9,7 @@
 
 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;
 
@@ -31,6 +32,52 @@ public class BandagedObjectPyraminx extends BandagedObject
      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()
@@ -85,43 +132,52 @@ public class BandagedObjectPyraminx extends BandagedObject
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// 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);
      }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////