TwistyPuzzleLib

import org.distorted.objectlib.main.TwistyObject;

  public int getNumFaces()

    {

    return mNumFaces;

    }

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

  public boolean isMultigon()

    {

    return mFacesMultigon;

    }

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

  public float[][] getVertices()

    {

    return mVertices;

    }

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

  public int[][] getVertIndices()

    {

    return mVertIndices;

    }

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

  public int[][][] getMultigonIndices()

    {

    return mMultigonIndices;

    }

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

  public float[] getFirstVertexInFace(int face)

    {

    if( mFacesMultigon )

      {

      int[][][] indices=getMultigonIndices();

      int vertIndex=indices[face][0][0];

      return getVertices()[vertIndex];

      }

    else

      {

      int[][] indices=getVertIndices();

      int vertIndex=indices[face][0];

      return getVertices()[vertIndex];

      }

    }

  public static int[][] computeColors(ObjectShape[] shapes, float[][] moves, Static4D[] quats, TwistyObject object)

// Copyright 2020 Leszek Koltunski                                                               //

import java.io.DataInputStream;

import java.io.IOException;

import org.distorted.library.effect.VertexEffectQuaternion;

import org.distorted.library.effect.VertexEffectSink;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.helpers.QuatHelper;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshFile;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.type.Static1D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

