From: hgn <hgodden00@gmail.com>
Date: Wed, 19 Oct 2022 02:22:15 +0000 (+0100)
Subject: MENY
X-Git-Url: https://harrygodden.com/git/?a=commitdiff_plain;ds=sidebyside;h=15beb60ade240af4e00b0d204f7e89a4d35dca36;p=carveJwlIkooP6JGAAIwe30JlM.git

MENY
---

diff --git a/main.c b/main.c
index 5cce721..bbb4c32 100644
--- a/main.c
+++ b/main.c
@@ -27,6 +27,7 @@
 #include "world.h"
 #include "player.h"
 #include "network.h"
+#include "menu.h"
 
 static int cl_ui     = 1,
            cl_menu   = 0;
@@ -70,13 +71,13 @@ vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
 
    steam_init();
    vg_loader_highwater( NULL, steam_end, NULL );
-
    vg_loader_highwater( network_init, network_end, NULL );
 }
 
 void vg_load(void)
 {
    vg_loader_highwater( render_init, render_free, NULL );
+   vg_loader_highwater( menu_init, menu_free, NULL );
    vg_loader_highwater( world_init, world_free, NULL );
    vg_loader_highwater( player_init, NULL, NULL );
 
@@ -92,7 +93,7 @@ void vg_load(void)
 
 static void vg_start(void)
 {
-   player_load_model( "ch_outlaw" );
+   player_load_model( "ch_jordan" );
    reset_player( 1, (const char *[]){ "start" } );
 }
 
@@ -109,21 +110,27 @@ void vg_update( int loaded )
 
    if( loaded )
    {
+      if( vg_get_button_down( "menu" ) )
+      {
+         cl_menu = !cl_menu;
+      }
+
       draw_origin_axis();
       network_update();
-      player_update_pre();
-      world_update( player.phys.rb.co );
-   }
 
-   if( vg_get_button_down( "menu" ) )
-   {
-      cl_menu = !cl_menu;
+      if( !cl_menu )
+      {
+         player_update_pre();
+         world_update( player.phys.rb.co );
+      }
+
+      menu_update( cl_menu );
    }
 }
 
 static void vg_update_fixed( int loaded )
 {
-   if( loaded )
+   if( loaded && !cl_menu )
    {
       player_update_fixed();
    }
@@ -131,7 +138,7 @@ static void vg_update_fixed( int loaded )
 
 static void vg_update_post( int loaded )
 {
-   if( loaded )
+   if( loaded && !cl_menu )
    {
       player_update_post();
    }
@@ -146,17 +153,32 @@ static void vg_framebuffer_resize( int w, int h )
 
 static void render_main_game(void)
 {
+   v3f *active_cam_inv = NULL,
+       *active_cam     = NULL;
+
    m4x4f world_4x4;
-   m4x3_expand( player.camera_inverse, world_4x4 );
+
+   if( cl_menu )
+   {
+      active_cam = menu_cam;
+      active_cam_inv = menu_cam_inv;
+   }
+   else
+   {
+      active_cam_inv = player.camera_inverse;
+      active_cam = player.camera;
+   }
+
+   m4x3_expand( active_cam_inv, world_4x4 );
 
    static float fov = 97.0f;
-   float fov_target = player.phys.on_board? 125.0f: 108.0f;
+   float fov_target = (player.phys.on_board&&!cl_menu)? 125.0f: 108.0f;
    fov = vg_lerpf( fov, fov_target, vg.time_delta * 2.0f );
 
    gpipeline.fov = freecam? 60.0f: fov; /* 120 */
    m4x4_projection( vg.pv, gpipeline.fov, 
          (float)vg.window_x / (float)vg.window_y, 
-         0.02f, 2100.0f );
+         0.1f, 2100.0f );
 
    m4x4_mul( vg.pv, world_4x4, vg.pv );
    glEnable( GL_DEPTH_TEST );
@@ -167,15 +189,18 @@ static void render_main_game(void)
 
    int draw_solid = player.is_dead | freecam;
    
-   render_world( vg.pv, player.camera );
+   render_world( vg.pv, active_cam );
    if( draw_solid )
-      draw_player();
-   render_water_texture( player.camera );
+      draw_player( active_cam );
+
+   render_water_texture( active_cam );
 
    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
-   render_water_surface( vg.pv, player.camera );
+   render_water_surface( vg.pv, active_cam );
+   render_world_gates( vg.pv, player.phys.rb.co, active_cam );
 
-   render_world_gates( vg.pv, player.phys.rb.co, player.camera );
+   if( cl_menu )
+      menu_render( vg.pv );
    
    /* Copy the RGB of what we have into the background buffer */
    glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 );
@@ -200,7 +225,7 @@ static void render_main_game(void)
             (float)vg.window_x / (float)vg.window_y, 
             0.01f, 600.0f );
       m4x4_mul( vg.pv, world_4x4, vg.pv );
