TwistyPuzzleLib

  public static final int CA_333 = ObjectType.CA_333.ordinal();

  CA_333 ( TwistyCamouflage.class     , 32, R.drawable.din4_3, true,    50, new InitData(new int[] {3,3,3}, TwistyCamouflage.CAM_333)),

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

// Copyright 2021 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.objectlib.objects;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_CUBOID;

import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_NOT_SPLIT;

import org.distorted.library.effect.EffectName;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.FactoryBandagedCubit;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.scrambling.ScrambleState;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

import java.io.InputStream;

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

public abstract class TwistyBandagedAbstract extends ShapeHexahedron

{

  private static final int CUBIT_111 = 0;

  private static final int CUBIT_211 = 1;

  private static final int CUBIT_311 = 2;

  private static final int CUBIT_221 = 3;

  private static final int CUBIT_222 = 4;

  private static final int CUBIT_OTH = 5;

  // the three rotation axis of a 3x3 Cube. Must be normalized.

  static final Static3D[] ROT_AXIS = new Static3D[]

         {

           new Static3D(1,0,0),

           new Static3D(0,1,0),

           new Static3D(0,0,1)

         };

  private static final int[][] mDims = new int[][]

        {

         {1,1,1},  // has to be X>=Z>=Y so that all

         {2,1,1},  // the faces are horizontal

         {3,1,1},

         {2,1,2},

         {2,2,2},

        };

  private int[][] mBasicAngle;

  private Static4D[] mInitQuats;

  private float[][] mCuts;

  private int[] mCubitVariantMap;

  private int[] mTypeVariantMap;

  private int[][] mSolvedQuatsAbstract;

  protected ObjectShape[] mTmpShapes;

  protected int mNumVariants;

  protected float[][] mPosition;

  protected ObjectSignature mSignature;

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

  public TwistyBandagedAbstract(InitData data, int meshState, int iconMode, float size, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, size, quat, move, scale, stream);

    }

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

  abstract float[][] getVertices(int variant);

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

// return 0 if cubit is 'external' (it has at least two walls which belong to two different faces

// of the cuboid, faces which do not both rotate along the same axis! So: it is an edge, a corner,

// or a bandaged cubit which 'comes out' in two different, non-opposite, faces.

// Otherwise, if the cubit only comes out in one face or in two faces which are opposite to each other,

// return the index of the first of the three quats which rotate stuff in this face (so right or left

// return 1 because quats 1,2,3 are the ones rotating along the X axis)

  private int cubitIsExternal(float[] pos, float dx, float dy, float dz)

    {

    int len = pos.length/3;

    int x=0, y=0, z=0;

    for(int i=0; i<len; i++)

      {

      float cx = pos[3*i  ];

      float cy = pos[3*i+1];

      float cz = pos[3*i+2];

      if( cx>dx || cx<-dx ) x=1;

      if( cy>dy || cy<-dy ) y=1;

      if( cz>dz || cz<-dz ) z=1;

      }

    if( x+y+z>=2 ) return 0;

    if( x==1 ) return 1;

    if( y==1 ) return 4;

    if( z==1 ) return 7;

    android.util.Log.e("D", "ERROR: unsupported: internal cubit! ");

    return 0;

    }

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

// If we have a flat cuboid than retCubitSolvedStatus() wrongly reports that the internal cubits

// are edges (they do have two non-black faces after all!) which leads to wrong solvedQuats and

// mis-detection of a solved status. Correct this manually here.

//

// Note that this is still not completely good in case of bandaged cuboids - there can be a 4x4x2

// bandaged cuboid whose 4 'internal' cubits from the 4x4 face are fused with the other 4 internal

