protected override void OnUpdateFrame(FrameEventArgs e) {
            base.OnUpdateFrame(e);

            if (KeyWasReleased(Key.Tilde)) {
                ToggleConsole();
            }
        }

        private void GameWindow_RenderFrame(object sender, FrameEventArgs e)
        {
            GL.Clear(ClearBufferMask.ColorBufferBit);

            //setup blending equation Color = Color_s · alpha + Color_d · (1 - alpha)
            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.BlendEquation(BlendEquationMode.FuncAdd);

            GL.Enable(EnableCap.Blend);
            var rect = new Box2D(-.75f, -.75f, .5f, .5f);
            DrawRect(rect, new Color4(.5f, .7f, .1f, 1));
            rect.X += .25f;
            rect.Y += .25f;
            DrawRect(rect, new Color4(.7f, .5f, .9f, .5f));
            rect.X += .25f;
            rect.Y += .25f;
            DrawRect(rect, new Color4(.7f, .5f, .9f, .5f));
            rect.X += .25f;
            rect.Y += .25f;
            DrawRect(rect, new Color4(.5f, .7f, 1, .5f));
            rect.X += .25f;
            rect.Y += .25f;
            DrawRect(rect, new Color4(.5f, .7f, 1, .5f));
            GL.Disable(EnableCap.Blend);
        }

        /// <summary>
        /// Called when it is time to render the next frame. Add your rendering code here.
        /// </summary>
        /// <param name="e">Contains timing information.</param>
        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            GL.MatrixMode(MatrixMode.Modelview);
            var look = Matrix4.LookAt(3f, 3f, 2f, 0f, 0f, 0f, 0f, 0f, 1f);
            GL.LoadMatrix(ref look);

            var matrixTranslation = Matrix4.CreateTranslation(_translation);
            var matrixRotationx = Matrix4.CreateRotationX(_rotationx);
            var matrixRotationy = Matrix4.CreateRotationY(_rotationy);
            var matrixRotationz = Matrix4.CreateRotationZ(_rotationz);
            GL.MultMatrix(ref matrixTranslation);
            GL.MultMatrix(ref matrixRotationx);
            GL.MultMatrix(ref matrixRotationy);
            GL.MultMatrix(ref matrixRotationz);

            GL.Begin(BeginMode.Triangles);

            for (var iy = -5; iy < 5; iy++)
            {
                for (var i = -5; i < 5; i++)
                {
                    GL.Color3(1.0f, 1.0f, 0.0f); GL.Vertex3(-0.5f + i, -0.5f + iy, 0f);
                    GL.Color3(1.0f, 0.0f, 0.5f); GL.Vertex3(0.5f + i, -0.5f + iy, 0f);
                    GL.Color3(0.2f, 0.9f, 1.0f); GL.Vertex3(0.0f + i, 0.5f + iy, 0f);
                }
            }

            GL.End();

            SwapBuffers();
        }

 private void Game_UpdateFrame(object sender, FrameEventArgs e)
 {
     if (Game.Keyboard[Key.Escape])
     {
         Game.Exit();
     }
 }

        public void Update(FrameEventArgs e)
        {
            RotationCounter = (RotationCounter + 1) % 360;

            WorldData.Chunks.Update(e);
            GameObjects.GameItems.GameItemDynamic.UpdateAll(e);
        }

        static void gameWnd_RenderFrame(object sender, FrameEventArgs e)
        {
            game.Render();

            ((GameWindow)sender).SwapBuffers();

            renderWatch.Stop();

            if (renderWatch.Elapsed.TotalSeconds >= stepInterval)
            {
                float elapsed = (float)renderWatch.Elapsed.TotalSeconds;

                game.Tick(elapsed);

                for (float tickTime = 0f; tickTime < elapsed; tickTime += stepInterval)
                {
                    game.TickPhysics(stepInterval);

                    //if (elapsed - tickTime < 0.008f && elapsed - tickTime > 0.005f)
                    //{
                    //    //game.TickPhysics(elapsed - tickTime);
                    //}
                    //else
                    //{

                    //}
                }

                renderWatch.Restart();
            }
            else
            {
                renderWatch.Start();
            }
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            // Clear the screen
            GL.ClearColor(Color4.Purple);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            // Activate shader program and set uniforms
            this.shaderProgram.Use();
            this.projectionMatrix.Set(this.shaderProgram);

            // Bind vertex buffer and array object
            this.vertexBuffer.Bind();
            this.vertexArray.Bind();

            // Upload vertices to GPU and draw them
            this.vertexBuffer.BufferData();
            this.vertexBuffer.Draw();

            // Reset state for potential further draw calls
            GL.BindVertexArray(0);
            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            GL.UseProgram(0);

            // Swap backbuffer
            this.SwapBuffers();

            // TODO: Render world
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            _shader.Use();
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            SetupCamera();

            //            _cube.Draw();

            var points = new[] { new Vector2(0, 0), new Vector2(1, 2), new Vector2(-1, 1) };
            var aBezierCurve = new BezierCurve(points);

            GL.LineWidth(4.0f);

            CatmullRomSpline a = new CatmullRomSpline();
            a.AddPoint(new Vector3(-1, -1, 0));
            a.AddPoint(new Vector3(1, 1, 0));
            a.AddPoint(new Vector3(1, -1, 0));
            a.AddPoint(new Vector3(-1, 1, 0));
            a.AddPoint(new Vector3(-1, -1, 0));

            Vector3 vec = a.GetValue((float)_time / 10);
            GL.Translate(vec);

            _cube.Draw();

            SwapBuffers();
        }

        /// <summary>
        /// Called when it is time to render the next frame. Add your rendering code here.
        /// </summary>
        /// <param name="e">Contains timing information.</param>
        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);
            Matrix4 lookat = Matrix4.LookAt(0, 5, 5, 0, 0, 0, 0, 1, 0);
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadMatrix(ref lookat);

            //GL.Rotate(angle, 0.0f, 1.0f, 0.0f);
            //angle += 0.1f;
            //GL.Rotate(this.lookupdown, 1.0f, 0.0f, 0.0f);
            GL.Rotate(360.0f - this.yrot, 0.0f, 1.0f, 0.0f);

            GL.Translate(-this.xpos, -this.walkbias - 0.25f, -this.zpos);

               // GL.Rotate(rotateY + this.drY, -1.0f, 0.0f, 0.0f);
            GL.Rotate(xrot, 0.0f, 0.0f, 1.0f);

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.BindTexture(TextureTarget.Texture2D, boxTexture);
            //shapeDraw.rawbox();
            shapeDraw.testBox();
            GL.Translate(2f,0,0);
               // shapeDraw.rawbox();

            SwapBuffers();
        }

		protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);
			
            if (Keyboard[Key.Escape])
                Exit();
        }

		protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
			
			float camDistance = 3.0f;
			float scale = 2.0f;
			Vector3 centerPos = new Vector3(0.0f, -1.0f, 0.0f);
			
			// Front
			GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width / 2, ClientRectangle.Height);
			Rescale();
            Matrix4 modelview = Matrix4.LookAt(new Vector3(0.0f, -1.0f, camDistance), centerPos, Vector3.UnitY);
            GL.MatrixMode(MatrixMode.Modelview);
			GL.LoadIdentity();
            GL.MultMatrix(ref modelview);
			GL.Scale(scale, scale, scale);
			
			RenderJoints();
			
			// Side
			GL.Viewport(ClientRectangle.X + ClientRectangle.Width / 2, ClientRectangle.Y, ClientRectangle.Width / 2, ClientRectangle.Height);
			Rescale();
            modelview = Matrix4.LookAt(new Vector3(camDistance, -1.0f, 0.0f), centerPos, Vector3.UnitY);
            GL.MatrixMode(MatrixMode.Modelview);
			GL.LoadIdentity();
            GL.MultMatrix(ref modelview);
			GL.Scale(scale, scale, scale);
			
			RenderJoints();
			
            SwapBuffers();
        }

    protected override void OnRenderFrame(FrameEventArgs e)
    {
        Tick tick = new Tick();
        base.OnRenderFrame(e);

        GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

        GL.MatrixMode(MatrixMode.Modelview);

        m_camera.UpdateCameraView();
        List<CoordinateEngine.RelativisticObject> ros = universe.GetNPCs();
        lock (ros) {
            foreach (CoordinateEngine.RelativisticObject ro in ros) {
                DrawRelativisticObject (ro);
            }
        }
        lock(universe.bro){
            m_camera.camera_position = CoordinateEngine.toVector3(universe.bro.x);//Loses accuracy in this...
        }
        //DrawRelativisticObject(universe.bro, false);//Don't draw bro if the camera is at bro.

        DrawHUD();

        stats.AddValue(FPS_TAG, tick.Tock());

        this.SwapBuffers();
        Thread.Sleep(1);
    }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame (e);
            //select some bits from a bitmask that represent what we want to clear I guess
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            //create a perspective projection
            Matrix4 perspective = Matrix4.CreatePerspectiveFieldOfView(0.9f, ClientRectangle.Width/(float)ClientRectangle.Height, 0.01f, 1000f);
            //tell openGL we want to set the Projection matrix
            GL.MatrixMode(MatrixMode.Projection);
            //set the projection matrix
            GL.LoadMatrix(ref perspective);

            //builds a world space to camera space matrix up is <0,1,0>
            Matrix4 modelview = Matrix4.LookAt(eye, target, Vector3.UnitY);
            //tell openGL we want to set the modelview matrix to this matrix
            GL.MatrixMode(MatrixMode.Modelview);
            //set it
            GL.LoadMatrix(ref modelview);

            //these coords in world space are multiplied by the world space -> camera matrix to provide something we can see
            //so this is where we want the drawing code to go
            Draw(t);

            if (film)
            {
                using (Bitmap b = GrabScreenshot())	{
                    b.Save(String.Format("{0}.bmp", frame_updates++)) ;
                }
            }

            SwapBuffers();
        }

 protected override void OnUpdateFrame(FrameEventArgs e)
 {
     base.OnUpdateFrame(e);
     if (Keyboard[Key.Escape]) {
         Exit();
     }
     if (Keyboard[Key.Q]) {
         p1.Z -= 0.1F;
     }
     if (Keyboard[Key.Z]) {
         p1.Z += 0.1F;
     }
     if (Keyboard[Key.W]) {
         p1.Y -= 0.1F;
     }
     if (Keyboard[Key.S]) {
         p1.Y += 0.1F;
     }
     if (Keyboard[Key.A]) {
         p1.X -= 0.1F;
     }
     if (Keyboard[Key.D]) {
         p1.X += 0.1F;
     }
 }

        protected override void OnRenderFrame(FrameEventArgs _e)
        {
            m_stopwatch.Restart();
            if (IsActive)
            {
                if (World.TheWorld != null)
                {
                    var avatar = World.TheWorld.Avatar;
                    Title = string.Format("The Hall lc:{0} wc:{1} bld:{2} pmc:{3} fps:{4} per frame, ms:{5}, creatures:{6}",
                                          avatar[0, 0].LiveCoords, avatar[0, 0].WorldCoords, avatar[0, 0].InBuilding,
                                          avatar[0, 0].PathMapCoords, Math.Round(1 / _e.Time), (m_sum / m_cnt),
                                          World.TheWorld.CreatureManager.InfoByCreature.Count);
                }

                m_game.Update(KeyState);
                if (m_needRedraw)
                {
                    m_needRedraw = false;
                    Clear(FColor.Empty);
                    m_game.Draw();
                    OnRenderFinished();
                }
            }
            m_stopwatch.Stop();
            m_sum += m_stopwatch.ElapsedMilliseconds;
            m_cnt++;
            if (m_stopwatch.ElapsedMilliseconds < 1000 / FPS)
            {
                Thread.Sleep(1000 / FPS - (int)m_stopwatch.ElapsedMilliseconds);
            }

        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            // Clear the screen
            GL.ClearColor(0.1f, 0.1f, 0.1f, 1.0f);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            if(texture != null)
            {
                // Bind the texture to use
                texture.Bind();

                // Update the texture quality settings if they have changed
                texture.UpdateQuality();

                // Enable the shader
                shader.Enable();

                // Render the batch
                batch.Render();

                // Clean up frame
                shader.Disable();
                texture.UnBind();
            }

            // Display rendered frame
            SwapBuffers();
        }

 public override void Draw(FrameEventArgs e)
 {
     if (levelmodel != null)
     {
         levelmodel.Draw();
     }
 }

        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);

            if (Keyboard[OpenTK.Input.Key.Escape])
                this.Exit();
        }

        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);

