Revision control
Copy as Markdown
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qphysxworld_p.h"
#include "characterkinematic/PxControllerManager.h"
#include "extensions/PxDefaultCpuDispatcher.h"
#include "foundation/PxFoundation.h"
#include "PxPhysics.h"
#include "foundation/PxPhysicsVersion.h"
#include "PxRigidActor.h"
#include "PxScene.h"
#include "PxShape.h"
#include "PxSimulationEventCallback.h"
#include "qabstractcollisionshape_p.h"
#include "qabstractphysicsnode_p.h"
#include "qphysicsutils_p.h"
#include "qphysicsworld_p.h"
#include "qstaticphysxobjects_p.h"
#include "qtriggerbody_p.h"
QT_BEGIN_NAMESPACE
// The shape a PhysX shape was built for, or null if it was not built for one.
// Only ever compared, since the shape can be gone by the time it is looked at.
static QAbstractCollisionShape *frontendShape(const physx::PxShape *shape)
{
return shape ? static_cast<QAbstractCollisionShape *>(shape->userData) : nullptr;
}
class SimulationEventCallback : public physx::PxSimulationEventCallback
{
public:
SimulationEventCallback(QPhysicsWorld *worldIn) : world(worldIn) {};
virtual ~SimulationEventCallback() = default;
void onTrigger(physx::PxTriggerPair *pairs, physx::PxU32 count) override
{
// A body one of whose shapes leaves a trigger as another of them enters
// it has a lost and a found pair in the same batch, and taking the lost
// one first would report the body as having left and entered again. So
// the found pair is taken first, and only for the trigger and body that
// has both: every other pair is handled in the order PhysX gave it, so
// a body leaving one trigger as it enters another is still reported that
// way.
const auto replacesLostOverlap = [pairs, count](physx::PxU32 i) {
if (pairs[i].status != physx::PxPairFlag::eNOTIFY_TOUCH_FOUND)
return false;
for (physx::PxU32 j = 0; j < count; j++) {
if (pairs[j].status == physx::PxPairFlag::eNOTIFY_TOUCH_LOST
&& pairs[j].triggerActor == pairs[i].triggerActor
&& pairs[j].otherActor == pairs[i].otherActor) {
return true;
}
}
return false;
};
// Those first, then every pair in turn. Registering one of them again
// on the second pass does nothing: the body is inside already and the
// pair is one of its own already.
enum Pass { ReplacedOverlaps, EveryPair };
for (const Pass pass : { ReplacedOverlaps, EveryPair }) {
for (physx::PxU32 i = 0; i < count; i++) {
if (pass == ReplacedOverlaps && !replacesLostOverlap(i))
continue;
// ignore pairs when shapes have been deleted
if (pairs[i].flags
& (physx::PxTriggerPairFlag::eREMOVED_SHAPE_TRIGGER
| physx::PxTriggerPairFlag::eREMOVED_SHAPE_OTHER))
continue;
QTriggerBody *triggerNode =
static_cast<QTriggerBody *>(pairs[i].triggerActor->userData);
QAbstractPhysicsNode *otherNode =
static_cast<QAbstractPhysicsNode *>(pairs[i].otherActor->userData);
if (!triggerNode || !otherNode) {
qWarning() << "QtQuick3DPhysics internal error: null pointer in trigger "
"collision.";
continue;
}
// Asked per pair, since one batch can report the same node in
// several pairs and a handler run for one of them can delete a
// node a later one points at. Nothing else can: PhysX sends
// these from the thread that deletes nodes.
if (world->isNodeRemoved(triggerNode) || world->isNodeRemoved(otherNode))
continue;
// Passed on so the trigger can tell one pair of a body from
// another: PhysX reports a pair of shapes and a body is several
// of those, so one of them stopping overlapping is not the body
// leaving.
const QTriggerBody::ShapePair shapes { frontendShape(pairs[i].triggerShape),
frontendShape(pairs[i].otherShape) };
// Whether a body is worth following, and what it is owed, is
// the trigger's to decide, once per body rather than once per
// pair: a body that changes its mind while inside would
// otherwise be half followed.
if (pairs[i].status == physx::PxPairFlag::eNOTIFY_TOUCH_FOUND)
triggerNode->registerCollision(otherNode, shapes);
else if (pairs[i].status == physx::PxPairFlag::eNOTIFY_TOUCH_LOST)
triggerNode->deregisterCollision(otherNode, shapes);
}
}
}
void onConstraintBreak(physx::PxConstraintInfo * /*constraints*/,
physx::PxU32 /*count*/) override {};
void onWake(physx::PxActor ** /*actors*/, physx::PxU32 /*count*/) override {};
void onSleep(physx::PxActor ** /*actors*/, physx::PxU32 /*count*/) override {};
void onContact(const physx::PxContactPairHeader &pairHeader, const physx::PxContactPair *pairs,
physx::PxU32 nbPairs) override
{
constexpr physx::PxU32 bufferSize = 64;
physx::PxContactPairPoint contacts[bufferSize];
for (physx::PxU32 i = 0; i < nbPairs; i++) {
const physx::PxContactPair &contactPair = pairs[i];
if (contactPair.events & physx::PxPairFlag::eNOTIFY_TOUCH_FOUND) {
QAbstractPhysicsNode *trigger =
static_cast<QAbstractPhysicsNode *>(pairHeader.actors[0]->userData);
QAbstractPhysicsNode *other =
static_cast<QAbstractPhysicsNode *>(pairHeader.actors[1]->userData);
if (!trigger || !other || world->isNodeRemoved(trigger)
|| world->isNodeRemoved(other) || !trigger->m_backendObject
|| !other->m_backendObject)
continue;
const bool triggerReceive =
trigger->receiveContactReports() && other->sendContactReports();
const bool otherReceive =
other->receiveContactReports() && trigger->sendContactReports();
if (!triggerReceive && !otherReceive)
continue;
physx::PxU32 nbContacts = pairs[i].extractContacts(contacts, bufferSize);
QList<QVector3D> positions;
QList<QVector3D> impulses;
QList<QVector3D> normals;
positions.reserve(nbContacts);
impulses.reserve(nbContacts);
normals.reserve(nbContacts);
for (physx::PxU32 j = 0; j < nbContacts; j++) {
physx::PxVec3 position = contacts[j].position;
physx::PxVec3 impulse = contacts[j].impulse;
physx::PxVec3 normal = contacts[j].normal;
positions.push_back(QPhysicsUtils::toQtType(position));
impulses.push_back(QPhysicsUtils::toQtType(impulse));
normals.push_back(QPhysicsUtils::toQtType(normal));
}
QList<QVector3D> normalsInverted;
normalsInverted.reserve(normals.size());
for (const QVector3D &v : std::as_const(normals)) {
normalsInverted.push_back(QVector3D(-v.x(), -v.y(), -v.z()));
}
if (triggerReceive)
world->registerContact(other, trigger, positions, impulses, normals);
if (otherReceive)
world->registerContact(trigger, other, positions, impulses, normalsInverted);
}
}
};
void onAdvance(const physx::PxRigidBody *const * /*bodyBuffer*/,
const physx::PxTransform * /*poseBuffer*/,
const physx::PxU32 /*count*/) override {};
private:
QPhysicsWorld *world = nullptr;
};
static constexpr bool isBitSet(quint32 value, quint32 position)
{
Q_ASSERT(position <= 32);
return value & (1 << (position));
}
// If any 'id' bit is set in the other mask it means collisions should be ignored, i.e.
static bool isFilteredOut(physx::PxFilterData filterData0, physx::PxFilterData filterData1)
{
// First word is id, second is collision mask
const quint32 id0 = filterData0.word0;
const quint32 id1 = filterData1.word0;
const quint32 mask0 = filterData0.word1;
const quint32 mask1 = filterData1.word1;
return id0 < 32 && id1 < 32 && (isBitSet(mask0, id1) || isBitSet(mask1, id0));
}
static physx::PxFilterFlags
contactReportFilterShader(physx::PxFilterObjectAttributes attributes0,
physx::PxFilterData filterData0,
physx::PxFilterObjectAttributes attributes1,
physx::PxFilterData filterData1, physx::PxPairFlags &pairFlags,
const void * /*constantBlock*/, physx::PxU32 /*constantBlockSize*/)
{
if (isFilteredOut(filterData0, filterData1)) {
// We return a 'suppress' since that will still re-evaluate when filter data is changed.
return physx::PxFilterFlag::eSUPPRESS;
}
// A trigger shape does not collide, it only reports what overlaps it, so
// there is nothing to solve and nothing for a continuous sweep to do. The
// scene has CCD enabled unconditionally (see below), and PhysX warns for
// every trigger pair that asks for a CCD contact, so ask only for what a
// trigger actually needs.
if (physx::PxFilterObjectIsTrigger(attributes0)
|| physx::PxFilterObjectIsTrigger(attributes1)) {
pairFlags = physx::PxPairFlag::eTRIGGER_DEFAULT;
return physx::PxFilterFlag::eDEFAULT;
}
// Makes objects collide
const auto defaultCollisonFlags =
physx::PxPairFlag::eSOLVE_CONTACT |
physx::PxPairFlag::eDETECT_DISCRETE_CONTACT |
physx::PxPairFlag::eDETECT_CCD_CONTACT; // will be ignored by physX engine if the ccd is disabled
// For trigger body detection
const auto notifyTouchFlags =
physx::PxPairFlag::eNOTIFY_TOUCH_FOUND | physx::PxPairFlag::eNOTIFY_TOUCH_LOST;
// For contact detection
const auto notifyContactFlags = physx::PxPairFlag::eNOTIFY_CONTACT_POINTS;
pairFlags = defaultCollisonFlags | notifyTouchFlags | notifyContactFlags;
return physx::PxFilterFlag::eDEFAULT;
}
#define PHYSX_RELEASE(x) \
if (x != nullptr) { \
x->release(); \
x = nullptr; \
}
void QPhysXWorld::createWorld()
{
auto &s_physx = StaticPhysXObjects::getReference();
s_physx.foundationRefCount++;
if (s_physx.foundationCreated)
return;
s_physx.foundation = PxCreateFoundation(
PX_PHYSICS_VERSION, s_physx.defaultAllocatorCallback, s_physx.defaultErrorCallback);
if (!s_physx.foundation)
qFatal("PxCreateFoundation failed!");
s_physx.foundationCreated = true;
}
void QPhysXWorld::deleteWorld()
{
auto &s_physx = StaticPhysXObjects::getReference();
s_physx.foundationRefCount--;
if (s_physx.foundationRefCount == 0) {
PHYSX_RELEASE(controllerManager);
PHYSX_RELEASE(scene);
PHYSX_RELEASE(s_physx.dispatcher);
// Every node releases its material when it is cleaned up, which happens before the
// last world is deleted, so nothing should be left to release here
Q_ASSERT(s_physx.materials.isEmpty());
s_physx.materials.clear();
PHYSX_RELEASE(s_physx.physics);
PHYSX_RELEASE(s_physx.foundation);
delete callback;
callback = nullptr;
s_physx.foundationCreated = false;
s_physx.physicsCreated = false;
} else {
delete callback;
callback = nullptr;
PHYSX_RELEASE(controllerManager);
PHYSX_RELEASE(scene);
}
}
void QPhysXWorld::createScene(float typicalLength, float typicalSpeed, const QVector3D &gravity,
QPhysicsWorld *physicsWorld, unsigned int numThreads)
{
if (scene) {
qWarning() << "Scene already created";
return;
}
physx::PxTolerancesScale scale;
scale.length = typicalLength;
scale.speed = typicalSpeed;
auto &s_physx = StaticPhysXObjects::getReference();
if (!s_physx.physicsCreated) {
constexpr bool recordMemoryAllocations = true;
s_physx.physics = PxCreatePhysics(PX_PHYSICS_VERSION, *s_physx.foundation, scale,
recordMemoryAllocations);
if (!s_physx.physics)
qFatal("PxCreatePhysics failed!");
s_physx.dispatcher = physx::PxDefaultCpuDispatcherCreate(numThreads);
s_physx.physicsCreated = true;
}
callback = new SimulationEventCallback(physicsWorld);
physx::PxSceneDesc sceneDesc(scale);
sceneDesc.gravity = QPhysicsUtils::toPhysXType(gravity);
sceneDesc.cpuDispatcher = s_physx.dispatcher;
sceneDesc.filterShader = contactReportFilterShader;
// CCD is always enabled at the scene level. Since PhysX's CCD pass is cheap enough
// (see PxsCCDContext::updateCCD) when there are no CCD-enabled bodies in the scene,
// it makes the code simpler.
sceneDesc.flags |= physx::PxSceneFlag::eENABLE_CCD;
sceneDesc.solverType = physx::PxSolverType::eTGS;
sceneDesc.simulationEventCallback = callback;
if (physicsWorld->reportKinematicKinematicCollisions())
sceneDesc.kineKineFilteringMode = physx::PxPairFilteringMode::eKEEP;
if (physicsWorld->reportStaticKinematicCollisions())
sceneDesc.staticKineFilteringMode = physx::PxPairFilteringMode::eKEEP;
switch (physicsWorld->staticQueryStructure()) {
case QPhysicsWorld::QueryStructure::NoStructure: {
Q_ASSERT(false && "Unreachable: setStaticQueryStructure() rejects NoStructure");
break;
}
case QPhysicsWorld::QueryStructure::StaticTree: {
sceneDesc.staticStructure = physx::PxPruningStructureType::eSTATIC_AABB_TREE;
break;
}
case QPhysicsWorld::QueryStructure::DynamicTree: {
sceneDesc.staticStructure = physx::PxPruningStructureType::eDYNAMIC_AABB_TREE;
break;
}
}
switch (physicsWorld->dynamicQueryStructure()) {
case QPhysicsWorld::QueryStructure::NoStructure: {
sceneDesc.dynamicStructure = physx::PxPruningStructureType::eNONE;
break;
}
case QPhysicsWorld::QueryStructure::StaticTree: {
sceneDesc.dynamicStructure = physx::PxPruningStructureType::eSTATIC_AABB_TREE;
break;
}
case QPhysicsWorld::QueryStructure::DynamicTree: {
sceneDesc.dynamicStructure = physx::PxPruningStructureType::eDYNAMIC_AABB_TREE;
break;
}
}
scene = s_physx.physics->createScene(sceneDesc);
}
QT_END_NAMESPACE