sizeof(struct logic_achievement)
},
{
- k_classtype_point_light,
+ k_classtype_world_light,
(void*)&world->lights,
sizeof(struct world_light)
+ },
+ {
+ k_classtype_nonlocal_gate,
+ (void*)&world->nonlocal_gates,
+ sizeof(struct nonlocal_gate)
}
};
world->achievement_count ++;
}
-VG_STATIC void world_pct_point_light( world_instance *world, mdl_node *pnode )
+VG_STATIC void world_pct_world_light( world_instance *world, mdl_node *pnode )
{
- struct world_light *light = &world->lights[ world->light_count ];
- v3_copy( pnode->co, light->co );
+ struct world_light *light = &world->lights[ world->light_count ++ ];
+ light->node = pnode;
+ light->inf = mdl_get_entdata( world->meta, pnode );
- struct classtype_point_light *inf = mdl_get_entdata( world->meta, pnode );
- v4_copy( inf->colour, light->colour );
+ q_m3x3( pnode->q, light->inverse_world );
+ v3_copy( pnode->co, light->inverse_world[3] );
+ m4x3_invert_affine( light->inverse_world, light->inverse_world );
+
+ light->angle_sin_cos[0] = sinf( light->inf->angle * 0.5f );
+ light->angle_sin_cos[1] = cosf( light->inf->angle * 0.5f );
+}
- world->light_count ++;
+VG_STATIC void world_pct_nonlocal_gate( world_instance *world, mdl_node *pnode )
+{
+ struct nonlocal_gate *gate = &world->nonlocal_gates[
+ world->nonlocalgate_count ++ ];
+ struct classtype_gate *inf = mdl_get_entdata( world->meta, pnode );
+
+ gate->working = 0;
+ gate->node = pnode;
+ gate->target_map_index = 0;
+ v2_copy( inf->dims, gate->gate.dims );
}
VG_STATIC void world_entities_process( world_instance *world )
{ k_classtype_trigger, world_pct_trigger },
{ k_classtype_logic_relay, world_pct_relay },
{ k_classtype_logic_achievement, world_pct_achievement },
- { k_classtype_point_light, world_pct_point_light }
+ { k_classtype_world_light, world_pct_world_light },
+ { k_classtype_nonlocal_gate, world_pct_nonlocal_gate }
};
for( int i=0; i<world->meta->info.node_count; i++ )
}
}
+VG_STATIC void world_link_nonlocal_gates( int index_a, int index_b )
+{
+ vg_info( "Linking non-local gates\n" );
+ world_instance *a = &world_global.worlds[ index_a ],
+ *b = &world_global.worlds[ index_b ];
+
+ for( int i=0; i<a->nonlocalgate_count; i++ )
+ {
+ struct nonlocal_gate *ga = &a->nonlocal_gates[i];
+ struct classtype_gate *ga_inf = mdl_get_entdata( a->meta, ga->node );
+ const char *ga_name = mdl_pstr( a->meta, ga_inf->target );
+
+ for( int j=0; j<b->nonlocalgate_count; j++ )
+ {
+ struct nonlocal_gate *gb = &b->nonlocal_gates[j];
+ struct classtype_gate *gb_inf = mdl_get_entdata( b->meta, gb->node );
+ const char *gb_name = mdl_pstr( b->meta, gb_inf->target );
+
+ if( !strcmp( ga_name, gb_name ) )
+ {
+ vg_success( "Created longjump for ID '%s'\n", ga_name );
+
+ v4f qYflip;
+ q_axis_angle( qYflip, (v3f){0.0f,1.0f,0.0f}, VG_PIf );
+
+ /* TODO: Gates are created very wonkily. refactor. */
+ ga->target_map_index = index_b;
+ gb->target_map_index = index_a;
+ ga->working = 1;
+ gb->working = 1;
+
+ v4_copy( ga->node->q, ga->gate.q[0] );
+ v4_copy( gb->node->q, ga->gate.q[1] );
+ v3_copy( ga->node->co, ga->gate.co[0] );
+ v3_copy( gb->node->co, ga->gate.co[1] );
+
+ v4_copy( gb->node->q, gb->gate.q[0] );
+ v4_copy( ga->node->q, gb->gate.q[1] );
+ v3_copy( gb->node->co, gb->gate.co[0] );
+ v3_copy( ga->node->co, gb->gate.co[1] );
+
+ /* reverse B's direction */
+ q_mul( gb->gate.q[0], qYflip, gb->gate.q[0] );
+ q_mul( gb->gate.q[1], qYflip, gb->gate.q[1] );
+ q_normalize( gb->gate.q[0] );
+ q_normalize( gb->gate.q[1] );
+
+ gate_transform_update( &ga->gate );
+ gate_transform_update( &gb->gate );
+ }
+ }
+ }
+}
+
+VG_STATIC float colour_luminance( v3f v )
+{
+ return v3_dot( v, (v3f){0.2126f, 0.7152f, 0.0722f} );
+}
+
+VG_STATIC float calc_light_influence( world_instance *world, v3f position,
+ int light )
+{
+ struct world_light *world_light = &world->lights[ light ];
+ struct classtype_world_light *inf = world_light->inf;
+
+ v3f light_delta;
+ v3_sub( world_light->node->co, position, light_delta );
+ v3_muls( light_delta, 10.0f, light_delta );
+
+ float quadratic = v3_dot( light_delta, light_delta ),
+ attenuation = 1.0f/( 1.0f + quadratic );
+
+ float quadratic_light = attenuation * colour_luminance( inf->colour );
+
+ if( (inf->type == k_light_type_point) ||
+ (inf->type == k_light_type_point_nighttime_only) )
+ {
+ return quadratic_light;
+ }
+ else if( (inf->type == k_light_type_spot) ||
+ (inf->type == k_light_type_spot_nighttime_only) )
+ {
+ v3f dir;
+ q_mulv( world_light->node->q, (v3f){0.0f,1.0f,0.0f}, dir );
+
+ float spot_theta = vg_maxf( 0.0f, v3_dot( light_delta, dir ) ),
+ falloff = spot_theta >= 0.0f? 1.0f: 0.0f;
+
+ return quadratic_light * falloff;
+ }
+ else
+ return 0.0f;
+}
+
VG_STATIC void world_scene_compute_light_clusters( world_instance *world,
scene *sc )
{
for( int i=0; i<sc->vertex_count; i++ )
{
scene_vert *vert = &sc->arrvertices[i];
- vert->lights[0] = 255;
- vert->lights[1] = 255;
- vert->lights[2] = 255;
- vert->lights[3] = 255;
+ vert->lights[0] = 0;
+ vert->lights[1] = 1;
+ vert->lights[2] = 2;
+ vert->lights[3] = 0;
- float distances[4] = { INFINITY, INFINITY, INFINITY, INFINITY };
+ float influences[3] = { 0.0f, 0.0f, 0.0f };
+ const int N = vg_list_size( influences );
for( int j=0; j<world->light_count; j ++ )
{
- float dist = v3_dist2( world->lights[j].co, vert->co );
+ float influence = calc_light_influence( world, vert->co, j );
- int best_pos = 4;
+ int best_pos = N;
for( int k=best_pos-1; k>=0; k -- )
- if( dist < distances[k] )
+ if( influence > influences[k] )
best_pos = k;
- if( best_pos < 4 )
+ if( best_pos < N )
{
- for( int k=3; k>best_pos; k -- )
+ for( int k=N-1; k>best_pos; k -- )
{
- distances[k] = distances[k-1];
+ influences[k] = influences[k-1];
vert->lights[k] = vert->lights[k-1];
}
- distances[best_pos] = dist;
+ influences[best_pos] = influence;
vert->lights[best_pos] = j;
}
}
+
+ for( int j=0; j<N; j++ )
+ {
+ if( influences[j] > 0.00000125f )
+ vert->lights[3] ++ ;
+ }
}
}
world->scene_no_collide = NULL;
}
+float fsd_cone_infinite( v3f p, v2f c )
+{
+ v2f q = { v2_length( (v2f){ p[0], p[2] } ), -p[1] };
+ float s = vg_maxf( 0.0f, v2_dot( q, c ) );
+
+ v2f v0;
+ v2_muls( c, s, v0 );
+ v2_sub( q, v0, v0 );
+
+ float d = v2_length( v0 );
+ return d * ((q[0]*c[1]-q[1]*c[0]<0.0f)?-1.0f:1.0f);
+}
+
VG_STATIC int reset_player( int argc, char const *argv[] );
VG_STATIC void world_post_process( world_instance *world )
{
vg_acquire_thread_sync();
{
+ /* create scene lighting buffer */
+
+ u32 size = VG_MAX(world->light_count,1) * sizeof(float)*12;
+
+ vg_info( "Upload %ubytes (lighting)\n", size );
+
+ glGenBuffers( 1, &world->tbo_light_entities );
+ glBindBuffer( GL_TEXTURE_BUFFER, world->tbo_light_entities );
+ glBufferData( GL_TEXTURE_BUFFER, size, NULL, GL_DYNAMIC_DRAW );
+
+ /* buffer layout
+ *
+ * colour position direction (spots)
+ * | . . . . | . . . . | . . . . |
+ * | Re Ge Be Night | Xco Yco Zco Range | Dx Dy Dz Da |
+ *
+ */
+
+ v4f *light_dst = glMapBuffer( GL_TEXTURE_BUFFER, GL_WRITE_ONLY );
+
+ for( int i=0; i<world->light_count; i++ )
+ {
+ struct world_light *light = &world->lights[i];
+ struct classtype_world_light *inf = light->inf;
+
+ /* colour + night */
+ v3_muls( inf->colour, inf->colour[3] * 2.0f, light_dst[i*3+0] );
+ light_dst[i*3+0][3] = -1.0f;
+
+ if( (inf->type == k_light_type_spot_nighttime_only) ||
+ (inf->type == k_light_type_point_nighttime_only ) )
+ {
+ u32 hash = (i * 29986577) & 0xff;
+ float switch_on = hash;
+ switch_on *= (1.0f/255.0f);
+
+ light_dst[i*3+0][3] = 0.44f + switch_on * 0.015f;
+ }
+
+ /* position + 1/range^2 */
+ v3_copy( light->node->co, light_dst[i*3+1] );
+ light_dst[i*3+1][3] = 1.0f/(inf->range*inf->range);
+
+ /* direction + angle */
+ q_mulv( light->node->q, (v3f){0.0f,-1.0f,0.0f}, light_dst[i*3+2]);
+ light_dst[i*3+2][3] = cosf( inf->angle );
+ }
+
+ glUnmapBuffer( GL_TEXTURE_BUFFER );
+
+ glGenTextures( 1, &world->tex_light_entities );
+ glBindTexture( GL_TEXTURE_BUFFER, world->tex_light_entities );
+ glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, world->tbo_light_entities );
+
+
+ /* Upload lighting uniform buffer */
+ if( world->water.enabled )
+ v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
+
+ v4f info_vec;
+ v3f *bounds = world->scene_geo->bbx;
+
+ info_vec[0] = bounds[0][0];
+ info_vec[1] = bounds[0][2];
+ info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
+ info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
+ v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
+
+
/*
* Rendering the depth map
*/
glBlendFunc(GL_ONE, GL_ONE);
glBlendEquation(GL_MAX);
- render_world_depth( world, &ortho );
+ render_world_position( world, &ortho );
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
- /* Upload lighting uniform buffer */
- if( world->water.enabled )
- v4_copy( world->water.plane, world->ub_lighting.g_water_plane );
- v4f info_vec;
- v3f *bounds = world->scene_geo->bbx;
- info_vec[0] = bounds[0][0];
- info_vec[1] = bounds[0][2];
- info_vec[2] = 1.0f/ (bounds[1][0]-bounds[0][0]);
- info_vec[3] = 1.0f/ (bounds[1][2]-bounds[0][2]);
- v4_copy( info_vec, world->ub_lighting.g_depth_bounds );
- /* add scene lights */
- for( int i=0; i<world->light_count; i++ )
+ /* light cubes */
+
+ v3f cubes_min, cubes_max;
+ v3_muls( world->scene_geo->bbx[0], 1.0f/k_light_cube_size, cubes_min );
+ v3_muls( world->scene_geo->bbx[1], 1.0f/k_light_cube_size, cubes_max );
+
+ v3_sub( cubes_min, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_min );
+ v3_add( cubes_max, (v3f){ 0.5f, 0.5f, 0.5f }, cubes_max );
+
+ v3_floor( cubes_min, cubes_min );
+ v3_floor( cubes_max, cubes_max );
+
+ v3i icubes_min, icubes_max;
+
+ for( int i=0; i<3; i++ )
{
- struct world_light *light = &world->lights[i];
+ icubes_min[i] = cubes_min[i];
+ icubes_max[i] = cubes_max[i];
+ }
+
+ v3i icubes_count;
+ v3i_sub( icubes_max, icubes_min, icubes_count );
+
+ for( int i=0; i<3; i++ )
+ {
+ icubes_count[i] = VG_MIN( 128, icubes_count[i]+1 );
+ cubes_max[i] = icubes_min[i] + icubes_count[i];
+ }
+
+ v3_muls( cubes_min, k_light_cube_size, cubes_min );
+ v3_muls( cubes_max, k_light_cube_size, cubes_max );
+
+ for( int i=0; i<3; i++ )
+ {
+ float range = cubes_max[i]-cubes_min[i];
+ world->ub_lighting.g_cube_inv_range[i] = 1.0f / range;
+ world->ub_lighting.g_cube_inv_range[i] *= (float)icubes_count[i];
+
+ vg_info( "cubes[%d]: %d\n", i, icubes_count[i] );
+ }
+
+ int total_cubes = icubes_count[0]*icubes_count[1]*icubes_count[2];
+
+ u32 *cubes_index = vg_linear_alloc( world_global.generic_heap,
+ total_cubes * sizeof(u32) * 2.0f );
+
+ vg_info( "Computing light cubes (%d) [%f %f %f] -> [%f %f %f]\n",
+ total_cubes, cubes_min[0], -cubes_min[2], cubes_min[1],
+ cubes_max[0], -cubes_max[2], cubes_max[1] );
+
+ v3_copy( cubes_min, world->ub_lighting.g_cube_min );
- v3_muls( light->colour, light->colour[3] * 2.0f,
- world->ub_lighting.g_point_light_colours[i] );
- v3_copy( light->co,
- world->ub_lighting.g_point_light_positions[i] );
+ vg_info( "g_cube_min[%f %f %f]\n",
+ world->ub_lighting.g_cube_min[0],
+ world->ub_lighting.g_cube_min[1],
+ world->ub_lighting.g_cube_min[2] );
+ vg_info( "g_cube_inv_range[%f %f %f]\n",
+ world->ub_lighting.g_cube_inv_range[0],
+ world->ub_lighting.g_cube_inv_range[1],
+ world->ub_lighting.g_cube_inv_range[2] );
+
+ v3f cube_size;
+ v3_div( (v3f){1.0f,1.0f,1.0f}, world->ub_lighting.g_cube_inv_range,
+ cube_size );
+ float bound_radius = v3_length( cube_size );
+
+ for( int iz = 0; iz<icubes_count[2]; iz ++ )
+ {
+ for( int iy = 0; iy<icubes_count[1]; iy++ )
+ {
+ for( int ix = 0; ix<icubes_count[0]; ix++ )
+ {
+ boxf bbx;
+ v3_div( (v3f){ ix, iy, iz }, world->ub_lighting.g_cube_inv_range,
+ bbx[0] );
+ v3_div( (v3f){ ix+1, iy+1, iz+1 },
+ world->ub_lighting.g_cube_inv_range,
+ bbx[1] );
+
+ v3_add( bbx[0], world->ub_lighting.g_cube_min, bbx[0] );
+ v3_add( bbx[1], world->ub_lighting.g_cube_min, bbx[1] );
+
+ v3f center;
+ v3_add( bbx[0], bbx[1], center );
+ v3_muls( center, 0.5f, center );
+
+ u32 indices[6] = { 0, 0, 0, 0, 0, 0 };
+ u32 count = 0;
+
+ float influences[6] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+ const int N = vg_list_size( influences );
+
+ for( int j=0; j<world->light_count; j ++ )
+ {
+ struct world_light *light = &world->lights[j];
+ v3f closest;
+ closest_point_aabb( light->node->co, bbx, closest );
+
+ float dist = v3_dist( closest, light->node->co ),
+ influence = 1.0f/(dist+1.0f);
+
+ if( dist > light->inf->range )
+ continue;
+
+ if( (light->inf->type == k_light_type_spot) ||
+ (light->inf->type == k_light_type_spot_nighttime_only) )
+ {
+ v3f local;
+ m4x3_mulv( light->inverse_world, center, local );
+
+ float r = fsd_cone_infinite( local, light->angle_sin_cos );
+
+ if( r > bound_radius )
+ continue;
+ }
+
+ int best_pos = N;
+ for( int k=best_pos-1; k>=0; k -- )
+ if( influence > influences[k] )
+ best_pos = k;
+
+ if( best_pos < N )
+ {
+ for( int k=N-1; k>best_pos; k -- )
+ {
+ influences[k] = influences[k-1];
+ indices[k] = indices[k-1];
+ }
+
+ influences[best_pos] = influence;
+ indices[best_pos] = j;
+ }
+ }
+
+ for( int j=0; j<N; j++ )
+ if( influences[j] > 0.0f )
+ count ++;
+
+ int base_index = iz * (icubes_count[0]*icubes_count[1]) +
+ iy * (icubes_count[0]) +
+ ix;
+
+ int lower_count = VG_MIN( 3, count );
+ u32 packed_index_lower = lower_count;
+ packed_index_lower |= indices[0]<<2;
+ packed_index_lower |= indices[1]<<12;
+ packed_index_lower |= indices[2]<<22;
+
+ int upper_count = VG_MAX( 0, count - lower_count );
+ u32 packed_index_upper = upper_count;
+ packed_index_upper |= indices[3]<<2;
+ packed_index_upper |= indices[4]<<12;
+ packed_index_upper |= indices[5]<<22;
+
+ cubes_index[ base_index * 2 + 0 ] = packed_index_lower;
+ cubes_index[ base_index * 2 + 1 ] = packed_index_upper;
+ }
+ }
}
+ glGenTextures( 1, &world->tex_light_cubes ); /* FIXME: glDeleteTextures */
+ glBindTexture( GL_TEXTURE_3D, world->tex_light_cubes );
+ glTexImage3D( GL_TEXTURE_3D, 0, GL_RG32UI,
+ icubes_count[0], icubes_count[1], icubes_count[2],
+ 0, GL_RG_INTEGER, GL_UNSIGNED_INT, cubes_index );
+ glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+ glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+
+ vg_linear_del( world_global.generic_heap, cubes_index );
+
+
+
+
+
/* upload full buffer */
glBindBuffer( GL_UNIFORM_BUFFER, world->ubo_lighting );
glBufferSubData( GL_UNIFORM_BUFFER, 0,
mesh_free( &world->mesh_geo );
mesh_free( &world->mesh_no_collide );
+ glDeleteBuffers( 1, &world->tbo_light_entities );
+ glDeleteTextures( 1, &world->tex_light_entities );
+
/* FIXME: CANT DO THIS HERE */
world_global.time = 0.0;
world_global.rewind_from = 0.0;
world->collectors = NULL;
world->collector_count = 0;
+ world->nonlocal_gates = NULL;
+ world->nonlocalgate_count = 0;
+
world->water.enabled = 0;
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff