From 824579234685171f0ca78674c7c18dfe6b43fe6e Mon Sep 17 00:00:00 2001 From: omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Wed, 29 May 2024 14:10:55 +1000 Subject: start adding opengl backend --- examples/cube/ex_cube.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'examples/cube/ex_cube.c') diff --git a/examples/cube/ex_cube.c b/examples/cube/ex_cube.c index 68ce0d5..b87071f 100644 --- a/examples/cube/ex_cube.c +++ b/examples/cube/ex_cube.c @@ -125,8 +125,8 @@ int main() { .scale = 1.0 }; mat4 model = transform_to_mat(&transform); mat4 view, proj; - camera_view_projection(&cam, g_core.renderer.swapchain.extent.width, - g_core.renderer.swapchain.extent.height, &view, &proj); + camera_view_projection(&cam, 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; -- cgit v1.2.3-70-g09d2 From baf787b9eb742b0c52ecf8c9ae319dbfb4ea0f1b Mon Sep 17 00:00:00 2001 From: Omniscient <17525998+omnisci3nce@users.noreply.github.com> Date: Wed, 29 May 2024 14:50:49 +1000 Subject: opengl clear color working --- examples/cube/ex_cube.c | 10 ++++++-- src/defines.h | 5 ++-- src/renderer/archive/old_backend_vulkan.c | 6 ++--- src/renderer/backends/backend_vulkan.c | 2 +- src/renderer/backends/opengl/backend_opengl.c | 37 ++++++++++++++++++++++----- src/renderer/backends/opengl/backend_opengl.h | 4 +-- src/renderer/render_types.h | 2 ++ xmake.lua | 7 +++-- 8 files changed, 51 insertions(+), 22 deletions(-) (limited to 'examples/cube/ex_cube.c') diff --git a/examples/cube/ex_cube.c b/examples/cube/ex_cube.c index b87071f..7b0ab48 100644 --- a/examples/cube/ex_cube.c +++ b/examples/cube/ex_cube.c @@ -68,8 +68,14 @@ int main() { gpu_renderpass_desc pass_description = {}; gpu_renderpass* renderpass = gpu_renderpass_create(&pass_description); - str8 vert_path = str8lit("build/linux/x86_64/debug/cube.vert.spv"); - str8 frag_path = str8lit("build/linux/x86_64/debug/cube.frag.spv"); + 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"); +#else + vert_path = str8lit("build/linux/x86_64/debug/cube.vert.spv"); + frag_path = str8lit("build/linux/x86_64/debug/cube.frag.spv"); +#endif str8_opt vertex_shader = str8_from_file(&scratch, vert_path); str8_opt fragment_shader = str8_from_file(&scratch, frag_path); if (!vertex_shader.has_value || !fragment_shader.has_value) { diff --git a/src/defines.h b/src/defines.h index 4b6f8c7..a35dbf4 100644 --- a/src/defines.h +++ b/src/defines.h @@ -64,10 +64,11 @@ Renderer backend defines: #define CEL_REND_BACKEND_METAL 1 */ +// NOTE: The below is now handled in xmake.lua // Platform will inform renderer backend (unless user overrides) #if defined(CEL_PLATFORM_LINUX) -// #define CEL_REND_BACKEND_OPENGL 1 -#define CEL_REND_BACKEND_VULKAN 1 +#define CEL_REND_BACKEND_OPENGL 1 +// #define CEL_REND_BACKEND_VULKAN 1 #endif #if defined(CEL_PLATFORM_WINDOWS) diff --git a/src/renderer/archive/old_backend_vulkan.c b/src/renderer/archive/old_backend_vulkan.c index a18ca70..0dfba98 100644 --- a/src/renderer/archive/old_backend_vulkan.c +++ b/src/renderer/archive/old_backend_vulkan.c @@ -1,8 +1,8 @@ -#include "camera.h" -#include "primitives.h" #define CDEBUG -#define CEL_REND_BACKEND_VULKAN 1 +// #define CEL_REND_BACKEND_VULKAN 1 #if CEL_REND_BACKEND_VULKAN +#include "camera.h" +#include "primitives.h" // ^ Temporary #include diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c index 10358f1..c3fad75 100644 --- a/src/renderer/backends/backend_vulkan.c +++ b/src/renderer/backends/backend_vulkan.c @@ -1,4 +1,4 @@ -#if defined (CEL_REND_BACKEND_VULKAN) +#if defined(CEL_REND_BACKEND_VULKAN) #include #include diff --git a/src/renderer/backends/opengl/backend_opengl.c b/src/renderer/backends/opengl/backend_opengl.c index 4ceba8f..cbc90f2 100644 --- a/src/renderer/backends/opengl/backend_opengl.c +++ b/src/renderer/backends/opengl/backend_opengl.c @@ -1,19 +1,22 @@ +#include "colours.h" #define CEL_REND_BACKEND_OPENGL #if defined(CEL_REND_BACKEND_OPENGL) #include #include "camera.h" +#include "backend_opengl.h" #include "defines.h" #include "file.h" #include "log.h" #include "maths_types.h" #include "ral.h" -#include "backend_opengl.h" #include #include -typedef struct opengl_context {} opengl_context; +typedef struct opengl_context { + GLFWwindow* window; +} opengl_context; static opengl_context context; @@ -21,11 +24,23 @@ struct GLFWwindow; bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { INFO("loading OpenGL backend"); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); + + memset(&context, 0, sizeof(opengl_context)); + context.window = window; + + 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); + return true; } @@ -48,10 +63,17 @@ bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {} void gpu_swapchain_destroy(gpu_swapchain* swapchain) {} // --- Command buffer -gpu_cmd_encoder gpu_cmd_encoder_create(); +gpu_cmd_encoder gpu_cmd_encoder_create() { + gpu_cmd_encoder encoder = { 0 }; + return encoder; +} void gpu_cmd_encoder_destroy(gpu_cmd_encoder* encoder) {} void gpu_cmd_encoder_begin(gpu_cmd_encoder encoder) {} -void gpu_cmd_encoder_begin_render(gpu_cmd_encoder* encoder, gpu_renderpass* renderpass) {} +void gpu_cmd_encoder_begin_render(gpu_cmd_encoder* encoder, gpu_renderpass* renderpass) { + rgba clear_colour = STONE_900; + glClearColor(clear_colour.r, clear_colour.g, clear_colour.b, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); +} void gpu_cmd_encoder_end_render(gpu_cmd_encoder* encoder) {} void gpu_cmd_encoder_begin_compute() {} gpu_cmd_encoder* gpu_get_default_cmd_encoder() {} @@ -104,10 +126,11 @@ bytebuffer vertices_as_bytebuffer(arena* a, vertex_format format, vertex_darray* // --- TEMP bool gpu_backend_begin_frame() { return true; } -void gpu_backend_end_frame() {} +void gpu_backend_end_frame() { + glfwSwapBuffers(context.window); +} void gpu_temp_draw(size_t n_verts) {} - // /** @brief Internal backend state */ // typedef struct opengl_state { // } opengl_state; diff --git a/src/renderer/backends/opengl/backend_opengl.h b/src/renderer/backends/opengl/backend_opengl.h index 3bc742d..649bc7b 100644 --- a/src/renderer/backends/opengl/backend_opengl.h +++ b/src/renderer/backends/opengl/backend_opengl.h @@ -1,8 +1,6 @@ #pragma once -#define CEL_REND_BACKEND_OPENGL - -#if defined(CEL_REND_BACKEND_OPENGL) +#ifdef CEL_REND_BACKEND_OPENGL #include "defines.h" #include "maths_types.h" diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h index ed5c6e1..aeedf85 100644 --- a/src/renderer/render_types.h +++ b/src/renderer/render_types.h @@ -21,6 +21,8 @@ #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 09082ff..5a2707c 100644 --- a/xmake.lua +++ b/xmake.lua @@ -17,11 +17,10 @@ elseif is_mode("release") then add_defines("CRELEASE") end - -- Platform defines and system packages if is_plat("linux") then add_defines("CEL_PLATFORM_LINUX") - add_syslinks("vulkan", "dl", "X11", "pthread") + add_syslinks("dl", "X11", "pthread") elseif is_plat("windows") then add_defines("CEL_PLATFORM_WINDOWS") add_syslinks("user32", "gdi32", "kernel32", "shell32") @@ -95,12 +94,11 @@ rule("compile_glsl_frag_shaders") end) -- TODO: Metal shaders compilation --- - -- common configuration for both static and shared libraries target("core_config") set_kind("static") -- kind is required but you can ignore it since it's just for common settings add_packages("local_glfw") + add_defines("CEL_REND_BACKEND_OPENGL") add_includedirs("deps/cgltf", {public = true}) add_includedirs("deps/glfw-3.3.8/include/GLFW", {public = true}) add_includedirs("deps/glad/include", {public = true}) @@ -172,6 +170,7 @@ target("tri") target("cube") set_kind("binary") set_group("examples") + -- add_defines("CEL_REND_BACKEND_OPENGL") add_deps("core_static") add_files("examples/cube/ex_cube.c") set_rundir("$(projectdir)") -- 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 'examples/cube/ex_cube.c') 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 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 'examples/cube/ex_cube.c') 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