Distorted Android

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

// Copyright 2020 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.examples.meshfile;

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

import org.distorted.library.effect.VertexEffect;

import org.distorted.library.effect.VertexEffectDeform;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.mesh.MeshJoined;

import org.distorted.library.mesh.MeshPolygon;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.util.ArrayList;

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

class FactoryCubit

  {

  private static final float[] mBuffer = new float[3];

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

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

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

  private static final Static1D RADIUS = new Static1D(1);

  private static FactoryCubit mThis;

  private static class StickerInfo

    {

    float[] vertices;

    }

  private static class FaceInfo

    {

    int sticker;

    float vx,vy,vz;

    float scale;

    float qx,qy,qz,qw;

    boolean flip;

    }

  private static final ArrayList<FaceInfo>       mFaceInfo = new ArrayList<>();

  private static final ArrayList<StickerInfo> mStickerInfo = new ArrayList<>();

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

  private FactoryCubit()

    {

    }

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

  public static FactoryCubit getInstance()

    {

    if( mThis==null ) mThis = new FactoryCubit();

    return mThis;

    }

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

// H - height of the band in the middle

// alpha - angle of the edge  [0,90]

// dist - often in a polygon the distance from edge to center is not 1, but something else.

// This is the distance.

// K - where to begin the second, much more flat part of the band. [0,1]

// N - number of bands. N>=3

//

// theory: two distinct parts to the band:

// 1) (0,B) - steep

// 2) (B,1) - flat

//

// In first part, we have y = g(x) ; in second - y = g(f(x)) where

//

// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha)

// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B)

// h(x) = R*(sin(alpha) - sin(x))

// R = H/(1-cos(alpha))

// D = H*sin(alpha)

// B = h(K*alpha)

//

// The N points are taken at:

//

// 1) in the second part, there are K2 = (N-3)/3 such points

// 2) in the first - K1 = (N-3) - K2

// 3) also, the 3 points 0,B,1

//

// so we have the sequence A[i] of N points

//

// 0

// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1)

// B

// (1-B)*(i+1)/(K2+1) + B   (i=0,i,...,K2-1)

// 1

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

  private float f(float D, float B, float x)

    {

    return ((D-B)*x + B*(1-D))/(1-B);

    }

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

  private float g(float R, float D, float x, float cosAlpha)

    {

    float d = x-D;

    return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha);

    }

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

  private float h(float R, float sinAlpha, float x)

    {

    return R*(sinAlpha-(float)Math.sin(x));

    }

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

  float[] computeBands(float H, int alpha, float dist, float K, int N)

    {

    float[] bands = new float[2*N];

    bands[0] = 1.0f;

    bands[1] = 0.0f;

    float beta = (float)Math.atan(dist*Math.tan(Math.PI*alpha/180));

    float sinBeta = (float)Math.sin(beta);

    float cosBeta = (float)Math.cos(beta);

    float R = cosBeta<1.0f ? H/(1.0f-cosBeta) : 0.0f;

    float D = R*sinBeta;

    float B = h(R,sinBeta,K*beta);

    if( D>1.0f )

      {

      for(int i=1; i<N; i++)

        {

        bands[2*i  ] = (float)(N-1-i)/(N-1);

        bands[2*i+1] = H*(1-bands[2*i]);

        }

      }

    else

      {

      int K2 = (int)((N-3)*K);

      int K1 = (N-3)-K2;

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

        {

        float angle = K*beta + (1-K)*beta*(K1-i)/(K1+1);

        float x = h(R,sinBeta,angle);

        bands[2*i+2] = 1.0f - x;

        bands[2*i+3] = g(R,D,x,cosBeta);

        }

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

        {

        float x = (1-B)*(i+1)/(K2+1) + B;

        bands[2*K1+2 + 2*i+2] = 1.0f - x;

        bands[2*K1+2 + 2*i+3] = g(R,D,f(D,B,x),cosBeta);

        }

      }

    bands[2*N-2] = 0.0f;

    bands[2*N-1] =    H;

    return bands;

    }

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

  private void roundCorners(MeshBase mesh, Static3D center, Static3D[] vertices, float strength, float regionRadius)

    {

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

    float centX = center.get0();

    float centY = center.get1();

    float centZ = center.get2();

    for (Static3D vertex : vertices)

      {

      float x = strength*(centX - vertex.get0());

      float y = strength*(centY - vertex.get1());

      float z = strength*(centZ - vertex.get2());

      VertexEffect effect = new VertexEffectDeform(new Static3D(x,y,z), RADIUS, vertex, region);

      mesh.apply(effect);

      }

    }

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

  private boolean areColinear(float[][] vertices, int index1, int index2, int index3)

    {

    float x1 = vertices[index1][0];

    float y1 = vertices[index1][1];

    float z1 = vertices[index1][2];

    float x2 = vertices[index2][0];

    float y2 = vertices[index2][1];

    float z2 = vertices[index2][2];

    float x3 = vertices[index3][0];

    float y3 = vertices[index3][1];

    float z3 = vertices[index3][2];

    float v1x = x2-x1;

    float v1y = y2-y1;

    float v1z = z2-z1;

    float v2x = x3-x1;

    float v2y = y3-y1;

    float v2z = z3-z1;

    float A = (float)Math.sqrt( (v1x*v1x+v1y*v1y+v1z*v1z) / (v2x*v2x+v2y*v2y+v2z*v2z) );

    return (v1x==A*v2x && v1y==A*v2y && v1z==A*v2z);

    }

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

  private void computeNormalVector(float[][] vertices, int index1, int index2, int index3)

    {

    float x1 = vertices[index1][0];

    float y1 = vertices[index1][1];

    float z1 = vertices[index1][2];

    float x2 = vertices[index2][0];

    float y2 = vertices[index2][1];

    float z2 = vertices[index2][2];

    float x3 = vertices[index3][0];

    float y3 = vertices[index3][1];

    float z3 = vertices[index3][2];

    float v1x = x2-x1;

    float v1y = y2-y1;

    float v1z = z2-z1;

    float v2x = x3-x1;

    float v2y = y3-y1;

    float v2z = z3-z1;

    mBuffer[0] = v1y*v2z - v2y*v1z;

    mBuffer[1] = v1z*v2x - v2z*v1x;

    mBuffer[2] = v1x*v2y - v2x*v1y;

    float len = mBuffer[0]*mBuffer[0] + mBuffer[1]*mBuffer[1] + mBuffer[2]*mBuffer[2];

    len = (float)Math.sqrt(len);

    mBuffer[0] /= len;

    mBuffer[1] /= len;

    mBuffer[2] /= len;

    }

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

