X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=render.h;h=58c88311d76af42a6a6c7860af46f2224db3a9f8;hb=f7db507815e2822d971031c30f25e02b45e9c914;hp=f77f10625ef1ee8b71bae081bc310e82b3863346;hpb=be0f28b651e5c39943e476c0cd68c146e9952857;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/render.h b/render.h
index f77f106..58c8831 100644
--- a/render.h
+++ b/render.h
@@ -1,22 +1,48 @@
+/*
+ * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ */
+
 #include "common.h"
 #include "model.h"
+#include "camera.h"
+
+#include "shaders/blit.h"
+#include "shaders/blitblur.h"
+#include "shaders/standard.h"
+#include "shaders/vblend.h"
 
-static void render_water_texture( m4x3f camera );
-static void render_water_surface( m4x4f pv, m4x3f camera );
-static void render_world( m4x4f projection, m4x3f camera );
-static void shader_link_standard_ub( GLuint shader, int texture_id );
-static void render_world_depth( m4x4f projection, m4x3f camera );
+VG_STATIC void render_water_texture( camera *cam );
+VG_STATIC void render_water_surface( camera *cam );
+VG_STATIC void render_world( camera *cam );
+VG_STATIC void shader_link_standard_ub( GLuint shader, int texture_id );
+VG_STATIC void render_world_depth( camera *cam );
 
 #ifndef RENDER_H
 #define RENDER_H
 
-static struct pipeline
+struct framebuffer
+{
+   GLuint fb, colour, rb;
+   int div;
+   GLuint format;
+
+   int allocated;
+};
+
+/* 
+ * All standard buffers used in rendering
+ */
+VG_STATIC struct pipeline
 {
+#if 0
    float fov;
+#endif
    glmesh fsquad;
 
    GLuint fb_background,
-          rgb_background;
+          rgb_background,
+          mv_background,
+          rb_background;
 
    /* STD140 */
    struct ub_world_lighting
@@ -32,6 +58,7 @@ static struct pipeline
       float g_water_fog;
       int g_light_count;
       int g_light_preview;
+      int g_shadow_samples;
    }
    ub_world_lighting;
 
@@ -48,6 +75,8 @@ static struct pipeline
    GLuint fb_depthmap, rgb_depthmap;
    GLuint ubo_world_lighting,
           ubo_world;
+
+   int ready;
 }
 gpipeline =
 {
@@ -78,42 +107,10 @@ gpipeline =
    }
 };
 
-/* 
- * Matrix Projections
- */
-/* 
- * http://www.terathon.com/lengyel/Lengyel-Oblique.pdf 
- */
-static void plane_clip_projection( m4x4f mat, v4f plane )
-{
-   v4f c = 
-   {
-      (vg_signf(plane[0]) + mat[2][0]) / mat[0][0],
-      (vg_signf(plane[1]) + mat[2][1]) / mat[1][1],
-      -1.0f,
-      (1.0f + mat[2][2]) / mat[3][2]
-   };
-
-   v4_muls( plane, 2.0f / v4_dot(plane,c), c );
-
-   mat[0][2] = c[0];
-   mat[1][2] = c[1];
-   mat[2][2] = c[2] + 1.0f;
-   mat[3][2] = c[3];
-}
-
-static void pipeline_projection( m4x4f mat, float nearz, float farz )
-{
-   m4x4_projection( mat,
-         gpipeline.fov,
-         (float)vg_window_x / (float)vg_window_y, 
-         nearz, farz );
-}
-
 /*
  * Shaders
  */
-static void shader_link_standard_ub( GLuint shader, int texture_id )
+VG_STATIC void shader_link_standard_ub( GLuint shader, int texture_id )
 {
    GLuint idx = glGetUniformBlockIndex( shader, "ub_world_lighting" );   
    glUniformBlockBinding( shader, idx, 0 );
@@ -123,7 +120,7 @@ static void shader_link_standard_ub( GLuint shader, int texture_id )
    glUniform1i( glGetUniformLocation( shader, "g_world_depth" ), texture_id );
 }
 
-static void render_update_lighting_ub(void)
+VG_STATIC void render_update_lighting_ub(void)
 {
    struct ub_world_lighting *winf = &gpipeline.ub_world_lighting;
    int c = 0;
@@ -150,50 +147,38 @@ static void render_update_lighting_ub(void)
    winf->g_light_directions[0][3] = gpipeline.shadow_length;
    winf->g_light_colours[0][3] = gpipeline.shadow_spread;
 
+   if( vg.quality_profile == k_quality_profile_low )
+      winf->g_shadow_samples = 0;
+   else
+      winf->g_shadow_samples = 8;
+
    glBindBuffer( GL_UNIFORM_BUFFER, gpipeline.ubo_world_lighting );
    glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(struct ub_world_lighting),
          &gpipeline.ub_world_lighting );
 }
 
