VisClient/org/hfbk/vis/VisClient.java

Go to the documentation of this file.

/*
 * Created on 17.03.2008
 *
 */
package org.hfbk.vis;

import java.awt.AWTEvent;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.EventObject;
import java.util.LinkedList;
import java.util.List;

import org.dronus.gl.GLUtil;
import org.hfbk.vis.visnode.VisHUD;
import org.hfbk.vis.visnode.VisNodeMousable;
import org.hfbk.vis.visnode.VisRoot;
import org.hfbk.vis.visnode.VisStructure;
import org.hfbk.vis.visnode.VisWelcome;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.Color;
import org.lwjgl.util.Timer;
import org.lwjgl.util.vector.Vector3f;
public class VisClient{

        //the Panel we draw in 
        public VisClientPanel panel;
        
        //services
        Timer timer = new Timer();
        public float timescale=1;
        public float dt;
        
        List<AWTEvent> events = new LinkedList<AWTEvent>(), oldEvents = new LinkedList<AWTEvent>();
        
        public VisRoot root;

        public VisHUD hud;
        public boolean hudEnabled=true;
        
        public VisNodeMousable hoovered=null;
        
        //viewpoint management
        List<Viewpoint> history = new ArrayList<Viewpoint>();
        int viewpointIndex = -1; 
        public MouseViewpoint mouseViewpoint=new MouseViewpoint();
        public TransitionViewpoint transViewpoint = null;
        public boolean animateViewpoint=false;
        float timeSinceVpSave=0;  
        

        public VisClient(VisClientPanel panel) {
                System.out.println("vis/client revision "+Prefs.current.version);
                this.panel=panel;
        }

        public void reset(){ //
                if (root!=null) root.close(); //stops threads if any 
                root = new VisRoot(this);
                root.add(new VisStructure());
                
                hud = new VisHUD(this);

                panel.removeKeyListener(mouseViewpoint.keys);
                mouseViewpoint=new MouseViewpoint();
                panel.addKeyListener(mouseViewpoint.keys);
                mouseViewpoint.forward(-100);
                mouseViewpoint.angle = -.3f;
                
                history.clear();
                animateViewpoint=false;
                transViewpoint=null;
                
                if (Prefs.current.init.length()>0){
                        try{
                                new VisClientScripter(this).evaluate(Prefs.current.init);
                        }catch(Exception e){
                                System.out.println("Init script failed! Check prefs->init!");
                        }
                }
                
                System.gc();
                System.runFinalization();
        }
        
        public void resetValues() {
                timescale=1;
                mouseViewpoint.fov=Viewpoint.DEFAULT_FOV;
        }

        public void init() {
                GLUtil.init(); // some gl default setup

                reset();
                root.add(new VisWelcome());
        }

        
        AWTEvent lastDragEvent=null;
        public void processEvent(AWTEvent e) {
                
                if (mouseViewpoint.drag && e instanceof MouseEvent){
                        mouseViewpoint.handleEvent((MouseEvent) e); //handle right here instead of in paintGL()
                        lastDragEvent=null;
                }else{
                        events.add(e);
                        
                        if (e.getID()==MouseEvent.MOUSE_DRAGGED) lastDragEvent=e;
                        else if (e.getID()==MouseEvent.MOUSE_RELEASED) lastDragEvent=null;
                }
                
                
        }
                
