Distorted Android

import org.distorted.library.effect.MatrixEffect;

import org.distorted.library.effect.MatrixEffectMove;

import org.distorted.library.effect.MatrixEffectQuaternion;

import org.distorted.library.effect.MatrixEffectScale;

  private static class StickerInfo

    }

  private static class FaceInfo

    {

    int sticker;

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

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

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

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

    StickerInfo sInfo = new StickerInfo();

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

    mStickerInfo.add(sInfo);

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

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

  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;

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

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

      float xR = newVert[2*vertex  ];

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

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

  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;

    mStickerInfo.clear();

    FaceInfo preInfo;

        preInfo = mFaceInfo.get(previous);

        if( successfullyCollapsedStickers(newInfo,preInfo) ) break;

  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]+") ");

        }

  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)

    FaceInfo fInfo;

    StickerInfo sInfo;

    //printStickerInfo();

      fInfo = mFaceInfo.get(face);

      sInfo = mStickerInfo.get(fInfo.sticker);

      //printFaceInfo(fInfo);

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

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

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

      mesh.apply(effects[EFFECTS_PER_FACE*face  ],assoc,-1);

      mesh.apply(effects[EFFECTS_PER_FACE*face+1],assoc,-1);

      mesh.apply(effects[EFFECTS_PER_FACE*face+2],assoc,-1);

    prepareAndRoundCorners(mesh, vertices, vertIndexes, corners, cornerIndexes);

      final float[][] corners = new float[][]

          {

              { 0.01f, 0.10f }

          };

      final int[] cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };

      mMesh = factory.createRoundedSolid(vertices, vertIndexes, bands, bandIndexes, corners, cornerIndexes);