-      draw_player();
+      draw_player( active_cam );
    }
 
    /* Draw back in the background
@@ -242,6 +267,7 @@ void vg_render(void)
 
 void vg_ui(void)
 {
+#if 0
    if( cl_menu )
    {
       ui_rect menu =
@@ -275,7 +301,6 @@ void vg_ui(void)
       }
    }
    
-#if 0
    if( lightedit )
    {
       ui_global_ctx.cursor[0] = 10;
diff --git a/menu.h b/menu.h
new file mode 100644
index 0000000..e062b30
--- /dev/null
+++ b/menu.h
@@ -0,0 +1,135 @@
+#ifndef MENU_H
+#define MENU_H
+
+#include "common.h"
+#include "model.h"
+#include "world_render.h"
+#include "player.h"
+
+#include "shaders/menu.h"
+
+static mdl_header *menu_model;
+static glmesh      menu_glmesh;
+static v3f         menu_cam_pos,
+                   menu_target_cam_pos;
+static v4f         menu_cam_q = { 0.0f, 0.0f, 0.0f, 1.0f },
+                   menu_target_cam_q;
+static m4x3f       menu_cam, menu_cam_inv;
+static float       menu_opacity = 0.0f;
+
+static void menu_init(void)
+{
+   menu_model = mdl_load( "models/rs_menu.mdl" );
+
+   if( !menu_model )
+      vg_fatal_exit_loop( "No menu model" );
+
+   vg_acquire_thread_sync();
+   mdl_unpack_glmesh( menu_model, &menu_glmesh );
+   vg_release_thread_sync();
+
+   shader_menu_register();
+}
+
+static void menu_update( int enabled )
+{
+   static int enabled_last = 0;
+
+   if( enabled && !enabled_last )
+   {
+      v3_copy( player.camera[3], menu_cam_pos );
+      m3x3_q( player.camera, menu_cam_q );
+
+      if( player.phys.on_board )
+      {
+         v4f r90;
+         q_axis_angle( r90, player.phys.rb.up, VG_PIf*-0.5f );
+         q_mul( r90, player.phys.rb.q, menu_target_cam_q );
+         m4x3_mulv( player.phys.rb.to_world, (v3f){-1.0f,1.6f,0.0f},
+                                             menu_target_cam_pos );
+      }
+      else
+      {
+         v4f r180;
+         q_axis_angle( r180, player.phys.rb.up, VG_PIf );
+         q_mul( r180, player.phys.rb.q, menu_target_cam_q );
+         m4x3_mulv( player.phys.rb.to_world, (v3f){0.0f,1.6f,-1.0f},
+                                             menu_target_cam_pos );
+      }
+
+      q_normalize( menu_target_cam_q );
+      q_normalize( menu_cam_q );
+      menu_opacity = 0.0f;
+   }
+
+   if( enabled_last && !enabled )
+   {
+      m3x3_q( player.camera, menu_target_cam_q );
+      v3_copy( player.camera[3], menu_target_cam_pos );
+   }
+
+   float dt = vg.time_delta * 6.0f;
+
+   q_nlerp( menu_cam_q, menu_target_cam_q, dt, menu_cam_q );
+   v3_lerp( menu_cam_pos, menu_target_cam_pos, dt, menu_cam_pos );
+
+   q_m3x3( menu_cam_q, menu_cam );
+   v3_copy( menu_cam_pos, menu_cam[3] );
+   m4x3_invert_affine( menu_cam, menu_cam_inv );
+   menu_opacity = vg_lerpf( menu_opacity, enabled, dt );
+
+   enabled_last = enabled;
+}
+
+static void menu_render( m4x4f projection )
+{
+   glEnable(GL_BLEND);
+   glDisable(GL_DEPTH_TEST);
+   glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+   glBlendEquation(GL_FUNC_ADD);
+
+   shader_fscolour_use();
+   shader_fscolour_uColour( (v4f){ 0.1f, 0.1f, 0.3f, menu_opacity*0.5f } );
+   render_fsquad();
+
+   glEnable( GL_DEPTH_TEST );
+   glDisable( GL_BLEND );
+
+   m4x3f mtx;
+   
+   shader_menu_use();
+   shader_menu_uColour( (v4f){ 1.0f,1.0f,1.0f,1.0f} );
+   shader_menu_uTexMain( 1 );
+   vg_tex2d_bind( &tex_graffiti, 1 );
+
+   shader_menu_uPv( projection );
+   mesh_bind( &menu_glmesh );
+
+   m4x3_identity( mtx );
+   shader_menu_uMdl( mtx );
+   mesh_draw( &menu_glmesh );
+
+   for( int i=0; i<menu_model->node_count; i++ )
+   {
+      mdl_node *pnode = mdl_node_from_id( menu_model, i );
+      
+      for( int j=0; j<pnode->submesh_count; j++ )
+      {
+         mdl_submesh *sm = 
+            mdl_submesh_from_id( menu_model, pnode->submesh_start+j );
+
+         mdl_node_transform( pnode, mtx );
+         m4x3_mul( player.phys.rb.to_world, mtx, mtx );
+         shader_menu_uMdl( mtx );
+
+         mdl_draw_submesh( sm );
+      }
+   }
+}
+
+static void menu_free(void *_)
+{
+   mesh_free( &menu_glmesh );
+}
+
+#endif /* MENU_H */
diff --git a/models_src/ch_jordan.mdl b/models_src/ch_jordan.mdl
index a191251..3af60ac 100644
Binary files a/models_src/ch_jordan.mdl and b/models_src/ch_jordan.mdl differ
diff --git a/models_src/rs_menu.mdl b/models_src/rs_menu.mdl
new file mode 100644
index 0000000..a852486
Binary files /dev/null and b/models_src/rs_menu.mdl differ
diff --git a/player.h b/player.h
index 0d77338..38c3224 100644
--- a/player.h
+++ b/player.h
@@ -318,7 +318,7 @@ static void player_update_post(void)
    player_camera_update();
 }
 
