synched latest gl changes

Author: codeanticode

core/src/processing/opengl/PGraphicsOpenGL.java

@@ -509,6 +509,12 @@ public class PGraphicsOpenGL extends PGraphics {
     "to render this geometry properly, using default shader instead.";
   static final String TESSELLATION_ERROR =
     "Tessellation Error: %1$s";
+  static final String GL_THREAD_NOT_CURRENT =
+    "You are trying to draw outside OpenGL's animation thread.\n" +
+    "Place all drawing commands in the draw() function, or inside\n" +
+    "your own functions as long as they are called from draw(),\n" +
+    "but not in event handling functions such as keyPressed()\n" +
+    "or mousePressed().";
 
   //////////////////////////////////////////////////////////////
 
@@ -677,15 +683,14 @@ public void requestDraw() {
   }
 
 
-  /*
+/*
   @Override
   // Java only
   public PSurface createSurface() {  // ignore
     return surface = new PSurfaceJOGL(this);
   }
 */
 
-
   public boolean saveImpl(String filename) {
     return super.save(filename); // ASYNC save frame using PBOs not yet available on Android
 
@@ -1467,6 +1472,11 @@ public void beginDraw() {
       getPrimaryPG().setCurrentPG(this);
     }
 
+    if (!pgl.threadIsCurrent()) {
+      PGraphics.showWarning(GL_THREAD_NOT_CURRENT);
+      return;
+    }
+
     // This has to go after the surface initialization, otherwise offscreen
     // surfaces will have a null gl object.
     report("top beginDraw()");
@@ -3788,6 +3798,30 @@ static protected void invTranslate(PMatrix3D matrix,
   }
 
 
+  static protected float matrixScale(PMatrix matrix) {
+    // Volumetric scaling factor that is associated to the given
+    // transformation matrix, which is given by the absolute value of its
+    // determinant:
+    float factor = 1;
+
+    if (matrix != null) {
+      if (matrix instanceof PMatrix2D) {
+        PMatrix2D tr = (PMatrix2D)matrix;
+        float areaScaleFactor = Math.abs(tr.m00 * tr.m11 - tr.m01 * tr.m10);
+        factor = (float) Math.sqrt(areaScaleFactor);
+      } else if (matrix instanceof PMatrix3D) {
+        PMatrix3D tr = (PMatrix3D)matrix;
+        float volumeScaleFactor =
+          Math.abs(tr.m00 * (tr.m11 * tr.m22 - tr.m12 * tr.m21) +
+                   tr.m01 * (tr.m12 * tr.m20 - tr.m10 * tr.m22) +
+                   tr.m02 * (tr.m10 * tr.m21 - tr.m11 * tr.m20));
+        factor = (float) Math.pow(volumeScaleFactor, 1.0f / 3.0f);
+      }
+    }
+    return factor;
+  }
+
+
   /**
    * Two dimensional rotation. Same as rotateZ (this is identical to a 3D
    * rotation along the z-axis) but included for clarity -- it'd be weird for
@@ -5138,7 +5172,7 @@ protected void lightPosition(int num, float x, float y, float z,
       x*modelview.m20 + y*modelview.m21 + z*modelview.m22 + modelview.m23;
 
     // Used to indicate if the light is directional or not.
-    lightPosition[4 * num + 3] = dir ? 1: 0;
+    lightPosition[4 * num + 3] = dir ? 0 : 1;
   }
 
 
@@ -10674,6 +10708,7 @@ void applyMatrixOnLineGeometry(PMatrix2D tr, int first, int last) {
       if (first < last) {
         int index;
 
+        float scaleFactor = matrixScale(tr);
         for (int i = first; i <= last; i++) {
           index = 4 * i;
           float x = lineVertices[index++];
@@ -10690,6 +10725,7 @@ void applyMatrixOnLineGeometry(PMatrix2D tr, int first, int last) {
           index = 4 * i;
           lineDirections[index++] = dx*tr.m00 + dy*tr.m01;
           lineDirections[index  ] = dx*tr.m10 + dy*tr.m11;
+          lineDirections[index + 2] *= scaleFactor;
         }
       }
     }
@@ -10698,6 +10734,7 @@ void applyMatrixOnPointGeometry(PMatrix2D tr, int first, int last) {
       if (first < last) {
         int index;
 
+        float matrixScale = matrixScale(tr);
         for (int i = first; i <= last; i++) {
           index = 4 * i;
           float x = pointVertices[index++];
@@ -10706,6 +10743,10 @@ void applyMatrixOnPointGeometry(PMatrix2D tr, int first, int last) {
           index = 4 * i;
           pointVertices[index++] = x*tr.m00 + y*tr.m01 + tr.m02;
           pointVertices[index  ] = x*tr.m10 + y*tr.m11 + tr.m12;
+
+          index = 2 * i;
+          pointOffsets[index++] *= matrixScale;
+          pointOffsets[index] *= matrixScale;
         }
       }
     }
@@ -10771,6 +10812,7 @@ void applyMatrixOnLineGeometry(PMatrix3D tr, int first, int last) {
       if (first < last) {
         int index;
 
+        float scaleFactor = matrixScale(tr);
         for (int i = first; i <= last; i++) {
           index = 4 * i;
           float x = lineVertices[index++];
@@ -10792,7 +10834,8 @@ void applyMatrixOnLineGeometry(PMatrix3D tr, int first, int last) {
           index = 4 * i;
           lineDirections[index++] = dx*tr.m00 + dy*tr.m01 + dz*tr.m02;
           lineDirections[index++] = dx*tr.m10 + dy*tr.m11 + dz*tr.m12;
-          lineDirections[index  ] = dx*tr.m20 + dy*tr.m21 + dz*tr.m22;
+          lineDirections[index++] = dx*tr.m20 + dy*tr.m21 + dz*tr.m22;
+          lineDirections[index] *= scaleFactor;
         }
       }
     }
@@ -10801,6 +10844,7 @@ void applyMatrixOnPointGeometry(PMatrix3D tr, int first, int last) {
       if (first < last) {
         int index;
 
+        float matrixScale = matrixScale(tr);
         for (int i = first; i <= last; i++) {
           index = 4 * i;
           float x = pointVertices[index++];
@@ -10813,6 +10857,10 @@ void applyMatrixOnPointGeometry(PMatrix3D tr, int first, int last) {
           pointVertices[index++] = x*tr.m10 + y*tr.m11 + z*tr.m12 + w*tr.m13;
           pointVertices[index++] = x*tr.m20 + y*tr.m21 + z*tr.m22 + w*tr.m23;
           pointVertices[index  ] = x*tr.m30 + y*tr.m31 + z*tr.m32 + w*tr.m33;
+
+          index = 2 * i;
+          pointOffsets[index++] *= matrixScale;
+          pointOffsets[index] *= matrixScale;
         }
       }
     }
@@ -11954,28 +12002,7 @@ boolean noCapsJoins() {
 
     float transformScale() {
       if (-1 < transformScale) return transformScale;
-
-      // Volumetric scaling factor that is associated to the current
-      // transformation matrix, which is given by the absolute value of its
-      // determinant:
-      float factor = 1;
-
-      if (transform != null) {
-        if (transform instanceof PMatrix2D) {
-          PMatrix2D tr = (PMatrix2D)transform;
-          float areaScaleFactor = Math.abs(tr.m00 * tr.m11 - tr.m01 * tr.m10);
-          factor = (float) Math.sqrt(areaScaleFactor);
-        } else if (transform instanceof PMatrix3D) {
-          PMatrix3D tr = (PMatrix3D)transform;
-          float volumeScaleFactor =
-            Math.abs(tr.m00 * (tr.m11 * tr.m22 - tr.m12 * tr.m21) +
-                     tr.m01 * (tr.m12 * tr.m20 - tr.m10 * tr.m22) +
-                     tr.m02 * (tr.m10 * tr.m21 - tr.m11 * tr.m20));
-          factor = (float) Math.pow(volumeScaleFactor, 1.0f / 3.0f);
-        }
-      }
-
-      return transformScale = factor;
+      return transformScale = matrixScale(transform);
     }
 
     boolean segmentIsAxisAligned(int i0, int i1) {

core/src/processing/opengl/PShapeOpenGL.java

@@ -1459,6 +1459,7 @@ protected void applyMatrixImpl(PMatrix matrix) {
         tessGeo.applyMatrixOnPointGeometry(matrix,
                                            firstPointVertex, lastPointVertex);
         root.setModifiedPointVertices(firstPointVertex, lastPointVertex);
+        root.setModifiedPointAttributes(firstPointVertex, lastPointVertex);
       }
     }
   }

core/src/processing/opengl/shaders/LightVert.glsl

@@ -98,7 +98,7 @@ void main() {
     if (lightCount == i) break;
 
     vec3 lightPos = lightPosition[i].xyz;
-    bool isDir = zero_float < lightPosition[i].w;
+    bool isDir = lightPosition[i].w < one_float;
     float spotCos = lightSpot[i].x;
     float spotExp = lightSpot[i].y;
 

core/src/processing/opengl/shaders/TexLightVert.glsl

@@ -101,7 +101,7 @@ void main() {
     if (lightCount == i) break;
 
     vec3 lightPos = lightPosition[i].xyz;
-    bool isDir = zero_float < lightPosition[i].w;
+    bool isDir = lightPosition[i].w < one_float;
     float spotCos = lightSpot[i].x;
     float spotExp = lightSpot[i].y;