#include "world.h"
#include "player.h"
#include "network.h"
+#include "menu.h"
static int cl_ui = 1,
cl_menu = 0;
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 );
static void vg_start(void)
{
- player_load_model( "ch_outlaw" );
+ player_load_model( "ch_jordan" );
reset_player( 1, (const char *[]){ "start" } );
}
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();
}
static void vg_update_post( int loaded )
{
- if( loaded )
+ if( loaded && !cl_menu )
{
player_update_post();
}
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 );
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 );
(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
void vg_ui(void)
{
+#if 0
if( cl_menu )
{
ui_rect menu =
}
}
-#if 0
if( lightedit )
{
ui_global_ctx.cursor[0] = 10;
--- /dev/null
+#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 */
player_camera_update();
}
-static void draw_player(void) /* 3 */
+static void draw_player( m4x3f cam )
{
if( player.is_dead )
player_model_copy_ragdoll();
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,
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
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 */
{
#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 );
shader_blit_register();
shader_standard_register();
shader_vblend_register();
- shader_unlit_register();
vg_acquire_thread_sync();
{
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
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
"\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"
""},
};
-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 );
}
}
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" );
"\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"
""},
};
-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 );
}
}
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" );
}
--- /dev/null
+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;
+}
--- /dev/null
+#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 */
"\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"
""},
};
-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 );
}
}
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" );
}
"\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"
""},
};
-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 );
}
}
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" );
"\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"
""},
};
-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 );
}
}
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" );
"\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"
""},
};
-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 );
}
}
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" );
}
#include "vertex_standard.glsl"
-uniform mat4 uPv;
uniform mat4x3 uMdl;
+uniform mat4 uPv;
out vec4 aColour;
out vec2 aUv;
"\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"
""},
};
-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 );
}
}
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" );
void main()
{
vec3 diffuse = texture( uTexMain, aUv ).rgb;
- FragColor = vec4(pow(diffuse,vec3(1.0)),1.0);
+ FragColor = vec4( diffuse, 1.0 );
}
"\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"
""},
};
-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 );
}
}
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" );
"\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"
""},
};
-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;
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 );
}
}
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" );
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff
