7 //#include "character.h"
8 #include "player_model.h"
17 k_board_radius
= 0.3f
,
18 k_board_length
= 0.45f
,
19 k_board_allowance
= 0.04f
,
20 k_friction_lat
= 8.8f
,
21 k_friction_resistance
= 0.01f
,
22 k_max_push_speed
= 16.0f
,
24 k_push_cycle_rate
= 8.0f
,
25 k_steer_ground
= 2.5f
,
27 k_steer_air_lerp
= 0.3f
,
28 k_pump_force
= 000.0f
,
30 k_jump_charge_speed
= (1.0f
/1.0f
),
33 static int freecam
= 0;
34 static int walk_grid_iterations
= 1;
35 static float fc_speed
= 10.0f
;
40 rigidbody rb
, collide_front
, collide_back
, rb_gate_frame
;
42 v3f a
, v_last
, m
, bob
, vl
;
45 float vswitch
, slip
, slip_last
,
48 float iY
; /* Yaw inertia */
49 int in_air
, is_dead
, on_board
;
54 float pushing
, push_time
;
59 v3f land_target_log
[22];
60 u32 land_target_colours
[22];
66 v3f handl_target
, handr_target
,
72 v3f camera_pos
, smooth_localcam
;
74 m4x3f camera
, camera_inverse
;
90 .collide_front
= { .type
= k_rb_shape_sphere
, .inf
.sphere
.radius
= 0.3f
},
91 .collide_back
= { .type
= k_rb_shape_sphere
, .inf
.sphere
.radius
= 0.3f
}
100 * Free camera movement
103 static void player_mouseview(void)
105 if( gui_want_mouse() )
108 static v2f mouse_last
,
109 view_vel
= { 0.0f
, 0.0f
};
111 if( vg_get_button_down( "primary" ) )
112 v2_copy( vg_mouse
, mouse_last
);
114 else if( vg_get_button( "primary" ) )
117 v2_sub( vg_mouse
, mouse_last
, delta
);
118 v2_copy( vg_mouse
, mouse_last
);
120 v2_muladds( view_vel
, delta
, 0.001f
, view_vel
);
123 v2_muladds( view_vel
,
124 (v2f
){ vg_get_axis("h1"), vg_get_axis("v1") },
126 v2_muls( view_vel
, 0.93f
, view_vel
);
127 v2_add( view_vel
, player
.angles
, player
.angles
);
128 player
.angles
[1] = vg_clampf( player
.angles
[1], -VG_PIf
*0.5f
, VG_PIf
*0.5f
);
131 static void player_freecam(void)
135 float movespeed
= fc_speed
;
136 v3f lookdir
= { 0.0f
, 0.0f
, -1.0f
},
137 sidedir
= { 1.0f
, 0.0f
, 0.0f
};
139 m3x3_mulv( player
.camera
, lookdir
, lookdir
);
140 m3x3_mulv( player
.camera
, sidedir
, sidedir
);
142 static v3f move_vel
= { 0.0f
, 0.0f
, 0.0f
};
143 if( vg_get_button( "forward" ) )
144 v3_muladds( move_vel
, lookdir
, ktimestep
* movespeed
, move_vel
);
145 if( vg_get_button( "back" ) )
146 v3_muladds( move_vel
, lookdir
, ktimestep
*-movespeed
, move_vel
);
147 if( vg_get_button( "left" ) )
148 v3_muladds( move_vel
, sidedir
, ktimestep
*-movespeed
, move_vel
);
149 if( vg_get_button( "right" ) )
150 v3_muladds( move_vel
, sidedir
, ktimestep
* movespeed
, move_vel
);
152 v3_muls( move_vel
, 0.7f
, move_vel
);
153 v3_add( move_vel
, player
.camera_pos
, player
.camera_pos
);
157 * Player Physics Implementation
160 static void apply_gravity( v3f vel
, float const timestep
)
162 v3f gravity
= { 0.0f
, -9.6f
, 0.0f
};
163 v3_muladds( vel
, gravity
, timestep
, vel
);
167 * TODO: The angle bias should become greater when launching from a steeper
168 * angle and skewed towords more 'downwards' angles when launching from
169 * shallower trajectories
171 * it should also be tweaked by the controller left stick being pushed
174 static void player_start_air(void)
181 float pstep
= ktimestep
*10.0f
;
182 float best_velocity_delta
= -9999.9f
;
183 float k_bias
= 0.96f
;
186 v3_cross( player
.rb
.up
, player
.rb
.v
, axis
);
187 v3_normalize( axis
);
188 player
.land_log_count
= 0;
190 m3x3_identity( player
.vr
);
192 for( int m
=-3;m
<=12; m
++ )
194 float vmod
= ((float)m
/ 15.0f
)*0.09f
;
197 v3_copy( player
.rb
.co
, pco
);
198 v3_muls( player
.rb
.v
, k_bias
, pv
);
201 * Try different 'rotations' of the velocity to find the best possible
202 * landing normal. This conserves magnitude at the expense of slightly
203 * unrealistic results
209 q_axis_angle( vr_q
, axis
, vmod
);
212 m3x3_mulv( vr
, pv
, pv
);
213 v3_muladds( pco
, pv
, pstep
, pco
);
215 for( int i
=0; i
<50; i
++ )
217 v3_copy( pco
, pco1
);
218 apply_gravity( pv
, pstep
);
220 m3x3_mulv( vr
, pv
, pv
);
221 v3_muladds( pco
, pv
, pstep
, pco
);
226 v3_sub( pco
, pco1
, vdir
);
227 contact
.dist
= v3_length( vdir
);
228 v3_divs( vdir
, contact
.dist
, vdir
);
230 if( ray_world( pco1
, vdir
, &contact
))
232 float land_delta
= v3_dot( pv
, contact
.normal
);
233 u32 scolour
= (u8
)(vg_minf(-land_delta
* 2.0f
, 255.0f
));
235 /* Bias prediction towords ramps */
236 if( ray_hit_is_ramp( &contact
) )
239 scolour
|= 0x0000a000;
242 if( (land_delta
< 0.0f
) && (land_delta
> best_velocity_delta
) )
244 best_velocity_delta
= land_delta
;
246 v3_copy( contact
.pos
, player
.land_target
);
248 m3x3_copy( vr
, player
.vr_pstep
);
249 q_axis_angle( vr_q
, axis
, vmod
*0.1f
);
250 q_m3x3( vr_q
, player
.vr
);
253 v3_copy( contact
.pos
,
254 player
.land_target_log
[player
.land_log_count
] );
255 player
.land_target_colours
[player
.land_log_count
] =
256 0xff000000 | scolour
;
258 player
.land_log_count
++;
266 static void draw_cross(v3f pos
,u32 colour
, float scale
)
269 v3_add( (v3f
){ scale
,0.0f
,0.0f
}, pos
, p0
);
270 v3_add( (v3f
){-scale
,0.0f
,0.0f
}, pos
, p1
);
271 vg_line( p0
, p1
, colour
);
272 v3_add( (v3f
){0.0f
, scale
,0.0f
}, pos
, p0
);
273 v3_add( (v3f
){0.0f
,-scale
,0.0f
}, pos
, p1
);
274 vg_line( p0
, p1
, colour
);
275 v3_add( (v3f
){0.0f
,0.0f
, scale
}, pos
, p0
);
276 v3_add( (v3f
){0.0f
,0.0f
,-scale
}, pos
, p1
);
277 vg_line( p0
, p1
, colour
);
280 static void player_physics_control(void)
283 * Computing localized friction forces for controlling the character
284 * Friction across X is significantly more than Z
288 m3x3_mulv( player
.rb
.to_local
, player
.rb
.v
, vel
);
291 if( fabsf(vel
[2]) > 0.01f
)
292 slip
= fabsf(-vel
[0] / vel
[2]) * vg_signf(vel
[0]);
294 if( fabsf( slip
) > 1.2f
)
295 slip
= vg_signf( slip
) * 1.2f
;
297 player
.reverse
= -vg_signf(vel
[2]);
299 float substep
= ktimestep
* 0.2f
;
300 float fwd_resistance
= (vg_get_button( "break" )? 5.0f
: 0.02f
) * -substep
;
302 for( int i
=0; i
<5; i
++ )
304 vel
[2] = stable_force( vel
[2], vg_signf( vel
[2] ) * fwd_resistance
);
305 vel
[0] = stable_force( vel
[0],
306 vg_signf( vel
[0] ) * -k_friction_lat
*substep
);
309 static double start_push
= 0.0;
310 if( vg_get_button_down( "push" ) )
311 start_push
= vg_time
;
313 if( vg_get_button( "jump" ) )
315 player
.jump
+= ktimestep
* k_jump_charge_speed
;
316 player
.jump_charge
= 1;
319 if( !vg_get_button("break") && vg_get_button( "push" ) )
321 player
.pushing
= 1.0f
;
322 player
.push_time
= vg_time
-start_push
;
324 float cycle_time
= player
.push_time
*k_push_cycle_rate
,
325 amt
= k_push_accel
* (sinf(cycle_time
)*0.5f
+0.5f
)*ktimestep
,
326 current
= v3_length( vel
),
327 new_vel
= vg_minf( current
+ amt
, k_max_push_speed
);
329 new_vel
-= vg_minf(current
, k_max_push_speed
);
330 vel
[2] -= new_vel
* player
.reverse
;
334 static float previous
= 0.0f
;
335 float delta
= previous
- player
.grab
,
336 pump
= delta
* k_pump_force
*ktimestep
;
337 previous
= player
.grab
;
340 v3_muladds( player
.rb
.co
, player
.rb
.up
, pump
, p1
);
341 vg_line( player
.rb
.co
, p1
, 0xff0000ff );
346 m3x3_mulv( player
.rb
.to_world
, vel
, player
.rb
.v
);
348 float steer
= vg_get_axis( "horizontal" );
349 player
.iY
-= vg_signf(steer
)*powf(steer
,2.0f
) * k_steer_ground
* ktimestep
;
351 v2_lerp( player
.board_xy
, (v2f
){ slip
*0.25f
, 0.0f
},
352 ktimestep
*5.0f
, player
.board_xy
);
355 static void player_physics_control_air(void)
357 m3x3_mulv( player
.vr
, player
.rb
.v
, player
.rb
.v
);
358 draw_cross( player
.land_target
, 0xff0000ff, 0.25f
);
365 float pstep
= ktimestep
*10.0f
;
368 v3_copy( player
.rb
.co
, pco
);
369 v3_copy( player
.rb
.v
, pv
);
371 float time_to_impact
= 0.0f
;
372 float limiter
= 1.0f
;
374 for( int i
=0; i
<50; i
++ )
376 v3_copy( pco
, pco1
);
377 m3x3_mulv( player
.vr_pstep
, pv
, pv
);
378 apply_gravity( pv
, pstep
);
379 v3_muladds( pco
, pv
, pstep
, pco
);
381 //vg_line( pco, pco1, i&0x1?0xff000000:0xffffffff );
386 v3_sub( pco
, pco1
, vdir
);
387 contact
.dist
= v3_length( vdir
);
388 v3_divs( vdir
, contact
.dist
, vdir
);
390 float orig_dist
= contact
.dist
;
391 if( ray_world( pco1
, vdir
, &contact
))
393 float angle
= v3_dot( player
.rb
.up
, contact
.normal
);
395 v3_cross( player
.rb
.up
, contact
.normal
, axis
);
397 time_to_impact
+= (contact
.dist
/orig_dist
)*pstep
;
398 limiter
= vg_minf( 5.0f
, time_to_impact
)/5.0f
;
399 limiter
= 1.0f
-limiter
;
401 limiter
= 1.0f
-limiter
;
406 q_axis_angle( correction
, axis
, acosf(angle
)*0.05f
*(1.0f
-limiter
) );
407 q_mul( correction
, player
.rb
.q
, player
.rb
.q
);
410 draw_cross( contact
.pos
, 0xffff0000, 0.25f
);
413 time_to_impact
+= pstep
;
416 player
.iY
-= vg_get_axis( "horizontal" ) * k_steer_air
* ktimestep
;
418 float iX
= vg_get_axis( "vertical" ) *
419 player
.reverse
* k_steer_air
* limiter
* ktimestep
;
421 static float siX
= 0.0f
;
422 siX
= vg_lerpf( siX
, iX
, k_steer_air_lerp
);
425 q_axis_angle( rotate
, player
.rb
.right
, siX
);
426 q_mul( rotate
, player
.rb
.q
, player
.rb
.q
);
429 v2f target
= {0.0f
,0.0f
};
430 v2_muladds( target
, (v2f
){ vg_get_axis("h1"), vg_get_axis("v1") },
431 player
.grab
, target
);
432 v2_lerp( player
.board_xy
, target
, ktimestep
*3.0f
, player
.board_xy
);
435 static void player_init(void)
437 rb_init( &player
.collide_front
);
438 rb_init( &player
.collide_back
);
441 static void player_physics(void)
444 * Update collision fronts
447 rigidbody
*rbf
= &player
.collide_front
,
448 *rbb
= &player
.collide_back
;
450 m3x3_copy( player
.rb
.to_world
, player
.collide_front
.to_world
);
451 m3x3_copy( player
.rb
.to_world
, player
.collide_back
.to_world
);
453 player
.air_blend
= vg_lerpf( player
.air_blend
, player
.in_air
, 0.1f
);
454 float h
= player
.air_blend
*0.2f
;
456 m4x3_mulv( player
.rb
.to_world
, (v3f
){0.0f
,h
,-k_board_length
}, rbf
->co
);
457 v3_copy( rbf
->co
, rbf
->to_world
[3] );
458 m4x3_mulv( player
.rb
.to_world
, (v3f
){0.0f
,h
, k_board_length
}, rbb
->co
);
459 v3_copy( rbb
->co
, rbb
->to_world
[3] );
461 m4x3_invert_affine( rbf
->to_world
, rbf
->to_local
);
462 m4x3_invert_affine( rbb
->to_world
, rbb
->to_local
);
464 rb_update_bounds( rbf
);
465 rb_update_bounds( rbb
);
467 rb_debug( rbf
, 0xff00ffff );
468 rb_debug( rbb
, 0xffffff00 );
473 len
+= rb_sphere_vs_scene( rbf
, &world
.rb_geo
, manifold
+len
);
474 len
+= rb_sphere_vs_scene( rbb
, &world
.rb_geo
, manifold
+len
);
476 rb_presolve_contacts( manifold
, len
);
477 v3f surface_avg
= {0.0f
, 0.0f
, 0.0f
};
485 for( int i
=0; i
<len
; i
++ )
487 v3_add( manifold
[i
].n
, surface_avg
, surface_avg
);
490 if( manifold
[i
].element_id
<= world
.sm_geo_std_oob
.vertex_count
)
493 character_ragdoll_copypose( &player
.mdl
, player
.rb
.v
);
499 v3_normalize( surface_avg
);
501 if( v3_dot( player
.rb
.v
, surface_avg
) > 0.5f
)
509 for( int j
=0; j
<5; j
++ )
511 for( int i
=0; i
<len
; i
++ )
513 struct contact
*ct
= &manifold
[i
];
516 v3_sub( ct
->co
, player
.rb
.co
, delta
);
517 v3_cross( player
.rb
.w
, delta
, dv
);
518 v3_add( player
.rb
.v
, dv
, dv
);
520 float vn
= -v3_dot( dv
, ct
->n
);
523 float temp
= ct
->norm_impulse
;
524 ct
->norm_impulse
= vg_maxf( temp
+ vn
, 0.0f
);
525 vn
= ct
->norm_impulse
- temp
;
528 v3_muls( ct
->n
, vn
, impulse
);
530 if( fabsf(v3_dot( impulse
, player
.rb
.forward
)) > 10.0f
||
531 fabsf(v3_dot( impulse
, player
.rb
.up
)) > 50.0f
)
534 character_ragdoll_copypose( &player
.mdl
, player
.rb
.v
);
538 v3_add( impulse
, player
.rb
.v
, player
.rb
.v
);
539 v3_cross( delta
, impulse
, impulse
);
542 * W Impulses are limited to the Y and X axises, we don't really want
543 * roll angular velocities being included.
545 * Can also tweak the resistance of each axis here by scaling the wx,wy
549 float wy
= v3_dot( player
.rb
.up
, impulse
),
550 wx
= v3_dot( player
.rb
.right
, impulse
)*1.5f
;
552 v3_muladds( player
.rb
.w
, player
.rb
.up
, wy
, player
.rb
.w
);
553 v3_muladds( player
.rb
.w
, player
.rb
.right
, wx
, player
.rb
.w
);
557 float grabt
= vg_get_axis( "grabr" )*0.5f
+0.5f
;
558 player
.grab
= vg_lerpf( player
.grab
, grabt
, 0.14f
);
559 player
.pushing
= 0.0f
;
564 float angle
= v3_dot( player
.rb
.up
, surface_avg
);
565 v3_cross( player
.rb
.up
, surface_avg
, axis
);
567 //float cz = v3_dot( player.rb.forward, axis );
568 //v3_muls( player.rb.forward, cz, axis );
573 q_axis_angle( correction
, axis
, acosf(angle
)*0.3f
);
574 q_mul( correction
, player
.rb
.q
, player
.rb
.q
);
577 v3_muladds( player
.rb
.v
, player
.rb
.up
,
578 -k_downforce
*ktimestep
, player
.rb
.v
);
580 player_physics_control();
582 if( !player
.jump_charge
&& player
.jump
> 0.2f
)
584 v3_muladds( player
.rb
.v
, player
.rb
.up
, k_jump_force
*player
.jump
,
587 player
.jump_time
= vg_time
;
592 player_physics_control_air();
595 if( !player
.jump_charge
)
597 player
.jump
-= k_jump_charge_speed
* ktimestep
;
599 player
.jump_charge
= 0;
600 player
.jump
= vg_clampf( player
.jump
, 0.0f
, 1.0f
);
603 static void player_do_motion(void)
605 float horizontal
= vg_get_axis("horizontal"),
606 vertical
= vg_get_axis("vertical");
610 /* Integrate velocity */
612 v3_copy( player
.rb
.co
, prevco
);
614 apply_gravity( player
.rb
.v
, ktimestep
);
615 v3_muladds( player
.rb
.co
, player
.rb
.v
, ktimestep
, player
.rb
.co
);
617 /* Real angular velocity integration */
618 v3_lerp( player
.rb
.w
, (v3f
){0.0f
,0.0f
,0.0f
}, 0.125f
, player
.rb
.w
);
619 if( v3_length2( player
.rb
.w
) > 0.0f
)
623 v3_copy( player
.rb
.w
, axis
);
625 float mag
= v3_length( axis
);
626 v3_divs( axis
, mag
, axis
);
627 q_axis_angle( rotation
, axis
, mag
*k_rb_delta
);
628 q_mul( rotation
, player
.rb
.q
, player
.rb
.q
);
631 /* Faux angular velocity */
634 static float siY
= 0.0f
;
635 float lerpq
= player
.in_air
? 0.04f
: 0.3f
;
636 siY
= vg_lerpf( siY
, player
.iY
, lerpq
);
638 q_axis_angle( rotate
, player
.rb
.up
, siY
);
639 q_mul( rotate
, player
.rb
.q
, player
.rb
.q
);
643 * Gate intersection, by tracing a line over the gate planes
645 for( int i
=0; i
<world
.routes
.gate_count
; i
++ )
647 struct route_gate
*rg
= &world
.routes
.gates
[i
];
648 teleport_gate
*gate
= &rg
->gate
;
650 if( gate_intersect( gate
, player
.rb
.co
, prevco
) )
652 m4x3_mulv( gate
->transport
, player
.rb
.co
, player
.rb
.co
);
653 m3x3_mulv( gate
->transport
, player
.rb
.v
, player
.rb
.v
);
654 m3x3_mulv( gate
->transport
, player
.vl
, player
.vl
);
655 m3x3_mulv( gate
->transport
, player
.v_last
, player
.v_last
);
656 m3x3_mulv( gate
->transport
, player
.m
, player
.m
);
657 m3x3_mulv( gate
->transport
, player
.bob
, player
.bob
);
659 v4f transport_rotation
;
660 m3x3_q( gate
->transport
, transport_rotation
);
661 q_mul( transport_rotation
, player
.rb
.q
, player
.rb
.q
);
663 world_routes_activate_gate( i
);
664 player
.rb_gate_frame
= player
.rb
;
669 rb_update_transform( &player
.rb
);
673 * Walkgrid implementation,
674 * loosely based of cmuratoris youtube video 'Killing the Walkmonster'
677 #define WALKGRID_SIZE 16
684 k_sample_type_air
, /* Nothing was hit. */
685 k_sample_type_invalid
, /* The point is invalid, but there is a sample
686 underneath that can be used */
687 k_sample_type_valid
, /* This point is good */
696 k_traverse_none
= 0x00,
702 samples
[WALKGRID_SIZE
][WALKGRID_SIZE
];
706 float move
; /* Current amount of movement we have left to apply */
707 v2f dir
; /* The movement delta */
708 v2i cell_id
;/* Current cell */
709 v2f pos
; /* Local position (in cell) */
713 static int player_walkgrid_tri_walkable( u32 tri
[3] )
715 return tri
[0] > world
.sm_geo_std_oob
.vertex_count
;
719 * Get a sample at this pole location, will return 1 if the sample is valid,
720 * and pos will be updated to be the intersection location.
722 static void player_walkgrid_samplepole( struct grid_sample
*s
)
724 boxf region
= {{ s
->pos
[0] -0.01f
, s
->pos
[1] - 4.0f
, s
->pos
[2] -0.01f
},
725 { s
->pos
[0] +0.01f
, s
->pos
[1] + 4.0f
, s
->pos
[2] +0.01f
}};
729 int len
= bh_select( &world
.geo
.bhtris
, region
, geo
, 256 );
731 const float k_minworld_y
= -2000.0f
;
733 float walk_height
= k_minworld_y
,
734 block_height
= k_minworld_y
;
736 s
->type
= k_sample_type_air
;
738 for( int i
=0; i
<len
; i
++ )
740 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
742 for( int j
=0; j
<3; j
++ )
743 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
745 v3f vdown
= {0.0f
,-1.0f
,0.0f
};
747 v3_copy( s
->pos
, sample_from
);
748 sample_from
[1] = region
[1][1];
751 if( ray_tri( tri
, sample_from
, vdown
, &dist
))
754 v3_muladds( sample_from
, vdown
, dist
, p0
);
756 if( player_walkgrid_tri_walkable(ptri
) )
758 if( p0
[1] > walk_height
)
765 if( p0
[1] > block_height
)
766 block_height
= p0
[1];
771 s
->pos
[1] = walk_height
;
773 if( walk_height
> k_minworld_y
)
774 if( block_height
> walk_height
)
775 s
->type
= k_sample_type_invalid
;
777 s
->type
= k_sample_type_valid
;
779 s
->type
= k_sample_type_air
;
782 float const k_gridscale
= 0.5f
;
790 static void player_walkgrid_clip_blocker( struct grid_sample
*sa
,
791 struct grid_sample
*sb
,
792 struct grid_sample
*st
,
796 int valid_a
= sa
->type
== k_sample_type_valid
,
797 valid_b
= sb
->type
== k_sample_type_valid
;
798 struct grid_sample
*target
= valid_a
? sa
: sb
,
799 *other
= valid_a
? sb
: sa
;
800 v3_copy( target
->pos
, pos
);
801 v3_sub( other
->pos
, target
->pos
, clipdir
);
804 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, -k_gridscale
*2.1f
, cell_region
[0]);
805 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, k_gridscale
*2.1f
, cell_region
[1]);
809 int len
= bh_select( &world
.geo
.bhtris
, cell_region
, geo
, 256 );
811 float start_time
= v3_length( clipdir
),
812 min_time
= start_time
;
813 v3_normalize( clipdir
);
814 v3_muls( clipdir
, 0.0001f
, st
->clip
[dir
] );
816 for( int i
=0; i
<len
; i
++ )
818 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
819 for( int j
=0; j
<3; j
++ )
820 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
822 if( player_walkgrid_tri_walkable(ptri
) )
826 if(ray_tri( tri
, pos
, clipdir
, &dist
))
828 if( dist
> 0.0f
&& dist
< min_time
)
831 sb
->type
= k_sample_type_air
;
836 if( !(min_time
< start_time
) )
837 min_time
= 0.5f
* k_gridscale
;
839 min_time
= vg_clampf( min_time
/k_gridscale
, 0.01f
, 0.99f
);
841 v3_muls( clipdir
, min_time
, st
->clip
[dir
] );
844 v3_muladds( target
->pos
, st
->clip
[dir
], k_gridscale
, p0
);
847 static void player_walkgrid_clip_edge( struct grid_sample
*sa
,
848 struct grid_sample
*sb
,
849 struct grid_sample
*st
, /* data store */
852 v3f clipdir
= { 0.0f
, 0.0f
, 0.0f
}, pos
;
853 int valid_a
= sa
->type
== k_sample_type_valid
,
854 valid_b
= sb
->type
== k_sample_type_valid
;
856 struct grid_sample
*target
= valid_a
? sa
: sb
,
857 *other
= valid_a
? sb
: sa
;
859 v3_sub( other
->pos
, target
->pos
, clipdir
);
862 v3_copy( target
->pos
, pos
);
865 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, -k_gridscale
*1.1f
, cell_region
[0]);
866 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, k_gridscale
*1.1f
, cell_region
[1]);
869 int len
= bh_select( &world
.geo
.bhtris
, cell_region
, geo
, 256 );
871 float max_dist
= 0.0f
;
874 v3_cross( clipdir
,(v3f
){0.0f
,1.0f
,0.0f
},perp
);
875 v3_muls( clipdir
, 0.001f
, st
->clip
[dir
] );
877 for( int i
=0; i
<len
; i
++ )
879 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
880 for( int j
=0; j
<3; j
++ )
881 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
883 if( !player_walkgrid_tri_walkable(ptri
) )
886 for( int k
=0; k
<3; k
++ )
892 v3_sub( tri
[ia
], pos
, v0
);
893 v3_sub( tri
[ib
], pos
, v1
);
895 if( (clipdir
[2]*v0
[0] - clipdir
[0]*v0
[2]) *
896 (clipdir
[2]*v1
[0] - clipdir
[0]*v1
[2]) < 0.0f
)
898 float da
= v3_dot(v0
,perp
),
899 db
= v3_dot(v1
,perp
),
904 v3_muls( v1
, qa
, p0
);
905 v3_muladds( p0
, v0
, 1.0f
-qa
, p0
);
907 float h
= v3_dot(p0
,clipdir
)/v3_dot(clipdir
,clipdir
);
909 if( h
>= max_dist
&& h
<= 1.0f
)
912 float l
= 1.0f
/v3_length(clipdir
);
913 v3_muls( p0
, l
, st
->clip
[dir
] );
920 static const struct conf
927 * o: the 'other' point to do a A/B test with
928 * if its -1, all AB is done.
938 k_walkgrid_configs
[16] = {
940 {{{ 3,3, 3,0, 1,0, -1,-1 }}, 1},
941 {{{ 2,2, 1,3, 0,1, -1,-1 }}, 1},
942 {{{ 2,3, 1,0, 0,0, 3,-1 }}, 1},
944 {{{ 1,1, 0,1, 1,0, -1,-1 }}, 1},
945 {{{ 3,3, 3,0, 1,0, -1,-1 },
946 { 1,1, 0,1, 1,0, -1,-1 }}, 2},
947 {{{ 1,2, 0,3, 1,1, 2,-1 }}, 1},
948 {{{ 1,3, 0,0, 1,0, 2, 2 }}, 1},
950 {{{ 0,0, 0,0, 0,1, -1,-1 }}, 1},
951 {{{ 3,0, 3,0, 1,1, 0,-1 }}, 1},
952 {{{ 2,2, 1,3, 0,1, -1,-1 },
953 { 0,0, 0,0, 0,1, -1,-1 }}, 2},
954 {{{ 2,0, 1,0, 0,1, 3, 3 }}, 1},
956 {{{ 0,1, 0,1, 0,0, 1,-1 }}, 1},
957 {{{ 3,1, 3,1, 1,0, 0, 0 }}, 1},
958 {{{ 0,2, 0,3, 0,1, 1, 1 }}, 1},
963 * Get a buffer of edges from cell location
965 static const struct conf
*player_walkgrid_conf( struct walkgrid
*wg
,
967 struct grid_sample
*corners
[4] )
969 corners
[0] = &wg
->samples
[cell
[1] ][cell
[0] ];
970 corners
[1] = &wg
->samples
[cell
[1]+1][cell
[0] ];
971 corners
[2] = &wg
->samples
[cell
[1]+1][cell
[0]+1];
972 corners
[3] = &wg
->samples
[cell
[1] ][cell
[0]+1];
974 u32 vd0
= corners
[0]->type
== k_sample_type_valid
,
975 vd1
= corners
[1]->type
== k_sample_type_valid
,
976 vd2
= corners
[2]->type
== k_sample_type_valid
,
977 vd3
= corners
[3]->type
== k_sample_type_valid
,
978 config
= (vd0
<<3) | (vd1
<<2) | (vd2
<<1) | vd3
;
980 return &k_walkgrid_configs
[ config
];
983 static void player_walkgrid_floor(v3f pos
)
985 v3_muls( pos
, 1.0f
/k_gridscale
, pos
);
986 v3_floor( pos
, pos
);
987 v3_muls( pos
, k_gridscale
, pos
);
991 * Computes the barycentric coordinate of location on a triangle (vertical),
992 * then sets the Y position to the interpolation of the three points
994 static void player_walkgrid_stand_tri( v3f a
, v3f b
, v3f c
, v3f pos
)
999 v3_sub( pos
, a
, v2
);
1001 float d
= v0
[0]*v1
[2] - v1
[0]*v0
[2],
1002 v
= (v2
[0]*v1
[2] - v1
[0]*v2
[2]) / d
,
1003 w
= (v0
[0]*v2
[2] - v2
[0]*v0
[2]) / d
,
1006 vg_line( pos
, a
, 0xffff0000 );
1007 vg_line( pos
, b
, 0xff00ff00 );
1008 vg_line( pos
, c
, 0xff0000ff );
1009 pos
[1] = u
*a
[1] + v
*b
[1] + w
*c
[1];
1013 * Get the minimum time value of pos+dir until a cell edge
1015 * t[0] -> t[3] are the individual time values
1016 * t[5] & t[6] are the maximum axis values
1017 * t[6] is the minimum value
1020 static void player_walkgrid_min_cell( float t
[7], v2f pos
, v2f dir
)
1022 v2f frac
= { 1.0f
/dir
[0], 1.0f
/dir
[1] };
1029 if( fabsf(dir
[0]) > 0.0001f
)
1031 t
[0] = (0.0f
-pos
[0]) * frac
[0];
1032 t
[1] = (1.0f
-pos
[0]) * frac
[0];
1034 if( fabsf(dir
[1]) > 0.0001f
)
1036 t
[2] = (0.0f
-pos
[1]) * frac
[1];
1037 t
[3] = (1.0f
-pos
[1]) * frac
[1];
1040 t
[4] = vg_maxf(t
[0],t
[1]);
1041 t
[5] = vg_maxf(t
[2],t
[3]);
1042 t
[6] = vg_minf(t
[4],t
[5]);
1045 static void player_walkgrid_iter(struct walkgrid
*wg
, int iter
)
1049 * For each walkgrid iteration we are stepping through cells and determining
1050 * the intersections with the grid, and any edges that are present
1053 u32 icolours
[] = { 0xffff00ff, 0xff00ffff, 0xffffff00 };
1055 v3f pa
, pb
, pc
, pd
, pl0
, pl1
;
1056 pa
[0] = wg
->region
[0][0] + (float)wg
->cell_id
[0] *k_gridscale
;
1057 pa
[1] = (wg
->region
[0][1] + wg
->region
[1][1]) * 0.5f
+ k_gridscale
;
1058 pa
[2] = wg
->region
[0][2] + (float)wg
->cell_id
[1] *k_gridscale
;
1062 pb
[2] = pa
[2] + k_gridscale
;
1063 pc
[0] = pa
[0] + k_gridscale
;
1065 pc
[2] = pa
[2] + k_gridscale
;
1066 pd
[0] = pa
[0] + k_gridscale
;
1069 /* if you want to draw the current cell */
1070 vg_line( pa
, pb
, 0xff00ffff );
1071 vg_line( pb
, pc
, 0xff00ffff );
1072 vg_line( pc
, pd
, 0xff00ffff );
1073 vg_line( pd
, pa
, 0xff00ffff );
1075 pl0
[0] = pa
[0] + wg
->pos
[0]*k_gridscale
;
1077 pl0
[2] = pa
[2] + wg
->pos
[1]*k_gridscale
;
1080 * If there are edges present, we need to create a 'substep' event, where
1081 * we find the intersection point, find the fully resolved position,
1082 * then the new pos dir is the intersection->resolution
1084 * the resolution is applied in non-discretized space in order to create a
1085 * suitable vector for finding outflow, we want it to leave the cell so it
1086 * can be used by the quad
1090 v2_copy( wg
->pos
, pos
);
1091 v2_muls( wg
->dir
, wg
->move
, dir
);
1093 struct grid_sample
*corners
[4];
1094 v2f corners2d
[4] = {{0.0f
,0.0f
},{0.0f
,1.0f
},{1.0f
,1.0f
},{1.0f
,0.0f
}};
1095 const struct conf
*conf
= player_walkgrid_conf( wg
, wg
->cell_id
, corners
);
1098 player_walkgrid_min_cell( t
, pos
, dir
);
1100 for( int i
=0; i
<conf
->edge_count
; i
++ )
1102 const struct confedge
*edge
= &conf
->edges
[i
];
1104 v2f e0
, e1
, n
, r
, target
, res
, tangent
;
1105 e0
[0] = corners2d
[edge
->i0
][0] + corners
[edge
->d0
]->clip
[edge
->a0
][0];
1106 e0
[1] = corners2d
[edge
->i0
][1] + corners
[edge
->d0
]->clip
[edge
->a0
][2];
1107 e1
[0] = corners2d
[edge
->i1
][0] + corners
[edge
->d1
]->clip
[edge
->a1
][0];
1108 e1
[1] = corners2d
[edge
->i1
][1] + corners
[edge
->d1
]->clip
[edge
->a1
][2];
1110 v3f pe0
= { pa
[0] + e0
[0]*k_gridscale
,
1112 pa
[2] + e0
[1]*k_gridscale
};
1113 v3f pe1
= { pa
[0] + e1
[0]*k_gridscale
,
1115 pa
[2] + e1
[1]*k_gridscale
};
1117 v2_sub( e1
, e0
, tangent
);
1123 * If we find ourselfs already penetrating the edge, move back out a
1126 v2_sub( e0
, pos
, r
);
1127 float p1
= v2_dot(r
,n
);
1131 v2_muladds( pos
, n
, p1
+0.0001f
, pos
);
1132 v2_copy( pos
, wg
->pos
);
1133 v3f p_new
= { pa
[0] + pos
[0]*k_gridscale
,
1135 pa
[2] + pos
[1]*k_gridscale
};
1136 v3_copy( p_new
, pl0
);
1139 v2_add( pos
, dir
, target
);
1142 v2_sub( e0
, pos
, v1
);
1143 v2_sub( target
, pos
, v2
);
1147 v2_sub( e0
, target
, r
);
1148 float p
= v2_dot(r
,n
),
1149 t1
= v2_dot(v1
,v3
)/v2_dot(v2
,v3
);
1151 if( t1
< t
[6] && t1
> 0.0f
&& -p
< 0.001f
)
1153 v2_muladds( target
, n
, p
+0.0001f
, res
);
1156 v2_muladds( pos
, dir
, t1
, intersect
);
1157 v2_copy( intersect
, pos
);
1158 v2_sub( res
, intersect
, dir
);
1160 v3f p_res
= { pa
[0] + res
[0]*k_gridscale
,
1162 pa
[2] + res
[1]*k_gridscale
};
1163 v3f p_int
= { pa
[0] + intersect
[0]*k_gridscale
,
1165 pa
[2] + intersect
[1]*k_gridscale
};
1167 vg_line( pl0
, p_int
, icolours
[iter
%3] );
1168 v3_copy( p_int
, pl0
);
1169 v2_copy( pos
, wg
->pos
);
1171 player_walkgrid_min_cell( t
, pos
, dir
);
1176 * Compute intersection with grid cell moving outwards
1178 t
[6] = vg_minf( t
[6], 1.0f
);
1180 pl1
[0] = pl0
[0] + dir
[0]*k_gridscale
*t
[6];
1182 pl1
[2] = pl0
[2] + dir
[1]*k_gridscale
*t
[6];
1183 vg_line( pl0
, pl1
, icolours
[iter
%3] );
1188 * To figure out what t value created the clip so we know which edge
1194 wg
->pos
[1] = pos
[1] + dir
[1]*t
[6];
1196 if( t
[0] > t
[1] ) /* left edge */
1198 wg
->pos
[0] = 0.9999f
;
1201 if( wg
->cell_id
[0] == 0 )
1204 else /* Right edge */
1206 wg
->pos
[0] = 0.0001f
;
1209 if( wg
->cell_id
[0] == WALKGRID_SIZE
-2 )
1215 wg
->pos
[0] = pos
[0] + dir
[0]*t
[6];
1217 if( t
[2] > t
[3] ) /* bottom edge */
1219 wg
->pos
[1] = 0.9999f
;
1222 if( wg
->cell_id
[1] == 0 )
1227 wg
->pos
[1] = 0.0001f
;
1230 if( wg
->cell_id
[1] == WALKGRID_SIZE
-2 )
1239 v2_muladds( wg
->pos
, dir
, wg
->move
, wg
->pos
);
1244 static void player_walkgrid_stand_cell(struct walkgrid
*wg
)
1247 * NOTE: as opposed to the other function which is done in discretized space
1248 * this use a combination of both.
1252 world
[0] = wg
->region
[0][0]+((float)wg
->cell_id
[0]+wg
->pos
[0])*k_gridscale
;
1253 world
[1] = player
.rb
.co
[1];
1254 world
[2] = wg
->region
[0][2]+((float)wg
->cell_id
[1]+wg
->pos
[1])*k_gridscale
;
1256 struct grid_sample
*corners
[4];
1257 const struct conf
*conf
= player_walkgrid_conf( wg
, wg
->cell_id
, corners
);
1259 if( conf
!= k_walkgrid_configs
)
1261 if( conf
->edge_count
== 0 )
1265 /* Split the basic quad along the shortest diagonal */
1266 if( fabsf(corners
[2]->pos
[1] - corners
[0]->pos
[1]) <
1267 fabsf(corners
[3]->pos
[1] - corners
[1]->pos
[1]) )
1269 vg_line( corners
[2]->pos
, corners
[0]->pos
, 0xffaaaaaa );
1271 if( wg
->pos
[0] > wg
->pos
[1] )
1272 player_walkgrid_stand_tri( corners
[0]->pos
,
1274 corners
[2]->pos
, world
);
1276 player_walkgrid_stand_tri( corners
[0]->pos
,
1278 corners
[1]->pos
, world
);
1282 vg_line( corners
[3]->pos
, corners
[1]->pos
, 0xffaaaaaa );
1284 if( wg
->pos
[0] < 1.0f
-wg
->pos
[1] )
1285 player_walkgrid_stand_tri( corners
[0]->pos
,
1287 corners
[1]->pos
, world
);
1289 player_walkgrid_stand_tri( corners
[3]->pos
,
1291 corners
[1]->pos
, world
);
1296 for( int i
=0; i
<conf
->edge_count
; i
++ )
1298 const struct confedge
*edge
= &conf
->edges
[i
];
1301 v3_muladds( corners
[edge
->i0
]->pos
,
1302 corners
[edge
->d0
]->clip
[edge
->a0
], k_gridscale
, p0
);
1303 v3_muladds( corners
[edge
->i1
]->pos
,
1304 corners
[edge
->d1
]->clip
[edge
->a1
], k_gridscale
, p1
);
1307 * Find penetration distance between player position and the edge
1310 v2f normal
= { -(p1
[2]-p0
[2]), p1
[0]-p0
[0] },
1311 rel
= { world
[0]-p0
[0], world
[2]-p0
[2] };
1313 if( edge
->o0
== -1 )
1315 /* No subregions (default case), just use triangle created by
1317 player_walkgrid_stand_tri( corners
[edge
->i0
]->pos
,
1324 * Test if we are in the first region, which is
1325 * edge.i0, edge.e0, edge.o0,
1328 v3_sub( p0
, corners
[edge
->o0
]->pos
, ref
);
1329 v3_sub( world
, corners
[edge
->o0
]->pos
, v0
);
1331 vg_line( corners
[edge
->o0
]->pos
, p0
, 0xffffff00 );
1332 vg_line( corners
[edge
->o0
]->pos
, world
, 0xff000000 );
1334 if( ref
[0]*v0
[2] - ref
[2]*v0
[0] < 0.0f
)
1336 player_walkgrid_stand_tri( corners
[edge
->i0
]->pos
,
1338 corners
[edge
->o0
]->pos
, world
);
1342 if( edge
->o1
== -1 )
1345 * No other edges mean we just need to use the opposite
1347 * e0, e1, o0 (in our case, also i1)
1349 player_walkgrid_stand_tri( p0
,
1351 corners
[edge
->o0
]->pos
, world
);
1356 * Note: this v0 calculation can be ommited with the
1359 * the last two triangles we have are:
1364 v3_sub( p1
, corners
[edge
->o1
]->pos
, ref
);
1365 v3_sub( world
, corners
[edge
->o1
]->pos
, v0
);
1366 vg_line( corners
[edge
->o1
]->pos
, p1
, 0xff00ffff );
1368 if( ref
[0]*v0
[2] - ref
[2]*v0
[0] < 0.0f
)
1370 player_walkgrid_stand_tri( p0
,
1372 corners
[edge
->o1
]->pos
,
1377 player_walkgrid_stand_tri( p1
,
1378 corners
[edge
->i1
]->pos
,
1379 corners
[edge
->o1
]->pos
,
1389 v3_copy( world
, player
.rb
.co
);
1392 static void player_walkgrid_getsurface(void)
1394 float const k_stepheight
= 0.5f
;
1395 float const k_miny
= 0.6f
;
1396 float const k_height
= 1.78f
;
1397 float const k_region_size
= (float)WALKGRID_SIZE
/2.0f
* k_gridscale
;
1399 static struct walkgrid wg
;
1402 v3_copy( player
.rb
.co
, cell
);
1403 player_walkgrid_floor( cell
);
1405 v3_muladds( cell
, (v3f
){-1.0f
,-1.0f
,-1.0f
}, k_region_size
, wg
.region
[0] );
1406 v3_muladds( cell
, (v3f
){ 1.0f
, 1.0f
, 1.0f
}, k_region_size
, wg
.region
[1] );
1410 * Create player input vector
1412 v3f delta
= {0.0f
,0.0f
,0.0f
};
1413 v3f fwd
= { -sinf(-player
.angles
[0]), 0.0f
, -cosf(-player
.angles
[0]) },
1414 side
= { -fwd
[2], 0.0f
, fwd
[0] };
1417 if( !vg_console_enabled() )
1419 if( glfwGetKey( vg_window
, GLFW_KEY_W
) )
1420 v3_muladds( delta
, fwd
, ktimestep
*k_walkspeed
, delta
);
1421 if( glfwGetKey( vg_window
, GLFW_KEY_S
) )
1422 v3_muladds( delta
, fwd
, -ktimestep
*k_walkspeed
, delta
);
1424 if( glfwGetKey( vg_window
, GLFW_KEY_A
) )
1425 v3_muladds( delta
, side
, -ktimestep
*k_walkspeed
, delta
);
1426 if( glfwGetKey( vg_window
, GLFW_KEY_D
) )
1427 v3_muladds( delta
, side
, ktimestep
*k_walkspeed
, delta
);
1429 v3_muladds( delta
, fwd
,
1430 vg_get_axis("vertical")*-ktimestep
*k_walkspeed
, delta
);
1431 v3_muladds( delta
, side
,
1432 vg_get_axis("horizontal")*ktimestep
*k_walkspeed
, delta
);
1436 * Create our move in grid space
1438 wg
.dir
[0] = delta
[0] * (1.0f
/k_gridscale
);
1439 wg
.dir
[1] = delta
[2] * (1.0f
/k_gridscale
);
1444 (player
.rb
.co
[0] - wg
.region
[0][0]) * (1.0f
/k_gridscale
),
1445 (player
.rb
.co
[2] - wg
.region
[0][2]) * (1.0f
/k_gridscale
)
1447 v2f region_cell_pos
;
1448 v2_floor( region_pos
, region_cell_pos
);
1449 v2_sub( region_pos
, region_cell_pos
, wg
.pos
);
1451 wg
.cell_id
[0] = region_cell_pos
[0];
1452 wg
.cell_id
[1] = region_cell_pos
[1];
1454 for(int y
=0; y
<WALKGRID_SIZE
; y
++ )
1456 for(int x
=0; x
<WALKGRID_SIZE
; x
++ )
1458 struct grid_sample
*s
= &wg
.samples
[y
][x
];
1459 v3_muladds( wg
.region
[0], (v3f
){ x
, 0, y
}, k_gridscale
, s
->pos
);
1460 s
->state
= k_traverse_none
;
1461 s
->type
= k_sample_type_air
;
1462 v3_zero( s
->clip
[0] );
1463 v3_zero( s
->clip
[1] );
1467 v2i border
[WALKGRID_SIZE
*WALKGRID_SIZE
];
1468 v2i
*cborder
= border
;
1469 u32 border_length
= 1;
1471 struct grid_sample
*base
= NULL
;
1473 v2i starters
[] = {{0,0},{1,1},{0,1},{1,0}};
1475 for( int i
=0;i
<4;i
++ )
1478 v2i_add( wg
.cell_id
, starters
[i
], test
);
1479 v2i_copy( test
, border
[0] );
1480 base
= &wg
.samples
[test
[1]][test
[0]];
1482 base
->pos
[1] = cell
[1];
1483 player_walkgrid_samplepole( base
);
1485 if( base
->type
== k_sample_type_valid
)
1488 base
->type
= k_sample_type_air
;
1491 vg_line_pt3( base
->pos
, 0.1f
, 0xffffffff );
1495 while( border_length
)
1497 v2i directions
[] = {{1,0},{0,1},{-1,0},{0,-1}};
1499 v2i
*old_border
= cborder
;
1500 int len
= border_length
;
1503 cborder
= old_border
+len
;
1505 for( int i
=0; i
<len
; i
++ )
1508 v2i_copy( old_border
[i
], co
);
1509 struct grid_sample
*sa
= &wg
.samples
[co
[1]][co
[0]];
1511 for( int j
=0; j
<4; j
++ )
1514 v2i_add( co
, directions
[j
], newp
);
1516 if( newp
[0] < 0 || newp
[1] < 0 ||
1517 newp
[0] == WALKGRID_SIZE
|| newp
[1] == WALKGRID_SIZE
)
1520 struct grid_sample
*sb
= &wg
.samples
[newp
[1]][newp
[0]];
1521 enum traverse_state thismove
= j
%2==0? 1: 2;
1523 if( (sb
->state
& thismove
) == 0x00 ||
1524 sb
->type
== k_sample_type_air
)
1526 sb
->pos
[1] = sa
->pos
[1];
1528 player_walkgrid_samplepole( sb
);
1530 if( sb
->type
!= k_sample_type_air
)
1533 * Need to do a blocker pass
1536 struct grid_sample
*store
= (j
>>1 == 0)? sa
: sb
;
1537 player_walkgrid_clip_blocker( sa
, sb
, store
, j
%2 );
1540 if( sb
->type
!= k_sample_type_air
)
1542 vg_line( sa
->pos
, sb
->pos
, 0xffffffff );
1544 if( sb
->state
== k_traverse_none
)
1545 v2i_copy( newp
, cborder
[ border_length
++ ] );
1550 v3_muladds( sa
->pos
, store
->clip
[j
%2], k_gridscale
, p1
);
1551 vg_line( sa
->pos
, p1
, 0xffffffff );
1557 * A clipping pass is now done on the edge of the walkable
1561 struct grid_sample
*store
= (j
>>1 == 0)? sa
: sb
;
1562 player_walkgrid_clip_edge( sa
, sb
, store
, j
%2 );
1565 v3_muladds( sa
->pos
, store
->clip
[j
%2], k_gridscale
, p1
);
1566 vg_line( sa
->pos
, p1
, 0xffffffff );
1569 sb
->state
|= thismove
;
1573 sa
->state
= k_traverse_h
|k_traverse_v
;
1577 if( iter
== walk_grid_iterations
)
1581 /* Draw connections */
1582 struct grid_sample
*corners
[4];
1583 for( int x
=0; x
<WALKGRID_SIZE
-1; x
++ )
1585 for( int z
=0; z
<WALKGRID_SIZE
-1; z
++ )
1587 const struct conf
*conf
=
1588 player_walkgrid_conf( &wg
, (v2i
){x
,z
}, corners
);
1590 for( int i
=0; i
<conf
->edge_count
; i
++ )
1592 const struct confedge
*edge
= &conf
->edges
[i
];
1595 v3_muladds( corners
[edge
->i0
]->pos
,
1596 corners
[edge
->d0
]->clip
[edge
->a0
], k_gridscale
, p0
);
1597 v3_muladds( corners
[edge
->i1
]->pos
,
1598 corners
[edge
->d1
]->clip
[edge
->a1
], k_gridscale
, p1
);
1600 vg_line( p0
, p1
, 0xff0000ff );
1606 * Commit player movement into the grid
1609 if( v3_length2(delta
) <= 0.00001f
)
1613 for(; i
<8 && wg
.move
> 0.001f
; i
++ )
1614 player_walkgrid_iter( &wg
, i
);
1616 player_walkgrid_stand_cell( &wg
);
1619 static void player_walkgrid(void)
1621 player_walkgrid_getsurface();
1623 m4x3_mulv( player
.rb
.to_world
, (v3f
){0.0f
,1.8f
,0.0f
}, player
.camera_pos
);
1625 rb_update_transform( &player
.rb
);
1632 static void player_animate(void)
1634 /* Camera position */
1635 v3_sub( player
.rb
.v
, player
.v_last
, player
.a
);
1636 v3_copy( player
.rb
.v
, player
.v_last
);
1638 v3_add( player
.m
, player
.a
, player
.m
);
1639 v3_lerp( player
.m
, (v3f
){0.0f
,0.0f
,0.0f
}, 0.1f
, player
.m
);
1641 player
.m
[0] = vg_clampf( player
.m
[0], -2.0f
, 2.0f
);
1642 player
.m
[1] = vg_clampf( player
.m
[1], -2.0f
, 2.0f
);
1643 player
.m
[2] = vg_clampf( player
.m
[2], -2.0f
, 2.0f
);
1644 v3_lerp( player
.bob
, player
.m
, 0.2f
, player
.bob
);
1647 float lslip
= fabsf(player
.slip
);
1649 float kheight
= 2.0f
,
1654 m3x3_mulv( player
.rb
.to_local
, player
.bob
, offset
);
1656 static float speed_wobble
= 0.0f
, speed_wobble_2
= 0.0f
;
1658 float kickspeed
= vg_clampf(v3_length(player
.rb
.v
)*(1.0f
/40.0f
), 0.0f
, 1.0f
);
1659 float kicks
= (vg_randf()-0.5f
)*2.0f
*kickspeed
;
1660 float sign
= vg_signf( kicks
);
1661 speed_wobble
= vg_lerpf( speed_wobble
, kicks
*kicks
*sign
, 0.1f
);
1662 speed_wobble_2
= vg_lerpf( speed_wobble_2
, speed_wobble
, 0.04f
);
1665 offset
[0] += speed_wobble_2
*3.0f
;
1670 offset
[0] = vg_clampf( offset
[0], -0.8f
, 0.8f
);
1671 offset
[1] = vg_clampf( offset
[1], -0.5f
, 0.0f
);
1675 * Animation blending
1676 * ===========================================
1679 /* scalar blending information */
1680 float speed
= v3_length( player
.rb
.v
);
1684 float desired
= vg_clampf( lslip
, 0.0f
, 1.0f
);
1685 player
.fslide
= vg_lerpf( player
.fslide
, desired
, 0.04f
);
1688 /* movement information */
1690 float dirz
= player
.reverse
> 0.0f
? 0.0f
: 1.0f
,
1691 dirx
= player
.slip
< 0.0f
? 0.0f
: 1.0f
,
1692 fly
= player
.in_air
? 1.0f
: 0.0f
;
1694 player
.fdirz
= vg_lerpf( player
.fdirz
, dirz
, 0.04f
);
1695 player
.fdirx
= vg_lerpf( player
.fdirx
, dirx
, 0.01f
);
1696 player
.ffly
= vg_lerpf( player
.ffly
, fly
, 0.04f
);
1699 struct skeleton
*sk
= &player
.mdl
.sk
;
1701 mdl_keyframe apose
[32], bpose
[32];
1702 mdl_keyframe ground_pose
[32];
1704 /* when the player is moving fast he will crouch down a little bit */
1705 float stand
= 1.0f
- vg_clampf( speed
* 0.03f
, 0.0f
, 1.0f
);
1706 player
.fstand
= vg_lerpf( player
.fstand
, stand
, 0.1f
);
1709 float dir_frame
= player
.fdirz
* (15.0f
/30.0f
),
1710 stand_blend
= offset
[1]*-2.0f
;
1712 skeleton_sample_anim( sk
, player
.mdl
.anim_stand
, dir_frame
, apose
);
1713 skeleton_sample_anim( sk
, player
.mdl
.anim_highg
, dir_frame
, bpose
);
1714 skeleton_lerp_pose( sk
, apose
, bpose
, stand_blend
, apose
);
1717 float slide_frame
= player
.fdirx
* (15.0f
/30.0f
);
1718 skeleton_sample_anim( sk
, player
.mdl
.anim_slide
, slide_frame
, bpose
);
1719 skeleton_lerp_pose( sk
, apose
, bpose
, player
.fslide
, apose
);
1722 player
.fpush
= vg_lerpf( player
.fpush
, player
.pushing
, 0.1f
);
1724 float pt
= player
.push_time
;
1725 if( player
.reverse
> 0.0f
)
1726 skeleton_sample_anim( sk
, player
.mdl
.anim_push
, pt
, bpose
);
1728 skeleton_sample_anim( sk
, player
.mdl
.anim_push_reverse
, pt
, bpose
);
1730 skeleton_lerp_pose( sk
, apose
, bpose
, player
.fpush
, apose
);
1733 float setup_frame
= player
.jump
* (12.0f
/30.0f
),
1734 setup_blend
= vg_minf( player
.jump
*5.0f
, 1.0f
);
1736 float jump_frame
= (vg_time
- player
.jump_time
) + (12.0f
/30.0f
);
1737 if( jump_frame
>= (12.0f
/30.0f
) && jump_frame
<= (40.0f
/30.0f
) )
1738 setup_frame
= jump_frame
;
1740 skeleton_sample_anim_clamped( sk
, player
.mdl
.anim_ollie
,
1741 setup_frame
, bpose
);
1742 skeleton_lerp_pose( sk
, apose
, bpose
, setup_blend
, ground_pose
);
1745 mdl_keyframe air_pose
[32];
1747 float target
= -vg_get_axis("horizontal");
1748 player
.fairdir
= vg_lerpf( player
.fairdir
, target
, 0.04f
);
1750 float air_frame
= (player
.fairdir
*0.5f
+0.5f
) * (15.0f
/30.0f
);
1752 skeleton_sample_anim( sk
, player
.mdl
.anim_air
, air_frame
, air_pose
);
1755 skeleton_lerp_pose( sk
, ground_pose
, air_pose
, player
.ffly
, apose
);
1757 /* additive effects */
1758 apose
[player
.mdl
.id_hip
-1].co
[0] += offset
[0];
1759 apose
[player
.mdl
.id_hip
-1].co
[2] += offset
[2];
1760 apose
[player
.mdl
.id_ik_hand_l
-1].co
[0] += offset
[0];
1761 apose
[player
.mdl
.id_ik_hand_l
-1].co
[2] += offset
[2];
1762 apose
[player
.mdl
.id_ik_hand_r
-1].co
[0] += offset
[0];
1763 apose
[player
.mdl
.id_ik_hand_r
-1].co
[2] += offset
[2];
1764 apose
[player
.mdl
.id_ik_elbow_l
-1].co
[0] += offset
[0];
1765 apose
[player
.mdl
.id_ik_elbow_l
-1].co
[2] += offset
[2];
1766 apose
[player
.mdl
.id_ik_elbow_r
-1].co
[0] += offset
[0];
1767 apose
[player
.mdl
.id_ik_elbow_r
-1].co
[2] += offset
[2];
1769 skeleton_apply_pose( &player
.mdl
.sk
, apose
, k_anim_apply_defer_ik
);
1770 skeleton_apply_ik_pass( &player
.mdl
.sk
);
1771 skeleton_apply_pose( &player
.mdl
.sk
, apose
, k_anim_apply_deffered_only
);
1773 v3_copy( player
.mdl
.sk
.final_mtx
[player
.mdl
.id_head
-1][3],
1774 player
.mdl
.cam_pos
);
1775 skeleton_apply_inverses( &player
.mdl
.sk
);
1776 skeleton_apply_transform( &player
.mdl
.sk
, player
.rb
.to_world
);
1778 skeleton_debug( &player
.mdl
.sk
);
1781 static void player_camera_update(void)
1783 /* Update camera matrices */
1784 m4x3_identity( player
.camera
);
1785 m4x3_rotate_y( player
.camera
, -player
.angles
[0] );
1786 m4x3_rotate_x( player
.camera
, -player
.angles
[1] );
1787 v3_copy( player
.camera_pos
, player
.camera
[3] );
1788 m4x3_invert_affine( player
.camera
, player
.camera_inverse
);
1791 static void player_animate_death_cam(void)
1796 v3_copy( player
.mdl
.ragdoll
[k_chpart_head
].co
, head_pos
);
1798 v3_sub( head_pos
, player
.camera_pos
, delta
);
1799 v3_normalize( delta
);
1802 v3_muladds( head_pos
, delta
, -2.5f
, follow_pos
);
1803 v3_lerp( player
.camera_pos
, follow_pos
, 0.1f
, player
.camera_pos
);
1806 * Make sure the camera stays above the ground
1808 v3f min_height
= {0.0f
,1.0f
,0.0f
};
1811 v3_add( player
.camera_pos
, min_height
, sample
);
1813 hit
.dist
= min_height
[1]*2.0f
;
1815 if( ray_world( sample
, (v3f
){0.0f
,-1.0f
,0.0f
}, &hit
))
1816 v3_add( hit
.pos
, min_height
, player
.camera_pos
);
1818 player
.camera_pos
[1] =
1819 vg_maxf( wrender
.height
+ 2.0f
, player
.camera_pos
[1] );
1821 player
.angles
[0] = atan2f( delta
[0], -delta
[2] );
1822 player
.angles
[1] = -asinf( delta
[1] );
1826 static void player_animate_camera(void)
1828 static v3f lerp_cam
= {0.0f
,0.0f
,0.0f
};
1829 v3f offs
= { -0.4f
, 0.15f
, 0.0f
};
1831 v3_lerp( lerp_cam
, player
.mdl
.cam_pos
, 0.8f
, lerp_cam
);
1832 v3_add( lerp_cam
, offs
, offs
);
1833 m4x3_mulv( player
.rb
.to_world
, offs
, player
.camera_pos
);
1836 v3_lerp( player
.vl
, player
.rb
.v
, 0.05f
, player
.vl
);
1838 float yaw
= atan2f( player
.vl
[0], -player
.vl
[2] ),
1839 pitch
= atan2f( -player
.vl
[1],
1841 player
.vl
[0]*player
.vl
[0] + player
.vl
[2]*player
.vl
[2]
1844 player
.angles
[0] = yaw
;
1845 player
.angles
[1] = pitch
+ 0.30f
;
1848 static v2f shake_damp
= {0.0f
,0.0f
};
1849 v2f shake
= { vg_randf()-0.5f
, vg_randf()-0.5f
};
1850 v2_muls( shake
, v3_length(player
.rb
.v
)*0.3f
1851 * (1.0f
+fabsf(player
.slip
)), shake
);
1853 v2_lerp( shake_damp
, shake
, 0.01f
, shake_damp
);
1854 shake_damp
[0] *= 0.2f
;
1856 v2_muladds( player
.angles
, shake_damp
, 0.1f
, player
.angles
);
1862 static void player_audio(void)
1864 float speed
= vg_minf(v3_length( player
.rb
.v
)*0.1f
,1.0f
),
1865 attn
= v3_dist( player
.rb
.co
, player
.camera
[3] )+1.0f
;
1866 attn
= (1.0f
/(attn
*attn
)) * speed
;
1868 static float air
= 0.0f
;
1869 air
= vg_lerpf(air
, player
.in_air
? 1.0f
: 0.0f
, 0.7f
);
1871 v3f ears
= { 1.0f
,0.0f
,0.0f
};
1874 v3_sub( player
.rb
.co
, player
.camera
[3], delta
);
1875 v3_normalize( delta
);
1876 m3x3_mulv( player
.camera
, ears
, ears
);
1878 float pan
= v3_dot( ears
, delta
);
1879 audio_player0
.pan
= pan
;
1880 audio_player1
.pan
= pan
;
1881 audio_player2
.pan
= pan
;
1885 audio_player0
.vol
= 0.0f
;
1886 audio_player1
.vol
= 0.0f
;
1887 audio_player2
.vol
= 0.0f
;
1891 if( player
.is_dead
)
1893 audio_player0
.vol
= 0.0f
;
1894 audio_player1
.vol
= 0.0f
;
1895 audio_player2
.vol
= 0.0f
;
1899 float slide
= vg_clampf( fabsf(player
.slip
), 0.0f
, 1.0f
);
1900 audio_player0
.vol
= (1.0f
-air
)*attn
*(1.0f
-slide
);
1901 audio_player1
.vol
= air
*attn
;
1902 audio_player2
.vol
= (1.0f
-air
)*attn
*slide
;
1910 static float *player_cam_pos(void)
1912 return player
.camera_pos
;
1915 static int reset_player( int argc
, char const *argv
[] )
1917 struct respawn_point
*rp
= NULL
, *r
;
1921 for( int i
=0; i
<world
.spawn_count
; i
++ )
1923 r
= &world
.spawns
[i
];
1924 if( !strcmp( r
->name
, argv
[0] ) )
1932 vg_warn( "No spawn named '%s'\n", argv
[0] );
1937 float min_dist
= INFINITY
;
1939 for( int i
=0; i
<world
.spawn_count
; i
++ )
1941 r
= &world
.spawns
[i
];
1942 float d
= v3_dist2( r
->co
, player
.rb
.co
);
1944 vg_info( "Dist %s : %f\n", r
->name
, d
);
1955 vg_error( "No spawn found\n" );
1956 if( !world
.spawn_count
)
1959 rp
= &world
.spawns
[0];
1962 v4_copy( rp
->q
, player
.rb
.q
);
1963 v3_copy( rp
->co
, player
.rb
.co
);
1965 player
.vswitch
= 1.0f
;
1966 player
.slip_last
= 0.0f
;
1969 m3x3_identity( player
.vr
);
1971 player
.mdl
.shoes
[0] = 1;
1972 player
.mdl
.shoes
[1] = 1;
1974 rb_update_transform( &player
.rb
);
1975 m3x3_mulv( player
.rb
.to_world
, (v3f
){ 0.0f
, 0.0f
, -1.2f
}, player
.rb
.v
);
1977 player
.rb_gate_frame
= player
.rb
;
1981 static void player_update(void)
1983 for( int i
=0; i
<player
.land_log_count
; i
++ )
1984 draw_cross( player
.land_target_log
[i
],
1985 player
.land_target_colours
[i
], 0.25f
);
1987 if( vg_get_axis("grabl")>0.0f
)
1989 player
.rb
= player
.rb_gate_frame
;
1992 m3x3_identity( player
.vr
);
1994 player
.mdl
.shoes
[0] = 1;
1995 player
.mdl
.shoes
[1] = 1;
1997 world_routes_notify_reset();
2000 if( vg_get_button_down( "switchmode" ) )
2002 player
.on_board
^= 0x1;
2005 if( player
.is_dead
)
2007 character_ragdoll_iter( &player
.mdl
);
2008 character_debug_ragdoll( &player
.mdl
);
2011 player_animate_death_cam();
2015 if( player
.on_board
)
2021 player_animate_camera();
2032 player_camera_update();
2036 static void draw_player(void)
2040 m4x3_copy( player
.rb
.to_world
, player
.mdl
.mroot
);
2042 if( player
.is_dead
)
2043 character_mimic_ragdoll( &player
.mdl
);
2045 character_eval( &player
.mdl
);
2047 float opacity
= 1.0f
-player
.air_blend
;
2048 if( player
.is_dead
)
2051 character_draw( &player
.mdl
, opacity
, player
.camera
);
2054 shader_viewchar_use();
2055 vg_tex2d_bind( &tex_characters
, 0 );
2056 shader_viewchar_uTexMain( 0 );
2057 shader_viewchar_uCamera( player
.camera
[3] );
2058 shader_viewchar_uPv( vg_pv
);
2059 shader_link_standard_ub( _shader_viewchar
.id
, 2 );
2060 glUniformMatrix4x3fv( _uniform_viewchar_uTransforms
,
2061 player
.mdl
.sk
.bone_count
,
2063 (float *)player
.mdl
.sk
.final_mtx
);
2065 mesh_bind( &player
.mdl
.mesh
);
2066 mesh_draw( &player
.mdl
.mesh
);
2069 #endif /* PLAYER_H */