commit e514732cc0d6cb295910c55eaff02d64ef991f5e
Author: leszek <leszek@koltunski.pl>
Date:   Wed Jul 12 19:57:11 2023 +0200

    move the non-UI bandaged stuff to its own package in the object library.

diff --git a/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java b/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
index 19a66982..488a0e69 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCreatorRenderer.java
@@ -39,6 +39,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.bandaged.BandagedObject;
+import org.distorted.objectlib.bandaged.BandagedObjectCuboid;
 import org.distorted.objectlib.json.JsonWriter;
 import org.distorted.objectlib.main.TwistyObject;
 
diff --git a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
index 62c92180..d04e77ba 100644
--- a/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
+++ b/src/main/java/org/distorted/bandaged/BandagedCreatorTouchControl.java
@@ -12,6 +12,7 @@ package org.distorted.bandaged;
 import org.distorted.library.helpers.QuatHelper;
 import org.distorted.library.type.Static3D;
 import org.distorted.library.type.Static4D;
+import org.distorted.objectlib.bandaged.BandagedObject;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
diff --git a/src/main/java/org/distorted/bandaged/BandagedCubit.java b/src/main/java/org/distorted/bandaged/BandagedCubit.java
deleted file mode 100644
index 7af13509..00000000
--- a/src/main/java/org/distorted/bandaged/BandagedCubit.java
+++ /dev/null
@@ -1,263 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Copyright 2022 Leszek Koltunski                                                               //
-//                                                                                               //
-// This file is part of Magic Cube.                                                              //
-//                                                                                               //
-// Magic Cube is proprietary software licensed under an EULA which you should have received      //
-// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-package org.distorted.bandaged;
-
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.graphics.Paint;
-
-import org.distorted.library.effect.EffectType;
-import org.distorted.library.effect.FragmentEffectBrightness;
-import org.distorted.library.effect.MatrixEffectMove;
-import org.distorted.library.effect.MatrixEffectQuaternion;
-import org.distorted.library.effect.MatrixEffectScale;
-import org.distorted.library.main.DistortedEffects;
-import org.distorted.library.main.DistortedNode;
-import org.distorted.library.main.DistortedTexture;
-import org.distorted.library.helpers.QuatHelper;
-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.FactoryCubit;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-public class BandagedCubit
-{
-    private static final Static3D CENTER = new Static3D(0,0,0);
-    private static final float[] mTmp = new float[4];
-    private static final Static1D mAlpha = new Static1D(2.0f);
-    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 int mVariant;
-    private final boolean mRoundCorners;
-
-    private float mUnscaledX, mUnscaledY, mUnscaledZ;
-    private float[] mPosition;
-    private boolean mIsAttached;
-    private long mMarkedEffectID;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private static void createBitmap(int[] colors)
-      {
-      final int NUM = colors.length;
-      final int SIZE= 32;
-
-      mTextureMaps = new Static4D[NUM];
-
-      Paint paint = new Paint();
-      paint.setStyle(Paint.Style.FILL);
-      mBitmap = Bitmap.createBitmap( NUM*SIZE, SIZE, Bitmap.Config.ARGB_4444);
-      Canvas canvas = new Canvas(mBitmap);
-
-      for(int color=0; color<NUM; 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 );
-        }
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private void resetTextureMaps(MeshBase mesh)
-      {
-      FactoryCubit fact = FactoryCubit.getInstance();
-      int numComponents = mesh.getNumTexComponents();
-      Static4D[] maps = new Static4D[numComponents];
-
-      for(int i=0; i<numComponents; i++)
-        {
-        Static4D q = fact.getQuaternion(i);
-        QuatHelper.rotateVectorByQuat(mTmp,0,0,1,0,q);
-        int index = mObject.computeMapsIndex(mTmp);
-        maps[i] = mTextureMaps[index];
-        }
-
-      mesh.setTextureMap(maps,0);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private void computeMove(float[] position)
-      {
-      int numCenters = position.length/3;
-      mUnscaledX=0.0f;
-      mUnscaledY=0.0f;
-      mUnscaledZ=0.0f;
-
-      for(int center=0; center<numCenters; center++)
-        {
-        mUnscaledX += position[3*center  ];
-        mUnscaledY += position[3*center+1];
-        mUnscaledZ += position[3*center+2];
-        }
-
-      mUnscaledX /= numCenters;
-      mUnscaledY /= numCenters;
-      mUnscaledZ /= numCenters;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// PUBLIC API
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public BandagedCubit(BandagedObject object, float[] position, int variant, Static4D quat1,
-                         Static4D quat2, Static3D scale, boolean roundCorners)
-      {
-      mObject = object;
-      mRoundCorners = roundCorners;
-      mPosition = position;
-      mIsAttached = true;
-      mMarkedEffectID = -1;
-      mVariant = variant;
-
-      computeMove(mPosition);
-      mMove = new Static3D(0,0,0);
-
-      MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
-
-      mTexture = new DistortedTexture();
-      if( mBitmap==null ) createBitmap(mObject.getColors());
-      mTexture.setTextureAlreadyInverted(mBitmap);
-
-      resetTextureMaps(mesh);
-
-      MatrixEffectScale scaleEffect = new MatrixEffectScale(scale);
-      MatrixEffectQuaternion quat1Effect = new MatrixEffectQuaternion(quat1, CENTER);
-      MatrixEffectQuaternion quat2Effect = new MatrixEffectQuaternion(quat2, CENTER);
-      MatrixEffectMove moveEffect = new MatrixEffectMove(mMove);
-
-      mEffects = new DistortedEffects();
-      mEffects.apply(scaleEffect);
-      mEffects.apply(moveEffect);
-      mEffects.apply(quat2Effect);
-      mEffects.apply(quat1Effect);
-
-      mNode = new DistortedNode(mTexture,mEffects,mesh);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void join(float[] position, float scale)
-      {
-      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);
-      mPosition = tmpPosition;
-
-      computeMove(mPosition);
-      MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
-      resetTextureMaps(mesh);
-      mNode.setMesh(mesh);
-      mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void reset(float scale)
-      {
-      float x = mPosition[0];
-      float y = mPosition[1];
-      float z = mPosition[2];
-
-      mPosition = new float[3];
-      mPosition[0] = x;
-      mPosition[1] = y;
-      mPosition[2] = z;
-
-      computeMove(mPosition);
-      MeshBase mesh = mObject.createMesh(mPosition,mRoundCorners);
-      resetTextureMaps(mesh);
-      mNode.setMesh(mesh);
-      mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void recreateBitmap()
-      {
-      if( mBitmap==null ) createBitmap(mObject.getColors());
-      mTexture.setTextureAlreadyInverted(mBitmap);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void scaleMove(float scale)
-      {
-      mMove.set( scale*mUnscaledX, scale*mUnscaledY, scale*mUnscaledZ);
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void setMarked()
-      {
-      if( mMarkedEffectID<0 )
-        {
-        FragmentEffectBrightness effect = new FragmentEffectBrightness(mAlpha);
-        mMarkedEffectID = effect.getID();
-        mEffects.apply(effect);
-        }
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void setUnmarked()
-      {
-      mEffects.abortByType(EffectType.FRAGMENT);
-      mMarkedEffectID = -1;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void detach()
-      {
-      mIsAttached = false;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public void attach()
-      {
-      mIsAttached = true;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public boolean isAttached()
-      {
-      return mIsAttached;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public float[] getPosition()
-      {
-      return mPosition;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-    public DistortedNode getNode()
-      {
-      return mNode;
-      }
-}
-
diff --git a/src/main/java/org/distorted/bandaged/BandagedObject.java b/src/main/java/org/distorted/bandaged/BandagedObject.java
deleted file mode 100644
index f78fbed4..00000000
--- a/src/main/java/org/distorted/bandaged/BandagedObject.java
+++ /dev/null
@@ -1,289 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Copyright 2023 Leszek Koltunski                                                               //
-//                                                                                               //
-// This file is part of Magic Cube.                                                              //
-//                                                                                               //
-// Magic Cube is proprietary software licensed under an EULA which you should have received      //
-// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-package org.distorted.bandaged;
-
-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.main.TwistyObject;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-public abstract class BandagedObject
-{
-    private final DistortedScreen mScreen;
-    private final float[][] mFaceAxis;
-    private BandagedCubit[] mCubits;
-
-    final int[] mSize;
-    final float mDist2D;
-
-    int mMax;
-    int mNumCubits;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   BandagedObject(DistortedScreen screen)
-     {
-     mScreen = screen;
-     mSize = new int[3];
-     mDist2D = getDist2D();
-     Static3D[] axis = getFaceAxis();
-     int numAxis = axis.length;
-     mFaceAxis = new float[numAxis][];
-     for(int i=0; i<numAxis; i++) mFaceAxis[i] = new float[] { axis[i].get0(), axis[i].get1(), axis[1].get2() };
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   abstract float getDist2D();
-   abstract float[] getDist3D();
-   abstract int[] getColors();
-   abstract Static3D[] getFaceAxis();
-   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 boolean isInsideFace(int face, float[] p);
-   abstract TwistyObject createObject(int mode, float scale );
-   abstract MeshBase createMesh(float[] pos, boolean round);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void createCubits(Static4D quatT, Static4D quatA, Static3D scale)
-     {
-     mCubits = new BandagedCubit[mNumCubits];
-     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 computeMapsIndex(float[] faceAx)
-      {
-      int min=-1, numAxis = mFaceAxis.length;
-      float error = Float.MAX_VALUE;
-      float x = faceAx[0];
-      float y = faceAx[1];
-      float z = faceAx[2];
-
-      for(int i=0; i<numAxis; i++)
-        {
-        float[] ax = mFaceAxis[i];
-        float dx = x-ax[0];
-        float dy = y-ax[1];
-        float dz = z-ax[2];
-
-        float diff = dx*dx + dy*dy + dz*dz;
-
-        if( error>diff )
-          {
-          error = diff;
-          min = i;
-          }
-        }
-
-      return min;
-      }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void resetObject(float scale)
-     {
-     for(int c=0; c<mNumCubits; c++)
-       {
-       if( !mCubits[c].isAttached() )
-         {
-         mCubits[c].attach();
-         mScreen.attach(mCubits[c].getNode());
-         }
-       if( mCubits[c].getPosition().length>3 )
-         {
-         mCubits[c].reset(scale);
-         }
-       mCubits[c].setUnmarked();
-       }
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   float getMaxSize()
-     {
-     return mMax;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   float[][] getCubitPositions()
-     {
-     int numAttached = 0;
-
-     for(int i=0; i<mNumCubits; i++)
-       if( mCubits[i].isAttached() ) numAttached++;
-
-     float[][] pos = new float[numAttached][];
-     int attached=0;
-
-     for(int i=0; i<mNumCubits; i++)
-       if( mCubits[i].isAttached() )
-         {
-         pos[attached++] = mCubits[i].getPosition();
-         }
-
-     return pos;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void tryConnectingCubits(int index1, int index2, float scale)
-     {
-     if( index1!=index2 )
-       {
-       float[] pos1 = mCubits[index1].getPosition();
-       float[] pos2 = mCubits[index2].getPosition();
-
-       if( isAdjacent(pos1,pos2) )
-         {
-         mCubits[index2].join(pos1,scale);
-         mCubits[index1].detach();
-         mScreen.detach(mCubits[index1].getNode());
-         }
-       }
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void attachCubits(float scale)
-     {
-     for(int i=0; i<mNumCubits; i++)
-       {
-       mCubits[i].scaleMove(scale);
-       DistortedNode node = mCubits[i].getNode();
-       mScreen.attach(node);
-       }
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void attachAndMarkCubits(float scale, int touched)
-     {
-     for(int i=0; i<mNumCubits; i++)
-       {
-       if( mCubits[i].isAttached() )
-         {
-         mCubits[i].scaleMove(scale);
-         if( touched==i ) mCubits[i].setMarked();
-         else             mCubits[i].setUnmarked();
-         DistortedNode node = mCubits[i].getNode();
-         mScreen.attach(node);
-         }
-       }
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void scaleCubits(float scale)
-     {
-     for(int i=0; i<mNumCubits; i++) mCubits[i].scaleMove(scale);
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   void recreateCubits(Static4D quatT, Static4D quatA, Static3D scale)
-     {
-     if( mCubits==null )
-        {
-        createCubits(quatT,quatA,scale);
-        }
-      else
-        {
-        for(int i=0; i<mNumCubits; i++) mCubits[i].recreateBitmap();
-        }
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  void touchCubit(int index)
-    {
-    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setMarked();
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  void untouchCubit(int index)
-    {
-    if( index>=0 && index<mNumCubits && mCubits[index]!=null ) mCubits[index].setUnmarked();
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  int whichCubitTouched(float[] point3D)
-    {
-    float x = point3D[0]*mMax;
-    float y = point3D[1]*mMax;
-    float z = point3D[2]*mMax;
-
-    int minIndex = -1;
-    float minDist = Float.MAX_VALUE;
-
-    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++)
-          {
-          float dx = pos[3*p  ]-x;
-          float dy = pos[3*p+1]-y;
-          float dz = pos[3*p+2]-z;
-          float dist = dx*dx + dy*dy + dz*dz;
-
-          if( dist<minDist )
-            {
-            minDist = dist;
-            minIndex = c;
-            }
-          }
-        }
-
-    return minIndex;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  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
deleted file mode 100644
index 20768642..00000000
--- a/src/main/java/org/distorted/bandaged/BandagedObjectCuboid.java
+++ /dev/null
@@ -1,165 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Copyright 2023 Leszek Koltunski                                                               //
-//                                                                                               //
-// This file is part of Magic Cube.                                                              //
-//                                                                                               //
-// Magic Cube is proprietary software licensed under an EULA which you should have received      //
-// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-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.objectlib.helpers.FactoryBandagedCuboid;
-import org.distorted.objectlib.main.InitData;
-import org.distorted.objectlib.main.TwistyObject;
-import org.distorted.objectlib.objects.TwistyBandagedCuboid;
-import org.distorted.objectlib.shape.ShapeHexahedron;
-import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-public class BandagedObjectCuboid extends BandagedObject
-{
-   BandagedObjectCuboid(DistortedScreen screen)
-     {
-     super(screen);
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   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;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-   int[] getColors()
-     {
-     return ShapeHexahedron.FACE_COLORS;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  Static3D[] getFaceAxis()
-    {
-    return TouchControlHexahedron.FACE_AXIS;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  boolean isAdjacent(float dx, float dy, float dz)
-    {
-    return dx*dx + dy*dy + dz*dz <= 1;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float[][][] getPositions()
-    {
-    float[][][] pos = new float[1][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 )
-              {
-              pos[0][c++] = new float[] { begX+x,begY+y,begZ+z };
-              }
-
-    return pos;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  boolean tryChangeObject(int x, int y, int z)
-     {
-     if( mSize[0]!=x || mSize[1]!=y || mSize[2]!=z )
-       {
-       mSize[0] = x;
-       mSize[1] = y;
-       mSize[2] = z;
-       mMax = x>y ? Math.max(x,z) : Math.max(y,z);
-       mNumCubits = ( x<=1 || y<=1 || z<=1 ) ? x*y*z : x*y*z-(x-2)*(y-2)*(z-2);
-       return true;
-       }
-
-     return false;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  int computeProjectionAngle()
-     {
-     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);
-     float quot7 = Math.max(quot5,quot6);
-
-          if( quot7<=1.0f ) return 120;
-     else if( quot7<=1.5f ) return 90;
-     else if( quot7<=2.0f ) return 60;
-     else                   return 30;
-     }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  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)
-     {
-     FactoryBandagedCuboid factory = FactoryBandagedCuboid.getInstance();
-     return factory.createMesh(pos,mSize,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 );
-     }
-}
diff --git a/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java b/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java
deleted file mode 100644
index 2e6856d3..00000000
--- a/src/main/java/org/distorted/bandaged/BandagedObjectPyraminx.java
+++ /dev/null
@@ -1,183 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Copyright 2023 Leszek Koltunski                                                               //
-//                                                                                               //
-// This file is part of Magic Cube.                                                              //
-//                                                                                               //
-// Magic Cube is proprietary software licensed under an EULA which you should have received      //
-// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-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;
-
-import org.distorted.library.main.DistortedScreen;
-import org.distorted.library.mesh.MeshBase;
-import org.distorted.library.type.Static3D;
-import org.distorted.objectlib.helpers.FactoryBandagedPyraminx;
-import org.distorted.objectlib.main.InitData;
-import org.distorted.objectlib.main.TwistyObject;
-import org.distorted.objectlib.objects.TwistyBandagedPyraminx;
-import org.distorted.objectlib.shape.ShapeTetrahedron;
-import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-public class BandagedObjectPyraminx extends BandagedObject
-{
-  BandagedObjectPyraminx(DistortedScreen screen)
-    {
-    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()
-    {
-    float d = mSize[0]*SQ6/12;
-    return new float[] {d,d,d,d};
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  float getDist2D()
-    {
-    return SQ3/6;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  int[] getColors()
-    {
-    return ShapeTetrahedron.FACE_COLORS;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  Static3D[] getFaceAxis()
-    {
-    return TouchControlTetrahedron.FACE_AXIS;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  boolean tryChangeObject(int x, int y, int z)
-    {
-    if( mSize[0]!=x )
-      {
-      mSize[0] = x;
-      mMax = mSize[0];
-      int numOcta = (x-1)*x*(x+1)/6;
-      int numTetra= x*(x+1)*(x+2)/6;
-      mNumCubits = numOcta + numTetra;
-      return true;
-      }
-
-    return false;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  int computeProjectionAngle()
-    {
-    return 120;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  boolean isAdjacent(float dx, float dy, float dz)
-    {
-    return dx*dx + dy*dy + dz*dz < (SQ3/4)*1.01f;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  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 };
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  boolean isInsideFace(int face, float[] p)
-    {
-    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)
-    {
-    FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();
-    return factory.createMesh(pos,mSize,false,round);
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  TwistyObject createObject(int mode, float size)
-    {
-    float[][] pos = getCubitPositions();
-    InitData data = new InitData( mSize,pos);
-    return new TwistyBandagedPyraminx( TwistyObject.MESH_NICE, mode, ShapeTetrahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );
-    }
-}