path: root/rsgl.zig

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_filterNearest,
  linear  = raw.RSGL_filterLinear,
};

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;