checkpoint

darcs-hash:20080629214848-5007d-5782771468a28941fad9e768e1bf660a942334cf.gz

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index c041792..7f806f8 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -84,6 +84,8 @@ public class Mesh implements Iterable<Mesh.T> {
 
         private boolean illegal = false;
 
+        public boolean visible = false;
+
         public Point getPoint() { return p; }
         public float error() { return olderror; }
 
@@ -673,12 +675,16 @@ public class Mesh implements Iterable<Mesh.T> {
         return ret;
     }
 
+    private int max_serial = 0;
     /** [UNIQUE] a triangle (face) */
     public final class T extends Triangle {
         public final E e1;
         public final int color;
         public final int colorclass;
 
+        public final int serial = max_serial++;
+        public boolean occluded;
+
         T(E e1, int colorclass) {
             this.e1 = e1;
             E e2 = e1.next;
@@ -730,17 +736,18 @@ public class Mesh implements Iterable<Mesh.T> {
             return true;
         }
 
+        public void glTriangle(GL gl, Matrix m) {
+            gl.glPushName(serial);
+            gl.glBegin(GL.GL_TRIANGLES);
+            glVertices(gl, m);
+            gl.glEnd();
+            gl.glPopName();
+        }
+
         /** issue gl.glVertex() for each of the triangle's points */
-        public void glVertices(GL gl) {
+        public void glVertices(GL gl, Matrix m) {
             if (!shouldBeDrawn()) return;
-            norm().glNormal(gl);
-            Point p1 = v1().goodp;
-            Point p2 = v2().goodp;
-            Point p3 = v3().goodp;
-            p1.glVertex(gl);
-            p2.glVertex(gl);
-            p3.glVertex(gl);
+            super.glVertices(gl, m);
         }
-
     }
 }

diff --git a/src/edu/berkeley/qfat/MeshViewer.java b/src/edu/berkeley/qfat/MeshViewer.java
index cc05e86..6bad5eb 100644 (file)
--- a/src/edu/berkeley/qfat/MeshViewer.java
+++ b/src/edu/berkeley/qfat/MeshViewer.java
@@ -1,5 +1,6 @@
 package edu.berkeley.qfat;
 import java.io.*;
+import java.nio.*;
 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;
@@ -215,9 +216,9 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
 
         gl.glBegin(GL.GL_TRIANGLES);
         if (tileon)
-        draw(gl, true, safeTriangles);
+            draw(gl, true, safeTriangles);
         if (tilemeshon)
-        draw(gl, false, safeTriangles);
+            draw(gl, false, safeTriangles);
         gl.glEnd();
 
         //draw(gl, false, tile);
@@ -258,8 +259,128 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
             */
         }
         //gl.glEnable(GL.GL_DEPTH_TEST);
-        gl.glEnable (GL.GL_LIGHTING);
 
+        gl.glDrawBuffer(GL.GL_BACK);
+        gl.glReadBuffer( GL.GL_BACK );
+        gl.glPixelStorei( GL.GL_PACK_ALIGNMENT, 1);
+        gl.glFlush();
+        gl.glDisable(GL.GL_LIGHTING);
+        gl.glShadeModel(GL.GL_FLAT);
+
+        int viewport[] = new int[4];
+        double mvmatrix[] = new double[16];
+        double projmatrix[] = new double[16];
+        double wcoord[] = new double[4];
+        gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
+        gl.glGetDoublev(GL.GL_MODELVIEW_MATRIX, mvmatrix, 0);
+        gl.glGetDoublev(GL.GL_PROJECTION_MATRIX, projmatrix, 0);
+
+        IntBuffer buf = ByteBuffer.allocateDirect(9*4*4).order(ByteOrder.nativeOrder()).asIntBuffer();
+        gl.glColor3f(0,0,0);
+        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        synchronized(safeTriangles) {
+            for(Mesh.T t : safeTriangles)
+                t.glTriangle(gl, null);
+            for(Mesh.Vertex v : tile.vertices()) {
+                Point p = v.getPoint();
+                gl.glColor3f(1,1,1);
+                gl.glBegin(gl.GL_POINTS);
+                p.glVertex(gl);
+                gl.glEnd();
+                gl.glFlush();
+
+                glu.gluProject(p.x, 
+                               p.y, 
+                               p.z,
+                               mvmatrix, 0, projmatrix, 0, viewport, 0, wcoord, 0);
+                int x = (int)Math.round(wcoord[0]);
+                int y = (int)Math.round(wcoord[1]);
+
+                gl.glReadPixels(x-1, y-1, 3, 3, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, buf);
+                boolean vis = false;
+                for(int j=0; j<9*4; j++) vis |= buf.get(j)!=0;
+                v.visible = vis;
+                if (vis) {
+                    gl.glColor3f(0,0,0);
+                    gl.glBegin(gl.GL_POINTS);
+                    p.glVertex(gl);
+                    gl.glEnd();
+                }
+            }
+        }
+        gl.glShadeModel(GL.GL_SMOOTH);
+        gl.glEnable(GL.GL_LIGHTING);
+        gl.glDrawBuffer(GL.GL_FRONT);
+        /*
+        IntBuffer selectionBuffer =
+        ByteBuffer.allocateDirect(4*10000).order(ByteOrder.nativeOrder()).asIntBuffer();
+        gl.glSelectBuffer(selectionBuffer.capacity(), selectionBuffer);
+        gl.glInitNames();
+        gl.glRenderMode(GL.GL_SELECT);
+        draw(gl, true, safeTriangles);
+        int hits = gl.glRenderMode(GL.GL_RENDER);
+        synchronized(safeTriangles) {
+            for(Mesh.T t : safeTriangles) {
+                t.occluded = true;
+            }
+            processHits(hits, selectionBuffer);
+        }
+        */
+    }
+
+
+    // I copied this method without changes from the mentioned base class.
+    // It extracts the data in the selection buffer and writes it on the console.
+    public void processHits(int hits, IntBuffer buffer) {
+        /*
+        System.out.println("---------------------------------");
+        System.out.println(" HITS: " + hits);
+        */
+        int offset = 0;
+        int names;
+        float z1, z2;
+        for (int i = 0; i < hits; i++) {
+            /*
+            System.out.println("- - - - - - - - - - - -");
+            System.out.println(" hit: " + (i + 1));
+            */
+            names = buffer.get(offset);
+            offset++;
+            z1 = (float) buffer.get(offset) / 0x7fffffff;
+            offset++;
+            z2 = (float) buffer.get(offset) / 0x7fffffff;
+            offset++;
+            /*
+            System.out.println(" number of names: " + names);
+            System.out.println(" z1: " + z1);
+            System.out.println(" z2: " + z2);
+            System.out.println(" names: ");
+            */
+
+            for (int j = 0; j < names; j++) {
+                int who = buffer.get(offset);
+                for(Mesh.T t : safeTriangles) {
+                    if (t.serial==who) {
+                        t.occluded = false;
+                    }
+                }
+                /*
+                System.out.print("  " + who);
+                if (j == (names - 1)) {
+                    System.out.println("<-");
+                } else {
+                    System.out.println();
+                    }
+                */
+                offset++;
+            }
+            /*
+            System.out.println("- - - - - - - - - - - -");
+            */
+        }
+        /*
+        System.out.println("--------------------------------- ");
+        */
     }
 
     protected HashSet<Mesh.T> safeTriangles = new HashSet<Mesh.T>();
