commit 3083fab8550aa83058bd85068e54b89ebd5197de
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Wed Apr 14 00:03:44 2021 +0200

    Cubit creation: properly cener the textures. Add Kilominx edge.

diff --git a/src/main/java/org/distorted/examples/meshfile/FactoryCubit.java b/src/main/java/org/distorted/examples/meshfile/FactoryCubit.java
index 20ace76..1a97aa2 100644
--- a/src/main/java/org/distorted/examples/meshfile/FactoryCubit.java
+++ b/src/main/java/org/distorted/examples/meshfile/FactoryCubit.java
@@ -41,6 +41,7 @@ class FactoryCubit
   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 final double[] mQuat4  = new double[4];
 
   private static final Static1D RADIUS = new Static1D(1);
 
@@ -49,7 +50,6 @@ class FactoryCubit
   private static class StickerInfo
     {
     double[] vertices;
-    double dx,dy;
     }
 
   private static class FaceInfo
@@ -308,7 +308,16 @@ class FactoryCubit
       if (y < minY) minY = y;
       }
 
-    info.scale = Math.max(maxX-minX,maxY-minY);
+    minX = minX<0 ? -minX:minX;
+    maxX = maxX<0 ? -maxX:maxX;
+    minY = minY<0 ? -minY:minY;
+    maxY = maxY<0 ? -maxY:maxY;
+
+    double max1 = Math.max(minX,minY);
+    double max2 = Math.max(maxX,maxY);
+    double max3 = Math.max(max1,max2);
+
+    info.scale = max3/0.5;
 
     int len = vert3D.length;
     StickerInfo sInfo = new StickerInfo();
