TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

package org.distorted.objectlib.touchcontrol;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.main.TwistyObject;

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

    private final float distance;      // distance from (0,0,0) to the surface of the face

    private final float[][] vertices;  // vertices of the face. Already rotated by the initQuat and

                                       // moved by 'position' (arithmetic average of all positions)

    private final float[][] rotated;   // temp array to store vertices times rotation quaternion.

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

      vertices = new float[numV][];

      rotated  = new float[numV][];

        {

        int len = verts[i].length;

        vertices[i]= new float[len];

        rotated[i] = new float[len];

        for(int j=0; j<len; j++) vertices[i][j] = verts[i][j]/size;

        }

      // assuming the first three vertices are linearly independent

      float a1 = vertices[0][0] - vertices[1][0];

      float a3 = vertices[0][2] - vertices[1][2];

      float b3 = vertices[1][2] - vertices[2][2];

      float vx = a2*b3-a3*b2;

      float vy = a3*b1-a1*b3;

      float vz = a1*b2-a2*b1;

      float len = (float)Math.sqrt(vx*vx+vy*vy+vz*vz);

      vx/=len;

      vy/=len;

      vz/=len;

      normal[0] = vx;

      normal[1] = vy;

      normal[2] = vz;

      normal[3] = 0.0f;

      }

      {

      return normal;

    }

  private int[] mNumFaces;

  private boolean mPreparationDone;

  final float[] mCamera, mPoint;

  final Static3D[] mRotAxis;

  final TwistyObject mObject;

  float[][] mQuats;

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

    mCamera= new float[3];

    mTouch = new float[3];

    mPreparationDone = false;

    if( object!=null )

      {

      mRotAxis    = object.getRotationAxis() ;

      mNumAxis    = mRotAxis.length;

      mRotatable  = object.getLayerRotatable(numL);

      mCuts       = object.getCuts(numL);

      float size  = object.getSize();

      computeBorders(mCuts,mRotatable,size);

    else

      {

      mRotAxis = null;

      mNumAxis = 0;

      }

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

    float avgX = 0.0f;

    float avgY = 0.0f;

    float avgZ = 0.0f;

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

      {

      avgX += position[3*i  ];

      avgY += position[3*i+1];

      avgZ += position[3*i+2];

      }

    avgX /= len;

    avgY /= len;

    avgZ /= len;

    Static4D tmp;

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

      {

      int[][] inds = indices[f];

      int numSegments = inds.length;

      int numVerts = 0;

      for(int[] ind : inds) numVerts += ind.length;

      float[][] verts = new float[numVerts][4];

      int pointer = 0;

        {

        int numV = inds[s].length;

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

          {

          int index = indices[f][s][v];

          float x = vertices[index][0];

          float y = vertices[index][1];

          float z = vertices[index][2];

          float w = 1.0f;

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

          verts[pointer][0] = tmp.get0() + avgX;

          verts[pointer][1] = tmp.get1() + avgY;

          verts[pointer][2] = tmp.get2() + avgZ;

          verts[pointer][3] = 1.0f;

          pointer++;

          }

        }

      infos[f] = new FaceInfo(verts,size);

      }

    return infos;

    }

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

// mesh polygon

  private FaceInfo[] computeInfos(float[][] vertices, int[][] indices, float[] position, Static4D quat, float size)

    {

    float avgX = 0.0f;

    float avgY = 0.0f;

    float avgZ = 0.0f;

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

      {

      avgX += position[3*i  ];

      avgY += position[3*i+1];

      avgZ += position[3*i+2];

      }

    avgX /= len;

    avgY /= len;

    avgZ /= len;

    Static4D tmp;

        float y = vertices[index][1];

        float z = vertices[index][2];

        float w = 1.0f;

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

        verts[v][1] = tmp.get1() + avgY;

        verts[v][2] = tmp.get2() + avgZ;

        verts[v][3] = 1.0f;

    return infos;

    }

// software implementation of DistortedLibrary.mainVertexShader.degree() function.

// (limited to regions centered at [0,0,0])

  private float computeVertexDegree(float radius, float[] vert)

    {

    float x = vert[0];

    float y = vert[1];

    float z = vert[2];

    float len = (float)Math.sqrt(x*x + y*y + z*z);

    return len>radius ? 0.0f : 1.0f-len/radius;

    }

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

