dead
[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 debug_sphere( mtx, sphere->radius, VG__BLACK );
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.05f );
50
51 if( len > 1 )
52 {
53 rb_manifold_filter_backface( man, len );
54 rb_manifold_filter_joint_edges( man, len, 0.05f );
55 rb_manifold_filter_pairs( man, len, 0.05f );
56 }
57 int new_len = rb_manifold_apply_filtered( man, len );
58 if( len && !new_len )
59 len = 1;
60 else
61 len = new_len;
62
63 return len;
64 }
65 /*
66 * Gets the closest grindable edge to the player within max_dist
67 */
68 VG_STATIC struct grind_edge *skate_collect_grind_edge( v3f p0, v3f p1,
69 v3f c0, v3f c1,
70 float max_dist )
71 {
72 bh_iter it;
73 bh_iter_init( 0, &it );
74
75 boxf region;
76
77 box_init_inf( region );
78 box_addpt( region, p0 );
79 box_addpt( region, p1 );
80
81 float k_r = max_dist;
82 v3_add( (v3f){ k_r, k_r, k_r}, region[1], region[1] );
83 v3_add( (v3f){-k_r,-k_r,-k_r}, region[0], region[0] );
84
85 float closest = k_r*k_r;
86 struct grind_edge *closest_edge = NULL;
87
88 int idx;
89 while( bh_next( world.grind_bh, &it, region, &idx ) )
90 {
91 struct grind_edge *edge = &world.grind_edges[ idx ];
92
93 float s,t;
94 v3f pa, pb;
95
96 float d2 =
97 closest_segment_segment( p0, p1, edge->p0, edge->p1, &s,&t, pa, pb );
98
99 if( d2 < closest )
100 {
101 closest = d2;
102 closest_edge = edge;
103 v3_copy( pa, c0 );
104 v3_copy( pb, c1 );
105 }
106 }
107
108 return closest_edge;
109 }
110
111 VG_STATIC int skate_grind_collide( player_instance *player, rb_ct *contact )
112 {
113 v3f p0, p1, c0, c1;
114 v3_muladds( player->rb.co, player->rb.to_world[2], 0.5f, p0 );
115 v3_muladds( player->rb.co, player->rb.to_world[2], -0.5f, p1 );
116 v3_muladds( p0, player->rb.to_world[1], 0.125f-0.15f, p0 );
117 v3_muladds( p1, player->rb.to_world[1], 0.125f-0.15f, p1 );
118
119 float const k_r = 0.25f;
120 struct grind_edge *closest_edge = skate_collect_grind_edge( p0, p1,
121 c0, c1, k_r );
122
123 if( closest_edge )
124 {
125 v3f delta;
126 v3_sub( c1, c0, delta );
127
128 if( v3_dot( delta, player->rb.to_world[1] ) > 0.0001f )
129 {
130 contact->p = v3_length( delta );
131 contact->type = k_contact_type_edge;
132 contact->element_id = 0;
133 v3_copy( c1, contact->co );
134 contact->rba = NULL;
135 contact->rbb = NULL;
136
137 v3f edge_dir, axis_dir;
138 v3_sub( closest_edge->p1, closest_edge->p0, edge_dir );
139 v3_normalize( edge_dir );
140 v3_cross( (v3f){0.0f,1.0f,0.0f}, edge_dir, axis_dir );
141 v3_cross( edge_dir, axis_dir, contact->n );
142
143 return 1;
144 }
145 else
146 return 0;
147 }
148
149 return 0;
150 }
151
152 /*
153 *
154 * Prediction system
155 *
156 *
157 */
158
159 /*
160 * Trace a path given a velocity rotation.
161 *
162 * TODO: this MIGHT be worth doing RK4 on the gravity field.
163 */
164 VG_STATIC void skate_score_biased_path( v3f co, v3f v, m3x3f vr,
165 struct land_prediction *prediction )
166 {
167 float pstep = VG_TIMESTEP_FIXED * 10.0f;
168 float k_bias = 0.96f;
169
170 v3f pco, pco1, pv;
171 v3_copy( co, pco );
172 v3_muls( v, k_bias, pv );
173
174 m3x3_mulv( vr, pv, pv );
175 v3_muladds( pco, pv, pstep, pco );
176
177 struct grind_edge *best_grind = NULL;
178 float closest_grind = INFINITY;
179
180 float grind_score = INFINITY,
181 air_score = INFINITY,
182 time_to_impact = 0.0f;
183
184 prediction->log_length = 0;
185 v3_copy( pco, prediction->apex );
186
187 for( int i=0; i<vg_list_size(prediction->log); i++ )
188 {
189 v3_copy( pco, pco1 );
190
191 pv[1] += -k_gravity * pstep;
192
193 m3x3_mulv( vr, pv, pv );
194 v3_muladds( pco, pv, pstep, pco );
195
196 if( pco[1] > prediction->apex[1] )
197 v3_copy( pco, prediction->apex );
198
199 v3f vdir;
200
201 v3_sub( pco, pco1, vdir );
202
203 float l = v3_length( vdir );
204 v3_muls( vdir, 1.0f/l, vdir );
205
206 v3f c0, c1;
207 struct grind_edge *ge = skate_collect_grind_edge( pco, pco1,
208 c0, c1, 0.4f );
209
210 if( ge && (v3_dot((v3f){0.0f,1.0f,0.0f},vdir) < -0.2f ) )
211 {
212 float d2 = v3_dist2( c0, c1 );
213 if( d2 < closest_grind )
214 {
215 closest_grind = d2;
216 best_grind = ge;
217 grind_score = closest_grind * 0.05f;
218 }
219 }
220
221 v3f n1;
222
223 float t1;
224 int idx = spherecast_world( pco1, pco, 0.4f, &t1, n1 );
225 if( idx != -1 )
226 {
227 v3_copy( n1, prediction->n );
228 air_score = -v3_dot( pv, n1 );
229
230 u32 vert_index = world.scene_geo->arrindices[ idx*3 ];
231 struct world_material *mat = world_tri_index_material( vert_index );
232
233 /* Bias prediction towords ramps */
234 if( mat->info.flags & k_material_flag_skate_surface )
235 air_score *= 0.1f;
236
237 v3_lerp( pco1, pco, t1, prediction->log[ prediction->log_length ++ ] );
238 time_to_impact += t1 * pstep;
239 break;
240 }
241
242 time_to_impact += pstep;
243 v3_copy( pco, prediction->log[ prediction->log_length ++ ] );
244 }
245
246 if( grind_score < air_score )
247 {
248 prediction->score = grind_score;
249 prediction->type = k_prediction_grind;
250 }
251 else if( air_score < INFINITY )
252 {
253 prediction->score = air_score;
254 prediction->type = k_prediction_land;
255 }
256 else
257 {
258 prediction->score = INFINITY;
259 prediction->type = k_prediction_none;
260 }
261
262 prediction->land_dist = time_to_impact;
263 }
264
265 VG_STATIC
266 void player__approximate_best_trajectory( player_instance *player )
267 {
268 struct player_skate *s = &player->_skate;
269
270 float pstep = VG_TIMESTEP_FIXED * 10.0f;
271 float best_velocity_delta = -9999.9f;
272
273 v3f axis;
274 v3_cross( player->rb.to_world[1], player->rb.v, axis );
275 v3_normalize( axis );
276
277 s->prediction_count = 0;
278 m3x3_identity( s->state.velocity_bias );
279
280 float best_vmod = 0.0f,
281 min_score = INFINITY,
282 max_score = -INFINITY;
283
284 v3_zero( s->state.apex );
285 s->land_dist = 0.0f;
286
287 /*
288 * Search a broad selection of futures
289 */
290 for( int m=-3;m<=12; m++ )
291 {
292 struct land_prediction *p = &s->predictions[ s->prediction_count ++ ];
293
294 float vmod = ((float)m / 15.0f)*0.09f;
295
296 m3x3f bias;
297 v4f bias_q;
298
299 q_axis_angle( bias_q, axis, vmod );
300 q_m3x3( bias_q, bias );
301
302 skate_score_biased_path( player->rb.co, player->rb.v, bias, p );
303
304 if( p->type != k_prediction_none )
305 {
306 if( p->score < min_score )
307 {
308 min_score = p->score;
309 best_vmod = vmod;
310 s->land_dist = p->land_dist;
311 v3_copy( p->apex, s->state.apex );
312 }
313
314 if( p->score > max_score )
315 max_score = p->score;
316 }
317 }
318
319 v4f vr_q;
320 q_axis_angle( vr_q, axis, best_vmod*0.1f );
321 q_m3x3( vr_q, s->state.velocity_bias );
322
323 q_axis_angle( vr_q, axis, best_vmod );
324 q_m3x3( vr_q, s->state.velocity_bias_pstep );
325
326 /*
327 * Logging
328 */
329 for( int i=0; i<s->prediction_count; i ++ )
330 {
331 struct land_prediction *p = &s->predictions[i];
332
333 float l = p->score;
334
335 if( l < 0.0f )
336 {
337 vg_error( "negative score! (%f)\n", l );
338 }
339
340 l -= min_score;
341 l /= (max_score-min_score);
342 l = 1.0f - l;
343 l *= 255.0f;
344
345 p->colour = l;
346 p->colour <<= 8;
347 p->colour |= 0xff000000;
348 }
349
350
351 v2f steer = { player->input_js1h->axis.value,
352 player->input_js1v->axis.value };
353 v2_normalize_clamp( steer );
354
355 if( (fabsf(steer[1]) > 0.5f) && (s->land_dist >= 1.0f) )
356 {
357 s->state.flip_rate = (1.0f/s->land_dist) * vg_signf(steer[1]) *
358 s->state.reverse ;
359 s->state.flip_time = 0.0f;
360 v3_copy( player->rb.to_world[0], s->state.flip_axis );
361 }
362 else
363 {
364 s->state.flip_rate = 0.0f;
365 v3_zero( s->state.flip_axis );
366 }
367 }
368
369 /*
370 *
371 * Varius physics models
372 * ------------------------------------------------
373 */
374
375 VG_STATIC void skate_apply_grind_model( player_instance *player,
376 rb_ct *manifold, int len )
377 {
378 struct player_skate *s = &player->_skate;
379
380 /* FIXME: Queue audio events instead */
381 if( len == 0 )
382 {
383 if( s->state.activity == k_skate_activity_grind )
384 {
385 #if 0
386 audio_lock();
387 audio_player_set_flags( &audio_player_extra,
388 AUDIO_FLAG_SPACIAL_3D );
389 audio_player_set_position( &audio_player_extra, player.rb.co );
390 audio_player_set_vol( &audio_player_extra, 20.0f );
391 audio_player_playclip( &audio_player_extra, &audio_board[6] );
392 audio_unlock();
393 #endif
394
395 s->state.activity = k_skate_activity_air;
396 }
397 return;
398 }
399
400 v2f steer = { player->input_js1h->axis.value,
401 player->input_js1v->axis.value };
402 v2_normalize_clamp( steer );
403
404 s->state.steery -= steer[0] * k_steer_air * k_rb_delta;
405 s->state.steerx += steer[1] * s->state.reverse * k_steer_air * k_rb_delta;
406
407 #if 0
408 v4f rotate;
409 q_axis_angle( rotate, player->rb.to_world[0], siX );
410 q_mul( rotate, player.rb.q, player.rb.q );
411 #endif
412
413 s->state.slip = 0.0f;
414 s->state.activity = k_skate_activity_grind;
415
416 /* TODO: Compression */
417 v3f up = { 0.0f, 1.0f, 0.0f };
418 float angle = v3_dot( player->rb.to_world[1], up );
419
420 if( fabsf(angle) < 0.99f )
421 {
422 v3f axis;
423 v3_cross( player->rb.to_world[1], up, axis );
424
425 v4f correction;
426 q_axis_angle( correction, axis, k_rb_delta * 10.0f * acosf(angle) );
427 q_mul( correction, player->rb.q, player->rb.q );
428 }
429
430 float const DOWNFORCE = -k_downforce*1.2f*VG_TIMESTEP_FIXED;
431 v3_muladds( player->rb.v, manifold->n, DOWNFORCE, player->rb.v );
432 m3x3_identity( s->state.velocity_bias );
433 m3x3_identity( s->state.velocity_bias_pstep );
434
435 if( s->state.activity_prev != k_skate_activity_grind )
436 {
437 /* FIXME: Queue audio events instead */
438 #if 0
439 audio_lock();
440 audio_player_set_flags( &audio_player_extra,
441 AUDIO_FLAG_SPACIAL_3D );
442 audio_player_set_position( &audio_player_extra, player.rb.co );
443 audio_player_set_vol( &audio_player_extra, 20.0f );
444 audio_player_playclip( &audio_player_extra, &audio_board[5] );
445 audio_unlock();
446 #endif
447 }
448 }
449
450 /*
451 * Air control, no real physics
452 */
453 VG_STATIC void skate_apply_air_model( player_instance *player )
454 {
455 struct player_skate *s = &player->_skate;
456
457 if( s->state.activity != k_skate_activity_air )
458 return;
459
460 if( s->state.activity_prev != k_skate_activity_air )
461 player__approximate_best_trajectory( player );
462
463 m3x3_mulv( s->state.velocity_bias, player->rb.v, player->rb.v );
464 ray_hit hit;
465
466 /*
467 * Prediction
468 */
469 float pstep = VG_TIMESTEP_FIXED * 1.0f;
470 float k_bias = 0.98f;
471
472 v3f pco, pco1, pv;
473 v3_copy( player->rb.co, pco );
474 v3_muls( player->rb.v, 1.0f, pv );
475
476 float time_to_impact = 0.0f;
477 float limiter = 1.0f;
478
479 struct grind_edge *best_grind = NULL;
480 float closest_grind = INFINITY;
481
482 v3f target_normal = { 0.0f, 1.0f, 0.0f };
483 int has_target = 0;
484
485 for( int i=0; i<250; i++ )
486 {
487 v3_copy( pco, pco1 );
488 m3x3_mulv( s->state.velocity_bias, pv, pv );
489
490 pv[1] += -k_gravity * pstep;
491 v3_muladds( pco, pv, pstep, pco );
492
493 ray_hit contact;
494 v3f vdir;
495
496 v3_sub( pco, pco1, vdir );
497 contact.dist = v3_length( vdir );
498 v3_divs( vdir, contact.dist, vdir);
499
500 v3f c0, c1;
501 struct grind_edge *ge = skate_collect_grind_edge( pco, pco1,
502 c0, c1, 0.4f );
503
504 if( ge && (v3_dot((v3f){0.0f,1.0f,0.0f},vdir) < -0.2f ) )
505 {
506 vg_line( ge->p0, ge->p1, 0xff0000ff );
507 vg_line_cross( pco, 0xff0000ff, 0.25f );
508 has_target = 1;
509 break;
510 }
511
512 float orig_dist = contact.dist;
513 if( ray_world( pco1, vdir, &contact ) )
514 {
515 v3_copy( contact.normal, target_normal );
516 has_target = 1;
517 time_to_impact += (contact.dist/orig_dist)*pstep;
518 vg_line_cross( contact.pos, 0xffff0000, 0.25f );
519 break;
520 }
521 time_to_impact += pstep;
522 }
523
524 if( has_target )
525 {
526 float angle = v3_dot( player->rb.to_world[1], target_normal );
527 v3f axis;
528 v3_cross( player->rb.to_world[1], target_normal, axis );
529
530 limiter = vg_minf( 5.0f, time_to_impact )/5.0f;
531 limiter = 1.0f-limiter;
532 limiter *= limiter;
533 limiter = 1.0f-limiter;
534
535 if( fabsf(angle) < 0.99f )
536 {
537 v4f correction;
538 q_axis_angle( correction, axis,
539 acosf(angle)*(1.0f-limiter)*2.0f*VG_TIMESTEP_FIXED );
540 q_mul( correction, player->rb.q, player->rb.q );
541 }
542 }
543
544 v2f steer = { player->input_js1h->axis.value,
545 player->input_js1v->axis.value };
546 v2_normalize_clamp( steer );
547
548 s->state.steery -= steer[0] * k_steer_air * VG_TIMESTEP_FIXED;
549 s->state.steerx += steer[1] * s->state.reverse * k_steer_air
550 * limiter * k_rb_delta;
551 s->land_dist = time_to_impact;
552 v3_copy( target_normal, s->land_normal );
553 }
554
555 VG_STATIC void skate_get_board_points( player_instance *player,
556 v3f front, v3f back )
557 {
558 v3f pos_front = {0.0f,0.0f,-k_board_length},
559 pos_back = {0.0f,0.0f, k_board_length};
560
561 m4x3_mulv( player->rb.to_world, pos_front, front );
562 m4x3_mulv( player->rb.to_world, pos_back, back );
563 }
564
565 /*
566 * Casts and pushes a sphere-spring model into the world
567 */
568 VG_STATIC int skate_simulate_spring( player_instance *player,
569 v3f pos )
570 {
571 struct player_skate *s = &player->_skate;
572
573 float mod = 0.7f * player->input_grab->axis.value + 0.3f,
574 spring_k = mod * k_spring_force,
575 damp_k = mod * k_spring_dampener,
576 disp_k = 0.4f;
577
578 v3f start, end;
579 v3_copy( pos, start );
580 v3_muladds( pos, player->rb.to_world[1], -disp_k, end );
581
582 float t;
583 v3f n;
584 int hit_info = spherecast_world( start, end, 0.2f, &t, n );
585
586 if( hit_info != -1 )
587 {
588 v3f F, delta;
589 v3_sub( start, player->rb.co, delta );
590
591 float displacement = vg_clampf( 1.0f-t, 0.0f, 1.0f ),
592 damp =
593 vg_maxf( 0.0f, v3_dot( player->rb.to_world[1], player->rb.v ) );
594
595 v3_muls( player->rb.to_world[1], displacement*spring_k*k_rb_delta -
596 damp*damp_k*k_rb_delta, F );
597
598 v3_muladds( player->rb.v, F, 1.0f, player->rb.v );
599
600 /* Angular velocity */
601 v3f wa;
602 v3_cross( delta, F, wa );
603 v3_muladds( player->rb.w, wa, k_spring_angular, player->rb.w );
604
605 v3_lerp( start, end, t, pos );
606 return 1;
607 }
608 else
609 {
610 v3_copy( end, pos );
611 return 0;
612 }
613 }
614
615
616 /*
617 * Handles connection between the player and the ground
618 */
619 VG_STATIC void skate_apply_interface_model( player_instance *player,
620 rb_ct *manifold, int len )
621 {
622 struct player_skate *s = &player->_skate;
623
624 if( !((s->state.activity == k_skate_activity_ground) ||
625 (s->state.activity == k_skate_activity_air )) )
626 return;
627
628 if( s->state.activity == k_skate_activity_air )
629 s->debug_normal_pressure = 0.0f;
630 else
631 s->debug_normal_pressure = v3_dot( player->rb.to_world[1], player->rb.v );
632
633 /* springs */
634 v3f spring0, spring1;
635
636 skate_get_board_points( player, spring1, spring0 );
637 int spring_hit0 = 0, //skate_simulate_spring( player, s, spring0 ),
638 spring_hit1 = 0; //skate_simulate_spring( player, s, spring1 );
639
640 v3f animavg, animdelta;
641 v3_add( spring0, spring1, animavg );
642 v3_muls( animavg, 0.5f, animavg );
643
644 v3_sub( spring1, spring0, animdelta );
645 v3_normalize( animdelta );
646
647 m4x3_mulv( player->rb.to_local, animavg, s->board_offset );
648
649 float dx = -v3_dot( animdelta, player->rb.to_world[2] ),
650 dy = v3_dot( animdelta, player->rb.to_world[1] );
651
652 float angle = -atan2f( dy, dx );
653 q_axis_angle( s->board_rotation, (v3f){1.0f,0.0f,0.0f}, angle );
654
655 int lift_frames_limit = 6;
656
657 /* Surface connection */
658 if( len == 0 && !(spring_hit0 && spring_hit1) )
659 {
660 s->state.lift_frames ++;
661
662 if( s->state.lift_frames >= lift_frames_limit )
663 s->state.activity = k_skate_activity_air;
664 }
665 else
666 {
667 v3f surface_avg;
668 v3_zero( surface_avg );
669
670 for( int i=0; i<len; i++ )
671 v3_add( surface_avg, manifold[i].n, surface_avg );
672 v3_normalize( surface_avg );
673
674 if( v3_dot( player->rb.v, surface_avg ) > 0.7f )
675 {
676 s->state.lift_frames ++;
677
678 if( s->state.lift_frames >= lift_frames_limit )
679 s->state.activity = k_skate_activity_air;
680 }
681 else
682 {
683 s->state.activity = k_skate_activity_ground;
684 s->state.lift_frames = 0;
685 v3f projected, axis;
686
687 if( s->state.activity_prev == k_skate_activity_air )
688 {
689 player->cam_land_punch_v += v3_dot( player->rb.v, surface_avg ) *
690 k_cam_punch;
691 }
692
693 float const DOWNFORCE = -k_downforce*VG_TIMESTEP_FIXED;
694 v3_muladds( player->rb.v, player->rb.to_world[1],
695 DOWNFORCE, player->rb.v );
696
697 float d = v3_dot( player->rb.to_world[2], surface_avg );
698 v3_muladds( surface_avg, player->rb.to_world[2], -d, projected );
699 v3_normalize( projected );
700
701 float angle = v3_dot( player->rb.to_world[1], projected );
702 v3_cross( player->rb.to_world[1], projected, axis );
703
704 if( fabsf(angle) < 0.9999f )
705 {
706 v4f correction;
707 q_axis_angle( correction, axis,
708 acosf(angle)*4.0f*VG_TIMESTEP_FIXED );
709 q_mul( correction, player->rb.q, player->rb.q );
710 }
711 }
712 }
713 }
714
715 VG_STATIC int player_skate_trick_input( player_instance *player );
716 VG_STATIC void skate_apply_trick_model( player_instance *player )
717 {
718 struct player_skate *s = &player->_skate;
719
720 v3f Fd, Fs, F;
721 v3f strength = { 3.7f, 3.6f, 8.0f };
722
723 v3_muls( s->board_trick_residualv, -4.0f , Fd );
724 v3_muls( s->board_trick_residuald, -10.0f, Fs );
725 v3_add( Fd, Fs, F );
726 v3_mul( strength, F, F );
727
728 v3_muladds( s->board_trick_residualv, F, k_rb_delta,
729 s->board_trick_residualv );
730 v3_muladds( s->board_trick_residuald, s->board_trick_residualv,
731 k_rb_delta, s->board_trick_residuald );
732
733 if( s->state.activity == k_skate_activity_air )
734 {
735 if( v3_length2( s->state.trick_vel ) < 0.0001f )
736 return;
737
738 int carry_on = player_skate_trick_input( player );
739
740 /* we assume velocities share a common divisor, in which case the
741 * interval is the minimum value (if not zero) */
742
743 float min_rate = 99999.0f;
744
745 for( int i=0; i<3; i++ )
746 {
747 float v = s->state.trick_vel[i];
748 if( (v > 0.0f) && (v < min_rate) )
749 min_rate = v;
750 }
751
752 float interval = 1.0f / min_rate,
753 current = floorf( s->state.trick_time / interval ),
754 next_end = (current+1.0f) * interval;
755
756
757 /* integrate trick velocities */
758 v3_muladds( s->state.trick_euler, s->state.trick_vel, k_rb_delta,
759 s->state.trick_euler );
760
761 if( !carry_on && (s->state.trick_time + k_rb_delta >= next_end) )
762 {
763 s->state.trick_time = 0.0f;
764 s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
765 s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
766 s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
767 v3_copy( s->state.trick_vel, s->board_trick_residualv );
768 v3_zero( s->state.trick_vel );
769 }
770
771 s->state.trick_time += k_rb_delta;
772 }
773 else
774 {
775 if( (s->state.lift_frames == 0)
776 && (v3_length2(s->state.trick_vel) >= 0.0001f ) &&
777 s->state.trick_time > 0.2f)
778 {
779 player__dead_transition( player );
780 }
781
782 s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
783 s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
784 s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
785 s->state.trick_time = 0.0f;
786 v3_zero( s->state.trick_vel );
787 }
788 }
789
790 VG_STATIC void skate_apply_grab_model( player_instance *player )
791 {
792 struct player_skate *s = &player->_skate;
793
794 float grabt = player->input_grab->axis.value;
795
796 if( grabt > 0.5f )
797 {
798 v2_muladds( s->state.grab_mouse_delta, vg.mouse_delta, 0.02f,
799 s->state.grab_mouse_delta );
800
801 v2_normalize_clamp( s->state.grab_mouse_delta );
802 }
803 else
804 v2_zero( s->state.grab_mouse_delta );
805
806 s->state.grabbing = vg_lerpf( s->state.grabbing, grabt, 8.4f*k_rb_delta );
807 }
808
809 /*
810 * Computes friction and surface interface model
811 */
812 VG_STATIC void skate_apply_friction_model( player_instance *player )
813 {
814 struct player_skate *s = &player->_skate;
815
816 if( s->state.activity != k_skate_activity_ground )
817 return;
818
819 /*
820 * Computing localized friction forces for controlling the character
821 * Friction across X is significantly more than Z
822 */
823
824 v3f vel;
825 m3x3_mulv( player->rb.to_local, player->rb.v, vel );
826 float slip = 0.0f;
827
828 if( fabsf(vel[2]) > 0.01f )
829 slip = fabsf(-vel[0] / vel[2]) * vg_signf(vel[0]);
830
831 if( fabsf( slip ) > 1.2f )
832 slip = vg_signf( slip ) * 1.2f;
833
834 s->state.slip = slip;
835 s->state.reverse = -vg_signf(vel[2]);
836
837 vel[0] += vg_cfrictf( vel[0], k_friction_lat * k_rb_delta );
838 vel[2] += vg_cfrictf( vel[2], k_friction_resistance * k_rb_delta );
839
840 /* Pushing additive force */
841
842 if( !player->input_jump->button.value )
843 {
844 if( player->input_push->button.value )
845 {
846 if( (vg.time - s->state.cur_push) > 0.25 )
847 s->state.start_push = vg.time;
848
849 s->state.cur_push = vg.time;
850
851 double push_time = vg.time - s->state.start_push;
852
853 float cycle_time = push_time*k_push_cycle_rate,
854 accel = k_push_accel * (sinf(cycle_time)*0.5f+0.5f),
855 amt = accel * VG_TIMESTEP_FIXED,
856 current = v3_length( vel ),
857 new_vel = vg_minf( current + amt, k_max_push_speed ),
858 delta = new_vel - vg_minf( current, k_max_push_speed );
859
860 vel[2] += delta * -s->state.reverse;
861 }
862 }
863
864 /* Send back to velocity */
865 m3x3_mulv( player->rb.to_world, vel, player->rb.v );
866
867 /* Steering */
868 float input = player->input_js1h->axis.value,
869 grab = player->input_grab->axis.value,
870 steer = input * (1.0f-(s->state.jump_charge+grab)*0.4f),
871 steer_scaled = vg_signf(steer) * powf(steer,2.0f) * k_steer_ground;
872
873 s->state.steery -= steer_scaled * k_rb_delta;
874 }
875
876 VG_STATIC void skate_apply_jump_model( player_instance *player )
877 {
878 struct player_skate *s = &player->_skate;
879 int charging_jump_prev = s->state.charging_jump;
880 s->state.charging_jump = player->input_jump->button.value;
881
882 /* Cannot charge this in air */
883 if( s->state.activity != k_skate_activity_ground )
884 s->state.charging_jump = 0;
885
886 if( s->state.charging_jump )
887 {
888 s->state.jump_charge += k_rb_delta * k_jump_charge_speed;
889
890 if( !charging_jump_prev )
891 s->state.jump_dir = s->state.reverse>0.0f? 1: 0;
892 }
893 else
894 {
895 s->state.jump_charge -= k_jump_charge_speed * VG_TIMESTEP_FIXED;
896 }
897
898 s->state.jump_charge = vg_clampf( s->state.jump_charge, 0.0f, 1.0f );
899
900 if( s->state.activity == k_skate_activity_air )
901 return;
902
903 /* player let go after charging past 0.2: trigger jump */
904 if( (!s->state.charging_jump) && (s->state.jump_charge > 0.2f) )
905 {
906 v3f jumpdir;
907
908 /* Launch more up if alignment is up else improve velocity */
909 float aup = v3_dot( (v3f){0.0f,1.0f,0.0f}, player->rb.to_world[1] ),
910 mod = 0.5f,
911 dir = mod + fabsf(aup)*(1.0f-mod);
912
913 v3_copy( player->rb.v, jumpdir );
914 v3_normalize( jumpdir );
915 v3_muls( jumpdir, 1.0f-dir, jumpdir );
916 v3_muladds( jumpdir, player->rb.to_world[1], dir, jumpdir );
917 v3_normalize( jumpdir );
918
919 float force = k_jump_force*s->state.jump_charge;
920 v3_muladds( player->rb.v, jumpdir, force, player->rb.v );
921 s->state.jump_charge = 0.0f;
922 s->state.jump_time = vg.time;
923
924 v2f steer = { player->input_js1h->axis.value,
925 player->input_js1v->axis.value };
926 v2_normalize_clamp( steer );
927
928 float maxspin = k_steer_air * k_rb_delta * k_spin_boost;
929 s->state.steery_s = -steer[0] * maxspin;
930 s->state.steerx = s->state.steerx_s;
931 s->state.lift_frames ++;
932
933 /* FIXME audio events */
934 #if 0
935 audio_lock();
936 audio_player_set_flags( &audio_player_extra, AUDIO_FLAG_SPACIAL_3D );
937 audio_player_set_position( &audio_player_extra, player.rb.co );
938 audio_player_set_vol( &audio_player_extra, 20.0f );
939 audio_player_playclip( &audio_player_extra, &audio_jumps[rand()%2] );
940 audio_unlock();
941 #endif
942 }
943 }
944
945 VG_STATIC void skate_apply_pump_model( player_instance *player )
946 {
947 struct player_skate *s = &player->_skate;
948
949 /* Throw / collect routine
950 *
951 * TODO: Max speed boost
952 */
953 if( player->input_grab->axis.value > 0.5f )
954 {
955 if( s->state.activity == k_skate_activity_ground )
956 {
957 /* Throw */
958 v3_muls( player->rb.to_world[1], k_mmthrow_scale, s->state.throw_v );
959 }
960 }
961 else
962 {
963 /* Collect */
964 float doty = v3_dot( player->rb.to_world[1], s->state.throw_v );
965
966 v3f Fl, Fv;
967 v3_muladds( s->state.throw_v, player->rb.to_world[1], -doty, Fl);
968
969 if( s->state.activity == k_skate_activity_ground )
970 {
971 v3_muladds( player->rb.v, Fl, k_mmcollect_lat, player->rb.v );
972 v3_muladds( s->state.throw_v, Fl, -k_mmcollect_lat, s->state.throw_v );
973 }
974
975 v3_muls( player->rb.to_world[1], -doty, Fv );
976 v3_muladds( player->rb.v, Fv, k_mmcollect_vert, player->rb.v );
977 v3_muladds( s->state.throw_v, Fv, k_mmcollect_vert, s->state.throw_v );
978 }
979
980 /* Decay */
981 if( v3_length2( s->state.throw_v ) > 0.0001f )
982 {
983 v3f dir;
984 v3_copy( s->state.throw_v, dir );
985 v3_normalize( dir );
986
987 float max = v3_dot( dir, s->state.throw_v ),
988 amt = vg_minf( k_mmdecay * k_rb_delta, max );
989 v3_muladds( s->state.throw_v, dir, -amt, s->state.throw_v );
990 }
991 }
992
993 VG_STATIC void skate_apply_cog_model( player_instance *player )
994 {
995 struct player_skate *s = &player->_skate;
996
997 v3f ideal_cog, ideal_diff;
998 v3_muladds( player->rb.co, player->rb.to_world[1],
999 1.0f-player->input_grab->axis.value, ideal_cog );
1000 v3_sub( ideal_cog, s->state.cog, ideal_diff );
1001
1002 /* Apply velocities */
1003 v3f rv;
1004 v3_sub( player->rb.v, s->state.cog_v, rv );
1005
1006 v3f F;
1007 v3_muls( ideal_diff, -k_cog_spring * k_rb_rate, F );
1008 v3_muladds( F, rv, -k_cog_damp * k_rb_rate, F );
1009
1010 float ra = k_cog_mass_ratio,
1011 rb = 1.0f-k_cog_mass_ratio;
1012
1013 /* Apply forces & intergrate */
1014 v3_muladds( s->state.cog_v, F, -rb, s->state.cog_v );
1015 s->state.cog_v[1] += -9.8f * k_rb_delta;
1016 v3_muladds( s->state.cog, s->state.cog_v, k_rb_delta, s->state.cog );
1017 }
1018
1019 VG_STATIC void skate_collision_response( player_instance *player,
1020 rb_ct *manifold, int len )
1021 {
1022 struct player_skate *s = &player->_skate;
1023
1024 for( int j=0; j<10; j++ )
1025 {
1026 for( int i=0; i<len; i++ )
1027 {
1028 struct contact *ct = &manifold[i];
1029
1030 v3f dv, delta;
1031 v3_sub( ct->co, player->rb.co, delta );
1032 v3_cross( player->rb.w, delta, dv );
1033 v3_add( player->rb.v, dv, dv );
1034
1035 float vn = -v3_dot( dv, ct->n );
1036 vn += ct->bias;
1037
1038 float temp = ct->norm_impulse;
1039 ct->norm_impulse = vg_maxf( temp + vn, 0.0f );
1040 vn = ct->norm_impulse - temp;
1041
1042 v3f impulse;
1043 v3_muls( ct->n, vn, impulse );
1044
1045 if( fabsf(v3_dot( impulse, player->rb.to_world[2] )) > 10.0f ||
1046 fabsf(v3_dot( impulse, player->rb.to_world[1] )) > 50.0f )
1047 {
1048 player__dead_transition( player );
1049 return;
1050 }
1051
1052 v3_add( impulse, player->rb.v, player->rb.v );
1053 v3_cross( delta, impulse, impulse );
1054
1055 /*
1056 * W Impulses are limited to the Y and X axises, we don't really want
1057 * roll angular velocities being included.
1058 *
1059 * Can also tweak the resistance of each axis here by scaling the wx,wy
1060 * components.
1061 */
1062
1063 float wy = v3_dot( player->rb.to_world[1], impulse ) * 0.8f,
1064 wx = v3_dot( player->rb.to_world[0], impulse ) * 1.0f;
1065
1066 v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
1067 v3_muladds( player->rb.w, player->rb.to_world[0], wx, player->rb.w );
1068 }
1069 }
1070 }
1071
1072 VG_STATIC void skate_integrate( player_instance *player )
1073 {
1074 struct player_skate *s = &player->_skate;
1075
1076 /* integrate rigidbody velocities */
1077 v3f gravity = { 0.0f, -9.6f, 0.0f };
1078 v3_muladds( player->rb.v, gravity, k_rb_delta, player->rb.v );
1079 v3_muladds( player->rb.co, player->rb.v, k_rb_delta, player->rb.co );
1080
1081 float decay_rate = 0.5f*0.125f;
1082
1083 if( s->state.activity == k_skate_activity_air )
1084 {
1085 float dist = 1.0f-(s->land_dist/4.0f);
1086 decay_rate = 0.5f * vg_maxf( dist*dist, 0.0f );
1087 }
1088
1089 v3_lerp( player->rb.w, (v3f){0.0f,0.0f,0.0f}, decay_rate, player->rb.w );
1090
1091 if( v3_length2( player->rb.w ) > 0.0f )
1092 {
1093 v4f rotation;
1094 v3f axis;
1095 v3_copy( player->rb.w, axis );
1096
1097 float mag = v3_length( axis );
1098 v3_divs( axis, mag, axis );
1099 q_axis_angle( rotation, axis, mag*k_rb_delta );
1100 q_mul( rotation, player->rb.q, player->rb.q );
1101 }
1102
1103 /* integrate steering velocities */
1104 v4f rotate;
1105 float l = (s->state.activity == k_skate_activity_air)? 0.04f: 0.24f;
1106
1107 s->state.steery_s = vg_lerpf( s->state.steery_s, s->state.steery, l );
1108 s->state.steerx_s = vg_lerpf( s->state.steerx_s, s->state.steerx, l );
1109
1110 q_axis_angle( rotate, player->rb.to_world[1], s->state.steery_s );
1111 q_mul( rotate, player->rb.q, player->rb.q );
1112
1113 q_axis_angle( rotate, player->rb.to_world[0], s->state.steerx_s );
1114 q_mul( rotate, player->rb.q, player->rb.q );
1115
1116 s->state.steerx = 0.0f;
1117 s->state.steery = 0.0f;
1118
1119 s->state.flip_time += s->state.flip_rate * k_rb_delta;
1120 rb_update_transform( &player->rb );
1121 }
1122
1123 /*
1124 * 1 2 or 3
1125 */
1126
1127 VG_STATIC int player_skate_trick_input( player_instance *player )
1128 {
1129 return (player->input_trick0->button.value) |
1130 (player->input_trick1->button.value << 1) |
1131 (player->input_trick2->button.value << 1) |
1132 (player->input_trick2->button.value);
1133 }
1134
1135 VG_STATIC void player__skate_pre_update( player_instance *player )
1136 {
1137 struct player_skate *s = &player->_skate;
1138
1139 if( vg_input_button_down( player->input_use ) )
1140 {
1141 player->subsystem = k_player_subsystem_walk;
1142
1143 v3f angles;
1144 v3_copy( player->cam.angles, angles );
1145 angles[2] = 0.0f;
1146
1147 player__walk_transition( player, angles );
1148 return;
1149 }
1150
1151 int trick_id;
1152 if( (s->state.lift_frames > 0) &&
1153 (trick_id = player_skate_trick_input( player )) )
1154 {
1155 if( (vg.time - s->state.jump_time) < 0.1f )
1156 {
1157 v3_zero( s->state.trick_vel );
1158 s->state.trick_time = 0.0f;
1159
1160 if( trick_id == 1 )
1161 {
1162 s->state.trick_vel[0] = 3.0f;
1163 }
1164 else if( trick_id == 2 )
1165 {
1166 s->state.trick_vel[2] = 3.0f;
1167 }
1168 else if( trick_id == 3 )
1169 {
1170 s->state.trick_vel[0] = 2.0f;
1171 s->state.trick_vel[2] = 2.0f;
1172 }
1173 }
1174 }
1175 }
1176
1177 VG_STATIC void player__skate_post_update( player_instance *player )
1178 {
1179 struct player_skate *s = &player->_skate;
1180 for( int i=0; i<s->prediction_count; i++ )
1181 {
1182 struct land_prediction *p = &s->predictions[i];
1183
1184 for( int j=0; j<p->log_length - 1; j ++ )
1185 vg_line( p->log[j], p->log[j+1], p->colour );
1186
1187 vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
1188
1189 v3f p1;
1190 v3_add( p->log[p->log_length-1], p->n, p1 );
1191 vg_line( p->log[p->log_length-1], p1, 0xffffffff );
1192
1193 vg_line_pt3( p->apex, 0.02f, 0xffffffff );
1194 }
1195
1196 vg_line_pt3( s->state.apex, 0.200f, 0xff0000ff );
1197 vg_line_pt3( s->state.apex, 0.201f, 0xff00ffff );
1198 }
1199
1200 VG_STATIC void player__skate_update( player_instance *player )
1201 {
1202 struct player_skate *s = &player->_skate;
1203 v3_copy( player->rb.co, s->state.prev_pos );
1204 s->state.activity_prev = s->state.activity;
1205
1206 /* Setup colliders */
1207 m4x3f mtx_front, mtx_back;
1208 m3x3_identity( mtx_front );
1209 m3x3_identity( mtx_back );
1210
1211 skate_get_board_points( player, mtx_front[3], mtx_back[3] );
1212
1213 s->sphere_back.radius = 0.3f;
1214 s->sphere_front.radius = 0.3f;
1215
1216 /* create manifold(s) */
1217 rb_ct manifold[72],
1218 *interface_manifold = NULL,
1219 *grind_manifold = NULL;
1220
1221 int
1222 len_front = skate_collide_smooth( player, mtx_front,
1223 &s->sphere_front, manifold ),
1224 len_back = skate_collide_smooth( player, mtx_back,
1225 &s->sphere_back, &manifold[len_front] ),
1226 interface_len = len_front + len_back;
1227
1228 /* try to slap both wheels onto the ground when landing to prevent mega
1229 * angular velocities being added */
1230 if( (s->state.activity == k_skate_activity_air) && (len_front != len_back) )
1231 {
1232 v3f trace_from, trace_dir;
1233 v3_muls( player->rb.to_world[1], -1.0f, trace_dir );
1234
1235 if( len_front )
1236 v3_copy( mtx_back[3], trace_from );
1237 else
1238 v3_copy( mtx_front[3], trace_from );
1239
1240 ray_hit ray;
1241 ray.dist = 0.6f;
1242
1243 if( ray_world( trace_from, trace_dir, &ray ) )
1244 {
1245 rb_ct *ct = &manifold[ interface_len ];
1246
1247 v3_copy( ray.pos, ct->co );
1248 v3_copy( ray.normal, ct->n );
1249 ct->p = 0.0f;
1250
1251 interface_len ++;
1252 }
1253 }
1254
1255 interface_manifold = manifold;
1256 grind_manifold = manifold + interface_len;
1257
1258 int grind_len = skate_grind_collide( player, grind_manifold );
1259
1260 for( int i=0; i<interface_len+grind_len; i ++ )
1261 {
1262 rb_prepare_contact( &manifold[i] );
1263 rb_debug_contact( &manifold[i] );
1264 }
1265
1266 skate_apply_grind_model( player, grind_manifold, grind_len );
1267 skate_apply_interface_model( player, manifold, interface_len );
1268
1269 skate_apply_pump_model( player );
1270 skate_apply_cog_model( player );
1271 skate_collision_response( player, manifold, interface_len + grind_len );
1272
1273 skate_apply_grab_model( player );
1274 skate_apply_friction_model( player );
1275 skate_apply_jump_model( player );
1276 skate_apply_air_model( player );
1277 skate_apply_trick_model( player );
1278
1279 skate_integrate( player );
1280
1281 vg_line_pt3( s->state.cog, 0.1f, VG__WHITE );
1282 vg_line_pt3( s->state.cog, 0.11f, VG__WHITE );
1283 vg_line_pt3( s->state.cog, 0.12f, VG__WHITE );
1284 vg_line_pt3( s->state.cog, 0.13f, VG__WHITE );
1285 vg_line_pt3( s->state.cog, 0.14f, VG__WHITE );
1286
1287 vg_line( player->rb.co, s->state.cog, VG__RED );
1288
1289 teleport_gate *gate;
1290 if( (gate = world_intersect_gates( player->rb.co, s->state.prev_pos )) )
1291 {
1292 m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
1293 m3x3_mulv( gate->transport, player->rb.v, player->rb.v );
1294 m4x3_mulv( gate->transport, s->state.cog, s->state.cog );
1295 m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
1296 m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
1297
1298 v4f transport_rotation;
1299 m3x3_q( gate->transport, transport_rotation );
1300 q_mul( transport_rotation, player->rb.q, player->rb.q );
1301 rb_update_transform( &player->rb );
1302
1303 s->state_gate_storage = s->state;
1304 player__pass_gate( player, gate );
1305 }
1306 }
1307
1308 VG_STATIC void player__skate_im_gui( player_instance *player )
1309 {
1310 struct player_skate *s = &player->_skate;
1311
1312 /* FIXME: Compression */
1313 player__debugtext( 1, "V: %5.2f %5.2f %5.2f",player->rb.v[0],
1314 player->rb.v[1],
1315 player->rb.v[2] );
1316 player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
1317 player->rb.co[1],
1318 player->rb.co[2] );
1319 player__debugtext( 1, "W: %5.2f %5.2f %5.2f",player->rb.w[0],
1320 player->rb.w[1],
1321 player->rb.w[2] );
1322
1323 player__debugtext( 1, "activity: %s",
1324 (const char *[]){ "k_skate_activity_air",
1325 "k_skate_activity_ground",
1326 "k_skate_activity_grind }" }
1327 [s->state.activity] );
1328 player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
1329 s->state.steerx_s, s->state.steery_s,
1330 k_steer_ground, k_steer_air );
1331 player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate,
1332 s->state.flip_time );
1333 player__debugtext( 1, "trickv: %.2f %.2f %.2f",
1334 s->state.trick_vel[0],
1335 s->state.trick_vel[1],
1336 s->state.trick_vel[2] );
1337 player__debugtext( 1, "tricke: %.2f %.2f %.2f",
1338 s->state.trick_euler[0],
1339 s->state.trick_euler[1],
1340 s->state.trick_euler[2] );
1341 }
1342
1343 VG_STATIC void player__skate_animate( player_instance *player,
1344 player_animation *dest )
1345 {
1346 struct player_skate *s = &player->_skate;
1347 struct player_avatar *av = player->playeravatar;
1348 struct skeleton *sk = &av->sk;
1349
1350 /* Head */
1351 float kheight = 2.0f,
1352 kleg = 0.6f;
1353
1354 v3f offset;
1355 v3_zero( offset );
1356
1357 m4x3_mulv( player->rb.to_local, s->state.cog, offset );
1358 v3_muls( offset, -4.0f, offset );
1359
1360 float curspeed = v3_length( player->rb.v ),
1361 kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
1362 kicks = (vg_randf()-0.5f)*2.0f*kickspeed,
1363 sign = vg_signf( kicks );
1364
1365 s->wobble[0] = vg_lerpf( s->wobble[0], kicks*kicks*sign, 6.0f*vg.time_delta);
1366 s->wobble[1] = vg_lerpf( s->wobble[1], s->wobble[0], 2.4f*vg.time_delta);
1367
1368 offset[0] *= 0.26f;
1369 offset[0] += s->wobble[1]*3.0f;
1370
1371 offset[1] *= -0.3f;
1372 offset[2] *= 0.01f;
1373
1374 offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(s->blend_slide)*0.9f);
1375 offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
1376
1377 /*
1378 * Animation blending
1379 * ===========================================
1380 */
1381
1382 /* sliding */
1383 {
1384 float desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
1385 s->blend_slide = vg_lerpf( s->blend_slide, desired, 2.4f*vg.time_delta);
1386 }
1387
1388 /* movement information */
1389 {
1390 int iair = (s->state.activity == k_skate_activity_air) ||
1391 (s->state.activity == k_skate_activity_grind );
1392
1393 float dirz = s->state.reverse > 0.0f? 0.0f: 1.0f,
1394 dirx = s->state.slip < 0.0f? 0.0f: 1.0f,
1395 fly = iair? 1.0f: 0.0f;
1396
1397 s->blend_z = vg_lerpf( s->blend_z, dirz, 2.4f*vg.time_delta );
1398 s->blend_x = vg_lerpf( s->blend_x, dirx, 0.6f*vg.time_delta );
1399 s->blend_fly = vg_lerpf( s->blend_fly, fly, 2.4f*vg.time_delta );
1400 }
1401
1402 mdl_keyframe apose[32], bpose[32];
1403 mdl_keyframe ground_pose[32];
1404 {
1405 /* when the player is moving fast he will crouch down a little bit */
1406 float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
1407 s->blend_stand = vg_lerpf( s->blend_stand, stand, 6.0f*vg.time_delta );
1408
1409 /* stand/crouch */
1410 float dir_frame = s->blend_z * (15.0f/30.0f),
1411 stand_blend = offset[1]*-2.0f;
1412
1413 v3f local_cog;
1414 m4x3_mulv( player->rb.to_local, s->state.cog, local_cog );
1415
1416 stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 );
1417
1418 skeleton_sample_anim( sk, s->anim_stand, dir_frame, apose );
1419 skeleton_sample_anim( sk, s->anim_highg, dir_frame, bpose );
1420 skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
1421
1422 /* sliding */
1423 float slide_frame = s->blend_x * (15.0f/30.0f);
1424 skeleton_sample_anim( sk, s->anim_slide, slide_frame, bpose );
1425 skeleton_lerp_pose( sk, apose, bpose, s->blend_slide, apose );
1426
1427 /* pushing */
1428 double push_time = vg.time - s->state.start_push;
1429 s->blend_push = vg_lerpf( s->blend_push,
1430 (vg.time - s->state.cur_push) < 0.125,
1431 6.0f*vg.time_delta );
1432
1433 float pt = push_time + vg.accumulator;
1434 if( s->state.reverse > 0.0f )
1435 skeleton_sample_anim( sk, s->anim_push, pt, bpose );
1436 else
1437 skeleton_sample_anim( sk, s->anim_push_reverse, pt, bpose );
1438
1439 skeleton_lerp_pose( sk, apose, bpose, s->blend_push, apose );
1440
1441 /* trick setup */
1442 float jump_start_frame = 14.0f/30.0f;
1443
1444 float charge = s->state.jump_charge;
1445 s->blend_jump = vg_lerpf( s->blend_jump, charge, 8.4f*vg.time_delta );
1446
1447 float setup_frame = charge * jump_start_frame,
1448 setup_blend = vg_minf( s->blend_jump, 1.0f );
1449
1450 float jump_frame = (vg.time - s->state.jump_time) + jump_start_frame;
1451 if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
1452 setup_frame = jump_frame;
1453
1454 struct skeleton_anim *jump_anim = s->state.jump_dir?
1455 s->anim_ollie:
1456 s->anim_ollie_reverse;
1457
1458 skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose );
1459 skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
1460 }
1461
1462 mdl_keyframe air_pose[32];
1463 {
1464 float target = -player->input_js1h->axis.value;
1465 s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
1466
1467 float air_frame = (s->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
1468 skeleton_sample_anim( sk, s->anim_air, air_frame, apose );
1469
1470 static v2f grab_choice;
1471
1472 v2f grab_input = { player->input_js2h->axis.value,
1473 player->input_js2v->axis.value };
1474 v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
1475 if( v2_length2( grab_input ) <= 0.001f )
1476 grab_input[0] = -1.0f;
1477 else
1478 v2_normalize_clamp( grab_input );
1479 v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
1480
1481 float ang = atan2f( grab_choice[0], grab_choice[1] ),
1482 ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
1483 grab_frame = ang_unit * (15.0f/30.0f);
1484
1485 skeleton_sample_anim( sk, s->anim_grabs, grab_frame, bpose );
1486 skeleton_lerp_pose( sk, apose, bpose, s->state.grabbing, air_pose );
1487 }
1488
1489 skeleton_lerp_pose( sk, ground_pose, air_pose, s->blend_fly, dest->pose );
1490
1491 float add_grab_mod = 1.0f - s->blend_fly;
1492
1493 /* additive effects */
1494 {
1495 u32 apply_to[] = { av->id_hip,
1496 av->id_ik_hand_l,
1497 av->id_ik_hand_r,
1498 av->id_ik_elbow_l,
1499 av->id_ik_elbow_r };
1500
1501 for( int i=0; i<vg_list_size(apply_to); i ++ )
1502 {
1503 dest->pose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
1504 dest->pose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
1505 }
1506
1507 mdl_keyframe *kf_board = &dest->pose[av->id_board-1],
1508 *kf_foot_l = &dest->pose[av->id_ik_foot_l-1],
1509 *kf_foot_r = &dest->pose[av->id_ik_foot_r-1];
1510
1511 v3f bo;
1512 v3_muls( s->board_offset, add_grab_mod, bo );
1513
1514 v3_add( bo, kf_board->co, kf_board->co );
1515 v3_add( bo, kf_foot_l->co, kf_foot_l->co );
1516 v3_add( bo, kf_foot_r->co, kf_foot_r->co );
1517
1518 #if 0
1519 m3x3f c;
1520 q_m3x3( s->board_rotation, c );
1521 #endif
1522
1523 v4f qtotal;
1524
1525 v4f qtrickr, qyawr, qpitchr, qrollr;
1526 v3f eulerr;
1527
1528
1529
1530 v3_muls( s->board_trick_residuald, VG_TAUf, eulerr );
1531
1532 q_axis_angle( qyawr, (v3f){0.0f,1.0f,0.0f}, eulerr[0] * 0.5f );
1533 q_axis_angle( qpitchr, (v3f){1.0f,0.0f,0.0f}, eulerr[1] );
1534 q_axis_angle( qrollr, (v3f){0.0f,0.0f,1.0f}, eulerr[2] );
1535
1536 q_mul( qpitchr, qrollr, qtrickr );
1537 q_mul( qyawr, qtrickr, qtrickr );
1538 q_mul( s->board_rotation, qtrickr, qtotal );
1539 q_normalize( qtotal );
1540
1541 q_mul( qtotal, kf_board->q, kf_board->q );
1542
1543
1544 v3f d;
1545 v3_sub( kf_foot_l->co, bo, d );
1546 q_mulv( qtotal, d, d );
1547 v3_add( bo, d, kf_foot_l->co );
1548
1549 v3_sub( kf_foot_r->co, bo, d );
1550 q_mulv( qtotal, d, d );
1551 v3_add( bo, d, kf_foot_r->co );
1552
1553 q_mul( s->board_rotation, kf_board->q, kf_board->q );
1554 q_normalize( kf_board->q );
1555
1556
1557 /* trick rotation */
1558 v4f qtrick, qyaw, qpitch, qroll;
1559 v3f euler;
1560 v3_muls( s->state.trick_euler, VG_TAUf, euler );
1561
1562 q_axis_angle( qyaw, (v3f){0.0f,1.0f,0.0f}, euler[0] * 0.5f );
1563 q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, euler[1] );
1564 q_axis_angle( qroll, (v3f){0.0f,0.0f,1.0f}, euler[2] );
1565
1566 q_mul( qpitch, qroll, qtrick );
1567 q_mul( qyaw, qtrick, qtrick );
1568 q_mul( kf_board->q, qtrick, kf_board->q );
1569 q_normalize( kf_board->q );
1570 }
1571
1572 /* transform */
1573 rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
1574 v3_muladds( dest->root_co, player->rb.to_world[1], -0.28f, dest->root_co );
1575
1576 v4f qresy, qresx, qresidual;
1577 m3x3f mtx_residual;
1578 float substep = vg_clampf( vg.accumulator / VG_TIMESTEP_FIXED, 0.0f, 1.0f );
1579 q_axis_angle( qresy, player->rb.to_world[1], s->state.steery_s*substep );
1580 q_axis_angle( qresx, player->rb.to_world[0], s->state.steerx_s*substep );
1581
1582 q_mul( qresy, qresx, qresidual );
1583 q_normalize( qresidual );
1584 q_mul( dest->root_q, qresidual, dest->root_q );
1585 q_normalize( dest->root_q );
1586
1587 v4f qflip;
1588 if( (s->state.activity == k_skate_activity_air) &&
1589 (fabsf(s->state.flip_rate) > 0.01f) )
1590 {
1591 float t = s->state.flip_time + s->state.flip_rate*substep*k_rb_delta,
1592 angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
1593 distm = s->land_dist * fabsf(s->state.flip_rate) * 3.0f,
1594 blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
1595
1596 angle = vg_lerpf( angle, vg_signf(s->state.flip_rate) * VG_TAUf, blend );
1597
1598 q_axis_angle( qflip, s->state.flip_axis, angle );
1599 q_mul( qflip, dest->root_q, dest->root_q );
1600 q_normalize( dest->root_q );
1601
1602 v3f rotation_point, rco;
1603 v3_muladds( player->rb.co, player->rb.to_world[1], 0.5f, rotation_point );
1604 v3_sub( dest->root_co, rotation_point, rco );
1605
1606 q_mulv( qflip, rco, rco );
1607 v3_add( rco, rotation_point, dest->root_co );
1608 }
1609 }
1610
1611 VG_STATIC void player__skate_post_animate( player_instance *player )
1612 {
1613 struct player_skate *s = &player->_skate;
1614 struct player_avatar *av = player->playeravatar;
1615
1616 player->cam_velocity_influence = 1.0f;
1617 }
1618
1619 VG_STATIC void player__skate_reset_animator( player_instance *player )
1620 {
1621 struct player_skate *s = &player->_skate;
1622
1623 if( s->state.activity == k_skate_activity_air )
1624 s->blend_fly = 1.0f;
1625 else
1626 s->blend_fly = 0.0f;
1627
1628 s->blend_slide = 0.0f;
1629 s->blend_z = 0.0f;
1630 s->blend_x = 0.0f;
1631 s->blend_stand = 0.0f;
1632 s->blend_push = 0.0f;
1633 s->blend_jump = 0.0f;
1634 s->blend_airdir = 0.0f;
1635 }
1636
1637 VG_STATIC void player__skate_clear_mechanics( player_instance *player )
1638 {
1639 struct player_skate *s = &player->_skate;
1640 s->state.jump_charge = 0.0f;
1641 s->state.lift_frames = 0;
1642 s->state.flip_rate = 0.0f;
1643 s->state.steery = 0.0f;
1644 s->state.steerx = 0.0f;
1645 s->state.steery_s = 0.0f;
1646 s->state.steerx_s = 0.0f;
1647 s->state.reverse = 0.0f;
1648 s->state.slip = 0.0f;
1649 v3_copy( player->rb.co, s->state.prev_pos );
1650
1651 m3x3_identity( s->state.velocity_bias );
1652 m3x3_identity( s->state.velocity_bias_pstep );
1653 v3_zero( s->state.throw_v );
1654 v3_zero( s->state.trick_vel );
1655 v3_zero( s->state.trick_euler );
1656 }
1657
1658 VG_STATIC void player__skate_reset( player_instance *player,
1659 struct respawn_point *rp )
1660 {
1661 struct player_skate *s = &player->_skate;
1662 v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
1663 v3_zero( player->rb.v );
1664 v3_zero( s->state.cog_v );
1665 v4_copy( rp->q, player->rb.q );
1666
1667 s->state.activity = k_skate_activity_air;
1668 s->state.activity_prev = k_skate_activity_air;
1669
1670 player__skate_clear_mechanics( player );
1671 player__skate_reset_animator( player );
1672 }
1673
1674 #endif /* PLAYER_SKATE_C */