class classtype_bone(Structure):
#{
_pack_ = 1
- _fields_ = [("deform",c_uint32),
+ _fields_ = [("flags",c_uint32),
("ik_target",c_uint32),
("ik_pole",c_uint32),
- ("collider",c_uint32),
- ("use_limits",c_uint32),
- ("angle_limits",(c_float*3)*2),
- ("hitbox",(c_float*3)*2)]
+ ("hitbox",(c_float*3)*2),
+ ("conevx",c_float*3),
+ ("conevy",c_float*3),
+ ("coneva",c_float*3),
+ ("conet",c_float)]
def encode_obj(_, node,node_def):
#{
armature_def = node_def['linked_armature']
obj = node_def['bone']
- _.deform = node_def['deform']
+ _.flags = node_def['deform']
if 'ik_target' in node_def:
#{
+ _.flags |= 0x2
_.ik_target = armature_def['bones'].index( node_def['ik_target'] )
_.ik_pole = armature_def['bones'].index( node_def['ik_pole'] )
#}
# For ragdolls
#
- if obj.cv_data.collider:
+ if obj.cv_data.collider != 'collider_none':
#{
- _.collider = 1
+ if obj.cv_data.collider == 'collider_box':
+ _.flags |= 0x4
+ else:
+ _.flags |= 0x8
+
_.hitbox[0][0] = obj.cv_data.v0[0]
_.hitbox[0][1] = obj.cv_data.v0[2]
_.hitbox[0][2] = -obj.cv_data.v1[1]
if obj.cv_data.con0:
#{
- _.use_limits = 1
- _.angle_limits[0][0] = obj.cv_data.mins[0]
- _.angle_limits[0][1] = obj.cv_data.mins[2]
- _.angle_limits[0][2] = -obj.cv_data.maxs[1]
- _.angle_limits[1][0] = obj.cv_data.maxs[0]
- _.angle_limits[1][1] = obj.cv_data.maxs[2]
- _.angle_limits[1][2] = -obj.cv_data.mins[1]
+ _.flags |= 0x100
+ _.conevx[0] = obj.cv_data.conevx[0]
+ _.conevx[1] = obj.cv_data.conevx[2]
+ _.conevx[2] = -obj.cv_data.conevx[1]
+ _.conevy[0] = obj.cv_data.conevy[0]
+ _.conevy[1] = obj.cv_data.conevy[2]
+ _.conevy[2] = -obj.cv_data.conevy[1]
+ _.coneva[0] = obj.cv_data.coneva[0]
+ _.coneva[1] = obj.cv_data.coneva[2]
+ _.coneva[2] = -obj.cv_data.coneva[1]
+ _.conet = obj.cv_data.conet
#}
#}
#}
#}
#}
- if n.cv_data.collider:
+ if n.cv_data.collider != 'collider_none':
tree['collider_count'] += 1
btree['deform'] = n.use_deform
cv_draw_lines()
#}
+# Draw axis alligned sphere at position with radius
+#
+def cv_draw_halfsphere( pos, tx, ty, tz, radius, colour ):
+#{
+ global cv_view_verts, cv_view_colours
+
+ ly = pos + tz*radius
+ lx = pos + ty*radius
+ lz = pos + tz*radius
+
+ pi = 3.14159265358979323846264
+
+ for i in range(16):
+ #{
+ t = ((i+1.0) * 1.0/16.0) * pi
+ s = math.sin(t)
+ c = math.cos(t)
+
+ s1 = math.sin(t*2.0)
+ c1 = math.cos(t*2.0)
+
+ py = pos + s*tx*radius + c *tz*radius
+ px = pos + s*tx*radius + c *ty*radius
+ pz = pos + s1*ty*radius + c1*tz*radius
+
+ cv_view_verts += [ px, lx ]
+ cv_view_verts += [ py, ly ]
+ cv_view_verts += [ pz, lz ]
+
+ cv_view_colours += [ colour, colour, colour, colour, colour, colour ]
+
+ ly = py
+ lx = px
+ lz = pz
+ #}
+ cv_draw_lines()
+#}
+
# Draw transformed -1 -> 1 cube
#
def cv_draw_ucube( transform, colour ):
cv_draw_lines()
#}
-# Just the tx because we dont really need ty for this app
+#
#
-def cv_tangent_basis_tx( n, tx ):
+def cv_tangent_basis( n, tx, ty ):
#{
if abs( n[0] ) >= 0.57735027:
#{
#}
tx.normalize()
+ _ty = n.cross( tx )
+
+ ty[0] = _ty[0]
+ ty[1] = _ty[1]
+ ty[2] = _ty[2]
#}
# Draw coloured arrow
n.normalize()
tx = Vector((1,0,0))
- cv_tangent_basis_tx( n, tx )
+ ty = Vector((1,0,0))
+ cv_tangent_basis( n, tx, ty )
cv_view_verts += [p0,p1, midpt+(tx-n)*0.15,midpt, midpt+(-tx-n)*0.15,midpt ]
cv_view_colours += [c0,c0,c0,c0,c0,c0]
cv_draw_lines()
#}
+# Cone and twist limit
+#
+def draw_cone_twist( center, vx, vy, va ):
+#{
+ global cv_view_verts, cv_view_colours
+ axis = vy.cross( vx )
+ axis.normalize()
+
+ size = 0.12
+
+ cv_view_verts += [center, center+va*size]
+ cv_view_colours += [ (1,1,1,1), (1,1,1,1) ]
+
+ for x in range(32):
+ #{
+ t0 = (x/32) * math.tau
+ t1 = ((x+1)/32) * math.tau
+
+ c0 = math.cos(t0)
+ s0 = math.sin(t0)
+ c1 = math.cos(t1)
+ s1 = math.sin(t1)
+
+ p0 = center + (axis + vx*c0 + vy*s0).normalized() * size
+ p1 = center + (axis + vx*c1 + vy*s1).normalized() * size
+
+ col0 = ( abs(c0), abs(s0), 0.0, 1.0 )
+ col1 = ( abs(c1), abs(s1), 0.0, 1.0 )
+
+ cv_view_verts += [center, p0, p0, p1]
+ cv_view_colours += [ (0,0,0,0), col0, col0, col1 ]
+ #}
+
+ cv_draw_lines()
+#}
+
# Draws constraints and stuff for the skeleton. This isnt documented and wont be
#
def draw_skeleton_helpers( obj ):
#{
global cv_view_verts, cv_view_colours
+ if obj.data.pose_position != 'REST':
+ #{
+ return
+ #}
+
for bone in obj.data.bones:
#{
- if bone.cv_data.collider and (obj.data.pose_position == 'REST'):
+ c = bone.head_local
+ a = Vector((bone.cv_data.v0[0], bone.cv_data.v0[1], bone.cv_data.v0[2]))
+ b = Vector((bone.cv_data.v1[0], bone.cv_data.v1[1], bone.cv_data.v1[2]))
+
+ if bone.cv_data.collider == 'collider_box':
#{
- c = bone.head_local
- a = bone.cv_data.v0
- b = bone.cv_data.v1
vs = [None]*8
vs[0]=obj.matrix_world@Vector((c[0]+a[0],c[1]+a[1],c[2]+a[2]))
cv_view_verts += [(v1[0],v1[1],v1[2])]
cv_view_colours += [(0.5,0.5,0.5,0.5),(0.5,0.5,0.5,0.5)]
#}
+ #}
+ elif bone.cv_data.collider == 'collider_capsule':
+ #{
+ v0 = b-a
+ major_axis = 0
+ largest = -1.0
- center = obj.matrix_world @ c
- if bone.cv_data.con0:
+ for i in range(3):
#{
- draw_limit( obj, c, Vector((0,1,0)),Vector((0,0,1)), \
- bone.cv_data.mins[0], bone.cv_data.maxs[0], \
- (1,0,0,1))
- draw_limit( obj, c, Vector((0,0,1)),Vector((1,0,0)), \
- bone.cv_data.mins[1], bone.cv_data.maxs[1], \
- (0,1,0,1))
- draw_limit( obj, c, Vector((1,0,0)),Vector((0,1,0)), \
- bone.cv_data.mins[2], bone.cv_data.maxs[2], \
- (0,0,1,1))
+ if abs(v0[i]) > largest:
+ #{
+ largest = abs(v0[i])
+ major_axis = i
+ #}
#}
+
+ v1 = Vector((0,0,0))
+ v1[major_axis] = 1.0
+
+ tx = Vector((0,0,0))
+ ty = Vector((0,0,0))
+
+ cv_tangent_basis( v1, tx, ty )
+ r = (abs(tx.dot( v0 )) + abs(ty.dot( v0 ))) * 0.25
+ l = v0[ major_axis ] - r*2
+
+ p0 = obj.matrix_world@Vector( c + (a+b)*0.5 + v1*l*-0.5 )
+ p1 = obj.matrix_world@Vector( c + (a+b)*0.5 + v1*l* 0.5 )
+
+ colour = [0.2,0.2,0.2,1.0]
+ colour[major_axis] = 0.5
+
+ cv_draw_halfsphere( p0, -v1, ty, tx, r, colour )
+ cv_draw_halfsphere( p1, v1, ty, tx, r, colour )
+ cv_draw_line( p0+tx* r, p1+tx* r, colour )
+ cv_draw_line( p0+tx*-r, p1+tx*-r, colour )
+ cv_draw_line( p0+ty* r, p1+ty* r, colour )
+ cv_draw_line( p0+ty*-r, p1+ty*-r, colour )
+ #}
+ else:
+ #{
+ continue
+ #}
+
+ center = obj.matrix_world @ c
+ if bone.cv_data.con0:
+ #{
+ vx = Vector([bone.cv_data.conevx[_] for _ in range(3)])
+ vy = Vector([bone.cv_data.conevy[_] for _ in range(3)])
+ va = Vector([bone.cv_data.coneva[_] for _ in range(3)])
+ draw_cone_twist( center, vx, vy, va )
+
+ #draw_limit( obj, c, Vector((0,0,1)),Vector((0,-1,0)), \
+ # bone.cv_data.mins[0], bone.cv_data.maxs[0], \
+ # (1,0,0,1))
+ #draw_limit( obj, c, Vector((0,-1,0)),Vector((1,0,0)), \
+ # bone.cv_data.mins[1], bone.cv_data.maxs[1], \
+ # (0,1,0,1))
+ #draw_limit( obj, c, Vector((1,0,0)),Vector((0,0,1)), \
+ # bone.cv_data.mins[2], bone.cv_data.maxs[2], \
+ # (0,0,1,1))
#}
#}
#}
class CV_BONE_SETTINGS(bpy.types.PropertyGroup):
#{
- collider: bpy.props.BoolProperty(name="Collider",default=False)
+ collider: bpy.props.EnumProperty(
+ name="Collider Type",
+ items = [
+ ('collider_none', "collider_none", "", 0),
+ ('collider_box', "collider_box", "", 1),
+ ('collider_capsule', "collider_capsule", "", 2),
+ ])
+
v0: bpy.props.FloatVectorProperty(name="v0",size=3)
v1: bpy.props.FloatVectorProperty(name="v1",size=3)
con0: bpy.props.BoolProperty(name="Constriant 0",default=False)
mins: bpy.props.FloatVectorProperty(name="mins",size=3)
maxs: bpy.props.FloatVectorProperty(name="maxs",size=3)
+
+ conevx: bpy.props.FloatVectorProperty(name="conevx",size=3)
+ conevy: bpy.props.FloatVectorProperty(name="conevy",size=3)
+ coneva: bpy.props.FloatVectorProperty(name="coneva",size=3)
+ conet: bpy.props.FloatProperty(name="conet")
#}
class CV_BONE_PANEL(bpy.types.Panel):
_.layout.label( text="Angle Limits" )
_.layout.prop( bone.cv_data, "con0" )
- _.layout.prop( bone.cv_data, "mins" )
- _.layout.prop( bone.cv_data, "maxs" )
+
+ _.layout.prop( bone.cv_data, "conevx" )
+ _.layout.prop( bone.cv_data, "conevy" )
+ _.layout.prop( bone.cv_data, "coneva" )
+ _.layout.prop( bone.cv_data, "conet" )
#}
#}
#include "player.h"
VG_STATIC float k_ragdoll_floatyiness = 20.0f,
- k_ragdoll_floatydrag = 1.0f;
+ k_ragdoll_floatydrag = 1.0f,
+ k_ragdoll_limit_scale = 1.0f;
+
+VG_STATIC int k_ragdoll_div = 1,
+ ragdoll_frame = 0,
+ k_ragdoll_debug_collider = 1,
+ k_ragdoll_debug_constraints = 0;
+
+VG_STATIC void player_init_ragdoll_bone_collider( struct skeleton_bone *bone,
+ struct ragdoll_part *rp )
+{
+ m4x3_identity( rp->collider_mtx );
+
+ if( bone->flags & k_bone_flag_collider_box )
+ {
+ v3f delta;
+ v3_sub( bone->hitbox[1], bone->hitbox[0], delta );
+ v3_muls( delta, 0.5f, delta );
+ v3_add( bone->hitbox[0], delta, rp->collider_mtx[3] );
+
+ v3_copy( delta, rp->rb.bbx[1] );
+ v3_muls( delta, -1.0f, rp->rb.bbx[0] );
+
+ q_identity( rp->rb.q );
+ rp->rb.type = k_rb_shape_box;
+ rp->colour = 0xffcccccc;
+ }
+ else if( bone->flags & k_bone_flag_collider_capsule )
+ {
+ v3f v0, v1, tx, ty;
+ v3_sub( bone->hitbox[1], bone->hitbox[0], v0 );
+
+ int major_axis = 0;
+ float largest = -1.0f;
+
+ for( int i=0; i<3; i ++ )
+ {
+ if( fabsf( v0[i] ) > largest )
+ {
+ largest = fabsf( v0[i] );
+ major_axis = i;
+ }
+ }
+
+ v3_zero( v1 );
+ v1[ major_axis ] = 1.0f;
+ rb_tangent_basis( v1, tx, ty );
+
+ float r = (fabsf(v3_dot(tx,v0)) + fabsf(v3_dot(ty,v0))) * 0.25f,
+ l = fabsf(v0[ major_axis ]);
+
+ /* orientation */
+ v3_muls( tx, -1.0f, rp->collider_mtx[0] );
+ v3_muls( v1, -1.0f, rp->collider_mtx[1] );
+ v3_muls( ty, -1.0f, rp->collider_mtx[2] );
+ v3_add( bone->hitbox[0], bone->hitbox[1], rp->collider_mtx[3] );
+ v3_muls( rp->collider_mtx[3], 0.5f, rp->collider_mtx[3] );
+
+ rp->rb.type = k_rb_shape_capsule;
+ rp->rb.inf.capsule.height = l;
+ rp->rb.inf.capsule.radius = r;
+
+ rp->colour = 0xff000000 | (0xff << (major_axis*8));
+ }
+ else
+ vg_fatal_exit_loop( "Invalid bone collider type" );
+
+ m4x3_invert_affine( rp->collider_mtx, rp->inv_collider_mtx );
+
+ /* Position collider into rest */
+ m3x3_q( rp->collider_mtx, rp->rb.q );
+ v3_add( rp->collider_mtx[3], bone->co, rp->rb.co );
+ rp->rb.is_world = 0;
+ rb_init( &rp->rb );
+}
+
+/*
+ * Get parent index in the ragdoll
+ */
+VG_STATIC u32 ragdoll_bone_parent( struct player_model *mdl, u32 bone_id )
+{
+ for( u32 j=0; j<mdl->ragdoll_count; j++ )
+ if( mdl->ragdoll[ j ].bone_id == bone_id )
+ return j;
+
+ vg_fatal_exit_loop( "Referenced parent bone does not have a rigidbody" );
+ return 0;
+}
/*
* Setup ragdoll colliders
}
mdl->ragdoll_count = 0;
+ mdl->position_constraints_count = 0;
+ mdl->cone_constraints_count = 0;
for( u32 i=0; i<mdl->sk.bone_count; i ++ )
{
struct skeleton_bone *bone = &mdl->sk.bones[i];
-
- if( bone->collider )
- {
- if( mdl->ragdoll_count > vg_list_size(player.mdl.ragdoll) )
- vg_fatal_exit_loop( "Playermodel has too many colliders" );
- struct ragdoll_part *rp = &mdl->ragdoll[ mdl->ragdoll_count ++ ];
- rp->bone_id = i;
-
- v3f delta;
- v3_sub( bone->hitbox[1], bone->hitbox[0], delta );
- v3_muls( delta, 0.5f, delta );
+ /*
+ * Bones with colliders
+ */
+ if( !(bone->flags & k_bone_flag_collider_any) )
+ continue;
- v3_add( bone->hitbox[0], delta, rp->offset );
+ if( mdl->ragdoll_count > vg_list_size(player.mdl.ragdoll) )
+ vg_fatal_exit_loop( "Playermodel has too many colliders" );
- v3_copy( delta, rp->rb.bbx[1] );
- v3_muls( delta, -1.0f, rp->rb.bbx[0] );
+ struct ragdoll_part *rp = &mdl->ragdoll[ mdl->ragdoll_count ++ ];
+ rp->bone_id = i;
+ rp->parent = 0xffffffff;
- q_identity( rp->rb.q );
- v3_add( bone->co, rp->offset, rp->rb.co );
- rp->rb.type = k_rb_shape_box;
- rp->rb.is_world = 0;
- rp->parent = 0xffffffff;
+ player_init_ragdoll_bone_collider( bone, rp );
+
+ struct mdl_node *pnode = mdl_node_from_id( src, bone->orig_node );
+ struct classtype_bone *inf = mdl_get_entdata( src, pnode );
+
+ /*
+ * Bones with collider and parent
+ */
+ if( !bone->parent )
+ continue;
- if( bone->parent )
- {
- for( u32 j=0; j<mdl->ragdoll_count; j++ )
- {
- if( mdl->ragdoll[ j ].bone_id == bone->parent )
- {
- rp->parent = j;
- break;
- }
- }
- }
+ rp->parent = ragdoll_bone_parent( mdl, bone->parent );
+
+ /* Always assign a point-to-point constraint */
+ struct rb_constr_pos *c =
+ &mdl->position_constraints[ mdl->position_constraints_count ++ ];
+
+ struct skeleton_bone *bj = &mdl->sk.bones[rp->bone_id];
+ struct ragdoll_part *pp = &mdl->ragdoll[rp->parent];
+ struct skeleton_bone *bp = &mdl->sk.bones[pp->bone_id];
+
+ /* Convention: rba -- parent, rbb -- child */
+ c->rba = &pp->rb;
+ c->rbb = &rp->rb;
+
+ v3f delta;
+ v3_sub( bj->co, bp->co, delta );
+ m4x3_mulv( rp->inv_collider_mtx, (v3f){0.0f,0.0f,0.0f}, c->lcb );
+ m4x3_mulv( pp->inv_collider_mtx, delta, c->lca );
+
+ if( inf->flags & k_bone_flag_cone_constraint )
+ {
+ struct rb_constr_swingtwist *a =
+ &mdl->cone_constraints[ mdl->cone_constraints_count ++ ];
+ a->rba = &pp->rb;
+ a->rbb = &rp->rb;
+ a->conet = cosf( inf->conet )-0.0001f;
+
+ /* Store constraint in local space vectors */
+ m3x3_mulv( c->rba->to_local, inf->conevx, a->conevx );
+ m3x3_mulv( c->rba->to_local, inf->conevy, a->conevy );
+ m3x3_mulv( c->rbb->to_local, inf->coneva, a->coneva );
+ v3_copy( c->lca, a->view_offset );
- struct mdl_node *pnode = mdl_node_from_id( src, bone->orig_node );
- struct classtype_bone *bone_inf = mdl_get_entdata( src, pnode );
+ v3_cross( inf->coneva, inf->conevy, a->conevxb );
+ m3x3_mulv( c->rbb->to_local, a->conevxb, a->conevxb );
- rp->use_limits = bone_inf->use_limits;
- v3_copy( bone_inf->angle_limits[0], rp->limits[0] );
- v3_copy( bone_inf->angle_limits[1], rp->limits[1] );
+ v3_normalize( a->conevxb );
+ v3_normalize( a->conevx );
+ v3_normalize( a->conevy );
+ v3_normalize( a->coneva );
- rb_init( &rp->rb );
+ a->conevx[3] = v3_length( inf->conevx );
+ a->conevy[3] = v3_length( inf->conevy );
+
+ rp->use_limits = 1;
}
}
}
struct ragdoll_part *part = &mdl->ragdoll[i];
m4x3f offset;
m3x3_identity(offset);
- v3_negate( part->offset, offset[3] );
- m4x3_mul( part->rb.to_world, offset, mdl->sk.final_mtx[part->bone_id] );
+ m4x3_mul( part->rb.to_world, part->inv_collider_mtx,
+ mdl->sk.final_mtx[part->bone_id] );
}
skeleton_apply_inverses( &mdl->sk );
v3f pos, offset;
u32 bone = part->bone_id;
-
+
m4x3_mulv( mdl->sk.final_mtx[bone], mdl->sk.bones[bone].co, pos );
- m3x3_mulv( mdl->sk.final_mtx[bone], part->offset, offset );
+ m3x3_mulv( mdl->sk.final_mtx[bone], part->collider_mtx[3], offset );
v3_add( pos, offset, part->rb.co );
- m3x3_q( mdl->sk.final_mtx[bone], part->rb.q );
+
+ m3x3f r;
+ m3x3_mul( mdl->sk.final_mtx[bone], part->collider_mtx, r );
+ m3x3_q( r, part->rb.q );
+
v3_copy( v, part->rb.v );
v3_zero( part->rb.w );
VG_STATIC void player_debug_ragdoll(void)
{
struct player_model *mdl = &player.mdl;
-
- for( u32 i=0; i<mdl->ragdoll_count; i ++ )
- rb_debug( &mdl->ragdoll[i].rb, 0xff00ff00 );
}
/*
VG_STATIC void player_ragdoll_iter(void)
{
struct player_model *mdl = &player.mdl;
- rb_solver_reset();
+ int run_sim = 0;
+ ragdoll_frame ++;
+
+ if( ragdoll_frame >= k_ragdoll_div )
+ {
+ ragdoll_frame = 0;
+ run_sim = 1;
+ }
+
+ rb_solver_reset();
for( int i=0; i<mdl->ragdoll_count; i ++ )
rb_collide( &mdl->ragdoll[i].rb, &world.rb_geo );
+ /*
+ * COLLISION DETECTION
+ */
+ for( int i=0; i<mdl->ragdoll_count-1; i ++ )
+ {
+ for( int j=i+1; j<mdl->ragdoll_count; j ++ )
+ {
+ if( mdl->ragdoll[j].parent != i )
+ rb_collide( &mdl->ragdoll[i].rb, &mdl->ragdoll[j].rb );
+ }
+ }
+
+ /*
+ * PRESOLVE
+ */
rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
+ rb_presolve_swingtwist_constraints( mdl->cone_constraints,
+ mdl->cone_constraints_count );
+
+ /*
+ * DEBUG
+ */
+ if( k_ragdoll_debug_collider )
+ {
+ for( u32 i=0; i<mdl->ragdoll_count; i ++ )
+ rb_debug( &mdl->ragdoll[i].rb, mdl->ragdoll[i].colour );
+ }
- v3f rv;
+ if( k_ragdoll_debug_constraints )
+ {
+ rb_debug_position_constraints( mdl->position_constraints,
+ mdl->position_constraints_count );
+
+ rb_debug_swingtwist_constraints( mdl->cone_constraints,
+ mdl->cone_constraints_count );
+ }
#if 0
- float shoe_vel[2] = {0.0f,0.0f};
- for( int i=0; i<2; i++ )
- if( mdl->shoes[i] )
- shoe_vel[i] = v3_length( mdl->ragdoll[i].rb.v );
-#endif
-
for( int j=0; j<mdl->ragdoll_count; j++ )
{
struct ragdoll_part *pj = &mdl->ragdoll[j];
struct skeleton_bone *bj = &mdl->sk.bones[pj->bone_id];
- if( pj->parent != 0xffffffff )
+ if( run_sim )
{
- struct ragdoll_part *pp = &mdl->ragdoll[pj->parent];
- struct skeleton_bone *bp = &mdl->sk.bones[pp->bone_id];
-
- v3f lca, lcb;
- v3_negate( pj->offset, lca );
- v3_add( bp->co, pp->offset, lcb );
- v3_sub( bj->co, lcb, lcb );
-
- rb_debug_constraint_position( &pj->rb, lca, &pp->rb, lcb );
-
- if( pj->use_limits )
- {
- rb_debug_constraint_limits( &pj->rb, &pp->rb, lca, pj->limits );
- }
+ v4f plane = {0.0f,1.0f,0.0f,0.0f};
+ rb_effect_simple_bouyency( &pj->rb, plane, k_ragdoll_floatyiness,
+ k_ragdoll_floatydrag );
}
-
- v4f plane = {0.0f,1.0f,0.0f,0.0f};
- rb_effect_simple_bouyency( &pj->rb, plane, k_ragdoll_floatyiness,
- k_ragdoll_floatydrag );
}
+#endif
- /* CONSTRAINTS */
- for( int i=0; i<10; i++ )
+ /*
+ * SOLVE CONSTRAINTS
+ */
+ if( run_sim )
{
- rb_solve_contacts( rb_contact_buffer, rb_contact_count );
-
- for( int j=0; j<mdl->ragdoll_count; j++ )
+ for( int i=0; i<25; i++ )
{
- struct ragdoll_part *pj = &mdl->ragdoll[j];
- struct skeleton_bone *bj = &mdl->sk.bones[pj->bone_id];
+ rb_solve_contacts( rb_contact_buffer, rb_contact_count );
+ rb_solve_swingtwist_constraints( mdl->cone_constraints,
+ mdl->cone_constraints_count );
+ rb_solve_position_constraints( mdl->position_constraints,
+ mdl->position_constraints_count );
+ }
- if( (pj->parent != 0xffffffff) && pj->use_limits )
- {
- struct ragdoll_part *pp = &mdl->ragdoll[pj->parent];
- struct skeleton_bone *bp = &mdl->sk.bones[pp->bone_id];
+ for( int i=0; i<mdl->ragdoll_count; i++ )
+ rb_iter( &mdl->ragdoll[i].rb );
- v3f lca, lcb;
- v3_negate( pj->offset, lca );
- v3_add( bp->co, pp->offset, lcb );
- v3_sub( bj->co, lcb, lcb );
+ for( int i=0; i<mdl->ragdoll_count; i++ )
+ rb_update_transform( &mdl->ragdoll[i].rb );
- rb_constraint_position( &pj->rb, lca, &pp->rb, lcb );
+ rb_correct_swingtwist_constraints( mdl->cone_constraints,
+ mdl->cone_constraints_count, 0.25f );
- rb_constraint_limits( &pj->rb, lca, &pp->rb, lcb, pj->limits );
- }
- }
+ rb_correct_position_constraints( mdl->position_constraints,
+ mdl->position_constraints_count, 0.5f );
}
- /* INTEGRATION */
- for( int i=0; i<mdl->ragdoll_count; i++ )
- rb_iter( &mdl->ragdoll[i].rb );
-
- /* SHOES */
- for( int i=0; i<mdl->ragdoll_count; i++ )
- rb_update_transform( &mdl->ragdoll[i].rb );
}
#endif /* PLAYER_RAGDOLL_H */
#include "common.h"
#include "bvh.h"
#include "scene.h"
-#include "distq.h"
#include <math.h>
VG_STATIC const float
k_rb_rate = (1.0/VG_TIMESTEP_FIXED),
k_rb_delta = (1.0/k_rb_rate),
- k_friction = 0.6f,
- k_damp_linear = 0.05f, /* scale velocity 1/(1+x) */
+ k_friction = 0.4f,
+ k_damp_linear = 0.1f, /* scale velocity 1/(1+x) */
k_damp_angular = 0.1f, /* scale angular 1/(1+x) */
+ k_penetration_slop = 0.01f,
+ k_inertia_scale = 8.0f,
+ k_phys_baumgarte = 0.2f;
+
+VG_STATIC float
k_limit_bias = 0.02f,
- k_joint_bias = 0.08f, /* positional joints */
k_joint_correction = 0.01f,
- k_penetration_slop = 0.01f,
- k_inertia_scale = 4.0f;
+ k_joint_impulse = 1.0f,
+ k_joint_bias = 0.08f; /* positional joints */
+
+VG_STATIC void rb_register_cvar(void)
+{
+ vg_convar_push( (struct vg_convar){
+ .name = "k_limit_bias", .data = &k_limit_bias,
+ .data_type = k_convar_dtype_f32, .opt_f32 = {.clamp = 0}, .persistent = 1
+ });
+
+ vg_convar_push( (struct vg_convar){
+ .name = "k_joint_bias", .data = &k_joint_bias,
+ .data_type = k_convar_dtype_f32, .opt_f32 = {.clamp = 0}, .persistent = 1
+ });
+
+ vg_convar_push( (struct vg_convar){
+ .name = "k_joint_correction", .data = &k_joint_correction,
+ .data_type = k_convar_dtype_f32, .opt_f32 = {.clamp = 0}, .persistent = 1
+ });
+
+ vg_convar_push( (struct vg_convar){
+ .name = "k_joint_impulse", .data = &k_joint_impulse,
+ .data_type = k_convar_dtype_f32, .opt_f32 = {.clamp = 0}, .persistent = 1
+ });
+}
/*
* -----------------------------------------------------------------------------
rb_contact_buffer[256];
VG_STATIC int rb_contact_count = 0;
+typedef struct rb_constr_pos rb_constr_pos;
+typedef struct rb_constr_swingtwist rb_constr_swingtwist;
+
+struct rb_constr_pos
+{
+ rigidbody *rba, *rbb;
+ v3f lca, lcb;
+};
+
+struct rb_constr_swingtwist
+{
+ rigidbody *rba, *rbb;
+
+ v4f conevx, conevy; /* relative to rba */
+ v3f view_offset, /* relative to rba */
+ coneva, conevxb;/* relative to rbb */
+
+ int tangent_violation, axis_violation;
+ v3f axis, tangent_axis, tangent_target, axis_target;
+
+ float conet;
+ float tangent_mass, axis_mass;
+};
+
/*
* -----------------------------------------------------------------------------
* Math Utils
if( ct->type != k_contact_type_disabled )
{
v3f p1;
- v3_muladds( ct->co, ct->n, 0.1f, p1 );
- vg_line_pt3( ct->co, 0.025f, 0xff0000ff );
+ v3_muladds( ct->co, ct->n, 0.05f, p1 );
+ vg_line_pt3( ct->co, 0.0025f, 0xff0000ff );
vg_line( ct->co, p1, 0xffffffff );
}
}
h = rb->inf.capsule.height;
volume = sphere_volume( r ) + VG_PIf * r*r * (h - r*2.0f);
- v3_fill( rb->bbx[0], -rb->inf.sphere.radius );
- v3_fill( rb->bbx[1], rb->inf.sphere.radius );
+ v3_fill( rb->bbx[0], -r );
+ v3_fill( rb->bbx[1], r );
rb->bbx[0][1] = -h;
rb->bbx[1][1] = h;
}
* on the oriented object which created this pair.
*/
VG_STATIC void rb_capsule_manifold( v3f pa, v3f pb, float t, float r,
- capsule_manifold *manifold )
+ capsule_manifold *manifold )
{
v3f delta;
v3_sub( pa, pb, delta );
VG_STATIC int rb_capsule_capsule( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
{
+ if( !box_overlap( rba->bbx_world, rbb->bbx_world ) )
+ return 0;
+
float ha = rba->inf.capsule.height,
hb = rbb->inf.capsule.height,
ra = rba->inf.capsule.radius,
return count;
}
+/*
+ * Generates up to two contacts; optimised for the most stable manifold
+ */
+VG_STATIC int rb_capsule_triangle( rigidbody *rba, rigidbody *rbb,
+ v3f tri[3], rb_ct *buf )
+{
+ float h = rba->inf.capsule.height,
+ r = rba->inf.capsule.radius;
+
+ v3f pc, p0w, p1w;
+ v3_muladds( rba->co, rba->up, -h*0.5f+r, p0w );
+ v3_muladds( rba->co, rba->up, h*0.5f-r, p1w );
+
+ capsule_manifold manifold;
+ rb_capsule_manifold_init( &manifold );
+
+ v3f c0, c1;
+ closest_on_triangle_1( p0w, tri, c0 );
+ closest_on_triangle_1( p1w, tri, c1 );
+
+ v3f d0, d1, da;
+ v3_sub( c0, p0w, d0 );
+ v3_sub( c1, p1w, d1 );
+ v3_sub( p1w, p0w, da );
+
+ v3_normalize(d0);
+ v3_normalize(d1);
+ v3_normalize(da);
+
+ if( v3_dot( da, d0 ) <= 0.01f )
+ rb_capsule_manifold( p0w, c0, 0.0f, r, &manifold );
+
+ if( v3_dot( da, d1 ) >= -0.01f )
+ rb_capsule_manifold( p1w, c1, 1.0f, r, &manifold );
+
+ for( int i=0; i<3; i++ )
+ {
+ int i0 = i,
+ i1 = (i+1)%3;
+
+ v3f ca, cb;
+ float ta, tb;
+ closest_segment_segment( p0w, p1w, tri[i0], tri[i1], &ta, &tb, ca, cb );
+ rb_capsule_manifold( ca, cb, ta, r, &manifold );
+ }
+
+ v3f v0, v1, n;
+ v3_sub( tri[1], tri[0], v0 );
+ v3_sub( tri[2], tri[0], v1 );
+ v3_cross( v0, v1, n );
+ v3_normalize( n );
+
+ int count = rb_capsule_manifold_done( rba, rbb, &manifold, buf );
+ for( int i=0; i<count; i++ )
+ v3_copy( n, buf[i].n );
+
+ return count;
+}
+
+VG_STATIC int rb_capsule_scene( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+#if 0
+ float h = rba->inf.capsule.height,
+ r = rba->inf.capsule.radius,
+ g = 90.8f;
+
+ v3f p[2];
+ v3_muladds( rba->co, rba->up, -h*0.5f+r, p[0] );
+ v3_muladds( rba->co, rba->up, h*0.5f-r, p[1] );
+
+ int count = 0;
+
+
+ for( int i=0; i<2; i++ )
+ {
+ if( p[i][1] < g + r )
+ {
+ rb_ct *ct = &buf[ count ++ ];
+
+ v3_copy( p[i], ct->co );
+ ct->p = r - (p[i][1]-g);
+ ct->co[1] -= r;
+ v3_copy( (v3f){0.0f,1.0f,0.0f}, ct->n );
+ ct->rba = rba;
+ ct->rbb = rbb;
+ ct->type = k_contact_type_default;
+ }
+ }
+
+ return count;
+
+#else
+ scene *sc = rbb->inf.scene.bh_scene->user;
+
+ bh_iter it;
+ bh_iter_init( 0, &it );
+ int idx;
+
+ int count = 0;
+
+ while( bh_next( rbb->inf.scene.bh_scene, &it, rba->bbx_world, &idx ) )
+ {
+ u32 *ptri = &sc->arrindices[ idx*3 ];
+ v3f tri[3];
+
+ for( int j=0; j<3; j++ )
+ v3_copy( sc->arrvertices[ptri[j]].co, tri[j] );
+
+ buf[ count ].element_id = ptri[0];
+
+#if 0
+ vg_line( tri[0],tri[1],0x70ff6000 );
+ vg_line( tri[1],tri[2],0x70ff6000 );
+ vg_line( tri[2],tri[0],0x70ff6000 );
+#endif
+
+ int contact = rb_capsule_triangle( rba, rbb, tri, buf+count );
+ count += contact;
+
+ if( count == 16 )
+ {
+ vg_warn("Exceeding capsule_vs_scene capacity. Geometry too dense!\n");
+ return count;
+ }
+ }
+
+ return count;
+#endif
+}
+
+VG_STATIC int rb_scene_capsule( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ return rb_capsule_scene( rbb, rba, buf );
+}
+
VG_STATIC int RB_MATRIX_ERROR( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
{
+#if 0
vg_error( "Collision type is unimplemented between types %d and %d\n",
rba->type, rbb->type );
+#endif
return 0;
}
/* box */ /* Sphere */ /* Capsule */ /* Mesh */
{ RB_MATRIX_ERROR, rb_box_sphere, rb_box_capsule, rb_box_scene },
{ rb_sphere_box, rb_sphere_sphere, rb_sphere_capsule, rb_sphere_scene },
- { rb_capsule_box, rb_capsule_sphere, rb_capsule_capsule, RB_MATRIX_ERROR },
- { rb_scene_box, RB_MATRIX_ERROR, RB_MATRIX_ERROR, RB_MATRIX_ERROR }
+ { rb_capsule_box, rb_capsule_sphere, rb_capsule_capsule, rb_capsule_scene },
+ { rb_scene_box, RB_MATRIX_ERROR, rb_scene_capsule, RB_MATRIX_ERROR }
};
VG_STATIC int rb_collide( rigidbody *rba, rigidbody *rbb )
}
/*
- * Creates relative contact velocity vector, and offsets between each body
+ * Creates relative contact velocity vector
*/
-VG_STATIC void rb_rcv( rb_ct *ct, v3f rv, v3f da, v3f db )
+VG_STATIC void rb_rcv( rigidbody *rba, rigidbody *rbb, v3f ra, v3f rb, v3f rv )
{
- rigidbody *rba = ct->rba,
- *rbb = ct->rbb;
-
- v3_sub( ct->co, rba->co, da );
- v3_sub( ct->co, rbb->co, db );
-
v3f rva, rvb;
- v3_cross( rba->w, da, rva );
- v3_add( rba->v, rva, rva );
- v3_cross( rbb->w, db, rvb );
- v3_add( rbb->v, rvb, rvb );
+ v3_cross( rba->w, ra, rva );
+ v3_add( rba->v, rva, rva );
+ v3_cross( rbb->w, rb, rvb );
+ v3_add( rbb->v, rvb, rvb );
v3_sub( rva, rvb, rv );
}
{
struct contact *ct = &buf[i];
- rigidbody *rb = ct->rba;
-
- v3f rv, da, db;
- rb_rcv( ct, rv, da, db );
+ v3f rv, ra, rb;
+ v3_sub( ct->co, ct->rba->co, ra );
+ v3_sub( ct->co, ct->rbb->co, rb );
+ rb_rcv( ct->rba, ct->rbb, ra, rb, rv );
/* Friction */
for( int j=0; j<2; j++ )
v3f impulse;
v3_muls( ct->t[j], lambda, impulse );
- rb_linear_impulse( ct->rba, da, impulse );
+ rb_linear_impulse( ct->rba, ra, impulse );
v3_muls( ct->t[j], -lambda, impulse );
- rb_linear_impulse( ct->rbb, db, impulse );
+ rb_linear_impulse( ct->rbb, rb, impulse );
}
/* Normal */
- rb_rcv( ct, rv, da, db );
+ rb_rcv( ct->rba, ct->rbb, ra, rb, rv );
float vn = v3_dot( rv, ct->n ),
lambda = ct->normal_mass * (-vn + ct->bias);
v3f impulse;
v3_muls( ct->n, lambda, impulse );
- rb_linear_impulse( ct->rba, da, impulse );
+ rb_linear_impulse( ct->rba, ra, impulse );
v3_muls( ct->n, -lambda, impulse );
- rb_linear_impulse( ct->rbb, db, impulse );
+ rb_linear_impulse( ct->rbb, rb, impulse );
}
}
* -----------------------------------------------------------------------------
*/
-VG_STATIC void draw_angle_limit( v3f c, v3f major, v3f minor,
- float amin, float amax, float measured,
- u32 colour )
+VG_STATIC void rb_debug_position_constraints( rb_constr_pos *buffer, int len )
{
- float f = 0.05f;
- v3f ay, ax;
- v3_muls( major, f, ay );
- v3_muls( minor, f, ax );
-
- for( int x=0; x<16; x++ )
+ for( int i=0; i<len; i++ )
{
- float t0 = (float)x / 16.0f,
- t1 = (float)(x+1) / 16.0f,
- a0 = vg_lerpf( amin, amax, t0 ),
- a1 = vg_lerpf( amin, amax, t1 );
+ rb_constr_pos *constr = &buffer[i];
+ rigidbody *rba = constr->rba, *rbb = constr->rbb;
+
+ v3f wca, wcb;
+ m3x3_mulv( rba->to_world, constr->lca, wca );
+ m3x3_mulv( rbb->to_world, constr->lcb, wcb );
v3f p0, p1;
- v3_muladds( c, ay, cosf(a0), p0 );
- v3_muladds( p0, ax, sinf(a0), p0 );
- v3_muladds( c, ay, cosf(a1), p1 );
- v3_muladds( p1, ax, sinf(a1), p1 );
+ v3_add( wca, rba->co, p0 );
+ v3_add( wcb, rbb->co, p1 );
+ vg_line_pt3( p0, 0.0025f, 0xff000000 );
+ vg_line_pt3( p1, 0.0025f, 0xffffffff );
+ vg_line2( p0, p1, 0xff000000, 0xffffffff );
+ }
+}
+
+VG_STATIC void rb_presolve_swingtwist_constraints( rb_constr_swingtwist *buf,
+ int len )
+{
+ float size = 0.12f;
+
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_swingtwist *st = &buf[ i ];
- vg_line( p0, p1, colour );
+ v3f vx, vy, va, vxb, axis, center;
- if( x == 0 )
- vg_line( c, p0, colour );
- if( x == 15 )
- vg_line( c, p1, colour );
- }
+ m3x3_mulv( st->rba->to_world, st->conevx, vx );
+ m3x3_mulv( st->rbb->to_world, st->conevxb, vxb );
+ m3x3_mulv( st->rba->to_world, st->conevy, vy );
+ m3x3_mulv( st->rbb->to_world, st->coneva, va );
+ m4x3_mulv( st->rba->to_world, st->view_offset, center );
+ v3_cross( vy, vx, axis );
+
+ /* Constraint violated ? */
+ float fx = v3_dot( vx, va ), /* projection world */
+ fy = v3_dot( vy, va ),
+ fn = v3_dot( va, axis ),
+
+ rx = st->conevx[3], /* elipse radii */
+ ry = st->conevy[3],
+
+ lx = fx/rx, /* projection local (fn==lz) */
+ ly = fy/ry;
+
+ st->tangent_violation = ((lx*lx + ly*ly) > fn*fn) || (fn <= 0.0f);
+ if( st->tangent_violation )
+ {
+ /* Calculate a good position and the axis to solve on */
+ v2f closest, tangent,
+ p = { fx/fabsf(fn), fy/fabsf(fn) };
+
+ closest_point_elipse( p, (v2f){rx,ry}, closest );
+ tangent[0] = -closest[1] / (ry*ry);
+ tangent[1] = closest[0] / (rx*rx);
+ v2_normalize( tangent );
+
+ v3f v0, v1;
+ v3_muladds( axis, vx, closest[0], v0 );
+ v3_muladds( v0, vy, closest[1], v0 );
+ v3_normalize( v0 );
+
+ v3_muls( vx, tangent[0], v1 );
+ v3_muladds( v1, vy, tangent[1], v1 );
+
+ v3_copy( v0, st->tangent_target );
+ v3_copy( v1, st->tangent_axis );
+
+ /* calculate mass */
+ v3f aIw, bIw;
+ m3x3_mulv( st->rba->iIw, st->tangent_axis, aIw );
+ m3x3_mulv( st->rbb->iIw, st->tangent_axis, bIw );
+ st->tangent_mass = 1.0f / (v3_dot( st->tangent_axis, aIw ) +
+ v3_dot( st->tangent_axis, bIw ));
+
+ float angle = v3_dot( va, st->tangent_target );
+ }
+
+ v3f refaxis;
+ v3_cross( vy, va, refaxis ); /* our default rotation */
+ v3_normalize( refaxis );
+
+ float angle = v3_dot( refaxis, vxb );
+ st->axis_violation = fabsf(angle) < st->conet;
- v3f p2;
- v3_muladds( c, ay, cosf(measured)*1.2f, p2 );
- v3_muladds( p2, ax, sinf(measured)*1.2f, p2 );
- vg_line( c, p2, colour );
+ if( st->axis_violation )
+ {
+ v3f dir_test;
+ v3_cross( refaxis, vxb, dir_test );
+
+ if( v3_dot(dir_test, va) < 0.0f )
+ st->axis_violation = -st->axis_violation;
+
+ float newang = (float)st->axis_violation * acosf(st->conet-0.0001f);
+
+ v3f refaxis_up;
+ v3_cross( va, refaxis, refaxis_up );
+ v3_muls( refaxis_up, sinf(newang), st->axis_target );
+ v3_muladds( st->axis_target, refaxis, -cosf(newang), st->axis_target );
+
+ /* calculate mass */
+ v3_copy( va, st->axis );
+ v3f aIw, bIw;
+ m3x3_mulv( st->rba->iIw, st->axis, aIw );
+ m3x3_mulv( st->rbb->iIw, st->axis, bIw );
+ st->axis_mass = 1.0f / (v3_dot( st->axis, aIw ) +
+ v3_dot( st->axis, bIw ));
+ }
+ }
}
-VG_STATIC void rb_debug_constraint_limits( rigidbody *ra, rigidbody *rb, v3f lca,
- v3f limits[2] )
+VG_STATIC void rb_debug_swingtwist_constraints( rb_constr_swingtwist *buf,
+ int len )
{
- v3f ax, ay, az, bx, by, bz;
- m3x3_mulv( ra->to_world, (v3f){1.0f,0.0f,0.0f}, ax );
- m3x3_mulv( ra->to_world, (v3f){0.0f,1.0f,0.0f}, ay );
- m3x3_mulv( ra->to_world, (v3f){0.0f,0.0f,1.0f}, az );
- m3x3_mulv( rb->to_world, (v3f){1.0f,0.0f,0.0f}, bx );
- m3x3_mulv( rb->to_world, (v3f){0.0f,1.0f,0.0f}, by );
- m3x3_mulv( rb->to_world, (v3f){0.0f,0.0f,1.0f}, bz );
+ float size = 0.12f;
+
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_swingtwist *st = &buf[ i ];
+
+ v3f vx, vxb, vy, va, axis, center;
+
+ m3x3_mulv( st->rba->to_world, st->conevx, vx );
+ m3x3_mulv( st->rbb->to_world, st->conevxb, vxb );
+ m3x3_mulv( st->rba->to_world, st->conevy, vy );
+ m3x3_mulv( st->rbb->to_world, st->coneva, va );
+ m4x3_mulv( st->rba->to_world, st->view_offset, center );
+ v3_cross( vy, vx, axis );
+
+ float rx = st->conevx[3], /* elipse radii */
+ ry = st->conevy[3];
+
+ v3f p0, p1;
+ v3_muladds( center, va, size, p1 );
+ vg_line( center, p1, 0xffffffff );
+ vg_line_pt3( p1, 0.00025f, 0xffffffff );
+
+ if( st->tangent_violation )
+ {
+ v3_muladds( center, st->tangent_target, size, p0 );
+
+ vg_line( center, p0, 0xff00ff00 );
+ vg_line_pt3( p0, 0.00025f, 0xff00ff00 );
+ vg_line( p1, p0, 0xff000000 );
+ }
+
+ for( int x=0; x<32; x++ )
+ {
+ float t0 = ((float)x * (1.0f/32.0f)) * VG_TAUf,
+ t1 = (((float)x+1.0f) * (1.0f/32.0f)) * VG_TAUf,
+ c0 = cosf( t0 ),
+ s0 = sinf( t0 ),
+ c1 = cosf( t1 ),
+ s1 = sinf( t1 );
+
+ v3f v0, v1;
+ v3_muladds( axis, vx, c0*rx, v0 );
+ v3_muladds( v0, vy, s0*ry, v0 );
+ v3_muladds( axis, vx, c1*rx, v1 );
+ v3_muladds( v1, vy, s1*ry, v1 );
+
+ v3_normalize( v0 );
+ v3_normalize( v1 );
+
+ v3_muladds( center, v0, size, p0 );
+ v3_muladds( center, v1, size, p1 );
+
+ u32 col0r = fabsf(c0) * 255.0f,
+ col0g = fabsf(s0) * 255.0f,
+ col1r = fabsf(c1) * 255.0f,
+ col1g = fabsf(s1) * 255.0f,
+ col = st->tangent_violation? 0xff0000ff: 0xff000000,
+ col0 = col | (col0r<<16) | (col0g << 8),
+ col1 = col | (col1r<<16) | (col1g << 8);
+
+ vg_line2( center, p0, VG__NONE, col0 );
+ vg_line2( p0, p1, col0, col1 );
+ }
- v2f px, py, pz;
- px[0] = v3_dot( ay, by );
- px[1] = v3_dot( az, by );
+ /* Draw twist */
+ v3_muladds( center, va, size, p0 );
+ v3_muladds( p0, vxb, size, p1 );
- py[0] = v3_dot( az, bz );
- py[1] = v3_dot( ax, bz );
+ vg_line( p0, p1, 0xff0000ff );
- pz[0] = v3_dot( ax, bx );
- pz[1] = v3_dot( ay, bx );
+ if( st->axis_violation )
+ {
+ v3_muladds( p0, st->axis_target, size*1.25f, p1 );
+ vg_line( p0, p1, 0xffffff00 );
+ vg_line_pt3( p1, 0.0025f, 0xffffff80 );
+ }
- float r0 = atan2f( px[1], px[0] ),
- r1 = atan2f( py[1], py[0] ),
- r2 = atan2f( pz[1], pz[0] );
+ v3f refaxis;
+ v3_cross( vy, va, refaxis ); /* our default rotation */
+ v3_normalize( refaxis );
+ v3f refaxis_up;
+ v3_cross( va, refaxis, refaxis_up );
+ float newang = acosf(st->conet-0.0001f);
- v3f c;
- m4x3_mulv( ra->to_world, lca, c );
- draw_angle_limit( c, ay, az, limits[0][0], limits[1][0], r0, 0xff0000ff );
- draw_angle_limit( c, az, ax, limits[0][1], limits[1][1], r1, 0xff00ff00 );
- draw_angle_limit( c, ax, ay, limits[0][2], limits[1][2], r2, 0xffff0000 );
+ v3_muladds( p0, refaxis_up, sinf(newang)*size, p1 );
+ v3_muladds( p1, refaxis, -cosf(newang)*size, p1 );
+ vg_line( p0, p1, 0xff000000 );
+
+ v3_muladds( p0, refaxis_up, sinf(-newang)*size, p1 );
+ v3_muladds( p1, refaxis, -cosf(-newang)*size, p1 );
+ vg_line( p0, p1, 0xff404040 );
+ }
}
-VG_STATIC void rb_limit_cure( rigidbody *ra, rigidbody *rb, v3f axis, float d )
+/*
+ * Solve a list of positional constraints
+ */
+VG_STATIC void rb_solve_position_constraints( rb_constr_pos *buf, int len )
{
- if( d != 0.0f )
+ for( int i=0; i<len; i++ )
{
- float avx = v3_dot( ra->w, axis ) - v3_dot( rb->w, axis );
- float joint_mass = rb->inv_mass + ra->inv_mass;
- joint_mass = 1.0f/joint_mass;
+ rb_constr_pos *constr = &buf[i];
+ rigidbody *rba = constr->rba, *rbb = constr->rbb;
- float bias = (k_limit_bias * k_rb_rate) * d,
- lambda = -(avx + bias) * joint_mass;
-
- /* Angular velocity */
v3f wa, wb;
- v3_muls( axis, lambda * ra->inv_mass, wa );
- v3_muls( axis, -lambda * rb->inv_mass, wb );
+ m3x3_mulv( rba->to_world, constr->lca, wa );
+ m3x3_mulv( rbb->to_world, constr->lcb, wb );
- v3_add( ra->w, wa, ra->w );
- v3_add( rb->w, wb, rb->w );
+ m3x3f ssra, ssrat, ssrb, ssrbt;
+
+ m3x3_skew_symetric( ssrat, wa );
+ m3x3_skew_symetric( ssrbt, wb );
+ m3x3_transpose( ssrat, ssra );
+ m3x3_transpose( ssrbt, ssrb );
+
+ v3f b, b_wa, b_wb, b_a, b_b;
+ m3x3_mulv( ssra, rba->w, b_wa );
+ m3x3_mulv( ssrb, rbb->w, b_wb );
+ v3_add( rba->v, b_wa, b );
+ v3_sub( b, rbb->v, b );
+ v3_sub( b, b_wb, b );
+ v3_muls( b, -1.0f, b );
+
+ m3x3f invMa, invMb;
+ m3x3_diagonal( invMa, rba->inv_mass );
+ m3x3_diagonal( invMb, rbb->inv_mass );
+
+ m3x3f ia, ib;
+ m3x3_mul( ssra, rba->iIw, ia );
+ m3x3_mul( ia, ssrat, ia );
+ m3x3_mul( ssrb, rbb->iIw, ib );
+ m3x3_mul( ib, ssrbt, ib );
+
+ m3x3f cma, cmb;
+ m3x3_add( invMa, ia, cma );
+ m3x3_add( invMb, ib, cmb );
+
+ m3x3f A;
+ m3x3_add( cma, cmb, A );
+
+ /* Solve Ax = b ( A^-1*b = x ) */
+ v3f impulse;
+ m3x3f invA;
+ m3x3_inv( A, invA );
+ m3x3_mulv( invA, b, impulse );
+
+ v3f delta_va, delta_wa, delta_vb, delta_wb;
+ m3x3f iwa, iwb;
+ m3x3_mul( rba->iIw, ssrat, iwa );
+ m3x3_mul( rbb->iIw, ssrbt, iwb );
+
+ m3x3_mulv( invMa, impulse, delta_va );
+ m3x3_mulv( invMb, impulse, delta_vb );
+ m3x3_mulv( iwa, impulse, delta_wa );
+ m3x3_mulv( iwb, impulse, delta_wb );
+
+ v3_add( rba->v, delta_va, rba->v );
+ v3_add( rba->w, delta_wa, rba->w );
+ v3_sub( rbb->v, delta_vb, rbb->v );
+ v3_sub( rbb->w, delta_wb, rbb->w );
}
}
-VG_STATIC void rb_constraint_limits( rigidbody *ra, v3f lca,
- rigidbody *rb, v3f lcb, v3f limits[2] )
+VG_STATIC void rb_solve_swingtwist_constraints( rb_constr_swingtwist *buf,
+ int len )
{
- v3f ax, ay, az, bx, by, bz;
- m3x3_mulv( ra->to_world, (v3f){1.0f,0.0f,0.0f}, ax );
- m3x3_mulv( ra->to_world, (v3f){0.0f,1.0f,0.0f}, ay );
- m3x3_mulv( ra->to_world, (v3f){0.0f,0.0f,1.0f}, az );
- m3x3_mulv( rb->to_world, (v3f){1.0f,0.0f,0.0f}, bx );
- m3x3_mulv( rb->to_world, (v3f){0.0f,1.0f,0.0f}, by );
- m3x3_mulv( rb->to_world, (v3f){0.0f,0.0f,1.0f}, bz );
+ float size = 0.12f;
+
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_swingtwist *st = &buf[ i ];
+
+ if( !st->axis_violation )
+ continue;
+
+ float rv = v3_dot( st->axis, st->rbb->w ) -
+ v3_dot( st->axis, st->rba->w );
+
+ if( rv * (float)st->axis_violation > 0.0f )
+ continue;
+
+ v3f impulse, wa, wb;
+ v3_muls( st->axis, rv*st->axis_mass, impulse );
+ m3x3_mulv( st->rba->iIw, impulse, wa );
+ v3_add( st->rba->w, wa, st->rba->w );
- v2f px, py, pz;
- px[0] = v3_dot( ay, by );
- px[1] = v3_dot( az, by );
+ v3_muls( impulse, -1.0f, impulse );
+ m3x3_mulv( st->rbb->iIw, impulse, wb );
+ v3_add( st->rbb->w, wb, st->rbb->w );
- py[0] = v3_dot( az, bz );
- py[1] = v3_dot( ax, bz );
+ float rv2 = v3_dot( st->axis, st->rbb->w ) -
+ v3_dot( st->axis, st->rba->w );
+ }
- pz[0] = v3_dot( ax, bx );
- pz[1] = v3_dot( ay, bx );
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_swingtwist *st = &buf[ i ];
- float r0 = atan2f( px[1], px[0] ),
- r1 = atan2f( py[1], py[0] ),
- r2 = atan2f( pz[1], pz[0] );
+ if( !st->tangent_violation )
+ continue;
- /* calculate angle deltas */
- float dx = 0.0f, dy = 0.0f, dz = 0.0f;
+ float rv = v3_dot( st->tangent_axis, st->rbb->w ) -
+ v3_dot( st->tangent_axis, st->rba->w );
- if( r0 < limits[0][0] ) dx = limits[0][0] - r0;
- if( r0 > limits[1][0] ) dx = limits[1][0] - r0;
- if( r1 < limits[0][1] ) dy = limits[0][1] - r1;
- if( r1 > limits[1][1] ) dy = limits[1][1] - r1;
- if( r2 < limits[0][2] ) dz = limits[0][2] - r2;
- if( r2 > limits[1][2] ) dz = limits[1][2] - r2;
+ if( rv > 0.0f )
+ continue;
+
+ v3f impulse, wa, wb;
+ v3_muls( st->tangent_axis, rv*st->tangent_mass, impulse );
+ m3x3_mulv( st->rba->iIw, impulse, wa );
+ v3_add( st->rba->w, wa, st->rba->w );
- v3f wca, wcb;
- m3x3_mulv( ra->to_world, lca, wca );
- m3x3_mulv( rb->to_world, lcb, wcb );
+ v3_muls( impulse, -1.0f, impulse );
+ m3x3_mulv( st->rbb->iIw, impulse, wb );
+ v3_add( st->rbb->w, wb, st->rbb->w );
- rb_limit_cure( ra, rb, ax, dx );
- rb_limit_cure( ra, rb, ay, dy );
- rb_limit_cure( ra, rb, az, dz );
+ float rv2 = v3_dot( st->tangent_axis, st->rbb->w ) -
+ v3_dot( st->tangent_axis, st->rba->w );
+ }
}
-VG_STATIC void rb_debug_constraint_position( rigidbody *ra, v3f lca,
- rigidbody *rb, v3f lcb )
+VG_STATIC void rb_solve_constr_angle( rigidbody *rba, rigidbody *rbb,
+ v3f ra, v3f rb )
{
- v3f wca, wcb;
- m3x3_mulv( ra->to_world, lca, wca );
- m3x3_mulv( rb->to_world, lcb, wcb );
+ m3x3f ssra, ssrb, ssrat, ssrbt;
+ m3x3f cma, cmb;
+
+ m3x3_skew_symetric( ssrat, ra );
+ m3x3_skew_symetric( ssrbt, rb );
+ m3x3_transpose( ssrat, ssra );
+ m3x3_transpose( ssrbt, ssrb );
+
+ m3x3_mul( ssra, rba->iIw, cma );
+ m3x3_mul( cma, ssrat, cma );
+ m3x3_mul( ssrb, rbb->iIw, cmb );
+ m3x3_mul( cmb, ssrbt, cmb );
+
+ m3x3f A, invA;
+ m3x3_add( cma, cmb, A );
+ m3x3_inv( A, invA );
+
+ v3f b_wa, b_wb, b;
+ m3x3_mulv( ssra, rba->w, b_wa );
+ m3x3_mulv( ssrb, rbb->w, b_wb );
+ v3_add( b_wa, b_wb, b );
+ v3_negate( b, b );
+
+ v3f impulse;
+ m3x3_mulv( invA, b, impulse );
+
+ v3f delta_wa, delta_wb;
+ m3x3f iwa, iwb;
+ m3x3_mul( rba->iIw, ssrat, iwa );
+ m3x3_mul( rbb->iIw, ssrbt, iwb );
+ m3x3_mulv( iwa, impulse, delta_wa );
+ m3x3_mulv( iwb, impulse, delta_wb );
+ v3_add( rba->w, delta_wa, rba->w );
+ v3_sub( rbb->w, delta_wb, rbb->w );
+}
- v3f p0, p1;
- v3_add( wca, ra->co, p0 );
- v3_add( wcb, rb->co, p1 );
- vg_line_pt3( p0, 0.005f, 0xffffff00 );
- vg_line_pt3( p1, 0.005f, 0xffffff00 );
- vg_line( p0, p1, 0xffffff00 );
+/*
+ * Correct position constraint drift errors
+ * [ 0.0 <= amt <= 1.0 ]: the correction amount
+ */
+VG_STATIC void rb_correct_position_constraints( rb_constr_pos *buf, int len,
+ float amt )
+{
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_pos *constr = &buf[i];
+ rigidbody *rba = constr->rba, *rbb = constr->rbb;
+
+ v3f p0, p1, d;
+ m3x3_mulv( rba->to_world, constr->lca, p0 );
+ m3x3_mulv( rbb->to_world, constr->lcb, p1 );
+ v3_add( rba->co, p0, p0 );
+ v3_add( rbb->co, p1, p1 );
+ v3_sub( p1, p0, d );
+
+ v3_muladds( rbb->co, d, -1.0f * amt, rbb->co );
+ rb_update_transform( rbb );
+ }
}
-VG_STATIC void rb_constraint_position( rigidbody *ra, v3f lca,
- rigidbody *rb, v3f lcb )
+VG_STATIC void rb_correct_swingtwist_constraints( rb_constr_swingtwist *buf,
+ int len, float amt )
{
- /* C = (COa + Ra*LCa) - (COb + Rb*LCb) = 0 */
- v3f wca, wcb;
- m3x3_mulv( ra->to_world, lca, wca );
- m3x3_mulv( rb->to_world, lcb, wcb );
+ for( int i=0; i<len; i++ )
+ {
+ rb_constr_swingtwist *st = &buf[i];
- v3f rcv;
- v3_sub( ra->v, rb->v, rcv );
+ if( !st->tangent_violation )
+ continue;
- v3f rcv_Ra, rcv_Rb;
- v3_cross( ra->w, wca, rcv_Ra );
- v3_cross( rb->w, wcb, rcv_Rb );
- v3_add( rcv_Ra, rcv, rcv );
- v3_sub( rcv, rcv_Rb, rcv );
+ v3f va;
+ m3x3_mulv( st->rbb->to_world, st->coneva, va );
- v3f delta;
- v3f p0, p1;
- v3_add( wca, ra->co, p0 );
- v3_add( wcb, rb->co, p1 );
- v3_sub( p1, p0, delta );
+ float angle = v3_dot( va, st->tangent_target );
- float dist2 = v3_length2( delta );
+ if( fabsf(angle) < 0.9999f )
+ {
+ v3f axis;
+ v3_cross( va, st->tangent_target, axis );
- if( dist2 > 0.00001f )
+ v4f correction;
+ q_axis_angle( correction, axis, acosf(angle) * amt );
+ q_mul( correction, st->rbb->q, st->rbb->q );
+ rb_update_transform( st->rbb );
+ }
+ }
+
+ for( int i=0; i<len; i++ )
{
- float dist = sqrtf(dist2);
- v3_muls( delta, 1.0f/dist, delta );
+ rb_constr_swingtwist *st = &buf[i];
- float joint_mass = rb->inv_mass + ra->inv_mass;
+ if( !st->axis_violation )
+ continue;
- v3f raCn, rbCn, raCt, rbCt;
- v3_cross( wca, delta, raCn );
- v3_cross( wcb, delta, rbCn );
-
- /* orient inverse inertia tensors */
- v3f raCnI, rbCnI;
- m3x3_mulv( ra->iIw, raCn, raCnI );
- m3x3_mulv( rb->iIw, rbCn, rbCnI );
- joint_mass += v3_dot( raCn, raCnI );
- joint_mass += v3_dot( rbCn, rbCnI );
- joint_mass = 1.0f/joint_mass;
+ v3f vxb;
+ m3x3_mulv( st->rbb->to_world, st->conevxb, vxb );
- float vd = v3_dot( rcv, delta ),
- bias = -(k_joint_bias * k_rb_rate) * dist,
- lambda = -(vd + bias) * joint_mass;
+ float angle = v3_dot( vxb, st->axis_target );
- v3f impulse;
- v3_muls( delta, lambda, impulse );
- rb_linear_impulse( ra, wca, impulse );
- v3_muls( delta, -lambda, impulse );
- rb_linear_impulse( rb, wcb, impulse );
-
- /* 'fake' snap */
- v3_muladds( ra->co, delta, dist * k_joint_correction, ra->co );
- v3_muladds( rb->co, delta, -dist * k_joint_correction, rb->co );
+ if( fabsf(angle) < 0.9999f )
+ {
+ v3f axis;
+ v3_cross( vxb, st->axis_target, axis );
+
+ v4f correction;
+ q_axis_angle( correction, axis, acosf(angle) * amt );
+ q_mul( correction, st->rbb->q, st->rbb->q );
+ rb_update_transform( st->rbb );
+ }
}
}
+
/*
* Effectors
*/
VG_STATIC void rb_effect_simple_bouyency( rigidbody *ra, v4f plane,
- float amt, float drag )
+ float amt, float drag )
{
/* float */
float depth = v3_dot( plane, ra->co ) - plane[3],
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff