projects / carveJwlIkooP6JGAAIwe30JlM.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vehicle stuff
[carveJwlIkooP6JGAAIwe30JlM.git] / player.h
1 /*
2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
3 */
4
5 #ifndef PLAYER_H
6 #define PLAYER_H
7
8 #define PLAYER_REWIND_FRAMES 60*4
9
10 #include "conf.h"
11 #include "audio.h"
12 #include "common.h"
13 #include "world.h"
14 #include "skeleton.h"
15 #include "bvh.h"
16
17 VG_STATIC float
18 k_walkspeed = 12.0f,
19 k_air_accelerate = 20.0f,
20 k_runspeed = 20.0f,
21 k_board_radius = 0.3f,
22 k_board_length = 0.45f,
23 k_board_allowance = 0.04f,
24 k_friction_lat = 12.0f,
25 k_friction_resistance = 0.01f,
26 k_max_push_speed = 16.0f,
27 k_push_accel = 10.0f,
28 k_push_cycle_rate = 8.0f,
29 k_steer_ground = 2.5f,
30 k_steer_air = 3.6f,
31 k_steer_air_lerp = 0.3f,
32 k_pump_force = 0.0f,
33 k_downforce = 5.0f,
34 k_walk_downforce = 8.0f,
35 k_jump_charge_speed = (1.0f/1.0f),
36 k_jump_force = 5.0f,
37 k_pitch_limit = 1.5f,
38 k_look_speed = 2.0f,
39 k_walk_accel = 150.0f,
40 k_walk_friction = 8.0f,
41
42 k_cog_spring = 0.2f,
43 k_cog_damp = 0.02f,
44 k_cog_mass_ratio = 0.9f,
45
46 k_mmthrow_scale = 6.0f,
47 k_mmcollect_lat = 2.0f,
48 k_mmcollect_vert = 0.0f,
49 k_mmdecay = 12.0f,
50 k_spring_angular = 1.0f,
51
52 k_spring_force = 15.0f,
53 k_spring_dampener = 5.0f;
54
55 VG_STATIC int freecam = 0;
56 VG_STATIC int walk_grid_iterations = 1;
57 VG_STATIC float fc_speed = 10.0f;
58 VG_STATIC int cl_thirdperson = 0;
59
60 /*
61 * -----------------------------------------------------------------------------
62 * Memory
63 * -----------------------------------------------------------------------------
64 */
65
66 VG_STATIC struct gplayer
67 {
68 /* Physics */
69 rigidbody collide_front, collide_back;
70
71 struct player_phys
72 {
73 rigidbody rb, rb_gate_frame;
74 float iY, siY; /* Yaw inertia */
75
76 v3f a, v_last, m, bob, vl;
77
78 /* Utility */
79 float vswitch, slip, slip_last, reverse;
80 float grab, jump, pushing, push_time, rise;
81 v2f grab_mouse_delta;
82
83 v3f throw_v;
84 v3f cog,
85 cog_v;
86
87 int lift_frames;
88
89 double start_push;
90 int in_air, on_board, jump_charge, jump_dir, grind;
91
92 m3x3f vr,vr_pstep;
93 }
94 phys,
95 phys_gate_frame;
96
97 float normal_pressure;
98 v3f debug_mmcollect_lat,
99 debug_mmcollect_vert;
100
101 m4x3f visual_transform,
102 inv_visual_transform;
103
104 int is_dead, death_tick_allowance, rewinding;
105 int rewind_sound_wait;
106
107 struct land_prediction
108 {
109 v3f log[50];
110 v3f n;
111 u32 log_length;
112 float score;
113
114 enum prediction_type
115 {
116 k_prediction_none,
117 k_prediction_land,
118 k_prediction_grind
119 }
120 type;
121
122 u32 colour;
123 }
124 predictions[22];
125 u32 prediction_count;
126
127 v3f handl_target, handr_target,
128 handl, handr;
129
130 /* Input */
131 struct input_binding *input_js1h,
132 *input_js1v,
133 *input_js2h,
134 *input_js2v,
135 *input_jump,
136 *input_push,
137 *input_walk,
138 *input_walkh,
139 *input_walkv,
140 *input_switch_mode,
141 *input_reset,
142 *input_grab;
143
144 /* Camera */
145 float air_blend;
146 float air_time;
147
148 v3f camera_pos, smooth_localcam;
149 v2f angles;
150
151 struct rewind_frame
152 {
153 v3f pos;
154 v2f ang;
155 }
156 *rewind_buffer;
157 u32 rewind_incrementer,
158 rewind_length;
159
160 float rewind_time, rewind_total_length, rewind_predicted_time;
161 double diag_rewind_start, diag_rewind_time;
162 float dist_accum;
163
164 /* animation */
165 double jump_time;
166 float fslide,
167 fdirz, fdirx,
168 fstand,
169 ffly,
170 fpush,
171 fairdir,
172 fsetup,
173 walk_timer,
174 fjump,
175 fonboard,
176 frun,
177 fgrind;
178
179 v3f board_offset;
180 v4f board_rotation;
181
182 float walk;
183 int step_phase;
184 enum mdl_surface_prop surface_prop;
185
186 /* player model */
187 struct player_model
188 {
189 glmesh player_meshes[3];
190
191 mdl_context meta;
192 struct skeleton sk;
193 struct skeleton_anim *anim_stand,
194 *anim_highg,
195 *anim_slide,
196 *anim_air,
197 *anim_push, *anim_push_reverse,
198 *anim_ollie, *anim_ollie_reverse,
199 *anim_grabs, *anim_stop,
200 *anim_walk, *anim_run, *anim_idle,
201 *anim_jump;
202
203 u32 id_hip,
204 id_ik_hand_l,
205 id_ik_hand_r,
206 id_ik_elbow_l,
207 id_ik_elbow_r,
208 id_head,
209 id_ik_foot_l,
210 id_ik_foot_r,
211 id_board;
212
213 v3f cam_pos;
214
215 struct ragdoll_part
216 {
217 u32 bone_id;
218 //v3f offset;
219
220 /* Collider transform relative to bone */
221 m4x3f collider_mtx,
222 inv_collider_mtx;
223
224 u32 use_limits;
225 v3f limits[2];
226
227 rigidbody rb;
228 u32 parent;
229 u32 colour;
230 }
231 ragdoll[32];
232 u32 ragdoll_count;
233
234 rb_constr_pos position_constraints[32];
235 u32 position_constraints_count;
236
237 rb_constr_swingtwist cone_constraints[32];
238 u32 cone_constraints_count;
239
240 int shoes[2];
241 }
242 mdl;
243 }
244 player =
245 {
246 .collide_front = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f },
247 .collide_back = { .type = k_rb_shape_sphere, .inf.sphere.radius = 0.3f }
248 };
249
250 /*
251 * API
252 */
253 VG_STATIC float *player_get_pos(void);
254 VG_STATIC void player_kill(void);
255 VG_STATIC float *player_cam_pos(void);
256 VG_STATIC void player_save_frame(void);
257 VG_STATIC void player_restore_frame(void);
258 VG_STATIC void player_save_rewind_frame(void);
259
260 /*
261 * Submodules
262 */
263 VG_STATIC void player_mouseview(void);
264
265 #include "player_physics.h"
266 #include "player_ragdoll.h"
267 #include "player_model.h"
268 #include "player_animation.h"
269 #include "player_audio.h"
270
271 /*
272 * -----------------------------------------------------------------------------
273 * Events
274 * -----------------------------------------------------------------------------
275 */
276 VG_STATIC int kill_player( int argc, char const *argv[] );
277 VG_STATIC int reset_player( int argc, char const *argv[] );
278 VG_STATIC void reset_player_poll( int argc, char const *argv[] );
279
280 VG_STATIC void player_init(void) /* 1 */
281 {
282 player.input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
283 player.input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
284 player.input_grab = vg_create_named_input( "grab", k_input_type_axis_norm );
285 player.input_js2h = vg_create_named_input( "grab-h", k_input_type_axis );
286 player.input_js2v = vg_create_named_input( "grab-v", k_input_type_axis );
287 player.input_jump = vg_create_named_input( "jump", k_input_type_button );
288 player.input_push = vg_create_named_input( "push", k_input_type_button );
289 player.input_walk = vg_create_named_input( "walk", k_input_type_button );
290
291 player.input_walkh = vg_create_named_input( "walk-h",
292 k_input_type_axis );
293 player.input_walkv = vg_create_named_input( "walk-v",
294 k_input_type_axis );
295
296
297 player.input_switch_mode = vg_create_named_input( "switch-mode",
298 k_input_type_button );
299 player.input_reset = vg_create_named_input( "reset", k_input_type_button );
300
301 const char *default_cfg[] =
302 {
303 "bind steer-h gp-ls-h",
304 "bind -steer-h a",
305 "bind +steer-h d",
306
307 "bind steer-v gp-ls-v",
308 "bind -steer-v w",
309 "bind +steer-v s",
310
311 "bind grab gp-rt",
312 "bind +grab shift",
313 "bind grab-h gp-rs-h",
314 "bind grab-v gp-rs-v",
315
316 "bind jump space",
317 "bind jump gp-a",
318
319 "bind push gp-b",
320 "bind push w",
321
322 "bind walk shift",
323 "bind walk gp-ls",
324
325 "bind walk-h gp-ls-h",
326 "bind walk-v -gp-ls-v",
327 "bind +walk-h d",
328 "bind -walk-h a",
329 "bind +walk-v w",
330 "bind -walk-v s",
331
332 "bind reset gp-lb",
333 "bind reset r",
334
335 "bind switch-mode gp-y",
336 "bind switch-mode e",
337 };
338
339 for( int i=0; i<vg_list_size(default_cfg); i++ )
340 vg_execute_console_input(default_cfg[i]);
341
342 rb_init( &player.phys.rb );
343 rb_init( &player.collide_front );
344 rb_init( &player.collide_back );
345
346 VG_VAR_F32( k_walkspeed );
347 VG_VAR_F32( k_air_accelerate );
348 VG_VAR_F32( k_runspeed );
349 VG_VAR_F32( k_walk_accel );
350
351 VG_VAR_I32( freecam );
352 VG_VAR_I32( cl_thirdperson );
353 VG_VAR_F32_PERSISTENT( fc_speed );
354
355 /* TODO: NOT PERSISTENT */
356 VG_VAR_F32( k_ragdoll_limit_scale );
357 VG_VAR_I32( k_ragdoll_div );
358 VG_VAR_I32( k_ragdoll_debug_collider );
359 VG_VAR_I32( k_ragdoll_debug_constraints );
360
361 VG_VAR_F32( k_friction_lat );
362
363 VG_VAR_F32( k_cog_spring );
364 VG_VAR_F32( k_cog_damp );
365
366 VG_VAR_F32( k_cog_mass_ratio );
367 VG_VAR_F32( k_downforce );
368
369 VG_VAR_F32( k_spring_force );
370 VG_VAR_F32( k_spring_dampener );
371 VG_VAR_F32( k_spring_angular );
372
373 VG_VAR_F32( k_mmthrow_scale );
374 VG_VAR_F32( k_mmcollect_lat );
375 VG_VAR_F32( k_mmcollect_vert );
376 VG_VAR_F32( k_mmdecay );
377
378 vg_function_push( (struct vg_cmd){
379 .name = "reset",
380 .function = reset_player,
381 .poll_suggest = reset_player_poll
382 });
383
384 vg_function_push( (struct vg_cmd){
385 .name = "kill",
386 .function = kill_player
387 });
388
389 /* HACK */
390 rb_register_cvar();
391
392 player.rewind_length = 0;
393 player.rewind_buffer =
394 vg_linear_alloc( vg_mem.rtmemory,
395 sizeof(struct rewind_frame) * PLAYER_REWIND_FRAMES );
396
397 player_model_init();
398 }
399
400 VG_STATIC void player_save_rewind_frame(void)
401 {
402 if( player.rewind_length < PLAYER_REWIND_FRAMES )
403 {
404 struct rewind_frame *fr =
405 &player.rewind_buffer[ player.rewind_length ++ ];
406
407 v2_copy( player.angles, fr->ang );
408 v3_copy( player.camera_pos, fr->pos );
409
410 player.rewind_incrementer = 0;
411
412 if( player.rewind_length > 1 )
413 {
414 player.rewind_total_length +=
415 v3_dist( player.rewind_buffer[player.rewind_length-1].pos,
416 player.rewind_buffer[player.rewind_length-2].pos );
417 }
418 }
419 }
420
421
422 /* disaster */
423 VG_STATIC int menu_enabled(void);
424 #include "menu.h"
425
426 /*
427 * Free camera movement
428 */
429 VG_STATIC void player_mouseview(void)
430 {
431 if( menu_enabled() )
432 return;
433
434 v2_muladds( player.angles, vg.mouse_delta, 0.0025f, player.angles );
435
436 if( vg_input.controller_should_use_trackpad_look )
437 {
438 static v2f last_input;
439 static v2f vel;
440 static v2f vel_smooth;
441
442 v2f input = { player.input_js2h->axis.value,
443 player.input_js2v->axis.value };
444
445 if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) )
446 {
447 v2_sub( input, last_input, vel );
448 v2_muls( vel, 1.0f/vg.time_delta, vel );
449 }
450 else
451 {
452 v2_zero( vel );
453 }
454
455 v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
456
457 v2_muladds( player.angles, vel_smooth, vg.time_delta, player.angles );
458 v2_copy( input, last_input );
459 }
460 else
461 {
462 player.angles[0] += player.input_js2h->axis.value * vg.time_delta * 4.0f;
463 player.angles[1] += player.input_js2v->axis.value * vg.time_delta * 4.0f;
464 }
465
466 player.angles[1] = vg_clampf( player.angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
467 }
468
469 /* Deal with input etc */
470 VG_STATIC void player_update_pre(void)
471 {
472 struct player_phys *phys = &player.phys;
473
474
475 {
476 v3f ra, rb, rx;
477 v3_copy( main_camera.pos, ra );
478 v3_muladds( ra, main_camera.transform[2], -10.0f, rb );
479
480 float t;
481 if( spherecast_world( ra, rb, 0.4f, &t, rx ) != -1 )
482 {
483 m4x3f mtx;
484 m3x3_identity( mtx );
485 v3_lerp( ra, rb, t, mtx[3] );
486
487 debug_sphere( mtx, 0.4f, 0xff00ff00 );
488
489 v3f x1;
490 v3_muladds( mtx[3], rx, 0.4f, x1 );
491 vg_line( mtx[3], x1, 0xffffffff );
492 }
493 }
494
495
496 vg_line_pt3( phys->cog, 0.10f, 0xffffffff );
497 vg_line_pt3( phys->cog, 0.09f, 0xffffffff );
498 vg_line_pt3( phys->cog, 0.08f, 0xffffffff );
499 vg_line( phys->cog, phys->rb.co, 0xff000000 );
500
501 v3f spring_end;
502 v3f throw_end, p0, p1;
503 v3_muladds( phys->rb.co, phys->rb.up, 1.0f, spring_end );
504 v3_muladds( spring_end, phys->throw_v, 1.0f, throw_end );
505 v3_muladds( spring_end, player.debug_mmcollect_lat, 1.0f, p0 );
506 v3_muladds( spring_end, player.debug_mmcollect_vert, 1.0f, p1 );
507 vg_line( spring_end, throw_end, VG__RED );
508 vg_line( spring_end, p0, VG__GREEN );
509 vg_line( spring_end, p1, VG__BLUE );
510
511 if( player.rewinding )
512 return;
513
514 if( vg_input_button_down( player.input_reset ) && !menu_enabled() )
515 {
516 double delta = world.time - world.last_use;
517
518 if( (delta <= RESET_MAX_TIME) && (world.last_use != 0.0) )
519 {
520 player.rewinding = 1;
521 player.rewind_sound_wait = 1;
522 player.rewind_time = (float)player.rewind_length - 0.0001f;
523 player_save_rewind_frame();
524 audio_lock();
525 audio_play_oneshot( &audio_rewind[0], 1.0f );
526 audio_unlock();
527
528 /* based on analytical testing. DONT CHANGE!
529 *
530 * time taken: y = (x^(4/5)) * 74.5
531 * inverse : x = (2/149)^(4/5) * y^(4/5)
532 */
533
534 float constant = powf( 2.0f/149.0f, 4.0f/5.0f ),
535 curve = powf( player.rewind_total_length, 4.0f/5.0f );
536
537 player.rewind_predicted_time = constant * curve;
538 player.diag_rewind_start = vg.time;
539 player.diag_rewind_time = player.rewind_time;
540
541 player.is_dead = 0;
542 player.death_tick_allowance = 30;
543 player_restore_frame();
544
545 if( !phys->on_board )
546 {
547 player.angles[0] = atan2f( -phys->rb.forward[2],
548 -phys->rb.forward[0] );
549 }
550
551 player.mdl.shoes[0] = 1;
552 player.mdl.shoes[1] = 1;
553
554 world_routes_notify_reset();
555
556 /* apply 1 frame of movement */
557 player_do_motion();
558 }
559 else
560 {
561 if( player.is_dead )
562 {
563 reset_player( 0, NULL );
564 }
565 else
566 {
567 /* cant do that */
568 audio_lock();
569 audio_play_oneshot( &audio_rewind[4], 1.0f );
570 audio_unlock();
571 }
572 }
573 }
574
575 if( vg_input_button_down( player.input_switch_mode ) && !menu_enabled() )
576 {
577 phys->on_board ^= 0x1;
578
579 audio_lock();
580 if( phys->on_board )
581 {
582 v3_muladds( phys->rb.v, phys->rb.forward, 0.2f, phys->rb.v );
583 audio_play_oneshot( &audio_lands[6], 1.0f );
584 }
585 else
586 {
587 audio_play_oneshot( &audio_lands[5], 1.0f );
588 }
589
590 audio_unlock();
591 }
592
593 if( !phys->on_board )
594 player_mouseview();
595 }
596
597 VG_STATIC void player_update_fixed(void) /* 2 */
598 {
599 if( player.rewinding )
600 return;
601
602 if( player.death_tick_allowance )
603 player.death_tick_allowance --;
604
605 struct player_phys *phys = &player.phys;
606
607 if( player.is_dead )
608 {
609 player_ragdoll_iter();
610 }
611 else
612 {
613 player.rewind_incrementer ++;
614
615 if( player.rewind_incrementer > (u32)(0.25/VG_TIMESTEP_FIXED) )
616 {
617 player_save_rewind_frame();
618 }
619
620 player_do_motion();
621 }
622 }
623
624 VG_STATIC void player_update_post(void)
625 {
626 for( int i=0; i<player.prediction_count; i++ )
627 {
628 struct land_prediction *p = &player.predictions[i];
629
630 for( int j=0; j<p->log_length - 1; j ++ )
631 vg_line( p->log[j], p->log[j+1], p->colour );
632
633 vg_line_cross( p->log[p->log_length-1], p->colour, 0.25f );
634
635 v3f p1;
636 v3_add( p->log[p->log_length-1], p->n, p1 );
637 vg_line( p->log[p->log_length-1], p1, 0xffffffff );
638 }
639
640 if( player.is_dead )
641 {
642 player_debug_ragdoll();
643
644 if( !freecam )
645 player_animate_death_cam();
646 }
647 else
648 {
649 player_animate();
650
651 if( !freecam )
652 {
653 if( cl_thirdperson )
654 player_animate_camera_thirdperson();
655 else
656 player_animate_camera();
657 }
658 }
659
660 if( freecam )
661 player_freecam();
662
663 /* CAMERA POSITIONING: LAYER 0 */
664 v2_copy( player.angles, main_camera.angles );
665 v3_copy( player.camera_pos, main_camera.pos );
666
667 if( player.rewinding )
668 {
669 if( player.rewind_time <= 0.0f )
670 {
671 double taken = vg.time - player.diag_rewind_start;
672 vg_success( "Rewind took (rt, pl, tl): %f, %f, %f\n",
673 taken, player.diag_rewind_time,
674 player.rewind_total_length );
675
676 player.rewinding = 0;
677 player.rewind_length = 1;
678 player.rewind_total_length = 0.0f;
679 player.rewind_incrementer = 0;
680 world.sky_target_rate = 1.0;
681 }
682 else
683 {
684 world.sky_target_rate = -100.0;
685 assert( player.rewind_length > 0 );
686
687 v2f override_angles;
688 v3f override_pos;
689
690 float budget = vg.time_delta,
691 overall_length = player.rewind_length;
692
693 world_routes_rollback_time( player.rewind_time / overall_length );
694
695 for( int i=0; (i<10)&&(player.rewind_time>0.0f)&&(budget>0.0f); i ++ )
696 {
697 /* Interpolate frames */
698 int i0 = floorf( player.rewind_time ),
699 i1 = VG_MIN( i0+1, player.rewind_length-1 );
700
701 struct rewind_frame *fr = &player.rewind_buffer[i0],
702 *fr1 = &player.rewind_buffer[i1];
703
704 float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
705 subl = vg_fractf( player.rewind_time ) + 0.001f,
706
707 sramp= 3.0f-(1.0f/(0.4f+0.4f*player.rewind_time)),
708 speed = sramp*28.0f + 0.5f*player.rewind_time,
709 mod = speed * (budget / dist),
710
711 advl = vg_minf( mod, subl ),
712 advt = (advl / mod) * budget;
713
714 player.dist_accum += speed * advt;
715 player.rewind_time -= advl;
716 budget -= advt;
717 }
718
719 player.rewind_time = vg_maxf( 0.0f, player.rewind_time );
720
721 float current_time = vg.time - player.diag_rewind_start,
722 remaining = player.rewind_predicted_time - current_time;
723
724 if( player.rewind_sound_wait )
725 {
726 if( player.rewind_predicted_time >= 6.5f )
727 {
728 if( remaining <= 6.5f )
729 {
730 audio_lock();
731 audio_play_oneshot( &audio_rewind[3], 1.0f );
732 audio_unlock();
733 player.rewind_sound_wait = 0;
734 }
735 }
736 else if( player.rewind_predicted_time >= 2.5f )
737 {
738 if( remaining <= 2.5f )
739 {
740 audio_lock();
741 audio_play_oneshot( &audio_rewind[2], 1.0f );
742 audio_unlock();
743 player.rewind_sound_wait = 0;
744 }
745 }
746 else if( player.rewind_predicted_time >= 1.5f )
747 {
748 if( remaining <= 1.5f )
749 {
750 audio_lock();
751 audio_play_oneshot( &audio_rewind[1], 1.0f );
752 audio_unlock();
753 player.rewind_sound_wait = 0;
754 }
755 }
756 }
757
758 int i0 = floorf( player.rewind_time ),
759 i1 = VG_MIN( i0+1, player.rewind_length-1 );
760
761 struct rewind_frame *fr = &player.rewind_buffer[i0],
762 *fr1 = &player.rewind_buffer[i1];
763
764 float sub = vg_fractf(player.rewind_time);
765
766 v3_lerp( fr->pos, fr1->pos, sub, override_pos );
767 override_angles[0] = vg_alerpf( fr->ang[0], fr1->ang[0], sub );
768 override_angles[1] = vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
769
770 /* CAMERA POSITIONING: LAYER 1 */
771 float blend = (4.0f-player.rewind_time) * 0.25f,
772 c = vg_clampf( blend, 0.0f, 1.0f );
773
774 main_camera.angles[0] =
775 vg_alerpf(override_angles[0], player.angles[0], c);
776 main_camera.angles[1] =
777 vg_lerpf (override_angles[1], player.angles[1], c);
778 v3_lerp( override_pos, player.camera_pos, c, main_camera.pos );
779 }
780 }
781
782 camera_update_transform( &main_camera );
783 player_audio();
784 }
785
786 VG_STATIC void draw_player( camera *cam )
787 {
788 if( player.is_dead )
789 player_model_copy_ragdoll();
790
791 shader_viewchar_use();
792 vg_tex2d_bind( &tex_characters, 0 );
793 shader_viewchar_uTexMain( 0 );
794 shader_viewchar_uCamera( cam->transform[3] );
795 shader_viewchar_uPv( cam->mtx.pv );
796 shader_link_standard_ub( _shader_viewchar.id, 2 );
797 glUniformMatrix4x3fv( _uniform_viewchar_uTransforms,
798 player.mdl.sk.bone_count,
799 0,
800 (float *)player.mdl.sk.final_mtx );
801
802 mesh_bind( &player.mdl.player_meshes[cl_playermdl_id] );
803 mesh_draw( &player.mdl.player_meshes[cl_playermdl_id] );
804 }
805
806 /*
807 * -----------------------------------------------------------------------------
808 * API implementation
809 * -----------------------------------------------------------------------------
810 */
811
812 VG_STATIC float *player_get_pos(void)
813 {
814 return player.phys.rb.co;
815 }
816
817 VG_STATIC void player_kill(void)
818 {
819 if( player.death_tick_allowance == 0 )
820 {
821 player.is_dead = 1;
822 player_ragdoll_copy_model( player.phys.rb.v );
823 }
824 }
825
826 VG_STATIC float *player_cam_pos(void)
827 {
828 return player.camera_pos;
829 }
830
831
832 #endif /* PLAYER_H */
Skaterift source tree