isolate world code
[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
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 /* Throw / collect routine
880 *
881 * TODO: Max speed boost
882 */
883 if( player->input_grab->axis.value > 0.5f )
884 {
885 if( s->state.activity == k_skate_activity_ground )
886 {
887 /* Throw */
888 v3_muls( player->rb.to_world[1], k_mmthrow_scale, s->state.throw_v );
889 }
890 }
891 else
892 {
893 /* Collect */
894 float doty = v3_dot( player->rb.to_world[1], s->state.throw_v );
895
896 v3f Fl, Fv;
897 v3_muladds( s->state.throw_v, player->rb.to_world[1], -doty, Fl);
898
899 if( s->state.activity == k_skate_activity_ground )
900 {
901 v3_muladds( player->rb.v, Fl, k_mmcollect_lat, player->rb.v );
902 v3_muladds( s->state.throw_v, Fl, -k_mmcollect_lat, s->state.throw_v );
903 }
904
905 v3_muls( player->rb.to_world[1], -doty, Fv );
906 v3_muladds( player->rb.v, Fv, k_mmcollect_vert, player->rb.v );
907 v3_muladds( s->state.throw_v, Fv, k_mmcollect_vert, s->state.throw_v );
908 }
909
910 /* Decay */
911 if( v3_length2( s->state.throw_v ) > 0.0001f )
912 {
913 v3f dir;
914 v3_copy( s->state.throw_v, dir );
915 v3_normalize( dir );
916
917 float max = v3_dot( dir, s->state.throw_v ),
918 amt = vg_minf( k_mmdecay * k_rb_delta, max );
919 v3_muladds( s->state.throw_v, dir, -amt, s->state.throw_v );
920 }
921 }
922
923 VG_STATIC void skate_apply_cog_model( player_instance *player )
924 {
925 struct player_skate *s = &player->_skate;
926
927 v3f ideal_cog, ideal_diff, ideal_dir;
928 v3_copy( s->state.up_dir, ideal_dir );
929 v3_normalize( ideal_dir );
930
931 v3_muladds( player->rb.co, ideal_dir,
932 1.0f-player->input_grab->axis.value, ideal_cog );
933 v3_sub( ideal_cog, s->state.cog, ideal_diff );
934
935 /* Apply velocities */
936 v3f rv;
937 v3_sub( player->rb.v, s->state.cog_v, rv );
938
939 v3f F;
940 v3_muls( ideal_diff, -k_cog_spring * k_rb_rate, F );
941 v3_muladds( F, rv, -k_cog_damp * k_rb_rate, F );
942
943 float ra = k_cog_mass_ratio,
944 rb = 1.0f-k_cog_mass_ratio;
945
946 /* Apply forces & intergrate */
947 v3_muladds( s->state.cog_v, F, -rb, s->state.cog_v );
948 v3_muladds( s->state.cog_v, player->basis[1], -9.8f * k_rb_delta,
949 s->state.cog_v );
950
951 v3_muladds( s->state.cog, s->state.cog_v, k_rb_delta, s->state.cog );
952 }
953
954
955 VG_STATIC void skate_integrate( player_instance *player )
956 {
957 struct player_skate *s = &player->_skate;
958
959 float decay_rate = 1.0f - (k_rb_delta * 3.0f),
960 decay_rate_y = 1.0f;
961
962 if( s->state.activity >= k_skate_activity_grind_any )
963 {
964 decay_rate = 1.0f-vg_lerpf( 3.0f, 20.0f, s->grind_strength ) * k_rb_delta;
965 decay_rate_y = decay_rate;
966 }
967
968 float wx = v3_dot( player->rb.w, player->rb.to_world[0] ) * decay_rate,
969 wy = v3_dot( player->rb.w, player->rb.to_world[1] ) * decay_rate_y,
970 wz = v3_dot( player->rb.w, player->rb.to_world[2] ) * decay_rate;
971
972 v3_muls( player->rb.to_world[0], wx, player->rb.w );
973 v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
974 v3_muladds( player->rb.w, player->rb.to_world[2], wz, player->rb.w );
975
976 s->state.flip_time += s->state.flip_rate * k_rb_delta;
977 rb_update_transform( &player->rb );
978 }
979
980 /*
981 * 1 2 or 3
982 */
983
984 VG_STATIC int player_skate_trick_input( player_instance *player )
985 {
986 return (player->input_trick0->button.value) |
987 (player->input_trick1->button.value << 1) |
988 (player->input_trick2->button.value << 1) |
989 (player->input_trick2->button.value);
990 }
991
992 VG_STATIC void player__skate_pre_update( player_instance *player )
993 {
994 struct player_skate *s = &player->_skate;
995
996 if( vg_input_button_down( player->input_use ) )
997 {
998 player->subsystem = k_player_subsystem_walk;
999
1000 v3f angles;
1001 v3_copy( player->cam.angles, angles );
1002 angles[2] = 0.0f;
1003
1004 player->holdout_time = 0.25f;
1005 player__walk_transition( player, angles );
1006 return;
1007 }
1008
1009 if( vg_input_button_down( player->input_reset ) )
1010 {
1011 player->rb.co[1] += 2.0f;
1012 s->state.cog[1] += 2.0f;
1013 q_axis_angle( player->rb.q, (v3f){1.0f,0.0f,0.0f}, VG_PIf * 0.25f );
1014 v3_zero( player->rb.w );
1015 v3_zero( player->rb.v );
1016
1017 rb_update_transform( &player->rb );
1018 }
1019
1020 int trick_id;
1021 if( (s->state.activity == k_skate_activity_air) &&
1022 (trick_id = player_skate_trick_input( player )) )
1023 {
1024 if( (vg.time - s->state.jump_time) < 0.1f )
1025 {
1026 v3_zero( s->state.trick_vel );
1027 s->state.trick_time = 0.0f;
1028
1029 if( trick_id == 1 )
1030 {
1031 s->state.trick_vel[0] = 3.0f;
1032 }
1033 else if( trick_id == 2 )
1034 {
1035 s->state.trick_vel[2] = 3.0f;
1036 }
1037 else if( trick_id == 3 )
1038 {
1039 s->state.trick_vel[0] = 2.0f;
1040 s->state.trick_vel[2] = 2.0f;
1041 }
1042 }
1043 }
1044 }
1045
1046 VG_STATIC void player__skate_post_update( player_instance *player )
1047 {
1048 struct player_skate *s = &player->_skate;
1049
1050 for( int i=0; i<s->prediction_count; i++ )
1051 {
1052 struct land_prediction *p = &s->predictions[i];
1053
1054 for( int j=0; j<p->log_length - 1; j ++ )
1055 {
1056 float brightness = p->score*p->score*p->score;
1057 v3f p1;
1058 v3_lerp( p->log[j], p->log[j+1], brightness, p1 );
1059 vg_line( p->log[j], p1, p->colour );
1060 }
1061
1062 vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
1063
1064 v3f p1;
1065 v3_add( p->log[p->log_length-1], p->n, p1 );
1066 vg_line( p->log[p->log_length-1], p1, 0xffffffff );
1067
1068 vg_line_pt3( p->apex, 0.02f, 0xffffffff );
1069 }
1070
1071 #if 0
1072 vg_line_pt3( s->state.apex, 0.030f, 0xff0000ff );
1073 #endif
1074 }
1075
1076 /*
1077 * truck alignment model at ra(local)
1078 * returns 1 if valid surface:
1079 * surface_normal will be filled out with an averaged normal vector
1080 * axel_dir will be the direction from left to right wheels
1081 *
1082 * returns 0 if no good surface found
1083 */
1084 VG_STATIC
1085 int skate_compute_surface_alignment( player_instance *player,
1086 v3f ra, u32 colour,
1087 v3f surface_normal, v3f axel_dir )
1088 {
1089 struct player_skate *s = &player->_skate;
1090 world_instance *world = get_active_world();
1091
1092 v3f truck, left, right;
1093 m4x3_mulv( player->rb.to_world, ra, truck );
1094
1095 v3_muladds( truck, player->rb.to_world[0], -k_board_width, left );
1096 v3_muladds( truck, player->rb.to_world[0], k_board_width, right );
1097 vg_line( left, right, colour );
1098
1099 float k_max_truck_flex = VG_PIf * 0.25f;
1100
1101 ray_hit ray_l, ray_r;
1102
1103 v3f dir;
1104 v3_muls( player->rb.to_world[1], -1.0f, dir );
1105
1106 int res_l = 0, res_r = 0;
1107
1108 for( int i=0; i<8; i++ )
1109 {
1110 float t = 1.0f - (float)i * (1.0f/8.0f);
1111 v3_muladds( truck, player->rb.to_world[0], -k_board_radius*t, left );
1112 v3_muladds( left, player->rb.to_world[1], k_board_radius, left );
1113 ray_l.dist = 2.1f * k_board_radius;
1114
1115 res_l = ray_world( world, left, dir, &ray_l );
1116
1117 if( res_l )
1118 break;
1119 }
1120
1121 for( int i=0; i<8; i++ )
1122 {
1123 float t = 1.0f - (float)i * (1.0f/8.0f);
1124 v3_muladds( truck, player->rb.to_world[0], k_board_radius*t, right );
1125 v3_muladds( right, player->rb.to_world[1], k_board_radius, right );
1126 ray_r.dist = 2.1f * k_board_radius;
1127
1128 res_r = ray_world( world, right, dir, &ray_r );
1129
1130 if( res_r )
1131 break;
1132 }
1133
1134 v3f v0;
1135 v3f midpoint;
1136 v3f tangent_average;
1137 v3_muladds( truck, player->rb.to_world[1], -k_board_radius, midpoint );
1138 v3_zero( tangent_average );
1139
1140 if( res_l || res_r )
1141 {
1142 v3f p0, p1, t;
1143 v3_copy( midpoint, p0 );
1144 v3_copy( midpoint, p1 );
1145
1146 if( res_l )
1147 {
1148 v3_copy( ray_l.pos, p0 );
1149 v3_cross( ray_l.normal, player->rb.to_world[0], t );
1150 v3_add( t, tangent_average, tangent_average );
1151 }
1152 if( res_r )
1153 {
1154 v3_copy( ray_r.pos, p1 );
1155 v3_cross( ray_r.normal, player->rb.to_world[0], t );
1156 v3_add( t, tangent_average, tangent_average );
1157 }
1158
1159 v3_sub( p1, p0, v0 );
1160 v3_normalize( v0 );
1161 }
1162 else
1163 {
1164 /* fallback: use the closes point to the trucks */
1165 v3f closest;
1166 int idx = bh_closest_point( world->geo_bh, midpoint, closest, 0.1f );
1167
1168 if( idx != -1 )
1169 {
1170 u32 *tri = &world->scene_geo->arrindices[ idx * 3 ];
1171 v3f verts[3];
1172
1173 for( int j=0; j<3; j++ )
1174 v3_copy( world->scene_geo->arrvertices[ tri[j] ].co, verts[j] );
1175
1176 v3f vert0, vert1, n;
1177 v3_sub( verts[1], verts[0], vert0 );
1178 v3_sub( verts[2], verts[0], vert1 );
1179 v3_cross( vert0, vert1, n );
1180 v3_normalize( n );
1181
1182 if( v3_dot( n, player->rb.to_world[1] ) < 0.3f )
1183 return 0;
1184
1185 v3_cross( n, player->rb.to_world[2], v0 );
1186 v3_muladds( v0, player->rb.to_world[2],
1187 -v3_dot( player->rb.to_world[2], v0 ), v0 );
1188 v3_normalize( v0 );
1189
1190 v3f t;
1191 v3_cross( n, player->rb.to_world[0], t );
1192 v3_add( t, tangent_average, tangent_average );
1193 }
1194 else
1195 return 0;
1196 }
1197
1198 v3_muladds( truck, v0, k_board_width, right );
1199 v3_muladds( truck, v0, -k_board_width, left );
1200
1201 vg_line( left, right, VG__WHITE );
1202
1203 v3_normalize( tangent_average );
1204 v3_cross( v0, tangent_average, surface_normal );
1205 v3_copy( v0, axel_dir );
1206
1207 return 1;
1208 }
1209
1210 VG_STATIC void skate_weight_distribute( player_instance *player )
1211 {
1212 struct player_skate *s = &player->_skate;
1213 v3_zero( s->weight_distribution );
1214
1215 int reverse_dir = v3_dot( player->rb.to_world[2], player->rb.v ) < 0.0f?1:-1;
1216
1217 if( s->state.manual_direction == 0 )
1218 {
1219 if( (player->input_js1v->axis.value > 0.7f) &&
1220 (s->state.activity == k_skate_activity_ground) &&
1221 (s->state.jump_charge <= 0.01f) )
1222 s->state.manual_direction = reverse_dir;
1223 }
1224 else
1225 {
1226 if( player->input_js1v->axis.value < 0.1f )
1227 {
1228 s->state.manual_direction = 0;
1229 }
1230 else
1231 {
1232 if( reverse_dir != s->state.manual_direction )
1233 {
1234 return;
1235 }
1236 }
1237 }
1238
1239 if( s->state.manual_direction )
1240 {
1241 float amt = vg_minf( player->input_js1v->axis.value * 8.0f, 1.0f );
1242 s->weight_distribution[2] = k_board_length * amt *
1243 (float)s->state.manual_direction;
1244 }
1245
1246 /* TODO: Fall back on land normal */
1247 /* TODO: Lerp weight distribution */
1248 if( s->state.manual_direction )
1249 {
1250 v3f plane_z;
1251
1252 m3x3_mulv( player->rb.to_world, s->weight_distribution, plane_z );
1253 v3_negate( plane_z, plane_z );
1254
1255 v3_muladds( plane_z, s->surface_picture,
1256 -v3_dot( plane_z, s->surface_picture ), plane_z );
1257 v3_normalize( plane_z );
1258
1259 v3_muladds( plane_z, s->surface_picture, 0.3f, plane_z );
1260 v3_normalize( plane_z );
1261
1262 v3f p1;
1263 v3_muladds( player->rb.co, plane_z, 1.5f, p1 );
1264 vg_line( player->rb.co, p1, VG__GREEN );
1265
1266 v3f refdir;
1267 v3_muls( player->rb.to_world[2], -(float)s->state.manual_direction,
1268 refdir );
1269
1270 rb_effect_spring_target_vector( &player->rb, refdir, plane_z,
1271 k_manul_spring, k_manul_dampener,
1272 s->substep_delta );
1273 }
1274 }
1275
1276 VG_STATIC void skate_adjust_up_direction( player_instance *player )
1277 {
1278 struct player_skate *s = &player->_skate;
1279
1280 if( s->state.activity == k_skate_activity_ground )
1281 {
1282 v3f target;
1283 v3_copy( s->surface_picture, target );
1284
1285 target[1] += 2.0f * s->surface_picture[1];
1286 v3_normalize( target );
1287
1288 v3_lerp( s->state.up_dir, target,
1289 8.0f * s->substep_delta, s->state.up_dir );
1290 }
1291 else if( s->state.activity == k_skate_activity_air )
1292 {
1293 v3_lerp( s->state.up_dir, player->rb.to_world[1],
1294 8.0f * s->substep_delta, s->state.up_dir );
1295 }
1296 else
1297 {
1298 v3_lerp( s->state.up_dir, player->basis[1],
1299 12.0f * s->substep_delta, s->state.up_dir );
1300 }
1301 }
1302
1303 VG_STATIC int skate_point_visible( v3f origin, v3f target )
1304 {
1305 v3f dir;
1306 v3_sub( target, origin, dir );
1307
1308 ray_hit ray;
1309 ray.dist = v3_length( dir );
1310 v3_muls( dir, 1.0f/ray.dist, dir );
1311 ray.dist -= 0.025f;
1312
1313 if( ray_world( get_active_world(), origin, dir, &ray ) )
1314 return 0;
1315
1316 return 1;
1317 }
1318
1319 VG_STATIC void skate_grind_orient( struct grind_info *inf, m3x3f mtx )
1320 {
1321 /* TODO: Is N and Dir really orthogonal? */
1322 v3_copy( inf->dir, mtx[0] );
1323 v3_copy( inf->n, mtx[1] );
1324 v3_cross( mtx[0], mtx[1], mtx[2] );
1325 }
1326
1327 VG_STATIC void skate_grind_friction( player_instance *player,
1328 struct grind_info *inf, float strength )
1329 {
1330 v3f v2;
1331 v3_muladds( player->rb.to_world[2], inf->n,
1332 -v3_dot( player->rb.to_world[2], inf->n ), v2 );
1333
1334 float a = 1.0f-fabsf( v3_dot( v2, inf->dir ) ),
1335 dir = vg_signf( v3_dot( player->rb.v, inf->dir ) ),
1336 F = a * -dir * k_grind_max_friction;
1337
1338 v3_muladds( player->rb.v, inf->dir, F*k_rb_delta*strength, player->rb.v );
1339 }
1340
1341 VG_STATIC void skate_grind_decay( player_instance *player,
1342 struct grind_info *inf, float strength )
1343 {
1344 m3x3f mtx, mtx_inv;
1345 skate_grind_orient( inf, mtx );
1346 m3x3_transpose( mtx, mtx_inv );
1347
1348 v3f v_grind;
1349 m3x3_mulv( mtx_inv, player->rb.v, v_grind );
1350
1351 float decay = 1.0f - ( k_rb_delta * k_grind_decayxy * strength );
1352 v3_mul( v_grind, (v3f){ 1.0f, decay, decay }, v_grind );
1353 m3x3_mulv( mtx, v_grind, player->rb.v );
1354 }
1355
1356 VG_STATIC void skate_grind_truck_apply( player_instance *player,
1357 float sign, struct grind_info *inf,
1358 float strength )
1359 {
1360 struct player_skate *s = &player->_skate;
1361
1362 /* TODO: Trash compactor this */
1363 v3f ra = { 0.0f, -k_board_radius, sign * k_board_length };
1364 v3f raw, wsp;
1365 m3x3_mulv( player->rb.to_world, ra, raw );
1366 v3_add( player->rb.co, raw, wsp );
1367
1368 v3_copy( ra, s->weight_distribution );
1369
1370 v3f delta;
1371 v3_sub( inf->co, wsp, delta );
1372
1373 /* spring force */
1374 v3_muladds( player->rb.v, delta, k_spring_force*strength*k_rb_delta,
1375 player->rb.v );
1376
1377 skate_grind_decay( player, inf, strength );
1378 skate_grind_friction( player, inf, strength );
1379
1380 /* yeah yeah yeah yeah */
1381 v3f raw_nplane, axis;
1382 v3_muladds( raw, inf->n, -v3_dot( inf->n, raw ), raw_nplane );
1383 v3_cross( raw_nplane, inf->n, axis );
1384 v3_normalize( axis );
1385
1386 /* orientation */
1387 m3x3f mtx;
1388 skate_grind_orient( inf, mtx );
1389 v3f target_fwd, fwd, up, target_up;
1390 m3x3_mulv( mtx, s->grind_vec, target_fwd );
1391 v3_copy( raw_nplane, fwd );
1392 v3_copy( player->rb.to_world[1], up );
1393 v3_copy( inf->n, target_up );
1394
1395 v3_muladds( target_fwd, inf->n, -v3_dot(inf->n,target_fwd), target_fwd );
1396 v3_muladds( fwd, inf->n, -v3_dot(inf->n,fwd), fwd );
1397
1398 v3_normalize( target_fwd );
1399 v3_normalize( fwd );
1400
1401
1402 float way = player->input_js1v->axis.value *
1403 vg_signf( v3_dot( raw_nplane, player->rb.v ) );
1404
1405 v4f q;
1406 q_axis_angle( q, axis, VG_PIf*0.125f * way );
1407 q_mulv( q, target_up, target_up );
1408 q_mulv( q, target_fwd, target_fwd );
1409
1410 rb_effect_spring_target_vector( &player->rb, up, target_up,
1411 k_grind_spring,
1412 k_grind_dampener,
1413 k_rb_delta );
1414
1415 rb_effect_spring_target_vector( &player->rb, fwd, target_fwd,
1416 k_grind_spring*strength,
1417 k_grind_dampener*strength,
1418 k_rb_delta );
1419
1420 vg_line_arrow( player->rb.co, target_up, 1.0f, VG__GREEN );
1421 vg_line_arrow( player->rb.co, fwd, 0.8f, VG__RED );
1422 vg_line_arrow( player->rb.co, target_fwd, 1.0f, VG__YELOW );
1423
1424 s->grind_strength = strength;
1425
1426 /* Fake contact */
1427 struct grind_limit *limit = &s->limits[ s->limit_count ++ ];
1428 m4x3_mulv( player->rb.to_local, wsp, limit->ra );
1429 m3x3_mulv( player->rb.to_local, inf->n, limit->n );
1430 limit->p = 0.0f;
1431
1432 v3_copy( inf->dir, s->grind_dir );
1433 }
1434
1435 VG_STATIC void skate_5050_apply( player_instance *player,
1436 struct grind_info *inf_front,
1437 struct grind_info *inf_back )
1438 {
1439 struct player_skate *s = &player->_skate;
1440 struct grind_info inf_avg;
1441
1442 v3_sub( inf_front->co, inf_back->co, inf_avg.dir );
1443 v3_muladds( inf_back->co, inf_avg.dir, 0.5f, inf_avg.co );
1444 v3_normalize( inf_avg.dir );
1445
1446 v3f axis_front, axis_back, axis;
1447 v3_cross( inf_front->dir, inf_front->n, axis_front );
1448 v3_cross( inf_back->dir, inf_back->n, axis_back );
1449 v3_add( axis_front, axis_back, axis );
1450 v3_normalize( axis );
1451
1452 v3_cross( axis, inf_avg.dir, inf_avg.n );
1453
1454 skate_grind_decay( player, &inf_avg, 1.0f );
1455
1456
1457 float way = player->input_js1v->axis.value *
1458 vg_signf( v3_dot( player->rb.to_world[2], player->rb.v ) );
1459 v4f q;
1460 v3f up, target_up;
1461 v3_copy( player->rb.to_world[1], up );
1462 v3_copy( inf_avg.n, target_up );
1463 q_axis_angle( q, player->rb.to_world[0], VG_PIf*0.25f * -way );
1464 q_mulv( q, target_up, target_up );
1465
1466 v3_zero( s->weight_distribution );
1467 s->weight_distribution[2] = k_board_length * -way;
1468
1469 rb_effect_spring_target_vector( &player->rb, up, target_up,
1470 k_grind_spring,
1471 k_grind_dampener,
1472 k_rb_delta );
1473
1474 v3f fwd_nplane, dir_nplane;
1475 v3_muladds( player->rb.to_world[2], inf_avg.n,
1476 -v3_dot( player->rb.to_world[2], inf_avg.n ), fwd_nplane );
1477
1478 v3f dir;
1479 v3_muls( inf_avg.dir, v3_dot( fwd_nplane, inf_avg.dir ), dir );
1480 v3_muladds( dir, inf_avg.n, -v3_dot( dir, inf_avg.n ), dir_nplane );
1481
1482 v3_normalize( fwd_nplane );
1483 v3_normalize( dir_nplane );
1484
1485 rb_effect_spring_target_vector( &player->rb, fwd_nplane, dir_nplane,
1486 1000.0f,
1487 k_grind_dampener,
1488 k_rb_delta );
1489
1490 v3f pos_front = { 0.0f, -k_board_radius, -1.0f * k_board_length },
1491 pos_back = { 0.0f, -k_board_radius, 1.0f * k_board_length },
1492 delta_front, delta_back, delta_total;
1493
1494 m4x3_mulv( player->rb.to_world, pos_front, pos_front );
1495 m4x3_mulv( player->rb.to_world, pos_back, pos_back );
1496
1497 v3_sub( inf_front->co, pos_front, delta_front );
1498 v3_sub( inf_back->co, pos_back, delta_back );
1499 v3_add( delta_front, delta_back, delta_total );
1500
1501 v3_muladds( player->rb.v, delta_total, 50.0f * k_rb_delta, player->rb.v );
1502
1503 /* Fake contact */
1504 struct grind_limit *limit = &s->limits[ s->limit_count ++ ];
1505 v3_zero( limit->ra );
1506 m3x3_mulv( player->rb.to_local, inf_avg.n, limit->n );
1507 limit->p = 0.0f;
1508
1509 v3_copy( inf_avg.dir, s->grind_dir );
1510 }
1511
1512 VG_STATIC int skate_grind_truck_renew( player_instance *player, float sign,
1513 struct grind_info *inf )
1514 {
1515 struct player_skate *s = &player->_skate;
1516
1517 v3f wheel_co = { 0.0f, 0.0f, sign * k_board_length },
1518 grind_co = { 0.0f, -k_board_radius, sign * k_board_length };
1519
1520 m4x3_mulv( player->rb.to_world, wheel_co, wheel_co );
1521 m4x3_mulv( player->rb.to_world, grind_co, grind_co );
1522
1523 /* Exit condition: lost grind tracking */
1524 if( !skate_grind_scansq( player, grind_co, player->rb.v, 0.3f, inf ) )
1525 return 0;
1526
1527 /* Exit condition: cant see grind target directly */
1528 if( !skate_point_visible( wheel_co, inf->co ) )
1529 return 0;
1530
1531 /* Exit condition: minimum velocity not reached, but allow a bit of error */
1532 float dv = fabsf(v3_dot( player->rb.v, inf->dir )),
1533 minv = k_grind_axel_min_vel*0.8f;
1534
1535 if( dv < minv )
1536 return 0;
1537
1538 if( fabsf(v3_dot( inf->dir, s->grind_dir )) < k_grind_max_edge_angle )
1539 return 0;
1540
1541 v3_copy( inf->dir, s->grind_dir );
1542 return 1;
1543 }
1544
1545 VG_STATIC int skate_grind_truck_entry( player_instance *player, float sign,
1546 struct grind_info *inf )
1547 {
1548 struct player_skate *s = &player->_skate;
1549
1550 /* TODO: Trash compactor this */
1551 v3f ra = { 0.0f, -k_board_radius, sign * k_board_length };
1552
1553 v3f raw, wsp;
1554 m3x3_mulv( player->rb.to_world, ra, raw );
1555 v3_add( player->rb.co, raw, wsp );
1556
1557 if( skate_grind_scansq( player, wsp, player->rb.v, 0.3, inf ) )
1558 {
1559 if( fabsf(v3_dot( player->rb.v, inf->dir )) < k_grind_axel_min_vel )
1560 return 0;
1561
1562 /* velocity should be at least 60% aligned */
1563 v3f pv, axis;
1564 v3_cross( inf->n, inf->dir, axis );
1565 v3_muladds( player->rb.v, inf->n, -v3_dot( player->rb.v, inf->n ), pv );
1566
1567 if( v3_length2( pv ) < 0.0001f )
1568 return 0;
1569 v3_normalize( pv );
1570
1571 if( fabsf(v3_dot( pv, inf->dir )) < k_grind_axel_max_angle )
1572 return 0;
1573
1574 if( v3_dot( player->rb.v, inf->n ) > 0.5f )
1575 return 0;
1576
1577 #if 0
1578 /* check for vertical alignment */
1579 if( v3_dot( player->rb.to_world[1], inf->n ) < k_grind_axel_max_vangle )
1580 return 0;
1581 #endif
1582
1583 v3f local_co, local_dir, local_n;
1584 m4x3_mulv( player->rb.to_local, inf->co, local_co );
1585 m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
1586 m3x3_mulv( player->rb.to_local, inf->n, local_n );
1587
1588 v2f delta = { local_co[0], local_co[2] - k_board_length*sign };
1589
1590 float truck_height = -(k_board_radius+0.03f);
1591
1592 v3f rv;
1593 v3_cross( player->rb.w, raw, rv );
1594 v3_add( player->rb.v, rv, rv );
1595
1596 if( (local_co[1] >= truck_height) &&
1597 (v2_length2( delta ) <= k_board_radius*k_board_radius) )
1598 {
1599 return 1;
1600 }
1601 }
1602
1603 return 0;
1604 }
1605
1606 VG_STATIC void skate_boardslide_apply( player_instance *player,
1607 struct grind_info *inf )
1608 {
1609 struct player_skate *s = &player->_skate;
1610
1611 v3f local_co, local_dir, local_n;
1612 m4x3_mulv( player->rb.to_local, inf->co, local_co );
1613 m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
1614 m3x3_mulv( player->rb.to_local, inf->n, local_n );
1615
1616 v3f intersection;
1617 v3_muladds( local_co, local_dir, local_co[0]/-local_dir[0],
1618 intersection );
1619 v3_copy( intersection, s->weight_distribution );
1620
1621 skate_grind_decay( player, inf, 0.1f );
1622 skate_grind_friction( player, inf, 0.25f );
1623
1624 /* direction alignment */
1625 v3f dir, perp;
1626 v3_cross( local_dir, local_n, perp );
1627 v3_muls( local_dir, vg_signf(local_dir[0]), dir );
1628 v3_muls( perp, vg_signf(perp[2]), perp );
1629
1630 m3x3_mulv( player->rb.to_world, dir, dir );
1631 m3x3_mulv( player->rb.to_world, perp, perp );
1632
1633 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[0],
1634 dir,
1635 k_grind_spring, k_grind_dampener,
1636 k_rb_delta );
1637
1638 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[2],
1639 perp,
1640 k_grind_spring, k_grind_dampener,
1641 k_rb_delta );
1642
1643 vg_line_arrow( player->rb.co, dir, 0.5f, VG__GREEN );
1644 vg_line_arrow( player->rb.co, perp, 0.5f, VG__BLUE );
1645
1646 v3_copy( inf->dir, s->grind_dir );
1647 }
1648
1649 VG_STATIC int skate_boardslide_entry( player_instance *player,
1650 struct grind_info *inf )
1651 {
1652 struct player_skate *s = &player->_skate;
1653
1654 if( skate_grind_scansq( player, player->rb.co,
1655 player->rb.to_world[0], k_board_length,
1656 inf ) )
1657 {
1658 v3f local_co, local_dir;
1659 m4x3_mulv( player->rb.to_local, inf->co, local_co );
1660 m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
1661
1662 if( (fabsf(local_co[2]) <= k_board_length) && /* within wood area */
1663 (local_co[1] >= 0.0f) && /* at deck level */
1664 (fabsf(local_dir[0]) >= 0.5f) ) /* perpendicular to us */
1665 {
1666 if( fabsf(v3_dot( player->rb.v, inf->dir )) < k_grind_axel_min_vel )
1667 return 0;
1668
1669 return 1;
1670 }
1671 }
1672
1673 return 0;
1674 }
1675
1676 VG_STATIC int skate_boardslide_renew( player_instance *player,
1677 struct grind_info *inf )
1678 {
1679 struct player_skate *s = &player->_skate;
1680
1681 if( !skate_grind_scansq( player, player->rb.co,
1682 player->rb.to_world[0], k_board_length,
1683 inf ) )
1684 return 0;
1685
1686 /* Exit condition: cant see grind target directly */
1687 v3f vis;
1688 v3_muladds( player->rb.co, player->rb.to_world[1], 0.2f, vis );
1689 if( !skate_point_visible( vis, inf->co ) )
1690 return 0;
1691
1692 /* Exit condition: minimum velocity not reached, but allow a bit of error
1693 * TODO: trash compactor */
1694 float dv = fabsf(v3_dot( player->rb.v, inf->dir )),
1695 minv = k_grind_axel_min_vel*0.8f;
1696
1697 if( dv < minv )
1698 return 0;
1699
1700 if( fabsf(v3_dot( inf->dir, s->grind_dir )) < k_grind_max_edge_angle )
1701 return 0;
1702
1703 return 1;
1704 }
1705
1706 VG_STATIC void skate_store_grind_vec( player_instance *player,
1707 struct grind_info *inf )
1708 {
1709 struct player_skate *s = &player->_skate;
1710
1711 m3x3f mtx;
1712 skate_grind_orient( inf, mtx );
1713 m3x3_transpose( mtx, mtx );
1714
1715 v3f raw;
1716 v3_sub( inf->co, player->rb.co, raw );
1717
1718 m3x3_mulv( mtx, raw, s->grind_vec );
1719 v3_normalize( s->grind_vec );
1720 v3_copy( inf->dir, s->grind_dir );
1721 }
1722
1723 VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
1724 {
1725 struct player_skate *s = &player->_skate;
1726
1727 /* debounces this state manager a little bit */
1728 if( s->frames_since_activity_change < 10 )
1729 {
1730 s->frames_since_activity_change ++;
1731 return k_skate_activity_undefined;
1732 }
1733
1734 struct grind_info inf_back50,
1735 inf_front50,
1736 inf_slide;
1737
1738 int res_back50 = 0,
1739 res_front50 = 0,
1740 res_slide = 0;
1741
1742 if( s->state.activity == k_skate_activity_grind_boardslide )
1743 {
1744 res_slide = skate_boardslide_renew( player, &inf_slide );
1745 }
1746 else if( s->state.activity == k_skate_activity_grind_back50 )
1747 {
1748 res_back50 = skate_grind_truck_renew( player, 1.0f, &inf_back50 );
1749 res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
1750 }
1751 else if( s->state.activity == k_skate_activity_grind_front50 )
1752 {
1753 res_front50 = skate_grind_truck_renew( player, -1.0f, &inf_front50 );
1754 res_back50 = skate_grind_truck_entry( player, 1.0f, &inf_back50 );
1755 }
1756 else if( s->state.activity == k_skate_activity_grind_5050 )
1757 {
1758 res_front50 = skate_grind_truck_renew( player, -1.0f, &inf_front50 );
1759 res_back50 = skate_grind_truck_entry( player, 1.0f, &inf_back50 );
1760 }
1761 else
1762 {
1763 res_slide = skate_boardslide_entry( player, &inf_slide );
1764 res_back50 = skate_grind_truck_entry( player, 1.0f, &inf_back50 );
1765 res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
1766
1767 if( res_back50 != res_front50 )
1768 {
1769 int wants_to_do_that = fabsf(player->input_js1v->axis.value) >= 0.25f;
1770
1771 res_back50 &= wants_to_do_that;
1772 res_front50 &= wants_to_do_that;
1773 }
1774 }
1775
1776 const enum skate_activity table[] =
1777 { /* slide | back | front */
1778 k_skate_activity_undefined, /* 0 0 0 */
1779 k_skate_activity_grind_front50, /* 0 0 1 */
1780 k_skate_activity_grind_back50, /* 0 1 0 */
1781 k_skate_activity_grind_5050, /* 0 1 1 */
1782
1783 /* slide has priority always */
1784 k_skate_activity_grind_boardslide, /* 1 0 0 */
1785 k_skate_activity_grind_boardslide, /* 1 0 1 */
1786 k_skate_activity_grind_boardslide, /* 1 1 0 */
1787 k_skate_activity_grind_boardslide, /* 1 1 1 */
1788 }
1789 , new_activity = table[ res_slide << 2 | res_back50 << 1 | res_front50 ];
1790
1791 if( new_activity == k_skate_activity_undefined )
1792 {
1793 if( s->state.activity >= k_skate_activity_grind_any )
1794 s->frames_since_activity_change = 0;
1795 }
1796 else if( new_activity == k_skate_activity_grind_boardslide )
1797 {
1798 skate_boardslide_apply( player, &inf_slide );
1799 }
1800 else if( new_activity == k_skate_activity_grind_back50 )
1801 {
1802 if( s->state.activity != k_skate_activity_grind_back50 )
1803 skate_store_grind_vec( player, &inf_back50 );
1804
1805 skate_grind_truck_apply( player, 1.0f, &inf_back50, 1.0f );
1806 }
1807 else if( new_activity == k_skate_activity_grind_front50 )
1808 {
1809 if( s->state.activity != k_skate_activity_grind_front50 )
1810 skate_store_grind_vec( player, &inf_front50 );
1811
1812 skate_grind_truck_apply( player, -1.0f, &inf_front50, 1.0f );
1813 }
1814 else if( new_activity == k_skate_activity_grind_5050 )
1815 skate_5050_apply( player, &inf_front50, &inf_back50 );
1816
1817 return new_activity;
1818 }
1819
1820 VG_STATIC void player__skate_update( player_instance *player )
1821 {
1822 struct player_skate *s = &player->_skate;
1823 world_instance *world = get_active_world();
1824
1825 v3_copy( player->rb.co, s->state.prev_pos );
1826 s->state.activity_prev = s->state.activity;
1827
1828 struct board_collider
1829 {
1830 v3f pos;
1831 float radius;
1832
1833 u32 colour;
1834
1835 enum board_collider_state
1836 {
1837 k_collider_state_default,
1838 k_collider_state_disabled,
1839 k_collider_state_colliding
1840 }
1841 state;
1842 }
1843 wheels[] =
1844 {
1845 {
1846 { 0.0f, 0.0f, -k_board_length },
1847 .radius = k_board_radius,
1848 .colour = VG__RED
1849 },
1850 {
1851 { 0.0f, 0.0f, k_board_length },
1852 .radius = k_board_radius,
1853 .colour = VG__GREEN
1854 }
1855 };
1856
1857 const int k_wheel_count = 2;
1858
1859 s->substep = k_rb_delta;
1860 s->substep_delta = s->substep;
1861 s->limit_count = 0;
1862
1863 int substep_count = 0;
1864
1865 v3_zero( s->surface_picture );
1866
1867 for( int i=0; i<k_wheel_count; i++ )
1868 wheels[i].state = k_collider_state_default;
1869
1870 /* check if we can enter or continue grind */
1871 enum skate_activity grindable_activity = skate_availible_grind( player );
1872 if( grindable_activity != k_skate_activity_undefined )
1873 {
1874 s->state.activity = grindable_activity;
1875 goto grinding;
1876 }
1877
1878 int contact_count = 0;
1879 for( int i=0; i<2; i++ )
1880 {
1881 v3f normal, axel;
1882 v3_copy( player->rb.to_world[0], axel );
1883
1884 if( skate_compute_surface_alignment( player, wheels[i].pos,
1885 wheels[i].colour, normal, axel ) )
1886 {
1887 rb_effect_spring_target_vector( &player->rb, player->rb.to_world[0],
1888 axel,
1889 k_surface_spring, k_surface_dampener,
1890 s->substep_delta );
1891
1892 v3_add( normal, s->surface_picture, s->surface_picture );
1893 contact_count ++;
1894 }
1895
1896 m3x3_mulv( player->rb.to_local, axel, s->truckv0[i] );
1897 }
1898
1899 if( contact_count )
1900 {
1901 s->state.activity = k_skate_activity_ground;
1902 s->state.gravity_bias = k_gravity;
1903 v3_normalize( s->surface_picture );
1904
1905 skate_apply_friction_model( player );
1906 skate_weight_distribute( player );
1907 skate_apply_pump_model( player );
1908 }
1909 else
1910 {
1911 s->state.activity = k_skate_activity_air;
1912 v3_zero( s->weight_distribution );
1913 skate_apply_air_model( player );
1914 }
1915
1916 grinding:;
1917
1918 if( s->state.activity == k_skate_activity_grind_back50 )
1919 wheels[1].state = k_collider_state_disabled;
1920 if( s->state.activity == k_skate_activity_grind_front50 )
1921 wheels[0].state = k_collider_state_disabled;
1922 if( s->state.activity == k_skate_activity_grind_5050 )
1923 {
1924 wheels[0].state = k_collider_state_disabled;
1925 wheels[1].state = k_collider_state_disabled;
1926 }
1927
1928 /* all activities */
1929 skate_apply_steering_model( player );
1930 skate_adjust_up_direction( player );
1931 skate_apply_cog_model( player );
1932 skate_apply_jump_model( player );
1933 skate_apply_grab_model( player );
1934 skate_apply_trick_model( player );
1935
1936 begin_collision:;
1937
1938 /*
1939 * Phase 0: Continous collision detection
1940 * --------------------------------------------------------------------------
1941 */
1942
1943 v3f head_wp0, head_wp1, start_co;
1944 m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp0 );
1945 v3_copy( player->rb.co, start_co );
1946
1947 /* calculate transform one step into future */
1948 v3f future_co;
1949 v4f future_q;
1950 v3_muladds( player->rb.co, player->rb.v, s->substep, future_co );
1951
1952 if( v3_length2( player->rb.w ) > 0.0f )
1953 {
1954 v4f rotation;
1955 v3f axis;
1956 v3_copy( player->rb.w, axis );
1957
1958 float mag = v3_length( axis );
1959 v3_divs( axis, mag, axis );
1960 q_axis_angle( rotation, axis, mag*s->substep );
1961 q_mul( rotation, player->rb.q, future_q );
1962 q_normalize( future_q );
1963 }
1964 else
1965 v4_copy( player->rb.q, future_q );
1966
1967 v3f future_cg, current_cg, cg_offset;
1968 q_mulv( player->rb.q, s->weight_distribution, current_cg );
1969 q_mulv( future_q, s->weight_distribution, future_cg );
1970 v3_sub( future_cg, current_cg, cg_offset );
1971
1972 /* calculate the minimum time we can move */
1973 float max_time = s->substep;
1974
1975 for( int i=0; i<k_wheel_count; i++ )
1976 {
1977 if( wheels[i].state == k_collider_state_disabled )
1978 continue;
1979
1980 v3f current, future, r_cg;
1981
1982 q_mulv( future_q, wheels[i].pos, future );
1983 v3_add( future, future_co, future );
1984 v3_add( cg_offset, future, future );
1985
1986 q_mulv( player->rb.q, wheels[i].pos, current );
1987 v3_add( current, player->rb.co, current );
1988
1989 float t;
1990 v3f n;
1991
1992 float cast_radius = wheels[i].radius - k_penetration_slop * 2.0f;
1993 if( spherecast_world( world, current, future, cast_radius, &t, n ) != -1)
1994 max_time = vg_minf( max_time, t * s->substep );
1995 }
1996
1997 /* clamp to a fraction of delta, to prevent locking */
1998 float rate_lock = substep_count;
1999 rate_lock *= k_rb_delta * 0.1f;
2000 rate_lock *= rate_lock;
2001
2002 max_time = vg_maxf( max_time, rate_lock );
2003 s->substep_delta = max_time;
2004
2005 /* integrate */
2006 v3_muladds( player->rb.co, player->rb.v, s->substep_delta, player->rb.co );
2007 if( v3_length2( player->rb.w ) > 0.0f )
2008 {
2009 v4f rotation;
2010 v3f axis;
2011 v3_copy( player->rb.w, axis );
2012
2013 float mag = v3_length( axis );
2014 v3_divs( axis, mag, axis );
2015 q_axis_angle( rotation, axis, mag*s->substep_delta );
2016 q_mul( rotation, player->rb.q, player->rb.q );
2017 q_normalize( player->rb.q );
2018
2019 q_mulv( player->rb.q, s->weight_distribution, future_cg );
2020 v3_sub( current_cg, future_cg, cg_offset );
2021 v3_add( player->rb.co, cg_offset, player->rb.co );
2022 }
2023
2024 rb_update_transform( &player->rb );
2025 v3_muladds( player->rb.v, player->basis[1],
2026 -s->state.gravity_bias * s->substep_delta, player->rb.v );
2027
2028 s->substep -= s->substep_delta;
2029
2030 rb_ct manifold[128];
2031 int manifold_len = 0;
2032
2033 /*
2034 * Phase -1: head detection
2035 * --------------------------------------------------------------------------
2036 */
2037 m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp1 );
2038
2039 float t;
2040 v3f n;
2041 if( (v3_dist2( head_wp0, head_wp1 ) > 0.001f) &&
2042 (spherecast_world( world, head_wp0, head_wp1, 0.2f, &t, n ) != -1) )
2043 {
2044 v3_lerp( start_co, player->rb.co, t, player->rb.co );
2045 rb_update_transform( &player->rb );
2046
2047 player__dead_transition( player );
2048 return;
2049 }
2050
2051 /*
2052 * Phase 1: Regular collision detection
2053 * --------------------------------------------------------------------------
2054 */
2055
2056 for( int i=0; i<k_wheel_count; i++ )
2057 {
2058 if( wheels[i].state == k_collider_state_disabled )
2059 continue;
2060
2061 m4x3f mtx;
2062 m3x3_identity( mtx );
2063 m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
2064
2065 rb_sphere collider = { .radius = wheels[i].radius };
2066
2067 rb_ct *man = &manifold[ manifold_len ];
2068
2069 int l = skate_collide_smooth( player, mtx, &collider, man );
2070 if( l )
2071 wheels[i].state = k_collider_state_colliding;
2072
2073 manifold_len += l;
2074 }
2075
2076 float grind_radius = k_board_radius * 0.75f;
2077 rb_capsule capsule = { .height = (k_board_length+0.2f)*2.0f,
2078 .radius=grind_radius };
2079 m4x3f mtx;
2080 v3_muls( player->rb.to_world[0], 1.0f, mtx[0] );
2081 v3_muls( player->rb.to_world[2], -1.0f, mtx[1] );
2082 v3_muls( player->rb.to_world[1], 1.0f, mtx[2] );
2083 v3_muladds( player->rb.to_world[3], player->rb.to_world[1],
2084 grind_radius + k_board_radius*0.25f, mtx[3] );
2085
2086 rb_ct *cman = &manifold[manifold_len];
2087
2088 int l = rb_capsule__scene( mtx, &capsule, NULL, &world->rb_geo.inf.scene,
2089 cman );
2090
2091 /* weld joints */
2092 for( int i=0; i<l; i ++ )
2093 cman[l].type = k_contact_type_edge;
2094 rb_manifold_filter_joint_edges( cman, l, 0.03f );
2095 l = rb_manifold_apply_filtered( cman, l );
2096
2097 manifold_len += l;
2098
2099 debug_capsule( mtx, capsule.radius, capsule.height, VG__WHITE );
2100
2101 /* add limits */
2102 for( int i=0; i<s->limit_count; i++ )
2103 {
2104 struct grind_limit *limit = &s->limits[i];
2105 rb_ct *ct = &manifold[ manifold_len ++ ];
2106 m4x3_mulv( player->rb.to_world, limit->ra, ct->co );
2107 m3x3_mulv( player->rb.to_world, limit->n, ct->n );
2108 ct->p = limit->p;
2109 ct->type = k_contact_type_default;
2110 }
2111
2112 /*
2113 * Phase 3: Dynamics
2114 * --------------------------------------------------------------------------
2115 */
2116
2117
2118 v3f world_cog;
2119 m4x3_mulv( player->rb.to_world, s->weight_distribution, world_cog );
2120 vg_line_pt3( world_cog, 0.02f, VG__BLACK );
2121
2122 for( int i=0; i<manifold_len; i ++ )
2123 {
2124 rb_prepare_contact( &manifold[i], s->substep_delta );
2125 rb_debug_contact( &manifold[i] );
2126 }
2127
2128 /* yes, we are currently rebuilding mass matrices every frame. too bad! */
2129 v3f extent = { k_board_width, 0.1f, k_board_length };
2130 float ex2 = k_board_interia*extent[0]*extent[0],
2131 ey2 = k_board_interia*extent[1]*extent[1],
2132 ez2 = k_board_interia*extent[2]*extent[2];
2133
2134 float mass = 2.0f * (extent[0]*extent[1]*extent[2]);
2135 float inv_mass = 1.0f/mass;
2136
2137 v3f I;
2138 I[0] = ((1.0f/12.0f) * mass * (ey2+ez2));
2139 I[1] = ((1.0f/12.0f) * mass * (ex2+ez2));
2140 I[2] = ((1.0f/12.0f) * mass * (ex2+ey2));
2141
2142 m3x3f iI;
2143 m3x3_identity( iI );
2144 iI[0][0] = I[0];
2145 iI[1][1] = I[1];
2146 iI[2][2] = I[2];
2147 m3x3_inv( iI, iI );
2148
2149 m3x3f iIw;
2150 m3x3_mul( iI, player->rb.to_local, iIw );
2151 m3x3_mul( player->rb.to_world, iIw, iIw );
2152
2153 for( int j=0; j<10; j++ )
2154 {
2155 for( int i=0; i<manifold_len; i++ )
2156 {
2157 /*
2158 * regular dance; calculate velocity & total mass, apply impulse.
2159 */
2160
2161 struct contact *ct = &manifold[i];
2162
2163 v3f rv, delta;
2164 v3_sub( ct->co, world_cog, delta );
2165 v3_cross( player->rb.w, delta, rv );
2166 v3_add( player->rb.v, rv, rv );
2167
2168 v3f raCn;
2169 v3_cross( delta, ct->n, raCn );
2170
2171 v3f raCnI, rbCnI;
2172 m3x3_mulv( iIw, raCn, raCnI );
2173
2174 float normal_mass = 1.0f / (inv_mass + v3_dot(raCn,raCnI)),
2175 vn = v3_dot( rv, ct->n ),
2176 lambda = normal_mass * ( -vn );
2177
2178 float temp = ct->norm_impulse;
2179 ct->norm_impulse = vg_maxf( temp + lambda, 0.0f );
2180 lambda = ct->norm_impulse - temp;
2181
2182 v3f impulse;
2183 v3_muls( ct->n, lambda, impulse );
2184
2185 v3_muladds( player->rb.v, impulse, inv_mass, player->rb.v );
2186 v3_cross( delta, impulse, impulse );
2187 m3x3_mulv( iIw, impulse, impulse );
2188 v3_add( impulse, player->rb.w, player->rb.w );
2189
2190 v3_cross( player->rb.w, delta, rv );
2191 v3_add( player->rb.v, rv, rv );
2192 vn = v3_dot( rv, ct->n );
2193 }
2194 }
2195
2196 v3f dt;
2197 rb_depenetrate( manifold, manifold_len, dt );
2198 v3_add( dt, player->rb.co, player->rb.co );
2199 rb_update_transform( &player->rb );
2200
2201 substep_count ++;
2202
2203 if( s->substep >= 0.0001f )
2204 goto begin_collision; /* again! */
2205
2206 /*
2207 * End of collision and dynamics routine
2208 * --------------------------------------------------------------------------
2209 */
2210
2211 for( int i=0; i<k_wheel_count; i++ )
2212 {
2213 m4x3f mtx;
2214 m3x3_copy( player->rb.to_world, mtx );
2215 m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
2216 debug_sphere( mtx, wheels[i].radius,
2217 (u32[]){ VG__WHITE, VG__BLACK,
2218 wheels[i].colour }[ wheels[i].state ]);
2219 }
2220
2221 skate_integrate( player );
2222 vg_line_pt3( s->state.cog, 0.02f, VG__WHITE );
2223
2224 teleport_gate *gate;
2225 if( (gate = world_intersect_gates(world, player->rb.co, s->state.prev_pos)) )
2226 {
2227 m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
2228 m3x3_mulv( gate->transport, player->rb.v, player->rb.v );
2229 m4x3_mulv( gate->transport, s->state.cog, s->state.cog );
2230 m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
2231 m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
2232 m3x3_mulv( gate->transport, s->state.head_position,
2233 s->state.head_position );
2234 m3x3_mulv( gate->transport, s->state.up_dir, s->state.up_dir );
2235
2236 v4f transport_rotation;
2237 m3x3_q( gate->transport, transport_rotation );
2238 q_mul( transport_rotation, player->rb.q, player->rb.q );
2239 rb_update_transform( &player->rb );
2240
2241 s->state_gate_storage = s->state;
2242 player__pass_gate( player, gate );
2243 }
2244 }
2245
2246 VG_STATIC void player__skate_im_gui( player_instance *player )
2247 {
2248 struct player_skate *s = &player->_skate;
2249
2250 /* FIXME: Compression */
2251 player__debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
2252 player->rb.v[1],
2253 player->rb.v[2] );
2254 player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
2255 player->rb.co[1],
2256 player->rb.co[2] );
2257 player__debugtext( 1, "W: %5.2f %5.2f %5.2f",player->rb.w[0],
2258 player->rb.w[1],
2259 player->rb.w[2] );
2260
2261 const char *activity_txt[] =
2262 {
2263 "air",
2264 "ground",
2265 "undefined (INVALID)",
2266 "grind_any (INVALID)",
2267 "grind_boardslide",
2268 "grind_noseslide",
2269 "grind_tailslide",
2270 "grind_back50",
2271 "grind_front50",
2272 "grind_5050"
2273 };
2274
2275 player__debugtext( 1, "activity: %s", activity_txt[s->state.activity] );
2276 #if 0
2277 player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
2278 s->state.steerx_s, s->state.steery_s,
2279 k_steer_ground, k_steer_air );
2280 #endif
2281 player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate,
2282 s->state.flip_time );
2283 player__debugtext( 1, "trickv: %.2f %.2f %.2f",
2284 s->state.trick_vel[0],
2285 s->state.trick_vel[1],
2286 s->state.trick_vel[2] );
2287 player__debugtext( 1, "tricke: %.2f %.2f %.2f",
2288 s->state.trick_euler[0],
2289 s->state.trick_euler[1],
2290 s->state.trick_euler[2] );
2291 }
2292
2293 VG_STATIC void player__skate_animate( player_instance *player,
2294 player_animation *dest )
2295 {
2296 struct player_skate *s = &player->_skate;
2297 struct player_avatar *av = player->playeravatar;
2298 struct skeleton *sk = &av->sk;
2299
2300 /* Head */
2301 float kheight = 2.0f,
2302 kleg = 0.6f;
2303
2304 v3f offset;
2305 v3_zero( offset );
2306
2307 v3f cog_local, cog_ideal;
2308 m4x3_mulv( player->rb.to_local, s->state.cog, cog_local );
2309
2310 v3_copy( s->state.up_dir, cog_ideal );
2311 v3_normalize( cog_ideal );
2312 m3x3_mulv( player->rb.to_local, cog_ideal, cog_ideal );
2313
2314 v3_sub( cog_ideal, cog_local, offset );
2315
2316
2317 v3_muls( offset, 4.0f, offset );
2318 offset[1] *= -1.0f;
2319
2320 float curspeed = v3_length( player->rb.v ),
2321 kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
2322 kicks = (vg_randf()-0.5f)*2.0f*kickspeed,
2323 sign = vg_signf( kicks );
2324
2325 s->wobble[0] = vg_lerpf( s->wobble[0], kicks*kicks*sign, 6.0f*vg.time_delta);
2326 s->wobble[1] = vg_lerpf( s->wobble[1], s->wobble[0], 2.4f*vg.time_delta);
2327
2328 offset[0] *= 0.26f;
2329 offset[0] += s->wobble[1]*3.0f;
2330
2331 offset[1] *= -0.3f;
2332 offset[2] *= 0.01f;
2333
2334 offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(s->blend_slide)*0.9f);
2335 offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
2336
2337 /*
2338 * Animation blending
2339 * ===========================================
2340 */
2341
2342 /* sliding */
2343 {
2344 float desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
2345 s->blend_slide = vg_lerpf( s->blend_slide, desired, 2.4f*vg.time_delta);
2346 }
2347
2348 /* movement information */
2349 {
2350 int iair = s->state.activity == k_skate_activity_air;
2351
2352 float dirz = s->state.reverse > 0.0f? 0.0f: 1.0f,
2353 dirx = s->state.slip < 0.0f? 0.0f: 1.0f,
2354 fly = iair? 1.0f: 0.0f,
2355 wdist= s->weight_distribution[2] / k_board_length;
2356
2357 s->blend_z = vg_lerpf( s->blend_z, dirz, 2.4f*vg.time_delta );
2358 s->blend_x = vg_lerpf( s->blend_x, dirx, 0.6f*vg.time_delta );
2359 s->blend_fly = vg_lerpf( s->blend_fly, fly, 2.4f*vg.time_delta );
2360 s->blend_weight= vg_lerpf( s->blend_weight, wdist, 9.0f*vg.time_delta );
2361 }
2362
2363 mdl_keyframe apose[32], bpose[32];
2364 mdl_keyframe ground_pose[32];
2365 {
2366 /* when the player is moving fast he will crouch down a little bit */
2367 float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
2368 s->blend_stand = vg_lerpf( s->blend_stand, stand, 6.0f*vg.time_delta );
2369
2370 /* stand/crouch */
2371 float dir_frame = s->blend_z * (15.0f/30.0f),
2372 stand_blend = offset[1]*-2.0f;
2373
2374 v3f local_cog;
2375 m4x3_mulv( player->rb.to_local, s->state.cog, local_cog );
2376
2377 stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 );
2378
2379 skeleton_sample_anim( sk, s->anim_stand, dir_frame, apose );
2380 skeleton_sample_anim( sk, s->anim_highg, dir_frame, bpose );
2381 skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
2382
2383 /* sliding */
2384 float slide_frame = s->blend_x * (15.0f/30.0f);
2385 skeleton_sample_anim( sk, s->anim_slide, slide_frame, bpose );
2386 skeleton_lerp_pose( sk, apose, bpose, s->blend_slide, apose );
2387
2388 /* pushing */
2389 double push_time = vg.time - s->state.start_push;
2390 s->blend_push = vg_lerpf( s->blend_push,
2391 (vg.time - s->state.cur_push) < 0.125,
2392 6.0f*vg.time_delta );
2393
2394 float pt = push_time + vg.accumulator;
2395 if( s->state.reverse > 0.0f )
2396 skeleton_sample_anim( sk, s->anim_push, pt, bpose );
2397 else
2398 skeleton_sample_anim( sk, s->anim_push_reverse, pt, bpose );
2399
2400 skeleton_lerp_pose( sk, apose, bpose, s->blend_push, apose );
2401
2402 /* trick setup */
2403 float jump_start_frame = 14.0f/30.0f;
2404
2405 float charge = s->state.jump_charge;
2406 s->blend_jump = vg_lerpf( s->blend_jump, charge, 8.4f*vg.time_delta );
2407
2408 float setup_frame = charge * jump_start_frame,
2409 setup_blend = vg_minf( s->blend_jump, 1.0f );
2410
2411 float jump_frame = (vg.time - s->state.jump_time) + jump_start_frame;
2412 if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
2413 setup_frame = jump_frame;
2414
2415 struct skeleton_anim *jump_anim = s->state.jump_dir?
2416 s->anim_ollie:
2417 s->anim_ollie_reverse;
2418
2419 skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose );
2420 skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
2421 }
2422
2423 mdl_keyframe air_pose[32];
2424 {
2425 float target = -player->input_js1h->axis.value;
2426 s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
2427
2428 float air_frame = (s->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
2429 skeleton_sample_anim( sk, s->anim_air, air_frame, apose );
2430
2431 static v2f grab_choice;
2432
2433 v2f grab_input = { player->input_js2h->axis.value,
2434 player->input_js2v->axis.value };
2435 v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
2436 if( v2_length2( grab_input ) <= 0.001f )
2437 grab_input[0] = -1.0f;
2438 else
2439 v2_normalize_clamp( grab_input );
2440 v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
2441
2442 float ang = atan2f( grab_choice[0], grab_choice[1] ),
2443 ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
2444 grab_frame = ang_unit * (15.0f/30.0f);
2445
2446 skeleton_sample_anim( sk, s->anim_grabs, grab_frame, bpose );
2447 skeleton_lerp_pose( sk, apose, bpose, s->state.grabbing, air_pose );
2448 }
2449
2450 skeleton_lerp_pose( sk, ground_pose, air_pose, s->blend_fly, dest->pose );
2451
2452 float add_grab_mod = 1.0f - s->blend_fly;
2453
2454 /* additive effects */
2455 {
2456 u32 apply_to[] = { av->id_hip,
2457 av->id_ik_hand_l,
2458 av->id_ik_hand_r,
2459 av->id_ik_elbow_l,
2460 av->id_ik_elbow_r };
2461
2462 for( int i=0; i<vg_list_size(apply_to); i ++ )
2463 {
2464 dest->pose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
2465 dest->pose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
2466 }
2467
2468
2469 /* angle correction */
2470 if( v3_length2( s->state.up_dir ) > 0.001f )
2471 {
2472 v3f ndir;
2473 m3x3_mulv( player->rb.to_local, s->state.up_dir, ndir );
2474 v3_normalize( ndir );
2475
2476 v3f up = { 0.0f, 1.0f, 0.0f };
2477
2478 float a = v3_dot( ndir, up );
2479 a = acosf( vg_clampf( a, -1.0f, 1.0f ) );
2480
2481 v3f axis;
2482 v4f q;
2483
2484 v3_cross( up, ndir, axis );
2485 q_axis_angle( q, axis, a );
2486
2487 mdl_keyframe *kf_hip = &dest->pose[av->id_hip-1];
2488
2489 for( int i=0; i<vg_list_size(apply_to); i ++ )
2490 {
2491 mdl_keyframe *kf = &dest->pose[apply_to[i]-1];
2492
2493 v3f v0;
2494 v3_sub( kf->co, kf_hip->co, v0 );
2495 q_mulv( q, v0, v0 );
2496 v3_add( v0, kf_hip->co, kf->co );
2497
2498 q_mul( q, kf->q, kf->q );
2499 q_normalize( kf->q );
2500 }
2501
2502 v3f p1, p2;
2503 m3x3_mulv( player->rb.to_world, up, p1 );
2504 m3x3_mulv( player->rb.to_world, ndir, p2 );
2505
2506 vg_line_arrow( player->rb.co, p1, 0.25f, VG__PINK );
2507 vg_line_arrow( player->rb.co, p2, 0.25f, VG__PINK );
2508 }
2509
2510
2511
2512 mdl_keyframe *kf_board = &dest->pose[av->id_board-1],
2513 *kf_foot_l = &dest->pose[av->id_ik_foot_l-1],
2514 *kf_foot_r = &dest->pose[av->id_ik_foot_r-1],
2515 *kf_wheels[] = { &dest->pose[av->id_wheel_r-1],
2516 &dest->pose[av->id_wheel_l-1] };
2517
2518 v4f qtotal;
2519 v4f qtrickr, qyawr, qpitchr, qrollr;
2520 v3f eulerr;
2521
2522 v3_muls( s->board_trick_residuald, VG_TAUf, eulerr );
2523
2524 q_axis_angle( qyawr, (v3f){0.0f,1.0f,0.0f}, eulerr[0] * 0.5f );
2525 q_axis_angle( qpitchr, (v3f){1.0f,0.0f,0.0f}, eulerr[1] );
2526 q_axis_angle( qrollr, (v3f){0.0f,0.0f,1.0f}, eulerr[2] );
2527
2528 q_mul( qpitchr, qrollr, qtrickr );
2529 q_mul( qyawr, qtrickr, qtotal );
2530 q_normalize( qtotal );
2531
2532 q_mul( qtotal, kf_board->q, kf_board->q );
2533
2534
2535 /* trick rotation */
2536 v4f qtrick, qyaw, qpitch, qroll;
2537 v3f euler;
2538 v3_muls( s->state.trick_euler, VG_TAUf, euler );
2539
2540 q_axis_angle( qyaw, (v3f){0.0f,1.0f,0.0f}, euler[0] * 0.5f );
2541 q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, euler[1] );
2542 q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, euler[2] );
2543
2544 q_mul( qpitch, qroll, qtrick );
2545 q_mul( qyaw, qtrick, qtrick );
2546 q_mul( kf_board->q, qtrick, kf_board->q );
2547 q_normalize( kf_board->q );
2548
2549 /* foot weight distribution */
2550 if( s->blend_weight > 0.0f )
2551 {
2552 kf_foot_l->co[2] += s->blend_weight * 0.2f;
2553 kf_foot_r->co[2] += s->blend_weight * 0.1f;
2554 }
2555 else
2556 {
2557 kf_foot_r->co[2] += s->blend_weight * 0.3f;
2558 kf_foot_l->co[2] += s->blend_weight * 0.1f;
2559 }
2560
2561 /* truck rotation */
2562 for( int i=0; i<2; i++ )
2563 {
2564 float a = vg_minf( s->truckv0[i][0], 1.0f );
2565 a = -acosf( a ) * vg_signf( s->truckv0[i][1] );
2566
2567 v4f q;
2568 q_axis_angle( q, (v3f){0.0f,0.0f,1.0f}, a );
2569 q_mul( q, kf_wheels[i]->q, kf_wheels[i]->q );
2570 q_normalize( kf_wheels[i]->q );
2571 }
2572 }
2573
2574 /* transform */
2575 rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
2576 v3_muladds( dest->root_co, player->rb.to_world[1], -0.1f, dest->root_co );
2577
2578 float substep = vg_clampf( vg.accumulator / VG_TIMESTEP_FIXED, 0.0f, 1.0f );
2579 #if 0
2580 v4f qresy, qresx, qresidual;
2581 m3x3f mtx_residual;
2582 q_axis_angle( qresy, player->rb.to_world[1], s->state.steery_s*substep );
2583 q_axis_angle( qresx, player->rb.to_world[0], s->state.steerx_s*substep );
2584
2585 q_mul( qresy, qresx, qresidual );
2586 q_normalize( qresidual );
2587 q_mul( dest->root_q, qresidual, dest->root_q );
2588 q_normalize( dest->root_q );
2589 #endif
2590
2591 v4f qflip;
2592 if( (s->state.activity == k_skate_activity_air) &&
2593 (fabsf(s->state.flip_rate) > 0.01f) )
2594 {
2595 float t = s->state.flip_time + s->state.flip_rate*substep*k_rb_delta,
2596 angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
2597 distm = s->land_dist * fabsf(s->state.flip_rate) * 3.0f,
2598 blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
2599
2600 angle = vg_lerpf( angle, vg_signf(s->state.flip_rate) * VG_TAUf, blend );
2601
2602 q_axis_angle( qflip, s->state.flip_axis, angle );
2603 q_mul( qflip, dest->root_q, dest->root_q );
2604 q_normalize( dest->root_q );
2605
2606 v3f rotation_point, rco;
2607 v3_muladds( player->rb.co, player->rb.to_world[1], 0.5f, rotation_point );
2608 v3_sub( dest->root_co, rotation_point, rco );
2609
2610 q_mulv( qflip, rco, rco );
2611 v3_add( rco, rotation_point, dest->root_co );
2612 }
2613
2614 skeleton_copy_pose( sk, dest->pose, player->holdout_pose );
2615 }
2616
2617 VG_STATIC void player__skate_post_animate( player_instance *player )
2618 {
2619 struct player_skate *s = &player->_skate;
2620 struct player_avatar *av = player->playeravatar;
2621
2622 player->cam_velocity_influence = 1.0f;
2623
2624 v3f head = { 0.0f, 1.8f, 0.0f }; /* FIXME: Viewpoint entity */
2625 m4x3_mulv( av->sk.final_mtx[ av->id_head ], head, s->state.head_position );
2626 m4x3_mulv( player->rb.to_local, s->state.head_position,
2627 s->state.head_position );
2628 }
2629
2630 VG_STATIC void player__skate_reset_animator( player_instance *player )
2631 {
2632 struct player_skate *s = &player->_skate;
2633
2634 if( s->state.activity == k_skate_activity_air )
2635 s->blend_fly = 1.0f;
2636 else
2637 s->blend_fly = 0.0f;
2638
2639 s->blend_slide = 0.0f;
2640 s->blend_z = 0.0f;
2641 s->blend_x = 0.0f;
2642 s->blend_stand = 0.0f;
2643 s->blend_push = 0.0f;
2644 s->blend_jump = 0.0f;
2645 s->blend_airdir = 0.0f;
2646 }
2647
2648 VG_STATIC void player__skate_clear_mechanics( player_instance *player )
2649 {
2650 struct player_skate *s = &player->_skate;
2651 s->state.jump_charge = 0.0f;
2652 s->state.lift_frames = 0;
2653 s->state.flip_rate = 0.0f;
2654 #if 0
2655 s->state.steery = 0.0f;
2656 s->state.steerx = 0.0f;
2657 s->state.steery_s = 0.0f;
2658 s->state.steerx_s = 0.0f;
2659 #endif
2660 s->state.reverse = 0.0f;
2661 s->state.slip = 0.0f;
2662 v3_copy( player->rb.co, s->state.prev_pos );
2663
2664 #if 0
2665 m3x3_identity( s->state.velocity_bias );
2666 m3x3_identity( s->state.velocity_bias_pstep );
2667 #endif
2668
2669 v3_zero( s->state.throw_v );
2670 v3_zero( s->state.trick_vel );
2671 v3_zero( s->state.trick_euler );
2672 }
2673
2674 VG_STATIC void player__skate_reset( player_instance *player,
2675 struct respawn_point *rp )
2676 {
2677 struct player_skate *s = &player->_skate;
2678 v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
2679 v3_zero( player->rb.v );
2680 v3_zero( s->state.cog_v );
2681 v4_copy( rp->q, player->rb.q );
2682
2683 s->state.activity = k_skate_activity_air;
2684 s->state.activity_prev = k_skate_activity_air;
2685
2686 player__skate_clear_mechanics( player );
2687 player__skate_reset_animator( player );
2688
2689 v3_zero( s->state.head_position );
2690 s->state.head_position[1] = 1.8f;
2691 }
2692
2693 #endif /* PLAYER_SKATE_C */