C++ JoltPhysics：高性能物理引擎深度解析

icy 昨天 17 抢沙发

默认

摘要： C++ JoltPhysics：高性能物理引擎深度解析项目概述 JoltPhysics 是一个用现代 C++ 编写的高性能物理引擎，由 Jorrit Rouwe 开发并开源。该项...

C++ JoltPhysics：高性能物理引擎深度解析

项目概述

JoltPhysics 是一个用现代 C++ 编写的高性能物理引擎，由 Jorrit Rouwe 开发并开源。该项目专注于游戏和实时模拟应用，提供了完整的刚体动力学解决方案，具有卓越的性能和内存效率。

核心特性

1. 高性能架构

SIMD 优化：广泛使用 SIMD 指令进行向量和矩阵运算
多线程支持：内置作业系统，充分利用多核处理器
内存高效：精心设计的数据结构，减少内存碎片

2. 物理功能

刚体动力学：支持静态、动态和运动学刚体
碰撞检测：多种碰撞形状（球体、盒子、胶囊、凸包等）
约束系统：丰富的关节类型（铰链、滑块、圆锥扭转等）
连续碰撞检测：防止高速物体穿透

3. 现代 C++ 特性

使用 C++17 标准
模板元编程优化
RAII 资源管理
零成本抽象设计

基础使用示例

环境配置

text

# CMakeLists.txt
find_package(JoltPhysics REQUIRED)
target_link_libraries(your_target PRIVATE Jolt::Jolt)

简单物理场景创建

text

#include <Jolt/Jolt.h>
#include <Jolt/RegisterTypes.h>
#include <Jolt/Core/Factory.h>
#include <Jolt/Core/TempAllocator.h>
#include <Jolt/Core/JobSystemThreadPool.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Collision/Shape/BoxShape.h>
#include <Jolt/Physics/Collision/Shape/SphereShape.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Body/BodyActivationListener.h>

using namespace JPH;

// 初始化物理系统
void InitializePhysics()
{
    // 注册所有类型
    RegisterTypes();
    
    // 创建工厂
    Factory::sInstance = new Factory();
    
    // 创建分配器
    TempAllocatorImpl temp_allocator(10 * 1024 * 1024);
    
    // 创建任务系统
    JobSystemThreadPool job_system(cMaxPhysicsJobs, cMaxPhysicsBarriers, 
                                   thread::hardware_concurrency() - 1);
    
    // 创建物理系统
    PhysicsSystem physics_system;
    physics_system.Init(cMaxBodies, cNumBodyMutexes, cMaxBodyPairs, 
                       cMaxContactConstraints, broad_phase_layer_interface, 
                       object_vs_broadphase_layer_filter, 
                       object_vs_object_layer_filter);
    
    // 设置重力
    physics_system.SetGravity(Vec3(0, -9.81f, 0));
}

创建刚体示例

text

// 创建地面（静态刚体）
BodyInterface& body_interface = physics_system.GetBodyInterface();

// 创建盒子形状
RefConst<Shape> floor_shape = new BoxShape(Vec3(100.0f, 1.0f, 100.0f));

// 创建地面刚体
BodyCreationSettings floor_settings(floor_shape, 
                                   RVec3(0.0f, -1.0f, 0.0f), 
                                   Quat::sIdentity(), 
                                   EMotionType::Static, 
                                   Layers::NON_MOVING);
BodyID floor_id = body_interface.CreateBody(floor_settings);
body_interface.AddBody(floor_id, EActivation::DontActivate);

// 创建动态球体
RefConst<Shape> sphere_shape = new SphereShape(1.0f);

// 创建球体刚体
BodyCreationSettings sphere_settings(sphere_shape, 
                                    RVec3(0.0f, 10.0f, 0.0f), 
                                    Quat::sIdentity(), 
                                    EMotionType::Dynamic, 
                                    Layers::MOVING);
sphere_settings.mRestitution = 0.5f;  // 设置弹性系数
sphere_settings.mFriction = 0.8f;     // 设置摩擦系数