// cubits from the other 4x4 face - and those would again get mis-detected as edges...

  @Override

  public int[][] getSolvedQuats()

    {

    if( mSolvedQuatsAbstract==null )

      {

      int[] numLayers = getNumLayers();

      float dx = 0.5f*(numLayers[0]-1) - 0.1f;

      float dy = 0.5f*(numLayers[1]-1) - 0.1f;

      float dz = 0.5f*(numLayers[2]-1) - 0.1f;

      float[][] pos = getPositions();

      int numTotal = pos.length;

      boolean[] isExternal = new boolean[numTotal];

      int[] internalQuat = new int[numTotal];

      int numExternal = 0;

      int pointer = 0;

      for(int cubit=0; cubit<numTotal; cubit++)

        {

        int q = cubitIsExternal(pos[cubit],dx,dy,dz);

        if( q<=0 )

          {

          isExternal[cubit] = true;

          numExternal++;

          }

        else

          {

          isExternal[cubit] = false;

          internalQuat[pointer] = q;

          pointer++;

          }

        }

      int numInternal = numTotal - numExternal;

      mSolvedQuatsAbstract = new int[numInternal+1][];

      mSolvedQuatsAbstract[0] = new int[numExternal+1];

      mSolvedQuatsAbstract[0][0] = numExternal;

      for(int i=0; i<numInternal; i++)

        {

        int q = internalQuat[i];

        mSolvedQuatsAbstract[i+1] = new int[5];

        mSolvedQuatsAbstract[i+1][0] = 1;

        mSolvedQuatsAbstract[i+1][2] = q;

        mSolvedQuatsAbstract[i+1][3] = q+1;

        mSolvedQuatsAbstract[i+1][4] = q+2;

        }

      int pointerExternal = 1;

      int pointerInternal = 1;

      for(int cubit=0; cubit<numTotal; cubit++)

        {

        if( isExternal[cubit] ) mSolvedQuatsAbstract[0][pointerExternal++] = cubit;

        else                    mSolvedQuatsAbstract[pointerInternal++][1] = cubit;

        }

      }

    return mSolvedQuatsAbstract;

    }

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

// Computing scramble states of many a bandaged cubes takes way too long time and too much space.

