--- a/render/render.d	Fri Mar 27 19:26:01 2009 -0400
+++ b/render/render.d	Mon Mar 30 12:41:29 2009 -0400
@@ -30,12 +30,7 @@
  */
 module openmelee.render.render;
 
-import tango.math.Math : PI;
-
-import xf.dog.Dog;
-import xf.omg.core.LinearAlgebra;
-import xf.hybrid.Event;
-import xf.hybrid.Font;
+import tango.math.Math : PI, cos, sin;
 
 import blaze.bzWorld : bzWorld;
 import blaze.dynamics.bzBody : bzBody;
@@ -51,6 +46,11 @@
 
 import openmelee.ships.ship : Ship, State;
 import openmelee.melee.melee : Settings;
+import openmelee.ai.human : Human;
+
+import derelict.opengl.gl;
+import derelict.opengl.glu;
+import openmelee.glfw.glfw;
 
 // Cursor scale factor
 const CURSORSIZE = 0.05f;
@@ -65,6 +65,8 @@
 const MIN_DIMENSION = 0.1;
 const MAX_CIRCLE_RES = 32;
 
+Human human;
+
 /// Color for drawing. Each value has the range [0,1].
 struct Color {
     static Color opCall(float r, float g, float b)
@@ -81,28 +83,69 @@
     float b = 0;
 }
 
+void key(int a, int b) {
+    human.onKey(a, b);
+}
+
 class Render 
 {
 
 	float zoom = 40;
-	vec2 viewCenter;
+	bzVec2 viewCenter;
     bzWorld world;
-    vec2i screenSize;
+    bzVec2 screenSize;
     bool scaling = false;
     bool full = false;
     Settings settings;
     Ship ship1, ship2;
     
-    this(bzWorld world, Ship s1, Ship s2, Settings settings) {
+    this(bzWorld world, Ship s1, Ship s2, Human h, Settings settings) {
+        
+        human = h;
         this.settings = settings;
         ship1 = s1;
         ship2 = s2;
         this.world = world;
-        viewCenter = vec2(10, 10);
-        screenSize = vec2i.zero;
+        viewCenter = bzVec2(10, 10);
+        screenSize = bzVec2(800, 600);
+
+        DerelictGL.load();
+        DerelictGLU.load();
+        DerelictGLFW.load();
+        glfwInit();
+        
+        // Open window
+        int width = cast(int) screenSize.x;
+        int height = cast(int) screenSize.y;
+        int ok = glfwOpenWindow(width, height, 8, 8, 8, 8, 8, 0, GLFW_WINDOW);
+
+        if(!ok) {
+            assert(0, "error loading window");
+        }
+        
+        glfwSetWindowTitle("OpenMelee");
+        glfwEnable(GLFW_STICKY_KEYS);
+        
+    }
+    
+    ~this() {
+        glfwTerminate();
+    }
+    
+    void update() {
+        // Limit the fps
+        glfwSwapInterval(1);
+        draw();
+        glfwSwapBuffers();
+    }
+    
+    void keys() {
+        GLFWkeyfun cbfun;
+        cbfun = &key;
+        glfwSetKeyCallback(cbfun);
     }
 
-    void drawCircle(GL gl, vec2 center, float radius, bool water = false, float theta = float.nan)
+    void drawCircle(bzVec2 center, float radius, bool water = false, float theta = float.nan)
     {
         int segs = cast(int)(radius) + 20;
         if (segs > MAX_CIRCLE_RES) segs = MAX_CIRCLE_RES;
@@ -110,114 +153,123 @@
 
         auto realTheta = (theta <>= 0 ? theta : 0);
         if (water) {
-            gl.immediate(GL_TRIANGLE_FAN,
+            glBegin(GL_TRIANGLE_FAN);
             {
-                gl.Vertex2fv(center.ptr);
+                glVertex2f(center.x, center.y);
                 for (int n = 0; n <= segs; n++) {
                     double rads = n * coef;
-                    gl.Vertex2f(radius * cos(rads + realTheta) + center.x, radius * sin(rads + realTheta) + center.y);
+                    glVertex2f(radius * cos(rads + realTheta) + center.x, radius * sin(rads + realTheta) + center.y);
                 }
-            });
+            }
+            glEnd();
         }
 
-        gl.immediate(GL_LINE_STRIP,
+        glBegin(GL_LINE_STRIP);
         {
             for (int n = 0; n <= segs; n++) {
                 double rads = n * coef;
-                gl.Vertex2f(radius * cos(rads + realTheta) + center.x, radius * sin(rads + realTheta) + center.y);
+                glVertex2f(radius * cos(rads + realTheta) + center.x, radius * sin(rads + realTheta) + center.y);
             }
             if (theta <>= 0)
-                gl.Vertex2fv(center.ptr);
-        });
+                glVertex2f(center.x, center.y);
+        }
+        glEnd();
     }
 
