X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=render.h;h=7b5b473739f7ec6c6b01083bd3448f6e73d43697;hb=aa4c26eae2208872824e0eb5b71bc05c16d43242;hp=493ed3b6d4520c8954bc7860e4702c28fb9b9893;hpb=7758c7efec3956c68294bc914e7524045a2b1bd7;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/render.h b/render.h
index 493ed3b..7b5b473 100644
--- a/render.h
+++ b/render.h
@@ -1,82 +1,893 @@
+/*
+ * 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/blitcolour.h"
+
+#if 0
+#include "shaders/standard.h"
+#include "shaders/vblend.h"
+#endif
+
+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
-#define VG_3D
-#include "vg/vg.h"
 
-static struct pipeline
+typedef struct framebuffer framebuffer;
+
+
+/* 
+ * All standard buffers used in rendering
+ */
+VG_STATIC struct pipeline
+{
+   glmesh fsquad;
+
+   framebuffer *fb_main,
+               *fb_heightmap,
+               *fb_water_reflection,
+               *fb_water_beneath;
+
+   /* STD140 */
+   struct ub_world_lighting
+   {
+      /* v3f (padded) */
+      v4f g_light_colours[3],
+          g_light_directions[3],
+          g_ambient_colour;
+
+      v4f g_water_plane,
+          g_depth_bounds;
+
+      float g_water_fog;
+      int g_light_count;
+      int g_light_preview;
+      int g_shadow_samples;
+
+      v4f g_point_light_positions[32];
+      v4f g_point_light_colours[32];
+   }
+   ub_world_lighting;
+
+   struct light_widget
+   {
+      int enabled;
+      v2f dir;
+      v3f colour;
+   } 
+   widgets[3];
+
+   float shadow_spread, shadow_length;
+   GLuint ubo_world_lighting,
+          ubo_world;
+
+   int ready;
+}
+gpipeline =
+{
+   .widgets =
+   {
+      {
+         .enabled = 1,
+         .colour = { 1.36f, 1.35f, 1.01f },
+         .dir = { 0.63f, -0.08f }
+      },
+      {
+         .enabled = 1,
+         .colour = { 0.33f, 0.56f, 0.64f },
+         .dir = { -2.60f, -0.13f }
+      },
+      {
+         .enabled = 1,
+         .colour = { 0.05f, 0.05f, 0.23f },
+         .dir = { 2.60f, -0.84f }
+      }
+   },
+   .shadow_spread = 0.65f,
+   .shadow_length = 9.50f,
+
+   .ub_world_lighting =
+   {
+      .g_ambient_colour = { 0.09f, 0.03f, 0.07f }
+   }
+};
+
+struct framebuffer
+{
+   const char *display_name;
+   int         resolution_div,
+               fixed_w,
+               fixed_h;
+
+   struct framebuffer_attachment
+   {
+      const char *display_name;
+      
+      enum framebuffer_attachment_type
+      {
+         k_framebuffer_attachment_type_none,
+         k_framebuffer_attachment_type_colour,
+         k_framebuffer_attachment_type_renderbuffer
+      }
+      purpose;
+
+      enum framebuffer_quality_profile
+      {
+         k_framebuffer_quality_all,
+         k_framebuffer_quality_high_only
+      }
+      quality;
+      
+      GLenum internalformat,
+             format,
+             type,
+             attachment;
+
+      GLuint id;
+
+      /* Runtime */
+      int debug_view;
+   }
+   attachments[5];
+   GLuint fb;
+   framebuffer **link;
+}
+framebuffers[] = 
+{
+   {
+      /*
+       * The primary draw target
+       */
+      "main", 
+      .link = &gpipeline.fb_main,
+      .resolution_div = 1,
+      .attachments = 
+      {
+         {
+            "colour", k_framebuffer_attachment_type_colour,
+
+            .internalformat = GL_RGB,
+            .format         = GL_RGB,
+            .type           = GL_UNSIGNED_BYTE,
+            .attachment     = GL_COLOR_ATTACHMENT0
+         },
+         {
+            "motion", k_framebuffer_attachment_type_colour,
+
+            .quality        = k_framebuffer_quality_high_only,
+            .internalformat = GL_RG16F,
+            .format         = GL_RG,
+            .type           = GL_FLOAT,
+            .attachment     = GL_COLOR_ATTACHMENT1
+         },
+         {
+            "depth_stencil", k_framebuffer_attachment_type_renderbuffer,
+
+            .internalformat = GL_DEPTH24_STENCIL8,
+            .attachment     = GL_DEPTH_STENCIL_ATTACHMENT
+         }
+      }
+   },
+   {
+      /*
+       * A ortho projection of the world, used for shadows and ocean colouring.
+       * Note: it does not have a render buffer attachement because it's
+       *       intended to be drawn to in a MAX blending mode
+       */
+      "heightmap", 
+      .link = &gpipeline.fb_heightmap,
+      .fixed_w = 1024,
+      .fixed_h = 1024,
+
+      .attachments =
+      {
+         {
+            "depth", k_framebuffer_attachment_type_colour,
+
+            .internalformat = GL_R32F,
+            .format         = GL_RED,
+            .type           = GL_FLOAT,
+            .attachment     = GL_COLOR_ATTACHMENT0
+         }
+      }
+   },
+   {
+      /*
+       * Second rendered view from the perspective of the water reflection
+       */
+      "water_reflection",
+      .link = &gpipeline.fb_water_reflection,
+      .resolution_div = 3,
+      .attachments = 
+      {
+         {
+            "colour", k_framebuffer_attachment_type_colour,
+            .internalformat = GL_RGB,
+            .format         = GL_RGB,
+            .type           = GL_UNSIGNED_BYTE,
+            .attachment     = GL_COLOR_ATTACHMENT0
+         },
+         {
+            "depth_stencil", k_framebuffer_attachment_type_renderbuffer,
+
+            .internalformat = GL_DEPTH24_STENCIL8,
+            .attachment     = GL_DEPTH_STENCIL_ATTACHMENT
+         }
+      }
+   },
+   {
+      /*
+       * Thid rendered view from the perspective of the camera, but just 
+       * captures stuff thats under the water
+       */
+      "water_beneath",
+      .link = &gpipeline.fb_water_beneath,
+      .resolution_div = 4,
+      .attachments = 
+      {
+         {
+            "colour", k_framebuffer_attachment_type_colour,
+            .internalformat = GL_RGBA,
+            .format         = GL_RGBA,
+            .type           = GL_UNSIGNED_BYTE,
+            .attachment     = GL_COLOR_ATTACHMENT0
+         },
+         {
+            "depth_stencil", k_framebuffer_attachment_type_renderbuffer,
+
+            .internalformat = GL_DEPTH24_STENCIL8,
+            .attachment     = GL_DEPTH_STENCIL_ATTACHMENT
+         }
+      }
+   }
+};
+
+/* 
+ * Get the current (automatically scaled or fixed) resolution of framebuffer
+ */
+VG_STATIC void render_fb_get_current_res( struct framebuffer *fb, 
+                                          int *x, int *y )
+{
+   if( fb->resolution_div )
+   {
+      *x = vg.window_x / fb->resolution_div;
+      *y = vg.window_y / fb->resolution_div;
+   }
+   else
+   {
+      *x = fb->fixed_w;
+      *y = fb->fixed_h;
+   }
+}
+
+/*
+ * Bind framebuffer for drawing to
+ */
+VG_STATIC void render_fb_bind( framebuffer *fb )
+{
+   int x, y;
+   render_fb_get_current_res( fb, &x, &y );
+   glBindFramebuffer( GL_FRAMEBUFFER, fb->fb );
+   glViewport( 0, 0, x, y );
+}
+
+/*
+ * Bind framebuffer attachment's texture
+ */
+VG_STATIC void render_fb_bind_texture( framebuffer *fb, 
+                                       int attachment, int slot )
+{
+   struct framebuffer_attachment *at = &fb->attachments[attachment];
+
+   if( at->purpose != k_framebuffer_attachment_type_colour )
+   {
+      vg_fatal_exit_loop( "illegal operation: bind non-colour framebuffer"
+                          " attachment to texture slot" );
+   }
+
+   glActiveTexture( GL_TEXTURE0 + slot );
+   glBindTexture( GL_TEXTURE_2D, fb->attachments[attachment].id );
+}
+
+
+/*
+ * Shaders
+ */
+VG_STATIC void shader_link_standard_ub( GLuint shader, int texture_id )
+{
+   GLuint idx = glGetUniformBlockIndex( shader, "ub_world_lighting" );   
+   glUniformBlockBinding( shader, idx, 0 );
+
+   render_fb_bind_texture( gpipeline.fb_heightmap, 0, texture_id );
+   glUniform1i( glGetUniformLocation( shader, "g_world_depth" ), texture_id );
+}
+
+VG_STATIC void render_update_lighting_ub(void)
+{
+   struct ub_world_lighting *winf = &gpipeline.ub_world_lighting;
+   int c = 0;
+
+   for( int i=0; i<3; i++ )
+   {
+      struct light_widget *lw = &gpipeline.widgets[i];
+
+      if( lw->enabled )
+      {
+         float pitch = lw->dir[0],
+               yaw = lw->dir[1],
+               xz = cosf( pitch );
+         
+         v3_copy( (v3f){ xz*cosf(yaw), sinf(pitch), xz*sinf(yaw) }, 
+               winf->g_light_directions[c] );
+         v3_copy( lw->colour, winf->g_light_colours[c] );
+
+         c ++;
+      }
+   }
+
+   winf->g_light_count = c;
+   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 );
+}
+
+#define FB_FORMAT_STR( E ) { E, #E },
+
+/* 
+ * Convert OpenGL attachment ID enum to string
+ */
+VG_STATIC const char *render_fb_attachment_str( GLenum e )
+{
+   struct { GLenum e; const char *str; }
+   formats[] =
+   { 
+      FB_FORMAT_STR(GL_COLOR_ATTACHMENT0)
+      FB_FORMAT_STR(GL_COLOR_ATTACHMENT1)
+      FB_FORMAT_STR(GL_COLOR_ATTACHMENT2)
+      FB_FORMAT_STR(GL_COLOR_ATTACHMENT3)
+      FB_FORMAT_STR(GL_COLOR_ATTACHMENT4)
+      FB_FORMAT_STR(GL_DEPTH_STENCIL_ATTACHMENT)
+   };
+
+   for( int i=0; i<vg_list_size(formats); i++ )
+      if( formats[i].e == e )
+         return formats[i].str;
+
+   return "UNDEFINED";
+}
+
+/*
+ * Convert OpenGL texture format enums from TexImage2D table 1,2 &
+ * RenderBufferStorage Table 1, into strings
+ */
+VG_STATIC const char *render_fb_format_str( GLenum format )
 {
-   float fov;
+   struct { GLenum e; const char *str; }
+   formats[] =
+   { 
+      /* Table 1 */
+      FB_FORMAT_STR(GL_DEPTH_COMPONENT)
+      FB_FORMAT_STR(GL_DEPTH_STENCIL)
+      FB_FORMAT_STR(GL_RED)
+      FB_FORMAT_STR(GL_RG)
+      FB_FORMAT_STR(GL_RGB)
+      FB_FORMAT_STR(GL_RGBA)
+
+      /* Render buffer formats */
+      FB_FORMAT_STR(GL_DEPTH_COMPONENT16)
+      FB_FORMAT_STR(GL_DEPTH_COMPONENT24)
+      FB_FORMAT_STR(GL_DEPTH_COMPONENT32F)
+      FB_FORMAT_STR(GL_DEPTH24_STENCIL8)
+      FB_FORMAT_STR(GL_DEPTH32F_STENCIL8)
+      FB_FORMAT_STR(GL_STENCIL_INDEX8)
+
+      /* Table 2 */
+      FB_FORMAT_STR(GL_R8)
+      FB_FORMAT_STR(GL_R8_SNORM)
+      FB_FORMAT_STR(GL_R16)
+      FB_FORMAT_STR(GL_R16_SNORM)
+      FB_FORMAT_STR(GL_RG8)
+      FB_FORMAT_STR(GL_RG8_SNORM)
+      FB_FORMAT_STR(GL_RG16)
+      FB_FORMAT_STR(GL_RG16_SNORM)
+      FB_FORMAT_STR(GL_R3_G3_B2)
+      FB_FORMAT_STR(GL_RGB4)
+      FB_FORMAT_STR(GL_RGB5)
+      FB_FORMAT_STR(GL_RGB8)
+      FB_FORMAT_STR(GL_RGB8_SNORM)
+      FB_FORMAT_STR(GL_RGB10)
+      FB_FORMAT_STR(GL_RGB12)
+      FB_FORMAT_STR(GL_RGB16_SNORM)
+      FB_FORMAT_STR(GL_RGBA2)
+      FB_FORMAT_STR(GL_RGBA4)
+      FB_FORMAT_STR(GL_RGB5_A1)
+      FB_FORMAT_STR(GL_RGBA8)
+      FB_FORMAT_STR(GL_RGBA8_SNORM)
+      FB_FORMAT_STR(GL_RGB10_A2)
+      FB_FORMAT_STR(GL_RGB10_A2UI)
+      FB_FORMAT_STR(GL_RGBA12)
+      FB_FORMAT_STR(GL_RGBA16)
+      FB_FORMAT_STR(GL_SRGB8)
+      FB_FORMAT_STR(GL_SRGB8_ALPHA8)
+      FB_FORMAT_STR(GL_R16F)
+      FB_FORMAT_STR(GL_RG16F)
+      FB_FORMAT_STR(GL_RGB16F)
+      FB_FORMAT_STR(GL_RGBA16F)
+      FB_FORMAT_STR(GL_R32F)
+      FB_FORMAT_STR(GL_RG32F)
+      FB_FORMAT_STR(GL_RGB32F)
+      FB_FORMAT_STR(GL_RGBA32F)
+      FB_FORMAT_STR(GL_R11F_G11F_B10F)
+      FB_FORMAT_STR(GL_RGB9_E5)
+      FB_FORMAT_STR(GL_R8I)
+      FB_FORMAT_STR(GL_R8UI)
+      FB_FORMAT_STR(GL_R16I)
+      FB_FORMAT_STR(GL_R16UI)
+      FB_FORMAT_STR(GL_R32I)
+      FB_FORMAT_STR(GL_R32UI)
+      FB_FORMAT_STR(GL_RG8I)
+      FB_FORMAT_STR(GL_RG8UI)
+      FB_FORMAT_STR(GL_RG16I)
+      FB_FORMAT_STR(GL_RG16UI)
+      FB_FORMAT_STR(GL_RG32I)
+      FB_FORMAT_STR(GL_RG32UI)
+      FB_FORMAT_STR(GL_RGB8I)
+      FB_FORMAT_STR(GL_RGB8UI)
+      FB_FORMAT_STR(GL_RGB16I)
+      FB_FORMAT_STR(GL_RGB16UI)
+      FB_FORMAT_STR(GL_RGB32I)
+      FB_FORMAT_STR(GL_RGB32UI)
+      FB_FORMAT_STR(GL_RGBA8I)
+      FB_FORMAT_STR(GL_RGBA8UI)
+      FB_FORMAT_STR(GL_RGBA16I)
+      FB_FORMAT_STR(GL_RGBA16UI)
+      FB_FORMAT_STR(GL_RGBA32I)
+      FB_FORMAT_STR(GL_RGBA32UI)
+   };
+
+   for( int i=0; i<vg_list_size(formats); i++ )
+      if( formats[i].e == format )
+         return formats[i].str;
+
+   return "UNDEFINED";
 }
