public ImageWithCaption(string titleText, string captionText, string media) : this(titleText, captionText) { image = new Texture(media); imageVAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(904, 410)); imageModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 65 - 410, 0)); }
private Vector3 TransformNormal(Vector3 normal, OpenGL.Matrix4 matrix) { return(new Vector3( normal.X * matrix[0].X + normal.Y * matrix[1].X + normal.Z * matrix[2].X, normal.X * matrix[0].Y + normal.Y * matrix[1].Y + normal.Z * matrix[2].Y, normal.X * matrix[0].Z + normal.Y * matrix[1].Z + normal.Z * matrix[2].Z)); }
private Vector3 Transform(Vector3 position, OpenGL.Matrix4 matrix) { return(new Vector3( position.X * matrix[0].X + position.Y * matrix[1].X + position.Z * matrix[2].X + matrix[3].X, position.X * matrix[0].Y + position.Y * matrix[1].Y + position.Z * matrix[2].Y + matrix[3].Y, position.X * matrix[0].Z + position.Y * matrix[1].Z + position.Z * matrix[2].Z + matrix[3].Z)); }
public ImageAndText(string titleText, string media, string[] bulletText) : this(titleText, bulletText) { image = new Texture(media); imageVAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410)); imageModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 227 - 410, 0)); }
public static void Draw3DPlotLeft(float[] data, float depth, Vector3 color, Matrix4 viewMatrix, bool log = false) { if (data.Length < 441) throw new ArgumentException("The argument data was not the correct length."); for (int i = 0; i < fftData.Length; i++) fftData[i] = new Vector3((log ? Math.Log10(i) * 166 : i) - 441 / 2f, Math.Max(-200, Math.Min(200, 200 * data[i])), depth); //fftData[i] = new Vector3(i - 441 / 2f, Math.Max(-200, Math.Min(200, 200 * data[i])), depth); if (fftVAO == null) { int[] array = new int[441]; for (int i = 0; i < array.Length; i++) array[i] = i; fftHandle = GCHandle.Alloc(fftData, GCHandleType.Pinned); fftVBO = BufferData(fftVBO, fftData, fftHandle); fftVAO = new VAO<Vector3>(Shaders.SimpleColoredShader, fftVBO, "in_position", new VBO<int>(array, BufferTarget.ElementArrayBuffer, BufferUsageHint.StaticDraw)); fftVAO.DrawMode = BeginMode.LineStrip; } else fftVBO = BufferData(fftVBO, fftData, fftHandle); Shaders.SimpleColoredShader.Use(); Shaders.SimpleColoredShader["projectionMatrix"].SetValue(Program.uiProjectionMatrix); Shaders.SimpleColoredShader["viewMatrix"].SetValue(viewMatrix); Shaders.SimpleColoredShader["modelMatrix"].SetValue(Matrix4.CreateTranslation(new Vector3(72 + 441 / 2f, 288, 0))); Shaders.SimpleColoredShader["color"].SetValue(color); fftVAO.Draw(); }
private System.Numerics.Matrix4x4 FromMatrix4(OpenGL.Matrix4 matrix) { return(new System.Numerics.Matrix4x4( matrix[0].X, matrix[0].Y, matrix[0].Z, matrix[0].W, matrix[1].X, matrix[1].Y, matrix[1].Z, matrix[1].W, matrix[2].X, matrix[2].Y, matrix[2].Z, matrix[2].W, matrix[3].X, matrix[3].Y, matrix[3].Z, matrix[3].W)); }
public static void DrawBox(Matrix4 modelMatrix, Vector3 color) { Shaders.SimpleColoredShader.Use(); Shaders.SimpleColoredShader["modelMatrix"].SetValue(modelMatrix); Shaders.SimpleColoredShader["viewMatrix"].SetValue(Matrix4.Identity); Shaders.SimpleColoredShader["color"].SetValue(color); BoxQuad.Draw(); }
public void MatrixCreateFromArray() { Matrix4 matrix = new Matrix4(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); Assert.AreEqual(matrix[0], new Vector4(0, 1, 2, 3)); Assert.AreEqual(matrix[1], new Vector4(4, 5, 6, 7)); Assert.AreEqual(matrix[2], new Vector4(8, 9, 10, 11)); Assert.AreEqual(matrix[3], new Vector4(12, 13, 14, 15)); }
public void MatrixMultiply() { Matrix4 m1 = new Matrix4(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); Matrix4 m2 = new Matrix4(new double[] { 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10 }); Matrix4 mult = m1 * m2; Assert.AreEqual(mult[0], new Vector4(220, 230, 190, 100)); Assert.AreEqual(mult[1], new Vector4(740, 710, 630, 500)); Assert.AreEqual(mult[2], new Vector4(1260, 1190, 1070, 900)); Assert.AreEqual(mult[3], new Vector4(1780, 1670, 1510, 1300)); }
public void MatrixSubtract() { Matrix4 m1 = new Matrix4(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); Matrix4 m2 = new Matrix4(new double[] { 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10 }); Matrix4 difference = m1 - m2; Assert.AreEqual(difference[0], m1[0] - m2[0]); Assert.AreEqual(difference[1], m1[1] - m2[1]); Assert.AreEqual(difference[2], m1[2] - m2[2]); Assert.AreEqual(difference[3], m1[3] - m2[3]); }
public void MatrixAdd() { Matrix4 m1 = new Matrix4(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }); Matrix4 m2 = new Matrix4(new double[] { 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10 }); Matrix4 sum = m1 + m2; Assert.AreEqual(sum[0], m1[0] + m2[0]); Assert.AreEqual(sum[1], m1[1] + m2[1]); Assert.AreEqual(sum[2], m1[2] + m2[2]); Assert.AreEqual(sum[3], m1[3] + m2[3]); }
public static void OnReshape() { uiProjectionMatrix = Matrix4.CreateTranslation(new Vector3(-Program.Width / 2, -Program.Height / 2, 0)) * Matrix4.CreateOrthographic(Program.Width, Program.Height, -500, 1000); // the uiProjectMatrix need only be set once (unless we reshape) Shaders.FontShader.Use(); Shaders.FontShader["projectionMatrix"].SetValue(uiProjectionMatrix); Shaders.SimpleColoredShader.Use(); Shaders.SimpleColoredShader["projectionMatrix"].SetValue(uiProjectionMatrix); }
private VoxelChunkManager() { chunks = new Dictionary<Tuple<int, int>, VoxelChunk>(); chunksToMesh = new Dictionary<Tuple<int, int>, VoxelChunk>(); chunkLoadQueue = new Queue<Tuple<int, int>>(); noise = new OpenSimplexNoise(2); frustum = new Frustum(); chunkScalingMatrix = Matrix4.CreateScaling(new Vector3(ChunkWidth, ChunkHeight, ChunkDepth)); chunkShader = new ShaderProgram(chunkvertexshader, chunkfragmentshader); chunkShader["lightDirection"].SetValue(new Vector3(-0.75, -0.5, -1).Normalize()); }
public TwoImages(string titleText, string media1, string media2) { title = new Text(Text.FontSize._72pt, titleText, Common.TitleColor); title.ModelMatrix = Matrix4.CreateTranslation(new Vector3(80, 720 - 120, 0)); image1 = new Texture(media1); image1VAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410)); image1ModelMatrix = Matrix4.CreateTranslation(new Vector3(72, 720 - 227 - 410, 0)); image2 = new Texture(media2); image2VAO = Utilities.CreateQuad(Shaders.SimpleTexturedShader, Vector2.Zero, new Vector2(441, 410)); image2ModelMatrix = Matrix4.CreateTranslation(new Vector3(535, 720 - 227 - 410, 0)); }
public void MatrixCreateFromVectors() { Vector4 v4 = new Vector4(0, 1, 2, 3); Vector4 v3 = new Vector4(4, 5, 6, 7); Vector4 v2 = new Vector4(8, 9, 10, 11); Vector4 v1 = new Vector4(12, 13, 14, 15); Matrix4 matrix = new Matrix4(v1, v2, v3, v4); Assert.AreEqual(matrix[0], v1); Assert.AreEqual(matrix[1], v2); Assert.AreEqual(matrix[2], v3); Assert.AreEqual(matrix[3], v4); }
public VoxelChunk(int _chunkX, int _chunkZ, int _width, int _height, int _depth) { chunkX = _chunkX; chunkZ = _chunkZ; width = _width; height = _height; depth = _depth; bounds = new AxisAlignedBoundingBox(new Vector3(chunkX * width, 0, chunkZ * depth), new Vector3((chunkX + 1) * width, height, (chunkZ + 1) * depth)); translationMatrix = Matrix4.CreateTranslation(new Vector3(chunkX * width, 0, chunkZ * depth)); meshBuilt = false; data = new ushort[width, height, depth]; }
/// <summary> /// Builds the Planes so that they make up the left, right, up, down, front and back of the Frustum. /// </summary> /// <param name="clipMatrix">The combined projection and view matrix (usually from the camera).</param> public void UpdateFrustum(Matrix4 clipMatrix) { planes[0].Set(clipMatrix[3].w - clipMatrix[3].x, new Vector3(clipMatrix[0].w - clipMatrix[0].x, clipMatrix[1].w - clipMatrix[1].x, clipMatrix[2].w - clipMatrix[2].x)); planes[1].Set(clipMatrix[3].w + clipMatrix[3].x, new Vector3(clipMatrix[0].w + clipMatrix[0].x, clipMatrix[1].w + clipMatrix[1].x, clipMatrix[2].w + clipMatrix[2].x)); planes[2].Set(clipMatrix[3].w + clipMatrix[3].y, new Vector3(clipMatrix[0].w + clipMatrix[0].y, clipMatrix[1].w + clipMatrix[1].y, clipMatrix[2].w + clipMatrix[2].y)); planes[3].Set(clipMatrix[3].w - clipMatrix[3].y, new Vector3(clipMatrix[0].w - clipMatrix[0].y, clipMatrix[1].w - clipMatrix[1].y, clipMatrix[2].w - clipMatrix[2].y)); planes[4].Set(clipMatrix[3].w - clipMatrix[3].z, new Vector3(clipMatrix[0].w - clipMatrix[0].z, clipMatrix[1].w - clipMatrix[1].z, clipMatrix[2].w - clipMatrix[2].z)); planes[5].Set(clipMatrix[3].w + clipMatrix[3].z, new Vector3(clipMatrix[0].w + clipMatrix[0].z, clipMatrix[1].w + clipMatrix[1].z, clipMatrix[2].w + clipMatrix[2].z)); for (int i = 0; i < 6; i++) { float t_mag = planes[i].Normal.Length; planes[i].Scalar /= t_mag; planes[i].Normal /= t_mag; } }
public void Vector3StaticMethods() { for (int i = 0; i < 1000000; i++) { Vector3 v1 = new Vector3(GetRandomFloat(), GetRandomFloat(), GetRandomFloat()); Vector3 v2 = new Vector3(GetRandomFloat(), GetRandomFloat(), GetRandomFloat()); Vector3 v3 = new Vector3(GetRandomFloat(), GetRandomFloat(), GetRandomFloat()); float f1 = GetRandomFloat(); Quaternion q = new Quaternion(GetRandomFloat(), GetRandomFloat(), GetRandomFloat(), GetRandomFloat()); float[] ma = new float[16]; for (int j = 0; j < 16; j++) { ma[j] = GetRandomFloat(); } OpenGL.Matrix4 m = new OpenGL.Matrix4(ma); Assert.AreEqual(Vector3.Abs(v1), new Vector3(Math.Abs(v1.X), Math.Abs(v1.Y), Math.Abs(v1.Z))); Assert.AreEqual(Vector3.Add(v1, v2), new Vector3(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z)); Assert.AreEqual(Vector3.Clamp(v1, v2, v3), new Vector3(Clamp(v1.X, v2.X, v3.X), Clamp(v1.Y, v2.Y, v3.Y), Clamp(v1.Z, v2.Z, v3.Z))); Assert.AreEqual(Vector3.Cross(v1, v2), new Vector3(v1.Y * v2.Z - v1.Z * v2.Y, v1.Z * v2.X - v1.X * v2.Z, v1.X * v2.Y - v1.Y * v2.X)); #if USE_NUMERICS Assert.IsTrue(CloseEnough(Vector3.Distance(v1, v2), (v1 - v2).Length())); #else Assert.IsTrue(CloseEnough(Vector3.Distance(v1, v2), (v1 - v2).Length)); #endif Assert.IsTrue(CloseEnough(Vector3.DistanceSquared(v1, v2), (v1 - v2).LengthSquared())); Assert.AreEqual(Vector3.Divide(v1, f1), new Vector3(v1.X / f1, v1.Y / f1, v1.Z / f1)); Assert.AreEqual(Vector3.Divide(v1, v2), new Vector3(v1.X / v2.X, v1.Y / v2.Y, v1.Z / v2.Z)); Assert.IsTrue(CloseEnough(Vector3.Dot(v1, v2), v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z)); Assert.IsTrue(CloseEnough(Vector3.Lerp(v1, v2, f1), v1 + (v2 - v1) * f1, 1e-02f)); Assert.AreEqual(Vector3.Max(v1, v2), new Vector3(Math.Max(v1.X, v2.X), Math.Max(v1.Y, v2.Y), Math.Max(v1.Z, v2.Z))); Assert.AreEqual(Vector3.Min(v1, v2), new Vector3(Math.Min(v1.X, v2.X), Math.Min(v1.Y, v2.Y), Math.Min(v1.Z, v2.Z))); Assert.AreEqual(Vector3.Multiply(v1, f1), new Vector3(v1.X * f1, v1.Y * f1, v1.Z * f1)); Assert.AreEqual(Vector3.Multiply(f1, v1), new Vector3(v1.X * f1, v1.Y * f1, v1.Z * f1)); Assert.AreEqual(Vector3.Multiply(v1, v2), new Vector3(v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z)); Assert.AreEqual(Vector3.Negate(v1), new Vector3(-v1.X, -v1.Y, -v1.Z)); #if USE_NUMERICS Assert.AreEqual(Vector3.Normalize(v1), v1 / v1.Length()); #else Assert.AreEqual(Vector3.Normalize(v1), v1 / v1.Length); #endif Assert.IsTrue(CloseEnough(Vector3.Reflect(v1, v2), v1 - Vector3.Dot(v1, v2) * v2 * 2f)); Assert.IsTrue(CloseEnough(Vector3.SquareRoot(v1), new Vector3((float)Math.Sqrt(v1.X), (float)Math.Sqrt(v1.Y), (float)Math.Sqrt(v1.Z)))); Assert.AreEqual(Vector3.Subtract(v1, v2), new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z)); Assert.IsTrue(CloseEnough(Vector3.Transform(v1, q), Transform(v1, q), 1e-01f)); } }
/// <summary> /// Builds the Planes so that they make up the left, right, up, down, front and back of the Frustum /// </summary> public void UpdateFrustum(Matrix4 projectionMatrix, Matrix4 modelviewMatrix) { Matrix4 clipMatrix = modelviewMatrix * projectionMatrix; planes[0] = new Plane(clipMatrix[0].w - clipMatrix[0].x, clipMatrix[1].w - clipMatrix[1].x, clipMatrix[2].w - clipMatrix[2].x, clipMatrix[3].w - clipMatrix[3].x); planes[1] = new Plane(clipMatrix[0].w + clipMatrix[0].x, clipMatrix[1].w + clipMatrix[1].x, clipMatrix[2].w + clipMatrix[2].x, clipMatrix[3].w + clipMatrix[3].x); planes[2] = new Plane(clipMatrix[0].w + clipMatrix[0].y, clipMatrix[1].w + clipMatrix[1].y, clipMatrix[2].w + clipMatrix[2].y, clipMatrix[3].w + clipMatrix[3].y); planes[3] = new Plane(clipMatrix[0].w - clipMatrix[0].y, clipMatrix[1].w - clipMatrix[1].y, clipMatrix[2].w - clipMatrix[2].y, clipMatrix[3].w - clipMatrix[3].y); planes[4] = new Plane(clipMatrix[0].w - clipMatrix[0].z, clipMatrix[1].w - clipMatrix[1].z, clipMatrix[2].w - clipMatrix[2].z, clipMatrix[3].w - clipMatrix[3].z); planes[5] = new Plane(clipMatrix[0].w + clipMatrix[0].z, clipMatrix[1].w + clipMatrix[1].z, clipMatrix[2].w + clipMatrix[2].z, clipMatrix[3].w + clipMatrix[3].z); for (int i = 0; i < 6; i++) { float t_mag = planes[i].Normal.Length; planes[i].Scalar /= t_mag; planes[i].Normal /= t_mag; } }
public void LoadViewMat(Matrix4 mat) { GL.UniformMatrix4(loc_view, false, ref mat); }
public void LoadTransformMat(Matrix4 mat) { GL.UniformMatrix4(loc_transformation, false, ref mat); }
public void MatrixMultiplyByFloat() { Vector4 v4 = new Vector4(0, 1, 2, 3); Vector4 v3 = new Vector4(4, 5, 6, 7); Vector4 v2 = new Vector4(8, 9, 10, 11); Vector4 v1 = new Vector4(12, 13, 14, 15); Matrix4 matrix = new Matrix4(v1, v2, v3, v4); Matrix4 mult = matrix * 2f; Assert.AreEqual(mult[0], v1 * 2f); Assert.AreEqual(mult[1], v2 * 2f); Assert.AreEqual(mult[2], v3 * 2f); Assert.AreEqual(mult[3], v4 * 2f); }
public void Render(Matrix4 test, bool outline) { chunkShader.Use(); chunkShader["projectionMatrix"].SetValue(projectionMatrix); chunkShader["viewMatrix"].SetValue(viewMatrix); vertexCount = 0; renderedChunks = 0; frustum.UpdateFrustum(projectionMatrix, test); foreach (var kvp in chunks) { // frustum check var coords = kvp.Key; var chunk = kvp.Value; bool intersects = frustum.Intersects(chunk.AABB); if (outline) { Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); Gl.Disable(EnableCap.CullFace); //VoxelChunk.ChunkBoundsShader.Use(); //VoxelChunk.ChunkBoundsShader["projectionViewMatrix"].SetValue(viewMatrix * projectionMatrix); //VoxelChunk.ChunkBoundsShader["modelMatrix"].SetValue(); //Gl.BindBufferToShaderAttribute(intersects ? VoxelChunk.redColors : VoxelChunk.whiteColors, VoxelChunk.ChunkBoundsShader, "in_color"); //Gl.BindBufferToShaderAttribute(VoxelChunk.boundsVertices, VoxelChunk.ChunkBoundsShader, "in_position"); //Gl.BindBuffer(VoxelChunk.boundsInidices); //Gl.DrawElements(BeginMode.Quads, VoxelChunk.boundsInidices.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Cube.Render(projectionMatrix, viewMatrix, chunkScalingMatrix * chunk.TranslationMatrix, intersects?"ED1111" : "ffffff"); } if (!intersects) continue; Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); Gl.Enable(EnableCap.CullFace); chunkShader.Use(); chunkShader["modelMatrix"].SetValue(chunk.TranslationMatrix); Gl.BindBufferToShaderAttribute(chunk.Vertices, chunkShader, "vertexPosition"); Gl.BindBufferToShaderAttribute(chunk.Normals, chunkShader, "vertexNormal"); Gl.BindBufferToShaderAttribute(chunk.Colors, chunkShader, "vertexColor"); Gl.BindBuffer(chunk.Indices); Gl.DrawElements(BeginMode.Triangles, chunk.Indices.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); vertexCount += chunk.Vertices.Count; renderedChunks++; } }
/// <summary> /// Project it on the screen /// </summary> /// <param name="objPos"></param> /// <param name="projection"></param> /// <param name="view"></param> /// <param name="viewport"></param> /// <returns>bad...</returns> public static Vector4 Project(OpenTK.Vector4 objPos, Matrix4 projection, Matrix4 view, Size viewport) { Vector4 vec = objPos; vec = Vector4.Transform(vec, Matrix4.Mult(projection, view)); vec.X = (vec.X + 1) * (viewport.Width / 2); vec.Y = (vec.Y + 1) * (viewport.Height / 2); return vec; }
static void Main(string[] args) { timefromstart = System.Diagnostics.Stopwatch.StartNew(); Console.WriteLine("Initializing GLUT - {0}s", getTimeFromStart().ToString()); Glut.glutInit(); Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH); Glut.glutInitWindowSize(width, height); Glut.glutCreateWindow("kVoxGame"); Console.WriteLine("GLUT window created - {0}s", getTimeFromStart().ToString()); //Callbacks Glut.glutIdleFunc(OnRenderFrame); Glut.glutDisplayFunc(OnDisplay); //Mouse Glut.glutMouseFunc(OnMouse); Glut.glutMotionFunc(OnMove); //Keyboard Glut.glutKeyboardFunc(OnKeyboardDown); Glut.glutKeyboardUpFunc(OnKeyboardUp); Console.WriteLine("GLUT callbacks binded - {0}s", getTimeFromStart().ToString()); Gl.Enable(EnableCap.DepthTest); Gl.Enable(EnableCap.Blend); Gl.Enable(EnableCap.Multisample); Gl.Enable(EnableCap.SampleAlphaToCoverage); Gl.Enable(EnableCap.FragmentLightingSgix); Gl.Enable(EnableCap.CullFace); Console.WriteLine("GL Enables enabled :D - {0}s", getTimeFromStart().ToString()); skydomeTexture = new Texture("skydome.jpg"); //Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); // create main shader program terrainSP = new ShaderProgram(terrainVS, terrainFS); terrainSP.Use(); terrainSP["color"].SetValue(new Vector3(0, 0.8, 0)); projectionMatrix = Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f); terrainSP["projection_matrix"].SetValue(projectionMatrix); terrainSP["model_matrix"].SetValue(Matrix4.CreateTranslation(new Vector3(0, 0, 0)) * Matrix4.CreateRotation(new Vector3(0, 0, 0), 0.0f)); Console.WriteLine("Shader program (main) compiled and data injected - {0}s", getTimeFromStart().ToString()); // create main skybox program skyboxSP = new ShaderProgram(skyboxVS, skyboxFS); skyboxSP.Use(); skyboxSP["color"].SetValue(new Vector3(0.2, 1.0, 1.0)); skyboxSP["resolution"].SetValue(new Vector2(width, height)); projectionMatrix = Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f); skyboxSP["projection_matrix"].SetValue(projectionMatrix); skyboxSP["model_matrix"].SetValue(Matrix4.CreateTranslation(new Vector3(0, 0, 0)) * Matrix4.CreateRotation(new Vector3(0, 0, 0), 0.0f)); Console.WriteLine("Shader program (skybox) compiled and data injected - {0}s", getTimeFromStart().ToString()); //Setup camera camera = new Camera(new Vector3(0, 0, 10), Quaternion.Identity); camera.SetDirection(new Vector3(0, 0, -1)); Console.WriteLine("Cam setup complete - {0}s", getTimeFromStart().ToString()); watch = System.Diagnostics.Stopwatch.StartNew(); chunks = new VoxelChunk[4]; //instance few voxel chunks chunks[0] = new VoxelChunk(0,0); chunks[1] = new VoxelChunk(0, 32); chunks[2] = new VoxelChunk(32, 0); chunks[3] = new VoxelChunk(32, 32); Console.WriteLine("Chunks added to array - {0}s", getTimeFromStart().ToString()); //init frustum frustum = new Frustum(); frustum.UpdateFrustum(projectionMatrix, camera.ViewMatrix); Console.WriteLine("starting main GLUT loop - {0}s", getTimeFromStart().ToString()); Glut.glutMainLoop(); }
/// <summary> /// Creates an orientated bounding box of size min, max /// </summary> /// <param name="Min">Minimum x,y,z</param> /// <param name="Max">Maximum x,y,z</param> public OrientatedBoundingBox(Vector3 Min, Vector3 Max) { box = new AxisAlignedBoundingBox(Min, Max); modelMatrix = Matrix4.Identity; }
public void SetValue(Matrix4 param) { if (Type != typeof(Matrix4)) throw new Exception(string.Format("SetValue({0}) was given a Matrix4.", Type)); Gl.UniformMatrix4fv(location, 1, false, param.ToFloat()); }
public static void EnableStencil(Matrix4 modelMatrix) { // draw an outline around the chunk Gl.ClearStencil(0); Gl.Clear(ClearBufferMask.StencilBufferBit); Gl.Enable(EnableCap.StencilTest); Gl.StencilFunc(StencilFunction.Always, 1, 0xFFFF); Gl.StencilOp(StencilOp.Keep, StencilOp.Keep, StencilOp.Replace); Gl.ColorMask(false, false, false, false); Shaders.SimpleColoredShader.Use(); Shaders.SimpleColoredShader["modelMatrix"].SetValue(modelMatrix); Shaders.SimpleColoredShader["viewMatrix"].SetValue(Matrix4.Identity); StencilQuad.Draw(); Gl.ColorMask(true, true, true, true); }
public static void Run() { using (var w = new GameWindow(720, 480, null, "ComGr", GameWindowFlags.Default, DisplayDevice.Default, 4, 0, OpenTK.Graphics.GraphicsContextFlags.ForwardCompatible)) { int hProgram = 0; int hTexture = 0; int hHeight = 0; int vaoTriangle = 0; int[] triangleIndices = null; int vboTriangleIndices = 0; byte[] imageData; byte[] heightData; double time = 0; int gridSize = 100; w.Load += (o, ea) => { //set up opengl GL.ClearColor(0.5f, 0.5f, 0.5f, 0); GL.ClearDepth(1); GL.Enable(EnableCap.DepthTest); GL.DepthFunc(DepthFunction.Less); //GL.Enable(EnableCap.CullFace); //load, compile and link shaders //see https://www.khronos.org/opengl/wiki/Vertex_Shader var VertexShaderSource = @" #version 400 core in vec3 pos; in vec2 uvVertex; uniform mat4 model; uniform mat4 projection; uniform sampler2D height; out vec2 uvFragment; out vec3 absolutePos; out vec3 normalFragment; float getHeight(in vec2 pos) { float h = texture(height, pos).x; return log(h*30+1) * 8; } vec3 getNormal(in vec2 pos) { float offset = 1.0/float(textureSize(height,0).x); vec2 xOff = vec2(offset, 0); vec2 zOff = vec2(0, offset); vec3 x = vec3(offset*2, getHeight(pos+xOff) - getHeight(pos-xOff), 0); vec3 z = vec3(0, getHeight(pos+zOff) - getHeight(pos-zOff), offset*2); return normalize(cross(z, x)); } void main() { uvFragment = uvVertex; absolutePos = (model * vec4(pos, 1)).xyz; vec3 n = getNormal(uvVertex); normalFragment = normalize((model * vec4(n, 0)).xyz); vec3 p = pos; p.y = getHeight(uvVertex); gl_Position = projection * vec4(p,1); } "; var hVertexShader = GL.CreateShader(ShaderType.VertexShader); GL.ShaderSource(hVertexShader, VertexShaderSource); GL.CompileShader(hVertexShader); GL.GetShader(hVertexShader, ShaderParameter.CompileStatus, out int status); if (status != 1) { throw new Exception(GL.GetShaderInfoLog(hVertexShader)); } //see https://www.khronos.org/opengl/wiki/Fragment_Shader var FragmentShaderSource = @" #version 400 core uniform sampler2D tex; in vec3 absolutePos; in vec2 uvFragment; in vec3 lightPos; in vec3 normalFragment; out vec4 color; void main() { vec4 col = texture(tex, uvFragment); vec3 lightPos = vec3(2, 7, 0); vec3 toLight = normalize(lightPos - absolutePos); float diffuse = max(0, dot(toLight, normalFragment)); vec3 eye = vec3(0, 0, 0); vec3 viewDir = normalize(absolutePos - eye); vec3 specularDir = normalFragment * (2 * dot(normalFragment, toLight)) - toLight; specularDir = normalize(specularDir); vec3 specular = vec3(0.8) * pow(max(0.0, -dot(specularDir, viewDir)), 5); color = vec4(0.1)*col + diffuse * col + vec4(specular, 1); } "; var hFragmentShader = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(hFragmentShader, FragmentShaderSource); GL.CompileShader(hFragmentShader); GL.GetShader(hFragmentShader, ShaderParameter.CompileStatus, out status); if (status != 1) { throw new Exception(GL.GetShaderInfoLog(hFragmentShader)); } //link shaders to a program hProgram = GL.CreateProgram(); GL.AttachShader(hProgram, hFragmentShader); GL.AttachShader(hProgram, hVertexShader); GL.LinkProgram(hProgram); GL.GetProgram(hProgram, GetProgramParameterName.LinkStatus, out status); if (status != 1) { throw new Exception(GL.GetProgramInfoLog(hProgram)); } var triangleVertices = new float[(gridSize + 1) * (gridSize + 1) * 3]; var uvs = new float[(gridSize + 1) * (gridSize + 1) * 2]; triangleIndices = new int[gridSize * gridSize * 2 * 3]; for (int i = 0; i < gridSize + 1; i++) { for (int j = 0; j < gridSize + 1; j++) { triangleVertices[((gridSize + 1) * i + j) * 3 + 0] = i; triangleVertices[((gridSize + 1) * i + j) * 3 + 1] = 0; triangleVertices[((gridSize + 1) * i + j) * 3 + 2] = j; uvs[((gridSize + 1) * i + j) * 2 + 0] = i / (float)gridSize; uvs[((gridSize + 1) * i + j) * 2 + 1] = j / (float)gridSize; } } for (int i = 0; i < gridSize; i++) { for (int j = 0; j < gridSize; j++) { triangleIndices[(gridSize * i + j) * 6 + 0] = ((gridSize + 1) * i + j) + (gridSize + 1) * 0 + 0; triangleIndices[(gridSize * i + j) * 6 + 1] = ((gridSize + 1) * i + j) + (gridSize + 1) * 0 + 1; triangleIndices[(gridSize * i + j) * 6 + 2] = ((gridSize + 1) * i + j) + (gridSize + 1) * 1 + 0; triangleIndices[(gridSize * i + j) * 6 + 3] = ((gridSize + 1) * i + j) + (gridSize + 1) * 1 + 0; triangleIndices[(gridSize * i + j) * 6 + 4] = ((gridSize + 1) * i + j) + (gridSize + 1) * 0 + 1; triangleIndices[(gridSize * i + j) * 6 + 5] = ((gridSize + 1) * i + j) + (gridSize + 1) * 1 + 1; } } //upload model vertices to a vbo var vboTriangleVertices = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ArrayBuffer, vboTriangleVertices); GL.BufferData(BufferTarget.ArrayBuffer, triangleVertices.Length * sizeof(float), triangleVertices, BufferUsageHint.StaticDraw); // upload model indices to a vbo vboTriangleIndices = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, vboTriangleIndices); GL.BufferData(BufferTarget.ElementArrayBuffer, triangleIndices.Length * sizeof(int), triangleIndices, BufferUsageHint.StaticDraw); var vboUvs = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ArrayBuffer, vboUvs); GL.BufferData(BufferTarget.ArrayBuffer, uvs.Length * sizeof(float), uvs, BufferUsageHint.StaticDraw); //set up a vao vaoTriangle = GL.GenVertexArray(); GL.BindVertexArray(vaoTriangle); GL.EnableVertexAttribArray(GL.GetAttribLocation(hProgram, "pos")); GL.BindBuffer(BufferTarget.ArrayBuffer, vboTriangleVertices); GL.VertexAttribPointer(GL.GetAttribLocation(hProgram, "pos"), 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(GL.GetAttribLocation(hProgram, "uvVertex")); GL.BindBuffer(BufferTarget.ArrayBuffer, vboUvs); GL.VertexAttribPointer(GL.GetAttribLocation(hProgram, "uvVertex"), 2, VertexAttribPointerType.Float, false, 0, 0); var image = new Bitmap("./stones.bmp"); var imageW = image.Width; var h = image.Height; imageData = new byte[imageW * h * 3]; BitmapData data = image.LockBits(new Rectangle(0, 0, imageW, h), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb); unsafe { byte *p = (byte *)data.Scan0; for (int i = 0; i < imageW * h * 3; i += 3) { imageData[i] = *(p++); //r imageData[i + 1] = *(p++); //g imageData[i + 2] = *(p++); //b } image.UnlockBits(data); } GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1); GL.GenTextures(1, out hTexture); GL.BindTexture(TextureTarget.Texture2D, hTexture); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Srgb8, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Rgb, PixelType.UnsignedByte, imageData); GL.GenerateMipmap(GenerateMipmapTarget.Texture2D); image = new Bitmap("./height.bmp"); imageW = image.Width; h = image.Height; heightData = new byte[imageW * h * 3]; data = image.LockBits(new Rectangle(0, 0, imageW, h), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb); unsafe { byte *p = (byte *)data.Scan0; for (int i = 0; i < imageW * h * 3; i += 3) { heightData[i] = *(p++); //r heightData[i + 1] = *(p++); //g heightData[i + 2] = *(p++); //b } image.UnlockBits(data); } GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1); GL.GenTextures(1, out hHeight); GL.BindTexture(TextureTarget.Texture2D, hHeight); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Srgb8, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Rgb, PixelType.UnsignedByte, heightData); GL.GenerateMipmap(GenerateMipmapTarget.Texture2D); { //check for errors during all previous calls var error = GL.GetError(); if (error != ErrorCode.NoError) { throw new Exception(error.ToString()); } } }; w.UpdateFrame += (o, fea) => { //perform logic time += fea.Time; }; w.RenderFrame += (o, fea) => { //clear screen and z-buffer GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); //switch to our shader GL.UseProgram(hProgram); GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(TextureTarget.Texture2D, hTexture); GL.Uniform1(GL.GetUniformLocation(hProgram, "tex"), 0); GL.ActiveTexture(TextureUnit.Texture1); GL.BindTexture(TextureTarget.Texture2D, hHeight); GL.Uniform1(GL.GetUniformLocation(hProgram, "height"), 1); var scale = Matrix4.CreateScale(5f / gridSize); var transCenter = Matrix4.CreateTranslation(-gridSize / 2, 0f, -gridSize / 2); var rotate = Matrix4x4.CreateFromYawPitchRoll((float)time / 2, 0, 0).ToGlMatrix(); var tilt = Matrix4x4.CreateFromYawPitchRoll(0, 0.2f, 0).ToGlMatrix(); var translate = Matrix4.CreateTranslation(0f, -1.5f, -5f); var perspective = Matrix4.CreatePerspectiveFieldOfView((float)Math.PI / 2, 1, 1, 100); var allTransforms = transCenter * scale * rotate * tilt * translate; GL.UniformMatrix4(GL.GetUniformLocation(hProgram, "model"), false, ref allTransforms); allTransforms = allTransforms * perspective; GL.UniformMatrix4(GL.GetUniformLocation(hProgram, "projection"), false, ref allTransforms); //render our model GL.BindVertexArray(vaoTriangle); GL.BindBuffer(BufferTarget.ElementArrayBuffer, vboTriangleIndices); GL.DrawElements(PrimitiveType.Triangles, triangleIndices.Length, DrawElementsType.UnsignedInt, 0); //display w.SwapBuffers(); var error = GL.GetError(); if (error != ErrorCode.NoError) { throw new Exception(error.ToString()); } }; w.Resize += (o, ea) => { GL.Viewport(w.ClientRectangle); }; w.Run(); } }
public static void DrawXPlotter(Matrix4 modelMatrix) { DrawBox(modelMatrix, SubtitleColor); Shaders.SimpleColoredShader["color"].SetValue(TextColor); CrosshairVAO.VertexCount = 2; CrosshairVAO.Draw(); CrosshairVAO.VertexCount = 4; }
/// <summary> /// This is the frustum. /// </summary> /// <param name="normalize">Normalize the vectors</param> /// <returns>0-3 is left,right,top,bottom, 4-5 is the near/far plane</returns> public static Vector4[] GetFrustum(bool normalize) { // Get bounds of view. float[] viewport = new float[4]; float[] projectiofM = new float[16]; float[] modelviewfM = new float[16]; Matrix4 projectionM = new Matrix4(); Matrix4 modelviewM = new Matrix4(); Matrix4 projMultimodel;// = new Matrix4(); Matrix4 ScreenFrustum = new Matrix4(); // all 4 used Vector4[] NearFarFrustum = new Vector4[2]; // only 0-1 used, 2-3 is zero Vector4[] RetArr = new Vector4[6]; // only 0-1 used, 2-3 is zero GL.GetFloat(GetPName.Viewport, viewport); GL.GetFloat(GetPName.ProjectionMatrix, out projectionM); GL.GetFloat(GetPName.ModelviewMatrix, out modelviewM); projMultimodel = Matrix4.Mult(projectionM, modelviewM); // Got the wrong order used columns when it should have been rows..... /*Vector4 rPlane = new Vector4(projMultimodel.Column0.W - projMultimodel.Column0.X, projMultimodel.Column1.W - projMultimodel.Column1.X, projMultimodel.Column2.W - projMultimodel.Column2.X, projMultimodel.Column3.W - projMultimodel.Column3.X);*/ Vector4 rPlane = new Vector4(projMultimodel.Column3.X - projMultimodel.Column0.X, projMultimodel.Column3.Y - projMultimodel.Column1.X, projMultimodel.Column3.Z - projMultimodel.Column2.X, projMultimodel.Column3.W - projMultimodel.Column3.X); if (normalize) { rPlane.Normalize(); } Vector4 rPlaneManual = new Vector4(projMultimodel.M14 - projMultimodel.M11, projMultimodel.M24 - projMultimodel.M21, projMultimodel.M34 - projMultimodel.M31, projMultimodel.M44 - projMultimodel.M41); if (normalize) { rPlaneManual.Normalize(); } /*Vector4 rPlaneManual2; unsafe { float* clip1 = (float*)(&projMultimodel); rPlaneManual2 = new Vector4(clip1[3] - clip1[0], clip1[7] - clip1[4], clip1[11] - clip1[8], clip1[15] - clip1[12]); rPlaneManual2.Normalize(); } */ /*Vector4 lPlane = new Vector4(projMultimodel.Column0.W + projMultimodel.Column0.X, projMultimodel.Column1.W + projMultimodel.Column1.X, projMultimodel.Column2.W + projMultimodel.Column2.X, projMultimodel.Column3.W + projMultimodel.Column3.X);*/ /* Vector4 lPlane = new Vector4(projMultimodel.Column3.X + projMultimodel.Column0.X, projMultimodel.Column3.Y + projMultimodel.Column1.X, projMultimodel.Column3.Z + projMultimodel.Column2.X, projMultimodel.Column3.W + projMultimodel.Column3.X);*/ Vector4 row = projMultimodel.Row0; Vector4 lPlane = new Vector4(projMultimodel.Column3.X + row.X, projMultimodel.Column3.Y + row.Y, projMultimodel.Column3.Z + row.Z, projMultimodel.Column3.W + row.W); if (normalize) { lPlane.Normalize(); } /*Vector4 bPlane = new Vector4(projMultimodel.Column0.W - projMultimodel.Column0.Y, projMultimodel.Column1.W - projMultimodel.Column1.Y, projMultimodel.Column2.W - projMultimodel.Column2.Y, projMultimodel.Column3.W - projMultimodel.Column3.Y);*/ Vector4 bPlane = new Vector4(projMultimodel.Column3.X - projMultimodel.Column0.Y, projMultimodel.Column3.Y - projMultimodel.Column1.Y, projMultimodel.Column3.Z - projMultimodel.Column2.Y, projMultimodel.Column3.W - projMultimodel.Column3.Y); if (normalize) { bPlane.Normalize(); } /*Vector4 tPlane = new Vector4(projMultimodel.Column0.W + projMultimodel.Column0.Y, projMultimodel.Column1.W + projMultimodel.Column1.Y, projMultimodel.Column2.W + projMultimodel.Column2.Y, projMultimodel.Column3.W + projMultimodel.Column3.Y);*/ Vector4 tPlane = new Vector4(projMultimodel.Column3.X + projMultimodel.Column0.Y, projMultimodel.Column3.Y + projMultimodel.Column1.Y, projMultimodel.Column3.Z + projMultimodel.Column2.Y, projMultimodel.Column3.W + projMultimodel.Column3.Y); if (normalize) { tPlane.Normalize(); } ScreenFrustum = new Matrix4(rPlane, lPlane, bPlane, tPlane); /*NearFarFrustum[0] = new Vector4(projMultimodel.Column0.W + projMultimodel.Column0.Z, projMultimodel.Column1.W + projMultimodel.Column1.Z, projMultimodel.Column2.W + projMultimodel.Column2.Z, projMultimodel.Column3.W + projMultimodel.Column3.Z);*/ NearFarFrustum[0] = new Vector4(projMultimodel.Column3.X + projMultimodel.Column0.Z, projMultimodel.Column3.Y + projMultimodel.Column1.Z, projMultimodel.Column3.Z + projMultimodel.Column2.Z, projMultimodel.Column3.W + projMultimodel.Column3.Z); if (normalize) { NearFarFrustum[0].Normalize(); } /*NearFarFrustum[1] = new Vector4(projMultimodel.Column0.W - projMultimodel.Column0.Z, projMultimodel.Column1.W - projMultimodel.Column1.Z, projMultimodel.Column2.W - projMultimodel.Column2.Z, projMultimodel.Column3.W - projMultimodel.Column3.Z);*/ NearFarFrustum[1] = new Vector4(projMultimodel.Column3.X - projMultimodel.Column0.Z, projMultimodel.Column3.Y - projMultimodel.Column1.Z, projMultimodel.Column3.Z - projMultimodel.Column2.Z, projMultimodel.Column3.W - projMultimodel.Column3.Z); if (normalize) { NearFarFrustum[1].Normalize(); } RetArr[0] = ScreenFrustum.Row0; RetArr[1] = ScreenFrustum.Row1; RetArr[2] = ScreenFrustum.Row2; RetArr[3] = ScreenFrustum.Row3; RetArr[4] = NearFarFrustum[0]; RetArr[5] = NearFarFrustum[1]; return RetArr; }
// new test for get max with... /// <summary> /// UnProject the projection ie. flatten it on the screen /// </summary> /// <param name="projection"></param> /// <param name="view"></param> /// <param name="viewport"></param> /// <param name="mouse"></param> /// <returns>bad...</returns> public static Vector4 UnProject(Matrix4 projection, Matrix4 view, 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 = 1.0f; 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; }
/// <summary> /// Builds the Planes so that they make up the left, right, up, down, front and back of the Frustum. /// </summary> public void UpdateFrustum(Matrix4 projectionMatrix, Matrix4 modelviewMatrix) { UpdateFrustum(modelviewMatrix * projectionMatrix); }
public static void DrawBullet(Matrix4 modelMatrix) { Shaders.SimpleTexturedShader.Use(); Shaders.SimpleTexturedShader["modelMatrix"].SetValue(modelMatrix); Gl.BindTexture(BulletTexture); BulletQuad.Draw(); }
public static void Render(Matrix4 proj, Matrix4 view, Matrix4 model, string color) { Shader.Use(); Shader["projectionMatrix"].SetValue(proj); Shader["viewMatrix"].SetValue(view); Shader["modelMatrix"].SetValue(model); Gl.BindBufferToShaderAttribute(Vertices, Shader, "vertexPosition"); Gl.BindBufferToShaderAttribute(Colors(color), Shader, "vertexColor"); Gl.BindBuffer(Indices); Gl.DrawElements(BeginMode.Quads, Indices.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); }
/// <summary> /// Transforms the box by a Matrix4. Will maintain the axis-alignment even during rotations. /// </summary> /// <param name="TranformMatrix">The Matrix4 to transform by</param> public void Transform(Matrix4 TranformMatrix) { Vector3 t_min = min, t_max = max, t_corner; min = max = Vector3.Zero; // Compute corners in the order of 0, 6, 5, 1, 2, 4, 7, 3 // Allows the code to change only one member at a time to get to all corners t_corner = t_min; // min min min AddPoint(TranformMatrix * t_corner); t_corner.z = t_max.z; // min min max AddPoint(TranformMatrix * t_corner); t_corner.y = t_max.y; // min max max AddPoint(TranformMatrix * t_corner); t_corner.z = t_min.z; // min max min AddPoint(TranformMatrix * t_corner); t_corner.x = t_max.x; // max max min AddPoint(TranformMatrix * t_corner); t_corner.z = t_max.z; // max max max AddPoint(TranformMatrix * t_corner); t_corner.y = t_min.y; // max min max AddPoint(TranformMatrix * t_corner); t_corner.z = t_min.z; // max min min AddPoint(TranformMatrix * t_corner); }
/// <summary> /// Get the Viewport matrix /// </summary> /// <returns>Matrix4 of the viewport</returns> public static Matrix4 GetMVP() { /*//float[] viewport = new float[4]; //float[] projectiofM = new float[16]; //float[] modelviewfM = new float[16]; Matrix4 projectionM = new Matrix4(); Matrix4 modelviewM = new Matrix4(); Matrix4 projMultimodel; //GL.GetFloat(GetPName.Viewport, viewport); GL.GetFloat(GetPName.ProjectionMatrix, out projectionM); GL.GetFloat(GetPName.ModelviewMatrix, out modelviewM); //projMultimodel = Matrix4.Mult(projectionM, modelviewM); projMultimodel = Matrix4.Mult(modelviewM, projectionM); return projMultimodel;*/ if (MVP_changed) { Matrix4 projectionM = new Matrix4(); Matrix4 modelviewM = new Matrix4(); GL.GetFloat(GetPName.ProjectionMatrix, out projectionM); GL.GetFloat(GetPName.ModelviewMatrix, out modelviewM); MVPMatrix = Matrix4.Mult(modelviewM, projectionM); MVP_changed = false; } return MVPMatrix; }
public void LoadProjectionMat(Matrix4 mat) { GL.UniformMatrix4(loc_projection, false, ref mat); }