public static void CollideTV( btDbvtNode root, ref btDbvtVolume volume, ICollide collideable )
{
CollideTVCount++;
Debug.Assert( CollideTVCount < 2 );
CollideTVStack.Clear();
if( root != null )
{
CollideTVStack.Push( root );
do
{
btDbvtNode n = CollideTVStack.Pop();
if( btDbvtVolume.Intersect( ref n.volume, ref volume ) )
{
if( n.IsInternal() )
{
CollideTVStack.Push( n._children0 );
CollideTVStack.Push( n._children1 );
}
else
{
collideable.Process( n );
}
}
} while( CollideTVStack.Count > 0 );
}
CollideTVCount--;
}
public bool update( btDbvtNode leaf, ref btDbvtVolume volume, double margin )
{
if( leaf.volume.Contain( ref volume ) )
{
return ( false );
}
volume.Expand( new btVector3( margin ) );
update( leaf, ref volume );
return ( true );
}
public static void swap( ref btDbvtVolume a, ref btDbvtVolume b )
{
btDbvtVolume temp = b;
b = a;
a = temp;
}
public void update( btDbvtNode leaf, ref btDbvtVolume volume )
{
btDbvtNode root = RemoveLeaf( this, leaf );
if( root != null )
{
if( m_lkhd >= 0 )
{
for( int i = 0; ( i < m_lkhd ) && ( root.parent != null ); ++i )
{
root = root.parent;
}
}
else
{
root = Root;
}
}
leaf.volume = volume;
InsertLeaf( this, root, leaf );
}
public bool update( btDbvtNode leaf, ref btDbvtVolume volume, ref btVector3 velocity )
{
if( leaf.volume.Contain( ref volume ) )
{
return ( false );
}
volume.SignedExpand( velocity );
update( leaf, ref volume );
return ( true );
}
//
public static btDbvtNode CreateNode( btDbvt pdbvt,
btDbvtNode parent,
ref btDbvtVolume volume,
Object data )
{
btDbvtNode node = CreateNode( pdbvt, parent, data );
node.volume = volume;
return ( node );
}
public btDbvtNode( btDbvt tree, btDbvtNode aparent, ref btDbvtVolume avolume, Object adata )
: this()
{
volume = avolume;
parent = aparent;
data = adata;
if( data is int )
{
dataAsInt = (int)data;
}
}
public bool Contain( ref btDbvtVolume a )
{
return ( ( _min.x <= a._min.x ) &&
( _min.y <= a._min.y ) &&
( _min.z <= a._min.z ) &&
( _max.x >= a._max.x ) &&
( _max.y >= a._max.y ) &&
( _max.z >= a._max.z ) );
}
public static bool Intersect( ref btDbvtVolume a, ref btDbvtVolume b )
{
return ( ( a._min.x <= b._max.x ) &&
( a._max.x >= b._min.x ) &&
( a._min.y <= b._max.y ) &&
( a._max.y >= b._min.y ) &&
( a._min.z <= b._max.z ) &&
( a._max.z >= b._min.z ) );
}
public static int Select( ref btDbvtVolume o,
ref btDbvtVolume a,
ref btDbvtVolume b )
{
return ( Proximity( ref o, ref a ) < Proximity( ref o, ref b ) ? 0 : 1 );
}
public static bool NotEqual( ref btDbvtVolume a, ref btDbvtVolume b )
{
return ( ( a._min.x != b._min.x ) ||
( a._min.y != b._min.y ) ||
( a._min.z != b._min.z ) ||
( a._max.x != b._max.x ) ||
( a._max.y != b._max.y ) ||
( a._max.z != b._max.z ) );
}
public static void Merge( ref btDbvtVolume a, ref btDbvtVolume b, out btDbvtVolume r )
{
//r = a;
//SetMin(ref r._min, ref b._min);
//SetMax(ref r._max, ref b._max);
btVector3.setMin( ref a._min, ref b._min, out r._min );
btVector3.setMax( ref a._max, ref b._max, out r._max );
}
public static btDbvtVolume Merge( ref btDbvtVolume a, ref btDbvtVolume b )
{
btDbvtVolume res = new btDbvtVolume();
Merge( ref a, ref b, out res );
return ( res );
}
public static double Proximity( ref btDbvtVolume a, ref btDbvtVolume b )
{
btVector3 d = ( a._min + a._max ) - ( b._min + b._max );
return ( Math.Abs( d.x ) + Math.Abs( d.y ) + Math.Abs( d.z ) );
}
//
public static void Bounds( btList<btDbvtNode> leafs, out btDbvtVolume volume )
{
volume = leafs[0].volume;
foreach( btDbvtNode node in leafs )
{
btDbvtVolume.Merge( ref volume, ref node.volume, out volume );
}
}
public static bool Intersect( btDbvtVolume a, ref btVector3 b )
{
return ( ( b.x >= a._min.x ) &&
( b.y >= a._min.y ) &&
( b.z >= a._min.z ) &&
( b.x <= a._max.x ) &&
( b.y <= a._max.y ) &&
( b.z <= a._max.z ) );
}
public static btDbvtNode CreateNode2( btDbvt tree, btDbvtNode aparent, ref btDbvtVolume avolume, Object adata )
{
btDbvtNode node = BulletGlobals.DbvtNodePool.Get();
node.volume = avolume;
node.parent = aparent;
node.data = adata;
node._children0 = null;
node._children1 = null;
if( node.data is int )
{
Debug.Assert( false );
node.dataAsInt = (int)node.data;
}
return node;
}
public btDbvtNode insert( ref btDbvtVolume box, Object data )
{
btDbvtNode leaf = CreateNode( this, null, ref box, data );
InsertLeaf( this, Root, leaf );
++m_leaves;
return leaf;
}
//
public static btDbvtNode CreateNode( btDbvt pdbvt,
btDbvtNode parent,
ref btDbvtVolume volume0,
ref btDbvtVolume volume1,
Object data )
{
btDbvtNode node = CreateNode( pdbvt, parent, data );
btDbvtVolume.Merge( ref volume0, ref volume1, out node.volume );
return ( node );
}
// volume+edge lengths
public static double Size( ref btDbvtVolume a )
{
btVector3 edges = a.Lengths();
return ( edges.x * edges.y * edges.z +
edges.x + edges.y + edges.z );
}