public abstract class TwistyObject extends TwistyObjectTheoretical

  public static final float SQ2 = (float)Math.sqrt(2);

  public static final float SQ3 = (float)Math.sqrt(3);

  public static final float SQ5 = (float)Math.sqrt(5);

  public static final float SQ6 = (float)Math.sqrt(6);

  private static final Static3D CENTER = new Static3D(0,0,0);

  private Static4D[] mOrigQuat;

  private MeshBase[] mMeshes;

  private int mNumCubitFaces, mNumStickerTypes;

  private Static4D[] mMixupModeQuats;

  private boolean mIsInMixupMode;

  private int[] mNumLayers;

  private DistortedEffects mEffects;

  private MeshBase mMesh;

  private ObjectShape[] mShapes;

  private int mNumCubitVariants;

  private int[][] mCubitFaceColors;

  private int[][] mVariantFaceIsOuter;

  private int mMaxNumLayers;

    Static3D[] axis = getRotationAxis();

    int[][] angles = getBasicAngles();

    Static3D[] faceAxis = getFaceAxis();

    float[][] positions = getCubitPositions(mNumLayers);

    float[][] cuts = getCuts(mNumLayers);

    int[][] minCubits = getMinimalCubiesInRow();

    int numCubits = positions.length;

    float[][] offsets = new float[numCubits][];

    int[] types = new int[numCubits];

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

      {

      offsets[c] = getCubitRowOffset(c);

      types[c] = getCubitRotationType(c);

      }

    super.initialize(axis, angles, positions, cuts, minCubits, offsets, types, faceAxis);

    mMaxNumLayers = -1;

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

      {

      if( mMaxNumLayers<mNumLayers[i] ) mMaxNumLayers = mNumLayers[i];

      }

    mEffects = new DistortedEffects();

    createQuaternionEffects();

    getQuatsAndShapes(fromDMESH,fromJSON);

    createMesh(meshStream,fromDMESH);

    for(int c=0; c<mNumCubits; c++) setCubitQuat(c,0);

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

  private void createQuaternionEffects()

    {

    if( mNumQuats<=ObjectControl.MAX_QUATS )

      {

      mIsInMixupMode = false;

      for( int q=0; q<mNumQuats; q++)

        {

        VertexEffectQuaternion vq = new VertexEffectQuaternion(mObjectQuats[q],CENTER);

        vq.setMeshAssociation(0,q);

        mEffects.apply(vq);

        }

      }

    else if( mNumCubits<=ObjectControl.MAX_QUATS )

      {

      mIsInMixupMode = true;

      mMixupModeQuats = new Static4D[mNumCubits];

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

        {

        mMixupModeQuats[q] = new Static4D(mObjectQuats[0]);

        VertexEffectQuaternion vq = new VertexEffectQuaternion(mMixupModeQuats[q],CENTER);

        vq.setMeshAssociation(0,q);

        mEffects.apply(vq);

        }

      }

    else

      {

      android.util.Log.e("D", "object has too many quaternions ("+mNumQuats+") or too many cubits ("+mNumCubits+")");

      }

    }

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

  private Static3D getPos(float[] origPos)

    {

    int len = origPos.length/3;

    float sumX = 0.0f;

    float sumY = 0.0f;

    float sumZ = 0.0f;

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

      {

      sumX += origPos[3*i  ];

      sumY += origPos[3*i+1];

      sumZ += origPos[3*i+2];

      }

    sumX /= len;

    sumY /= len;

    sumZ /= len;

    return new Static3D(sumX,sumY,sumZ);

    }

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

  private void createOuterFaces()

    {

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

      {

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

      mVariantFaceIsOuter[v] = new int[numFaces];

      }

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

      {

      int variant = getCubitVariant(cubit,mNumLayers);

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

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

        if( getDefaultCubitFaceColor(cubit,face)>=0 )

          {

          mVariantFaceIsOuter[variant][face] = 1;

          }

      }

    }

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

  private void getQuatsAndShapes(boolean fromDMESH, boolean fromJSON)

    {

    mNumCubitVariants = getNumCubitVariants(mNumLayers);

    if( !fromDMESH || !fromJSON )

      {

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.clear();

      mShapes = new ObjectShape[mNumCubitVariants];

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

      mNumCubitFaces = ObjectShape.computeNumComponents(mShapes);

      mVariantFaceIsOuter = new int[mNumCubitVariants][];

      mOrigQuat = new Static4D[mNumCubits];

      for(int i=0; i<mNumCubits; i++) mOrigQuat[i] = getCubitQuats(i,mNumLayers);

      if( !fromJSON )

        {

        mCubitFaceColors = ObjectShape.computeColors(mShapes,mCubitPos,mOrigQuat,this);

        createOuterFaces();

        }

      if( fromDMESH )

        {

        for(int i=0; i<mNumCubitVariants; i++) factory.createNewFaceTransform(mShapes[i], mVariantFaceIsOuter[i]);

        }

      }

    }

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

  private void createMesh(InputStream stream, boolean fromDMESH)

    {

    if( fromDMESH )

      {

      DataInputStream dos = new DataInputStream(stream);

      mMesh = new MeshFile(dos);

      try

        {

        stream.close();

        }

      catch(IOException e)

        {

        android.util.Log.e("meshFile", "Error closing InputStream: "+e);

        }

      }

    else

      {

      MeshBase[] cubitMesh = new MeshBase[mNumCubits];

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

        {

        cubitMesh[i] = createCubitMesh(i,mNumLayers,mNumCubitFaces);

        Static3D pos = getPos(mCubitPos[i]);

        cubitMesh[i].apply(new MatrixEffectMove(pos),1,0);

        }

      mMesh = new MeshJoined(cubitMesh);

      float pillowCoeff = getPillowCoeff();

      if( pillowCoeff!=1.0f )

        {

        float radius = getCircumscribedRadius();

        Static1D coeff = new Static1D(pillowCoeff);

        Static4D region= new Static4D(0,0,0,radius);

        VertexEffectSink sink = new VertexEffectSink(coeff,CENTER,region);

        mMesh.apply(sink);

        }

      }

    }

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

  private MeshBase createCubitMesh(int cubit, int[] numLayers, int numComponents)

    {

    int variant = getCubitVariant(cubit,numLayers);

    if( mMeshes==null ) mMeshes = new MeshBase[mNumCubitVariants];

    if( mMeshes[variant]==null )

      {

      ObjectFaceShape faceShape = getObjectFaceShape(variant);

      ObjectVertexEffects effects = getVertexEffects(variant);

      FactoryCubit factory = FactoryCubit.getInstance();

      factory.createNewFaceTransform(mShapes[variant],mVariantFaceIsOuter[variant]);

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

      }

    MeshBase mesh = mMeshes[variant].copy(true);

    MatrixEffectQuaternion quat = new MatrixEffectQuaternion( mOrigQuat[cubit], CENTER );

    mesh.apply(quat,0xffffffff,0);

    return mesh;

    }

      mNumCubitFaces = getNumCubitFaces();

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

  void rotateAllCubits(int axisIndex, int rowBitmap, int angle)

    {

    super.rotateAllCubits(axisIndex,rowBitmap,angle);

    for(int i=0; i<mNumCubits; i++) setCubitQuat(i,getCubitQuatIndex(i));

    }

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

  private boolean sticksOut(Static3D[] faceAxis, float[] dist, float x, float y, float z )

    {

    final float MAXERR = 0.05f;

    int numAxis = dist.length;

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

      {

      Static3D ax = faceAxis[i];

      float len = ax.get0()*x + ax.get1()*y + ax.get2()*z;

      if( len>mSize*dist[i]+MAXERR ) return true;

      }

    return false;

    }

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

  private boolean doesNotStickOut(int variant, float px, float py, float pz, float[] tmp, Static4D quat)

    {

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

    Static3D[] axis = getFaceAxis();

    float[] dist3D = getDist3D(mNumLayers);

    for( float[] vertex : vertices)

      {

      float x = vertex[0];

      float y = vertex[1];

      float z = vertex[2];

      QuatHelper.rotateVectorByQuat(tmp, x, y, z, 1, quat);

      float mx = tmp[0] + px;

      float my = tmp[1] + py;

      float mz = tmp[2] + pz;

      if( sticksOut(axis, dist3D, mx,my,mz) ) return false;

      }

    return true;

    }

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

  private float computeAvg(float[] pos, int offset)

    {

    int len = pos.length/3;

    float ret=0.0f;

    for(int i=0; i<len; i++) ret += pos[3*i+offset];

    ret /= len;

    return ret;

    }

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

  protected void displayCubitQuats()

    {

    StringBuilder builder = new StringBuilder();

    float[] tmp = new float[4];

    float ERR = 0.01f;

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

      {

      builder.append(cubit);

      builder.append(" : ");

      int refCubit,variant = getCubitVariant(cubit,mNumLayers);

      for(refCubit=0; refCubit<mNumCubits; refCubit++)

        {

        if( getCubitVariant(refCubit,mNumLayers)==variant ) break;

        }

      float[] curpos = mCubitPos[cubit];

      float[] refpos = mCubitPos[refCubit];

      float refX = computeAvg(refpos,0);

      float refY = computeAvg(refpos,1);

      float refZ = computeAvg(refpos,2);

      float curX = computeAvg(curpos,0);

      float curY = computeAvg(curpos,1);

      float curZ = computeAvg(curpos,2);

      for(int quat=0; quat<mNumQuats; quat++)

        {

        QuatHelper.rotateVectorByQuat(tmp,refX,refY,refZ,0,mObjectQuats[quat]);

        float dx = tmp[0]-curX;

        float dy = tmp[1]-curY;

        float dz = tmp[2]-curZ;

        if( dx>-ERR && dx<ERR && dy>-ERR && dy<ERR && dz>-ERR && dz<ERR )

          {

          if( doesNotStickOut(variant,curX,curY,curZ,tmp,mObjectQuats[quat]) )

            {

            builder.append(quat);

            builder.append(',');

            }

          else

            {

            android.util.Log.e("D", "cubit: "+cubit+" quat: "+quat+" : center correct, but shape sticks out");

            }

          }

        }

      builder.append('\n');

      }

    android.util.Log.e("D", "cubitQuats: \n"+builder );

    }

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

  public int getCubitRotationType(int cubit)

    {

    return TwistyObjectTheoreticalCubit.TYPE_NORMAL;

    }

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

  public float[] getCubitRowOffset(int cubitIndex)

    {

    return null;

    }

    return mSolved.getSolvedQuats(mNumLayers,mNumCubitFaces,mCubitFaceColors);

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

  public int[][] getMinimalCubiesInRow()

    {

    return null;

    }

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

  public int getCubitFaceMap(int cubit, int face)

    {

    int numFaces = mCubitFaceColors[cubit].length;

    int puzzleFace = face<numFaces ? mCubitFaceColors[cubit][face] : -1;

    return puzzleFace<0 ? -1 : puzzleFace;

    }

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

