finish x86_64-linux Wayland bindings for rfont, rgfw, rsgl :)

1 files changed, 410 insertions, 44 deletions

diff --git a/rsgl.c3 b/rsgl.c3
index 08459df..990db87 100644
--- a/rsgl.c3
+++ b/rsgl.c3
@@ -1,19 +1,162 @@
+/*
+*
+* 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 <https://www.gnu.org/licenses/>.
+*
+*/
+
 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));}
 
-alias Renderer = void;
-alias RenderPass = void;
-alias TextureBlob = void;
+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;
-alias Texture = usz;
 
-enum BufferType
+struct Rect
 {
-  ARRAY_BUFFER,
-  ELEMENT_ARRAY_BUFFER,
-  SHADER_STORAGE_BUFFER,
-  TEXTURE_BUFFER,
-  UNIFORM_BUFFER,
+  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
@@ -26,40 +169,112 @@ struct ProgramBlob
 
 struct ProgramInfo
 {
-  usz program;
-  usz perspectiveView;
-  usz model;
-  usz vertexPosition;
-  usz vertexTexCoord;
-  usz vertexColor;
+  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;
 }
 
-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);
+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
 {
@@ -91,5 +306,156 @@ struct RendererProc
   RendererProc_deleteFramebuffer      deleteFramebuffer;
 }
 
-extern fn Renderer*    renderer_init(RendererProc, void*) @cname("RSGL_renderer_init");
-extern fn RendererProc gl_rendererProc()                  @cname("RSGL_GL_rendererProc");
+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");