-    void drawSolidCircle(GL gl, vec2 center, float radius, vec2 axis, Color color)
+    void drawSolidCircle(bzVec2 center, float radius, bzVec2 axis, Color color)
     {
         const k_segments = 25.0f;
         const k_increment = 2.0f * PI / k_segments;
         float theta = 0.0f;
-        gl.Enable(GL_BLEND);
-        gl.BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-        gl.Color4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
-        gl.Begin(GL_TRIANGLE_FAN);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glColor4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
+        glBegin(GL_TRIANGLE_FAN);
         for (int i = 0; i < k_segments; ++i) {
-            vec2 v = center + radius * vec2(cos(theta), sin(theta));
-            gl.Vertex2f(v.x, v.y);
+            bzVec2 v = center + radius * bzVec2(cos(theta), sin(theta));
+            glVertex2f(v.x, v.y);
             theta += k_increment;
         }
-        gl.End();
-        gl.Disable(GL_BLEND);
+        glEnd();
+        glDisable(GL_BLEND);
 
         theta = 0.0f;
-        gl.Color4f(color.r, color.g, color.b, 1.0f);
-        gl.Begin(GL_LINE_LOOP);
+        glColor4f(color.r, color.g, color.b, 1.0f);
+        glBegin(GL_LINE_LOOP);
         for (int i = 0; i < k_segments; ++i) {
-            vec2 v = center + radius * vec2(cos(theta), sin(theta));
-            gl.Vertex2f(v.x, v.y);
+            bzVec2 v = center + radius * bzVec2(cos(theta), sin(theta));
+            glVertex2f(v.x, v.y);
             theta += k_increment;
         }
-        gl.End();
+        glEnd();
 
-        vec2 p = center + radius * axis;
-        gl.Begin(GL_LINES);
-        gl.Vertex2f(center.x, center.y);
-        gl.Vertex2f(p.x, p.y);
-        gl.End();
+        bzVec2 p = center + radius * axis;
+        glBegin(GL_LINES);
+        glVertex2f(center.x, center.y);
+        glVertex2f(p.x, p.y);
+        glEnd();
     }
 
-    void drawPolygon(GL gl, vec2[] glVerts, Color color)
+    void drawPolygon(bzVec2[] glVerts, Color color)
     {
-        gl.Color3f(color.r, color.g, color.b);
-        gl.immediate(GL_LINE_LOOP,
+        glColor3f(color.r, color.g, color.b);
+        glBegin(GL_LINE_LOOP);
         {
-            foreach (v; glVerts)
-                gl.Vertex2fv(v.ptr);
-        });
+            foreach (v; glVerts) {
+                glVertex2f(v.x, v.y);
+            }
+        }
+        glEnd();
     }
 
