shits fucked
[carveJwlIkooP6JGAAIwe30JlM.git] / player_skate.c
1 #ifndef PLAYER_SKATE_C
2 #define PLAYER_SKATE_C
3
4 #include "player.h"
5
6 VG_STATIC void player__skate_bind( player_instance *player )
7 {
8 struct player_skate *s = &player->_skate;
9 struct player_avatar *av = player->playeravatar;
10 struct skeleton *sk = &av->sk;
11
12 rb_update_transform( &player->rb );
13 s->anim_stand = skeleton_get_anim( sk, "pose_stand" );
14 s->anim_highg = skeleton_get_anim( sk, "pose_highg" );
15 s->anim_air = skeleton_get_anim( sk, "pose_air" );
16 s->anim_slide = skeleton_get_anim( sk, "pose_slide" );
17 s->anim_push = skeleton_get_anim( sk, "push" );
18 s->anim_push_reverse = skeleton_get_anim( sk, "push_reverse" );
19 s->anim_ollie = skeleton_get_anim( sk, "ollie" );
20 s->anim_ollie_reverse = skeleton_get_anim( sk, "ollie_reverse" );
21 s->anim_grabs = skeleton_get_anim( sk, "grabs" );
22 }
23
24 /*
25 * Collision detection routines
26 *
27 *
28 */
29
30 /*
31 * Does collision detection on a sphere vs world, and applies some smoothing
32 * filters to the manifold afterwards
33 */
34 VG_STATIC int skate_collide_smooth( player_instance *player,
35 m4x3f mtx, rb_sphere *sphere,
36 rb_ct *man )
37 {
38 int len = 0;
39 len = rb_sphere__scene( mtx, sphere, NULL, &world.rb_geo.inf.scene, man );
40
41 for( int i=0; i<len; i++ )
42 {
43 man[i].rba = &player->rb;
44 man[i].rbb = NULL;
45 }
46
47 return len;
48
49 rb_manifold_filter_coplanar( man, len, 0.05f );
50
51 if( len > 1 )
52 {
53 rb_manifold_filter_backface( man, len );
54 rb_manifold_filter_joint_edges( man, len, 0.05f );
55 rb_manifold_filter_pairs( man, len, 0.05f );
56 }
57 int new_len = rb_manifold_apply_filtered( man, len );
58 if( len && !new_len )
59 len = 1;
60 else
61 len = new_len;
62
63 return len;
64 }
65 /*
66 * Gets the closest grindable edge to the player within max_dist
67 */
68 VG_STATIC struct grind_edge *skate_collect_grind_edge( v3f p0, v3f p1,
69 v3f c0, v3f c1,
70 float max_dist )
71 {
72 bh_iter it;
73 bh_iter_init( 0, &it );
74
75 boxf region;
76
77 box_init_inf( region );
78 box_addpt( region, p0 );
79 box_addpt( region, p1 );
80
81 float k_r = max_dist;
82 v3_add( (v3f){ k_r, k_r, k_r}, region[1], region[1] );
83 v3_add( (v3f){-k_r,-k_r,-k_r}, region[0], region[0] );
84
85 float closest = k_r*k_r;
86 struct grind_edge *closest_edge = NULL;
87
88 int idx;
89 while( bh_next( world.grind_bh, &it, region, &idx ) )
90 {
91 struct grind_edge *edge = &world.grind_edges[ idx ];
92
93 float s,t;
94 v3f pa, pb;
95
96 float d2 =
97 closest_segment_segment( p0, p1, edge->p0, edge->p1, &s,&t, pa, pb );
98
99 if( d2 < closest )
100 {
101 closest = d2;
102 closest_edge = edge;
103 v3_copy( pa, c0 );
104 v3_copy( pb, c1 );
105 }
106 }
107
108 return closest_edge;
109 }
110
111 VG_STATIC int skate_grind_collide( player_instance *player, rb_ct *contact )
112 {
113 v3f p0, p1, c0, c1;
114 v3_muladds( player->rb.co, player->rb.to_world[2], 0.5f, p0 );
115 v3_muladds( player->rb.co, player->rb.to_world[2], -0.5f, p1 );
116 v3_muladds( p0, player->rb.to_world[1], 0.08f, p0 );
117 v3_muladds( p1, player->rb.to_world[1], 0.08f, p1 );
118
119 float const k_r = 0.25f;
120 struct grind_edge *closest_edge = skate_collect_grind_edge( p0, p1,
121 c0, c1, k_r );
122
123 if( closest_edge )
124 {
125 v3f delta;
126 v3_sub( c1, c0, delta );
127
128 if( v3_dot( delta, player->rb.to_world[1] ) > 0.0001f )
129 {
130 contact->p = v3_length( delta );
131 contact->type = k_contact_type_edge;
132 contact->element_id = 0;
133 v3_copy( c1, contact->co );
134 contact->rba = NULL;
135 contact->rbb = NULL;
136
137 v3f edge_dir, axis_dir;
138 v3_sub( closest_edge->p1, closest_edge->p0, edge_dir );
139 v3_normalize( edge_dir );
140 v3_cross( (v3f){0.0f,1.0f,0.0f}, edge_dir, axis_dir );
141 v3_cross( edge_dir, axis_dir, contact->n );
142
143 return 1;
144 }
145 else
146 return 0;
147 }
148
149 return 0;
150 }
151
152 VG_STATIC int skate_grind_scansq( player_instance *player, v3f pos,
153 v3f result_co, v3f result_dir, v3f result_n )
154 {
155 v4f plane;
156 v3_copy( player->rb.v, plane );
157 v3_normalize( plane );
158 plane[3] = v3_dot( plane, pos );
159
160 boxf box;
161 float r = 0.3f;
162 v3_add( pos, (v3f){ r, r, r }, box[1] );
163 v3_sub( pos, (v3f){ r, r, r }, box[0] );
164
165 #if 0
166 vg_line_boxf( box, VG__BLUE );
167 #endif
168
169 m4x3f mtx;
170 m3x3_copy( player->rb.to_world, mtx );
171 v3_copy( pos, mtx[3] );
172
173 #if 0
174 debug_sphere( mtx, r, VG__CYAN );
175 #endif
176
177 bh_iter it;
178 bh_iter_init( 0, &it );
179 int idx;
180
181 struct grind_sample
182 {
183 v2f co;
184 v2f normal;
185 v3f normal3,
186 centroid;
187 }
188 samples[48];
189
190 int sample_count = 0;
191
192 v2f support_min,
193 support_max;
194
195 v3f support_axis;
196 v3_cross( plane, (v3f){0.0f,1.0f,0.0f}, support_axis );
197 v3_normalize( support_axis );
198
199 while( bh_next( world.geo_bh, &it, box, &idx ) )
200 {
201 u32 *ptri = &world.scene_geo->arrindices[ idx*3 ];
202 v3f tri[3];
203
204 for( int j=0; j<3; j++ )
205 v3_copy( world.scene_geo->arrvertices[ptri[j]].co, tri[j] );
206
207 for( int j=0; j<3; j++ )
208 {
209 int i0 = j,
210 i1 = (j+1) % 3;
211
212 struct grind_sample *sample = &samples[ sample_count ];
213 v3f co;
214
215 if( plane_segment( plane, tri[i0], tri[i1], co ) )
216 {
217 v3f d;
218 v3_sub( co, pos, d );
219 if( v3_length2( d ) > r*r )
220 continue;
221
222 v3f va, vb, normal;
223 v3_sub( tri[1], tri[0], va );
224 v3_sub( tri[2], tri[0], vb );
225 v3_cross( va, vb, normal );
226
227 sample->normal[0] = v3_dot( support_axis, normal );
228 sample->normal[1] = normal[1];
229 sample->co[0] = v3_dot( support_axis, d );
230 sample->co[1] = d[1];
231
232 v3_copy( normal, sample->normal3 ); /* normalize later
233 if we want to us it */
234
235 v3_muls( tri[0], 1.0f/3.0f, sample->centroid );
236 v3_muladds( sample->centroid, tri[1], 1.0f/3.0f, sample->centroid );
237 v3_muladds( sample->centroid, tri[2], 1.0f/3.0f, sample->centroid );
238
239 v2_normalize( sample->normal );
240 sample_count ++;
241
242 if( sample_count == vg_list_size( samples ) )
243 {
244 break;
245 }
246 }
247 }
248 }
249
250 if( sample_count < 2 )
251 return 0;
252
253 v3f average_position,
254 average_direction,
255 average_normal;
256
257 v3_zero( average_position );
258 v3_zero( average_direction );
259 v3_zero( average_normal );
260
261 int passed_samples = 0;
262
263 for( int i=0; i<sample_count-1; i++ )
264 {
265 struct grind_sample *si, *sj;
266
267 si = &samples[i];
268
269 for( int j=i+1; j<sample_count; j++ )
270 {
271 if( i == j )
272 continue;
273
274 sj = &samples[j];
275
276 /* non overlapping */
277 if( v2_dist2( si->co, sj->co ) >= (0.01f*0.01f) )
278 continue;
279
280 /* not sharp angle */
281 if( v2_dot( si->normal, sj->normal ) >= 0.7f )
282 continue;
283
284 /* not convex */
285 v3f v0;
286 v3_sub( sj->centroid, si->centroid, v0 );
287 if( v3_dot( v0, si->normal3 ) >= 0.0f ||
288 v3_dot( v0, sj->normal3 ) <= 0.0f )
289 continue;
290
291 v3f p0;
292 v3_muls( support_axis, sj->co[0], p0 );
293 p0[1] += sj->co[1];
294
295 v3_add( average_position, p0, average_position );
296
297 v3f n0, n1, dir;
298 v3_copy( si->normal3, n0 );
299 v3_copy( sj->normal3, n1 );
300 v3_cross( n0, n1, dir );
301 v3_normalize( dir );
302
303 /* make sure the directions all face a common hemisphere */
304 v3_muls( dir, vg_signf(v3_dot(dir,plane)), dir );
305 v3_add( average_direction, dir, average_direction );
306
307 if( si->normal3[1] > sj->normal3[1] )
308 v3_add( si->normal3, average_normal, average_normal );
309 else
310 v3_add( sj->normal3, average_normal, average_normal );
311
312 passed_samples ++;
313 }
314 }
315
316 if( !passed_samples )
317 return 0;
318
319 if( (v3_length2( average_direction ) <= 0.001f) ||
320 (v3_length2( average_normal ) <= 0.001f ) )
321 return 0;
322
323 float div = 1.0f/(float)passed_samples;
324 v3_muls( average_position, div, average_position );
325 v3_normalize( average_direction );
326 v3_normalize( average_normal );
327
328 v3_add( pos, average_position, average_position );
329 vg_line_pt3( average_position, 0.02f, VG__GREEN );
330
331 v3f p0, p1;
332 v3_muladds( average_position, average_direction, 0.35f, p0 );
333 v3_muladds( average_position, average_direction, -0.35f, p1 );
334 vg_line( p0, p1, VG__PINK );
335
336 v3_copy( average_position, result_co );
337 v3_copy( average_normal, result_n );
338 v3_copy( average_direction, result_dir );
339
340 return passed_samples;
341 }
342
343 /*
344 *
345 * Prediction system
346 *
347 *
348 */
349
350 /*
351 * Trace a path given a velocity rotation.
352 *
353 * TODO: this MIGHT be worth doing RK4 on the gravity field.
354 */
355 VG_STATIC void skate_score_biased_path( v3f co, v3f v, m3x3f vr,
356 struct land_prediction *prediction )
357 {
358 float pstep = VG_TIMESTEP_FIXED * 10.0f;
359 float k_bias = 0.96f;
360
361 v3f pco, pco1, pv;
362 v3_copy( co, pco );
363 v3_muls( v, k_bias, pv );
364
365 m3x3_mulv( vr, pv, pv );
366 v3_muladds( pco, pv, pstep, pco );
367
368 struct grind_edge *best_grind = NULL;
369 float closest_grind = INFINITY;
370
371 float grind_score = INFINITY,
372 air_score = INFINITY,
373 time_to_impact = 0.0f;
374
375 prediction->log_length = 0;
376 v3_copy( pco, prediction->apex );
377
378 for( int i=0; i<vg_list_size(prediction->log); i++ )
379 {
380 v3_copy( pco, pco1 );
381
382 pv[1] += -k_gravity * pstep;
383
384 m3x3_mulv( vr, pv, pv );
385 v3_muladds( pco, pv, pstep, pco );
386
387 if( pco[1] > prediction->apex[1] )
388 v3_copy( pco, prediction->apex );
389
390 v3f vdir;
391
392 v3_sub( pco, pco1, vdir );
393
394 float l = v3_length( vdir );
395 v3_muls( vdir, 1.0f/l, vdir );
396
397 v3f c0, c1;
398 struct grind_edge *ge = skate_collect_grind_edge( pco, pco1,
399 c0, c1, 0.4f );
400
401 if( ge && (v3_dot((v3f){0.0f,1.0f,0.0f},vdir) < -0.2f ) )
402 {
403 float d2 = v3_dist2( c0, c1 );
404 if( d2 < closest_grind )
405 {
406 closest_grind = d2;
407 best_grind = ge;
408 grind_score = closest_grind * 0.05f;
409 }
410 }
411
412 v3f n1;
413
414 float t1;
415 int idx = spherecast_world( pco1, pco, 0.4f, &t1, n1 );
416 if( idx != -1 )
417 {
418 v3_copy( n1, prediction->n );
419 air_score = -v3_dot( pv, n1 );
420
421 u32 vert_index = world.scene_geo->arrindices[ idx*3 ];
422 struct world_material *mat = world_tri_index_material( vert_index );
423
424 /* Bias prediction towords ramps */
425 if( mat->info.flags & k_material_flag_skate_surface )
426 air_score *= 0.1f;
427
428 v3_lerp( pco1, pco, t1, prediction->log[ prediction->log_length ++ ] );
429 time_to_impact += t1 * pstep;
430 break;
431 }
432
433 time_to_impact += pstep;
434 v3_copy( pco, prediction->log[ prediction->log_length ++ ] );
435 }
436
437 if( grind_score < air_score )
438 {
439 prediction->score = grind_score;
440 prediction->type = k_prediction_grind;
441 }
442 else if( air_score < INFINITY )
443 {
444 prediction->score = air_score;
445 prediction->type = k_prediction_land;
446 }
447 else
448 {
449 prediction->score = INFINITY;
450 prediction->type = k_prediction_none;
451 }
452
453 prediction->land_dist = time_to_impact;
454 }
455
456 VG_STATIC
457 void player__approximate_best_trajectory( player_instance *player )
458 {
459 struct player_skate *s = &player->_skate;
460
461 float pstep = VG_TIMESTEP_FIXED * 10.0f;
462 float best_velocity_delta = -9999.9f;
463
464 v3f axis;
465 v3_cross( player->rb.to_world[1], player->rb.v, axis );
466 v3_normalize( axis );
467
468 s->prediction_count = 0;
469 m3x3_identity( s->state.velocity_bias );
470
471 float best_vmod = 0.0f,
472 min_score = INFINITY,
473 max_score = -INFINITY;
474
475 v3_zero( s->state.apex );
476 s->land_dist = 0.0f;
477
478 /*
479 * Search a broad selection of futures
480 */
481 for( int m=-3;m<=12; m++ )
482 {
483 struct land_prediction *p = &s->predictions[ s->prediction_count ++ ];
484
485 float vmod = ((float)m / 15.0f)*0.09f;
486
487 m3x3f bias;
488 v4f bias_q;
489
490 q_axis_angle( bias_q, axis, vmod );
491 q_m3x3( bias_q, bias );
492
493 skate_score_biased_path( player->rb.co, player->rb.v, bias, p );
494
495 if( p->type != k_prediction_none )
496 {
497 if( p->score < min_score )
498 {
499 min_score = p->score;
500 best_vmod = vmod;
501 s->land_dist = p->land_dist;
502 v3_copy( p->apex, s->state.apex );
503 }
504
505 if( p->score > max_score )
506 max_score = p->score;
507 }
508 }
509
510 v4f vr_q;
511 q_axis_angle( vr_q, axis, best_vmod*0.1f );
512 q_m3x3( vr_q, s->state.velocity_bias );
513
514 q_axis_angle( vr_q, axis, best_vmod );
515 q_m3x3( vr_q, s->state.velocity_bias_pstep );
516
517 /*
518 * Logging
519 */
520 for( int i=0; i<s->prediction_count; i ++ )
521 {
522 struct land_prediction *p = &s->predictions[i];
523
524 float l = p->score;
525
526 if( l < 0.0f )
527 {
528 vg_error( "negative score! (%f)\n", l );
529 }
530
531 l -= min_score;
532 l /= (max_score-min_score);
533 l = 1.0f - l;
534 l *= 255.0f;
535
536 p->colour = l;
537 p->colour <<= 8;
538 p->colour |= 0xff000000;
539 }
540
541
542 v2f steer = { player->input_js1h->axis.value,
543 player->input_js1v->axis.value };
544 v2_normalize_clamp( steer );
545
546 if( (fabsf(steer[1]) > 0.5f) && (s->land_dist >= 1.0f) )
547 {
548 s->state.flip_rate = (1.0f/s->land_dist) * vg_signf(steer[1]) *
549 s->state.reverse ;
550 s->state.flip_time = 0.0f;
551 v3_copy( player->rb.to_world[0], s->state.flip_axis );
552 }
553 else
554 {
555 s->state.flip_rate = 0.0f;
556 v3_zero( s->state.flip_axis );
557 }
558 }
559
560 /*
561 *
562 * Varius physics models
563 * ------------------------------------------------
564 */
565
566 VG_STATIC void skate_apply_grind_model( player_instance *player,
567 rb_ct *manifold, int len )
568 {
569 struct player_skate *s = &player->_skate;
570
571 /* FIXME: Queue audio events instead */
572 if( len == 0 )
573 {
574 if( s->state.activity == k_skate_activity_grind )
575 {
576 #if 0
577 audio_lock();
578 audio_player_set_flags( &audio_player_extra,
579 AUDIO_FLAG_SPACIAL_3D );
580 audio_player_set_position( &audio_player_extra, player.rb.co );
581 audio_player_set_vol( &audio_player_extra, 20.0f );
582 audio_player_playclip( &audio_player_extra, &audio_board[6] );
583 audio_unlock();
584 #endif
585
586 s->state.activity = k_skate_activity_air;
587 }
588 return;
589 }
590
591 v2f steer = { player->input_js1h->axis.value,
592 player->input_js1v->axis.value };
593 v2_normalize_clamp( steer );
594
595 #if 0
596 s->state.steery -= steer[0] * k_steer_air * k_rb_delta;
597 s->state.steerx += steer[1] * s->state.reverse * k_steer_air * k_rb_delta;
598 #endif
599
600 #if 0
601 v4f rotate;
602 q_axis_angle( rotate, player->rb.to_world[0], siX );
603 q_mul( rotate, player.rb.q, player.rb.q );
604 #endif
605
606 s->state.slip = 0.0f;
607 s->state.activity = k_skate_activity_grind;
608
609 /* TODO: Compression */
610 v3f up = { 0.0f, 1.0f, 0.0f };
611 float angle = v3_dot( player->rb.to_world[1], up );
612
613 if( fabsf(angle) < 0.99f )
614 {
615 v3f axis;
616 v3_cross( player->rb.to_world[1], up, axis );
617
618 v4f correction;
619 q_axis_angle( correction, axis, k_rb_delta * 10.0f * acosf(angle) );
620 q_mul( correction, player->rb.q, player->rb.q );
621 }
622
623 float const DOWNFORCE = -k_downforce*1.2f*VG_TIMESTEP_FIXED;
624 v3_muladds( player->rb.v, manifold->n, DOWNFORCE, player->rb.v );
625 m3x3_identity( s->state.velocity_bias );
626 m3x3_identity( s->state.velocity_bias_pstep );
627
628 if( s->state.activity_prev != k_skate_activity_grind )
629 {
630 /* FIXME: Queue audio events instead */
631 #if 0
632 audio_lock();
633 audio_player_set_flags( &audio_player_extra,
634 AUDIO_FLAG_SPACIAL_3D );
635 audio_player_set_position( &audio_player_extra, player.rb.co );
636 audio_player_set_vol( &audio_player_extra, 20.0f );
637 audio_player_playclip( &audio_player_extra, &audio_board[5] );
638 audio_unlock();
639 #endif
640 }
641 }
642
643 /*
644 * Air control, no real physics
645 */
646 VG_STATIC void skate_apply_air_model( player_instance *player )
647 {
648 struct player_skate *s = &player->_skate;
649
650 if( s->state.activity != k_skate_activity_air )
651 return;
652
653 if( s->state.activity_prev != k_skate_activity_air )
654 player__approximate_best_trajectory( player );
655
656 m3x3_mulv( s->state.velocity_bias, player->rb.v, player->rb.v );
657 ray_hit hit;
658
659 /*
660 * Prediction
661 */
662 float pstep = VG_TIMESTEP_FIXED * 1.0f;
663 float k_bias = 0.98f;
664
665 v3f pco, pco1, pv;
666 v3_copy( player->rb.co, pco );
667 v3_muls( player->rb.v, 1.0f, pv );
668
669 float time_to_impact = 0.0f;
670 float limiter = 1.0f;
671
672 struct grind_edge *best_grind = NULL;
673 float closest_grind = INFINITY;
674
675 v3f target_normal = { 0.0f, 1.0f, 0.0f };
676 int has_target = 0;
677
678 for( int i=0; i<250; i++ )
679 {
680 v3_copy( pco, pco1 );
681 m3x3_mulv( s->state.velocity_bias, pv, pv );
682
683 pv[1] += -k_gravity * pstep;
684 v3_muladds( pco, pv, pstep, pco );
685
686 ray_hit contact;
687 v3f vdir;
688
689 v3_sub( pco, pco1, vdir );
690 contact.dist = v3_length( vdir );
691 v3_divs( vdir, contact.dist, vdir);
692
693 v3f c0, c1;
694 struct grind_edge *ge = skate_collect_grind_edge( pco, pco1,
695 c0, c1, 0.4f );
696
697 if( ge && (v3_dot((v3f){0.0f,1.0f,0.0f},vdir) < -0.2f ) )
698 {
699 vg_line( ge->p0, ge->p1, 0xff0000ff );
700 vg_line_cross( pco, 0xff0000ff, 0.25f );
701 has_target = 1;
702 break;
703 }
704
705 float orig_dist = contact.dist;
706 if( ray_world( pco1, vdir, &contact ) )
707 {
708 v3_copy( contact.normal, target_normal );
709 has_target = 1;
710 time_to_impact += (contact.dist/orig_dist)*pstep;
711 vg_line_cross( contact.pos, 0xffff0000, 0.25f );
712 break;
713 }
714 time_to_impact += pstep;
715 }
716
717 if( has_target )
718 {
719 float angle = v3_dot( player->rb.to_world[1], target_normal );
720 v3f axis;
721 v3_cross( player->rb.to_world[1], target_normal, axis );
722
723 limiter = vg_minf( 5.0f, time_to_impact )/5.0f;
724 limiter = 1.0f-limiter;
725 limiter *= limiter;
726 limiter = 1.0f-limiter;
727
728 if( fabsf(angle) < 0.9999f )
729 {
730 v4f correction;
731 q_axis_angle( correction, axis,
732 acosf(angle)*(1.0f-limiter)*2.0f*VG_TIMESTEP_FIXED );
733 q_mul( correction, player->rb.q, player->rb.q );
734 }
735 }
736
737 v2f steer = { player->input_js1h->axis.value,
738 player->input_js1v->axis.value };
739 v2_normalize_clamp( steer );
740
741 #if 0
742 s->state.steery -= steer[0] * k_steer_air * VG_TIMESTEP_FIXED;
743 s->state.steerx += steer[1] * s->state.reverse * k_steer_air
744 * limiter * k_rb_delta;
745 #endif
746 s->land_dist = time_to_impact;
747 v3_copy( target_normal, s->land_normal );
748 }
749
750 VG_STATIC void skate_get_board_points( player_instance *player,
751 v3f front, v3f back )
752 {
753 v3f pos_front = {0.0f,0.0f,-k_board_length},
754 pos_back = {0.0f,0.0f, k_board_length};
755
756 m4x3_mulv( player->rb.to_world, pos_front, front );
757 m4x3_mulv( player->rb.to_world, pos_back, back );
758 }
759
760 /*
761 * Casts and pushes a sphere-spring model into the world
762 */
763 VG_STATIC int skate_simulate_spring( player_instance *player,
764 v3f pos )
765 {
766 struct player_skate *s = &player->_skate;
767
768 float mod = 0.7f * player->input_grab->axis.value + 0.3f,
769 spring_k = mod * k_spring_force,
770 damp_k = mod * k_spring_dampener,
771 disp_k = 0.4f;
772
773 v3f start, end;
774 v3_copy( pos, start );
775 v3_muladds( pos, player->rb.to_world[1], -disp_k, end );
776
777 float t;
778 v3f n;
779 int hit_info = spherecast_world( start, end, 0.2f, &t, n );
780
781 if( hit_info != -1 )
782 {
783 v3f F, delta;
784 v3_sub( start, player->rb.co, delta );
785
786 float displacement = vg_clampf( 1.0f-t, 0.0f, 1.0f ),
787 damp =
788 vg_maxf( 0.0f, v3_dot( player->rb.to_world[1], player->rb.v ) );
789
790 v3_muls( player->rb.to_world[1], displacement*spring_k*k_rb_delta -
791 damp*damp_k*k_rb_delta, F );
792
793 v3_muladds( player->rb.v, F, 1.0f, player->rb.v );
794
795 /* Angular velocity */
796 v3f wa;
797 v3_cross( delta, F, wa );
798 v3_muladds( player->rb.w, wa, k_spring_angular, player->rb.w );
799
800 v3_lerp( start, end, t, pos );
801 return 1;
802 }
803 else
804 {
805 v3_copy( end, pos );
806 return 0;
807 }
808 }
809
810
811 /*
812 * Handles connection between the player and the ground
813 *
814 * TODO: Must save original velocity to use here
815 */
816 VG_STATIC void skate_apply_interface_model( player_instance *player,
817 rb_ct *manifold, int len )
818 {
819 struct player_skate *s = &player->_skate;
820
821 if( !((s->state.activity == k_skate_activity_ground) ||
822 (s->state.activity == k_skate_activity_air )) )
823 return;
824
825 if( s->state.activity == k_skate_activity_air )
826 s->debug_normal_pressure = 0.0f;
827 else
828 s->debug_normal_pressure = v3_dot( player->rb.to_world[1], player->rb.v );
829
830 /* springs */
831 v3f spring0, spring1;
832
833 skate_get_board_points( player, spring1, spring0 );
834 int spring_hit0 = 0, //skate_simulate_spring( player, s, spring0 ),
835 spring_hit1 = 0; //skate_simulate_spring( player, s, spring1 );
836
837 v3f animavg, animdelta;
838 v3_add( spring0, spring1, animavg );
839 v3_muls( animavg, 0.5f, animavg );
840
841 v3_sub( spring1, spring0, animdelta );
842 v3_normalize( animdelta );
843
844 m4x3_mulv( player->rb.to_local, animavg, s->board_offset );
845
846 float dx = -v3_dot( animdelta, player->rb.to_world[2] ),
847 dy = v3_dot( animdelta, player->rb.to_world[1] );
848
849 float angle = -atan2f( dy, dx );
850 q_axis_angle( s->board_rotation, (v3f){1.0f,0.0f,0.0f}, angle );
851
852 int lift_frames_limit = 6;
853
854 /* Surface connection */
855 if( len == 0 && !(spring_hit0 && spring_hit1) )
856 {
857 s->state.lift_frames ++;
858
859 if( s->state.lift_frames >= lift_frames_limit )
860 s->state.activity = k_skate_activity_air;
861 }
862 else
863 {
864 v3f surface_avg;
865 v3_zero( surface_avg );
866
867 for( int i=0; i<len; i++ )
868 v3_add( surface_avg, manifold[i].n, surface_avg );
869 v3_normalize( surface_avg );
870
871 if( v3_dot( player->rb.v, surface_avg ) > 0.7f )
872 {
873 s->state.lift_frames ++;
874
875 if( s->state.lift_frames >= lift_frames_limit )
876 s->state.activity = k_skate_activity_air;
877 }
878 else
879 {
880 s->state.activity = k_skate_activity_ground;
881 s->state.lift_frames = 0;
882 v3f projected, axis;
883
884 if( s->state.activity_prev == k_skate_activity_air )
885 {
886 player->cam_land_punch_v += v3_dot( player->rb.v, surface_avg ) *
887 k_cam_punch;
888 }
889
890 float const DOWNFORCE = -k_downforce*VG_TIMESTEP_FIXED;
891 v3_muladds( player->rb.v, player->rb.to_world[1],
892 DOWNFORCE, player->rb.v );
893
894 float d = v3_dot( player->rb.to_world[2], surface_avg );
895 v3_muladds( surface_avg, player->rb.to_world[2], -d, projected );
896 v3_normalize( projected );
897
898 float angle = v3_dot( player->rb.to_world[1], projected );
899 v3_cross( player->rb.to_world[1], projected, axis );
900
901 #if 0
902 if( fabsf(angle) < 0.9999f )
903 {
904 v4f correction;
905 q_axis_angle( correction, axis,
906 acosf(angle)*4.0f*VG_TIMESTEP_FIXED );
907 q_mul( correction, player->rb.q, player->rb.q );
908 }
909 #endif
910 }
911 }
912 }
913
914 VG_STATIC int player_skate_trick_input( player_instance *player );
915 VG_STATIC void skate_apply_trick_model( player_instance *player )
916 {
917 struct player_skate *s = &player->_skate;
918
919 v3f Fd, Fs, F;
920 v3f strength = { 3.7f, 3.6f, 8.0f };
921
922 v3_muls( s->board_trick_residualv, -4.0f , Fd );
923 v3_muls( s->board_trick_residuald, -10.0f, Fs );
924 v3_add( Fd, Fs, F );
925 v3_mul( strength, F, F );
926
927 v3_muladds( s->board_trick_residualv, F, k_rb_delta,
928 s->board_trick_residualv );
929 v3_muladds( s->board_trick_residuald, s->board_trick_residualv,
930 k_rb_delta, s->board_trick_residuald );
931
932 if( s->state.activity == k_skate_activity_air )
933 {
934 if( v3_length2( s->state.trick_vel ) < 0.0001f )
935 return;
936
937 int carry_on = player_skate_trick_input( player );
938
939 /* we assume velocities share a common divisor, in which case the
940 * interval is the minimum value (if not zero) */
941
942 float min_rate = 99999.0f;
943
944 for( int i=0; i<3; i++ )
945 {
946 float v = s->state.trick_vel[i];
947 if( (v > 0.0f) && (v < min_rate) )
948 min_rate = v;
949 }
950
951 float interval = 1.0f / min_rate,
952 current = floorf( s->state.trick_time / interval ),
953 next_end = (current+1.0f) * interval;
954
955
956 /* integrate trick velocities */
957 v3_muladds( s->state.trick_euler, s->state.trick_vel, k_rb_delta,
958 s->state.trick_euler );
959
960 if( !carry_on && (s->state.trick_time + k_rb_delta >= next_end) )
961 {
962 s->state.trick_time = 0.0f;
963 s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
964 s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
965 s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
966 v3_copy( s->state.trick_vel, s->board_trick_residualv );
967 v3_zero( s->state.trick_vel );
968 }
969
970 s->state.trick_time += k_rb_delta;
971 }
972 else
973 {
974 if( (s->state.lift_frames == 0)
975 && (v3_length2(s->state.trick_vel) >= 0.0001f ) &&
976 s->state.trick_time > 0.2f)
977 {
978 player__dead_transition( player );
979 }
980
981 s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
982 s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
983 s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
984 s->state.trick_time = 0.0f;
985 v3_zero( s->state.trick_vel );
986 }
987 }
988
989 VG_STATIC void skate_apply_grab_model( player_instance *player )
990 {
991 struct player_skate *s = &player->_skate;
992
993 float grabt = player->input_grab->axis.value;
994
995 if( grabt > 0.5f )
996 {
997 v2_muladds( s->state.grab_mouse_delta, vg.mouse_delta, 0.02f,
998 s->state.grab_mouse_delta );
999
1000 v2_normalize_clamp( s->state.grab_mouse_delta );
1001 }
1002 else
1003 v2_zero( s->state.grab_mouse_delta );
1004
1005 s->state.grabbing = vg_lerpf( s->state.grabbing, grabt, 8.4f*k_rb_delta );
1006 }
1007
1008 /*
1009 * Computes friction and surface interface model
1010 */
1011 VG_STATIC void skate_apply_friction_model( player_instance *player )
1012 {
1013 struct player_skate *s = &player->_skate;
1014
1015 if( s->state.activity != k_skate_activity_ground )
1016 return;
1017
1018 /*
1019 * Computing localized friction forces for controlling the character
1020 * Friction across X is significantly more than Z
1021 */
1022
1023 v3f vel;
1024 m3x3_mulv( player->rb.to_local, player->rb.v, vel );
1025 float slip = 0.0f;
1026
1027 if( fabsf(vel[2]) > 0.01f )
1028 slip = fabsf(-vel[0] / vel[2]) * vg_signf(vel[0]);
1029
1030 if( fabsf( slip ) > 1.2f )
1031 slip = vg_signf( slip ) * 1.2f;
1032
1033 s->state.slip = slip;
1034 s->state.reverse = -vg_signf(vel[2]);
1035
1036 vel[0] += vg_cfrictf( vel[0], k_friction_lat * k_rb_delta );
1037 vel[2] += vg_cfrictf( vel[2], k_friction_resistance * k_rb_delta );
1038
1039 /* Pushing additive force */
1040
1041 if( !player->input_jump->button.value )
1042 {
1043 if( player->input_push->button.value )
1044 {
1045 if( (vg.time - s->state.cur_push) > 0.25 )
1046 s->state.start_push = vg.time;
1047
1048 s->state.cur_push = vg.time;
1049
1050 double push_time = vg.time - s->state.start_push;
1051
1052 float cycle_time = push_time*k_push_cycle_rate,
1053 accel = k_push_accel * (sinf(cycle_time)*0.5f+0.5f),
1054 amt = accel * VG_TIMESTEP_FIXED,
1055 current = v3_length( vel ),
1056 new_vel = vg_minf( current + amt, k_max_push_speed ),
1057 delta = new_vel - vg_minf( current, k_max_push_speed );
1058
1059 vel[2] += delta * -s->state.reverse;
1060 }
1061 }
1062
1063 /* Send back to velocity */
1064 m3x3_mulv( player->rb.to_world, vel, player->rb.v );
1065
1066 /* Steering */
1067 float input = player->input_js1h->axis.value,
1068 grab = player->input_grab->axis.value,
1069 steer = input * (1.0f-(s->state.jump_charge+grab)*0.4f),
1070 steer_scaled = vg_signf(steer) * powf(steer,2.0f) * k_steer_ground;
1071
1072 v3f steer_axis;
1073 v3_muls( player->rb.to_world[1], -vg_signf( steer_scaled ), steer_axis );
1074
1075 float current = v3_dot( player->rb.to_world[1], player->rb.w ),
1076 addspeed = (steer_scaled * -1.0f) - current,
1077 maxaccel = 26.0f * k_rb_delta,
1078 accel = vg_clampf( addspeed, -maxaccel, maxaccel );
1079
1080 v3_muladds( player->rb.w, player->rb.to_world[1], accel, player->rb.w );
1081
1082
1083 #if 0
1084 player_accelerate( player->rb.w, steer_axis,
1085 fabsf(steer_scaled) * 1.0f, 30.0f );
1086
1087 //s->state.steery -= steer_scaled * k_rb_delta;
1088 #endif
1089 }
1090
1091 VG_STATIC void skate_apply_jump_model( player_instance *player )
1092 {
1093 struct player_skate *s = &player->_skate;
1094 int charging_jump_prev = s->state.charging_jump;
1095 s->state.charging_jump = player->input_jump->button.value;
1096
1097 /* Cannot charge this in air */
1098 if( s->state.activity != k_skate_activity_ground )
1099 s->state.charging_jump = 0;
1100
1101 if( s->state.charging_jump )
1102 {
1103 s->state.jump_charge += k_rb_delta * k_jump_charge_speed;
1104
1105 if( !charging_jump_prev )
1106 s->state.jump_dir = s->state.reverse>0.0f? 1: 0;
1107 }
1108 else
1109 {
1110 s->state.jump_charge -= k_jump_charge_speed * VG_TIMESTEP_FIXED;
1111 }
1112
1113 s->state.jump_charge = vg_clampf( s->state.jump_charge, 0.0f, 1.0f );
1114
1115 if( s->state.activity == k_skate_activity_air )
1116 return;
1117
1118 /* player let go after charging past 0.2: trigger jump */
1119 if( (!s->state.charging_jump) && (s->state.jump_charge > 0.2f) )
1120 {
1121 v3f jumpdir;
1122
1123 /* Launch more up if alignment is up else improve velocity */
1124 float aup = v3_dot( (v3f){0.0f,1.0f,0.0f}, player->rb.to_world[1] ),
1125 mod = 0.5f,
1126 dir = mod + fabsf(aup)*(1.0f-mod);
1127
1128 v3_copy( player->rb.v, jumpdir );
1129 v3_normalize( jumpdir );
1130 v3_muls( jumpdir, 1.0f-dir, jumpdir );
1131 v3_muladds( jumpdir, player->rb.to_world[1], dir, jumpdir );
1132 v3_normalize( jumpdir );
1133
1134 float force = k_jump_force*s->state.jump_charge;
1135 v3_muladds( player->rb.v, jumpdir, force, player->rb.v );
1136 s->state.jump_charge = 0.0f;
1137 s->state.jump_time = vg.time;
1138
1139 v2f steer = { player->input_js1h->axis.value,
1140 player->input_js1v->axis.value };
1141 v2_normalize_clamp( steer );
1142
1143 #if 0
1144 float maxspin = k_steer_air * k_rb_delta * k_spin_boost;
1145 s->state.steery_s = -steer[0] * maxspin;
1146 s->state.steerx = s->state.steerx_s;
1147 #endif
1148 s->state.lift_frames ++;
1149
1150 /* FIXME audio events */
1151 #if 0
1152 audio_lock();
1153 audio_player_set_flags( &audio_player_extra, AUDIO_FLAG_SPACIAL_3D );
1154 audio_player_set_position( &audio_player_extra, player.rb.co );
1155 audio_player_set_vol( &audio_player_extra, 20.0f );
1156 audio_player_playclip( &audio_player_extra, &audio_jumps[rand()%2] );
1157 audio_unlock();
1158 #endif
1159 }
1160 }
1161
1162 VG_STATIC void skate_apply_pump_model( player_instance *player )
1163 {
1164 struct player_skate *s = &player->_skate;
1165
1166 /* Throw / collect routine
1167 *
1168 * TODO: Max speed boost
1169 */
1170 if( player->input_grab->axis.value > 0.5f )
1171 {
1172 if( s->state.activity == k_skate_activity_ground )
1173 {
1174 /* Throw */
1175 v3_muls( player->rb.to_world[1], k_mmthrow_scale, s->state.throw_v );
1176 }
1177 }
1178 else
1179 {
1180 /* Collect */
1181 float doty = v3_dot( player->rb.to_world[1], s->state.throw_v );
1182
1183 v3f Fl, Fv;
1184 v3_muladds( s->state.throw_v, player->rb.to_world[1], -doty, Fl);
1185
1186 if( s->state.activity == k_skate_activity_ground )
1187 {
1188 v3_muladds( player->rb.v, Fl, k_mmcollect_lat, player->rb.v );
1189 v3_muladds( s->state.throw_v, Fl, -k_mmcollect_lat, s->state.throw_v );
1190 }
1191
1192 v3_muls( player->rb.to_world[1], -doty, Fv );
1193 v3_muladds( player->rb.v, Fv, k_mmcollect_vert, player->rb.v );
1194 v3_muladds( s->state.throw_v, Fv, k_mmcollect_vert, s->state.throw_v );
1195 }
1196
1197 /* Decay */
1198 if( v3_length2( s->state.throw_v ) > 0.0001f )
1199 {
1200 v3f dir;
1201 v3_copy( s->state.throw_v, dir );
1202 v3_normalize( dir );
1203
1204 float max = v3_dot( dir, s->state.throw_v ),
1205 amt = vg_minf( k_mmdecay * k_rb_delta, max );
1206 v3_muladds( s->state.throw_v, dir, -amt, s->state.throw_v );
1207 }
1208 }
1209
1210 VG_STATIC void skate_apply_cog_model( player_instance *player )
1211 {
1212 struct player_skate *s = &player->_skate;
1213
1214 v3f ideal_cog, ideal_diff, ideal_dir;
1215 v3_copy( s->state.up_dir, ideal_dir );
1216 v3_normalize( ideal_dir );
1217
1218 v3_muladds( player->rb.co, ideal_dir,
1219 1.0f-player->input_grab->axis.value, ideal_cog );
1220 v3_sub( ideal_cog, s->state.cog, ideal_diff );
1221
1222 /* Apply velocities */
1223 v3f rv;
1224 v3_sub( player->rb.v, s->state.cog_v, rv );
1225
1226 v3f F;
1227 v3_muls( ideal_diff, -k_cog_spring * k_rb_rate, F );
1228 v3_muladds( F, rv, -k_cog_damp * k_rb_rate, F );
1229
1230 float ra = k_cog_mass_ratio,
1231 rb = 1.0f-k_cog_mass_ratio;
1232
1233 /* Apply forces & intergrate */
1234 v3_muladds( s->state.cog_v, F, -rb, s->state.cog_v );
1235 s->state.cog_v[1] += -9.8f * k_rb_delta;
1236 v3_muladds( s->state.cog, s->state.cog_v, k_rb_delta, s->state.cog );
1237 }
1238
1239 VG_STATIC void skate_collision_response( player_instance *player,
1240 rb_ct *manifold, int len )
1241 {
1242 struct player_skate *s = &player->_skate;
1243
1244 for( int j=0; j<10; j++ )
1245 {
1246 for( int i=0; i<len; i++ )
1247 {
1248 struct contact *ct = &manifold[i];
1249
1250 v3f rv, delta;
1251 v3_sub( ct->co, player->rb.co, delta );
1252 v3_cross( player->rb.w, delta, rv );
1253 v3_add( player->rb.v, rv, rv );
1254
1255 v3f raCn;
1256 v3_cross( delta, ct->n, raCn );
1257
1258 float normal_mass = 1.0f / (1.0f + v3_dot(raCn,raCn));
1259 float vn = v3_dot( rv, ct->n );
1260 float lambda = normal_mass * ( -vn + ct->bias );
1261
1262 float temp = ct->norm_impulse;
1263 ct->norm_impulse = vg_maxf( temp + lambda, 0.0f );
1264 lambda = ct->norm_impulse - temp;
1265
1266 v3f impulse;
1267 v3_muls( ct->n, lambda, impulse );
1268
1269 if( fabsf(v3_dot( impulse, player->rb.to_world[2] )) > 10.0f ||
1270 fabsf(v3_dot( impulse, player->rb.to_world[1] )) > 50.0f )
1271 {
1272 player__dead_transition( player );
1273 return;
1274 }
1275
1276 v3_add( impulse, player->rb.v, player->rb.v );
1277 v3_cross( delta, impulse, impulse );
1278
1279 /*
1280 * W Impulses are limited to the Y and X axises, we don't really want
1281 * roll angular velocities being included.
1282 *
1283 * Can also tweak the resistance of each axis here by scaling the wx,wy
1284 * components.
1285 */
1286
1287 float wy = v3_dot( player->rb.to_world[1], impulse ) * 1.0f,
1288 wx = v3_dot( player->rb.to_world[0], impulse ) * 1.0f,
1289 wz = v3_dot( player->rb.to_world[2], impulse ) * 1.0f;
1290
1291 v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
1292 v3_muladds( player->rb.w, player->rb.to_world[0], wx, player->rb.w );
1293 v3_muladds( player->rb.w, player->rb.to_world[2], wz, player->rb.w );
1294
1295
1296 v3_cross( player->rb.w, delta, rv );
1297 v3_add( player->rb.v, rv, rv );
1298 vn = v3_dot( rv, ct->n );
1299 }
1300 }
1301 }
1302
1303 VG_STATIC void skate_integrate( player_instance *player )
1304 {
1305 struct player_skate *s = &player->_skate;
1306
1307 /* integrate rigidbody velocities */
1308 #ifndef SKATE_CCD
1309 v3f gravity = { 0.0f, -9.6f, 0.0f };
1310 v3_muladds( player->rb.v, gravity, k_rb_delta, player->rb.v );
1311 v3_muladds( player->rb.co, player->rb.v, k_rb_delta, player->rb.co );
1312 #endif
1313
1314 float decay_rate = 1.0f - (k_rb_delta * 3.0f);
1315
1316 #if 0
1317 if( s->state.activity == k_skate_activity_air )
1318 {
1319 float dist = 1.0f-(s->land_dist/4.0f);
1320 decay_rate = 0.5f * vg_maxf( dist*dist, 0.0f );
1321 }
1322 #endif
1323
1324 float wx = v3_dot( player->rb.w, player->rb.to_world[0] ) * decay_rate,
1325 wy = v3_dot( player->rb.w, player->rb.to_world[1] ),
1326 wz = v3_dot( player->rb.w, player->rb.to_world[2] ) * decay_rate;
1327
1328 v3_muls( player->rb.to_world[0], wx, player->rb.w );
1329 v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
1330 v3_muladds( player->rb.w, player->rb.to_world[2], wz, player->rb.w );
1331
1332 #ifndef SKATE_CCD
1333 if( v3_length2( player->rb.w ) > 0.0f )
1334 {
1335 v4f rotation;
1336 v3f axis;
1337 v3_copy( player->rb.w, axis );
1338
1339 float mag = v3_length( axis );
1340 v3_divs( axis, mag, axis );
1341 q_axis_angle( rotation, axis, mag*k_rb_delta );
1342 q_mul( rotation, player->rb.q, player->rb.q );
1343 }
1344 #endif
1345
1346 /* integrate steering velocities */
1347 #if 0
1348 v4f rotate;
1349 float l = (s->state.activity == k_skate_activity_air)? 0.04f: 0.24f;
1350
1351 s->state.steery_s = vg_lerpf( s->state.steery_s, s->state.steery, l );
1352 s->state.steerx_s = vg_lerpf( s->state.steerx_s, s->state.steerx, l );
1353
1354 q_axis_angle( rotate, player->rb.to_world[1], s->state.steery_s );
1355 q_mul( rotate, player->rb.q, player->rb.q );
1356
1357 q_axis_angle( rotate, player->rb.to_world[0], s->state.steerx_s );
1358 q_mul( rotate, player->rb.q, player->rb.q );
1359
1360 s->state.steerx = 0.0f;
1361 s->state.steery = 0.0f;
1362 #endif
1363
1364 s->state.flip_time += s->state.flip_rate * k_rb_delta;
1365 rb_update_transform( &player->rb );
1366 }
1367
1368 /*
1369 * 1 2 or 3
1370 */
1371
1372 VG_STATIC int player_skate_trick_input( player_instance *player )
1373 {
1374 return (player->input_trick0->button.value) |
1375 (player->input_trick1->button.value << 1) |
1376 (player->input_trick2->button.value << 1) |
1377 (player->input_trick2->button.value);
1378 }
1379
1380 VG_STATIC void player__skate_pre_update( player_instance *player )
1381 {
1382 struct player_skate *s = &player->_skate;
1383
1384 if( vg_input_button_down( player->input_use ) )
1385 {
1386 player->subsystem = k_player_subsystem_walk;
1387
1388 v3f angles;
1389 v3_copy( player->cam.angles, angles );
1390 angles[2] = 0.0f;
1391
1392 player__walk_transition( player, angles );
1393 return;
1394 }
1395
1396 if( vg_input_button_down( player->input_reset ) )
1397 {
1398 player->rb.co[1] += 2.0f;
1399 s->state.cog[1] += 2.0f;
1400 q_axis_angle( player->rb.q, (v3f){1.0f,0.0f,0.0f}, VG_PIf * 0.25f );
1401 v3_zero( player->rb.w );
1402 v3_zero( player->rb.v );
1403
1404 rb_update_transform( &player->rb );
1405 }
1406
1407 int trick_id;
1408 if( (s->state.lift_frames > 0) &&
1409 (trick_id = player_skate_trick_input( player )) )
1410 {
1411 if( (vg.time - s->state.jump_time) < 0.1f )
1412 {
1413 v3_zero( s->state.trick_vel );
1414 s->state.trick_time = 0.0f;
1415
1416 if( trick_id == 1 )
1417 {
1418 s->state.trick_vel[0] = 3.0f;
1419 }
1420 else if( trick_id == 2 )
1421 {
1422 s->state.trick_vel[2] = 3.0f;
1423 }
1424 else if( trick_id == 3 )
1425 {
1426 s->state.trick_vel[0] = 2.0f;
1427 s->state.trick_vel[2] = 2.0f;
1428 }
1429 }
1430 }
1431 }
1432
1433 VG_STATIC void player__skate_post_update( player_instance *player )
1434 {
1435 struct player_skate *s = &player->_skate;
1436 for( int i=0; i<s->prediction_count; i++ )
1437 {
1438 struct land_prediction *p = &s->predictions[i];
1439
1440 for( int j=0; j<p->log_length - 1; j ++ )
1441 vg_line( p->log[j], p->log[j+1], p->colour );
1442
1443 vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
1444
1445 v3f p1;
1446 v3_add( p->log[p->log_length-1], p->n, p1 );
1447 vg_line( p->log[p->log_length-1], p1, 0xffffffff );
1448
1449 vg_line_pt3( p->apex, 0.02f, 0xffffffff );
1450 }
1451
1452 vg_line_pt3( s->state.apex, 0.200f, 0xff0000ff );
1453 vg_line_pt3( s->state.apex, 0.201f, 0xff00ffff );
1454 }
1455
1456 VG_STATIC void player__skate_update( player_instance *player )
1457 {
1458 struct player_skate *s = &player->_skate;
1459 v3_copy( player->rb.co, s->state.prev_pos );
1460 s->state.activity_prev = s->state.activity;
1461
1462 struct board_collider
1463 {
1464 v3f pos;
1465 float radius;
1466
1467 int apply_angular;
1468 u32 colour;
1469
1470 enum board_collider_state
1471 {
1472 k_collider_state_default,
1473 k_collider_state_disabled,
1474 k_collider_state_colliding
1475 }
1476 state;
1477 }
1478 wheels[] =
1479 {
1480 {
1481 { 0.0f, 0.0f, -k_board_length },
1482 .radius = 0.07f,
1483 .apply_angular = 1,
1484 .colour = VG__RED
1485 },
1486 {
1487 { 0.0f, 0.0f, k_board_length },
1488 .radius = 0.07f,
1489 .apply_angular = 1,
1490 .colour = VG__GREEN
1491 },
1492 {
1493 { 0.0f, 0.2f, -k_board_length - k_board_end_radius },
1494 .radius = k_board_end_radius,
1495 .apply_angular = 0,
1496 .colour = VG__YELOW
1497 },
1498 {
1499 { 0.0f, 0.2f, k_board_length + k_board_end_radius },
1500 .radius = k_board_end_radius,
1501 .apply_angular = 0,
1502 .colour = VG__YELOW
1503 },
1504 };
1505
1506 const int k_wheel_count = 2;
1507 #if 0
1508 if( skate_grind_scansq( player, (v3f){ 0.0f, 0.0f, -k_board_length } ) )
1509 {
1510 #if 0
1511 wheel_states[0] = 0;
1512 wheel_states[1] = 0;
1513 #endif
1514 }
1515
1516 if( skate_grind_scansq( player, (v3f){ 0.0f, 0.0f, k_board_length } ) )
1517 {
1518 #if 0
1519 wheel_states[2] = 0;
1520 wheel_states[3] = 0;
1521 #endif
1522 }
1523 #endif
1524
1525 s->substep = k_rb_delta;
1526 s->substep_delta = s->substep;
1527 int substep_count = 0;
1528
1529
1530
1531
1532
1533 /*
1534 * Phase 2: Truck alignment (spring/dampener model)
1535 * it uses the first two colliders as truck positions
1536 * --------------------------------------------------------------------------
1537 */
1538
1539 v3f surface_picture;
1540 v3_zero( surface_picture );
1541
1542 for( int i=0; i<2; i++ )
1543 {
1544 if( wheels[i].state == k_collider_state_disabled )
1545 continue;
1546
1547 v3f truck, left, right;
1548 m4x3_mulv( player->rb.to_world, wheels[i].pos, truck );
1549 v3_muladds( truck, player->rb.to_world[0], -k_board_width, left );
1550 v3_muladds( truck, player->rb.to_world[0], k_board_width, right );
1551
1552 vg_line( left, right, wheels[i].colour );
1553
1554 v3_muladds( left, player->rb.to_world[1], 0.1f, left );
1555 v3_muladds( right, player->rb.to_world[1], 0.1f, right );
1556
1557 float k_max_truck_flex = VG_PIf * 0.25f;
1558
1559 ray_hit ray_l, ray_r;
1560 ray_l.dist = 0.2f;
1561 ray_r.dist = 0.2f;
1562
1563 v3f dir;
1564 v3_muls( player->rb.to_world[1], -1.0f, dir );
1565
1566 int res_l = ray_world( left, dir, &ray_l ),
1567 res_r = ray_world( right, dir, &ray_r );
1568
1569 /* ignore bad normals */
1570 if( res_l )
1571 {
1572 if( v3_dot( ray_l.normal, player->rb.to_world[1] ) < 0.7071f )
1573 res_l = 0;
1574 else
1575 v3_add( ray_l.normal, surface_picture, surface_picture );
1576 }
1577
1578 if( res_r )
1579 {
1580 if( v3_dot( ray_r.normal, player->rb.to_world[1] ) < 0.7071f )
1581 res_r = 0;
1582 else
1583 v3_add( ray_r.normal, surface_picture, surface_picture );
1584 }
1585
1586 v3f v0;
1587 v3f midpoint;
1588 v3_muladds( truck, player->rb.to_world[1], -wheels[i].radius, midpoint );
1589
1590 if( res_l || res_r )
1591 {
1592 v3f p0, p1;
1593 v3_copy( midpoint, p0 );
1594 v3_copy( midpoint, p1 );
1595
1596 if( res_l ) v3_copy( ray_l.pos, p0 );
1597 if( res_r ) v3_copy( ray_r.pos, p1 );
1598
1599 v3_sub( p1, p0, v0 );
1600 v3_normalize( v0 );
1601 }
1602 else
1603 {
1604 /* fallback: use the closes point to the trucks */
1605 v3f closest;
1606 int idx = bh_closest_point( world.geo_bh, midpoint, closest, 0.1f );
1607
1608 if( idx != -1 )
1609 {
1610 u32 *tri = &world.scene_geo->arrindices[ idx * 3 ];
1611 v3f verts[3];
1612
1613 for( int j=0; j<3; j++ )
1614 v3_copy( world.scene_geo->arrvertices[ tri[j] ].co, verts[j] );
1615
1616 v3f vert0, vert1, n;
1617 v3_sub( verts[1], verts[0], vert0 );
1618 v3_sub( verts[2], verts[0], vert1 );
1619 v3_cross( vert0, vert1, n );
1620 v3_normalize( n );
1621
1622 if( v3_dot( n, player->rb.to_world[1] ) < 0.3f )
1623 continue;
1624
1625 v3_cross( n, player->rb.to_world[2], v0 );
1626 v3_muladds( v0, player->rb.to_world[2],
1627 -v3_dot( player->rb.to_world[2], v0 ), v0 );
1628 v3_normalize( v0 );
1629 }
1630 else
1631 continue;
1632 }
1633
1634 v3_muladds( truck, v0, k_board_width, right );
1635 v3_muladds( truck, v0, -k_board_width, left );
1636
1637 vg_line( left, right, VG__WHITE );
1638
1639 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[0], v0,
1640 k_board_spring, k_board_dampener,
1641 s->substep_delta );
1642 }
1643
1644 /*
1645 * Phase 2a: Manual alignment (spring/dampener model)
1646 * --------------------------------------------------------------------------
1647 */
1648
1649 v3f weight, world_cog;
1650 v3_zero( weight );
1651
1652 int reverse_dir = v3_dot( player->rb.to_world[2], player->rb.v ) < 0.0f?1:-1;
1653
1654 if( s->state.manual_direction == 0 )
1655 {
1656 if( (player->input_js1v->axis.value > 0.7f) &&
1657 (s->state.activity == k_skate_activity_ground) &&
1658 (s->state.jump_charge <= 0.01f) )
1659 s->state.manual_direction = reverse_dir;
1660 }
1661 else
1662 {
1663 if( player->input_js1v->axis.value < 0.1f )
1664 {
1665 s->state.manual_direction = 0;
1666 }
1667 else
1668 {
1669 if( reverse_dir != s->state.manual_direction )
1670 {
1671 player__dead_transition( player );
1672 return;
1673 }
1674 }
1675 }
1676
1677 if( s->state.manual_direction )
1678 {
1679 float amt = vg_minf( player->input_js1v->axis.value * 8.0f, 1.0f );
1680 weight[2] = k_board_length * amt * (float)s->state.manual_direction;
1681 }
1682
1683 if( v3_length2( surface_picture ) > 0.001f )
1684 {
1685 v3_normalize( surface_picture );
1686
1687 v3f target;
1688 v3_copy( surface_picture, target );
1689
1690 target[1] += 2.0f * surface_picture[1];
1691 v3_normalize( target );
1692
1693 v3_lerp( s->state.up_dir, target,
1694 8.0f * s->substep_delta, s->state.up_dir );
1695 }
1696 else
1697 {
1698 v3_lerp( s->state.up_dir, player->rb.to_world[1],
1699 8.0f * s->substep_delta, s->state.up_dir );
1700 }
1701
1702
1703 /* TODO: Fall back on land normal */
1704 /* TODO: Lerp weight distribution */
1705 /* TODO: Can start manual only if not charge jump */
1706 if( v3_length2( surface_picture ) > 0.001f &&
1707 v3_length2( weight ) > 0.001f &&
1708 s->state.manual_direction )
1709 {
1710 v3f plane_z;
1711
1712 m3x3_mulv( player->rb.to_world, weight, plane_z );
1713 v3_negate( plane_z, plane_z );
1714
1715 v3_muladds( plane_z, surface_picture,
1716 -v3_dot( plane_z, surface_picture ), plane_z );
1717 v3_normalize( plane_z );
1718
1719 v3_muladds( plane_z, surface_picture, 0.3f, plane_z );
1720 v3_normalize( plane_z );
1721
1722 v3f p1;
1723 v3_muladds( player->rb.co, plane_z, 1.5f, p1 );
1724 vg_line( player->rb.co, p1, VG__GREEN );
1725
1726 v3f refdir;
1727 v3_muls( player->rb.to_world[2], -(float)s->state.manual_direction,
1728 refdir );
1729
1730 rb_effect_spring_target_vector( &player->rb, refdir, plane_z,
1731 k_manul_spring, k_manul_dampener,
1732 s->substep_delta );
1733 }
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743 begin_collision:;
1744
1745 /*
1746 * Phase 0: Continous collision detection
1747 * --------------------------------------------------------------------------
1748 */
1749
1750 v3f head_wp0, head_wp1, start_co;
1751 m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp0 );
1752 v3_copy( player->rb.co, start_co );
1753
1754 for( int i=0; i<k_wheel_count; i++ )
1755 wheels[i].state = k_collider_state_default;
1756
1757 /* calculate transform one step into future */
1758 v3f future_co;
1759 v4f future_q;
1760 v3_muladds( player->rb.co, player->rb.v, s->substep, future_co );
1761
1762 if( v3_length2( player->rb.w ) > 0.0f )
1763 {
1764 v4f rotation;
1765 v3f axis;
1766 v3_copy( player->rb.w, axis );
1767
1768 float mag = v3_length( axis );
1769 v3_divs( axis, mag, axis );
1770 q_axis_angle( rotation, axis, mag*s->substep );
1771 q_mul( rotation, player->rb.q, future_q );
1772 q_normalize( future_q );
1773 }
1774
1775 /* calculate the minimum time we can move */
1776 float max_time = s->substep;
1777
1778 for( int i=0; i<k_wheel_count; i++ )
1779 {
1780 if( wheels[i].state == k_collider_state_disabled )
1781 continue;
1782
1783 v3f current, future;
1784 q_mulv( future_q, wheels[i].pos, future );
1785 v3_add( future, future_co, future );
1786
1787 q_mulv( player->rb.q, wheels[i].pos, current );
1788 v3_add( current, player->rb.co, current );
1789
1790 float t;
1791 v3f n;
1792
1793 float cast_radius = wheels[i].radius - k_penetration_slop * 1.2f;
1794 if( spherecast_world( current, future, cast_radius, &t, n ) != -1)
1795 max_time = vg_minf( max_time, t * s->substep );
1796 }
1797
1798 /* clamp to a fraction of delta, to prevent locking */
1799 float rate_lock = substep_count;
1800 rate_lock *= k_rb_delta * 0.1f;
1801 rate_lock *= rate_lock;
1802
1803 max_time = vg_maxf( max_time, rate_lock );
1804 s->substep_delta = max_time;
1805
1806 /* integrate */
1807 v3_muladds( player->rb.co, player->rb.v, s->substep_delta, player->rb.co );
1808 if( v3_length2( player->rb.w ) > 0.0f )
1809 {
1810 v4f rotation;
1811 v3f axis;
1812 v3_copy( player->rb.w, axis );
1813
1814 float mag = v3_length( axis );
1815 v3_divs( axis, mag, axis );
1816 q_axis_angle( rotation, axis, mag*s->substep_delta );
1817 q_mul( rotation, player->rb.q, player->rb.q );
1818 }
1819
1820 rb_update_transform( &player->rb );
1821
1822 v3f gravity = { 0.0f, -9.6f, 0.0f };
1823 v3_muladds( player->rb.v, gravity, s->substep_delta, player->rb.v );
1824
1825 s->substep -= s->substep_delta;
1826
1827
1828 rb_ct manifold[128];
1829 int manifold_len = 0;
1830
1831 /*
1832 * Phase -1: head detection
1833 * --------------------------------------------------------------------------
1834 */
1835 m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp1 );
1836 vg_line( head_wp0, head_wp1, VG__RED );
1837
1838 float t;
1839 v3f n;
1840 if( (v3_dist2( head_wp0, head_wp1 ) > 0.001f) &&
1841 (spherecast_world( head_wp0, head_wp1, 0.2f, &t, n ) != -1) )
1842 {
1843 v3_lerp( start_co, player->rb.co, t, player->rb.co );
1844 rb_update_transform( &player->rb );
1845
1846 #if 0
1847 player__dead_transition( player );
1848 #endif
1849 return;
1850 }
1851
1852 /*
1853 * Phase 2-1+0.5: Grind collision
1854 * --------------------------------------------------------------------------
1855 */
1856
1857 for( int i=0; i<1; i++ )
1858 {
1859
1860 /*
1861 * Grind collision detection
1862 * ------------------------------------------------
1863 */
1864 v3f grind_co, grind_n, grind_dir;
1865 if( skate_grind_scansq( player, player->rb.co,
1866 grind_co, grind_dir, grind_n ) )
1867 {
1868 #if 0
1869 rb_ct *ct = &manifold[ manifold_len ++ ];
1870
1871 v3_copy( truck, ct->co );
1872 v3_copy( grind_n, ct->n );
1873 ct->p = vg_maxf( 0.0f, ct->co[1] - truck[1] );
1874 #endif
1875
1876 v3f target_dir;
1877 v3_cross( grind_dir, (v3f){0.0f,1.0f,0.0f}, target_dir );
1878 target_dir[1] = 0.0f;
1879
1880 if( v3_length2( target_dir ) <= 0.001f )
1881 continue;
1882
1883 if( fabsf(v3_dot( player->rb.v, grind_dir )) < 0.7071f )
1884 continue;
1885
1886 v3_copy( grind_co, player->rb.co );
1887
1888 q_axis_angle( player->rb.q, (v3f){0.0f,1.0f,0.0f},
1889 -atan2f( target_dir[2], target_dir[0] ) );
1890
1891 wheels[0].state = k_collider_state_disabled;
1892 wheels[1].state = k_collider_state_disabled;
1893 v3_muls( grind_dir, v3_dot(player->rb.v,grind_dir), player->rb.v );
1894 v3_zero( player->rb.w );
1895
1896 rb_update_transform( &player->rb );
1897
1898
1899 #if 0
1900 v3f displacement, dir;
1901 v3_sub( truck, grind_co, displacement );
1902 v3_copy( displacement, dir );
1903 v3_normalize( dir );
1904
1905 v3f rv, raW;
1906 q_mulv( player->rb.q, wheels[i].pos, raW );
1907
1908 v3_cross( player->rb.w, raW, rv );
1909 v3_add( player->rb.v, rv, rv );
1910
1911 v3_muladds( rv, player->rb.to_world[2],
1912 -v3_dot( rv, player->rb.to_world[2] ), rv );
1913
1914 v3f Fd, Fs, F;
1915 v3_muls( displacement, -k_grind_spring, Fs );
1916 v3_muls( rv, -k_grind_dampener, Fd );
1917
1918 v3_add( Fd, Fs, F );
1919 v3_muls( F, s->substep_delta, F );
1920
1921 v3_add( player->rb.v, F, player->rb.v );
1922 v3f wa;
1923 v3_cross( raW, F, wa );
1924 v3_add( player->rb.w, wa, player->rb.w );
1925
1926 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[1],
1927 grind_n,
1928 k_board_spring, k_board_dampener,
1929 s->substep_delta );
1930
1931 v3f adj;
1932 v3_cross( grind_dir, (v3f){0.0f,1.0f,0.0f}, adj );
1933 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[2],
1934 adj,
1935 k_grind_spring, k_grind_dampener,
1936 s->substep_delta );
1937 #endif
1938
1939 s->state.activity = k_skate_activity_grind;
1940 }
1941 else
1942 s->state.activity = k_skate_activity_ground;
1943 }
1944
1945
1946 /*
1947 * Phase 1: Regular collision detection
1948 * TODO: Me might want to automatically add contacts from CCD,
1949 * since at high angular velocities, theres a small change
1950 * that discreet detection will miss.
1951 * --------------------------------------------------------------------------
1952 */
1953
1954 for( int i=0; i<k_wheel_count; i++ )
1955 {
1956 if( wheels[i].state == k_collider_state_disabled )
1957 continue;
1958
1959 m4x3f mtx;
1960 m3x3_identity( mtx );
1961 m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
1962
1963 rb_sphere collider = { .radius = wheels[i].radius };
1964
1965 rb_ct *man = &manifold[ manifold_len ];
1966
1967 int l = skate_collide_smooth( player, mtx, &collider, man );
1968 if( l )
1969 wheels[i].state = k_collider_state_colliding;
1970
1971 /* for non-angular contacts we just want Y. contact positions are
1972 * snapped to the local xz plane */
1973 if( !wheels[i].apply_angular )
1974 {
1975 for( int j=0; j<l; j++ )
1976 {
1977 v3f ra;
1978 v3_sub( man[j].co, player->rb.co, ra );
1979
1980 float dy = v3_dot( player->rb.to_world[1], ra );
1981 v3_muladds( man[j].co, player->rb.to_world[1], -dy, man[j].co );
1982 }
1983 }
1984
1985 manifold_len += l;
1986 }
1987
1988 /*
1989 * Phase 3: Dynamics
1990 * --------------------------------------------------------------------------
1991 */
1992
1993 for( int i=0; i<manifold_len; i ++ )
1994 {
1995 rb_prepare_contact( &manifold[i], s->substep_delta );
1996 rb_debug_contact( &manifold[i] );
1997 }
1998
1999 /* yes, we are currently rebuilding mass matrices every frame. too bad! */
2000 v3f extent = { k_board_width, 0.1f, k_board_length };
2001 float ex2 = k_board_interia*extent[0]*extent[0],
2002 ey2 = k_board_interia*extent[1]*extent[1],
2003 ez2 = k_board_interia*extent[2]*extent[2];
2004
2005 float mass = 2.0f * (extent[0]*extent[1]*extent[2]);
2006 float inv_mass = 1.0f/mass;
2007
2008 v3f I;
2009 I[0] = ((1.0f/12.0f) * mass * (ey2+ez2));
2010 I[1] = ((1.0f/12.0f) * mass * (ex2+ez2));
2011 I[2] = ((1.0f/12.0f) * mass * (ex2+ey2));
2012
2013 m3x3f iI;
2014 m3x3_identity( iI );
2015 iI[0][0] = I[0];
2016 iI[1][1] = I[1];
2017 iI[2][2] = I[2];
2018 m3x3_inv( iI, iI );
2019
2020 m3x3f iIw;
2021 m3x3_mul( iI, player->rb.to_local, iIw );
2022 m3x3_mul( player->rb.to_world, iIw, iIw );
2023
2024 m4x3_mulv( player->rb.to_world, weight, world_cog );
2025 vg_line_pt3( world_cog, 0.1f, VG__BLACK );
2026
2027 for( int j=0; j<10; j++ )
2028 {
2029 for( int i=0; i<manifold_len; i++ )
2030 {
2031 /*
2032 * regular dance; calculate velocity & total mass, apply impulse.
2033 */
2034
2035 struct contact *ct = &manifold[i];
2036
2037 v3f rv, delta;
2038 v3_sub( ct->co, world_cog, delta );
2039 v3_cross( player->rb.w, delta, rv );
2040 v3_add( player->rb.v, rv, rv );
2041
2042 v3f raCn;
2043 v3_cross( delta, ct->n, raCn );
2044
2045 v3f raCnI, rbCnI;
2046 m3x3_mulv( iIw, raCn, raCnI );
2047
2048 float normal_mass = 1.0f / (inv_mass + v3_dot(raCn,raCnI)),
2049 vn = v3_dot( rv, ct->n ),
2050 lambda = normal_mass * ( -vn );
2051
2052 /* FIXME! */
2053 v3_muladds( player->rb.co, ct->n, ct->bias*0.02f, player->rb.co );
2054
2055 float temp = ct->norm_impulse;
2056 ct->norm_impulse = vg_maxf( temp + lambda, 0.0f );
2057 lambda = ct->norm_impulse - temp;
2058
2059 v3f impulse;
2060 v3_muls( ct->n, lambda, impulse );
2061
2062 v3_muladds( player->rb.v, impulse, inv_mass, player->rb.v );
2063 v3_cross( delta, impulse, impulse );
2064 m3x3_mulv( iIw, impulse, impulse );
2065 v3_add( impulse, player->rb.w, player->rb.w );
2066
2067 v3_cross( player->rb.w, delta, rv );
2068 v3_add( player->rb.v, rv, rv );
2069 vn = v3_dot( rv, ct->n );
2070 }
2071 }
2072
2073 substep_count ++;
2074
2075 if( s->substep >= 0.0001f )
2076 goto begin_collision; /* again! */
2077
2078 /*
2079 * End of collision and dynamics routine
2080 * --------------------------------------------------------------------------
2081 */
2082
2083 for( int i=0; i<k_wheel_count; i++ )
2084 {
2085 m4x3f mtx;
2086 m3x3_copy( player->rb.to_world, mtx );
2087 m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
2088 debug_sphere( mtx, wheels[i].radius,
2089 (u32[]){ VG__WHITE, VG__BLACK,
2090 wheels[i].colour }[ wheels[i].state ]);
2091 }
2092
2093 #if 0
2094 skate_apply_grind_model( player, &manifold[manifold_len], grind_len );
2095 #endif
2096
2097 skate_apply_interface_model( player, manifold, manifold_len );
2098
2099 skate_apply_pump_model( player );
2100 skate_apply_cog_model( player );
2101
2102 skate_apply_grab_model( player );
2103 skate_apply_friction_model( player );
2104 skate_apply_jump_model( player );
2105 skate_apply_air_model( player );
2106 skate_apply_trick_model( player );
2107
2108 skate_integrate( player );
2109
2110 vg_line_pt3( s->state.cog, 0.1f, VG__WHITE );
2111 vg_line_pt3( s->state.cog, 0.11f, VG__WHITE );
2112 vg_line_pt3( s->state.cog, 0.12f, VG__WHITE );
2113 vg_line_pt3( s->state.cog, 0.13f, VG__WHITE );
2114 vg_line_pt3( s->state.cog, 0.14f, VG__WHITE );
2115
2116 vg_line( player->rb.co, s->state.cog, VG__RED );
2117
2118 teleport_gate *gate;
2119 if( (gate = world_intersect_gates( player->rb.co, s->state.prev_pos )) )
2120 {
2121 m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
2122 m3x3_mulv( gate->transport, player->rb.v, player->rb.v );
2123 m4x3_mulv( gate->transport, s->state.cog, s->state.cog );
2124 m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
2125 m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
2126 m3x3_mulv( gate->transport, s->state.head_position,
2127 s->state.head_position );
2128
2129 v4f transport_rotation;
2130 m3x3_q( gate->transport, transport_rotation );
2131 q_mul( transport_rotation, player->rb.q, player->rb.q );
2132 rb_update_transform( &player->rb );
2133
2134 s->state_gate_storage = s->state;
2135 player__pass_gate( player, gate );
2136 }
2137 }
2138
2139 VG_STATIC void player__skate_im_gui( player_instance *player )
2140 {
2141 struct player_skate *s = &player->_skate;
2142
2143 /* FIXME: Compression */
2144 player__debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
2145 player->rb.v[1],
2146 player->rb.v[2] );
2147 player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
2148 player->rb.co[1],
2149 player->rb.co[2] );
2150 player__debugtext( 1, "W: %5.2f %5.2f %5.2f",player->rb.w[0],
2151 player->rb.w[1],
2152 player->rb.w[2] );
2153
2154 player__debugtext( 1, "activity: %s",
2155 (const char *[]){ "k_skate_activity_air",
2156 "k_skate_activity_ground",
2157 "k_skate_activity_grind }" }
2158 [s->state.activity] );
2159 #if 0
2160 player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
2161 s->state.steerx_s, s->state.steery_s,
2162 k_steer_ground, k_steer_air );
2163 #endif
2164 player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate,
2165 s->state.flip_time );
2166 player__debugtext( 1, "trickv: %.2f %.2f %.2f",
2167 s->state.trick_vel[0],
2168 s->state.trick_vel[1],
2169 s->state.trick_vel[2] );
2170 player__debugtext( 1, "tricke: %.2f %.2f %.2f",
2171 s->state.trick_euler[0],
2172 s->state.trick_euler[1],
2173 s->state.trick_euler[2] );
2174 }
2175
2176 VG_STATIC void player__skate_animate( player_instance *player,
2177 player_animation *dest )
2178 {
2179 struct player_skate *s = &player->_skate;
2180 struct player_avatar *av = player->playeravatar;
2181 struct skeleton *sk = &av->sk;
2182
2183 /* Head */
2184 float kheight = 2.0f,
2185 kleg = 0.6f;
2186
2187 v3f offset;
2188 v3_zero( offset );
2189
2190 v3f cog_local, cog_ideal;
2191 m4x3_mulv( player->rb.to_local, s->state.cog, cog_local );
2192
2193 v3_copy( s->state.up_dir, cog_ideal );
2194 v3_normalize( cog_ideal );
2195 m3x3_mulv( player->rb.to_local, cog_ideal, cog_ideal );
2196
2197 v3_sub( cog_ideal, cog_local, offset );
2198
2199
2200 v3_muls( offset, 4.0f, offset );
2201 offset[1] *= -1.0f;
2202
2203 float curspeed = v3_length( player->rb.v ),
2204 kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
2205 kicks = (vg_randf()-0.5f)*2.0f*kickspeed,
2206 sign = vg_signf( kicks );
2207
2208 s->wobble[0] = vg_lerpf( s->wobble[0], kicks*kicks*sign, 6.0f*vg.time_delta);
2209 s->wobble[1] = vg_lerpf( s->wobble[1], s->wobble[0], 2.4f*vg.time_delta);
2210
2211 offset[0] *= 0.26f;
2212 offset[0] += s->wobble[1]*3.0f;
2213
2214 offset[1] *= -0.3f;
2215 offset[2] *= 0.01f;
2216
2217 offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(s->blend_slide)*0.9f);
2218 offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
2219
2220 /*
2221 * Animation blending
2222 * ===========================================
2223 */
2224
2225 /* sliding */
2226 {
2227 float desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
2228 s->blend_slide = vg_lerpf( s->blend_slide, desired, 2.4f*vg.time_delta);
2229 }
2230
2231 /* movement information */
2232 {
2233 int iair = (s->state.activity == k_skate_activity_air) ||
2234 (s->state.activity == k_skate_activity_grind );
2235
2236 float dirz = s->state.reverse > 0.0f? 0.0f: 1.0f,
2237 dirx = s->state.slip < 0.0f? 0.0f: 1.0f,
2238 fly = iair? 1.0f: 0.0f;
2239
2240 s->blend_z = vg_lerpf( s->blend_z, dirz, 2.4f*vg.time_delta );
2241 s->blend_x = vg_lerpf( s->blend_x, dirx, 0.6f*vg.time_delta );
2242 s->blend_fly = vg_lerpf( s->blend_fly, fly, 2.4f*vg.time_delta );
2243 }
2244
2245 mdl_keyframe apose[32], bpose[32];
2246 mdl_keyframe ground_pose[32];
2247 {
2248 /* when the player is moving fast he will crouch down a little bit */
2249 float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
2250 s->blend_stand = vg_lerpf( s->blend_stand, stand, 6.0f*vg.time_delta );
2251
2252 /* stand/crouch */
2253 float dir_frame = s->blend_z * (15.0f/30.0f),
2254 stand_blend = offset[1]*-2.0f;
2255
2256 v3f local_cog;
2257 m4x3_mulv( player->rb.to_local, s->state.cog, local_cog );
2258
2259 stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 );
2260
2261 skeleton_sample_anim( sk, s->anim_stand, dir_frame, apose );
2262 skeleton_sample_anim( sk, s->anim_highg, dir_frame, bpose );
2263 skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
2264
2265 /* sliding */
2266 float slide_frame = s->blend_x * (15.0f/30.0f);
2267 skeleton_sample_anim( sk, s->anim_slide, slide_frame, bpose );
2268 skeleton_lerp_pose( sk, apose, bpose, s->blend_slide, apose );
2269
2270 /* pushing */
2271 double push_time = vg.time - s->state.start_push;
2272 s->blend_push = vg_lerpf( s->blend_push,
2273 (vg.time - s->state.cur_push) < 0.125,
2274 6.0f*vg.time_delta );
2275
2276 float pt = push_time + vg.accumulator;
2277 if( s->state.reverse > 0.0f )
2278 skeleton_sample_anim( sk, s->anim_push, pt, bpose );
2279 else
2280 skeleton_sample_anim( sk, s->anim_push_reverse, pt, bpose );
2281
2282 skeleton_lerp_pose( sk, apose, bpose, s->blend_push, apose );
2283
2284 /* trick setup */
2285 float jump_start_frame = 14.0f/30.0f;
2286
2287 float charge = s->state.jump_charge;
2288 s->blend_jump = vg_lerpf( s->blend_jump, charge, 8.4f*vg.time_delta );
2289
2290 float setup_frame = charge * jump_start_frame,
2291 setup_blend = vg_minf( s->blend_jump, 1.0f );
2292
2293 float jump_frame = (vg.time - s->state.jump_time) + jump_start_frame;
2294 if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
2295 setup_frame = jump_frame;
2296
2297 struct skeleton_anim *jump_anim = s->state.jump_dir?
2298 s->anim_ollie:
2299 s->anim_ollie_reverse;
2300
2301 skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose );
2302 skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
2303 }
2304
2305 mdl_keyframe air_pose[32];
2306 {
2307 float target = -player->input_js1h->axis.value;
2308 s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
2309
2310 float air_frame = (s->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
2311 skeleton_sample_anim( sk, s->anim_air, air_frame, apose );
2312
2313 static v2f grab_choice;
2314
2315 v2f grab_input = { player->input_js2h->axis.value,
2316 player->input_js2v->axis.value };
2317 v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
2318 if( v2_length2( grab_input ) <= 0.001f )
2319 grab_input[0] = -1.0f;
2320 else
2321 v2_normalize_clamp( grab_input );
2322 v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
2323
2324 float ang = atan2f( grab_choice[0], grab_choice[1] ),
2325 ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
2326 grab_frame = ang_unit * (15.0f/30.0f);
2327
2328 skeleton_sample_anim( sk, s->anim_grabs, grab_frame, bpose );
2329 skeleton_lerp_pose( sk, apose, bpose, s->state.grabbing, air_pose );
2330 }
2331
2332 skeleton_lerp_pose( sk, ground_pose, air_pose, s->blend_fly, dest->pose );
2333
2334 float add_grab_mod = 1.0f - s->blend_fly;
2335
2336 /* additive effects */
2337 {
2338 u32 apply_to[] = { av->id_hip,
2339 av->id_ik_hand_l,
2340 av->id_ik_hand_r,
2341 av->id_ik_elbow_l,
2342 av->id_ik_elbow_r };
2343
2344 for( int i=0; i<vg_list_size(apply_to); i ++ )
2345 {
2346 dest->pose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
2347 dest->pose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
2348 }
2349
2350
2351
2352
2353 /* angle correction */
2354 if( v3_length2( s->state.up_dir ) > 0.001f )
2355 {
2356 v3f ndir;
2357 m3x3_mulv( player->rb.to_local, s->state.up_dir, ndir );
2358 v3_normalize( ndir );
2359
2360 v3f up = { 0.0f, 1.0f, 0.0f };
2361
2362 float a = v3_dot( ndir, up );
2363 a = acosf( vg_clampf( a, -1.0f, 1.0f ) );
2364
2365 v3f axis;
2366 v4f q;
2367
2368 v3_cross( up, ndir, axis );
2369 q_axis_angle( q, axis, a );
2370
2371 mdl_keyframe *kf_hip = &dest->pose[av->id_hip-1];
2372
2373 for( int i=0; i<vg_list_size(apply_to); i ++ )
2374 {
2375 mdl_keyframe *kf = &dest->pose[apply_to[i]-1];
2376
2377 v3f v0;
2378 v3_sub( kf->co, kf_hip->co, v0 );
2379 q_mulv( q, v0, v0 );
2380 v3_add( v0, kf_hip->co, kf->co );
2381
2382 q_mul( q, kf->q, kf->q );
2383 q_normalize( kf->q );
2384 }
2385
2386 v3f p1, p2;
2387 m4x3_mulv( player->rb.to_world, up, p1 );
2388 m4x3_mulv( player->rb.to_world, ndir, p2 );
2389
2390 vg_line( player->rb.co, p1, VG__PINK );
2391 vg_line( player->rb.co, p2, VG__CYAN );
2392 }
2393
2394
2395
2396 mdl_keyframe *kf_board = &dest->pose[av->id_board-1],
2397 *kf_foot_l = &dest->pose[av->id_ik_foot_l-1],
2398 *kf_foot_r = &dest->pose[av->id_ik_foot_r-1];
2399
2400 v3f bo;
2401 v3_muls( s->board_offset, add_grab_mod, bo );
2402
2403 v3_add( bo, kf_board->co, kf_board->co );
2404 v3_add( bo, kf_foot_l->co, kf_foot_l->co );
2405 v3_add( bo, kf_foot_r->co, kf_foot_r->co );
2406
2407 #if 0
2408 m3x3f c;
2409 q_m3x3( s->board_rotation, c );
2410 #endif
2411
2412 v4f qtotal;
2413
2414 v4f qtrickr, qyawr, qpitchr, qrollr;
2415 v3f eulerr;
2416
2417
2418
2419 v3_muls( s->board_trick_residuald, VG_TAUf, eulerr );
2420
2421 q_axis_angle( qyawr, (v3f){0.0f,1.0f,0.0f}, eulerr[0] * 0.5f );
2422 q_axis_angle( qpitchr, (v3f){1.0f,0.0f,0.0f}, eulerr[1] );
2423 q_axis_angle( qrollr, (v3f){0.0f,0.0f,1.0f}, eulerr[2] );
2424
2425 q_mul( qpitchr, qrollr, qtrickr );
2426 q_mul( qyawr, qtrickr, qtrickr );
2427 q_mul( s->board_rotation, qtrickr, qtotal );
2428 q_normalize( qtotal );
2429
2430 q_mul( qtotal, kf_board->q, kf_board->q );
2431
2432
2433 v3f d;
2434 v3_sub( kf_foot_l->co, bo, d );
2435 q_mulv( qtotal, d, d );
2436 v3_add( bo, d, kf_foot_l->co );
2437
2438 v3_sub( kf_foot_r->co, bo, d );
2439 q_mulv( qtotal, d, d );
2440 v3_add( bo, d, kf_foot_r->co );
2441
2442 q_mul( s->board_rotation, kf_board->q, kf_board->q );
2443 q_normalize( kf_board->q );
2444
2445
2446 /* trick rotation */
2447 v4f qtrick, qyaw, qpitch, qroll;
2448 v3f euler;
2449 v3_muls( s->state.trick_euler, VG_TAUf, euler );
2450
2451 q_axis_angle( qyaw, (v3f){0.0f,1.0f,0.0f}, euler[0] * 0.5f );
2452 q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, euler[1] );
2453 q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, euler[2] );
2454
2455 q_mul( qpitch, qroll, qtrick );
2456 q_mul( qyaw, qtrick, qtrick );
2457 q_mul( kf_board->q, qtrick, kf_board->q );
2458 q_normalize( kf_board->q );
2459 }
2460
2461 /* transform */
2462 rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
2463 v3_muladds( dest->root_co, player->rb.to_world[1], -0.1f, dest->root_co );
2464
2465 float substep = vg_clampf( vg.accumulator / VG_TIMESTEP_FIXED, 0.0f, 1.0f );
2466 #if 0
2467 v4f qresy, qresx, qresidual;
2468 m3x3f mtx_residual;
2469 q_axis_angle( qresy, player->rb.to_world[1], s->state.steery_s*substep );
2470 q_axis_angle( qresx, player->rb.to_world[0], s->state.steerx_s*substep );
2471
2472 q_mul( qresy, qresx, qresidual );
2473 q_normalize( qresidual );
2474 q_mul( dest->root_q, qresidual, dest->root_q );
2475 q_normalize( dest->root_q );
2476 #endif
2477
2478 v4f qflip;
2479 if( (s->state.activity == k_skate_activity_air) &&
2480 (fabsf(s->state.flip_rate) > 0.01f) )
2481 {
2482 float t = s->state.flip_time + s->state.flip_rate*substep*k_rb_delta,
2483 angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
2484 distm = s->land_dist * fabsf(s->state.flip_rate) * 3.0f,
2485 blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
2486
2487 angle = vg_lerpf( angle, vg_signf(s->state.flip_rate) * VG_TAUf, blend );
2488
2489 q_axis_angle( qflip, s->state.flip_axis, angle );
2490 q_mul( qflip, dest->root_q, dest->root_q );
2491 q_normalize( dest->root_q );
2492
2493 v3f rotation_point, rco;
2494 v3_muladds( player->rb.co, player->rb.to_world[1], 0.5f, rotation_point );
2495 v3_sub( dest->root_co, rotation_point, rco );
2496
2497 q_mulv( qflip, rco, rco );
2498 v3_add( rco, rotation_point, dest->root_co );
2499 }
2500 }
2501
2502 VG_STATIC void player__skate_post_animate( player_instance *player )
2503 {
2504 struct player_skate *s = &player->_skate;
2505 struct player_avatar *av = player->playeravatar;
2506
2507 player->cam_velocity_influence = 1.0f;
2508
2509 v3f head = { 0.0f, 1.8f, 0.0f }; /* FIXME: Viewpoint entity */
2510 m4x3_mulv( av->sk.final_mtx[ av->id_head ], head, s->state.head_position );
2511 m4x3_mulv( player->rb.to_local, s->state.head_position,
2512 s->state.head_position );
2513 }
2514
2515 VG_STATIC void player__skate_reset_animator( player_instance *player )
2516 {
2517 struct player_skate *s = &player->_skate;
2518
2519 if( s->state.activity == k_skate_activity_air )
2520 s->blend_fly = 1.0f;
2521 else
2522 s->blend_fly = 0.0f;
2523
2524 s->blend_slide = 0.0f;
2525 s->blend_z = 0.0f;
2526 s->blend_x = 0.0f;
2527 s->blend_stand = 0.0f;
2528 s->blend_push = 0.0f;
2529 s->blend_jump = 0.0f;
2530 s->blend_airdir = 0.0f;
2531 }
2532
2533 VG_STATIC void player__skate_clear_mechanics( player_instance *player )
2534 {
2535 struct player_skate *s = &player->_skate;
2536 s->state.jump_charge = 0.0f;
2537 s->state.lift_frames = 0;
2538 s->state.flip_rate = 0.0f;
2539 #if 0
2540 s->state.steery = 0.0f;
2541 s->state.steerx = 0.0f;
2542 s->state.steery_s = 0.0f;
2543 s->state.steerx_s = 0.0f;
2544 #endif
2545 s->state.reverse = 0.0f;
2546 s->state.slip = 0.0f;
2547 v3_copy( player->rb.co, s->state.prev_pos );
2548
2549 m3x3_identity( s->state.velocity_bias );
2550 m3x3_identity( s->state.velocity_bias_pstep );
2551 v3_zero( s->state.throw_v );
2552 v3_zero( s->state.trick_vel );
2553 v3_zero( s->state.trick_euler );
2554 }
2555
2556 VG_STATIC void player__skate_reset( player_instance *player,
2557 struct respawn_point *rp )
2558 {
2559 struct player_skate *s = &player->_skate;
2560 v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
2561 v3_zero( player->rb.v );
2562 v3_zero( s->state.cog_v );
2563 v4_copy( rp->q, player->rb.q );
2564
2565 s->state.activity = k_skate_activity_air;
2566 s->state.activity_prev = k_skate_activity_air;
2567
2568 player__skate_clear_mechanics( player );
2569 player__skate_reset_animator( player );
2570
2571 v3_zero( s->state.head_position );
2572 s->state.head_position[1] = 1.8f;
2573 }
2574
2575 #endif /* PLAYER_SKATE_C */