TwistyPuzzleLib

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

// Copyright 2021 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.objectlib.touchcontrol;

import org.distorted.library.main.QuatHelper;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.main.TwistyObject;

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

  private static class FaceInfo

    {

    private final float[] vector;

    private final float distance;

    private final float[][] vertices;

    private final float[][] rotated;

      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;

      float dist = vx*vertices[0][0] + vy*vertices[0][1] + vz*vertices[0][2];

      if( dist<0 )

        {

        dist = -dist;

        vx = -vx;

        vy = -vy;

        vz = -vz;

        }

      vector[1] = vy;

      vector[2] = vz;

      vector[3] = 0.0f;

      distance = dist;

    }

  private final float[] mPoint, mCamera, mTouch;

  private final TwistyObject mObject;

  private float[][] mQuats;

  private int mNumCubits;

  private int[] mNumFaces;

  private boolean mPreparationDone;

  private FaceInfo[][] mInfos;

  private int mTouchedCubit;

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

    mCamera= new float[3];

    mTouch = new float[3];

    mObject= object;

    mPreparationDone = false;

    }

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

    int numFaces = indices.length;

    int len = position.length/3;

    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;

    FaceInfo[] infos = new FaceInfo[numFaces];

    Static4D tmp;

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

      {

      int numVerts = indices[i].length;

        int index = indices[i][j];

        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[j][0] = tmp.get0() + avgX;

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

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

    return infos;

    }

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

  private void prepare()

    {

    int[] numLayers = mObject.getNumLayers();

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

    mNumFaces  = new int[mNumCubits];

    mInfos = new FaceInfo[mNumCubits][];

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

      {

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

      ObjectShape shape = mObject.getObjectShape(variant);

      Static4D quat = mObject.getQuat(i,numLayers);

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

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

      }

    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)]

  private void castTouchPointOntoFace(float nx, float ny, float nz, float distance, float[] output)

    {

    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;

      }

    }

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

  private boolean faceIsVisible(float nx, float ny, float nz, float distance)

    {

    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

// 5) if yes, return its Z; otherwise, return NOT_TOUCHED

    QuatHelper.rotateVectorByQuat(mTmp,info.vector,quat);

    float nx = mTmp[0];

    float ny = mTmp[1];

    float nz = mTmp[2];

    if( faceIsVisible(nx,ny,nz,info.distance) )

      {

      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;

    }

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

// PUBLIC API

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

  public boolean objectTouched(Static4D rotatedTouchPoint, Static4D rotatedCamera)

    {

    if( !mPreparationDone ) prepare();

    mPoint[0]  = rotatedTouchPoint.get0()/mObjectRatio;

    mPoint[1]  = rotatedTouchPoint.get1()/mObjectRatio;

    mPoint[2]  = rotatedTouchPoint.get2()/mObjectRatio;

    mCamera[0] = rotatedCamera.get0()/mObjectRatio;

    mCamera[1] = rotatedCamera.get1()/mObjectRatio;

    mCamera[2] = rotatedCamera.get2()/mObjectRatio;

    float closestSoFar = NOT_TOUCHED;

    mTouchedCubit = -1;

          {

          mTouchedFace = face;

          closestSoFar = dist;

        }

      }

      {

    }

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

// TODO

  public void newRotation(int[] output, Static4D rotatedTouchPoint)

    {

    if( !mPreparationDone ) prepare();

    int rotIndex = 0;

    int row = 0;

    output[0] = rotIndex;

    output[1] = row;

    }

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

// TODO

  public void getCastedRotAxis(float[] output, Static4D quat, int rotIndex)

    {

    output[0] = 1.0f;

    output[1] = 0.0f;

    }

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

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

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

  public float returnRotationFactor(int[] numLayers, int row)

    {

    return 1.0f;

    }