/* * * 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. * * 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 . * */ module rsgl; import rfont; 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, } constdef TextureDataType { INT = 0, FLOAT, } constdef TextureFilter { NEAREST = 0, LINEAR, } struct TextureBlob { void* data; usz width; usz height; TextureDataType dataType; TextureFormat dataFormat; TextureFormat textureFormat; TextureFilter minFilter; TextureFilter magFilter; } alias Texture = usz; alias Framebuffer = usz; struct Rect { float x; float y; float w; float h; } struct Cube { float x; float y; float z; float w; float l; float h; } struct Vec2D { float x; float y; } struct Vec3D { float x; float y; float z; } struct Color { 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"); constdef ProjectionType { ORTHO_2D = 0, ORTHO_3D, PERSPECTIVE_3D, } struct Projection2D { ProjectionType type; uint width; uint height; } struct Projection3D { ProjectionType type; float fov; float ratio; float pNear; float pFar; } union Projection { 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, } struct ProgramBlob { ZString vertex; usz vertexLen; ZString fragment; usz fragmentLen; } struct ProgramInfo { 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; } struct RenderData { 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, } struct RenderBuffers { 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; } struct RenderPass { 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); 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; } 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; } 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, } struct RawVerts { DrawType type; float* verts; float* texCoords; ushort* elements; usz elmCount; usz vert_count; } extern fn int drawRawVerts(Renderer*, RawVerts*) @cname("RSGL_drawRawVerts"); extern fn rfont::Renderer_proc rfont_renderer_proc() @cname("RFont_RSGL_renderer_proc") @if($feature(RFONT)); extern fn rfont::Renderer* rfont_renderer_init(Renderer*) @cname("RFont_RSGL_renderer_init") @if($feature(RFONT)); extern fn void rfont_renderer_initPtr(Renderer*, rfont::Renderer*) @cname("RFont_RSGL_renderer_initPtr") @if($feature(RFONT)); extern fn void rfont_renderer_free(rfont::Renderer*) @cname("RFont_RSGL_renderer_free") @if($feature(RFONT)); 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, } struct View2D @if($feature(HIGHLEVEL)) { ViewType type; Vec3D offset; Vec3D target; float rotation; float zoom; } struct View3D @if($feature(HIGHLEVEL)) { ViewType type; Vec3D pos; Vec3D target; Vec3D up; } union View @if($feature(HIGHLEVEL)) { ViewType type; View2D view2D; View3D view3D; } extern fn Mat4 view_getMatrix(View*) @cname("RSGL_view_getMatrix") @if($feature(HIGHLEVEL)); module rsgl::gl @if($feature(OPENGL)); struct GlRenderer { uint vao; } extern fn RendererProc rendererProc() @cname("RSGL_GL_rendererProc"); extern fn usz size() @cname("RSGL_GL_size");