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); }