-static void draw_player(void)                                            /* 3 */
+static void draw_player( m4x3f cam )
 {
    if( player.is_dead )
       player_model_copy_ragdoll();
@@ -326,7 +326,7 @@ static void draw_player(void)                                            /* 3 */
    shader_viewchar_use();
    vg_tex2d_bind( &tex_characters, 0 );
    shader_viewchar_uTexMain( 0 );
-   shader_viewchar_uCamera( player.camera[3] );
+   shader_viewchar_uCamera( cam[3] );
    shader_viewchar_uPv( vg.pv );
    shader_link_standard_ub( _shader_viewchar.id, 2 );
    glUniformMatrix4x3fv( _uniform_viewchar_uTransforms, 
diff --git a/player_animation.h b/player_animation.h
index ea7d566..9f0c0d5 100644
--- a/player_animation.h
+++ b/player_animation.h
@@ -139,8 +139,8 @@ static void player_animate(void)
    offset[1] *= -0.3f;
    offset[2] *= 0.01f;
 
-   offset[0] = vg_clampf( offset[0], -0.8f, 0.8f );
-   offset[1] = vg_clampf( offset[1], -0.5f, 0.0f );
+   offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(player.fslide)*0.9f);
+   offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
 
    /* 
     * Animation blending
@@ -245,7 +245,7 @@ static void player_animate(void)
 
    skeleton_lerp_pose( sk, ground_pose, air_pose, player.ffly, apose );
 
-   float add_grab_mod = 1.0f - player.ffly*phys->grab;
+   float add_grab_mod = 1.0f - player.ffly;//*phys->grab;
 
    /* additive effects */
    {
diff --git a/render.h b/render.h
index f97d612..8122b2a 100644
--- a/render.h
+++ b/render.h
@@ -8,7 +8,6 @@
 #include "shaders/blit.h"
 #include "shaders/standard.h"
 #include "shaders/vblend.h"
-#include "shaders/unlit.h"
 
 static void render_water_texture( m4x3f camera );
 static void render_water_surface( m4x4f pv, m4x3f camera );
@@ -347,7 +346,6 @@ static void render_init(void)
    shader_blit_register();
    shader_standard_register();
    shader_vblend_register();
-   shader_unlit_register();
 
    vg_acquire_thread_sync();
    {
diff --git a/shaders.sh b/shaders.sh
index b4b0f03..4d78657 100755
--- a/shaders.sh
+++ b/shaders.sh
@@ -13,7 +13,6 @@ shader(){
 shader blit blit.vs blit.fs
 shader standard standard.vs standard.fs
 shader vblend standard.vs vblend.fs
-shader unlit standard.vs unlit.fs
 shader terrain standard.vs terrain.fs
 shader sky standard.vs sky.fs
 shader planeinf standard.vs planeinf.fs
@@ -27,6 +26,7 @@ shader gatelq gate.vs gate_lq.fs
 shader route standard.vs route.fs
 shader routeui routeui.vs routeui.fs
 shader viewchar standard_skinned.vs viewchar.fs
+shader menu standard.vs unlit.fs
 
 cd shaders
 ../bin/linux/tools/shader $target_shaders
diff --git a/shaders/alphatest.h b/shaders/alphatest.h
index 80ce028..9b161c1 100644
--- a/shaders/alphatest.h
+++ b/shaders/alphatest.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_alphatest = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -186,19 +186,19 @@ static struct vg_shader _shader_alphatest = {
 ""},
 };
 
-static GLuint _uniform_alphatest_uPv;
 static GLuint _uniform_alphatest_uMdl;
+static GLuint _uniform_alphatest_uPv;
 static GLuint _uniform_alphatest_uTexGarbage;
 static GLuint _uniform_alphatest_uTexMain;
 static GLuint _uniform_alphatest_uCamera;
 static GLuint _uniform_alphatest_uPlane;
 static GLuint _uniform_alphatest_g_world_depth;
-static void shader_alphatest_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_alphatest_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_alphatest_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_alphatest_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_alphatest_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_alphatest_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_alphatest_uTexGarbage(int i){
    glUniform1i( _uniform_alphatest_uTexGarbage, i );
 }
@@ -219,8 +219,8 @@ static void shader_alphatest_register(void){
 }
 static void shader_alphatest_use(void){ glUseProgram(_shader_alphatest.id); }
 static void shader_alphatest_link(void){
-   _uniform_alphatest_uPv = glGetUniformLocation( _shader_alphatest.id, "uPv" );
    _uniform_alphatest_uMdl = glGetUniformLocation( _shader_alphatest.id, "uMdl" );
+   _uniform_alphatest_uPv = glGetUniformLocation( _shader_alphatest.id, "uPv" );
    _uniform_alphatest_uTexGarbage = glGetUniformLocation( _shader_alphatest.id, "uTexGarbage" );
    _uniform_alphatest_uTexMain = glGetUniformLocation( _shader_alphatest.id, "uTexMain" );
    _uniform_alphatest_uCamera = glGetUniformLocation( _shader_alphatest.id, "uCamera" );
diff --git a/shaders/gpos.h b/shaders/gpos.h
index 1cb364e..8b7dbf4 100644
--- a/shaders/gpos.h
+++ b/shaders/gpos.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_gpos = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -174,16 +174,16 @@ static struct vg_shader _shader_gpos = {
 ""},
 };
 
-static GLuint _uniform_gpos_uPv;
 static GLuint _uniform_gpos_uMdl;
+static GLuint _uniform_gpos_uPv;
 static GLuint _uniform_gpos_uCamera;
 static GLuint _uniform_gpos_g_world_depth;
-static void shader_gpos_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_gpos_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_gpos_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_gpos_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_gpos_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_gpos_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_gpos_uCamera(v3f v){
    glUniform3fv( _uniform_gpos_uCamera, 1, v );
 }
@@ -195,8 +195,8 @@ static void shader_gpos_register(void){
 }
 static void shader_gpos_use(void){ glUseProgram(_shader_gpos.id); }
 static void shader_gpos_link(void){
-   _uniform_gpos_uPv = glGetUniformLocation( _shader_gpos.id, "uPv" );
    _uniform_gpos_uMdl = glGetUniformLocation( _shader_gpos.id, "uMdl" );
+   _uniform_gpos_uPv = glGetUniformLocation( _shader_gpos.id, "uPv" );
    _uniform_gpos_uCamera = glGetUniformLocation( _shader_gpos.id, "uCamera" );
    _uniform_gpos_g_world_depth = glGetUniformLocation( _shader_gpos.id, "g_world_depth" );
 }
diff --git a/shaders/menu.fs b/shaders/menu.fs
new file mode 100644
index 0000000..e957ddf
--- /dev/null
+++ b/shaders/menu.fs
@@ -0,0 +1,19 @@
+out vec4 FragColor;
+
+uniform sampler2D uTexMain;
+uniform vec4 uColour;
+
+in vec4 aColour;
+in vec2 aUv;
+in vec3 aNorm;
+in vec3 aCo;
+
+void main()
+{
+   vec4 diffuse = texture( uTexMain, aUv );
+
+   if( diffuse.a < 0.5 )
+      discard;
+
+   FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;
+}
diff --git a/shaders/menu.h b/shaders/menu.h
new file mode 100644
index 0000000..67700e8
--- /dev/null
+++ b/shaders/menu.h
@@ -0,0 +1,89 @@
+#ifndef SHADER_menu_H
+#define SHADER_menu_H
+static void shader_menu_link(void);
+static void shader_menu_register(void);
+static struct vg_shader _shader_menu = {
+   .name = "menu",
+   .link = shader_menu_link,
+   .vs = 
+{
+.orig_file = "../../shaders/standard.vs",
+.static_src = 
+"layout (location=0) in vec3 a_co;\n"
+"layout (location=1) in vec3 a_norm;\n"
+"layout (location=2) in vec2 a_uv;\n"
+"layout (location=3) in vec4 a_colour;\n"
+"layout (location=4) in vec4 a_weights;\n"
+"layout (location=5) in ivec4 a_groups;\n"
+"\n"
+"#line      2        0 \n"
+"\n"
+"uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
+"\n"
+"out vec4 aColour;\n"
+"out vec2 aUv;\n"
+"out vec3 aNorm;\n"
+"out vec3 aCo;\n"
+"out vec3 aWorldCo;\n"
+"\n"
+"void main()\n"
+"{\n"
+"   vec3 world_pos = uMdl * vec4(a_co,1.0);\n"
+"   gl_Position = uPv * vec4( world_pos, 1.0 );\n"
+"   aColour = a_colour;\n"
+"   aUv = a_uv;\n"
+"   aNorm = mat3(uMdl) * a_norm;\n"
+"   aCo = a_co;\n"
+"   aWorldCo = world_pos;\n"
+"}\n"
+""},
+   .fs = 
+{
+.orig_file = "../../shaders/unlit.fs",
+.static_src = 
+"out vec4 FragColor;\n"
+"\n"
+"uniform sampler2D uTexMain;\n"
+"uniform vec4 uColour;\n"
+"\n"
+"in vec4 aColour;\n"
+"in vec2 aUv;\n"
+"in vec3 aNorm;\n"
+"in vec3 aCo;\n"
+"\n"
+"void main()\n"
+"{\n"
+"   vec3 diffuse = texture( uTexMain, aUv ).rgb;\n"
+"   FragColor = vec4( diffuse, 1.0 );\n"
+"}\n"
+""},
+};
+
+static GLuint _uniform_menu_uMdl;
+static GLuint _uniform_menu_uPv;
+static GLuint _uniform_menu_uTexMain;
+static GLuint _uniform_menu_uColour;
+static void shader_menu_uMdl(m4x3f m){
+   glUniformMatrix4x3fv( _uniform_menu_uMdl, 1, GL_FALSE, (float *)m );
+}
+static void shader_menu_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_menu_uPv, 1, GL_FALSE, (float *)m );
+}
+static void shader_menu_uTexMain(int i){
+   glUniform1i( _uniform_menu_uTexMain, i );
+}
+static void shader_menu_uColour(v4f v){
+   glUniform4fv( _uniform_menu_uColour, 1, v );
+}
+static void shader_menu_register(void){
+   vg_shader_register( &_shader_menu );
+}
+static void shader_menu_use(void){ glUseProgram(_shader_menu.id); }
+static void shader_menu_link(void){
+   _uniform_menu_uMdl = glGetUniformLocation( _shader_menu.id, "uMdl" );
+   _uniform_menu_uPv = glGetUniformLocation( _shader_menu.id, "uPv" );
+   _uniform_menu_uTexMain = glGetUniformLocation( _shader_menu.id, "uTexMain" );
+   _uniform_menu_uColour = glGetUniformLocation( _shader_menu.id, "uColour" );
+}
+#endif /* SHADER_menu_H */
diff --git a/shaders/planeinf.h b/shaders/planeinf.h
index a0272a8..bb2a89a 100644
--- a/shaders/planeinf.h
+++ b/shaders/planeinf.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_planeinf = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -72,16 +72,16 @@ static struct vg_shader _shader_planeinf = {
 ""},
 };
 
