ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

logic: skip traversing unspecialized template method of implicit template class specialization

Browse Source
This commit is contained in:
mlangkabel
2019-10-18 13:05:29 +02:00
committed by Eberhard Graether
parent ee7dcc2d83
commit cd731a3798
11 changed files with 100 additions and 676 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvh.txt
-112
View File
@@ -311,7 +311,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer b3Al
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -332,7 +331,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::pointer b3Alig
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::construct(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<const b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<const b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -352,7 +350,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -371,7 +368,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer b3A
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -390,7 +386,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer b3Al
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DbvtNode *, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -408,7 +403,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtNode *, 16>::pointer b3AlignedAll
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::construct(b3AlignedAllocator<b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -429,7 +423,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer b3A
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -510,11 +503,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::push_back
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch2(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -552,11 +541,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::push_back(c
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<const b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch2(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -594,11 +579,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -638,11 +619,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::push_bac
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch2(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -680,11 +657,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::push_back
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch2(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -722,11 +695,7 @@ SYMBOL_METHOD: public b3DbvtNode * & b3AlignedObjectArray<b3DbvtNode *>::expand(
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::push_back(b3DbvtNode * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findLinearSearch(b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtNode *>::findLinearSearch2(b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -766,11 +735,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::push_bac
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findLinearSearch(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findLinearSearch2(const b3DynamicBvh::sStkCLN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2671,8 +2636,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2714,8 +2677,6 @@ REFERENCE_CALL: void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3Al
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<const b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2751,8 +2712,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2794,8 +2753,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2831,8 +2788,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::dealloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2874,8 +2829,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DbvtNode *, 16>::deallocate(b3AlignedA
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtNode *, 16>::destroy(b3AlignedAllocator<b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtNode *, 16>::self_type & b3AlignedAllocator<b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2917,8 +2870,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::deallocate(b
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkCLN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3219,19 +3170,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3395,19 +3337,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) ->
REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> const b3DbvtNode * * b3AlignedObjectArray<const b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<const b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<const b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3523,19 +3456,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::reserve(int)
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3682,19 +3606,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int)
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> b3DynamicBvh::sStkNPS * b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3797,19 +3712,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3982,14 +3888,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> bool b
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::downHeap<typename L>(b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3999,7 +3897,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3Db
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <422:4 422:9>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <422:21 422:26>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::swap(int, int) -> b3DbvtNode * * b3AlignedObjectArray<b3DbvtNode *>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtNode *>::findBinarySearch(b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4161,19 +4058,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int)
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) -> b3DynamicBvh::sStkCLN * b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> b3DynamicBvh::sStkCLN [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::downHeap<typename L>(b3DynamicBvh::sStkCLN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkCLN>::findBinarySearch(const b3DynamicBvh::sStkCLN &) const -> b3DynamicBvh::sStkCLN [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3DynamicBvhBroadphase.txt
+2 -114
View File
@@ -300,7 +300,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer b3Al
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -321,7 +320,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::pointer b3Alig
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::construct(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer, const b3AlignedAllocator<const b3DbvtNode *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<const b3DbvtNode *, 16>::b3AlignedAllocator(const b3AlignedAllocator<const b3DbvtNode *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -341,7 +339,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -360,7 +357,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer b3A
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -379,7 +375,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer b3Al
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::construct(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::deallocate(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3Int4, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -398,7 +393,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_CLASS: b3AlignedAllocator<b3DbvtProxy, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
@@ -417,7 +411,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtProxy, 16>::pointer b3AlignedAllo
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::construct(b3AlignedAllocator<b3DbvtProxy, 16>::pointer, const b3AlignedAllocator<b3DbvtProxy, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::deallocate(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3DbvtProxy, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3DbvtProxy, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -499,11 +492,7 @@ SYMBOL_METHOD: public b3DynamicBvh::sStkNN & b3AlignedObjectArray<b3DynamicBvh::
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::push_back(const b3DynamicBvh::sStkNN &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findLinearSearch2(const b3DynamicBvh::sStkNN &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -541,11 +530,7 @@ SYMBOL_METHOD: public const b3DbvtNode * & b3AlignedObjectArray<const b3DbvtNode
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::push_back(const b3DbvtNode * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<const b3DbvtNode *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<const b3DbvtNode *>::findLinearSearch2(const b3DbvtNode * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -583,11 +568,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -627,11 +608,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::push_bac
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findLinearSearch2(const b3DynamicBvh::sStkNPS &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -669,11 +646,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::push_back
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findLinearSearch2(const b3DynamicBvh::sStkNP &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -714,16 +687,12 @@ SYMBOL_METHOD: public b3Int4 & b3AlignedObjectArray<b3Int4>::expand(const b3Int4
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4 &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
SYMBOL_CLASS: b3BroadphasePairSortPredicate [b3OverlappingPair.h <52:1 <52:7 52:35> 64:1>]
SYMBOL_METHOD: public bool b3BroadphasePairSortPredicate::operator()(const b3BroadphasePair &, const b3BroadphasePair &) const [b3OverlappingPair.h <56:3 <56:3 <56:8 56:17> 56:80> 63:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public b3Int4 & b3Int4::operator=(const b3Int4 &) [b3Int4.h <26:32 <26:32 26:37> 26:37>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch2(const b3Int4 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -765,11 +734,7 @@ SYMBOL_METHOD: public b3DbvtProxy & b3AlignedObjectArray<b3DbvtProxy>::expand(co
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::push_back(const b3DbvtProxy &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3DbvtProxy>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3DbvtProxy>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findLinearSearch(const b3DbvtProxy &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3DbvtProxy>::findLinearSearch2(const b3DbvtProxy &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -3066,8 +3031,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::deallocate(b3
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNN, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3109,8 +3072,6 @@ REFERENCE_CALL: void b3AlignedAllocator<const b3DbvtNode *, 16>::deallocate(b3Al
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<const b3DbvtNode *, 16>::destroy(b3AlignedAllocator<const b3DbvtNode *, 16>::pointer) -> b3AlignedAllocator<const b3DbvtNode *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<const b3DbvtNode *, 16>::self_type & b3AlignedAllocator<const b3DbvtNode *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &, const b3AlignedAllocator<const b3DbvtNode *, 16>::self_type &) -> b3AlignedAllocator<const b3DbvtNode *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3146,8 +3107,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3189,8 +3148,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::deallocate(b
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNPS, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3226,8 +3183,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::dealloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::destroy(b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type & b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &, const b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type &) -> b3AlignedAllocator<b3DynamicBvh::sStkNP, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3269,8 +3224,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocat
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3312,8 +3265,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3DbvtProxy, 16>::deallocate(b3AlignedAl
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3DbvtProxy, 16>::destroy(b3AlignedAllocator<b3DbvtProxy, 16>::pointer) -> b3AlignedAllocator<b3DbvtProxy, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3DbvtProxy, 16>::self_type & b3AlignedAllocator<b3DbvtProxy, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &, const b3AlignedAllocator<b3DbvtProxy, 16>::self_type &) -> b3AlignedAllocator<b3DbvtProxy, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3648,19 +3599,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> b3DynamicBvh::sStkNN * b3AlignedObjectArray<b3DynamicBvh::sStkNN>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNN>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::downHeap<typename L>(b3DynamicBvh::sStkNN *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNN>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNN>::findBinarySearch(const b3DynamicBvh::sStkNN &) const -> b3DynamicBvh::sStkNN [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3837,19 +3779,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) ->
REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> const b3DbvtNode * * b3AlignedObjectArray<const b3DbvtNode *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::reserve(int) -> int b3AlignedObjectArray<const b3DbvtNode *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<const b3DbvtNode *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> b3DbvtNode [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::downHeap<typename L>(const b3DbvtNode * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<const b3DbvtNode *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<const b3DbvtNode *>::findBinarySearch(const b3DbvtNode * const &) const -> b3DbvtNode [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3962,19 +3895,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::reserve(int)
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4121,19 +4045,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int)
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> b3DynamicBvh::sStkNPS * b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::reserve(int) -> int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::downHeap<typename L>(b3DynamicBvh::sStkNPS *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNPS>::findBinarySearch(const b3DynamicBvh::sStkNPS &) const -> b3DynamicBvh::sStkNPS [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4236,19 +4151,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkN
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DynamicBvh::sStkNP>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::downHeap<typename L>(b3DynamicBvh::sStkNP *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DynamicBvh::sStkNP>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DynamicBvh::sStkNP>::findBinarySearch(const b3DynamicBvh::sStkNP &) const -> b3DynamicBvh::sStkNP [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4397,10 +4303,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> bool b3Align
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int b3AlignedObjectArray<b3Int4>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <341:32 341:32>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -4416,17 +4319,12 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3Broadphas
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <371:24 371:24>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -4439,7 +4337,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <422:19 422:19>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <423:19 423:19>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4602,19 +4499,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> bool b3
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> b3DbvtProxy * b3AlignedObjectArray<b3DbvtProxy>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::reserve(int) -> int b3AlignedObjectArray<b3DbvtProxy>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3DbvtProxy>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> b3DbvtProxy [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::downHeap<typename L>(b3DbvtProxy *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3DbvtProxy>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3DbvtProxy>::findBinarySearch(const b3DbvtProxy &) const -> b3DbvtProxy [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_BroadPhaseCollision_b3OverlappingPairCache.txt
+2 -34
View File
@@ -287,7 +287,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Int4, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -307,7 +306,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -388,16 +386,12 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::reserve(int) [b3Aligned
SYMBOL_METHOD: public b3Int4 & b3AlignedObjectArray<b3Int4>::expand(const b3Int4 &) [b3AlignedObjectArray.h <260:3 <260:23 260:28> 273:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
SYMBOL_CLASS: b3BroadphasePairSortPredicate [b3OverlappingPair.h <52:1 <52:7 52:35> 64:1>]
SYMBOL_METHOD: public bool b3BroadphasePairSortPredicate::operator()(const b3BroadphasePair &, const b3BroadphasePair &) const [b3OverlappingPair.h <56:3 <56:3 <56:8 56:17> 56:80> 63:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public b3Int4 & b3Int4::operator=(const b3Int4 &) [b3Int4.h <26:32 <26:32 26:37> 26:37>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
SYMBOL_FUNCTION: bool operator==(const b3BroadphasePair &, const b3BroadphasePair &) [b3OverlappingPair.h <66:1 <66:1 <66:22 66:31> 66:85> 69:1>]
@@ -436,11 +430,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2271,8 +2261,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocat
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2314,8 +2302,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2658,10 +2644,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> bool b3Align
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int b3AlignedObjectArray<b3Int4>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <341:32 341:32>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -2677,17 +2660,12 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3Broadphas
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> b3BroadphasePairSortPredicate [b3AlignedObjectArray.h <371:24 371:24>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> int b3AlignedObjectArray<b3Int4>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::quickSort<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &) -> void b3AlignedObjectArray<b3Int4>::quickSortInternal<b3BroadphasePairSortPredicate>(const b3BroadphasePairSortPredicate &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -2700,7 +2678,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b
REFERENCE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 * b3AlignedObjectArray<b3Int4>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <422:19 422:19>]
REFERENCE_CALL: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> b3Int4 & b3Int4::operator=(const b3Int4 &) [b3AlignedObjectArray.h <423:19 423:19>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -2865,19 +2842,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3ConvexUtility.txt
+1 -113
View File
@@ -306,7 +306,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -341,7 +340,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Vector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -362,7 +360,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::pointer b3AlignedAllocat
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::construct(b3AlignedAllocator<b3MyFace, 16>::pointer, const b3AlignedAllocator<b3MyFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3MyFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -386,7 +383,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointe
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::construct(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::deallocate(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -407,7 +403,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3GrahamVector3, 16>::pointer b3Aligned
SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::construct(b3AlignedAllocator<b3GrahamVector3, 16>::pointer, const b3AlignedAllocator<b3GrahamVector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::deallocate(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GrahamVector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3GrahamVector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -428,7 +423,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3InternalEdge, 16>::pointer b3AlignedA
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::construct(b3AlignedAllocator<b3InternalEdge, 16>::pointer, const b3AlignedAllocator<b3InternalEdge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::deallocate(b3AlignedAllocator<b3InternalEdge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalEdge, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3InternalEdge, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -449,7 +443,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3InternalVertexPair, 16>::pointer b3Al
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::construct(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer, const b3AlignedAllocator<b3InternalVertexPair, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::deallocate(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3InternalVertexPair, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3InternalVertexPair, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -528,11 +521,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:2 <471:6 471:21> 471:41> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -573,11 +562,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -618,11 +603,7 @@ SYMBOL_METHOD: public b3MyFace & b3AlignedObjectArray<b3MyFace>::expand(const b3
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::push_back(const b3MyFace &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3MyFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch(const b3MyFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch2(const b3MyFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -661,11 +642,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::pus
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch2(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -705,15 +682,11 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::push_back(cons
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3GrahamVector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
SYMBOL_STRUCT: b3AngleCompareFunc [b3GrahamScan2dConvexHull.h <36:1 <36:8 36:25> 57:1>]
SYMBOL_METHOD: public bool b3AngleCompareFunc::operator()(const b3GrahamVector3 &, const b3GrahamVector3 &) const [b3GrahamScan2dConvexHull.h <42:2 <42:2 <42:7 42:16> 42:74> 56:2>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3GrahamScan2dConvexHull.h <24:8 <24:8 24:22> 24:22>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GrahamVector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findLinearSearch(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GrahamVector3>::findLinearSearch2(const b3GrahamVector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -753,11 +726,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::push_back(const
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3InternalEdge>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalEdge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findLinearSearch(const b3InternalEdge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalEdge>::findLinearSearch2(const b3InternalEdge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -797,11 +766,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::push_back
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3InternalVertexPair>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3InternalVertexPair>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findLinearSearch(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3InternalVertexPair>::findLinearSearch2(const b3InternalVertexPair &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2586,8 +2551,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2629,8 +2592,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2672,8 +2633,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAlloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> b3AlignedAllocator<b3MyFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2711,8 +2670,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::dealloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2754,8 +2711,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3GrahamVector3, 16>::deallocate(b3Align
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GrahamVector3, 16>::destroy(b3AlignedAllocator<b3GrahamVector3, 16>::pointer) -> b3AlignedAllocator<b3GrahamVector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GrahamVector3, 16>::self_type & b3AlignedAllocator<b3GrahamVector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &, const b3AlignedAllocator<b3GrahamVector3, 16>::self_type &) -> b3AlignedAllocator<b3GrahamVector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2797,8 +2752,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3InternalEdge, 16>::deallocate(b3Aligne
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalEdge, 16>::destroy(b3AlignedAllocator<b3InternalEdge, 16>::pointer) -> b3AlignedAllocator<b3InternalEdge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalEdge, 16>::self_type & b3AlignedAllocator<b3InternalEdge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalEdge, 16>::self_type &, const b3AlignedAllocator<b3InternalEdge, 16>::self_type &) -> b3AlignedAllocator<b3InternalEdge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2840,8 +2793,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3InternalVertexPair, 16>::deallocate(b3
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3InternalVertexPair, 16>::destroy(b3AlignedAllocator<b3InternalVertexPair, 16>::pointer) -> b3AlignedAllocator<b3InternalVertexPair, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3InternalVertexPair, 16>::self_type & b3AlignedAllocator<b3InternalVertexPair, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &, const b3AlignedAllocator<b3InternalVertexPair, 16>::self_type &) -> b3AlignedAllocator<b3InternalVertexPair, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3201,14 +3152,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3218,7 +3161,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3Align
REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <422:4 422:9>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <422:21 422:26>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3404,19 +3346,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3589,19 +3522,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> bool b3Ali
REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> b3MyFace * b3AlignedObjectArray<b3MyFace>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> int b3AlignedObjectArray<b3MyFace>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3MyFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> b3MyFace [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> b3MyFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3727,19 +3651,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullCompute
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3904,10 +3819,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> boo
REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> b3GrahamVector3 * b3AlignedObjectArray<b3GrahamVector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::reserve(int) -> int b3AlignedObjectArray<b3GrahamVector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3GrahamVector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> b3AngleCompareFunc [b3AlignedObjectArray.h <341:32 341:32>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -3923,11 +3835,6 @@ REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3
REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) -> void b3AlignedObjectArray<b3GrahamVector3>::quickSortInternal<b3AngleCompareFunc>(const b3AngleCompareFunc &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> b3GrahamVector3 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::downHeap<typename L>(b3GrahamVector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -3940,7 +3847,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b
REFERENCE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 * b3AlignedObjectArray<b3GrahamVector3>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3AlignedObjectArray.h <422:19 422:19>]
REFERENCE_CALL: void b3AlignedObjectArray<b3GrahamVector3>::swap(int, int) -> b3GrahamVector3 & b3GrahamVector3::operator=(const b3GrahamVector3 &) [b3AlignedObjectArray.h <423:19 423:19>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GrahamVector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GrahamVector3>::findBinarySearch(const b3GrahamVector3 &) const -> b3GrahamVector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4098,19 +4004,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> bool
REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> b3InternalEdge * b3AlignedObjectArray<b3InternalEdge>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::reserve(int) -> int b3AlignedObjectArray<b3InternalEdge>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3InternalEdge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> b3InternalEdge [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::downHeap<typename L>(b3InternalEdge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalEdge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalEdge>::findBinarySearch(const b3InternalEdge &) const -> b3InternalEdge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4269,19 +4166,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -
REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -> b3InternalVertexPair * b3AlignedObjectArray<b3InternalVertexPair>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::reserve(int) -> int b3AlignedObjectArray<b3InternalVertexPair>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3InternalVertexPair>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> b3InternalVertexPair [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::downHeap<typename L>(b3InternalVertexPair *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3InternalVertexPair>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3InternalVertexPair>::findBinarySearch(const b3InternalVertexPair &) const -> b3InternalVertexPair [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Collision_NarrowPhaseCollision_b3CpuNarrowPhase.txt
-176
View File
@@ -296,7 +296,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::b3AlignedAllocator(const b3AlignedAllocator<int, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -331,7 +330,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Vector3, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -352,7 +350,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::pointer b3AlignedAllocat
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::construct(b3AlignedAllocator<b3MyFace, 16>::pointer, const b3AlignedAllocator<b3MyFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3MyFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3MyFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -374,7 +371,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3GpuFace, 16>::pointer b3AlignedAlloca
SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::construct(b3AlignedAllocator<b3GpuFace, 16>::pointer, const b3AlignedAllocator<b3GpuFace, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::deallocate(b3AlignedAllocator<b3GpuFace, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3GpuFace, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3GpuFace, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -396,7 +392,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Collidable, 16>::pointer b3AlignedAll
SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::construct(b3AlignedAllocator<b3Collidable, 16>::pointer, const b3AlignedAllocator<b3Collidable, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::deallocate(b3AlignedAllocator<b3Collidable, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Collidable, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Collidable, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -418,7 +413,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer b3
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::construct(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::deallocate(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexPolyhedronData, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -440,7 +434,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Contact4Data, 16>::pointer b3AlignedA
SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::construct(b3AlignedAllocator<b3Contact4Data, 16>::pointer, const b3AlignedAllocator<b3Contact4Data, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::deallocate(b3AlignedAllocator<b3Contact4Data, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Contact4Data, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Contact4Data, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -462,7 +455,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3RigidBodyData, 16>::pointer b3Aligned
SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::construct(b3AlignedAllocator<b3RigidBodyData, 16>::pointer, const b3AlignedAllocator<b3RigidBodyData, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::deallocate(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_CLASS: b3AlignedAllocator<b3Aabb, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
SYMBOL_TYPEDEF: private b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -481,7 +473,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Aabb, 16>::pointer b3AlignedAllocator
SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::construct(b3AlignedAllocator<b3Aabb, 16>::pointer, const b3AlignedAllocator<b3Aabb, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::deallocate(b3AlignedAllocator<b3Aabb, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Aabb, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3Aabb, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -503,7 +494,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexUtility *, 16>::pointer b3Align
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::construct(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer, const b3AlignedAllocator<b3ConvexUtility *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::deallocate(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexUtility *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexUtility *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -524,7 +514,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::pointer b3AlignedAllocator
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::construct(b3AlignedAllocator<b3Int4, 16>::pointer, const b3AlignedAllocator<b3Int4, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:16 89:25> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_GLOBAL_VARIABLE: const __m128 b3vMzeroMask [b3Vector3.h <58:37 58:48>]
SYMBOL_GLOBAL_VARIABLE: const __m128 b3v1110 [b3Vector3.h <59:37 59:43>]
@@ -1081,11 +1070,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1123,11 +1108,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1166,11 +1147,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::push_back(const b3Int4
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Int4>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch(const b3Int4 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Int4>::findLinearSearch2(const b3Int4 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1210,11 +1187,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::push_back(const b3Aabb
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Aabb>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Aabb>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findLinearSearch(const b3Aabb &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Aabb>::findLinearSearch2(const b3Aabb &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1252,11 +1225,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::push_back(cons
SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3RigidBodyData>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3RigidBodyData>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findLinearSearch(const b3RigidBodyData &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3RigidBodyData>::findLinearSearch2(const b3RigidBodyData &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1297,11 +1266,7 @@ SYMBOL_METHOD: public b3Contact4Data & b3AlignedObjectArray<b3Contact4Data>::exp
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::push_back(const b3Contact4Data &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Contact4Data>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Contact4Data>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findLinearSearch(const b3Contact4Data &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Contact4Data>::findLinearSearch2(const b3Contact4Data &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1340,11 +1305,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::push_back(const b3MyF
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:23 295:30> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:24 300:30> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3MyFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch(const b3MyFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3MyFace>::findLinearSearch2(const b3MyFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1385,11 +1346,7 @@ SYMBOL_METHOD: public b3GpuFace & b3AlignedObjectArray<b3GpuFace>::expand(const
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::push_back(const b3GpuFace &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3GpuFace>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3GpuFace>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findLinearSearch(const b3GpuFace &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3GpuFace>::findLinearSearch2(const b3GpuFace &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1430,11 +1387,7 @@ SYMBOL_METHOD: public b3ConvexPolyhedronData & b3AlignedObjectArray<b3ConvexPoly
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::push_back(const b3ConvexPolyhedronData &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexPolyhedronData>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexPolyhedronData>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findLinearSearch(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexPolyhedronData>::findLinearSearch2(const b3ConvexPolyhedronData &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1472,11 +1425,7 @@ SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::capacity() const [
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::push_back(const b3Collidable &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Collidable>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Collidable>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findLinearSearch(const b3Collidable &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Collidable>::findLinearSearch2(const b3Collidable &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1514,11 +1463,7 @@ SYMBOL_METHOD: public b3ConvexUtility * & b3AlignedObjectArray<b3ConvexUtility *
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::push_back(b3ConvexUtility * const &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexUtility *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexUtility *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findLinearSearch(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexUtility *>::findLinearSearch2(b3ConvexUtility * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -3134,8 +3079,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3177,8 +3120,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3216,8 +3157,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3MyFace, 16>::deallocate(b3AlignedAlloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3MyFace, 16>::destroy(b3AlignedAllocator<b3MyFace, 16>::pointer) -> b3AlignedAllocator<b3MyFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3MyFace, 16>::self_type & b3AlignedAllocator<b3MyFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3MyFace, 16>::self_type &, const b3AlignedAllocator<b3MyFace, 16>::self_type &) -> b3AlignedAllocator<b3MyFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3259,8 +3198,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3GpuFace, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3GpuFace, 16>::destroy(b3AlignedAllocator<b3GpuFace, 16>::pointer) -> b3AlignedAllocator<b3GpuFace, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3GpuFace, 16>::self_type & b3AlignedAllocator<b3GpuFace, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3GpuFace, 16>::self_type &, const b3AlignedAllocator<b3GpuFace, 16>::self_type &) -> b3AlignedAllocator<b3GpuFace, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3302,8 +3239,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Collidable, 16>::deallocate(b3AlignedA
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Collidable, 16>::destroy(b3AlignedAllocator<b3Collidable, 16>::pointer) -> b3AlignedAllocator<b3Collidable, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Collidable, 16>::self_type & b3AlignedAllocator<b3Collidable, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Collidable, 16>::self_type &, const b3AlignedAllocator<b3Collidable, 16>::self_type &) -> b3AlignedAllocator<b3Collidable, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3345,8 +3280,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::deallocate(
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexPolyhedronData, 16>::destroy(b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type & b3AlignedAllocator<b3ConvexPolyhedronData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &, const b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type &) -> b3AlignedAllocator<b3ConvexPolyhedronData, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3388,8 +3321,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Contact4Data, 16>::deallocate(b3Aligne
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Contact4Data, 16>::destroy(b3AlignedAllocator<b3Contact4Data, 16>::pointer) -> b3AlignedAllocator<b3Contact4Data, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Contact4Data, 16>::self_type & b3AlignedAllocator<b3Contact4Data, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Contact4Data, 16>::self_type &, const b3AlignedAllocator<b3Contact4Data, 16>::self_type &) -> b3AlignedAllocator<b3Contact4Data, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3425,8 +3356,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::deallocate(b
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3RigidBodyData, 16>::destroy(b3AlignedAllocator<b3RigidBodyData, 16>::pointer) -> b3AlignedAllocator<b3RigidBodyData, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3RigidBodyData, 16>::self_type & b3AlignedAllocator<b3RigidBodyData, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &, const b3AlignedAllocator<b3RigidBodyData, 16>::self_type &) -> b3AlignedAllocator<b3RigidBodyData, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3468,8 +3397,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Aabb, 16>::deallocate(b3AlignedAllocat
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Aabb, 16>::destroy(b3AlignedAllocator<b3Aabb, 16>::pointer) -> b3AlignedAllocator<b3Aabb, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Aabb, 16>::self_type & b3AlignedAllocator<b3Aabb, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Aabb, 16>::self_type &, const b3AlignedAllocator<b3Aabb, 16>::self_type &) -> b3AlignedAllocator<b3Aabb, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3511,8 +3438,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexUtility *, 16>::deallocate(b3Ali
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexUtility *, 16>::destroy(b3AlignedAllocator<b3ConvexUtility *, 16>::pointer) -> b3AlignedAllocator<b3ConvexUtility *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexUtility *, 16>::self_type & b3AlignedAllocator<b3ConvexUtility *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &, const b3AlignedAllocator<b3ConvexUtility *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexUtility *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3548,8 +3473,6 @@ REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::deallocate(b3AlignedA
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Int4, 16>::destroy(b3AlignedAllocator<b3Int4, 16>::pointer) -> b3AlignedAllocator<b3Int4, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Int4, 16>::self_type & b3AlignedAllocator<b3Int4, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Int4, 16>::self_type &, const b3AlignedAllocator<b3Int4, 16>::self_type &) -> b3AlignedAllocator<b3Int4, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -6858,19 +6781,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7040,19 +6954,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7159,19 +7064,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::reserve(in
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Int4>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> b3Int4 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::downHeap<typename L>(b3Int4 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Int4>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Int4>::findBinarySearch(const b3Int4 &) const -> b3Int4 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7331,19 +7227,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> bool b3Align
REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> b3Aabb * b3AlignedObjectArray<b3Aabb>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Aabb>::reserve(int) -> int b3AlignedObjectArray<b3Aabb>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Aabb>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> b3Aabb [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::downHeap<typename L>(b3Aabb *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Aabb>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Aabb>::findBinarySearch(const b3Aabb &) const -> b3Aabb [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7452,19 +7339,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3RigidBodyData>::r
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3RigidBodyData>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> b3RigidBodyData [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::downHeap<typename L>(b3RigidBodyData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3RigidBodyData>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3RigidBodyData>::findBinarySearch(const b3RigidBodyData &) const -> b3RigidBodyData [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7642,19 +7520,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> bool
REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> b3Contact4Data * b3AlignedObjectArray<b3Contact4Data>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::reserve(int) -> int b3AlignedObjectArray<b3Contact4Data>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Contact4Data>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> b3Contact4Data [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::downHeap<typename L>(b3Contact4Data *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Contact4Data>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Contact4Data>::findBinarySearch(const b3Contact4Data &) const -> b3Contact4Data [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7780,19 +7649,10 @@ REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::reserve(
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> void [b3AlignedObjectArray.h <300:19 300:22>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::reserve(int) -> int [b3AlignedObjectArray.h <300:32 300:34>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3MyFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> b3MyFace [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::downHeap<typename L>(b3MyFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3MyFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3MyFace>::findBinarySearch(const b3MyFace &) const -> b3MyFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -7962,19 +7822,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> bool b3Al
REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> b3GpuFace * b3AlignedObjectArray<b3GpuFace>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3GpuFace>::reserve(int) -> int b3AlignedObjectArray<b3GpuFace>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3GpuFace>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> b3GpuFace [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::downHeap<typename L>(b3GpuFace *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3GpuFace>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3GpuFace>::findBinarySearch(const b3GpuFace &) const -> b3GpuFace [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8140,19 +7991,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int)
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int) -> b3ConvexPolyhedronData * b3AlignedObjectArray<b3ConvexPolyhedronData>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::reserve(int) -> int b3AlignedObjectArray<b3ConvexPolyhedronData>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexPolyhedronData>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> b3ConvexPolyhedronData [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::downHeap<typename L>(b3ConvexPolyhedronData *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexPolyhedronData>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexPolyhedronData>::findBinarySearch(const b3ConvexPolyhedronData &) const -> b3ConvexPolyhedronData [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8316,19 +8158,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> bool b
REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> b3Collidable * b3AlignedObjectArray<b3Collidable>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Collidable>::reserve(int) -> int b3AlignedObjectArray<b3Collidable>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Collidable>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> b3Collidable [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::downHeap<typename L>(b3Collidable *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Collidable>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Collidable>::findBinarySearch(const b3Collidable &) const -> b3Collidable [b3AlignedObjectArray.h <452:29 452:29>]
@@ -8486,19 +8319,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> b
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> b3ConvexUtility * * b3AlignedObjectArray<b3ConvexUtility *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexUtility *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexUtility *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> b3ConvexUtility [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::downHeap<typename L>(b3ConvexUtility * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexUtility *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexUtility *>::findBinarySearch(b3ConvexUtility * const &) const -> b3ConvexUtility [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3ConvexHullComputer.txt
+2 -98
View File
@@ -296,7 +296,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_CLASS: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
SYMBOL_TYPEDEF: private b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -316,7 +315,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointe
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::construct(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::deallocate(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_CLASS: b3AlignedAllocator<int, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
SYMBOL_TYPEDEF: private b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -333,7 +331,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::pointer b3AlignedAllocator<in
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::construct(b3AlignedAllocator<int, 16>::pointer, const b3AlignedAllocator<int, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_CLASS: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16> [b3AlignedAllocator.h <60:1 <61:7 61:24> 102:1>]
SYMBOL_TYPEDEF: private b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <63:46 63:54>]
@@ -351,7 +348,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::po
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -372,7 +368,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::poi
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -392,7 +387,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::poin
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::construct(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::deallocate(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::~b3AlignedAllocator() [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::b3AlignedAllocator(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16> &) [b3AlignedAllocator.h <61:7 <61:7 61:24> 61:24>]
@@ -626,11 +620,7 @@ SYMBOL_METHOD: public b3Vector3 & b3AlignedObjectArray<b3Vector3>::expand(const
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Vector3 &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -671,11 +661,7 @@ SYMBOL_METHOD: public b3ConvexHullComputer::Edge & b3AlignedObjectArray<b3Convex
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::push_back(const b3ConvexHullComputer::Edge &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findLinearSearch2(const b3ConvexHullComputer::Edge &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -713,11 +699,7 @@ SYMBOL_METHOD: public int & b3AlignedObjectArray<int>::expand(const int &) [b3Al
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::push_back(const int &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<int>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findBinarySearch(const int &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch(const int &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<int>::findLinearSearch2(const int &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -755,11 +737,7 @@ SYMBOL_METHOD: public b3ConvexHullInternal::Vertex * & b3AlignedObjectArray<b3Co
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::push_back(b3ConvexHullInternal::Vertex * const &) [b3AlignedObjectArray.h <276:3 <276:3 <276:24 276:32> 276:47> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findLinearSearch(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findLinearSearch2(b3ConvexHullInternal::Vertex * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -800,14 +778,10 @@ SYMBOL_METHOD: public b3ConvexHullInternal::Point32 & b3AlignedObjectArray<b3Con
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::push_back(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <276:3 <276:24 276:32> 291:3>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Point32>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <341:3 <341:3 <341:8 341:24> 341:61> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:3 <413:8 413:11> 413:34> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) [b3AlignedObjectArray.h <371:3 <371:3 <371:8 371:16> 371:38> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3ConvexHullComputer.cpp <82:9 <82:9 82:15> 82:15>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findLinearSearch(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findLinearSearch2(const b3ConvexHullInternal::Point32 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -845,11 +819,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::p
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3ConvexHullInternal::Face *>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findLinearSearch(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findLinearSearch2(b3ConvexHullInternal::Face * const &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -2159,8 +2129,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2202,8 +2170,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::dealloc
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::destroy(b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type & b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullComputer::Edge, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2245,8 +2211,6 @@ REFERENCE_CALL: void b3AlignedAllocator<int, 16>::deallocate(b3AlignedAllocator<
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<int, 16>::destroy(b3AlignedAllocator<int, 16>::pointer) -> b3AlignedAllocator<int, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<int, 16>::self_type & b3AlignedAllocator<int, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<int, 16>::self_type &, const b3AlignedAllocator<int, 16>::self_type &) -> b3AlignedAllocator<int, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2288,8 +2252,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::dea
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Vertex *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2331,8 +2293,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::deal
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Point32, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2374,8 +2334,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::deall
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::destroy(b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type & b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &, const b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type &) -> b3AlignedAllocator<b3ConvexHullInternal::Face *, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -3561,19 +3519,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3741,19 +3690,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> b3ConvexHullComputer::Edge * b3AlignedObjectArray<b3ConvexHullComputer::Edge>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullComputer::Edge>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::downHeap<typename L>(b3ConvexHullComputer::Edge *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullComputer::Edge>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullComputer::Edge>::findBinarySearch(const b3ConvexHullComputer::Edge &) const -> b3ConvexHullComputer::Edge [b3AlignedObjectArray.h <452:29 452:29>]
@@ -3916,19 +3856,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> bool b3AlignedO
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int * b3AlignedObjectArray<int>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<int>::reserve(int) -> int b3AlignedObjectArray<int>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<int>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::downHeap<typename L>(int *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<int>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<int>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<int>::findBinarySearch(const int &) const -> int [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4114,19 +4045,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::rese
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::reserve(int) -> b3ConvexHullInternal::Vertex * * b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> b3ConvexHullInternal::Vertex [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::downHeap<typename L>(b3ConvexHullInternal::Vertex * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Vertex *>::findBinarySearch(b3ConvexHullInternal::Vertex * const &) const -> b3ConvexHullInternal::Vertex [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4287,10 +4209,7 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reser
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reserve(int) -> b3ConvexHullInternal::Point32 * b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Point32>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<typename T>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:8 341:24>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <341:32 341:32>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
@@ -4304,17 +4223,12 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quick
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) [b3AlignedObjectArray.h <357:6 357:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <364:5 364:21>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <366:5 366:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<typename T>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:8 371:16>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <371:24 371:24>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::size() const [b3AlignedObjectArray.h <374:8 374:11>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::size() const [b3AlignedObjectArray.h <376:37 376:40>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSort<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &) -> void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::quickSortInternal<bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &)>(bool(const b3ConvexHullInternal::Point32 &, const b3ConvexHullInternal::Point32 &) &, int, int) [b3AlignedObjectArray.h <376:5 376:21>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> b3ConvexHullInternal::Point32 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::downHeap<typename L>(b3ConvexHullInternal::Point32 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
@@ -4327,7 +4241,6 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 * b3AlignedObjectArray<b3ConvexHullInternal::Point32>::m_data [b3AlignedObjectArray.h <423:4 423:9>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <422:19 422:19>]
REFERENCE_CALL: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::swap(int, int) -> b3ConvexHullInternal::Point32 & b3ConvexHullInternal::Point32::operator=(const b3ConvexHullInternal::Point32 &) [b3AlignedObjectArray.h <423:19 423:19>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Point32>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Point32>::findBinarySearch(const b3ConvexHullInternal::Point32 &) const -> b3ConvexHullInternal::Point32 [b3AlignedObjectArray.h <452:29 452:29>]
@@ -4483,19 +4396,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserv
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) -> b3ConvexHullInternal::Face * * b3AlignedObjectArray<b3ConvexHullInternal::Face *>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::reserve(int) -> int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3ConvexHullInternal::Face *>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> b3ConvexHullInternal::Face [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::downHeap<typename L>(b3ConvexHullInternal::Face * *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3ConvexHullInternal::Face *>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3ConvexHullInternal::Face *>::findBinarySearch(b3ConvexHullInternal::Face * const &) const -> b3ConvexHullInternal::Face [b3AlignedObjectArray.h <452:29 452:29>]
bin/test/data/CxxIndexSampleProjectsTestSuite/Bullet3/expected_output/Bullet3Geometry_b3GeometryUtil.txt
-16
View File
@@ -248,7 +248,6 @@ SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::pointer b3AlignedAlloca
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::construct(b3AlignedAllocator<b3Vector3, 16>::pointer, const b3AlignedAllocator<b3Vector3, 16>::value_type &) [b3AlignedAllocator.h <88:2 <88:16 88:24> 88:116>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <89:2 <89:2 <89:16 89:25> 89:49> 91:2>]
SYMBOL_METHOD: public void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) [b3AlignedAllocator.h <92:2 <92:16 92:22> 92:105>]
SYMBOL_METHOD: public b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) [b3AlignedAllocator.h <99:2 <99:14 99:22> 99:87>]
SYMBOL_FUNCTION: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) [b3AlignedAllocator.h <101:2 <101:14 101:23> 101:81>]
SYMBOL_GLOBAL_VARIABLE: const __m128 b3vMzeroMask [b3Vector3.h <58:37 58:48>]
SYMBOL_GLOBAL_VARIABLE: const __m128 b3v1110 [b3Vector3.h <59:37 59:43>]
@@ -479,11 +478,7 @@ SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::push_back(const b3Ve
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::capacity() const [b3AlignedObjectArray.h <295:3 <295:3 <295:23 295:30> 295:38> 298:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::reserve(int) [b3AlignedObjectArray.h <300:3 <300:3 <300:24 300:30> 300:42> 326:3>]
SYMBOL_CLASS: public b3AlignedObjectArray<b3Vector3>::less [b3AlignedObjectArray.h <329:9 329:12>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) [b3AlignedObjectArray.h <341:3 <341:8 341:24> 367:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) [b3AlignedObjectArray.h <371:3 <371:8 371:16> 378:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) [b3AlignedObjectArray.h <383:3 <383:8 383:15> 411:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::swap(int, int) [b3AlignedObjectArray.h <413:3 <413:8 413:11> 426:3>]
SYMBOL_METHOD: public void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) [b3AlignedObjectArray.h <429:2 <429:7 429:14> 449:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const [b3AlignedObjectArray.h <452:2 <452:6 452:21> 468:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch(const b3Vector3 &) const [b3AlignedObjectArray.h <471:2 <471:6 471:21> 485:2>]
SYMBOL_METHOD: public int b3AlignedObjectArray<b3Vector3>::findLinearSearch2(const b3Vector3 &) const [b3AlignedObjectArray.h <487:5 <487:9 487:25> 501:5>]
@@ -1240,8 +1235,6 @@ REFERENCE_CALL: void b3AlignedAllocator<b3Vector3, 16>::deallocate(b3AlignedAllo
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void b3AlignedAllocator<typename T, unsigned int Alignment>::destroy(b3AlignedAllocator<typename T, unsigned int Alignment>::pointer) [b3AlignedAllocator.h <92:16 92:22>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> void [b3AlignedAllocator.h <92:2 92:5>]
REFERENCE_TYPE_USAGE: void b3AlignedAllocator<b3Vector3, 16>::destroy(b3AlignedAllocator<b3Vector3, 16>::pointer) -> b3AlignedAllocator<b3Vector3, 16>::pointer [b3AlignedAllocator.h <92:28 92:34>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <99:2 99:10>]
REFERENCE_TYPE_USAGE: b3AlignedAllocator<b3Vector3, 16>::self_type & b3AlignedAllocator<b3Vector3, 16>::operator=<typename O>(const b3AlignedAllocator<typename T, unsigned int Alignment> &) -> b3AlignedAllocator<typename T, unsigned int Alignment> [b3AlignedAllocator.h <99:31 99:48>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> bool [b3AlignedAllocator.h <101:9 101:12>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:32 101:40>]
REFERENCE_TYPE_USAGE: bool operator==(const b3AlignedAllocator<b3Vector3, 16>::self_type &, const b3AlignedAllocator<b3Vector3, 16>::self_type &) -> b3AlignedAllocator<b3Vector3, 16>::self_type [b3AlignedAllocator.h <101:52 101:60>]
@@ -2421,19 +2414,10 @@ REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> bool b3Al
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> b3Vector3 * b3AlignedObjectArray<b3Vector3>::m_data [b3AlignedObjectArray.h <321:5 321:10>]
REFERENCE_USAGE: void b3AlignedObjectArray<b3Vector3>::reserve(int) -> int b3AlignedObjectArray<b3Vector3>::m_capacity [b3AlignedObjectArray.h <323:5 323:14>]
REFERENCE_TEMPLATE_SPECIALIZATION: b3AlignedObjectArray<b3Vector3>::less -> b3AlignedObjectArray<typename T>::less [b3AlignedObjectArray.h <329:9 329:12>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> void [b3AlignedObjectArray.h <341:3 341:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:47 341:49>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSortInternal<typename L>(const L &, int, int) -> int [b3AlignedObjectArray.h <341:55 341:57>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::quickSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <371:3 371:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> void [b3AlignedObjectArray.h <383:3 383:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> b3Vector3 [b3AlignedObjectArray.h <383:17 383:17>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:26 383:28>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::downHeap<typename L>(b3Vector3 *, int, int, const L &) -> int [b3AlignedObjectArray.h <383:33 383:35>]
REFERENCE_TEMPLATE_SPECIALIZATION: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void b3AlignedObjectArray<typename T>::swap(int, int) [b3AlignedObjectArray.h <413:8 413:11>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> void [b3AlignedObjectArray.h <413:3 413:6>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:13 413:15>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::swap(int, int) -> int [b3AlignedObjectArray.h <413:24 413:26>]
REFERENCE_TYPE_USAGE: void b3AlignedObjectArray<b3Vector3>::heapSort<typename L>(const L &) -> void [b3AlignedObjectArray.h <429:2 429:5>]
REFERENCE_TEMPLATE_SPECIALIZATION: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int b3AlignedObjectArray<typename T>::findBinarySearch(const T &) const [b3AlignedObjectArray.h <452:6 452:21>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> int [b3AlignedObjectArray.h <452:2 452:4>]
REFERENCE_TYPE_USAGE: int b3AlignedObjectArray<b3Vector3>::findBinarySearch(const b3Vector3 &) const -> b3Vector3 [b3AlignedObjectArray.h <452:29 452:29>]
src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp
+18 -1
View File
@@ -66,7 +66,7 @@ CanonicalFilePathCache* CxxAstVisitor::getCanonicalFilePathCache() const
void CxxAstVisitor::indexDecl(clang::Decl* d)
{
LOG_INFO("starting AST traversal");
//d->dump();
this->TraverseDecl(d);
}
@@ -236,6 +236,23 @@ bool CxxAstVisitor::traverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& d)
return ret;
}
bool CxxAstVisitor::TraverseCXXMethodDecl(clang::CXXMethodDecl* d)
{
if (d->getTemplatedKind() == clang::CXXMethodDecl::TK_FunctionTemplate)
{
if (clang::CXXRecordDecl* recordDecl = d->getParent())
{
if (!clang::isa<clang::ClassTemplatePartialSpecializationDecl>(recordDecl) &&
clang::isa<clang::ClassTemplateSpecializationDecl>(recordDecl) &&
!clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(recordDecl)->isExplicitSpecialization())
{
return true; // we skip visiting an implicit definition of a template method and its contents
}
}
}
return Base::TraverseCXXMethodDecl(d);
}
// same as Base::TraverseTemplateTypeParmDecl(..) but we need to integrate the setter for the context info.
bool CxxAstVisitor::TraverseTemplateTypeParmDecl(clang::TemplateTypeParmDecl* d)
{
src/lib_cxx/data/parser/cxx/CxxAstVisitor.h
+1
View File
@@ -67,6 +67,7 @@ public:
virtual bool TraverseCXXRecordDecl(clang::CXXRecordDecl* d);
bool traverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& d);
virtual bool TraverseCXXMethodDecl(clang::CXXMethodDecl* d);
virtual bool TraverseTemplateTypeParmDecl(clang::TemplateTypeParmDecl* d);
virtual bool TraverseTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl* d);
virtual bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc);
src/lib_cxx/data/parser/cxx/CxxAstVisitorComponentIndexer.cpp
+46 -11
View File
@@ -191,13 +191,12 @@ void CxxAstVisitorComponentIndexer::visitClassTemplateSpecializationDecl(clang::
{
if (getAstVisitor()->shouldVisitDecl(d))
{
clang::NamedDecl* specializedFromDecl = nullptr;
clang::CXXRecordDecl* specializedFromDecl = nullptr;
// todo: use context and childcontext!!
llvm::PointerUnion<clang::ClassTemplateDecl*, clang::ClassTemplatePartialSpecializationDecl*> pu = d->getSpecializedTemplateOrPartial();
if (pu.is<clang::ClassTemplateDecl*>())
{
specializedFromDecl = pu.get<clang::ClassTemplateDecl*>();
specializedFromDecl = pu.get<clang::ClassTemplateDecl*>()->getTemplatedDecl();
}
else if (pu.is<clang::ClassTemplatePartialSpecializationDecl*>())
{
@@ -330,14 +329,49 @@ void CxxAstVisitorComponentIndexer::visitFunctionDecl(clang::FunctionDecl* d)
if (d->isFunctionTemplateSpecialization())
{
Id templateId = getOrCreateSymbolId(d->getPrimaryTemplate()->getTemplatedDecl());
m_client->recordSymbolKind(templateId, SYMBOL_FUNCTION);
m_client->recordReference(
REFERENCE_TEMPLATE_SPECIALIZATION,
templateId,
symbolId,
getParseLocation(d->getLocation())
);
if (clang::isa<clang::ClassTemplateSpecializationDecl>(d->getParent()) &&
!clang::isa<clang::ClassTemplatePartialSpecializationDecl>(d->getParent()) &&
!clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(d->getParent())->isExplicitSpecialization())
{
// record edge from Foo<int>::bar<float>() to Foo<T>::bar<U>() instead of recording an edge from Foo<int>::bar<float>() to Foo<int>::bar<U>()
// because there is not "written" code for Foo<int>::bar<U>() if Foo<int> is an implicit template specialization.
if (clang::CXXRecordDecl* declaringRecordDecl = clang::dyn_cast_or_null<clang::CXXRecordDecl>(d->getParent()))
{
if (clang::CXXRecordDecl* declaringRecordTemplateDecl = declaringRecordDecl->getTemplateInstantiationPattern())
{
for (clang::Decl* templateMethodDecl : declaringRecordTemplateDecl->decls())
{
if (clang::FunctionTemplateDecl* functionTemplateDecl = clang::dyn_cast_or_null<clang::FunctionTemplateDecl>(templateMethodDecl))
{
if (d->getName() == functionTemplateDecl->getName())
{
Id templateMethodId = getOrCreateSymbolId(functionTemplateDecl);
m_client->recordSymbolKind(templateMethodId, SYMBOL_METHOD);
m_client->recordReference(
REFERENCE_TEMPLATE_SPECIALIZATION,
templateMethodId,
symbolId,
getParseLocation(d->getLocation())
);
break;
}
}
}
}
}
}
else
{
// record edge from foo<int>() to foo<T>()
Id templateId = getOrCreateSymbolId(d->getPrimaryTemplate()->getTemplatedDecl());
m_client->recordSymbolKind(templateId, SYMBOL_FUNCTION);
m_client->recordReference(
REFERENCE_TEMPLATE_SPECIALIZATION,
templateId,
symbolId,
getParseLocation(d->getLocation())
);
}
}
}
}
@@ -363,6 +397,7 @@ void CxxAstVisitorComponentIndexer::visitCXXMethodDecl(clang::CXXMethodDecl* d)
);
}
// record edge from Foo::bar<int>() to Foo::bar<T>()
recordTemplateMemberSpecialization(
d->getMemberSpecializationInfo(),
symbolId,
src/test/CxxParserTestSuite.h
+28 -1
View File
@@ -15,8 +15,35 @@
class CxxParserTestSuite: public CxxTest::TestSuite
{
public:
void test_cxx_parser_skips_implicit_template_method_definition_of_implicit_template_class_instantiation()
{
std::shared_ptr<TestIntermediateStorage> client = parseCode(
"template <typename T>\n"
"class A\n"
"{\n"
"public:\n"
" template <typename U>\n"
" void foo() {}\n"
"};\n"
"\n"
"int main()\n"
"{\n"
" A<int>().foo<float>();\n"
" return 0;\n"
"}\n"
);
void test_foofooofooofow()
TS_ASSERT( /*NOT!*/ !utility::containsElement<std::wstring>(
client->methods, L"public void A<int>::foo<typename U>() <6:2 <6:7 6:9> 6:14>"
));
TS_ASSERT(utility::containsElement<std::wstring>(
client->templateSpecializations, L"void A<int>::foo<float>() -> void A<typename T>::foo<typename U>() <6:7 6:9>"
));
}
void test_foofooofooofow1()
{
{
std::shared_ptr<TestIntermediateStorage> client = parseCode(