// this would return the REAL value of outer; the 'getCubitFaceColor()>=0' returns if the face is

// colored, which for example in case of Container (which has colored internal faces) is not the

// same thing

  boolean faceIsOuter(int cubit, int face)

    {

    if( mCubitFaceColors==null )

      {

      if( mShapes==null )

        {

        mShapes = new ObjectShape[mNumCubitVariants];

        }

      if( mShapes[0]==null )

        {

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

        }

      if( mOrigQuat==null )

        {

        mOrigQuat = new Static4D[mNumCubits];

        }

      if( mOrigQuat[0]==null )

        {

        for(int c=0; c<mNumCubits; c++) mOrigQuat[c] = getCubitQuats(c,mNumLayers);

        }

      mCubitFaceColors = ObjectShape.computeColors(mShapes,mCubitPos,mOrigQuat,this);

      }

    return mCubitFaceColors[cubit][face]>=0;

    }

    mMesh.markForDeletion();

    mEffects.markForDeletion();

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

  int computeAssociation(int cubit)

    {

    int result = 0, accumulativeShift = 0;

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

      {

      int rotRow = getCubitRotRow(cubit,axis);

      result += (rotRow<<accumulativeShift);

      accumulativeShift += mMaxNumLayers;

      }

    return result;

    }

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

  private void setCubitQuat(int cubit, int equAssociation)

    {

    int andAssociation = computeAssociation(cubit);

    if( !mIsInMixupMode )

      {

      mMesh.setEffectAssociation(cubit,andAssociation,equAssociation);

      }

    else

      {

      mMesh.setEffectAssociation(cubit,andAssociation,cubit);

      Static4D tmp = mObjectQuats[equAssociation];

      mMixupModeQuats[cubit].set(tmp);

      }

    }

    boolean error = super.restorePreferences(key,os);

    if( error )

      {

      for(int c=0; c<mNumCubits; c++) setCubitQuat(c,0);

      }

    else

      {

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

        {

        int q = getCubitQuatIndex(c);

        setCubitQuat(c, q);

        }

      }

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

