From d2f456cf5280f59425084532bd2397ec625f7577 Mon Sep 17 00:00:00 2001
From: Normand Briere <nbriere@noware.ca>
Date: Mon, 24 Jun 2019 22:53:37 -0400
Subject: [PATCH] More tools.

---
 CameraPane.java | 1056 ++++++++++++++++++++++++++++++++++++++++++++++-----------
 1 files changed, 844 insertions(+), 212 deletions(-)

diff --git a/CameraPane.java b/CameraPane.java
index fc57173..6966eee 100644
--- a/CameraPane.java
+++ b/CameraPane.java
@@ -37,7 +37,6 @@
     static boolean[] selectedstack = new boolean[65536];
     static int materialdepth = 0;
 
-    static boolean DEBUG = false;
     static boolean FRUSTUM = false; // still bogus true; // frustum culling
 
     // camera change fix
@@ -56,8 +55,6 @@
     static int CURRENTANTIALIAS = 0; // 1;
 	/*static*/ boolean RENDERSHADOW = true;
     /*static*/ int RENDERPROGRAM = 2; // 0 == none, 1 == fast, 2 == normal
-    static boolean ANIMATION = false;
-    static String filename;
     
     boolean DISPLAYTEXT = false;
     //boolean REDUCETEXTURE = true;
@@ -92,6 +89,8 @@
 
 static    int tickcount = 0; // slow pose issue
 
+static    boolean BUTTONLESSWHEEL = false;
+static    boolean ZOOMBOXMODE = false;
 static    boolean BOXMODE = false;
 static    boolean IMAGEFLIP = false;
 static    boolean SMOOTHFOCUS = false;
@@ -106,7 +105,7 @@
 static    boolean OEIL = true;
 static    boolean OEILONCE = false; // do oeilon then oeiloff
 static    boolean LOOKAT = true;
-static    boolean RANDOM = true; // false;
+static    boolean SWITCH = true; // false;
 static    boolean HANDLES = false; // selection doesn't work!!
 static  boolean PAINTMODE = false;
 
@@ -150,12 +149,12 @@
         defaultcaps.setAccumAlphaBits(16);
     }
     
-    static CameraPane theRenderer;
+    private File defaultDirectory = javax.swing.filechooser.FileSystemView.getFileSystemView().getDefaultDirectory();
     
     void SetAsGLRenderer(boolean b)
     {
         isRenderer = b;
-        theRenderer = this;
+        Globals.theRenderer = this;
     }
 
     CameraPane(Object3D o, Camera cam, boolean withcontext)
@@ -193,9 +192,43 @@
     
     /// INTERFACE
     
+    public javax.media.opengl.GL GetGL0()
+    {
+            return null;
+    }
+    
+    public int GenList()
+    {
+            javax.media.opengl.GL gl = GetGL();
+        return gl.glGenLists(1);
+    }
+    
+    public void NewList(int id)
+    {
+            javax.media.opengl.GL gl = GetGL();
+        gl.glNewList(id, gl.GL_COMPILE); //_AND_EXECUTE);
+    }
+    
+    public void CallList(int id)
+    {
+        javax.media.opengl.GL gl = GetGL();
+        gl.glCallList(id);
+    }
+    
+    public void EndList()
+    {
+            javax.media.opengl.GL gl = GetGL();
+        gl.glEndList();
+    }
+    
     public boolean IsBoxMode()
     {
             return BOXMODE;
+    }
+    
+    public boolean IsZoomBoxMode()
+    {
+            return ZOOMBOXMODE;
     }
     
     public void ClearDepth()
@@ -293,7 +326,7 @@
                 cStatic.objectstack[materialdepth++] = obj;
                 //System.out.println("material " + material);
                 //Applet3D.tracein(this, selected);
-                display.vector2buffer = obj.projectedVertices;
+                //display.vector2buffer = obj.projectedVertices;
                 if (obj instanceof Camera)
                 {
                     display.options1[0] = material.shift;
@@ -325,7 +358,7 @@
                 /**/
                 } else
                 {
-                    DrawMaterial(material, selected);
+                    DrawMaterial(material, selected, obj.projectedVertices);
                 }
             } else
             {
@@ -349,8 +382,8 @@
             cStatic.objectstack[materialdepth++] = obj;
             //System.out.println("material " + material);
             //Applet3D.tracein("selected ", selected);
-            display.vector2buffer = obj.projectedVertices;
-            display.DrawMaterial(material, selected);
+            //display.vector2buffer = obj.projectedVertices;
+            display.DrawMaterial(material, selected, obj.projectedVertices);
         }
     }
     
@@ -367,8 +400,8 @@
                 materialdepth -= 1;
                 if (materialdepth > 0)
                 {
-                    display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
-                    display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
+                    //display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
+                    display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1], cStatic.objectstack[materialdepth - 1].projectedVertices);
                 }
             //Applet3D.traceout("selected ", (stackdepth>0)?selectedstack[stackdepth-1]:"???");
             } else if (selected && CameraPane.flash && obj.GetMaterial() != null)
@@ -388,8 +421,8 @@
             materialdepth -= 1;
             if (materialdepth > 0)
             {
-                display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
-                display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
+                //display.vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
+                display.DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1], cStatic.objectstack[materialdepth - 1].projectedVertices);
             }
         //Applet3D.traceout("selected ", (stackdepth>0)?selectedstack[stackdepth-1]:"???");
         //else
