From 59854f60b761d77cee4095c9ce45062c926dea5a Mon Sep 17 00:00:00 2001 From: Omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Thu, 30 May 2024 22:19:07 +1000 Subject: wip --- assets/shaders/cube.vert | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'assets/shaders/cube.vert') diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert index dc625ec..fa9f85b 100644 --- a/assets/shaders/cube.vert +++ b/assets/shaders/cube.vert @@ -4,8 +4,7 @@ layout(binding = 0) uniform UniformBufferObject { mat4 model; mat4 view; mat4 proj; -} -ubo; +} ubo; layout(location = 0) in vec3 inPosition; layout(location = 1) in vec3 inNormal; -- cgit v1.2.3-70-g09d2 From 859ea7e23d2bbbc4b32b43727ae50aebe399e720 Mon Sep 17 00:00:00 2001 From: omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Sun, 9 Jun 2024 01:43:02 +1000 Subject: metal is back, baby --- assets/shaders/blinn_phong.vert | 2 +- assets/shaders/cube.frag | 2 +- assets/shaders/cube.vert | 2 +- assets/shaders/triangle.metal | 33 +++ assets/shaders/triangle.vert | 2 +- deps/Unity/extras/fixture/src/unity_fixture.c | 6 +- examples/cube/ex_cube.c | 4 +- examples/triangle/ex_triangle.c | 42 ++-- src/defines.h | 4 +- src/renderer/backends/backend_vulkan.c | 1 + src/renderer/backends/metal/backend_metal.h | 74 +++++++ src/renderer/backends/metal/backend_metal.m | 285 ++++++++++++++++++++++++++ src/renderer/backends/opengl/backend_opengl.c | 2 +- src/renderer/backends/opengl/opengl_helpers.h | 18 +- src/renderer/ral.c | 6 + src/renderer/ral.h | 3 +- src/renderer/render_types.h | 4 +- xmake.lua | 13 +- 18 files changed, 458 insertions(+), 45 deletions(-) create mode 100644 assets/shaders/triangle.metal create mode 100644 src/renderer/backends/metal/backend_metal.h create mode 100644 src/renderer/backends/metal/backend_metal.m (limited to 'assets/shaders/cube.vert') diff --git a/assets/shaders/blinn_phong.vert b/assets/shaders/blinn_phong.vert index 1d2a53e..18609b7 100644 --- a/assets/shaders/blinn_phong.vert +++ b/assets/shaders/blinn_phong.vert @@ -1,4 +1,4 @@ -#version 430 core +#version 410 core struct Uniforms { mat4 model; diff --git a/assets/shaders/cube.frag b/assets/shaders/cube.frag index 292578f..88ba822 100644 --- a/assets/shaders/cube.frag +++ b/assets/shaders/cube.frag @@ -1,4 +1,4 @@ -#version 450 +#version 430 layout(location = 0) in vec3 fragColor; layout(location = 1) in vec2 fragTexCoord; diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert index fa9f85b..2f1d76d 100644 --- a/assets/shaders/cube.vert +++ b/assets/shaders/cube.vert @@ -1,4 +1,4 @@ -#version 450 +#version 430 layout(binding = 0) uniform UniformBufferObject { mat4 model; diff --git a/assets/shaders/triangle.metal b/assets/shaders/triangle.metal new file mode 100644 index 0000000..6055705 --- /dev/null +++ b/assets/shaders/triangle.metal @@ -0,0 +1,33 @@ +#include + +using namespace metal; + +struct VertexIn { + float2 position; + float3 color; +}; + +struct VertexOut { + float4 computedPosition [[position]]; + float3 fragColor; +}; + +// Vertex shader +vertex VertexOut basic_vertex( + const device VertexIn* vertex_array [[ buffer(0) ]], + unsigned int vid [[ vertex_id ]] + ) { + VertexIn v = vertex_array[vid]; + + VertexOut outVertex = VertexOut(); + outVertex.computedPosition = float4(v.position.xy, 0.0, 1.0); + outVertex.fragColor = v.color; + return outVertex; +} + +// Fragment shader +fragment float4 basic_fragment( + VertexOut interpolated [[stage_in]] +) { + return float4(interpolated.fragColor, 1.0); +} \ No newline at end of file diff --git a/assets/shaders/triangle.vert b/assets/shaders/triangle.vert index 8030561..f98696c 100644 --- a/assets/shaders/triangle.vert +++ b/assets/shaders/triangle.vert @@ -1,4 +1,4 @@ -#version 450 +#version 430 layout(location = 0) in vec2 inPos; layout(location = 1) in vec3 inColor; diff --git a/deps/Unity/extras/fixture/src/unity_fixture.c b/deps/Unity/extras/fixture/src/unity_fixture.c index e69b5a3..8ffe1f8 100644 --- a/deps/Unity/extras/fixture/src/unity_fixture.c +++ b/deps/Unity/extras/fixture/src/unity_fixture.c @@ -15,10 +15,8 @@ struct UNITY_FIXTURE_T UnityFixture; * Build with -D UNITY_OUTPUT_CHAR=outputChar and include * int (*outputChar)(int) = putchar; */ -void setUp(void) { /*does nothing*/ -} -void tearDown(void) { /*does nothing*/ -} +void setUp(void) { /*does nothing*/ } +void tearDown(void) { /*does nothing*/ } static void announceTestRun(unsigned int runNumber) { UnityPrint("Unity test run "); diff --git a/examples/cube/ex_cube.c b/examples/cube/ex_cube.c index 7b0ab48..a3d5a9f 100644 --- a/examples/cube/ex_cube.c +++ b/examples/cube/ex_cube.c @@ -70,8 +70,8 @@ int main() { str8 vert_path, frag_path; #ifdef CEL_REND_BACKEND_OPENGL - vert_path = str8lit("assets/shaders/blinn_phong.vert"); - frag_path = str8lit("assets/shaders/blinn_phong.frag"); + vert_path = str8lit("assets/shaders/cube.vert"); + frag_path = str8lit("assets/shaders/cube.frag"); #else vert_path = str8lit("build/linux/x86_64/debug/cube.vert.spv"); frag_path = str8lit("build/linux/x86_64/debug/cube.frag.spv"); diff --git a/examples/triangle/ex_triangle.c b/examples/triangle/ex_triangle.c index 0191c18..d9954e6 100644 --- a/examples/triangle/ex_triangle.c +++ b/examples/triangle/ex_triangle.c @@ -36,12 +36,12 @@ int main() { gpu_renderpass* renderpass = gpu_renderpass_create(&pass_description); str8 vert_path, frag_path; -#ifdef CEL_REND_BACKEND_OPENGL +#if defined(CEL_REND_BACKEND_OPENGL) vert_path = str8lit("assets/shaders/triangle.vert"); frag_path = str8lit("assets/shaders/triangle.frag"); -#else - vert_path = str8lit("build/linux/x86_64/debug/triangle.vert.spv"); - frag_path = str8lit("build/linux/x86_64/debug/triangle.frag.spv"); +#elif defined(CEL_REND_BACKEND_METAL) + vert_path = str8lit("build/gfx.metallib"); + frag_path = str8lit("build/gfx.metallib"); #endif str8_opt vertex_shader = str8_from_file(&scratch, vert_path); str8_opt fragment_shader = str8_from_file(&scratch, frag_path); @@ -57,7 +57,11 @@ int main() { .vs = { .debug_name = "Triangle Vertex Shader", .filepath = vert_path, .code = vertex_shader.contents, - .is_spirv = true }, +#ifdef CEL_REND_BACKEND_METAL + .is_combined_vert_frag = true, +#endif + .is_spirv = true, + }, .fs = { .debug_name = "Triangle Fragment Shader", .filepath = frag_path, .code = fragment_shader.contents, @@ -75,7 +79,7 @@ int main() { buffer_handle triangle_index_buf = gpu_buffer_create(sizeof(indices), CEL_BUFFER_INDEX, CEL_BUFFER_FLAG_GPU, indices); - // Main loop + // // Main loop while (!should_exit()) { input_update(&g_core.input); @@ -83,24 +87,24 @@ int main() { continue; } gpu_cmd_encoder* enc = gpu_get_default_cmd_encoder(); - // Begin recording + // // Begin recording gpu_cmd_encoder_begin(*enc); gpu_cmd_encoder_begin_render(enc, renderpass); - encode_bind_pipeline(enc, PIPELINE_GRAPHICS, gfx_pipeline); - encode_set_default_settings(enc); + // encode_bind_pipeline(enc, PIPELINE_GRAPHICS, gfx_pipeline); + // encode_set_default_settings(enc); - // Record draw calls - encode_set_vertex_buffer(enc, triangle_vert_buf); - encode_set_index_buffer(enc, triangle_index_buf); - encode_draw_indexed(enc, 6); + // // Record draw calls + // encode_set_vertex_buffer(enc, triangle_vert_buf); + // encode_set_index_buffer(enc, triangle_index_buf); + // encode_draw_indexed(enc, 6); - // End recording - gpu_cmd_encoder_end_render(enc); + // // End recording + // gpu_cmd_encoder_end_render(enc); - gpu_cmd_buffer buf = gpu_cmd_encoder_finish( - enc); // Command buffer is no longer recording and is ready to submit - // Submit - gpu_queue_submit(&buf); + // gpu_cmd_buffer buf = gpu_cmd_encoder_finish(enc); // Command buffer is no longer recording + // and is ready to submit + // // Submit + // gpu_queue_submit(&buf); gpu_backend_end_frame(); } diff --git a/src/defines.h b/src/defines.h index a35dbf4..9050f25 100644 --- a/src/defines.h +++ b/src/defines.h @@ -77,6 +77,6 @@ Renderer backend defines: #endif #if defined(CEL_PLATFORM_MAC) -// #define CEL_REND_BACKEND_METAL 1 -#define CEL_REND_BACKEND_OPENGL 1 +#define CEL_REND_BACKEND_METAL 1 +// #define CEL_REND_BACKEND_OPENGL 1 #endif \ No newline at end of file diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c index 06d8898..112e38b 100644 --- a/src/renderer/backends/backend_vulkan.c +++ b/src/renderer/backends/backend_vulkan.c @@ -403,6 +403,7 @@ VkFormat format_from_vertex_attr(vertex_attrib_type attr) { } gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) { + TRACE("GPU Graphics Pipeline creation"); // Allocate gpu_pipeline_layout* layout = pipeline_layout_pool_alloc(&context.gpu_pools.pipeline_layouts, NULL); diff --git a/src/renderer/backends/metal/backend_metal.h b/src/renderer/backends/metal/backend_metal.h new file mode 100644 index 0000000..59b21d6 --- /dev/null +++ b/src/renderer/backends/metal/backend_metal.h @@ -0,0 +1,74 @@ +#pragma once +#define CEL_REND_BACKEND_METAL +#if defined(CEL_REND_BACKEND_METAL) + +#include "defines.h" +#include "maths_types.h" +#ifdef __OBJC__ +#import +#import +#import +#import +#else +typedef void* id; +#endif + +typedef struct gpu_swapchain { + u32x2 dimensions; + #ifdef __OBJC__ + CAMetalLayer* swapchain; + #else + void* swapchain; + #endif +} gpu_swapchain; +typedef struct gpu_device { + /** @brief `device` gives us access to our GPU */ + #ifdef __OBJC__ + id id; + #else + void* id; + #endif +} gpu_device; +typedef struct gpu_pipeline_layout { + void* pad; +} gpu_pipeline_layout; +typedef struct gpu_pipeline { + #ifdef __OBJC__ + id pipeline_state; + #else + void* pipeline_state; + #endif +} gpu_pipeline; +typedef struct gpu_renderpass { + #ifdef __OBJC__ + MTLRenderPassDescriptor* rpass_descriptor; + #else + void* rpass_descriptor; + #endif +} gpu_renderpass; +typedef struct gpu_cmd_encoder { + #ifdef __OBJC__ + id cmd_buffer; + id render_encoder; + #else + void* cmd_buffer; + void* render_encoder; + #endif +} gpu_cmd_encoder; +typedef struct gpu_cmd_buffer { + void* pad; +} gpu_cmd_buffer; + +typedef struct gpu_buffer { + #ifdef __OBJC__ + id id; + #else + void* id; + #endif + u64 size; +} gpu_buffer; +typedef struct gpu_texture { + void* pad; +} gpu_texture; + +#endif \ No newline at end of file diff --git a/src/renderer/backends/metal/backend_metal.m b/src/renderer/backends/metal/backend_metal.m new file mode 100644 index 0000000..0e9399e --- /dev/null +++ b/src/renderer/backends/metal/backend_metal.m @@ -0,0 +1,285 @@ +#include +#define CEL_REND_BACKEND_METAL +#if defined(CEL_REND_BACKEND_METAL) +#include +#include "ral_types.h" +#include "colours.h" +#include +#include "camera.h" +#include "defines.h" +#include "file.h" +#include "log.h" +#include "maths_types.h" +#include "ral.h" + +#define GLFW_INCLUDE_NONE +#define GLFW_EXPOSE_NATIVE_COCOA + +#include +#include + +#import +#import +#import +#import +#include "backend_metal.h" + +// --- Handy macros +#define BUFFER_GET(h) (buffer_pool_get(&context.resource_pools->buffers, h)) +#define TEXTURE_GET(h) (texture_pool_get(&context.resource_pools->textures, h)) + +typedef struct metal_context { + GLFWwindow* window; + NSWindow* metal_window; + arena pool_arena; + + gpu_device* device; + gpu_swapchain* swapchain; + id surface; + + id command_queue; + gpu_cmd_encoder main_command_buf; + gpu_backend_pools gpu_pools; + struct resource_pools* resource_pools; +} metal_context; + +static metal_context context; + +struct GLFWwindow; + +bool gpu_backend_init(const char *window_name, struct GLFWwindow *window) { + INFO("loading Metal backend"); + + memset(&context, 0, sizeof(metal_context)); + context.window = window; + + size_t pool_buffer_size = 1024 * 1024; + context.pool_arena = arena_create(malloc(pool_buffer_size), pool_buffer_size); + + backend_pools_init(&context.pool_arena, &context.gpu_pools); + context.resource_pools = malloc(sizeof(struct resource_pools)); + resource_pools_init(&context.pool_arena, context.resource_pools); + + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + + glfwMakeContextCurrent(window); + // FIXME: glfwSetFramebufferSizeCallback(ren->window, framebuffer_size_callback); + + // get a NSWindow pointer from GLFWwindow + NSWindow *nswindow = glfwGetCocoaWindow(window); + context.metal_window = nswindow; + + // const id queue = [gpu newCommandQueue]; + // CAMetalLayer *swapchain = [CAMetalLayer layer]; + // swapchain.device = gpu; + // swapchain.opaque = YES; + + // // set swapchain for the window + // nswindow.contentView.layer = swapchain; + // nswindow.contentView.wantsLayer = YES; + + // MTLClearColor color = MTLClearColorMake(0.7, 0.1, 0.2, 1.0); + + // // set all our state properties + // state->device = gpu; + // state->cmd_queue = queue; + // state->swapchain = swapchain; + // state->clear_color = color; + + // NSError *err = 0x0; // TEMPORARY + + // WARN("About to try loading metallib"); + // id defaultLibrary = [state->device newLibraryWithFile: @"build/gfx.metallib" error:&err]; + // CASSERT(defaultLibrary); + // state->default_lib = defaultLibrary; + // if (!state->default_lib) { + // NSLog(@"Failed to load library"); + // exit(0); + // } + + // create_render_pipeline(state); + + return true; +} + +void gpu_backend_shutdown() {} + +bool gpu_device_create(gpu_device* out_device) { + TRACE("GPU Device creation"); + const id gpu = MTLCreateSystemDefaultDevice(); + out_device->id = gpu; + context.device = out_device; + + const id queue = [gpu newCommandQueue]; + context.command_queue = queue; + + return true; +} +void gpu_device_destroy() {} + +// --- Render Pipeline +gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) { + TRACE("GPU Graphics Pipeline creation"); + // Allocate + // gpu_pipeline_layout* layout = + // pipeline_layout_pool_alloc(&context.gpu_pools.pipeline_layouts, NULL); + gpu_pipeline* pipeline = pipeline_pool_alloc(&context.gpu_pools.pipelines, NULL); + + WARN("About to try loading metallib"); + assert(description.vs.is_combined_vert_frag); + // Ignore fragment shader data, as vert shader data contains both + NSError *err = 0x0; // TEMPORARY + NSString *myNSString = [NSString stringWithUTF8String:(char*)description.vs.filepath.buf]; + id default_library = [context.device->id newLibraryWithFile:myNSString error:&err]; + assert(default_library); + + // setup vertex and fragment shaders + id ren_vert = [default_library newFunctionWithName:@"basic_vertex"]; + assert(ren_vert); + id ren_frag = [default_library newFunctionWithName:@"basic_fragment"]; + assert(ren_frag); + + // create pipeline descriptor + @autoreleasepool { + NSError *err = 0x0; + MTLRenderPipelineDescriptor *pld = [[MTLRenderPipelineDescriptor alloc] init]; + NSString *pipeline_name = [NSString stringWithUTF8String: description.debug_name]; + pld.label = pipeline_name; + pld.vertexFunction = ren_vert; + pld.fragmentFunction = ren_frag; + pld.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm; + pld.colorAttachments[0].blendingEnabled = YES; + + MTLDepthStencilDescriptor *depthStencilDescriptor = [MTLDepthStencilDescriptor new]; + depthStencilDescriptor.depthCompareFunction = MTLCompareFunctionLess; + depthStencilDescriptor.depthWriteEnabled = YES; + pld.depthAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8; + + id depth_descriptor = [context.device->id newDepthStencilStateWithDescriptor:depthStencilDescriptor]; + // FIXME: state->depth_state = depth_descriptor; + + id pipeline_state = [context.device->id newRenderPipelineStateWithDescriptor:pld error:&err]; + TRACE("created renderpipelinestate"); + pipeline->pipeline_state = pipeline_state; + + } + + return pipeline; +} +void gpu_pipeline_destroy(gpu_pipeline* pipeline) {} + +// --- Renderpass +gpu_renderpass* gpu_renderpass_create(const gpu_renderpass_desc* description) { + gpu_renderpass* renderpass = renderpass_pool_alloc(&context.gpu_pools.renderpasses, NULL); + + // TODO: Configure based on description + // set up render pass + context.surface = [context.swapchain->swapchain nextDrawable]; + MTLRenderPassDescriptor *renderPassDescriptor = [[MTLRenderPassDescriptor alloc] init]; + MTLRenderPassColorAttachmentDescriptor *cd = renderPassDescriptor.colorAttachments[0]; + [cd setTexture:context.surface.texture]; + [cd setLoadAction:MTLLoadActionClear]; + MTLClearColor clearColor = MTLClearColorMake(0.1, 0.1, 0.0, 1.0); + [cd setClearColor:clearColor]; + [cd setStoreAction:MTLStoreActionStore]; + + renderpass->rpass_descriptor = renderPassDescriptor; + + return renderpass; +} + +void gpu_renderpass_destroy(gpu_renderpass* pass) {} + +// --- Swapchain +bool gpu_swapchain_create(gpu_swapchain* out_swapchain) { + TRACE("GPU Swapchain creation"); + CAMetalLayer *swapchain = [CAMetalLayer layer]; + swapchain.device = context.device->id; + swapchain.opaque = YES; + out_swapchain->swapchain = swapchain; + + // set swapchain for the window + context.metal_window.contentView.layer = swapchain; + context.metal_window.contentView.wantsLayer = YES; + + context.swapchain = out_swapchain; + return true; +} +void gpu_swapchain_destroy(gpu_swapchain* swapchain) {} + +// --- Command buffer +gpu_cmd_encoder gpu_cmd_encoder_create() { + id cmd_buffer = [context.command_queue commandBuffer]; + + return (gpu_cmd_encoder) { + .cmd_buffer = cmd_buffer + }; +} +void gpu_cmd_encoder_destroy(gpu_cmd_encoder* encoder) {} +void gpu_cmd_encoder_begin(gpu_cmd_encoder encoder) { /* no-op */ } +void gpu_cmd_encoder_begin_render(gpu_cmd_encoder* encoder, gpu_renderpass* renderpass) { + DEBUG("Create Render Command Encoder"); + id render_encoder = [encoder->cmd_buffer renderCommandEncoderWithDescriptor:renderpass->rpass_descriptor]; + encoder->render_encoder = render_encoder; + // [encoder setDepthStencilState:state->depth_state]; +} +void gpu_cmd_encoder_end_render(gpu_cmd_encoder* encoder) {} +void gpu_cmd_encoder_begin_compute() {} +gpu_cmd_encoder* gpu_get_default_cmd_encoder() { + return &context.main_command_buf; +} + +/** @brief Finish recording and return a command buffer that can be submitted to a queue */ +gpu_cmd_buffer gpu_cmd_encoder_finish(gpu_cmd_encoder* encoder) {} + +void gpu_queue_submit(gpu_cmd_buffer* buffer) {} + +void encode_buffer_copy(gpu_cmd_encoder* encoder, buffer_handle src, u64 src_offset, + buffer_handle dst, u64 dst_offset, u64 copy_size); +void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset, u64 size); + +void copy_buffer_to_buffer_oneshot(buffer_handle src, u64 src_offset, buffer_handle dst, + u64 dst_offset, u64 copy_size); +void copy_buffer_to_image_oneshot(buffer_handle src, texture_handle dst); + +void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline) {} +void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* data) {} +void encode_set_default_settings(gpu_cmd_encoder* encoder) { + [encoder->render_encoder setCullMode:MTLCullModeBack]; +} +void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) { + gpu_buffer* vertex_buf = BUFFER_GET(buf); + [encoder->render_encoder setVertexBuffer:vertex_buf->id offset:0 atIndex:0]; +} +void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {} +void encode_set_bind_group() {} +void encode_draw(gpu_cmd_encoder* encoder) {} +void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count) {} +void encode_clear_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {} + +buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_flags flags, + const void* data) { + buffer_handle handle; + gpu_buffer* buffer = buffer_pool_alloc(&context.resource_pools->buffers, &handle); + buffer->size = size; + + id mtl_vert_buf = [context.device->id newBufferWithBytes:data + length: size + options:MTLResourceStorageModeShared]; + return handle; +} +void gpu_buffer_destroy(buffer_handle buffer) {} +void gpu_buffer_upload(const void* data) {} + +texture_handle gpu_texture_create(texture_desc desc, bool create_view, const void* data) {} +void gpu_texture_destroy(texture_handle) {} +void gpu_texture_upload(texture_handle texture, const void* data) {} + +bool gpu_backend_begin_frame() { + context.main_command_buf.cmd_buffer = [context.command_queue commandBuffer]; + return true; + } +void gpu_backend_end_frame() {} +void gpu_temp_draw(size_t n_verts) {} + +#endif \ No newline at end of file diff --git a/src/renderer/backends/opengl/backend_opengl.c b/src/renderer/backends/opengl/backend_opengl.c index 8be1c2a..96415f1 100644 --- a/src/renderer/backends/opengl/backend_opengl.c +++ b/src/renderer/backends/opengl/backend_opengl.c @@ -2,7 +2,7 @@ #include "colours.h" #include "opengl_helpers.h" #include "ral_types.h" -#define CEL_REND_BACKEND_OPENGL +// #define CEL_REND_BACKEND_OPENGL #if defined(CEL_REND_BACKEND_OPENGL) #include #include "camera.h" diff --git a/src/renderer/backends/opengl/opengl_helpers.h b/src/renderer/backends/opengl/opengl_helpers.h index 2f6bef3..44d40cb 100644 --- a/src/renderer/backends/opengl/opengl_helpers.h +++ b/src/renderer/backends/opengl/opengl_helpers.h @@ -1,36 +1,36 @@ #pragma once -#include "ral_types.h" #include #include +#include "ral_types.h" typedef struct opengl_vertex_attr { u32 count; GLenum data_type; -} opengl_vertex_attr ; +} opengl_vertex_attr; opengl_vertex_attr format_from_vertex_attr(vertex_attrib_type attr) { switch (attr) { case ATTR_F32: - return (opengl_vertex_attr){.count = 1, .data_type = GL_FLOAT }; + return (opengl_vertex_attr){ .count = 1, .data_type = GL_FLOAT }; case ATTR_U32: - return (opengl_vertex_attr){.count = 1, .data_type = GL_UNSIGNED_INT }; + return (opengl_vertex_attr){ .count = 1, .data_type = GL_UNSIGNED_INT }; case ATTR_I32: - return (opengl_vertex_attr){.count = 1, .data_type = GL_INT }; + return (opengl_vertex_attr){ .count = 1, .data_type = GL_INT }; case ATTR_F32x2: - return (opengl_vertex_attr){.count = 2, .data_type = GL_FLOAT }; + return (opengl_vertex_attr){ .count = 2, .data_type = GL_FLOAT }; case ATTR_U32x2: // return VK_FORMAT_R32G32_UINT; case ATTR_I32x2: // return VK_FORMAT_R32G32_UINT; case ATTR_F32x3: - return (opengl_vertex_attr){.count = 3, .data_type = GL_FLOAT }; + return (opengl_vertex_attr){ .count = 3, .data_type = GL_FLOAT }; case ATTR_U32x3: // return VK_FORMAT_R32G32B32_UINT; case ATTR_I32x3: // return VK_FORMAT_R32G32B32_SINT; case ATTR_F32x4: - return (opengl_vertex_attr){.count = 4, .data_type = GL_FLOAT }; + return (opengl_vertex_attr){ .count = 4, .data_type = GL_FLOAT }; case ATTR_U32x4: // return VK_FORMAT_R32G32B32A32_UINT; case ATTR_I32x4: - // return VK_FORMAT_R32G32B32A32_SINT; + return (opengl_vertex_attr){ .count = 4, .data_type = GL_INT }; } } \ No newline at end of file diff --git a/src/renderer/ral.c b/src/renderer/ral.c index 4f2a999..fe12b4f 100644 --- a/src/renderer/ral.c +++ b/src/renderer/ral.c @@ -1,6 +1,12 @@ #include "ral.h" +#if defined(CEL_REND_BACKEND_VULKAN) +#include "backend_vulkan.h" +#elif defined(CEL_REND_BACKEND_METAL) +#include "backend_metal.h" +#elif defined(CEL_REND_BACKEND_OPENGL) #include "backend_opengl.h" +#endif size_t vertex_attrib_size(vertex_attrib_type attr) { switch (attr) { diff --git a/src/renderer/ral.h b/src/renderer/ral.h index a18ea87..3415b04 100644 --- a/src/renderer/ral.h +++ b/src/renderer/ral.h @@ -66,9 +66,10 @@ typedef enum pipeline_kind { typedef struct shader_desc { const char* debug_name; - str8 filepath; // where it came from + str8 filepath; // Where it came from str8 code; // Either GLSL or SPIRV bytecode bool is_spirv; + bool is_combined_vert_frag; // Contains both vertex and fragment stages } shader_desc; struct graphics_pipeline_desc { diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h index 63e5b29..a2c35fe 100644 --- a/src/renderer/render_types.h +++ b/src/renderer/render_types.h @@ -17,12 +17,12 @@ #endif #if defined(CEL_REND_BACKEND_VULKAN) #include "backend_vulkan.h" +#elif defined(CEL_REND_BACKEND_METAL) +#include "backend_metal.h" #elif defined(CEL_REND_BACKEND_OPENGL) #include "backend_opengl.h" #endif -#include "backend_opengl.h" - struct GLFWwindow; /** @brief configuration passed to the renderer at init time */ diff --git a/xmake.lua b/xmake.lua index 5a2707c..86a673a 100644 --- a/xmake.lua +++ b/xmake.lua @@ -1,6 +1,6 @@ set_project("celeritas") set_version("0.1.0") -set_config("cc", "gcc") +set_config("cc", "clang") add_rules("mode.debug", "mode.release") -- we have two modes: debug & release @@ -30,6 +30,7 @@ elseif is_plat("windows") then elseif is_plat("macosx") then add_defines("CEL_PLATFORM_MAC") add_frameworks("Cocoa", "IOKit", "CoreVideo", "OpenGL") + add_frameworks( "Foundation", "Metal", "QuartzCore") set_runenv("MTL_DEBUG_LAYER", "1") -- add_syslinks("GL") end @@ -62,6 +63,7 @@ local core_sources = { "src/renderer/*.c", "src/renderer/backends/*.c", "src/renderer/backends/opengl/*.c", + "src/renderer/backends/metal/*.m", "src/resources/*.c", "src/std/*.c", "src/std/containers/*.c", @@ -113,6 +115,7 @@ target("core_config") add_includedirs("src/renderer/", {public = true}) add_includedirs("src/renderer/backends/", {public = true}) add_includedirs("src/renderer/backends/opengl", {public = true}) + add_includedirs("src/renderer/backends/metal", {public = true}) add_includedirs("src/resources/", {public = true}) add_includedirs("src/std/", {public = true}) add_includedirs("src/std/containers", {public = true}) @@ -166,6 +169,14 @@ target("tri") add_deps("core_static") add_files("examples/triangle/ex_triangle.c") set_rundir("$(projectdir)") + if is_plat("macosx") then + before_build(function (target) + print("build metal shaders lib") + os.exec("mkdir -p build/shaders") + os.exec("xcrun -sdk macosx metal -c assets/shaders/triangle.metal -o build/shaders/gfx.air") + os.exec("xcrun -sdk macosx metallib build/shaders/gfx.air -o build/gfx.metallib") + end) + end target("cube") set_kind("binary") -- cgit v1.2.3-70-g09d2 From 64830ce51a185091f54c2b42b365110d89d44f1b Mon Sep 17 00:00:00 2001 From: Omniscient Date: Sun, 9 Jun 2024 11:42:17 +1000 Subject: triangle on opengl works again. happy days --- assets/shaders/cube.frag | 3 +- assets/shaders/cube.vert | 3 +- assets/shaders/triangle.frag | 2 +- examples/triangle/ex_triangle.c | 31 ++-- src/renderer/backends/backend_vulkan.c | 8 +- src/renderer/backends/backend_vulkan.h | 2 +- src/renderer/backends/metal/backend_metal.h | 42 +++--- src/renderer/backends/opengl/backend_opengl.c | 204 +++++++++----------------- src/renderer/backends/opengl/backend_opengl.h | 9 +- src/renderer/backends/opengl/opengl_helpers.h | 43 +++++- src/renderer/ral.c | 7 +- src/renderer/ral.h | 9 +- src/renderer/ral_types.h | 6 + src/renderer/render_types.h | 1 + xmake.lua | 6 +- 15 files changed, 192 insertions(+), 184 deletions(-) (limited to 'assets/shaders/cube.vert') diff --git a/assets/shaders/cube.frag b/assets/shaders/cube.frag index 88ba822..796f1c8 100644 --- a/assets/shaders/cube.frag +++ b/assets/shaders/cube.frag @@ -8,5 +8,6 @@ layout(binding = 1) uniform sampler2D texSampler; layout(location = 0) out vec4 outColor; void main() { - outColor = texture(texSampler, fragTexCoord); // vec4(fragTexCoord, 0.0); + // outColor = texture(texSampler, fragTexCoord); // vec4(fragTexCoord, 0.0); + outColor = vec4(1.0); } diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert index 2f1d76d..57475e7 100644 --- a/assets/shaders/cube.vert +++ b/assets/shaders/cube.vert @@ -1,6 +1,6 @@ #version 430 -layout(binding = 0) uniform UniformBufferObject { +layout(binding = 0) uniform Matrices { mat4 model; mat4 view; mat4 proj; @@ -15,6 +15,7 @@ layout(location = 1) out vec2 fragTexCoord; void main() { gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0); + // gl_Position = vec4(inPosition, 1.0); fragColor = abs(inNormal); fragTexCoord = inTexCoords; } diff --git a/assets/shaders/triangle.frag b/assets/shaders/triangle.frag index c3ff328..ad6de8e 100644 --- a/assets/shaders/triangle.frag +++ b/assets/shaders/triangle.frag @@ -1,4 +1,4 @@ -#version 450 +#version 430 layout(location = 0) in vec3 fragColor; layout(location = 0) out vec4 outColor; diff --git a/examples/triangle/ex_triangle.c b/examples/triangle/ex_triangle.c index d9954e6..cd401c7 100644 --- a/examples/triangle/ex_triangle.c +++ b/examples/triangle/ex_triangle.c @@ -4,6 +4,7 @@ #include "buf.h" #include "camera.h" #include "core.h" +#include "defines.h" #include "file.h" #include "log.h" #include "maths.h" @@ -73,8 +74,8 @@ int main() { gpu_pipeline* gfx_pipeline = gpu_graphics_pipeline_create(pipeline_description); // Load triangle vertex and index data - buffer_handle triangle_vert_buf = - gpu_buffer_create(4 * sizeof(vertex), CEL_BUFFER_VERTEX, CEL_BUFFER_FLAG_GPU, vertices); + buffer_handle triangle_vert_buf = gpu_buffer_create(4 * sizeof(custom_vertex), CEL_BUFFER_VERTEX, + CEL_BUFFER_FLAG_GPU, vertices); buffer_handle triangle_index_buf = gpu_buffer_create(sizeof(indices), CEL_BUFFER_INDEX, CEL_BUFFER_FLAG_GPU, indices); @@ -87,24 +88,24 @@ int main() { continue; } gpu_cmd_encoder* enc = gpu_get_default_cmd_encoder(); - // // Begin recording + // // Begin recording gpu_cmd_encoder_begin(*enc); gpu_cmd_encoder_begin_render(enc, renderpass); - // encode_bind_pipeline(enc, PIPELINE_GRAPHICS, gfx_pipeline); - // encode_set_default_settings(enc); + encode_bind_pipeline(enc, PIPELINE_GRAPHICS, gfx_pipeline); + encode_set_default_settings(enc); - // // Record draw calls - // encode_set_vertex_buffer(enc, triangle_vert_buf); - // encode_set_index_buffer(enc, triangle_index_buf); - // encode_draw_indexed(enc, 6); + // // Record draw calls + encode_set_vertex_buffer(enc, triangle_vert_buf); + encode_set_index_buffer(enc, triangle_index_buf); + encode_draw_indexed(enc, 6); - // // End recording - // gpu_cmd_encoder_end_render(enc); + // // End recording + // gpu_cmd_encoder_end_render(enc); - // gpu_cmd_buffer buf = gpu_cmd_encoder_finish(enc); // Command buffer is no longer recording - // and is ready to submit - // // Submit - // gpu_queue_submit(&buf); + // gpu_cmd_buffer buf = gpu_cmd_encoder_finish(enc); // Command buffer is no longer recording + // and is ready to submit + // // Submit + // gpu_queue_submit(&buf); gpu_backend_end_frame(); } diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c index 112e38b..8801230 100644 --- a/src/renderer/backends/backend_vulkan.c +++ b/src/renderer/backends/backend_vulkan.c @@ -1,7 +1,10 @@ +#include "defines.h" #if defined(CEL_REND_BACKEND_VULKAN) -#include +#define GLFW_INCLUDE_VULKAN #include + +#include #include #include #include @@ -19,7 +22,6 @@ #include "str.h" #include "vulkan_helpers.h" -#include "defines.h" #include "file.h" #include "log.h" #include "ral.h" @@ -1637,7 +1639,7 @@ texture_handle gpu_texture_create(texture_desc desc, bool create_view, const voi &texture->sampler); if (res != VK_SUCCESS) { ERROR("Error creating texture sampler for image %s", texture->debug_label); - return; + exit(1); } return handle; diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h index 21a80ba..6ca0bb5 100644 --- a/src/renderer/backends/backend_vulkan.h +++ b/src/renderer/backends/backend_vulkan.h @@ -1,10 +1,10 @@ #pragma once +#include "defines.h" #if defined(CEL_REND_BACKEND_VULKAN) #include #include #include -#include "defines.h" #include "mem.h" #include "ral.h" #include "ral_types.h" diff --git a/src/renderer/backends/metal/backend_metal.h b/src/renderer/backends/metal/backend_metal.h index 59b21d6..9561bb6 100644 --- a/src/renderer/backends/metal/backend_metal.h +++ b/src/renderer/backends/metal/backend_metal.h @@ -1,70 +1,70 @@ #pragma once -#define CEL_REND_BACKEND_METAL +// #define CEL_REND_BACKEND_METAL #if defined(CEL_REND_BACKEND_METAL) #include "defines.h" #include "maths_types.h" #ifdef __OBJC__ +#import #import #import #import -#import #else typedef void* id; #endif typedef struct gpu_swapchain { u32x2 dimensions; - #ifdef __OBJC__ +#ifdef __OBJC__ CAMetalLayer* swapchain; - #else +#else void* swapchain; - #endif +#endif } gpu_swapchain; typedef struct gpu_device { - /** @brief `device` gives us access to our GPU */ - #ifdef __OBJC__ +/** @brief `device` gives us access to our GPU */ +#ifdef __OBJC__ id id; - #else +#else void* id; - #endif +#endif } gpu_device; typedef struct gpu_pipeline_layout { void* pad; } gpu_pipeline_layout; typedef struct gpu_pipeline { - #ifdef __OBJC__ +#ifdef __OBJC__ id pipeline_state; - #else +#else void* pipeline_state; - #endif +#endif } gpu_pipeline; typedef struct gpu_renderpass { - #ifdef __OBJC__ +#ifdef __OBJC__ MTLRenderPassDescriptor* rpass_descriptor; - #else +#else void* rpass_descriptor; - #endif +#endif } gpu_renderpass; typedef struct gpu_cmd_encoder { - #ifdef __OBJC__ +#ifdef __OBJC__ id cmd_buffer; id render_encoder; - #else +#else void* cmd_buffer; void* render_encoder; - #endif +#endif } gpu_cmd_encoder; typedef struct gpu_cmd_buffer { void* pad; } gpu_cmd_buffer; typedef struct gpu_buffer { - #ifdef __OBJC__ +#ifdef __OBJC__ id id; - #else +#else void* id; - #endif +#endif u64 size; } gpu_buffer; typedef struct gpu_texture { diff --git a/src/renderer/backends/opengl/backend_opengl.c b/src/renderer/backends/opengl/backend_opengl.c index 96415f1..073f343 100644 --- a/src/renderer/backends/opengl/backend_opengl.c +++ b/src/renderer/backends/opengl/backend_opengl.c @@ -2,8 +2,9 @@ #include "colours.h" #include "opengl_helpers.h" #include "ral_types.h" -// #define CEL_REND_BACKEND_OPENGL +#define CEL_REND_BACKEND_OPENGL 1 #if defined(CEL_REND_BACKEND_OPENGL) +#include #include #include "camera.h" @@ -29,8 +30,6 @@ static opengl_context context; struct GLFWwindow; -size_t vertex_attrib_size(vertex_attrib_type attr); - bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { INFO("loading OpenGL backend"); @@ -62,7 +61,7 @@ bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { void gpu_backend_shutdown() {} -bool gpu_device_create(gpu_device* out_device) {} +bool gpu_device_create(gpu_device* out_device) { /* No-op in OpenGL */ } void gpu_device_destroy() {} // --- Render Pipeline @@ -73,23 +72,8 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip u32 shader_id = shader_create_separate(description.vs.filepath.buf, description.fs.filepath.buf); pipeline->shader_id = shader_id; - // Vertex - u32 vao; - glGenVertexArrays(1, &vao); - pipeline->vao = vao; - - // Attributes - u32 attr_count = description.vertex_desc.attributes_count; - printf("N attributes %d\n", attr_count); - u64 offset = 0; - size_t vertex_size = description.vertex_desc.stride; - for (u32 i = 0; i < description.vertex_desc.attributes_count; i++) { - opengl_vertex_attr format = format_from_vertex_attr(description.vertex_desc.attributes[i]); - glVertexAttribPointer(i, format.count, format.data_type, GL_FALSE, vertex_size, (void*)offset); - size_t this_offset = format.count * vertex_attrib_size(description.vertex_desc.attributes[i]); - printf("offset total %lld this attr %ld\n", offset, this_offset); - offset += this_offset; - } + // Vertex format + pipeline->vertex_desc = description.vertex_desc; // Allocate uniform buffers if needed printf("data layouts %d\n", description.data_layouts_count); @@ -98,6 +82,20 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip TRACE("Got shader data layout %d's bindings! . found %d", layout_i, sdl.bindings_count); for (u32 binding_j = 0; binding_j < sdl.bindings_count; binding_j++) { + u32 binding_id = binding_j; + assert(binding_id < MAX_PIPELINE_UNIFORM_BUFFERS); + shader_binding binding = sdl.bindings[binding_j]; + if (binding.type == SHADER_BINDING_BYTES) { + buffer_handle ubo_handle = + gpu_buffer_create(binding.data.bytes.size, CEL_BUFFER_UNIFORM, CEL_BUFFER_FLAG_GPU, + NULL); // no data right now + pipeline->uniform_bindings[binding_id] = ubo_handle; + gpu_buffer* ubo_buf = BUFFER_GET(ubo_handle); + glBindBuffer(GL_UNIFORM_BUFFER, ubo_buf->id.ubo); + glBindBufferBase(GL_UNIFORM_BUFFER, binding_j, ubo_buf->id.ubo); + + // Now we want to store a handle associated with the shader for this + } } } @@ -139,7 +137,10 @@ void gpu_queue_submit(gpu_cmd_buffer* buffer) {} void encode_buffer_copy(gpu_cmd_encoder* encoder, buffer_handle src, u64 src_offset, buffer_handle dst, u64 dst_offset, u64 copy_size) {} /** @brief Upload CPU-side data as array of bytes to a GPU buffer */ -void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset, u64 size) {} +void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset, u64 size) { + // TODO: finish implementing this + gpu_buffer* buf = BUFFER_GET(gpu_buf); +} /** @brief Copy data from buffer to buffer using a one time submit command buffer and a wait */ void copy_buffer_to_buffer_oneshot(buffer_handle src, u64 src_offset, buffer_handle dst, @@ -149,43 +150,77 @@ void copy_buffer_to_image_oneshot(buffer_handle src, texture_handle dst) {} // --- Render commands void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline) { + encoder->pipeline = pipeline; // In OpenGL this is more or less equivalent to just setting the shader glUseProgram(pipeline->shader_id); - glBindVertexArray(pipeline->vao); } void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* data) { shader_data_layout sdl = data->shader_data_get_layout(data->data); - size_t binding_count = sdl.bindings_count; for (u32 i = 0; i < sdl.bindings_count; i++) { shader_binding binding = sdl.bindings[i]; + print_shader_binding(binding); + + if (binding.type == SHADER_BINDING_BYTES) { + buffer_handle b = encoder->pipeline->uniform_bindings[i]; + gpu_buffer* ubo_buf = BUFFER_GET(b); + glBindBuffer(GL_UNIFORM_BUFFER, ubo_buf->id.ubo); + glBufferSubData(GL_UNIFORM_BUFFER, 0, ubo_buf->size, data->data); + glBindBuffer(GL_UNIFORM_BUFFER, 0); + } } } void encode_set_default_settings(gpu_cmd_encoder* encoder) {} -void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {} -void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {} -void encode_draw(gpu_cmd_encoder* encoder) {} -void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count) {} +void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) { + gpu_buffer* buffer = BUFFER_GET(buf); + if (buffer->vao == 0) { // if no VAO for this vertex buffer, create it + buffer->vao = opengl_bindcreate_vao(buffer, encoder->pipeline->vertex_desc); + } + glBindVertexArray(buffer->vao); +} +void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) { + gpu_buffer* buffer = BUFFER_GET(buf); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer->id.ibo); +} +void encode_draw(gpu_cmd_encoder* encoder, u64 count) { glDrawArrays(GL_TRIANGLES, 0, count); } +void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count) { + glDrawElements(GL_TRIANGLES, index_count, GL_UNSIGNED_INT, 0); +} void encode_clear_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {} // --- Buffers buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_flags flags, const void* data) { + // "allocating" the cpu-side buffer struct + buffer_handle handle; + gpu_buffer* buffer = buffer_pool_alloc(&context.resource_pools->buffers, &handle); + buffer->size = size; + buffer->vao = 0; // When we create a new buffer, there will be no VAO. + + // Opengl buffer GLuint gl_buffer_id; glGenBuffers(1, &gl_buffer_id); GLenum gl_buf_type; + GLenum gl_buf_usage = GL_STATIC_DRAW; switch (buf_type) { case CEL_BUFFER_UNIFORM: + DEBUG("Creating Uniform buffer"); gl_buf_type = GL_UNIFORM_BUFFER; + gl_buf_usage = GL_DYNAMIC_DRAW; + buffer->id.ubo = gl_buffer_id; break; case CEL_BUFFER_DEFAULT: case CEL_BUFFER_VERTEX: + DEBUG("Creating Vertex buffer"); gl_buf_type = GL_ARRAY_BUFFER; + buffer->id.vbo = gl_buffer_id; break; case CEL_BUFFER_INDEX: + DEBUG("Creating Index buffer"); gl_buf_type = GL_ELEMENT_ARRAY_BUFFER; + buffer->id.ibo = gl_buffer_id; break; default: WARN("Unimplemented gpu_buffer_type provided %s", buffer_type_names[buf_type]); @@ -194,27 +229,22 @@ buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_f // bind buffer glBindBuffer(gl_buf_type, gl_buffer_id); - // "allocating" the cpu-side buffer struct - buffer_handle handle; - gpu_buffer* buffer = buffer_pool_alloc(&context.resource_pools->buffers, &handle); - buffer->size = size; - if (data) { TRACE("Upload data (%d bytes) as part of buffer creation", size); - glBufferData(gl_buf_type, buffer->size, data, GL_STATIC_DRAW); + glBufferData(gl_buf_type, buffer->size, data, gl_buf_usage); + } else { + TRACE("Allocating the correct size anyway"); + glBufferData(gl_buf_type, buffer->size, NULL, gl_buf_usage); } + glBindBuffer(gl_buf_type, 0); + return handle; } void gpu_buffer_destroy(buffer_handle buffer) {} void gpu_buffer_upload(const void* data) {} -// Textures -/** @brief Create a new GPU texture resource. - * @param create_view creates a texture view (with same dimensions) at the same time - * @param data if not NULL then the data stored at the pointer will be uploaded to the GPU texture - * @note automatically creates a sampler for you */ texture_handle gpu_texture_create(texture_desc desc, bool create_view, const void* data) {} void gpu_texture_destroy(texture_handle) {} void gpu_texture_upload(texture_handle texture, const void* data) {} @@ -279,48 +309,16 @@ u32 shader_create_separate(const char* vert_shader, const char* frag_shader) { return shader_prog; } -// /** @brief Internal backend state */ -// typedef struct opengl_state { -// } opengl_state; - -// bool gfx_backend_init(renderer *ren) { -// INFO("loading OpenGL backend"); - -// // glfwInit(); // Already handled in `renderer_init` -// glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); -// glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); -// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); -// glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); - -// // glad: load all OpenGL function pointers -// if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { -// ERROR("Failed to initialise GLAD \n"); - -// return false; -// } - -// glEnable(GL_DEPTH_TEST); - -// opengl_state *internal = malloc(sizeof(opengl_state)); -// ren->backend_context = (void *)internal; - -// return true; -// } - -// void gfx_backend_draw_frame(renderer *ren, camera *cam, mat4 model, texture *tex) {} - -// void gfx_backend_shutdown(renderer *ren) {} - -void uniform_vec3f(u32 program_id, const char* uniform_name, vec3* value) { +inline void uniform_vec3f(u32 program_id, const char* uniform_name, vec3* value) { glUniform3fv(glGetUniformLocation(program_id, uniform_name), 1, &value->x); } -void uniform_f32(u32 program_id, const char* uniform_name, f32 value) { +inline void uniform_f32(u32 program_id, const char* uniform_name, f32 value) { glUniform1f(glGetUniformLocation(program_id, uniform_name), value); } -void uniform_i32(u32 program_id, const char* uniform_name, i32 value) { +inline void uniform_i32(u32 program_id, const char* uniform_name, i32 value) { glUniform1i(glGetUniformLocation(program_id, uniform_name), value); } -void uniform_mat4f(u32 program_id, const char* uniform_name, mat4* value) { +inline void uniform_mat4f(u32 program_id, const char* uniform_name, mat4* value) { glUniformMatrix4fv(glGetUniformLocation(program_id, uniform_name), 1, GL_FALSE, value->data); } @@ -377,60 +375,4 @@ void uniform_mat4f(u32 program_id, const char* uniform_name, mat4* value) { // u32 gl_primitive = to_gl_prim_topology(primitive); // glDrawArrays(gl_primitive, start_index, count); // } - -// shader shader_create_separate(const char *vert_shader, const char *frag_shader) { -// INFO("Load shaders at %s and %s", vert_shader, frag_shader); -// int success; -// char info_log[512]; - -// u32 vertex = glCreateShader(GL_VERTEX_SHADER); -// const char *vertex_shader_src = string_from_file(vert_shader); -// if (vertex_shader_src == NULL) { -// ERROR("EXIT: couldnt load shader"); -// exit(-1); -// } -// glShaderSource(vertex, 1, &vertex_shader_src, NULL); -// glCompileShader(vertex); -// glGetShaderiv(vertex, GL_COMPILE_STATUS, &success); -// if (!success) { -// glGetShaderInfoLog(vertex, 512, NULL, info_log); -// printf("%s\n", info_log); -// ERROR("EXIT: vertex shader compilation failed"); -// exit(-1); -// } - -// // fragment shader -// u32 fragment = glCreateShader(GL_FRAGMENT_SHADER); -// const char *fragment_shader_src = string_from_file(frag_shader); -// if (fragment_shader_src == NULL) { -// ERROR("EXIT: couldnt load shader"); -// exit(-1); -// } -// glShaderSource(fragment, 1, &fragment_shader_src, NULL); -// glCompileShader(fragment); -// glGetShaderiv(fragment, GL_COMPILE_STATUS, &success); -// if (!success) { -// glGetShaderInfoLog(fragment, 512, NULL, info_log); -// printf("%s\n", info_log); -// ERROR("EXIT: fragment shader compilation failed"); -// exit(-1); -// } - -// u32 shader_prog; -// shader_prog = glCreateProgram(); - -// glAttachShader(shader_prog, vertex); -// glAttachShader(shader_prog, fragment); -// glLinkProgram(shader_prog); -// glDeleteShader(vertex); -// glDeleteShader(fragment); -// free((char *)vertex_shader_src); -// free((char *)fragment_shader_src); - -// shader s = { .program_id = shader_prog }; -// return s; -// } - -// void set_shader(shader s) { glUseProgram(s.program_id); } - #endif diff --git a/src/renderer/backends/opengl/backend_opengl.h b/src/renderer/backends/opengl/backend_opengl.h index a9835c1..91de38d 100644 --- a/src/renderer/backends/opengl/backend_opengl.h +++ b/src/renderer/backends/opengl/backend_opengl.h @@ -4,6 +4,9 @@ #include "defines.h" #include "maths_types.h" +#include "ral_types.h" + +#define MAX_PIPELINE_UNIFORM_BUFFERS 32 typedef struct gpu_swapchain { u32x2 dimensions; @@ -15,13 +18,14 @@ typedef struct gpu_pipeline_layout { } gpu_pipeline_layout; typedef struct gpu_pipeline { u32 shader_id; - u32 vao; + vertex_description vertex_desc; + buffer_handle uniform_bindings[MAX_PIPELINE_UNIFORM_BUFFERS]; } gpu_pipeline; typedef struct gpu_renderpass { void *pad } gpu_renderpass; typedef struct gpu_cmd_encoder { - void *pad + gpu_pipeline *pipeline; } gpu_cmd_encoder; // Recording typedef struct gpu_cmd_buffer { void *pad @@ -31,6 +35,7 @@ typedef struct gpu_buffer { union { u32 vbo; u32 ibo; + u32 ubo; } id; u32 vao; // Optional u64 size; diff --git a/src/renderer/backends/opengl/opengl_helpers.h b/src/renderer/backends/opengl/opengl_helpers.h index 44d40cb..405a8f1 100644 --- a/src/renderer/backends/opengl/opengl_helpers.h +++ b/src/renderer/backends/opengl/opengl_helpers.h @@ -1,4 +1,10 @@ +#if defined(CEL_REND_BACKEND_OPENGL) #pragma once +#include "backend_opengl.h" +#include "log.h" +#include "ral.h" +#include "ral_types.h" + #include #include #include "ral_types.h" @@ -6,7 +12,8 @@ typedef struct opengl_vertex_attr { u32 count; GLenum data_type; } opengl_vertex_attr; -opengl_vertex_attr format_from_vertex_attr(vertex_attrib_type attr) { + +static opengl_vertex_attr format_from_vertex_attr(vertex_attrib_type attr) { switch (attr) { case ATTR_F32: return (opengl_vertex_attr){ .count = 1, .data_type = GL_FLOAT }; @@ -31,6 +38,36 @@ opengl_vertex_attr format_from_vertex_attr(vertex_attrib_type attr) { case ATTR_U32x4: // return VK_FORMAT_R32G32B32A32_UINT; case ATTR_I32x4: - return (opengl_vertex_attr){ .count = 4, .data_type = GL_INT }; + return (opengl_vertex_attr){ .count = 4, .data_type = GL_INT }; + } +} + +static u32 opengl_bindcreate_vao(gpu_buffer* buf, vertex_description desc) { + // 1. Bind the buffer + glBindBuffer(GL_ARRAY_BUFFER, buf->id.vbo); + // 2. Create new VAO + u32 vao; + glGenVertexArrays(1, &vao); + glBindVertexArray(vao); + + // Attributes + u32 attr_count = desc.attributes_count; + printf("N attributes %d\n", attr_count); + u64 offset = 0; + size_t vertex_size = desc.stride; + for (u32 i = 0; i < desc.attributes_count; i++) { + opengl_vertex_attr format = format_from_vertex_attr(desc.attributes[i]); + glVertexAttribPointer(i, format.count, format.data_type, GL_FALSE, vertex_size, (void*)offset); + TRACE(" %d %d %d %d %d %s", i, format.count, format.data_type, vertex_size, offset, + desc.attr_names[i]); + glEnableVertexAttribArray(i); // nth index + size_t this_offset = vertex_attrib_size(desc.attributes[i]); + printf("offset total %lld this attr %ld\n", offset, this_offset); + offset += this_offset; } -} \ No newline at end of file + glBindBuffer(GL_ARRAY_BUFFER, 0); + + return vao; +} + +#endif diff --git a/src/renderer/ral.c b/src/renderer/ral.c index fe12b4f..123c932 100644 --- a/src/renderer/ral.c +++ b/src/renderer/ral.c @@ -68,4 +68,9 @@ void resource_pools_init(arena* a, struct resource_pools* res_pools) { res_pools->textures = tex_pool; // context.resource_pools = res_pools; -} \ No newline at end of file +} + +void print_shader_binding(shader_binding b) { + printf("Binding name: %s type %s vis %d stores data %d\n", b.label, + shader_binding_type_name[b.type], b.vis, b.stores_data); +} diff --git a/src/renderer/ral.h b/src/renderer/ral.h index 3415b04..067847b 100644 --- a/src/renderer/ral.h +++ b/src/renderer/ral.h @@ -44,6 +44,10 @@ TYPED_POOL(gpu_pipeline_layout, pipeline_layout); TYPED_POOL(gpu_pipeline, pipeline); TYPED_POOL(gpu_renderpass, renderpass); +// --- Handy macros +#define BUFFER_GET(h) (buffer_pool_get(&context.resource_pools->buffers, h)) +#define TEXTURE_GET(h) (texture_pool_get(&context.resource_pools->textures, h)) + // --- Pools typedef struct gpu_backend_pools { pipeline_pool pipelines; @@ -69,7 +73,7 @@ typedef struct shader_desc { str8 filepath; // Where it came from str8 code; // Either GLSL or SPIRV bytecode bool is_spirv; - bool is_combined_vert_frag; // Contains both vertex and fragment stages + bool is_combined_vert_frag; // Contains both vertex and fragment stages } shader_desc; struct graphics_pipeline_desc { @@ -149,7 +153,7 @@ void encode_set_default_settings(gpu_cmd_encoder* encoder); void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf); void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf); void encode_set_bind_group(); // TODO -void encode_draw(gpu_cmd_encoder* encoder); +void encode_draw(gpu_cmd_encoder* encoder, u64 count); void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count); void encode_clear_buffer(gpu_cmd_encoder* encoder, buffer_handle buf); @@ -182,3 +186,4 @@ void gpu_temp_draw(size_t n_verts); // --- Helpers vertex_description static_3d_vertex_description(); +size_t vertex_attrib_size(vertex_attrib_type attr); diff --git a/src/renderer/ral_types.h b/src/renderer/ral_types.h index 415796c..f1f7809 100644 --- a/src/renderer/ral_types.h +++ b/src/renderer/ral_types.h @@ -201,6 +201,10 @@ typedef enum shader_binding_type { SHADER_BINDING_COUNT } shader_binding_type; +static const char* shader_binding_type_name[] = { "BUFFER", "BUFFER ARRAY", "TEXTURE", + "TEXTURE ARRAY", "SAMPLER", "BYTES", + "COUNT" }; + // pub trait ShaderBindable: Clone + Copy { // fn bind_to(&self, context: &mut PipelineContext, index: u32); // } @@ -228,6 +232,8 @@ typedef struct shader_binding { #define MAX_LAYOUT_BINDINGS 8 +void print_shader_binding(shader_binding b); + /** @brief A list of bindings that describe what data a shader / pipeline expects @note This roughly correlates to a descriptor set layout in Vulkan */ diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h index a2c35fe..349f65a 100644 --- a/src/renderer/render_types.h +++ b/src/renderer/render_types.h @@ -10,6 +10,7 @@ */ #pragma once +#include "defines.h" #include "ral.h" #include "ral_types.h" #if defined(CEL_PLATFORM_WINDOWS) diff --git a/xmake.lua b/xmake.lua index 86a673a..6af1402 100644 --- a/xmake.lua +++ b/xmake.lua @@ -20,7 +20,7 @@ end -- Platform defines and system packages if is_plat("linux") then add_defines("CEL_PLATFORM_LINUX") - add_syslinks("dl", "X11", "pthread") + add_syslinks("dl", "X11", "pthread", "vulkan") elseif is_plat("windows") then add_defines("CEL_PLATFORM_WINDOWS") add_syslinks("user32", "gdi32", "kernel32", "shell32") @@ -63,7 +63,6 @@ local core_sources = { "src/renderer/*.c", "src/renderer/backends/*.c", "src/renderer/backends/opengl/*.c", - "src/renderer/backends/metal/*.m", "src/resources/*.c", "src/std/*.c", "src/std/containers/*.c", @@ -133,6 +132,9 @@ target("core_config") add_linkdirs("$(env VULKAN_SDK)/Lib", {public = true}) add_links("vulkan-1") end + if is_plat("macosx") then + add_files("src/renderer/backends/metal/*.m") + end set_default(false) -- prevents standalone building of this target target("core_static") -- cgit v1.2.3-70-g09d2 From d4ff15d9cd82a6e3bc71da9d04ee0f250460cef1 Mon Sep 17 00:00:00 2001 From: Omniscient Date: Sun, 9 Jun 2024 14:55:53 +1000 Subject: fix cube --- assets/shaders/cube.frag | 2 +- assets/shaders/cube.vert | 8 ++++-- examples/cube/ex_cube.c | 16 ++++++++--- src/maths/maths.h | 1 + src/renderer/backends/opengl/backend_opengl.c | 39 ++++++++++++++++++--------- src/renderer/backends/opengl/opengl_helpers.h | 2 +- src/renderer/render.c | 1 + 7 files changed, 49 insertions(+), 20 deletions(-) (limited to 'assets/shaders/cube.vert') diff --git a/assets/shaders/cube.frag b/assets/shaders/cube.frag index 796f1c8..9d8ab28 100644 --- a/assets/shaders/cube.frag +++ b/assets/shaders/cube.frag @@ -9,5 +9,5 @@ layout(location = 0) out vec4 outColor; void main() { // outColor = texture(texSampler, fragTexCoord); // vec4(fragTexCoord, 0.0); - outColor = vec4(1.0); + outColor = vec4(fragColor, 1.0); } diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert index 57475e7..e7d6a79 100644 --- a/assets/shaders/cube.vert +++ b/assets/shaders/cube.vert @@ -1,10 +1,13 @@ #version 430 -layout(binding = 0) uniform Matrices { +layout( binding = 0) uniform Matrices { mat4 model; mat4 view; mat4 proj; } ubo; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; layout(location = 0) in vec3 inPosition; layout(location = 1) in vec3 inNormal; @@ -14,7 +17,8 @@ layout(location = 0) out vec3 fragColor; layout(location = 1) out vec2 fragTexCoord; void main() { - gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0); + // gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0); + gl_Position = projection * view * model * vec4(inPosition, 1.0); // gl_Position = vec4(inPosition, 1.0); fragColor = abs(inNormal); fragTexCoord = inTexCoords; diff --git a/examples/cube/ex_cube.c b/examples/cube/ex_cube.c index a3d5a9f..e85b5c1 100644 --- a/examples/cube/ex_cube.c +++ b/examples/cube/ex_cube.c @@ -62,6 +62,7 @@ int main() { vertex_desc_add(&vertex_input, "inPosition", ATTR_F32x3); vertex_desc_add(&vertex_input, "inNormal", ATTR_F32x3); vertex_desc_add(&vertex_input, "inTexCoords", ATTR_F32x2); + vertex_input.use_full_vertex_size = true; shader_data mvp_uniforms_data = { .data = NULL, .shader_data_get_layout = &mvp_uniforms_layout }; @@ -129,14 +130,23 @@ int main() { transform transform = { .position = vec3(-0.5, -0.5, -0.5), .rotation = quat_from_axis_angle(VEC3_Y, theta, true), .scale = 1.0 }; + /* INFO("Swapchain dimensions x %d y %d", g_core.renderer.swapchain.dimensions.x, + * g_core.renderer.swapchain.dimensions.y); */ + mat4 model = transform_to_mat(&transform); mat4 view, proj; - camera_view_projection(&cam, g_core.renderer.swapchain.dimensions.x, - g_core.renderer.swapchain.dimensions.y, &view, &proj); + camera_view_projection(&cam, 1000, 1000, + /* g_core.renderer.swapchain.dimensions.x, */ + /* g_core.renderer.swapchain.dimensions.y, */ + &view, &proj); mvp_uniforms mvp_data = { .model = model, .view = view, .projection = proj }; my_shader_bind_group shader_bind_data = { .mvp = mvp_data, .tex = texture }; mvp_uniforms_data.data = &shader_bind_data; - encode_bind_shader_data(enc, 0, &mvp_uniforms_data); + /* encode_bind_shader_data(enc, 0, &mvp_uniforms_data); */ + + uniform_mat4f(enc->pipeline->shader_id, "model", &model); + uniform_mat4f(enc->pipeline->shader_id, "view", &view); + uniform_mat4f(enc->pipeline->shader_id, "projection", &proj); // Record draw calls draw_mesh(&cube, &model); diff --git a/src/maths/maths.h b/src/maths/maths.h index 217f2e0..45d69c1 100644 --- a/src/maths/maths.h +++ b/src/maths/maths.h @@ -10,6 +10,7 @@ #include #include +#include "defines.h" #include "maths_types.h" // --- Helpers diff --git a/src/renderer/backends/opengl/backend_opengl.c b/src/renderer/backends/opengl/backend_opengl.c index 073f343..17587a2 100644 --- a/src/renderer/backends/opengl/backend_opengl.c +++ b/src/renderer/backends/opengl/backend_opengl.c @@ -1,12 +1,11 @@ #include +#include #include "colours.h" #include "opengl_helpers.h" #include "ral_types.h" -#define CEL_REND_BACKEND_OPENGL 1 #if defined(CEL_REND_BACKEND_OPENGL) #include #include -#include "camera.h" #include "backend_opengl.h" #include "defines.h" @@ -55,6 +54,7 @@ bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { } glEnable(GL_DEPTH_TEST); + // glFrontFace(GL_CW); return true; } @@ -62,7 +62,7 @@ bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { void gpu_backend_shutdown() {} bool gpu_device_create(gpu_device* out_device) { /* No-op in OpenGL */ } -void gpu_device_destroy() {} +void gpu_device_destroy() { /* No-op in OpenGL */ } // --- Render Pipeline gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) { @@ -91,8 +91,20 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip NULL); // no data right now pipeline->uniform_bindings[binding_id] = ubo_handle; gpu_buffer* ubo_buf = BUFFER_GET(ubo_handle); + + u32 blockIndex = glGetUniformBlockIndex(pipeline->shader_id, "Matrices"); + printf("Block index for Matrices: %d", blockIndex); + u32 blocksize; + glGetActiveUniformBlockiv(pipeline->shader_id, blockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, + &blocksize); + printf("\t with size %d bytes\n", blocksize); + glBindBuffer(GL_UNIFORM_BUFFER, ubo_buf->id.ubo); glBindBufferBase(GL_UNIFORM_BUFFER, binding_j, ubo_buf->id.ubo); + if (blockIndex != GL_INVALID_INDEX) { + printf("Here\n"); + glUniformBlockBinding(pipeline->shader_id, blockIndex, 0); + } // Now we want to store a handle associated with the shader for this } @@ -151,7 +163,7 @@ void copy_buffer_to_image_oneshot(buffer_handle src, texture_handle dst) {} // --- Render commands void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline) { encoder->pipeline = pipeline; - // In OpenGL this is more or less equivalent to just setting the shader + // In OpenGL binding a pipeline is more or less equivalent to just setting the shader glUseProgram(pipeline->shader_id); } void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* data) { @@ -159,14 +171,16 @@ void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* d for (u32 i = 0; i < sdl.bindings_count; i++) { shader_binding binding = sdl.bindings[i]; - print_shader_binding(binding); + /* print_shader_binding(binding); */ if (binding.type == SHADER_BINDING_BYTES) { buffer_handle b = encoder->pipeline->uniform_bindings[i]; gpu_buffer* ubo_buf = BUFFER_GET(b); glBindBuffer(GL_UNIFORM_BUFFER, ubo_buf->id.ubo); glBufferSubData(GL_UNIFORM_BUFFER, 0, ubo_buf->size, data->data); - glBindBuffer(GL_UNIFORM_BUFFER, 0); + /* printf("Size %d\n", ubo_buf->size); */ + + /* glBindBuffer(GL_UNIFORM_BUFFER, 0); */ } } } @@ -174,6 +188,7 @@ void encode_set_default_settings(gpu_cmd_encoder* encoder) {} void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) { gpu_buffer* buffer = BUFFER_GET(buf); if (buffer->vao == 0) { // if no VAO for this vertex buffer, create it + INFO("Setting up VAO"); buffer->vao = opengl_bindcreate_vao(buffer, encoder->pipeline->vertex_desc); } glBindVertexArray(buffer->vao); @@ -208,7 +223,7 @@ buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_f case CEL_BUFFER_UNIFORM: DEBUG("Creating Uniform buffer"); gl_buf_type = GL_UNIFORM_BUFFER; - gl_buf_usage = GL_DYNAMIC_DRAW; + /* gl_buf_usage = GL_DYNAMIC_DRAW; */ buffer->id.ubo = gl_buffer_id; break; case CEL_BUFFER_DEFAULT: @@ -254,7 +269,10 @@ bytebuffer vertices_as_bytebuffer(arena* a, vertex_format format, vertex_darray* // --- TEMP bool gpu_backend_begin_frame() { return true; } -void gpu_backend_end_frame() { glfwSwapBuffers(context.window); } +void gpu_backend_end_frame() { + // TODO: Reset all bindings + glfwSwapBuffers(context.window); +} void gpu_temp_draw(size_t n_verts) {} u32 shader_create_separate(const char* vert_shader, const char* frag_shader) { @@ -370,9 +388,4 @@ inline void uniform_mat4f(u32 program_id, const char* uniform_name, mat4* value) // break; // } // } - -// void draw_primitives(cel_primitive_topology primitive, u32 start_index, u32 count) { -// u32 gl_primitive = to_gl_prim_topology(primitive); -// glDrawArrays(gl_primitive, start_index, count); -// } #endif diff --git a/src/renderer/backends/opengl/opengl_helpers.h b/src/renderer/backends/opengl/opengl_helpers.h index 405a8f1..a3c4014 100644 --- a/src/renderer/backends/opengl/opengl_helpers.h +++ b/src/renderer/backends/opengl/opengl_helpers.h @@ -54,7 +54,7 @@ static u32 opengl_bindcreate_vao(gpu_buffer* buf, vertex_description desc) { u32 attr_count = desc.attributes_count; printf("N attributes %d\n", attr_count); u64 offset = 0; - size_t vertex_size = desc.stride; + size_t vertex_size = desc.use_full_vertex_size ? sizeof(vertex) : desc.stride; for (u32 i = 0; i < desc.attributes_count; i++) { opengl_vertex_attr format = format_from_vertex_attr(desc.attributes[i]); glVertexAttribPointer(i, format.count, format.data_type, GL_FALSE, vertex_size, (void*)offset); diff --git a/src/renderer/render.c b/src/renderer/render.c index 5723c9e..7833ac9 100644 --- a/src/renderer/render.c +++ b/src/renderer/render.c @@ -161,6 +161,7 @@ void draw_mesh(mesh* mesh, mat4* model) { // , mat4* view, mat4* proj) { } // Assume this has already been done /* encode_bind_shader_data(enc, 0, &mvp_uniforms_data); */ + encode_draw_indexed(enc, mesh->index_count); } -- cgit v1.2.3-70-g09d2