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