// software implementation of DistortedLibrary.VertexEffectSink

  private float[] adjustVert(float pillow, float radius, float[] vert)

    {

    float[] output = new float[3];

    float deg = computeVertexDegree(radius,vert);

    float t = 1.0f - deg*(1.0f-pillow)/pillow;

    output[0] = t*vert[0];

    output[1] = t*vert[1];

    output[2] = t*vert[2];

    return output;

    }

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

  private float[][] adjustVerticesForPillow(float pillow, float radius, float[][] verts)

    {

    int num = verts.length;

    float[][] output = new float[num][3];

    for(int i=0; i<num; i++) output[i] = adjustVert(pillow,radius,verts[i]);

    return output;

    }

  private void prepare()

    {

    int[] numLayers = mObject.getNumLayers();

    float[][] positions = mObject.getCubitPositions(numLayers);

    mNumFaces  = new int[mNumCubits];

    mInfos = new FaceInfo[mNumCubits][];

    float radius = mObject.getCircumscribedRadius();

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

      {

      int variant = mObject.getCubitVariant(i,numLayers);

      ObjectShape shape = mObject.getObjectShape(variant);

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

      if( indices!=null )

        {

        mInfos[i] = computeInfos(vertices, indices, positions[i], quat, size);

        }

      else

        {

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

        mInfos[i] = computeInfos(vertices, ind, positions[i], quat, size);

        }

    Static4D[] quats = mObject.getQuats();

    int numQuats = quats.length;

    mQuats = new float[numQuats][4];

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

      {

      Static4D q = quats[i];

      mQuats[i][0] = q.get0();

      mQuats[i][1] = q.get1();

      mQuats[i][2] = q.get2();

      mQuats[i][3] = q.get3();

      }

    mPreparationDone = true;

    }

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

// Compute D1 = A-B, D2=C-B. Then D1 and D2 are parallel vectors.

// They disagree in direction iff |D1+D2|<|D1-D2|

                            float bx, float by, float bz,

                            float cx, float cy, float cz)

    float d1y = ay-by;

    float d1z = az-bz;

    float d2x = cx-bx;

    float d2y = cy-by;

    float d2z = cz-bz;

    float sx = d1x+d2x;

    float sy = d1y+d2y;

    float sz = d1z+d2z;

    float dx = d1x-d2x;

    float dy = d1y-d2y;

    float dz = d1z-d2z;

    return sx*sx+sy*sy+sz*sz < dx*dx+dy*dy+dz*dz;

    }

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

// sides of the polygon it intersects with. The point is inside iff this number

// is odd. Note that this works also in case of concave polygons.

//

// Arbitrarily take point P on the plane ( we have decided on P=(vert[0]+vert[1])/2 )

// as the other point defining the half-line.

// 'point' and 'P' define a line L1 in 3D. Then for each side the pair of its vertices

// defines a line L2. If L1||L2 return false. Otherwise, the lines are skew so it's

// possible to compute points C1 and C2 on lines L1 and L2 which are closest to the

// other line and check if

//

// a) C1 and P are on the same side of 'point'

//    (which happens iff 'point' is not in between of C1 and P)

// b) C2 is between the two vertices.

//

// Both a) and b) together mean that the half-line intersects with side defined by (p2,d2)

//

// C1 and C2 can be computed in the following way:

// Let n = d1 x d2 - then vector n is perpendicular to both d1 and d2 --> (c1-c2) is

// parallel to n.

// There exist real numbers A,B,C such that

// c1 = p1 + A*d1

// c2 = p2 + B*d2 and

// c2 = c1 + C*n so that

// p1 + A*d1 + C*n = p2 + B*d2  --> (p1-p2) + A*d1 = B*d2 - C*n (*)

// Let n2 = n x d2. Let's multiply both sides of (*) by n2. Then

// (p1-p2)*n2 + A*(d1*n2) = 0 (0 because d1*n2 = n*n2 = 0)

// and from that A = [(p1-p2)*n2]/[d1*n2]

// Similarly     B = [(p2-p1)*n1]/[d2*n1]  where n1 = n x d1.

    float e1y = (vertices[0][1]+vertices[1][1])/2;

    float e1z = (vertices[0][2]+vertices[1][2])/2;

    float d1x = e1x - point[0];

    float d1y = e1y - point[1];

    float d1z = e1z - point[2];

    float ax = vertices[0][0] - vertices[1][0];

    float ay = vertices[0][1] - vertices[1][1];

    float az = vertices[0][2] - vertices[1][2];

    float normX = d1y*az - d1z*ay;

    float normY = d1z*ax - d1x*az;

    float normZ = d1x*ay - d1y*ax;

    float n1x = d1y*normZ - d1z*normY;

    float n1y = d1z*normX - d1x*normZ;

    float n1z = d1x*normY - d1y*normX;

    float p1x = point[0];

    float p1y = point[1];

    float p1z = point[2];

    int len = vertices.length;

    int numCrossings = 0;

      float p2y = vertices[side][1];

      float p2z = vertices[side][2];

      int next = side==len-1 ? 0 : side+1;

      float e2x = vertices[next][0];

      float e2y = vertices[next][1];

      float e2z = vertices[next][2];

      float d2x = e2x-p2x;

      float d2y = e2y-p2y;

      float d2z = e2z-p2z;

      float nx = d2y*d1z - d2z*d1y;

      float ny = d2z*d1x - d2x*d1z;

      float nz = d2x*d1y - d2y*d1x;

      float n2x = d2y*nz - d2z*ny;

      float n2y = d2z*nx - d2x*nz;

      float n2z = d2x*ny - d2y*nx;

      float dpx = p1x-p2x;

      float dpy = p1y-p2y;

      float dpz = p1z-p2z;

      float A1 =-dpx*n2x-dpy*n2y-dpz*n2z;

      float B1 = d1x*n2x+d1y*n2y+d1z*n2z;

      float A2 = dpx*n1x+dpy*n1y+dpz*n1z;

      float B2 = d2x*n1x+d2y*n1y+d2z*n1z;

      if( B1==0 || B2==0 ) continue;

      float C1 = A1/B1;

      float C2 = A2/B2;

      float c1x = p1x + C1*d1x;

      float c1y = p1y + C1*d1y;

      float c1z = p1z + C1*d1z;

      float c2x = p2x + C2*d2x;

      float c2y = p2y + C2*d2y;

      float c2z = p2z + C2*d2z;

      if( !isBetween(c1x,c1y,c1z, p1x,p1y,p1z, e1x,e1y,e1z ) &&

           isBetween(p2x,p2y,p2z, c2x,c2y,c2z, e2x,e2y,e2z )  )

        {

        numCrossings++;

        }

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

  private void rotateVertices(float[][] points, float[][] rotated, float[] quat)

    {

    int numPoints = points.length;

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

      {

      QuatHelper.rotateVectorByQuat(rotated[i],points[i],quat);

      }

    }

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

