nicer interfaceHEADmaster

1 files changed, 411 insertions, 0 deletions

diff --git a/rsgl.zig b/rsgl.zig
new file mode 100644
index 0000000..ccd05bb
--- /dev/null
+++ b/rsgl.zig
@@ -0,0 +1,411 @@
+const __root = @This();
+const raw = @import("rsgl_raw");
+const zeroes = @import("std").mem.zeroes;
+const MAX_BATCHES = 2028;
+const MAX_VERTS = 8192;
+
+pub const textureFormat = enum(c_uint) {
+  none      = raw.RSGL_formatNone,
+  RGB       = raw.RSGL_formatRGB,
+  BGR       = raw.RSGL_formatBGR,
+  RGBA      = raw.RSGL_formatRGBA,
+  BGRA      = raw.RSGL_formatBGRA,
+  red       = raw.RSGL_formatRed,
+  grayscale = raw.RSGL_formatGrayscale,
+};
+
+pub const textureDataType = enum(c_uint) {
+  int   = raw.RSGL_textureDataInt,
+  float = raw.RSGL_textureDataFloat,
+};
+
+pub const textureFilter = enum(c_uint) {
+  nearest = raw.RSGL_textureFilterNearest,
+  linear  = raw.RSGL_textureFilterLinear,
+};
+
+pub const textureBlob = extern struct {
+  data:          ?*anyopaque     = null,
+  width:         usize           = 0,
+  height:        usize           = 0,
+  dataType:      textureDataType = zeroes(textureDataType),
+  dataFormat:    textureFormat   = zeroes(textureFormat),
+  textureFormat: textureFormat   = zeroes(textureFormat),
+  minFilter:     textureFilter   = zeroes(textureFilter),
+  magFilter:     textureFilter   = zeroes(textureFilter),
+};
+
+pub const rect = raw.RSGL_rect;
+pub const cube = raw.RSGL_cube;
+pub const vec2 = raw.RSGL_vec2D;
+pub const vec3 = raw.RSGL_vec3D;
+pub const color = raw.RSGL_color;
+pub const mat4  = extern struct {
+  m: [16]f32 = zeroes([16]f32),
+  pub fn loadIdentity() mat4 {return RSGL_mat4_loadIdentity();}
+  pub fn scale(self: *mat4, x: f32, y: f32, z: f32) void {self.* = RSGL_mat4_scale(self.m, x, y, z);}
+  pub fn rotate(self: *mat4, angle: f32, x: f32, y: f32, z: f32) void {self.* = RSGL_mat4_rotate(self.m, angle, x, y, z);}
+  pub fn translate(self: *mat4, x: f32, y: f32, z: f32) void {self.* = RSGL_mat4_translate(self.m, x, y, z);}
+  pub fn perspective(self: *mat4, fovY: f32, aspect: f32, znear: f32, zfar: f32) void {self.* = RSGL_mat4_perspective(self.m, fovY, aspect, znear, zfar);}
+  pub fn ortho(self: *mat4, left: f32, right: f32, bottom: f32, top: f32, znear: f32, zfar: f32) void {self.* = RSGL_mat4_ortho(self.m, left, right, bottom, top, znear, zfar);}
+  pub fn lookAt(self: *mat4, eyeX: f32, eyeY: f32, eyeZ: f32, targetX: f32, targetY: f32, targetZ: f32, upX: f32, upY: f32, upZ: f32) void {self.* = RSGL_mat4_lookAt(self.m, eyeX, eyeY, eyeZ, targetX, targetY, targetZ, upX, upY, upZ);}
+  pub fn multiply(self: *mat4, right: *mat4) void {self.* = RSGL_mat4_multiply(self.m, right.m);}
+  pub fn multiplyPoint(self: mat4, point: vec3) vec3 {return RSGL_mat4_multiplyPoint(self, point);}
+};
+extern fn RSGL_mat4_loadIdentity() mat4;
+extern fn RSGL_mat4_scale(matrix: [*]f32, x: f32, y: f32, z: f32) mat4;
+extern fn RSGL_mat4_rotate(matrix: [*]f32, angle: f32, x: f32, y: f32, z: f32) mat4;
+extern fn RSGL_mat4_translate(matrix: [*]f32, x: f32, y: f32, z: f32) mat4;
+extern fn RSGL_mat4_perspective(matrix: [*]f32, fovY: f32, aspect: f32, zNear: f32, zFar: f32) mat4;
+extern fn RSGL_mat4_ortho(matrix: [*]f32, left: f32, right: f32, bottom: f32, top: f32, znear: f32, zfar: f32) mat4;
+extern fn RSGL_mat4_lookAt(matrix: [*]f32, eyeX: f32, eyeY: f32, eyeZ: f32, targetX: f32, targetY: f32, targetZ: f32, upX: f32, upY: f32, upZ: f32) mat4;
+extern fn RSGL_mat4_multiply(left: [*]f32, right: [*]f32) mat4;
+extern fn RSGL_mat4_multiplyPoint(matrix: mat4, point: vec3) vec3;
+
+pub const projectionType = enum(c_uint) {
+  ortho2       = raw.RSGL_projectionOrtho2D,
+  ortho3       = raw.RSGL_projectionOrtho3D,
+  perspective3 = raw.RSGL_projectionPerspective3D,
+};
+
+pub const projection2 = extern struct {
+  type:   projectionType = zeroes(projectionType),
+  width:  u32            = 0,
+  height: u32            = 0,
+};
+
+pub const projection3 = extern struct {
+  type:  projectionType = zeroes(projectionType),
+  fov:   f32            = 0,
+  ratio: f32            = 0,
+  pNear: f32            = 0,
+  pFar:  f32            = 0,
+};
+
+pub const projection = extern union {
+  type: projectionType,
+  p2:   projection2,
+  p3:   projection3,
+  pub fn matrix(self: *const projection) mat4 {return RSGL_projection_getMatrix(self);}
+};
+extern fn RSGL_projection_getMatrix(projection: [*c]const projection) mat4;
+
+pub const shaderType = enum(c_uint) {
+  none     = raw.RSGL_shaderTypeNone,
+  standard = raw.RSGL_shaderTypeStandard,
+  compute  = raw.RSGL_shaderTypeCompute,
+  geometry = raw.RSGL_shaderTypeGeometry,
+};
+
+pub const programBlob = extern struct {
+  vertex:      ?[*]const u8 = null,
+  vertexLen:   usize        = 0,
+  fragment:    ?[*]const u8 = null,
+  fragmentLen: usize        = 0,
+};
+
+pub const programInfo = extern struct {
+  program:         usize      = 0,
+  perspectiveView: usize      = 0,
+  model:           usize      = 0,
+  vertexPosition:  usize      = 0,
+  vertexTexCoord:  usize      = 0,
+  vertexColor:     usize      = 0,
+  type:            shaderType = zeroes(shaderType),
+};
+
+pub const batch = extern struct {
+  start:     usize = 0,
+  len:       usize = 0,
+  elmStart:  usize = 0,
+  elmCount:  usize = 0,
+  type:      u32   = 0,
+  tex:       usize = 0,
+  lineWidth: f32   = 0,
+  matrix:    mat4  = zeroes(mat4),
+};
+
+pub const renderData = extern struct {
+    verts:          ?[*]f32 = null,
+    texCoords:      ?[*]f32 = null,
+    colors:         ?[*]f32 = null,
+    elements:       ?[*]u16 = null,
+    elements_count: usize   = 0,
+    len:            usize   = 0,
+    perspective:    mat4    = zeroes(mat4),
+};
+
+pub const bufferType = enum(@TypeOf(raw.RSGL_bufferType)) {
+  array         = raw.RSGL_arrayBuffer,
+  elementArray  = raw.RSGL_elementArrayBuffer,
+  shaderStorage = raw.RSGL_shaderStorageBuffer,
+  texture       = raw.RSGL_textureBuffer,
+  uniform       = raw.RSGL_uniformBuffer,
+};
+
+pub const renderBuffers = extern struct {
+  vertex:     usize              = 0,
+  color:      usize              = 0,
+  texture:    usize              = 0,
+  elements:   usize              = 0,
+  maxVerts:   usize              = 0,
+  batches:    [MAX_BATCHES]batch = zeroes([MAX_BATCHES]batch),
+  batchCount: usize              = 0,
+};
+
+pub const renderState = extern struct {
+  gradient:          ?[*]f32           = null,
+  source:            rect              = zeroes(rect),
+  texture:           usize             = 0,
+  gradient_len:      u32               = 0,
+  color:             color             = zeroes(color),
+  rotate:            vec3              = zeroes(vec3),
+  program:           ?*programInfo     = null,
+  buffers:           ?[*]renderBuffers = null,
+  center:            vec3              = zeroes(vec3),
+  lineWidth:         f32               = 0,
+  modelMatrix:       mat4              = zeroes(mat4),
+  viewMatrix:        mat4              = zeroes(mat4),
+  perspectiveMatrix: mat4              = zeroes(mat4),
+  forceBatch:        bool              = false,
+  overflow:          bool              = false,
+  framebuffer:       usize             = 0,
+};
+
+pub const renderPass = extern struct {
+  program:     ?*programInfo     = null,
+  matrix:      ?[*]f32           = null,
+  buffers:     ?[*]renderBuffers = null,
+  framebuffer: usize             = 0,
+};
+
+pub const rendererProc = extern struct {
+  size:                   ?*const fn () callconv(.c) usize = null,
+  defaultBlob:            ?*const fn (ctx: ?*anyopaque) callconv(.c) programBlob = null,
+  initPtrCallback:        ?*const fn (ctx: ?*anyopaque, proc: ?*anyopaque) callconv(.c) void = null,
+  freePtr:                ?*const fn (ctx: ?*anyopaque) callconv(.c) void = null,
+  render:                 ?*const fn (ctx: ?*anyopaque, pass: *const renderPass) callconv(.c) void = null,
+  clear:                  ?*const fn (ctx: ?*anyopaque, framebuffer: usize, r: f32, g: f32, b: f32, a: f32) callconv(.c) void = null,
+  viewport:               ?*const fn (ctx: ?*anyopaque, x: i32, y: i32, w: i32, h: i32) callconv(.c) void = null,
+  setSurface:             ?*const fn (ctx: ?*anyopaque, surface: ?*anyopaque) callconv(.c) void = null,
+  createTexture:          ?*const fn (ctx: ?*anyopaque, blob: *const textureBlob) callconv(.c) usize = null,
+  copyToTexture:          ?*const fn (ctx: ?*anyopaque, texture: usize, x: usize, y: usize, blob: *const textureBlob) callconv(.c) void = null,
+  deleteTexture:          ?*const fn (ctx: ?*anyopaque, tex: usize) callconv(.c) void = null,
+  scissorStart:           ?*const fn (ctx: ?*anyopaque, x: f32, y: f32, w: f32, h: f32, renderer_height: f32) callconv(.c) void = null,
+  scissorEnd:             ?*const fn (ctx: ?*anyopaque) callconv(.c) void = null,
+  createProgram:          ?*const fn (ctx: ?*anyopaque, blob: *programBlob) callconv(.c) programInfo = null,
+  deleteProgram:          ?*const fn (ctx: ?*anyopaque, program: *const programInfo) callconv(.c) void = null,
+  findShaderVariable:     ?*const fn (?*anyopaque, *const programInfo, [*]const u8, usize) callconv(.c) usize = null,
+  updateShaderVariable:   ?*const fn (?*anyopaque, *const programInfo, usize, [*]const f32, u8) callconv(.c) void = null,
+  createComputeProgram:   ?*const fn (ctx: ?*anyopaque, CShaderCode: [*]const u8) callconv(.c) programInfo = null,
+  dispatchComputeProgram: ?*const fn (ctx: ?*anyopaque, program: *const programInfo, groups_x: u32, groups_y: u32, groups_z: u32) callconv(.c) void = null,
+  bindComputeTexture:     ?*const fn (ctx: ?*anyopaque, texture: u32, format: u8) callconv(.c) void = null,
+  createBuffer:           ?*const fn (ctx: ?*anyopaque, @"type": bufferType, size: usize, data: ?*const anyopaque, buffer: [*]usize) callconv(.c) void = null,
+  updateBuffer:           ?*const fn (ctx: ?*anyopaque, @"type": bufferType, buffer: usize, data: ?*anyopaque, start: usize, len: usize) callconv(.c) void = null,
+  deleteBuffer:           ?*const fn (ctx: ?*anyopaque, buffer: usize) callconv(.c) void = null,
+  createFramebuffer:      ?*const fn (ctx: ?*anyopaque, width: usize, height: usize) callconv(.c) usize = null,
+  attachFramebuffer:      ?*const fn (ctx: ?*anyopaque, fbo: usize, tex: usize, attachType: u8, mipLevel: u8) callconv(.c) void = null,
+  deleteFramebuffer:      ?*const fn (ctx: ?*anyopaque, fbo: usize) callconv(.c) void = null,
+  pub fn initPtr(self: rendererProc, loader: ?*anyopaque, ptr: ?*anyopaque, r: *renderer) void {r = RSGL_renderer_initPtr(self, loader, ptr, r);}
+  pub fn init(self: rendererProc, loader: ?*anyopaque) *renderer {return RSGL_renderer_init(self, loader);}
+};
+extern fn RSGL_renderer_initPtr(proc: rendererProc, loader: ?*anyopaque, ptr: ?*anyopaque, renderer: *renderer) void;
+extern fn RSGL_renderer_init(proc: rendererProc, loader: ?*anyopaque) *renderer;
+
+pub const renderer = extern struct {
+  data:                     renderData = zeroes(renderData),
+  state:                    renderState = zeroes(renderState),
+  proc:                     rendererProc =zeroes(rendererProc),
+  userPtr:                  ?*anyopaque = null,
+  ctx:                      ?*anyopaque = null,
+  defaultTexture:           usize = 0,
+  defaultProgram:           programInfo = zeroes(programInfo),
+  defaultPerspectiveMatrix: mat4 = zeroes(mat4),
+  verts:                    [MAX_VERTS * 3]f32 = zeroes([MAX_VERTS * 3]f32),
+  texCoords:                [MAX_VERTS * 2]f32 = zeroes([MAX_VERTS * 2]f32),
+  colors:                   [MAX_VERTS * 4]f32 = zeroes([MAX_VERTS * 4]f32),
+  elements:                 [MAX_VERTS * 6]u16 = zeroes([MAX_VERTS * 6]u16),
+  buffers:                  renderBuffers = zeroes(renderBuffers),
+  pub fn getRenderState(self: *renderer, state: *renderState) void {RSGL_renderer_getRenderState(self, state);}
+  pub fn size(self: *renderer) usize {return RSGL_renderer_size(self);}
+  pub fn updateSize(self: *renderer, width: usize, height: usize) void {RSGL_renderer_updateSize(self, width, height);}
+  pub fn freePtr(self: *renderer) void {RSGL_renderer_freePtr(self);}
+  pub fn setSurface(self: *renderer, surface: ?*anyopaque) void {RSGL_renderer_setSurface(self, surface);}
+  pub fn createBuffer(self: *renderer, @"type": bufferType, sz: usize, data: ?*const anyopaque, buffer: [*]usize) void {RSGL_renderer_createBuffer(self, @"type", sz, data, buffer);}
+  pub fn updateBuffer(self: *renderer, @"type": bufferType, buffer: usize, data: ?*anyopaque, start: usize, len: usize) void {RSGL_renderer_updateBuffer(self, @"type", buffer, data, start, len);}
+  pub fn deleteBuffer(self: *renderer, buffer: usize) void {RSGL_renderer_deleteBuffer(self, buffer);}
+  pub fn createRenderBuffers(self: *renderer, sz: usize, buffers: *renderBuffers) void {RSGL_renderer_createRenderBuffers(self, sz, buffers);}
+  pub fn deleteRenderBuffers(self: *renderer, buffers: *renderBuffers) void {RSGL_renderer_deleteRenderBuffers(self, buffers);}
+  pub fn render(self: *renderer) void {RSGL_renderer_render(self);}
+  pub fn updateRenderBuffers(self: *renderer) void {RSGL_renderer_updateRenderBuffers(self);}
+  pub fn renderBuffers_(self: *renderer) void {RSGL_renderer_renderBuffers(self);}
+  pub fn free(self: *renderer) void {RSGL_renderer_free(self);}
+  pub fn setRotate(self: *renderer, rotate: vec3) void {RSGL_renderer_setRotate(self, rotate);}
+  pub fn setTexture(self: *renderer, texture: usize) void {RSGL_renderer_setTexture(self, texture);}
+  pub fn setTextureSource(self: *renderer, texture: usize, r: rect) void {RSGL_renderer_setTextureSource(self, texture, r);}
+  pub fn setColor(self: *renderer, c: color) void {RSGL_renderer_setColor(self, c);}
+  pub fn setProgram(self: *renderer, program: *programInfo) void {RSGL_renderer_setProgram(self, program);}
+  pub fn setFramebuffer(self: *renderer, framebuffer: usize) void {RSGL_renderer_setFramebuffer(self, framebuffer);}
+  pub fn setRenderBuffers(self: *renderer, buffers: *renderBuffers) void {RSGL_renderer_setRenderBuffers(self, buffers);}
+  pub fn setGradient(self: *renderer, gradient: [*]f32, len: usize) void {RSGL_renderer_setGradient(self, gradient, len);}
+  pub fn setCenter(self: *renderer, center: vec3) void {RSGL_renderer_setCenter(self, center);}
+  pub fn setOverflow(self: *renderer, overflow: bool) void {RSGL_renderer_setOverflow(self, overflow);}
+  pub fn clearArgs(self: *renderer) void {RSGL_renderer_clearArgs(self);}
+  pub fn initDrawMatrix(self: *renderer, center: vec3) mat4 {return RSGL_renderer_initDrawMatrix(self, center);}
+  pub fn clear(self: *renderer, c: color) void {RSGL_renderer_clear(self, c);}
+  pub fn viewport(self: *renderer, r: rect) void {RSGL_renderer_viewport(self, r);}
+  pub fn createTexture(self: *renderer, blob: *const textureBlob) usize {return RSGL_renderer_createTexture(self, blob);}
+  pub fn copyToTexture(self: *renderer, texture: usize, x: usize, y: usize, blob: *const textureBlob) void {RSGL_renderer_copyToTexture(self, texture, x, y, blob);}
+  pub fn deleteTexture(self: *renderer, tex: usize) void {RSGL_renderer_deleteTexture(self, tex);}
+  pub fn createFramebuffer(self: *renderer, width: usize, height: usize) usize {return RSGL_renderer_createFramebuffer(self, width, height);}
+  pub fn attachFramebuffer(self: *renderer, fbo: usize, tex: usize, attachType: u8, mipLevel: u8) void {RSGL_renderer_attachFramebuffer(self, fbo, tex, attachType, mipLevel);}
+  pub fn deleteFramebuffer(self: *renderer, fbo: usize) void {RSGL_renderer_deleteFramebuffer(self, fbo);}
+  pub fn scissorStart(self: *renderer, scissor: rect, height: i32) void {RSGL_renderer_scissorStart(self, scissor, height);}
+  pub fn scissorEnd(self: *renderer) void {RSGL_renderer_scissorEnd(self);}
+  pub fn defaultBlob(self: *renderer) programBlob {return RSGL_renderer_defaultBlob(self);}
+  pub fn createProgram(self: *renderer, blob: *programBlob) programInfo {return RSGL_renderer_createProgram(self, blob);}
+  pub fn deleteProgram(self: *renderer, program: *const programInfo) void {RSGL_renderer_deleteProgram(self, program);}
+  pub fn findShaderVariable(self: *renderer, program: *const programInfo, @"var": *const u8, len: usize) usize {return RSGL_renderer_findShaderVariable(self, program, @"var", len);}
+  pub fn updateShaderVariable(self: *renderer, program: *const programInfo, @"var": usize, value: *const f32, len: u8) void {RSGL_renderer_updateShaderVariable(self, program, @"var", value, len);}
+  pub fn forceBatch(self: *renderer) void {RSGL_renderer_forceBatch(self);}
+  pub fn setPerspectiveMatrix(self: *renderer, matrix: mat4) void {RSGL_renderer_setPerspectiveMatrix(self, matrix);}
+  pub fn setDefaultPerspectiveMatrix(self: *renderer, matrix: mat4) void {RSGL_renderer_setDefaultPerspectiveMatrix(self, matrix);}
+  pub fn setModelMatrix(self: *renderer, matrix: mat4) void {RSGL_renderer_setModelMatrix(self, matrix);}
+  pub fn resetModelMatrix(self: *renderer) void {RSGL_renderer_resetModelMatrix(self);}
+  pub fn createComputeProgram(self: *renderer, CShaderCode: [*]const u8) programInfo {return RSGL_renderer_createComputeProgram(self, CShaderCode);}
+  pub fn dispatchComputeProgram(self: *renderer, program: *const programInfo, groups_x: u32, groups_y: u32, groups_z: u32) void {RSGL_renderer_dispatchComputeProgram(self, program, groups_x, groups_y, groups_z);}
+  pub fn bindComputeTexture(self: *renderer, texture: u32, format: u8) void {RSGL_renderer_bindComputeTexture(self, texture, format);}
+  pub fn drawRawVerts(self: *renderer, data: *const rawVerts) i32 {return RSGL_drawRawVerts(self, data);}
+  pub fn drawPoint(self: *renderer, p: vec2) i32 {return RSGL_drawPoint(self, p);}
+  pub fn drawRect(self: *renderer, r: rect) i32 {return RSGL_drawRect(self, r);}
+  pub fn drawRoundRect(self: *renderer, r: rect, rounding: vec2) i32 {return RSGL_drawRoundRect(self, r, rounding);}
+  pub fn drawPolygon(self: *renderer, r: rect, sides: u32) i32 {return RSGL_drawPolygon(self, r, sides);}
+  pub fn drawArc(self: *renderer, o: rect, arc: vec2) i32 {return RSGL_drawArc(self, o, arc);}
+  pub fn drawOval(self: *renderer, o: rect) i32 {return RSGL_drawOval(self, o);}
+  pub fn drawLine(self: *renderer, p1: vec2, p2: vec2, thickness: u32) i32 {return RSGL_drawLine(self, p1, p2, thickness);}
+  pub fn drawTriangle(self: *renderer, t: *vec3) i32 {return RSGL_drawTriangle(self, t);}
+  pub fn drawPoint3D(self: *renderer, p: vec3) i32 {return RSGL_drawPoint3D(self, p);}
+  pub fn drawLine3D(self: *renderer, p1: vec3, p2: vec3, thickness: u32) i32 {return RSGL_drawLine3D(self, p1, p2, thickness);}
+  pub fn drawCube(self: *renderer, c: cube) i32 {return RSGL_drawCube(self, c);}
+  pub fn drawTriangleOutline(self: *renderer, triangle: *vec3, thickness: u32) i32 {return RSGL_drawTriangleOutline(self, triangle, thickness);}
+  pub fn drawRoundRectOutline(self: *renderer, r: rect, rounding: vec2, thickness: u32) i32 {return RSGL_drawRoundRectOutline(self, r, rounding, thickness);}
+  pub fn drawPolygonOutline(self: *renderer, r: rect, sides: u32, thickness: u32) i32 {return RSGL_drawPolygonOutline(self, r, sides, thickness);}
+  pub fn drawArcOutline(self: *renderer, o: rect, arc: vec2, thickness: u32) i32 {return RSGL_drawArcOutline(self, o, arc, thickness);}
+  pub fn drawOvalOutline(self: *renderer, o: rect, thickness: u32) i32 {return RSGL_drawOvalOutline(self, o, thickness);}
+};
+extern fn RSGL_renderer_getRenderState(renderer: *renderer, state: *renderState) void;
+extern fn RSGL_renderer_size(renderer: *renderer) usize;
+extern fn RSGL_renderer_updateSize(renderer: *renderer, width: usize, height: usize) void;
+extern fn RSGL_renderer_freePtr(renderer: *renderer) void;
+extern fn RSGL_renderer_setSurface(renderer: *renderer, surface: ?*anyopaque) void;
+extern fn RSGL_renderer_createBuffer(renderer: *renderer, @"type": bufferType, size: usize, data: ?*const anyopaque, buffer: [*]usize) void;
+extern fn RSGL_renderer_updateBuffer(renderer: *renderer, @"type": bufferType, buffer: usize, data: ?*anyopaque, start: usize, len: usize) void;
+extern fn RSGL_renderer_deleteBuffer(renderer: *renderer, buffer: usize) void;
+extern fn RSGL_renderer_createRenderBuffers(renderer: *renderer, size: usize, buffers: *renderBuffers) void;
+extern fn RSGL_renderer_deleteRenderBuffers(renderer: *renderer, buffers: *renderBuffers) void;
+extern fn RSGL_renderer_render(renderer: *renderer) void;
+extern fn RSGL_renderer_updateRenderBuffers(renderer: *renderer) void;
+extern fn RSGL_renderer_renderBuffers(renderer: *renderer) void;
+extern fn RSGL_renderer_free(renderer: *renderer) void;
+extern fn RSGL_renderer_setRotate(renderer: *renderer, rotate: vec3) void;
+extern fn RSGL_renderer_setTexture(renderer: *renderer, texture: usize) void;
+extern fn RSGL_renderer_setTextureSource(renderer: *renderer, texture: usize, rect: rect) void;
+extern fn RSGL_renderer_setColor(renderer: *renderer, color: color) void;
+extern fn RSGL_renderer_setProgram(renderer: *renderer, program: *programInfo) void;
+extern fn RSGL_renderer_setFramebuffer(renderer: *renderer, framebuffer: usize) void;
+extern fn RSGL_renderer_setRenderBuffers(renderer: *renderer, buffers: *renderBuffers) void;
+extern fn RSGL_renderer_setGradient(renderer: *renderer, gradient: [*]f32, len: usize) void;
+extern fn RSGL_renderer_setCenter(renderer: *renderer, center: vec3) void;
+extern fn RSGL_renderer_setOverflow(renderer: *renderer, overflow: bool) void;
+extern fn RSGL_renderer_clearArgs(renderer: *renderer) void;
+extern fn RSGL_renderer_initDrawMatrix(renderer: *renderer, center: vec3) mat4;
+extern fn RSGL_renderer_clear(renderer: *renderer, color: color) void;
+extern fn RSGL_renderer_viewport(renderer: *renderer, rect: rect) void;
+extern fn RSGL_renderer_createTexture(renderer: *renderer, blob: *const textureBlob) usize;
+extern fn RSGL_renderer_copyToTexture(renderer: *renderer, texture: usize, x: usize, y: usize, blob: *const textureBlob) void;
+extern fn RSGL_renderer_deleteTexture(renderer: *renderer, tex: usize) void;
+extern fn RSGL_renderer_createFramebuffer(renderer: *renderer, width: usize, height: usize) usize;
+extern fn RSGL_renderer_attachFramebuffer(renderer: *renderer, fbo: usize, tex: usize, attachType: u8, mipLevel: u8) void;
+extern fn RSGL_renderer_deleteFramebuffer(renderer: *renderer, fbo: usize) void;
+extern fn RSGL_renderer_scissorStart(renderer: *renderer, scissor: rect, height: i32) void;
+extern fn RSGL_renderer_scissorEnd(renderer: *renderer) void;
+extern fn RSGL_renderer_defaultBlob(ctx: *renderer) programBlob;
+extern fn RSGL_renderer_createProgram(renderer: *renderer, blob: *programBlob) programInfo;
+extern fn RSGL_renderer_deleteProgram(renderer: *renderer, program: *const programInfo) void;
+extern fn RSGL_renderer_findShaderVariable(renderer: *renderer, program: *const programInfo, @"var": *const u8, len: usize) usize;
+extern fn RSGL_renderer_updateShaderVariable(renderer: *renderer, program: *const programInfo, @"var": usize, value: *const f32, len: u8) void;
+extern fn RSGL_renderer_forceBatch(renderer: *renderer) void;
+extern fn RSGL_renderer_setPerspectiveMatrix(renderer: *renderer, matrix: mat4) void;
+extern fn RSGL_renderer_setDefaultPerspectiveMatrix(renderer: *renderer, matrix: mat4) void;
+extern fn RSGL_renderer_setModelMatrix(renderer: *renderer, matrix: mat4) void;
+extern fn RSGL_renderer_resetModelMatrix(renderer: *renderer) void;
+extern fn RSGL_renderer_createComputeProgram(renderer: *renderer, CShaderCode: [*]const u8) programInfo;
+extern fn RSGL_renderer_dispatchComputeProgram(renderer: *renderer, program: *const programInfo, groups_x: u32, groups_y: u32, groups_z: u32) void;
+extern fn RSGL_renderer_bindComputeTexture(renderer: *renderer, texture: u32, format: u8) void;
+extern fn RSGL_drawRawVerts(renderer: *renderer, data: *const rawVerts) i32;
+extern fn RSGL_drawPoint(renderer: *renderer, p: vec2) i32;
+extern fn RSGL_drawRect(renderer: *renderer, r: rect) i32;
+extern fn RSGL_drawRoundRect(renderer: *renderer, r: rect, rounding: vec2) i32;
+extern fn RSGL_drawPolygon(renderer: *renderer, r: rect, sides: u32) i32;
+extern fn RSGL_drawArc(renderer: *renderer, o: rect, arc: vec2) i32;
+extern fn RSGL_drawOval(renderer: *renderer, o: rect) i32;
+extern fn RSGL_drawLine(renderer: *renderer, p1: vec2, p2: vec2, thickness: u32) i32;
+extern fn RSGL_drawTriangle(renderer: *renderer, *vec3) i32;
+extern fn RSGL_drawPoint3D(renderer: *renderer, p: vec3) i32;
+extern fn RSGL_drawLine3D(renderer: *renderer, p1: vec3, p2: vec3, thickness: u32) i32;
+extern fn RSGL_drawCube(renderer: *renderer, cube: cube) i32;
+extern fn RSGL_drawTriangleOutline(renderer: *renderer, triangle: *vec3, thickness: u32) i32;
+extern fn RSGL_drawRectOutline(renderer: *renderer, r: rect, thickness: u32) i32;
+extern fn RSGL_drawRoundRectOutline(renderer: *renderer, r: rect, rounding: vec2, thickness: u32) i32;
+extern fn RSGL_drawPolygonOutline(renderer: *renderer, r: rect, sides: u32, thickness: u32) i32;
+extern fn RSGL_drawArcOutline(renderer: *renderer, o: rect, arc: vec2, thickness: u32) i32;
+extern fn RSGL_drawOvalOutline(renderer: *renderer, o: rect, thickness: u32) i32;
+
+pub const drawType = enum(c_uint) {
+  triangles = raw.RSGL_TRIANGLES,
+  points    = raw.RSGL_POINTS,
+  lines     = raw.RSGL_LINES,
+};
+
+pub const rawVerts = extern struct {
+  type:       drawType = zeroes(drawType),
+  verts:      [*]f32   = null,
+  texCoords:  [*]f32   = null,
+  elements:   [*]u16   = null,
+  elmCount:   usize    = 0,
+  vert_count: usize    = 0,
+};
+
+pub const viewType = enum(c_uint) {
+  none  = raw.RSGL_viewTypeNone,
+  @"2D" = raw.RSGL_viewType2D,
+  @"3D" = raw.RSGL_viewType3D,
+};
+
+pub const view2 = extern struct {
+  type:     viewType = zeroes(viewType),
+  offset:   vec3     = zeroes(vec3),
+  target:   vec3     = zeroes(vec3),
+  rotation: f32      = 0,
+  zoom:     f32      = 0,
+};
+
+pub const view3 = extern struct {
+  type:   viewType = zeroes(viewType),
+  pos:    vec3     = zeroes(vec3),
+  target: vec3     = zeroes(vec3),
+  up:     vec3     = zeroes(vec3),
+};
+
+pub const view = extern union {
+  type: viewType,
+  v2:   view2,
+  v3:   view3,
+  pub fn getMatrix(self: *const view) mat4 {return RSGL_view_getMatrix(self);}
+};
+extern fn RSGL_view_getMatrix(view: *const view) mat4;
+
+pub const gl = struct {
+  pub fn rendererProc() __root.rendererProc {return  RSGL_GL_rendererProc();}
+};
+extern fn RSGL_GL_rendererProc() rendererProc;
\ No newline at end of file