-static GLuint _uniform_planeinf_uPv;
 static GLuint _uniform_planeinf_uMdl;
+static GLuint _uniform_planeinf_uPv;
 static GLuint _uniform_planeinf_uCamera;
 static GLuint _uniform_planeinf_uPlane;
-static void shader_planeinf_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_planeinf_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_planeinf_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_planeinf_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_planeinf_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_planeinf_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_planeinf_uCamera(v3f v){
    glUniform3fv( _uniform_planeinf_uCamera, 1, v );
 }
@@ -93,8 +93,8 @@ static void shader_planeinf_register(void){
 }
 static void shader_planeinf_use(void){ glUseProgram(_shader_planeinf.id); }
 static void shader_planeinf_link(void){
-   _uniform_planeinf_uPv = glGetUniformLocation( _shader_planeinf.id, "uPv" );
    _uniform_planeinf_uMdl = glGetUniformLocation( _shader_planeinf.id, "uMdl" );
+   _uniform_planeinf_uPv = glGetUniformLocation( _shader_planeinf.id, "uPv" );
    _uniform_planeinf_uCamera = glGetUniformLocation( _shader_planeinf.id, "uCamera" );
    _uniform_planeinf_uPlane = glGetUniformLocation( _shader_planeinf.id, "uPlane" );
 }
