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