Can render triangles now

8 files changed, 192 insertions, 30 deletions

diff --git a/Unicity.Renderer/GraphicsRenderer.cs b/Unicity.Renderer/GraphicsRenderer.cs
index 4a794c9..1df8bfb 100644
--- a/Unicity.Renderer/GraphicsRenderer.cs
+++ b/Unicity.Renderer/GraphicsRenderer.cs
@@ -1,45 +1,120 @@
-using System.IO;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using OpenTK;
 using OpenTK.Graphics.OpenGL4;
+using Unicity.Renderer.Shapes;
 
 namespace Unicity.Renderer
 {
-    public class GraphicsRenderer
+    public class GraphicsRenderer : IDisposable
     {
         RenderWindow window = null;
 
         // Tests
-        float[] vertices =
-        {
-            -0.5f, -0.5f, 0.0f,
-            0.5f, -0.5f, 0.0f,
-            0.0f, 0.5f, 0.0f
-        };
+        List<float> triangleVerts = new List<float>();
+        int triangleCount = -1;
+        int triangleVBO = -1;
+        int triangleVAO = -1;
 
         Shader shader = null;
 
-        int VBO = 0;
+        bool disposed = false;
 
         public GraphicsRenderer(RenderWindow window)
         {
             this.window = window;
+            window.Render += Window_Render;
+
+            string vertexCode = File.ReadAllText("shaders/test.vert");
+            string fragmentCode = File.ReadAllText("shaders/test.frag");
+
+            shader = new Shader(vertexCode, fragmentCode);
+            shader.Use();
+
+            shader.SetUniform("inColor", new Vector4(1.0f, 1.0f, 1.0f, 1.0f));
+
+            GL.ClearColor(0.5f, 0.5f, 0.5f, 1.0f);
+            SetRenderData(new Shape[0]);
         }
 
-        public void TestInit()
+        public void SetRenderData(Shape[] shapes)
         {
-            window.MakeCurrent();
+            triangleVerts = new List<float>();
 
-            string vertexCode = File.ReadAllText("shaders/test.vert");
+            triangleCount = 0;
+
+            for (int i = 0; i < shapes.Length; i++)
+            {
+                if (typeof(Triangle) == shapes[i].GetType())
+                {
+                    foreach (float val in ((Triangle)shapes[i]).Vertices)
+                    {
+                        triangleVerts.Add(val);
+                    }
+
+                    triangleCount++;
+                }
+            }
+
+            if (triangleVAO != -1)
+            {
+                GL.DeleteVertexArray(triangleVAO);
+            }
+
+            if (triangleVBO != -1)
+            {
+                GL.DeleteBuffer(triangleVBO);
+            }
 
-            shader = new Shader(vertexCode, "");
+            triangleVAO = GL.GenVertexArray();
+            triangleVBO = GL.GenBuffer();
 
-            VBO = GL.GenBuffer();
-            GL.BindBuffer(BufferTarget.ArrayBuffer, VBO);
-            GL.BufferData(BufferTarget.ArrayBuffer, vertices.Length * sizeof(float), vertices, BufferUsageHint.StaticDraw);
+            GL.BindVertexArray(triangleVAO);
+            GL.BindBuffer(BufferTarget.ArrayBuffer, triangleVBO);
+            GL.BufferData(BufferTarget.ArrayBuffer, triangleVerts.Count * sizeof(float), triangleVerts.ToArray(), BufferUsageHint.DynamicDraw);
+
+            GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), 0);
+            GL.EnableVertexAttribArray(0);
+
+            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
+            GL.BindVertexArray(0);
         }
 
-        public void TestLoop()
+        private void Window_Render(object sender, System.EventArgs e)
         {
             window.MakeCurrent();
+
+            shader.Use();
+            
+            GL.BindVertexArray(triangleVAO);
+            GL.DrawArrays(PrimitiveType.Triangles, 0, triangleCount * 3);
+            GL.BindVertexArray(0);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                // Dispose of managed resources
+            }
+
+            // Dispose of unmanaged resources
+            GL.DeleteVertexArray(triangleVAO);
+            GL.DeleteBuffer(triangleVBO);
+
+            disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Unicity.Renderer/RenderWindow.cs b/Unicity.Renderer/RenderWindow.cs
index 4566295..eceac9a 100644
--- a/Unicity.Renderer/RenderWindow.cs
+++ b/Unicity.Renderer/RenderWindow.cs
@@ -30,12 +30,13 @@ namespace Unicity.Renderer
         private void Window_Load(object sender, EventArgs e)
         {
             GL.Viewport(0, 0, Width, Height);
-            GL.ClearColor(1.0f, 0.0f, 0.0f, 1.0f);
         }
 
         private void Window_Resize(object sender, EventArgs e)
         {
             GL.Viewport(0, 0, Width, Height);
+
+            Window_RenderFrame(this, new FrameEventArgs());
         }
 
         private void Window_UpdateFrame(object sender, FrameEventArgs e)
@@ -47,7 +48,7 @@ namespace Unicity.Renderer
         {
             GL.Clear(ClearBufferMask.ColorBufferBit);
 
-            Update?.Invoke(this, EventArgs.Empty);
+            Render?.Invoke(this, EventArgs.Empty);
 
             window.SwapBuffers();
         }
diff --git a/Unicity.Renderer/Shader.cs b/Unicity.Renderer/Shader.cs
index 6ee0b33..31dcef7 100644
--- a/Unicity.Renderer/Shader.cs
+++ b/Unicity.Renderer/Shader.cs
@@ -1,31 +1,79 @@
 using System;
