Magic Cube

///////////////////////////////////////////////////////////////////////////////////////////////////

// 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;

      }

}

///////////////////////////////////////////////////////////////////////////////////////////////////

// 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;

     }

}

///////////////////////////////////////////////////////////////////////////////////////////////////

// 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 );

     }

}

///////////////////////////////////////////////////////////////////////////////////////////////////

// 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 );

    }

}