remove assertion
[carveJwlIkooP6JGAAIwe30JlM.git] / world_entity.c
1 #ifndef WORLD_ENTITY_C
2 #define WORLD_ENTITY_C
3
4 #include "model.h"
5 #include "entity.h"
6 #include "world.h"
7 #include "world_load.h"
8 #include "save.h"
9 #include "vg/vg_msg.h"
10 #include "menu.h"
11 #include "ent_challenge.h"
12 #include "ent_skateshop.h"
13 #include "ent_route.h"
14
15 static void world_entity_focus( u32 entity_id ){
16 localplayer.immobile = 1;
17 menu.disable_open = 1;
18
19 v3_zero( localplayer.rb.v );
20 v3_zero( localplayer.rb.w );
21 player_walk.move_speed = 0.0f;
22 world_static.focused_entity = entity_id;
23 skaterift.activity = k_skaterift_ent_focus;
24 }
25
26 static void world_entity_unfocus(void){
27 localplayer.immobile = 0;
28 skaterift.activity = k_skaterift_default;
29 menu.disable_open = 0;
30 srinput.state = k_input_state_resume;
31 }
32
33 static void world_entity_focus_camera( world_instance *world, u32 uid ){
34 if( mdl_entity_id_type( uid ) == k_ent_camera ){
35 u32 index = mdl_entity_id_id( uid );
36 ent_camera *cam = mdl_arritm( &world->ent_camera, index );
37
38 v3f dir = {0.0f,-1.0f,0.0f};
39 mdl_transform_vector( &cam->transform, dir, dir );
40 v3_angles( dir, world_static.focus_cam.angles );
41 v3_copy( cam->transform.co, world_static.focus_cam.pos );
42 world_static.focus_cam.fov = cam->fov;
43 }
44 else {
45 camera_copy( &localplayer.cam, &world_static.focus_cam );
46
47 /* TODO ? */
48 world_static.focus_cam.nearz = localplayer.cam.nearz;
49 world_static.focus_cam.farz = localplayer.cam.farz;
50 }
51 }
52
53 /* logic preupdate */
54 static void world_entity_focus_preupdate(void){
55 f32 rate = vg_minf( 1.0f, vg.time_frame_delta * 2.0f );
56 int active = 0;
57 if( skaterift.activity == k_skaterift_ent_focus )
58 active = 1;
59
60 vg_slewf( &world_static.focus_strength, active,
61 vg.time_frame_delta * (1.0f/0.5f) );
62
63 u32 type = mdl_entity_id_type( world_static.focused_entity ),
64 index = mdl_entity_id_id( world_static.focused_entity );
65 world_instance *world = world_current_instance();
66
67 /* TODO: Table. */
68 if( type == k_ent_skateshop ){
69 ent_skateshop *skateshop = mdl_arritm( &world->ent_skateshop, index );
70 ent_skateshop_preupdate( skateshop, active );
71 }
72 else if( type == k_ent_challenge ){
73 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
74 ent_challenge_preupdate( challenge, active );
75 }
76 else if( type == k_ent_route ){
77 ent_route *route = mdl_arritm( &world->ent_route, index );
78 ent_route_preupdate( route, active );
79 }
80 }
81
82 /* additional renderings like text etc.. */
83 static void world_entity_focus_render(void){
84 if( skaterift.activity != k_skaterift_ent_focus )
85 return;
86
87 u32 type = mdl_entity_id_type( world_static.focused_entity ),
88 index = mdl_entity_id_id( world_static.focused_entity );
89 world_instance *world = world_current_instance();
90
91 if( type == k_ent_skateshop ){
92 ent_skateshop *skateshop = mdl_arritm( &world->ent_skateshop, index );
93 skateshop_render( skateshop );
94 }
95 else if( type == k_ent_challenge ){}
96 else if( type == k_ent_route ){}
97 else if( type == k_ent_miniworld ){}
98 else {
99 vg_fatal_error( "Programming error\n" );
100 }
101 }
102
103 static void world_gen_entities_init( world_instance *world ){
104 /* lights */
105 for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
106 ent_light *light = mdl_arritm( &world->ent_light, j );
107
108 m4x3f to_world;
109 q_m3x3( light->transform.q, to_world );
110 v3_copy( light->transform.co, to_world[3] );
111 m4x3_invert_affine( to_world, light->inverse_world );
112
113 light->angle_sin_cos[0] = sinf( light->angle * 0.5f );
114 light->angle_sin_cos[1] = cosf( light->angle * 0.5f );
115 }
116
117 /* gates */
118 for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
119 ent_gate *gate = mdl_arritm( &world->ent_gate, j );
120
121 if( !(gate->flags & k_ent_gate_nonlocal) ) {
122 gate_transform_update( gate );
123 }
124 }
125
126 vg_async_call( world_link_nonlocal_async, world, 0 );
127
128 /* water */
129 for( u32 j=0; j<mdl_arrcount(&world->ent_water); j++ ){
130 ent_water *water = mdl_arritm( &world->ent_water, j );
131 if( world->water.enabled ){
132 vg_warn( "Multiple water surfaces in level!\n" );
133 break;
134 }
135
136 world->water.enabled = 1;
137 water_set_surface( world, water->transform.co[1] );
138 }
139
140 /* volumes */
141 for( u32 j=0; j<mdl_arrcount(&world->ent_volume); j++ ){
142 ent_volume *volume = mdl_arritm( &world->ent_volume, j );
143 mdl_transform_m4x3( &volume->transform, volume->to_world );
144 m4x3_invert_full( volume->to_world, volume->to_local );
145 }
146
147 /* audio packs */
148 for( u32 j=0; j<mdl_arrcount(&world->ent_audio); j++ ){
149 ent_audio *audio = mdl_arritm( &world->ent_audio, j );
150
151 for( u32 k=0; k<audio->clip_count; k++ ){
152 ent_audio_clip *clip = mdl_arritm( &world->ent_audio_clip,
153 audio->clip_start+k );
154
155 if( clip->_.file.pack_size ){
156 u32 size = clip->_.file.pack_size,
157 offset = clip->_.file.pack_offset;
158
159 /* embedded files are fine to clear the scratch buffer, only
160 * external audio uses it */
161
162 vg_linear_clear( vg_mem.scratch );
163 void *data = vg_linear_alloc( vg_mem.scratch,
164 clip->_.file.pack_size );
165
166 mdl_fread_pack_file( &world->meta, &clip->_.file, data );
167
168 clip->_.clip.path = NULL;
169 clip->_.clip.flags = audio->flags;
170 clip->_.clip.data = data;
171 clip->_.clip.size = size;
172 }
173 else{
174 clip->_.clip.path = mdl_pstr(&world->meta,clip->_.file.pstr_path);
175 clip->_.clip.flags = audio->flags;
176 clip->_.clip.data = NULL;
177 clip->_.clip.size = 0;
178 }
179
180 audio_clip_load( &clip->_.clip, world->heap );
181 }
182 }
183
184 /* create generic entity hierachy for those who need it */
185 u32 indexed_count = 0;
186 struct {
187 u32 type;
188 mdl_array_ptr *array;
189 }
190 indexables[] = {
191 { k_ent_gate, &world->ent_gate },
192 { k_ent_objective, &world->ent_objective },
193 { k_ent_volume, &world->ent_volume },
194 { k_ent_challenge, &world->ent_challenge }
195 };
196
197 for( u32 i=0; i<vg_list_size(indexables); i++ )
198 indexed_count += mdl_arrcount( indexables[i].array );
199 vg_info( "indexing %u entities\n", indexed_count );
200
201 world->entity_list = vg_linear_alloc( world->heap,
202 vg_align8(indexed_count*sizeof(u32)));
203
204 u32 index=0;
205 for( u32 i=0; i<vg_list_size(indexables); i++ ){
206 u32 type = indexables[i].type,
207 count = mdl_arrcount( indexables[i].array );
208
209 for( u32 j=0; j<count; j ++ )
210 world->entity_list[index ++] = mdl_entity_id( type, j );
211 }
212
213 world->entity_bh = bh_create( world->heap, &bh_system_entity_list, world,
214 indexed_count, 2 );
215 }
216
217 static
218 ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
219 {
220 ent_spawn *rp = NULL, *r;
221 float min_dist = INFINITY;
222
223 for( u32 i=0; i<mdl_arrcount(&world->ent_spawn); i++ ){
224 r = mdl_arritm( &world->ent_spawn, i );
225 float d = v3_dist2( r->transform.co, position );
226
227 if( d < min_dist ){
228 min_dist = d;
229 rp = r;
230 }
231 }
232
233 if( !rp ){
234 if( mdl_arrcount(&world->ent_spawn) ){
235 vg_warn( "Invalid distances to spawns.. defaulting to first one.\n" );
236 return mdl_arritm( &world->ent_spawn, 0 );
237 }
238 else{
239 vg_error( "There are no spawns in the level!\n" );
240 }
241 }
242
243 return rp;
244 }
245
246 static
247 ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name )
248 {
249 ent_spawn *rp = NULL, *r;
250 for( u32 i=0; i<mdl_arrcount(&world->ent_spawn); i++ ){
251 r = mdl_arritm( &world->ent_spawn, i );
252 if( !strcmp( mdl_pstr(&world->meta, r->pstr_name), name ) ){
253 rp = r;
254 break;
255 }
256 }
257
258 if( !rp )
259 vg_warn( "No spawn named '%s'\n", name );
260
261 return rp;
262 }
263
264 static void ent_volume_call( world_instance *world, ent_call *call )
265 {
266 u32 index = mdl_entity_id_id( call->id );
267 ent_volume *volume = mdl_arritm( &world->ent_volume, index );
268 if( !volume->target ) return;
269
270 if( call->function == k_ent_function_trigger ){
271 call->id = volume->target;
272
273 if( volume->flags & k_ent_volume_flag_particles ){
274 float *co = alloca( sizeof(float)*3 );
275 co[0] = vg_randf64()*2.0f-1.0f;
276 co[1] = vg_randf64()*2.0f-1.0f;
277 co[2] = vg_randf64()*2.0f-1.0f;
278 m4x3_mulv( volume->to_world, co, co );
279
280 call->function = k_ent_function_particle_spawn;
281 call->data = co;
282 entity_call( world, call );
283 }
284 else{
285 call->function = volume->trigger.event;
286 entity_call( world, call );
287 }
288 }
289 else if( call->function == k_ent_function_trigger_leave ){
290 call->id = volume->target;
291
292 if( volume->flags & k_ent_volume_flag_particles ){
293 assert(0);
294 }
295 else{
296 call->function = volume->trigger.event_leave;
297 entity_call( world, call );
298 }
299 }
300 }
301
302 static void ent_audio_call( world_instance *world, ent_call *call ){
303 if( world->status == k_world_status_unloading ){
304 vg_warn( "cannot modify audio while unloading world\n" );
305 return;
306 }
307
308 u8 world_id = (world - world_static.instances) + 1;
309 u32 index = mdl_entity_id_id( call->id );
310 ent_audio *audio = mdl_arritm( &world->ent_audio, index );
311
312 v3f sound_co;
313
314 if( call->function == k_ent_function_particle_spawn ){
315 v3_copy( call->data, sound_co );
316 }
317 else if( call->function == k_ent_function_trigger ){
318 v3_copy( audio->transform.co, sound_co );
319 }
320 else
321 return;
322
323 float chance = vg_randf64()*100.0f,
324 bar = 0.0f;
325
326 for( u32 i=0; i<audio->clip_count; i++ ){
327 ent_audio_clip *clip = mdl_arritm( &world->ent_audio_clip,
328 audio->clip_start+i );
329
330 float mod = world->probabilities[ audio->probability_curve ],
331 p = clip->probability * mod;
332
333 bar += p;
334 if( chance < bar ){
335 audio_lock();
336
337 if( audio->behaviour == k_channel_behaviour_unlimited ){
338 audio_oneshot_3d( &clip->_.clip, sound_co,
339 audio->transform.s[0],
340 audio->volume );
341 }
342 else if( audio->behaviour == k_channel_behaviour_discard_if_full ){
343 audio_channel *ch =
344 audio_get_group_idle_channel( audio->group,
345 audio->max_channels );
346
347 if( ch ){
348 audio_channel_init( ch, &clip->_.clip, audio->flags );
349 audio_channel_group( ch, audio->group );
350 audio_channel_world( ch, world_id );
351 audio_channel_set_spacial( ch, sound_co, audio->transform.s[0] );
352 audio_channel_edit_volume( ch, audio->volume, 1 );
353 ch = audio_relinquish_channel( ch );
354 }
355 }
356 else if( audio->behaviour == k_channel_behaviour_crossfade_if_full){
357 audio_channel *ch =
358 audio_get_group_idle_channel( audio->group,
359 audio->max_channels );
360
361 /* group is full */
362 if( !ch ){
363 audio_channel *existing =
364 audio_get_group_first_active_channel( audio->group );
365
366 if( existing ){
367 if( existing->source == &clip->_.clip ){
368 audio_unlock();
369 return;
370 }
371
372 existing->group = 0;
373 existing = audio_channel_fadeout(existing, audio->crossfade);
374 }
375
376 ch = audio_get_first_idle_channel();
377 }
378
379 if( ch ){
380 audio_channel_init( ch, &clip->_.clip, audio->flags );
381 audio_channel_group( ch, audio->group );
382 audio_channel_world( ch, world_id );
383 audio_channel_fadein( ch, audio->crossfade );
384 ch = audio_relinquish_channel( ch );
385 }
386 }
387
388 audio_unlock();
389 return;
390 }
391 }
392 }
393
394
395 static void ent_ccmd_call( world_instance *world, ent_call *call ){
396 if( call->function == k_ent_function_trigger ){
397 u32 index = mdl_entity_id_id( call->id );
398 ent_ccmd *ccmd = mdl_arritm( &world->ent_ccmd, index );
399 vg_execute_console_input( mdl_pstr(&world->meta, ccmd->pstr_command) );
400 }
401 }
402
403 /*
404 * BVH implementation
405 * ----------------------------------------------------------------------------
406 */
407
408 static void
409 entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){
410 world_instance *world = user;
411
412 u32 id = world->entity_list[ item_index ],
413 type = mdl_entity_id_type( id ),
414 index = mdl_entity_id_id( id );
415
416 if( type == k_ent_gate ){
417 ent_gate *gate = mdl_arritm( &world->ent_gate, index );
418 boxf box = {{ -gate->dimensions[0], -gate->dimensions[1], -0.1f },
419 { gate->dimensions[0], gate->dimensions[1], 0.1f }};
420
421 m4x3_expand_aabb_aabb( gate->to_world, bound, box );
422 }
423 else if( type == k_ent_objective ){
424 ent_objective *objective = mdl_arritm( &world->ent_objective, index );
425
426 /* TODO: This might be more work than necessary. could maybe just get
427 * away with representing them as points */
428
429 boxf box;
430 box_init_inf( box );
431
432 for( u32 i=0; i<objective->submesh_count; i++ ){
433 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
434 objective->submesh_start+i );
435 box_concat( box, sm->bbx );
436 }
437
438 m4x3f transform;
439 mdl_transform_m4x3( &objective->transform, transform );
440 m4x3_expand_aabb_aabb( transform, bound, box );
441 }
442 else if( type == k_ent_volume ){
443 ent_volume *volume = mdl_arritm( &world->ent_volume, index );
444 m4x3_expand_aabb_aabb( volume->to_world, bound,
445 (boxf){{-1.0f,-1.0f,-1.0f},{ 1.0f, 1.0f, 1.0f}} );
446 }
447 else if( type == k_ent_challenge ){
448 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
449
450 boxf box = {{-1.2f*0.5f,-0.72f*0.5f,-0.01f*0.5f},
451 { 1.2f*0.5f, 0.72f*0.5f, 0.01f*0.5f}};
452 m4x3f transform;
453 mdl_transform_m4x3( &challenge->transform, transform );
454 m4x3_expand_aabb_aabb( transform, bound, box );
455 }
456 else{
457 vg_fatal_error( "Programming error\n" );
458 }
459 }
460
461 static float entity_bh_centroid( void *user, u32 item_index, int axis ){
462 world_instance *world = user;
463
464 u32 id = world->entity_list[ item_index ],
465 type = mdl_entity_id_type( id ),
466 index = mdl_entity_id_id( id );
467
468 if( type == k_ent_gate ){
469 ent_gate *gate = mdl_arritm( &world->ent_gate, index );
470 return gate->to_world[3][axis];
471 }
472 else if( type == k_ent_objective ){
473 ent_objective *objective = mdl_arritm( &world->ent_objective, index );
474 return objective->transform.co[axis];
475 }
476 else if( type == k_ent_volume ){
477 ent_volume *volume = mdl_arritm( &world->ent_volume, index );
478 return volume->transform.co[axis];
479 }
480 else if( type == k_ent_challenge ){
481 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
482 return challenge->transform.co[axis];
483 }
484 else {
485 vg_fatal_error( "Programming error\n" );
486 return INFINITY;
487 }
488 }
489
490 static void entity_bh_swap( void *user, u32 ia, u32 ib ){
491 world_instance *world = user;
492
493 u32 a = world->entity_list[ ia ],
494 b = world->entity_list[ ib ];
495
496 world->entity_list[ ia ] = b;
497 world->entity_list[ ib ] = a;
498 }
499
500 static void entity_bh_debug( void *user, u32 item_index ){
501 world_instance *world = user;
502
503 u32 id = world->entity_list[ item_index ],
504 type = mdl_entity_id_type( id ),
505 index = mdl_entity_id_id( id );
506
507 if( type == k_ent_gate ){
508 ent_gate *gate = mdl_arritm( &world->ent_gate, index );
509 boxf box = {{ -gate->dimensions[0], -gate->dimensions[1], -0.1f },
510 { gate->dimensions[0], gate->dimensions[1], 0.1f }};
511 vg_line_boxf_transformed( gate->to_world, box, 0xf000ff00 );
512 }
513 else if( type == k_ent_objective ){
514 ent_objective *objective = mdl_arritm( &world->ent_objective, index );
515 boxf box;
516 box_init_inf( box );
517
518 for( u32 i=0; i<objective->submesh_count; i++ ){
519 mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
520 objective->submesh_start+i );
521 box_concat( box, sm->bbx );
522 }
523
524 m4x3f transform;
525 mdl_transform_m4x3( &objective->transform, transform );
526 vg_line_boxf_transformed( transform, box, 0xf000ff00 );
527 }
528 else if( type == k_ent_volume ){
529 ent_volume *volume = mdl_arritm( &world->ent_volume, index );
530 vg_line_boxf_transformed( volume->to_world,
531 (boxf){{-1.0f,-1.0f,-1.0f},{ 1.0f, 1.0f, 1.0f}},
532 0xf000ff00 );
533 }
534 else if( type == k_ent_challenge ){
535 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
536
537 boxf box = {{-1.2f*0.5f,-0.72f*0.5f,-0.01f*0.5f},
538 { 1.2f*0.5f, 0.72f*0.5f, 0.01f*0.5f}};
539 m4x3f transform;
540 mdl_transform_m4x3( &challenge->transform, transform );
541 vg_line_boxf_transformed( transform, box, 0xf0ff0000 );
542 }
543 else{
544 vg_fatal_error( "Programming error\n" );
545 }
546 }
547
548 static void entity_bh_closest( void *user, u32 item_index, v3f point,
549 v3f closest ){
550 world_instance *world = user;
551
552 u32 id = world->entity_list[ item_index ],
553 type = mdl_entity_id_type( id ),
554 index = mdl_entity_id_id( id );
555
556 if( type == k_ent_gate ){
557 ent_gate *gate = mdl_arritm( &world->ent_gate, index );
558 v3_copy( gate->to_world[3], closest );
559 }
560 else if( type == k_ent_objective ){
561 ent_objective *challenge = mdl_arritm( &world->ent_objective, index );
562 v3_copy( challenge->transform.co, closest );
563 }
564 else if( type == k_ent_volume ){
565 ent_volume *volume = mdl_arritm( &world->ent_volume, index );
566 v3_copy( volume->to_world[3], closest );
567 }
568 else if( type == k_ent_challenge ){
569 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
570 v3_copy( challenge->transform.co, closest );
571 }
572 else{
573 vg_fatal_error( "Programming error\n" );
574 }
575 }
576
577 static void world_entity_start( world_instance *world, vg_msg *sav ){
578 vg_info( "Start instance %p\n", world );
579
580 world->probabilities[ k_probability_curve_constant ] = 1.0f;
581 for( u32 i=0; i<mdl_arrcount(&world->ent_audio); i++ ){
582 ent_audio *audio = mdl_arritm(&world->ent_audio,i);
583 if( audio->flags & AUDIO_FLAG_AUTO_START ){
584 ent_call call;
585 call.data = NULL;
586 call.function = k_ent_function_trigger;
587 call.id = mdl_entity_id( k_ent_audio, i );
588 entity_call( world, &call );
589 }
590 }
591
592 /* read savedata
593 * ----------------------------------------------------------------------- */
594
595 for( u32 i=0; i<mdl_arrcount(&world->ent_challenge); i++ ){
596 ent_challenge *challenge = mdl_arritm( &world->ent_challenge, i );
597 const char *alias = mdl_pstr( &world->meta, challenge->pstr_alias );
598
599 if( vg_msg_getkvu32( sav, alias, 0 ) ){
600 ent_call call;
601 call.data = NULL;
602 call.function = 0;
603 call.id = mdl_entity_id( k_ent_challenge, i );
604 entity_call( world, &call );
605 }
606 }
607 }
608
609 static void world_entity_serialize( world_instance *world, vg_msg *sav ){
610 for( u32 i=0; i<mdl_arrcount(&world->ent_challenge); i++ ){
611 ent_challenge *challenge = mdl_arritm(&world->ent_challenge,i);
612
613 const char *alias = mdl_pstr(&world->meta,challenge->pstr_alias);
614 vg_msg_wkvu32( sav, alias, challenge->status );
615 }
616 }
617
618 #endif /* WORLD_ENTITY_C */