← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/bullet/src/BulletCollision/CollisionDispatch/btGhostObject.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/bullet/src/BulletCollision/CollisionDispatch/btGhostObject.cpp
 
1
/*
 
2
Bullet Continuous Collision Detection and Physics Library
 
3
Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
 
4
 
 
5
This software is provided 'as-is', without any express or implied warranty.
 
6
In no event will the authors be held liable for any damages arising from the use of this software.
 
7
Permission is granted to anyone to use this software for any purpose, 
 
8
including commercial applications, and to alter it and redistribute it freely, 
 
9
subject to the following restrictions:
 
10
 
 
11
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.
 
12
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
 
13
3. This notice may not be removed or altered from any source distribution.
 
14
*/
 
15
 
 
16
#include "btGhostObject.h"
 
17
#include "btCollisionWorld.h"
 
18
#include "BulletCollision/CollisionShapes/btConvexShape.h"
 
19
#include "LinearMath/btAabbUtil2.h"
 
20
 
 
21
btGhostObject::btGhostObject()
 
22
{
 
23
        m_internalType = CO_GHOST_OBJECT;
 
24
}
 
25
 
 
26
btGhostObject::~btGhostObject()
 
27
{
 
28
        ///btGhostObject should have been removed from the world, so no overlapping objects
 
29
        btAssert(!m_overlappingObjects.size());
 
30
}
 
31
 
 
32
 
 
33
void btGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* otherProxy,btBroadphaseProxy* thisProxy)
 
34
{
 
35
        btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
 
36
        btAssert(otherObject);
 
37
        ///if this linearSearch becomes too slow (too many overlapping objects) we should add a more appropriate data structure
 
38
        int index = m_overlappingObjects.findLinearSearch(otherObject);
 
39
        if (index==m_overlappingObjects.size())
 
40
        {
 
41
                //not found
 
42
                m_overlappingObjects.push_back(otherObject);
 
43
        }
 
44
}
 
45
 
 
46
void btGhostObject::removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy,btDispatcher* dispatcher,btBroadphaseProxy* thisProxy)
 
47
{
 
48
        btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
 
49
        btAssert(otherObject);
 
50
        int index = m_overlappingObjects.findLinearSearch(otherObject);
 
51
        if (index<m_overlappingObjects.size())
 
52
        {
 
53
                m_overlappingObjects[index] = m_overlappingObjects[m_overlappingObjects.size()-1];
 
54
                m_overlappingObjects.pop_back();
 
55
        }
 
56
}
 
57
 
 
58
 
 
59
btPairCachingGhostObject::btPairCachingGhostObject()
 
60
{
 
61
        m_hashPairCache = new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
 
62
}
 
63
 
 
64
btPairCachingGhostObject::~btPairCachingGhostObject()
 
65
{
 
66
        m_hashPairCache->~btHashedOverlappingPairCache();
 
67
        btAlignedFree( m_hashPairCache );
 
68
}
 
69
 
 
70
void btPairCachingGhostObject::addOverlappingObjectInternal(btBroadphaseProxy* otherProxy,btBroadphaseProxy* thisProxy)
 
71
{
 
72
        btBroadphaseProxy*actualThisProxy = thisProxy ? thisProxy : getBroadphaseHandle();
 
73
        btAssert(actualThisProxy);
 
74
 
 
75
        btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
 
76
        btAssert(otherObject);
 
77
        int index = m_overlappingObjects.findLinearSearch(otherObject);
 
78
        if (index==m_overlappingObjects.size())
 
79
        {
 
80
                m_overlappingObjects.push_back(otherObject);
 
81
                m_hashPairCache->addOverlappingPair(actualThisProxy,otherProxy);
 
82
        }
 
83
}
 
84
 
 
85
void btPairCachingGhostObject::removeOverlappingObjectInternal(btBroadphaseProxy* otherProxy,btDispatcher* dispatcher,btBroadphaseProxy* thisProxy1)
 
