VisClient/org/hfbk/vis/visnode/VisObj.java

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.dronus.gl.Convexiser;
import org.dronus.gl.GLFont;
import org.dronus.gl.GLUtil;
import org.dronus.graph.Node;
import org.hfbk.vis.Prefs;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class VisObj extends VisNodeDraggable {

        int dl;  // DisplayList number

        Vector3f epicenter;
        
        class Line extends ArrayList<Vector3f>{}
        class Face extends ArrayList<Vector3f>{}
        class Group { 
                String name;
                List<Face> faces=new ArrayList<Face>();
                List<Line> lines=new ArrayList<Line>();                 
        }
        
        
        List<Vector3f> verticies=new ArrayList<Vector3f>(); //store verticies
        List<Group> groups=new ArrayList<Group>();   
        
        List<List<Vector3f>> triangles=new ArrayList<List<Vector3f>>(); //all triangles for hit detection
        
        
        public VisObj(Node n, Vector3f position) {
                super(n, position);
                
                try {
                        load(new URL("file:"+n.text));
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
        
        public VisObj(String ressource, Vector3f pos){
                super(new Node(ressource), pos);
                try {
                        URL r=ClassLoader.getSystemResource(ressource);
                        load(r);
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
        
        void load(URL url) throws  IOException{
                BufferedReader r=new BufferedReader(new InputStreamReader(url.openStream()));
                //r.mark((int)file.length()+1); //buffer whole file for vertex readahead
                Vector3f scale=new Vector3f(1,1,1);
                
                Group currentGroup=new Group();
                currentGroup.name="default";
                groups.add(currentGroup);
                
                String line;            
                while ((line=r.readLine())!=null){ //read file while lines left..
                        String[] params=line.split(" +"); //split line on (maybe mutliple) whitespaces
                        if (params.length==0) continue; //empty line
                        
                        String command=params[0];  //useful command is either v or f
                        

                        if (params[0].equals("v")){ //parse a vertex
                                Vector3f vertex=new Vector3f(
                                                Float.parseFloat(params[1])*scale.x, 
                            Float.parseFloat(params[2])*scale.y,
                            Float.parseFloat(params[3])*scale.z
                           );
                                verticies.add(vertex);
                                
                                radius=Math.max(radius, vertex.length());
                                
                        }       
                        
                        if (command.equals("center")){ //parse the center
                                epicenter=new Vector3f(Float.parseFloat(params[1]), 
                                   Float.parseFloat(params[2]),
                                   Float.parseFloat(params[3])
                                   );
                                                                                
                        }else if (command.equals("f")){ //parse a face
                                Face f=new Face();
                                for (int i=1; i<params.length; i++){
                                        String parts[]=params[i].split("/");
                                          //only care for verticie indicies
                                        //ignoring texture and normals
                                        
                                        Vector3f v=verticies.get(Integer.parseInt(parts[0])-1);
                                        f.add(v); 
                                }
                                currentGroup.faces.add(f); 
                        }else if (command.equals("l")){ //parse a line
                                Line l=new Line();
                                for (int i=1; i<params.length; i++){
                                        Vector3f v=verticies.get(Integer.parseInt(params[i])-1);
                                        l.add(v);   
                                }
                                currentGroup.lines.add(l);
                        }else if (command.equals("g") && params.length>1){
                                currentGroup=new Group();
                                currentGroup.name=params[1];
                                groups.add(currentGroup);
                        }else if (command.equals("scale")){
                                scale=new Vector3f(Float.parseFloat(params[1]), 
                            Float.parseFloat(params[2]),
                            Float.parseFloat(params[3])
                           );
                        }       
                }
                r.close();
//              System.out.println(maxx+","+minx+","+maxz+","+minz);
        }

        void drawNormals(){
                GL11.glLineWidth(2);
                for (Group g: groups)
                        for (Face f: g.faces){
                                if (f.size()<3) continue;
                        
                                Vector3f normal=getNormal(f);
                                normal.scale(10);
                                
                                Vector3f mid=getCenter(f);
                                
                                GL11.glBegin(GL11.GL_LINE_STRIP);
                                GL11.glColor3f(0,0,1);
                                GL11.glVertex3f(normal.x+mid.x, normal.y+mid.y,normal.z+mid.z);
                                GL11.glColor3f(1,1,1);
                                GL11.glVertex3f(mid.x,mid.y,mid.z);
                                GL11.glColor3f(1,0,0);
                                GL11.glVertex3f(-normal.x+mid.x, -normal.y+mid.y, -normal.z+mid.z);
                                GL11.glEnd();
                        }
                                
                GL11.glLineWidth(1);
        }
        
        Vector3f getNormal(List<Vector3f> tri){
                Vector3f n0=tri.get(0), n1=tri.get(1), n2=tri.get(2);
                Vector3f d0=new Vector3f(), d2=new Vector3f();
                Vector3f.sub(n0,n1, d0);
                Vector3f.sub(n2,n1, d2);
                Vector3f normal=new Vector3f();
                Vector3f.cross(d0, d2, normal);
                normal.normalise();             
                return normal;
        }
        
        Vector3f getCenter(List<Vector3f> poly){
                Vector3f c=new Vector3f();
                for (Vector3f v: poly){
                        Vector3f.add(c, v, c);                  
                }
                c.scale(1f/poly.size());
                return c;
        }
        
        void drawFaces(){
                
                for (Group g:groups){
                        if (!g.name.equals("default")) groupColor(g.name.hashCode()&0xFF);
                        for (Face f: g.faces){
                                
                                List<List<Vector3f>> convexPolys;                               
                                if (f.size()<4){
                                        convexPolys=new ArrayList<List<Vector3f>>();
                                        convexPolys.add(f);
                                }else{
                                        Convexiser bfec=new Convexiser();                               
                                        convexPolys=bfec.convexise(f);
                                }
                                
                                for (List<Vector3f> t: convexPolys){
                                        GL11.glBegin(GL11.GL_POLYGON);  
                                        for (Vector3f v: t)
                                                GL11.glVertex3f(v.x,v.y,v.z);
                                        GL11.glEnd();
                                        
                                        triangles.add(t);
                                }
                        }
                }
        }
        
        void groupColor(float g){
                if (g>0) {
                        g=g*41;
                        GL11.glColor3f((g/3)%1f, (g/5)%1f, (g/7)%1f);
                }
        }
        
        void drawWireframe(){
                for (Group g: groups)
                        for (Face f: g.faces){
                                GL11.glBegin(GL11.GL_LINE_LOOP);
                                for (Vector3f v: f) 
                                        GL11.glVertex3f(v.x,v.y,v.z);                                   
                                GL11.glEnd();
                        }               
        }
        
        void drawLines(){
                for (Group g: groups)
                        for (Line l: g.lines){
                                GL11.glBegin(GL11.GL_LINE_STRIP);
                                for (Vector3f v: l)
                                        GL11.glVertex3f(v.x,v.y,v.z);
                                GL11.glEnd();
                        }
        }
        
        void renderSelf() {
                
                //if we have a VisStructure, place us underneath to conveniently stay close
                //to the user if he raises the floor via fetches.
                if (parent instanceof VisRoot){
                        VisNode struct=parent.findNode(VisStructure.class);
                        if (struct!=null){
                                parent.remove(this);
                                struct.add(this);
                        }
                }
                
                if (dl==0){ //display list already built? if not, compile it.
                        dl=GL11.glGenLists(1); 
                        GL11.glNewList(dl, GL11.GL_COMPILE);
                        
                        GL11.glDisable(GL11.GL_TEXTURE_2D);
                        
                        GL11.glPolygonOffset(1,1); //push back the surface in z buffer to allow clean wireframe drawing
                        GL11.glColor4f(.5f,.5f,.5f,.3f);
                        drawFaces();
                        GL11.glPolygonOffset(0,0);
                        
                        GL11.glColor3f(1,1,1);
                        drawWireframe();

                        drawLines();
                        
                        GL11.glEndList();
                        
                        if (epicenter!=null)
                                getRoot().epicenter=epicenter;
                }
                
                //draw compiled list
                GL11.glCallList(dl);
                
                if (isHoovered) {
                        GL11.glColor3f(1,0,0);
                        drawWireframe();
                } 
                
                if (Prefs.current.debug){
                        
                        drawNormals();
                        drawIndicies();
                        
/*                      if (hitTri!=null){
                                GL11.glColor3f(1,1,1);                          
                                GL11.glBegin(GL11.GL_POLYGON);  
                                for (Vector3f v: hitTri)
                                        GL11.glVertex3f(v.x,v.y,v.z);
                                GL11.glEnd();                           
                        }*/                     
                        
                }
        }
        
        void drawIndicies(){
                GLFont.getDefault().render();
                int index=0;
                for (Vector3f v: verticies){
                        GL11.glPushMatrix();
                        GL11.glTranslatef(v.x, v.y, v.z);
                        GLUtil.billboardCylinder();
                        GL11.glColor3f(1,1,1);
                        GLFont.getDefault().print(""+index++);                                  
                        GL11.glPopMatrix();
                }
                
                GL11.glDisable(GL11.GL_TEXTURE_2D);
        }


         boolean hitTriangle(Ray ray, List<Vector3f> polygon) {
        
                 final double EPSILON=0.000001;
                 
                 Vector3f vert0=polygon.get(0);
                 Vector3f vert1=polygon.get(1);
                 Vector3f vert2=polygon.get(2);
                 
                Vector3f edge1=new Vector3f(), edge2=new Vector3f(), tvec=new Vector3f(), pvec=new Vector3f(), qvec=new Vector3f();
            
            Vector3f.sub(vert1, vert0, edge1);
            Vector3f.sub(vert2, vert0, edge2);
            
            Vector3f.cross(ray.dir, edge2, pvec);           
            
             // if determinant is near zero, ray lies in plane of triangle 
           double det =Vector3f.dot(edge1,pvec); 
           
            if (det > -EPSILON && det < EPSILON)
              return false;
        
            double inv_det = 1.0 / det;

            // calculate distance from vert0 to ray origin
            Vector3f.sub(ray.start, vert0, tvec);
            
            // calculate U parameter and test bounds 
            double u = Vector3f.dot(tvec, pvec) * inv_det;
            if (u < 0.0 || u > 1.0)
              return false;

            
            // calculate V parameter and test bounds 
            Vector3f.cross(tvec,edge1,qvec);        
            double v = Vector3f.dot(ray.dir, qvec) * inv_det;
            if (v < 0.0 || u + v > 1.0)
              return false;
            
            // calculate t for hit = ray.start + ray.dir * t
            // t = Vector3f.dor(edge2, qvec) * inv_det;
            
            return true;
         }
         
        boolean hit(Ray mouseray, Vector3f hit) {
                float distance;
                
                if(handle==null)        distance=GLUtil.getPosition().length();
                else                            distance=hitDepth;
                Vector3f projector=(Vector3f)new Vector3f(mouseray.dir).scale(distance);  // / projectiveLength; 
                Vector3f.add(mouseray.start, projector, hit);

                //if (hit.length()>radius) return false;
                
                for (List<Vector3f> t:triangles)
                        if (hitTriangle(mouseray, t)) 
                                return true;
                
                return false;                   
        }
}

---