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

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.awt.event.MouseEvent;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.List;

import org.dronus.gl.Buffers;
import org.dronus.gl.GLUtil;
import org.dronus.graph.Node;
import org.hfbk.vis.visnode.VisDucts.VisDuct.Port;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Matrix4f;
import org.lwjgl.util.vector.Vector3f;

public class VisDucts extends VisNode {

        //javascript: client.root.add(new VisDucts());
        
        public VisDucts(Node dummy, Vector3f pos) {
                super(null, pos);
                
                for (int i=0; i< 9; i++)
                        add(new VisDuct(1));
                
                for (int i=2; i<30; i++)  
                        add(new VisDuct(i)); 
                        
                
        }


        static class VisDuct extends VisObj{
                static int index=0;
                
                VisDuct diz=this;

                Matrix4f orientation=new Matrix4f();
                
                VisDuct getThis(){return this;} //needed to get the owning duct of a Port 
                
                class Port{
                        float w,h;
                        
                        Vector3f center;
                        Vector3f normal;
                        Vector3f base;
                        List<Vector3f> polygon=new ArrayList<Vector3f>();
                
                        Port(List<Vector3f> polygon){
                                this.polygon=polygon;
                                center=getCenter(polygon);
                                normal=getNormal(polygon);
                                
                                Vector3f n0=polygon.get(0),n1=polygon.get(1),n2=polygon.get(2);
                                
                                base=new Vector3f();
                                Vector3f baseh=new Vector3f();
                                
                                w=Vector3f.sub(n0,n1, base ).length();
                                h=Vector3f.sub(n2,n1, baseh).length();
                                
                                if (h>w) base=baseh; 
                                
                        }
                        
                        VisDuct getOwner(){return getThis();}
                        
                        void render(){
                                GL11.glLineWidth(3);
                                GL11.glBegin(GL11.GL_LINE_LOOP);                        
                                for (Vector3f v : polygon)
                                        GL11.glVertex3f(v.x,v.y,v.z);                                   
                                GL11.glEnd();
                                GL11.glLineWidth(1);
                        }
                        
                        boolean isDualAspect(Port other){
                                return tolerate(w, other.h) && tolerate(h, other.w);
                        }       
                        boolean isCompatible(Port other){
                                return ((tolerate(w, other.w) && tolerate(h, other.h)) ||
                                                isDualAspect(other)
                                );
                        }
                        
                        float matchPlaneRotation(Vector3f other, Vector3f axis){
                                float dot=Vector3f.dot(normal, other);
                                
                                if (dot>.9f) { //same orientation
                                        Vector3f.cross(normal, base, axis);
                                        axis.normalise();
                                        return 180;                                     
                                }else if(dot<-.9f){ //already opposite
                                        return 0;
                                }else { // perpendicular
                                        Vector3f.cross(normal, other, axis);
                                        axis.normalise();
                                        return -90;                             
                                }
                        }
                        
                        float matchAspect(Vector3f other, Vector3f axis){
                                axis.set(normal);
                                float dot=Vector3f.dot(base, other);
                                if (dot>.9f || dot<-.9f) { //same orientation                                   
                                        return 0;
                                }else { // perpendicular                                        
                                        return -90;
                                }
                        } 
                        
                        
                        final float TOLERANCE=3; //cm
                        boolean tolerate(float a, float b){
                                return Math.abs(a-b)<TOLERANCE;
                        }
                }
                List<Port> ports=new ArrayList<Port>();
                
                Port candidate, candidateOwn;
                
                int type;
                
                VisDuct(int type){
                        super(new Node("misc/duct/"+type+".obj"), new Vector3f(index++*50,0,0));
                        this.type=type;
                        buildPorts();   
                        
                        radius*=2;
                }
                
                void buildPorts(){
                        for(Group g: groups)                             
                                if (g.name.matches("dock.*")) 
                                        ports.add(new Port(g.faces.get(0)));
                }
                
