TwistyPuzzleLib

    FactoryCubit factory = FactoryCubit.getInstance();

    factory.clear();

    return factory.createRoundedSolid(shape,face,effects,numFaces);

    }

  }

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

    {

    float[][] vertices = shape.getVertices();

    int[][] indices = shape.getVertIndices();

    for (int face=0; face<numFaces; face++)

      {

      boolean collapsed = false;

      FaceTransform newT;

      if( !isMultigon )

package org.distorted.objectlib.helpers;

import org.distorted.library.type.Static4D;

public class FactoryCutSolid

  {

  public static class CutSolidInfo

    {

    private final int[][] mVariantQuatMap;

    public int[][] getVariantQuatMap() { return mVariantQuatMap; }

    };

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

    {

    return -1;

    }

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

    {

    int numCubits = pos.length;

    float[][] potentialVertices = FactoryShape.computePotentialVertices(cutPlanes);

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

      shapes[c] = FactoryShape.createShape(cutPlanes,potentialVertices,pos[c],pos[c]);

    int variant = 0;

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

        for(int d=c+1; d<numCubits; d++)

          {

          ObjectShape shape2 = shapes[d];

          if( quat>=0 )

            {

        }

    ObjectShape[] variantShapes = new ObjectShape[variant];

      {

      }

    }

  }

  private final int mNumFaces;

  private final int[][][] mMultigonIndices;

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

  public ObjectShape(float[][] vertices, int[][] vertIndices)

    output[2] /= len;

    }

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

// Attention: ATM this can return either (nx,ny,nz) or the negative (-nx,-ny,-nz)

// (negative if the first three points of the first loop are 'concave' - as for example are the

  private Static4D[] mCubitQuats;

  private int mNumCubitVariants;

  private int[] mCubitVariant;

  private ObjectSticker[] mObjectSticker;

  private Static3D[] mAxis;

  private int[][] mBasicAngle;

    {

    mNumCubitVariants     = object.length();

    mVariantStickerShape  = new int[mNumCubitVariants][];

    mShapes               = new ObjectShape[mNumCubitVariants];

    mFaceShapes           = new ObjectFaceShape[mNumCubitVariants];

    mVertexEffects        = new ObjectVertexEffects[mNumCubitVariants];

    mNumCubitFaces = -1;

      {

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

      ////// ObjectShape //////////////////////////////////////////////////////

      int numVertices = jsonVertices.length();

      float[][] verts = new float[numVertices][3];

        {

        }

      JSONArray jsonFaces= jsonShape.getJSONArray("faces");

          for(int k=0; k<numV; k++) vertIndices[f][k] = vertices.getInt(k);

          }

        }

      else

        {

            }

          }

        }

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

      ////// StickerShape & Outer /////////////////////////////////////////////

      int[] bandIndices = new int[numFaces];

      for(int f=0; f<numFaces; f++)

        {

        JSONObject jsonFace = jsonFaces.getJSONObject(f);

        bandIndices[f] = jsonFace.getInt("bandIndex");

        }

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

      ////// ObjectFaceShape //////////////////////////////////////////////////

        convexity[2] = (float)jsonConvexity.getDouble("z");

        }

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

      ////// ObjectVertexEffects //////////////////////////////////////////////

          use[j] = jsonEffect.getBoolean("use");

          }

        }

      }

    }

  public float[][] returnRotationFactor()              { return mRotationFactor; }

  public int[] getCubitTypes()                         { return mCubitType; }

  public float[][] getCubitOffsets()                   { return mCubitRowOffset; }

  public int getCubitFaceFace(int cubit, int face)     { return mCubitFaceColor[cubit][face]; }

  public int getNumScrambles()                         { return mNumScrambles; }

  public int getPrice()                                { return mPrice; }

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

    {

    JSONArray array = new JSONArray();

    int numFaces = shape.getNumFaces();

    int[][] vertIndices1   = shape.getVertIndices();

    int[][][] vertIndices2 = shape.getMultigonIndices();

      {

      JSONObject face = new JSONObject();

      face.put("sticker", stiShape);

      JSONArray faceArr = new JSONArray();

      if( !multigon )

        {

        }

      else

        {

          {

          JSONArray compArr = new JSONArray();

          faceArr.put(compArr);

          }

        }

    JSONArray shapes = new JSONArray();

    int numVariants = object.getNumCubitVariants();

    float[][] positions = object.getCubitPositions();

    int numCubits = positions.length;

    mNumCubitFaces = 0;

      JSONArray verticesArr = generateVertices(vertices);

      shapeObj.put("vertices", verticesArr);

      shapeObj.put("faces", facesArr);

      JSONArray bandsArr = generateBands(bands);

      shapeObj.put("bands", bandsArr);

  @Override public int[][] getMinimalCubiesInRow()                   { return mReader.getMinimalCubiesInRow(); }

  @Override public int getCubitRotationType(int cubit)               { return mReader.getCubitTypes()[cubit]; }

  @Override public float[] getCubitRowOffset(int cubit)              { return mReader.getCubitOffsets()[cubit]; }

  @Override public int[][] getSolvedQuats()                          { return mReader.getSolvedQuats(); }

  @Override public Static4D[] getQuats()                             { return mReader.getQuats(); }

  @Override public int getSolvedFunctionIndex()                      { return mReader.getSolvedFunctionIndex(); }

  private ObjectShape[] mShapes;

  private int mNumCubitVariants;

  private int[][] mCubitFaceToPuzzleFaceMap;

  private int mMaxNumLayers;

  private int mIconMode;

  private float mRadius;

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

  public float getPillowCoeff()                { return 1.0f; }

  public int getMaxNumCubitFaces()             { return 0; }

  public int[] getNumLayers()                  { return mNumLayers; }

  public boolean isInIconMode()                { return mIconMode==MODE_ICON; }

  private void createOuterFaces()

    {

    for(int v=0; v<mNumCubitVariants; v++)

      {

      int numFaces = mShapes[v].getNumFaces();

      }

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

      int numFaces = mShapes[variant].getNumFaces();

      for(int face=0; face<numFaces; face++)

      }

    }

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

      mShapes = new ObjectShape[mNumCubitVariants];

      for(int v=0; v<mNumCubitVariants; v++) mShapes[v] = getObjectShape(v);

      if( !fromJSON )

        {

        createGhostQuat();

        mCubitFaceToPuzzleFaceMap= ObjectShape.computePuzzleFaceMap(mShapes,mCubitPos, mCubitOrigQuat, mCubitGhostQuat, this);

        }

      if( fromDMESH )

        {

        }

      }

    }

      ObjectFaceShape faceShape = getObjectFaceShape(variant);

      ObjectVertexEffects effects = getVertexEffects(variant);

      FactoryCubit factory = FactoryCubit.getInstance();

      mVariantMeshes[variant] = factory.createRoundedSolid(mShapes[variant],faceShape,effects,numComponents);

      }

  private void prepareShapes()

    {

    if( mCutPlanes==null ) createCutPlanes();

    mShapes = info.getShapes();

    mCubitToVariantQuatMap = info.getVariantQuatMap();

    }