#region interface call
			foreach (KeyboardInterface ki in iter_go)
            {
                ki.OnKeyDown(Keyboard);
            }
			
			foreach (MouseInterface mi in iter_go)
            {
					mi.OnMouseMove(Mouse.XDelta, Mouse.YDelta);
					if (Mouse[OpenTK.Input.MouseButton.Left]){ mi.OnMouseClick(); _mouseclicked = true; }
					if (!Mouse[OpenTK.Input.MouseButton.Left] && _mouseclicked){ mi.OnMouseRelease(); _mouseclicked = false; }
					if (Mouse.WheelPrecise > _wheelvalue) { mi.OnWheelUp(Mouse.WheelPrecise); _wheelvalue = Mouse.WheelPrecise; }
					if (Mouse.WheelPrecise < _wheelvalue) { mi.OnWheelDown(Mouse.WheelPrecise); _wheelvalue = Mouse.WheelPrecise; }
            }
#endregion 
			
			if (Keyboard[OpenTK.Input.Key.Escape])
            {
                Exit();
            }
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);

            GL.LoadIdentity();
            GL.Rotate(rotation, Vector3.UnitZ);

            GL.Clear(ClearBufferMask.ColorBufferBit);

            GL.Begin(BeginMode.Quads);

            GL.BindTexture(TextureTarget.Texture2D, charTextureId); // Bind our texture that we want rendered.

            // Since we are using a texture instead of colors, we can get rid of the Color3() calls and replace
            // them with TexCoord2() calls. We need to describe what part of the image (in X,Y coordinates from
            // 0 to 1) correlates to the point we are rendering. The renderer will work out how the image needs
            // to be drawn for each of the pixels in-between these corner vertices. Additionally, we also
            // changed our Vertex3() calls to draw the points based on the caveman's width/height.
            GL.TexCoord2(0f, 0f); GL.Vertex3(-charSize / 2, charSize / 2, 0);
            GL.TexCoord2(0f, 1f); GL.Vertex3(-charSize / 2, -charSize / 2, 0);
            GL.TexCoord2(1f, 1f); GL.Vertex3(charSize / 2, -charSize / 2, 0);
            GL.TexCoord2(1f, 0f); GL.Vertex3(charSize / 2, charSize / 2, 0);

            GL.BindTexture(TextureTarget.Texture2D, 0); // Unbind texture when we are done with it.

            GL.End();

            SwapBuffers();
        }