15 k_board_radius
= 0.3f
,
16 k_board_length
= 0.55f
,
17 k_board_allowance
= 0.04f
,
18 k_friction_lat
= 8.68f
,
19 k_friction_resistance
= 0.02f
,
20 k_max_push_speed
= 16.0f
,
22 k_push_cycle_rate
= 8.0f
,
23 k_steer_ground
= 2.5f
,
25 k_steer_air_lerp
= 0.3f
,
28 static int freecam
= 0;
29 static int walk_grid_iterations
= 1;
36 v3f a
, v_last
, m
, bob
, vl
;
39 float vswitch
, slip
, slip_last
,
42 float iY
; /* Yaw inertia */
43 int in_air
, is_dead
, on_board
;
50 v3f land_target_log
[22];
51 u32 land_target_colours
[22];
57 v3f handl_target
, handr_target
,
63 v3f camera_pos
, smooth_localcam
;
65 m4x3f camera
, camera_inverse
;
71 .rb
= { .type
= k_rb_shape_capsule
}
80 * Free camera movement
83 static void player_mouseview(void)
85 if( gui_want_mouse() )
88 static v2f mouse_last
,
89 view_vel
= { 0.0f
, 0.0f
};
91 if( vg_get_button_down( "primary" ) )
92 v2_copy( vg_mouse
, mouse_last
);
94 else if( vg_get_button( "primary" ) )
97 v2_sub( vg_mouse
, mouse_last
, delta
);
98 v2_copy( vg_mouse
, mouse_last
);
100 v2_muladds( view_vel
, delta
, 0.005f
, view_vel
);
103 v2_muladds( view_vel
,
104 (v2f
){ vg_get_axis("h1"), vg_get_axis("v1") },
106 v2_muls( view_vel
, 0.7f
, view_vel
);
107 v2_add( view_vel
, player
.angles
, player
.angles
);
108 player
.angles
[1] = vg_clampf( player
.angles
[1], -VG_PIf
*0.5f
, VG_PIf
*0.5f
);
111 static void player_freecam(void)
115 float movespeed
= 25.0f
;
116 v3f lookdir
= { 0.0f
, 0.0f
, -1.0f
},
117 sidedir
= { 1.0f
, 0.0f
, 0.0f
};
119 m3x3_mulv( player
.camera
, lookdir
, lookdir
);
120 m3x3_mulv( player
.camera
, sidedir
, sidedir
);
122 static v3f move_vel
= { 0.0f
, 0.0f
, 0.0f
};
123 if( vg_get_button( "forward" ) )
124 v3_muladds( move_vel
, lookdir
, ktimestep
* movespeed
, move_vel
);
125 if( vg_get_button( "back" ) )
126 v3_muladds( move_vel
, lookdir
, ktimestep
*-movespeed
, move_vel
);
127 if( vg_get_button( "left" ) )
128 v3_muladds( move_vel
, sidedir
, ktimestep
*-movespeed
, move_vel
);
129 if( vg_get_button( "right" ) )
130 v3_muladds( move_vel
, sidedir
, ktimestep
* movespeed
, move_vel
);
132 v3_muls( move_vel
, 0.7f
, move_vel
);
133 v3_add( move_vel
, player
.camera_pos
, player
.camera_pos
);
137 * Player Physics Implementation
140 static void apply_gravity( v3f vel
, float const timestep
)
142 v3f gravity
= { 0.0f
, -9.6f
, 0.0f
};
143 v3_muladds( vel
, gravity
, timestep
, vel
);
147 * TODO: The angle bias should become greater when launching from a steeper
148 * angle and skewed towords more 'downwards' angles when launching from
149 * shallower trajectories
151 * it should also be tweaked by the controller left stick being pushed
154 static void player_start_air(void)
161 float pstep
= ktimestep
*10.0f
;
163 float best_velocity_mod
= 0.0f
,
164 best_velocity_delta
= -9999.9f
;
166 float k_bias
= 0.97f
;
169 v3_cross( player
.rb
.up
, player
.rb
.v
, axis
);
170 v3_normalize( axis
);
171 player
.land_log_count
= 0;
173 m3x3_identity( player
.vr
);
175 for( int m
=-3;m
<=12; m
++ )
177 float vmod
= ((float)m
/ 15.0f
)*0.09f
;
180 v3_copy( player
.rb
.co
, pco
);
181 v3_muls( player
.rb
.v
, k_bias
, pv
);
184 * Try different 'rotations' of the velocity to find the best possible
185 * landing normal. This conserves magnitude at the expense of slightly
186 * unrealistic results
192 q_axis_angle( vr_q
, axis
, vmod
);
195 m3x3_mulv( vr
, pv
, pv
);
196 v3_muladds( pco
, pv
, pstep
, pco
);
198 for( int i
=0; i
<50; i
++ )
200 v3_copy( pco
, pco1
);
201 apply_gravity( pv
, pstep
);
203 m3x3_mulv( vr
, pv
, pv
);
204 v3_muladds( pco
, pv
, pstep
, pco
);
209 v3_sub( pco
, pco1
, vdir
);
210 contact
.dist
= v3_length( vdir
);
211 v3_divs( vdir
, contact
.dist
, vdir
);
213 if( ray_world( pco1
, vdir
, &contact
))
215 float land_delta
= v3_dot( pv
, contact
.normal
);
216 u32 scolour
= (u8
)(vg_minf(-land_delta
* 2.0f
, 255.0f
));
218 /* Bias prediction towords ramps */
219 if( ray_hit_is_ramp( &contact
) )
222 scolour
|= 0x0000a000;
225 if( (land_delta
< 0.0f
) && (land_delta
> best_velocity_delta
) )
227 best_velocity_delta
= land_delta
;
228 best_velocity_mod
= vmod
;
230 v3_copy( contact
.pos
, player
.land_target
);
232 m3x3_copy( vr
, player
.vr_pstep
);
233 q_axis_angle( vr_q
, axis
, vmod
*0.1f
);
234 q_m3x3( vr_q
, player
.vr
);
237 v3_copy( contact
.pos
,
238 player
.land_target_log
[player
.land_log_count
] );
239 player
.land_target_colours
[player
.land_log_count
] =
240 0xff000000 | scolour
;
242 player
.land_log_count
++;
250 static void draw_cross(v3f pos
,u32 colour
, float scale
)
253 v3_add( (v3f
){ scale
,0.0f
,0.0f
}, pos
, p0
);
254 v3_add( (v3f
){-scale
,0.0f
,0.0f
}, pos
, p1
);
255 vg_line( p0
, p1
, colour
);
256 v3_add( (v3f
){0.0f
, scale
,0.0f
}, pos
, p0
);
257 v3_add( (v3f
){0.0f
,-scale
,0.0f
}, pos
, p1
);
258 vg_line( p0
, p1
, colour
);
259 v3_add( (v3f
){0.0f
,0.0f
, scale
}, pos
, p0
);
260 v3_add( (v3f
){0.0f
,0.0f
,-scale
}, pos
, p1
);
261 vg_line( p0
, p1
, colour
);
264 static void player_physics_control(void)
267 * Computing localized friction forces for controlling the character
268 * Friction across X is significantly more than Z
272 m3x3_mulv( player
.rb
.to_local
, player
.rb
.v
, vel
);
275 if( fabsf(vel
[2]) > 0.01f
)
276 slip
= fabsf(-vel
[0] / vel
[2]) * vg_signf(vel
[0]);
278 if( fabsf( slip
) > 1.2f
)
279 slip
= vg_signf( slip
) * 1.2f
;
281 player
.reverse
= -vg_signf(vel
[2]);
283 float substep
= ktimestep
* 0.2f
;
284 float fwd_resistance
= (vg_get_button( "break" )? 5.0f
: 0.02f
) * -substep
;
286 for( int i
=0; i
<5; i
++ )
288 vel
[2] = stable_force( vel
[2], vg_signf( vel
[2] ) * fwd_resistance
);
289 vel
[0] = stable_force( vel
[0], vg_signf( vel
[0] ) * -8.78f
*substep
);
292 static double start_push
= 0.0;
293 if( vg_get_button_down( "push" ) )
294 start_push
= vg_time
;
296 if( !vg_get_button("break") && vg_get_button( "push" ) )
298 float cycle_time
= (vg_time
-start_push
)*k_push_cycle_rate
,
299 amt
= k_push_accel
* (sinf(cycle_time
)*0.5f
+0.5f
)*ktimestep
,
300 current
= v3_length( vel
),
301 new_vel
= vg_minf( current
+ amt
, k_max_push_speed
);
302 new_vel
-= vg_minf(current
, k_max_push_speed
);
303 vel
[2] -= new_vel
* player
.reverse
;
306 m3x3_mulv( player
.rb
.to_world
, vel
, player
.rb
.v
);
308 float steer
= vg_get_axis( "horizontal" );
309 player
.iY
-= vg_signf(steer
)*powf(steer
,2.0f
) * k_steer_ground
* ktimestep
;
311 v2_lerp( player
.board_xy
, (v2f
){ slip
*0.25f
, 0.0f
},
312 ktimestep
*5.0f
, player
.board_xy
);
315 static void player_physics_control_air(void)
317 m3x3_mulv( player
.vr
, player
.rb
.v
, player
.rb
.v
);
318 draw_cross( player
.land_target
, 0xff0000ff, 0.25f
);
325 float pstep
= ktimestep
*10.0f
;
328 v3_copy( player
.rb
.co
, pco
);
329 v3_copy( player
.rb
.v
, pv
);
331 float time_to_impact
= 0.0f
;
332 float limiter
= 1.0f
;
334 for( int i
=0; i
<50; i
++ )
336 v3_copy( pco
, pco1
);
337 m3x3_mulv( player
.vr_pstep
, pv
, pv
);
338 apply_gravity( pv
, pstep
);
339 v3_muladds( pco
, pv
, pstep
, pco
);
341 //vg_line( pco, pco1, i&0x1?0xff000000:0xffffffff );
346 v3_sub( pco
, pco1
, vdir
);
347 contact
.dist
= v3_length( vdir
);
348 v3_divs( vdir
, contact
.dist
, vdir
);
350 float orig_dist
= contact
.dist
;
351 if( ray_world( pco1
, vdir
, &contact
))
353 float angle
= v3_dot( player
.rb
.up
, contact
.normal
);
355 v3_cross( player
.rb
.up
, contact
.normal
, axis
);
357 time_to_impact
+= (contact
.dist
/orig_dist
)*pstep
;
358 limiter
= vg_minf( 5.0f
, time_to_impact
)/5.0f
;
359 limiter
= 1.0f
-limiter
;
361 limiter
= 1.0f
-limiter
;
366 q_axis_angle( correction
, axis
, acosf(angle
)*0.05f
*(1.0f
-limiter
) );
367 q_mul( correction
, player
.rb
.q
, player
.rb
.q
);
370 draw_cross( contact
.pos
, 0xffff0000, 0.25f
);
373 time_to_impact
+= pstep
;
376 player
.iY
-= vg_get_axis( "horizontal" ) * k_steer_air
* ktimestep
;
378 float iX
= vg_get_axis( "vertical" ) *
379 player
.reverse
* k_steer_air
* limiter
* ktimestep
;
381 static float siX
= 0.0f
;
382 siX
= vg_lerpf( siX
, iX
, k_steer_air_lerp
);
385 q_axis_angle( rotate
, player
.rb
.right
, siX
);
386 q_mul( rotate
, player
.rb
.q
, player
.rb
.q
);
389 v2f target
= {0.0f
,0.0f
};
390 v2_muladds( target
, (v2f
){ vg_get_axis("h1"), vg_get_axis("v1") },
391 player
.grab
, target
);
392 v2_lerp( player
.board_xy
, target
, ktimestep
*3.0f
, player
.board_xy
);
395 static void player_physics(void)
398 * Player physics uses a customized routine seperate from the main
399 * rigidbody implementation. It requires some non-standard impulse
400 * responses being applied for example limiting the effect on certain axises
401 * ( especially for angular velocity )
403 * The capsule collider is also at a different angle to the players roation.
407 v3_copy( player
.rb
.to_world
[0], mboard
[0] );
408 v3_copy( player
.rb
.to_world
[2], mboard
[1] );
409 v3_copy( player
.rb
.to_world
[1], mboard
[2] );
410 m4x3_mulv( player
.rb
.to_world
, (v3f
){ 0.0f
, 0.3f
, 0.0f
}, mboard
[3] );
412 debug_capsule( mboard
, k_board_length
*2.0f
, k_board_radius
, 0xff0000ff );
414 boxf region
= {{ -k_board_radius
, -k_board_length
, -k_board_radius
},
415 { k_board_radius
, k_board_length
, k_board_radius
}};
416 m4x3_transform_aabb( mboard
, region
);
420 int len
= bh_select( &world
.geo
.bhtris
, region
, geo
, 256 );
423 m4x3_mulv(mboard
, (v3f
){0.0f
,-k_board_length
+k_board_radius
,0.0f
}, poles
[0]);
424 m4x3_mulv(mboard
, (v3f
){0.0f
, k_board_length
-k_board_radius
,0.0f
}, poles
[1]);
426 struct contact manifold
[12];
427 int manifold_count
= 0;
429 v3f surface_avg
= {0.0f
, 0.0f
, 0.0f
};
431 for( int i
=0; i
<len
; i
++ )
433 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
435 for( int j
=0; j
<3; j
++ )
436 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
438 vg_line(tri
[0],tri
[1],0xff00ff00 );
439 vg_line(tri
[1],tri
[2],0xff00ff00 );
440 vg_line(tri
[2],tri
[0],0xff00ff00 );
445 for( int j
=0; j
<2; j
++ )
447 if( sphere_vs_triangle( poles
[j
], k_board_radius
, tri
,co
,norm
,&p
) )
449 if(manifold_count
>= vg_list_size(manifold
))
451 vg_error("Manifold overflow!\n");
456 v3_muladds( poles
[j
], norm
, p
, p1
);
457 vg_line( poles
[j
], p1
, 0xffffffff );
459 struct contact
*ct
= &manifold
[manifold_count
++];
460 v3_sub( co
, player
.rb
.co
, ct
->delta
);
461 v3_copy( co
, ct
->co
);
462 v3_copy( norm
, ct
->n
);
464 ct
->bias
= -0.2f
*k_rb_rate
*vg_minf(0.0f
,-p
+k_board_allowance
);
465 ct
->norm_impulse
= 0.0f
;
467 v3_add( norm
, surface_avg
, surface_avg
);
472 if( !manifold_count
)
478 v3_normalize( surface_avg
);
480 if( v3_dot( player
.rb
.v
, surface_avg
) > 0.5f
)
488 for( int j
=0; j
<5; j
++ )
490 for( int i
=0; i
<manifold_count
; i
++ )
492 struct contact
*ct
= &manifold
[i
];
495 v3_cross( player
.rb
.w
, ct
->delta
, dv
);
496 v3_add( player
.rb
.v
, dv
, dv
);
498 float vn
= -v3_dot( dv
, ct
->n
);
501 float temp
= ct
->norm_impulse
;
502 ct
->norm_impulse
= vg_maxf( temp
+ vn
, 0.0f
);
503 vn
= ct
->norm_impulse
- temp
;
507 v3_muls( ct
->n
, vn
, impulse
);
509 if( fabsf(v3_dot( impulse
, player
.rb
.forward
)) > 10.0f
||
510 fabsf(v3_dot( impulse
, player
.rb
.up
)) > 50.0f
)
513 character_ragdoll_copypose( &player
.mdl
, player
.rb
.v
);
517 v3_add( impulse
, player
.rb
.v
, player
.rb
.v
);
518 v3_cross( ct
->delta
, impulse
, impulse
);
521 * W Impulses are limited to the Y and X axises, we don't really want
522 * roll angular velocities being included.
524 * Can also tweak the resistance of each axis here by scaling the wx,wy
528 float wy
= v3_dot( player
.rb
.up
, impulse
),
529 wx
= v3_dot( player
.rb
.right
, impulse
)*1.5f
;
531 v3_muladds( player
.rb
.w
, player
.rb
.up
, wy
, player
.rb
.w
);
532 v3_muladds( player
.rb
.w
, player
.rb
.right
, wx
, player
.rb
.w
);
539 float angle
= v3_dot( player
.rb
.up
, surface_avg
);
540 v3_cross( player
.rb
.up
, surface_avg
, axis
);
542 float cz
= v3_dot( player
.rb
.forward
, axis
);
543 v3_muls( player
.rb
.forward
, cz
, axis
);
548 q_axis_angle( correction
, axis
, acosf(angle
)*0.3f
);
549 q_mul( correction
, player
.rb
.q
, player
.rb
.q
);
552 v3_muladds( player
.rb
.v
, player
.rb
.up
,
553 -k_downforce
*ktimestep
, player
.rb
.v
);
554 player_physics_control();
558 player_physics_control_air();
562 static void player_do_motion(void)
564 float horizontal
= vg_get_axis("horizontal"),
565 vertical
= vg_get_axis("vertical");
569 /* Integrate velocity */
571 v3_copy( player
.rb
.co
, prevco
);
573 apply_gravity( player
.rb
.v
, ktimestep
);
574 v3_muladds( player
.rb
.co
, player
.rb
.v
, ktimestep
, player
.rb
.co
);
576 /* Real angular velocity integration */
577 v3_lerp( player
.rb
.w
, (v3f
){0.0f
,0.0f
,0.0f
}, 0.125f
, player
.rb
.w
);
578 if( v3_length2( player
.rb
.w
) > 0.0f
)
582 v3_copy( player
.rb
.w
, axis
);
584 float mag
= v3_length( axis
);
585 v3_divs( axis
, mag
, axis
);
586 q_axis_angle( rotation
, axis
, mag
*k_rb_delta
);
587 q_mul( rotation
, player
.rb
.q
, player
.rb
.q
);
590 /* Faux angular velocity */
593 static float siY
= 0.0f
;
594 float lerpq
= player
.in_air
? 0.04f
: 0.3f
;
595 siY
= vg_lerpf( siY
, player
.iY
, lerpq
);
597 q_axis_angle( rotate
, player
.rb
.up
, siY
);
598 q_mul( rotate
, player
.rb
.q
, player
.rb
.q
);
602 * Gate intersection, by tracing a line over the gate planes
604 for( int i
=0; i
<world
.gate_count
; i
++ )
606 teleport_gate
*gate
= &world
.gates
[i
];
608 if( gate_intersect( gate
, player
.rb
.co
, prevco
) )
610 m4x3_mulv( gate
->transport
, player
.rb
.co
, player
.rb
.co
);
611 m3x3_mulv( gate
->transport
, player
.rb
.v
, player
.rb
.v
);
612 m3x3_mulv( gate
->transport
, player
.vl
, player
.vl
);
613 m3x3_mulv( gate
->transport
, player
.v_last
, player
.v_last
);
614 m3x3_mulv( gate
->transport
, player
.m
, player
.m
);
615 m3x3_mulv( gate
->transport
, player
.bob
, player
.bob
);
617 v4f transport_rotation
;
618 m3x3_q( gate
->transport
, transport_rotation
);
619 q_mul( transport_rotation
, player
.rb
.q
, player
.rb
.q
);
625 rb_update_transform( &player
.rb
);
629 * Walkgrid implementation,
630 * loosely based of cmuratoris youtube video 'Killing the Walkmonster'
633 #define WALKGRID_SIZE 16
640 k_sample_type_air
, /* Nothing was hit. */
641 k_sample_type_invalid
, /* The point is invalid, but there is a sample
642 underneath that can be used */
643 k_sample_type_valid
, /* This point is good */
652 k_traverse_none
= 0x00,
658 samples
[WALKGRID_SIZE
][WALKGRID_SIZE
];
662 float move
; /* Current amount of movement we have left to apply */
663 v2f dir
; /* The movement delta */
664 v2i cell_id
;/* Current cell */
665 v2f pos
; /* Local position (in cell) */
669 static int player_walkgrid_tri_walkable( u32 tri
[3] )
671 return tri
[0] > world
.sm_geo_std_oob
.vertex_count
;
675 * Get a sample at this pole location, will return 1 if the sample is valid,
676 * and pos will be updated to be the intersection location.
678 static void player_walkgrid_samplepole( struct grid_sample
*s
)
680 boxf region
= {{ s
->pos
[0] -0.01f
, s
->pos
[1] - 4.0f
, s
->pos
[2] -0.01f
},
681 { s
->pos
[0] +0.01f
, s
->pos
[1] + 4.0f
, s
->pos
[2] +0.01f
}};
685 int len
= bh_select( &world
.geo
.bhtris
, region
, geo
, 256 );
687 const float k_minworld_y
= -2000.0f
;
689 float walk_height
= k_minworld_y
,
690 block_height
= k_minworld_y
;
692 s
->type
= k_sample_type_air
;
694 for( int i
=0; i
<len
; i
++ )
696 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
698 for( int j
=0; j
<3; j
++ )
699 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
701 v3f vdown
= {0.0f
,-1.0f
,0.0f
};
703 v3_copy( s
->pos
, sample_from
);
704 sample_from
[1] = region
[1][1];
707 if( ray_tri( tri
, sample_from
, vdown
, &dist
))
710 v3_muladds( sample_from
, vdown
, dist
, p0
);
712 if( player_walkgrid_tri_walkable(ptri
) )
714 if( p0
[1] > walk_height
)
721 if( p0
[1] > block_height
)
722 block_height
= p0
[1];
727 s
->pos
[1] = walk_height
;
729 if( walk_height
> k_minworld_y
)
730 if( block_height
> walk_height
)
731 s
->type
= k_sample_type_invalid
;
733 s
->type
= k_sample_type_valid
;
735 s
->type
= k_sample_type_air
;
738 float const k_gridscale
= 0.5f
;
746 static void player_walkgrid_clip_blocker( struct grid_sample
*sa
,
747 struct grid_sample
*sb
,
748 struct grid_sample
*st
,
752 int valid_a
= sa
->type
== k_sample_type_valid
,
753 valid_b
= sb
->type
== k_sample_type_valid
;
754 struct grid_sample
*target
= valid_a
? sa
: sb
,
755 *other
= valid_a
? sb
: sa
;
756 v3_copy( target
->pos
, pos
);
757 v3_sub( other
->pos
, target
->pos
, clipdir
);
760 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, -k_gridscale
*2.1f
, cell_region
[0]);
761 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, k_gridscale
*2.1f
, cell_region
[1]);
765 int len
= bh_select( &world
.geo
.bhtris
, cell_region
, geo
, 256 );
767 float start_time
= v3_length( clipdir
),
768 min_time
= start_time
;
769 v3_normalize( clipdir
);
770 v3_muls( clipdir
, 0.0001f
, st
->clip
[dir
] );
772 for( int i
=0; i
<len
; i
++ )
774 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
775 for( int j
=0; j
<3; j
++ )
776 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
778 if( player_walkgrid_tri_walkable(ptri
) )
782 if(ray_tri( tri
, pos
, clipdir
, &dist
))
784 if( dist
> 0.0f
&& dist
< min_time
)
787 sb
->type
= k_sample_type_air
;
792 if( !(min_time
< start_time
) )
793 min_time
= 0.5f
* k_gridscale
;
795 min_time
= vg_clampf( min_time
/k_gridscale
, 0.01f
, 0.99f
);
797 v3_muls( clipdir
, min_time
, st
->clip
[dir
] );
800 v3_muladds( target
->pos
, st
->clip
[dir
], k_gridscale
, p0
);
803 static void player_walkgrid_clip_edge( struct grid_sample
*sa
,
804 struct grid_sample
*sb
,
805 struct grid_sample
*st
, /* data store */
808 v3f clipdir
= { 0.0f
, 0.0f
, 0.0f
}, pos
;
809 int valid_a
= sa
->type
== k_sample_type_valid
,
810 valid_b
= sb
->type
== k_sample_type_valid
;
812 struct grid_sample
*target
= valid_a
? sa
: sb
,
813 *other
= valid_a
? sb
: sa
;
815 v3_sub( other
->pos
, target
->pos
, clipdir
);
818 v3_copy( target
->pos
, pos
);
821 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, -k_gridscale
*1.1f
, cell_region
[0]);
822 v3_muladds( pos
, (v3f
){1.0f
,1.0f
,1.0f
}, k_gridscale
*1.1f
, cell_region
[1]);
825 int len
= bh_select( &world
.geo
.bhtris
, cell_region
, geo
, 256 );
827 float max_dist
= 0.0f
;
830 v3_cross( clipdir
,(v3f
){0.0f
,1.0f
,0.0f
},perp
);
831 v3_muls( clipdir
, 0.001f
, st
->clip
[dir
] );
833 for( int i
=0; i
<len
; i
++ )
835 u32
*ptri
= &world
.geo
.indices
[ geo
[i
]*3 ];
836 for( int j
=0; j
<3; j
++ )
837 v3_copy( world
.geo
.verts
[ptri
[j
]].co
, tri
[j
] );
839 if( !player_walkgrid_tri_walkable(ptri
) )
842 for( int k
=0; k
<3; k
++ )
848 v3_sub( tri
[ia
], pos
, v0
);
849 v3_sub( tri
[ib
], pos
, v1
);
851 if( (clipdir
[2]*v0
[0] - clipdir
[0]*v0
[2]) *
852 (clipdir
[2]*v1
[0] - clipdir
[0]*v1
[2]) < 0.0f
)
854 float da
= v3_dot(v0
,perp
),
855 db
= v3_dot(v1
,perp
),
860 v3_muls( v1
, qa
, p0
);
861 v3_muladds( p0
, v0
, 1.0f
-qa
, p0
);
863 float h
= v3_dot(p0
,clipdir
)/v3_dot(clipdir
,clipdir
);
865 if( h
>= max_dist
&& h
<= 1.0f
)
868 float l
= 1.0f
/v3_length(clipdir
);
869 v3_muls( p0
, l
, st
->clip
[dir
] );
876 static const struct conf
883 * o: the 'other' point to do a A/B test with
884 * if its -1, all AB is done.
894 k_walkgrid_configs
[16] = {
896 {{{ 3,3, 3,0, 1,0, -1,-1 }}, 1},
897 {{{ 2,2, 1,3, 0,1, -1,-1 }}, 1},
898 {{{ 2,3, 1,0, 0,0, 3,-1 }}, 1},
900 {{{ 1,1, 0,1, 1,0, -1,-1 }}, 1},
901 {{{ 3,3, 3,0, 1,0, -1,-1 },
902 { 1,1, 0,1, 1,0, -1,-1 }}, 2},
903 {{{ 1,2, 0,3, 1,1, 2,-1 }}, 1},
904 {{{ 1,3, 0,0, 1,0, 2, 2 }}, 1},
906 {{{ 0,0, 0,0, 0,1, -1,-1 }}, 1},
907 {{{ 3,0, 3,0, 1,1, 0,-1 }}, 1},
908 {{{ 2,2, 1,3, 0,1, -1,-1 },
909 { 0,0, 0,0, 0,1, -1,-1 }}, 2},
910 {{{ 2,0, 1,0, 0,1, 3, 3 }}, 1},
912 {{{ 0,1, 0,1, 0,0, 1,-1 }}, 1},
913 {{{ 3,1, 3,1, 1,0, 0, 0 }}, 1},
914 {{{ 0,2, 0,3, 0,1, 1, 1 }}, 1},
919 * Get a buffer of edges from cell location
921 static const struct conf
*player_walkgrid_conf( struct walkgrid
*wg
,
923 struct grid_sample
*corners
[4] )
925 corners
[0] = &wg
->samples
[cell
[1] ][cell
[0] ];
926 corners
[1] = &wg
->samples
[cell
[1]+1][cell
[0] ];
927 corners
[2] = &wg
->samples
[cell
[1]+1][cell
[0]+1];
928 corners
[3] = &wg
->samples
[cell
[1] ][cell
[0]+1];
930 u32 vd0
= corners
[0]->type
== k_sample_type_valid
,
931 vd1
= corners
[1]->type
== k_sample_type_valid
,
932 vd2
= corners
[2]->type
== k_sample_type_valid
,
933 vd3
= corners
[3]->type
== k_sample_type_valid
,
934 config
= (vd0
<<3) | (vd1
<<2) | (vd2
<<1) | vd3
;
936 return &k_walkgrid_configs
[ config
];
939 static void player_walkgrid_floor(v3f pos
)
941 v3_muls( pos
, 1.0f
/k_gridscale
, pos
);
942 v3_floor( pos
, pos
);
943 v3_muls( pos
, k_gridscale
, pos
);
947 * Computes the barycentric coordinate of location on a triangle (vertical),
948 * then sets the Y position to the interpolation of the three points
950 static void player_walkgrid_stand_tri( v3f a
, v3f b
, v3f c
, v3f pos
)
955 v3_sub( pos
, a
, v2
);
957 float d
= v0
[0]*v1
[2] - v1
[0]*v0
[2],
958 v
= (v2
[0]*v1
[2] - v1
[0]*v2
[2]) / d
,
959 w
= (v0
[0]*v2
[2] - v2
[0]*v0
[2]) / d
,
962 vg_line( pos
, a
, 0xffff0000 );
963 vg_line( pos
, b
, 0xff00ff00 );
964 vg_line( pos
, c
, 0xff0000ff );
965 pos
[1] = u
*a
[1] + v
*b
[1] + w
*c
[1];
969 * Get the minimum time value of pos+dir until a cell edge
971 * t[0] -> t[3] are the individual time values
972 * t[5] & t[6] are the maximum axis values
973 * t[6] is the minimum value
976 static void player_walkgrid_min_cell( float t
[7], v2f pos
, v2f dir
)
978 v2f frac
= { 1.0f
/dir
[0], 1.0f
/dir
[1] };
985 if( fabsf(dir
[0]) > 0.0001f
)
987 t
[0] = (0.0f
-pos
[0]) * frac
[0];
988 t
[1] = (1.0f
-pos
[0]) * frac
[0];
990 if( fabsf(dir
[1]) > 0.0001f
)
992 t
[2] = (0.0f
-pos
[1]) * frac
[1];
993 t
[3] = (1.0f
-pos
[1]) * frac
[1];
996 t
[4] = vg_maxf(t
[0],t
[1]);
997 t
[5] = vg_maxf(t
[2],t
[3]);
998 t
[6] = vg_minf(t
[4],t
[5]);
1001 static void player_walkgrid_iter(struct walkgrid
*wg
, int iter
)
1005 * For each walkgrid iteration we are stepping through cells and determining
1006 * the intersections with the grid, and any edges that are present
1009 u32 icolours
[] = { 0xffff00ff, 0xff00ffff, 0xffffff00 };
1011 v3f pa
, pb
, pc
, pd
, pl0
, pl1
;
1012 pa
[0] = wg
->region
[0][0] + (float)wg
->cell_id
[0] *k_gridscale
;
1013 pa
[1] = (wg
->region
[0][1] + wg
->region
[1][1]) * 0.5f
+ k_gridscale
;
1014 pa
[2] = wg
->region
[0][2] + (float)wg
->cell_id
[1] *k_gridscale
;
1017 pb
[2] = pa
[2] + k_gridscale
;
1018 pc
[0] = pa
[0] + k_gridscale
;
1020 pc
[2] = pa
[2] + k_gridscale
;
1021 pd
[0] = pa
[0] + k_gridscale
;
1025 /* if you want to draw the current cell */
1026 vg_line( pa
, pb
, 0xff00ffff );
1027 vg_line( pb
, pc
, 0xff00ffff );
1028 vg_line( pc
, pd
, 0xff00ffff );
1029 vg_line( pd
, pa
, 0xff00ffff );
1031 pl0
[0] = pa
[0] + wg
->pos
[0]*k_gridscale
;
1033 pl0
[2] = pa
[2] + wg
->pos
[1]*k_gridscale
;
1036 * If there are edges present, we need to create a 'substep' event, where
1037 * we find the intersection point, find the fully resolved position,
1038 * then the new pos dir is the intersection->resolution
1040 * the resolution is applied in non-discretized space in order to create a
1041 * suitable vector for finding outflow, we want it to leave the cell so it
1042 * can be used by the quad
1046 v2_copy( wg
->pos
, pos
);
1047 v2_muls( wg
->dir
, wg
->move
, dir
);
1049 struct grid_sample
*corners
[4];
1050 v2f corners2d
[4] = {{0.0f
,0.0f
},{0.0f
,1.0f
},{1.0f
,1.0f
},{1.0f
,0.0f
}};
1051 const struct conf
*conf
= player_walkgrid_conf( wg
, wg
->cell_id
, corners
);
1054 player_walkgrid_min_cell( t
, pos
, dir
);
1056 for( int i
=0; i
<conf
->edge_count
; i
++ )
1058 const struct confedge
*edge
= &conf
->edges
[i
];
1060 v2f e0
, e1
, n
, r
, target
, res
, tangent
;
1061 e0
[0] = corners2d
[edge
->i0
][0] + corners
[edge
->d0
]->clip
[edge
->a0
][0];
1062 e0
[1] = corners2d
[edge
->i0
][1] + corners
[edge
->d0
]->clip
[edge
->a0
][2];
1063 e1
[0] = corners2d
[edge
->i1
][0] + corners
[edge
->d1
]->clip
[edge
->a1
][0];
1064 e1
[1] = corners2d
[edge
->i1
][1] + corners
[edge
->d1
]->clip
[edge
->a1
][2];
1066 v3f pe0
= { pa
[0] + e0
[0]*k_gridscale
,
1068 pa
[2] + e0
[1]*k_gridscale
};
1069 v3f pe1
= { pa
[0] + e1
[0]*k_gridscale
,
1071 pa
[2] + e1
[1]*k_gridscale
};
1073 v2_sub( e1
, e0
, tangent
);
1079 * If we find ourselfs already penetrating the edge, move back out a
1082 v2_sub( e0
, pos
, r
);
1083 float p1
= v2_dot(r
,n
);
1087 v2_muladds( pos
, n
, p1
+0.0001f
, pos
);
1088 v2_copy( pos
, wg
->pos
);
1089 v3f p_new
= { pa
[0] + pos
[0]*k_gridscale
,
1091 pa
[2] + pos
[1]*k_gridscale
};
1092 v3_copy( p_new
, pl0
);
1095 v2_add( pos
, dir
, target
);
1098 v2_sub( e0
, pos
, v1
);
1099 v2_sub( target
, pos
, v2
);
1103 v2_sub( e0
, target
, r
);
1104 float p
= v2_dot(r
,n
),
1105 t1
= v2_dot(v1
,v3
)/v2_dot(v2
,v3
);
1107 if( t1
< t
[6] && t1
> 0.0f
&& -p
< 0.001f
)
1109 v2_muladds( target
, n
, p
+0.0001f
, res
);
1112 v2_muladds( pos
, dir
, t1
, intersect
);
1113 v2_copy( intersect
, pos
);
1114 v2_sub( res
, intersect
, dir
);
1116 v3f p_res
= { pa
[0] + res
[0]*k_gridscale
,
1118 pa
[2] + res
[1]*k_gridscale
};
1119 v3f p_int
= { pa
[0] + intersect
[0]*k_gridscale
,
1121 pa
[2] + intersect
[1]*k_gridscale
};
1123 vg_line( pl0
, p_int
, icolours
[iter
%3] );
1124 v3_copy( p_int
, pl0
);
1125 v2_copy( pos
, wg
->pos
);
1127 player_walkgrid_min_cell( t
, pos
, dir
);
1132 * Compute intersection with grid cell moving outwards
1134 t
[6] = vg_minf( t
[6], 1.0f
);
1136 pl1
[0] = pl0
[0] + dir
[0]*k_gridscale
*t
[6];
1138 pl1
[2] = pl0
[2] + dir
[1]*k_gridscale
*t
[6];
1139 vg_line( pl0
, pl1
, icolours
[iter
%3] );
1144 * To figure out what t value created the clip so we know which edge
1150 wg
->pos
[1] = pos
[1] + dir
[1]*t
[6];
1152 if( t
[0] > t
[1] ) /* left edge */
1154 wg
->pos
[0] = 0.9999f
;
1157 if( wg
->cell_id
[0] == 0 )
1160 else /* Right edge */
1162 wg
->pos
[0] = 0.0001f
;
1165 if( wg
->cell_id
[0] == WALKGRID_SIZE
-2 )
1171 wg
->pos
[0] = pos
[0] + dir
[0]*t
[6];
1173 if( t
[2] > t
[3] ) /* bottom edge */
1175 wg
->pos
[1] = 0.9999f
;
1178 if( wg
->cell_id
[1] == 0 )
1183 wg
->pos
[1] = 0.0001f
;
1186 if( wg
->cell_id
[1] == WALKGRID_SIZE
-2 )
1195 v2_muladds( wg
->pos
, dir
, wg
->move
, wg
->pos
);
1200 static void player_walkgrid_stand_cell(struct walkgrid
*wg
)
1203 * NOTE: as opposed to the other function which is done in discretized space
1204 * this use a combination of both.
1208 world
[0] = wg
->region
[0][0]+((float)wg
->cell_id
[0]+wg
->pos
[0])*k_gridscale
;
1209 world
[1] = player
.rb
.co
[1];
1210 world
[2] = wg
->region
[0][2]+((float)wg
->cell_id
[1]+wg
->pos
[1])*k_gridscale
;
1212 struct grid_sample
*corners
[4];
1213 const struct conf
*conf
= player_walkgrid_conf( wg
, wg
->cell_id
, corners
);
1215 if( conf
!= k_walkgrid_configs
)
1217 if( conf
->edge_count
== 0 )
1221 /* Split the basic quad along the shortest diagonal */
1222 if( fabsf(corners
[2]->pos
[1] - corners
[0]->pos
[1]) <
1223 fabsf(corners
[3]->pos
[1] - corners
[1]->pos
[1]) )
1225 vg_line( corners
[2]->pos
, corners
[0]->pos
, 0xffaaaaaa );
1227 if( wg
->pos
[0] > wg
->pos
[1] )
1228 player_walkgrid_stand_tri( corners
[0]->pos
,
1230 corners
[2]->pos
, world
);
1232 player_walkgrid_stand_tri( corners
[0]->pos
,
1234 corners
[1]->pos
, world
);
1238 vg_line( corners
[3]->pos
, corners
[1]->pos
, 0xffaaaaaa );
1240 if( wg
->pos
[0] < 1.0f
-wg
->pos
[1] )
1241 player_walkgrid_stand_tri( corners
[0]->pos
,
1243 corners
[1]->pos
, world
);
1245 player_walkgrid_stand_tri( corners
[3]->pos
,
1247 corners
[1]->pos
, world
);
1252 for( int i
=0; i
<conf
->edge_count
; i
++ )
1254 const struct confedge
*edge
= &conf
->edges
[i
];
1257 v3_muladds( corners
[edge
->i0
]->pos
,
1258 corners
[edge
->d0
]->clip
[edge
->a0
], k_gridscale
, p0
);
1259 v3_muladds( corners
[edge
->i1
]->pos
,
1260 corners
[edge
->d1
]->clip
[edge
->a1
], k_gridscale
, p1
);
1263 * Find penetration distance between player position and the edge
1266 v2f normal
= { -(p1
[2]-p0
[2]), p1
[0]-p0
[0] },
1267 rel
= { world
[0]-p0
[0], world
[2]-p0
[2] };
1269 if( edge
->o0
== -1 )
1271 /* No subregions (default case), just use triangle created by
1273 player_walkgrid_stand_tri( corners
[edge
->i0
]->pos
,
1280 * Test if we are in the first region, which is
1281 * edge.i0, edge.e0, edge.o0,
1284 v3_sub( p0
, corners
[edge
->o0
]->pos
, ref
);
1285 v3_sub( world
, corners
[edge
->o0
]->pos
, v0
);
1287 vg_line( corners
[edge
->o0
]->pos
, p0
, 0xffffff00 );
1288 vg_line( corners
[edge
->o0
]->pos
, world
, 0xff000000 );
1290 if( ref
[0]*v0
[2] - ref
[2]*v0
[0] < 0.0f
)
1292 player_walkgrid_stand_tri( corners
[edge
->i0
]->pos
,
1294 corners
[edge
->o0
]->pos
, world
);
1298 if( edge
->o1
== -1 )
1301 * No other edges mean we just need to use the opposite
1303 * e0, e1, o0 (in our case, also i1)
1305 player_walkgrid_stand_tri( p0
,
1307 corners
[edge
->o0
]->pos
, world
);
1312 * Note: this v0 calculation can be ommited with the
1315 * the last two triangles we have are:
1320 v3_sub( p1
, corners
[edge
->o1
]->pos
, ref
);
1321 v3_sub( world
, corners
[edge
->o1
]->pos
, v0
);
1322 vg_line( corners
[edge
->o1
]->pos
, p1
, 0xff00ffff );
1324 if( ref
[0]*v0
[2] - ref
[2]*v0
[0] < 0.0f
)
1326 player_walkgrid_stand_tri( p0
,
1328 corners
[edge
->o1
]->pos
,
1333 player_walkgrid_stand_tri( p1
,
1334 corners
[edge
->i1
]->pos
,
1335 corners
[edge
->o1
]->pos
,
1345 v3_copy( world
, player
.rb
.co
);
1348 static void player_walkgrid_getsurface(void)
1350 float const k_stepheight
= 0.5f
;
1351 float const k_miny
= 0.6f
;
1352 float const k_height
= 1.78f
;
1353 float const k_region_size
= (float)WALKGRID_SIZE
/2.0f
* k_gridscale
;
1355 static struct walkgrid wg
;
1358 v3_copy( player
.rb
.co
, cell
);
1359 player_walkgrid_floor( cell
);
1361 v3_muladds( cell
, (v3f
){-1.0f
,-1.0f
,-1.0f
}, k_region_size
, wg
.region
[0] );
1362 v3_muladds( cell
, (v3f
){ 1.0f
, 1.0f
, 1.0f
}, k_region_size
, wg
.region
[1] );
1366 * Create player input vector
1368 v3f delta
= {0.0f
,0.0f
,0.0f
};
1369 v3f fwd
= { -sinf(-player
.angles
[0]), 0.0f
, -cosf(-player
.angles
[0]) },
1370 side
= { -fwd
[2], 0.0f
, fwd
[0] };
1373 if( !vg_console_enabled() )
1375 if( glfwGetKey( vg_window
, GLFW_KEY_W
) )
1376 v3_muladds( delta
, fwd
, ktimestep
*k_walkspeed
, delta
);
1377 if( glfwGetKey( vg_window
, GLFW_KEY_S
) )
1378 v3_muladds( delta
, fwd
, -ktimestep
*k_walkspeed
, delta
);
1380 if( glfwGetKey( vg_window
, GLFW_KEY_A
) )
1381 v3_muladds( delta
, side
, -ktimestep
*k_walkspeed
, delta
);
1382 if( glfwGetKey( vg_window
, GLFW_KEY_D
) )
1383 v3_muladds( delta
, side
, ktimestep
*k_walkspeed
, delta
);
1385 v3_muladds( delta
, fwd
,
1386 vg_get_axis("vertical")*-ktimestep
*k_walkspeed
, delta
);
1387 v3_muladds( delta
, side
,
1388 vg_get_axis("horizontal")*ktimestep
*k_walkspeed
, delta
);
1392 * Create our move in grid space
1394 wg
.dir
[0] = delta
[0] * (1.0f
/k_gridscale
);
1395 wg
.dir
[1] = delta
[2] * (1.0f
/k_gridscale
);
1400 (player
.rb
.co
[0] - wg
.region
[0][0]) * (1.0f
/k_gridscale
),
1401 (player
.rb
.co
[2] - wg
.region
[0][2]) * (1.0f
/k_gridscale
)
1403 v2f region_cell_pos
;
1404 v2_floor( region_pos
, region_cell_pos
);
1405 v2_sub( region_pos
, region_cell_pos
, wg
.pos
);
1407 wg
.cell_id
[0] = region_cell_pos
[0];
1408 wg
.cell_id
[1] = region_cell_pos
[1];
1410 for(int y
=0; y
<WALKGRID_SIZE
; y
++ )
1412 for(int x
=0; x
<WALKGRID_SIZE
; x
++ )
1414 struct grid_sample
*s
= &wg
.samples
[y
][x
];
1415 v3_muladds( wg
.region
[0], (v3f
){ x
, 0, y
}, k_gridscale
, s
->pos
);
1416 s
->state
= k_traverse_none
;
1417 s
->type
= k_sample_type_air
;
1418 v3_zero( s
->clip
[0] );
1419 v3_zero( s
->clip
[1] );
1423 v2i border
[WALKGRID_SIZE
*WALKGRID_SIZE
];
1424 v2i
*cborder
= border
;
1425 u32 border_length
= 1;
1427 struct grid_sample
*base
= NULL
;
1429 v2i starters
[] = {{0,0},{1,1},{0,1},{1,0}};
1431 for( int i
=0;i
<4;i
++ )
1434 v2i_add( wg
.cell_id
, starters
[i
], test
);
1435 v2i_copy( test
, border
[0] );
1436 base
= &wg
.samples
[test
[1]][test
[0]];
1438 base
->pos
[1] = cell
[1];
1439 player_walkgrid_samplepole( base
);
1441 if( base
->type
== k_sample_type_valid
)
1444 base
->type
= k_sample_type_air
;
1447 vg_line_pt3( base
->pos
, 0.1f
, 0xffffffff );
1451 while( border_length
)
1453 v2i directions
[] = {{1,0},{0,1},{-1,0},{0,-1}};
1455 v2i
*old_border
= cborder
;
1456 int len
= border_length
;
1459 cborder
= old_border
+len
;
1461 for( int i
=0; i
<len
; i
++ )
1464 v2i_copy( old_border
[i
], co
);
1465 struct grid_sample
*sa
= &wg
.samples
[co
[1]][co
[0]];
1467 for( int j
=0; j
<4; j
++ )
1470 v2i_add( co
, directions
[j
], newp
);
1472 if( newp
[0] < 0 || newp
[1] < 0 ||
1473 newp
[0] == WALKGRID_SIZE
|| newp
[1] == WALKGRID_SIZE
)
1476 struct grid_sample
*sb
= &wg
.samples
[newp
[1]][newp
[0]];
1477 enum traverse_state thismove
= j
%2==0? 1: 2;
1479 if( (sb
->state
& thismove
) == 0x00 ||
1480 sb
->type
== k_sample_type_air
)
1482 sb
->pos
[1] = sa
->pos
[1];
1484 player_walkgrid_samplepole( sb
);
1486 if( sb
->type
!= k_sample_type_air
)
1489 * Need to do a blocker pass
1492 struct grid_sample
*store
= (j
>>1 == 0)? sa
: sb
;
1493 player_walkgrid_clip_blocker( sa
, sb
, store
, j
%2 );
1496 if( sb
->type
!= k_sample_type_air
)
1498 vg_line( sa
->pos
, sb
->pos
, 0xffffffff );
1500 if( sb
->state
== k_traverse_none
)
1501 v2i_copy( newp
, cborder
[ border_length
++ ] );
1506 v3_muladds( sa
->pos
, store
->clip
[j
%2], k_gridscale
, p1
);
1507 vg_line( sa
->pos
, p1
, 0xffffffff );
1513 * A clipping pass is now done on the edge of the walkable
1517 struct grid_sample
*store
= (j
>>1 == 0)? sa
: sb
;
1518 player_walkgrid_clip_edge( sa
, sb
, store
, j
%2 );
1521 v3_muladds( sa
->pos
, store
->clip
[j
%2], k_gridscale
, p1
);
1522 vg_line( sa
->pos
, p1
, 0xffffffff );
1525 sb
->state
|= thismove
;
1529 sa
->state
= k_traverse_h
|k_traverse_v
;
1533 if( iter
== walk_grid_iterations
)
1537 /* Draw connections */
1538 struct grid_sample
*corners
[4];
1539 for( int x
=0; x
<WALKGRID_SIZE
-1; x
++ )
1541 for( int z
=0; z
<WALKGRID_SIZE
-1; z
++ )
1543 const struct conf
*conf
=
1544 player_walkgrid_conf( &wg
, (v2i
){x
,z
}, corners
);
1546 for( int i
=0; i
<conf
->edge_count
; i
++ )
1548 const struct confedge
*edge
= &conf
->edges
[i
];
1551 v3_muladds( corners
[edge
->i0
]->pos
,
1552 corners
[edge
->d0
]->clip
[edge
->a0
], k_gridscale
, p0
);
1553 v3_muladds( corners
[edge
->i1
]->pos
,
1554 corners
[edge
->d1
]->clip
[edge
->a1
], k_gridscale
, p1
);
1556 vg_line( p0
, p1
, 0xff0000ff );
1562 * Commit player movement into the grid
1565 if( v3_length2(delta
) <= 0.00001f
)
1569 for(; i
<8 && wg
.move
> 0.001f
; i
++ )
1570 player_walkgrid_iter( &wg
, i
);
1572 player_walkgrid_stand_cell( &wg
);
1575 static void player_walkgrid(void)
1577 player_walkgrid_getsurface();
1579 m4x3_mulv( player
.rb
.to_world
, (v3f
){0.0f
,1.8f
,0.0f
}, player
.camera_pos
);
1581 rb_update_transform( &player
.rb
);
1588 static void player_animate(void)
1590 /* Camera position */
1591 v3_sub( player
.rb
.v
, player
.v_last
, player
.a
);
1592 v3_copy( player
.rb
.v
, player
.v_last
);
1594 v3_add( player
.m
, player
.a
, player
.m
);
1595 v3_lerp( player
.m
, (v3f
){0.0f
,0.0f
,0.0f
}, 0.1f
, player
.m
);
1597 player
.m
[0] = vg_clampf( player
.m
[0], -2.0f
, 2.0f
);
1598 player
.m
[1] = vg_clampf( player
.m
[1], -2.0f
, 2.0f
);
1599 player
.m
[2] = vg_clampf( player
.m
[2], -2.0f
, 2.0f
);
1600 v3_lerp( player
.bob
, player
.m
, 0.2f
, player
.bob
);
1603 float lslip
= fabsf(player
.slip
);
1605 float grabt
= vg_get_axis( "grabr" )*0.5f
+0.5f
;
1606 player
.grab
= vg_lerpf( player
.grab
, grabt
, 0.04f
);
1608 float kheight
= 2.0f
,
1612 m3x3_mulv( player
.rb
.to_local
, player
.bob
, offset
);
1614 static float speed_wobble
= 0.0f
, speed_wobble_2
= 0.0f
;
1616 float kickspeed
= vg_clampf(v3_length(player
.rb
.v
)*(1.0f
/40.0f
), 0.0f
, 1.0f
);
1617 float kicks
= (vg_randf()-0.5f
)*2.0f
*kickspeed
;
1618 float sign
= vg_signf( kicks
);
1619 speed_wobble
= vg_lerpf( speed_wobble
, kicks
*kicks
*sign
, 0.1f
);
1620 speed_wobble_2
= vg_lerpf( speed_wobble_2
, speed_wobble
, 0.04f
);
1623 offset
[0] += speed_wobble_2
*3.0f
;
1628 offset
[0] = vg_clampf( offset
[0], -0.8f
, 0.8f
);
1629 offset
[1] = vg_clampf( offset
[1], -0.5f
, 0.0f
);
1633 * Animation blending
1634 * ===========================================
1637 static float fslide
= 0.0f
;
1638 static float fdirz
= 0.0f
;
1639 static float fdirx
= 0.0f
;
1640 static float fstand
= 0.0f
;
1641 static float ffly
= 0.0f
;
1643 float speed
= v3_length( player
.rb
.v
);
1645 fstand
= vg_lerpf(fstand
, 1.0f
-vg_clampf(speed
*0.03f
,0.0f
,1.0f
),0.1f
);
1646 fslide
= vg_lerpf(fslide
, vg_clampf(lslip
,0.0f
,1.0f
), 0.04f
);
1647 fdirz
= vg_lerpf(fdirz
, player
.reverse
> 0.0f
? 1.0f
: 0.0f
, 0.04f
);
1648 fdirx
= vg_lerpf(fdirx
, player
.slip
< 0.0f
? 1.0f
: 0.0f
, 0.01f
);
1649 ffly
= vg_lerpf(ffly
, player
.in_air
? 1.0f
: 0.0f
, 0.04f
);
1651 character_pose_reset( &player
.mdl
);
1654 float fstand1
= 1.0f
-(1.0f
-fstand
)*0.3f
;
1656 float amt_air
= ffly
*ffly
,
1657 amt_ground
= 1.0f
-amt_air
,
1658 amt_std
= (1.0f
-fslide
) * amt_ground
,
1659 amt_stand
= amt_std
* fstand1
,
1660 amt_aero
= amt_std
* (1.0f
-fstand1
),
1661 amt_slide
= amt_ground
* fslide
;
1663 character_final_pose( &player
.mdl
, offset
, &pose_stand
, amt_stand
*fdirz
);
1664 character_final_pose( &player
.mdl
, offset
,
1665 &pose_stand_reverse
, amt_stand
* (1.0f
-fdirz
) );
1667 character_final_pose( &player
.mdl
, offset
, &pose_aero
, amt_aero
*fdirz
);
1668 character_final_pose( &player
.mdl
, offset
,
1669 &pose_aero_reverse
, amt_aero
* (1.0f
-fdirz
) );
1671 character_final_pose( &player
.mdl
, offset
, &pose_slide
, amt_slide
*fdirx
);
1672 character_final_pose( &player
.mdl
, offset
,
1673 &pose_slide1
, amt_slide
*(1.0f
-fdirx
) );
1675 character_final_pose( &player
.mdl
, (v3f
){0.0f
,0.0f
,0.0f
},
1676 &pose_fly
, amt_air
);
1681 * ==========================
1683 struct ik_basic
*arm_l
= &player
.mdl
.ik_arm_l
,
1684 *arm_r
= &player
.mdl
.ik_arm_r
;
1687 m3x3_mulv( player
.rb
.to_local
, player
.rb
.v
, localv
);
1689 /* New board transformation */
1690 v4f board_rotation
; v3f board_location
;
1693 q_axis_angle( rz
, (v3f
){ 0.0f
, 0.0f
, 1.0f
}, player
.board_xy
[0] );
1694 q_axis_angle( rx
, (v3f
){ 1.0f
, 0.0f
, 0.0f
}, player
.board_xy
[1] );
1695 q_mul( rx
, rz
, board_rotation
);
1697 v3f
*mboard
= player
.mdl
.matrices
[k_chpart_board
];// player.mboard;
1698 q_m3x3( board_rotation
, mboard
);
1699 m3x3_mulv( mboard
, (v3f
){ 0.0f
, -0.5f
, 0.0f
}, board_location
);
1700 v3_add( (v3f
){0.0f
,0.5f
,0.0f
}, board_location
, board_location
);
1701 v3_copy( board_location
, mboard
[3] );
1704 float wheel_r
= offset
[0]*-0.4f
;
1706 q_axis_angle( qwheel
, (v3f
){0.0f
,1.0f
,0.0f
}, wheel_r
);
1708 q_m3x3( qwheel
, player
.mdl
.matrices
[k_chpart_wb
] );
1710 m3x3_transpose( player
.mdl
.matrices
[k_chpart_wb
],
1711 player
.mdl
.matrices
[k_chpart_wf
] );
1712 v3_copy( player
.mdl
.offsets
[k_chpart_wb
],
1713 player
.mdl
.matrices
[k_chpart_wb
][3] );
1714 v3_copy( player
.mdl
.offsets
[k_chpart_wf
],
1715 player
.mdl
.matrices
[k_chpart_wf
][3] );
1717 m4x3_mul( mboard
, player
.mdl
.matrices
[k_chpart_wb
],
1718 player
.mdl
.matrices
[k_chpart_wb
] );
1719 m4x3_mul( mboard
, player
.mdl
.matrices
[k_chpart_wf
],
1720 player
.mdl
.matrices
[k_chpart_wf
] );
1722 m4x3_mulv( mboard
, player
.mdl
.ik_leg_l
.end
, player
.mdl
.ik_leg_l
.end
);
1723 m4x3_mulv( mboard
, player
.mdl
.ik_leg_r
.end
, player
.mdl
.ik_leg_r
.end
);
1726 v3_copy( player
.mdl
.ik_arm_l
.end
, player
.handl_target
);
1727 v3_copy( player
.mdl
.ik_arm_r
.end
, player
.handr_target
);
1729 if( 1||player
.in_air
)
1731 float tuck
= player
.board_xy
[1],
1732 tuck_amt
= fabsf( tuck
) * (1.0f
-fabsf(player
.board_xy
[0]));
1734 float crouch
= player
.grab
*0.3f
;
1735 v3_muladds( player
.mdl
.ik_body
.base
, (v3f
){0.0f
,-1.0f
,0.0f
},
1736 crouch
, player
.mdl
.ik_body
.base
);
1737 v3_muladds( player
.mdl
.ik_body
.end
, (v3f
){0.0f
,-1.0f
,0.0f
},
1738 crouch
*1.2f
, player
.mdl
.ik_body
.end
);
1742 //foot_l *= 1.0f-tuck_amt*1.5f;
1744 if( player
.grab
> 0.1f
)
1746 m4x3_mulv( mboard
, (v3f
){0.1f
,0.14f
,0.6f
},
1747 player
.handl_target
);
1752 //foot_r *= 1.0f-tuck_amt*1.4f;
1754 if( player
.grab
> 0.1f
)
1756 m4x3_mulv( mboard
, (v3f
){0.1f
,0.14f
,-0.6f
},
1757 player
.handr_target
);
1762 v3_lerp( player
.handl
, player
.handl_target
, 1.0f
, player
.handl
);
1763 v3_lerp( player
.handr
, player
.handr_target
, 1.0f
, player
.handr
);
1765 v3_copy( player
.handl
, player
.mdl
.ik_arm_l
.end
);
1766 v3_copy( player
.handr
, player
.mdl
.ik_arm_r
.end
);
1770 static float rhead
= 0.0f
;
1771 static const float klook_max
= 0.8f
;
1772 rhead
= vg_lerpf( rhead
,
1773 vg_clampf( atan2f(localv
[2],-localv
[0]),-klook_max
,klook_max
), 0.04f
);
1774 player
.mdl
.rhead
= rhead
;
1777 static void player_camera_update(void)
1779 /* Update camera matrices */
1780 m4x3_identity( player
.camera
);
1781 m4x3_rotate_y( player
.camera
, -player
.angles
[0] );
1782 m4x3_rotate_x( player
.camera
, -player
.angles
[1] );
1783 v3_copy( player
.camera_pos
, player
.camera
[3] );
1784 m4x3_invert_affine( player
.camera
, player
.camera_inverse
);
1787 static void player_animate_death_cam(void)
1791 v3_copy( player
.mdl
.ragdoll
[k_chpart_head
].co
, head_pos
);
1793 v3_sub( head_pos
, player
.camera_pos
, delta
);
1794 v3_normalize( delta
);
1797 v3_muladds( head_pos
, delta
, -2.5f
, follow_pos
);
1798 v3_lerp( player
.camera_pos
, follow_pos
, 0.1f
, player
.camera_pos
);
1801 * Make sure the camera stays above the ground
1803 v3f min_height
= {0.0f
,1.0f
,0.0f
};
1806 v3_add( player
.camera_pos
, min_height
, sample
);
1808 hit
.dist
= min_height
[1]*2.0f
;
1810 if( ray_world( sample
, (v3f
){0.0f
,-1.0f
,0.0f
}, &hit
))
1811 v3_add( hit
.pos
, min_height
, player
.camera_pos
);
1813 player
.camera_pos
[1] =
1814 vg_maxf( wrender
.height
+ 2.0f
, player
.camera_pos
[1] );
1816 player
.angles
[0] = atan2f( delta
[0], -delta
[2] );
1817 player
.angles
[1] = -asinf( delta
[1] );
1820 static void player_animate_camera(void)
1822 v3f offs
= { -0.29f
, 0.08f
, 0.0f
};
1823 m3x3_mulv( player
.rb
.to_world
, offs
, offs
);
1824 m4x3_mulv( player
.rb
.to_world
, player
.mdl
.ik_body
.end
, player
.camera_pos
);
1825 v3_add( offs
, player
.camera_pos
, player
.camera_pos
);
1828 v3_lerp( player
.vl
, player
.rb
.v
, 0.05f
, player
.vl
);
1830 float yaw
= atan2f( player
.vl
[0], -player
.vl
[2] ),
1831 pitch
= atan2f( -player
.vl
[1],
1833 player
.vl
[0]*player
.vl
[0] + player
.vl
[2]*player
.vl
[2]
1836 player
.angles
[0] = yaw
;
1837 player
.angles
[1] = pitch
+ 0.30f
;
1840 static v2f shake_damp
= {0.0f
,0.0f
};
1841 v2f shake
= { vg_randf()-0.5f
, vg_randf()-0.5f
};
1842 v2_muls( shake
, v3_length(player
.rb
.v
)*0.3f
1843 * (1.0f
+fabsf(player
.slip
)), shake
);
1845 v2_lerp( shake_damp
, shake
, 0.01f
, shake_damp
);
1846 shake_damp
[0] *= 0.2f
;
1848 v2_muladds( player
.angles
, shake_damp
, 0.1f
, player
.angles
);
1854 static void player_audio(void)
1856 float speed
= vg_minf(v3_length( player
.rb
.v
)*0.1f
,1.0f
),
1857 attn
= v3_dist( player
.rb
.co
, player
.camera
[3] )+1.0f
;
1858 attn
= (1.0f
/(attn
*attn
)) * speed
;
1860 static float air
= 0.0f
;
1861 air
= vg_lerpf(air
, player
.in_air
? 1.0f
: 0.0f
, 0.7f
);
1863 v3f ears
= { 1.0f
,0.0f
,0.0f
};
1866 v3_sub( player
.rb
.co
, player
.camera
[3], delta
);
1867 v3_normalize( delta
);
1868 m3x3_mulv( player
.camera
, ears
, ears
);
1870 float pan
= v3_dot( ears
, delta
);
1871 audio_player0
.pan
= pan
;
1872 audio_player1
.pan
= pan
;
1873 audio_player2
.pan
= pan
;
1877 audio_player0
.vol
= 0.0f
;
1878 audio_player1
.vol
= 0.0f
;
1879 audio_player2
.vol
= 0.0f
;
1883 if( player
.is_dead
)
1885 audio_player0
.vol
= 0.0f
;
1886 audio_player1
.vol
= 0.0f
;
1887 audio_player2
.vol
= 0.0f
;
1891 float slide
= vg_clampf( fabsf(player
.slip
), 0.0f
, 1.0f
);
1892 audio_player0
.vol
= (1.0f
-air
)*attn
*(1.0f
-slide
);
1893 audio_player1
.vol
= air
*attn
;
1894 audio_player2
.vol
= (1.0f
-air
)*attn
*slide
;
1902 static float *player_cam_pos(void)
1904 return player
.camera_pos
;
1907 static int reset_player( int argc
, char const *argv
[] )
1909 struct respawn_point
*rp
= NULL
, *r
;
1913 for( int i
=0; i
<world
.spawn_count
; i
++ )
1915 r
= &world
.spawns
[i
];
1916 if( !strcmp( r
->name
, argv
[0] ) )
1924 vg_warn( "No spawn named '%s'\n", argv
[0] );
1929 float min_dist
= INFINITY
;
1931 for( int i
=0; i
<world
.spawn_count
; i
++ )
1933 r
= &world
.spawns
[i
];
1934 float d
= v3_dist2( r
->co
, player
.rb
.co
);
1936 vg_info( "Dist %s : %f\n", r
->name
, d
);
1947 vg_error( "No spawn found\n" );
1948 if( !world
.spawn_count
)
1951 rp
= &world
.spawns
[0];
1954 v4_copy( rp
->q
, player
.rb
.q
);
1955 v3_copy( rp
->co
, player
.rb
.co
);
1957 player
.vswitch
= 1.0f
;
1958 player
.slip_last
= 0.0f
;
1961 m3x3_identity( player
.vr
);
1963 player
.mdl
.shoes
[0] = 1;
1964 player
.mdl
.shoes
[1] = 1;
1966 rb_update_transform( &player
.rb
);
1967 m3x3_mulv( player
.rb
.to_world
, (v3f
){ 0.0f
, 0.0f
, -1.2f
}, player
.rb
.v
);
1971 static void player_update(void)
1973 for( int i
=0; i
<player
.land_log_count
; i
++ )
1974 draw_cross( player
.land_target_log
[i
],
1975 player
.land_target_colours
[i
], 0.25f
);
1977 if( vg_get_axis("grabl")>0.0f
)
1978 reset_player(0,NULL
);
1980 if( vg_get_button_down( "switchmode" ) )
1982 player
.on_board
^= 0x1;
1985 if( player
.is_dead
)
1987 character_ragdoll_iter( &player
.mdl
);
1988 character_debug_ragdoll( &player
.mdl
);
1991 player_animate_death_cam();
1995 if( player
.on_board
)
2001 player_animate_camera();
2012 player_camera_update();
2016 static void draw_player(void)
2019 m4x3_copy( player
.rb
.to_world
, player
.mdl
.mroot
);
2021 if( player
.is_dead
)
2022 character_mimic_ragdoll( &player
.mdl
);
2024 character_eval( &player
.mdl
);
2026 float opacity
= 1.0f
-player
.air_blend
;
2027 if( player
.is_dead
)
2030 character_draw( &player
.mdl
, opacity
, player
.camera
);
2033 #endif /* PLAYER_H */