diff --git a/shaders/route.h b/shaders/route.h
index 2ecff91..271a47f 100644
--- a/shaders/route.h
+++ b/shaders/route.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_route = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -199,19 +199,19 @@ static struct vg_shader _shader_route = {
 ""},
 };
 
-static GLuint _uniform_route_uPv;
 static GLuint _uniform_route_uMdl;
+static GLuint _uniform_route_uPv;
 static GLuint _uniform_route_uTexGarbage;
 static GLuint _uniform_route_uTexGradients;
 static GLuint _uniform_route_uCamera;
 static GLuint _uniform_route_uColour;
 static GLuint _uniform_route_g_world_depth;
-static void shader_route_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_route_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_route_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_route_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_route_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_route_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_route_uTexGarbage(int i){
    glUniform1i( _uniform_route_uTexGarbage, i );
 }
@@ -232,8 +232,8 @@ static void shader_route_register(void){
 }
 static void shader_route_use(void){ glUseProgram(_shader_route.id); }
 static void shader_route_link(void){
-   _uniform_route_uPv = glGetUniformLocation( _shader_route.id, "uPv" );
    _uniform_route_uMdl = glGetUniformLocation( _shader_route.id, "uMdl" );
+   _uniform_route_uPv = glGetUniformLocation( _shader_route.id, "uPv" );
    _uniform_route_uTexGarbage = glGetUniformLocation( _shader_route.id, "uTexGarbage" );
    _uniform_route_uTexGradients = glGetUniformLocation( _shader_route.id, "uTexGradients" );
    _uniform_route_uCamera = glGetUniformLocation( _shader_route.id, "uCamera" );
diff --git a/shaders/sky.h b/shaders/sky.h
index 0abd65a..53fb5a6 100644
--- a/shaders/sky.h
+++ b/shaders/sky.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_sky = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -78,17 +78,17 @@ static struct vg_shader _shader_sky = {
 ""},
 };
 
