youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

daily update on 20231016 by nitload youmu, vao,vbo,ebo struct added

Browse Source
This commit is contained in:
Nitload
2023-10-17 01:22:30 +08:00
parent 6c3349f5a2
commit 614fabe26c
135 changed files with 28619 additions and 5432 deletions
Download Patch File Download Diff File Expand all files Collapse all files
源代码/StgSharp/Graphics/GLFunc.cs
+134 -62
View File
@@ -1,16 +1,95 @@
using StgSharp.Controlling;
using StgSharp.Graphics;
using StgSharp.Math;
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Text;
namespace StgSharp
namespace StgSharp.Graphics
{
public static unsafe partial class Graphic
{
/// <summary>
/// sets the framebuffer resize callback of the specified <see cref="Form"/>,
///which is called when the framebuffer of the specified <see cref="Form"/> is resized.
/// </summary>
/// <param name="form">The Form instance to be controlled</param>
/// <param name="handler">Method hadler </param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void SetFrameBufferSizeCallback(Form form, FrameBufferSizeHadler handler)
{
internalIO.glfwSetFramebufferSizeCallback(form.windowID, handler);
}
/// <summary>
/// Call glClearColor in OpenGL
/// specifies the red, green, blue, and alpha values used by glClear to clear the color buffers.
/// Values specified by glClearColor are clamped to the range [0,1]
/// </summary>
/// <param name="R">Specify the red values used when the color buffers are cleared.</param>
/// <param name="G">Specify the red values used when the color buffers are cleared.</param>
/// <param name="B">Specify the red values used when the color buffers are cleared.</param>
/// <param name="A">Specify the red values used when the color buffers are cleared.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ClearColor(float R, float G, float B, float A)
{
glClearColor(R, G, B, A);
}
/// <summary>
/// Conpile the provided shader code in string form.
/// </summary>
/// <param name="shaderCode">A string represent the shader's code</param>
/// <param name="shaderType">An <see cref="ShaderType"/> enum represent the type of the shader to
/// conpile, including vertex shader and fragment shader.</param>
/// <returns>An uint value as the only mark of conpiled shader</returns>
public static unsafe uint CompileShader(string shaderCode, ShaderType shaderType)
{
uint shaderID;
shaderCode += '\0';
byte[] buffer = Encoding.ASCII.GetBytes(shaderCode);
fixed (byte* data = &buffer[0])
{
shaderID = internalIO.InternalLoadShaderCode(data, (int)shaderType);
}
if (shaderID == 0)
{
IntPtr logPtr = internalIO.InternalReadLog();
string log;
try
{
byte[] logByte = new byte[512];
Marshal.Copy(logPtr, logByte, 0, 512);
log = Encoding.UTF8.GetString(logByte);
log = log.Replace("\0", "");
bool isUseful = false;
foreach (char item in log)
{
if (!char.IsControl(item))
{
isUseful = true; break;
}
}
if (!isUseful)
{
throw new Exception();
}
}
catch (Exception)
{
log = "Failed to compile shader.\nFailed to get GLSL compiler log";
}
internalIO.InternalWriteLog(log, LogType.Error);
}
return shaderID;
}
/// <summary>
/// Creates a form and its associated context.
@@ -22,7 +101,7 @@ namespace StgSharp
/// <param name="share"></param>
/// <returns>The instance of created form</returns>
/// <exception cref="Exception"></exception>
public static unsafe Form GLcreateWindow(
public static unsafe Form CreateWindow(
int width, int height, string tittle, IntPtr monitor, Form share)
{
byte[] tittleBytes = Encoding.UTF8.GetBytes(tittle);
@@ -30,7 +109,7 @@ namespace StgSharp
if (share == null)
{
windowPtr = internalIO.glfwCreateWindow(
800, 600, tittleBytes, monitor, IntPtr.Zero);
width, height, tittleBytes, monitor, IntPtr.Zero);
}
else
{
@@ -52,71 +131,64 @@ namespace StgSharp
}
}
/// <summary>
/// Creates a window and its associated context.
/// </summary>
/// <param name="width">Required width</param>
/// <param name="height">Required width</param>
/// <param name="tittle">Tittle of the window </param>
/// <param name="monitor"></param>
/// <param name="share"></param>
/// <returns>The handle of created window</returns>
/// <exception cref="Exception"></exception>
public static unsafe Form GLcreateWindow(int width, int height, string tittle, IntPtr monitor, IntPtr share)
public static unsafe uint CreatGraphicProgram()
{
byte[] tittleCharArray = System.Text.Encoding.UTF8.GetBytes(tittle);
IntPtr windowPtr = internalIO.glfwCreateWindow
(width, height, tittleCharArray, monitor, share);
if ((int)windowPtr == -1 || (int)windowPtr == -2)
{
throw new Exception("Cannot create the form!");
}
else
{
Form form = new Form();
form.Size = new Vec2d(width, height);
form.windowID = windowPtr;
return form;
}
return glCreateProgram();
}
public static unsafe void GLmakeContexCurrent(Form form)
{
internalIO.glfwMakeContextCurrent(form.windowID);
}
public static unsafe bool GLwindowShouldClose(Form form)
{
int a = internalIO.glfwWindowShouldClose(form.windowID);
return a != 0;
}
public static unsafe void GLswapBuffers(Form form)
{
internalIO.glfwSwapBuffers(form.windowID);
}
public static IntPtr GetProcAddress(string name)
{
IntPtr ret = internalIO.glfwGetProcAddress(name);
if (ret == IntPtr.Zero)
{
#if DEBUG
Console.WriteLine(name);
#endif
return internalIO.glfwGetProcAddress(name);
}
else
{
return ret;
}
return ret;
}
public static unsafe bool GetWindowShouldClose(Form form)
{
return internalIO.glfwWindowShouldClose(form.windowID) != 0;
}
public static unsafe void GLswapBuffers(Form form)
{
if (form.windowID == IntPtr.Zero)
{
return;
}
internalIO.glfwSwapBuffers(form.windowID);
}
public static unsafe void MakeContexCurrent(Form form)
{
if (form.windowID == IntPtr.Zero)
{
return;
}
internalIO.glfwMakeContextCurrent(form.windowID);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe void SetBufferData<T>(BufferType bufferType, T bufferData, BufferReadType readType) where T : IMat
{
int size = Marshal.SizeOf(bufferData);
glBufferData(
(int)bufferType,
size,
&bufferData,
(int)readType);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static unsafe void SetBufferData<T>(BufferType bufferType, T[] bufferArray, BufferReadType readType) where T : struct, IConvertible
{
int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
fixed (void* bufferPtr = &bufferArray[0])
glBufferData(
(int)bufferType,
size,
bufferPtr,
(int)readType);
}
}
}