TwistyPuzzleLib

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

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

    }

      ObjectShape objShape = shapes[variant];

      int numFaces = objShape.getNumFaces();

        float[] surface = mParent.getMonochromaticSurface(variant,c,f,px,py,pz);

        if( surface==null ) continue;

// 'numQuats' quats. Only kept here for a moment, then offloaded to TwistyObjectSolved.mSurfaceTable

    int numPlanes = surface.length / 4;

    StringBuilder sb = new StringBuilder();

    for(int p=0; p<numPlanes; p++)

      {

      sb.append('[');

      sb.append(surface[4*p]);

      sb.append(' ');

      sb.append(surface[4*p+1]);

      sb.append(' ');

      sb.append(surface[4*p+2]);

      sb.append(' ');

      sb.append(surface[4*p+3]);

      sb.append(']');

      sb.append(' ');

      }

    return sb.toString();

  private boolean surfaceSame(float[] s1, int i1, float[] s2, int i2)

    float x1 = s1[4*i1  ];

    float y1 = s1[4*i1+1];

    float z1 = s1[4*i1+2];

    float w1 = s1[4*i1+3];

    float x2 = s2[4*i2  ];

    float y2 = s2[4*i2+1];

    float z2 = s2[4*i2+2];

    float w2 = s2[4*i2+3];

    dnx = x1 + x2;

    dny = y1 + y2;

    dnz = z1 + z2;

    dnw = w1 + w2;

    dnx = x1 - x2;

    dny = y1 - y2;

    dnz = z1 - z2;

    dnw = w1 - w2;

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

  boolean isSame(TwistyObjectSurface s)

    {

    int n1 = surface.length/4;

    int n2 = s.surface.length/4;

    for(int n=0; n<n1; n++)

      {

      boolean exists = false;

      for(int p=0; p<n2; p++)

        if( surfaceSame(surface,n,s.surface,p) )

          {

          exists = true;

          break;

          }

      if( !exists ) return false;

      }

    return true;

    }

    int numPlanes = surface.length / 4;

    float[] ret = new float[numPlanes*4];

    float[] tmp = new float[4];

    for(int p=0; p<numPlanes; p++)

      {

      QuatHelper.rotateVectorByQuat(tmp,surface[4*p],surface[4*p+1],surface[4*p+2],0,quat);

      ret[4*p  ] = tmp[0];

      ret[4*p+1] = tmp[1];

      ret[4*p+2] = tmp[2];

      ret[4*p+3] = surface[4*p+3];

      }

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

// here we define 8 artificial monochromatic 'surfaces' - 8 vectors coming out from the center of the

// cube to each vertex and some distance (doesn't matter)

  private static final float[][] mMonoSurfaces =

          {

                  { 1, 1, 1, 1 },

                  { 1, 1,-1, 1 },

                  { 1,-1, 1, 1 },

                  { 1,-1,-1, 1 },

                  {-1, 1, 1, 1 },

                  {-1, 1,-1, 1 },

                  {-1,-1, 1, 1 },

                  {-1,-1,-1, 1 },

          };

  private static final int[] mSurfaceIndices = { 4,2,2,4,1,2,7,4,1,1,7,7 };

  @Override

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

    {

    int index = mSurfaceIndices[cubitIndex];

    return faceIndex<2 ? mMonoSurfaces[index] : null;

    }

/*

*/