-gpipeline;
 
-static void render_water_texture( m4x3f camera );
-static void render_water_surface( m4x4f pv );
-static void render_world( m4x4f projection, m4x3f camera );
+/*
+ * Bind and allocate texture for framebuffer attachment
+ */
+VG_STATIC void render_fb_allocate_texture( struct framebuffer *fb, 
+                                           struct framebuffer_attachment *a )
+{
+   int rx, ry;
+   render_fb_get_current_res( fb, &rx, &ry );
+
+   if( a->purpose == k_framebuffer_attachment_type_renderbuffer )
+   {
+      glBindRenderbuffer( GL_RENDERBUFFER, a->id );
+      glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, rx, ry );
+   }
+   else if( a->purpose == k_framebuffer_attachment_type_colour )
+   {
+      glBindTexture( GL_TEXTURE_2D, a->id );
+      glTexImage2D( GL_TEXTURE_2D, 0, a->internalformat, rx, ry,
+                                   0, a->format, a->type, NULL );
+   }
+}
 
 /* 
- * http://www.terathon.com/lengyel/Lengyel-Oblique.pdf 
+ * Full allocation of a framebuffer
+ */
+VG_STATIC void render_fb_allocate( struct framebuffer *fb )
+{
+   glGenFramebuffers( 1, &fb->fb );
+   glBindFramebuffer( GL_FRAMEBUFFER, fb->fb );
+
+   int rx, ry;
+   render_fb_get_current_res( fb, &rx, &ry );
+
+   vg_info( "allocate_framebuffer( %s, %dx%d )\n", fb->display_name, rx, ry );
+   vg_info( "{\n" );
+
+   GLenum colour_attachments[4];
+   u32    colour_count = 0;
+
+   for( int j=0; j<vg_list_size(fb->attachments); j++ )
+   {
+      struct framebuffer_attachment *attachment = &fb->attachments[j];
+
+      if( attachment->purpose == k_framebuffer_attachment_type_none )
+         continue;
+
+      vg_info( "  %s: %s\n", 
+                  render_fb_attachment_str( attachment->attachment ),
+                  render_fb_format_str( attachment->internalformat ) );
+
+      if( attachment->purpose == k_framebuffer_attachment_type_renderbuffer )
+      {
+         glGenRenderbuffers( 1, &attachment->id );
+         render_fb_allocate_texture( fb, attachment );
+         glFramebufferRenderbuffer( GL_FRAMEBUFFER, 
+                                    GL_DEPTH_STENCIL_ATTACHMENT,
+                                    GL_RENDERBUFFER, attachment->id );
+      }
+      else if( attachment->purpose == k_framebuffer_attachment_type_colour )
+      {
+         glGenTextures( 1, &attachment->id );
+         render_fb_allocate_texture( fb, attachment );
+         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, attachment->attachment,
+                                 GL_TEXTURE_2D,  attachment->id, 0 );
+
+         colour_attachments[ colour_count ++ ] = attachment->attachment;
+      }
+   }
+
+   glDrawBuffers( colour_count, colour_attachments );
+
+   /* 
+    * Check result 
+    */
+   GLenum result = glCheckFramebufferStatus( GL_FRAMEBUFFER );
+
+   if( result == GL_FRAMEBUFFER_COMPLETE )
+   {
+      /* 
+       * Attatch to gpipeline
+       */
+      if( fb->link )
+         *fb->link = fb;
+
+      vg_success( "  status: complete\n" );
+      vg_info( "}\n" );
+   }
+   else
+   {
+      if( result == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT )
+         vg_error( "  status: Incomplete attachment" );
+      else if( result == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT )
+         vg_error( "  status: Missing attachment" );
+      else if( result == GL_FRAMEBUFFER_UNSUPPORTED )
+         vg_error( "  status: Unsupported framebuffer format" );
+      else
+         vg_error( "  status: Generic Error" );
+
+      vg_info( "}\n" );
+      vg_fatal_exit_loop( "Incomplete framebuffer (see logs)" );
+   }
+}
+
+/*
+ * Resize/Update all framebuffers(we know about)
  */