// given precomputed mCamera and mPoint, respectively camera and touch point positions in ScreenSpace,

// a normalVec (nx,ny,nz) and distance (which together define a plane) compute point 'output[]' which:

// 1) lies on this plane

// 2) is co-linear with mCamera and mPoint

//

// output = camera + alpha*(point-camera), where alpha = [dist-normalVec*camera] / [normalVec*(point-camera)]

    float d0 = mPoint[0]-mCamera[0];

    float d1 = mPoint[1]-mCamera[1];

    float d2 = mPoint[2]-mCamera[2];

    float denom = nx*d0 + ny*d1 + nz*d2;

    if( denom != 0.0f )

      {

      float axisCam = nx*mCamera[0] + ny*mCamera[1] + nz*mCamera[2];

      float alpha = (distance-axisCam)/denom;

      output[0] = mCamera[0] + d0*alpha;

      output[1] = mCamera[1] + d1*alpha;

      output[2] = mCamera[2] + d2*alpha;

      }

    }

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

    return mCamera[0]*nx + mCamera[1]*ny + mCamera[2]*nz > distance;

    }

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

// FaceInfo defines a 3D plane (by means of a unit normal vector 'vector' and distance from the origin

// 'distance') and a list of points on the plane ('vertices').

//

// 0) rotate the face normal vector by quat

// 1) see if the face is visible. If not, return NOT_TOUCHED

// 2) else, cast the line passing through mPoint and mCamera onto this plane

// 3) if Z of this point is further from us than the already computed closestSoFar, return NOT_TOUCHED

// 4) else, rotate 'vertices' by quat and see if the casted point lies inside the polygon defined by them

    float ny = mTmp[1];

    float nz = mTmp[2];

      castTouchPointOntoFace(nx,ny,nz,info.distance,mTouch);

      float dy = mTouch[1]-mCamera[1];

      float dz = mTouch[2]-mCamera[2];

      float dist = dx*dx + dy*dy + dz*dz;

      if( dist<closestSoFar )

        rotateVertices(info.vertices,info.rotated,quat);

      }

    return NOT_TOUCHED;

    }

// This is in order to support non-rotatable rows.

// If mTouchedCubit ( as computed by objectTouched() ) turns out to be not rotatable with respect to

// the rotAxis, we need to figure out which of the neighbouring 'rotatable' cubits is the closest.

//

// Note that we cannot do it in objectTouched(), because then we do not yet know which axis we are

// going to be rotating along.

  private float distanceToRow(int rotIndex, int row)

    {

    float closestSoFar = NOT_TOUCHED;

    int numQuats = mQuats.length;

    int bmp = (1<<row);

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

      {

      int rowBitmap = mObject.getCubitRotRow(cubit,rotIndex);

      if( (rowBitmap&bmp) != 0 )

        {

        int quatIndex = mObject.getCubitQuatIndex(cubit);

        if( quatIndex<numQuats )

          {

          float[] quat = mQuats[quatIndex];

          for(int face=0; face<mNumFaces[cubit]; face++)

            {

            float dist = cubitFaceTouched(mInfos[cubit][face],quat,closestSoFar);

            if( dist!=NOT_TOUCHED ) closestSoFar = dist;

            }

          }

        }

      }

    return closestSoFar;

    }

    float x = mLastT[0]*a.get0() + mLastT[1]*a.get1() + mLastT[2]*a.get2();

    x *= mObject.getSize();

    float[] cuts = mCuts[axis];

    int l = cuts.length;

    if( l>0 && x>=cuts[l-1] ) return (l>=2 && x<=(3*cuts[l-2]-cuts[l-1])/2) ? l-1 : -1;

      if( x<=cuts[i] )

        return x<((cuts[i-1]+cuts[i])/2) ? i-1 : i+1;