// return quat1*quat2

  private static void quatMultiply( float[] quat1, float[] quat2, float[] result )

    {

    float qx = quat1[0];

    float qy = quat1[1];

    float qz = quat1[2];

    float qw = quat1[3];

    float rx = quat2[0];

    float ry = quat2[1];

    float rz = quat2[2];

    float rw = quat2[3];

    result[0] = rw*qx - rz*qy + ry*qz + rx*qw;

    result[1] = rw*qy + rz*qx + ry*qw - rx*qz;

    result[2] = rw*qz + rz*qw - ry*qx + rx*qy;

    result[3] = rw*qw - rz*qz - ry*qy - rx*qx;

    }

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

  private void fitInSquare(FaceInfo info, float[][] vert3D)

    {

    float minX = Float.MAX_VALUE;

    float maxX =-Float.MAX_VALUE;

    float minY = Float.MAX_VALUE;

    float maxY =-Float.MAX_VALUE;

    for (float[] vert : vert3D)

      {

      float x = vert[0];

      float y = vert[1];

      if (x > maxX) maxX = x;

      if (x < minX) minX = x;

      if (y > maxY) maxY = y;

      if (y < minY) minY = y;

      }

    info.scale = Math.max(maxX-minX,maxY-minY);

    int len = vert3D.length;

    StickerInfo sInfo = new StickerInfo();

    sInfo.vertices = new float[2*len];

    mStickerInfo.add(sInfo);

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

      {

      sInfo.vertices[2*vertex  ] = vert3D[vertex][0] / info.scale;

      sInfo.vertices[2*vertex+1] = vert3D[vertex][1] / info.scale;

      }

    info.flip = false;

    }

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

  private void constructNew(FaceInfo info, final float[][] vert3D)

    {

    // compute center of gravity

    info.vx = 0.0f;

    info.vy = 0.0f;

    info.vz = 0.0f;

    int len = vert3D.length;

    for (float[] vert : vert3D)

      {

      info.vx += vert[0];

      info.vy += vert[1];

      info.vz += vert[2];

      }

    info.vx /= len;

    info.vy /= len;

    info.vz /= len;

    // move all vertices so that their center of gravity is at (0,0,0)

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

      {

      vert3D[i][0] -= info.vx;

      vert3D[i][1] -= info.vy;

      vert3D[i][2] -= info.vz;

      }

    // find 3 non-colinear vertices

    int foundIndex = -1;

    for(int vertex=2; vertex<len; vertex++)

      {

      if( !areColinear(vert3D,0,1,vertex) )

        {

        foundIndex = vertex;

        break;

        }

      }

    // compute the normal vector

    if( foundIndex==-1 )

      {

      throw new RuntimeException("all vertices colinear");

      }

    computeNormalVector(vert3D,0,1,foundIndex);

    // rotate so that the normal vector becomes (0,0,1)

    float axisX, axisY, axisZ;

    if( mBuffer[0]!=0.0f || mBuffer[1]!=0.0f )

      {

      axisX = -mBuffer[1];

      axisY =  mBuffer[0];

      axisZ = 0.0f;

      float axiLen = axisX*axisX + axisY*axisY + axisZ*axisZ;

      axiLen = (float)Math.sqrt(axiLen);

      axisX /= axiLen;

      axisY /= axiLen;

      axisZ /= axiLen;

      }

    else

      {

      axisX = 0.0f;

      axisY = 1.0f;

      axisZ = 0.0f;

      }

    float cosTheta = mBuffer[2];

    float sinHalfTheta = (float)Math.sqrt(0.5f*(1-cosTheta));

    float cosHalfTheta = (float)Math.sqrt(0.5f*(1+cosTheta));

    mQuat1[0] = axisX*sinHalfTheta;

    mQuat1[1] = axisY*sinHalfTheta;

    mQuat1[2] = axisZ*sinHalfTheta;

    mQuat1[3] = cosHalfTheta;

    mQuat2[0] = axisX*sinHalfTheta;

    mQuat2[1] = axisY*sinHalfTheta;

    mQuat2[2] = axisZ*sinHalfTheta;

    mQuat2[3] = -cosHalfTheta;

    for (float[] vert : vert3D)

      {

      quatMultiply(mQuat1, vert, mQuat3);

      quatMultiply(mQuat3, mQuat2, vert);

      }

    // fit the whole thing in a square and remember the scale & 2D vertices

    fitInSquare(info, vert3D);

    // remember the rotation

    info.qx = mQuat1[0];

    info.qy = mQuat1[1];

    info.qz = mQuat1[2];

    info.qw =-mQuat1[3];

    }

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

  private float computeCos(float x1, float y1, float x2, float y2, float len1, float len2)

    {

    return (x1*x2+y1*y2) / (len1*len2);

    }

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

