+ float v = d1 / (d1-d3);
+ v3_muladds( tri[0], ab, v, dest );
+ return;
+ }
+
+ /* Region outside C */
+ v3f cp;
+ float d5, d6;
+ v3_sub( p, tri[2], cp );
+ d5 = v3_dot(ab, cp);
+ d6 = v3_dot(ac, cp);
+
+ if( d6 >= 0.0f && d5 <= d6 )
+ {
+ v3_copy( tri[2], dest );
+ return;
+ }
+
+ /* Region of AC */
+ float vb = d5*d2 - d1*d6;
+ if( vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f )
+ {
+ float w = d2 / (d2-d6);
+ v3_muladds( tri[0], ac, w, dest );
+ return;
+ }
+
+ /* Region of BC */
+ float va = d3*d6 - d5*d4;
+ if( va <= 0.0f && (d4-d3) >= 0.0f && (d5-d6) >= 0.0f )
+ {
+ float w = (d4-d3) / ((d4-d3) + (d5-d6));
+ v3f bc;
+ v3_sub( tri[2], tri[1], bc );
+ v3_muladds( tri[1], bc, w, dest );
+ return;
+ }
+
+ /* P inside region, Q via barycentric coordinates uvw */
+ float d = 1.0f/(va+vb+vc),
+ v = vb*d,
+ w = vc*d;
+
+ v3_muladds( tri[0], ab, v, dest );
+ v3_muladds( dest, ac, w, dest );
+}
+
+/*
+ * -----------------------------------------------------------------------------
+ * Boolean shape overlap functions
+ * -----------------------------------------------------------------------------
+ */
+
+/*
+ * Project AABB, and triangle interval onto axis to check if they overlap
+ */
+VG_STATIC int rb_box_triangle_interval( v3f extent, v3f axis, v3f tri[3] )
+{
+ float
+
+ r = extent[0] * fabsf(axis[0]) +
+ extent[1] * fabsf(axis[1]) +
+ extent[2] * fabsf(axis[2]),
+
+ p0 = v3_dot( axis, tri[0] ),
+ p1 = v3_dot( axis, tri[1] ),
+ p2 = v3_dot( axis, tri[2] ),
+
+ e = vg_maxf(-vg_maxf(p0,vg_maxf(p1,p2)), vg_minf(p0,vg_minf(p1,p2)));
+
+ if( e > r ) return 0;
+ else return 1;
+}
+
+/*
+ * Seperating axis test box vs triangle
+ */
+VG_STATIC int rb_box_triangle_sat( rigidbody *rba, v3f tri_src[3] )
+{
+ v3f tri[3];
+
+ v3f extent, c;
+ v3_sub( rba->bbx[1], rba->bbx[0], extent );
+ v3_muls( extent, 0.5f, extent );
+ v3_add( rba->bbx[0], extent, c );
+
+ for( int i=0; i<3; i++ )
+ {
+ m4x3_mulv( rba->to_local, tri_src[i], tri[i] );
+ v3_sub( tri[i], c, tri[i] );
+ }
+
+ /* u0, u1, u2 */
+ if(!rb_box_triangle_interval( extent, (v3f){1.0f,0.0f,0.0f}, tri )) return 0;
+ if(!rb_box_triangle_interval( extent, (v3f){0.0f,1.0f,0.0f}, tri )) return 0;
+ if(!rb_box_triangle_interval( extent, (v3f){0.0f,0.0f,1.0f}, tri )) return 0;
+
+ v3f v0,v1,v2,n, e0,e1,e2;
+ v3_sub( tri[1], tri[0], v0 );
+ v3_sub( tri[2], tri[0], v1 );
+ v3_sub( tri[2], tri[1], v2 );
+ v3_normalize( v0 );
+ v3_normalize( v1 );
+ v3_normalize( v2 );
+ v3_cross( v0, v1, n );
+ v3_cross( v0, n, e0 );
+ v3_cross( n, v1, e1 );
+ v3_cross( v2, n, e2 );
+
+ /* normal */
+ if(!rb_box_triangle_interval( extent, n, tri )) return 0;
+
+ v3f axis[9];
+ v3_cross( e0, (v3f){1.0f,0.0f,0.0f}, axis[0] );
+ v3_cross( e0, (v3f){0.0f,1.0f,0.0f}, axis[1] );
+ v3_cross( e0, (v3f){0.0f,0.0f,1.0f}, axis[2] );
+ v3_cross( e1, (v3f){1.0f,0.0f,0.0f}, axis[3] );
+ v3_cross( e1, (v3f){0.0f,1.0f,0.0f}, axis[4] );
+ v3_cross( e1, (v3f){0.0f,0.0f,1.0f}, axis[5] );
+ v3_cross( e2, (v3f){1.0f,0.0f,0.0f}, axis[6] );
+ v3_cross( e2, (v3f){0.0f,1.0f,0.0f}, axis[7] );
+ v3_cross( e2, (v3f){0.0f,0.0f,1.0f}, axis[8] );
+
+ for( int i=0; i<9; i++ )
+ if(!rb_box_triangle_interval( extent, axis[i], tri )) return 0;
+
+ return 1;
+}
+
+/*
+ * -----------------------------------------------------------------------------
+ * Collision matrix
+ * -----------------------------------------------------------------------------
+ */
+
+/*
+ * Contact generators
+ *
+ * These do not automatically allocate contacts, an appropriately sized
+ * buffer must be supplied. The function returns the size of the manifold
+ * which was generated.
+ *
+ * The values set on the contacts are: n, co, p, rba, rbb
+ */
+
+/*
+ * By collecting the minimum(time) and maximum(time) pairs of points, we
+ * build a reduced and stable exact manifold.
+ *
+ * tx: time at point
+ * rx: minimum distance of these points
+ * dx: the delta between the two points
+ *
+ * pairs will only ammend these if they are creating a collision
+ */
+typedef struct capsule_manifold capsule_manifold;
+struct capsule_manifold
+{
+ float t0, t1;
+ float r0, r1;
+ v3f d0, d1;
+};
+
+/*
+ * Expand a line manifold with a new pair. t value is the time along segment
+ * 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 )
+{
+ v3f delta;
+ v3_sub( pa, pb, delta );
+
+ if( v3_length2(delta) < r*r )
+ {
+ if( t < manifold->t0 )
+ {
+ v3_copy( delta, manifold->d0 );
+ manifold->t0 = t;
+ manifold->r0 = r;
+ }
+
+ if( t > manifold->t1 )
+ {
+ v3_copy( delta, manifold->d1 );
+ manifold->t1 = t;
+ manifold->r1 = r;
+ }
+ }
+}
+
+VG_STATIC void rb_capsule_manifold_init( capsule_manifold *manifold )
+{
+ manifold->t0 = INFINITY;
+ manifold->t1 = -INFINITY;
+}
+
+VG_STATIC int rb_capsule_manifold_done( rigidbody *rba, rigidbody *rbb,
+ capsule_manifold *manifold, rb_ct *buf )
+{
+ float h = rba->inf.capsule.height,
+ ra = rba->inf.capsule.radius;
+
+ v3f p0, p1;
+ v3_muladds( rba->co, rba->up, -h*0.5f+ra, p0 );
+ v3_muladds( rba->co, rba->up, h*0.5f-ra, p1 );
+
+ int count = 0;
+ if( manifold->t0 <= 1.0f )
+ {
+ rb_ct *ct = buf;
+
+ v3f pa;
+ v3_muls( p0, 1.0f-manifold->t0, pa );
+ v3_muladds( pa, p1, manifold->t0, pa );
+
+ float d = v3_length( manifold->d0 );
+ v3_muls( manifold->d0, 1.0f/d, ct->n );
+ v3_muladds( pa, ct->n, -ra, ct->co );
+
+ ct->p = manifold->r0 - d;
+ ct->rba = rba;
+ ct->rbb = rbb;
+
+ count ++;
+ }
+
+ if( (manifold->t1 >= 0.0f) && (manifold->t0 != manifold->t1) )
+ {
+ rb_ct *ct = buf+count;
+
+ v3f pa;
+ v3_muls( p0, 1.0f-manifold->t1, pa );
+ v3_muladds( pa, p1, manifold->t1, pa );
+
+ float d = v3_length( manifold->d1 );
+ v3_muls( manifold->d1, 1.0f/d, ct->n );
+ v3_muladds( pa, ct->n, -ra, ct->co );
+
+ ct->p = manifold->r1 - d;
+ ct->rba = rba;
+ ct->rbb = rbb;
+
+ count ++;
+ }
+
+ /*
+ * Debugging
+ */
+
+ if( count == 2 )
+ vg_line( buf[0].co, buf[1].co, 0xff0000ff );
+
+ return count;
+}
+
+VG_STATIC int rb_capsule_sphere( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ float h = rba->inf.capsule.height,
+ ra = rba->inf.capsule.radius,
+ rb = rbb->inf.sphere.radius;
+
+ v3f p0, p1;
+ v3_muladds( rba->co, rba->up, -h*0.5f+ra, p0 );
+ v3_muladds( rba->co, rba->up, h*0.5f-ra, p1 );
+
+ v3f c, delta;
+ closest_point_segment( p0, p1, rbb->co, c );
+ v3_sub( c, rbb->co, delta );
+
+ float d2 = v3_length2(delta),
+ r = ra + rb;
+
+ if( d2 < r*r )
+ {
+ float d = sqrtf(d2);
+
+ rb_ct *ct = buf;
+ v3_muls( delta, 1.0f/d, ct->n );
+ ct->p = r-d;
+
+ v3f p0, p1;
+ v3_muladds( c, ct->n, -ra, p0 );
+ v3_muladds( rbb->co, ct->n, rb, p1 );
+ v3_add( p0, p1, ct->co );
+ v3_muls( ct->co, 0.5f, ct->co );
+
+ ct->rba = rba;
+ ct->rbb = rbb;
+
+ return 1;
+ }
+
+ return 0;
+}
+
+VG_STATIC int rb_capsule_capsule( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ float ha = rba->inf.capsule.height,
+ hb = rbb->inf.capsule.height,
+ ra = rba->inf.capsule.radius,
+ rb = rbb->inf.capsule.radius,
+ r = ra+rb;
+
+ v3f p0, p1, p2, p3;
+ v3_muladds( rba->co, rba->up, -ha*0.5f+ra, p0 );
+ v3_muladds( rba->co, rba->up, ha*0.5f-ra, p1 );
+ v3_muladds( rbb->co, rbb->up, -hb*0.5f+rb, p2 );
+ v3_muladds( rbb->co, rbb->up, hb*0.5f-rb, p3 );
+
+ capsule_manifold manifold;
+ rb_capsule_manifold_init( &manifold );
+
+ v3f pa, pb;
+ float ta, tb;
+ closest_segment_segment( p0, p1, p2, p3, &ta, &tb, pa, pb );
+ rb_capsule_manifold( pa, pb, ta, r, &manifold );
+
+ ta = closest_point_segment( p0, p1, p2, pa );
+ tb = closest_point_segment( p0, p1, p3, pb );
+ rb_capsule_manifold( pa, p2, ta, r, &manifold );
+ rb_capsule_manifold( pb, p3, tb, r, &manifold );
+
+ closest_point_segment( p2, p3, p0, pa );
+ closest_point_segment( p2, p3, p1, pb );
+ rb_capsule_manifold( p0, pa, 0.0f, r, &manifold );
+ rb_capsule_manifold( p1, pb, 1.0f, r, &manifold );
+
+ return rb_capsule_manifold_done( rba, rbb, &manifold, buf );
+}
+
+/*
+ * Generates up to two contacts; optimised for the most stable manifold
+ */
+VG_STATIC int rb_capsule_box( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ float h = rba->inf.capsule.height,
+ r = rba->inf.capsule.radius;
+
+ /*
+ * Solving this in symetric local space of the cube saves us some time and a
+ * couple branches when it comes to the quad stage.
+ */
+ v3f centroid;
+ v3_add( rbb->bbx[0], rbb->bbx[1], centroid );
+ v3_muls( centroid, 0.5f, centroid );
+
+ boxf bbx;
+ v3_sub( rbb->bbx[0], centroid, bbx[0] );
+ v3_sub( rbb->bbx[1], centroid, bbx[1] );
+
+ v3f pc, p0w, p1w, p0, p1;
+ v3_muladds( rba->co, rba->up, -h*0.5f+r, p0w );
+ v3_muladds( rba->co, rba->up, h*0.5f-r, p1w );
+
+ m4x3_mulv( rbb->to_local, p0w, p0 );
+ m4x3_mulv( rbb->to_local, p1w, p1 );
+ v3_sub( p0, centroid, p0 );
+ v3_sub( p1, centroid, p1 );
+ v3_add( p0, p1, pc );
+ v3_muls( pc, 0.5f, pc );
+
+ /*
+ * Finding an appropriate quad to collide lines with
+ */
+ v3f region;
+ v3_div( pc, bbx[1], region );
+
+ v3f quad[4];
+ if( (fabsf(region[0]) > fabsf(region[1])) &&
+ (fabsf(region[0]) > fabsf(region[2])) )
+ {
+ float px = vg_signf(region[0]) * bbx[1][0];
+ v3_copy( (v3f){ px, bbx[0][1], bbx[0][2] }, quad[0] );
+ v3_copy( (v3f){ px, bbx[1][1], bbx[0][2] }, quad[1] );
+ v3_copy( (v3f){ px, bbx[1][1], bbx[1][2] }, quad[2] );
+ v3_copy( (v3f){ px, bbx[0][1], bbx[1][2] }, quad[3] );
+ }
+ else if( fabsf(region[1]) > fabsf(region[2]) )
+ {
+ float py = vg_signf(region[1]) * bbx[1][1];
+ v3_copy( (v3f){ bbx[0][0], py, bbx[0][2] }, quad[0] );
+ v3_copy( (v3f){ bbx[1][0], py, bbx[0][2] }, quad[1] );
+ v3_copy( (v3f){ bbx[1][0], py, bbx[1][2] }, quad[2] );
+ v3_copy( (v3f){ bbx[0][0], py, bbx[1][2] }, quad[3] );
+ }
+ else
+ {
+ float pz = vg_signf(region[2]) * bbx[1][2];
+ v3_copy( (v3f){ bbx[0][0], bbx[0][1], pz }, quad[0] );
+ v3_copy( (v3f){ bbx[1][0], bbx[0][1], pz }, quad[1] );
+ v3_copy( (v3f){ bbx[1][0], bbx[1][1], pz }, quad[2] );
+ v3_copy( (v3f){ bbx[0][0], bbx[1][1], pz }, quad[3] );
+ }
+
+ capsule_manifold manifold;
+ rb_capsule_manifold_init( &manifold );
+
+ v3f c0, c1;
+ closest_point_aabb( p0, bbx, c0 );
+ closest_point_aabb( p1, bbx, c1 );
+
+ v3f d0, d1, da;
+ v3_sub( c0, p0, d0 );
+ v3_sub( c1, p1, d1 );
+ v3_sub( p1, p0, da );
+
+ v3_normalize(d0);
+ v3_normalize(d1);
+ v3_normalize(da);
+
+ if( v3_dot( da, d0 ) <= 0.01f )
+ rb_capsule_manifold( p0, c0, 0.0f, r, &manifold );
+
+ if( v3_dot( da, d1 ) >= -0.01f )
+ rb_capsule_manifold( p1, c1, 1.0f, r, &manifold );
+
+ for( int i=0; i<4; i++ )
+ {
+ int i0 = i,
+ i1 = (i+1)%4;
+
+ v3f ca, cb;
+ float ta, tb;
+ closest_segment_segment( p0, p1, quad[i0], quad[i1], &ta, &tb, ca, cb );
+ rb_capsule_manifold( ca, cb, ta, r, &manifold );
+ }
+
+ /*
+ * Create final contacts based on line manifold
+ */
+ m3x3_mulv( rbb->to_world, manifold.d0, manifold.d0 );
+ m3x3_mulv( rbb->to_world, manifold.d1, manifold.d1 );
+
+ /*
+ * Debugging
+ */
+
+#if 0
+ for( int i=0; i<4; i++ )
+ {
+ v3f q0, q1;
+ int i0 = i,
+ i1 = (i+1)%4;
+
+ v3_add( quad[i0], centroid, q0 );
+ v3_add( quad[i1], centroid, q1 );
+
+ m4x3_mulv( rbb->to_world, q0, q0 );
+ m4x3_mulv( rbb->to_world, q1, q1 );
+
+ vg_line( q0, q1, 0xffffffff );
+ }
+#endif
+
+ return rb_capsule_manifold_done( rba, rbb, &manifold, buf );
+}
+
+VG_STATIC int rb_sphere_box( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ v3f co, delta;
+
+ closest_point_obb( rba->co, rbb, co );
+ v3_sub( rba->co, co, delta );
+
+ float d2 = v3_length2(delta),
+ r = rba->inf.sphere.radius;
+
+ if( d2 <= r*r )
+ {
+ float d;
+
+ rb_ct *ct = buf;
+ if( d2 <= 0.0001f )
+ {
+ v3_sub( rba->co, rbb->co, delta );
+
+ /*
+ * some extra testing is required to find the best axis to push the
+ * object back outside the box. Since there isnt a clear seperating
+ * vector already, especially on really high aspect boxes.
+ */
+ float lx = v3_dot( rbb->right, delta ),
+ ly = v3_dot( rbb->up, delta ),
+ lz = v3_dot( rbb->forward, delta ),
+ px = rbb->bbx[1][0] - fabsf(lx),
+ py = rbb->bbx[1][1] - fabsf(ly),
+ pz = rbb->bbx[1][2] - fabsf(lz);
+
+ if( px < py && px < pz )
+ v3_muls( rbb->right, vg_signf(lx), ct->n );
+ else if( py < pz )
+ v3_muls( rbb->up, vg_signf(ly), ct->n );
+ else
+ v3_muls( rbb->forward, vg_signf(lz), ct->n );
+
+ v3_muladds( rba->co, ct->n, -r, ct->co );
+ ct->p = r;
+ }
+ else
+ {
+ d = sqrtf(d2);
+ v3_muls( delta, 1.0f/d, ct->n );
+ ct->p = r-d;
+ v3_copy( co, ct->co );
+ }
+
+ ct->rba = rba;
+ ct->rbb = rbb;
+ return 1;
+ }
+
+ return 0;
+}
+
+VG_STATIC int rb_sphere_sphere( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ v3f delta;
+ v3_sub( rba->co, rbb->co, delta );
+
+ float d2 = v3_length2(delta),
+ r = rba->inf.sphere.radius + rbb->inf.sphere.radius;
+
+ if( d2 < r*r )
+ {
+ float d = sqrtf(d2);
+
+ rb_ct *ct = buf;
+ v3_muls( delta, 1.0f/d, ct->n );
+
+ v3f p0, p1;
+ v3_muladds( rba->co, ct->n,-rba->inf.sphere.radius, p0 );
+ v3_muladds( rbb->co, ct->n, rbb->inf.sphere.radius, p1 );
+ v3_add( p0, p1, ct->co );
+ v3_muls( ct->co, 0.5f, ct->co );
+ ct->p = r-d;
+ ct->rba = rba;
+ ct->rbb = rbb;
+ return 1;
+ }
+
+ return 0;
+}
+
+#define RIGIDBODY_DYNAMIC_MESH_EDGES
+
+VG_STATIC int rb_sphere_triangle( rigidbody *rba, rigidbody *rbb,
+ v3f tri[3], rb_ct *buf )
+{
+ v3f delta, co;
+
+#ifdef RIGIDBODY_DYNAMIC_MESH_EDGES
+ closest_on_triangle( rba->co, tri, co );
+#else
+ closest_on_triangle_1( rba->co, tri, co );
+#endif
+
+ v3_sub( rba->co, co, delta );
+
+ vg_line( rba->co, co, 0xffff0000 );
+ vg_line_pt3( rba->co, 0.1f, 0xff00ffff );
+
+ float d2 = v3_length2( delta ),
+ r = rba->inf.sphere.radius;
+
+ if( d2 < r*r )
+ {
+ rb_ct *ct = buf;
+
+ v3f ab, ac, tn;
+ v3_sub( tri[2], tri[0], ab );
+ v3_sub( tri[1], tri[0], ac );
+ v3_cross( ac, ab, tn );
+ v3_copy( tn, ct->n );
+ v3_normalize( ct->n );
+
+ float d = sqrtf(d2);
+
+ v3_copy( co, ct->co );
+ ct->p = r-d;
+ ct->rba = rba;
+ ct->rbb = rbb;
+ return 1;
+ }
+
+ return 0;
+}
+
+VG_STATIC int rb_sphere_scene( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ scene *sc = rbb->inf.scene.bh_scene->user;
+
+ u32 geo[128];
+
+ int len = bh_select( rbb->inf.scene.bh_scene, rba->bbx_world, geo, 128 );
+ int count = 0;
+
+#ifdef RIGIDBODY_DYNAMIC_MESH_EDGES
+ /* !experimental! build edge array on the fly. time could be improved! */
+
+ v3f co_picture[128*3];
+ int unique_cos = 0;
+
+ struct face_info
+ {
+ int unique_cos[3]; /* indexes co_picture array */
+ int collided;
+ v3f normal;
+ u32 element_id;
+ }
+ faces[128];
+
+ /* create geometry picture */
+ for( int i=0; i<len; i++ )
+ {
+ u32 *tri_indices = &sc->arrindices[ geo[i]*3 ];
+ struct face_info *inf = &faces[i];
+ inf->element_id = tri_indices[0];
+ inf->collided = 0;
+
+ for( int j=0; j<3; j++ )
+ {
+ struct mdl_vert *pvert = &sc->arrvertices[tri_indices[j]];
+
+ for( int k=0; k<unique_cos; k++ )
+ {
+ if( v3_dist( pvert->co, co_picture[k] ) < 0.01f*0.01f )
+ {
+ inf->unique_cos[j] = k;
+ goto next_vert;
+ }
+ }
+
+ inf->unique_cos[j] = unique_cos;
+ v3_copy( pvert->co, co_picture[ unique_cos ++ ] );
+next_vert:;
+ }
+
+ v3f ab, ac;
+ v3_sub( co_picture[inf->unique_cos[2]],
+ co_picture[inf->unique_cos[0]], ab );
+
+ v3_sub( co_picture[inf->unique_cos[1]],
+ co_picture[inf->unique_cos[0]], ac );
+ v3_cross( ac, ab, inf->normal );
+ v3_normalize( inf->normal );
+ }
+
+
+ /* build edges brute force */
+ int edge_picture[ 128*3 ][4];
+ int unique_edges = 0;
+
+ for( int i=0; i<len; i++ )
+ {
+ struct face_info *inf = &faces[i];
+
+ for( int j=0; j<3; j++ )
+ {
+ int i0 = j,
+ i1 = (j+1)%3,
+ e0 = VG_MIN( inf->unique_cos[i0], inf->unique_cos[i1] ),
+ e1 = VG_MAX( inf->unique_cos[i0], inf->unique_cos[i1] ),
+ matched = 0;
+
+ for( int k=0; k<unique_edges; k ++ )
+ {
+ int k0 = VG_MIN( edge_picture[k][0], edge_picture[k][1] ),
+ k1 = VG_MAX( edge_picture[k][0], edge_picture[k][1] );
+
+ /* matched ! */
+ if( (k0 == e0) && (k1 == e1) )
+ {
+ edge_picture[ k ][3] = i;
+ matched = 1;
+ break;
+ }
+ }
+
+ if( !matched )
+ {
+ /* create new edge */
+ edge_picture[ unique_edges ][0] = inf->unique_cos[i0];
+ edge_picture[ unique_edges ][1] = inf->unique_cos[i1];
+
+ edge_picture[ unique_edges ][2] = i;
+ edge_picture[ unique_edges ][3] = -1;
+
+ unique_edges ++;
+ }
+ }
+ }
+#endif
+
+ v3f tri[3];
+
+ for( int i=0; i<len; i++ )
+ {
+#ifdef RIGIDBODY_DYNAMIC_MESH_EDGES
+ struct face_info *inf = &faces[i];
+
+ float *v0 = co_picture[inf->unique_cos[0]],
+ *v1 = co_picture[inf->unique_cos[1]],
+ *v2 = co_picture[inf->unique_cos[2]];
+
+ v3_copy( v0, tri[0] );
+ v3_copy( v1, tri[1] );
+ v3_copy( v2, tri[2] );
+
+ buf[count].element_id = inf->element_id;
+#else
+ u32 *ptri = &sc->arrindices[ geo[i]*3 ];
+
+ for( int j=0; j<3; j++ )
+ v3_copy( sc->arrvertices[ptri[j]].co, tri[j] );
+
+ buf[count].element_id = ptri[0];
+#endif
+
+ vg_line( tri[0],tri[1],0x10ffffff );
+ vg_line( tri[1],tri[2],0x10ffffff );
+ vg_line( tri[2],tri[0],0x10ffffff );
+
+ int contact = rb_sphere_triangle( rba, rbb, tri, buf+count );
+
+#ifdef RIGIDBODY_DYNAMIC_MESH_EDGES
+ if( contact )
+ inf->collided = 1;
+#endif
+ count += contact;
+
+ if( count == 12 )
+ {
+ vg_warn( "Exceeding sphere_vs_scene capacity. Geometry too dense!\n" );
+ return count;
+ }
+ }
+
+#ifdef RIGIDBODY_DYNAMIC_MESH_EDGES
+ for( int i=0; i<unique_edges; i++ )
+ {
+ int *edge = edge_picture[i];
+
+ if( edge[3] == -1 )
+ continue;
+
+ struct face_info *inf_i = &faces[edge[2]],
+ *inf_j = &faces[edge[3]];
+
+ if( inf_i->collided || inf_j->collided )
+ continue;
+
+ v3f co, delta;
+ closest_point_segment( co_picture[edge[0]], co_picture[edge[1]],
+ rba->co, co );
+
+ v3_sub( rba->co, co, delta );
+ float d2 = v3_length2( delta ),
+ r = rba->inf.sphere.radius;
+
+ if( d2 < r*r )
+ {
+ float d = sqrtf(d2);
+
+ v3_muls( delta, 1.0f/d, delta );
+ float c0 = v3_dot( inf_i->normal, delta ),
+ c1 = v3_dot( inf_j->normal, delta );
+
+ if( c0 < 0.0f || c1 < 0.0f )
+ continue;
+
+ rb_ct *ct = buf+count;
+
+ v3_muls( inf_i->normal, c0, ct->n );
+ v3_muladds( ct->n, inf_j->normal, c1, ct->n );
+ v3_normalize( ct->n );
+
+ v3_copy( co, ct->co );
+ ct->p = r-d;
+ ct->rba = rba;
+ ct->rbb = rbb;
+ ct->element_id = inf_i->element_id;
+
+ count ++;
+
+ if( count == 12 )
+ {
+ vg_warn( "Geometry too dense!\n" );
+ return count;
+ }
+ }
+ }
+#endif
+
+ return count;
+}
+
+VG_STATIC int rb_box_scene( rigidbody *rba, rigidbody *rbb, rb_ct *buf )
+{
+ scene *sc = rbb->inf.scene.bh_scene->user;
+
+ u32 geo[128];
+ v3f tri[3];
+ int len = bh_select( rbb->inf.scene.bh_scene, rba->bbx_world, geo, 128 );
+
+ int count = 0;
+
+ for( int i=0; i<len; i++ )
+ {
+ u32 *ptri = &sc->arrindices[ geo[i]*3 ];