TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

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

package org.distorted.objectlib.json;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.StandardCharsets;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSticker;

import org.distorted.objectlib.helpers.ScrambleState;

import org.distorted.objectlib.main.ObjectType;

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

public class JsonReader

{

  private ScrambleState[] mStates;

  private int[][] mSolvedQuats;

  private Static4D[] mQuats;

  private int mSolvedFuncIndex;

  private int mNumStickerTypes;

  private float[][] mCuts;

  private boolean[][] mLayerRotatable;

  private int mMovementType, mMovementSplit;

  private int[][][] mEnabled;

  private float[] mDist3D;

  private int mNumCubitFaces, mNumFaces, mNumFaceColors;

  private float[][] mPositions;

  private ObjectShape[] mShapes;

  private ObjectFaceShape[] mFaceShapes;

  private Static4D[] mCubitQuats;

  private int mNumCubitVariants;

  private int[] mCubitVariant;

  private int[][] mVariantFaceColor, mCubitFaceColor;

  private ObjectSticker[] mObjectSticker;

  private Static3D[] mAxis;

  private int[] mBasicAngle;

  private String mLongName, mShortName, mInventor;

  private int mYearOfInvention, mComplexity;

  private int[] mNumLayers;

  private float mSize;

  private int mScrambleType, mNumScrambles;

  private int[] mColor;

  private ObjectType mType;

  private boolean mResetMaps;

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

  private void parseMetadata(JSONObject object) throws JSONException

    {

    mLongName        = object.getString("longname");

    mShortName       = object.getString("shortname");

    mInventor        = object.getString("inventor");

    mYearOfInvention = object.getInt("year");

    mComplexity      = object.getInt("complexity");

    mSize            = (float)object.getDouble("size");

    mNumScrambles    = object.getInt("scrambles");

    mResetMaps       = object.getBoolean("resetmaps");

    mNumFaces        = object.getInt("num_faces");

    int ordinal = ObjectType.getOrdinal(mShortName);

    mType = ordinal>=0 ? ObjectType.getObject(ordinal) : null;

    }

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

  private void parseCubits(JSONArray object) throws JSONException

    {

    int numCubits = object.length();

    mCubitQuats     = new Static4D[numCubits];

    mCubitVariant   = new int[numCubits];

    mPositions      = new float[numCubits][];

    mCubitFaceColor = new int[numCubits][];

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

      {

      JSONObject jsonCubit = object.getJSONObject(i);

      float qx = (float)jsonCubit.getDouble("qx");

      float qy = (float)jsonCubit.getDouble("qy");

      float qz = (float)jsonCubit.getDouble("qz");

      float qw = (float)jsonCubit.getDouble("qw");

      mCubitQuats[i] = new Static4D(qx,qy,qz,qw);

      mCubitVariant[i] = jsonCubit.getInt("variant");

      JSONArray jsonCenter = jsonCubit.getJSONArray("centers");

      int numCenter = jsonCenter.length();

      mPositions[i] = new float[numCenter];

      for(int j=0; j<numCenter; j++) mPositions[i][j] = (float)jsonCenter.getDouble(j);

      JSONArray jsonColor  = jsonCubit.getJSONArray("colors");

      int numColor = jsonColor.length();

      mCubitFaceColor[i] = new int[numColor];

      for(int j=0; j<numColor; j++) mCubitFaceColor[i][j] = jsonColor.getInt(j);

      }

    }

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

  private void parseShapes(JSONArray object) throws JSONException

    {

    mNumCubitVariants = object.length();

    mVariantFaceColor = new int[mNumCubitVariants][];

    mShapes     = new ObjectShape[mNumCubitVariants];

    mFaceShapes = new ObjectFaceShape[mNumCubitVariants];

    float[][][] verts     = new float[mNumCubitVariants][][];

    float[][][] bands     = new float[mNumCubitVariants][][];

    float[][][] corners   = new float[mNumCubitVariants][][];

    float[][][] centers   = new float[mNumCubitVariants][][];

    float[][] convexity   = new float[mNumCubitVariants][];

    int[][] cornerIndices = new int[mNumCubitVariants][];

    int[][] centerIndices = new int[mNumCubitVariants][];

    int[][] bandIndices   = new int[mNumCubitVariants][];

    int[][][] vertIndices = new int[mNumCubitVariants][][];

    mNumCubitFaces = -1;

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

      {

      JSONObject jsonShape = object.getJSONObject(i);

      ////// vertices /////////////////////////////////////////////////

      JSONArray jsonVertices= jsonShape.getJSONArray("vertices");

      int numVertices = jsonVertices.length();

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

      cornerIndices[i] = new int[numVertices];

      centerIndices[i] = new int[numVertices];

      for(int j=0; j<numVertices; j++)

        {

        JSONObject vert = jsonVertices.getJSONObject(j);

        verts[i][j][0] = (float)vert.getDouble("x");

        verts[i][j][1] = (float)vert.getDouble("y");

        verts[i][j][2] = (float)vert.getDouble("z");

        cornerIndices[i][j] = vert.getInt("cornerIndex");

        centerIndices[i][j] = vert.getInt("centerIndex");

        }

      ////// faces ////////////////////////////////////////////////////

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

      int numFaces = jsonFaces.length();

      mVariantFaceColor[i] = new int[numFaces];

      bandIndices[i] = new int[numFaces];

      vertIndices[i] = new int[numFaces][];

      if( mNumCubitFaces<numFaces ) mNumCubitFaces=numFaces;

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

        {

        JSONObject jsonFace = jsonFaces.getJSONObject(j);

        mVariantFaceColor[i][j] = jsonFace.getInt("sticker");

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

        JSONArray vertices = jsonFace.getJSONArray("vertexIndices");

        int numV = vertices.length();

        vertIndices[i][j] = new int[numV];

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

        }

      ////// bands ////////////////////////////////////////////////////

      JSONArray jsonBands= jsonShape.getJSONArray("bands");

      int numBands = jsonBands.length();

      bands[i] = new float[numBands][7];

      for(int j=0; j<numBands; j++)

        {

        JSONObject jsonBand = jsonBands.getJSONObject(j);

        bands[i][j][0] = (float)jsonBand.getDouble("height");

        bands[i][j][1] = (float)jsonBand.getDouble("angle");

        bands[i][j][2] = (float)jsonBand.getDouble("distanceToCenter");

        bands[i][j][3] = (float)jsonBand.getDouble("distanceToFlat");

        bands[i][j][4] = (float)jsonBand.getDouble("numOfBands");

        bands[i][j][5] = (float)jsonBand.getDouble("extraI");

        bands[i][j][6] = (float)jsonBand.getDouble("extraJ");

        }

      ////// cornerPush ///////////////////////////////////////////////

      JSONArray jsonCornerPush= jsonShape.optJSONArray("cornerPush");

      if( jsonCornerPush!=null )

        {

        int numCornerP = jsonCornerPush.length();

        corners[i] = new float[numCornerP][2];

        for(int j=0; j<numCornerP; j++)

          {

          JSONObject jsonC = jsonCornerPush.getJSONObject(j);

          corners[i][j][0] = (float)jsonC.getDouble("strength");

          corners[i][j][1] = (float)jsonC.getDouble("radius");

          }

        }

      ////// centerPush ///////////////////////////////////////////////

      JSONArray jsonCenterPush= jsonShape.optJSONArray("centerPush");

      if( jsonCenterPush!=null )

        {

        int numCenterP = jsonCenterPush.length();

        centers[i] = new float[numCenterP][3];

        for(int j=0; j<numCenterP; j++)

          {

          JSONObject jsonC = jsonCenterPush.getJSONObject(j);

          centers[i][j][0] = (float)jsonC.getDouble("x");

          centers[i][j][1] = (float)jsonC.getDouble("y");

          centers[i][j][2] = (float)jsonC.getDouble("z");

          }

        }

      ////// convexity ///////////////////////////////////////////////

      JSONObject jsonConvexity = jsonShape.optJSONObject("convexity");

      if( jsonConvexity!=null )

        {

        convexity[i] = new float[3];

        convexity[i][0] = (float)jsonConvexity.getDouble("x");

        convexity[i][1] = (float)jsonConvexity.getDouble("y");

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

        }

      }

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

      {

      mShapes[i] = new ObjectShape(verts[i],vertIndices[i]);

      mFaceShapes[i] = new ObjectFaceShape(bands[i],bandIndices[i],corners[i],cornerIndices[i],centers[i],centerIndices[i],convexity[i] );

      }

    }

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