        public void paintGL(int w, int h) {
                
                // got time since last frame
                Timer.tick();   
                dt = timer.getTime()*timescale;
                timer.reset();
                
                timeSinceVpSave+=dt;
                if (timeSinceVpSave>4){
                        saveVewpoint();
                        timeSinceVpSave=Float.NEGATIVE_INFINITY; //never save again until moved.
                        hud.notifyUser();
                }
                
                coerceEvents();
                
                oldEvents.addAll(events); // remember events to detect new ones

                // lets begin rendering.
                //GL11.glColor4d(6, 6, 6, 0);
                GLUtil.aspect = w / (float) h;
                GL11.glViewport(0, 0, w, h); // may have changed due to window resizing!                
                GLUtil.initFrustum(GLUtil.fov, .1, 300); // set the perspective transform

                Color c=GLUtil.backgroundcolor;
                GL11.glClearColor(c.getRed()/256f, c.getGreen()/256f, c.getBlue()/256f, c.getAlpha()/256f);
                
                GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

                
                // set the camera transform
                if (transViewpoint != null) {// are we just in transition?
                        transViewpoint.render(dt);
                        if (transViewpoint.checkArrived()) {
                                // the  transition just finished.
                                mouseViewpoint.set(transViewpoint);
                                transViewpoint = null;
                                
                                if (animateViewpoint) //animation, so continue with further vps. 
                                        stepViewpoint(1); 
                        }
                } else {
                        mouseViewpoint.render(dt);
                        if (mouseViewpoint.moving)
                                timeSinceVpSave=0; //only save a vp if resting for some secs
                }

                // now render all visual nodes, respecting incoming events
                root.render(events);
                
                //render the HUD overlay
                hud.render(events); 

                for (AWTEvent e : events) // let the viewpoint process its events..
                        if (e instanceof MouseEvent)
                                mouseViewpoint.handleEvent((MouseEvent) e);

                for (EventObject e : oldEvents) // clear all events except new issued ones.
                        events.remove(e);
                oldEvents.clear();
        }

        void coerceEvents() {
                //      dirty: push back last drag event to allow dragging by camera mvmnt.
                if (mouseViewpoint.moving && lastDragEvent!=null && lastDragEvent.getID()==MouseEvent.MOUSE_DRAGGED)
                        events.add(lastDragEvent);
                //TODO  corerce events!!!
                //List<AWTEvent> tmp=events.clone();
        }

        public void setViewpoint(Viewpoint vp, float speed) {
                if (transViewpoint!=null)
                        mouseViewpoint.set(transViewpoint);
                transViewpoint = new TransitionViewpoint(mouseViewpoint, vp, speed);
        }
        
        public void setViewpoint(Vector3f vposition, float speed) {
                Viewpoint vp=new Viewpoint(vposition, 0, 0);
                vp.z += 40;
                setViewpoint(vp, speed);
        }

        public void setLookAt(Vector3f position) {

                Vector3f eye = new Vector3f(mouseViewpoint);

                Vector3f dir = Vector3f.sub(eye, position, null);
                
                //calculate heading
                float angle = (float) Math.atan(dir.x / dir.z);
                if (dir.z < 0)
                        angle += Math.PI;

                eye.y = position.y; //set height

                setViewpoint(new Viewpoint(eye, angle, 0),1);
        }
        
        public void stepViewpoint(int direction){
                
                if (transViewpoint!=null) //we interrupt or continue a existing transition
                        mouseViewpoint.set(transViewpoint);//get back its current position
                
                int s=history.size();
                viewpointIndex=(viewpointIndex+direction+s)%s;          
                
                if (viewpointIndex>=0)
                        transViewpoint = new TransitionViewpoint(mouseViewpoint, history.get(viewpointIndex), .4f);
        }
        public boolean saveVewpoint() {
                //check if we just added this vp to prevent double vps if user presses button too much :-)
                if (! (history.size()>0 && mouseViewpoint.equals(history.get(history.size()-1)))){
                        history.add(mouseViewpoint.clone());
                        return true;
                }
                return false;
        }
        public void animateViewpoint(boolean animate) {
                if (animate && history.size() > 0) {
                        stepViewpoint(1);
                        animateViewpoint=true;
                } else if (transViewpoint!=null){                       
                        mouseViewpoint.set(transViewpoint);
                        transViewpoint = null;
                        animateViewpoint=false;
                }               
        }
        
        public static void main(String[] args) throws Exception{

                Prefs.current.load();
                if (args.length>0)
                        Prefs.current.parse(args);      
                else 
                        Prefs.addShutdownHook(); //register Prefs to save itself on exit
                
                //get a working vis server.
                new ServerManager().start();
                
                //let's go!
                new VisClientWindow();
        }
}

---