target_event_leave: bpy.props.IntProperty( name="Leave Ev", default=-1 )
auto_run: bpy.props.BoolProperty( name="Auto Run" )
+ water_volume: bpy.props.BoolProperty( name="Water Volume" )
text: bpy.props.StringProperty()
@staticmethod
SR_OBJECT_ENT_VOLUME.inspect_target( layout, data, 'target', ['_event','_event_leave'] )
if data[0].subtype == '2':
layout.prop( data[0], 'text' )
+ layout.prop( data[0], 'water_volume' )
#}
#}
if obj_data.subtype == '1':
volume.flags |= 0x1
+ if obj_data.water_volume:
+ volume.flags |= 0x10
+
#if obj_data.auto_run:
# volume.flags |= 0x4
compile_obj_transform( obj, volume.transform )
#include "ent_relay.h"
#include "ent_challenge.h"
#include "ent_route.h"
-#include "ent_miniworld.h"
#include "ent_region.h"
#include "ent_glider.h"
#include "ent_prop.h"
[k_ent_relay] = ent_relay_call,
[k_ent_challenge] = ent_challenge_call,
[k_ent_route] = ent_route_call,
- [k_ent_miniworld] = ent_miniworld_call,
[k_ent_region] = ent_region_call,
[k_ent_glider] = ent_glider_call,
[k_ent_water] = ent_water_call,
enum ent_volume_flag {
k_ent_volume_flag_particles = 0x1,
k_ent_volume_flag_disabled = 0x2,
- k_ent_volume_flag_interact = 0x8
+ k_ent_volume_flag_removed0 = 0x4,
+ k_ent_volume_flag_interact = 0x8,
+ k_ent_volume_flag_water = 0x10
};
struct ent_volume
#include "entity.h"
#include "input.h"
#include "world_map.h"
-#include "ent_miniworld.h"
#include "audio.h"
#include "workshop.h"
#include "gui.h"
"Here you can visit different locations and keep\n"
"track of your progress.\n"
"\n"
- "Walk through the rifts to visit the worlds. Our\n"
+ "Visit the sandcastles to enter the worlds. Our\n"
"story begins at the training volcano where you\n"
"will learn to skate again!\n"
"\n"
#include "network.h"
#include "network_common.h"
#include "world_routes.h"
-#include "ent_miniworld.h"
#include "gui.h"
#include "shaders/model_entity.h"
(const char *[]){ [k_skaterift_menu] = "menu",
[k_skaterift_replay] = "replay",
[k_skaterift_default] = "default",
+ [k_skaterift_activity_max] = NULL
} [skaterift.activity] );
player__debugtext( ctx, 1, "world event: %s",
(const char *[]){ [k_world_event_none] = "no event",
[k_world_event_challenge] = "challenge",
+ [k_world_event_shop] = "shop",
+ [k_world_event_route_leaderboard] = "route leaderboard",
+ [k_world_event_interact] = "interact",
+ [k_world_event_board_maker] = "board maker",
+ [k_world_event_max] = NULL
} [_world.event] );
player__debugtext( ctx, 1, "time_rate: %.4f", skaterift.time_rate );
#include "addon.h"
#include "font.h"
#include "gui.h"
-#include "ent_miniworld.h"
#include "ent_region.h"
#include "shaders/model_entity.h"
#include "vg/vg_steam_friends.h"
#include "trail.h"
#include "freecam.h"
#include "ent_tornado.h"
-#include "ent_miniworld.h"
#include "ent_skateshop.h"
#include "ent_camera.h"
#include "world_map.h"
glEnable( GL_DEPTH_TEST );
world_prerender( &_world.main );
-#if 0
- if( menu_viewing_preview() )
- {
- glClearColor( 0.1f, 0.1f, 0.2f, 0.0f );
- glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
-
- if( _world.preview_instance.complete )
- render_world_preview();
-
- return;
- }
-#endif
-
- render_world( &_world.main, &g_render.cam, render_stenciled, 0, 1, 1 );
+ render_world( &_world.main, &g_render.cam, render_stenciled, 0, 1, 1, _vg_render.fb_main );
particle_system_update( &particles_grind, vg.time_delta );
//particle_system_debug( &particles_grind );
/* continue with variable rate */
vg_framebuffer_bind( _vg_render.fb_main, _vg_render.scale );
- render_world_gates( &_world.main, &g_render.cam );
+ render_world_gates( &_world.main, &g_render.cam, _vg_render.fb_main );
}
/* composite */
#include "ent_challenge.c"
#include "ent_glider.c"
#include "entity.c"
-#include "ent_miniworld.c"
#include "ent_objective.c"
#include "ent_region.c"
#include "ent_relay.c"
k_skaterift_default = 0x00, /* regular playing */
k_skaterift_replay = 0x01,
k_skaterift_menu = 0x04,
+ k_skaterift_activity_max = 0x8
}
activity;
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
- render_world( &_world.main, &g_render.cam, 0, 0, 1, 1 );
+ render_world( &_world.main, &g_render.cam, 0, 0, 1, 1, g_render.fb_workshop_preview );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glViewport( 0,0, vg.window_x, vg.window_y );
m4x3_mulv( mmdl1, vp0, ubo->g_board_0 );
m4x3_mulv( mmdl1, vp1, ubo->g_board_1 );
glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
- glBufferSubData( GL_UNIFORM_BUFFER, 0,
- sizeof(struct ub_world_lighting), &world->ub_lighting );
+ glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(struct ub_world_lighting), &world->ub_lighting );
- render_world( world, &cam, 0, 0, 0, 0 );
+ render_world( world, &cam, 0, 0, 0, 0, g_render.fb_workshop_preview );
struct player_board_pose pose = {0};
render_board( &cam, world, board, mmdl, &pose, k_board_shader_entity );
render_board( &cam, world, board, mmdl1, &pose, k_board_shader_entity );
k_world_event_shop,
k_world_event_route_leaderboard,
k_world_event_interact,
- k_world_event_board_maker
+ k_world_event_board_maker,
+ k_world_event_max
}
event;
/*
* Render the view through a gate
*/
-int render_gate( world_instance *world, world_instance *world_inside,
- ent_gate *gate, vg_camera *cam )
+int render_gate( world_instance *world, world_instance *world_inside, ent_gate *gate, vg_camera *cam,
+ vg_framebuffer *target_fb )
{
v3f viewdir, gatedir;
m3x3_mulv( cam->transform, (v3f){0.0f,0.0f,-1.0f}, viewdir );
render_gate_mesh( world, gate );
if( world_inside )
- {
- render_world( world_inside, &world_gates.cam,
- 1, !localplayer.gate_waiting, 1, 1 );
- }
+ render_world( world_inside, &world_gates.cam, 1, !localplayer.gate_waiting, 1, 1, target_fb );
return 1;
}
void world_gates_init(void);
void gate_transform_update( ent_gate *gate );
int render_gate( world_instance *world, world_instance *world_inside,
- ent_gate *gate, vg_camera *cam );
+ ent_gate *gate, vg_camera *cam, vg_framebuffer *target_fb );
int gate_intersect( ent_gate *gate, v3f pos, v3f last );
u32 world_intersect_gates( world_instance *world, v3f pos, v3f last );
#include "font.h"
#include "gui.h"
#include "world_map.h"
-#include "ent_miniworld.h"
#include "player_remote.h"
#include "ent_skateshop.h"
#include "shaders/model_entity.h"
glDepthMask( GL_TRUE );
}
-void render_world_gates( world_instance *world, vg_camera *cam )
+void render_world_gates( world_instance *world, vg_camera *cam, vg_framebuffer *target_fb )
{
float closest = INFINITY;
struct ent_gate *gate = NULL;
if( gate->flags & k_ent_gate_linked )
{
- render_gate( world, NULL, gate, cam );
+ render_gate( world, NULL, gate, cam, target_fb );
m4x3f mmdl;
m4x4f pvm;
}
}
else
- render_gate( world, world, gate, cam );
+ render_gate( world, world, gate, cam, target_fb );
}
}
void render_world( world_instance *world, vg_camera *cam,
int stenciled, int viewing_from_gate,
- int with_water, int with_cubemaps )
+ int with_water, int with_cubemaps, vg_framebuffer *target_fb )
{
if( stenciled )
{
u32 closest = 0;
float min_dist = INFINITY;
- if( af_arrcount( &world->ent_route ) ){
- for( u32 i=0; i<af_arrcount( &world->ent_route ); i++ ){
+ if( af_arrcount( &world->ent_route ) )
+ {
+ for( u32 i=0; i<af_arrcount( &world->ent_route ); i++ )
+ {
ent_route *route = af_arritm( &world->ent_route, i );
float dist = v3_dist2( route->board_transform[3], cam->pos );
-
- if( dist < min_dist ){
+ if( dist < min_dist )
+ {
min_dist = dist;
closest = i;
}
if( with_water )
{
render_water_texture( world, cam );
- vg_framebuffer_bind( _vg_render.fb_main, _vg_render.scale );
+ vg_framebuffer_bind( target_fb, _vg_render.scale );
}
if( stenciled )
render_remote_players( world, cam );
render_other_entities( world, cam );
- ent_miniworld_render( world, cam );
_board_maker_render( world, cam );
if( stenciled )
glEnable( GL_CULL_FACE );
}
-static void render_cubemap_side( world_instance *world, v3f co, m3x3f rotation, u32 side )
+static void render_cubemap_side( world_instance *world, v3f co, m3x3f rotation, u32 side, vg_framebuffer *target_fb )
{
vg_camera cam;
v3f forward[6] = {
vg_camera_finalize( &cam );
vg_camera_finalize( &cam );
- /* TODO: CANT RENDER CUBEMAPS BECAUSE RENDER_WORLD FUCKS WITH GLVIEWPORT AND STUFF */
- render_world( world, &cam, 0, 1, 0, 0 );
+ render_world( world, &cam, 0, 1, 1, 0, target_fb );
}
void render_world_cubemaps( world_instance *world )
world->cubemap_side = 0;
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_CUBE_MAP_POSITIVE_X + world->cubemap_side,
- cm->texture_id, 0 );
+ GL_TEXTURE_CUBE_MAP_POSITIVE_X + world->cubemap_side,
+ cm->texture_id, 0 );
glClear( GL_DEPTH_BUFFER_BIT );
- render_cubemap_side( world, cm->co, identity, world->cubemap_side );
+ vg_framebuffer temp_vg_framebuffer =
+ {
+ .display_name = NULL,
+ .resolution_div = 0,
+ .fixed_w = WORLD_CUBEMAP_RES,
+ .fixed_h = WORLD_CUBEMAP_RES,
+ .id = cm->framebuffer_id,
+ .attachment_count = 0,
+ .attachments = NULL
+ };
+ render_cubemap_side( world, cm->co, identity, world->cubemap_side, &temp_vg_framebuffer );
}
}
}
}
glViewport( 0, 0, 512, 512 );
+ vg_framebuffer temp_vg_framebuffer =
+ {
+ .display_name = NULL,
+ .resolution_div = 0,
+ .fixed_w = 512,
+ .fixed_h = 512,
+ .id = temp_fb,
+ .attachment_count = 0,
+ .attachments = NULL
+ };
world_instance *world = &_world.main;
for( u32 i=0; i<6; i ++ )
{
glClear( GL_DEPTH_BUFFER_BIT );
- render_cubemap_side( &_world.main, co, gate->to_world, i );
+ render_cubemap_side( &_world.main, co, gate->to_world, i, &temp_vg_framebuffer );
u8 *dest_side = src_image + i*512*512*3;
glReadBuffer( GL_COLOR_ATTACHMENT0 );
void render_world_depth( world_instance *world, vg_camera *cam );
void render_world( world_instance *world, vg_camera *cam,
int stenciled, int viewing_from_gate,
- int with_water, int with_cubemaps );
+ int with_water, int with_cubemaps, vg_framebuffer *target_fb );
void render_world_cubemaps( world_instance *world );
void bind_terrain_noise(void);
void render_world_override( world_instance *world,
vg_camera *cam,
ent_spawn *dest_spawn, v4f map_info );
void render_world_preview( vg_camera *cam );
-void render_world_gates( world_instance *world, vg_camera *cam );
+void render_world_gates( world_instance *world, vg_camera *cam, vg_framebuffer *target_fb );
void imgui_world_light_edit( ui_context *ctx, world_instance *world );
#define WORLD_BIND_LIGHT_BUFFERS_UB0_TEX234( WORLD, SHADER ) \
i32 idx = _world.active_trigger_volumes[i];
ent_volume *volume = af_arritm( &world->ent_volume, idx );
+ bool in_volume = 1;
+
v3f local;
m4x3_mulv( volume->to_local, pos, local );
- if( (fabsf(local[0]) <= 1.0f) &&
- (fabsf(local[1]) <= 1.0f) &&
- (fabsf(local[2]) <= 1.0f) &&
- (localplayer.subsystem != k_player_subsystem_dead) )
+ if( (fabsf(local[0]) > 1.0f) || (fabsf(local[1]) > 1.0f) || (fabsf(local[2]) > 1.0f) )
+ in_volume = 0;
+
+ if( (localplayer.subsystem == k_player_subsystem_dead) && !(volume->flags & k_ent_volume_flag_water) )
+ in_volume = 0;
+
+ if( in_volume )
{
_world.active_trigger_volumes[ j ++ ] = idx;
boxf cube = {{-1.0f,-1.0f,-1.0f},{1.0f,1.0f,1.0f}};
if( _world.active_trigger_volume_count > VG_ARRAY_LEN(_world.active_trigger_volumes) )
continue;
- if( localplayer.subsystem == k_player_subsystem_dead )
+ if( (localplayer.subsystem == k_player_subsystem_dead) && !(volume->flags & k_ent_volume_flag_water) )
continue;
v3f local;
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
glCullFace( GL_FRONT );
- render_world( world, &water_cam, 0, 1, 0, 1 );
+ render_world( world, &water_cam, 0, 1, 0, 1, _vg_render.fb_water_reflection );
glCullFace( GL_BACK );
/*
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
render_world_depth( world, &beneath_cam );
- //glViewport( 0,0, g_render_x, g_render_y );
}
void render_water_surface( world_instance *world, vg_camera *cam )