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

Go to the documentation of this file.

/*
 * Created on 15.04.2008
 */
package org.hfbk.vis.visnode;

import java.awt.AWTEvent;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

import org.dronus.gl.GLUtil;
import org.dronus.graph.Node;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Matrix4f;
import org.lwjgl.util.vector.Vector3f;
import org.lwjgl.util.vector.Vector4f;

public abstract class VisNode {

        public Node node;
        
        public String url;
        
        public VisNode parent;
        
        public List<VisNode> children=new CopyOnWriteArrayList<VisNode>();
        
        public Vector3f position;
        
        public Matrix4f currentTransform=new Matrix4f();
        
        public float radius=10;  
        
        public boolean layoutLocked=false;
        
        protected VisNode(Node node, Vector3f position){
                this.node=node;
                this.position=new Vector3f(position);
        }
        
        public void add(VisNode node){
                children.add(node);
                node.parent=this;
        } 
        
        public void remove(VisNode node){
                children.remove(node);
                //node.parent=null;
        }
        
        public VisRoot getRoot(){
                VisNode n=this;
                while (n.parent!=null)
                        n=n.parent;
                return (VisRoot)n; 
        }
        
        public Vector3f traverse(VisNode other, Vector3f pos){
                pos=new Vector3f(pos);
                
                Matrix4f xform=new Matrix4f();          
                xform.load(other.currentTransform);
                //invert the transform to get from root space to others local space 
                xform.invert(); 
                Matrix4f.mul(xform, currentTransform, xform);
                
                //transform pos from root space to others local space
                Vector4f newpos=Matrix4f.transform(xform, new Vector4f(pos.x,pos.y,pos.z,1), null);
                
                return new Vector3f(newpos); //return as 3d vector
        }
        
        public void render(List<AWTEvent> events){
                GL11.glPushMatrix();
                
                transform();
                GLUtil.getTransform(currentTransform); //store transform 
                                                                                                //for traverse(.) etc.
                if(GLUtil.showExtents)
                        GLUtil.debugDoubleSphere(getExtends(),radius);
                
                //simple sphere vs frustrum culling
                if (radius==Float.POSITIVE_INFINITY || GLUtil.inFrustum(getExtends())){
                        
                        //handle events here so the handler can retrieve the nodes transformation
                        handleEvents(events);
                        renderChildren(events);
                        renderSelf();
                }
                GL11.glPopMatrix();
        }
        
        void renderChildren(List<AWTEvent> events) {
                for(VisNode n: children) n.render(events);              
        }
        
        float getExtends() {
                float r=radius;
                for(VisNode child: children){
                        Vector3f pos=child.position;
                        float d=pos.length()+child.getExtends();
                        r=Math.max(d,r); //the extends is either maximized by
                                                        // the child nodes or by this nodes geometry    
                }
                return r; 
        }

        public Vector3f center(){
                Vector3f center=new Vector3f();
                for(VisNode n: children)
                        Vector3f.add(center, n.position, center);
                center.scale(1f/children.size());
                for(VisNode n: children)
                        Vector3f.sub(n.position, center, n.position);
                return center;
        }
        
        void transform(){
                GL11.glTranslatef(position.x,position.y,position.z);            
        }
        
        abstract void renderSelf(); 
        
        void handleEvents(List<AWTEvent> events){       }
        
        void closeSelf(){}
        
        public void close(){
                for(VisNode n: children) n.close();                     
                closeSelf();
        }

        static VisNode findNode (VisNode root, Class<?> cl){
                if (cl.isAssignableFrom(root.getClass())) return root; //hurray!
                for (VisNode n: root.children){
                        VisNode found=findNode(n,cl);
                        if (found!=null) return found;
                }
                return null;
        }
        
        public VisNode findNode(Class<?> cls) {
                return findNode(this, cls);
        }
}

---