-static GLuint _uniform_sky_uPv;
 static GLuint _uniform_sky_uMdl;
+static GLuint _uniform_sky_uPv;
 static GLuint _uniform_sky_uColour;
 static GLuint _uniform_sky_uTexGarbage;
 static GLuint _uniform_sky_uTime;
-static void shader_sky_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_sky_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_sky_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_sky_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_sky_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_sky_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_sky_uColour(v4f v){
    glUniform4fv( _uniform_sky_uColour, 1, v );
 }
@@ -103,8 +103,8 @@ static void shader_sky_register(void){
 }
 static void shader_sky_use(void){ glUseProgram(_shader_sky.id); }
 static void shader_sky_link(void){
-   _uniform_sky_uPv = glGetUniformLocation( _shader_sky.id, "uPv" );
    _uniform_sky_uMdl = glGetUniformLocation( _shader_sky.id, "uMdl" );
+   _uniform_sky_uPv = glGetUniformLocation( _shader_sky.id, "uPv" );
    _uniform_sky_uColour = glGetUniformLocation( _shader_sky.id, "uColour" );
    _uniform_sky_uTexGarbage = glGetUniformLocation( _shader_sky.id, "uTexGarbage" );
    _uniform_sky_uTime = glGetUniformLocation( _shader_sky.id, "uTime" );
diff --git a/shaders/standard.h b/shaders/standard.h
index 16f36ce..cf98fb0 100644
--- a/shaders/standard.h
+++ b/shaders/standard.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_standard = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -65,16 +65,16 @@ static struct vg_shader _shader_standard = {
 ""},
 };
 
