public GraphicsProvider(
ISdl2 sdl,
IOpenGl gl,
IntPtr windowPointer)
{
_sdl = sdl;
Graphics = gl;
_windowPointer = windowPointer;
}
public static uint LoadShaderProgramFromFiles(
IOpenGl gl,
string vertexShaderPath,
string fragmentShaderPath)
{
var vertexSource = File.ReadAllBytes(vertexShaderPath);
var fragmentSource = File.ReadAllBytes(fragmentShaderPath);
return(LoadShaderProgram(gl, vertexSource, fragmentSource));
}
public static void LogProgress(
this IOpenGl gl,
[CallerFilePath] string?file = null,
[CallerMemberName] string?caller = null,
[CallerLineNumber] int lineNumber = 0)
{
if (!gl.DumpErrors(file, caller, lineNumber))
{
Console.WriteLine($"{file} - {caller} : {lineNumber} - No errors");
}
}
public static void TexParams(
this IOpenGl gl,
uint target,
ReadOnlySpan <uint> parameters)
{
for (int i = 1; i < parameters.Length; i += 2)
{
gl.TexParameteri(
target,
parameters[i - 1],
parameters[i]);
}
}
internal Window(
ISdl2 sdl,
IOpenGl openGl,
IWindowEventHandler windowEventHandler,
IntPtr windowPointer,
IntPtr contextPointer,
uint windowId)
{
Sdl = sdl;
WindowEventHandler = windowEventHandler;
WindowPointer = windowPointer;
ContextPointer = contextPointer;
WindowId = windowId;
_graphicsProvider = new GraphicsProvider(sdl, openGl, windowPointer);
}
public static bool DumpErrors(
this IOpenGl gl,
[CallerFilePath] string?file = null,
[CallerMemberName] string?caller = null,
[CallerLineNumber] int lineNumber = 0)
{
bool result = false;
while (true)
{
var err = gl.GetError();
if (err == Gl.NoError)
{
break;
}
result = true;
Console.Write($"{file} - {caller} : {lineNumber} - ");
switch (err)
{
case Gl.InvalidEnum: Console.WriteLine("GL_INVALID_ENUM"); break;
case Gl.InvalidValue: Console.WriteLine("GL_INVALID_VALUE"); break;
case Gl.InvalidOperation: Console.WriteLine("GL_INVALID_OPERATION"); break;
case Gl.StackOverflow: Console.WriteLine("GL_STACK_OVERFLOW"); break;
case Gl.StackUnderflow: Console.WriteLine("GL_STACK_UNDERFLOW"); break;
case Gl.OutOfMemory: Console.WriteLine("GL_OUT_OF_MEMORY"); break;
case Gl.InvalidFramebufferOperation: Console.WriteLine("GL_INVALID_FRAMEBUFFER_OPERATION"); break;
case Gl.ContextLost: Console.WriteLine("GL_CONTEXT_LOST"); break;
default: Console.WriteLine("Everything is fine. Nothing is broken."); break;
}
}
return(result);
}
public static uint LoadShaderProgram(
IOpenGl gl,
ReadOnlySpan <byte> vertexSource,
ReadOnlySpan <byte> fragmentSource)
{
var vertexShader = LoadShader(gl, vertexSource, Gl.VertexShader);
try
{
var fragmentShader = LoadShader(gl, fragmentSource, Gl.FragmentShader);
try
{
var program = gl.CreateProgram();
gl.AttachShader(program, vertexShader);
gl.AttachShader(program, fragmentShader);
gl.LinkProgram(program);
gl.DeleteShader(fragmentShader);
gl.DeleteShader(vertexShader);
gl.GetProgramiv(program, Gl.LinkStatus, out var result);
if (result == Gl.False)
{
gl.GetProgramiv(program, Gl.InfoLogLength, out var logLength);
var buffer = new byte[logLength];
gl.GetProgramInfoLog(program, buffer.Length, out _, buffer);
var errors = Encoding.UTF8.GetString(buffer);
throw new OpenGlException("Error linking program: " + errors);
}
return(program);
}
finally
{
gl.DeleteShader(fragmentShader);
}
}
finally
{
gl.DeleteShader(vertexShader);
}
}
public static bool TryLogErrors(
this IOpenGl gl,
ILogger logger,
[CallerFilePath] string?file = null,
[CallerMemberName] string?caller = null,
[CallerLineNumber] int lineNumber = 0)
{
bool result = false;
while (true)
{
var err = gl.GetError();
if (err == Gl.NoError)
{
break;
}
result = true;
var errorEnum = err switch
{
Gl.InvalidEnum => "GL_INVALID_ENUM",
Gl.InvalidValue => "GL_INVALID_VALUE",
Gl.InvalidOperation => "GL_INVALID_OPERATION",
Gl.StackOverflow => "GL_STACK_OVERFLOW",
Gl.StackUnderflow => "GL_STACK_UNDERFLOW",
Gl.OutOfMemory => "GL_OUT_OF_MEMORY",
Gl.InvalidFramebufferOperation => "GL_INVALID_FRAMEBUFFER_OPERATION",
Gl.ContextLost => "GL_CONTEXT_LOST",
_ => $"unknown error value: " + err
};
logger.LogError($"{file} - {caller} : {lineNumber} - {errorEnum}");
}
return(result);
}
}
public static uint LoadShader(
IOpenGl gl,
ReadOnlySpan <byte> source,
uint shaderType)
{
unsafe
{
fixed(byte *pointer = source)
{
var shader = gl.CreateShader(shaderType);
try
{
var ptr = new IntPtr(pointer);
gl.ShaderSource(shader, 1, ptr, source.Length);
gl.CompileShader(shader);
gl.GetShaderiv(shader, Gl.CompileStatus, out var result);
if (result == Gl.False)
{
gl.GetShaderiv(shader, Gl.InfoLogLength, out var logLength);
var buffer = new byte[logLength];
gl.GetShaderInfoLog(shader, buffer.Length, out var actualLength, buffer);
// We can disregard the actual length because we queried the actual length up above.
var errors = Encoding.UTF8.GetString(buffer);
throw new OpenGlException("Error compiling shader: " + errors);
}
return(shader);
}
catch
{
gl.DeleteShader(shader);
throw;
}
}
}
}
public static int GetInteger(this IOpenGl gl, uint pname)
{
gl.GetIntegerv(pname, out var result);
return(result);
}
public static void DeleteVertexArrays(this IOpenGl gl, ReadOnlySpan <uint> arrays)
{
gl.DeleteVertexArrays(arrays.Length, arrays[0]);
}
public static void DeleteVertexArray(this IOpenGl gl, uint array)
{
gl.DeleteVertexArrays(1, array);
}
public static void DeleteTextures(this IOpenGl gl, ReadOnlySpan <uint> textures)
{
gl.DeleteTextures(textures.Length, textures[0]);
}
public static void DeleteTexture(this IOpenGl gl, uint texture)
{
gl.DeleteTextures(1, texture);
}
public static void DeleteBuffers(this IOpenGl gl, ReadOnlySpan <uint> buffers)
{
gl.DeleteBuffers(buffers.Length, buffers[0]);
}
public static void DeleteBuffer(this IOpenGl gl, uint buffer)
{
gl.DeleteBuffers(1, buffer);
}
public static uint GenBuffer(this IOpenGl gl)
{
gl.GenBuffers(1, out var buffer);
return(buffer);
}
public static void GenBuffers(this IOpenGl gl, Span <uint> buffers)
{
gl.GenBuffers(buffers.Length, out buffers[0]);
}
public static void GenVertexArrays(this IOpenGl gl, Span <uint> arrays)
{
gl.GenVertexArrays(arrays.Length, out arrays[0]);
}
public static uint GenVertexArray(this IOpenGl gl)
{
gl.GenVertexArrays(1, out var array);
return(array);
}
public static void GenTextures(this IOpenGl gl, Span <uint> textures)
{
gl.GenTextures(textures.Length, out textures[0]);
}
public static uint GenTexture(this IOpenGl gl)
{
gl.GenTextures(1, out var result);
return(result);
}
