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

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import org.dronus.gl.GLSphereRenderer;
import org.dronus.graph.Node;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

class VisBalistic extends VisNode{
        
        public Vector3f target=new Vector3f(50,-20,0);

        VisBalistic(Node node, Vector3f pos) {
                super(node, pos);
                
                radius=Float.MAX_VALUE;
        }
        
        float heading; 
        float elevation;
        
        float G=9.81f, v0=20, y0; 
        
        double wurfweite (double a){
                double s=Math.sin(a);
                double r= v0*Math.cos(a)*( v0*s + Math.sqrt(v0*v0*s*s+2*G*y0 )) / G;
                return r;
        }

        float invWurfweite(double X){
                double  d=1E-12f,//Schrittweite zum schätzen der Ableitung
                                e=1E-6f; //erlaubte Ungenauigkeit
                double  a=0, //Winkel (Startwert ist ~40 Grad.)
                                f;        //Funktionswert (ist-soll) zum aktuellen Winkel
                int i=0;        //Iterationszähler
                
                /*
                 * Das Newtonverfahren
                 * Wir ziehen den Sollwert X von der Wurfweite ab und erhalten 
                 * damit eine Funktion f, die 0 werden muss. Das leistet das Newtonverfahren: In jedenm
                 * Schritt wird eine Tangente an die Funktion angelegt, und deren Schnittpunkt mit der
                 * x-Achse bestimmt. Von dort aus geht es dann weiter.
                 * Das Verfahren konvergiert sehr schnell, wenn es denn konvergiert; 
                 * wenn man Pech hat osziliert es zwischen mehreren Nullstellen oder schaukelt sich auf.
                 */
                do{ //je ein Newtonschritt:
                        if (i++>10) 
                                return Float.NaN;
                        double df=0;
                        f=  wurfweite(a)-X;                                     //Funktionswert ist - soll
                        df=(wurfweite(a)-wurfweite(a-d))/d;     //Ableitung von ist - soll
                
                        //System.out.println(f+" "+df+" "+a);
                        
                        a=a-f/df;       //neues a ist jetzt Schnitt der Tangente durch a mit der x-Achse
                        
                        //      System.out.println("f:"+f+" da:"+a);
                }while(Math.abs(f)>e); //Toleranz erreicht?
                
                return (float)a;
        }
        
        double bestAngle(double y){
                return Math.asin(v0/Math.sqrt(2*v0*v0+2*G*y));
        }
        
        void renderSelf() {
                
                
                GL11.glDisable(GL11.GL_TEXTURE_2D);
                GLSphereRenderer.renderSphere(1);
                
                if (target!=null)
                        y0=-target.y;
                
                
//                      Zeichne Reichweitenkreise
                drawRanges();

                //letzter wert für r ist fast maximale reichweite
                
                GL11.glColor3f(1,1,1);
                
                if (target==null)       return;
                
                Vector3f v=new Vector3f(target); //Abwurfvektor: Richtung...
                v.y=0;
                float wurfweite=v.length();
                heading=(float) (Math.atan(v.z/v.x)+(v.x<0?Math.PI:0));
                
                //if (wurfweite>r) //in Reichweite?
                        //return;
                
                v.normalise();  
                elevation=invWurfweite(wurfweite);  //Abwurfwinkel berechnen
                
                //System.out.println(heading+" "+elevation);
                
                float s=(float)Math.sin(elevation), c=(float)Math.cos(elevation);
                v.x*=c; v.z*=c; v.y=s;  //Winkel einstellen
                
                v.scale(v0);
                
//                      Zeichne Wurfbahn
                GL11.glBegin(GL11.GL_LINE_STRIP);
                Vector3f p=new Vector3f(); //Aktuelle Position
                
                while(p.y>-y0){ 
                        float dt = .001f; //Schrittweite (in Sekunden)
                        
                        GL11.glVertex3f(p.x,p.y,p.z);           
                        
                        Vector3f dp=new Vector3f(v);
                        dp.scale(dt);   //Strecke=Geschwindigkeit*Zeit  
                        
                        Vector3f.add(p,dp,p);   //Position aktualisieren
                        v.y+=-G*dt;                             //Bewegungsvektor aktualisieren
                }
                GL11.glEnd();
                        
        }

        float drawRanges() {
                float r=0;
                GL11.glColor4f(1,1,1,.3f);
                for (float y=-100; y<y0; y+=3){
                        r=(float)wurfweite(bestAngle(y));  //Reichweite
                        if (r!=Float.NaN){
                                GL11.glBegin(GL11.GL_LINE_STRIP);
                                for (float i=0; i<2*Math.PI; i+=.01f)
                                        GL11.glVertex3f((float)Math.cos(i)*r, -y, (float)Math.sin(i)*r);                
                                GL11.glEnd();
                        }
                }
                return r;
        }               
}

---