BodyID sphere_id = body_interface.CreateBody(sphere_settings);
body_interface.AddBody(sphere_id, EActivation::Activate);

物理模拟循环

text

// 物理模拟更新
void UpdatePhysics(PhysicsSystem& physics_system, float delta_time)
{
    // 物理系统更新
    physics_system.Update(delta_time, 
                         cCollisionSteps, 
                         cIntegrationSubSteps, 
                         &temp_allocator, 
                         &job_system);
    
    // 获取所有活动刚体
    BodyInterface& body_interface = physics_system.GetBodyInterface();
    const BodyID* body_ids = physics_system.GetBodies();
    uint32_t num_bodies = physics_system.GetNumBodies();
    
    // 更新刚体状态
    for (uint32_t i = 0; i < num_bodies; ++i)
    {
        BodyID body_id = body_ids[i];
        BodyLockRead lock(physics_system.GetBodyLockInterface(), body_id);
        if (lock.Succeeded())
        {
            const Body& body = lock.GetBody();
            if (body.IsActive())
            {
                // 获取位置和旋转
                RVec3 position = body.GetPosition();
                Quat rotation = body.GetRotation();
                
                // 更新游戏对象
                UpdateGameObject(body_id, position, rotation);
            }
        }
    }
}

碰撞检测示例

text

// 自定义碰撞监听器
class MyContactListener : public ContactListener
{
public:
    // 接触开始
    virtual ValidateResult OnContactValidate(const Body& inBody1, 
                                            const Body& inBody2, 
                                            RVec3Arg inBaseOffset, 
                                            const CollideShapeResult& inCollisionResult) override
    {
        // 可以在这里过滤碰撞
        return ValidateResult::AcceptAllContactsForThisBodyPair;
    }
    
    // 接触添加
    virtual void OnContactAdded(const Body& inBody1, 
                               const Body& inBody2, 
                               const ContactManifold& inManifold, 
                               ContactSettings& ioSettings) override
    {
        // 处理碰撞开始事件
        std::cout << "Collision detected between body " 
                  << inBody1.GetID().GetIndex() 
                  << " and " 
                  << inBody2.GetID().GetIndex() 
                  << std::endl;
    }
    
    // 接触持续
    virtual void OnContactPersisted(const Body& inBody1, 
                                   const Body& inBody2, 
                                   const ContactManifold& inManifold, 
                                   ContactSettings& ioSettings) override
    {
        // 处理持续碰撞
    }
    
    // 接触移除
    virtual void OnContactRemoved(const SubShapeIDPair& inSubShapePair) override
    {
        // 处理碰撞结束
    }
};

// 使用自定义碰撞监听器
MyContactListener contact_listener;
physics_system.SetContactListener(&contact_listener);

高级特性示例

角色控制器

text

// 创建角色控制器
CharacterVirtualSettings settings;
settings.mMaxSlopeAngle = DegreesToRadians(45.0f);
settings.mShape = new CapsuleShape(0.5f * settings.mHeight, settings.mRadius);
settings.mSupportingVolume = Plane(Vec3::sAxisY(), -settings.mHeight); 

CharacterVirtual* character = new CharacterVirtual(&settings, 
                                                   RVec3::sZero(), 
                                                   Quat::sIdentity(), 
                                                   &physics_system);

射线检测

text

// 执行射线检测
RayCastResult result;
RayCast ray(RVec3(0, 10, 0), Vec3(0, -20, 0));  // 从上向下的射线

// 忽略特定层
DefaultBroadPhaseLayerFilter broadphase_layer_filter = 
    physics_system.GetDefaultBroadPhaseLayerFilter(Layers::MOVING);
DefaultObjectLayerFilter object_layer_filter = 
    physics_system.GetDefaultLayerFilter(Layers::MOVING);

// 执行检测
bool hit = physics_system.GetNarrowPhaseQuery().CastRay(
    ray, 
    result, 
    broadphase_layer_filter, 
    object_layer_filter
);

if (hit)
{
    std::cout << "Hit body: " << result.mBodyID.GetIndex() 
              << " at distance: " << result.mFraction 
              << std::endl;
}