add uefi.c3l, c3fmt

1 files changed, 386 insertions, 304 deletions

diff --git a/rsgl.c3l/rsgl.c3 b/rsgl.c3l/rsgl.c3
index db292e0..dc770b2 100644
--- a/rsgl.c3l/rsgl.c3
+++ b/rsgl.c3l/rsgl.c3
@@ -1,5 +1,4 @@
-/*
-*
+/**
 * Copyright (C) 2026 andromeda
 *
 * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
@@ -7,439 +6,522 @@
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*
-*/
+**/
 
 module rsgl;
 
-macro @rect(#x,#y,#w,#h) {return (Rect){#x,#y,#w,#h};}
-macro @cube(#x,#y,#z,#w,#l,#h) {return (Cube){#x,#y,#z,#w,#l,#h};}
-macro @vec2D(#x,#y) {return (Vec2D){#x,#y};}
-macro @vec3D(#x,#y,#z) {return (Vec3D){#x,#y,#z};}
-macro @triangle(#p1,#p2,#p3) {return (Vec3D[3]){#p1,#p2,#p3};}
-macro @createTriangle(#p1x,#p1y,#p1z,#p2x,#p2y,#p2z,#p3x,#p3y,#p3z) {return @triangle(@vec3D(#p1x,#p1y,#p1z),@vec3D(#p2x,#p2y,#p2z),@vec3D(#p3x,#p3y,#p3z));}
-macro @rgba(#r,#g,#b,#a) {return (Color){#a,#b,#g,#r};}
-macro @rgb(#r,#g,#b) {return (Color){255,#b,#g,#r};}
-macro @colorToHex(#color) {return (uint)#color & 0xFFFFFF00;}
-macro @rgbToHex(#r,#g,#b) {return @colorToHex(@rgb(#r,#g,#b));}
-macro @rgbaToHex(#r,#g,#b,#a) {return @colorToHex(@rgba(#r,#g,#b,#a));}
+macro @rect(#x, #y, #w, #h)
+{
+	return (Rect) { #x, #y, #w, #h };
+}
+macro @cube(#x, #y, #z, #w, #l, #h)
+{
+	return (Cube) { #x, #y, #z, #w, #l, #h };
+}
+macro @vec2D(#x, #y)
+{
+	return (Vec2D) { #x, #y };
+}
+macro @vec3D(#x, #y, #z)
+{
+	return (Vec3D) { #x, #y, #z };
+}
+macro @triangle(#p1, #p2, #p3)
+{
+	return (Vec3D[3]) { #p1, #p2, #p3 };
+}
+macro @createTriangle(#p1x, #p1y, #p1z, #p2x, #p2y, #p2z, #p3x, #p3y, #p3z)
+{
+	return @triangle(@vec3D(#p1x, #p1y, #p1z), @vec3D(#p2x, #p2y, #p2z), @vec3D(#p3x, #p3y, #p3z));
+}
+macro @rgba(#r, #g, #b, #a)
+{
+	return (Color) { #a, #b, #g, #r };
+}
+macro @rgb(#r, #g, #b)
+{
+	return (Color) { 255, #b, #g, #r };
+}
+macro @colorToHex(#color)
+{
+	return (uint)#color & 0xFFFFFF00;
+}
+macro @rgbToHex(#r, #g, #b)
+{
+	return @colorToHex(@rgb(#r, #g, #b));
+}
+macro @rgbaToHex(#r, #g, #b, #a)
+{
+	return @colorToHex(@rgba(#r, #g, #b, #a));
+}
 
 const int MAX_BATCHES = 2028;
 const int MAX_VERTS   = 8192;
 
 constdef TextureFormat
 {
-  NONE = 0,
-  RGB,
-  BGR,
-  RGBA,
-  BGRA,
-  RED,
-  GRAYSCALE,
-  GRAYSCALE_ALPHA,
-  FORMAT_COUNT,
+	NONE = 0,
+	RGB,
+	BGR,
+	RGBA,
+	BGRA,
+	RED,
+	GRAYSCALE,
+	GRAYSCALE_ALPHA,
+	FORMAT_COUNT,
 }
 
 constdef TextureDataType
 {
-  INT = 0,
-  FLOAT,
+	INT = 0,
+	FLOAT,
 }
 
 constdef TextureFilter
 {
-  NEAREST = 0,
-  LINEAR,
+	NEAREST = 0,
+	LINEAR,
 }
 
 struct TextureBlob
 {
-  void*           data;
-  usz             width;
-  usz             height;
-  TextureDataType dataType;
-  TextureFormat   dataFormat;
-  TextureFormat   textureFormat;
-  TextureFilter   minFilter;
-  TextureFilter   magFilter;
+	void* data;
+	usz width;
+	usz height;
+	TextureDataType dataType;
+	TextureFormat dataFormat;
+	TextureFormat textureFormat;
+	TextureFilter minFilter;
+	TextureFilter magFilter;
 }
 
-alias Texture     = usz;
+alias Texture = usz;
 alias Framebuffer = usz;
 
 struct Rect
 {
-  float x;
-  float y;
-  float w;
-  float h;
+	float x;
+	float y;
+	float w;
+	float h;
 }
 
 struct Cube
 {
-  float x;
-  float y;
-  float z;
-  float w;
-  float l;
-  float h;
+	float x;
+	float y;
+	float z;
+	float w;
+	float l;
+	float h;
 }
 
 struct Vec2D
 {
-  float x;
-  float y;
+	float x;
+	float y;
 }
 
 struct Vec3D
 {
-  float x;
-  float y;
-  float z;
+	float x;
+	float y;
+	float z;
 }
 
 struct Color
 {
-  char a;
-  char b;
-  char g;
-  char r;
+	char a;
+	char b;
+	char g;
+	char r;
 }
 
 alias Mat4 = float[16];
 
-extern fn Mat4  mat4_loadIdentity()                                                              @cname("RSGL_mat4_loadIdentity");
-extern fn Mat4  mat4_scale(Mat4, float, float, float)                                            @cname("RSGL_mat4_scale");
-extern fn Mat4  mat4_rotate(Mat4, float, float, float, float)                                    @cname("RSGL_mat4_rotate");
-extern fn Mat4  mat4_translate(Mat4, float, float, float)                                        @cname("RSGL_mat4_translate");
-extern fn Mat4  mat4_perspective(Mat4, float, float, float, float)                               @cname("RSGL_mat4_perspective");
-extern fn Mat4  mat4_ortho(Mat4, float, float, float, float, float, float)                       @cname("RSGL_mat4_ortho");
-extern fn Mat4  mat4_lookAt(Mat4, float, float, float, float, float, float, float, float, float) @cname("RSGL_mat4_lookAt");
-extern fn Mat4  mat4_multiply(Mat4, Mat4)                                                        @cname("RSGL_mat4_multiply");
-extern fn Vec3D mat4_multiplyPoint(Mat4, Vec3D)                                                  @cname("RSGL_mat4_multiplyPoint");
+extern fn Mat4 mat4_loadIdentity() @cname("RSGL_mat4_loadIdentity");
+extern fn Mat4 mat4_scale(Mat4, float, float, float) @cname("RSGL_mat4_scale");
+extern fn Mat4 mat4_rotate(Mat4, float, float, float, float) @cname("RSGL_mat4_rotate");
+extern fn Mat4 mat4_translate(Mat4, float, float, float) @cname("RSGL_mat4_translate");
+extern fn Mat4 mat4_perspective(Mat4, float, float, float, float) @cname("RSGL_mat4_perspective");
+extern fn Mat4 mat4_ortho(Mat4, float, float, float, float, float, float) @cname("RSGL_mat4_ortho");
+extern fn Mat4 mat4_lookAt(
+	Mat4,
+	float,
+	float,
+	float,
+	float,
+	float,
+	float,
+	float,
+	float,
+	float
+) @cname("RSGL_mat4_lookAt");
+extern fn Mat4 mat4_multiply(Mat4, Mat4) @cname("RSGL_mat4_multiply");
+extern fn Vec3D mat4_multiplyPoint(Mat4, Vec3D) @cname("RSGL_mat4_multiplyPoint");
 
 constdef ProjectionType
 {
-  ORTHO_2D = 0,
-  ORTHO_3D,
-  PERSPECTIVE_3D,
+	ORTHO_2D = 0,
+	ORTHO_3D,
+	PERSPECTIVE_3D,
 }
 
 struct Projection2D
 {
-  ProjectionType type;
-  uint           width;
-  uint           height;
+	ProjectionType type;
+	uint width;
+	uint height;
 }
 
 struct Projection3D
 {
-  ProjectionType type;
-  float          fov;
-  float          ratio;
-  float          pNear;
-  float          pFar;
+	ProjectionType type;
+	float fov;
+	float ratio;
+	float pNear;
+	float pFar;
 }
 
 union Projection
 {
-  ProjectionType type;
-  Projection2D   p2D;
-  Projection3D   p3D;
+	ProjectionType type;
+	Projection2D p2D;
+	Projection3D p3D;
 }
 
 extern fn Mat4 projection_getMatrix(Projection*) @cname("RSGL_projection_getMatrix");
 
 constdef ShaderType
 {
-  NONE     = 0,
-  STANDARD = 1,
-  COMPUTE  = 2,
-  GEOMETRY = 4,
+	NONE     = 0,
+	STANDARD = 1,
+	COMPUTE  = 2,
+	GEOMETRY = 4,
 }
 
 struct ProgramBlob
 {
-  ZString vertex;
-  usz vertexLen;
-  ZString fragment;
-  usz fragmentLen;
+	ZString vertex;
+	usz vertexLen;
+	ZString fragment;
+	usz fragmentLen;
 }
 
 struct ProgramInfo
 {
-  usz        program;
-  usz        perspectiveView;
-  usz        model;
-  usz        vertexPosition;
-  usz        vertexTexCoord;
-  usz        vertexColor;
-  ShaderType type;
+	usz program;
+	usz perspectiveView;
+	usz model;
+	usz vertexPosition;
+	usz vertexTexCoord;
+	usz vertexColor;
+	ShaderType type;
 }
 
 struct Batch
 {
-  usz     start;
-  usz     len;
-  usz     elmStart;
-  usz     elmCount;
-  uint    type;
-  Texture tex;
-  float   lineWidth;
-  Mat4    matrix;
+	usz start;
+	usz len;
+	usz elmStart;
+	usz elmCount;
+	uint type;
+	Texture tex;
+	float lineWidth;
+	Mat4 matrix;
 }
 
 struct RenderData
 {
-  float* verts;
-  float* texCoords;
-  float* colors;
-  ushort* elements;
-  usz     elements_count;
-  usz     len;
-  Mat4    perspective;
+	float* verts;
+	float* texCoords;
+	float* colors;
+	ushort* elements;
+	usz elements_count;
+	usz len;
+	Mat4 perspective;
 }
 
 constdef BufferType
 {
-  ARRAY_BUFFER = 0,
-  ELEMENT_ARRAY_BUFFER,
-  SHADER_STORAGE_BUFFER,
-  TEXTURE_BUFFER,
-  UNIFORM_BUFFER,
+	ARRAY_BUFFER = 0,
+	ELEMENT_ARRAY_BUFFER,
+	SHADER_STORAGE_BUFFER,
+	TEXTURE_BUFFER,
+	UNIFORM_BUFFER,
 }
 
 struct RenderBuffers
 {
-  usz                vertex;
-  usz                color;
-  usz                texture;
-  usz                elements;
-  usz                maxVerts;
-  Batch[MAX_BATCHES] batches;
-  usz                batchCount;
+	usz vertex;
+	usz color;
+	usz texture;
+	usz elements;
+	usz maxVerts;
+	Batch[MAX_BATCHES] batches;
+	usz batchCount;
 }
 
 struct RenderState
 {
-  float*  gradient;
-  Rect    source;
-  Texture texture;
-  uint    gradient_len;
-  Color   color;
-  Vec3D   rotate;
-  ProgramInfo*   program;
-  RenderBuffers* buffers;
-  Vec3D          center;
-  float          lineWidth;
-  Mat4           modelMatrix;
-  Mat4           viewMatrix;
-  Mat4           perspectiveMatrix;
-  bool           forceBatch;
-  bool           overflow;
-  Framebuffer    framebuffer;
+	float* gradient;
+	Rect source;
+	Texture texture;
+	uint gradient_len;
+	Color color;
+	Vec3D rotate;
+	ProgramInfo* program;
+	RenderBuffers* buffers;
+	Vec3D center;
+	float lineWidth;
+	Mat4 modelMatrix;
+	Mat4 viewMatrix;
+	Mat4 perspectiveMatrix;
+	bool forceBatch;
+	bool overflow;
+	Framebuffer framebuffer;
 }
 
 struct RenderPass
 {
-  ProgramInfo*   program;
-  float*         matrix;
-  RenderBuffers* buffers;
-  Framebuffer    framebuffer;
+	ProgramInfo* program;
+	float* matrix;
+	RenderBuffers* buffers;
+	Framebuffer framebuffer;
 }
 
-alias RendererProc_size                   = fn usz         ();
-alias RendererProc_defaultBlob            = fn ProgramBlob (void*);
-alias RendererProc_initPtr                = fn void        (void*, void*);
-alias RendererProc_freePtr                = fn void        (void*);
-alias RendererProc_render                 = fn void        (void*, RenderPass*);
-alias RendererProc_clear                  = fn void        (void*, Framebuffer, float, float, float, float);
-alias RendererProc_viewport               = fn void        (void*, int, int, int, int);
-alias RendererProc_setSurface             = fn void        (void*, void*);
-alias RendererProc_createTexture          = fn Texture     (void*, TextureBlob*);
-alias RendererProc_copyToTexture          = fn void        (void*, Texture, usz, usz, TextureBlob*);
-alias RendererProc_deleteTexture          = fn void        (void*, Texture);
-alias RendererProc_scissorStart           = fn void        (void*, float, float, float, float, float);
-alias RendererProc_scissorEnd             = fn void        (void*);
-alias RendererProc_createProgram          = fn ProgramInfo (void*, ProgramBlob*);
-alias RendererProc_deleteProgram          = fn void        (void*, ProgramInfo*);
-alias RendererProc_findShaderVariable     = fn usz         (void*, ProgramInfo*, ZString, usz);
-alias RendererProc_updateShaderVariable   = fn void        (void*, ProgramInfo*, usz, float*, char);
-alias RendererProc_createComputeProgram   = fn ProgramInfo (void*, ZString);
-alias RendererProc_dispatchComputeProgram = fn void        (void*, ProgramInfo*, uint, uint, uint);
-alias RendererProc_bindComputeTexture     = fn void        (void*, uint, char);
-alias RendererProc_createBuffer           = fn void        (void*, BufferType, usz, void*, usz*);
-alias RendererProc_updateBuffer           = fn void        (void*, BufferType, usz, void*, usz, usz);
-alias RendererProc_deleteBuffer           = fn void        (void*, usz);
-alias RendererProc_createFramebuffer      = fn Framebuffer (void*, usz, usz);
-alias RendererProc_attachFramebuffer      = fn void        (void*, Framebuffer, Texture, char, char);
-alias RendererProc_deleteFramebuffer      = fn void        (void*, Framebuffer);
+alias RendererProc_size = fn usz();
+alias RendererProc_defaultBlob = fn ProgramBlob(void*);
+alias RendererProc_initPtr = fn void(void*, void*);
+alias RendererProc_freePtr = fn void(void*);
+alias RendererProc_render = fn void(void*, RenderPass*);
+alias RendererProc_clear = fn void(void*, Framebuffer, float, float, float, float);
+alias RendererProc_viewport = fn void(void*, int, int, int, int);
+alias RendererProc_setSurface = fn void(void*, void*);
+alias RendererProc_createTexture = fn Texture(void*, TextureBlob*);
+alias RendererProc_copyToTexture = fn void(void*, Texture, usz, usz, TextureBlob*);
+alias RendererProc_deleteTexture = fn void(void*, Texture);
+alias RendererProc_scissorStart = fn void(void*, float, float, float, float, float);
+alias RendererProc_scissorEnd = fn void(void*);
+alias RendererProc_createProgram = fn ProgramInfo(void*, ProgramBlob*);
+alias RendererProc_deleteProgram = fn void(void*, ProgramInfo*);
+alias RendererProc_findShaderVariable = fn usz(void*, ProgramInfo*, ZString, usz);
+alias RendererProc_updateShaderVariable = fn void(void*, ProgramInfo*, usz, float*, char);
+alias RendererProc_createComputeProgram = fn ProgramInfo(void*, ZString);
+alias RendererProc_dispatchComputeProgram = fn void(void*, ProgramInfo*, uint, uint, uint);
+alias RendererProc_bindComputeTexture = fn void(void*, uint, char);
+alias RendererProc_createBuffer = fn void(void*, BufferType, usz, void*, usz*);
+alias RendererProc_updateBuffer = fn void(void*, BufferType, usz, void*, usz, usz);
+alias RendererProc_deleteBuffer = fn void(void*, usz);
+alias RendererProc_createFramebuffer = fn Framebuffer(void*, usz, usz);
+alias RendererProc_attachFramebuffer = fn void(void*, Framebuffer, Texture, char, char);
+alias RendererProc_deleteFramebuffer = fn void(void*, Framebuffer);
 
 struct RendererProc
 {
-  RendererProc_size                   size;
-  RendererProc_defaultBlob            defaultBlob;
-  RendererProc_initPtr                initPtr;
-  RendererProc_freePtr                freePtr;
-  RendererProc_render                 render;
-  RendererProc_clear                  clear;
-  RendererProc_viewport               viewport;
-  RendererProc_setSurface             setSurface;
-  RendererProc_createTexture          createTexture;
-  RendererProc_copyToTexture          copyToTexture;
-  RendererProc_deleteTexture          deleteTexture;
-  RendererProc_scissorStart           scissorStart;
-  RendererProc_scissorEnd             scissorEnd;
-  RendererProc_createProgram          createProgram;
-  RendererProc_deleteProgram          deleteProgram;
-  RendererProc_findShaderVariable     findShaderVariable;
-  RendererProc_updateShaderVariable   updateShaderVariable;
-  RendererProc_createComputeProgram   createComputeProgram;
-  RendererProc_dispatchComputeProgram dispatchComputeProgram;
-  RendererProc_bindComputeTexture     bindComputeTexture;
-  RendererProc_createBuffer           createBuffer;
-  RendererProc_updateBuffer           updateBuffer;
-  RendererProc_deleteBuffer           deleteBuffer;
-  RendererProc_createFramebuffer      createFramebuffer;
-  RendererProc_attachFramebuffer      attachFramebuffer;
-  RendererProc_deleteFramebuffer      deleteFramebuffer;
+	RendererProc_size size;
+	RendererProc_defaultBlob defaultBlob;
+	RendererProc_initPtr initPtr;
+	RendererProc_freePtr freePtr;
+	RendererProc_render render;
+	RendererProc_clear clear;
+	RendererProc_viewport viewport;
+	RendererProc_setSurface setSurface;
+	RendererProc_createTexture createTexture;
+	RendererProc_copyToTexture copyToTexture;
+	RendererProc_deleteTexture deleteTexture;
+	RendererProc_scissorStart scissorStart;
+	RendererProc_scissorEnd scissorEnd;
+	RendererProc_createProgram createProgram;
+	RendererProc_deleteProgram deleteProgram;
+	RendererProc_findShaderVariable findShaderVariable;
+	RendererProc_updateShaderVariable updateShaderVariable;
+	RendererProc_createComputeProgram createComputeProgram;
+	RendererProc_dispatchComputeProgram dispatchComputeProgram;
+	RendererProc_bindComputeTexture bindComputeTexture;
+	RendererProc_createBuffer createBuffer;
+	RendererProc_updateBuffer updateBuffer;
+	RendererProc_deleteBuffer deleteBuffer;
+	RendererProc_createFramebuffer createFramebuffer;
+	RendererProc_attachFramebuffer attachFramebuffer;
+	RendererProc_deleteFramebuffer deleteFramebuffer;
 }
 
 struct Renderer
 {
-  RenderData          data;
-  RenderState         state;
-  RendererProc        proc;
-  void*               userPtr;
-  void*               ctx;
-  Texture             defaultTexture;
-  ProgramInfo         defaultProgram;
-  Mat4                defaultPerspectiveMatrix;
-  float[MAX_VERTS*3]  verts;
-  float[MAX_VERTS*2]  texCoords;
-  float[MAX_VERTS*4]  colors;
-  ushort[MAX_VERTS*6] elements;
-  RenderBuffers       buffers;
+	RenderData data;
+	RenderState state;
+	RendererProc proc;
+	void* userPtr;
+	void* ctx;
+	Texture defaultTexture;
+	ProgramInfo defaultProgram;
+	Mat4 defaultPerspectiveMatrix;
+	float[MAX_VERTS * 3] verts;
+	float[MAX_VERTS * 2] texCoords;
+	float[MAX_VERTS * 4] colors;
+	ushort[MAX_VERTS * 6] elements;
+	RenderBuffers buffers;
 }
 
-extern fn void        renderer_getRenderState(Renderer*, RenderState*)                           @cname("RSGL_renderer_getRenderState");
-extern fn usz         renderer_size(Renderer*)                                                   @cname("RSGL_renderer_size");
-extern fn void        renderer_initPtr(RendererProc*, void*, void*, Renderer*)                   @cname("RSGL_renderer_initPtr");
-extern fn Renderer*   renderer_init(RendererProc, void*)                                         @cname("RSGL_renderer_init");
-extern fn void        renderer_updateSize(Renderer*, usz, usz)                                   @cname("RSGL_renderer_updateSize");
-extern fn void        renderer_freePtr(Renderer*)                                                @cname("RSGL_renderer_freePtr");
-extern fn void        renderer_setSurface(Renderer*, void*)                                      @cname("RSGL_renderer_setSurface");
-extern fn void        renderer_createBuffer(Renderer*, BufferType, usz, void*, usz*)             @cname("RSGL_renderer_createBuffer");
-extern fn void        renderer_updateBuffer(Renderer*, BufferType, usz, void*, usz, usz)         @cname("RSGL_renderer_updateBuffer");
-extern fn void        renderer_deleteBuffer(Renderer*, usz)                                      @cname("RSGL_renderer_deleteBuffer");
-extern fn void        renderer_createRenderBuffers(Renderer*, usz, RenderBuffers*)               @cname("RSGL_renderer_createRenderBuffers");
-extern fn void        renderer_deleteRenderBuffers(Renderer*, RenderBuffers*)                    @cname("RSGL_renderer_deleteRenderBuffers");
-extern fn void        renderer_render(Renderer*)                                                 @cname("RSGL_renderer_render");
-extern fn void        renderer_updateRenderBuffers(Renderer*)                                    @cname("RSGL_renderer_updateRenderbuffers");
-extern fn void        renderer_renderBuffers(Renderer*)                                          @cname("RSGL_renderer_renderBuffers");
-extern fn void        renderer_free(Renderer*)                                                   @cname("RSGL_renderer_free");
-extern fn void        renderer_setRotate(Renderer*, Vec3D)                                       @cname("RSGL_renderer_setRotate");
-extern fn void        renderer_setTexture(Renderer*, Texture)                                    @cname("RSGL_renderer_setTexture");
-extern fn void        renderer_setTextureSource(Renderer*, Texture, Rect)                        @cname("RSGL_renderer_setTextureSource");
-extern fn void        renderer_setColor(Renderer*, Color)                                        @cname("RSGL_renderer_setColor");
-extern fn void        renderer_setProgram(Renderer*, ProgramInfo*)                               @cname("RSGL_renderer_setProgram");
-extern fn void        renderer_setFramebuffer(Renderer*, Framebuffer)                            @cname("RSGL_renderer_setFramebuffer");
-extern fn void        renderer_setRenderBuffers(Renderer*, RenderBuffers*)                       @cname("RSGL_renderer_setRenderBuffers");
-extern fn void        renderer_setGradient(Renderer*, float*, usz)                               @cname("RSGL_renderer_setGradient");
-extern fn void        renderer_setCenter(Renderer*, Vec3D)                                       @cname("RSGL_renderer_setCenter");
-extern fn void        renderer_setOverflow(Renderer*, bool)                                      @cname("RSGL_renderer_setOverflow");
-extern fn void        renderer_clearArgs(Renderer*)                                              @cname("RSGL_renderer_clearArgs");
-extern fn Mat4        renderer_initDrawMatrix(Renderer*, Vec3D)                                  @cname("RSGL_renderer_initDrawMatrix");
-extern fn void        renderer_clear(Renderer*, Color)                                           @cname("RSGL_renderer_clear");
-extern fn void        renderer_viewport(Renderer*, Rect)                                         @cname("RSGL_renderer_viewport");
-extern fn Texture     renderer_createTexture(Renderer*, TextureBlob*)                            @cname("RSGL_renderer_createTexture");
-extern fn void        renderer_copyToTexture(Renderer*, Texture, usz, usz, TextureBlob*)         @cname("RSGL_renderer_copyToTexture");
-extern fn void        renderer_deleteTexture(Renderer*, Texture)                                 @cname("RSGL_renderer_deleteTexture");
-extern fn Framebuffer renderer_createFramebuffer(Renderer*, usz, usz)                            @cname("RSGL_renderer_createFramebuffer");
-extern fn void        renderer_attachFramebuffer(Renderer*, Framebuffer, Texture, char, char)    @cname("RSGL_renderer_attachFramebuffer");
-extern fn void        renderer_deleteFramebuffer(Renderer*, Framebuffer)                         @cname("RSGL_renderer_deleteFramebuffer");
-extern fn void        renderer_scissorStart(Renderer*, Rect, int)                                @cname("RSGL_renderer_scissorStart");
-extern fn void        renderer_scissorEnd(Renderer*)                                             @cname("RSGL_renderer_scissorEnd");
-extern fn ProgramBlob renderer_defaultBlob(Renderer*)                                            @cname("RSGL_renderer_defaultBlob");
-extern fn ProgramInfo renderer_createProgram(Renderer*, ProgramBlob*)                            @cname("RSGL_renderer_createProgram");
-extern fn void        renderer_deleteProgram(Renderer*, ProgramInfo*)                            @cname("RSGL_renderer_deleteProgram");
-extern fn usz         renderer_findShaderVariable(Renderer*, ProgramInfo*, ZString, usz)         @cname("RSGL_renderer_findShaderVariable");
-extern fn void        renderer_updateShaderVariable(Renderer*, ProgramInfo*, usz, float*, char)  @cname("RSGL_renderer_updateShaderVariable");
-extern fn void        renderer_forceBatch(Renderer*)                                             @cname("RSGL_renderer_forceBatch");
-extern fn void        renderer_setPerspectiveMatrix(Renderer*, Mat4)                             @cname("RSGL_renderer_setPerspectiveMatrix");
-extern fn void        renderer_setDefaultPerspectiveMatrix(Renderer*, Mat4)                      @cname("RSGL_renderer_setDefaultPerspectiveMatrix");
-extern fn void        renderer_setModelMatrix(Renderer*, Mat4)                                   @cname("RSGL_renderer_setModelMatrix");
-extern fn void        renderer_resetModelMatrix(Renderer*)                                       @cname("RSGL_renderer_resetModelMatrix");
-extern fn ProgramInfo renderer_createComputeProgram(Renderer*, ZString)                          @cname("RSGL_renderer_createComputeProgram");
-extern fn void        renderer_dispatchComputeProgram(Renderer*, ProgramInfo*, uint, uint, uint) @cname("RSGL_renderer_dispatchComputeProgram");
-extern fn void        renderer_bindComputeTexture(Renderer*, uint, char)                         @cname("RSGL_renderer_bindComputeTexture");
+extern fn void renderer_getRenderState(Renderer*, RenderState*) @cname("RSGL_renderer_getRenderState");
+extern fn usz renderer_size(Renderer*) @cname("RSGL_renderer_size");
+extern fn void renderer_initPtr(RendererProc*, void*, void*, Renderer*) @cname("RSGL_renderer_initPtr");
+extern fn Renderer* renderer_init(RendererProc, void*) @cname("RSGL_renderer_init");
+extern fn void renderer_updateSize(Renderer*, usz, usz) @cname("RSGL_renderer_updateSize");
+extern fn void renderer_freePtr(Renderer*) @cname("RSGL_renderer_freePtr");
+extern fn void renderer_setSurface(Renderer*, void*) @cname("RSGL_renderer_setSurface");
+extern fn void renderer_createBuffer(Renderer*, BufferType, usz, void*, usz*) @cname("RSGL_renderer_createBuffer");
+extern fn void renderer_updateBuffer(Renderer*, BufferType, usz, void*, usz, usz) @cname("RSGL_renderer_updateBuffer");
+extern fn void renderer_deleteBuffer(Renderer*, usz) @cname("RSGL_renderer_deleteBuffer");
+extern fn void renderer_createRenderBuffers(Renderer*, usz, RenderBuffers*) @cname("RSGL_renderer_createRenderBuffers");
+extern fn void renderer_deleteRenderBuffers(Renderer*, RenderBuffers*) @cname("RSGL_renderer_deleteRenderBuffers");
+extern fn void renderer_render(Renderer*) @cname("RSGL_renderer_render");
+extern fn void renderer_updateRenderBuffers(Renderer*) @cname("RSGL_renderer_updateRenderbuffers");
+extern fn void renderer_renderBuffers(Renderer*) @cname("RSGL_renderer_renderBuffers");
+extern fn void renderer_free(Renderer*) @cname("RSGL_renderer_free");
+extern fn void renderer_setRotate(Renderer*, Vec3D) @cname("RSGL_renderer_setRotate");
+extern fn void renderer_setTexture(Renderer*, Texture) @cname("RSGL_renderer_setTexture");
+extern fn void renderer_setTextureSource(Renderer*, Texture, Rect) @cname("RSGL_renderer_setTextureSource");
+extern fn void renderer_setColor(Renderer*, Color) @cname("RSGL_renderer_setColor");
+extern fn void renderer_setProgram(Renderer*, ProgramInfo*) @cname("RSGL_renderer_setProgram");
+extern fn void renderer_setFramebuffer(Renderer*, Framebuffer) @cname("RSGL_renderer_setFramebuffer");
+extern fn void renderer_setRenderBuffers(Renderer*, RenderBuffers*) @cname("RSGL_renderer_setRenderBuffers");
+extern fn void renderer_setGradient(Renderer*, float*, usz) @cname("RSGL_renderer_setGradient");
+extern fn void renderer_setCenter(Renderer*, Vec3D) @cname("RSGL_renderer_setCenter");
+extern fn void renderer_setOverflow(Renderer*, bool) @cname("RSGL_renderer_setOverflow");
+extern fn void renderer_clearArgs(Renderer*) @cname("RSGL_renderer_clearArgs");
+extern fn Mat4 renderer_initDrawMatrix(Renderer*, Vec3D) @cname("RSGL_renderer_initDrawMatrix");
+extern fn void renderer_clear(Renderer*, Color) @cname("RSGL_renderer_clear");
+extern fn void renderer_viewport(Renderer*, Rect) @cname("RSGL_renderer_viewport");
+extern fn Texture renderer_createTexture(Renderer*, TextureBlob*) @cname("RSGL_renderer_createTexture");
+extern fn void renderer_copyToTexture(Renderer*, Texture, usz, usz, TextureBlob*) @cname("RSGL_renderer_copyToTexture");
+extern fn void renderer_deleteTexture(Renderer*, Texture) @cname("RSGL_renderer_deleteTexture");
+extern fn Framebuffer renderer_createFramebuffer(Renderer*, usz, usz) @cname("RSGL_renderer_createFramebuffer");
+extern fn void renderer_attachFramebuffer(
+	Renderer*,
+	Framebuffer,
+	Texture,
+	char,
+	char
+) @cname("RSGL_renderer_attachFramebuffer");
+extern fn void renderer_deleteFramebuffer(Renderer*, Framebuffer) @cname("RSGL_renderer_deleteFramebuffer");
+extern fn void renderer_scissorStart(Renderer*, Rect, int) @cname("RSGL_renderer_scissorStart");
+extern fn void renderer_scissorEnd(Renderer*) @cname("RSGL_renderer_scissorEnd");
+extern fn ProgramBlob renderer_defaultBlob(Renderer*) @cname("RSGL_renderer_defaultBlob");
+extern fn ProgramInfo renderer_createProgram(Renderer*, ProgramBlob*) @cname("RSGL_renderer_createProgram");
+extern fn void renderer_deleteProgram(Renderer*, ProgramInfo*) @cname("RSGL_renderer_deleteProgram");
+extern fn usz renderer_findShaderVariable(
+	Renderer*,
+	ProgramInfo*,
+	ZString,
+	usz
+) @cname("RSGL_renderer_findShaderVariable");
+extern fn void renderer_updateShaderVariable(
+	Renderer*,
+	ProgramInfo*,
+	usz,
+	float*,
+	char
+) @cname("RSGL_renderer_updateShaderVariable");
+extern fn void renderer_forceBatch(Renderer*) @cname("RSGL_renderer_forceBatch");
+extern fn void renderer_setPerspectiveMatrix(Renderer*, Mat4) @cname("RSGL_renderer_setPerspectiveMatrix");
+extern fn void renderer_setDefaultPerspectiveMatrix(
+	Renderer*,
+	Mat4
+) @cname("RSGL_renderer_setDefaultPerspectiveMatrix");
+extern fn void renderer_setModelMatrix(Renderer*, Mat4) @cname("RSGL_renderer_setModelMatrix");
+extern fn void renderer_resetModelMatrix(Renderer*) @cname("RSGL_renderer_resetModelMatrix");
+extern fn ProgramInfo renderer_createComputeProgram(Renderer*, ZString) @cname("RSGL_renderer_createComputeProgram");
+extern fn void renderer_dispatchComputeProgram(
+	Renderer*,
+	ProgramInfo*,
+	uint,
+	uint,
+	uint
+) @cname("RSGL_renderer_dispatchComputeProgram");
+extern fn void renderer_bindComputeTexture(Renderer*, uint, char) @cname("RSGL_renderer_bindComputeTexture");
 
 constdef DrawType
 {
-  TRIANGLES = 0,
-  POINTS    = 1,
-  LINES     = 2,
+	TRIANGLES = 0,
+	POINTS    = 1,
+	LINES     = 2,
 }
 
 struct RawVerts
 {
-  DrawType type;
-  float*   verts;
-  float*   texCoords;
-  ushort*  elements;
-  usz      elmCount;
-  usz      vert_count;
+	DrawType type;
+	float* verts;
+	float* texCoords;
+	ushort* elements;
+	usz elmCount;
+	usz vert_count;
 }
 
 extern fn int drawRawVerts(Renderer*, RawVerts*) @cname("RSGL_drawRawVerts");
 
-extern fn int drawPoint(Renderer*, Vec2D)                        @cname("RSGL_drawPoint")            @if($feature(HIGHLEVEL));
-extern fn int drawRect(Renderer*, Rect)                          @cname("RSGL_drawRect")             @if($feature(HIGHLEVEL));
-extern fn int drawRoundRect(Renderer*, Rect, Vec2D)              @cname("RSGL_drawRoundRect")        @if($feature(HIGHLEVEL));
-extern fn int drawPolygon(Renderer*, Rect, uint)                 @cname("RSGL_drawPolygon")          @if($feature(HIGHLEVEL));
-extern fn int drawArc(Renderer*, Rect, Vec2D)                    @cname("RSGL_drawArc")              @if($feature(HIGHLEVEL));
-extern fn int drawOval(Renderer*, Rect)                          @cname("RSGL_drawOval")             @if($feature(HIGHLEVEL));
-extern fn int drawLine(Renderer*, Vec2D, Vec2D, uint)            @cname("RSGL_drawLine")             @if($feature(HIGHLEVEL));
-extern fn int drawTriangle(Renderer*, Vec3D[3])                  @cname("RSGL_drawTriangle")         @if($feature(HIGHLEVEL));
-extern fn int drawPoint3D(Renderer*, Vec3D)                      @cname("RSGL_drawPoint3D")          @if($feature(HIGHLEVEL));
-extern fn int drawLine3D(Renderer*, Vec3D, Vec3D, uint)          @cname("RSGL_drawLine3D")           @if($feature(HIGHLEVEL));
-extern fn int drawCube(Renderer*, Cube)                          @cname("RSGL_drawCube")             @if($feature(HIGHLEVEL));
-extern fn int drawTriangleOutline(Renderer*, Vec3D[3], uint)     @cname("RSGL_drawTriangleOutline")  @if($feature(HIGHLEVEL));
-extern fn int drawRectOutline(Renderer*, Rect, uint)             @cname("RSGL_drawRectOutline")      @if($feature(HIGHLEVEL));
-extern fn int drawRoundRectOutline(Renderer*, Rect, Vec2D, uint) @cname("RSGL_drawRoundRectOutline") @if($feature(HIGHLEVEL));
-extern fn int drawPolygonOutline(Renderer*, Rect, uint, uint)    @cname("RSGL_drawPolygonOutline")   @if($feature(HIGHLEVEL));
-extern fn int drawArcOutline(Renderer*, Rect, Vec2D, uint)       @cname("RSGL_drawArcOutline")       @if($feature(HIGHLEVEL));
-extern fn int drawOvalOutline(Renderer*, Rect, uint)             @cname("RSGL_drawovalOutline")      @if($feature(HIGHLEVEL));
+extern fn int drawPoint(Renderer*, Vec2D) @cname("RSGL_drawPoint") @if($feature(HIGHLEVEL));
+extern fn int drawRect(Renderer*, Rect) @cname("RSGL_drawRect") @if($feature(HIGHLEVEL));
+extern fn int drawRoundRect(Renderer*, Rect, Vec2D) @cname("RSGL_drawRoundRect") @if($feature(HIGHLEVEL));
+extern fn int drawPolygon(Renderer*, Rect, uint) @cname("RSGL_drawPolygon") @if($feature(HIGHLEVEL));
+extern fn int drawArc(Renderer*, Rect, Vec2D) @cname("RSGL_drawArc") @if($feature(HIGHLEVEL));
+extern fn int drawOval(Renderer*, Rect) @cname("RSGL_drawOval") @if($feature(HIGHLEVEL));
+extern fn int drawLine(Renderer*, Vec2D, Vec2D, uint) @cname("RSGL_drawLine") @if($feature(HIGHLEVEL));
+extern fn int drawTriangle(Renderer*, Vec3D[3]) @cname("RSGL_drawTriangle") @if($feature(HIGHLEVEL));
+extern fn int drawPoint3D(Renderer*, Vec3D) @cname("RSGL_drawPoint3D") @if($feature(HIGHLEVEL));
+extern fn int drawLine3D(Renderer*, Vec3D, Vec3D, uint) @cname("RSGL_drawLine3D") @if($feature(HIGHLEVEL));
+extern fn int drawCube(Renderer*, Cube) @cname("RSGL_drawCube") @if($feature(HIGHLEVEL));
+extern fn int drawTriangleOutline(
+	Renderer*,
+	Vec3D[3],
+	uint
+) @cname("RSGL_drawTriangleOutline") @if($feature(HIGHLEVEL));
+extern fn int drawRectOutline(Renderer*, Rect, uint) @cname("RSGL_drawRectOutline") @if($feature(HIGHLEVEL));
+extern fn int drawRoundRectOutline(
+	Renderer*,
+	Rect,
+	Vec2D,
+	uint
+) @cname("RSGL_drawRoundRectOutline") @if($feature(HIGHLEVEL));
+extern fn int drawPolygonOutline(
+	Renderer*,
+	Rect,
+	uint,
+	uint
+) @cname("RSGL_drawPolygonOutline") @if($feature(HIGHLEVEL));
+extern fn int drawArcOutline(Renderer*, Rect, Vec2D, uint) @cname("RSGL_drawArcOutline") @if($feature(HIGHLEVEL));
+extern fn int drawOvalOutline(Renderer*, Rect, uint) @cname("RSGL_drawovalOutline") @if($feature(HIGHLEVEL));
 
 constdef ViewType @if($feature(HIGHLEVEL))
 {
-  NONE = 0,
-  TWO_D,
-  THREE_D,
+	NONE = 0,
+	TWO_D,
+	THREE_D,
 }
 
 struct View2D @if($feature(HIGHLEVEL))
 {
-  ViewType type;
-  Vec3D    offset;
-  Vec3D    target;
-  float    rotation;
-  float    zoom;
+	ViewType type;
+	Vec3D offset;
+	Vec3D target;
+	float rotation;
+	float zoom;
 }
 
 struct View3D @if($feature(HIGHLEVEL))
 {
-  ViewType type;
-  Vec3D    pos;
-  Vec3D    target;
-  Vec3D    up;
+	ViewType type;
+	Vec3D pos;
+	Vec3D target;
+	Vec3D up;
 }
 
 union View @if($feature(HIGHLEVEL))
 {
-  ViewType type;
-  View2D   view2D;
-  View3D   view3D;
+	ViewType type;
+	View2D view2D;
+	View3D view3D;
 }
 
 extern fn Mat4 view_getMatrix(View*) @cname("RSGL_view_getMatrix") @if($feature(HIGHLEVEL));
@@ -448,16 +530,16 @@ module rsgl::gl @if($feature(OPENGL));
 
 struct GlRenderer
 {
-  uint vao;
+	uint vao;
 }
 
 extern fn RendererProc rendererProc() @cname("RSGL_GL_rendererProc");
-extern fn usz          size()         @cname("RSGL_GL_size");
+extern fn usz size() @cname("RSGL_GL_size");
 
 module rsgl::rfont @if($feature(RFONT));
 import rfont;
 
-extern fn rfont::Renderer_proc renderer_proc()                                     @cname("RFont_RSGL_renderer_proc");
-extern fn rfont::Renderer*     renderer_init(rsgl::Renderer*)                      @cname("RFont_RSGL_renderer_init");
-extern fn void                 renderer_initPtr(rsgl::Renderer*, rfont::Renderer*) @cname("RFont_RSGL_renderer_initPtr");
-extern fn void                 renderer_free(rfont::Renderer*)                     @cname("RFont_RSGL_renderer_free");
+extern fn rfont::Renderer_proc renderer_proc() @cname("RFont_RSGL_renderer_proc");
+extern fn rfont::Renderer* renderer_init(rsgl::Renderer*) @cname("RFont_RSGL_renderer_init");
+extern fn void renderer_initPtr(rsgl::Renderer*, rfont::Renderer*) @cname("RFont_RSGL_renderer_initPtr");
+extern fn void renderer_free(rfont::Renderer*) @cname("RFont_RSGL_renderer_free");
\ No newline at end of file