-static void plane_clip_projection( m4x4f mat, v4f plane )
+VG_STATIC void render_fb_resize(void)
 {
-   v4f c = 
+   if( !gpipeline.ready )
+      return;
+
+   for( int i=0; i<vg_list_size(framebuffers); i++ )
    {
-      (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]
+      struct framebuffer *fb = &framebuffers[i];
+      for( int j=0; j<vg_list_size(fb->attachments); j++ )
+      {
+         struct framebuffer_attachment *attachment = &fb->attachments[j];
+         render_fb_allocate_texture( fb, attachment );
+      }
+   }
+}
+
+VG_STATIC int render_framebuffer_control( int argc, char const *argv[] );
+VG_STATIC void render_framebuffer_poll( int argc, char const *argv[] );
+VG_STATIC void render_init_fs_quad(void)
+{
+   vg_info( "[render] Allocate quad\n" );
+
+   float quad[] = 
+   { 
+      0.00f,0.00f, 1.00f,1.00f, 0.00f,1.00f,
+      0.00f,0.00f, 1.00f,0.00f, 1.00f,1.00f,
+
+      0.20f,0.00f, 0.80f,1.00f, 0.20f,1.00f,
+      0.20f,0.00f, 0.80f,0.00f, 0.80f,1.00f,
+
+      /* 9x9 debug grid */
+      /* row0 */
+      0.00f,0.00f, 0.30f,0.30f, 0.00f,0.30f,
+      0.00f,0.00f, 0.30f,0.00f, 0.30f,0.30f,
+      0.30f,0.00f, 0.60f,0.30f, 0.30f,0.30f,
+      0.30f,0.00f, 0.60f,0.00f, 0.60f,0.30f,
+      0.60f,0.00f, 0.90f,0.30f, 0.60f,0.30f,
+      0.60f,0.00f, 0.90f,0.00f, 0.90f,0.30f,
+      /* row1 */
+      0.00f,0.30f, 0.30f,0.60f, 0.00f,0.60f,
+      0.00f,0.30f, 0.30f,0.30f, 0.30f,0.60f,
+      0.30f,0.30f, 0.60f,0.60f, 0.30f,0.60f,
+      0.30f,0.30f, 0.60f,0.30f, 0.60f,0.60f,
+      0.60f,0.30f, 0.90f,0.60f, 0.60f,0.60f,
+      0.60f,0.30f, 0.90f,0.30f, 0.90f,0.60f,
+      /* row2 */
+      0.00f,0.60f, 0.30f,0.90f, 0.00f,0.90f,
+      0.00f,0.60f, 0.30f,0.60f, 0.30f,0.90f,
+      0.30f,0.60f, 0.60f,0.90f, 0.30f,0.90f,
+      0.30f,0.60f, 0.60f,0.60f, 0.60f,0.90f,
+      0.60f,0.60f, 0.90f,0.90f, 0.60f,0.90f,
+      0.60f,0.60f, 0.90f,0.60f, 0.90f,0.90f,
    };
 
-   v4_muls( plane, 2.0f / v4_dot(plane,c), c );
+	vg_function_push( (struct vg_cmd)
+   {
+		.name = "fb",
+		.function = render_framebuffer_control,
+      .poll_suggest = render_framebuffer_poll
+	});
+
+   glGenVertexArrays( 1, &gpipeline.fsquad.vao );
+   glGenBuffers( 1, &gpipeline.fsquad.vbo );
+   glBindVertexArray( gpipeline.fsquad.vao );
+   glBindBuffer( GL_ARRAY_BUFFER, gpipeline.fsquad.vbo );
+   glBufferData( GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW );
+   glBindVertexArray( gpipeline.fsquad.vao );
+   glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 
+                          sizeof(float)*2, (void*)0 );
+   glEnableVertexAttribArray( 0 );
 
