TwistyPuzzleLib

      if( totalAngle(vertices,normal)<0 )

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

    // 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 does not, when the first three vertices

    // (from which the vector is computed) are 'concave'.

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

      }