PhysicsScene.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/Reference.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/SoftBody/SoftBodyCreationSettings.h>
#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;
 
class JPH_EXPORT PhysicsScene : public RefTarget<PhysicsScene>
{
    JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, PhysicsScene)
 
public:
    void                                    AddBody(const BodyCreationSettings &inBody);
 
    static constexpr uint32                 cFixedToWorld = 0xffffffff;
 
    void                                    AddConstraint(const TwoBodyConstraintSettings *inConstraint, uint32 inBody1, uint32 inBody2);
 
    void                                    AddSoftBody(const SoftBodyCreationSettings &inSoftBody);
 
    size_t                                  GetNumBodies() const                            { return mBodies.size(); }
 
    const Array<BodyCreationSettings> &     GetBodies() const                               { return mBodies; }
    Array<BodyCreationSettings> &           GetBodies()                                     { return mBodies; }
 
    class ConnectedConstraint
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, ConnectedConstraint)
 
    public:
                                            ConnectedConstraint() = default;
                                            ConnectedConstraint(const TwoBodyConstraintSettings *inSettings, uint inBody1, uint inBody2) : mSettings(inSettings), mBody1(inBody1), mBody2(inBody2) { }
 
        RefConst<TwoBodyConstraintSettings> mSettings;                                      
        uint32                              mBody1;                                         
        uint32                              mBody2;                                         
    };
 
    size_t                                  GetNumConstraints() const                       { return mConstraints.size(); }
 
    const Array<ConnectedConstraint> &      GetConstraints() const                          { return mConstraints; }
    Array<ConnectedConstraint> &            GetConstraints()                                { return mConstraints; }
 
    size_t                                  GetNumSoftBodies() const                        { return mSoftBodies.size(); }
 
    const Array<SoftBodyCreationSettings> & GetSoftBodies() const                           { return mSoftBodies; }
    Array<SoftBodyCreationSettings> &       GetSoftBodies()                                 { return mSoftBodies; }
 
    bool                                    CreateBodies(PhysicsSystem *inSystem) const;
 
    bool                                    FixInvalidScales();
 
    void                                    SaveBinaryState(StreamOut &inStream, bool inSaveShapes, bool inSaveGroupFilter) const;
 
    using PhysicsSceneResult = Result<Ref<PhysicsScene>>;
 
    static PhysicsSceneResult               sRestoreFromBinaryState(StreamIn &inStream);
 
    void                                    FromPhysicsSystem(const PhysicsSystem *inSystem);
 
private:
    Array<BodyCreationSettings>             mBodies;
 
    Array<ConnectedConstraint>              mConstraints;
 
    Array<SoftBodyCreationSettings>         mSoftBodies;
};
 
JPH_NAMESPACE_END