86
{
 
87
        btCollisionObject* otherObject = (btCollisionObject*)otherProxy->m_clientObject;
 
88
        btBroadphaseProxy* actualThisProxy = thisProxy1 ? thisProxy1 : getBroadphaseHandle();
 
89
        btAssert(actualThisProxy);
 
90
 
 
91
        btAssert(otherObject);
 
92
        int index = m_overlappingObjects.findLinearSearch(otherObject);
 
93
        if (index<m_overlappingObjects.size())
 
94
        {
 
95
                m_overlappingObjects[index] = m_overlappingObjects[m_overlappingObjects.size()-1];
 
96
                m_overlappingObjects.pop_back();
 
97
                m_hashPairCache->removeOverlappingPair(actualThisProxy,otherProxy,dispatcher);
 
98
        }
 
99
}
 
100
 
 
101
 
 
102
void    btGhostObject::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const
 
103
{
 
104
        btTransform     convexFromTrans,convexToTrans;
 
105
        convexFromTrans = convexFromWorld;
 
106
        convexToTrans = convexToWorld;
 
107
        btVector3 castShapeAabbMin, castShapeAabbMax;
 
108
        /* Compute AABB that encompasses angular movement */
 
109
        {
 
110
                btVector3 linVel, angVel;
 
111
                btTransformUtil::calculateVelocity (convexFromTrans, convexToTrans, 1.0, linVel, angVel);
 
112
                btTransform R;
 
113
                R.setIdentity ();
 
114
                R.setRotation (convexFromTrans.getRotation());
 
115
                castShape->calculateTemporalAabb (R, linVel, angVel, 1.0, castShapeAabbMin, castShapeAabbMax);
 
116
        }
 
117
 
 
118
        /// go over all objects, and if the ray intersects their aabb + cast shape aabb,
 
119
        // do a ray-shape query using convexCaster (CCD)
 
120
        int i;
 
121
        for (i=0;i<m_overlappingObjects.size();i++)
 
122
        {
 
123
                btCollisionObject*      collisionObject= m_overlappingObjects[i];
 
124
                //only perform raycast if filterMask matches
 
125
                if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) {
 
126
                        //RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
 
127
                        btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
 
128
                        collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
 
129
                        AabbExpand (collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
 
130
                        btScalar hitLambda = btScalar(1.); //could use resultCallback.m_closestHitFraction, but needs testing
 
131
                        btVector3 hitNormal;
 
132
                        if (btRayAabb(convexFromWorld.getOrigin(),convexToWorld.getOrigin(),collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,hitNormal))
 
133
                        {
 
134
                                btCollisionWorld::objectQuerySingle(castShape, convexFromTrans,convexToTrans,
 
135
                                        collisionObject,
 
136
                                                collisionObject->getCollisionShape(),
 
137
                                                collisionObject->getWorldTransform(),
 
138
                                                resultCallback,
 
139
                                                allowedCcdPenetration);
 
140
                        }
 
141
                }
 
142
        }
 
143
 
 
144
}
 
145
 
 
146
void    btGhostObject::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, btCollisionWorld::RayResultCallback& resultCallback) const
 
147
{
 
148
        btTransform rayFromTrans;
 
149
        rayFromTrans.setIdentity();
 
150
        rayFromTrans.setOrigin(rayFromWorld);
 
151
        btTransform  rayToTrans;
 
152
        rayToTrans.setIdentity();
 
153
        rayToTrans.setOrigin(rayToWorld);
 
154
 
 
155
 
 
156
        int i;
 
157
        for (i=0;i<m_overlappingObjects.size();i++)
 
158
        {
 
159
                btCollisionObject*      collisionObject= m_overlappingObjects[i];
 
160
                //only perform raycast if filterMask matches
 
161
                if(resultCallback.needsCollision(collisionObject->getBroadphaseHandle())) 
 
162
                {
 
163
                        btCollisionWorld::rayTestSingle(rayFromTrans,rayToTrans,
 
164
                                                        collisionObject,
 
165
                                                                collisionObject->getCollisionShape(),
 
166
                                                                collisionObject->getWorldTransform(),
 
167
                                                                resultCallback);
 
168
                }
 
169
        }
 
170
}
 
171