-static GLuint _uniform_standard_uPv;
 static GLuint _uniform_standard_uMdl;
+static GLuint _uniform_standard_uPv;
 static GLuint _uniform_standard_uTexMain;
 static GLuint _uniform_standard_uColour;
-static void shader_standard_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_standard_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_standard_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_standard_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_standard_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_standard_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_standard_uTexMain(int i){
    glUniform1i( _uniform_standard_uTexMain, i );
 }
@@ -86,8 +86,8 @@ static void shader_standard_register(void){
 }
 static void shader_standard_use(void){ glUseProgram(_shader_standard.id); }
 static void shader_standard_link(void){
-   _uniform_standard_uPv = glGetUniformLocation( _shader_standard.id, "uPv" );
    _uniform_standard_uMdl = glGetUniformLocation( _shader_standard.id, "uMdl" );
+   _uniform_standard_uPv = glGetUniformLocation( _shader_standard.id, "uPv" );
    _uniform_standard_uTexMain = glGetUniformLocation( _shader_standard.id, "uTexMain" );
    _uniform_standard_uColour = glGetUniformLocation( _shader_standard.id, "uColour" );
 }
diff --git a/shaders/standard.vs b/shaders/standard.vs
index ac062ae..33f4154 100644
--- a/shaders/standard.vs
+++ b/shaders/standard.vs
@@ -1,7 +1,7 @@
 #include "vertex_standard.glsl"
 
-uniform mat4 uPv;
 uniform mat4x3 uMdl;
+uniform mat4 uPv;
 
 out vec4 aColour;
 out vec2 aUv;
diff --git a/shaders/terrain.h b/shaders/terrain.h
index 0635662..5ebef38 100644
--- a/shaders/terrain.h
+++ b/shaders/terrain.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_terrain = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -200,18 +200,18 @@ static struct vg_shader _shader_terrain = {
 ""},
 };
 
-static GLuint _uniform_terrain_uPv;
 static GLuint _uniform_terrain_uMdl;
+static GLuint _uniform_terrain_uPv;
 static GLuint _uniform_terrain_uTexGarbage;
 static GLuint _uniform_terrain_uTexGradients;
 static GLuint _uniform_terrain_uCamera;
 static GLuint _uniform_terrain_g_world_depth;
-static void shader_terrain_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_terrain_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_terrain_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_terrain_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_terrain_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_terrain_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_terrain_uTexGarbage(int i){
    glUniform1i( _uniform_terrain_uTexGarbage, i );
 }
@@ -229,8 +229,8 @@ static void shader_terrain_register(void){
 }
 static void shader_terrain_use(void){ glUseProgram(_shader_terrain.id); }
 static void shader_terrain_link(void){
-   _uniform_terrain_uPv = glGetUniformLocation( _shader_terrain.id, "uPv" );
    _uniform_terrain_uMdl = glGetUniformLocation( _shader_terrain.id, "uMdl" );
+   _uniform_terrain_uPv = glGetUniformLocation( _shader_terrain.id, "uPv" );
    _uniform_terrain_uTexGarbage = glGetUniformLocation( _shader_terrain.id, "uTexGarbage" );
    _uniform_terrain_uTexGradients = glGetUniformLocation( _shader_terrain.id, "uTexGradients" );
    _uniform_terrain_uCamera = glGetUniformLocation( _shader_terrain.id, "uCamera" );
diff --git a/shaders/unlit.fs b/shaders/unlit.fs
index ec4d7ae..bc57d62 100644
--- a/shaders/unlit.fs
+++ b/shaders/unlit.fs
@@ -11,5 +11,5 @@ in vec3 aCo;
 void main()
 {
    vec3 diffuse = texture( uTexMain, aUv ).rgb;
-   FragColor = vec4(pow(diffuse,vec3(1.0)),1.0);
+   FragColor = vec4( diffuse, 1.0 );
 }
diff --git a/shaders/vblend.h b/shaders/vblend.h
index b8027c1..61b0cce 100644
--- a/shaders/vblend.h
+++ b/shaders/vblend.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_vblend = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -199,18 +199,18 @@ static struct vg_shader _shader_vblend = {
 ""},
 };
 
