diff options
34 files changed, 1138 insertions, 279 deletions
diff --git a/assets/shaders/blinn_phong.frag b/assets/shaders/blinn_phong.frag index a0ba905..267c71b 100644 --- a/assets/shaders/blinn_phong.frag +++ b/assets/shaders/blinn_phong.frag @@ -1,4 +1,4 @@ -#version 410 core +#version 430 core out vec4 FragColor; // A Blinn-Phong material with textures for diffuse and specular @@ -32,7 +32,7 @@ in VS_OUT { vec3 FragPos; vec3 Normal; vec2 TexCoords; - vec4 FragPosLightSpace; + // vec4 FragPosLightSpace; vec4 Color; } fs_in; @@ -94,4 +94,4 @@ vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir) diffuse *= attentuation; specular *= attentuation; return (ambient + diffuse + specular); -}
\ No newline at end of file +} diff --git a/assets/shaders/blinn_phong.vert b/assets/shaders/blinn_phong.vert index 06dc5e7..18609b7 100644 --- a/assets/shaders/blinn_phong.vert +++ b/assets/shaders/blinn_phong.vert @@ -1,28 +1,37 @@ #version 410 core + +struct Uniforms { + mat4 model; + mat4 view; + mat4 projection; +}; + +uniform Uniforms ubo; + // Inputs layout (location = 0) in vec3 inPos; layout (location = 1) in vec3 inNormal; layout (location = 2) in vec2 inTexCoords; -uniform mat4 model; -uniform mat4 view; -uniform mat4 projection; -uniform mat4 lightSpaceMatrix; +// uniform mat4 model; +// uniform mat4 view; +// uniform mat4 projection; +// uniform mat4 lightSpaceMatrix; // Output out VS_OUT { vec3 FragPos; vec3 Normal; vec2 TexCoords; - vec4 FragPosLightSpace; + // vec4 FragPosLightSpace; vec4 Color; } vs_out; void main() { - vs_out.FragPos = vec3(model * vec4(inPos, 1.0)); + vs_out.FragPos = vec3(ubo.model * vec4(inPos, 1.0)); vs_out.Normal = inNormal; vs_out.TexCoords = inTexCoords; - vs_out.FragPosLightSpace = lightSpaceMatrix * vec4(vs_out.FragPos, 1.0); + // vs_out.FragPosLightSpace = lightSpaceMatrix * vec4(vs_out.FragPos, 1.0); vs_out.Color = vec4(1.0); - gl_Position = projection * view * model * vec4(inPos, 1.0); -}
\ No newline at end of file + gl_Position = ubo.projection * ubo.view * ubo.model * vec4(inPos, 1.0); +} diff --git a/assets/shaders/cube.frag b/assets/shaders/cube.frag index 292578f..9d8ab28 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; @@ -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(fragColor, 1.0); } diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert index dc625ec..e7d6a79 100644 --- a/assets/shaders/cube.vert +++ b/assets/shaders/cube.vert @@ -1,11 +1,13 @@ -#version 450 +#version 430 -layout(binding = 0) uniform UniformBufferObject { +layout( binding = 0) uniform Matrices { mat4 model; mat4 view; mat4 proj; -} -ubo; +} ubo; +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; layout(location = 0) in vec3 inPosition; layout(location = 1) in vec3 inNormal; @@ -15,7 +17,9 @@ 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/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/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 <metal_stdlib> + +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 <stdio.h> * 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 68ce0d5..e85b5c1 100644 --- a/examples/cube/ex_cube.c +++ b/examples/cube/ex_cube.c @@ -62,14 +62,21 @@ 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 }; 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/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"); +#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) { @@ -123,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.extent.width, - g_core.renderer.swapchain.extent.height, &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/examples/triangle/ex_triangle.c b/examples/triangle/ex_triangle.c index d57e224..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" @@ -15,15 +16,15 @@ extern core g_core; -const custom_vertex vertices[] = { - (custom_vertex){ .pos = vec2(-0.5, -0.5), .color = vec3(1.0, 1.0, 1.0) }, - (custom_vertex){ .pos = vec2(0.5, -0.5), .color = vec3(1.0, 0.0, 0.0) }, - (custom_vertex){ .pos = vec2(-0.5, 0.5), .color = vec3(0.0, 0.0, 1.0) }, - (custom_vertex){ .pos = vec2(0.5, 0.5), .color = vec3(0.0, 1.0, 0.0) }, -}; -const u32 indices[] = { 2, 1, 0, 1, 2, 3 }; - int main() { + custom_vertex vertices[] = { + (custom_vertex){ .pos = vec2(-0.5, -0.5), .color = vec3(1.0, 1.0, 1.0) }, + (custom_vertex){ .pos = vec2(0.5, -0.5), .color = vec3(1.0, 0.0, 0.0) }, + (custom_vertex){ .pos = vec2(-0.5, 0.5), .color = vec3(0.0, 0.0, 1.0) }, + (custom_vertex){ .pos = vec2(0.5, 0.5), .color = vec3(0.0, 1.0, 0.0) }, + }; + const u32 indices[] = { 2, 1, 0, 1, 2, 3 }; + core_bringup(); arena scratch = arena_create(malloc(1024 * 1024), 1024 * 1024); @@ -35,8 +36,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/triangle.vert.spv"); - str8 frag_path = str8lit("build/linux/x86_64/debug/triangle.frag.spv"); + str8 vert_path, frag_path; +#if defined(CEL_REND_BACKEND_OPENGL) + vert_path = str8lit("assets/shaders/triangle.vert"); + frag_path = str8lit("assets/shaders/triangle.frag"); +#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); if (!vertex_shader.has_value || !fragment_shader.has_value) { @@ -51,7 +58,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, @@ -63,13 +74,13 @@ 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); - // Main loop + // // Main loop while (!should_exit()) { input_update(&g_core.input); @@ -77,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); - // Record draw calls + // // 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 4b6f8c7..9050f25 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) @@ -76,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/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 <math.h> #include <stdio.h> +#include "defines.h" #include "maths_types.h" // --- Helpers 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 <assert.h> diff --git a/src/renderer/archive/render_backend.h b/src/renderer/archive/render_backend.h index da30bcc..6df9c81 100644 --- a/src/renderer/archive/render_backend.h +++ b/src/renderer/archive/render_backend.h @@ -22,7 +22,7 @@ void clear_screen(vec3 colour); void texture_data_upload(texture* tex); void bind_texture(shader s, texture* tex, u32 slot); void bind_mesh_vertex_buffer(void* backend, mesh* mesh); -void draw_primitives(cel_primitive_topology primitive, u32 start_index, u32 count); +// void draw_primitives(cel_primitive_topology primitive, u32 start_index, u32 count); shader shader_create_separate(const char* vert_shader, const char* frag_shader); void set_shader(shader s); diff --git a/src/renderer/archive/render_types.h b/src/renderer/archive/render_types.h index f5ea986..5ee3316 100644 --- a/src/renderer/archive/render_types.h +++ b/src/renderer/archive/render_types.h @@ -147,10 +147,10 @@ typedef struct mesh { u32 vbo, vao; /** OpenGL data. TODO: dont leak OpenGL details */ } mesh; -// #ifndef TYPED_MESH_ARRAY -// KITC_DECL_TYPED_ARRAY(mesh) // creates "mesh_darray" -// #define TYPED_MESH_ARRAY -// #endif +#ifndef TYPED_MESH_ARRAY +KITC_DECL_TYPED_ARRAY(mesh) // creates "mesh_darray" +#define TYPED_MESH_ARRAY +#endif typedef struct model { str8 name; diff --git a/src/renderer/backends/backend_opengl.c b/src/renderer/backends/backend_opengl.c deleted file mode 100644 index 4cd97b5..0000000 --- a/src/renderer/backends/backend_opengl.c +++ /dev/null @@ -1,171 +0,0 @@ -#include <stdlib.h> -#include "camera.h" -#define CEL_PLATFORM_LINUX - -#include "defines.h" -#include "file.h" -#include "log.h" -#include "maths_types.h" -#include "ral.h" - -#if CEL_REND_BACKEND_OPENGL - -#include <glad/glad.h> - -#include <glfw3.h> - -/** @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) { - glUniform3fv(glGetUniformLocation(program_id, uniform_name), 1, &value->x); -} -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) { - glUniform1i(glGetUniformLocation(program_id, uniform_name), value); -} -void uniform_mat4f(u32 program_id, const char *uniform_name, mat4 *value) { - glUniformMatrix4fv(glGetUniformLocation(program_id, uniform_name), 1, GL_FALSE, value->data); -} - -void clear_screen(vec3 colour) { - glClearColor(colour.x, colour.y, colour.z, 1.0f); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); -} - -void texture_data_upload(texture *tex) { - printf("Texture name %s\n", tex->name); - TRACE("Upload texture data"); - u32 texture_id; - glGenTextures(1, &texture_id); - glBindTexture(GL_TEXTURE_2D, texture_id); - tex->texture_id = texture_id; - - // set the texture wrapping parameters - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, - GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - // set texture filtering parameters - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex->width, tex->height, 0, tex->channel_type, - GL_UNSIGNED_BYTE, tex->image_data); - glGenerateMipmap(GL_TEXTURE_2D); - DEBUG("Freeing texture image data after uploading to GPU"); - // stbi_image_free(tex->image_data); // data is on gpu now so we dont need it around -} - -void bind_texture(shader s, texture *tex, u32 slot) { - // printf("bind texture slot %d with texture id %d \n", slot, tex->texture_id); - glActiveTexture(GL_TEXTURE0 + slot); - glBindTexture(GL_TEXTURE_2D, tex->texture_id); -} - -void bind_mesh_vertex_buffer(void *_backend, mesh *mesh) { glBindVertexArray(mesh->vao); } - -static inline GLenum to_gl_prim_topology(enum cel_primitive_topology primitive) { - switch (primitive) { - case CEL_PRIMITIVE_TOPOLOGY_TRIANGLE: - return GL_TRIANGLES; - case CEL_PRIMITIVE_TOPOLOGY_POINT: - case CEL_PRIMITIVE_TOPOLOGY_LINE: - case CEL_PRIMITIVE_TOPOLOGY_LINE_STRIP: - case CEL_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: - case CEL_PRIMITIVE_TOPOLOGY_COUNT: - 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); -} - -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
\ No newline at end of file diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c index 2f8fdf7..8801230 100644 --- a/src/renderer/backends/backend_vulkan.c +++ b/src/renderer/backends/backend_vulkan.c @@ -1,5 +1,10 @@ -#include <assert.h> +#include "defines.h" +#if defined(CEL_REND_BACKEND_VULKAN) + +#define GLFW_INCLUDE_VULKAN #include <glfw3.h> + +#include <assert.h> #include <stddef.h> #include <stdint.h> #include <stdlib.h> @@ -17,7 +22,6 @@ #include "str.h" #include "vulkan_helpers.h" -#include "defines.h" #include "file.h" #include "log.h" #include "ral.h" @@ -401,6 +405,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); @@ -1634,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; @@ -1688,23 +1693,13 @@ void vulkan_transition_image_layout(gpu_texture* texture, VkFormat format, VkIma /* TYPED_POOL(gpu_buffer, buffer); */ /* TYPED_POOL(gpu_texture, texture); */ -void resource_pools_init(arena* a, struct resource_pools* res_pools) { - buffer_pool buf_pool = buffer_pool_create(a, MAX_BUFFERS, sizeof(gpu_buffer)); - res_pools->buffers = buf_pool; - texture_pool tex_pool = texture_pool_create(a, MAX_TEXTURES, sizeof(gpu_texture)); - res_pools->textures = tex_pool; +/* void resource_pools_init(arena* a, struct resource_pools* res_pools) { */ +/* buffer_pool buf_pool = buffer_pool_create(a, MAX_BUFFERS, sizeof(gpu_buffer)); */ +/* res_pools->buffers = buf_pool; */ +/* texture_pool tex_pool = texture_pool_create(a, MAX_TEXTURES, sizeof(gpu_texture)); */ +/* res_pools->textures = tex_pool; */ - context.resource_pools = res_pools; -} +/* context.resource_pools = res_pools; */ +/* } */ -void backend_pools_init(arena* a, gpu_backend_pools* backend_pools) { - pipeline_layout_pool pipeline_layout_pool = - pipeline_layout_pool_create(a, MAX_PIPELINES, sizeof(gpu_pipeline_layout)); - backend_pools->pipeline_layouts = pipeline_layout_pool; - pipeline_pool pipeline_pool = pipeline_pool_create(a, MAX_PIPELINES, sizeof(gpu_pipeline)); - backend_pools->pipelines = pipeline_pool; - renderpass_pool rpass_pool = renderpass_pool_create(a, MAX_RENDERPASSES, sizeof(gpu_renderpass)); - backend_pools->renderpasses = rpass_pool; - - context.gpu_pools; -} +#endif diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h index dc0f7bd..6ca0bb5 100644 --- a/src/renderer/backends/backend_vulkan.h +++ b/src/renderer/backends/backend_vulkan.h @@ -1,9 +1,10 @@ #pragma once +#include "defines.h" +#if defined(CEL_REND_BACKEND_VULKAN) #include <vulkan/vk_platform.h> #include <vulkan/vulkan.h> #include <vulkan/vulkan_core.h> -#include "defines.h" #include "mem.h" #include "ral.h" #include "ral_types.h" @@ -35,6 +36,7 @@ typedef struct gpu_swapchain { VkSwapchainKHR handle; arena swapchain_arena; VkExtent2D extent; + u32x2 dimensions; VkSurfaceFormatKHR image_format; VkPresentModeKHR present_mode; u32 image_count; @@ -113,3 +115,4 @@ typedef struct gpu_texture { VkSampler sampler; char* debug_label; } gpu_texture; +#endif
\ No newline at end of file diff --git a/src/renderer/backends/metal/backend_metal.h b/src/renderer/backends/metal/backend_metal.h new file mode 100644 index 0000000..9561bb6 --- /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 <Foundation/Foundation.h> +#import <Metal/Metal.h> +#import <MetalKit/MetalKit.h> +#import <QuartzCore/CAMetalLayer.h> +#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<MTLDevice> id; +#else + void* id; +#endif +} gpu_device; +typedef struct gpu_pipeline_layout { + void* pad; +} gpu_pipeline_layout; +typedef struct gpu_pipeline { +#ifdef __OBJC__ + id<MTLRenderPipelineState> 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<MTLCommandBuffer> cmd_buffer; + id<MTLRenderCommandEncoder> 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<MTLBuffer> 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 <assert.h> +#define CEL_REND_BACKEND_METAL +#if defined(CEL_REND_BACKEND_METAL) +#include <stddef.h> +#include "ral_types.h" +#include "colours.h" +#include <stdlib.h> +#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 <GLFW/glfw3.h> +#include <GLFW/glfw3native.h> + +#import <Foundation/Foundation.h> +#import <Metal/Metal.h> +#import <MetalKit/MetalKit.h> +#import <QuartzCore/CAMetalLayer.h> +#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<CAMetalDrawable> surface; + + id<MTLCommandQueue> 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<MTLCommandQueue> 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<MTLLibrary> 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<MTLDevice> gpu = MTLCreateSystemDefaultDevice(); + out_device->id = gpu; + context.device = out_device; + + const id<MTLCommandQueue> 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<MTLLibrary> default_library = [context.device->id newLibraryWithFile:myNSString error:&err]; + assert(default_library); + + // setup vertex and fragment shaders + id<MTLFunction> ren_vert = [default_library newFunctionWithName:@"basic_vertex"]; + assert(ren_vert); + id<MTLFunction> 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<MTLDepthStencilState> depth_descriptor = [context.device->id newDepthStencilStateWithDescriptor:depthStencilDescriptor]; + // FIXME: state->depth_state = depth_descriptor; + + id<MTLRenderPipelineState> 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 <MTLCommandBuffer> 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<MTLRenderCommandEncoder> 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<MTLBuffer> 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 new file mode 100644 index 0000000..17587a2 --- /dev/null +++ b/src/renderer/backends/opengl/backend_opengl.c @@ -0,0 +1,391 @@ +#include <stddef.h> +#include <stdio.h> +#include "colours.h" +#include "opengl_helpers.h" +#include "ral_types.h" +#if defined(CEL_REND_BACKEND_OPENGL) +#include <assert.h> +#include <stdlib.h> + +#include "backend_opengl.h" +#include "defines.h" +#include "file.h" +#include "log.h" +#include "maths_types.h" +#include "ral.h" + +#include <glad/glad.h> +#include <glfw3.h> + +typedef struct opengl_context { + GLFWwindow* window; + arena pool_arena; + gpu_cmd_encoder command_buffer; + gpu_backend_pools gpu_pools; + struct resource_pools* resource_pools; +} opengl_context; + +static opengl_context context; + +struct GLFWwindow; + +bool gpu_backend_init(const char* window_name, struct GLFWwindow* window) { + INFO("loading OpenGL backend"); + + memset(&context, 0, sizeof(opengl_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_CONTEXT_VERSION_MAJOR, 4); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + 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); + // glFrontFace(GL_CW); + + return true; +} + +void gpu_backend_shutdown() {} + +bool gpu_device_create(gpu_device* out_device) { /* No-op in OpenGL */ } +void gpu_device_destroy() { /* No-op in OpenGL */ } + +// --- Render Pipeline +gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) { + gpu_pipeline* pipeline = pipeline_pool_alloc(&context.gpu_pools.pipelines, NULL); + + // Create shader program + u32 shader_id = shader_create_separate(description.vs.filepath.buf, description.fs.filepath.buf); + pipeline->shader_id = shader_id; + + // Vertex format + pipeline->vertex_desc = description.vertex_desc; + + // Allocate uniform buffers if needed + printf("data layouts %d\n", description.data_layouts_count); + for (u32 layout_i = 0; layout_i < description.data_layouts_count; layout_i++) { + shader_data_layout sdl = description.data_layouts[layout_i].shader_data_get_layout(NULL); + 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); + + 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 + } + } + } + + return pipeline; +} +void gpu_pipeline_destroy(gpu_pipeline* pipeline) {} + +// --- Renderpass +gpu_renderpass* gpu_renderpass_create(const gpu_renderpass_desc* description) {} +void gpu_renderpass_destroy(gpu_renderpass* pass) {} + +// --- Swapchain +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 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) { + 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() { return &context.command_buffer; } + +/** @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) {} + +// --- Data copy commands +/** @brief Copy data from one buffer to another */ +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) { + // 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, + u64 dst_offset, u64 copy_size) {} +/** @brief Copy data from buffer to an image using a one time submit command buffer */ +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 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) { + shader_data_layout sdl = data->shader_data_get_layout(data->data); + + 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); + /* printf("Size %d\n", ubo_buf->size); */ + + /* 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) { + 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); +} +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]); + break; + } + // bind buffer + glBindBuffer(gl_buf_type, gl_buffer_id); + + if (data) { + TRACE("Upload data (%d bytes) as part of buffer creation", size); + 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) {} + +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) {} + +// --- Vertex formats +bytebuffer vertices_as_bytebuffer(arena* a, vertex_format format, vertex_darray* vertices) {} + +// --- TEMP +bool gpu_backend_begin_frame() { return true; } +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) { + 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); + + return shader_prog; +} + +inline void uniform_vec3f(u32 program_id, const char* uniform_name, vec3* value) { + glUniform3fv(glGetUniformLocation(program_id, uniform_name), 1, &value->x); +} +inline void uniform_f32(u32 program_id, const char* uniform_name, f32 value) { + glUniform1f(glGetUniformLocation(program_id, uniform_name), value); +} +inline void uniform_i32(u32 program_id, const char* uniform_name, i32 value) { + glUniform1i(glGetUniformLocation(program_id, uniform_name), 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); +} + +// void clear_screen(vec3 colour) { +// glClearColor(colour.x, colour.y, colour.z, 1.0f); +// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); +// } + +// void texture_data_upload(texture *tex) { +// printf("Texture name %s\n", tex->name); +// TRACE("Upload texture data"); +// u32 texture_id; +// glGenTextures(1, &texture_id); +// glBindTexture(GL_TEXTURE_2D, texture_id); +// tex->texture_id = texture_id; + +// // set the texture wrapping parameters +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, +// GL_REPEAT); // set texture wrapping to GL_REPEAT (default wrapping method) +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); +// // set texture filtering parameters +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); +// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + +// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tex->width, tex->height, 0, tex->channel_type, +// GL_UNSIGNED_BYTE, tex->image_data); +// glGenerateMipmap(GL_TEXTURE_2D); +// DEBUG("Freeing texture image data after uploading to GPU"); +// // stbi_image_free(tex->image_data); // data is on gpu now so we dont need it around +// } + +// void bind_texture(shader s, texture *tex, u32 slot) { +// // printf("bind texture slot %d with texture id %d \n", slot, tex->texture_id); +// glActiveTexture(GL_TEXTURE0 + slot); +// glBindTexture(GL_TEXTURE_2D, tex->texture_id); +// } + +// void bind_mesh_vertex_buffer(void *_backend, mesh *mesh) { glBindVertexArray(mesh->vao); } + +// static inline GLenum to_gl_prim_topology(enum cel_primitive_topology primitive) { +// switch (primitive) { +// case CEL_PRIMITIVE_TOPOLOGY_TRIANGLE: +// return GL_TRIANGLES; +// case CEL_PRIMITIVE_TOPOLOGY_POINT: +// case CEL_PRIMITIVE_TOPOLOGY_LINE: +// case CEL_PRIMITIVE_TOPOLOGY_LINE_STRIP: +// case CEL_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: +// case CEL_PRIMITIVE_TOPOLOGY_COUNT: +// break; +// } +// } +#endif diff --git a/src/renderer/backends/opengl/backend_opengl.h b/src/renderer/backends/opengl/backend_opengl.h new file mode 100644 index 0000000..91de38d --- /dev/null +++ b/src/renderer/backends/opengl/backend_opengl.h @@ -0,0 +1,53 @@ +#pragma once + +#ifdef CEL_REND_BACKEND_OPENGL + +#include "defines.h" +#include "maths_types.h" +#include "ral_types.h" + +#define MAX_PIPELINE_UNIFORM_BUFFERS 32 + +typedef struct gpu_swapchain { + u32x2 dimensions; +} gpu_swapchain; +typedef struct gpu_device { +} gpu_device; +typedef struct gpu_pipeline_layout { + void *pad +} gpu_pipeline_layout; +typedef struct gpu_pipeline { + u32 shader_id; + 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 { + gpu_pipeline *pipeline; +} gpu_cmd_encoder; // Recording +typedef struct gpu_cmd_buffer { + void *pad +} gpu_cmd_buffer; // Ready for submission + +typedef struct gpu_buffer { + union { + u32 vbo; + u32 ibo; + u32 ubo; + } id; + u32 vao; // Optional + u64 size; +} gpu_buffer; +typedef struct gpu_texture { + void *pad +} gpu_texture; + +u32 shader_create_separate(const char *vert_shader, const char *frag_shader); + +void uniform_vec3f(u32 program_id, const char *uniform_name, vec3 *value); +void uniform_f32(u32 program_id, const char *uniform_name, f32 value); +void uniform_i32(u32 program_id, const char *uniform_name, i32 value); +void uniform_mat4f(u32 program_id, const char *uniform_name, mat4 *value); +#endif diff --git a/src/renderer/backends/opengl/opengl_helpers.h b/src/renderer/backends/opengl/opengl_helpers.h new file mode 100644 index 0000000..a3c4014 --- /dev/null +++ b/src/renderer/backends/opengl/opengl_helpers.h @@ -0,0 +1,73 @@ +#if defined(CEL_REND_BACKEND_OPENGL) +#pragma once +#include "backend_opengl.h" +#include "log.h" +#include "ral.h" +#include "ral_types.h" + +#include <glad/glad.h> +#include <glfw3.h> +#include "ral_types.h" +typedef struct opengl_vertex_attr { + u32 count; + GLenum data_type; +} opengl_vertex_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 }; + case ATTR_U32: + return (opengl_vertex_attr){ .count = 1, .data_type = GL_UNSIGNED_INT }; + case ATTR_I32: + return (opengl_vertex_attr){ .count = 1, .data_type = GL_INT }; + case ATTR_F32x2: + 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 }; + 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 }; + case ATTR_U32x4: + // return VK_FORMAT_R32G32B32A32_UINT; + case ATTR_I32x4: + 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.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); + 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; + } + glBindBuffer(GL_ARRAY_BUFFER, 0); + + return vao; +} + +#endif diff --git a/src/renderer/ral.c b/src/renderer/ral.c index 7d868be..123c932 100644 --- a/src/renderer/ral.c +++ b/src/renderer/ral.c @@ -1,5 +1,13 @@ #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) { case ATTR_F32: @@ -40,3 +48,29 @@ vertex_description static_3d_vertex_description() { vertex_desc_add(&builder, "texCoords", ATTR_F32x2); return builder; } + +void backend_pools_init(arena* a, gpu_backend_pools* backend_pools) { + pipeline_layout_pool pipeline_layout_pool = + pipeline_layout_pool_create(a, MAX_PIPELINES, sizeof(gpu_pipeline_layout)); + backend_pools->pipeline_layouts = pipeline_layout_pool; + pipeline_pool pipeline_pool = pipeline_pool_create(a, MAX_PIPELINES, sizeof(gpu_pipeline)); + backend_pools->pipelines = pipeline_pool; + renderpass_pool rpass_pool = renderpass_pool_create(a, MAX_RENDERPASSES, sizeof(gpu_renderpass)); + backend_pools->renderpasses = rpass_pool; + + // context.gpu_pools; +} + +void resource_pools_init(arena* a, struct resource_pools* res_pools) { + buffer_pool buf_pool = buffer_pool_create(a, MAX_BUFFERS, sizeof(gpu_buffer)); + res_pools->buffers = buf_pool; + texture_pool tex_pool = texture_pool_create(a, MAX_TEXTURES, sizeof(gpu_texture)); + res_pools->textures = tex_pool; + + // context.resource_pools = res_pools; +} + +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 1ca37b4..067847b 100644 --- a/src/renderer/ral.h +++ b/src/renderer/ral.h @@ -44,17 +44,23 @@ 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; pipeline_layout_pool pipeline_layouts; renderpass_pool renderpasses; } gpu_backend_pools; +void backend_pools_init(arena* a, gpu_backend_pools* backend_pools); struct resource_pools { buffer_pool buffers; texture_pool textures; }; +void resource_pools_init(arena* a, struct resource_pools* res_pools); // --- Pipeline description typedef enum pipeline_kind { @@ -64,9 +70,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 { @@ -146,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); @@ -179,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 704f2cb..f1f7809 100644 --- a/src/renderer/ral_types.h +++ b/src/renderer/ral_types.h @@ -77,6 +77,11 @@ typedef enum gpu_buffer_type { CEL_BUFFER_COUNT } gpu_buffer_type; +static const char* buffer_type_names[] = { + "RAL Buffer Default", "RAL Buffer Vertex", "RAL Buffer Index", + "RAL Buffer Uniform", "RAL Buffer Count", +}; + typedef enum gpu_buffer_flag { CEL_BUFFER_FLAG_CPU = 1 << 0, CEL_BUFFER_FLAG_GPU = 1 << 1, @@ -196,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); // } @@ -223,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.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); } diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h index cc5fd93..349f65a 100644 --- a/src/renderer/render_types.h +++ b/src/renderer/render_types.h @@ -10,12 +10,19 @@ */ #pragma once +#include "defines.h" #include "ral.h" #include "ral_types.h" #if defined(CEL_PLATFORM_WINDOWS) // #include "backend_dx11.h" #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 struct GLFWwindow; diff --git a/src/resources/gltf.c b/src/resources/gltf.c index 022bf95..61b99d7 100644 --- a/src/resources/gltf.c +++ b/src/resources/gltf.c @@ -47,7 +47,8 @@ model_handle model_load_gltf(struct core *core, const char *path, bool invert_te model model = { 0 }; model.name = str8_cstr_view(path); - model.meshes = mesh_darray_new(1); + // FIXME: Use mesh* malloc'd + /* model.meshes = mesh_darray_new(1); */ // model.materials = material_darray_new(1); bool success = @@ -771,4 +772,4 @@ bool model_load_gltf(const char *path, model *out_model) { TRACE("Finished loading GLTF"); return true; } -*/
\ No newline at end of file +*/ diff --git a/src/resources/obj.c b/src/resources/obj.c index 888e16e..19d8657 100644 --- a/src/resources/obj.c +++ b/src/resources/obj.c @@ -54,7 +54,7 @@ model_handle model_load_obj(core *core, const char *path, bool invert_textures_y model model = { 0 }; model.name = str8_cstr_view(path); - model.meshes = mesh_darray_new(1); + /* model.meshes = mallocmesh_darray_new(1); */ // model.materials = material_darray_new(1); bool success = model_load_obj_str(file_string, relative_path.path, &model, invert_textures_y); @@ -228,6 +228,8 @@ bool model_load_obj_str(const char *file_string, str8 relative_path, model *out_ // // TODO: bounding box calculation for each mesh // // TODO: bounding box calculation for model + // TODO: copy from mesh_darray to malloc'd mesh* array + return true; } diff --git a/src/std/mem.c b/src/std/mem.c index a5321fb..ede1db4 100644 --- a/src/std/mem.c +++ b/src/std/mem.c @@ -46,15 +46,18 @@ void arena_rewind(arena_save savepoint) { savepoint.arena->curr = savepoint.save // --- Pool -void_pool void_pool_create(arena* a, u64 capacity, u64 entry_size) { +void_pool void_pool_create(arena* a, const char* debug_label, u64 capacity, u64 entry_size) { size_t memory_requirements = capacity * entry_size; void* backing_buf = arena_alloc(a, memory_requirements); + assert(entry_size >= sizeof(void_pool_header)); // TODO: create my own assert with error message + void_pool pool = { .capacity = capacity, .entry_size = entry_size, .count = 0, .backing_buffer = backing_buf, - .free_list_head = NULL }; + .free_list_head = NULL, + .debug_label = debug_label }; void_pool_free_all(&pool); @@ -99,7 +102,7 @@ void* void_pool_alloc(void_pool* pool, u32* out_raw_handle) { uintptr_t start = (uintptr_t)pool->backing_buffer; uintptr_t cur = (uintptr_t)free_node; TRACE("%ld %ld ", start, cur); - /* assert(cur > start); */ + assert(cur > start); u32 index = (u32)((cur - start) / pool->entry_size); printf("Index %d\n", index); if (out_raw_handle != NULL) { diff --git a/src/std/mem.h b/src/std/mem.h index 1d508ce..6e76763 100644 --- a/src/std/mem.h +++ b/src/std/mem.h @@ -48,9 +48,10 @@ typedef struct void_pool { u64 count; void* backing_buffer; void_pool_header* free_list_head; + const char* debug_label; } void_pool; -void_pool void_pool_create(arena* a, u64 capacity, u64 entry_size); +void_pool void_pool_create(arena* a, const char* debug_label, u64 capacity, u64 entry_size); void void_pool_free_all(void_pool* pool); bool void_pool_is_empty(void_pool* pool); bool void_pool_is_full(void_pool* pool); @@ -68,7 +69,7 @@ void void_pool_dealloc(void_pool* pool, u32 raw_handle); } Name##_pool; \ \ static Name##_pool Name##_pool_create(arena* a, u64 cap, u64 entry_size) { \ - void_pool p = void_pool_create(a, cap, entry_size); \ + void_pool p = void_pool_create(a, "\"" #Name "\"", cap, entry_size); \ return (Name##_pool){ .inner = p }; \ } \ static inline T* Name##_pool_get(Name##_pool* pool, Name##_handle handle) { \ diff --git a/tests/pool_tests.c b/tests/pool_tests.c index df65773..10a4bed 100644 --- a/tests/pool_tests.c +++ b/tests/pool_tests.c @@ -20,7 +20,7 @@ TEST(Pool, SanityCheckTest) { TEST_ASSERT_EQUAL(true, true); } TEST(Pool, Initialisation) { // u32 pool - void_pool pool = void_pool_create(&a, 256, sizeof(u32)); + void_pool pool = void_pool_create(&a, "Test pool", 256, sizeof(u32)); u32 x_handle; u32* x_ptr = (u32*)void_pool_alloc(&pool, &x_handle); // store something in it @@ -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 @@ -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", "vulkan") elseif is_plat("windows") then add_defines("CEL_PLATFORM_WINDOWS") add_syslinks("user32", "gdi32", "kernel32", "shell32") @@ -31,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 +62,7 @@ local core_sources = { "src/physics/*.c", "src/renderer/*.c", "src/renderer/backends/*.c", + "src/renderer/backends/opengl/*.c", "src/resources/*.c", "src/std/*.c", "src/std/containers/*.c", @@ -94,12 +95,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}) @@ -113,23 +113,28 @@ target("core_config") add_includedirs("src/physics/", {public = true}) 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}) add_includedirs("src/systems/", {public = true}) add_files("src/empty.c") -- for some reason we need this on Mac so it doesnt call 'ar' with no files and error - add_rules("compile_glsl_vert_shaders") - add_rules("compile_glsl_frag_shaders") - add_files("assets/shaders/triangle.vert") - add_files("assets/shaders/triangle.frag") - add_files("assets/shaders/cube.vert") - add_files("assets/shaders/cube.frag") + -- add_rules("compile_glsl_vert_shaders") + -- add_rules("compile_glsl_frag_shaders") + -- add_files("assets/shaders/triangle.vert") + -- add_files("assets/shaders/triangle.frag") + -- add_files("assets/shaders/cube.vert") + -- add_files("assets/shaders/cube.frag") -- add_files("assets/shaders/*.frag") if is_plat("windows") then add_includedirs("$(env VULKAN_SDK)/Include", {public = true}) 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") @@ -166,10 +171,19 @@ 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") set_group("examples") + -- add_defines("CEL_REND_BACKEND_OPENGL") add_deps("core_static") add_files("examples/cube/ex_cube.c") set_rundir("$(projectdir)") |