projects / carveJwlIkooP6JGAAIwe30JlM.git / blob
? search:


a73122c57c5351cf5afa929b6b3ff995490fe3be
[carveJwlIkooP6JGAAIwe30JlM.git] / player.c
1 #ifndef PLAYER_C
2 #define PLAYER_C
3
4 #include "player.h"
5 #include "camera.h"
6 #include "player_model.h"
7
8 PLAYER_API
9 void player__debugtext( int size, const char *fmt, ... )
10 {
11 char buffer[ 1024 ];
12
13 va_list args;
14 va_start( args, fmt );
15 vsnprintf( buffer, 1024, fmt, args );
16 va_end( args );
17
18 ui_text( vg_uictx.cursor, buffer, size, k_text_align_right );
19 vg_uictx.cursor[1] += 14*size;
20 }
21
22 /*
23 * Init
24 */
25 PLAYER_API
26 void player__create( player_instance *inst )
27 {
28 static int only_once = 0;
29 assert( only_once == 0 );
30 only_once ++;
31
32 inst->input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
33 inst->input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
34 inst->input_grab = vg_create_named_input( "grab", k_input_type_axis_norm);
35 inst->input_js2h = vg_create_named_input( "grab-h", k_input_type_axis );
36 inst->input_js2v = vg_create_named_input( "grab-v", k_input_type_axis );
37 inst->input_jump = vg_create_named_input( "jump", k_input_type_button );
38 inst->input_push = vg_create_named_input( "push", k_input_type_button );
39 inst->input_walk = vg_create_named_input( "walk", k_input_type_button );
40 inst->input_walkh= vg_create_named_input( "walk-h", k_input_type_axis );
41 inst->input_walkv= vg_create_named_input( "walk-v", k_input_type_axis );
42 inst->input_use = vg_create_named_input( "use", k_input_type_button );
43 inst->input_reset= vg_create_named_input( "reset", k_input_type_button );
44 inst->input_camera=vg_create_named_input( "camera", k_input_type_button );
45 inst->input_trick0=vg_create_named_input( "trick0", k_input_type_button );
46 inst->input_trick1=vg_create_named_input( "trick1", k_input_type_button );
47 inst->input_trick2=vg_create_named_input( "trick2", k_input_type_button );
48
49 const char *default_cfg[] =
50 {
51 "bind steer-h gp-ls-h",
52 "bind -steer-h a",
53 "bind +steer-h d",
54
55 "bind steer-v gp-ls-v",
56 "bind -steer-v w",
57 "bind +steer-v s",
58
59 "bind grab gp-rt",
60 "bind +grab shift",
61 "bind grab-h gp-rs-h",
62 "bind grab-v gp-rs-v",
63
64 "bind jump space",
65 "bind jump gp-a",
66
67 "bind trick0 mouse1",
68 "bind trick0 gp-a",
69 "bind trick1 mouse2",
70 "bind trick1 gp-b",
71 "bind trick2 gp-x", /* keyboard: m0 + m1 */
72
73 "bind push gp-b",
74 "bind push w",
75
76 "bind walk shift",
77 "bind walk gp-ls",
78
79 "bind walk-h gp-ls-h",
80 "bind walk-v -gp-ls-v",
81 "bind +walk-h d",
82 "bind -walk-h a",
83 "bind +walk-v w",
84 "bind -walk-v s",
85
86 "bind reset gp-lb",
87 "bind reset r",
88
89 "bind use gp-y",
90 "bind use e",
91 "bind camera c",
92 "bind camera gp-rb"
93 };
94
95 for( int i=0; i<vg_list_size(default_cfg); i++ )
96 vg_execute_console_input(default_cfg[i]);
97
98 v3_zero( inst->rb.co );
99 v3_zero( inst->rb.w );
100 v3_zero( inst->rb.v );
101 q_identity( inst->rb.q );
102 m4x3_identity( inst->rb.to_world );
103 m4x3_identity( inst->rb.to_local );
104
105 inst->rewind_length = 0;
106 inst->rewind_buffer =
107 vg_linear_alloc( vg_mem.rtmemory,
108 sizeof(struct rewind_frame) * PLAYER_REWIND_FRAMES );
109
110 }
111
112 /*
113 * Appearence
114 */
115 PLAYER_API
116 void player__use_avatar( player_instance *player, struct player_avatar *av )
117 {
118 player->playeravatar = av;
119 player_setup_ragdoll_from_avatar( &player->ragdoll, av );
120 }
121
122 PLAYER_API
123 void player__use_mesh( player_instance *player, glmesh *mesh )
124 {
125 player->playermesh = mesh;
126 }
127
128 PLAYER_API
129 void player__use_texture( player_instance *player, vg_tex2d *tex )
130 {
131 player->playertex = tex;
132 }
133
134 PLAYER_API
135 void player__bind( player_instance *player )
136 {
137 for( u32 i=0; i<vg_list_size(_player_bind); i++ ){
138 if( _player_bind[i] )
139 _player_bind[i]( player );
140 }
141 }
142
143 /*
144 * Gameloop events
145 * ----------------------------------------------------------------------------
146 */
147
148 VG_STATIC void player_save_rewind_frame( player_instance *player )
149 {
150 if( player->rewind_length < PLAYER_REWIND_FRAMES ){
151 struct rewind_frame *fr =
152 &player->rewind_buffer[ player->rewind_length ++ ];
153
154 v2_copy( player->cam.angles, fr->ang );
155 v3_copy( player->cam.pos, fr->pos );
156
157 if( player->rewind_length >= 2 ){
158 player->rewind_total_length +=
159 v3_dist( player->rewind_buffer[player->rewind_length-1].pos,
160 player->rewind_buffer[player->rewind_length-2].pos );
161 }
162 }
163 }
164
165 PLAYER_API
166 void player__pre_update( player_instance *player )
167 {
168 if( player->rewinding ){
169 return;
170 }
171
172 if( vg_input_button_down( player->input_reset ) ){
173 double delta = world_global.time - world_global.last_use;
174
175 if( (delta <= RESET_MAX_TIME) && (world_global.last_use != 0.0) ){
176 player->rewinding = 1;
177 player->rewind_sound_wait = 1;
178 player->rewind_time = (double)player->rewind_length - 0.0001;
179 player_save_rewind_frame( player );
180
181 audio_lock();
182 audio_oneshot( &audio_rewind[0], 1.0f, 0.0f );
183 audio_unlock();
184
185 /* based on testing. DONT CHANGE!
186 *
187 * time taken: y = (x^(4/5)) * 74.5
188 * inverse : x = (2/149)^(4/5) * y^(4/5)
189 */
190
191 float constant = powf( 2.0f/149.0f, 4.0f/5.0f ),
192 curve = powf( player->rewind_total_length, 4.0f/5.0f );
193
194 player->rewind_predicted_time = constant * curve;
195 player->rewind_start = vg.time;
196 player->subsystem = player->subsystem_gate;
197 player->rb = player->rb_gate_storage;
198 v3_copy( player->angles_storage, player->angles );
199
200 if( _player_restore[ player->subsystem ] )
201 _player_restore[ player->subsystem ]( player );
202 }
203 else{
204 if( player->subsystem == k_player_subsystem_dead ){
205 __respawn( 0, NULL );
206 }
207 else{
208 /* cant do that */
209 audio_lock();
210 audio_oneshot( &audio_rewind[4], 1.0f, 0.0f );
211 audio_unlock();
212 }
213 }
214 }
215
216 if( vg_input_button_down( player->input_camera ) ){
217 if( player->camera_mode == k_cam_firstperson )
218 player->camera_mode = k_cam_thirdperson;
219 else
220 player->camera_mode = k_cam_firstperson;
221 }
222
223 if( _player_pre_update[ player->subsystem ] )
224 _player_pre_update[ player->subsystem ]( player );
225 }
226
227 PLAYER_API
228 void player__update( player_instance *player )
229 {
230 if( player->rewinding )
231 return;
232
233 if( _player_update[ player->subsystem ] )
234 _player_update[ player->subsystem ]( player );
235 }
236
237 PLAYER_API
238 void player__post_update( player_instance *player )
239 {
240 if( player->rewinding )
241 return;
242
243 if( _player_post_update[ player->subsystem ] )
244 _player_post_update[ player->subsystem ]( player );
245
246 if((player->subsystem != k_player_subsystem_dead) && !player->gate_waiting){
247 player->rewind_accum += vg.frame_delta;
248
249 if( player->rewind_accum > 0.25f ){
250 player->rewind_accum -= 0.25f;
251 player_save_rewind_frame( player );
252 }
253 }
254 }
255
256 VG_STATIC void player_apply_transport_to_cam( m4x3f transport )
257 {
258 /* FIXME: Applies to main_camera directly! */
259
260 /* Pre-emptively edit the camera matrices so that the motion vectors
261 * are correct */
262 m4x3f transport_i;
263 m4x4f transport_4;
264 m4x3_invert_affine( transport, transport_i );
265 m4x3_expand( transport_i, transport_4 );
266 m4x4_mul( main_camera.mtx.pv, transport_4, main_camera.mtx.pv );
267 m4x4_mul( main_camera.mtx.v, transport_4, main_camera.mtx.v );
268
269 /* we want the regular transform here no the inversion */
270 m4x3_expand( transport, transport_4 );
271 m4x4_mul( gate_camera.mtx.pv, transport_4, gate_camera.mtx.pv );
272 m4x4_mul( gate_camera.mtx.v, transport_4, gate_camera.mtx.v );
273 }
274
275 __attribute__ ((deprecated))
276 VG_STATIC void gate_rotate_angles( ent_gate *gate, v3f angles, v3f d )
277 {
278 v3_copy( angles, d );
279 return;
280
281 v3f fwd_dir = { cosf(angles[0]),
282 0.0f,
283 sinf(angles[0])};
284 m3x3_mulv( gate->transport, fwd_dir, fwd_dir );
285
286 v3_copy( angles, d );
287 d[0] = atan2f( fwd_dir[2], fwd_dir[0] );
288 }
289
290 /*
291 * Applies gate transport to a player_interface
292 */
293 PLAYER_API
294 void player__pass_gate( player_instance *player, ent_gate *gate )
295 {
296 world_routes_fracture( get_active_world(), gate,
297 player->rb.co, player->rb.v );
298
299 player->gate_waiting = gate;
300 world_routes_activate_entry_gate( get_active_world(), gate );
301
302 m4x3_mulv( gate->transport, player->tpv_lpf, player->tpv_lpf );
303 m3x3_mulv( gate->transport, player->cam_velocity_smooth,
304 player->cam_velocity_smooth );
305
306 m3x3_copy( player->basis, player->basis_gate );
307
308 v4f q;
309 m3x3_q( gate->transport, q );
310 q_mul( q, player->qbasis, player->qbasis );
311 q_normalize( player->qbasis );
312 q_m3x3( player->qbasis, player->basis );
313 m3x3_transpose( player->basis, player->invbasis );
314
315 player->subsystem_gate = player->subsystem;
316 player->rb_gate_storage = player->rb;
317 v3_copy( player->angles, player->angles_storage );
318 player->rewind_length = 0;
319 player->rewind_total_length = 0.0f;
320 player->rewind_gate = gate;
321 player->rewind_accum = 0.0f;
322
323 m4x3_mulv( gate->transport, player->cam.pos, player->cam.pos );
324 player_save_rewind_frame( player );
325
326 if( gate->type == k_gate_type_nonlocal )
327 world_global.active_world = gate->target;
328
329 world_global.in_volume = 0;
330
331 audio_lock();
332 audio_oneshot( &audio_gate_pass, 1.0f, 0.0f );
333 audio_unlock();
334 }
335
336 VG_STATIC void player__pre_render( player_instance *player )
337 {
338 if( _player_animate[ player->subsystem ] ){
339 player_animation res;
340 _player_animate[ player->subsystem ]( player, &res );
341
342 m4x3f transform;
343 q_m3x3( res.root_q, transform );
344 v3_copy( res.root_co, transform[3] );
345
346 struct skeleton *sk = &player->playeravatar->sk;
347
348 if( player->holdout_time > 0.0f ){
349 skeleton_lerp_pose( sk, res.pose, player->holdout_pose,
350 player->holdout_time, res.pose );
351 player->holdout_time -= vg.frame_delta * 2.0f;
352 }
353
354 skeleton_apply_pose( sk, res.pose, k_anim_apply_defer_ik );
355 skeleton_apply_ik_pass( sk );
356 skeleton_apply_pose( sk, res.pose, k_anim_apply_deffered_only );
357 skeleton_apply_inverses( sk );
358 skeleton_apply_transform( sk, transform );
359
360 skeleton_debug( sk );
361 }
362
363 if( _player_post_animate[ player->subsystem ] )
364 _player_post_animate[ player->subsystem ]( player );
365
366 struct player_avatar *av = player->playeravatar;
367 v3f vp0 = {0.0f,0.1f, 0.55f},
368 vp1 = {0.0f,0.1f,-0.55f};
369
370 struct ub_world_lighting *ubo = &get_active_world()->ub_lighting;
371 m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, ubo->g_board_0 );
372 m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, ubo->g_board_1 );
373
374 if( player->rewinding ){
375 if( player->rewind_time <= 0.0f ){
376 double taken = vg.time - player->rewind_start;
377 vg_success( "Rewind took (rt, pt, tl): %f, %f, %f\n",
378 taken, player->rewind_predicted_time,
379 player->rewind_total_length );
380
381 player->rewinding = 0;
382 player->rewind_length = 1;
383 player->rewind_total_length = 0.0f;
384 player->rewind_accum = 0.0f;
385 world_global.sky_target_rate = 1.0;
386 world_global.time = world_global.last_use;
387 }
388 else{
389 world_global.sky_target_rate = -100.0;
390
391 float budget = vg.time_delta,
392 overall_length = player->rewind_length;
393
394 for( int i=0; (i<10)&&(player->rewind_time>0.0f)&&(budget>0.0f); i++ ){
395 /* Interpolate frames */
396 int i0 = floorf( player->rewind_time ),
397 i1 = VG_MIN( i0+1, player->rewind_length-1 );
398
399 struct rewind_frame *fr = &player->rewind_buffer[i0],
400 *fr1 = &player->rewind_buffer[i1];
401
402 float dist = vg_maxf( v3_dist( fr->pos, fr1->pos ), 0.001f ),
403 subl = vg_fractf( player->rewind_time ) + 0.001f,
404
405 sramp = 3.0f-(1.0f/(0.4f+0.4f*player->rewind_time)),
406 speed = sramp*28.0f + 0.5f*player->rewind_time,
407 mod = speed * (budget / dist),
408
409 advl = vg_minf( mod, subl ),
410 advt = (advl / mod) * budget;
411
412 player->dist_accum += speed * advt;
413 player->rewind_time -= advl;
414 budget -= advt;
415 }
416
417 player->rewind_time = vg_maxf( 0.0f, player->rewind_time );
418
419 float current_time = vg.time - player->rewind_start,
420 remaining = player->rewind_predicted_time - current_time;
421
422 if( player->rewind_sound_wait ){
423 if( player->rewind_predicted_time >= 6.5f ){
424 if( remaining <= 6.5f ){
425 audio_lock();
426 audio_oneshot( &audio_rewind[3], 1.0f, 0.0f );
427 audio_unlock();
428 player->rewind_sound_wait = 0;
429 }
430 }
431 else if( player->rewind_predicted_time >= 2.5f ){
432 if( remaining <= 2.5f ){
433 audio_lock();
434 audio_oneshot( &audio_rewind[2], 1.0f, 0.0f );
435 audio_unlock();
436 player->rewind_sound_wait = 0;
437 }
438 }
439 else if( player->rewind_predicted_time >= 1.5f ){
440 if( remaining <= 1.5f ){
441 audio_lock();
442 audio_oneshot( &audio_rewind[1], 1.0f, 0.0f );
443 audio_unlock();
444 player->rewind_sound_wait = 0;
445 }
446 }
447 }
448
449 int i0 = floorf( player->rewind_time ),
450 i1 = VG_MIN( i0+1, player->rewind_length-1 );
451
452 struct rewind_frame *fr = &player->rewind_buffer[i0],
453 *fr1 = &player->rewind_buffer[i1];
454
455 float sub = vg_fractf(player->rewind_time);
456
457 v3_lerp( fr->pos, fr1->pos, sub, player->cam_override_pos );
458 player->cam_override_angles[0] =
459 vg_alerpf( fr->ang[0], fr1->ang[0], sub );
460 player->cam_override_angles[1] =
461 vg_lerpf ( fr->ang[1], fr1->ang[1], sub );
462
463 float blend = player->rewind_time * 0.25f;
464 player->cam_override_strength = vg_clampf( blend, 0.0f, 1.0f );
465 }
466 }
467 else player->cam_override_strength = 0.0f;
468
469 player__cam_iterate( player );
470 }
471
472 PLAYER_API void player__render( camera *cam, player_instance *player )
473 {
474 shader_model_character_view_use();
475 vg_tex2d_bind( player->playertex, 0 );
476 shader_model_character_view_uTexMain( 0 );
477 shader_model_character_view_uCamera( cam->transform[3] );
478 shader_model_character_view_uPv( cam->mtx.pv );
479
480 world_instance *world = get_active_world();
481 world_link_lighting_ub( world, _shader_model_character_view.id );
482 world_bind_position_texture( world, _shader_model_character_view.id,
483 _uniform_model_character_view_g_world_depth, 2 );
484 world_bind_light_array( world, _shader_model_character_view.id,
485 _uniform_model_character_view_uLightsArray, 3 );
486 world_bind_light_index( world, _shader_model_character_view.id,
487 _uniform_model_character_view_uLightsIndex, 4 );
488
489 glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms,
490 player->playeravatar->sk.bone_count,
491 0,
492 (float *)player->playeravatar->sk.final_mtx );
493
494 mesh_bind( player->playermesh );
495 mesh_draw( player->playermesh );
496 }
497
498 PLAYER_API void player__im_gui( player_instance *player )
499 {
500 vg_uictx.cursor[0] = vg.window_x - 200;
501 vg_uictx.cursor[1] = 0;
502 vg_uictx.cursor[2] = 200;
503 vg_uictx.cursor[3] = 200;
504
505 struct ui_vert *b = ui_fill_rect( vg_uictx.cursor, 0x70000000 );
506
507 vg_uictx.cursor[0] = vg.window_x;
508
509 player__debugtext( 1, "angles: " PRINTF_v3f( player->cam.angles ) );
510 player__debugtext( 1, "basis: " PRINTF_v4f( player->qbasis ) );
511
512 if( _player_im_gui[ player->subsystem ] )
513 _player_im_gui[ player->subsystem ]( player );
514
515 b[2].co[1] = vg_uictx.cursor[1];
516 b[3].co[1] = vg_uictx.cursor[1];
517 }
518
519 PLAYER_API void player__spawn( player_instance *player,
520 ent_spawn *rp )
521 {
522 v3_copy( rp->transform.co, player->rb.co );
523 v3_zero( player->rb.v );
524 v3_zero( player->rb.w );
525 q_identity( player->rb.q );
526 rb_update_transform( &player->rb );
527
528 q_identity( player->qbasis );
529 m3x3_identity( player->basis );
530 m3x3_identity( player->invbasis );
531
532 player->subsystem = k_player_subsystem_walk;
533 player->viewable_world = get_active_world();
534 player->gate_waiting = NULL;
535
536 if( _player_reset[ player->subsystem ] )
537 _player_reset[ player->subsystem ]( player, rp );
538 }
539
540
541 PLAYER_API void player__kill( player_instance *player )
542 {
543
544 }
545
546 #endif /* PLAYER_C */
Skaterift source tree