+using OpenTK;
 using OpenTK.Graphics.OpenGL4;
 
 namespace Unicity.Renderer
 {
     class Shader
     {
-        //int program = 0;
+        int program = 0;
 
         public Shader(string vertexCode, string fragmentCode)
         {
-            int vertex = GL.CreateShader(ShaderType.VertexShader);
+            int vertexShader = GL.CreateShader(ShaderType.VertexShader);
+            int fragmentShader = GL.CreateShader(ShaderType.FragmentShader);
 
-            GL.ShaderSource(vertex, vertexCode);
-            GL.CompileShader(vertex);
+            GL.ShaderSource(vertexShader, vertexCode);
+            GL.ShaderSource(fragmentShader, fragmentCode);
 
-            if (!Compiled(vertex))
+            GL.CompileShader(vertexShader);
+            GL.CompileShader(fragmentShader);
+
+            if (!ShaderCompiled(vertexShader))
+            {
+                GL.DeleteShader(vertexShader);
+                GL.DeleteBuffer(fragmentShader);
+                throw new Exception("Failed to compile vertex shader: " + GL.GetShaderInfoLog(vertexShader));
+            }
+
+            if (!ShaderCompiled(fragmentShader))
             {
-                GL.DeleteShader(vertex);
-                throw new Exception("Failed to compile vertex shader: " + GL.GetShaderInfoLog(vertex));
+                GL.DeleteShader(vertexShader);
+                GL.DeleteBuffer(fragmentShader);
+                throw new Exception("Failed to compile frgament shader: " + GL.GetShaderInfoLog(fragmentShader));
+            }
+
+            program = GL.CreateProgram();
+            GL.AttachShader(program, vertexShader);
+            GL.AttachShader(program, fragmentShader);
+
+            GL.LinkProgram(program);
+
+            GL.DetachShader(program, vertexShader);
+            GL.DetachShader(program, fragmentShader);
+            GL.DeleteShader(vertexShader);
+            GL.DeleteShader(fragmentShader);
+
+            if (!ProgramCompiled(program))
+            {
+                GL.DeleteProgram(program);
+                throw new Exception("Failed to link shader program: " + GL.GetProgramInfoLog(program));
             }
         }
 
-        private bool Compiled(int shader)
+        public void Use()
+        {
+            GL.UseProgram(program);
+        }
+
+        public void SetUniform(string name, Vector4 value)
+        {
+            int location = GL.GetUniformLocation(program, name);
+            GL.Uniform4(location, value);
+        }
+
+        private bool ShaderCompiled(int shader)
         {
             int[] output = new int[1];
             GL.GetShader(shader, ShaderParameter.CompileStatus, output);
             return output[0] != 0;
         }
+
+        private bool ProgramCompiled(int program)
+        {
+            int[] output = new int[1];
+            GL.GetProgram(program, GetProgramParameterName.LinkStatus, output);
+            return output[0] != 0;
+        }
     }
 }
diff --git a/Unicity.Renderer/Shapes/Shape.cs b/Unicity.Renderer/Shapes/Shape.cs
new file mode 100644
index 0000000..25d5148
--- /dev/null
+++ b/Unicity.Renderer/Shapes/Shape.cs
@@ -0,0 +1,7 @@
+namespace Unicity.Renderer.Shapes
+{
+    public abstract class Shape
+    {
+        
+    }
+}
diff --git a/Unicity.Renderer/Shapes/Triangle.cs b/Unicity.Renderer/Shapes/Triangle.cs
new file mode 100644
index 0000000..d0145ff
--- /dev/null
+++ b/Unicity.Renderer/Shapes/Triangle.cs
@@ -0,0 +1,16 @@
+using OpenTK;
+
+namespace Unicity.Renderer.Shapes
+{
+    public class Triangle : Shape
+    {
+        internal float[] Vertices;
+        Vector3 Color;
+
+        public Triangle(float[] vertices, float red, float green, float blue)
+        {
+            Vertices = vertices;
+            Color = new Vector3(red, green, blue);
+        }
+    }
+}
diff --git a/Unicity.Renderer/Unicity.Renderer.csproj b/Unicity.Renderer/Unicity.Renderer.csproj
index 6ea5c1b..2e8a049 100644
--- a/Unicity.Renderer/Unicity.Renderer.csproj
+++ b/Unicity.Renderer/Unicity.Renderer.csproj
@@ -53,6 +53,8 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RenderWindow.cs" />
     <Compile Include="Shader.cs" />
+    <Compile Include="Shapes\Shape.cs" />
+    <Compile Include="Shapes\Triangle.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="OpenTK.dll.config" />
diff --git a/Unicity.Renderer/shaders/test.frag b/Unicity.Renderer/shaders/test.frag
index 5f28270..58db0c6 100644
--- a/Unicity.Renderer/shaders/test.frag
+++ b/Unicity.Renderer/shaders/test.frag
@@ -1 +1,10 @@
-
\ No newline at end of file
+#version 400 core
+
+out vec4 FragColor;
+
+in vec4 vertexColor;
+
+void main()
+{
+	FragColor = vertexColor;
+}
\ No newline at end of file
diff --git a/Unicity.Renderer/shaders/test.vert b/Unicity.Renderer/shaders/test.vert
index c087c1a..c0395f0 100644
--- a/Unicity.Renderer/shaders/test.vert
+++ b/Unicity.Renderer/shaders/test.vert
@@ -2,7 +2,11 @@
 
 layout (location = 0) in vec3 aPos;
 
+out vec4 vertexColor;
+uniform vec4 inColor;
+
 void main()
 {
-	gl_Position = vec4(aPos, 1.0);
+	gl_Position = vec4(aPos, 1.0f);
+	vertexColor = inColor;
 }
\ No newline at end of file