variable scale menu

diff --git a/common.h b/common.h
index 24c7815071fb8df17020148703c23bd80ed02403..9eda6f67ae0e59dfcf76c8fd39b0f26d46d7d8ae 100644 (file)
--- a/common.h
+++ b/common.h
@@ -120,9 +120,6 @@ VG_STATIC int   k_debug_light_indices = 0,
                 k_debug_light_complexity = 0,
                 k_light_preview = 0;
 
-VG_STATIC int   g_render_x = 1,
-                g_render_y = 1;
-
 VG_STATIC int freecam = 0;
 VG_STATIC int walk_grid_iterations = 1;
 VG_STATIC float fc_speed = 10.0f;

diff --git a/menu.h b/menu.h
index bcd614198626e540ab06c4e792960c7b0758161e..4318e628141912a31a10dbc11b06567eb9f2a20f 100644 (file)
--- a/menu.h
+++ b/menu.h
@@ -49,13 +49,16 @@ VG_STATIC void menu_btn_settings( int event );
 VG_STATIC void menu_btn_invert_y( int event );
 
 VG_STATIC mdl_mesh *menu_mesh_fov_slider,
-                   *menu_mesh_vol_slider;
+                   *menu_mesh_vol_slider,
+                   *menu_mesh_res_slider;
 
 VG_STATIC ent_marker
                    *menu_mark_fov_min,
                    *menu_mark_fov_max,
                    *menu_mark_vol_min,
-                   *menu_mark_vol_max;
+                   *menu_mark_vol_max,
+                   *menu_mark_res_min,
+                   *menu_mark_res_max;
 
 struct{
    /* state */
@@ -188,7 +191,7 @@ VG_STATIC menu_buttons[] =
 
 { 
    "vol_slider",     menu_vis, {k_menu_page_settings},
-   .lu="text_blur"
+   .lu="res_slider"
 },
 { "vol_info",        menu_vis, {k_menu_page_settings} },
 
@@ -203,12 +206,18 @@ VG_STATIC menu_buttons[] =
 { 
    "text_blur",      menu_vis, {k_menu_page_settings},
    .fn_press = menu_btn_blur, 
-   .lu="text_invert_y", .ld="vol_slider"
+   .lu="text_invert_y", .ld="res_slider"
 },
 {
    "text_blur_check", menu_settings_if, {.ptr_generic=&cl_blur} 
 },
-
+{
+   "res_slider",     menu_vis, {k_menu_page_settings},
+   .ld = "vol_slider", .lu = "text_blur"
+},
+{
+   "res_info", menu_vis, {k_menu_page_settings},
+},
 { "ctr_xbox",        menu_controller_inf, {k_menu_controller_type_xbox}},
 { "ctr_xbox_text",   menu_controller_inf, {k_menu_controller_type_xbox}},
 { "ctr_steam",       menu_controller_inf, {k_menu_controller_type_steam}},
@@ -404,9 +413,14 @@ VG_STATIC void menu_init(void)
       ent_find_marker( &menu_model, &menu_markers, "vol_slider_max" );
    menu_mark_vol_min = 
       ent_find_marker( &menu_model, &menu_markers, "vol_slider_min" );
+   menu_mark_res_max =
+      ent_find_marker( &menu_model, &menu_markers, "res_slider_max" );
+   menu_mark_res_min =
+      ent_find_marker( &menu_model, &menu_markers, "res_slider_min" );
 
    menu_mesh_fov_slider = mdl_find_mesh( &menu_model, "fov_slider" );
    menu_mesh_vol_slider = mdl_find_mesh( &menu_model, "vol_slider" );
+   menu_mesh_res_slider = mdl_find_mesh( &menu_model, "res_slider" );
 
    shader_model_menu_register();
 
@@ -615,6 +629,11 @@ VG_STATIC void menu_page_settings(void)
                   menu_mesh_vol_slider, menu_mark_vol_min->transform.co,
                   menu_mark_vol_max->transform.co );
 