-static void render_alloc_ub(void)
-{
-   glGenBuffers( 1, &gpipeline.ubo_world_lighting );
-   glBindBuffer( GL_UNIFORM_BUFFER, gpipeline.ubo_world_lighting );
-   glBufferData( GL_UNIFORM_BUFFER, sizeof(struct ub_world_lighting), 
-         NULL, GL_DYNAMIC_DRAW );
-
-   render_update_lighting_ub();
-   glBindBufferBase( GL_UNIFORM_BUFFER, 0, gpipeline.ubo_world_lighting );
-}
-
 /* 
  * Framebuffers
  */
-struct framebuffer
-{
-   GLuint fb, colour, rb;
-   int div;
-   GLuint format;
-};
 
-static void fb_use( struct framebuffer *fb )
+VG_STATIC void fb_use( struct framebuffer *fb )
 {
    if( !fb )
    {
-      glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-      glViewport( 0, 0, vg_window_x, vg_window_y );
+      glBindFramebuffer( GL_FRAMEBUFFER, gpipeline.fb_background );
+      glViewport( 0, 0, vg.window_x, vg.window_y );
    }
    else
    {
       glBindFramebuffer( GL_FRAMEBUFFER, fb->fb );
-      glViewport( 0, 0, vg_window_x / fb->div, vg_window_y / fb->div );
+      glViewport( 0, 0, vg.window_x / fb->div, vg.window_y / fb->div );
    }
 }
 
-static void fb_init( struct framebuffer *fb )
+VG_STATIC void fb_init( struct framebuffer *fb )
 {
-   i32 ix = vg_window_x / fb->div,
-       iy = vg_window_y / fb->div;
+   i32 ix = vg.window_x / fb->div,
+       iy = vg.window_y / fb->div;
 
    glGenFramebuffers( 1, &fb->fb );
    glBindFramebuffer( GL_FRAMEBUFFER, fb->fb );
@@ -214,18 +199,31 @@ static void fb_init( struct framebuffer *fb )
 
    glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
          GL_RENDERBUFFER, fb->rb );
+   glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+
+   VG_CHECK_GL_ERR();
+   fb->allocated = 1;
+}
+
+VG_STATIC void fb_free( struct framebuffer *fb )
+{
+   glDeleteTextures( 1, &fb->colour );
+   glDeleteFramebuffers( 1, &fb->fb );
 }
 
-static void fb_bindtex( struct framebuffer *fb, int texture )
+VG_STATIC void fb_bindtex( struct framebuffer *fb, int texture )
 {
    glActiveTexture( GL_TEXTURE0 + texture );
    glBindTexture( GL_TEXTURE_2D, fb->colour );
 }
 
-static void fb_resize( struct framebuffer *fb )
+VG_STATIC void fb_resize( struct framebuffer *fb )
 {
-   i32 ix = vg_window_x / fb->div,
-       iy = vg_window_y / fb->div;
+   if( !fb->allocated )
+      return;
+
+   i32 ix = vg.window_x / fb->div,
+       iy = vg.window_y / fb->div;
 
    glBindTexture( GL_TEXTURE_2D, fb->colour );
    glTexImage2D( GL_TEXTURE_2D, 0, fb->format, ix, iy, 0,
@@ -235,36 +233,89 @@ static void fb_resize( struct framebuffer *fb )
    glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, ix, iy );
 }
 
-static void render_fb_resize(void)
+VG_STATIC void render_fb_resize(void)
 {
-   glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
-   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg_window_x, vg_window_y, 0, 
-         GL_RGB, GL_UNSIGNED_BYTE, NULL );
+   if( gpipeline.ready )
+   {
+      glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
+      glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg.window_x, vg.window_y, 0, 
+            GL_RGB, GL_UNSIGNED_BYTE, NULL );
+
+      /* FIXME: Resizeother textures and rb */
+   }
 }
 