-    void drawSolidPolygon(GL gl, vec2[] vertices, Color color)
+    void drawSolidPolygon(bzVec2[] vertices, Color color)
     {
-        gl.Enable(GL_BLEND);
-        gl.BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-        gl.Color4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
-        gl.Begin(GL_TRIANGLE_FAN);
-        for (int i = 0; i < vertices.length; ++i) {
-            gl.Vertex2f(vertices[i].x, vertices[i].y);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glColor4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
+        glBegin(GL_TRIANGLE_FAN);
+        {
+            for (int i = 0; i < vertices.length; ++i) {
+                glVertex2f(vertices[i].x, vertices[i].y);
+            }
         }
-        gl.End();
-        gl.Disable(GL_BLEND);
+        glEnd();
+        glDisable(GL_BLEND);
 
-        gl.Color4f(color.r, color.g, color.b, 1.0f);
-        gl.Begin(GL_LINE_LOOP);
-        for (int i = 0; i < vertices.length; ++i) {
-            gl.Vertex2f(vertices[i].x, vertices[i].y);
+        glColor4f(color.r, color.g, color.b, 1.0f);
+        glBegin(GL_LINE_LOOP);
+        {
+            for (int i = 0; i < vertices.length; ++i) {
+                glVertex2f(vertices[i].x, vertices[i].y);
+            }
         }
-        gl.End();
+        glEnd();
     }
 
 
-    void drawPoint(GL gl, vec2 p, float size, Color color)
+    void drawPoint(bzVec2 p, float size, Color color)
     {
-        gl.Color3f(color.r, color.g, color.b);
-        gl.PointSize(size);
-        gl.Begin(GL_POINTS);
-        gl.Vertex2f(p.x, p.y);
-        gl.End();
-        gl.PointSize(1.0f);
+        glColor3f(color.r, color.g, color.b);
+        glPointSize(size);
+        glBegin(GL_POINTS);
+        glVertex2f(p.x, p.y);
+        glEnd();
+        glPointSize(1.0f);
     }
 
-    void drawSegment(GL gl, vec2 begin, vec2 end, Color color)
+    void drawSegment(bzVec2 begin, bzVec2 end, Color color)
     {
-        gl.Color3f(color.r, color.g, color.b);
-        gl.immediate(GL_LINES,
+        glColor3f(color.r, color.g, color.b);
+        glBegin(GL_LINES);
         {
-            gl.Vertex2fv(begin.ptr);
-            gl.Vertex2fv(end.ptr);
-        });
+            glVertex2f(begin.x, begin.y);
+            glVertex2f(end.x, end.y);
+        }
+        glEnd();
     }
 
     // TODO: handle inequal radii correctly
-    void connectCircles(GL gl, vec2 center1, float radius1, vec2 center2, float radius2)
+    void connectCircles(bzVec2 center1, float radius1, bzVec2 center2, float radius2)
     {
         auto d = center2 - center1;
         if (!d.length)
@@ -225,58 +277,60 @@
         d *= (d.length - radius1) / d.length;
         center1 += d;
         center2 -= d;
-        gl.immediate(GL_LINES,
+        glBegin(GL_LINES);
         {
-            gl.Vertex2fv(center1.ptr);
-            gl.Vertex2fv(center2.ptr);
-        });
+            glVertex2f(center1.x, center1.y);
+            glVertex2f(center2.x, center2.y);
+        }
+        glEnd();
     }
 
-    void drawXForm(GL gl, bzXForm xf)
+    void drawXForm(bzXForm xf)
     {
         bzVec2 p1 = xf.position, p2;
         const k_axisScale = 0.4f;
 
-        gl.Begin(GL_LINES);
+        glBegin(GL_LINES);
         {
-            gl.Color3f(1.0f, 0.0f, 0.0f);
-            gl.Vertex2f(p1.x, p1.y);
+            glColor3f(1.0f, 0.0f, 0.0f);
+            glVertex2f(p1.x, p1.y);
             p2 = p1 + k_axisScale * xf.R.col1;
-            gl.Vertex2f(p2.x, p2.y);
+            glVertex2f(p2.x, p2.y);
 
-            gl.Color3f(0.0f, 1.0f, 0.0f);
-            gl.Vertex2f(p1.x, p1.y);
+            glColor3f(0.0f, 1.0f, 0.0f);
+            glVertex2f(p1.x, p1.y);
             p2 = p1 + k_axisScale * xf.R.col2;
-            gl.Vertex2f(p2.x, p2.y);
+            glVertex2f(p2.x, p2.y);
         }
-        gl.End();
+        glEnd();
     }
 