// sin of (signed!) angle between vectors (x1,y1) and (x2,y2), counterclockwise!

  private float computeSin(float x1, float y1, float x2, float y2, float len1, float len2)

    {

    return (x2*y1-x1*y2) / (len1*len2);

    }

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

  private void rotateAllVertices(float[] result, int len, float[] vertices, float sin, float cos)

    {

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

      {

      result[2*i  ] = vertices[2*i  ]*cos - vertices[2*i+1]*sin;

      result[2*i+1] = vertices[2*i  ]*sin + vertices[2*i+1]*cos;

      }

    }

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

  private boolean isScaledVersionOf(float[] v1, float[] v2, int len)

    {

    float EPSILON = 0.001f;

    float scale = v1[0]!=0.0f ? v2[0]/v1[0] : v2[1]/v1[1];

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

      {

      float horz = v2[2*i  ] - scale*v1[2*i  ];

      float vert = v2[2*i+1] - scale*v1[2*i+1];

      if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;

      }

    return true;

    }

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

  private void mirrorAllVertices(float[] output, int len, float[] input)

    {

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

      {

      output[2*vertex  ] = input[2*vertex  ];

      output[2*vertex+1] =-input[2*vertex+1];

      }

    }

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

  private void correctInfo(FaceInfo info, float scale, float sin, float cos, int oldSticker, boolean flip)

    {

    mStickerInfo.remove(info.sticker);

    info.flip = flip;

    info.sticker = oldSticker;

    info.scale *= scale;

    mQuat1[0] = 0.0f;

    mQuat1[1] = 0.0f;

    mQuat1[2] = sin;

    mQuat1[3] = cos;

    mQuat2[0] = info.qx;

    mQuat2[1] = info.qy;

    mQuat2[2] = info.qz;

    mQuat2[3] = info.qw;

    quatMultiply( mQuat1, mQuat2, mQuat3 );

    info.qx = mQuat3[0];

    info.qy = mQuat3[1];

    info.qz = mQuat3[2];

    info.qw = mQuat3[3];

    }

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

  private boolean foundVertex(FaceInfo info, float[] buffer, int len, float[] preVert,

                              float[] newVert, float lenVert, int oldSticker, boolean inverted)

    {

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

      {

      float xR = newVert[2*vertex  ];

      float yR = newVert[2*vertex+1];

      float lenRotV = (float)Math.sqrt(xR*xR+yR*yR);

      float cos = computeCos(xR,yR,preVert[0],preVert[1], lenRotV, lenVert);

      float sin = computeSin(xR,yR,preVert[0],preVert[1], lenRotV, lenVert);

      rotateAllVertices(buffer,len,newVert,sin,cos);

      if( isScaledVersionOf(buffer,preVert,len) )

        {

        float scale = preVert[0]!=0.0f ? buffer[0]/preVert[0] : buffer[1]/preVert[1];

        correctInfo(info,scale,sin,cos,oldSticker,inverted);

        return true;

        }

      }

    return false;

    }

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

  private boolean successfullyCollapsedStickers(final FaceInfo newInfo, final FaceInfo preInfo)

    {

    StickerInfo sNewInfo = mStickerInfo.get(newInfo.sticker);

    StickerInfo sPreInfo = mStickerInfo.get(preInfo.sticker);

    int len = sPreInfo.vertices.length;

    float[] newVert = sNewInfo.vertices;

    if( len == newVert.length )

      {

      int oldSticker = preInfo.sticker;

      float[] tmp1 = new float[len];

      float lenVert = (float)Math.sqrt(newVert[0]*newVert[0] + newVert[1]*newVert[1]);

      if( foundVertex(newInfo, tmp1, len/2, sPreInfo.vertices, newVert, lenVert, oldSticker, false) ) return true;

      float[] tmp2 = new float[len];

      mirrorAllVertices(tmp2,len/2,sPreInfo.vertices);

      if( foundVertex(newInfo, tmp1, len/2, tmp2             , newVert, lenVert, oldSticker, true ) ) return true;

      }

    return false;

    }

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

  private float[][] constructVert(float[][] vertices, int[] index)

    {

    int len = index.length;

    float[][] ret = new float[len][4];

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

      {

      ret[i][0] = vertices[index[i]][0];

      ret[i][1] = vertices[index[i]][1];

      ret[i][2] = vertices[index[i]][2];

      ret[i][3] = 1.0f;

      }

    return ret;

    }

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

  private void prepareFaceInfo( final float[][] vertices, final int[][] indexes)

    {

    mFaceInfo.clear();

    mStickerInfo.clear();

    int numFaces = indexes.length;

    FaceInfo preInfo;

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

      {

      FaceInfo newInfo = new FaceInfo();

      int[] index = indexes[face];

      float[][] vert = constructVert(vertices,index);

      constructNew(newInfo,vert);

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

        {

        preInfo = mFaceInfo.get(previous);

        if( successfullyCollapsedStickers(newInfo,preInfo) ) break;

        }

      mFaceInfo.add(newInfo);

      }

    }

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

  private void prepareAndRoundCorners(MeshBase mesh, float[][] vertices, int[][] vertIndexes,

                                      float[][] corners, int[] cornerIndexes )

    {

    int numNeig, lenFV;

    int lenV = vertices.length;

    int[] verts = new int[2*(lenV-1)];

    Static3D[] staticVert = new Static3D[1];

    Static3D center = new Static3D(0,0,0);

    float cx, cy, cz;

    float[] singleV;

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

      {

      // prepare verts[]

      numNeig = 0;

      for (int[] vertIndex : vertIndexes)

        {

        lenFV = vertIndex.length;

        for (int fv = 0; fv < lenFV; fv++)

          if (vertIndex[fv] == v)

            {

            int prev = fv > 0 ? fv - 1 : lenFV - 1;

            int next = fv < lenFV - 1 ? fv + 1 : 0;

            verts[numNeig++] = vertIndex[prev];

            verts[numNeig++] = vertIndex[next];

            }

        }

      cx=cy=cz=0.0f;

      // from verts[] prepare center

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

        {

        singleV = vertices[verts[n]];

        cx += singleV[0];

        cy += singleV[1];

        cz += singleV[2];

        }

      center.set(cx/numNeig - vertices[v][0],cy/numNeig - vertices[v][1],cz/numNeig - vertices[v][2]);

      // round Corners

      staticVert[0] = new Static3D(vertices[v][0], vertices[v][1], vertices[v][2]);

      int corn = cornerIndexes[v];

      float strength = corners[corn][0];

      float radius   = corners[corn][1];

      roundCorners(mesh, center, staticVert, strength, radius);

      }

    }

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

  private void printStickerInfo()

    {

    String ver="";

    int stickers = mStickerInfo.size();

    for(int s=0; s<stickers; s++)

      {

      ver = "";

      StickerInfo info = mStickerInfo.get(s);

      int len = info.vertices.length/2;

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

        {

        ver += ("("+info.vertices[2*i]+","+info.vertices[2*i+1]+") ");

        }

      }

    android.util.Log.e("D", "vertices= "+ver);

    }

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

  private void printFaceInfo(FaceInfo info)

    {

    android.util.Log.e("D", "q=("+info.qx+", "+info.qy+", "+info.qz+", "+info.qw+") v=("

                       +info.vx+", "+info.vy+", "+info.vz+") scale="+info.scale+" sticker="+info.sticker);

    }

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

  MeshBase createRoundedSolid(final float[][] vertices, final int[][] vertIndexes,

                              final float[][] bands   , final int[]   bandIndexes,

                              final float[][] corners , final int[]   cornerIndexes)

    {

    int EFFECTS_PER_FACE = 3;

    prepareFaceInfo(vertices,vertIndexes);

    int numFaces = vertIndexes.length;

    float[] band, bandsComputed;

    MeshBase[] meshes = new MeshBase[numFaces];

    FaceInfo fInfo;

    StickerInfo sInfo;

    //printStickerInfo();

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

      {

      fInfo = mFaceInfo.get(face);

      sInfo = mStickerInfo.get(fInfo.sticker);

      //printFaceInfo(fInfo);

      band = bands[bandIndexes[face]];

      bandsComputed = computeBands( band[0], (int)band[1], band[2], band[3], (int)band[4]);

      meshes[face] = new MeshPolygon(sInfo.vertices,bandsComputed,(int)band[5],(int)band[6]);

      meshes[face].setEffectAssociation(0,(1<<face),0);

      }

    MeshBase mesh = new MeshJoined(meshes);

    MatrixEffect[] effects = new MatrixEffect[EFFECTS_PER_FACE*numFaces];

    Static3D center = new Static3D(0,0,0);

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

      {

      int assoc = (1<<face);

      fInfo = mFaceInfo.get(face);

      Static3D move3D= new Static3D(fInfo.vx,fInfo.vy,fInfo.vz);

      Static3D scale = new Static3D(fInfo.scale,fInfo.scale, fInfo.flip ? -fInfo.scale : fInfo.scale);

      Static4D quat  = new Static4D(fInfo.qx,fInfo.qy,fInfo.qz,fInfo.qw);

      effects[EFFECTS_PER_FACE*face  ] = new MatrixEffectScale(scale);

      effects[EFFECTS_PER_FACE*face+1] = new MatrixEffectQuaternion(quat,center);

      effects[EFFECTS_PER_FACE*face+2] = new MatrixEffectMove(move3D);