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;