-    void drawSpring(GL gl, vec2 a, vec2 b, uint zigs)
+    void drawSpring(bzVec2 a, bzVec2 b, uint zigs)
     {
         zigs++;
 
         // Portion of length dedicated to connectors
         const float connPart = 0.2;
 
-        vec2 inc = (b - a) / (zigs);
+        bzVec2 inc = (b - a) / (zigs);
         // One step from a to b
-        vec2 zigLen = inc * (1 - connPart);
+        bzVec2 zigLen = inc * (1 - connPart);
         // Length of a connector
-        vec2 connLen = inc * (connPart / 2) * zigs;
+        bzVec2 connLen = inc * (connPart / 2) * zigs;
         // Width of a zig
-        vec2 zigWidth = (b - a).rotatedHalfPi.normalized;
-        gl.immediate(GL_LINE_STRIP,
+        bzVec2 zigWidth = (b - a).rotate(PI/2);
+        zigWidth.normalize;
+        glBegin(GL_LINE_STRIP);
         {
-            gl.Vertex2fv(a.ptr);
+            glVertex2f(a.x, a.y);
 
             a += connLen;
-            gl.Vertex2fv(a.ptr);
+            glVertex2f(a.x, a.y);
 
             bool dir = true;
             a += zigWidth / 2 + zigLen / 2;
             for (int i = 0; i < zigs; i++) {
-             gl.Vertex2fv(a.ptr);
+             glVertex2f(a.x, a.y);
              a += zigLen;
              if (dir) {
                  a -= zigWidth;
@@ -286,12 +340,13 @@
              dir = !dir;
             }
 
-            gl.Vertex2fv((b - connLen).ptr);
-            gl.Vertex2fv(b.ptr);
-        });
+            glVertex2f((b - connLen).x, (b - connLen).y);
+            glVertex2f(b.x, b.y);
+        }
+        glEnd();
     }
 
-    void drawShape(GL gl, bzShape shape, bzXForm xf, Color color, bool core)
+    void drawShape(bzShape shape, bzXForm xf, Color color, bool core)
     {
         Color coreColor = Color(0.9f, 0.6f, 0.6f);
 
@@ -299,36 +354,30 @@
         case bzShapeType.CIRCLE:
             auto circle = cast(bzCircle)shape;
 
-            vec2 center = vec2.from(bzMul(xf, circle.localPosition));
+            bzVec2 center = bzMul(xf, circle.localPosition);
             float radius = circle.radius;
-            vec2 axis = vec2.from(xf.R.col1);
+            bzVec2 axis = xf.R.col1;
 
-            gl.drawSolidCircle(center, radius, axis, color);
+            drawSolidCircle(center, radius, axis, color);
 
             if (core) {
-                gl.Color3f(coreColor.r, coreColor.g, coreColor.b);
-                gl.drawCircle(center, radius - k_toiSlop);
+                glColor3f(coreColor.r, coreColor.g, coreColor.b);
+                drawCircle(center, radius - k_toiSlop);
             }
             break;
         case bzShapeType.POLYGON:
         {
             bzPolygon poly = cast(bzPolygon)shape;
             bzVec2[] vertices = poly.worldVertices;
-            vec2[]  verts;
-            verts.length = vertices.length;
-            foreach (int i, v; vertices) {
-                verts[i] = vec2.from(v);
-            }
-
-            gl.drawSolidPolygon(verts, color);
+            drawSolidPolygon(vertices, color);
 
             if (core) {
                 bzVec2[] localCoreVertices = poly.coreVertices;
-                verts.length = localCoreVertices.length;
+                vertices.length = localCoreVertices.length;
                 for (int i = 0; i < localCoreVertices.length; ++i) {
-                    verts[i] = vec2.from(bzMul(xf, localCoreVertices[i]));
+                    vertices[i] = bzMul(xf, localCoreVertices[i]);
                 }
-                gl.drawPolygon(verts, coreColor);
+                drawPolygon(vertices, coreColor);
             }
         }
         break;
@@ -337,50 +386,48 @@
         {
             bzEdge edge = cast(bzEdge)shape;
 
-            vec2 p1 = vec2.from(bzMul(xf, edge.vertex1));
-            vec2 p2 = vec2.from(bzMul(xf, edge.vertex2));
-            gl.drawSegment(p1, p2, color);
+            bzVec2 p1 = bzMul(xf, edge.vertex1);
+            bzVec2 p2 = bzMul(xf, edge.vertex2);
+            drawSegment(p1, p2, color);
 
             if (core) {
-                p1 = vec2.from(bzMul(xf, edge.coreVertex1));
-                p2 = vec2.from(bzMul(xf, edge.coreVertex2));
-                gl.drawSegment(p1, p2, coreColor);
+                p1 = bzMul(xf, edge.coreVertex1);
+                p2 = bzMul(xf, edge.coreVertex2);
+                drawSegment(p1, p2, coreColor);
             }
         }
         break;
         }
     }
 