// Radius of the sphere circumscribed on the puzzle. Needed for pillowing.

//

// This won't work correctly for pillowing off-center puzzles (e.g. mirrors) - for those we'd need

// to introduce the concept of a 'sink center' as well.

//

// public because needed in TouchControlShapemod

  public float getCircumscribedRadius()

    {

    switch( getCategory() )

      {

      case Metadata.CATEGORY_SHAPE_TET: return (SQ6/4)*mSize;

      case Metadata.CATEGORY_SHAPE_HEX: return (SQ3/2)*mSize;

      case Metadata.CATEGORY_SHAPE_OCT: return (SQ2/2)*mSize;

      case Metadata.CATEGORY_SHAPE_DOD: return (SQ3/2)*((SQ5+1)/2)*mSize;

      case Metadata.CATEGORY_SHAPE_BAL: return 0.50f*mSize;

      case Metadata.CATEGORY_SHAPE_ICO: return 0; // no pillowed icosahedra

      case Metadata.CATEGORY_SHAPE_BAR: return 0; // no pillowed barrels

      }

    return 0.0f;

    }

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

// Return the 'surface' the given face of the given cubit is on. (px,py,pz) is the pre-computed

// center of the cubit (so we don't have to keep re-computing this per each face)

// If the face is not external, return null.