+   menu_slider( &gpipeline.view_render_scale, 
+                  (game_menu.loc == menu_get_loc( "res_slider" )),
+                  menu_mesh_res_slider, menu_mark_res_min->transform.co,
+                  menu_mark_res_max->transform.co );
+
    if( menu_page_should_backout() ){
       game_menu.page = k_menu_page_main;
       game_menu.loc = menu_get_loc( "text_settings" );

diff --git a/models_src/rs_menu.mdl b/models_src/rs_menu.mdl
index 2bcc670a270d70b71feb55d51abd21a47ab373b3..18c6db322b00ab8a34f40df8b7971e97c87e9f74 100644 (file)
Binary files a/models_src/rs_menu.mdl and b/models_src/rs_menu.mdl differ

diff --git a/render.h b/render.h
index e7220b0935a92f3a105eb8382bb8cd9345bfc1ba..712961ea3f196dc6956aeefe0b3c5164e2aef45c 100644 (file)
--- a/render.h
+++ b/render.h
@@ -28,7 +28,6 @@ VG_STATIC void render_world_depth( world_instance *world, camera *cam );
 
 typedef struct framebuffer framebuffer;
 
-
 /* 
  * All standard buffers used in rendering
  */
@@ -39,49 +38,22 @@ VG_STATIC struct pipeline
    framebuffer *fb_main,
                *fb_water_reflection,
                *fb_water_beneath;
-
-   struct light_widget
-   {
-      int enabled;
-      v2f dir;
-      v3f colour;
-   } 
-   widgets[3];
-
-   float shadow_spread, shadow_length;
-
    int ready;
+
+   float view_render_scale,
+         water_render_scale;
 }