-    void draw(vec2i screenSize, GL gl)
-    {
+    void draw() {
+        
        if(ship2) {
-            vec2 point1 = vec2.from(ship1.rBody.position);
-            vec2 point2 = vec2.from(ship2.rBody.position);
-            vec2 range = point1 - point2;
+            bzVec2 point1 = ship1.rBody.position;
+            bzVec2 point2 = ship2.rBody.position;
+            bzVec2 range = point1 - point2;
             zoom = bzClamp(1000/range.length, 2, 60);
             viewCenter = point1 - (range * 0.5f);
         } else {
-             viewCenter = vec2.from(ship1.rBody.position);
+             viewCenter = ship1.rBody.position;
              zoom = 10;
         }
- 
-        this.screenSize = screenSize;
-
-        gl.LoadIdentity();
-        gl.MatrixMode(GL_PROJECTION);
-        gl.LoadIdentity();
+        
+        glLoadIdentity();
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
         
         float left = -screenSize.x / zoom;
         float right = screenSize.x / zoom;
         float bottom = -screenSize.y / zoom;
         float top = screenSize.y / zoom;
 
-        gl.gluOrtho2D(left, right, bottom, top);
-        gl.Translatef(-viewCenter.x, -viewCenter.y, 0);
-        gl.MatrixMode(GL_MODELVIEW);
-        gl.Disable(GL_DEPTH_TEST);
-        gl.LoadIdentity();
-        gl.Clear(GL_COLOR_BUFFER_BIT);
+        gluOrtho2D(left, right, bottom, top);
+        glTranslatef(-viewCenter.x, -viewCenter.y, 0);
+        glMatrixMode(GL_MODELVIEW);
+        glDisable(GL_DEPTH_TEST);
+        glLoadIdentity();
+        glClear(GL_COLOR_BUFFER_BIT);
 
         // Draw dynamic bodies
         if (settings.drawShapes) {
@@ -389,15 +436,15 @@
                     bzShape s = shape;
                     bzXForm xf = b.xf;
                     if (b.isStatic) {
-                        gl.drawShape(s, xf, Color(0.5f, 0.9f, 0.5f), settings.drawCoreShapes);
+                        drawShape(s, xf, Color(0.5f, 0.9f, 0.5f), settings.drawCoreShapes);
                     }else if (b.isSleeping) {
-                        gl.drawShape(s, xf, Color(0.5f, 0.5f, 0.9f), settings.drawCoreShapes);
+                        drawShape(s, xf, Color(0.5f, 0.5f, 0.9f), settings.drawCoreShapes);
                     }else {
-                        gl.drawShape(s, xf, Color(0.9f, 0.9f, 0.9f), settings.drawCoreShapes);
+                        drawShape(s, xf, Color(0.9f, 0.9f, 0.9f), settings.drawCoreShapes);
                     }
 
-                    gl.LoadIdentity();
-                    gl.Flush();
+                    glLoadIdentity();
+                    glFlush();
                 }
             }
         }
