Move pipeline reset to rendering/window

Also set the damn memory to zero

Who could've guessed that you should zero your initialized memory when
you're making assumptions later that uninitizalied members are zero.

1 files changed, 139 insertions, 0 deletions

diff --git a/src/rendering.c b/src/rendering.c
index 296c2ed..8feac35 100644
--- a/src/rendering.c
+++ b/src/rendering.c
@@ -13,6 +13,64 @@
 #include <daw/rendering.h>
 #include <daw/logging.h>
 
+static f32 default_quad[8] = {
+  -1.0f, -1.0f,
+   1.0f, -1.0f,
+   1.0f,  1.0f,
+  -1.0f,  1.0f,
+};
+
+static f32 default_quad_uv[8] = {
+  0.f,  0.f,
+  1.f,  0.f,
+  1.f,  1.f,
+  0.f,  1.f,
+};
+
+static u8 default_quad_ibo[6] = {
+  0, 1, 2,
+  2, 3, 0,
+};
+
+#define DEFAULT_CAMERA { .pos = {3, 0, 0}, .dir = {1, 1, 1}, }
+static Camera default_camera = DEFAULT_CAMERA;
+
+
+// TODO: CREATE DEFAULT SHADERBUFF
+#define COUNT(a) sizeof(a) / sizeof(a[0])
+static ShaderBuffer shaderbuf[3] = {
+  SHADERBUFFER_NEW(f32, COUNT(default_quad),     2, default_quad,     ShaderBuffer_AccessFrequency_static | ShaderBuffer_AccessType_draw | ShaderBuffer_Type_vertexPosition),
+  SHADERBUFFER_NEW(f32, COUNT(default_quad_uv),  2, default_quad_uv,  ShaderBuffer_AccessFrequency_static | ShaderBuffer_AccessType_draw),
+  SHADERBUFFER_NEW(u8,  COUNT(default_quad_ibo), 3, default_quad_ibo, ShaderBuffer_AccessFrequency_static | ShaderBuffer_AccessType_draw | ShaderBuffer_Type_vertexIndex),
+};
+#undef COUNT
+
+static const char* default_quad_shader_vertex_src =
+"#version 330 core\n"
+"\n"
+"layout(location = 0) in vec2 vertexPosition_modelspace;\n"
+"layout(location = 1) in vec2 vertexUV;\n"
+"\n"
+"out vec2 UV;\n"
+"\n"
+"void main() {\n"
+"    gl_Position = vec4(vertexPosition_modelspace, 0, 1);\n"
+"\n"
+"    UV = vertexUV;\n"
+"}";
+
+static const char* default_quad_shader_fragment_src =
+"#version 330 core\n"
+"\n"
+"// Ouput data\n"
+"in vec2 UV;\n"
+"out vec3 color;\n"
+"\n"
+"uniform sampler2D textureSampler;\n"
+"\n"
+"void main() {\n"
+"  color = texture(textureSampler, UV).rgb;\n"
+"}";
 
 /* Extern globals */
 extern Instance* GLOBAL_PLATFORM;
@@ -922,3 +980,84 @@ void r_attach_buffers(void *restrict ctx, u32 fbo, u32* buffers, u32* buffer_par
     }
   }
 }
+
+void framebuffer_size_callback_default(ivec3* dst,ivec2 src) {
+  glm_ivec2_copy(src, *dst);
+}
+
+void camera_reset_callback_default(Camera* dst, void* state, ivec2 src) {
+  r_reset_camera(dst, src);
+}
+
+RenderObject init_default_renderobject(Window *restrict w, Shader s) {
+    u32 first_texture = 0;
+
+    for (usize i = 0; i < w->render_targets->buffer_len; i++) {
+      if (BUFFERPARAMETER_GET_TYPE(w->render_targets->buffer_parameters[i]) == BufferType_texture) {
+        first_texture = w->render_targets->buffer[i];
+        break;
+      }
+    }
+
+    // WHAT?!
+    // --- Should _really_ make renderobjects heap allocated..!
+    return RenderObject_new(
+        // Shader
+        &s,
+        // Texture
+        first_texture,
+        // Vertices
+        shaderbuf,
+        sizeof(shaderbuf) / sizeof(ShaderBuffer)
+        );
+}
+
+Shader init_default_shader(void) {
+  // TODO: MOVE TO INIT
+  Shader default_quad_shaders[] = {
+    compile_shader(default_quad_shader_vertex_src, Shader_Vertex),
+    compile_shader(default_quad_shader_fragment_src, Shader_Fragment),
+    (Shader){0},
+  };
+  return compose_shader(default_quad_shaders, 2);
+}
+
+void r_reset_pipeline(Window* w) {
+  if (w->render_targets == NULL) {
+    // Create only 1 additional framebuffer, in addition to the default
+    // one. This is used to render a texture that is represented as a quad
+    // on the default framebuffer.
+    u32 t[] = {
+      BUFFERPARAMETER_SET_PARAMETER(BUFFERPARAMETER_SET_TYPE(0, BufferType_texture), BUFFERPARAMETER_FMT_RGB8),
+
+      // The depth buffer could also be a texture like so:
+      //   BUFFERPARAMETER_SET_PARAMETER( BUFFERPARAMETER_SET_TYPE(0, BufferType_texture), BUFFERPARAMETER_FMT_DEPTH32),
+      BUFFERPARAMETER_SET_PARAMETER(BUFFERPARAMETER_SET_TYPE(0, BufferType_render), BUFFERPARAMETER_FMT_DEPTH32F),
+    };
+    FramebufferParameters p[] = {
+      // 16 by 16 is just some bogus values, but they cannot be zero, as they're
+      //    needed to be set when resetting cameras.
+      {.num_textures = 1, .num_renderbuffers = 1, .dimensions = {16, 16, 0}},
+    };
+    window_init_renderstack(w, 1, sizeof(t) / sizeof(t[0]), p, t);
+  }
+
+  // Set default callbacks and camera for default framebuffer
+  if (w->render_targets->framebuffer_size_callback[0] == NULL) {
+    w->render_targets->framebuffer_size_callback[0] = framebuffer_size_callback_default;
+  }
+  if (w->render_targets->camera_reset_callback[0] == NULL) {
+    w->render_targets->camera_reset_callback[0] = camera_reset_callback_default;
+  }
+  if (w->render_targets->camera_reset_callback[0 == NULL]) {
+    w->render_targets->cam[0] = &default_camera;
+  }
+
+  window_reset_cameras(w, GLOBAL_PLATFORM->mem->data, w->render_targets);
+
+  // TODO: Both the shader & renderobject should only be created here if it is
+  // overwritten in Instance->Window.
+  // TODO: Add default quad & renderobject to Instance->Window. Should allow
+  // for customization.
+  //default_quad_renderobject = init_default_renderobject(p->window, default_quad_shader);
+}