@@ -430,10 +463,12 @@
         if (!selectmode) // display.drawMode != display.SELECTION) // && display.drawMode != display.SHADOW) // (attributes & FILL) != 0)
         {
             //gl.glBegin(gl.GL_TRIANGLES);
-            boolean hasnorm = pv.norm != null; // && (pv.norm.x != 0 || pv.norm.y != 0 || pv.norm.z != 0);
+            boolean hasnorm = pv.norm != null && (pv.norm.x != 0 || pv.norm.y != 0 || pv.norm.z != 0)
+                    // TEST LIVE NORMALS && !obj.dontselect
+                    ;
             if (!hasnorm)
             {
-           //     System.out.println("FUCK!!");
+           //     System.out.println("Mesh normal");
                 LA.vecSub(pv/*.pos*/, qv/*.pos*/, obj.v0);
                 LA.vecSub(pv/*.pos*/, rv/*.pos*/, obj.v1);
                 LA.vecCross(obj.v0, obj.v1, obj.v2);
@@ -816,7 +851,7 @@
 
                         if ((i % 100) == 0 && i != 0)
                         {
-                    CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
+                    Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
                             //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
                                 System.out.println((int) (100.0 * i / (br.positions.length / 3)) + "% (" + i + " of " + (br.positions.length / 3) + ")");
                         }
@@ -848,7 +883,7 @@
 
                         if ((i % 100) == 0 && i != 0)
                         {
-                    CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
+                    Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
                             //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
                                 System.out.println((int) (100.0 * i / br.VertexCount()) + "% (" + i + " of " + br.VertexCount() + ")");
                         }
@@ -1061,7 +1096,342 @@
         gl.glMatrixMode(gl.GL_MODELVIEW);
     }
     
+        public void DrawBox(cVector min, cVector max)
+        {
+            javax.media.opengl.GL gl = GetGL();
+                gl.glBegin(gl.GL_LINES);
+                
+                gl.glVertex3d(min.x, min.y, min.z);
+                gl.glVertex3d(min.x, min.y, max.z);
+                gl.glVertex3d(min.x, min.y, min.z);
+                gl.glVertex3d(min.x, max.y, min.z);
+                gl.glVertex3d(min.x, min.y, min.z);
+                gl.glVertex3d(max.x, min.y, min.z);
+                
+                gl.glVertex3d(max.x, max.y, max.z);
+                gl.glVertex3d(min.x, max.y, max.z);
+                gl.glVertex3d(max.x, max.y, max.z);
+                gl.glVertex3d(max.x, min.y, max.z);
+                gl.glVertex3d(max.x, max.y, max.z);
+                gl.glVertex3d(max.x, max.y, min.z);
+                
+                gl.glEnd();
+        }
+
+        public void DrawGeometry(BoundaryRep bRep, boolean flipV, boolean selectmode)
+        {
+            int[] strips = bRep.getRawIndices();
+            
+            javax.media.opengl.GL gl = GetGL();
+        
+                // TRIANGLE STRIP ARRAY
+                if (bRep.trimmed)
+                {
+                    float[] v = bRep.getRawVertices();
+                    float[] n = bRep.getRawNormals();
+                    float[] c = bRep.getRawColors();
+                    float[] uv = bRep.getRawUVMap();
+
+                    int count2 = 0;
+                    int count3 = 0;
+
+                    if (n.length > 0)
+                    {
+                        for (int i = 0; i < strips.length; i++)
+                        {
+                            gl.glBegin(gl.GL_TRIANGLE_STRIP);
+
+                            /*
+                    boolean locked = false;
+                    float eps = 0.1f;
+                    boolean wrap = CameraPane.UVWRAP; // true; // UV WRAP TEXTURE ISSUE: true = artifacts, false = nice
+
+                    int dot = 0;
+
+                    if ((dot&1) == 0)
+                        dot |= (Math.abs(qv.s - pv.s) < eps && Math.abs(qv.t - pv.t) < eps) ? 3 : 1;
+
+                    if (wrap || (dot&2) != 0) // Math.abs(qv.s - pv.s) < eps && Math.abs(qv.t - pv.t) < eps)
+                        gl.glTexCoord2f((float) qv.s, (float) qv.t);
+                    else
+                    {
+                        locked = true;
+                        gl.glTexCoord2f((float) pv.s, (float) pv.t);
+                    }
+                    //System.out.println("vertexq = " + qv.x + ", " + qv.y + ", " + qv.z);
+                    gl.glVertex3f((float) qv.x, (float) qv.y, (float) qv.z);
+                    if (hasnorm)
+                    {
+                        //System.out.println("normalr = " + rv.norm.x + ", " + rv.norm.y + ", " + rv.norm.z);
+                        gl.glNormal3f((float) rv.norm.x, (float) rv.norm.y, (float) rv.norm.z);
+                    }
+
+                    if ((dot&4) == 0)
+                        dot |= (Math.abs(rv.s - pv.s) < eps && Math.abs(rv.t - pv.t) < eps) ? 12 : 4;
+
+                    if (wrap || !locked && (dot&8) != 0)
+                        gl.glTexCoord2f((float) rv.s, (float) rv.t);
+                    else
+                        gl.glTexCoord2f((float) pv.s, (float) pv.t);
+
+                    f.dot = dot;
+                    */
+
+                            if (!selectmode)
+                            {
+                                if (n[count3] != 0 || n[count3 + 1] != 0 || n[count3 + 2] != 0)
+                                {
+                                    gl.glNormal3f(n[count3], n[count3 + 1], n[count3 + 2]);
+                                } else
+                                {
+                                    gl.glNormal3f(0, 0, 1);
+                                }
+
+                                if (c != null)
+                                //System.out.println("glcolor = " + c[count3] + ", " + c[count3+1] + ", " + c[count3+2]);
+                                {
+                                    gl.glColor4f(c[count3/3], c[count3/3 /* + 1*/], c[count3/3 /* + 2*/], 1);
+                                }
+                            }
+                            
+                            if (flipV)
+                                gl.glTexCoord2f(uv[count2], 1-uv[count2 + 1]);
+                            else
+                                gl.glTexCoord2f(uv[count2], uv[count2 + 1]);
+                            
+                            //System.out.println("vertex1 = " + v[count3] + ", " + v[count3+1] + ", " + v[count3+2]);
+                            gl.glVertex3f(v[count3], v[count3 + 1], v[count3 + 2]);
+
+                            count2 += 2;
+                            count3 += 3;
+                            if (!selectmode)
+                            {
+                                if (n[count3] != 0 || n[count3 + 1] != 0 || n[count3 + 2] != 0)
+                                {
+                                    gl.glNormal3f(n[count3], n[count3 + 1], n[count3 + 2]);
+                                } else
+                                {
+                                    gl.glNormal3f(0, 0, 1);
+                                }
+                                if (c != null)
+                                {
+                                    gl.glColor4f(c[count3/3], c[count3/3 /* + 1*/], c[count3/3 /* + 2*/], 1);
+                                }
+                            }
+                            
+                            if (flipV)
+                                gl.glTexCoord2f(uv[count2], 1-uv[count2 + 1]);
+                            else
+                                gl.glTexCoord2f(uv[count2], uv[count2 + 1]);
+                            
+                            //System.out.println("vertex2 = " + v[count3] + ", " + v[count3+1] + ", " + v[count3+2]);
+                            gl.glVertex3f(v[count3], v[count3 + 1], v[count3 + 2]);
+
+                            count2 += 2;
+                            count3 += 3;
+                            for (int j = 0; j < strips[i] - 2; j++)
+                            {
+                                //gl.glTexCoord2d(...);
+                                if (!selectmode)
+                                {
+                                    if (n[count3] != 0 || n[count3 + 1] != 0 || n[count3 + 2] != 0)
+                                    {
+                                        gl.glNormal3f(n[count3], n[count3 + 1], n[count3 + 2]);
+                                    } else
+                                    {
+                                        gl.glNormal3f(0, 0, 1);
+                                    }
+                                    if (c != null)
+                                    {
+                                        gl.glColor4f(c[count3/3], c[count3/3 /* + 1*/], c[count3/3 /* + 2*/], 1);
+                                    }
+                                }
+
+                                if (flipV)
+                                    gl.glTexCoord2f(uv[count2], 1-uv[count2 + 1]);
+                                else
+                                    gl.glTexCoord2f(uv[count2], uv[count2 + 1]);
+                                
+                                //System.out.println("coord3 = " + uv[count2] + ", " + uv[count2+1]);
+                                gl.glVertex3f(v[count3], v[count3 + 1], v[count3 + 2]);
+                                
+                                count2 += 2;
+                                count3 += 3;
+                            }
+
+                            gl.glEnd();
+                        }
+                    }
+
+                    assert count3 == v.length;
+                }
+                else // !trimmed
+                {
+                    int count = 0;
+                    for (int i = 0; i < strips.length; i++)
+                    {
+                        gl.glBegin(gl.GL_TRIANGLE_STRIP);
+                        
+                        Vertex p = bRep.GetVertex(bRep.indices[count++]);
+                        Vertex q = bRep.GetVertex(bRep.indices[count++]);
+                        
+                        drawVertex(gl, p, flipV, selectmode);
+                        drawVertex(gl, q, flipV, selectmode);
+                        
+                        for (int j = 0; j < strips[i] - 2; j++)
+                        {
+                            Vertex r = bRep.GetVertex(bRep.indices[count++]);
+
+    //                        if (j%2 == 0)
+    //                            drawFace(p, q, r, display, null);
+    //                        else
+    //                            drawFace(p, r, q, display, null);
+                            
+    //                        p = q;
+    //                        q = r;
+                            drawVertex(gl, r, flipV, selectmode);
+                        }
+
+                        gl.glEnd();
+                    }
+                }
+        }
+
+    static cSpring.Point3D temp = new cSpring.Point3D();
+    static cSpring.Point3D temp2 = new cSpring.Point3D();
+    static cSpring.Point3D temp3 = new cSpring.Point3D();
+    
+        public void DrawDynamicMesh(cMesh mesh)
+        {
+                GL gl = GetGL(); // getGL();
+
+                cSpring.PhysicsController3D Phys = mesh.Phys;
+                
+                gl.glDisable(gl.GL_LIGHTING);
+                
+                gl.glLineWidth(1);
+                gl.glColor3f(1,1,1);
+                gl.glBegin(gl.GL_LINES);
+                double scale = 0;
+                int count = 0;
+                for (int s=0; s<Phys.allSprings.size(); s++)
+                {
+                    cSpring.Spring spring = Phys.allSprings.get(s);
+                        if(s == 0)
+                        {
+                            //System.out.println(" spring : " + spring.a.position + "; " + spring.b.position);
+                        }
+                if (mesh.showsprings)
+                {
+                    temp.set(spring.a.position);
+                    temp.add(spring.b.position);
+                    temp.mul(0.5);
+                    temp2.set(spring.a.position);
+                    temp2.sub(spring.b.position);
+                    temp2.mul(spring.restLength/2);
+                    temp.sub(temp2);
+                    gl.glVertex3f((float)temp.x, (float)temp.y, (float)temp.z);
+                    temp.add(temp2);
+                    temp.add(temp2);
+                    gl.glVertex3f((float)temp.x, (float)temp.y, (float)temp.z);
+                }
+
+                    if (spring.isHandle)
+                        continue;
+                    
+                    //if (scale < spring.restLength)
+                        scale += spring.restLength;
+                        count++;
+                }
+                gl.glEnd();
+
+                if (count == 0)
+                    scale = 0.01;
+                else
+                    scale /= count * 3;
+                
+                //scale = 0.25;
+                
+                if (mesh.ShowInfo())
+                {
+                    gl.glLineWidth(4);
+                    for (int s=0; s<Phys.allNodes.size(); s++)
+                    {
+                        cSpring.DynamicNode node = Phys.allNodes.get(s);
+                        if (node.mass == 0)
+                            continue;
+                        
+                        int i = node.springs==null?-1:node.springs.size();
+                        gl.glColor3f((i>>2)&1,(i>>1)&1,i&1);
+                        //temp.set(node.springForce.x, node.springForce.y, node.springForce.z);
+                        //temp.normalize();
+                        //gl.glColor3d((temp.x+1)/2, (temp.y+1)/2, (temp.z+1)/2);
+                        gl.glBegin(gl.GL_LINES);
+                        gl.glVertex3d(node.position.x, node.position.y, node.position.z);
+                        //gl.glVertex3d(node.position.x + node.normal.x*scale, node.position.y + node.normal.y*scale, node.position.z + node.normal.z*scale);
+                        gl.glVertex3d(node.position.x + mesh.bRep.GetVertex(s).norm.x*scale,
+                                node.position.y + mesh.bRep.GetVertex(s).norm.y*scale,
+                                node.position.z + mesh.bRep.GetVertex(s).norm.z*scale);
+                        gl.glEnd();
+                    }
+
+                    gl.glLineWidth(8);
+                    for (int s=0; s<Phys.allNodes.size(); s++)
+                    {
+                        cSpring.DynamicNode node = Phys.allNodes.get(s);
+
+                        if (node.springs != null)
+                        {
+                            for (int i=0; i<node.springs.size(); i+=1)
+                            {
+                                cSpring.DynamicNode f = node.springs.get(i).GetOther(node);
+                                
+                                int c = i+1;
+                           //     c = node.springs.get(i).nbcopies;
+
+                                gl.glColor3f((c>>2)&1,(c>>1)&1,c&1);
+                                gl.glBegin(gl.GL_LINES);
+                                    gl.glVertex3d(node.position.x, node.position.y, node.position.z);
+                                    gl.glVertex3d(f.position.x/3+node.position.x*2/3, f.position.y/3+node.position.y*2/3, f.position.z/3+node.position.z*2/3);
+                                gl.glEnd();
+                            }
+                        }
+                    }
+
+                    gl.glLineWidth(1);
+                }
+                
+                gl.glEnable(gl.GL_LIGHTING);
+        }
+    
     /// INTERFACE
+    
+    public void StartTriangles()
+    {
+         javax.media.opengl.GL gl = GetGL();
+         gl.glBegin(gl.GL_TRIANGLES);
+    }
+    
+    public void EndTriangles()
+    {
+         GetGL().glEnd();
+    }
+    
+    void drawVertex(javax.media.opengl.GL gl, Vertex pv, boolean flipV, boolean selectmode)
+    {
+        if (!selectmode)
+        {
+            gl.glNormal3f((float) pv.norm.x, (float) pv.norm.y, (float) pv.norm.z);
+            gl.glColor4f(pv.AO, pv.AO, pv.AO, 1);
+            
+            if (flipV)
+                gl.glTexCoord2f((float) pv.s, 1-(float) pv.t);
+            else
+                gl.glTexCoord2f((float) pv.s, (float) pv.t);
+        }
+
+        gl.glVertex3f((float) pv.x, (float) pv.y, (float) pv.z);
+    }
     
     void SetColor(Object3D obj, Vertex p0)
     {
@@ -1240,7 +1610,7 @@
 //        gl.glMaterialfv(gl.GL_BACK, gl.GL_DIFFUSE, colorV, 0);
     }
     
-    void DrawMaterial(cMaterial material, boolean selected)
+    void DrawMaterial(cMaterial material, boolean selected, Object3D.cVector2[] others)
     {
             CameraPane display = this;
         //new Exception().printStackTrace();
@@ -1256,18 +1626,18 @@
         //col.getColorComponents(ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB), CameraPane.modelParams0);
         if (!material.multiply)
         {
-            display.color = color;
+            display.color = material.color;
             display.saturation = material.modulation;
         }
         else
         {
-            display.color *= color*2;
+            display.color *= material.color*2;
             display.saturation *= material.modulation*2;
         }
             
         cColor.HSBtoRGB(display.color, display.saturation, 1, display.modelParams0);
 
-        float[] colorV = GrafreeD.colorV;
+        float[] colorV = Grafreed.colorV;
 
         /**/
         if (display.DrawMode() == display.DEFAULT) // && display.RENDERPROGRAM == 0)
@@ -1275,7 +1645,7 @@
             colorV[0] = display.modelParams0[0] * material.diffuse;
             colorV[1] = display.modelParams0[1] * material.diffuse;
             colorV[2] = display.modelParams0[2] * material.diffuse;
-            colorV[3] = material.opacity;
+            colorV[3] = 1; // material.opacity;
 
             gl.glColor4f(colorV[0], colorV[1], colorV[2], material.opacity);
             //System.out.println("Opacity = " + opacity);
@@ -1383,9 +1753,9 @@
         display.modelParams7[2] = 0;
         display.modelParams7[3] = 0;
 
-        display.modelParams6[0] = 100; // criss de bug de bump
+        //display.modelParams6[0] = 100; // criss de bug de bump
         
-        Object3D.cVector2[] extparams = display.vector2buffer;
+        Object3D.cVector2[] extparams = others; // display.vector2buffer;
         if (extparams != null && extparams.length > 0 && extparams[0] != null)
         {
             display.modelParams6[0] = extparams[0].x / 1000.0f; // bump
@@ -1527,7 +1897,7 @@
     void PushMatrix(double[][] matrix)
     {
     //    GrafreeD.tracein(matrix);
-        PushMatrix(matrix,1);
+        PushMatrix(matrix, 1);
     }
     
     void PushMatrix()
@@ -1624,7 +1994,7 @@
     
     static int camerachangeframe;
     
-    boolean SetCamera(Camera cam)
+    public boolean SetCamera(Camera cam)
     {
         // may 2014 if (cam == cameras[0] || cam == cameras[1])
         //    return false;
@@ -1752,33 +2122,6 @@
         mainDL ^= true;
     }
 
-    void ToggleTexture()
-    {
-        textureon ^= true;
-    }
-
-    void ToggleLive()
-    {
-        Globals.setLIVE(Globals.isLIVE() ^ true);
-        
-        System.err.println("LIVE = " + Globals.isLIVE());
-        
-        if (!Globals.isLIVE()) // save sound
-            GrafreeD.savesound = true; // wav.save();
-     //   else
-            repaint(); // start loop // may 2013
-    }
-
-    void ToggleSupport()
-    {
-        SUPPORT ^= true;
-    }
-
-    void ToggleAbort()
-    {
-        ABORTMODE ^= true;
-    }
-
     void ToggleFullScreen()
     {
         FULLSCREEN ^= true;
@@ -1789,72 +2132,94 @@
         Globals.CROWD ^= true;
     }
 
-    void ToggleInertia()
-    {
-        INERTIA ^= true;
-    }
-
     void ToggleLocal()
     {
         LOCALTRANSFORM ^= true;
     }
 
-    void ToggleFast()
+    public void ToggleTexture()
+    {
+        textureon ^= true;
+    }
+
+    public void ToggleLive()
+    {
+        Globals.setLIVE(Globals.isLIVE() ^ true);
+        
+        System.err.println("LIVE = " + Globals.isLIVE());
+        
+        if (!Globals.isLIVE()) // save sound
+            Grafreed.savesound = true; // wav.save();
+     //   else
+            repaint(); // start loop // may 2013
+    }
+
+    public void ToggleSupport()
+    {
+        SUPPORT ^= true;
+    }
+
+    public void ToggleAbort()
+    {
+        ABORTMODE ^= true;
+    }
+
+    public void ToggleInertia()
+    {
+        INERTIA ^= true;
+    }
+
+    public void ToggleFast()
     {
         FAST ^= true;
     }
 
-    void ToggleSlowPose()
+    public void ToggleSlowPose()
     {
         SLOWPOSE ^= true;
     }
 
-    void ToggleFootContact()
-    {
-        FOOTCONTACT ^= true;
-    }
-    
-    void ToggleBoxMode()
+    public void ToggleBoxMode()
     {
         BOXMODE ^= true;
     }
 
-    void ToggleSmoothFocus()
+    public void ToggleZoomBoxMode()
+    {
+        ZOOMBOXMODE ^= true;
+    }
+
+    public void ToggleSmoothFocus()
     {
         SMOOTHFOCUS ^= true;
     }
 
-    void ToggleImageFlip()
+    public void ToggleImageFlip()
     {
         IMAGEFLIP ^= true;
     }
 
-    void ToggleSpeakerMocap()
+    public void ToggleSpeakerMocap()
     {
         SPEAKERMOCAP ^= true;
     }
 
-    void ToggleSpeakerCamera()
+    public void ToggleSpeakerCamera()
     {
         SPEAKERCAMERA ^= true;
     }
 
-    void ToggleSpeakerFocus()
+    public void ToggleSpeakerFocus()
     {
         SPEAKERFOCUS ^= true;
     }
 
-    void ToggleDebug()
-    {
-        DEBUG ^= true;
-    }
-
-    void ToggleFrustum()
+    public void ToggleFrustum()
     {
         FRUSTUM ^= true;
     }
 
-    void ToggleTrack()
+    public void ToggleTrack()
     {
         TRACK ^= true;
         if (TRACK)
@@ -1873,25 +2238,35 @@
         repaint();
     }
 
-    void ToggleTrackOnce()
+    public void ToggleTrackOnce()
     {
         TRACKONCE ^= true;
     }
 
-    void ToggleShadowTrack()
+    public void ToggleShadowTrack()
     {
         SHADOWTRACK ^= true;
         repaint();
     }
 
-    void ToggleOeil()
+    public void ToggleOeil()
     {
         OEIL ^= true;
     }
 
-    void ToggleOeilOnce()
+    public void ToggleOeilOnce()
     {
         OEILONCE ^= true;
+    }
+
+    void ToggleFootContact()
+    {
+        FOOTCONTACT ^= true;
+    }
+    
+    void ToggleDebug()
+    {
+        Globals.DEBUG ^= true;
     }
 
     void ToggleLookAt()
@@ -1899,9 +2274,9 @@
         LOOKAT ^= true;
     }
 
-    void ToggleRandom()
+    void ToggleSwitch()
     {
-        RANDOM ^= true;
+        SWITCH ^= true;
     }
 
     void ToggleHandles()
@@ -2008,7 +2383,7 @@
     {
         return currentGL;
     }
-    
+
     /**/
     class CacheTexture
     {
@@ -3840,6 +4215,7 @@
     
     com.sun.opengl.util.texture.Texture CompressTexture2(String name)
     {
+                new Exception().printStackTrace();
         System.exit(0);
         com.sun.opengl.util.texture.Texture texture = null;
 
@@ -7552,6 +7928,64 @@
         ReleaseTexture(pigment, false);
     }
     
+    public void ReleasePigmentTexture(cTexture tex) // INTERFACE
+    {
+        if (/*tex == null ||*/ ambientOcclusion ) // || !textureon)
+        {
+            return;
+        }
+
+        if (tex == null)
+        {
+            ReleaseTexture(null, false);
+            return;
+        }
+        
+        String pigment = Object3D.GetPigment(tex);
+
+        if (!tex.equals(":") && !tex.equals(DEFAULT_TEXTURES))
+        {
+        //    System.out.print("RELEASE  +++++++++++++++  pigment = " + pigment);
+        //    System.out.println("; bump = " + bump);
+        }
+        
+        if (pigment.equals(""))
+        {
+            pigment = null;
+        }
+        
+        ReleaseTexture(pigment, false);
+    }
+    
+    public void ReleaseBumpTexture(cTexture tex) // INTERFACE
+    {
+        if (/*tex == null ||*/ ambientOcclusion ) // || !textureon)
+        {
+            return;
+        }
+
+        if (tex == null)
+        {
+            ReleaseTexture(null, true);
+            return;
+        }
+        
+        String bump = Object3D.GetBump(tex);
+
+        if (!tex.equals(":") && !tex.equals(DEFAULT_TEXTURES))
+        {
+        //    System.out.print("RELEASE  +++++++++++++++  pigment = " + pigment);
+        //    System.out.println("; bump = " + bump);
+        }
+        
+        if (bump.equals(""))
+        {
+            bump = null;
+        }
+        
+        ReleaseTexture(bump, true);
+    }
+    
     void ReleaseTexture(String tex, boolean bump)
     {
         if (// DrawMode() != 0 || /*tex == null ||*/
@@ -7655,7 +8089,7 @@
         }
     }
 
-    /*boolean*/ public void BindTextures(cTexture tex, int resolution) // INTERFACE
+    /*boolean*/ public void BindTextures(cTexture tex, int resolution) throws Exception // INTERFACE
     {
         if (// DrawMode() != 0 || /*tex == null ||*/
                 ambientOcclusion ) // || !textureon)
@@ -7700,7 +8134,94 @@
         return; // true;
     }
     
-    CacheTexture GetCacheTexture(String tex, boolean bump, int resolution)
+    /*boolean*/ public void BindPigmentTexture(cTexture tex, int resolution) throws Exception // INTERFACE
+    {
+        if (// DrawMode() != 0 || /*tex == null ||*/
+                ambientOcclusion ) // || !textureon)
+        {
+            return; // false;
+        }
+
+        if (tex == null)
+        {
+            BindTexture(null,false,resolution);
+            return;
+        }
+        
+        String pigment = Object3D.GetPigment(tex);
+
+        usedtextures.put(pigment, pigment);
+        
+        if (!tex.equals(":") && !tex.equals(DEFAULT_TEXTURES))
+        {
+        //    System.out.print("BIND  +++++++++++++++  pigment = " + pigment);
+        //    System.out.println("; bump = " + bump);
+        }
+        
+        if (pigment.equals(""))
+        {
+            pigment = null;
+        }
+        
+        GetGL().glActiveTexture(GetGL().GL_TEXTURE0);
+        BindTexture(pigment, false, resolution);
+    }
+    
+    /*boolean*/ public void BindBumpTexture(cTexture tex, int resolution) throws Exception // INTERFACE
+    {
+        if (// DrawMode() != 0 || /*tex == null ||*/
+                ambientOcclusion ) // || !textureon)
+        {
+            return; // false;
+        }
+
+        if (tex == null)
+        {
+            BindTexture(null,true,resolution);
+            return;
+        }
+        
+        String bump = Object3D.GetBump(tex);
+
+        usedtextures.put(bump, bump);
+        
+        if (!tex.equals(":") && !tex.equals(DEFAULT_TEXTURES))
+        {
+        //    System.out.print("BIND  +++++++++++++++  pigment = " + pigment);
+        //    System.out.println("; bump = " + bump);
+        }
+        
+        if (bump.equals(""))
+        {
+            bump = null;
+        }
+        
+        GetGL().glActiveTexture(GetGL().GL_TEXTURE2);
+        BindTexture(bump, true, resolution);
+        GetGL().glActiveTexture(GetGL().GL_TEXTURE0);
+    }
+    
+    java.util.HashSet<String> missingTextures = new java.util.HashSet<String>();
+    
+    private boolean FileExists(String tex)
+    {
+        if (missingTextures.contains(tex))
+        {
+            return false;
+        }
+        
+        boolean fileExists = new File(tex).exists();
+        
+        if (!fileExists)
+        {
+            // If file exists, the "new File()" is not executed sgain
+            missingTextures.add(tex);
+        }
+        
+        return fileExists;
+    }
+    
+    CacheTexture GetCacheTexture(String tex, boolean bump, int resolution) throws Exception
     {
         CacheTexture/*com.sun.opengl.util.texture.Texture*/ texture = null;
         
@@ -7708,12 +8229,18 @@
         {
             String texname = tex;
             
-            String[] split = tex.split("Textures");
-            if (split.length > 1)
-                texname = "/Users/nbriere/Textures" + split[split.length-1];
-            else
-                if (!texname.startsWith("/"))
-                    texname = "/Users/nbriere/Textures/" + texname;
+            String fallbackTextureName = defaultDirectory + "/Textures/" + texname;
+                
+//            String[] split = tex.split("Textures");
+//            if (split.length > 1)
+//                texname = "/Users/nbriere/Textures" + split[split.length-1];
+//            else
+//                if (!texname.startsWith("/"))
+//                    texname = "/Users/nbriere/Textures/" + texname;
+            if (!FileExists(tex))
+            {
+                    texname = fallbackTextureName;
+            }
             
             if (CACHETEXTURE)
                 texture = textures.get(texname); // TEXTURE CACHE
@@ -7782,7 +8309,7 @@
                                     }
                                 
                                     cachename = texname.substring(0, texname.length()-4)+ext+".jpg";
-                                    if (!new File(cachename).exists())
+                                    if (!FileExists(cachename))
                                         cachename = texname;
                                     else
                                         processbump = false; // don't process bump map again
@@ -7804,7 +8331,7 @@
                                     }
                                 
                                     cachename = texname.substring(0, texname.length()-4)+ext+".png";
-                                    if (!new File(cachename).exists())
+                                    if (!FileExists(cachename))
                                         cachename = texname;
                                     else
                                         processbump = false; // don't process bump map again
@@ -7813,7 +8340,9 @@
                                 texturedata = GetFileTexture(cachename, processbump, resolution);                                
                                 
                                 
-                                if (texturedata != null)
+                                if (texturedata == null)
+                                    throw new Exception();
+                                    
                                     texture = new CacheTexture(com.sun.opengl.util.texture.TextureIO.newTexture(texturedata),resolution);
         //texture = GetTexture(tex, bump);
                             }
@@ -7935,7 +8464,7 @@
         return texture;
     }
     
-    com.sun.opengl.util.texture.Texture GetTexture(String tex, boolean bump, int resolution)
+    com.sun.opengl.util.texture.Texture GetTexture(String tex, boolean bump, int resolution) throws Exception
     {
         CacheTexture texture = GetCacheTexture(tex, bump, resolution);
                 
@@ -7953,14 +8482,14 @@
         return texture!=null?texture.texture:null;
     }
     
-    com.sun.opengl.util.texture.TextureData GetTextureData(String tex, boolean bump, int resolution)
+    public com.sun.opengl.util.texture.TextureData GetTextureData(String tex, boolean bump, int resolution) throws Exception
     {
         CacheTexture texture = GetCacheTexture(tex, bump, resolution);
                 
         return texture!=null?texture.texturedata:null;
     }
     
-    boolean BindTexture(String tex, boolean bump, int resolution)
+    boolean BindTexture(String tex, boolean bump, int resolution) throws Exception
     {
         if (/*tex == null ||*/ ambientOcclusion ) // || !textureon)
         {
@@ -8937,8 +9466,8 @@
         assert (parentcam != renderCamera);
         
         if (renderCamera != lightCamera)
-        for (int count = parentcam.GetTransformCount(); --count>=0;)
-            LA.matConcat(matrix, parentcam.toParent, matrix);
+        //for (int count = parentcam.GetTransformCount(); --count>=0;)
+            LA.matConcat(matrix, parentcam.GlobalTransform(), matrix);
         
 //            LA.matConcat(renderCamera.toScreen, renderCamera.toParent, matrix);
             
@@ -8953,8 +9482,8 @@
             LA.matCopy(renderCamera.fromScreen, matrix);
             
         if (renderCamera != lightCamera)
-        for (int count = parentcam.GetTransformCount(); --count>=0;)
-            LA.matConcat(parentcam.fromParent, matrix, matrix);
+        //for (int count = parentcam.GetTransformCount(); --count>=0;)
+            LA.matConcat(parentcam.GlobalTransformInv(), matrix, matrix);
 
 //            LA.matConcat(renderCamera.fromParent, renderCamera.fromScreen, matrix);
             
@@ -9026,7 +9555,7 @@
             //gl.glFlush();
             gl.glAccum(gl.GL_ACCUM, 1.0f / ACSIZE);
 
-            if (ANIMATION && ABORTED)
+            if (Globals.ANIMATION && ABORTED)
             {
     System.err.println("    ABORTED FRAME");
                 break;
@@ -9056,7 +9585,7 @@
         setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
 
         // save image
-        if (ANIMATION && !ABORTED)
+        if (Globals.ANIMATION && !ABORTED)
         {
             VPwidth = viewport[2];
             VPheight = viewport[3];
@@ -9167,11 +9696,11 @@
             
 //            imagecount++;
             
-            String fullname = filename + (i%100000)/10000 + "" + (i%10000)/1000 + "" + (i%1000)/100 + "" + (i%100)/10 + "" + (i%10) + "." + ext;
+            String fullname = Globals.filename + (i%100000)/10000 + "" + (i%10000)/1000 + "" + (i%1000)/100 + "" + (i%100)/10 + "" + (i%10) + "." + ext;
             
             if (!BOXMODE)
             {
-                System.out.println("image: " + fullname + " (wav cursor=" + (GrafreeD.wav.cursor / 735 / 4) + ")");
+                System.out.println("image: " + fullname + " (wav cursor=" + (Grafreed.wav.cursor / 735 / 4) + ")");
             }
     
             if (!BOXMODE)
@@ -9209,7 +9738,7 @@
             ABORTED = false;
         }
         else
-            GrafreeD.wav.cursor += 735 * ACSIZE;
+            Grafreed.wav.cursor += 735 * ACSIZE;
         
         if (false)
         {
@@ -9872,11 +10401,11 @@
 
     public void display(GLAutoDrawable drawable)
     {
-        if (GrafreeD.savesound && GrafreeD.hassound)
+        if (Grafreed.savesound && Grafreed.hassound)
         {
-            GrafreeD.wav.save();
-            GrafreeD.savesound = false;
-            GrafreeD.hassound = false;
+            Grafreed.wav.save();
+            Grafreed.savesound = false;
+            Grafreed.hassound = false;
         }
 //        if (DEBUG_SELECTION)
 //        {
@@ -9952,6 +10481,7 @@
                     ANTIALIAS = 0;
                     //System.out.println("RESTART");
                     AAtimer.restart();
+                    Globals.TIMERRUNNING = true;
                 }
             }
         }
@@ -10006,7 +10536,7 @@
             Object3D theobject = object;
             Object3D theparent = object.parent;
             object.parent = null;
-            object = (Object3D)GrafreeD.clone(object);
+            object = (Object3D)Grafreed.clone(object);
             object.Stripify();
             if (theobject.selection == null || theobject.selection.Size() == 0)
                 theobject.PreprocessOcclusion(this);
@@ -10019,13 +10549,14 @@
             ambientOcclusion = false;
         }
 
-        if (Globals.lighttouched && DrawMode() == DEFAULT && !lightMode) // && !FROZEN)
+        if (//Globals.lighttouched &&
+                DrawMode() == DEFAULT) // && !lightMode) // && !FROZEN)
         {
             //if (RENDERSHADOW) // ?
             if (!IsFrozen())
             {
                 // dec 2012
-                if (!ambientOcclusion && !(!flash && !lightMode && DrawMode() == DEFAULT && ANTIALIAS > 0))
+                if (!ambientOcclusion && !(!flash && DrawMode() == DEFAULT && ANTIALIAS > 0))
                 {
             Globals.framecount++;
                     shadowbuffer.display();
@@ -10152,8 +10683,8 @@
             
 //        if (parentcam != renderCamera) // not a light
         if (cam != lightCamera)
-            for (int count = parentcam.GetTransformCount(); --count>=0;)
-                LA.matConcat(matrix, parentcam.toParent, matrix);
+            //for (int count = parentcam.GetTransformCount(); --count>=0;)
+                LA.matConcat(matrix, parentcam.GlobalTransform(), matrix);
             
             for (int j = 0; j < 4; j++)
             {
@@ -10167,8 +10698,8 @@
             
 //        if (parentcam != renderCamera) // not a light
         if (cam != lightCamera)
-            for (int count = parentcam.GetTransformCount(); --count>=0;)
-                LA.matConcat(parentcam.fromParent, matrix, matrix);
+            //for (int count = parentcam.GetTransformCount(); --count>=0;)
+                LA.matConcat(parentcam.GlobalTransformInv(), matrix, matrix);
         
             //LA.matConcat(cam.fromScreen, parentcam.fromParent, matrix);
             
@@ -10427,7 +10958,16 @@
             // Bump noise
             gl.glActiveTexture(GL.GL_TEXTURE6);
             //gl.glBindTexture(GL.GL_TEXTURE_2D, bump_noise);
-            BindTexture(NOISE_TEXTURE, false, 2);
+            
+    try
+    {
+        BindTexture(NOISE_TEXTURE, false, 2);
+    }
+    catch (Exception e)
+    {
+        System.err.println("FAILED: " + NOISE_TEXTURE);
+    }
+           
 
             gl.glActiveTexture(GL.GL_TEXTURE0);
             gl.glEnable(GL.GL_TEXTURE_2D);
@@ -10552,8 +11092,8 @@
                 System.err.println("parentcam != renderCamera");
 
 //            if (cam != lightCamera)
-            for (int count = parentcam.GetTransformCount(); --count>=0;)
-                LA.xformDir(lightposition, parentcam.toParent, lightposition); // may 2013
+            //for (int count = parentcam.GetTransformCount(); --count>=0;)
+                LA.xformDir(lightposition, parentcam.GlobalTransform(), lightposition); // may 2013
         }
         
         LA.xformDir(lightposition, cam.toScreen, lightposition);
@@ -10574,8 +11114,8 @@
             if (true) // TODO
             {
                 if (cam != lightCamera)
-                for (int count = parentcam.GetTransformCount(); --count>=0;)
-                   LA.xformDir(light0, parentcam.toParent, light0); // may 2013
+                //for (int count = parentcam.GetTransformCount(); --count>=0;)
+                   LA.xformDir(light0, parentcam.GlobalTransform(), light0); // may 2013
             }
             
             LA.xformPos(light0, cam.toScreen, light0);
@@ -10891,8 +11431,14 @@
     {
             renderpass++;
 //        System.out.println("Draw object... ");
+        STEP = 1;
         if (FAST) // in case there is no script
-            STEP = 16;
+            STEP = 8;
+            
+        if (CURRENTANTIALIAS == 0 || ACSIZE == 1)
+        {
+            STEP *= 4;
+        }
             
         //object.FullInvariants();
         
@@ -10906,13 +11452,31 @@
             e.printStackTrace();
         }
         
-        if (GrafreeD.RENDERME > 0)
-            GrafreeD.RENDERME--; // mechante magouille
+        if (Grafreed.RENDERME > 0)
+            Grafreed.RENDERME--; // mechante magouille
         
         Globals.ONESTEP = false;
     }
 
     static boolean zoomonce = false;
+    
+    static void CreateSelectedPoint()
+    {
+        if (selectedpoint == null)
+        {
+            debugpointG = new Sphere();
+            debugpointP = new Sphere();
+            debugpointC = new Sphere();
+            debugpointR = new Sphere();
+            
+            selectedpoint = new Superellipsoid();
+            
+            for (int i=0; i<8; i++)
+            {
+                debugpoints[i] = new Sphere();
+            }
+        }
+    }
     
     void DrawObject(GL gl, boolean draw)
     {
@@ -10977,7 +11541,14 @@
 
                 usedtextures.clear();
             
-                BindTextures(DEFAULT_TEXTURES, 2);
+    try
+    {
+        BindTextures(DEFAULT_TEXTURES, 2);
+    }
+    catch (Exception e)
+    {
+        System.err.println("FAILED: " + DEFAULT_TEXTURES);
+    }
             }
             //System.out.println("--> " + stackdepth);
 //            GrafreeD.traceon();
@@ -10987,8 +11558,9 @@
             
             if (DrawMode() == DEFAULT)
             {
-                if (DEBUG)
+                if (Globals.DEBUG)
                 {
+                    CreateSelectedPoint();
                     float radius = 0.05f;
                     if (selectedpoint.radius != radius)
                     {
@@ -11068,7 +11640,14 @@
             if (checker != null && DrawMode() == DEFAULT)
             {
                 //BindTexture(IMMORTAL_TEXTURE);
-                BindTextures(checker.GetTextures(), checker.texres);
+    try
+    {
+        BindTextures(checker.GetTextures(), checker.texres);
+    }
+    catch (Exception e)
+    {
+        System.err.println("FAILED: " + checker.GetTextures());
+    }
                 // NEAREST
                 GetGL().glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); // GL.GL_LINEAR);
                 DrawChecker(gl);
@@ -11150,7 +11729,7 @@
             return;
         }
 
-        String string = obj.GetToolTip();
+        String string = obj.toString(); //.GetToolTip();
         
         GL gl = GetGL();
         
@@ -11467,8 +12046,8 @@
             //obj.TransformToWorld(light, light);
             for (int i = tp.size(); --i >= 0;)
             {
-                for (int count = tp.get(i).GetTransformCount(); --count>=0;)
-                    LA.xformPos(light, tp.get(i).toParent, light);
+                //for (int count = tp.get(i).GetTransformCount(); --count>=0;)
+                    LA.xformPos(light, tp.get(i).GlobalTransform(), light);
             }
 
 
@@ -11485,8 +12064,8 @@
                 parentcam = cameras[0];
             }
             
-        for (int count = parentcam.GetTransformCount(); --count>=0;)
-            LA.xformPos(light, parentcam.toParent, light); // may 2013
+        //for (int count = parentcam.GetTransformCount(); --count>=0;)
+            LA.xformPos(light, parentcam.GlobalTransform(), light); // may 2013
 
             LA.xformPos(light, renderCamera.toScreen, light);
             
@@ -12100,8 +12679,8 @@
 
            // display shadow only (bump == 0)
          "SUB temp.x, half.x, shadow.x;" +
-         "MOV temp.y, -params6.x;" +
-         "SLT temp.z, temp.y, zero.x;" +
+         "MOV temp.y, -params5.z;" + // params6.x;" +
+         "SLT temp.z, temp.y, -one2048th.x;" +
          "SUB temp.y, one.x, temp.z;" +
          "MUL temp.x, temp.x, temp.y;" +
          "KIL temp.x;" +
@@ -12230,8 +12809,10 @@
             "MAX ndotl.x, ndotl.x, -ndotl.x;" +
                 
                 "SUB temp.x, one.x, ndotl.x;" +
-                "ADD temp.x, temp.x, options2.z;" + // lightsheen
-                "ADD temp.y, one.y, options2.y;" + // sursurface
+                // Tuning for default skin
+                //"ADD temp.x, temp.x, options2.z;" + // lightsheen
+                "MAD temp.x, options2.z, half.y, temp.x;" + // lightsheen
+                "ADD temp.y, one.y, options2.y;" + // subsurface
                 "MUL temp.x, temp.x, temp.y;" +
                                 
                 "MUL saturation, saturation, temp.xxxx;" +
@@ -12430,7 +13011,7 @@
             //once = true;
         }
 
-        System.out.print("Program #" + mode + "; length = " + program.length());
+        System.out.print("Program #" + mode + "; instructions = " + program.split(";").length + "; length = " + program.length());
         System.out.println(" - " + (mode >> 3) + " lights; " + ((mode & 2) == 2 ? "anisoUV " : "") + ((mode & 4) == 4 ? "SoftShadow " : ""));
         loadProgram(gl, GL.GL_FRAGMENT_PROGRAM_ARB, program);
 
@@ -12563,12 +13144,16 @@
 
                 "ADD " + depth + ".z, " + depth + ".z, temp.x;" +
                 //"SUB " + depth + ".z, " + depth + ".z, temp.x;" + // back face shadowing!
+                
+                // Compare fragment depth in light space with shadowmap.
                 "SUB temp.x, fragment.texcoord[1].z, " + depth + ".z;" +
                 "SGE temp.y, temp.x, zero.x;" +
-                "SUB " + shadow + ".y, one.x, temp.y;" +
+                "SUB " + shadow + ".y, one.x, temp.y;" + // Specular is fully occluded
+                
+                // Reverse comparison
                 "SUB temp.x, one.x, temp.x;" +
                 "MUL " + shadow + ".x, temp.x, temp.y;" +
-                "SUB " + shadow + ".x, one.x, " + shadow + ".x;" + // specular is fully occluded
+                "SUB " + shadow + ".x, one.x, " + shadow + ".x;" + // diffuse
                 "POW " + shadow + ".x, " + shadow + ".x, params5.z;" + // fake depth
 
                 "SLT " + shadow + ".z, fragment.texcoord[1].z, " + depth + ".z;" +
@@ -12582,6 +13167,10 @@
                 // No shadow for backface
                 "DP3 temp.x, normal, lightd;" +
                 "SLT temp.x, temp.x, zero.x;" + // shadoweps
+                "LRP " + shadow + ", temp.x, one, " + shadow + ";" +
+
+                // No shadow when out of frustrum
+                "SGE temp.x, " + depth + ".z, one.z;" +
                 "LRP " + shadow + ", temp.x, one, " + shadow + ";" +
                 "";
     }
@@ -12728,7 +13317,8 @@
     /*static*/ float[] modelParams5 = new float[]{0, 0, 0, 0}; // texture, opacity, fakedepth, shadowbias
     /*static*/ float[] modelParams6 = new float[]{0, 0, 0, 0}; // bump, noise, borderfade, fog punchthrough
     /*static*/ float[] modelParams7 = new float[]{0, 0, 0, 0}; // noise power, opacity power
-    Object3D.cVector2[] vector2buffer;
+    
+    //Object3D.cVector2[] vector2buffer;
 
     // IN : ndotl, ndoth, xxx, NdotL //, snininess, lightarea
     // OUT : diff, spec
@@ -13140,7 +13730,7 @@
     public void mousePressed(MouseEvent e)
     {
         //System.out.println("mousePressed: " + e);
-        clickStart(e.getX(), e.getY(), e.getModifiersEx());
+        clickStart(e.getX(), e.getY(), e.getModifiers(), e.getModifiersEx());
     }
 
     static long prevtime = 0;
@@ -13167,6 +13757,7 @@
 	
         //System.err.println("Dtime = " + Dtime + "; units = " + e.getUnitsToScroll() + "; ratio (units/ms) = " + ratio);
             
+        if (BUTTONLESSWHEEL)
 	if (Math.abs(ratio) < 0.1 || Math.abs(Dtime) == 0) // < 30)
 	{
             return;
@@ -13175,7 +13766,7 @@
         boolean capsLocked = Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
         
         // TIMER
-        if (!wheeltimer.isRunning() && e.getModifiersEx() == 0 && !capsLocked) // VR
+        if (ZOOMBOXMODE && !wheeltimer.isRunning() && e.getModifiersEx() == 0 && !capsLocked) // VR
         {
             keepboxmode = BOXMODE;
             keepsupport = SUPPORT;
@@ -13215,8 +13806,8 @@
       //      mode |= META;
         //}
         
-        SetMouseMode(WHEEL | e.getModifiersEx());
-        drag(anchorX, anchorY + e.getUnitsToScroll()*8, 0);
+        SetMouseMode(e.getModifiers(), WHEEL | e.getModifiersEx());
+        drag(anchorX, anchorY + e.getUnitsToScroll()*8, 0, 0);
         anchorX = ax;
         anchorY = ay;
         prevX = px;
@@ -13250,6 +13841,7 @@
         else
         if (evt.getSource() == AAtimer)
         {
+                    Globals.TIMERRUNNING = false;
             if (mouseDown)
             {
             //new Exception().printStackTrace();
@@ -13275,6 +13867,10 @@
 //            LIVE = waslive;
 //            wasliveok = true;
 //            waslive = false;
+            
+            // May 2019 Forget it:
+            if (true)
+                    return;
             
             // source == timer
             if (mouseDown)
@@ -13314,12 +13910,13 @@
     
     javax.swing.Timer timer = new javax.swing.Timer(350, this);
 
-    void clickStart(int x, int y, int modifiers)
+    void clickStart(int x, int y, int modifiers, int modifiersex)
     {
         if (!wasliveok)
             return;
         
         AAtimer.restart(); // 
+        Globals.TIMERRUNNING = true;
 
 //        waslive = LIVE;
 //        LIVE = false;
@@ -13331,7 +13928,7 @@
 //        touched = true; // main DL
         if (isRenderer)
         {
-            SetMouseMode(modifiers);
+            SetMouseMode(modifiers, modifiersex);
         }
 
         selectX = anchorX = x;
@@ -13344,7 +13941,7 @@
         clicked = true;
         hold = false;
 
-        if (((modifiers & ~1024) & ~0) == 0) // Single or multiple selection
+        if (((modifiersex & ~1024) & ~0) == 0) // Single or multiple selection
         // june 2013 means CTRL_CLICK: if (((modifiers & ~1024) & ~128) == 0) // Single or multiple selection
         {
       //  System.out.println("RESTART II " + modifiers);
@@ -13375,7 +13972,7 @@
             info.camera = renderCamera;
             info.x = x;
             info.y = y;
-            info.modifiers = modifiers;
+            info.modifiers = modifiersex;
             editObj = object.doEditClick(info, 0);
             if (!editObj)
             {
@@ -13392,11 +13989,14 @@
     
     public void mouseDragged(MouseEvent e)
     {
+        Globals.MOUSEDRAGGED = true;
+        
+        //System.out.println("mouseDragged: " + e);
         if (isRenderer)
             movingcamera = true;
+        
         //if (drawing)
         //return;
-        //System.out.println("mouseDragged: " + e);
         if ((e.getModifiersEx() & CTRL) != 0
             || (e.getModifiersEx() & COMMAND) != 0) // || IsFrozen())
         {
@@ -13404,7 +14004,7 @@
             clickEnd(e.getX(), e.getY(), e.getModifiersEx());
         }
         else
-            drag(e.getX(), e.getY(), e.getModifiersEx());
+            drag(e.getX(), e.getY(), e.getModifiers(), e.getModifiersEx());
         
     //try { Thread.sleep(1); } catch (Exception ex) {}
     }
@@ -13577,6 +14177,7 @@
         
         public void run()
         {
+                new Exception().printStackTrace();
             System.exit(0);
             for (;;)
             {
@@ -13640,7 +14241,7 @@
                     {
                         Globals.lighttouched = true;
                     }
-                    drag(X, (mouseMode != 0) ? Y : anchorY, MODIFIERS);
+                    drag(X, (mouseMode != 0) ? Y : anchorY, 0, MODIFIERS);
                 }
             //else
             }
@@ -13740,7 +14341,7 @@
     int X, Y;
     boolean SX, SY;
 
-    void drag(int x, int y, int modifiers)
+    void drag(int x, int y, int modifiers, int modifiersex)
     {
         if (IsFrozen())
         {
@@ -13749,17 +14350,17 @@
 
         drag = true; // NEW
         
-        boolean continuous = (modifiers & COMMAND) == COMMAND;
+        boolean continuous = (modifiersex & COMMAND) == COMMAND;
 
         X = x;
         Y = y;
         // floating state for animation
-        MODIFIERS = modifiers;
-        modifiers &= ~1024;
+        MODIFIERS = modifiersex;
+        modifiersex &= ~1024;
         if (false) // modifiers != 0)
         {
             //new Exception().printStackTrace();
-            System.out.println("mouseDragged: " + modifiers);
+            System.out.println("mouseDragged: " + modifiersex);
             System.out.println("SHIFT = " + SHIFT);
             System.out.println("CONTROL = " + COMMAND);
             System.out.println("META = " + META);
@@ -13779,7 +14380,8 @@
                 info.camera = renderCamera;
                 info.x = x;
                 info.y = y;
-                object.editWindow.copy.doEditDrag(info);
+                object.GetWindow().copy
+                        .doEditDrag(info, (modifiers & MouseEvent.BUTTON3_MASK) != 0);
             } else
             {
                 if (x < startX)
@@ -13931,7 +14533,6 @@
     public void mouseMoved(MouseEvent e)
     {
         //System.out.println("mouseMoved: " + e);
-
         if (isRenderer)
             return;
         
@@ -13944,7 +14545,9 @@
         ci.camera = renderCamera;
         if (!isRenderer)
         {
-            if (object.editWindow.copy.doEditClick(ci, 0))
+            //ObjEditor editWindow = object.editWindow;
+            //Object3D copy = editWindow.copy;
+            if (object.doEditClick(ci, 0))
             {
                 setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
             } else
@@ -13956,7 +14559,10 @@
 
     public void mouseReleased(MouseEvent e)
     {
+        Globals.MOUSEDRAGGED = false;
+        
         movingcamera = false;
+        X = Y = 0;
         //System.out.println("mouseReleased: " + e);
         clickEnd(e.getX(), e.getY(), e.getModifiersEx());
     }
@@ -13979,9 +14585,9 @@
         boolean control = ((modifiers & CTRL) != 0); // june 2013: for point selection
         boolean command = ((modifiers & COMMAND) != 0); // june 2013: for multiple selection
         
-        if (control || command || IsFrozen())
+// No delay        if (control || command || IsFrozen())
             timeout = true;
-        else
+// ?? May 2019        else
        // timer.setDelay((modifiers & 128) != 0?0:350);
         mouseDown = false;
     if (!control && !command) // june 2013
@@ -14091,7 +14697,7 @@
         System.out.println("keyReleased: " + e);
     }
 
-    void SetMouseMode(int modifiers)
+    void SetMouseMode(int modifiers, int modifiersex)
     {
         //System.out.println("SetMouseMode = " + modifiers);
         //modifiers &= ~1024;
@@ -14103,25 +14709,25 @@
         //if (modifiers == 0) // || (modifiers == (1024 | CONTROL)))
         //	return;
         //System.out.println("SetMode = " + modifiers);
-        if ((modifiers & WHEEL) == WHEEL)
+        if ((modifiersex & WHEEL) == WHEEL)
         {
             mouseMode |= ZOOM;
         }
         
         boolean capsLocked = Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
-        if (capsLocked || (modifiers & META) == META)
+        if (capsLocked) // || (modifiers & META) == META)
         {
             mouseMode |= VR; // BACKFORTH;
         }
-        if ((modifiers & CTRLCLICK) == CTRLCLICK)
+        if ((modifiersex & CTRLCLICK) == CTRLCLICK)
         {
             mouseMode |= SELECT;
         }
-        if ((modifiers & COMMAND) == COMMAND)
+        if ((modifiersex & COMMAND) == COMMAND)
         {
             mouseMode |= SELECT;
         }
-        if ((modifiers & SHIFT) == SHIFT || forcetranslate)
+        if ((modifiersex & SHIFT) == SHIFT || forcetranslate || (modifiers & MouseEvent.BUTTON3_MASK) != 0)
         {
             mouseMode &= ~VR;
             mouseMode |= TRANSLATE;
@@ -14150,10 +14756,10 @@
 
         if (isRenderer) //
         {
-            SetMouseMode(modifiers);
+            SetMouseMode(0, modifiers);
         }
 
-        theRenderer.keyPressed(key);
+        Globals.theRenderer.keyPressed(key);
     }
 
     int kompactbit = 4; // power bit
@@ -14165,7 +14771,7 @@
     float SATPOW = 1; // 2; // 0.5f;
     float BRIPOW = 1; // 0.5f; // 0.5f;
     
-    void keyPressed(int key)
+    public void keyPressed(int key)
     {
         if (key >= '0' && key <= '5')
             clampbit = (key-'0');
@@ -14322,8 +14928,14 @@
                 RevertCamera();
                 repaint();
                 break;
-            case 'L':
             case 'l':
+                lightMode ^= true;
+                Globals.lighttouched = true;
+                manipCamera = renderCamera = lightMode ? lightCamera : eyeCamera;
+                targetLookAt.set(manipCamera.lookAt);
+                repaint();
+                break;
+            case 'L':
                 if (lightMode)
                 {
                     lightMode = false;
@@ -14470,23 +15082,21 @@
                 kompactbit = 6;
                 break;
             case ' ':
-                lightMode ^= true;
-                Globals.lighttouched = true;
-                manipCamera = renderCamera = lightMode ? lightCamera : eyeCamera;
-                targetLookAt.set(manipCamera.lookAt);
+                ObjEditor.theFrame.ToggleFullScreen();
                 repaint();
                 break;
             //case '`' :
             case ESC:
                 RENDERPROGRAM += 1;
                 RENDERPROGRAM %= 3;
+
                 repaint();
                 break;
             case 'Z':
                 //RESIZETEXTURE ^= true;
                 //break;
             case 'z':
-                RENDERSHADOW ^= true;
+                Globals.RENDERSHADOW ^= true;
                 Globals.lighttouched = true;
                 repaint();
                 break;
@@ -14602,6 +15212,7 @@
         }
     //System.out.println("shaper_fovy = " + manipCamera.shaper_fovy);
     }
+    
     static double OCCLUSIONBOOST = 1; // 0.5;
 
     void keyReleased(int key, int modifiers)
@@ -14609,11 +15220,11 @@
         //mode = ROTATE;
         if ((MODIFIERS & COMMAND) == 0) // VR??
         {
-            SetMouseMode(modifiers);
+            SetMouseMode(0, modifiers);
         }
     }
 
-    protected void processKeyEvent(KeyEvent e)
+    public void processKeyEvent(KeyEvent e)
     {
         switch (e.getID())
         {
@@ -14743,8 +15354,9 @@
 
     protected void processMouseMotionEvent(MouseEvent e)
     {
-        //System.out.println("processMouseMotionEvent: " + mouseMode);
-        if (e.getButton() == MouseEvent.NOBUTTON && (mouseMode & SELECT) == 0)
+        //System.out.println("processMouseMotionEvent: " + mouseMode + " " + e.getModifiers() + " " + e.getModifiersEx() + " " + e.getButton());
+        //if (e.getButton() == MouseEvent.NOBUTTON && (mouseMode & SELECT) == 0)
+        if ((e.getModifiers() & MouseEvent.BUTTON1_MASK) == 0 && (e.getModifiers() & MouseEvent.BUTTON3_MASK) == 0 && (mouseMode & SELECT) == 0)
         {
             mouseMoved(e);
         } else
@@ -14769,11 +15381,12 @@
         }
          */
 
-        object.editWindow.EditSelection();
+        object.editWindow.EditSelection(false);
     }
 
     void SelectParent()
     {
+                new Exception().printStackTrace();
         System.exit(0);
         Composite group = (Composite) object;
         java.util.Vector selectees = new java.util.Vector(group.selection);
@@ -14797,6 +15410,7 @@
 
     void SelectChildren()
     {
+                new Exception().printStackTrace();
         System.exit(0);
         /*
         Composite group = (Composite) object;
@@ -14961,7 +15575,9 @@
         info.bounds.setBounds(0, 0, (int) (width * zoom), (int) (height * zoom));
         //Image img = CreateImage(width, height);
         //System.out.println("width = " + width + "; height = " + height + "\n");
+        
         Graphics gr = g; // img.getGraphics();
+        
         if (!hasMarquee)
         {
             if (Xmin < Xmax) // !locked)
@@ -15059,14 +15675,33 @@
             if (!isRenderer)
             {
                 object.drawEditHandles(info, 0);
+                
+                if (drag && (X != 0 || Y != 0) && object.selection.Size() > 0)
+                {
+                    switch (object.selection.get(0).hitSomething)
+                    {
+                        case Object3D.hitCenter: gr.setColor(Color.pink);
+                            gr.drawLine(X, Y, info.bounds.width/2, info.bounds.height/2);
+                            break;
+                        case Object3D.hitRotate: gr.setColor(Color.yellow);
+                            gr.drawLine(X, Y, info.bounds.width/2, info.bounds.height/2);
+                        break;
+                        case Object3D.hitScale: gr.setColor(Color.cyan);
+                            gr.drawLine(X, Y, info.bounds.width/2, info.bounds.height/2);
+                        break;
+                    }
+                    
+                }
             }
         }
+        
         if (isRenderer)
         {
         //gr.setColor(Color.black);
         //gr.drawRect(info.bounds.x - 1, info.bounds.y - 1, info.bounds.width + 1, info.bounds.height + 1);
         //gr.drawRect(info.bounds.x - 2, info.bounds.y - 2, info.bounds.width + 3, info.bounds.height + 3);
         }
+        
         if (hasMarquee)
         {
             gr.setXORMode(Color.white);
@@ -15179,6 +15814,7 @@
     public boolean mouseDown(Event evt, int x, int y)
     {
         System.out.println("mouseDown: " + evt);
+        System.exit(0);
         /*
         locked = true;
         drag = false;
@@ -15222,7 +15858,7 @@
         {
             keyPressed(0, modifiers);
         }
-        clickStart(x, y, modifiers);
+ //       clickStart(x, y, modifiers);
         return true;
     }
 
@@ -15340,7 +15976,7 @@
         {
             keyReleased(0, 0);
         }
-        drag(x, y, modifiers);
+        drag(x, y, 0, modifiers);
         return true;
     }
 
@@ -15472,7 +16108,7 @@
     Object3D object;
     static Object3D trackedobject;
     Camera renderCamera; // Light or Eye (or Occlusion)
-    /*static*/ Camera manipCamera; // Light or Eye
+    /*static*/ Camera manipCamera; // Light or Eye. Can be Light when Eye, not Eye when Light
 	/*static*/ Camera eyeCamera;
     /*static*/ Camera lightCamera;
     int cameracount;
@@ -15757,16 +16393,16 @@
                 cStatic.objectstack[materialdepth++] = checker;
                 //System.out.println("material " + material);
                 //Applet3D.tracein(this, selected);
-                vector2buffer = checker.projectedVertices;
+                //vector2buffer = checker.projectedVertices;
 
         //checker.GetMaterial().Draw(this, false); // true);
-        DrawMaterial(checker.GetMaterial(), false); // true);
+        DrawMaterial(checker.GetMaterial(), false, checker.projectedVertices); // true);
 
                 materialdepth -= 1;
                 if (materialdepth > 0)
                 {
-                    vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
-                    DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1]);
+                    //vector2buffer = cStatic.objectstack[materialdepth - 1].projectedVertices;
+                    DrawMaterial(materialstack[materialdepth - 1], selectedstack[materialdepth - 1], cStatic.objectstack[materialdepth - 1].projectedVertices);
                 }
         //checker.GetMaterial().opacity = 1f;
         ////checker.GetMaterial().ambient = 1f;
@@ -15910,6 +16546,7 @@
         {
             if (!selection)
             {
+                new Exception().printStackTrace();
                 System.exit(0);
                 return;
             }
@@ -15989,6 +16626,8 @@
 //                System.err.println("view = " + view[8] + " " + view[9] + " " + view[10] + " " + view[11]);
 //                System.err.println("view = " + view[12] + " " + view[13] + " " + view[14] + " " + view[15]);
                 
+                CreateSelectedPoint();
+                
                 // Will fit the mesh !!!
                 selectedpoint.toParent[0][0] = 0.0001;
                 selectedpoint.toParent[1][1] = 0.0001;
@@ -16037,16 +16676,16 @@
                             System.out.println("; fromto " + sel + " " + Trunk(previousselectedpoint.toParent[3][0]) + " " + Trunk(previousselectedpoint.toParent[3][2]) + " " + Trunk(selectedpoint.toParent[3][0]) + " " + Trunk(selectedpoint.toParent[3][2]));
                         }
                         
-                        previousselectedpoint = (Sphere) GrafreeD.clone(selectedpoint);
+                        previousselectedpoint = (Sphere) Grafreed.clone(selectedpoint);
                     }
                 }
                 
                 if (!movingcamera && !PAINTMODE)
                     object.editWindow.ScreenFitPoint(); // fev 2014
                 
-                if (PAINTMODE && GrafreeD.clipboard.size() == 1) // object.editWindow.copy.selection.Size() > 0)
+                if (PAINTMODE && Grafreed.clipboard.size() == 1) // object.editWindow.copy.selection.Size() > 0)
                 {
-                    Object3D paintobj = GrafreeD.clipboard.get(0); // object.editWindow.copy.selection.elementAt(0);
+                    Object3D paintobj = Grafreed.clipboard.get(0); // object.editWindow.copy.selection.elementAt(0);
                     
                     Object3D group = new Object3D("inst" + paintcount++);
                     
@@ -16202,7 +16841,7 @@
                 gl.glDisable(gl.GL_CULL_FACE);
             }
 
-            if (!RENDERSHADOW)
+            if (!Globals.RENDERSHADOW)
                 gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
             // SB gl.glPolygonOffset(2.5f, 10);
@@ -16212,7 +16851,7 @@
             //gl.glColorMask(false, false, false, false);
 
             //render_scene_from_light_view(gl, drawable, 0, 0);
-            if (RENDERSHADOW && Globals.lighttouched && !movingcamera) // && !parent.IsFreezed())
+            if (Globals.RENDERSHADOW && Globals.lighttouched && (!movingcamera || !Globals.FREEZEONMOVE)) // && !parent.IsFreezed())
             {
                 gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
@@ -16628,23 +17267,15 @@
     int AAbuffersize = 0;
     
     //double[] selectedpoint = new double[3];
-    static Superellipsoid selectedpoint = new Superellipsoid();
+    static Superellipsoid selectedpoint;
     static Sphere previousselectedpoint = null;
-    static Sphere debugpointG = new Sphere();
-    static Sphere debugpointP = new Sphere();
-    static Sphere debugpointC = new Sphere();
-    static Sphere debugpointR = new Sphere();
+    static Sphere debugpointG;
+    static Sphere debugpointP;
+    static Sphere debugpointC;
+    static Sphere debugpointR;
     
     static Sphere debugpoints[] = new Sphere[8];
  
-    static
-    {
-        for (int i=0; i<8; i++)
-        {
-            debugpoints[i] = new Sphere();
-        }
-    }
-    
     static void InitPoints(float radius)
     {
         for (int i=0; i<8; i++)
@@ -16696,10 +17327,11 @@
     static IntBuffer textbuffer = null; // IntBuffer.allocate(TEXT_WIDTH*8*8 * TEXT_HEIGHT);
     // Depth buffer format
     //private int depth_format;
-    static public void NextIndex(Object3D o, GL gl)
+    
+    public void NextIndex()
     {
         indexcount+=16;
-        gl.glColor3d(((indexcount >>> 16) & 255) / 255.0, ((indexcount >>> 8) & 255) / 255.0, ((indexcount) & 255) / 255.0);
+        GetGL().glColor3d(((indexcount >>> 16) & 255) / 255.0, ((indexcount >>> 8) & 255) / 255.0, ((indexcount) & 255) / 255.0);
     //objects[indexcount] = o;
     //System.out.println("indexcount = " + indexcount);
     }

--
Gitblit v1.6.2