@@ -418,18 +465,18 @@
                 if (distance) {
                     color = Color(.5, .5, 0);
                     // Endpoints
-                    vec2 a = vec2.from(distance.anchor1);
-                    vec2 b = vec2.from(distance.anchor2);
+                    bzVec2 a = bzVec2.from(distance.anchor1);
+                    bzVec2 b = bzVec2.from(distance.anchor2);
                     // Circles
                     gl.drawCircle(a, HINGE_RADIUS);
                     gl.drawCircle(b, HINGE_RADIUS);
                     // Connecting line
                     gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
                 }else if (pulley) {
-                    auto a = vec2.from(pulley.anchor1);
-                    auto b = vec2.from(pulley.groundAnchor1);
-                    auto c = vec2.from(pulley.groundAnchor2);
-                    auto d = vec2.from(pulley.anchor2);
+                    auto a = bzVec2.from(pulley.anchor1);
+                    auto b = bzVec2.from(pulley.groundAnchor1);
+                    auto c = bzVec2.from(pulley.groundAnchor2);
+                    auto d = bzVec2.from(pulley.anchor2);
                     gl.drawCircle(a, HINGE_RADIUS);
                     gl.drawCircle(b, HINGE_RADIUS);
                     gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
@@ -438,27 +485,27 @@
                     gl.drawCircle(d, HINGE_RADIUS);
                     gl.connectCircles(c, HINGE_RADIUS, d, HINGE_RADIUS);
                 }else if (revolute) {
-                    auto a = vec2.from(revolute.rBody1.position);
-                    auto b = vec2.from(revolute.anchor1);
-                    auto c = vec2.from(revolute.rBody2.position);
+                    auto a = bzVec2.from(revolute.rBody1.position);
+                    auto b = bzVec2.from(revolute.anchor1);
+                    auto c = bzVec2.from(revolute.rBody2.position);
                     gl.drawCircle(a, HINGE_RADIUS);
                     gl.drawCircle(b, HINGE_RADIUS);
                     gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
                     gl.drawCircle(c, HINGE_RADIUS);
                     gl.connectCircles(b, HINGE_RADIUS, c, HINGE_RADIUS);
                 }else if (prismatic) {
-                    auto a = vec2.from(prismatic.rBody1.position);
-                    auto b = vec2.from(prismatic.anchor1);
-                    auto c = vec2.from(prismatic.rBody2.position);
+                    auto a = bzVec2.from(prismatic.rBody1.position);
+                    auto b = bzVec2.from(prismatic.anchor1);
+                    auto c = bzVec2.from(prismatic.rBody2.position);
                     gl.drawCircle(a, HINGE_RADIUS);
                     gl.drawCircle(b, HINGE_RADIUS);
                     gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
                     gl.drawCircle(c, HINGE_RADIUS);
                     gl.connectCircles(b, HINGE_RADIUS, c, HINGE_RADIUS);
                 }else if (line) {
-                    auto a = vec2.from(line.rBody1.position);
-                    auto b = vec2.from(line.anchor1);
-                    auto c = vec2.from(line.rBody2.position);
+                    auto a = bzVec2.from(line.rBody1.position);
+                    auto b = bzVec2.from(line.anchor1);
+                    auto c = bzVec2.from(line.rBody2.position);
                     gl.drawCircle(a, HINGE_RADIUS);
                     gl.drawCircle(b, HINGE_RADIUS);
                     gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
@@ -480,8 +527,8 @@
                         if (bungee1) {
                             gl.Color3f(.5, .5, 0);
                             // Endpoints
-                            vec2 a = vec2.from(bungee1.rBody.position);
-                            vec2 b = vec2.from(bungee1.anchor);
+                            bzVec2 a = bzVec2.from(bungee1.rBody.position);
+                            bzVec2 b = bzVec2.from(bungee1.anchor);
                             // Circles
                             gl.drawCircle(a, HINGE_RADIUS);
                             gl.drawCircle(b, HINGE_RADIUS);
@@ -489,8 +536,8 @@
                             gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
                         }else {
                             uint zigs = 10;
-                            auto anchor1 = vec2.from(spring1.anchor);
-                            auto anchor2 = vec2.from(spring1.rBody.position);
+                            auto anchor1 = bzVec2.from(spring1.anchor);
+                            auto anchor2 = bzVec2.from(spring1.rBody.position);
                             gl.drawSpring(anchor1, anchor2, zigs);
                         }
                     }
