TwistyPuzzleLib

    // this theoretically should be uncommented to combat the same effect like in

    // TouchControlShapeChanging.FaceInfo, but when I try, the center sticker of

    // CoinTetrahedron gets inverted. Weird!

    // Uncommenting this does fix the fact that the convexity of the center cubits

    // of CoinT and CoinH goes concave

/*

    if( totalAngle(vertices,mBuffer)<0 )

      {

      mBuffer[0] *= -1;

      mBuffer[1] *= -1;

      mBuffer[2] *= -1;

      }

 */

    }

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

// this returns the total angle we get rotated about when we travel from the first vert to the last.

// It's always should be +2PI or -2PI, depending on if the verts are CW or CCW (when looking at the

// plane formed by the vertices from the direction the 'normal' vector points towards)

//

// The point: this way we can detect if the 'normal' vector is correct, i.e. if it points in the

// right direction.

// Sometimes it doesn't, when the first three vertices (from which the vector is computed) are 'concave'.

  public static float totalAngle(float[][] vert, float[] normal)

    {

    float ret = 0;

    int num = vert.length;

    for(int c=0; c<num; c++)

      {

      int n = (c==num-1 ? 0 : c+1);

      int m = (n==num-1 ? 0 : n+1);

      ret += angle( vert[c],vert[n],vert[m], normal);

      }

    return ret;

    }

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

  private static float angle(float[] v0, float[] v1, float[] v2, float[] normal)

    {

    float px = v1[0] - v0[0];

    float py = v1[1] - v0[1];

    float pz = v1[2] - v0[2];

    float rx = v2[0] - v1[0];

    float ry = v2[1] - v1[1];

    float rz = v2[2] - v1[2];

    float l1 = (float)Math.sqrt(px*px + py*py + pz*pz);

    float l2 = (float)Math.sqrt(rx*rx + ry*ry + rz*rz);

    px /= l1;

    py /= l1;

    pz /= l1;

    rx /= l2;

    ry /= l2;

    rz /= l2;

    float s = px*rx + py*ry + pz*rz;

    if( s> 1 ) s= 1;

    if( s<-1 ) s=-1;

    float a = (float) Math.acos(s);

    float[] cross = crossProduct(px,py,pz,rx,ry,rz);

    float ax = cross[0] + normal[0];

    float ay = cross[1] + normal[1];

    float az = cross[2] + normal[2];

    float bx = cross[0] - normal[0];

    float by = cross[1] - normal[1];

    float bz = cross[2] - normal[2];

    float f1 = ax*ax + ay*ay + az*az;

    float f2 = bx*bx + by*by + bz*bz;

    return f1>f2 ? a : -a;

    }

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

  private static float[] crossProduct(float a1, float a2, float a3, float b1, float b2, float b3)

    {

    float[] ret = new float[3];

    ret[0] = a2*b3 - a3*b2;

    ret[1] = a3*b1 - a1*b3;

    ret[2] = a1*b2 - a2*b1;

    return ret;

    float d_squared = dx*dx+dy*dy;

    float f = (float)Math.sqrt(r*r-d_squared);

// android.util.Log.e("D", "drawing arc ox="+oX+" oy="+oY+" R="+R+" startA="+startA+" sweepA="+sweepA+" stopA="+(stopA*(180/PI)));

// android.util.Log.e("D", "drawing arc v1="+v1x+" , "+v1y+" v2="+v2x+" , "+v2y+" tex: "+mTexHeight);

// android.util.Log.e("D", "drawing line from "+v1x+" , "+v1y+" to "+v2x+" , "+v2y);

import org.distorted.objectlib.helpers.FactoryCubit;

      if( FactoryCubit.totalAngle(vertices,normal)<0 )