NetGL - .Net Wrapper für OpenGL

    • Beta
    • Open Source

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von Andy.

      NetGL - .Net Wrapper für OpenGL



      NetGL ist ein benutzerfreundlicher Wrapper, der es ermöglicht, OpenGL-Funktionen in .NET-Anwendungen zu verwenden. Dieses Projekt begann vor rund 9 Jahren und hat sich über die Jahre entwickelt. Aufgrund von beruflichen Verpflichtungen und anderen Umständen konnte ich es nicht so regelmäßig aktualisieren, wie ich es gerne hätte.

      Nun, da ich wieder mehr Zeit zur Verfügung habe und durch meine beruflichen Erfahrungen besser mit der Thematik vertraut bin, möchte ich das Projekt endlich zu einem erfolgreichen Abschluss bringen.

      NetGL bietet eine einfache Schnittstelle für .NET-Entwickler, um die leistungsstarken Grafikfunktionen von OpenGL zu nutzen. Es ermöglicht die nahtlose Integration von 3D-Grafiken in .NET-Anwendungen, und ich hoffe, dass es für viele Entwickler eine wertvolle Ressource sein wird.

      Ich freue mich über jedes Feedback und stehe gerne für Fragen und Anregungen zur Verfügung.

      Beispiele:
      01 - ModernGL Dreieck

      C#-Quellcode

      1. using NetGL;
      2. using System;
      3. using System.Collections.Generic;
      4. using System.ComponentModel;
      5. using System.Data;
      6. using System.Drawing;
      7. using System.Linq;
      8. using System.Text;
      9. using System.Threading;
      10. using System.Threading.Tasks;
      11. using System.Windows.Forms;
      13. namespace WindowsFormsApp1
      14. {
      15. /// <summary>
      16. /// Simple modern opengl application made with NetGL
      17. /// </summary>
      18. public partial class Form1 : Form
      19. {
      20. private NetGL.OpenGL gl;
      21. private float rotate;
      22. public Form1()
      23. {
      24. InitializeComponent();
      25. CheckForIllegalCrossThreadCalls = false;
      26. DoubleBuffered = false;
      27. }
      29. private void loop()
      30. {
      31. //Creating the Vertex shader
      32. string vertexShaderCode = @"
      33. #version 330 core
      35. layout(location = 0) in vec3 inPosition;
      36. layout(location = 1) in vec3 inColor;
      38. out vec3 color;
      40. void main()
      41. {
      42. gl_Position = vec4(inPosition, 1.0);
      43. color = inColor;
      44. }
      45. ";
      47. //Creating the fragment shader
      48. string fragmentShaderCode = @"
      49. #version 330 core
      51. in vec3 color;
      52. out vec4 fragColor;
      54. void main()
      55. {
      56. fragColor = vec4(color, 1.0);
      57. }
      58. ";
      60. //Setup netgl
      61. gl = new NetGL.OpenGL();
      62. gl.modernGL = true;
      63. gl.Initial(this.panel1.Handle);
      64. gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      66. //Create the Vertex Shader
      67. int vertexShader = gl.CreateShader(OpenGL.VertexShader);
      68. gl.SetShaderSource(vertexShader, 1, vertexShaderCode);
      69. gl.CompileShader(vertexShader);
      71. //Creat the fragment Shader
      72. int fragmentShader = gl.CreateShader(OpenGL.FragmentShader);
      73. gl.SetShaderSource(fragmentShader, 1, fragmentShaderCode);
      74. gl.CompileShader(fragmentShader);
      76. //Create a programm out of the vertex and fragment shader
      77. int program = gl.CreateProgram();
      78. gl.AttachShader(program, vertexShader);
      79. gl.AttachShader(program, fragmentShader);
      80. gl.LinkProgram(program);
      81. gl.UseProgram(program);
      83. //Generte the vbo
      84. float[] verticies =
      85. {
      86. 0f, 1f, -1f,
      87. -1f, -1f, -1f,
      88. 1f, -1f, -1f
      89. };
      90. int vertexBuffer = gl.GenBuffer(1);
      91. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      92. gl.BufferData(OpenGL.ArrayBuffer, verticies.Length * sizeof(float), verticies, OpenGL.StaticDraw);
      94. //Generate the cbo
      95. float[] colors =
      96. {
      97. 1.0f, 0.0f, 0.0f,
      98. 0.0f, 1.0f, 0.0f,
      99. 0.0f, 0.0f, 1.0f
      100. };
      101. int colorBuffer = gl.GenBuffer(1);
      102. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      103. gl.BufferData(OpenGL.ArrayBuffer, colors.Length * sizeof(float), colors, OpenGL.StaticDraw);
      105. //Load the 2D ortho matrix
      106. gl.Ortho(-2f, 2f, -2f, 2f, -20f, 20f);
      108. while (true) {
      109. Thread.Sleep(60);
      110. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
      112. //Send the vbo to the shader
      113. gl.EnableVertexAttribArray(0);
      114. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      115. gl.VertexAttribPointer(0, 3, OpenGL.Float, false, 0, 0);
      117. //Send the cbo to the shader
      118. gl.EnableVertexAttribArray(1);
      119. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      120. gl.VertexAttribPointer(1, 3, OpenGL.Float, false, 0, 0);
      122. //Render the Triangle
      123. gl.DrawArrays(OpenGL.Triangles, 0, 3);
      125. gl.Flush();
      126. rotate += 1;
      127. gl.SwapLayerBuffers(NetGL.OpenGL.SwapMainPlane);
      129. }
      130. }
      132. private void Form1_Shown(object sender, EventArgs e)
      133. {
      134. Thread renderThread = new Thread(new ThreadStart(loop));
      135. renderThread.Start();
      136. }
      137. }
      138. }


      02 - ModernGL Dreieck mit Textur

      C#-Quellcode

      1. using NetGL;
      2. using System;
      3. using System.Collections.Generic;
      4. using System.ComponentModel;
      5. using System.Data;
      6. using System.Drawing;
      7. using System.Linq;
      8. using System.Text;
      9. using System.Threading;
      10. using System.Threading.Tasks;
      11. using System.Windows.Forms;
      13. namespace WindowsFormsApp1
      14. {
      15. /// <summary>
      16. /// Simple modern opengl application made with NetGL
      17. /// </summary>
      18. public partial class Form1 : Form
      19. {
      20. private NetGL.OpenGL gl;
      21. private float rotate;
      22. public Form1()
      23. {
      24. InitializeComponent();
      25. CheckForIllegalCrossThreadCalls = false;
      26. DoubleBuffered = false;
      27. }
      29. private void loop()
      30. {
      31. //Creating the Vertex shader
      32. string vertexShaderCode = @"
      33. #version 330 core
      35. layout(location = 0) in vec3 inPosition;
      36. layout(location = 1) in vec3 inColor;
      37. layout(location = 2) in vec2 inTexCoord;
      39. out vec3 color;
      40. out vec2 texCoord;
      42. void main()
      43. {
      44. gl_Position = vec4(inPosition, 1.0);
      45. color = inColor;
      46. texCoord = inTexCoord;
      47. }
      48. ";
      50. //Creating the fragment shader
      51. string fragmentShaderCode = @"
      52. #version 330 core
      54. in vec3 color;
      55. in vec2 texCoord;
      57. out vec4 fragColor;
      58. uniform sampler2D textureSampler;
      60. void main()
      61. {
      62. fragColor = texture(textureSampler, texCoord) * vec4(color, 1.0);
      63. }
      64. ";
      66. //Setup netgl
      67. gl = new NetGL.OpenGL();
      68. gl.modernGL = true;
      69. gl.Initial(this.panel1.Handle);
      70. gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      72. //Create the Vertex Shader
      73. int vertexShader = gl.CreateShader(OpenGL.VertexShader);
      74. gl.SetShaderSource(vertexShader, 1, vertexShaderCode);
      75. gl.CompileShader(vertexShader);
      77. //Creat the fragment Shader
      78. int fragmentShader = gl.CreateShader(OpenGL.FragmentShader);
      79. gl.SetShaderSource(fragmentShader, 1, fragmentShaderCode);
      80. gl.CompileShader(fragmentShader);
      82. //Create a programm out of the vertex and fragment shader
      83. int program = gl.CreateProgram();
      84. gl.AttachShader(program, vertexShader);
      85. gl.AttachShader(program, fragmentShader);
      86. gl.LinkProgram(program);
      87. gl.UseProgram(program);
      89. //Load the texture
      90. int texid = gl.GenTextures(1);
      91. Bitmap bitmap = Properties.Resources.Smiley;
      92. gl.BindTexture(NetGL.OpenGL.Texture2D, texid);
      93. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMinFilter, NetGL.OpenGL.Nearest);
      94. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMagFilter, NetGL.OpenGL.Linear);
      95. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapS, NetGL.OpenGL.Repeate);
      96. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapT, NetGL.OpenGL.Repeate);
      97. gl.TexImage2D(NetGL.OpenGL.Texture2D, 0, NetGL.OpenGL.RGBA, bitmap.Width, bitmap.Height, 0, NetGL.OpenGL.BGRAExt, NetGL.OpenGL.UnsignedByte, bitmap);
      98. gl.Uniform1I(gl.GetUniformLocation(program, "textureSampler"), 0);
      100. //Generte the vbo
      101. float[] verticies =
      102. {
      103. 0f, 1f, -1f,
      104. -1f, -1f, -1f,
      105. 1f, -1f, -1f
      106. };
      107. int vertexBuffer = gl.GenBuffer(1);
      108. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      109. gl.BufferData(OpenGL.ArrayBuffer, verticies.Length * sizeof(float), verticies, OpenGL.StaticDraw);
      111. //Generate the cbo
      112. float[] colors =
      113. {
      114. 1.0f, 1.0f, 1.0f,
      115. 1.0f, 1.0f, 1.0f,
      116. 1.0f, 1.0f, 1.0f
      117. };
      118. int colorBuffer = gl.GenBuffer(1);
      119. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      120. gl.BufferData(OpenGL.ArrayBuffer, colors.Length * sizeof(float), colors, OpenGL.StaticDraw);
      122. //Generate the tbo
      123. float[] texCoords =
      124. {
      125. 0.5f, 0.0f,
      126. 0.0f, 1.0f,
      127. 1.0f, 1.0f
      128. };
      129. int texCordBuffer = gl.GenBuffer(1);
      130. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      131. gl.BufferData(OpenGL.ArrayBuffer, texCoords.Length * sizeof(float), texCoords, OpenGL.StaticDraw);
      133. //Load the 2D ortho matrix
      134. gl.Ortho(-2f, 2f, -2f, 2f, -20f, 20f);
      136. while (true) {
      137. Thread.Sleep(60);
      138. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
      140. //Send the vbo to the shader
      141. gl.EnableVertexAttribArray(0);
      142. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      143. gl.VertexAttribPointer(0, 3, OpenGL.Float, false, 0, 0);
      145. //Send the cbo to the shader
      146. gl.EnableVertexAttribArray(1);
      147. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      148. gl.VertexAttribPointer(1, 3, OpenGL.Float, false, 0, 0);
      150. //Send the tex cords to the shader
      151. gl.EnableVertexAttribArray(2);
      152. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      153. gl.VertexAttribPointer(2, 2, OpenGL.Float, false, 0, 0);
      155. //Render the Triangle
      156. gl.DrawArrays(OpenGL.Triangles, 0, 3);
      158. gl.Flush();
      159. gl.SwapLayerBuffers(NetGL.OpenGL.SwapMainPlane);
      160. Console.WriteLine(gl.GetError());
      161. }
      162. }
      164. private void Form1_Shown(object sender, EventArgs e)
      165. {
      166. Thread renderThread = new Thread(new ThreadStart(loop));
      167. renderThread.Start();
      168. }
      169. }
      170. }


      03 - Nutzung mehrere Texturen

      C#-Quellcode

      1. using NetGL;
      2. using System;
      3. using System.Collections.Generic;
      4. using System.ComponentModel;
      5. using System.Data;
      6. using System.Drawing;
      7. using System.Linq;
      8. using System.Text;
      9. using System.Threading;
      10. using System.Threading.Tasks;
      11. using System.Windows.Forms;
      13. namespace WindowsFormsApp1
      14. {
      15. /// <summary>
      16. /// Simple modern opengl application made with NetGL
      17. /// In this example we create an shader with multiple textures and use them
      18. /// It might be look a bit wired.
      19. /// </summary>
      20. public partial class Form1 : Form
      21. {
      22. private NetGL.OpenGL gl;
      23. private float rotate;
      24. public Form1()
      25. {
      26. InitializeComponent();
      27. CheckForIllegalCrossThreadCalls = false;
      28. DoubleBuffered = false;
      29. }
      31. private void loop()
      32. {
      33. //Creating the Vertex shader
      34. string vertexShaderCode = @"
      35. #version 330 core
      37. layout(location = 0) in vec3 inPosition;
      38. layout(location = 1) in vec3 inColor;
      39. layout(location = 2) in vec2 inTexCoord;
      41. out vec3 color;
      42. out vec2 texCoord;
      44. void main()
      45. {
      46. gl_Position = vec4(inPosition, 1.0);
      47. color = inColor;
      48. texCoord = inTexCoord;
      49. }
      50. ";
      52. //Creating the fragment shader
      53. string fragmentShaderCode = @"
      54. #version 330 core
      56. in vec3 color;
      57. in vec2 texCoord;
      59. out vec4 fragColor;
      60. uniform sampler2D textureSampler;
      61. uniform sampler2D textureSampler2;
      63. void main()
      64. {
      65. fragColor = mix(texture(textureSampler, texCoord), texture(textureSampler2, texCoord), 0.2) * vec4(color, 1.0);
      66. }
      67. ";
      69. //Setup netgl
      70. gl = new NetGL.OpenGL();
      71. gl.modernGL = true;
      72. gl.Initial(this.panel1.Handle);
      73. gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      75. //Create the Vertex Shader
      76. int vertexShader = gl.CreateShader(OpenGL.VertexShader);
      77. gl.SetShaderSource(vertexShader, 1, vertexShaderCode);
      78. gl.CompileShader(vertexShader);
      80. //Creat the fragment Shader
      81. int fragmentShader = gl.CreateShader(OpenGL.FragmentShader);
      82. gl.SetShaderSource(fragmentShader, 1, fragmentShaderCode);
      83. gl.CompileShader(fragmentShader);
      85. //Create a programm out of the vertex and fragment shader
      86. int program = gl.CreateProgram();
      87. gl.AttachShader(program, vertexShader);
      88. gl.AttachShader(program, fragmentShader);
      89. gl.LinkProgram(program);
      90. gl.UseProgram(program);
      92. //Load the textures. Here we select first the texture slot
      93. //and load the texture within this slot.
      94. gl.ActiveTexture(OpenGL.Texture0);
      95. int texture1 = LoadTexture(gl, Properties.Resources.Smiley);
      96. gl.ActiveTexture(OpenGL.Texture1);
      97. int texture2 = LoadTexture(gl, Properties.Resources.Affe);
      98. //Passing the texture to the shader.
      99. gl.Uniform1I(gl.GetUniformLocation(program, "textureSampler"), 0);
      100. gl.Uniform1I(gl.GetUniformLocation(program, "textureSampler2"), 1);
      102. //Reset the active texture to 0
      103. gl.ActiveTexture(OpenGL.Texture0);
      105. //Generte the vbo
      106. float[] verticies =
      107. {
      108. 0f, 1f, -1f,
      109. -1f, -1f, -1f,
      110. 1f, -1f, -1f
      111. };
      112. int vertexBuffer = gl.GenBuffer(1);
      113. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      114. gl.BufferData(OpenGL.ArrayBuffer, verticies.Length * sizeof(float), verticies, OpenGL.StaticDraw);
      116. //Generate the cbo
      117. float[] colors =
      118. {
      119. 1.0f, 1.0f, 1.0f,
      120. 1.0f, 1.0f, 1.0f,
      121. 1.0f, 1.0f, 1.0f
      122. };
      123. int colorBuffer = gl.GenBuffer(1);
      124. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      125. gl.BufferData(OpenGL.ArrayBuffer, colors.Length * sizeof(float), colors, OpenGL.StaticDraw);
      127. //Generate the tbo
      128. float[] texCoords =
      129. {
      130. 0.5f, 0.0f,
      131. 0.0f, 1.0f,
      132. 1.0f, 1.0f
      133. };
      134. int texCordBuffer = gl.GenBuffer(1);
      135. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      136. gl.BufferData(OpenGL.ArrayBuffer, texCoords.Length * sizeof(float), texCoords, OpenGL.StaticDraw);
      138. //Load the 2D ortho matrix
      139. gl.Ortho(-2f, 2f, -2f, 2f, -20f, 20f);
      141. while (true) {
      142. Thread.Sleep(60);
      143. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
      145. //Bind the textures
      146. gl.ActiveTexture(OpenGL.Texture0);
      147. gl.BindTexture(OpenGL.Texture2D, texture1);
      148. gl.ActiveTexture(OpenGL.Texture1);
      149. gl.BindTexture(OpenGL.Texture2D, texture2);
      151. //Send the vbo to the shader
      152. gl.EnableVertexAttribArray(0);
      153. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      154. gl.VertexAttribPointer(0, 3, OpenGL.Float, false, 0, 0);
      156. //Send the cbo to the shader
      157. gl.EnableVertexAttribArray(1);
      158. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      159. gl.VertexAttribPointer(1, 3, OpenGL.Float, false, 0, 0);
      161. //Send the tex cords to the shader
      162. gl.EnableVertexAttribArray(2);
      163. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      164. gl.VertexAttribPointer(2, 2, OpenGL.Float, false, 0, 0);
      166. //Render the Triangle
      167. gl.DrawArrays(OpenGL.Triangles, 0, 3);
      169. gl.Flush();
      170. gl.SwapLayerBuffers(NetGL.OpenGL.SwapMainPlane);
      171. Console.WriteLine(gl.GetError());
      172. }
      173. }
      175. /// <summary>
      176. /// We use this function to load our textures
      177. /// this will help to have a clean code
      178. /// </summary>
      179. /// <param name="gl"></param>
      180. /// <param name="bitmap"></param>
      181. /// <returns></returns>
      182. private int LoadTexture(OpenGL gl, Bitmap bitmap)
      183. {
      184. int textureID = gl.GenTextures(1);
      185. gl.BindTexture(NetGL.OpenGL.Texture2D, textureID);
      186. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMinFilter, NetGL.OpenGL.Nearest);
      187. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMagFilter, NetGL.OpenGL.Linear);
      188. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapS, NetGL.OpenGL.Repeate);
      189. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapT, NetGL.OpenGL.Repeate);
      190. gl.TexImage2D(NetGL.OpenGL.Texture2D, 0, NetGL.OpenGL.RGBA, bitmap.Width, bitmap.Height, 0, NetGL.OpenGL.BGRAExt, NetGL.OpenGL.UnsignedByte, bitmap);
      191. return textureID;
      192. }
      194. private void Form1_Shown(object sender, EventArgs e)
      195. {
      196. Thread renderThread = new Thread(new ThreadStart(loop));
      197. renderThread.Start();
      198. }
      199. }
      200. }


      04 ModernGL - Tranformation mit den OpenGL Matrixen

      Hier werden die eigenen Matrixen von OpenGL genutzt um ein Objekt zu Transformieren. Im nächsten Example werden externe Matrixen und eine MVP genutzt.

      C#-Quellcode

      1. using NetGL;
      2. using System;
      3. using System.Collections.Generic;
      4. using System.ComponentModel;
      5. using System.Data;
      6. using System.Drawing;
      7. using System.Linq;
      8. using System.Text;
      9. using System.Threading;
      10. using System.Threading.Tasks;
      11. using System.Windows.Forms;
      13. namespace WindowsFormsApp1
      14. {
      15. /// <summary>
      16. /// Simple modern opengl application made with NetGL
      17. /// </summary>
      18. public partial class Form1 : Form
      19. {
      20. private NetGL.OpenGL gl;
      21. private float rotate;
      22. public Form1()
      23. {
      24. InitializeComponent();
      25. CheckForIllegalCrossThreadCalls = false;
      26. DoubleBuffered = false;
      27. }
      29. private void loop()
      30. {
      31. //Creating the Vertex shader
      32. string vertexShaderCode = @"
      33. #version 330 core
      35. layout(location = 0) in vec3 inPosition;
      36. layout(location = 1) in vec3 inColor;
      37. layout(location = 2) in vec2 inTexCoord;
      39. out vec3 color;
      40. out vec2 texCoord;
      42. uniform mat4 modelMatrix; // Modellmatrix
      43. uniform mat4 projMatrix; // Projektionsmatrix
      45. void main()
      46. {
      47. gl_Position = projMatrix * modelMatrix * vec4(inPosition, 1.0);
      48. color = inColor;
      49. texCoord = inTexCoord;
      50. }
      51. ";
      53. //Creating the fragment shader
      54. string fragmentShaderCode = @"
      55. #version 330 core
      57. in vec3 color;
      58. in vec2 texCoord;
      60. out vec4 fragColor;
      61. uniform sampler2D textureSampler;
      63. void main()
      64. {
      65. fragColor = texture(textureSampler, texCoord) * vec4(color, 1.0);
      66. }
      67. ";
      69. //Setup netgl
      70. gl = new NetGL.OpenGL();
      71. gl.modernGL = true;
      72. gl.Initial(this.panel1.Handle);
      73. gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      75. //Create the Vertex Shader
      76. int vertexShader = gl.CreateShader(OpenGL.VertexShader);
      77. gl.SetShaderSource(vertexShader, 1, vertexShaderCode);
      78. gl.CompileShader(vertexShader);
      80. //Creat the fragment Shader
      81. int fragmentShader = gl.CreateShader(OpenGL.FragmentShader);
      82. gl.SetShaderSource(fragmentShader, 1, fragmentShaderCode);
      83. gl.CompileShader(fragmentShader);
      85. //Create a programm out of the vertex and fragment shader
      86. int program = gl.CreateProgram();
      87. gl.AttachShader(program, vertexShader);
      88. gl.AttachShader(program, fragmentShader);
      89. gl.LinkProgram(program);
      90. gl.UseProgram(program);
      92. //Load the texture
      93. int texid = gl.GenTextures(1);
      94. Bitmap bitmap = Properties.Resources.Smiley;
      95. gl.BindTexture(NetGL.OpenGL.Texture2D, texid);
      96. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMinFilter, NetGL.OpenGL.Nearest);
      97. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMagFilter, NetGL.OpenGL.Linear);
      98. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapS, NetGL.OpenGL.Repeate);
      99. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapT, NetGL.OpenGL.Repeate);
      100. gl.TexImage2D(NetGL.OpenGL.Texture2D, 0, NetGL.OpenGL.RGBA, bitmap.Width, bitmap.Height, 0, NetGL.OpenGL.BGRAExt, NetGL.OpenGL.UnsignedByte, bitmap);
      101. gl.Uniform1I(gl.GetUniformLocation(program, "textureSampler"), 0);
      103. //Generte the vbo
      104. float[] verticies =
      105. {
      106. 0f, 1f, -1f,
      107. -1f, -1f, -1f,
      108. 1f, -1f, -1f
      109. };
      110. int vertexBuffer = gl.GenBuffer(1);
      111. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      112. gl.BufferData(OpenGL.ArrayBuffer, verticies.Length * sizeof(float), verticies, OpenGL.StaticDraw);
      114. //Generate the cbo
      115. float[] colors =
      116. {
      117. 1.0f, 1.0f, 1.0f,
      118. 1.0f, 1.0f, 1.0f,
      119. 1.0f, 1.0f, 1.0f
      120. };
      121. int colorBuffer = gl.GenBuffer(1);
      122. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      123. gl.BufferData(OpenGL.ArrayBuffer, colors.Length * sizeof(float), colors, OpenGL.StaticDraw);
      125. //Generate the tbo
      126. float[] texCoords =
      127. {
      128. 0.5f, 0.0f,
      129. 0.0f, 1.0f,
      130. 1.0f, 1.0f
      131. };
      132. int texCordBuffer = gl.GenBuffer(1);
      133. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      134. gl.BufferData(OpenGL.ArrayBuffer, texCoords.Length * sizeof(float), texCoords, OpenGL.StaticDraw);
      136. while (true) {
      137. Thread.Sleep(60);
      139. //Transform the Projection and Modelview Matrix
      140. gl.MatrixMode(OpenGL.Projection);
      141. gl.LoadIdentity();
      142. gl.Ortho(-2f, 2f, -2f, 2f, -20f, 20f);
      143. gl.MatrixMode(OpenGL.ModelView);
      144. gl.LoadIdentity();
      145. gl.Translate(-1f, 0f, 0f);
      147. //Send the matrix data to the shader. This are custom functions within NetGL
      148. //to increase the performance.
      149. gl.SetProjectionMatrix(gl.GetUniformLocation(program, "projMatrix"), 1, false);
      150. gl.SetModelviewMatrix(gl.GetUniformLocation(program, "modelMatrix"), 1, false);
      152. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
      154. //Send the vbo to the shader
      155. gl.EnableVertexAttribArray(0);
      156. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      157. gl.VertexAttribPointer(0, 3, OpenGL.Float, false, 0, 0);
      159. //Send the cbo to the shader
      160. gl.EnableVertexAttribArray(1);
      161. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      162. gl.VertexAttribPointer(1, 3, OpenGL.Float, false, 0, 0);
      164. //Send the tex cords to the shader
      165. gl.EnableVertexAttribArray(2);
      166. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      167. gl.VertexAttribPointer(2, 2, OpenGL.Float, false, 0, 0);
      169. //Render the Triangle
      170. gl.DrawArrays(OpenGL.Triangles, 0, 3);
      172. gl.Flush();
      173. gl.SwapLayerBuffers(NetGL.OpenGL.SwapMainPlane);
      174. Console.WriteLine(gl.GetError());
      175. }
      176. }
      178. private void Form1_Shown(object sender, EventArgs e)
      179. {
      180. Thread renderThread = new Thread(new ThreadStart(loop));
      181. renderThread.Start();
      182. }
      183. }
      184. }


      05 ModernGL - Transformation mit einer MVP

      C#-Quellcode

      1. using NetGL;
      2. using System;
      3. using System.Collections.Generic;
      4. using System.ComponentModel;
      5. using System.Data;
      6. using System.Drawing;
      7. using System.Linq;
      8. using System.Net.Security;
      9. using System.Text;
      10. using System.Threading;
      11. using System.Threading.Tasks;
      12. using System.Windows.Forms;
      13. using GenesisMath.Math;
      15. namespace WindowsFormsApp1
      16. {
      17. /// <summary>
      18. /// This example renders an triangle with modern OpenGL and an MVP Matrix
      19. /// (Modelview, View (Camera Matrix) and Projection Matrix. If you want dive
      20. /// deeper into matrices you can have a look here on this website.
      21. ///
      22. /// http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices/
      23. ///
      24. /// You will need some math libary for this example. I exported the imported math
      25. /// files out of my game engine and created an libary out of it. You can find it here
      26. ///
      27. /// https://github.com/Andy16823/GenesisMath
      28. ///
      29. /// or you use some more complex math libary like glmsharp which have more features but
      30. /// we wont need them realy for this example.
      31. ///
      32. /// https://github.com/Philip-Trettner/GlmSharp
      33. /// </summary>
      34. public partial class Form1 : Form
      35. {
      36. private NetGL.OpenGL gl;
      37. private float rotate;
      39. /// <summary>
      40. /// Initial the Windows Form
      41. /// </summary>
      42. public Form1()
      43. {
      44. InitializeComponent();
      45. CheckForIllegalCrossThreadCalls = false;
      46. DoubleBuffered = false;
      47. }
      49. /// <summary>
      50. /// Our rendering thread
      51. /// </summary>
      52. private void loop()
      53. {
      54. //Creating the Vertex shader
      55. string vertexShaderCode = @"
      56. #version 330 core
      58. layout(location = 0) in vec3 inPosition;
      59. layout(location = 1) in vec3 inColor;
      60. layout(location = 2) in vec2 inTexCoord;
      62. out vec3 color;
      63. out vec2 texCoord;
      65. uniform mat4 mvp;
      66. uniform mat4 modelMatrix; // Modellmatrix
      67. uniform mat4 projMatrix; // Projektionsmatrix
      69. void main()
      70. {
      71. gl_Position = mvp * vec4(inPosition, 1.0);
      72. color = inColor;
      73. texCoord = inTexCoord;
      74. }
      75. ";
      77. //Creating the fragment shader
      78. string fragmentShaderCode = @"
      79. #version 330 core
      81. in vec3 color;
      82. in vec2 texCoord;
      84. out vec4 fragColor;
      85. uniform sampler2D textureSampler;
      87. void main()
      88. {
      89. fragColor = texture(textureSampler, texCoord) * vec4(color, 1.0);
      90. }
      91. ";
      93. //Setup netgl
      94. gl = new NetGL.OpenGL();
      95. gl.modernGL = true;
      96. gl.Initial(this.panel1.Handle);
      97. gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
      99. //Create the Vertex Shader
      100. int vertexShader = gl.CreateShader(OpenGL.VertexShader);
      101. gl.SetShaderSource(vertexShader, 1, vertexShaderCode);
      102. gl.CompileShader(vertexShader);
      104. //Creat the fragment Shader
      105. int fragmentShader = gl.CreateShader(OpenGL.FragmentShader);
      106. gl.SetShaderSource(fragmentShader, 1, fragmentShaderCode);
      107. gl.CompileShader(fragmentShader);
      109. //Create a programm out of the vertex and fragment shader
      110. int program = gl.CreateProgram();
      111. gl.AttachShader(program, vertexShader);
      112. gl.AttachShader(program, fragmentShader);
      113. gl.LinkProgram(program);
      114. gl.UseProgram(program);
      116. //Load the texture
      117. int texid = gl.GenTextures(1);
      118. Bitmap bitmap = Properties.Resources.Smiley;
      119. gl.BindTexture(NetGL.OpenGL.Texture2D, texid);
      120. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMinFilter, NetGL.OpenGL.Nearest);
      121. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureMagFilter, NetGL.OpenGL.Linear);
      122. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapS, NetGL.OpenGL.Repeate);
      123. gl.TexParameteri(NetGL.OpenGL.Texture2D, NetGL.OpenGL.TextureWrapT, NetGL.OpenGL.Repeate);
      124. gl.TexImage2D(NetGL.OpenGL.Texture2D, 0, NetGL.OpenGL.RGBA, bitmap.Width, bitmap.Height, 0, NetGL.OpenGL.BGRAExt, NetGL.OpenGL.UnsignedByte, bitmap);
      125. gl.Uniform1I(gl.GetUniformLocation(program, "textureSampler"), 0);
      127. //Generte the vbo
      128. float[] verticies =
      129. {
      130. 0f, 1f, -1f,
      131. -1f, -1f, -1f,
      132. 1f, -1f, -1f
      133. };
      134. int vertexBuffer = gl.GenBuffer(1);
      135. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      136. gl.BufferData(OpenGL.ArrayBuffer, verticies.Length * sizeof(float), verticies, OpenGL.StaticDraw);
      138. //Generate the cbo
      139. float[] colors =
      140. {
      141. 1.0f, 1.0f, 1.0f,
      142. 1.0f, 1.0f, 1.0f,
      143. 1.0f, 1.0f, 1.0f
      144. };
      145. int colorBuffer = gl.GenBuffer(1);
      146. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      147. gl.BufferData(OpenGL.ArrayBuffer, colors.Length * sizeof(float), colors, OpenGL.StaticDraw);
      149. //Generate the tbo
      150. float[] texCoords =
      151. {
      152. 0.5f, 0.0f,
      153. 0.0f, 1.0f,
      154. 1.0f, 1.0f
      155. };
      156. int texCordBuffer = gl.GenBuffer(1);
      157. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      158. gl.BufferData(OpenGL.ArrayBuffer, texCoords.Length * sizeof(float), texCoords, OpenGL.StaticDraw);
      160. while (true) {
      161. Thread.Sleep(60);
      163. //Within the first stepp we create the projection matrix and then the view matrix
      164. Matrix4x4 p_mat = Matrix4x4.Ortho(-10.0f, 10.0f, -10.0f, 10.0f, -1.0f, 100.0f);
      165. Matrix4x4 v_mat = Matrix4x4.LookAt(new Vec3(0f, 0f, 1f), new Vec3(0f, 0f, 0f), new Vec3(0f, 1f, 0f));
      167. //Now we create the modelview matrix. Its a product from the Translate, Rotate and Scale matrix
      168. Matrix4x4 mt_mat = Matrix4x4.Translate(new Vec3(0f, 0f, 0f));
      169. Matrix4x4 mr_mat = Matrix4x4.RotateZ(rotate);
      170. Matrix4x4 ms_mat = Matrix4x4.Scale(new Vec3(5f, 5f, 0f));
      171. Matrix4x4 m_mat = mt_mat * mr_mat * ms_mat;
      173. //Now we have all matrices we need to create the "MVP" matrix
      174. Matrix4x4 mvp = p_mat * v_mat * m_mat;
      176. //Send the matrix data to the shader.
      177. gl.UniformMatrix4fv(gl.GetUniformLocation(program, "mvp"), 1, false, mvp.ToArray());
      179. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
      181. //Send the vbo to the shader
      182. gl.EnableVertexAttribArray(0);
      183. gl.BindBuffer(OpenGL.ArrayBuffer, vertexBuffer);
      184. gl.VertexAttribPointer(0, 3, OpenGL.Float, false, 0, 0);
      186. //Send the cbo to the shader
      187. gl.EnableVertexAttribArray(1);
      188. gl.BindBuffer(OpenGL.ArrayBuffer, colorBuffer);
      189. gl.VertexAttribPointer(1, 3, OpenGL.Float, false, 0, 0);
      191. //Send the tex cords to the shader
      192. gl.EnableVertexAttribArray(2);
      193. gl.BindBuffer(OpenGL.ArrayBuffer, texCordBuffer);
      194. gl.VertexAttribPointer(2, 2, OpenGL.Float, false, 0, 0);
      196. //Render the Triangle
      197. gl.DrawArrays(OpenGL.Triangles, 0, 3);
      199. gl.Flush();
      200. gl.SwapLayerBuffers(NetGL.OpenGL.SwapMainPlane);
      201. Console.WriteLine(gl.GetError());
      202. rotate += 0.5f;
      203. }
      204. }
      206. private void Form1_Shown(object sender, EventArgs e)
      207. {
      208. Thread renderThread = new Thread(new ThreadStart(loop));
      209. renderThread.Start();
      210. }
      212. private void Form1_Load(object sender, EventArgs e)
      213. {
      215. }
      216. }
      217. }




      Screenshot(s):


      Verwendete Programmiersprache(n) und IDE(s):
      C++/CLI - Visual Studio 2022 Enterprise

      Systemanforderungen:
      .Net4.5
      OpenGL fähige Grafikkarte

      Systemveränderungen:
      Keine Systemveränderungen

      Download(s):
      GitHub

      Lizenz/Weitergabe:
      OpenSource mit der MIT Lizenz

      Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von „Andy“ ()

      Ich habe eben das letzte Beispiel hinzugefügt. Außerdem ein paar Änderungen etc.
      • Die Meisten OpenGL 4 Funktionen sollten jetzt verfügbar sein
      • Das erstellen von Shadern ist nun möglich
      • Das Laden von externen Matrizen ist nun möglich
      • Das Verwenden von mehreren Texturen ist nun möglich
      • Optimierung alter Funktionen, die die Performance beeinträchtigt haben.
        Wie z.b. das Kopieren von Managed Array Daten zu Unmanged Arrays entfällt.
        Stattdessen werden pin_ptr genutzt.
      • Außerdem habe ich eine kleine Bibliothek für Matrizen aus meiner GameEngine
        geladen. Das interessante hierbei ist, dass ich ChatGPT da mit eingebunden habe :)
        github.com/Andy16823/GenesisMath

    Facebook
    Telefonspende