@@ -500,8 +547,8 @@
                         if (bungee2) {
                             gl.Color3f(.5, .5, 0);
                             // Endpoints
-                            vec2 a = vec2.from(bungee2.rBody.position);
-                            vec2 b = vec2.from(bungee2.otherBody.position);
+                            bzVec2 a = bzVec2.from(bungee2.rBody.position);
+                            bzVec2 b = bzVec2.from(bungee2.otherBody.position);
                             // Circles
                             gl.drawCircle(a, HINGE_RADIUS);
                             gl.drawCircle(b, HINGE_RADIUS);
@@ -509,16 +556,16 @@
                             gl.connectCircles(a, HINGE_RADIUS, b, HINGE_RADIUS);
                         }else {
                             uint zigs = 10;
-                            auto anchor1 = vec2.from(spring2.otherBody.position);
-                            auto anchor2 = vec2.from(spring2.rBody.position);
+                            auto anchor1 = bzVec2.from(spring2.otherBody.position);
+                            auto anchor2 = bzVec2.from(spring2.rBody.position);
                             gl.drawSpring(anchor1, anchor2, zigs);
                         }
                     }
 
                     if(buoyancy) {
                         float plane = buoyancy.planeOffset;
-                        vec2 p1 = vec2(-50, plane);
-                        vec2 p2 = vec2(50, plane);
+                        bzVec2 p1 = bzVec2(-50, plane);
+                        bzVec2 p2 = bzVec2(50, plane);
                         gl.drawSegment(p1, p2, color);
                     }
                 }
@@ -531,12 +578,12 @@
         bzVec2 worldLower = bp.m_worldAABB.lowerBound;
         bzVec2 worldUpper = bp.m_worldAABB.upperBound;
         Color color = Color(0.3f, 0.9f, 0.9f);        
-        vec2 vs[4];
-        vs[0] = vec2(worldLower.x, worldLower.y);
-        vs[1] = vec2(worldUpper.x, worldLower.y);
-        vs[2] = vec2(worldUpper.x, worldUpper.y);
-        vs[3] = vec2(worldLower.x, worldUpper.y);
-        drawPolygon(gl, vs, color);
+        bzVec2 vs[4];
+        vs[0] = bzVec2(worldLower.x, worldLower.y);
+        vs[1] = bzVec2(worldUpper.x, worldLower.y);
+        vs[2] = bzVec2(worldUpper.x, worldUpper.y);
+        vs[3] = bzVec2(worldLower.x, worldUpper.y);
+        drawPolygon(vs, color);
         
         // Draw axis aligned bounding boxes (bzAABB)
         if (settings.drawAABBs) {
@@ -556,12 +603,12 @@
                 b.upperBound.x = worldLower.x + invQ.x * bp.m_bounds[0][p.upperBounds[0]].value;
                 b.upperBound.y = worldLower.y + invQ.y * bp.m_bounds[1][p.upperBounds[1]].value;
 
-                vs[0] = vec2(b.lowerBound.x, b.lowerBound.y);
-                vs[1] = vec2(b.upperBound.x, b.lowerBound.y);
-                vs[2] = vec2(b.upperBound.x, b.upperBound.y);
-                vs[3] = vec2(b.lowerBound.x, b.upperBound.y);
+                vs[0] = bzVec2(b.lowerBound.x, b.lowerBound.y);
+                vs[1] = bzVec2(b.upperBound.x, b.lowerBound.y);
+                vs[2] = bzVec2(b.upperBound.x, b.upperBound.y);
+                vs[3] = bzVec2(b.lowerBound.x, b.upperBound.y);
 
-                drawPolygon(gl, vs, color);
+                drawPolygon(vs, color);
             }
         }
     }