-static GLuint _uniform_vblend_uPv;
 static GLuint _uniform_vblend_uMdl;
+static GLuint _uniform_vblend_uPv;
 static GLuint _uniform_vblend_uTexGarbage;
 static GLuint _uniform_vblend_uTexGradients;
 static GLuint _uniform_vblend_uCamera;
 static GLuint _uniform_vblend_g_world_depth;
-static void shader_vblend_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_vblend_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_vblend_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_vblend_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_vblend_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_vblend_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_vblend_uTexGarbage(int i){
    glUniform1i( _uniform_vblend_uTexGarbage, i );
 }
@@ -228,8 +228,8 @@ static void shader_vblend_register(void){
 }
 static void shader_vblend_use(void){ glUseProgram(_shader_vblend.id); }
 static void shader_vblend_link(void){
-   _uniform_vblend_uPv = glGetUniformLocation( _shader_vblend.id, "uPv" );
    _uniform_vblend_uMdl = glGetUniformLocation( _shader_vblend.id, "uMdl" );
+   _uniform_vblend_uPv = glGetUniformLocation( _shader_vblend.id, "uPv" );
    _uniform_vblend_uTexGarbage = glGetUniformLocation( _shader_vblend.id, "uTexGarbage" );
    _uniform_vblend_uTexGradients = glGetUniformLocation( _shader_vblend.id, "uTexGradients" );
    _uniform_vblend_uCamera = glGetUniformLocation( _shader_vblend.id, "uCamera" );
diff --git a/shaders/water.h b/shaders/water.h
index 0171a52..ca3ab47 100644
--- a/shaders/water.h
+++ b/shaders/water.h
@@ -18,8 +18,8 @@ static struct vg_shader _shader_water = {
 "\n"
 "#line      2        0 \n"
 "\n"
-"uniform mat4 uPv;\n"
 "uniform mat4x3 uMdl;\n"
+"uniform mat4 uPv;\n"
 "\n"
 "out vec4 aColour;\n"
 "out vec2 aUv;\n"
@@ -220,8 +220,8 @@ static struct vg_shader _shader_water = {
 ""},
 };
 
-static GLuint _uniform_water_uPv;
 static GLuint _uniform_water_uMdl;
+static GLuint _uniform_water_uPv;
 static GLuint _uniform_water_uTexMain;
 static GLuint _uniform_water_uTexDudv;
 static GLuint _uniform_water_uTexBack;
@@ -230,12 +230,12 @@ static GLuint _uniform_water_uTime;
 static GLuint _uniform_water_uCamera;
 static GLuint _uniform_water_uSurfaceY;
 static GLuint _uniform_water_g_world_depth;
-static void shader_water_uPv(m4x4f m){
-   glUniformMatrix4fv( _uniform_water_uPv, 1, GL_FALSE, (float *)m );
-}
 static void shader_water_uMdl(m4x3f m){
    glUniformMatrix4x3fv( _uniform_water_uMdl, 1, GL_FALSE, (float *)m );
 }
+static void shader_water_uPv(m4x4f m){
+   glUniformMatrix4fv( _uniform_water_uPv, 1, GL_FALSE, (float *)m );
+}
 static void shader_water_uTexMain(int i){
    glUniform1i( _uniform_water_uTexMain, i );
 }
@@ -265,8 +265,8 @@ static void shader_water_register(void){
 }
 static void shader_water_use(void){ glUseProgram(_shader_water.id); }
 static void shader_water_link(void){
-   _uniform_water_uPv = glGetUniformLocation( _shader_water.id, "uPv" );
    _uniform_water_uMdl = glGetUniformLocation( _shader_water.id, "uMdl" );
+   _uniform_water_uPv = glGetUniformLocation( _shader_water.id, "uPv" );
    _uniform_water_uTexMain = glGetUniformLocation( _shader_water.id, "uTexMain" );
    _uniform_water_uTexDudv = glGetUniformLocation( _shader_water.id, "uTexDudv" );
    _uniform_water_uTexBack = glGetUniformLocation( _shader_water.id, "uTexBack" );
diff --git a/textures_src/graffitibox.png b/textures_src/graffitibox.png
index 3f5521f..0376d45 100644
Binary files a/textures_src/graffitibox.png and b/textures_src/graffitibox.png differ