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

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.util.ArrayList;
import java.util.List;

import org.dronus.gl.Buffers;
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 VisUgl extends VisNodeDraggable {

        int dl;  // DisplayList number
        float w,h,l,r,xd,yd,zd;
    int rec;
    
    Vector3f origin=new Vector3f();
        Vector3f size=new Vector3f();
        
        

        Vector3f epicenter;
        

        List<Vector3f> verticies=new ArrayList<Vector3f>(); //store verticies 
        List<Integer>  faces=new ArrayList<Integer>();   //and faces as vertex indicies
        List<Integer>  lines=new ArrayList<Integer>();   //and lines as vertex indicies
        List<List<Vector3f>> triangles=new ArrayList<List<Vector3f>>(); //triangles for hit detection
        List<String> groups=new ArrayList<String>();



        
        public VisUgl(Node n, Vector3f position) {
//              super(n, position);
                super(n, new Vector3f());

                
        }
        
        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(){
                int n;
                for (int i=0; i<faces.size(); i+=n+1){ //for all faces
                        
                        float group=faces.get(i++)*13;
                        
                        n=0;                    
                        while (faces.get(i+n)!=-1) n++;
                        
                        if (n<3) continue;
                        
                        List<Vector3f> polygon=new ArrayList<Vector3f>();
                        
                        for (int k=0; k<n; k++) {
                                Vector3f v=verticies.get(faces.get(i+k)-1);
                                polygon.add(v);
                        }
                        
                        List<List<Vector3f>> convexPolys;                               
                        if (n<4){
                                convexPolys=new ArrayList<List<Vector3f>>();
                                convexPolys.add(polygon);
                        }else{
                                Convexiser bfec=new Convexiser();                               
                                convexPolys=bfec.convexise(polygon);
                        }
                        
                        for (List<Vector3f> t: convexPolys){
                                groupColor(group);
                                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 makeBox(float x,float y,float w,float h,int level)
        {
//      stroke(0);
        x+=.1f;y+=.1f;w-=.2f;h-=.2f;
//      rect(x,y,w,h);
/*      line (x,y,x+w,y);
        line (x+w,y,x+w,y+h);
        line (x+w,y+h,x,y+h);
        line (x,y+h,x,y);
*/
        float depth;
        if (level!=7)
        {
        depth=level*-.1f;
                
        GL11.glColor4f(level*.1f,level*.1f,level*.1f,.8f);
        
        GL11.glBegin(GL11.GL_QUADS);
//      front
//      GL11.glNormal3f(0.0f, 0.0f, -1.0f);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x,y+h,depth);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x,y+h,depth);
        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x,y+h,depth);
        

        GL11.glEnd();
        
        GL11.glColor4f(1,1,1,1);
        
        GL11.glBegin(GL11.GL_LINE_STRIP);
//      front
//      GL11.glNormal3f(0.0f, 0.0f, -1.0f);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glEnd();
        GL11.glBegin(GL11.GL_LINE_STRIP);

        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x,y+h,depth);
        GL11.glVertex3f(x,y,depth);
        GL11.glEnd();
        GL11.glBegin(GL11.GL_LINE_STRIP);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x,y+h,depth);
        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glEnd();
        GL11.glBegin(GL11.GL_LINE_STRIP);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glEnd();
        GL11.glBegin(GL11.GL_LINE_STRIP);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glVertex3f(x+w,y,0.01f);
        GL11.glVertex3f(x+w,y,depth);
        GL11.glVertex3f(x,y,depth);
        GL11.glVertex3f(x,y,0.01f);
        GL11.glEnd();
    GL11.glBegin(GL11.GL_LINE_STRIP);
        GL11.glVertex3f(x,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,0.01f);
        GL11.glVertex3f(x+w,y+h,depth);
        GL11.glVertex3f(x,y+h,depth);
        GL11.glVertex3f(x,y+h,0.01f);
        

        GL11.glEnd();
        }
        }

        
        void drawAuto(float x, float y,float w,float h, int level) 
        {
                
                
                
          if(level > 1) {
            level = level - 1;

            
            double ra=Math.random();

    
            
            if (ra<.33f)  //no split
                {
                
                        makeBox(x,y,w,h,level);

                }
                else
                
                if (ra>.66f)  //xsplit
                {
//                       X-split
                           drawAuto(x, y,w/3,h, level);
                            drawAuto(x+w/3,y,w*2/3,h,level);
                
                }
                else
                {
                    
//                       Y-split
                        
                          drawAuto(x, y,w,h/3, level);
                            drawAuto(x,y+h/3,w,h*2/3,level);
                
                
                }

            
          }         
                
        }
        
        void drawLines(){
                for (int i=0; i<lines.size(); i++){ //for all lines
                        int group=lines.get(i++); //skip group id
                        if (group>0) 
                                GL11.glColor3f((group%1.0f), (group*2)%1.0f, (group*7)%1.0f);
                        
                        GL11.glBegin(GL11.GL_LINE_STRIP);                               
                        while (lines.get(i)!=-1){ //for all verticies of one line
                                Vector3f v=verticies.get(lines.get(i)-1); //indicies range from 1 to .. 
                                GL11.glVertex3f(v.x,v.y,v.z);
                                i++;
                        }
                        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.glEnable(GL11.GL_LIGHTING);
                        
                        
                //      GL11.glMaterialf(GL11.GL_FRONT, GL11.GL_SHININESS, 10);
                        GL11.glMaterial(GL11.GL_FRONT, GL11.GL_DIFFUSE, Buffers.f4(.9f,.5f,.0f,.8f));
        
                //      GL11.glMaterial(GL11.GL_FRONT, GL11.GL_SPECULAR, Buffers.f4(1,.41f,.41f,.8f));                  
                        
                        
                        
                        GL11.glPushMatrix();
                        GL11.glTranslatef(0,-15,0);
                        GL11.glRotatef(90,1,0,0);
                        GL11.glScalef(50,50,50);
                        
                        
        
                        
                        radius=1000;
                        rec=0;
                        
                        w=l=h=1;
                        
                        zd=0;
                
                        
                        
                        for (xd=0;xd<8;xd=xd+1)
                    {
                        for (yd=0;yd>-8;yd=yd-1)
                            {

                
                                drawAuto(xd,yd,w,h,8);
                            }
                    }
                        GL11.glDisable(GL11.GL_LIGHTING);
                        
                        
                        //drawFaces();
                        
                        GL11.glPolygonOffset(0,0);
                        
                        GL11.glColor3f(1,1,1);
                        
                        //drawWireframe();

                        //drawLines();
                        
                        GL11.glPopMatrix();
                        
                        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();
                
                for (int i=0; i<faces.size(); i++){ //for all faces
                        i++; //skip group id
                        while (faces.get(i)!=-1){ //for all verticies of one face
                                Vector3f v=verticies.get(faces.get(i)-1); //indicies range from 1 to .. 
                                GL11.glPushMatrix();
                                GL11.glTranslatef(v.x, v.y, v.z);
                                GLUtil.billboardCylinder();
                                GL11.glColor3f(1,1,1);
                                GLFont.getDefault().print(""+(faces.get(i)-1));
                                
                                GL11.glPopMatrix();
                                i++;
                        }
                }       
                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;                   
        }
}

---