  private void parseStickers(JSONArray object) throws JSONException

    {

    mNumStickerTypes = object.length();

    mObjectSticker = new ObjectSticker[mNumStickerTypes];

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

      {

      JSONObject sticker = object.getJSONObject(i);

      float stroke = (float)sticker.getDouble("stroke");

      JSONArray vertices = sticker.getJSONArray("vertices");

      int numVertices = vertices.length();

      float[] coords     = new float[2*numVertices];

      float[] curvatures = new float[numVertices];

      float[] radii      = new float[numVertices];

      for(int j=0; j<numVertices; j++)

        {

        JSONObject vertex = vertices.getJSONObject(j);

        coords[2*j  ] = (float)vertex.getDouble("x");

        coords[2*j+1] = (float)vertex.getDouble("y");

        curvatures[j] = (float)vertex.getDouble("angle");

        radii[j]      = (float)vertex.getDouble("radius");

        }

      mObjectSticker[i] = new ObjectSticker(coords,curvatures,radii,stroke);

      }

    }

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

  private void parseMesh(JSONObject object) throws JSONException

    {

    JSONArray cubits   = object.getJSONArray("cubits");

    parseCubits(cubits);

    JSONArray shapes   = object.getJSONArray("shapes");

    parseShapes(shapes);

    JSONArray stickers = object.getJSONArray("stickers");

    parseStickers(stickers);

    }

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

  private void parseAxis(JSONArray object) throws JSONException

    {

    int numAxis = object.length();

    mBasicAngle     = new int[numAxis];

    mAxis           = new Static3D[numAxis];

    mCuts           = new float[numAxis][];

    mLayerRotatable = new boolean[numAxis][];

    mNumLayers      = new int[numAxis];

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

      {

      JSONObject jsonAx = object.getJSONObject(i);

      mBasicAngle[i] = jsonAx.getInt("basicAngle");

      float x = (float)jsonAx.getDouble("x");

      float y = (float)jsonAx.getDouble("y");

      float z = (float)jsonAx.getDouble("z");

      mAxis[i] = new Static3D(x,y,z);

      JSONArray jsonCuts = jsonAx.getJSONArray("cuts");

      int numCuts = jsonCuts.length();

      mCuts[i] = new float[numCuts];

      for(int j=0; j<numCuts; j++) mCuts[i][j] = (float)jsonCuts.getDouble(j);

      JSONArray jsonRota = jsonAx.getJSONArray("rotatable");

      int numRota = jsonRota.length();

      mLayerRotatable[i] = new boolean[numRota];

      for(int j=0; j<numRota; j++) mLayerRotatable[i][j] = jsonRota.getBoolean(j);

      mNumLayers[i] = numRota;

      }

    }

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

  private void parseQuats(JSONArray object) throws JSONException

    {

    int numQuats = object.length();

    mQuats = new Static4D[numQuats];

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

      {

      JSONObject jsonQuat = object.getJSONObject(i);

      float x = (float)jsonQuat.getDouble("x");

      float y = (float)jsonQuat.getDouble("y");

      float z = (float)jsonQuat.getDouble("z");

      float w = (float)jsonQuat.getDouble("w");

      mQuats[i] = new Static4D(x,y,z,w);

      }

    }

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

  private void parseScrambling(JSONObject object) throws JSONException

    {

    mScrambleType = object.getInt("scrambleType");

    if( mScrambleType==0 )

      {

      JSONArray jsonStates = object.getJSONArray("scrambleStates");

      int numStates = jsonStates.length();

      mStates = new ScrambleState[numStates];

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

        {

        JSONArray jsonState = jsonStates.getJSONArray(i);

        int numAxis = jsonState.length();

        int[][] scramblingData = new int[numAxis][];

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

          {

          JSONArray jsonData = jsonState.getJSONArray(j);

          int numData = jsonData.length();

          scramblingData[j] = new int[numData];

          for(int k=0; k<numData; k++) scramblingData[j][k] = jsonData.getInt(k);

          }

        mStates[i] = new ScrambleState(scramblingData);

        }

      }

    }

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

