Revision control
++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ // Tests what a TriggerBody reports as being inside it.
++ //
++ // bodyExited is documented as being emitted when the trigger is no longer
++ // penetrated by the body, and collisionCount as the number of bodies currently
++ // colliding with it. PhysX reports one pair per pair of shapes, so a body with
++ // more than one shape, or a trigger with more than one shape, is reported
++ // several times over, and the shapes of a body are all replaced whenever any one
++ // of them changes, so the pairs of the shapes that went away are reported as
++ // lost. Neither of the two documented promises holds unless the reports are
++ // followed per pair of shapes.
++ //
++ // One scene per thing that can happen to a body a trigger holds, left to right
++ // and front to back:
++ //
++ // two shapes, one leaves a body deleted while inside
++ // shapes rebuilt while in shapes destroyed while inside
++ // a trigger rebuilt a shape carried out a sleeping body
++ // a body that only listens a body that stops asking
++ //
++ // Both directions of reporting are per body: the trigger's bodyEntered and
++ // bodyExited, and the body's own enteredTriggerBody and exitedTriggerBody, which
++ // a body asks for separately and can ask for on its own.
++ //
++ // Bodies and shapes are deleted here while a trigger is holding them, and what
++ // it holds them by is pointers. Every handler below reads the body a report
++ // hands it and counts a body it did not expect as a hundred of them, so a stale
++ // pointer shows up as a failure rather than as a number that happens to look
++ // right. Worth running against a module built with -fsanitize=address, which
++ // makes a stale one that is read a use after free:
++ //
++ // ASAN_OPTIONS=detect_leaks=0 QML_IMPORT_PATH=<build>/qml \
++ // ./test_auto_trigger_counting
++ //
++ // The trigger volumes are drawn and light up while they report holding
++ // something, so the scene can also be judged by eye: every volume with a block
++ // in it has to be lit, and only those.
++
++ import QtCore
++ import QtQuick
++ import QtTest
++ import QtQuick3D
++ import QtQuick3D.Physics
++ import QtQuick3D.Physics.TestUtils
++
++ Item {
++ id: root
++
++ width: 640
++ height: 480
++ visible: true
++
++ PhysicsWorld {
++ id: world
++ // Nothing should move except what the test moves itself.
++ gravity: Qt.vector3d(0, 0, 0)
++ running: true
++ typicalLength: 100
++ typicalSpeed: 1000
++ minimumTimestep: 16
++ maximumTimestep: 16
++ scene: viewport.scene
++
++ // The scenes are stepped in simulated time, not wall clock time, so a
++ // renderer that cannot keep up makes the test slower instead of making
++ // it sample a scene that has not moved yet.
++ property int frames: 0
++ onFrameDone: world.frames++
++ }
++
++ View3D {
++ id: viewport
++ anchors.fill: parent
++
++ environment: SceneEnvironment {
++ clearColor: "#151a3f"
++ backgroundMode: SceneEnvironment.Color
++ }
++
++ PerspectiveCamera {
++ position: Qt.vector3d(500, 300, 2100)
++ eulerRotation.x: -9
++ clipFar: 6000
++ }
++
++ DirectionalLight {
++ eulerRotation.x: -35
++ eulerRotation.y: 25
++ }
++
++ // A trigger volume, drawn so it brightens while it reports holding a body.
++ component Volume: TriggerBody {
++ id: volume
++ property color tint: "#4488ff"
++ property real span: 300
++ readonly property bool occupied: volume.collisionCount > 0
++ // What the volume is drawn as holding, which is what it counts
++ // unless the scene it is in has a body it does not count.
++ property bool lit: volume.occupied
++
++ collisionShapes: BoxShape {
++ extents: Qt.vector3d(volume.span, volume.span, volume.span)
++ }
++
++ Model {
++ source: "#Cube"
++ scale: Qt.vector3d(volume.span / 100, volume.span / 100, volume.span / 100)
++ materials: PrincipledMaterial {
++ baseColor: volume.tint
++ opacity: volume.lit ? 0.55 : 0.14
++ lighting: PrincipledMaterial.NoLighting
++ }
++ }
++ }
++
++ // Reached once the simulation has taken "frames" steps since this was
++ // started, which is what every step of every scene below waits for.
++ component AfterFrames: Timer {
++ id: gate
++ property int frames: 36
++ property int startedAt: 0
++ signal reached()
++
++ interval: 16
++ repeat: true
++ onRunningChanged: if (running) gate.startedAt = world.frames
++ onTriggered: {
++ if (world.frames - gate.startedAt < gate.frames)
++ return;
++ gate.running = false;
++ gate.reached();
++ }
++ }
++
++ component Block: Model {
++ source: "#Cube"
++ scale: Qt.vector3d(0.4, 0.4, 0.4)
++ materials: PrincipledMaterial {
++ baseColor: "#e8e8e8"
++ roughness: 0.5
++ }
++ }
++
++ // ---- one body, two shapes, sliding out ----
++
++ Volume {
++ id: straddled
++ objectName: "straddled"
++ position: Qt.vector3d(-400, 0, 0)
++ tint: "#4488ff"
++ }
++
++ DynamicRigidBody {
++ id: strider
++ objectName: "strider"
++ isKinematic: true
++ sendTriggerReports: true
++ // Both directions of the same reports, which are both per body.
++ receiveTriggerReports: true
++ kinematicPosition: Qt.vector3d(-400 + slide.offset, 0, 0)
++ collisionShapes: [
++ BoxShape { extents: Qt.vector3d(40, 40, 40); position: Qt.vector3d(-100, 0, 0) },
++ BoxShape { extents: Qt.vector3d(40, 40, 40); position: Qt.vector3d(100, 0, 0) }
++ ]
++
++ Block { position: Qt.vector3d(-100, 0, 0) }
++ Block { position: Qt.vector3d(100, 0, 0) }
++ }
++
++ QtObject {
++ id: slide
++ property real offset: 0
++ property int exits: 0
++ // Read once the leading shape is outside the trigger and the trailing
++ // one is still 30 units inside it, and once both are clear.
++ property int countWhileHalfOut: -1
++ property int exitsWhileHalfOut: -1
++ property int countWhenOut: -1
++ property int exitsWhenOut: -1
++ // The same, as the body itself hears it.
++ property int enteredSelf: 0
++ property int exitedSelf: 0
++ property int selfEntersWhileHalfOut: -1
++ property int selfExitsWhileHalfOut: -1
++ property int selfExitsWhenOut: -1
++ }
++
++ Connections {
++ target: straddled
++ function onBodyExited(body) {
++ slide.exits += (body.objectName === "strider" ? 1 : 100);
++ }
++ }
++
++ Connections {
++ target: strider
++ function onEnteredTriggerBody(body) {
++ slide.enteredSelf += (body.objectName === "straddled" ? 1 : 100);
++ }
++ function onExitedTriggerBody(body) {
++ slide.exitedSelf += (body.objectName === "straddled" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: { slide.offset = 120; halfOutGate.running = true; }
++ }
++
++ AfterFrames {
++ id: halfOutGate
++ onReached: {
++ slide.countWhileHalfOut = straddled.collisionCount;
++ slide.exitsWhileHalfOut = slide.exits;
++ slide.selfEntersWhileHalfOut = slide.enteredSelf;
++ slide.selfExitsWhileHalfOut = slide.exitedSelf;
++ slide.offset = 600;
++ goneGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: goneGate
++ onReached: {
++ slide.countWhenOut = straddled.collisionCount;
++ slide.exitsWhenOut = slide.exits;
++ slide.selfExitsWhenOut = slide.exitedSelf;
++ }
++ }
++
++ // ---- a body deleted while inside ----
++
++ Volume {
++ id: outlived
++ position: Qt.vector3d(1400, 0, 0)
++ tint: "#ff9a2e"
++ }
++
++ DynamicRigidBody {
++ id: doomed
++ objectName: "doomed"
++ sendTriggerReports: true
++ position: Qt.vector3d(1400, 0, 0)
++ collisionShapes: BoxShape {
++ extents: Qt.vector3d(40, 40, 40)
++ }
++
++ Block {}
++ }
++
++ QtObject {
++ id: deletion
++ property int countAfter: -1
++ }
++
++ AfterFrames {
++ frames: 56; running: true
++ onReached: { doomed.destroy(); deletedGate.running = true; }
++ }
++
++ AfterFrames {
++ id: deletedGate
++ // Long enough that the body's actor has actually been taken out of
++ // the scene, not just its QML object deleted.
++ frames: 75
++ onReached: deletion.countAfter = outlived.collisionCount
++ }
++
++ // ---- the shapes of a body inside rebuilt over and over ----
++
++ Volume {
++ id: shifting
++ position: Qt.vector3d(-400, 0, -900)
++ tint: "#63d471"
++ }
++
++ DynamicRigidBody {
++ id: wiggler
++ objectName: "wiggler"
++ isKinematic: true
++ sendTriggerReports: true
++ kinematicPosition: Qt.vector3d(-400 + wiggle.offset, 0, -900)
++ collisionShapes: BoxShape {
++ id: wigglingShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(wiggle.shapeX, 0, 0)
++ }
++
++ Block { position: wigglingShape.position }
++ }
++
++ QtObject {
++ id: wiggle
++ property real offset: 0
++ // Moving a shape within its body replaces every PhysX shape of that
++ // body, so this keeps them being rebuilt while the body sits inside.
++ property real shapeX: 0
++ property int enters: 0
++ property int exits: 0
++ property int countWhileRebuilt: -1
++ property int entersWhileRebuilt: -1
++ property int exitsWhileRebuilt: -1
++ property int countWhenOut: -1
++ property int exitsWhenOut: -1
++ }
++
++ Connections {
++ target: shifting
++ function onBodyEntered(body) {
++ wiggle.enters += (body.objectName === "wiggler" ? 1 : 100);
++ }
++ function onBodyExited(body) {
++ wiggle.exits += (body.objectName === "wiggler" ? 1 : 100);
++ }
++ }
++
++ Timer {
++ interval: 16; running: true; repeat: true
++ onTriggered: wiggle.shapeX = wiggle.shapeX > 0 ? -60 : 60
++ }
++
++ AfterFrames {
++ frames: 62; running: true
++ onReached: {
++ wiggle.countWhileRebuilt = shifting.collisionCount;
++ wiggle.entersWhileRebuilt = wiggle.enters;
++ wiggle.exitsWhileRebuilt = wiggle.exits;
++ wiggle.offset = 600;
++ wiggleGoneGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: wiggleGoneGate
++ onReached: {
++ wiggle.countWhenOut = shifting.collisionCount;
++ wiggle.exitsWhenOut = wiggle.exits;
++ }
++ }
++
++ // ---- the shapes of a body inside destroyed one by one ----
++
++ Volume {
++ id: trimmed
++ position: Qt.vector3d(1400, 0, -900)
++ tint: "#ffd34e"
++ }
++
++ DynamicRigidBody {
++ id: shedder
++ objectName: "shedder"
++ isKinematic: true
++ sendTriggerReports: true
++ kinematicPosition: Qt.vector3d(1400, 0, -900)
++ collisionShapes: [
++ BoxShape {
++ id: keptShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(-60, 0, 0)
++ },
++ BoxShape {
++ id: droppedShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(60, 0, 0)
++ }
++ ]
++
++ Block { position: Qt.vector3d(-60, 0, 0) }
++ Block { position: Qt.vector3d(60, 0, 0) }
++ }
++
++ QtObject {
++ id: trim
++ property int exits: 0
++ property int countWithOneShape: -1
++ property int exitsWithOneShape: -1
++ property int countWithNoShapes: -1
++ property int exitsWithNoShapes: -1
++ }
++
++ Connections {
++ target: trimmed
++ function onBodyExited(body) {
++ trim.exits += (body.objectName === "shedder" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ frames: 44; running: true
++ onReached: { droppedShape.destroy(); oneShapeGate.running = true; }
++ }
++
++ AfterFrames {
++ id: oneShapeGate
++ frames: 44
++ onReached: {
++ trim.countWithOneShape = trimmed.collisionCount;
++ trim.exitsWithOneShape = trim.exits;
++ keptShape.destroy();
++ noShapesGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: noShapesGate
++ frames: 44
++ onReached: {
++ trim.countWithNoShapes = trimmed.collisionCount;
++ trim.exitsWithNoShapes = trim.exits;
++ }
++ }
++
++ // ---- the shapes of the trigger itself rebuilt over and over ----
++
++ Volume {
++ id: resized
++ position: Qt.vector3d(-1600, 0, -1800)
++ tint: "#4dd0e1"
++ span: resize.span
++ }
++
++ DynamicRigidBody {
++ id: sitter
++ objectName: "sitter"
++ isKinematic: true
++ sendTriggerReports: true
++ kinematicPosition: Qt.vector3d(-1600, 0, -1800)
++ collisionShapes: BoxShape {
++ extents: Qt.vector3d(40, 40, 40)
++ }
++
++ Block {}
++ }
++
++ QtObject {
++ id: resize
++ property real span: 300
++ property int enters: 0
++ property int exits: 0
++ property int countWhileRebuilt: -1
++ property int entersWhileRebuilt: -1
++ property int exitsWhileRebuilt: -1
++ }
++
++ Connections {
++ target: resized
++ function onBodyEntered(body) {
++ resize.enters += (body.objectName === "sitter" ? 1 : 100);
++ }
++ function onBodyExited(body) {
++ resize.exits += (body.objectName === "sitter" ? 1 : 100);
++ }
++ }
++
++ Timer {
++ interval: 16; running: true; repeat: true
++ onTriggered: resize.span = resize.span > 320 ? 300 : 340
++ }
++
++ AfterFrames {
++ frames: 62; running: true
++ onReached: {
++ resize.countWhileRebuilt = resized.collisionCount;
++ resize.entersWhileRebuilt = resize.enters;
++ resize.exitsWhileRebuilt = resize.exits;
++ }
++ }
++
++ // ---- a shape carried out of the trigger by itself ----
++
++ Volume {
++ id: vacated
++ position: Qt.vector3d(500, 0, -1800)
++ tint: "#c86bff"
++ }
++
++ DynamicRigidBody {
++ id: stayer
++ objectName: "stayer"
++ isKinematic: true
++ sendTriggerReports: true
++ kinematicPosition: Qt.vector3d(500, 0, -1800)
++ // The body stays where it is and its only shape is moved out from
++ // under it, which the simulation reports as the pair of a shape that
++ // is already gone and nothing else.
++ collisionShapes: BoxShape {
++ id: carriedShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(carry.shapeX, 0, 0)
++ }
++
++ Block { position: carriedShape.position }
++ }
++
++ QtObject {
++ id: carry
++ property real shapeX: 0
++ property int exits: 0
++ property int countInside: -1
++ property int countOutside: -1
++ property int exitsOutside: -1
++ }
++
++ Connections {
++ target: vacated
++ function onBodyExited(body) {
++ carry.exits += (body.objectName === "stayer" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: {
++ carry.countInside = vacated.collisionCount;
++ carry.shapeX = 400;
++ carriedGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: carriedGate
++ onReached: {
++ carry.countOutside = vacated.collisionCount;
++ carry.exitsOutside = carry.exits;
++ }
++ }
++
++ // ---- the shapes of a sleeping body inside rebuilt ----
++
++ Volume {
++ id: undisturbed
++ position: Qt.vector3d(2600, 0, -1800)
++ tint: "#ff7b7b"
++ }
++
++ DynamicRigidBody {
++ // Left to the simulation, and with nothing to move it, so it falls
++ // asleep where it is well before its shape is nudged.
++ id: dozer
++ objectName: "dozer"
++ sendTriggerReports: true
++ position: Qt.vector3d(2600, 0, -1800)
++ collisionShapes: BoxShape {
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(doze.shapeX, 0, 0)
++ }
++
++ Block { position: Qt.vector3d(doze.shapeX, 0, 0) }
++ }
++
++ QtObject {
++ id: doze
++ property real shapeX: 0
++ property int exits: 0
++ property int countAfterNudge: -1
++ property int exitsAfterNudge: -1
++ }
++
++ Connections {
++ target: undisturbed
++ function onBodyExited(body) {
++ doze.exits += (body.objectName === "dozer" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ // Well past the simulated second or so it takes the body to fall
++ // asleep where it is.
++ frames: 94; running: true
++ onReached: { doze.shapeX = 20; nudgedGate.running = true; }
++ }
++
++ AfterFrames {
++ id: nudgedGate
++ frames: 56
++ onReached: {
++ doze.countAfterNudge = undisturbed.collisionCount;
++ doze.exitsAfterNudge = doze.exits;
++ }
++ }
++
++ // ---- a body that only asked to be told itself ----
++
++ Volume {
++ id: unwitting
++ objectName: "unwitting"
++ position: Qt.vector3d(500, 0, -2700)
++ tint: "#9fe870"
++ // It does not count this body, so what it counts is not what it is
++ // drawn as holding.
++ lit: listen.enters > listen.exits
++ }
++
++ DynamicRigidBody {
++ id: listener
++ objectName: "listener"
++ isKinematic: true
++ // Without sendTriggerReports the trigger neither counts it nor
++ // reports it, but it is still told about itself, once for the two
++ // shapes it has inside.
++ receiveTriggerReports: true
++ kinematicPosition: Qt.vector3d(500 + listen.offset, 0, -2700)
++ collisionShapes: [
++ BoxShape { extents: Qt.vector3d(40, 40, 40); position: Qt.vector3d(-100, 0, 0) },
++ BoxShape { extents: Qt.vector3d(40, 40, 40); position: Qt.vector3d(100, 0, 0) }
++ ]
++
++ Block { position: Qt.vector3d(-100, 0, 0) }
++ Block { position: Qt.vector3d(100, 0, 0) }
++ }
++
++ QtObject {
++ id: listen
++ property real offset: 0
++ property int enters: 0
++ property int exits: 0
++ property int triggerReports: 0
++ property int entersInside: -1
++ property int countInside: -1
++ property int triggerReportsInside: -1
++ property int exitsWhenOut: -1
++ property int countWhenOut: -1
++ }
++
++ Connections {
++ target: listener
++ function onEnteredTriggerBody(body) {
++ listen.enters += (body.objectName === "unwitting" ? 1 : 100);
++ }
++ function onExitedTriggerBody(body) {
++ listen.exits += (body.objectName === "unwitting" ? 1 : 100);
++ }
++ }
++
++ Connections {
++ target: unwitting
++ // Neither of these is about a body that did not ask for them.
++ function onBodyEntered(body) { listen.triggerReports++; }
++ function onBodyExited(body) { listen.triggerReports++; }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: {
++ listen.entersInside = listen.enters;
++ listen.countInside = unwitting.collisionCount;
++ listen.triggerReportsInside = listen.triggerReports;
++ listen.offset = 600;
++ listenGoneGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: listenGoneGate
++ onReached: {
++ listen.exitsWhenOut = listen.exits;
++ listen.countWhenOut = unwitting.collisionCount;
++ }
++ }
++
++ // ---- a body that stops asking while it is inside ----
++
++ Volume {
++ id: forsaken
++ objectName: "forsaken"
++ position: Qt.vector3d(2600, 0, -2700)
++ tint: "#ff6fb5"
++ }
++
++ DynamicRigidBody {
++ id: quitter
++ objectName: "quitter"
++ isKinematic: true
++ // Turned off while the body is inside, so nothing is asked for by
++ // the time it leaves. The trigger still has to stop holding it, and
++ // still owes it the report it was holding it for.
++ sendTriggerReports: quit.asking
++ kinematicPosition: Qt.vector3d(2600 + quit.offset, 0, -2700)
++ collisionShapes: BoxShape {
++ id: quitterShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(quit.shapeX, 0, 0)
++ }
++
++ Block { position: quitterShape.position }
++ }
++
++ QtObject {
++ id: quit
++ property bool asking: true
++ property real offset: 0
++ // Moved once the body has stopped asking, to rebuild its shapes
++ // while it is inside: the pairs of the old shape have to be taken
++ // up again by the shape that replaces it, whatever the body is
++ // asking for by then.
++ property real shapeX: 0
++ property int exits: 0
++ property int countInside: -1
++ property int countAfterRebuild: -1
++ property int exitsAfterRebuild: -1
++ property int countWhenOut: -1
++ property int exitsWhenOut: -1
++ }
++
++ Connections {
++ target: forsaken
++ function onBodyExited(body) {
++ quit.exits += (body.objectName === "quitter" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: {
++ quit.countInside = forsaken.collisionCount;
++ quit.asking = false;
++ quit.shapeX = 20;
++ quitRebuiltGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: quitRebuiltGate
++ onReached: {
++ quit.countAfterRebuild = forsaken.collisionCount;
++ quit.exitsAfterRebuild = quit.exits;
++ quit.offset = 600;
++ quitGoneGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: quitGoneGate
++ onReached: {
++ quit.countWhenOut = forsaken.collisionCount;
++ quit.exitsWhenOut = quit.exits;
++ }
++ }
++
++ // ---- a body relaying its overlap from one shape to another ----
++
++ Volume {
++ id: relayed
++ objectName: "relayed"
++ position: Qt.vector3d(-1600, 0, -2700)
++ span: 100
++ tint: "#7de08d"
++ }
++
++ DynamicRigidBody {
++ id: relayer
++ objectName: "relayer"
++ isKinematic: true
++ sendTriggerReports: true
++ // Two shapes, far enough apart that only one of them is ever inside
++ // the volume. Moved by the distance between them in one step, which
++ // takes the one that was inside out and brings the other one in, so
++ // PhysX reports the pair it lost and the pair it found in the same
++ // batch. The body has not left, and must not be reported as having.
++ kinematicPosition: Qt.vector3d(-1600 + relay.offset, 0, -2700)
++ collisionShapes: [
++ BoxShape {
++ id: relayerLeft
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(-200, 0, 0)
++ },
++ BoxShape {
++ id: relayerRight
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(200, 0, 0)
++ }
++ ]
++
++ Block { position: relayerLeft.position }
++ Block { position: relayerRight.position }
++ }
++
++ QtObject {
++ id: relay
++ // The left shape starts inside, the right one outside.
++ property real offset: 200
++ property int enters: 0
++ property int exits: 0
++ property int countInside: -1
++ property int entersInside: -1
++ property int countAfterRelay: -1
++ property int entersAfterRelay: -1
++ property int exitsAfterRelay: -1
++ }
++
++ Connections {
++ target: relayed
++ function onBodyEntered(body) {
++ relay.enters += (body.objectName === "relayer" ? 1 : 100);
++ }
++ function onBodyExited(body) {
++ relay.exits += (body.objectName === "relayer" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: {
++ relay.countInside = relayed.collisionCount;
++ relay.entersInside = relay.enters;
++ relay.offset = -200;
++ relayGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: relayGate
++ onReached: {
++ relay.countAfterRelay = relayed.collisionCount;
++ relay.entersAfterRelay = relay.enters;
++ relay.exitsAfterRelay = relay.exits;
++ }
++ }
++
++ // ---- a body that starts asking while it is already inside ----
++
++ Volume {
++ id: unasked
++ objectName: "unasked"
++ position: Qt.vector3d(1400, 0, -2700)
++ tint: "#c39bd3"
++ }
++
++ DynamicRigidBody {
++ id: silent
++ objectName: "silent"
++ isKinematic: true
++ // Asks for nothing as it enters, and starts asking once it is
++ // inside. What it asks for then decides nothing about this stay, so
++ // it must not be told it entered something it never crossed into.
++ sendTriggerReports: mute.asking
++ receiveTriggerReports: mute.asking
++ kinematicPosition: Qt.vector3d(1400, 0, -2700)
++ collisionShapes: BoxShape {
++ id: silentShape
++ extents: Qt.vector3d(40, 40, 40)
++ position: Qt.vector3d(mute.shapeX, 0, 0)
++ }
++
++ Block { position: silentShape.position }
++ }
++
++ QtObject {
++ id: mute
++ property bool asking: false
++ // Rebuilds the body's shapes while it sits inside, which is what
++ // has PhysX report its pairs as found again.
++ property real shapeX: 0
++ property int enters: 0
++ property int selfEnters: 0
++ property int countAfterAsking: -1
++ property int entersAfterAsking: -1
++ property int selfEntersAfterAsking: -1
++ }
++
++ Timer {
++ interval: 16; running: true; repeat: true
++ onTriggered: mute.shapeX = mute.shapeX > 0 ? -20 : 20
++ }
++
++ Connections {
++ target: unasked
++ function onBodyEntered(body) {
++ mute.enters += (body.objectName === "silent" ? 1 : 100);
++ }
++ }
++
++ Connections {
++ target: silent
++ function onEnteredTriggerBody(body) {
++ mute.selfEnters += (body.objectName === "unasked" ? 1 : 100);
++ }
++ }
++
++ AfterFrames {
++ running: true
++ onReached: {
++ mute.asking = true;
++ mutedGate.running = true;
++ }
++ }
++
++ AfterFrames {
++ id: mutedGate
++ onReached: {
++ mute.countAfterAsking = unasked.collisionCount;
++ mute.entersAfterAsking = mute.enters;
++ mute.selfEntersAfterAsking = mute.selfEnters;
++ }
++ }
++
++ // ---- what all of that has to add up to ----
++
++ PhysicsTestCase {
++ name: "one shape of two leaving does not report the body as gone"
++ goalReached: slide.countWhileHalfOut === 1 && slide.exitsWhileHalfOut === 0
++ }
++
++ PhysicsTestCase {
++ name: "the last shape leaving does report the body as gone"
++ goalReached: slide.countWhenOut === 0 && slide.exitsWhenOut === 1
++ }
++
++ PhysicsTestCase {
++ name: "the body hears about entering once, not once per shape"
++ goalReached: slide.selfEntersWhileHalfOut === 1 && slide.selfExitsWhileHalfOut === 0
++ }
++
++ PhysicsTestCase {
++ name: "the body hears about leaving when its last shape leaves"
++ goalReached: slide.selfExitsWhenOut === 1
++ }
++
++ PhysicsTestCase {
++ name: "a body deleted while inside stops being counted"
++ goalReached: deletion.countAfter === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body whose shapes are rebuilt stays inside, and only once"
++ goalReached: wiggle.countWhileRebuilt === 1 && wiggle.entersWhileRebuilt === 1
++ && wiggle.exitsWhileRebuilt === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body whose shapes were rebuilt still reports leaving"
++ goalReached: wiggle.countWhenOut === 0 && wiggle.exitsWhenOut === 1
++ }
++
++ PhysicsTestCase {
++ name: "one shape of two destroyed does not report the body as gone"
++ goalReached: trim.countWithOneShape === 1 && trim.exitsWithOneShape === 0
++ }
++
++ PhysicsTestCase {
++ name: "the last shape destroyed does report the body as gone"
++ goalReached: trim.countWithNoShapes === 0 && trim.exitsWithNoShapes === 1
++ }
++
++ PhysicsTestCase {
++ name: "rebuilding the shapes of the trigger reports nothing"
++ goalReached: resize.countWhileRebuilt === 1 && resize.entersWhileRebuilt === 1
++ && resize.exitsWhileRebuilt === 0
++ }
++
++ PhysicsTestCase {
++ name: "a shape moved out reports the body as gone"
++ goalReached: carry.countInside === 1 && carry.countOutside === 0
++ && carry.exitsOutside === 1
++ }
++
++ PhysicsTestCase {
++ name: "nudging the shape of a sleeping body keeps it inside"
++ goalReached: doze.countAfterNudge === 1 && doze.exitsAfterNudge === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body that only listens is told once and counted not at all"
++ goalReached: listen.entersInside === 1 && listen.countInside === 0
++ && listen.triggerReportsInside === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body that only listens is told about leaving once"
++ goalReached: listen.exitsWhenOut === 1 && listen.countWhenOut === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body that stops asking while inside is still held"
++ goalReached: quit.countInside === 1 && quit.countAfterRebuild === 1
++ && quit.exitsAfterRebuild === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body that starts asking while inside is not told it entered"
++ goalReached: mute.countAfterAsking === 0 && mute.entersAfterAsking === 0
++ && mute.selfEntersAfterAsking === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body relaying its overlap in one step is still inside"
++ goalReached: relay.countInside === 1 && relay.entersInside === 1
++ && relay.countAfterRelay === 1
++ }
++
++ PhysicsTestCase {
++ name: "a body relaying its overlap in one step is not reported again"
++ goalReached: relay.countAfterRelay === 1 && relay.entersAfterRelay === 1
++ && relay.exitsAfterRelay === 0
++ }
++
++ PhysicsTestCase {
++ name: "a body that stops asking while inside is still let go of"
++ goalReached: quit.countWhenOut === 0 && quit.exitsWhenOut === 1
++ }
++ }
++ }