BodyCreationSettings.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/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
#include <Jolt/Physics/Collision/CollisionGroup.h>
#include <Jolt/Physics/Body/MotionType.h>
#include <Jolt/Physics/Body/MotionQuality.h>
#include <Jolt/Physics/Body/AllowedDOFs.h>
#include <Jolt/ObjectStream/SerializableObject.h>
#include <Jolt/Core/StreamUtils.h>
 
JPH_NAMESPACE_BEGIN
 
class StreamIn;
class StreamOut;
 
enum class EOverrideMassProperties : uint8
{
    CalculateMassAndInertia,            
    CalculateInertia,                   
    MassAndInertiaProvided              
};
 
class JPH_EXPORT BodyCreationSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, BodyCreationSettings)
 
    
                            BodyCreationSettings() = default;
                            BodyCreationSettings(const ShapeSettings *inShape, RVec3Arg inPosition, QuatArg inRotation, EMotionType inMotionType, ObjectLayer inObjectLayer) : mPosition(inPosition), mRotation(inRotation), mObjectLayer(inObjectLayer), mMotionType(inMotionType), mShape(inShape) { }
                            BodyCreationSettings(const Shape *inShape, RVec3Arg inPosition, QuatArg inRotation, EMotionType inMotionType, ObjectLayer inObjectLayer) : mPosition(inPosition), mRotation(inRotation), mObjectLayer(inObjectLayer), mMotionType(inMotionType), mShapePtr(inShape) { }
 
    const ShapeSettings *   GetShapeSettings() const                                        { return mShape; }
    void                    SetShapeSettings(const ShapeSettings *inShape)                  { mShape = inShape; mShapePtr = nullptr; }
 
    Shape::ShapeResult      ConvertShapeSettings();
 
    const Shape *           GetShape() const;
    void                    SetShape(const Shape *inShape)                                  { mShapePtr = inShape; mShape = nullptr; }
 
    bool                    HasMassProperties() const                                       { return mAllowDynamicOrKinematic || mMotionType != EMotionType::Static; }
 
    MassProperties          GetMassProperties() const;
 
    void                    SaveBinaryState(StreamOut &inStream) const;
 
    void                    RestoreBinaryState(StreamIn &inStream);
 
    using GroupFilterToIDMap = StreamUtils::ObjectToIDMap<GroupFilter>;
    using IDToGroupFilterMap = StreamUtils::IDToObjectMap<GroupFilter>;
    using ShapeToIDMap = Shape::ShapeToIDMap;
    using IDToShapeMap = Shape::IDToShapeMap;
    using MaterialToIDMap = StreamUtils::ObjectToIDMap<PhysicsMaterial>;
    using IDToMaterialMap = StreamUtils::IDToObjectMap<PhysicsMaterial>;
 
    void                    SaveWithChildren(StreamOut &inStream, ShapeToIDMap *ioShapeMap, MaterialToIDMap *ioMaterialMap, GroupFilterToIDMap *ioGroupFilterMap) const;
 
    using BCSResult = Result<BodyCreationSettings>;
 
    static BCSResult        sRestoreWithChildren(StreamIn &inStream, IDToShapeMap &ioShapeMap, IDToMaterialMap &ioMaterialMap, IDToGroupFilterMap &ioGroupFilterMap);
 
    RVec3                   mPosition = RVec3::sZero();                                     
    Quat                    mRotation = Quat::sIdentity();                                  
    Vec3                    mLinearVelocity = Vec3::sZero();                                
    Vec3                    mAngularVelocity = Vec3::sZero();                               
 
    uint64                  mUserData = 0;
 
    ObjectLayer             mObjectLayer = 0;                                               
    CollisionGroup          mCollisionGroup;                                                
 
    EMotionType             mMotionType = EMotionType::Dynamic;                             
    EAllowedDOFs            mAllowedDOFs = EAllowedDOFs::All;                               
    bool                    mAllowDynamicOrKinematic = false;                               
    bool                    mIsSensor = false;                                              
    bool                    mCollideKinematicVsNonDynamic = false;                          
    bool                    mUseManifoldReduction = true;                                   
    bool                    mApplyGyroscopicForce = false;                                  
    EMotionQuality          mMotionQuality = EMotionQuality::Discrete;                      
    bool                    mEnhancedInternalEdgeRemoval = false;                           
    bool                    mAllowSleeping = true;                                          
    float                   mFriction = 0.2f;                                               
    float                   mRestitution = 0.0f;                                            
    float                   mLinearDamping = 0.05f;                                         
    float                   mAngularDamping = 0.05f;                                        
    float                   mMaxLinearVelocity = 500.0f;                                    
    float                   mMaxAngularVelocity = 0.25f * JPH_PI * 60.0f;                   
    float                   mGravityFactor = 1.0f;                                          
    uint                    mNumVelocityStepsOverride = 0;                                  
    uint                    mNumPositionStepsOverride = 0;                                  
 
    EOverrideMassProperties mOverrideMassProperties = EOverrideMassProperties::CalculateMassAndInertia; 
    float                   mInertiaMultiplier = 1.0f;                                      
    MassProperties          mMassPropertiesOverride;                                        
 
private:
    RefConst<ShapeSettings> mShape;                                                         
    RefConst<Shape>         mShapePtr;                                                      
};
 
JPH_NAMESPACE_END