  private void parseTouchcontrol(JSONObject object) throws JSONException

    {

    mMovementType = object.getInt("movementType");

    mMovementSplit= object.getInt("movementSplit");

    JSONArray jsonEnabled = object.getJSONArray("enabledAxis");

    int numFace = jsonEnabled.length();

    mEnabled = new int[numFace][][];

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

      {

      JSONArray jsonSection = jsonEnabled.getJSONArray(i);

      int numSection = jsonSection.length();

      mEnabled[i] = new int[numSection][];

      for(int j=0; j<numSection; j++)

        {

        JSONArray jsonAx = jsonSection.getJSONArray(j);

        int numAxis = jsonAx.length();

        mEnabled[i][j] = new int[numAxis];

        for(int k=0; k<numAxis; k++) mEnabled[i][j][k] = jsonAx.getInt(k);

        }

      }

    try

      {

      JSONArray jsonDist = object.getJSONArray("dist3D");

      int num = jsonDist.length();

      mDist3D = new float[num];

      for(int j=0; j<num; j++) mDist3D[j] = (float)jsonDist.getDouble(j);

      }

    catch( JSONException ex )

      {

      // ignore, the object does not have a 'dist3D' which is possible.

      }

    }

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

  private void parseColors(JSONArray object) throws JSONException

    {

    mNumFaceColors = object.length();

    mColor = new int[mNumFaceColors];

    for(int i=0; i<mNumFaceColors; i++) mColor[i] = object.getInt(i);

    }

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

  private void parseSolved(JSONObject solved) throws JSONException

    {

    mSolvedFuncIndex = solved.getInt("functionIndex");

    try

      {

      JSONArray groupArray= solved.getJSONArray("groups");

      int numGroups = groupArray.length();

      mSolvedQuats  = new int[numGroups][];

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

        {

        JSONArray groupElements = groupArray.getJSONArray(i);

        int groupSize = groupElements.length();

        mSolvedQuats[i] = new int[groupSize];

        for(int j=0; j<groupSize; j++) mSolvedQuats[i][j] = groupElements.getInt(j);

        }

      }

    catch( JSONException ex )

      {

      // ignore, the object does not have to have an array of solved groups.

      }

    }

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

  private void parseVersion1(JSONObject object) throws JSONException

    {

    JSONObject metadata    = object.getJSONObject("metadata");

    parseMetadata(metadata);

    JSONObject mesh        = object.getJSONObject("mesh");

    parseMesh(mesh);

    JSONArray axis         = object.getJSONArray("axis");

    parseAxis(axis);

    JSONArray quats        = object.getJSONArray("quats");

    parseQuats(quats);

    JSONObject scrambling  = object.getJSONObject("scrambling");

    parseScrambling(scrambling);

    JSONObject touchcontrol= object.getJSONObject("touchcontrol");

    parseTouchcontrol(touchcontrol);

    JSONArray colors       = object.getJSONArray("colors");

    parseColors(colors);

    JSONObject solved      = object.getJSONObject("solved");

    parseSolved(solved);

    }

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

  private void parseVersion1Metadata(JSONObject object) throws JSONException

    {

    JSONObject metadata = object.getJSONObject("metadata");

    parseMetadata(metadata);

    }

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

  public void parseJsonFile(InputStream jsonStream)

    {

    BufferedReader br = new BufferedReader(new InputStreamReader(jsonStream, StandardCharsets.UTF_8));

    try

      {

      StringBuilder contents = new StringBuilder();

      String tmp;

      while( (tmp = br.readLine()) != null) contents.append(tmp);

      br.close();

      jsonStream.close();

      JSONObject object = new JSONObject(contents.toString());

      int major = object.getInt("major");

      if( major==1 )

        {

        parseVersion1(object);

        }

      else

        {

        android.util.Log.e("readJsonFile", "Unknown version "+major);

        }

      }

    catch(IOException e)

      {

      android.util.Log.e("readJsonFile", "Error reading JSON file: "+e.toString());

      }

    catch( JSONException e )

      {

      android.util.Log.e("parseJsonFile", "Error parsing JSON file: "+e.toString());

      }

    }

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

