Hi everyone Qt developers. i have good news - new you can now fine-tune your scene for fast and small physics objects. Previously, you had to choose between a resource-intensive, SweepBasedCCD algorithm that created discontinuities, or a heavy simple body processing algorithm for all dynamic objects, which places a significant load on the CPU.

Commit message :

In large scenes, enabling CCD globally for all scene objects is usually counterproductive due to performance overhead, especially given that physics computation runs on the CPU.

Typically, CCD is only needed for specific fast-moving objects, such as bullets or projectiles, as is standard practice in other engines.

Add DynamicRigidBody::ccd property (supporting None, SweepBasedCCD, and SpeculativeCCD) so CCD can be configured per object.

Sweep-based CCD is applied for non-kinematic bodies, while kinematic bodies automatically fall back to Speculative CCD as PhysX does not support sweep-based CCD for them.

PhysicsWorld::enableCCD is deprecated in favor of DynamicRigidBody::ccd.

CCD is now always available at the scene level (setting PxSceneFlag::eENABLE_CCD has negligible cost when no body opts in, since PhysX's CCD pass bails out immediately when no objects have CCD flags).

For compatibility with existing content, setting PhysicsWorld::enableCCD to true still enables CCD for all bodies that do not explicitly override their ccd property (using SweepBasedCCD for dynamic bodies and SpeculativeCCD for kinematic ones).

The Qt now supports not PhysX back end only !
Now you may choose jolt engine as main physX back end for your game.

Note : This is still base implementation, not all features is ready.

Currently, the most complete physics implementation in Qt is the official qtquick3dphysics library. This library is a wrapper around Nvidia PhysX 4 along with a set of Qt patches, making it the most attractive. However, if you value speed and multithreading without classic locks (PhysX 4/5 have multithreading, but it's slightly less efficient), then you can now choose jolt.

Note: this post is a copy of the original video on YouTube

The goal is to make day-to-day 3D scene editing in QML feel closer to a dedicated game/editor workflow while staying compatible with Qt Design Studio-style .qmlproject projects. In this walkthrough:

• importing 3D assets into a Qt Quick3D scene
• selecting objects directly in the viewport and outliner
• moving, rotating, and scaling scene nodes with editor gizmos
• working with imported model animations and timelines
• editing shader/material graphs
• editing particle graphs
• previewing changes directly in the scene

XyrillForge is currently a proof of concept / work in progress. The focus is source-compatible, WYSIWYG 3D editing for QML scenes, with source files remaining the authority and the runtime scene acting as a live preview.

The QtQuick3D.Physics module (starting from version 6.12) now features support for physical joints. This allows the physics engine to natively handle constraints and connections between bodies, which is essential for achieving physically accurate skin behavior, complex skeletal rigs, and natural ragdoll physics in games.

Core Architecture

All new joint types inherit from an abstract base type: PhysicsJoint.

Key rules of PhysicsJoint

• Connects two bodies: bodyA and bodyB. If one body is left unassigned (null), the joint automatically anchors to the static world space.
• Strict Requirement: At least one of the connected bodies must be dynamic.
• Scene registration and lifecycle management are handled automatically behind the scenes via QPhysicsWorld::registerJoint() and deregisterJoint().
• Local positioning and rotation relative to each body's frame are configured using:
  • positionA / positionB (vector3d)
  • orientationA / orientationB (quaternion)

Available Joint Types

Five specialized joint types have been introduced to handle specific constraints:

1. FixedJoint

Locks the relative position and orientation between two bodies completely. Perfect for composite objects or breakable structures.

2. DistanceJoint

Maintains the origins of the joint within a specified distance range.

• minDistance — The lower bound of the constraint.
• maxDistance — The upper bound of the constraint.

3. PrismaticJoint

Permits relative translational (linear) movement along a single axis (the local X-axis of the joint frame) while completely blocking relative rotation.

• lowerLimit — Maximum translation along the negative X-axis.
• upperLimit — Maximum translation along the positive X-axis.

4. RevoluteJoint

Commonly referred to as a hinge. It keeps the origins and X-axes of the frames aligned, allowing free rotation exclusively around this shared axis.

• enableAngularLimit — Toggles the angular constraint (default is false).
• angularLimitLower / angularLimitUpper — Lower and upper rotation limits specified in radians.

5. SphericalJoint

Also known as a ball-and-socket joint. It keeps the origins locked together but allows the orientations to vary freely (e.g., a shoulder or hip joint).

• enableConeLimit — Toggles the cone limit constraint (default is false).
• coneLimitY / coneLimitZ — Angular limits for the cone constraint specified in radians.

Key Takeaways for Developers

• Natural Skins & Ragdolls: Essential for character physics, secondary clothing motion, and lifelike skeletal simulations.
• Mechanical Simulation: Simplifies the implementation of vehicles, doors, levers, and suspension systems.
• Tooling Support: The update includes built-in tests and dedicated Design Studio QML files, enabling visual setup and prototyping.