                boolean wasDragged;
                void renderSelf() {
                        super.renderSelf();
                        for (Port p: ports) {
                                if (p==candidateOwn){
                                        if (!p.isCompatible(candidate)) GL11.glColor3f(1,0,0);
                                        else {
                                                GL11.glColor3f(0,1,0);
                                        }
                                }else
                                        GL11.glColor3f(1,1,1);
                                p.render();     
                        }
                        
                        //if (!isDragged && wasDragged && candidate!=null && candidateOwn.isCompatible(candidate)){ 
                        if (!isDragged && wasDragged && candidate!=null ){  
                                // this duct was dropped, and a candidate port 
                                // is lit! so we join them. 
                                
                                //origin of other duct piece to resolve absolute port positions
                                Vector3f otherOrigin=candidate.getOwner().traverse(this, new Vector3f());
                                
                                //traverse others port normal to our local transform
                                Vector3f otherNormal=candidate.getOwner().traverse(this, candidate.normal);
                                Vector3f.sub(otherNormal, otherOrigin, otherNormal);
                                
                                //compute rotation needed to get the ports into opposition
                                Vector3f alignAxis=new Vector3f();
                                float alignAngle=candidateOwn.matchPlaneRotation(otherNormal, alignAxis);
                                
                                if (alignAngle!=0) orientation.rotate(alignAngle/180*(float)Math.PI, alignAxis);
                        
                                //apply transformations inbetween to allow 
                                //further computations in new oriented local space.
                                retransform();
                                
                                //now traverse the ports position to our space and get them both aligned.
                                Vector3f should=candidate.getOwner().traverse(parent, candidate.center);
                                Vector3f is    =                     traverse(parent, candidateOwn.center);
                                Vector3f.sub(position, is, position);
                                Vector3f.add(position, should, position);
                                
                        }
                        
                        candidate=candidateOwn=null;                    
                        wasDragged=isDragged;
                        
                }
                
                void transform() {
                        super.transform();
                        
                        FloatBuffer b=Buffers.matrixBuffer();
                        orientation.store(b); b.flip();
                        GL11.glMultMatrix(b);
                }
                
                void retransform(){
                        GL11.glPopMatrix();
                        GL11.glPushMatrix();
                        transform();
                        GLUtil.getTransform(currentTransform);                  
                }
                
                void spin(Port port){
                        Vector3f should=traverse(parent, port.center);                                  
                        orientation.rotate((float)Math.PI/2, port.normal);
                        retransform();                  
                        Vector3f is=traverse(parent, port.center);                                      
                        Vector3f.sub(position, is, position);
                        Vector3f.add(position, should, position);
                }
        
                void handleEvent(VisMouseEvent evt) {
                        super.handleEvent(evt);
                        if (evt.getID()==MouseEvent.MOUSE_CLICKED){
                                Vector3f hit=evt.hit;
                                
                                //find nearest port to the 3d hit position
                                Port nearest=null;
                                float min=Float.MAX_VALUE;
                                for (Port p: ports){
                                        float d=Vector3f.sub(hit, p.center, null).length();
                                        if (d<min){
                                                min=d; 
                                                nearest=p;
                                        }
                                }
                                                                
                                //spin nearest.
                                if (nearest!=null) 
                                        spin(nearest);
                        }
                }
        } 
        
        
        void renderSelf() {
        
                final float SNAP=20;
                for (VisNode n1: children)
                        if (n1 instanceof VisDuct && ((VisDuct)n1).isDragged)
                                for(VisNode n2: children)
                                        if (n2 instanceof VisDuct && n2!=n1){
                                                VisDuct d1=(VisDuct)n1, d2=(VisDuct)n2;
                                                for (Port p1: d1.ports)
                                                        for (Port p2:d2.ports)
                                                                if (Vector3f.sub(d1.traverse(d2, p1.center),p2.center,null).length()<SNAP){
                                                                        d1.candidate=p2; d1.candidateOwn=p1;
                                                                        d2.candidate=p1; d2.candidateOwn=p2;
                                                                        return;
                                                                }                                                                                                                                                                       
                                        }               
        }

}

---