// Return null here and turn to construction of scramble tables just-in-time.

  @Override

  public ScrambleState[] getScrambleStates()

    {

    return null;

    }

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

  @Override

  public int getScrambleType()

    {

    return 2;

    }

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

  private int getType(float[] pos)

    {

    switch(pos.length)

      {

      case  3: return CUBIT_111;

      case  6: return CUBIT_211;

      case  9: boolean x1 = (pos[0]==pos[3] && pos[0]==pos[6]);

               boolean y1 = (pos[1]==pos[4] && pos[1]==pos[7]);

               boolean z1 = (pos[2]==pos[5] && pos[2]==pos[8]);

               return ( (x1&&y1) || (x1&&z1) || (y1&&z1) ) ? CUBIT_311 : CUBIT_OTH;

      case 12: float x = (pos[0]+pos[3]+pos[6]+pos[ 9])/4;

               float y = (pos[1]+pos[4]+pos[7]+pos[10])/4;

               float z = (pos[2]+pos[5]+pos[8]+pos[11])/4;

               float d1 = (pos[0]-x)*(pos[0]-x) + (pos[ 1]-y)*(pos[ 1]-y) + (pos[ 2]-z)*(pos[ 2]-z);

               float d2 = (pos[3]-x)*(pos[3]-x) + (pos[ 4]-y)*(pos[ 4]-y) + (pos[ 5]-z)*(pos[ 5]-z);

               float d3 = (pos[6]-x)*(pos[6]-x) + (pos[ 7]-y)*(pos[ 7]-y) + (pos[ 8]-z)*(pos[ 8]-z);

               float d4 = (pos[9]-x)*(pos[9]-x) + (pos[10]-y)*(pos[10]-y) + (pos[11]-z)*(pos[11]-z);

               return ( d1==0.5f && d2==0.5f && d3==0.5f && d4==0.5f ) ? CUBIT_221 : CUBIT_OTH;

      case 24: float x3 = pos[0];

               float y3 = pos[1];

               float z3 = pos[2];

               float x4=-10,y4=-10,z4=-10;

               int i;

               for(i=0; i<8; i++)

                 {

                 if( pos[3*i]!=x3 && pos[3*i+1]!=y3 && pos[3*i+2]!=z3 )

                   {

                   x4 = pos[3*i  ];

                   y4 = pos[3*i+1];

                   z4 = pos[3*i+2];

                   break;

                   }

                 }

               if( i==9 ) return CUBIT_OTH;

               float dX = x4-x3;

               float dY = y4-y3;

               float dZ = z4-z3;

               if( (dX==1.0f || dX==-1.0f) && (dY==1.0f || dY==-1.0f) && (dZ==1.0f || dZ==-1.0f) )

                 {

                 for(i=0; i<8; i++)

                   {

                   if( (pos[3*i  ]!=x3 && pos[3*i  ]!=x4) ||

                       (pos[3*i+1]!=y3 && pos[3*i+1]!=y4) ||

                       (pos[3*i+2]!=z3 && pos[3*i+2]!=z4)  ) return CUBIT_OTH;

                   }

                 return CUBIT_222;

                 }

      default: return CUBIT_OTH;

      }

    }

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

  private int getQuatIndex(int cubit)

    {

    float[][] positions = getPositions();

    int len = positions.length;

    if( cubit>=0 && cubit<len )

      {

      float[] pos = positions[cubit];

      int type = getType(pos);

      switch(type)

        {

        case CUBIT_222:

        case CUBIT_111: return 0;

        case CUBIT_211:

        case CUBIT_311: return (pos[1]==pos[4]) ? (pos[0]==pos[3] ? 2 : 0) : 3;

        case CUBIT_221: if( pos[0]==pos[3] && pos[0]==pos[6] ) return 3;

                        if( pos[1]==pos[4] && pos[1]==pos[7] ) return 0;

                        if( pos[2]==pos[5] && pos[2]==pos[8] ) return 1;

        }

      }

    return 0;

    }

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

  protected int[] getDim(int variant)

    {

    int type,numTypes = mDims.length;

    for(type=0; type<numTypes; type++) if( mTypeVariantMap[type]==variant ) break;

    return type<numTypes ? mDims[type] : null;

    }

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

  protected void produceTmpShape(int variant)

    {

    float[][] positions = getPositions();

    int cubit,numCubits = positions.length;

    for(cubit=0; cubit<numCubits; cubit++)

      {

      if( mCubitVariantMap[cubit]==variant ) break;

      }

    if( cubit>=numCubits )

      {

      android.util.Log.e("D", "unknown variant: "+variant);

      }

    else

      {

      FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

      mTmpShapes[variant] = factory.createIrregularShape(variant,positions[cubit]);

      }

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    if( getDim(variant)!=null )

      {

      int[][] indices =

        {

          {2,3,1,0},

          {7,6,4,5},

          {4,0,1,5},

          {7,3,2,6},

          {6,2,0,4},

          {3,7,5,1},

        };

      return new ObjectShape( getVertices(variant), indices);

      }

    if( mTmpShapes==null ) mTmpShapes = new ObjectShape[mNumVariants];

    if( mTmpShapes[variant]==null )produceTmpShape(variant);

    return mTmpShapes[variant];

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int[] numLayers = getNumLayers();

    int size = (numLayers[0]+numLayers[1]+numLayers[2])/3;

    int[] dim = getDim(variant);

    if( dim!=null )

      {

      int X = dim[0];

      int Y = dim[1];

      int Z = dim[2];

      float height     = isInIconMode() ? 0.001f : size<=5 ? 0.048f : 0.020f;

      int[] bandIndices= { 0,0,1,1,2,2 };

      int maxXY = Math.max(X,Y);

      int maxXZ = Math.max(X,Z);

      int maxYZ = Math.max(Y,Z);

      int angle = 45;

      float R = 0.25f;

      float S = 0.50f;

      float N = size<=4 ? 5 : size<=5 ? 4 : 3;

      float[][] bands =

        {

          {height/maxYZ,angle,R,S,N,0,0},

          {height/maxXZ,angle,R,S,N,0,0},

          {height/maxXY,angle,R,S,N,0,0}

        };

      return new ObjectFaceShape(bands,bandIndices,null);

      }

    FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

    return factory.createIrregularFaceShape(variant, isInIconMode() );

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    int[] numLayers = getNumLayers();

    int size = (numLayers[0]+numLayers[1]+numLayers[2])/3;

    boolean round = (DistortedLibrary.fastCompilationTF() && size<=5 && !isInIconMode());

    if( getDim(variant)!=null )

      {

      float[][] vertices = getVertices(variant);

      float strength = -0.04f;

      float[][] variables =

        {

          { 0, strength*vertices[0][0], strength*vertices[0][1], strength*vertices[0][2], 1  },

          { 0, strength*vertices[1][0], strength*vertices[1][1], strength*vertices[1][2], 1  },

          { 0, strength*vertices[2][0], strength*vertices[2][1], strength*vertices[2][2], 1  },

          { 0, strength*vertices[3][0], strength*vertices[3][1], strength*vertices[3][2], 1  },

          { 0, strength*vertices[4][0], strength*vertices[4][1], strength*vertices[4][2], 1  },

          { 0, strength*vertices[5][0], strength*vertices[5][1], strength*vertices[5][2], 1  },

          { 0, strength*vertices[6][0], strength*vertices[6][1], strength*vertices[6][2], 1  },

          { 0, strength*vertices[7][0], strength*vertices[7][1], strength*vertices[7][2], 1  },

        };

      String name = EffectName.DEFORM.name();

      float[] reg = {0,0,0,0.15f};

      String[] names = {name,name,name,name,name,name,name,name};

      float[][] regions = {reg,reg,reg,reg,reg,reg,reg,reg};

      boolean[] uses = {round,round,round,round,round,round,round,round};

      return new ObjectVertexEffects(names,variables,vertices,regions,uses);

      }

    FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

    return factory.createVertexEffects(variant,round);

    }

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

  public float[][] getCubitPositions(int[] numLayers)

    {

    return getPositions();

    }

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

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    if( mInitQuats ==null )

      {

      mInitQuats = new Static4D[]

        {

        new Static4D(  0.0f,   0.0f,   0.0f,   1.0f),  // NULL

        new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),  // X

        new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),  // Y

        new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),  // Z

        new Static4D( -0.5f,  +0.5f,  -0.5f,  +0.5f),  // ZX

        new Static4D( +0.5f,  +0.5f,  +0.5f,  -0.5f),  // YX

        };

      }

    return mInitQuats[getQuatIndex(cubit)];

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    if( mNumVariants==0 )

      {

      float[][] positions = getPositions();

      boolean C111=false;

      boolean C211=false;

      boolean C311=false;

      boolean C221=false;

      boolean C222=false;

      int numCubits = positions.length;

      mCubitVariantMap = new int[numCubits];

      int numTypes = mDims.length;

      mTypeVariantMap = new int[numTypes];

      for(int i=0; i<numTypes; i++) mTypeVariantMap[i] = -1;

      for (int cubit=0; cubit<numCubits; cubit++)

        {

        int type = getType(positions[cubit]);

        switch (type)

          {

          case CUBIT_111: if (!C111) { C111 = true; mTypeVariantMap[CUBIT_111]=mNumVariants++; }

                          mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_111];

                          break;

          case CUBIT_211: if (!C211) { C211 = true; mTypeVariantMap[CUBIT_211]=mNumVariants++; }

                          mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_211];

                          break;

          case CUBIT_311: if (!C311) { C311 = true; mTypeVariantMap[CUBIT_311]=mNumVariants++; }

                          mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_311];

                          break;

          case CUBIT_221: if (!C221) { C221 = true; mTypeVariantMap[CUBIT_221]=mNumVariants++; }

                          mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_221];

                          break;

          case CUBIT_222: if (!C222) { C222 = true; mTypeVariantMap[CUBIT_222]=mNumVariants++; }

                          mCubitVariantMap[cubit]=mTypeVariantMap[CUBIT_222];

                          break;

          default       : mCubitVariantMap[cubit] = mNumVariants++;

          }

        }

      FactoryBandagedCubit factory = FactoryBandagedCubit.getInstance();

      factory.prepare(mNumVariants,numLayers[0],numLayers[1],numLayers[2]);

      }

    return mNumVariants;

    }

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

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    return mCubitVariantMap[cubit];

    }

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

  public float[][] getCuts(int[] numLayers)

    {

    if( mCuts==null )

      {

      mCuts = new float[3][];

      for(int axis=0; axis<3; axis++)

        {

        int len = numLayers[axis];

        float start = (2-len)*0.5f;

        if( len>=2 )

          {

          mCuts[axis] = new float[len-1];

          for(int i=0; i<len-1; i++) mCuts[axis][i] = start+i;

          }

        }

      }

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable(int[] numLayers)

    {

    int numAxis = ROT_AXIS.length;

    boolean[][] layerRotatable = new boolean[numAxis][];

    for(int i=0; i<numAxis; i++)

      {

      layerRotatable[i] = new boolean[numLayers[i]];

      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;

      }

    return layerRotatable;

    }

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

  public int getTouchControlType()

    {

    return TC_CUBOID;

    }

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

  public int getTouchControlSplit()

    {

    return TYPE_NOT_SPLIT;

    }

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

  public int[][][] getEnabled()

    {

    return new int[][][] { {{1,2}},{{1,2}},{{0,2}},{{0,2}},{{0,1}},{{0,1}} };

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    float x = numLayers[0];

    float y = numLayers[1];

    float z = numLayers[2];

    float a = (x+y+z)/1.5f;

    return new float[] {x/a,x/a,y/a,y/a,z/a,z/a};

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  public float getStickerRadius()

    {

    return 0.10f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.16f : 0.08f;

    }

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

  public float[][] getStickerAngles()

    {

    return null;

    }

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

// PUBLIC API

  public Static3D[] getRotationAxis()

    {

    return ROT_AXIS;

    }

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

  public int[][] getBasicAngles()

    {

     if( mBasicAngle==null )

      {

      int[] num = getNumLayers();

      int numX = num[0];

      int numY = num[1];

      int numZ = num[2];

      int x = numY==numZ ? 4 : 2;

      int y = numX==numZ ? 4 : 2;

      int z = numX==numY ? 4 : 2;

      int[] tmpX = new int[numX];

      for(int i=0; i<numX; i++) tmpX[i] = x;

      int[] tmpY = new int[numY];

      for(int i=0; i<numY; i++) tmpY[i] = y;

      int[] tmpZ = new int[numZ];

      for(int i=0; i<numZ; i++) tmpZ[i] = z;

      mBasicAngle = new int[][] { tmpX,tmpY,tmpZ };

      }

    return mBasicAngle;

    }

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

  float[][] getPositions()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    return mPosition;

    }

}

