1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/* Copyright (c) <2003-2011> <Julio Jerez, Newton Game Dynamics>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/
#if !defined(AFX_DGCOLLISIONCOMPOUND_H__E164CA46_D0ED_46EE_8130_46C4004940BA__INCLUDED_)
#define AFX_DGCOLLISIONCOMPOUND_H__E164CA46_D0ED_46EE_8130_46C4004940BA__INCLUDED_
#include "dgCollision.h"
#include "dgContact.h"
class dgCollisionConvex;
#define DG_COMPOUND_STACK_DEPTH 256
class dgCollisionCompound : public dgCollision {
protected:
enum dgNodeType {
m_leaf,
m_node,
};
class OOBBTestData {
public:
OOBBTestData(const dgMatrix &matrix);
OOBBTestData(const dgMatrix &matrix, const dgVector &p0, const dgVector &p1);
dgMatrix m_matrix;
dgMatrix m_absMatrix;
dgVector m_origin;
dgVector m_size;
dgVector m_localP0;
dgVector m_localP1;
dgVector m_aabbP0;
dgVector m_aabbP1;
dgVector m_crossAxis[3][3];
dgVector m_crossAxisAbs[3][3];
dgVector m_crossAxisDotAbs[3][3];
dgVector m_extends[3][3];
};
DG_MSC_VECTOR_ALIGMENT
class dgNodeBase {
public:
DG_CLASS_ALLOCATOR(allocator)
dgNodeBase();
dgNodeBase(dgCollisionConvex *const m_shape, dgInt32 id);
dgNodeBase(dgNodeBase *const left, dgNodeBase *const right, dgInt32 id);
~dgNodeBase();
void reset();
bool BoxTest(const OOBBTestData &data) const;
bool BoxTest(const OOBBTestData &data, const dgNodeBase *const otherNode) const;
dgFloat32 BoxClosestDistance(const dgVector *const points, dgInt32 count) const;
dgVector m_p0;
dgVector m_p1;
dgVector m_size;
dgVector m_origin;
dgInt32 m_type;
dgInt32 m_id;
dgFloat32 m_area;
dgNodeBase *m_left;
dgNodeBase *m_right;
dgNodeBase *m_parent;
dgCollisionConvex *m_shape;
} DG_GCC_VECTOR_ALIGMENT;
class dgHeapNodePair {
public:
dgInt32 m_nodeA;
dgInt32 m_nodeB;
};
public:
dgCollisionCompound(dgWorld *world);
dgCollisionCompound(const dgCollisionCompound &source);
dgCollisionCompound(dgInt32 count, dgCollisionConvex *const shapeArray[], dgWorld *world);
dgCollisionCompound(dgWorld *const world, dgDeserialize deserialization, void *const userData);
virtual ~dgCollisionCompound();
void AddCollision(dgCollisionConvex *part);
// void RemoveCollision (dgCollisionConvex* part);
void RemoveCollision(dgNodeBase *node);
protected:
void Init(dgInt32 count, dgCollisionConvex *const shapeArray[]);
virtual dgFloat32 GetVolume() const;
virtual dgFloat32 GetBoxMinRadius() const;
virtual dgFloat32 GetBoxMaxRadius() const;
virtual dgVector SupportVertex(const dgVector &dir) const;
virtual void CalcAABB(const dgMatrix &matrix, dgVector &p0, dgVector &p1) const;
virtual void CalcAABBSimd(const dgMatrix &matrix, dgVector &p0, dgVector &p1) const;
virtual bool OOBBTest(const dgMatrix &matrix, const dgCollisionConvex *const shape, void *const cacheOrder) const;
virtual void DebugCollision(const dgMatrix &matrix, OnDebugCollisionMeshCallback callback, void *const userData) const;
virtual void CalculateInertia(dgVector &inertia, dgVector &origin) const;
virtual dgVector CalculateVolumeIntegral(const dgMatrix &globalMatrix, GetBuoyancyPlane bouyancyPlane, void *const context) const;
virtual dgFloat32 RayCast(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const;
virtual dgFloat32 RayCastSimd(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const;
dgNodeBase *BuildTree(dgInt32 count, dgCollisionConvex *const shapeArray[]);
virtual dgInt32 CalculateSignature() const;
virtual void SetCollisionBBox(const dgVector &p0, const dgVector &p1);
virtual void GetCollisionInfo(dgCollisionInfo *info) const;
virtual void Serialize(dgSerialize callback, void *const userData) const;
void LinkParentNodes();
dgInt32 CalculateContacts(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 CalculateContactsToSingle(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 CalculateContactsToCompound(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 CalculateContactsToCollisionTree(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 CalculateContactsToHeightField(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 CalculateContactsBruteForce(dgCollidingPairCollector::dgPair *const pair, dgCollisionParamProxy &proxy, dgInt32 useSimd) const;
dgInt32 ClosestDitance(dgBody *const bodyA, dgTriplex &contactA, dgBody *const bodyB, dgTriplex &contactB, dgTriplex &normalAB) const;
#ifdef _DEBUG
dgVector IntenalSupportVertex(const dgVector &dir) const;
#endif
protected:
// dgInt32 GetAxis (dgNodeBase** const proxiArray, dgInt32 boxCount) const;
// static dgInt32 CompareBox (const dgNodeBase* const boxA, const dgNodeBase* const boxB, void* const context);
// dgNodeBase* BuildBottomUpTree(dgInt32 count, dgNodeBase** const proxiArray);
void ImproveNodeFitness(dgNodeBase *const node) const;
dgNodeBase *BuildTopDownTree(dgInt32 count, dgNodeBase **const proxiArray, dgInt32 &id);
void PushNodes(dgNodeBase *const root, dgNodeBase **const proxiArray, dgInt32 &index) const;
dgFloat32 CalculateSurfaceArea(dgNodeBase *const node0, dgNodeBase *const node1, dgVector &minBox, dgVector &maxBox) const;
dgInt32 m_count;
dgFloat32 m_boxMinRadius;
dgFloat32 m_boxMaxRadius;
dgWorld *m_world;
dgNodeBase *m_root;
dgCollisionConvex **m_array;
OnCompoundCollisionPrefilter *m_preCollisionFilter;
friend class dgBody;
friend class dgWorld;
};
#endif
|