-/*
- * Vg
- */
-static void render_init(void)
+VG_STATIC void render_init_temp_buffer(void)
 {
+   vg_info( "[render] Allocate framebuffer\n" );
+
    glGenFramebuffers( 1, &gpipeline.fb_background );
    glBindFramebuffer( GL_FRAMEBUFFER, gpipeline.fb_background );
 
    glGenTextures( 1, &gpipeline.rgb_background );
    glBindTexture( GL_TEXTURE_2D, gpipeline.rgb_background );
-   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg_window_x, vg_window_y, 
-         0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-
+   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg.window_x, vg.window_y, 
+                                0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
    glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 
          GL_TEXTURE_2D, 
-         gpipeline.rgb_background, 0);
+         gpipeline.rgb_background, 0 );
+
+   glGenTextures( 1, &gpipeline.mv_background );
+   glBindTexture( GL_TEXTURE_2D, gpipeline.mv_background );
+#if 0
+   glTexImage2D( GL_TEXTURE_2D, 0, GL_RG, vg.window_x, vg.window_y, 
+                                0, GL_RG, GL_FLOAT, NULL);
+#endif
+   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA16F, vg.window_x, vg.window_y, 
+                                0, GL_RGBA, GL_FLOAT, NULL);
+
+   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+   glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, 
+         GL_TEXTURE_2D, 
+         gpipeline.mv_background, 0 );
+
+   /* render buffer */
+   glGenRenderbuffers( 1, &gpipeline.rb_background );
+   glBindRenderbuffer( GL_RENDERBUFFER, gpipeline.rb_background );
+   glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH24_STENCIL8,
+                          vg.window_x, vg.window_y );
+   glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                              GL_RENDERBUFFER, gpipeline.rb_background );
+
+   GLuint attachments[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
+   glDrawBuffers( 2, attachments );
+
+   GLenum result = glCheckFramebufferStatus( GL_FRAMEBUFFER );
+
+   if( result != GL_FRAMEBUFFER_COMPLETE )
+   {
+      if( result == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT )
+         vg_fatal_exit_loop( "Main RT: Incomplete attachment" );
+      else if( result == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT )
+         vg_fatal_exit_loop( "Main RT: Missing attachment" );
+      else if( result == GL_FRAMEBUFFER_UNSUPPORTED )
+         vg_fatal_exit_loop( "Main RT: Unsupported framebuffer format" );
+      else
+         vg_fatal_exit_loop( "Main RT: Generic Error" );
+   }
+
+   glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+   VG_CHECK_GL_ERR();
+}
+
+/* used for drawing world depth from the top view, used in our water and
+ * lighting calculations */
+VG_STATIC void render_init_depthmap_buffer(void)
+{
+   vg_info( "[render] Allocate depth map buffer\n" );
 
-   /* 
-    * World depth map, maybe this should be moved to world.h
-    * TODO: review
-    */
    glGenFramebuffers( 1, &gpipeline.fb_depthmap );
    glBindFramebuffer( GL_FRAMEBUFFER, gpipeline.fb_depthmap );
 
@@ -280,8 +331,18 @@ static void render_init(void)
          GL_TEXTURE_2D, 
          gpipeline.rgb_depthmap, 0);
 
+   VG_CHECK_GL_ERR();
+}
+
+VG_STATIC void render_init_fs_quad(void)
+{
+   vg_info( "[render] Allocate quad\n" );
+
    float quad[] = { 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-                    0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f };
+                    0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
+
+                    0.2f, 0.0f, 0.8f, 1.0f, 0.2f, 1.0f,
+                    0.2f, 0.0f, 0.8f, 0.0f, 0.8f, 1.0f};
 
    glGenVertexArrays( 1, &gpipeline.fsquad.vao );
    glGenBuffers( 1, &gpipeline.fsquad.vbo );
@@ -292,23 +353,59 @@ static void render_init(void)
    glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 
          sizeof(float)*2, (void*)0 );
    glEnableVertexAttribArray( 0 );
-   VG_CHECK_GL();
 
-   render_alloc_ub();
+   VG_CHECK_GL_ERR();
 }
 
-static void render_free(void)
+VG_STATIC void render_init_uniform_buffers(void)
 {
-   /* TODO: ... */
+   vg_info( "[render] Allocate uniform buffer\n" );
+
+   glGenBuffers( 1, &gpipeline.ubo_world_lighting );
+   glBindBuffer( GL_UNIFORM_BUFFER, gpipeline.ubo_world_lighting );
+   glBufferData( GL_UNIFORM_BUFFER, sizeof(struct ub_world_lighting), 
+         NULL, GL_DYNAMIC_DRAW );
+
+   render_update_lighting_ub();
+   glBindBufferBase( GL_UNIFORM_BUFFER, 0, gpipeline.ubo_world_lighting );
+
+   VG_CHECK_GL_ERR();
+}
+
+VG_STATIC void render_init(void)
+{
+   shader_blit_register();
+   shader_blitblur_register();
+   shader_standard_register();
+   shader_vblend_register();
+
+   vg_acquire_thread_sync();
+   {
+      render_init_temp_buffer();
+      render_init_depthmap_buffer();
+      render_init_fs_quad();
+      render_init_uniform_buffers();
+
+      glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+      gpipeline.ready = 1;
+   }
+
+   vg_release_thread_sync();
 }
 
 /*
  * Utility
  */
-static void render_fsquad(void)
+VG_STATIC void render_fsquad(void)
 {
    glBindVertexArray( gpipeline.fsquad.vao );
    glDrawArrays( GL_TRIANGLES, 0, 6 );
 }
 
+VG_STATIC void render_fsquad1(void)
+{
+   glBindVertexArray( gpipeline.fsquad.vao );
+   glDrawArrays( GL_TRIANGLES, 6, 6 );
+}
+
 #endif /* RENDER_H */