-   mat[0][2] = c[0];
-   mat[1][2] = c[1];
-   mat[2][2] = c[2] + 1.0f;
-   mat[3][2] = c[3];
+   VG_CHECK_GL_ERR();
 }
 
-static void pipeline_projection( m4x4f mat, float nearz, float farz )
+VG_STATIC void render_init_uniform_buffers(void)
 {
-   m4x4_projection( mat,
-         gpipeline.fov,
-         (float)vg_window_x / (float)vg_window_y, 
-         nearz, farz );
+   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();
 }
 
-static void create_renderbuffer_std( GLuint *fb, GLuint *rgb, GLuint *rb )
+VG_STATIC void render_init(void)
 {
-   glGenFramebuffers( 1, fb );
-   glBindFramebuffer( GL_FRAMEBUFFER, *fb );
+   shader_blit_register();
+   shader_blitblur_register();
+   shader_blitcolour_register();
 
-   glGenTextures( 1, rgb );
-   glBindTexture( GL_TEXTURE_2D, *rgb );
-   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg_window_x, vg_window_y, 
-         0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
+   vg_acquire_thread_sync();
+   {
+      /* 
+       * Complete Framebuffers
+       */
+      for( int i=0; i<vg_list_size(framebuffers); i++ )
+      {
+         struct framebuffer *fb = &framebuffers[i];
+         render_fb_allocate( fb );
+      }
 
-   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
-   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
-   glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 
-         GL_TEXTURE_2D, *rgb, 0);
+      render_init_fs_quad();
+      render_init_uniform_buffers();
 
-   /* TODO: Check for DEPTH32f availiblity and use if possible */
+      glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+      gpipeline.ready = 1;
+   }
 
