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;

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

public abstract class TouchControlShapeChanging extends TouchControl

  {

  private static final float NOT_TOUCHED = -1000000.0f;

  private static final float[] mTmp = new float[4];

  private static class FaceInfo

    {

    private final float[] vector;

    private final float distance;

    private final float[][] vertices;

    private final float[][] rotated;

    FaceInfo(float[][] verts)

      {

      vertices = verts;

      vector = new float[4];

      int numV = vertices.length;

      rotated = new float[numV][];

      for(int i=0; i<numV; i++) rotated[i] = new float[vertices[i].length];

      // assuming the first three vertices are linearly independent

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

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

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

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

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

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

      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[0] = vx;

      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;

  private int mTouchedSide;

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

  TouchControlShapeChanging(TwistyObject object)

    {

    mPoint = new float[3];

    mCamera= new float[3];

    mTouch = new float[3];

    mObject= object;

    mPreparationDone = false;

    }

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

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

    {

    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;

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

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

        {

        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;

        }

      infos[i] = new FaceInfo(verts);

      }

    return infos;

    }

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

  private void prepare()

    {

    int[] numLayers = mObject.getNumLayers();

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

    mNumCubits = positions.length;

    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();

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

      mNumFaces[i] = indices.length;

      }

    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;

    }

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

// input: four co-planar points in 3D. Guaranteed point1 != point2 != p2

//

// Draw a line through point1 and point2. This line splits the plana into two parts.

// Return true iff points 'p1' and 'p2' are located in different parts.

//

// Points 'p1' and 'p2' are in different parts iff vectors

// (p1-point2)x(point2-point1)  and (p2-point2)x(point2-point1)

// (which should be parallel because they are both normal to the plane) point in different directions.

//

// Two (almost) parallel vectors 'v1' and 'v2' point in different directions iff |v1+v2| < |v1-v2|

  private boolean areOnDifferentSides(float[] p1, float[] p2, float[] point1, float[] point2 )

    {

    float a1 = point2[0] - point1[0];

    float a2 = point2[1] - point1[2];

    float a3 = point2[2] - point1[3];

    float b1 = p1[0] - point2[0];

    float b2 = p1[1] - point2[2];

    float b3 = p1[2] - point2[3];

    float c1 = p2[0] - point2[0];

    float c2 = p2[1] - point2[2];

    float c3 = p2[2] - point2[3];

    float vx1 = a2*b3-a3*b2;

    float vy1 = a3*b1-a1*b3;

    float vz1 = a1*b2-a2*b1;

    float vx2 = a2*c3-a3*c2;

    float vy2 = a3*c1-a1*c3;

    float vz2 = a1*c2-a2*c1;

    float sx = vx1+vx2;

    float sy = vy1+vy2;

    float sz = vz1+vz2;

    float dx = vx1-vx2;

    float dy = vy1-vy2;

    float dz = vz1-vz2;

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

    }

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

// vertices are counterclockwise

  private boolean isInside(float[] point, float[][] vertices )

    {

    int numVert = vertices.length;

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

      {

      int index1= i==numVert-1 ? 0 : i+1;

      int index2= i==0 ? numVert-1 : i-1;

      if( areOnDifferentSides(point,vertices[index2],vertices[i],vertices[index1]) ) return false;

      }

    return true;

    }

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

  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

  private float cubitFaceTouched(FaceInfo info, float[] quat, float closestSoFar)

    {

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

      if( mTouch[2]>closestSoFar )

        {

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

        if( isInside(mTouch,info.rotated) ) return mTouch[2];

        }

      }

    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;

    mTouchedSide  = -1;

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

      {

      int quatIndex = mObject.getCubitQuatIndex(i);

      float[] quat = mQuats[quatIndex];

      for(int j=0; j<mNumFaces[i]; j++)

        {

        float dist = cubitFaceTouched(mInfos[i][j],quat,closestSoFar);

        if( dist!=NOT_TOUCHED )

          {

          mTouchedCubit = i;

          mTouchedSide  = j;

          }

        closestSoFar = dist;

        }

      }

    return closestSoFar!=NOT_TOUCHED;

    }

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

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

    }

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

// replace mode only

  public int getTouchedFace()

    {

    return -1;

    }

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

// replace mode only

  public float[] getTouchedPoint3D()

    {

    return null;

    }

  }