@@ -287,6 +408,9 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
                 case 5: gl.glColor4f((float)0.25, (float)0.75, (float)0.75, (float)0.3); break;
                 case 6: gl.glColor4f((float)0.75, (float)0.25, (float)0.75, (float)0.3); break;
             }
+            
+            if (t.v1().visible && t.v2().visible && t.v3().visible) continue;
+
             /*
             if (t.e1().pair.t==null) gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3);
             else if (t.e2().pair.t==null) gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3);
@@ -296,15 +420,7 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
             //gl.glBegin(GL.GL_LINES);
 
             if (triangles) {
-                gl.glBegin(GL.GL_TRIANGLES);
-                if (t.shouldBeDrawn()) {
-                    m.times(t.norm()).glNormal(gl);
-                    m.times(t.v1().goodp).glVertex(gl);
-                    m.times(t.v2().goodp).glVertex(gl);
-                    m.times(t.v3().goodp).glVertex(gl);
-                    //t.glVertices(gl, m);
-                }
-                gl.glEnd();
+                t.glTriangle(gl, m);
             } else {
                 gl.glDisable(GL.GL_LIGHTING);
                 gl.glBegin(GL.GL_LINES);

diff --git a/src/edu/berkeley/qfat/geom/Triangle.java b/src/edu/berkeley/qfat/geom/Triangle.java
index fece872..bfc0b84 100644 (file)
--- a/src/edu/berkeley/qfat/geom/Triangle.java
+++ b/src/edu/berkeley/qfat/geom/Triangle.java
@@ -23,17 +23,18 @@ public abstract class Triangle implements HasBoundingBox {
     }
 
     /** issue gl.glVertex() for each of the triangle's points */
-    public void glVertices(GL gl) {
-        norm().glNormal(gl);
-        p1().glVertex(gl);
-        p2().glVertex(gl);
-        p3().glVertex(gl);
-    }
     public void glVertices(GL gl, Matrix m) {
-        m.times(norm()).glNormal(gl);
-        m.times(p1()).glVertex(gl);
-        m.times(p2()).glVertex(gl);
-        m.times(p3()).glVertex(gl);
+        if (m==null) {
+            norm().glNormal(gl);
+            p1().glVertex(gl);
+            p2().glVertex(gl);
+            p3().glVertex(gl);
+        } else {
+            m.times(norm()).glNormal(gl);
+            m.times(p1()).glVertex(gl);
+            m.times(p2()).glVertex(gl);
+            m.times(p3()).glVertex(gl);
+        }
     }
 
     /** the triangle's centroid */