//

// This is needed by the TwistyObjectSolved's method2 detecting if the object is in a solved state.

//

// What is a 'surface' ? For objects with flat monochromatic external walls, it is simply a 4-tuple

// [(nx,ny,nz),d] (normal vector + distance from origin) describing a 3D plane this face is part of.

// Exceptions are objects with curved external walls (ATM Masterball & Penrose Cubes): it is a union

// of several surfaces which together define the bent, monochromatic wall. I.e. Penrose Cube has 3

// surfaces (blue, yellow and red), each defined by 3 planes (think before the bending effect!)

//

// This is the default which simply returns the single plane. If some puzzle has more complicated

// surfaces, it needs to override this method.

//

// We never need to test if a given point is part of a given surface (see TwistyObjectSurface!) - we

// only need to be able to rotate the surface by quats and test if two surfaces are the same. Thus:

// it is possible to provide some artificial surfaces - for example, in case of the Penrose, the

// three surfaces can be only the single 'middle' plane [the one on the bend].

  public float[] getMonochromaticSurface(int variant, int cubitIndex, int faceIndex, float px, float py, float pz)

    {

    if( !faceIsOuter(cubitIndex,faceIndex) ) return null;

    Static4D cubitQuat = getCubitQuats(cubitIndex,mNumLayers);

    float[] normal   = new float[4];

    float[] intPoint = new float[3];

    float[] rotPoint = new float[4];

    float[] surface  = new float[4];

    ObjectShape objShape = mShapes[variant];

    objShape.getFacePoint(faceIndex,intPoint);

    objShape.getFaceNormal(faceIndex,normal);

    QuatHelper.rotateVectorByQuat(rotPoint,intPoint[0],intPoint[1],intPoint[2],1,cubitQuat);

    QuatHelper.rotateVectorByQuat(surface,normal[0],normal[1],normal[2],0,cubitQuat);

    float x = rotPoint[0] + px;

    float y = rotPoint[1] + py;

    float z = rotPoint[2] + pz;

    surface[3] = x*surface[0] + y*surface[1] + z*surface[2];

    return surface;

    }

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

  public int[][] getVariantFaceIsOuter()

    {

    return mVariantFaceIsOuter;

    }

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

  public MeshBase getObjectMesh()

    {

    return mMesh;

    }

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

  public DistortedEffects getObjectEffects()

    {

    return mEffects;

    }

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

  public int[] getNumLayers()

    {

    return mNumLayers;

    }

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

  public synchronized void solve()

    {

    super.solve();

    for(int i=0; i<mNumCubits; i++) setCubitQuat(i,0);

    }

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

// this is here only so it can be overridden in TwistyJSON so that we can get this from JSON.

  public int getNumCubitFaces()

    {

    return 0;

    }

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

// 1.0 - i.e. no pillowing - by default.

// The coeff is really param of the 'sink' vertex effect - if it is not equal to 1.0, we apply the

// sink effect [centered at (0,0,0)] to the whole mesh as the last step of composing it.

  public float getPillowCoeff()

    {

    return 1.0f;

    }

  // for JSON only

  public abstract float[] getDist3D(int[] numLayers);

  public abstract Static3D[] getFaceAxis();

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

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

  public abstract ObjectShape getObjectShape(int variant);

  public abstract ObjectFaceShape getObjectFaceShape(int variant);

  public abstract ObjectVertexEffects getVertexEffects(int variant);

  public abstract int getNumCubitVariants(int[] numLayers);

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

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

  // not only for JSON

  public abstract Static3D[] getRotationAxis();

  public abstract int[][] getBasicAngles();