@@ -431,7 +440,11 @@ class FactoryCubit
 
   private double computeCos(double oldX, double oldY, double newX, double newY, double len1, double len2)
     {
-    return (oldX*newX+oldY*newY) / (len1*len2);
+    double ret= (oldX*newX+oldY*newY) / (len1*len2);
+    if( ret<-1.0 ) return -1.0;
+    if( ret> 1.0 ) return  1.0;
+
+    return ret;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -439,7 +452,11 @@ class FactoryCubit
 
   private double computeSin(double oldX, double oldY, double newX, double newY, double len1, double len2)
     {
-    return (newX*oldY-oldX*newY) / (len1*len2);
+    double ret= (newX*oldY-oldX*newY) / (len1*len2);
+    if( ret<-1.0 ) return -1.0;
+    if( ret> 1.0 ) return  1.0;
+
+    return ret;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -480,15 +497,28 @@ class FactoryCubit
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len)
+  private int computeRotatedIndex(int oldVertex, int len, int rotatedVertex, boolean inverted)
+    {
+    int v = (rotatedVertex + (inverted? -oldVertex : oldVertex));
+    if( v>=len ) v-=len;
+    if( v< 0   ) v+=len;
+
+    return v;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private boolean isScaledVersionOf(double[] newVert, double[] oldVert, int len, int vertex, boolean inverted)
     {
     double EPSILON = 0.001;
     double scale = computeScale(newVert,oldVert);
 
     for(int i=1; i<len; i++)
       {
-      double horz = oldVert[2*i  ] - scale*newVert[2*i  ];
-      double vert = oldVert[2*i+1] - scale*newVert[2*i+1];
+      int index = computeRotatedIndex(i,len,vertex,inverted);
+
+      double horz = oldVert[2*i  ] - scale*newVert[2*index  ];
+      double vert = oldVert[2*i+1] - scale*newVert[2*index+1];
 
       if( horz>EPSILON || horz<-EPSILON || vert>EPSILON || vert<-EPSILON ) return false;
       }
@@ -525,10 +555,27 @@ class FactoryCubit
     double sinHalf = computeSinHalf(cos);
     double cosHalf = computeCosHalf(sin,cos);
 
-    mQuat2[0] = 0.0f;
-    mQuat2[1] = 0.0f;
-    mQuat2[2] = sinHalf;
-    mQuat2[3] = cosHalf;
+    if( flip )
+      {
+      mQuat3[0] = 0.0f;
+      mQuat3[1] = 0.0f;
+      mQuat3[2] = sinHalf;
+      mQuat3[3] = cosHalf;
+
+      mQuat4[0] = 1.0;
+      mQuat4[1] = 0.0;
+      mQuat4[2] = 0.0;
+      mQuat4[3] = 0.0;
+
+      quatMultiply( mQuat3, mQuat4, mQuat2 );
+      }
+    else
+      {
+      mQuat2[0] = 0.0f;
+      mQuat2[1] = 0.0f;
+      mQuat2[2] = sinHalf;
+      mQuat2[3] = cosHalf;
+      }
 
     quatMultiply( mQuat1, mQuat2, mQuat3 );
 
@@ -538,6 +585,21 @@ class FactoryCubit
     info.qw = mQuat3[3];
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void printVert(double[] buffer)
+    {
+    int len = buffer.length/2;
+    String str = "";
+
+    for(int i=0; i<len; i++)
+      {
+      str += (" ("+buffer[2*i]+" , "+buffer[2*i+1]+" ) ");
+      }
+
+    android.util.Log.d("D", str);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private boolean foundVertex(FaceInfo info, double[] buffer, int len, double[] newVert,
@@ -553,7 +615,7 @@ class FactoryCubit
 
       rotateAllVertices(buffer,len,newVert,sin,cos);
 
-      if( isScaledVersionOf(buffer,oldVert,len) )
+      if( isScaledVersionOf(buffer,oldVert,len,vertex,inverted) )
         {
         double scale = computeScale(oldVert,newVert);
         correctInfo(info,scale,sin,cos,oldSticker,inverted);
@@ -607,50 +669,6 @@ class FactoryCubit
     return ret;
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  private void centerTextures()
-    {
-    int numStickers = mStickerInfo.size();
-    StickerInfo info;
-
-    for(int sticker=0; sticker<numStickers; sticker++)
-      {
-      double minX = Double.MAX_VALUE;
-      double minY = Double.MAX_VALUE;
-      double maxX =-Double.MAX_VALUE;
-      double maxY =-Double.MAX_VALUE;
-
-      info = mStickerInfo.get(sticker);
-      double[] vert = info.vertices;
-      int numVert = vert.length/2;
-
-      for ( int v=0; v<numVert; v++)
-        {
-        double x = vert[2*v  ];
-        double y = vert[2*v+1];
-
-        if (x < minX) minX = x;
-        if (y < minY) minY = y;
-        if (x > maxX) maxX = x;
-        if (y > maxY) maxY = y;
-        }
-
-      info.dx = info.dy = 0.0;
-
-      if( minX<-0.5 ) info.dx = minX + 0.5;
-      if( minY<-0.5 ) info.dy = minY + 0.5;
-      if( maxX> 0.5 ) info.dx = maxX - 0.5;
-      if( maxY> 0.5 ) info.dy = maxY - 0.5;
-
-      for ( int v=0; v<numVert; v++)
-        {
-        vert[2*v  ] -= info.dx;
-        vert[2*v+1] -= info.dy;
-        }
-      }
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private void prepareFaceInfo( final double[][] vertices, final int[][] indexes)
@@ -676,8 +694,6 @@ class FactoryCubit
 
       mFaceInfo.add(newInfo);
       }
-
-    centerTextures();
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -815,10 +831,7 @@ class FactoryCubit
       {
       int assoc = (1<<face);
       fInfo = mFaceInfo.get(face);
-      sInfo = mStickerInfo.get(fInfo.sticker);
 
-      float dx = (float)sInfo.dx;
-      float dy = (float)sInfo.dy;
       float vx = (float)fInfo.vx;
       float vy = (float)fInfo.vy;
       float vz = (float)fInfo.vz;
@@ -828,12 +841,10 @@ class FactoryCubit
       float qz = (float)fInfo.qz;
       float qw = (float)fInfo.qw;
 
-      Static3D move2D= new Static3D(dx,dy,0.0f);
-      Static3D move3D= new Static3D(vx,vy,vz);
       Static3D scale = new Static3D(sc,sc, fInfo.flip ? -sc : sc);
+      Static3D move3D= new Static3D(vx,vy,vz);
       Static4D quat  = new Static4D(qx,qy,qz,qw);
 
-      mesh.apply(new MatrixEffectMove(move2D)           ,assoc,-1);
       mesh.apply(new MatrixEffectScale(scale)           ,assoc,-1);
       mesh.apply(new MatrixEffectQuaternion(quat,center),assoc,-1);
       mesh.apply(new MatrixEffectMove(move3D)           ,assoc,-1);
diff --git a/src/main/java/org/distorted/examples/meshfile/MeshFileRenderer.java b/src/main/java/org/distorted/examples/meshfile/MeshFileRenderer.java
index e4d8216..b39c198 100644
--- a/src/main/java/org/distorted/examples/meshfile/MeshFileRenderer.java
+++ b/src/main/java/org/distorted/examples/meshfile/MeshFileRenderer.java
@@ -252,7 +252,7 @@ class MeshFileRenderer implements GLSurfaceView.Renderer, DistortedLibrary.Excep
 
     private void createMesh()
       {
-      int mode = 0;
+      int mode = 4;
       double[][] vertices = null;
       int[][] vertIndexes = null;
       float[][] bands     = null;
@@ -413,6 +413,58 @@ class MeshFileRenderer implements GLSurfaceView.Renderer, DistortedLibrary.Excep
         cornerIndexes = new int[] { 0,0,0,0,0,0 };
         }
 
+      ///// KILOMINX EDGE ////////////////////////////////////////////////////////////////////////
+
+      else if( mode==4 )
+        {
+        double SQ5  = Math.sqrt(5);
+        double SIN18= (SQ5-1)/4;
+        double COS18= 0.25*Math.sqrt(10.0+2.0*SQ5);
+        double H = 1.0;
+        double L = 2.0;
+        double X = H*Math.sqrt((5+SQ5)/10);
+        double Y = H*Math.sqrt((5-SQ5)/10);
+        double D = H*SIN18/COS18;
+
+        vertices = new double[][]
+          {
+              { 0.0,   Y, L/2},
+              {   X, 0.0, L/2},
+              { 0.0,  -Y, L/2},
+              {  -X, 0.0, L/2},
+              { 0.0,  Y, -L/2 +D},
+              {   X, 0.0,-L/2   },
+              { 0.0, -Y, -L/2-D },
+              {  -X, 0.0,-L/2   }
+          };
+
+        vertIndexes = new int[][]
+          {
+              {3,2,1,0},   // counterclockwise!
+              {0,1,5,4},
+              {3,0,4,7},
+              {2,1,5,6},
+              {3,2,6,7},
+              {4,5,6,7}
+          };
+
+        bands = new float[][]
+          {
+             {0.04f,13,(float)(L/3),(float)L/8, 5,2,3},
+             {0.00f, 0,(float)(L/2),(float)L/4, 5,2,3}
+          };
+
+        bandIndexes = new int[] { 1,0,0,1,1,1 };
+
+        corners = new float[][]
+          {
+              { 0.01f, 0.12f },
+              { 0.00f, 0.00f }
+          };
+
+        cornerIndexes = new int[] { 0,1,1,1,0,1,1,1 };
+        }
+
       FactoryCubit factory = FactoryCubit.getInstance();
       mMesh = factory.createRoundedSolid(vertices, vertIndexes, bands, bandIndexes, corners, cornerIndexes);