public static Vector4 UnProject(ref Matrix4 projection, Matrix4 view, Size viewport, MouseDevice mouse)
        {
            Vector4 vec;

            if (mouse.X > 0)
            {
                vec = new Vector4();
            }
            vec.X = 2.0f * mouse.X / (float)viewport.Width -1;
            vec.Y = -(2.0f * mouse.Y / (float)viewport.Height -1);
            vec.Z = 0;
            vec.W = 1.0f;

            Matrix4 viewInv = Matrix4.Invert(view);
            Matrix4 projInv = Matrix4.Invert(projection);

            Vector4.Transform(ref vec, ref projInv, out vec);
            Vector4.Transform(ref vec, ref viewInv, out vec);

            if (vec.W > float.Epsilon || vec.W < float.Epsilon)
            {
                vec.X /= vec.W;
                vec.Y /= vec.W;
                vec.Z /= vec.W;
            }

            return (vec);
        }

        public ColorScale(float min, float max, int width, int height)
        {
            this.width = width;
            this.height = height;
            this.min = min;
            this.max = max;
            length = 400.0f;
            barHeight = 25.0f;
            bottom = -height / 2.0f + 30.0f;
            left = -length / 2.0f;
            NumOfVertices = 0;
            cm = new Dictionary<float, Vector3>();
            popis_txt = new Text2D(width,height);
            popis_dic = new Dictionary<string, Vector4>();

            VAO = new int[1];
            VBO = new int[2];
            projectionMatrix = Matrix4.Identity;
            modelViewMatrix = Matrix4.Identity;

            VertexShader = new Shaders.Shader();
            FragmentShader = new Shaders.Shader();
            spMain = new Shaders.ShaderProgram();

            SetColorScale();
            SetText();
            Init();
        }

 /// 行列との掛け算
 public static Vector4 Mult( ref Vector4 pos, Matrix4 mtx )
 {
     calPos4.X = (mtx.M11 * pos.X) + (mtx.M21 * pos.Y) + ( mtx.M31 * pos.Z ) + ( mtx.M41 * pos.W );
     calPos4.Y = (mtx.M12 * pos.X) + (mtx.M22 * pos.Y) + ( mtx.M32 * pos.Z ) + ( mtx.M42 * pos.W );
     calPos4.Z = (mtx.M13 * pos.X) + (mtx.M23 * pos.Y) + ( mtx.M33 * pos.Z ) + ( mtx.M43 * pos.W );
     return calPos4;
 }

        // UnProject takes a window-local mouse-coordinate, and a Z-coordinate depth [0,1] and
        // unprojects it, returning the point in world space. To get a ray, UnProject the
        // mouse coordinates at two different z-values.
        //
        // http://www.opentk.com/node/1276#comment-13029
        public static Vector3 UnProject(
			ref Matrix4 projection, 
			Matrix4 view, 
			System.Drawing.Size viewport, 
			Vector3 mouse)
        {
            Vector4 vec;

            vec.X = 2.0f * mouse.X / (float)viewport.Width - 1;
            vec.Y = -(2.0f * mouse.Y / (float)viewport.Height - 1);
            vec.Z = mouse.Z;
            vec.W = 1.0f;

            Matrix4 viewInv = Matrix4.Invert(view);
            Matrix4 projInv = Matrix4.Invert(projection);

            Vector4.Transform(ref vec, ref projInv, out vec);
            Vector4.Transform(ref vec, ref viewInv, out vec);

            if (vec.W > float.Epsilon || vec.W < float.Epsilon)
            {
                vec.X /= vec.W;
                vec.Y /= vec.W;
                vec.Z /= vec.W;
            }

            return new Vector3(vec.X,vec.Y,vec.Z);
        }

 public virtual void ApplyProjectionMatrix(ref Matrix4 pickMatrix)
 {
     CalculateProjectionMatrix();
     Matrix4 result = ProjectionMatrix * pickMatrix;
     GL.MatrixMode(MatrixMode.PROJECTION);
     GL.LoadMatrix(ref result);
 }

 public unsafe static void SetWorldTransform(this MotionState obj, ref Matrix4 transform)
 {
     fixed (Matrix4* value = &transform)
     {
         obj.SetWorldTransform(ref *(Matrix*)value);
     }
 }

        /// <summary>
        /// position is top left of box.
        /// </summary>
        /// <param name="position"></param>
        /// <param name="size"></param>
        /// <param name="color"></param>
        public ColorBox(Vector2 position, Vector2 size, Color4 color)
        {
            this.position = position;
            this.size = size;
            model = Matrix4.CreateTranslation(position.X, position.Y, 0);
            Color = color;

            float[] vertices = new float[]
            {
                0, 0,
                0, size.Y,
                size.X, 0,
                size.X, size.Y
            };

            uint[] indices = new uint[]
            {
                0, 1, 2, 3
            };

            VBO vert = new VBO(), ind = new VBO();
            vert.SetData(ref vertices, BufferUsageHint.StaticDraw);
            ind.SetData(ref indices, BufferUsageHint.StaticDraw);

            bufSet = new BufferSet();
            bufSet.VertexBuffer = vert;
            bufSet.IndexBuffer = ind;
            bufSet.VertexSize = 2;
            bufSet.DrawMode = BeginMode.TriangleStrip;
            bufSet.SetDrawState(DrawStates.Vertex);
        }

        public void AddCube(Matrix4 transform)
        {
            // Create VAO
            var vao = GL.GenVertexArray();
            GL.BindVertexArray(vao);

            // Create new buffer
            var buffer = GL.GenBuffer();
            GL.BindBuffer(BufferTarget.ArrayBuffer, buffer);
            float[] vertices =
            {
                -1f, -1f, -1f, 1f, -1f, -1f, -1f, -1f, 1f, -1f, -1f, 1f, 1f, -1f, -1f, 1f, -1f, 1f, //Front face
                1f, 1f, -1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f, 1f, -1f, -1f, 1f, 1f, 1f, 1f, 1f, //Back face
                1f, -1f, -1f, 1f, 1f, -1f, 1f, -1f, 1f, 1f, -1f, 1f, 1f, 1f, -1f, 1f, 1f, 1f, //Right face
                -1f, 1f, -1f, -1f, -1f, -1f, -1f, -1f, 1f, -1f, 1f, -1f, -1f, -1f, 1f, -1f, 1f, 1f, //Left face
                -1f, -1f, 1f, 1f, -1f, 1f, -1f, 1f, 1f, -1f, 1f, 1f, 1f, -1f, 1f, 1f, 1f, 1f, //Top face
                1f, -1f, -1f, -1f, -1f, -1f, -1f, 1f, -1f, 1f, -1f, -1f, -1f, 1f, -1f, 1f, 1f, -1f //Bottom face
            };
            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(sizeof(float) * vertices.Length), vertices, BufferUsageHint.StaticDraw);

            var posAttribute = GL.GetAttribLocation(shaderProgram, "aVertexPos");
            GL.EnableVertexAttribArray(posAttribute);
            GL.VertexAttribPointer(posAttribute, 3, VertexAttribPointerType.Float, false, Vector3.SizeInBytes, 0);

            GL.BindVertexArray(0);

            objects.Add(new DebugObject(vao, vertices.Length / 3, transform));
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="graphics"></param>
        /// <param name="maxSprites">The maximum number of sprites which can be batched.</param>
        public SpriteRenderer(GraphicsContext graphics, int maxSprites)
        {
            if (graphics == null)
                throw new ArgumentNullException("graphics");

            if (maxSprites <= 0)
                throw new ArgumentOutOfRangeException("maxSprites", "MaxSprites must be >= 1.");

            this.graphics = graphics;

            this.vertices = new Vertex[maxSprites * 4];

            this.vertexBuffer = new DynamicVertexBuffer<Vertex>(this.graphics);

            ushort[] indices = new ushort[1024 * 6];
            for (ushort i = 0, vertex = 0; i < indices.Length; i += 6, vertex += 4)
            {
                indices[i] = vertex;
                indices[i + 1] = (ushort)(vertex + 1);
                indices[i + 2] = (ushort)(vertex + 3);
                indices[i + 3] = (ushort)(vertex + 1);
                indices[i + 4] = (ushort)(vertex + 2);
                indices[i + 5] = (ushort)(vertex + 3);
            }

            this.indexBuffer = new StaticIndexBuffer<ushort>(this.graphics, indices);

            this.transform = new Matrix4()
            {
                M33 = 1f,
                M44 = 1f,
                M41 = -1f,
                M42 = 1f
            };
        }

        public static void GetCurrentOrthogProjection(out bool isOrthog, out float left, out float right, out float bottom, out float top)
        {
            Matrix4 matrix = new Matrix4();
            GL.GetFloat(GetPName.ProjectionMatrix, out matrix.Row0.X);

			Helper.IsMatrixOrthogonal (out isOrthog, out left, out right, out bottom, out top, matrix);
        }

 public static Vector2 UnprojectPoint(Vector2 point, int screenWidth, int screenHeight, Matrix4 invProjection)
 {
     var x = (point.X * 2.0f / screenWidth) - 1.0f;
     var y = 1.0f - (point.Y * 2.0f / screenHeight);
     var p = new Vector3(x, y, -1.0f);
     return Vector3.Transform(p, invProjection).Xy;
 }

        public void Render(GameClient gameClient, RenderInfo renderInfo)
        {
            _currentFrameTime = GameTime.Now();

            GL.ClearColor(0.5f, 0.6f, 0.9f, 1f);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            GL.Enable(EnableCap.DepthTest);
            GL.Enable(EnableCap.CullFace);

            var offset = gameClient.PositionData.Placement.Pos - EntityPos.Origin;
            SetProjectionMatrix(renderInfo);

            _modelViewMatrix = Matrix4.Identity
                * Matrix4.CreateTranslation((float)-offset.X, (float)-offset.Y - gameClient.PhysicsValues.PlayerEyeHeight, (float)-offset.Z)
                * Matrix4.CreateRotationY((float)-gameClient.PositionData.Placement.Orientation.Horizontal)
                * Matrix4.CreateRotationX((float)gameClient.PositionData.Placement.Orientation.Vertical);

            _textureAtlas.Bind();

            RenderHighlightedFace(gameClient);

            RenderBlocks(gameClient);

            RenderEntities(gameClient);

            _outlineRenderer.RenderOutlines(renderInfo);
        }

            /// 視線方向を向く（upベクトルがY軸プラス方向に固定版）
            public static void LookTrgVec( ref Matrix4 mtx, Vector3 lookVec )
            {
                Vector3 upVec = new Vector3( 0.0f, 1.0f, 0.0f );

                if( lookVec.X == 0.0f && lookVec.Z == 0.0f){
                lookVec.Z = 1.0f;
                }
                // Z軸のセット
                lookVec = lookVec.Normalize();
                mtx.M31 = lookVec.X;
                mtx.M32 = lookVec.Y;
                mtx.M33 = lookVec.Z;
                mtx.M34 = 0;

                // X軸のセット
                Vector3 calVecX = Common.VectorUtil.Cross2( upVec, lookVec );
                calVecX = calVecX.Normalize();
                mtx.M11 = calVecX.X;
                mtx.M12 = calVecX.Y;
                mtx.M13 = calVecX.Z;
                mtx.M14 = 0;

                // Y軸のセット
                Vector3 calVecY = VectorUtil.Cross2( lookVec, calVecX );
                calVecY = calVecY.Normalize();
                mtx.M21 = calVecY.X;
                mtx.M22 = calVecY.Y;
                mtx.M23 = calVecY.Z;
                mtx.M24 = 0;
            }

 /// 平行移動の代入
 public static void SetTranslate( ref Matrix4 mtx, Vector3 pos )
 {
     mtx.M41 = pos.X;
     mtx.M42 = pos.Y;
     mtx.M43 = pos.Z;
     mtx.M44 = 1.0f;
 }

        public static void CreateBillboard(ref Vector3 objectPosition, ref Vector3 cameraPosition,
            ref Vector3 cameraUpVector, Vector3 cameraForwardVector, out Matrix4 result)
        {
            Vector3 look = cameraPosition - objectPosition;
            look = look.Normalize();

            Vector3 right = cameraUpVector.Cross(look).Normalize();
            Vector3 up = look.Cross(right).Normalize();
            //Matrix4 mat = Matrix4.LookAt(cameraPosition, cameraForwardVector, cameraUpVector);
            //Vector3 right = new Vector3(mat.M11, mat.M21, mat.M31);
            //right = right.Normalize();

            //Vector3 up = new Vector3(mat.M12, mat.M22, mat.M32);
            //up = up.Normalize();

            result.M11 = right.X;
            result.M12 = right.Y;
            result.M13 = right.Z;
            result.M14 = 0;
            result.M21 = up.X;
            result.M22 = up.Y;
            result.M23 = up.Z;
            result.M24 = 0;
            result.M31 = look.X;
            result.M32 = look.Y;
            result.M33 = look.Z;
            result.M34 = 0;
            result.M41 = objectPosition.X;
            result.M42 = objectPosition.Y;
            result.M43 = objectPosition.Z;
            result.M44 = 1;
        }

        public void Render(TerrainTile tile, TerrainGlobal terrainGlobal, Matrix4 projection, Matrix4 view, Vector3 eyePos)
        {
            var boxparam = tile.GetBoxParam();

            Vector3 eyePosTileCoords = Vector4.Transform(new Vector4(eyePos, 0.0f), tile.InverseModelMatrix).Xyz;

            GL.Enable(EnableCap.CullFace);
            GL.CullFace(CullFaceMode.Front);  // we only want to render back-faces

            tile.HeightTexture.Bind(TextureUnit.Texture0);
            tile.ParamTexture.Bind(TextureUnit.Texture1);
            tile.NormalTexture.Bind(TextureUnit.Texture2);

            this.boundingBoxProgram
                .UseProgram()
                .SetUniform("projection_matrix", projection)
                .SetUniform("model_matrix", tile.ModelMatrix)
                .SetUniform("view_matrix", view)
                .SetUniform("heightTex", 0)
                .SetUniform("paramTex", 1)
                .SetUniform("normalTex", 2)
                .SetUniform("eyePos", eyePos)
                .SetUniform("nEyePos", eyePosTileCoords)
                .SetUniform("boxparam", boxparam);
            this.vertexVBO.Bind(this.boundingBoxProgram.VariableLocation("vertex"));
            this.boxcoordVBO.Bind(this.boundingBoxProgram.VariableLocation("in_boxcoord"));
            this.indexVBO.Bind();
            GL.DrawElements(BeginMode.Triangles, this.indexVBO.Length, DrawElementsType.UnsignedInt, 0);
            Sampler.Unbind(TextureUnit.Texture0);
        }

 public Camera3D()
 {
     Matrix = Matrix4.Identity;
     rotation = Matrix4.Identity;
     translation = Matrix4.Identity;
     scale = Matrix4.Identity;
 }

 public Transform()
 {
     rotation = Quaternion.Identity;
     matrix = Matrix4.Identity;
     position = Vector3.Zero;
     scale = Vector3.One;
 }

 public static void ReadMatrix4(this BinaryReader reader, ref Matrix4 matrix)
 {
     ReadVector4(reader, ref matrix.Row0);
     ReadVector4(reader, ref matrix.Row1);
     ReadVector4(reader, ref matrix.Row2);
     ReadVector4(reader, ref matrix.Row3);
 }

 public void viewportSize(int viewportWidth, int viewportHeight)
 {
     this.Width = viewportWidth;
     this.Height = viewportHeight;
     float aspectRatio = Width / (float)Height;
     projectionMatrix = Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, 1.0f, 4096.0f);
 }