diff options
Diffstat (limited to 'rsgl.zig')
| -rw-r--r-- | rsgl.zig | 411 |
1 files changed, 411 insertions, 0 deletions
diff --git a/rsgl.zig b/rsgl.zig new file mode 100644 index 0000000..c65780d --- /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_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;
\ No newline at end of file |