public static OpenTK.Matrix4 GLSRT(OpenTK.Vector3 pos, OpenTK.Quaternion qua, OpenTK.Vector3 scale) { OpenTK.Matrix4 t = OpenTK.Matrix4.CreateTranslation(pos); OpenTK.Matrix4 r = OpenTK.Matrix4.CreateFromQuaternion(qua); OpenTK.Matrix4 s = OpenTK.Matrix4.CreateScale(scale); return(s * r * t); }
public static Matrix4x4 ConvertOpenTkMatrixToUnityMatrix(OpenTK.Matrix4 ret) { Matrix4x4 mat = new Matrix4x4(); mat.m00 = ret.M11; mat.m01 = ret.M12; mat.m02 = ret.M13; mat.m03 = ret.M14; mat.m10 = ret.M21; mat.m11 = ret.M22; mat.m12 = ret.M23; mat.m13 = ret.M24; mat.m20 = ret.M31; mat.m21 = ret.M32; mat.m22 = ret.M33; mat.m23 = ret.M34; mat.m30 = ret.M41; mat.m31 = ret.M42; mat.m32 = ret.M43; mat.m33 = ret.M44; return(mat); }
public static OpenTK.Matrix4 Multiply(OpenTK.Matrix4 lhs, OpenTK.Matrix4 rhs) { Matrix4x4 t1 = ConvertOpenTkMatrixToUnityMatrix(lhs); Matrix4x4 t2 = ConvertOpenTkMatrixToUnityMatrix(rhs); return(ConvertUnityMatrixToOpenTkMatrix(t1 * t2)); }
// float[] ConverToFloat3(Matrix4x4 mat) // { // float[] ret = new float[16]; // ret[0] = mat.m00; // ret[1] = mat.m10; // ret[2] = mat.m20; // ret[3] = mat.m30; // // ret[4] = mat.m01; // ret[5] = mat.m11; // ret[6] = mat.m21; // ret[7] = mat.m31; // // ret[8] = mat.m02; // ret[9] = mat.m12; // ret[10] = mat.m22; // ret[11] = mat.m32; // // ret[12] = mat.m03; // ret[13] = mat.m13; // ret[14] = mat.m23; // ret[15] = mat.m33; // // return ret; // } public static OpenTK.Matrix4 ConvertUnityMatrixToOpenTkMatrix(Matrix4x4 mat) { OpenTK.Matrix4 ret = new OpenTK.Matrix4(); ret.M11 = mat.m00; ret.M12 = mat.m01; ret.M13 = mat.m02; ret.M14 = mat.m03; ret.M21 = mat.m10; ret.M22 = mat.m11; ret.M23 = mat.m12; ret.M24 = mat.m13; ret.M31 = mat.m20; ret.M32 = mat.m21; ret.M33 = mat.m22; ret.M34 = mat.m23; ret.M41 = mat.m30; ret.M42 = mat.m31; ret.M43 = mat.m32; ret.M44 = mat.m33; return(ret); }
/// <summary> /// Matrix Overload for Framework Match /// </summary> public static void CreateScale(float x, float y, float z, out Matrix result) { #if SharpDX Matrix.Scaling(x, y, z, out result); #else Matrix.CreateScale(x, y, z, out result); #endif }
/// <summary> /// Matrix Overload for Framework Match /// </summary> public static void CreateScale(float scale, out Matrix result) { #if SharpDX Matrix.Scaling(scale, out result); #else Matrix.CreateScale(scale, out result); #endif }
public C2DGraphics() { ImgDbase = new Dictionary<String, C2DImage>(); FontDbase = new Dictionary<string,C2DFont>(); mNewImages = new List<C2DImage>(); m_2dView = OpenTK.Matrix4.LookAt(new OpenTK.Vector3(0, 0, 10), new OpenTK.Vector3(0, 0, 0), new OpenTK.Vector3(0, 1, 0)); mUserTexture = -1; }
void DrawCube() { float[] float_zeros = new float[] { 0.0f, 0.0f, 0.0f, 0.0f }; float[] float_ones = new float[] { 1.0f, 1.0f, 1.0f, 1.0f }; GL.BindFramebuffer(All.Framebuffer, m_gbuffer); GL.Viewport(0, 0, m_width, m_height); All[] draw_buffers = new All[] { All.ColorAttachment0, All.ColorAttachment1 }; GL.DrawBuffers(2, draw_buffers); GL.ClearBuffer(All.Color, 0, float_zeros); GL.ClearBuffer(All.Color, 1, float_zeros); GL.ClearBuffer(All.Depth, 0, float_ones); //float[] black = new float[] { 0, 0, 0, 1 }; //GL.ClearBuffer(ClearBuffer.Color, 0, black); //float[] ones = new float[] { 1.0f }; //GL.ClearBuffer(ClearBuffer.Depth, 0, ones); GL.UseProgram(m_prePassProgram); const int POS_INDEX = 0; const int NORMAL_INDEX = 1; const int POS_SIZE = 3; const int NORMAL_SIZE = 3; GL.VertexAttribPointer(POS_INDEX, POS_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptrCube); GL.VertexAttribPointer(NORMAL_INDEX, NORMAL_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptrCube + sizeof(float) * POS_SIZE); GL.EnableVertexAttribArray(POS_INDEX); GL.EnableVertexAttribArray(NORMAL_INDEX); float[] vEyeLight = { -100.0f, 100.0f, 100.0f }; OpenTK.Matrix4 model = OpenGLHelper.GLSRT(OpenTK.Vector3.One, OpenTK.Quaternion.Identity, OpenTK.Vector3.One); OpenTK.Matrix4 view = OpenGLHelper.GLLookAt(new OpenTK.Vector3(10, 10, 10), OpenTK.Vector3.Zero, new OpenTK.Vector3(0, 1, 0)); OpenTK.Matrix4 projection = OpenGLHelper.GLPerspective(60, m_width / (float)m_height, 0.1f, 100f); OpenTK.Matrix4 mv = OpenGLHelper.GLVMathMultiply(view, model); OpenTK.Matrix4 mvp = OpenGLHelper.GLVMathMultiply(projection, mv); GL.Uniform3(m_locLight, 1, vEyeLight); GL.UniformMatrix4(m_locMVP, 1, false, OpenGLHelper.ConverToFloat(mvp)); GL.UniformMatrix4(m_locMV, false, ref mv); GL.Enable(EnableCap.DepthTest); GL.DepthFunc(All.Lequal); GL.Enable(EnableCap.CullFace); GL.DrawElements(PrimitiveType.Triangles, m_meshData.m_index.Length, DrawElementsType.UnsignedShort, m_meshData.m_index); GL.DisableVertexAttribArray(POS_INDEX); GL.DisableVertexAttribArray(NORMAL_INDEX); GL.BindFramebuffer(All.Framebuffer, 0); GL.Disable(EnableCap.DepthTest); GL.Disable(EnableCap.CullFace); }
/// <summary> /// Matrix Overload for Framework Match /// </summary> public static void CreateRotation(Vector3 axis, float angle, out Matrix result) { #if SharpDX Matrix.RotationAxis(ref axis, angle, out result); #elif OpenTK Matrix.CreateFromAxisAngle(axis, angle, out result); #else Matrix.CreateFromAxisAngle(ref axis, angle, out result); #endif }
public void QuickTransform() { OpenTK.Matrix4 A = new OpenTK.Matrix4(); A[0, 0] = 16; A[0, 1] = 15; A[0, 2] = 14; A[0, 3] = 13; A[1, 0] = 12; A[1, 1] = 11; A[1, 2] = 10; A[1, 3] = 9; A[2, 0] = 8; A[2, 1] = 7; A[2, 2] = 6; A[2, 3] = 5; OpenTK.Vector3 x = new OpenTK.Vector3(1, 5, 9); OpenTK.Vector3 b = A.QuickTransform(ref x); OpenTK.Vector3 expected = new OpenTK.Vector3(230, 166, 102); Assert.IsTrue(expected == b); }
private OpenTK.Matrix4 ReadMatrix4( ) { OpenTK.Matrix4 m = new OpenTK.Matrix4 { Column0 = ReadVec4( ), Column1 = ReadVec4( ), Column2 = ReadVec4( ), Column3 = ReadVec4( ) }; return(m); }
/// <summary> /// Called when the user resizes the window. /// </summary> /// <param name="e">Contains the new width/height of the window.</param> /// <remarks> /// You want the OpenGL viewport to match the window. This is the place to do it! /// </remarks> protected override void OnResize(EventArgs e) { base.OnResize(e); GL.Viewport(0, 0, Width, Height); double aspect_ratio = Width / (double)Height; OpenTK.Matrix4 perspective = OpenTK.Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver4, (float)aspect_ratio, 1, 64); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref perspective); }
public void TestTranspose() { float x = TK.MathHelper.Pi; float y = TK.MathHelper.PiOver4; TK.Matrix4 tkM = TK.Matrix4.CreateRotationX(x) * TK.Matrix4.CreateRotationY(y); Matrix3x3 m = Matrix3x3.FromRotationX(x) * Matrix3x3.FromRotationY(y); tkM.Transpose(); m.Transpose(); TestHelper.AssertEquals(tkM, m, "Testing transpose"); }
private void RenderHandler(object sender, FrameEventArgs e) { GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.StencilBufferBit | ClearBufferMask.DepthBufferBit); var lookAtMatrix = Matrix4.LookAt(Eye, CameraAt, Up); GL.MatrixMode(MatrixMode.Modelview); GL.LoadMatrix(ref lookAtMatrix); DrawObjectsByStage(); Context.SwapBuffers(); }
public void SetShaderProgram(ShaderProgram program) { if (program != null) { program.__linkProgram(); __curProgramObject = program.__programObject; __curProgram = program; if (program.__programObject != 0) { __isUsedProgram[program.__programObject] = true; __programDic[program.__programObject] = program; __vertexBuffer.Clear(); //FIXME:?????? clear, because __programObject in UseProgram(program.__programObject) is changed //__textureDic.Clear(); //FIXME:?????? clear, because __programObject in UseProgram(program.__programObject) is changed //GL.Clear(ClearBufferMask.DepthBufferBit); //FIXME:??? GL.UseProgram(program.__programObject); foreach (int location in program.__uniformMatrix4.Keys) { OpenTK.Matrix4 v = program.__uniformMatrix4[location]; GL.UniformMatrix4(location, false, ref v); // if (program.__filename.Equals("/Application/Sample/Graphics/ShaderCatalogSample/shaders/Simple.cgx")) // { // Debug.WriteLine("======================location2:" + location + " : " + v.ToString()); // } } foreach (int location in program.__uniform4.Keys) { OpenTK.Vector4 v = program.__uniform4[location]; GL.Uniform4(location, v.X, v.Y, v.Z, v.W); } foreach (int location in program.__uniform3.Keys) { OpenTK.Vector3 v = program.__uniform3[location]; GL.Uniform3(location, v.X, v.Y, v.Z); } foreach (int location in program.__uniform1.Keys) { float v = program.__uniform1[location]; GL.Uniform1(location, v); } program.__afterUseProgram(); } else { //FIXME: } } else { __curProgramObject = 0; //FIXME: __curProgram = null; } }
/// <summary> /// Reads the matrix33. /// </summary> /// <param name="reader">The reader.</param> /// <returns>Matrix.</returns> public static Matrix ReadMatrix33(this BinaryReader reader) { Matrix identity = Matrix.Identity; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { identity[j, i] = reader.ReadSingle(); } } return(identity); }
public void TestFromEulerAnglesXYZ() { float x = TK.MathHelper.Pi; float y = 0.0f; float z = TK.MathHelper.PiOver4; TK.Matrix4 tkM = TK.Matrix4.CreateRotationX(x) * TK.Matrix4.CreateRotationZ(z); Matrix3x3 m = Matrix3x3.FromEulerAnglesXYZ(x, y, z); Matrix3x3 m2 = Matrix3x3.FromEulerAnglesXYZ(new Vector3D(x, y, z)); TestHelper.AssertEquals(tkM, m, "Testing create from euler angles"); Assert.IsTrue(m == m2, "Testing if create from euler angle as a vector is the same as floats."); }
public void TestInverse() { float x = TK.MathHelper.PiOver6; float y = TK.MathHelper.Pi; TK.Matrix4 tkM = TK.Matrix4.CreateRotationX(x) * TK.Matrix4.CreateRotationY(y); Matrix3x3 m = Matrix3x3.FromRotationX(x) * Matrix3x3.FromRotationY(y); tkM.Invert(); m.Inverse(); TestHelper.AssertEquals(tkM, m, "Testing inverse"); }
public static OpenTK.Matrix4 ToOpenTK(this UnityEngine.Matrix4x4 m) { var res = new OpenTK.Matrix4(); for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { res[r, c] = m[r, c]; } } return(res); }
public void TestDeterminant() { float x = TK.MathHelper.Pi; float y = TK.MathHelper.PiOver3; TK.Matrix4 tkM = TK.Matrix4.CreateRotationX(x) * TK.Matrix4.CreateRotationY(y); Matrix3x3 m = Matrix3x3.FromRotationX(x) * Matrix3x3.FromRotationY(y); float tkDet = tkM.Determinant; float det = m.Determinant(); TestHelper.AssertEquals(tkDet, det, "Testing determinant"); }
/// <summary> /// Compute World Matrix Starting From Node and Reading all Parents Transformations /// </summary> /// <param name="leaf"></param> /// <returns></returns> public static Matrix GetWorldMatrixFromNode(this NiAVObject leaf) { var current = leaf; var worldMatrix = Matrix.Identity; // For Each Parent Node while (current != null) { // Append Transformation To Matrix Matrix intermediate; #if SharpDX Matrix.Multiply(ref worldMatrix, ref current.Rotation, out intermediate); worldMatrix = intermediate; var scale = Matrix.Scaling(current.Scale); Matrix.Multiply(ref worldMatrix, ref scale, out intermediate); worldMatrix = intermediate; var translate = Matrix.Translation(current.Translation.X, current.Translation.Y, current.Translation.Z); Matrix.Multiply(ref worldMatrix, ref translate, out intermediate); worldMatrix = intermediate; #elif MonoGame Matrix.Multiply(ref worldMatrix, ref current.Rotation, out intermediate); worldMatrix = intermediate; var scale = Matrix.CreateScale(current.Scale); Matrix.Multiply(ref worldMatrix, ref scale, out intermediate); worldMatrix = intermediate; var translate = Matrix.CreateTranslation(current.Translation.X, current.Translation.Y, current.Translation.Z); Matrix.Multiply(ref worldMatrix, ref translate, out intermediate); worldMatrix = intermediate; #else Matrix.Mult(ref worldMatrix, ref current.Rotation, out intermediate); worldMatrix = intermediate; var scale = Matrix.CreateScale(current.Scale); Matrix.Mult(ref worldMatrix, ref scale, out intermediate); worldMatrix = intermediate; var translate = Matrix.CreateTranslation(current.Translation.X, current.Translation.Y, current.Translation.Z); Matrix.Mult(ref worldMatrix, ref translate, out intermediate); worldMatrix = intermediate; #endif current = current.Parent; } return(worldMatrix); }
/// <summary> /// /// </summary> /// <param name="filePath"></param> /// <returns></returns> public static BKE Open(string filePath) { var bke = new BKE(); using (FileStream stream = new FileStream(filePath, FileMode.Open)) using (StreamReader r = new StreamReader(stream)) { BKENode current = null; while (!r.EndOfStream) { var arg = r.ReadLine().TrimStart().Split(' '); if (arg[0].Contains("{")) { while (!r.EndOfStream) { arg = r.ReadLine().TrimStart().Split(' '); if (arg[0].Equals("}")) { break; } if (current != null) { float frame = float.Parse(arg[0]) - 1; var matrix = new OpenTK.Matrix4( float.Parse(arg[1]), float.Parse(arg[2]), float.Parse(arg[3]), float.Parse(arg[4]), float.Parse(arg[5]), float.Parse(arg[6]), float.Parse(arg[7]), float.Parse(arg[8]), float.Parse(arg[9]), float.Parse(arg[10]), float.Parse(arg[11]), float.Parse(arg[12]), float.Parse(arg[13]), float.Parse(arg[14]), float.Parse(arg[15]), float.Parse(arg[16])); current.Keys.Add(matrix); } } } else { current = bke.GetCreateNode(arg[0]); if (arg.Length > 1) { current.Parent = bke.GetCreateNode(arg[1]); } } } } return(bke); }
public static OpenTK.Vector4 LeftMultiply(OpenTK.Vector3 tmp, OpenTK.Matrix4 mat) { OpenTK.Vector4 vec = new OpenTK.Vector4(tmp); vec.W = 1; OpenTK.Vector4 ret = new OpenTK.Vector4(); ret.X = vec.X * mat.M11 + vec.Y * mat.M21 + vec.Z * mat.M31 + vec.W * mat.M41; ret.Y = vec.X * mat.M12 + vec.Y * mat.M22 + vec.Z * mat.M32 + vec.W * mat.M42; ret.Z = vec.X * mat.M13 + vec.Y * mat.M23 + vec.Z * mat.M33 + vec.W * mat.M43; ret.W = vec.X * mat.M14 + vec.Y * mat.M24 + vec.Z * mat.M34 + vec.W * mat.M44; return(ret); }
public static OpenTK.Vector4 RightMultiply(OpenTK.Matrix4 mat, OpenTK.Vector3 tmp) { OpenTK.Vector4 vec = new OpenTK.Vector4(tmp); vec.W = 1; OpenTK.Vector4 ret = new OpenTK.Vector4(); ret.X = mat.M11 * vec.X + mat.M12 * vec.Y + mat.M13 * vec.Z + mat.M14 * vec.W; ret.Y = mat.M21 * vec.X + mat.M22 * vec.Y + mat.M23 * vec.Z + mat.M24 * vec.W; ret.Z = mat.M31 * vec.X + mat.M32 * vec.Y + mat.M33 * vec.Z + mat.M34 * vec.W; ret.W = mat.M41 * vec.X + mat.M42 * vec.Y + mat.M43 * vec.Z + mat.M44 * vec.W; return(ret); }
private void SetupViewport() { float aspectRatio = (float)GLC_display.Width / (float)GLC_display.Height; GL.Viewport(0, 0, GLC_display.Width, GLC_display.Height); GL.MatrixMode(MatrixMode.Projection); GL.LoadIdentity(); OpenTK.Matrix4 perspective = OpenTK.Matrix4.CreatePerspectiveFieldOfView((float)(System.Math.PI / 4f), aspectRatio, 0.01f, 2000f); GL.MultMatrix(ref perspective); GL.MatrixMode(MatrixMode.Modelview); GL.LoadIdentity(); }
/// <summary> /// Initializes a new instance of the <see cref="NiAVObject" /> class. /// </summary> /// <param name="file">The file.</param> /// <param name="reader">The reader.</param> /// <exception cref="Exception">Cannot read BoundingBoxes yet</exception> public NiAVObject(NiFile file, BinaryReader reader) : base(file, reader) { if (this.File.Header.Version >= eNifVersion.VER_3_0) { this.Flags = reader.ReadUInt16(); } if (this.File.Header.Version >= eNifVersion.VER_20_2_0_7 && this.File.Header.UserVersion == 11u && this.File.Header.UserVersion2 > 26u) { this.UnkownShort1 = reader.ReadUInt16(); } this.Translation = reader.ReadVector3(); this.Rotation = reader.ReadMatrix33(); this.Scale = reader.ReadSingle(); if (this.File.Header.Version <= eNifVersion.VER_4_2_2_0) { this.Velocity = reader.ReadVector3(); } if (this.File.Header.Version <= eNifVersion.VER_20_2_0_7 || this.File.Header.UserVersion <= 11u) { uint num = reader.ReadUInt32(); this.Properties = new NiRef <NiProperty> [num]; int num2 = 0; while ((long)num2 < (long)((ulong)num)) { this.Properties[num2] = new NiRef <NiProperty>(reader.ReadUInt32()); num2++; } } if (this.File.Header.Version <= eNifVersion.VER_2_3) { this.UnkownInts1 = new uint[4]; for (int i = 0; i < 4; i++) { this.UnkownInts1[i] = reader.ReadUInt32(); } this.UnkownByte = reader.ReadByte(); } if (this.File.Header.Version >= eNifVersion.VER_3_0 && this.File.Header.Version <= eNifVersion.VER_4_2_2_0) { this.HasBoundingBox = reader.ReadBoolean(Version); if (this.HasBoundingBox) { throw new Exception("Cannot read BoundingBoxes yet"); } } if (this.File.Header.Version >= eNifVersion.VER_10_0_1_0) { this.CollisionObject = new NiRef <NiCollisionObject>(reader.ReadUInt32()); } }
protected override void OnLoad(EventArgs e) { var black = new OpenTK.Vector4(0.0f, 0.0f, 0.0f, 1.0f); var yellow = new OpenTK.Vector4(1.0f, 1.0f, 0.0f, 1.0f); var cyan = new OpenTK.Vector4(0.0f, 1.0f, 1.0f, 1.0f); var white = new OpenTK.Vector4(1.0f, 1.0f, 1.0f, 1.0f); var direction = new OpenTK.Vector4(1.0f, 1.0f, 1.0f, 0.0f); GL.Material(MaterialFace.Front, MaterialParameter.AmbientAndDiffuse, cyan); GL.Material(MaterialFace.Front, MaterialParameter.Specular, white); GL.Material(MaterialFace.Front, MaterialParameter.Shininess, 30f); GL.Light(LightName.Light0, LightParameter.Ambient, black); GL.Light(LightName.Light0, LightParameter.Diffuse, yellow); GL.Light(LightName.Light0, LightParameter.Specular, white); GL.Light(LightName.Light0, LightParameter.Position, direction); //GL.LightModel(LightModelParameter.LightModelAmbient, new float[] { 0.2f, 0.2f, 0.2f, 1.0f }); //GL.LightModel(LightModelParameter.LightModelTwoSide, 1); //GL.LightModel(LightModelParameter.LightModelLocalViewer, 1); GL.Enable(EnableCap.Lighting); // so the renderer considers light GL.Enable(EnableCap.Light0); // turn LIGHT0 on GL.Enable(EnableCap.DepthTest); // so the renderer considers depth // Set the current clear color to sky blue and the current drawing color to white. GL.ClearColor(0.1f, 0.39f, 0.88f, 1.0f); GL.Color3(1.0, 1.0, 1.0); float aspect_ratio = Width / (float)Height; // Aspect ratio of the screen float fov = MathHelper.PiOver2; // camera field of view float near_distance = 0.1f; // The nearest the camera can see. >= 0.1f else clips float far_distance = 100.0f; // Fartherest the camera can see OpenTK.Matrix4 perspective_matrix = OpenTK.Matrix4.CreatePerspectiveFieldOfView(fov, aspect_ratio, near_distance, far_distance); ////Then we tell GL to use are matrix as the new Projection matrix. GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref perspective_matrix); GL.Enable(EnableCap.DepthTest); // 'Enable correct Z Drawings GL.DepthFunc(DepthFunction.Less); // 'Enable correct Z Drawings //GL.Viewport(0, 0, Width, Height); GL.Enable(EnableCap.CullFace); GL.CullFace(CullFaceMode.Back); //GL.ShadeModel(ShadingModel.Smooth); // TODO - requires vertex normals to be calulated across polys }
/// <summary> /// Get World Matrix For NifGeometry /// </summary> /// <param name="nifGeom"></param> /// <param name="UnitFactor"></param> /// <returns></returns> protected static Matrix ComputeWorldMatrix(NifGeometry nifGeom, float UnitFactor) { if (nifGeom == null) { throw new ArgumentNullException("nifGeom"); } // Get Translation (XY Inverted), Scale, Rotation Matrix translation; ZoneDrawingExtensions.CreateTranslation(nifGeom.X * UnitFactor, nifGeom.Y * UnitFactor, nifGeom.Z * UnitFactor, out translation); Matrix scale; ZoneDrawingExtensions.CreateScale(nifGeom.Scale * UnitFactor, out scale); Matrix rotation; ZoneDrawingExtensions.CreateRotation(new Vector3(nifGeom.RotationX, nifGeom.RotationY, nifGeom.RotationZ * -1f), nifGeom.Angle, out rotation); Matrix result = Matrix.Identity; // Flip if needed if (nifGeom.Flip) { Matrix flip; ZoneDrawingExtensions.CreateScale(-1f, 1f, 1f, out flip); result = flip; } Matrix intermediateResult; // Combine Scale, Rotation, Translation, Invertion Rotation ZoneDrawingExtensions.Mult(ref result, ref scale, out intermediateResult); result = intermediateResult; ZoneDrawingExtensions.Mult(ref result, ref rotation, out intermediateResult); result = intermediateResult; ZoneDrawingExtensions.Mult(ref result, ref translation, out intermediateResult); result = intermediateResult; ZoneDrawingExtensions.Mult(ref result, ref RotationMatrix, out intermediateResult); result = intermediateResult; // Combine Matrix with Parent Matrix if (nifGeom.RelativeTo != null) { Matrix relativeMatrix = ComputeWorldMatrix(nifGeom.RelativeTo, UnitFactor); ZoneDrawingExtensions.Mult(ref result, ref relativeMatrix, out intermediateResult); result = intermediateResult; } return(result); }
/// <summary> /// Sets the viewport and projection matrix for orthographic projection. /// </summary> /// <param name="e">resize event args</param> protected override void OnResize(EventArgs e) { GL.Viewport(ClientRectangle); // Set projection matrix GL.MatrixMode(MatrixMode.Projection); OpenTK.Matrix4 ortho = OpenTK.Matrix4.CreateOrthographicOffCenter(-1, 1, -1, 1, 1, -1); GL.LoadMatrix(ref ortho); // Set selector state back to matrix mode GL.MatrixMode(MatrixMode.Modelview); base.OnResize(e); }
public static JToken Serialize(this OpenTK.Matrix4 mat) { var res = new JArray(); for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { var val = mat[r, c]; res.Add(val); } } return(res); }
public bool UpdateUniform(String name, OpenTK.Matrix4 mat) { bool result = true; GL.UniformMatrix4(uniforms[name], false, ref mat); ErrorCode error = GL.GetError(); if (error != ErrorCode.NoError) { result = false; } return(result); }
public void GetProjection(out OpenTK.Matrix4 projection) { if (type == CameraType.Perspective) { float aspectRatio = (float)renderWidth / (float)renderHeight; Matrix4.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlane, farPlane, out projection); } else { Matrix4.CreateOrthographic((float)renderWidth, (float)renderHeight, nearPlane, farPlane, out projection); } }
public void SetupViewport(int w, int h) { mWidth = w; mHeight = h; m_ortho = OpenTK.Matrix4.CreateOrthographicOffCenter(0, w, h, 0, 1, 2000); GL.MatrixMode(MatrixMode.Projection); //GL.LoadIdentity(); GL.LoadMatrix(ref m_ortho); GL.MatrixMode(MatrixMode.Modelview); //GL.LoadIdentity(); GL.LoadMatrix(ref m_2dView); GL.Disable(EnableCap.Lighting); GL.Disable(EnableCap.DepthTest); GL.CullFace(CullFaceMode.Front); // the 2d view is reverse looking }
private void SetupViewport() { int w = glControl1.Width; int h = glControl1.Height; //GL.MatrixMode(MatrixMode.Projection); //GL.LoadIdentity(); //GL.Ortho(0, w, 0, h, -1, 1); GL.Viewport(0, 0, w, h); double aspect_ratio = w / (double)h; OpenTK.Matrix4 perspective = OpenTK.Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver4, (float)aspect_ratio, 1, 64); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref perspective); }
public void ResetDrawingRegion() { GL.Flush(); m_ortho = OpenTK.Matrix4.CreateOrthographicOffCenter(0, mWidth, mHeight, 0, 1, 2000); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref m_ortho); GL.Disable(EnableCap.ScissorTest); }
public void SetRotation(float a_fRot) { m_m4ModelMatrix = Matrix4.CreateRotationZ(a_fRot); }
// Only computes if FOV, aspect ratio, or near/far planes have changed public void computeProjection() { if (m_projectionChanged) { //CreatePerspectiveFieldOfView m_projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView (m_verticalFov, m_aspectRatio, m_nearPlane, m_farPlane); m_projectionChanged = false; } }
private void initCommon() { // By default view is aligned with world axes m_view = OpenTK.Matrix4.Identity; m_verticalFov = MathHelper.PiOver4; m_aspectRatio = (float)ClientBounds.Width / ClientBounds.Height; m_nearPlane = 1.0f; m_farPlane = 1.0e5f; m_projectionChanged = true; computeProjection (); }
public void UpdatePos(int x, int y) { m_m4ModelMatrix = Matrix4.CreateTranslation(x, y, 0); }
/// <summary> /// Matrix Overload for Framework Match /// </summary> public static void Mult(ref Matrix left, ref Matrix right, out Matrix result) { #if OpenTK Matrix.Mult(ref left, ref right, out result); #else Matrix.Multiply(ref left, ref right, out result); #endif }
//---------------------------------------------------------------------------- public LandmarkTransform() { Matrix = new Matrix4(); }
/// <summary> /// Initializes a new instance of the <see cref="NiAVObject" /> class. /// </summary> /// <param name="file">The file.</param> /// <param name="reader">The reader.</param> /// <exception cref="Exception">Cannot read BoundingBoxes yet</exception> public NiAVObject(NiFile file, BinaryReader reader) : base(file, reader) { if (this.File.Header.Version >= eNifVersion.VER_3_0) { this.Flags = reader.ReadUInt16(); } if (this.File.Header.Version >= eNifVersion.VER_20_2_0_7 && this.File.Header.UserVersion == 11u && this.File.Header.UserVersion2 > 26u) { this.UnkownShort1 = reader.ReadUInt16(); } this.Translation = reader.ReadVector3(); this.Rotation = reader.ReadMatrix33(); this.Scale = reader.ReadSingle(); if (this.File.Header.Version <= eNifVersion.VER_4_2_2_0) { this.Velocity = reader.ReadVector3(); } if (this.File.Header.Version <= eNifVersion.VER_20_2_0_7 || this.File.Header.UserVersion <= 11u) { uint num = reader.ReadUInt32(); this.Properties = new NiRef<NiProperty>[num]; int num2 = 0; while ((long)num2 < (long)((ulong)num)) { this.Properties[num2] = new NiRef<NiProperty>(reader.ReadUInt32()); num2++; } } if (this.File.Header.Version <= eNifVersion.VER_2_3) { this.UnkownInts1 = new uint[4]; for (int i = 0; i < 4; i++) { this.UnkownInts1[i] = reader.ReadUInt32(); } this.UnkownByte = reader.ReadByte(); } if (this.File.Header.Version >= eNifVersion.VER_3_0 && this.File.Header.Version <= eNifVersion.VER_4_2_2_0) { this.HasBoundingBox = reader.ReadBoolean(Version); if (this.HasBoundingBox) { throw new Exception("Cannot read BoundingBoxes yet"); } } if (this.File.Header.Version >= eNifVersion.VER_10_0_1_0) { this.CollisionObject = new NiRef<NiCollisionObject>(reader.ReadUInt32()); } }
private void SetupViewport() { if (!loaded) return; float aspect = 1.0f; try { int w = glControl1.Width; int h = glControl1.Height; GL.Viewport(0, 0, w, h); // Use all of the glControl painting area aspect = ((float)glControl1.Width) / ((float)glControl1.Height); SetAlpha(false); // start off with alpha off GL.Enable(EnableCap.CullFace); // enable culling of faces GL.CullFace(CullFaceMode.Back); // specify culling backfaces m_projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView(0.55f, aspect, 1, 2000); m_axisProjection = OpenTK.Matrix4.CreatePerspectiveOffCenter(-2 * aspect + 0.3f, 0.3f, -0.3f, 1.7f, 1, 2000); m_modelView = OpenTK.Matrix4.LookAt(new OpenTK.Vector3(5, 0, -5), new OpenTK.Vector3(0, 0, 0), new OpenTK.Vector3(0, 0, 1)); GL.ShadeModel(ShadingModel.Smooth); // tell it to shade smoothly // properties of materials GL.Enable(EnableCap.ColorMaterial); // allow polys to have color float[] mat_specular = { 1.0f, 1.0f, 1.0f, 1.0f }; float[] mat_shininess = { 50.0f }; GL.Material(MaterialFace.Front, MaterialParameter.Specular, mat_specular); GL.Material(MaterialFace.Front, MaterialParameter.Shininess, mat_shininess); //set a color to clear the background GL.ClearColor(Color.LightBlue); // antialising lines GL.Enable(EnableCap.LineSmooth); //GL.Enable(EnableCap.PolygonSmooth); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); GL.Hint(HintTarget.LineSmoothHint, HintMode.Nicest); //GL.Hint(HintTarget.PolygonSmoothHint, HintMode.Nicest); float[] res = new float[2]; GL.GetFloat(GetPName.SmoothLineWidthRange, res); // DebugLogger.Instance().LogInfo("Stencil depth: " + glControl1.GraphicsMode.Stencil.ToString()); // prepare texture buffer to save 3d rendring if (mColorBuffer == 0) GL.GenTextures(1, out mColorBuffer); GL.BindTexture(TextureTarget.Texture2D, mColorBuffer); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, Width, Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero); // lighting if (firstTime) { GL.Enable(EnableCap.Lighting); GL.Enable(EnableCap.Light0); float[] light_position = { 1.0f, 1.0f, 1.0f, 0.0f }; GL.Light(LightName.Light0, LightParameter.Position, light_position); GL.Light(LightName.Light0, LightParameter.Diffuse, Color.LightGray); } // load gui elements if (firstTime) { gr2d.LoadTexture(global::UV_DLP_3D_Printer.Properties.Resources.cwtexture1_index); gr2d.LoadFont("Arial18", global::UV_DLP_3D_Printer.Properties.Resources.Arial18_metrics); LoadPluginGui(); //Visible = true; } Set3DView(); firstTime = false; } catch (Exception ex) { String s = ex.Message; // the create perspective function blows up on certain ratios } }
/// <summary> /// Initializes a new instance of the <see cref="NiTextureEffect"/> class. /// </summary> /// <param name="file">The file.</param> /// <param name="reader">The reader.</param> /// <exception cref="Exception">NOT SUPPORTED!</exception> public NiTextureEffect(NiFile file, BinaryReader reader) : base(file, reader) { this.ModelProjectionMatrix = reader.ReadMatrix33(); this.ModelProjectionTransform = reader.ReadVector3(); this.TextureFiltering = (eTexFilterMode)reader.ReadUInt32(); this.TextureClamping = (eTexClampMode)reader.ReadUInt32(); this.EffectType = (eEffectType)reader.ReadUInt32(); this.CoordGenType = (eCoordGenType)reader.ReadUInt32(); if (base.Version <= eNifVersion.VER_3_1) { throw new Exception("NOT SUPPORTED!"); } if (base.Version >= eNifVersion.VER_4_0_0_0) { this.SourceTexture = new NiRef<NiSourceTexture>(reader); } this.ClippingPlane = reader.ReadBoolean(Version); this.unknownVector = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); this.Unknown2 = reader.ReadSingle(); if (this.File.Header.Version <= eNifVersion.VER_10_2_0_0) { this.PS2L = reader.ReadInt16(); this.PS2K = reader.ReadInt16(); } if (this.File.Header.Version <= eNifVersion.VER_4_1_0_12) { this.Unknown3 = reader.ReadUInt16(); } }
public bool Update() { /* The solution is based on Berthold K. P. Horn (1987), "Closed-form solution of absolute orientation using unit quaternions," Journal of the Optical Society of America A, 4:629-642 */ // Original python implementation by David G. Gobbi if (this.SourceLandmarks == null || this.TargetLandmarks == null) { //Identity Matrix this.Matrix = new Matrix4(Vector4.UnitX, Vector4.UnitY, Vector4.UnitZ, Vector4.UnitW); return false; } // --- compute the necessary transform to match the two sets of landmarks --- int N_PTS = this.SourceLandmarks.Length; if (N_PTS != this.TargetLandmarks.Length) { System.Diagnostics.Debug.WriteLine("Error: Source and Target Landmarks contain a different number of points"); return false; } // -- if no points, stop here if (N_PTS == 0) { //Identity Matrix this.Matrix = new Matrix4(Vector4.UnitX, Vector4.UnitY, Vector4.UnitZ, Vector4.UnitW); return false; } float[] source_centroid = { 0, 0, 0 }; float[] target_centroid = { 0, 0, 0 }; FindCentroids(N_PTS, source_centroid, target_centroid); ///------------------------------- // -- if only one point, stop right here if (N_PTS == 1) { this.Matrix = new Matrix4(Vector4.UnitX, Vector4.UnitY, Vector4.UnitZ, Vector4.UnitW); Matrix[0, 3] = target_centroid[0] - source_centroid[0]; this.Matrix[1, 3] = target_centroid[1] - source_centroid[1]; this.Matrix[2, 3] = target_centroid[2] - source_centroid[2]; return true; } // -- build the 3x3 matrix M -- float[,] M = new float[3, 3]; float[,] AAT = new float[3, 3]; for (int i = 0; i < 3; i++) { AAT[i, 0] = M[i, 0] = 0.0F; // fill M with zeros AAT[i, 1] = M[i, 1] = 0.0F; AAT[i, 2] = M[i, 2] = 0.0F; } int pt; for (pt = 0; pt < N_PTS; pt++) { float scale = 0F; float[,] N = CreateMatrixForDiag(pt, source_centroid, target_centroid, M, ref scale); float[,] eigenvectorData = new float[4, 4]; //float *eigenvectors[4],eigenvalues[4]; float[,] eigenvectors = new float[4, 4]; float[] eigenvalues = new float[4]; //for (int i = 0; i < 4; i++) //{ // for (int j = 0; j < 4; j++) // { // eigenvectors[i, j] = eigenvectorData[i, j]; // } //} vtkJacobiN(N, 4, eigenvalues, eigenvectors); //returns this.Matrix CreateMatrixOutOfDiagonalizationResult(eigenvectors, eigenvalues, N_PTS, source_centroid, target_centroid, scale); //this.Matrix.Modified(); } return true; }
public void SetDrawingRegion(int x, int y, int w, int h) { GL.Flush(); m_ortho = OpenTK.Matrix4.CreateOrthographicOffCenter(-x, mWidth - x, mHeight - y, -y, 1, 2000); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref m_ortho); GL.Scissor(x, mHeight - y - h, w, h); GL.Enable(EnableCap.ScissorTest); }
/// <summary> /// Matrix Overload for Framework Match /// </summary> public static void CreateTranslation(float x, float y, float z, out Matrix result) { #if SharpDX Matrix.Translation(x, y, z, out result); #else Matrix.CreateTranslation(x, y, z, out result); #endif }
public void SetProjection(CalibrationResult calib, Matrix4? modelView = null, Matrix4? offset = null) { this.calib = calib; parent.MakeCurrent(); var Width = parent.Width; var Height = parent.Height; GL.Viewport(0, 0, Width, Height); var rt = calib.Extrinsic.ExtrinsicMatrix.Data; var extrin = new OpenTK.Matrix4( (float)rt[0, 0], (float)rt[1, 0], (float)rt[2, 0], 0, (float)rt[0, 1], (float)rt[1, 1], (float)rt[2, 1], 0, (float)rt[0, 2], (float)rt[1, 2], (float)rt[2, 2], 0, (float)rt[0, 3], (float)rt[1, 3], (float)rt[2, 3], 1) * (offset.HasValue ? offset.Value : Matrix4.Identity); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref extrin); GL.MatrixMode(MatrixMode.Modelview); if (modelView == null) GL.LoadIdentity(); else { var mat = modelView.Value; GL.LoadMatrix(ref mat); } var intrin = calib.Intrinsic.IntrinsicMatrix.Data; var dist = calib.Intrinsic.DistortionCoeffs.Data; F = new Vector2((float)intrin[0, 0], (float)intrin[1, 1]); C = new Vector2((float)intrin[0, 2], (float)intrin[1, 2]); K = new Matrix4( (float)dist[0, 0], (float)dist[1, 0], (float)dist[2, 0], (float)dist[3, 0], (float)dist[4, 0], (float)dist[5, 0], (float)dist[6, 0], (float)dist[7, 0], 0, 0, 0, 0, 0, 0, 0, 0); }
public virtual void RecalculateModelMatrix() { m_m4ModelMatrix = Matrix4.CreateScale(m_v2Size.X) * Matrix4.CreateTranslation(m_v3Position); }
void ResizeHandler(object sender, EventArgs e) { GL.Viewport(ClientRectangle); float aspect_ratio = Width / (float)Height; projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver2, aspect_ratio, 1, 512); GL.MatrixMode(MatrixMode.Projection); GL.LoadMatrix(ref projection); }
/// <summary> /// Initializes a new instance of the <see cref="SkinTransform"/> class. /// </summary> /// <param name="file">The file.</param> /// <param name="reader">The reader.</param> public SkinTransform(NiFile file, BinaryReader reader) { this.Rotation = reader.ReadMatrix33(); this.Translation = reader.ReadVector3(); this.Scale = reader.ReadSingle(); }
private void SetupViewport() { if (!loaded) return; float aspect = 1.0f; try { int w = glControl1.Width; int h = glControl1.Height; GL.Viewport(0, 0, w, h); // Use all of the glControl painting area aspect = ((float)glControl1.Width) / ((float)glControl1.Height); SetAlpha(false); // start off with alpha off GL.Enable(EnableCap.CullFace); // enable culling of faces GL.CullFace(CullFaceMode.Back); // specify culling backfaces m_projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView(0.55f, aspect, 1, 2000); m_modelView = OpenTK.Matrix4.LookAt(new OpenTK.Vector3(5, 0, -5), new OpenTK.Vector3(0, 0, 0), new OpenTK.Vector3(0, 0, 1)); m_ortho = OpenTK.Matrix4.CreateOrthographicOffCenter(0, w, h, 0, 1, 2000); m_2dView = OpenTK.Matrix4.LookAt(new OpenTK.Vector3(0, 0, 10), new OpenTK.Vector3(0, 0, 0), new OpenTK.Vector3(0, 1, 0)); GL.ShadeModel(ShadingModel.Smooth); // tell it to shade smoothly // properties of materials GL.Enable(EnableCap.ColorMaterial); // allow polys to have color float[] mat_specular = { 1.0f, 1.0f, 1.0f, 1.0f }; float[] mat_shininess = { 50.0f }; GL.Material(MaterialFace.Front, MaterialParameter.Specular, mat_specular); GL.Material(MaterialFace.Front, MaterialParameter.Shininess, mat_shininess); //set a color to clear the background GL.ClearColor(Color.LightBlue); // antialising lines GL.Enable(EnableCap.LineSmooth); //GL.Enable(EnableCap.PolygonSmooth); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); GL.Hint(HintTarget.LineSmoothHint, HintMode.Nicest); //GL.Hint(HintTarget.PolygonSmoothHint, HintMode.Nicest); float[] res = new float[2]; GL.GetFloat(GetPName.SmoothLineWidthRange, res); DebugLogger.Instance().LogInfo("Stencil depth: " + glControl1.GraphicsMode.Stencil.ToString()); // lighting if (firstTime) { GL.Enable(EnableCap.Lighting); GL.Enable(EnableCap.Light0); float[] light_position = { 1.0f, 1.0f, 1.0f, 0.0f }; GL.Light(LightName.Light0, LightParameter.Position, light_position); GL.Light(LightName.Light0, LightParameter.Diffuse, Color.LightGray); } Set3DView(); gr2d.LoadTexture(global::UV_DLP_3D_Printer.Properties.Resources.cwtexture1, global::UV_DLP_3D_Printer.Properties.Resources.cwtexture1_index); firstTime = false; } catch (Exception ex) { String s = ex.Message; // the create perspective function blows up on certain ratios } }