import org.distorted.objectlib.main.ObjectType;

public class TwistyBandagedCuboid extends TwistyBandagedAbstract

  public static int getType(String shortName, String longName)

    if( shortName.equals(ObjectType.BAN1_3.name()) ||

        shortName.equals(ObjectType.BAN2_3.name()) ||

        shortName.equals(ObjectType.BAN3_3.name()) ||

        shortName.equals(ObjectType.BAN4_3.name())  ) return 2;

    if( longName.equals(OBJECT_NAME) ) return 1;

  public TwistyBandagedCuboid(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    super(data, meshState, iconMode, (data.getNumLayers()[0]+data.getNumLayers()[1]+data.getNumLayers()[2])/3.0f, quat, move, scale, stream);

  float[][] getVertices(int variant)

    int[] dim = getDim(variant);

    if( dim!=null )

      int X = dim[0];

      int Y = dim[1];

      int Z = dim[2];

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

// 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.objectlib.objects;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import java.io.InputStream;

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

public class TwistyCamouflage extends TwistyBandagedAbstract

{

  public static final float[][] CAM_333 = new float[][]

    {

    // TODO: define centers of the Camouflage 3x3x3 cube.

    };

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

  public TwistyCamouflage(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, (data.getNumLayers()[0]+data.getNumLayers()[1]+data.getNumLayers()[2])/3.0f, quat, move, scale, stream);

    }

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

  float[][] getVertices(int variant)

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 )

      {

      // TODO: vertices of the Camouflage 3x3x3

      }

    return null;

    }

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

// PUBLIC API

  public String getShortName()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 ) return ObjectType.CA_333.name();

    return null;

    }

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

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      if( mPosition==null ) mPosition = getInitData().getPos();

      if( mPosition==CAM_333 ) mSignature = new ObjectSignature(ObjectType.CA_333);

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    int[] nL = getNumLayers();

    return "Camouflage "+nL[0]+"x"+nL[1]+"x"+nL[2];

    }

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

  public String getInventor()

    {

    return "Guan Yang";

    }

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

  public int getYearOfInvention()