-   glGenRenderbuffers( 1, rb );
-   glBindRenderbuffer( GL_RENDERBUFFER, *rb );
-   glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 
-         vg_window_x, vg_window_y );
+   vg_release_thread_sync();
+}
 
-   glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
-         GL_RENDERBUFFER, *rb );
+/*
+ * Utility
+ */
+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 );
 }
 
-static void resize_renderbuffer_std( GLuint *fb, GLuint *rgb, GLuint *rb )
+/*
+ * Call this inside the UI function
+ */
+VG_STATIC void render_view_framebuffer_ui(void)
 {
-   glBindTexture( GL_TEXTURE_2D, *rgb );
-   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vg_window_x, vg_window_y, 0,
-         GL_RGB, GL_UNSIGNED_BYTE, NULL );
+   int viewing_count = 0;
+
+   glBindVertexArray( gpipeline.fsquad.vao );
+   shader_blit_use();
+   shader_blit_uTexMain( 0 );
+
+   for( int i=0; i<vg_list_size(framebuffers); i++ )
+   {
+      struct framebuffer *fb = &framebuffers[i];
+
+      for( int j=0; j<vg_list_size(fb->attachments); j++ )
+      {
+         struct framebuffer_attachment *at = &fb->attachments[j];
+
+         if( !at->debug_view )
+            continue;
+
+         v2f corner,
+             window = { vg.window_x, vg.window_y };
+
+         corner[0] = viewing_count % 3;
+         corner[1] = 1 + (viewing_count / 3);
+         v2_mul( corner, window, corner );
+         v2_muls( corner, 0.3f, corner );
+         corner[1] = vg.window_y - corner[1];
+         
+         ui_text( (ui_rect){ corner[0], corner[1],      0.0f, 0.0f }, 
+                  fb->display_name, 2, k_text_align_left );
+         ui_text( (ui_rect){ corner[0], corner[1] + 32, 0.0f, 0.0f, },
+                  at->display_name, 1, k_text_align_left );
+
+         if( at->purpose == k_framebuffer_attachment_type_renderbuffer )
+         {
+            v2f center;
+            v2_muladds( corner, window, 0.15f, center );
+
+            ui_text( (ui_rect){ center[0], center[1], 0.0f, 0.0f },
+                     "<hardware texture>", 1, k_text_align_center );
+         }
+         else
+         {
+            render_fb_bind_texture( fb, j, 0 );
+            
+            int start = (viewing_count+2) * 6,
+                count = 6;
+            glDrawArrays( GL_TRIANGLES, start, count );
+         }
+
+         viewing_count ++;
+      }
+   }
+}
+
+VG_STATIC void render_framebuffer_show( struct framebuffer *fb,
+                                        struct framebuffer_attachment *at,
+                                        int operation )
+{
+   at->debug_view = operation;
+   vg_info( "%s %s:%s\n", (operation?"shown": "hidden"), 
+               fb->display_name, at->display_name );
+}
+
+/* 
+ * arg0: command           "show"/"hide"
+ * arg1: framebuffer name  <name>/"all"
+ * arg2: subname           <name>/none
+ */
+VG_STATIC int render_framebuffer_control( int argc, char const *argv[] )
+{
+   if( argc < 2 )
+   {
+      vg_error( "Usage: fb \"show/hide\" <name>/\"all\" <name>/none\n" );
+      return 0;
+   }
+
+   int modify_all = 0,
+       operation  = 0;
+
+   if( !strcmp( argv[0], "show" ) )
+      operation = 1;
+   else if( !strcmp( argv[0], "hide" ) )
+      operation = 0;
+   else
+   {
+      vg_error( "Unknown framebuffer operation: '%s'\n", argv[0] );
+      return 0;
+   }
+
+   if( !strcmp( argv[1], "all" ) )
+      modify_all = 1;
+
+   for( int i=0; i<vg_list_size(framebuffers); i++ )
+   {
+      struct framebuffer *fb = &framebuffers[i];
+      
+      for( int j=0; j<vg_list_size(fb->attachments); j++ )
+      {
+         struct framebuffer_attachment *at = &fb->attachments[j];
+
+         if( at->purpose == k_framebuffer_attachment_type_none )
+            continue;
+
+         if( modify_all )
+         {
+            render_framebuffer_show( fb, at, operation );
+         }
+         else
+         {
+            if( !strcmp( fb->display_name, argv[1] ) )
+            {
+               if( argc == 2 )
+                  render_framebuffer_show( fb, at, operation );
+               else if( !strcmp( at->display_name, argv[2] ) )
+                  render_framebuffer_show( fb, at, operation );
+            }
+         }
+      }
+   }
+
+   return 0;
+}
+
+VG_STATIC void render_framebuffer_poll( int argc, char const *argv[] )
+{
+   const char *term = argv[argc-1];
+
+   if( argc == 1 )
+   {
+      console_suggest_score_text( "show", term, 0 );
+      console_suggest_score_text( "hide", term, 0 );
+   }
+   else if( argc == 2 )
+   {
+      console_suggest_score_text( "all", term, 0 );
+
+      for( int i=0; i<vg_list_size(framebuffers); i++ )
+      {
+         struct framebuffer *fb = &framebuffers[i];
+         console_suggest_score_text( fb->display_name, term, 0 );
+      }
+   }
+   else if( argc == 3 )
+   {
+      int modify_all = 0;
+
+      if( !strcmp( argv[1], "all" ) )
+         modify_all = 1;
+
+      for( int i=0; i<vg_list_size(framebuffers); i++ )
+      {
+         struct framebuffer *fb = &framebuffers[i];
+         
+         for( int j=0; j<vg_list_size(fb->attachments); j++ )
+         {
+            struct framebuffer_attachment *at = &fb->attachments[j];
+
+            if( at->purpose == k_framebuffer_attachment_type_none )
+               continue;
 
-   glBindRenderbuffer( GL_RENDERBUFFER, *rb );
-   glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 
-         vg_window_x, vg_window_y );
+            if( modify_all )
+            {
+               console_suggest_score_text( at->display_name, term, 0 );
+            }
+            else if( !strcmp( fb->display_name, argv[1] ) )
+            {
+               console_suggest_score_text( at->display_name, term, 0 );
+            }
+         }
+      }
+   }
 }
 
 #endif /* RENDER_H */