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

daily uodate on 20231208 by nitload youmu, preparation for multi thread rendering

Browse Source
This commit is contained in:
Nitload
2023-12-08 05:36:04 +08:00
parent ae804553ce
commit ab85c1a9fe
297 changed files with 157896 additions and 5170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
源代码/StgSharp/Graphics/GL/Buffer/EBO.cs
+41 -33
View File
@@ -6,46 +6,54 @@ using System.Text;
namespace StgSharp.Graphics
{
internal unsafe class ElementBuffer : IDisposable
public partial class Form
{
uint[] _bufferID;
public ElementBuffer(int n)
protected ElementBuffer CreateElementBuffer(int n)
{
_bufferID = new uint[n];
fixed (uint* id = _bufferID)
return new ElementBuffer(n, GL);
}
protected unsafe class ElementBuffer : IDisposable
{
uint[] _bufferID;
private IglFunc GL;
internal ElementBuffer(int n, IglFunc glFunc)
{
GL.gl.GenBuffers(n, id);
_bufferID = new uint[n];
GL = glFunc;
fixed (uint* id = _bufferID)
{
GL.GenBuffers(n, id);
}
}
}
public uint this[int n]
{
get { return _bufferID[n]; }
}
public void Bind(int index)
{
GL.gl.BindBuffer(GLconst.ELEMENT_ARRAY_BUFFER, _bufferID[index]);
}
public void SetData<T>(int index, T[] bufferArray, BufferUsage usage)
where T : struct, IConvertible
{
GL.gl.BindBuffer(GLconst.ELEMENT_ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ELEMENT_ARRAY_BUFFER, bufferArray, usage);
}
public void Dispose()
{
fixed (uint* id = _bufferID)
public uint this[int n]
{
GL.gl.DeleteBuffers(1, id);
get { return _bufferID[n]; }
}
public void Bind(int index)
{
GL.BindBuffer(BufferType.ELEMENT_ARRAY_BUFFER, _bufferID[index]);
}
public void SetValue<T>(int index, T[] bufferArray, BufferUsage usage)
where T : struct, IConvertible
{
GL.BindBuffer(BufferType.ELEMENT_ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ELEMENT_ARRAY_BUFFER, bufferArray, usage);
}
public void Dispose()
{
fixed (uint* id = _bufferID)
{
GL.DeleteBuffers(_bufferID.Length, id);
}
}
}
}
}
源代码/StgSharp/Graphics/GL/Buffer/Shader.cs
-57
View File
@@ -1,57 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Graphics
{
internal class Shader
{
public readonly uint programID;
internal uint vertexShaderID;
internal uint fragmentShaderID;
public unsafe Shader()
{
programID = GL.gl.CreateProgram();
}
public unsafe void CompileVertexShader(string shaderCode)
{
vertexShaderID = GL.CompileShader(shaderCode, ShaderType.VERTEX);
GL.gl.AttachShader(programID, vertexShaderID);
}
public unsafe void CompileFragmentShader(string shaderCode)
{
fragmentShaderID = GL.CompileShader(shaderCode, ShaderType.FRAGMENT);
GL.gl.AttachShader(programID, fragmentShaderID);
}
public void Link()
{
if (InternalIO.InternalLinkShaderProgram(programID) == 0)
{
IntPtr logPtr = InternalIO.InternalReadLog();
try
{
byte[] logByte = new byte[512];
Marshal.Copy(logPtr, logByte, 0, 512);
string log = Encoding.UTF8.GetString(logByte);
log = log.Replace("\0", "");
InternalIO.InternalWriteLog(log, LogType.Error);
}
catch (Exception ex)
{
InternalIO.InternalWriteLog(ex.Message, LogType.Error);
}
}
}
public unsafe void Use()
{
GL.gl.UseProgram(programID);
}
}
}
源代码/StgSharp/Graphics/GL/Buffer/ShaderParameter.cs
-33
View File
@@ -1,33 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace StgSharp.Graphics.Buffer
{
public struct ShaderParameter<T>
{
private static readonly string[] supportedType = new string[] {
"Single",
"Int32",
"Uint32",
"Single*"
};
internal int signiture;
public readonly string name;
internal ShaderParameter(string name, int sign)
{
if (ShaderParameter<T>.supportedType.Contains(typeof(T).Name))
{
InternalIO.InternalWriteLog($"Invalid type of ShaderProgram named {name}.", LogType.Error);
return;
}
signiture = sign;
this.name = name;
}
}
}
源代码/StgSharp/Graphics/GL/Buffer/VAO.cs
+45 -29
View File
@@ -1,50 +1,66 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
namespace StgSharp.Graphics
{
internal unsafe struct VertexArray : IDisposable
public partial class Form
{
internal uint[] _bufferID;
public VertexArray(int n)
protected VertexArray CreateVertexArray(int n)
{
_bufferID = new uint[n];
fixed (uint* id = _bufferID)
return new VertexArray(n, GL);
}
protected unsafe struct VertexArray : IDisposable
{
internal uint[] _bufferID;
private IglFunc GL;
internal VertexArray(int n, IglFunc glFunc)
{
GL.gl.GenVertexArrays(n, id);
_bufferID = new uint[n];
GL = glFunc;
fixed (uint* id = _bufferID)
{
GL.GenVertexArrays(n, id);
}
}
}
public uint this[int n]
{
get
public uint this[int n]
{
return _bufferID[n];
get
{
return _bufferID[n];
}
}
}
public void Bind(int index)
{
GL.gl.BindVertexArray(_bufferID[index]);
}
public void Dispose()
{
fixed (uint* id = _bufferID)
public void Bind(int index)
{
GL.gl.DeleteVertexArrays(_bufferID.Length, id);
GL.BindVertexArray(_bufferID[index]);
}
}
public void Dispose()
{
fixed (uint* id = _bufferID)
{
GL.DeleteVertexArrays(_bufferID.Length, id);
}
}
public void SetVertexAttribute(uint index, int vertexLength, Type dataType, bool isNomalized, int stride, int pointer)
{
GL.gl.VertexAttribPointer(
index, vertexLength, InternalIO.GLtype[dataType],
isNomalized,
stride, (void*)pointer);
public void BindNull()
{
GL.BindVertexArray(0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetVertexAttribute(uint index, int vertexLength, Type dataType, bool isNomalized, int stride, int pointer)
{
GL.SetVertexAttribute(
index, vertexLength, dataType,
isNomalized,
stride, pointer);
}
}
}
}
源代码/StgSharp/Graphics/GL/Buffer/VBO.cs
+58 -47
View File
@@ -1,69 +1,80 @@
using StgSharp.Math;
using System;
using System.Collections.Generic;
using System.Net.Security;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
namespace StgSharp.Graphics
{
public unsafe struct VertexBuffer : IDisposable
public partial class Form
{
internal uint[] _bufferID;
public VertexBuffer(int n)
protected VertexBuffer CreateVertexBuffer(int n)
{
_bufferID = new uint[n];
fixed (uint* ptr = _bufferID)
return new VertexBuffer(n, GL);
}
protected unsafe struct VertexBuffer : IDisposable
{
internal uint[] _bufferID;
private IglFunc GL;
internal VertexBuffer(int n, IglFunc glFunc)
{
GL.gl.GenBuffers(n, ptr);
_bufferID = new uint[n];
GL = glFunc;
fixed (uint* ptr = _bufferID)
{
GL.GenBuffers(n, ptr);
}
}
}
public uint this[int n]
{
get { return _bufferID[n]; }
}
/// <summary>
///
/// </summary>
public static void Unbind()
{
GL.gl.BindBuffer(GLconst.ARRAY_BUFFER, 0);
}
public void Bind(int index)
{
GL.gl.BindBuffer(GLconst.ARRAY_BUFFER, _bufferID[index]);
}
public void Dispose()
{
fixed (uint* id = _bufferID)
public uint this[int n]
{
GL.gl.DeleteBuffers(_bufferID.Length, id);
get { return _bufferID[n]; }
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bufferData"></param>
/// <param name="readType"></param>
public void SetData<T>(int index, T bufferData, BufferUsage usage) where T : IMat
{
GL.gl.BindBuffer((int)BufferType.ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ARRAY_BUFFER, bufferData, usage);
/// <summary>
///
/// </summary>
public void Unbind()
{
GL.BindBuffer(BufferType.ARRAY_BUFFER, 0);
}
}
public void Bind(int index)
{
GL.BindBuffer(BufferType.ARRAY_BUFFER, _bufferID[index]);
}
public void SetDataArray<T>(int index, T[] bufferArray, BufferUsage usage) where T : struct, IConvertible
{
GL.gl.BindBuffer(GLconst.ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ARRAY_BUFFER, bufferArray, usage);
public void Dispose()
{
fixed (uint* id = _bufferID)
{
GL.DeleteBuffers(_bufferID.Length, id);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bufferData"></param>
/// <param name="readType"></param>
public void SetValue<T>(int index, T bufferData, BufferUsage usage) where T : IMat
{
GL.BindBuffer(BufferType.ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ARRAY_BUFFER, bufferData, usage);
}
public void SetValueArray<T>(int index, T[] bufferArray, BufferUsage usage) where T : struct, IConvertible
{
GL.BindBuffer(BufferType.ARRAY_BUFFER, _bufferID[index]);
GL.SetBufferData(BufferType.ARRAY_BUFFER, bufferArray, usage);
}
}
}
}
源代码/StgSharp/Graphics/GL/Buffer/texture.cs
+133 -12
View File
@@ -1,27 +1,148 @@
using System;
using StgSharp.Math;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Graphics
{
public unsafe class Texture
public partial class Form
{
internal uint[] textureId;
public Texture(int n)
protected Texture CreateTexture(int n)
{
textureId = new uint[n];
fixed (uint* id = textureId)
{
GL.gl.GenTextures(n, id);
}
return new Texture(n, GL);
}
public void Bind(int index)
protected unsafe class Texture
{
GL.gl.BindTexture(GLconst.PROXY_TEXTURE_2D, textureId[index]);
internal uint[] textureId;
internal Image[] sourceList;
internal static bool[] unitActivated = new bool[16];
private IglFunc GL;
internal Texture(int n, IglFunc glFunc)
{
textureId = new uint[n];
sourceList = new Image[n];
GL = glFunc;
fixed (uint* id = textureId)
{
GL.GenTextures(n, id);
}
}
public void Bind2D(int index)
{
GL.BindTexture(GLconst.TEXTURE_2D, textureId[index]);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="index"></param>
/// <param name="loader"></param>
public unsafe void LoadTexture(int index, string name, ImageLoader loader)
{
sourceList[index] = new Image();
fixed (Image.ImageInfo* textureInfo = &sourceList[index].info)
{
InternalIO.InternalLoadImage(name, textureInfo, loader);
}
if (sourceList[index].info.pixelPtr != IntPtr.Zero)
{
uint channel;
switch (sourceList[index].info.channel)
{
case 1:
channel = GLconst.RED; break;
case 2:
channel = GLconst.RG; break;
case 3:
channel = GLconst.RGB; break;
case 4:
channel = GLconst.RGBA; break;
default:
channel = 0;
break;
}
GL.TextureImage2d(
GLconst.TEXTURE_2D, 0, channel,
sourceList[index].Width, sourceList[index].Height,
channel, GLconst.UNSIGNED_BYTE, (byte*)sourceList[index].info.pixelPtr
);
}
else
{
InternalIO.InternalWriteLog($"Failed to load image file of \"{name}\".", LogType.Error);
}
}
#region texture set
public void Set2dFilterProperty(
Filter onMinify, Filter onMagnify)
{
GL.TextureParameter(GLconst.TEXTURE_2D, GLconst.TEXTURE_MIN_FILTER, (int)onMinify);
GL.TextureParameter(GLconst.TEXTURE_2D, GLconst.TEXTURE_MAG_FILTER, (int)onMagnify);
}
public void Set2dWrapProperty(
Wrap onHorizontial, Wrap onVertical)
{
GL.TextureParameter(GLconst.TEXTURE_2D, GLconst.TEXTURE_WRAP_S, (int)onHorizontial);
GL.TextureParameter(GLconst.TEXTURE_2D, GLconst.TEXTURE_WRAP_T, (int)onVertical);
}
#endregion
public void Activate(TextureUnit unit)
{
GL.ActiveTexture((uint)unit);
}
}
public enum TextureUnit
{
Unit0 = GLconst.TEXTURE0,
Unit1 = GLconst.TEXTURE1,
Unit2 = GLconst.TEXTURE2,
Unit3 = GLconst.TEXTURE3,
Unit4 = GLconst.TEXTURE4,
Unit5 = GLconst.TEXTURE5,
Unit6 = GLconst.TEXTURE6,
Unit7 = GLconst.TEXTURE7,
Unit8 = GLconst.TEXTURE8,
Unit9 = GLconst.TEXTURE9,
Unit10 = GLconst.TEXTURE10,
Unit11 = GLconst.TEXTURE11,
Unit12 = GLconst.TEXTURE12,
Unit13 = GLconst.TEXTURE13,
Unit14 = GLconst.TEXTURE14,
Unit15 = GLconst.TEXTURE15,
}
public enum Wrap
{
Repeat = GLconst.REPEAT,
MirroredRepeat = GLconst.MIRRORED_REPEAT,
ClampToEdge = GLconst.CLAMP_TO_EDGE,
ClampToBorder = GLconst.CLAMP_TO_BORDER,
}
public enum Filter
{
Nearest = GLconst.NEAREST,
Linear = GLconst.LINEAR,
Nearest_LinearMipmap = GLconst.NEAREST_MIPMAP_LINEAR,
Linear_LinearMipmap = GLconst.LINEAR_MIPMAP_LINEAR,
Nearest_NearestMipmap = GLconst.NEAREST_MIPMAP_NEAREST,
Linear_NearestMipmap = GLconst.LINEAR_MIPMAP_NEAREST,
}
}