public unsafe Texture
(GL gl, string name, int width, int height, IntPtr data, bool generateMipmaps = false, bool srgb = false)
{
_gl = gl;
MaxAniso ??= gl.GetFloat(GLEnum.MaxTextureMaxAnisotropy);
Name = name;
Width = (uint)width;
Height = (uint)height;
InternalFormat = srgb ? Srgb8Alpha8 : GLEnum.Rgba8;
MipmapLevels =
(uint)(generateMipmaps == false ? 1 : (int)Math.Floor(Math.Log(Math.Max(Width, Height), 2)));
_gl.CreateTexture(TextureTarget.Texture2D, Name, out GlTexture);
_gl.TextureStorage2D(GlTexture, MipmapLevels, InternalFormat, Width, Height);
_gl.TextureSubImage2D(GlTexture, 0, 0, 0, Width, Height, PixelFormat.Bgra, PixelType.UnsignedByte,
(void *)data);
if (generateMipmaps)
{
_gl.GenerateTextureMipmap(GlTexture);
}
SetWrap(TextureCoordinate.S, TextureWrapMode.Repeat);
SetWrap(TextureCoordinate.T, TextureWrapMode.Repeat);
_gl.TextureParameter(GlTexture, TextureParameterName.TextureMaxLevel, MipmapLevels - 1);
}
static void SetFilter(uint id, GLEnum f)
{
GL.ActiveTexture((uint)GLEnum.TEXTURE0);
GL.BindTexture(GLEnum.TEXTURE_2D, id);
GL.TexParameteri(GLEnum.TEXTURE_2D, GLEnum.TEXTURE_MIN_FILTER, (int)f);
GL.TexParameteri(GLEnum.TEXTURE_2D, GLEnum.TEXTURE_MAG_FILTER, (int)f);
}
protected void AssignTextureParameters(GLEnum wrapMode, GLEnum filterMode)
{
GL.TextureParameter(Handle, TextureParameterName.TextureWrapS, (int)wrapMode);
GL.TextureParameter(Handle, TextureParameterName.TextureWrapT, (int)wrapMode);
GL.TextureParameter(Handle, TextureParameterName.TextureMinFilter, (int)filterMode);
GL.TextureParameter(Handle, TextureParameterName.TextureMagFilter, (int)filterMode);
}
static void UploadBufferData(ref uint id, GLEnum type, ReadOnlySequence <T> data, ref long currentBufferSize)
{
if (id == 0)
{
id = GL.GenBuffer();
}
GL.BindBuffer(type, id);
var structSize = Marshal.SizeOf <T>();
// resize the buffer
var neededBufferSize = data.Length * structSize;
if (currentBufferSize < neededBufferSize)
{
currentBufferSize = neededBufferSize;
GL.BufferData(type, new IntPtr(structSize * currentBufferSize), IntPtr.Zero, GLEnum.STATIC_DRAW);
}
// upload the data
var offset = 0;
foreach (var memory in data)
{
using var pinned = memory.Pin();
GL.BufferSubData(type, new IntPtr(structSize * offset), new IntPtr(structSize * memory.Length), new IntPtr(pinned.Pointer));
offset += memory.Length;
}
GL.BindBuffer(type, 0);
}
private void GenerateEnum(IndentedTextWriter writer, GLEnum glEnum, GLFeature feature, HashSet <GLChangeReference> collected)
{
bool any = false;
using (var sb = new StringBuilderTextWriter(new StringBuilder()))
using (var tempWriter = new IndentedTextWriter(sb))
{
tempWriter.Indent = writer.Indent;
tempWriter.WriteLine("enum " + glEnum.Name + " : uint");
tempWriter.WriteLine("{");
using (tempWriter.Indentation())
{
foreach (var entry in glEnum.Entries)
{
var reference = new GLChangeReference("enum", entry.Value.Name);
if (!collected.Contains(reference))
{
continue;
}
any = true;
tempWriter.WriteLine(entry.Value.Name + " = " + entry.Value.Value + ",");
}
}
tempWriter.WriteLine("}");
if (any)
{
writer.WriteLine(sb.StringBuilder.ToString());
}
}
}
public Blend(GLEnum srcRgb, GLEnum dstRgb, GLEnum srcAlpha, GLEnum dstAlpha)
{
_srcRgb = srcRgb;
_dstRgb = dstRgb;
_srcAlpha = srcAlpha;
_dstAlpha = dstAlpha;
}
private static void OnDebug(GLEnum source, GLEnum type, int id, GLEnum severity, int length, IntPtr message, IntPtr userparam)
{
Console.WriteLine
(
$"|{severity.ToString().Substring(13)}| {type.ToString().Substring(9)}/{id}: {Marshal.PtrToStringAnsi(message)}"
);
}
public LayerBuffer(bool staticData)
{
index = State.Gl.GenBuffer();
if (staticData)
{
usageHint = GLEnum.StaticDraw;
}
}
public static void CheckGlError(this GL gl, string title)
{
GLEnum error = gl.GetError();
if (error != GLEnum.NoError)
{
Debug.Print($"{title}: {error}");
}
}
public ColorBuffer(bool staticData)
{
_index = State.Gl.GenBuffer();
if (staticData)
{
_usageHint = GLEnum.StaticDraw;
}
}
public void GetFloat(GLEnum pname, out Vector4 vector)
{
unsafe
{
fixed(Vector4 *ptr = &vector)
{
GetFloat(pname, (float *)ptr);
}
}
}
public void GetFloat(GLEnum pname, out Matrix4x4 matrix)
{
unsafe
{
fixed(Matrix4x4 *ptr = &matrix)
{
GetFloat(pname, (float *)ptr);
}
}
}
protected BufferObject(State state, bool staticData)
{
this.state = state;
index = state.Gl.GenBuffer();
if (staticData)
{
usageHint = GLEnum.StaticDraw;
}
}
public string GetActiveAttrib(uint program, uint index, out int size, out GLEnum type)
{
uint length;
GetProgram(program, GLEnum.ActiveAttributeMaxLength, out var lengthTmp);
length = (uint)lengthTmp;
GetActiveAttrib(program, index, (uint)(length == 0 ? 1 : length * 2), out length, out size, out type, out string str);
return(str.Substring(0, (int)length));
}
public unsafe BufferObject(GL gl, Span <TDataType> data, GLEnum bufferType, GLEnum StaticOrDynamic)
{
_gl = gl;
_bufferType = bufferType;
_handle = _gl.GenBuffer();
Bind();
fixed(void *d = data)
{
_gl.BufferData(bufferType, (nuint)(data.Length * sizeof(TDataType)), d, StaticOrDynamic);
}
}
public void BindTexture(Texture texture, GLEnum attachment = GLEnum.ColorAttachment0, GLEnum target = GLEnum.Texture2D, bool dispose = true)
{
Use();
if (dispose && createdTexture && BoundTexture != null)
{
createdTexture = false;
BoundTexture.Dispose();
}
BoundTexture = texture;
gl.FramebufferTexture2D(GLEnum.Framebuffer, attachment, target, texture != null ? texture.ID : 0, 0);
}
public void LoadPart(IGLSpecification context, XElement rootNode)
{
const string UNKNOWN_GROUP_NAME = "UNKNOWN_GROUP";
var enumTypes = context.Enums;
var unknownEnumGroup = new GLEnum(UNKNOWN_GROUP_NAME, null);
enumTypes.Add(UNKNOWN_GROUP_NAME, unknownEnumGroup);
foreach (var e in rootNode.Elements("enums"))
{
var vendorName = e.Attribute("vendor")?.Value;
var parentGroups = e.Attribute("group");
foreach (var enumEntry in e.Elements("enum"))
{
var enumEntryName = enumEntry.Attribute("name")?.Value;
var enumEntryValue = enumEntry.Attribute("value")?.Value;
var parentGroupValue = parentGroups?.Value;
var enumGroupValue = enumEntry.Attribute("group")?.Value;
IEnumerable <string> enumGroups = (enumGroupValue)?.Split(',');
if (enumGroups != null)
{
if (parentGroupValue != null && !enumGroups.Contains(parentGroupValue))
{
enumGroups = enumGroups.Append(parentGroupValue);
}
}
else
{
enumGroups = new[] { parentGroupValue ?? UNKNOWN_GROUP_NAME };
}
if (enumEntryName == null || enumEntryValue == null)
{
throw new ArgumentNullException();
}
foreach (var enumGroup in enumGroups)
{
if (!enumTypes.TryGetValue(enumGroup, out var enumType))
{
enumType = new GLEnum(enumGroup, vendorName);
enumTypes.Add(enumGroup, enumType);
}
enumType.AddEntry(enumEntryName, ConvertToUInt64(enumEntryValue));
}
}
}
}
internal void CheckError(string str)
{
if (!Debug)
{
return;
}
GLEnum err = Gl.GetError();
if (err != GLEnum.NoError)
{
Console.Error.WriteLine("Error " + err + " after" + Environment.NewLine + str);
return;
}
}
private static UniformType ToFosterType(GLEnum type)
{
return(type switch
{
GLEnum.INT => UniformType.Int,
GLEnum.FLOAT => UniformType.Float,
GLEnum.FLOAT_VEC2 => UniformType.Float2,
GLEnum.FLOAT_VEC3 => UniformType.Float3,
GLEnum.FLOAT_VEC4 => UniformType.Float4,
GLEnum.FLOAT_MAT3x2 => UniformType.Matrix3x2,
GLEnum.FLOAT_MAT4 => UniformType.Matrix4x4,
GLEnum.SAMPLER_2D => UniformType.Sampler,
_ => throw new InvalidOperationException("Unknown Enum Type"),
});
/// <summary>
/// Manually query OpenGL for errors.
/// </summary>
/// <remarks>
/// <p>
/// This function is very simple, and offers little-to-no debug information.
/// </p>
/// <p>
/// Thus, try to rely on the default debug context exception handling. This should
/// only be used when that functionality is insufficient or failing.
/// </p>
/// </remarks>
/// <param name="checkForErrors"></param>
/// <exception cref="OpenGLException"></exception>
public static void CheckForErrorsAndThrow(bool checkForErrors)
{
if (!checkForErrors)
{
return;
}
GLEnum glError = Instance.GL.GetError();
switch (glError)
{
case GLEnum.NoError: break;
default: throw new OpenGLException(glError);
}
}
public unsafe void StoreData <T>(T[] data, uint slot, int dimensions, GLEnum dataType)
where T : unmanaged
{
Bind();
uint vboID = _gl.GenBuffer();
_vbos.Add(vboID);
_gl.BindBuffer(BufferTargetARB.ArrayBuffer, vboID);
fixed(T *d = data)
{
_gl.BufferData(BufferTargetARB.ArrayBuffer, (uint)(sizeof(T) * data.Length), d, BufferUsageARB.StaticDraw);
}
_gl.VertexAttribPointer(slot, dimensions, dataType, false, (uint)(dimensions * sizeof(T)), null);
_gl.BindBuffer(BufferTargetARB.ArrayBuffer, 0);
Unbind();
}
private unsafe void UploadBuffer <T>(ref uint id, GLEnum type, ReadOnlySequence <T> data, ref long currentBufferSize)
{
if (graphics.MainThreadId != Thread.CurrentThread.ManagedThreadId)
{
lock (graphics.BackgroundContext)
{
graphics.System.SetCurrentGLContext(graphics.BackgroundContext);
UploadBufferData(ref id, type, data, ref currentBufferSize);
GL.Flush();
graphics.System.SetCurrentGLContext(null);
}
}
else
{
UploadBufferData(ref id, type, data, ref currentBufferSize);
}
protected override void SetFilter(TextureFilter filter)
{
GLEnum f = (filter == TextureFilter.Nearest ? GLEnum.NEAREST : GLEnum.LINEAR);
if (graphics.MainThreadId != Thread.CurrentThread.ManagedThreadId)
{
lock (graphics.BackgroundContext)
{
graphics.System.SetCurrentGLContext(graphics.BackgroundContext);
SetFilter(ID, f);
GL.Flush();
graphics.System.SetCurrentGLContext(graphics.BackgroundContext);
}
}
else
{
SetFilter(ID, f);
}
private void PrintGLError(GLEnum source, GLEnum type, int id, GLEnum severity, int length, nint message, nint userparam)
{
var buf = new byte[length];
Marshal.Copy(message, buf, 0, buf.Length);
var messageString = Encoding.UTF8.GetString(buf);
var logLevel = severity switch
{
GLEnum.DebugSeverityLow => LogLevel.Warning,
GLEnum.DebugSeverityMedium => LogLevel.Error,
GLEnum.DebugSeverityHigh => LogLevel.Fatal,
_ => LogLevel.Trace
};
if (logLevel != LogLevel.Trace)
{
App.Logger.Log(messageString, logLevel);
}
}
public Blend(CompositeOperationState compositeOperation, OpenGLRenderer renderer)
{
GLEnum srcRgb = ConvertBlend(compositeOperation.SrcRgb);
GLEnum dstRgb = ConvertBlend(compositeOperation.DstRgb);
GLEnum srcAlpha = ConvertBlend(compositeOperation.SrcAlpha);
GLEnum dstAlpha = ConvertBlend(compositeOperation.DstAlpha);
if (srcRgb == GLEnum.InvalidEnum || dstRgb == GLEnum.InvalidEnum ||
srcAlpha == GLEnum.InvalidEnum || dstAlpha == GLEnum.InvalidEnum)
{
srcRgb = GLEnum.One;
dstRgb = GLEnum.OneMinusSrcAlpha;
srcAlpha = GLEnum.One;
dstAlpha = GLEnum.OneMinusDstAlpha;
}
_srcRgb = srcRgb;
_dstRgb = dstRgb;
_srcAlpha = srcAlpha;
_dstAlpha = dstAlpha;
_renderer = renderer;
}
private void GenerateSpecialNumbers(IndentedTextWriter writer, GLEnum glEnum, GLFeature feature, HashSet <GLChangeReference> collected)
{
bool any = false;
using (var sb = new StringBuilderTextWriter(new StringBuilder()))
using (var tempWriter = new IndentedTextWriter(sb))
{
tempWriter.Indent = writer.Indent;
tempWriter.WriteLine("public static class " + glEnum.Name + "");
tempWriter.WriteLine("{");
using (tempWriter.Indentation())
{
foreach (var entry in glEnum.Entries)
{
var reference = new GLChangeReference("enum", entry.Value.Name);
if (!collected.Contains(reference))
{
continue;
}
any = true;
string dataType = entry.Value.Value <= byte.MaxValue ? "byte" :
entry.Value.Value <= ushort.MaxValue ? "ushort" :
entry.Value.Value <= uint.MaxValue ? "uint" : "ulong";
tempWriter.WriteLine($"public static {dataType} {entry.Value.Name} = {entry.Value.Value};");
}
}
tempWriter.WriteLine("}");
if (any)
{
writer.WriteLine(sb.StringBuilder.ToString());
}
}
}
protected override void Init(Texture texture)
{
this.texture = texture;
glInternalFormat = texture.Format switch
{
TextureFormat.Red => GLEnum.RED,
TextureFormat.RG => GLEnum.RG,
TextureFormat.RGB => GLEnum.RGB,
TextureFormat.Color => GLEnum.RGBA,
TextureFormat.DepthStencil => GLEnum.DEPTH24_STENCIL8,
_ => throw new Exception("Invalid Texture Format"),
};
glFormat = texture.Format switch
{
TextureFormat.Red => GLEnum.RED,
TextureFormat.RG => GLEnum.RG,
TextureFormat.RGB => GLEnum.RGB,
TextureFormat.Color => GLEnum.RGBA,
TextureFormat.DepthStencil => GLEnum.DEPTH_STENCIL,
_ => throw new Exception("Invalid Texture Format"),
};
glType = texture.Format switch
{
TextureFormat.Red => GLEnum.UNSIGNED_BYTE,
TextureFormat.RG => GLEnum.UNSIGNED_BYTE,
TextureFormat.RGB => GLEnum.UNSIGNED_BYTE,
TextureFormat.Color => GLEnum.UNSIGNED_BYTE,
TextureFormat.DepthStencil => GLEnum.UNSIGNED_INT_24_8,
_ => throw new Exception("Invalid Texture Format"),
};
Initialize();
}
private static void DebugOutputCallback(GLEnum source, GLEnum type, int id, GLEnum severity, int length, nint messagePtr, nint userParamPtr)
{
public unsafe void DrawElements(GLEnum mode, uint count, GLEnum type, int offset)
{
DrawElements((GLEnum)mode, count, type, (void *)(offset));
}
public unsafe void VertexAttribPointer(uint index, int size, GLEnum type, bool normalized, uint stride, int offset)
{
VertexAttribPointer(index, size, type, normalized, stride, (void *)offset);
}
