private void SetDbvtNodeInfo(DbvtNode dbvtNode, TreeNode parentNode)
{
if (dbvtNode == null)
{
return;
}
string text = dbvtNode.GetType().Name;
TreeNode dbvtNodeNode = GetOrCreateChildNode(dbvtNode, text, parentNode);
RemoveObjectsOfType <DbvtProxy>(dbvtNodeNode);
if (dbvtNode.IsLeaf)
{
DbvtProxy proxy = dbvtNode.Data;
string description = GetProxyDescription(proxy);
GetOrCreateChildNode(proxy, description, dbvtNodeNode);
}
else
{
foreach (DbvtNode child in dbvtNode.Childs)
{
SetDbvtNodeInfo(child, dbvtNodeNode);
}
}
RemoveMissingObjects(dbvtNode.Childs, dbvtNodeNode);
}
public void collideTV(DbvtNode root, ref DbvtAabbMm vol, ICollide policy)
{
if (root != null)
{
DbvtAabbMm volume = vol;
List<DbvtNode> stack = new List<DbvtNode>();
stack.Add(root);
do
{
DbvtNode n = stack[stack.Count - 1];
stack.RemoveAt(stack.Count - 1);
if (Intersect(ref n.volume,ref volume))
{
if (n.isinternal())
{
stack.Add(n.childs[0]);
stack.Add(n.childs[1]);
}
else
{
policy.Process(n);
}
}
} while (stack.Count > 0);
}
}
public Dbvt()
{
m_root = null;
m_free = null;
m_lkhd = -1;
m_leaves = 0;
m_opath = 0;
}
public override void Process(DbvtNode na, DbvtNode nb)
{
if (na != nb)
{
DbvtProxy pa = (DbvtProxy)na.data;
DbvtProxy pb = (DbvtProxy)nb.data;
#if DBVT_BP_SORTPAIRS
if(pa->m_uniqueId>pb->m_uniqueId)
btSwap(pa,pb);
#endif
pbp.m_paircache.addOverlappingPair(pa, pb);
++pbp.m_newpairs;
}
}
static DbvtNode createnode(Dbvt pdbvt,
DbvtNode parent,
object data)
{
DbvtNode node;
if (pdbvt.m_free != null)
{
node = pdbvt.m_free;
pdbvt.m_free = null;
}
else
{
node = new DbvtNode();
}
node.parent = parent;
node.data = data;
node.childs[1] = null;
return (node);
}
private void SetDbvtNodeInfo(DbvtNode dbvtNode, TreeNode parentNode)
{
if (dbvtNode == null)
{
return;
}
string text = dbvtNode.GetType().Name;
TreeNode dbvtNodeNode = GetOrCreateChildNode(dbvtNode, text, parentNode);
RemoveObjectsOfType <DbvtProxy>(dbvtNodeNode);
DbvtProxy proxy = dbvtNode.Data;
GetOrCreateChildNode(proxy, "DbvtProxy" + " " + proxy.ClientObject, dbvtNodeNode);
foreach (DbvtNode child in dbvtNode.Childs)
{
SetDbvtNodeInfo(child, dbvtNodeNode);
}
RemoveMissingObjects(dbvtNode.Childs, dbvtNodeNode);
}
static int indexof(DbvtNode node)
{
return (node.parent.childs[1] == node) ? 1 : 0;
}
public void collideTTpersistentStack(DbvtNode root0, DbvtNode root1, DbvtBroadphase pbp)
{
if (root0 != null && root1 != null)
{
//int depth=1;
//int treshold=DOUBLE_STACKSIZE-4;
//中身はただのPush-Pop動作なので、それに置き換え
m_stkStack.Clear();
//m_stkStack.AddRange(DOUBLE_STACKSIZE);
m_stkStack.Add(new sStkNN(root0, root1));
do
{
//sStkNN p=m_stkStack[--depth];
sStkNN p = m_stkStack[m_stkStack.Count - 1];
/*
if(depth>treshold)
{
m_stkStack.resize(m_stkStack.size()*2);
treshold=m_stkStack.size()-4;
}*/
if (p.a == p.b)
{
if (p.a.isinternal())
{
/*m_stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[0]);
m_stkStack[depth++]=sStkNN(p.a->childs[1],p.a->childs[1]);
m_stkStack[depth++]=sStkNN(p.a->childs[0],p.a->childs[1]);
*/
m_stkStack.Add(new sStkNN(p.a.childs[0], p.a.childs[0]));
m_stkStack.Add(new sStkNN(p.a.childs[1], p.a.childs[1]));
m_stkStack.Add(new sStkNN(p.a.childs[0], p.a.childs[1]));
}
}
else if (Intersect(ref p.a.volume,ref p.b.volume))
{
if (p.a.isinternal())
{
if (p.b.isinternal())
{
/*m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[0]);
m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[0]);
m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b->childs[1]);
m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b->childs[1]);
*/
m_stkStack.Add(new sStkNN(p.a.childs[0], p.b.childs[0]));
m_stkStack.Add(new sStkNN(p.a.childs[1], p.b.childs[0]));
m_stkStack.Add(new sStkNN(p.a.childs[0], p.b.childs[1]));
m_stkStack.Add(new sStkNN(p.a.childs[1], p.b.childs[1]));
}
else
{
/*m_stkStack[depth++]=sStkNN(p.a->childs[0],p.b);
m_stkStack[depth++]=sStkNN(p.a->childs[1],p.b);
*/
m_stkStack.Add(new sStkNN(p.a.childs[0], p.b));
m_stkStack.Add(new sStkNN(p.a.childs[1], p.b));
}
}
else
{
if (p.b.isinternal())
{
/*m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
m_stkStack[depth++] = sStkNN(p.a, p.b->childs[0]);
m_stkStack[depth++] = sStkNN(p.a, p.b->childs[1]);
*/
m_stkStack.Add(new sStkNN(p.a, p.b.childs[0]));
m_stkStack.Add(new sStkNN(p.a, p.b.childs[1]));
m_stkStack.Add(new sStkNN(p.a, p.b.childs[0]));
m_stkStack.Add(new sStkNN(p.a, p.b.childs[1]));
}
else
{
//policy.Process(p.a,p.b);
DbvtTreeCollider.Process(pbp, p.a, p.b);//stackにclassをnewできないので回避処理……
}
}
}
} while (m_stkStack.Count > 0);
}
}
public bool update(DbvtNode leaf,ref DbvtAabbMm volume,ref btVector3 velocity,float margin)
{
if(leaf.volume.Contain(ref volume)) return(false);
btVector3 temp = new btVector3(margin, margin, margin);
volume.Expand(ref temp);
volume.SignedExpand(ref velocity);
update(leaf,ref volume);
return(true);
}
public override void Process(DbvtNode n)
{
Process(n, proxy.leaf);
}
public virtual bool Descent(DbvtNode n) { return (true); }
public virtual void Process(DbvtNode n) { }
private static DbvtNode createnode(Dbvt pdbvt,
DbvtNode parent,
ref DbvtAabbMm volume0,
ref DbvtAabbMm volume1,
object data)
{
DbvtNode node = createnode(pdbvt, parent, data);
Merge(ref volume0,ref volume1,ref node.volume);
return (node);
}
private static void insertleaf(Dbvt pdbvt,
DbvtNode root,
DbvtNode leaf)
{
if (pdbvt.m_root == null)
{
pdbvt.m_root = leaf;
leaf.parent = null;
}
else
{
if (!root.isleaf())
{
do
{
root = root.childs[Select(ref leaf.volume,
ref root.childs[0].volume,
ref root.childs[1].volume)];
} while (!root.isleaf());
}
DbvtNode prev = root.parent;
DbvtNode node = createnode(pdbvt, prev,ref leaf.volume,ref root.volume, null);
if (prev != null)
{
prev.childs[indexof(root)] = node;
node.childs[0] = root; root.parent = node;
node.childs[1] = leaf; leaf.parent = node;
do
{
if (!prev.volume.Contain(ref node.volume))
Merge(ref prev.childs[0].volume,ref prev.childs[1].volume,ref prev.volume);
else
break;
node = prev;
prev = node.parent;
} while (null != prev);
}
else
{
node.childs[0] = root; root.parent = node;
node.childs[1] = leaf; leaf.parent = node;
pdbvt.m_root = node;
}
}
}
public sStkNN(DbvtNode na, DbvtNode nb) { a = na; b = nb; }
public sStkNP(DbvtNode n, uint m) { node = n; mask = m; }
public sStkNPS(DbvtNode n, uint m, float v) { node = n; mask = m; value = v; }
private static DbvtNode createnode(Dbvt pdbvt,
DbvtNode parent,
ref DbvtAabbMm volume,
object data)
{
DbvtNode node = createnode(pdbvt, parent, data);
node.volume = volume;
return (node);
}
public void remove(DbvtNode leaf)
{
removeleaf(this, leaf);
deletenode(this, leaf);
--m_leaves;
}
public override void Process(DbvtNode leaf)
{
DbvtProxy proxy=(DbvtProxy)leaf.data;
m_rayCallback.Process(proxy);
}
//
static DbvtNode removeleaf(Dbvt pdbvt, DbvtNode leaf)
{
if (leaf == pdbvt.m_root)
{
pdbvt.m_root = null;
return null;
}
else
{
DbvtNode parent = leaf.parent;
DbvtNode prev = parent.parent;
DbvtNode sibling = parent.childs[1 - indexof(leaf)];
if (prev != null)
{
prev.childs[indexof(parent)] = sibling;
sibling.parent = prev;
deletenode(pdbvt, parent);
while (prev != null)
{
DbvtAabbMm pb = prev.volume;
Merge(ref prev.childs[0].volume,ref prev.childs[1].volume,ref prev.volume);
if (NotEqual(ref pb, ref prev.volume))
{
prev = prev.parent;
}
else break;
}
return (prev != null ? prev : pdbvt.m_root);
}
else
{
pdbvt.m_root = sibling;
sibling.parent = null;
deletenode(pdbvt, parent);
return (pdbvt.m_root);
}
}
}
public virtual void Process(DbvtNode na, DbvtNode nb) { }
static void deletenode(Dbvt pdbvt, DbvtNode node)
{
//btAlignedFree(pdbvt->m_free);
pdbvt.m_free = node;
}
public virtual void Process(DbvtNode n, float f) { Process(n); }
public void update(DbvtNode leaf, ref DbvtAabbMm volume)
{
DbvtNode 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 = m_root;
}
leaf.volume = volume;
insertleaf(this, root, leaf);
}
public virtual bool AllLeaves(DbvtNode n) { return (true); }
public void Process(DbvtNode leaf)
{
DbvtProxy proxy=(DbvtProxy)leaf.data;
m_aabbCallback.Process(proxy);
}
