~ubuntu-branches/ubuntu/vivid/emscripten/vivid

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.

#ifndef BT_SIMPLE_BROADPHASE_H

#define BT_SIMPLE_BROADPHASE_H

#include "btOverlappingPairCache.h"

struct btSimpleBroadphaseProxy : public btBroadphaseProxy

{

int m_nextFree;

// int m_handleId;

btSimpleBroadphaseProxy() {};

btSimpleBroadphaseProxy(const btVector3& minpt,const btVector3& maxpt,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask,void* multiSapProxy)

:btBroadphaseProxy(minpt,maxpt,userPtr,collisionFilterGroup,collisionFilterMask,multiSapProxy)

{

(void)shapeType;

}

SIMD_FORCE_INLINE void SetNextFree(int next) {m_nextFree = next;}

SIMD_FORCE_INLINE int GetNextFree() const {return m_nextFree;}

};

///The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead.

///It is a brute force aabb culling broadphase based on O(n^2) aabb checks

class btSimpleBroadphase : public btBroadphaseInterface

{

protected:

int m_numHandles; // number of active handles

int m_maxHandles; // max number of handles

int m_LastHandleIndex;

btSimpleBroadphaseProxy* m_pHandles; // handles pool

void* m_pHandlesRawPtr;

int m_firstFreeHandle; // free handles list

int allocHandle()

{

btAssert(m_numHandles < m_maxHandles);

int freeHandle = m_firstFreeHandle;

m_firstFreeHandle = m_pHandles[freeHandle].GetNextFree();

m_numHandles++;

if(freeHandle > m_LastHandleIndex)

{

m_LastHandleIndex = freeHandle;

}

return freeHandle;

}

void freeHandle(btSimpleBroadphaseProxy* proxy)

{

int handle = int(proxy-m_pHandles);

btAssert(handle >= 0 && handle < m_maxHandles);

if(handle == m_LastHandleIndex)

{

m_LastHandleIndex--;

}

proxy->SetNextFree(m_firstFreeHandle);

m_firstFreeHandle = handle;

proxy->m_clientObject = 0;

m_numHandles--;

}

btOverlappingPairCache* m_pairCache;

bool m_ownsPairCache;

int m_invalidPair;

inline btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy)

100

{

101

btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxy);

102

return proxy0;

103

}

104

105

inline const btSimpleBroadphaseProxy* getSimpleProxyFromProxy(btBroadphaseProxy* proxy) const

106

{

107

const btSimpleBroadphaseProxy* proxy0 = static_cast<const btSimpleBroadphaseProxy*>(proxy);

108

return proxy0;

109

}

110

111

///reset broadphase internal structures, to ensure determinism/reproducability

112

virtual void resetPool(btDispatcher* dispatcher);

113

114

115

void validate();

116

117

protected:

118

119

120

121

122

public:

123

btSimpleBroadphase(int maxProxies=16384,btOverlappingPairCache* overlappingPairCache=0);

124

virtual ~btSimpleBroadphase();

125

126

127

static bool aabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1);

128

129

130

virtual btBroadphaseProxy* createProxy( const btVector3& aabbMin, const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy);

131

132

virtual void calculateOverlappingPairs(btDispatcher* dispatcher);

133

134

virtual void destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);

135

virtual void setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher);

136

virtual void getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;

137

138

virtual void rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0),const btVector3& aabbMax=btVector3(0,0,0));

139

virtual void aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);

140

141

btOverlappingPairCache* getOverlappingPairCache()

142

{

143

return m_pairCache;

144

}

145

const btOverlappingPairCache* getOverlappingPairCache() const

146

{

147

return m_pairCache;

148

}

149

150

bool testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);

151

152

153

///getAabb returns the axis aligned bounding box in the 'global' coordinate frame

154

///will add some transform later

155

virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const

156

{

157

aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_FLOAT);

158

aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOAT);

159

}

160

161

virtual void printStats()

162

{

163

// printf("btSimpleBroadphase.h\n");

164

// printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);

165

}

166

};

167

168

169

170

#endif //BT_SIMPLE_BROADPHASE_H

171

Older »