-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,
-};
+gpipeline = { .view_render_scale = 1.0f };
 
 struct framebuffer
 {
    const char *display_name;
-   int         resolution_div,
+   int         resolution_div,   /* definition */
                fixed_w,
-               fixed_h;
+               fixed_h,
+
+               render_w,         /* runtime */
+               render_h;
 
    struct framebuffer_attachment
    {
@@ -209,25 +181,46 @@ framebuffers[] =
 VG_STATIC void render_fb_get_current_res( struct framebuffer *fb, 
                                           int *x, int *y )
 {
-   if( fb->resolution_div )
-   {
+   if( fb->resolution_div ){
       *x = vg.window_x / fb->resolution_div;
       *y = vg.window_y / fb->resolution_div;
    }
-   else
-   {
+   else{
       *x = fb->fixed_w;
       *y = fb->fixed_h;
    }
 }
 
+VG_STATIC void render_fb_inverse_ratio( framebuffer *fb, v2f inverse )
+{
+   int x, y;
+   render_fb_get_current_res( fb, &x, &y );
+
+   v2f render   = { fb->render_w, fb->render_h },
+       original = { x, y };
+
+   v2_div( render, original, inverse );
+}
+
 /*
  * Bind framebuffer for drawing to
  */
-VG_STATIC void render_fb_bind( framebuffer *fb )
+VG_STATIC void render_fb_bind( framebuffer *fb, int use_scaling )
 {
    int x, y;
    render_fb_get_current_res( fb, &x, &y );
+
+   if( use_scaling ){
+      x = gpipeline.view_render_scale*(float)x;
+      y = gpipeline.view_render_scale*(float)y;
+
+      x = VG_MAX( 16, x );
+      y = VG_MAX( 16, y );
+
+      fb->render_w = x;
+      fb->render_h = y;
+   }
+
    glBindFramebuffer( GL_FRAMEBUFFER, fb->fb );
    glViewport( 0, 0, x, y );
 }
@@ -612,13 +605,14 @@ VG_STATIC void render_view_framebuffer_ui(void)
    glBindVertexArray( gpipeline.fsquad.vao );
    shader_blit_use();
    shader_blit_uTexMain( 0 );
+   
+   v2f identity = { 1.0f, 1.0f };
+   shader_blit_uInverseRatio( identity );
 
-   for( int i=0; i<vg_list_size(framebuffers); i++ )
-   {
+   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++ )
-      {
+      for( int j=0; j<vg_list_size(fb->attachments); j++ ){
          struct framebuffer_attachment *at = &fb->attachments[j];
 
          if( !at->debug_view )
@@ -638,16 +632,14 @@ VG_STATIC void render_view_framebuffer_ui(void)
          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 )
-         {
+         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
-         {
+         else{
             render_fb_bind_texture( fb, j, 0 );
             
             int start = (viewing_count+2) * 6,

diff --git a/shaders/blit.h b/shaders/blit.h
index 12a0dcb2c293823f2b21104175ac7252c56b2b34..116007aa8194e58c09644ec8721ac4596ea61f52 100644 (file)
--- a/shaders/blit.h
+++ b/shaders/blit.h
@@ -12,10 +12,12 @@ static struct vg_shader _shader_blit = {
 "layout (location=0) in vec2 a_co;\n"
 "out vec2 aUv;\n"
 "\n"
+"uniform vec2 uInverseRatio;\n"
+"\n"
 "void main()\n"
 "{\n"
 "   gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
-"   aUv = a_co;\n"
+"   aUv = a_co * uInverseRatio;\n"
 "}\n"
 ""},
    .fs = 
@@ -66,7 +68,11 @@ static struct vg_shader _shader_blit = {
 ""},
 };
 
+static GLuint _uniform_blit_uInverseRatio;
 static GLuint _uniform_blit_uTexMain;
+static void shader_blit_uInverseRatio(v2f v){
+   glUniform2fv(_uniform_blit_uInverseRatio,1,v);
+}
 static void shader_blit_uTexMain(int i){
    glUniform1i(_uniform_blit_uTexMain,i);
 }
@@ -75,6 +81,7 @@ static void shader_blit_register(void){
 }
 static void shader_blit_use(void){ glUseProgram(_shader_blit.id); }
 static void shader_blit_link(void){
+   _uniform_blit_uInverseRatio = glGetUniformLocation( _shader_blit.id, "uInverseRatio" );
    _uniform_blit_uTexMain = glGetUniformLocation( _shader_blit.id, "uTexMain" );
 }
 #endif /* SHADER_blit_H */

diff --git a/shaders/blit.vs b/shaders/blit.vs
index 2593725364951e47a10d6af27922f8cf90505f99..06ffba6ba1e2383f0abe19e3093ac6a473f5917c 100644 (file)
--- a/shaders/blit.vs
+++ b/shaders/blit.vs
@@ -1,8 +1,10 @@
 layout (location=0) in vec2 a_co;
 out vec2 aUv;
 
+uniform vec2 uInverseRatio;
+
 void main()
 {
    gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);
-   aUv = a_co;
+   aUv = a_co * uInverseRatio;
 }

diff --git a/shaders/blitblur.h b/shaders/blitblur.h
index 0eca2cefa1d7278195cc2e3e6aa0d7297208887c..ac5f7847d4d2a4157f5a6505065112c15e3483b6 100644 (file)
--- a/shaders/blitblur.h
+++ b/shaders/blitblur.h
@@ -12,10 +12,12 @@ static struct vg_shader _shader_blitblur = {
 "layout (location=0) in vec2 a_co;\n"
 "out vec2 aUv;\n"
 "\n"
+"uniform vec2 uInverseRatio;\n"
+"\n"
 "void main()\n"
 "{\n"
 "   gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
-"   aUv = a_co;\n"
+"   aUv = a_co * uInverseRatio;\n"
 "}\n"
 ""},
    .fs = 
@@ -55,10 +57,14 @@ static struct vg_shader _shader_blitblur = {
 ""},
 };
 
+static GLuint _uniform_blitblur_uInverseRatio;
 static GLuint _uniform_blitblur_uTexMain;
 static GLuint _uniform_blitblur_uTexMotion;
 static GLuint _uniform_blitblur_uBlurStrength;
 static GLuint _uniform_blitblur_uOverrideDir;
+static void shader_blitblur_uInverseRatio(v2f v){
+   glUniform2fv(_uniform_blitblur_uInverseRatio,1,v);
+}
 static void shader_blitblur_uTexMain(int i){
    glUniform1i(_uniform_blitblur_uTexMain,i);
 }
@@ -76,6 +82,7 @@ static void shader_blitblur_register(void){
 }
 static void shader_blitblur_use(void){ glUseProgram(_shader_blitblur.id); }
 static void shader_blitblur_link(void){
+   _uniform_blitblur_uInverseRatio = glGetUniformLocation( _shader_blitblur.id, "uInverseRatio" );
    _uniform_blitblur_uTexMain = glGetUniformLocation( _shader_blitblur.id, "uTexMain" );
    _uniform_blitblur_uTexMotion = glGetUniformLocation( _shader_blitblur.id, "uTexMotion" );
    _uniform_blitblur_uBlurStrength = glGetUniformLocation( _shader_blitblur.id, "uBlurStrength" );

diff --git a/shaders/blitcolour.h b/shaders/blitcolour.h
index 3d5dd5ed83c0ea9563b328420b3c9f125a4733da..91a2e618dadde87618690ad999af6a2899947e00 100644 (file)
--- a/shaders/blitcolour.h
+++ b/shaders/blitcolour.h
@@ -12,10 +12,12 @@ static struct vg_shader _shader_blitcolour = {
 "layout (location=0) in vec2 a_co;\n"
 "out vec2 aUv;\n"
 "\n"
+"uniform vec2 uInverseRatio;\n"
+"\n"
 "void main()\n"
 "{\n"
 "   gl_Position = vec4(a_co*2.0-1.0,0.0,1.0);\n"
-"   aUv = a_co;\n"
+"   aUv = a_co * uInverseRatio;\n"
 "}\n"
 ""},
    .fs = 
@@ -34,7 +36,11 @@ static struct vg_shader _shader_blitcolour = {
 ""},
 };
 
+static GLuint _uniform_blitcolour_uInverseRatio;
 static GLuint _uniform_blitcolour_uColour;
+static void shader_blitcolour_uInverseRatio(v2f v){
+   glUniform2fv(_uniform_blitcolour_uInverseRatio,1,v);
+}
 static void shader_blitcolour_uColour(v4f v){
    glUniform4fv(_uniform_blitcolour_uColour,1,v);
 }
@@ -43,6 +49,7 @@ static void shader_blitcolour_register(void){
 }
 static void shader_blitcolour_use(void){ glUseProgram(_shader_blitcolour.id); }
 static void shader_blitcolour_link(void){
+   _uniform_blitcolour_uInverseRatio = glGetUniformLocation( _shader_blitcolour.id, "uInverseRatio" );
    _uniform_blitcolour_uColour = glGetUniformLocation( _shader_blitcolour.id, "uColour" );
 }
 #endif /* SHADER_blitcolour_H */

diff --git a/skaterift.c b/skaterift.c
index 00dbb110fa1a78279df0b2ff463c20c6afb5fd45..f0fb21802cf194d54e7762a7dcbdae536138afff 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -37,7 +37,6 @@ player_instance *tmp_localplayer(void)
 #include "vehicle.h"
 
 static int cl_ui      = 1,
-           cl_view_id = 0,
            cl_light_edit = 0;
 
 int main( int argc, char *argv[] )
@@ -126,14 +125,6 @@ VG_STATIC void vg_preload(void)
       .persistent = 0
    });
 
-   vg_var_push( (struct vg_var){
-      .name = "cl_view_id",
-      .data = &cl_view_id,
-      .data_type = k_var_dtype_i32,
-      .opt_i32 = { .min=0, .max=1, .clamp=1 },
-      .persistent = 0
-   });
-
    vg_var_push( (struct vg_var){
       .name = "ledit",
       .data = &cl_light_edit,
@@ -429,34 +420,34 @@ VG_STATIC void vg_framebuffer_resize( int w, int h )
 VG_STATIC void present_view_with_post_processing(void)
 {
    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+   glViewport( 0,0, vg.window_x, vg.window_y );
 
    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);
    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
    glBlendEquation(GL_FUNC_ADD);
 
+   v2f inverse;
+   render_fb_inverse_ratio( gpipeline.fb_main, inverse );
+
    if( cl_blur ){
       shader_blitblur_use();
       shader_blitblur_uTexMain( 0 );
       shader_blitblur_uTexMotion( 1 );
       shader_blitblur_uBlurStrength(cl_blur_strength / (vg.frame_delta*60.0f));
+      shader_blitblur_uInverseRatio( inverse );
 
       v2f menu_blurring;
       v2_muls( (v2f){ 0.04f, 0.001f }, menu_opacity, menu_blurring );
       shader_blitblur_uOverrideDir( menu_blurring );
 
-      if( cl_view_id == 0 )
-         render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
-      else if( cl_view_id == 1 )
-         render_fb_bind_texture( gpipeline.fb_main, 1, 0 );
-      else
-         render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
-
+      render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
       render_fb_bind_texture( gpipeline.fb_main, 1, 1 );
    }
    else{
       shader_blit_use();
       shader_blit_uTexMain( 0 );
+      shader_blit_uInverseRatio( inverse );
       render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
    }
 
@@ -480,13 +471,13 @@ VG_STATIC void render_player_transparent(void)
 
    /* Draw player to window buffer and blend background ontop */
    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+   glViewport( 0,0, vg.window_x, vg.window_y );
    player__render( &small_cam, &localplayer );
 }
 
 VG_STATIC void render_scene(void)
 {
-   render_fb_bind( gpipeline.fb_main );
-   glViewport( 0,0, g_render_x, g_render_y );
+   render_fb_bind( gpipeline.fb_main, 1 );
    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
 
@@ -503,10 +494,8 @@ VG_STATIC void render_scene(void)
 
    render_world( view_world, &main_camera, 0 );
 
-
    render_water_texture( view_world, &main_camera, 0 );
-   render_fb_bind( gpipeline.fb_main );
-   glViewport( 0,0, g_render_x, g_render_y );
+   render_fb_bind( gpipeline.fb_main, 1 );
    render_water_surface( view_world, &main_camera );
 
    int depth = 1;
@@ -588,11 +577,7 @@ VG_STATIC void vg_render(void)
 {
    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 
-   float scale = (sin(vg.time)*0.5f+0.5f)*0.75f+0.25f;
-   g_render_x = VG_MAX((float)vg.window_x * scale,64),
-   g_render_y = VG_MAX((float)vg.window_y * scale,64);
-
-   glViewport( 0,0, g_render_x, g_render_y );
+   glViewport( 0,0, vg.window_x, vg.window_y );
    glDisable( GL_DEPTH_TEST );
 
    glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
@@ -609,7 +594,6 @@ VG_STATIC void vg_render(void)
    glViewport( 0,0, vg.window_x, vg.window_y );
 }
 
-VG_STATIC void run_light_widget( struct light_widget *lw );
 VG_STATIC void vg_ui(void)
 {
 #if 0
@@ -617,43 +601,6 @@ VG_STATIC void vg_ui(void)
 #endif
    world_instance *world = get_active_world();
    menu_crap_ui();
-
-#if 0
-   if( cl_light_edit )
-   {
-      vg_uictx.cursor[0] = 10;
-      vg_uictx.cursor[1] = 10;
-      vg_uictx.cursor[2] = 200;
-      vg_uictx.cursor[3] = 20;
-
-      struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
-      struct ui_slider_vector 
-         s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
-
-      struct ui_slider
-         s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
-         s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
-
-      for( int i=0; i<3; i++ )
-         run_light_widget( &gpipeline.widgets[i] );
-      
-      ui_text( vg_uictx.cursor, "Ambient", 1, 0 );
-      vg_uictx.cursor[1] += 16;
-      ui_slider_vector( &s5 );
-
-      ui_text( vg_uictx.cursor, "Shadows", 1, 0 );
-      vg_uictx.cursor[1] += 16;
-      ui_slider( &s8 );
-      ui_slider( &s9 );
-
-      ui_text( vg_uictx.cursor, "Misc", 1, 0 );
-      vg_uictx.cursor[1] += 16;
-      struct ui_checkbox c1 = {.data = &wl->g_light_preview};
-      ui_checkbox( &c1 );
-
-      render_update_lighting_ub();
-   }
-#endif
    
    audio_debug_soundscapes();
    render_view_framebuffer_ui();
@@ -663,24 +610,6 @@ VG_STATIC void vg_ui(void)
 #endif
 }
 
-VG_STATIC void run_light_widget( struct light_widget *lw )
-{
-   struct ui_checkbox c1 = { .data=&lw->enabled };
-
-   ui_checkbox( &c1 );
-   
-   if( lw->enabled )
-   {
-      struct ui_slider_vector 
-         colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
-         dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
-
-      ui_slider_vector( &colour );
-      vg_uictx.cursor[1] += 4;
-      ui_slider_vector( &dir );
-   }
-}
-
 VG_STATIC void run_debug_info(void)
 {
 #if 0

diff --git a/world_gate.h b/world_gate.h
index 2febafaaa0434f46a249ec2036cb686532e569ca..ad87ed1d106cdf8c484071c3fc1603805ddc8a55 100644 (file)
--- a/world_gate.h
+++ b/world_gate.h
@@ -155,7 +155,7 @@ VG_STATIC int render_gate( world_instance *world_inside,
       glDisable( GL_STENCIL_TEST );
 
       render_water_texture( world_inside, &gate_camera, layer_depth );
-      render_fb_bind( gpipeline.fb_main );
+      render_fb_bind( gpipeline.fb_main, 1 );
 
       glEnable( GL_STENCIL_TEST );
 

diff --git a/world_gen.h b/world_gen.h
index fb6031b32f02552d908f2c00abffc599641dbd88..3117dc071bba27e490a6167153a3d6d7f0a74400 100644 (file)
--- a/world_gen.h
+++ b/world_gen.h
@@ -498,7 +498,7 @@ VG_STATIC void world_post_process( world_instance *world )
       glDisable(GL_DEPTH_TEST);
       glDisable(GL_BLEND);
       glDisable(GL_CULL_FACE);
-      render_fb_bind( &world->heightmap );
+      render_fb_bind( &world->heightmap, 0 );
       shader_blitcolour_use();
       shader_blitcolour_uColour( (v4f){-9999.0f,-9999.0f,-9999.0f,-9999.0f} );
       render_fsquad();

diff --git a/world_water.h b/world_water.h
index 7d67b136893d80753bea1f776d24d3e9620145e2..84558a20f392c591449057d404d77f432b176849 100644 (file)
--- a/world_water.h
+++ b/world_water.h
@@ -55,7 +55,7 @@ VG_STATIC void render_water_texture( world_instance *world, camera *cam,
       return;
 
    /* Draw reflection buffa */
-   render_fb_bind( gpipeline.fb_water_reflection );
+   render_fb_bind( gpipeline.fb_water_reflection, 1 );
    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 
    /* 
@@ -101,7 +101,7 @@ VG_STATIC void render_water_texture( world_instance *world, camera *cam,
     * Create beneath view matrix
     */
    camera beneath_cam;
-   render_fb_bind( gpipeline.fb_water_beneath );
+   render_fb_bind( gpipeline.fb_water_beneath, 1 );
    glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 
@@ -121,7 +121,7 @@ VG_STATIC void render_water_texture( world_instance *world, camera *cam,
    glEnable( GL_DEPTH_TEST );
    glDisable( GL_BLEND );
    render_world_depth( world, &beneath_cam );
-   glViewport( 0,0, g_render_x, g_render_y );
+   //glViewport( 0,0, g_render_x, g_render_y );
 }
 
 VG_STATIC void render_water_surface( world_instance *world, camera *cam )