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