  public void parseJsonFileMetadata(InputStream jsonStream)

    {

    BufferedReader br = new BufferedReader(new InputStreamReader(jsonStream, StandardCharsets.UTF_8));

    try

      {

      StringBuilder contents = new StringBuilder();

      String tmp;

      while( (tmp = br.readLine()) != null) contents.append(tmp);

      br.close();

      jsonStream.close();

      JSONObject object = new JSONObject(contents.toString());

      int major = object.getInt("major");

      if( major==1 )

        {

        parseVersion1Metadata(object);

        }

      else

        {

        android.util.Log.e("readJsonFileQuick", "Unknown version "+major);

        }

      }

    catch(IOException e)

      {

      android.util.Log.e("readJsonFileQuick", "Error reading JSON file: "+e.toString());

      }

    catch( JSONException e )

      {

      android.util.Log.e("parseJsonFileQuick", "Error parsing JSON file: "+e.toString());

      }

    }

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

  public ScrambleState[] getScrambleStates()

    {

    return mStates;

    }

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

  public int[][] getSolvedQuats()

    {

    return mSolvedQuats;

    }

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

  public Static4D[] getQuats()

    {

    return mQuats;

    }

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

  public int getSolvedFunctionIndex()

    {

    return mSolvedFuncIndex;

    }

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

  public int getNumStickerTypes()

    {

    return mNumStickerTypes;

    }

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

  public float[][] getCuts()

    {

    return mCuts;

    }

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

  public boolean[][] getLayerRotatable()

    {

    return mLayerRotatable;

    }

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

  public int getMovementType()

    {

    return mMovementType;

    }

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

  public int getMovementSplit()

    {

    return mMovementSplit;

    }

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

  public int[][][] getEnabled()

    {

    return mEnabled;

    }

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

  public float[] getDist3D()

    {

    return mDist3D;

    }

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

  public int getNumCubitFaces()

    {

    return mNumCubitFaces;

    }

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

  public float[][] getCubitPositions()

    {

    return mPositions;

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    return mShapes[variant];

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    return mFaceShapes[variant];

    }

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

  public Static4D getCubitQuats(int cubit)

    {

    return mCubitQuats[cubit];

    }

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

  public int getNumCubitVariants()

    {

    return mNumCubitVariants;

    }

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

  public int getCubitVariant(int cubit)

    {

    return mCubitVariant[cubit];

    }

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

  public int getVariantFaceColor(int variant, int face)

    {

    int[] colors = mVariantFaceColor[variant];

    return colors.length>face ? colors[face] : -1;

    }

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

  public int getCubitFaceFace(int cubit, int face)

    {

    return mCubitFaceColor[cubit][face];

    }

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

  public int getNumScrambles()

    {

    return mNumScrambles;

    }

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

  public ObjectSticker retSticker(int sticker)

    {

    return mObjectSticker[sticker];

    }

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

  public Static3D[] getRotationAxis()

    {

    return mAxis;

    }

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

  public int[] getBasicAngle()

    {

    return mBasicAngle;

    }

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

  public ObjectType intGetObjectType()

    {

    return mType;

    }

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

  public String getObjectName()

    {

    return mLongName;

    }

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

  public String getShortName()

    {

    return mShortName;

    }

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

  public String getInventor()

    {

    return mInventor;

    }

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

  public int getYearOfInvention()

    {

    return mYearOfInvention;

    }

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

  public int getComplexity()

    {

    return mComplexity;

    }

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

  public int getNumFaces()

    {

    return mNumFaces;

    }

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

  public int getNumFaceColors()

    {

    return mNumFaceColors;

    }

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

  public int[] getNumLayers()

    {

    return mNumLayers;

    }

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

  public float getSize()

    {

    return mSize;

    }

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

  public int getScrambleType()

    {

    return mScrambleType;

    }

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

  public int getColor(int face)

    {

    return mColor[face];

    }

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

  public boolean shouldResetTextureMaps()

    {

    return mResetMaps;

    }

}