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.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

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;

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

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

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

  private static class FaceInfo

    {

    int sticker;

    double scale;

    double qx,qy,qz,qw;

    }

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

    }

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

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

      {

      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-1] =    H;

    }

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

  private void roundCorners(MeshBase mesh, Static3D center, Static3D[] vertices, float strength, float 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());

      }

    }

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

    double y1 = vertices[index1][1];

    double z1 = vertices[index1][2];

    double x2 = vertices[index2][0];

    double y2 = vertices[index2][1];

    double z2 = vertices[index2][2];

    double x3 = vertices[index3][0];

    double y3 = vertices[index3][1];

    double z3 = vertices[index3][2];

    double v1x = x2-x1;

    double v1y = y2-y1;

    double v1z = z2-z1;

    double v2x = x3-x1;

    double v2y = y3-y1;

    double v2z = z3-z1;

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

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

    double y1 = vertices[index1][1];

    double z1 = vertices[index1][2];

    double x2 = vertices[index2][0];

    double y2 = vertices[index2][1];

    double z2 = vertices[index2][2];

    double x3 = vertices[index3][0];

    double y3 = vertices[index3][1];

    double z3 = vertices[index3][2];

    double v1x = x2-x1;

    double v1y = y2-y1;

    double v1z = z2-z1;

    double v2x = x3-x1;

    double v2y = y3-y1;

    double v2z = z3-z1;

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

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

    len = Math.sqrt(len);

    mBuffer[1] /= len;

    mBuffer[2] /= len;

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

    double qy = quat1[1];

    double qz = quat1[2];

    double qw = quat1[3];

    double ry = quat2[1];

    double rz = quat2[2];

    double rw = quat2[3];

    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;

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

    double maxX =-Double.MAX_VALUE;

    double minY = Double.MAX_VALUE;

    double maxY =-Double.MAX_VALUE;

      double y = vert[1];

      if (x < minX) minX = x;

      if (y > maxY) maxY = y;

      if (y < minY) minY = y;

      }

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

    info.sticker = mStickerInfo.size() -1;

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

    info.vx = 0.0f;

    info.vy = 0.0f;

    info.vz = 0.0f;

    int len = vert3D.length;

      info.vy += vert[1];

      info.vz += vert[2];

    info.vy /= len;

    info.vz /= len;

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

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

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

    int foundIndex = -1;

        {

        foundIndex = vertex;

        break;

        }

    if( foundIndex==-1 )

      {

      throw new RuntimeException("all vertices colinear");

      }

      axisY =  mBuffer[0];

      axisZ = 0.0f;

      axiLen = Math.sqrt(axiLen);

      axisY /= axiLen;

      axisZ /= axiLen;

    else

      {

      axisX = 0.0f;

      axisY = 1.0f;

      axisZ = 0.0f;

      }

    double sinTheta = Math.sqrt(1-cosTheta*cosTheta);

    double sinHalfTheta = computeSinHalf(cosTheta);

    double cosHalfTheta = computeCosHalf(sinTheta,cosTheta);

    mQuat1[1] = axisY*sinHalfTheta;

    mQuat1[2] = axisZ*sinHalfTheta;

    mQuat1[3] = cosHalfTheta;

    mQuat2[1] =-axisY*sinHalfTheta;

    mQuat2[2] =-axisZ*sinHalfTheta;

    mQuat2[3] = cosHalfTheta;

      quatMultiply(mQuat3, mQuat2, vert  );

    fitInSquare(info, vert3D);

    info.qy =-mQuat1[1];

    info.qz =-mQuat1[2];

    info.qw = mQuat1[3];

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

    }

    double lenSq2 = v2[0]*v2[0] + v2[1]*v2[1];

    return Math.sqrt(lenSq2/lenSq1);

    }

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

  private double computeSinHalf(double cos)

    {

    return Math.sqrt((1-cos)/2);

    }

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

  private double computeCosHalf(double sin, double cos)

    {

    double cosHalf = Math.sqrt((1+cos)/2);

    return sin<0 ? -cosHalf : cosHalf;

    }

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

  private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len)

    {

    double EPSILON = 0.001;

    double scale = computeScale(newVert,oldVert);

      {

      double vert = oldVert[2*i+1] - scale*newVert[2*i+1];

      }

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

      {

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

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

      }

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

    mQuat1[0] = info.qx;

    mQuat1[1] = info.qy;

    mQuat1[2] = info.qz;

    mQuat1[3] = info.qw;

    double cosHalf = computeCosHalf(sin,cos);

    mQuat2[1] = 0.0f;

    mQuat2[2] = sinHalf;

    mQuat2[3] = cosHalf;

    info.qy = mQuat3[1];

    info.qz = mQuat3[2];

    info.qw = mQuat3[3];

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

                              double[] oldVert, double lenFirstOld, int oldSticker, boolean inverted)

      {

      double newY = newVert[2*vertex+1];

      double lenIthNew = Math.sqrt(newX*newX + newY*newY);

      double cos = computeCos( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);

      double sin = computeSin( oldVert[0], oldVert[1], newX, newY, lenIthNew, lenFirstOld);

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

        }

      }

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

    double[] newVert = sNewInfo.vertices;

    double[] oldVert = sOldInfo.vertices;

    int oldLen = oldVert.length;

    int newLen = newVert.length;

      double[] buffer1 = new double[oldLen];

      double[] buffer2 = new double[oldLen];

      mirrorAllVertices(buffer2, newLen/2, newVert);

      if( foundVertex(newInfo, buffer1, oldLen/2, buffer2, oldVert, lenFirstOld, oldSticker, true ) ) return true;

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

      {

      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;

      }

  private void centerTextures()

    {

    int numStickers = mStickerInfo.size();

    StickerInfo info;

    for(int sticker=0; sticker<numStickers; sticker++)