Plasma Engine  2.0
Loading...
Searching...
No Matches
Jolt6DOFConstraintComponent.h
1#if 0
2
3# pragma once
4
5# include <JoltPlugin/Constraints/JoltConstraintComponent.h>
6
7struct PL_JOLTPLUGIN_DLL plJoltAxis
8{
9 using StorageType = plUInt8;
10
11 enum Enum
12 {
13 None = 0,
14 X = PL_BIT(0),
15 Y = PL_BIT(1),
16 Z = PL_BIT(2),
17 All = X | Y | Z,
18 Default = All
19 };
20
21 struct Bits
22 {
23 StorageType X : 1;
24 StorageType Y : 1;
25 StorageType Z : 1;
26 };
27};
28
29PL_DECLARE_FLAGS_OPERATORS(plJoltAxis);
30PL_DECLARE_REFLECTABLE_TYPE(PL_JOLTPLUGIN_DLL, plJoltAxis);
31
32using plJolt6DOFConstraintComponentManager = plComponentManager<class plJolt6DOFConstraintComponent, plBlockStorageType::Compact>;
33
34class PL_JOLTPLUGIN_DLL plJolt6DOFConstraintComponent : public plJoltConstraintComponent
35{
36 PL_DECLARE_COMPONENT_TYPE(plJolt6DOFConstraintComponent, plJoltConstraintComponent, plJolt6DOFConstraintComponentManager);
37
39 // plComponent
40
41public:
42 virtual void SerializeComponent(plWorldWriter& stream) const override;
43 virtual void DeserializeComponent(plWorldReader& stream) override;
44
45
47 // plJoltConstraintComponent
48
49protected:
50 virtual void CreateContstraintType(JPH::Body* pBody0, JPH::Body* pBody1) override;
51
52
54 // plJolt6DOFConstraintComponent
55
56public:
57 plJolt6DOFConstraintComponent();
58 ~plJolt6DOFConstraintComponent();
59
60 virtual void ApplySettings() final override;
61
62 void SetFreeLinearAxis(plBitflags<plJoltAxis> flags); // [ property ]
63 plBitflags<plJoltAxis> GetFreeLinearAxis() const { return m_FreeLinearAxis; } // [ property ]
64
65 void SetFreeAngularAxis(plBitflags<plJoltAxis> flags); // [ property ]
66 plBitflags<plJoltAxis> GetFreeAngularAxis() const { return m_FreeAngularAxis; } // [ property ]
67
68 void SetLinearLimitMode(plJoltConstraintLimitMode::Enum mode); // [ property ]
69 plJoltConstraintLimitMode::Enum GetLinearLimitMode() const { return m_LinearLimitMode; } // [ property ]
70
71 void SetLinearRangeX(const plVec2& value); // [ property ]
72 const plVec2& GetLinearRangeX() const { return m_vLinearRangeX; } // [ property ]
73 void SetLinearRangeY(const plVec2& value); // [ property ]
74 const plVec2& GetLinearRangeY() const { return m_vLinearRangeY; } // [ property ]
75 void SetLinearRangeZ(const plVec2& value); // [ property ]
76 const plVec2& GetLinearRangeZ() const { return m_vLinearRangeZ; } // [ property ]
77
78 void SetLinearStiffness(float f); // [ property ]
79 float GetLinearStiffness() const { return m_fLinearStiffness; } // [ property ]
80
81 void SetLinearDamping(float f); // [ property ]
82 float GetLinearDamping() const { return m_fLinearDamping; } // [ property ]
83
84 void SetSwingLimitMode(plJoltConstraintLimitMode::Enum mode); // [ property ]
85 plJoltConstraintLimitMode::Enum GetSwingLimitMode() const { return m_SwingLimitMode; } // [ property ]
86
87 void SetSwingLimit(plAngle f); // [ property ]
88 plAngle GetSwingLimit() const { return m_SwingLimit; } // [ property ]
89
90 void SetSwingStiffness(float f); // [ property ]
91 float GetSwingStiffness() const { return m_fSwingStiffness; } // [ property ]
92
93 void SetSwingDamping(float f); // [ property ]
94 float GetSwingDamping() const { return m_fSwingDamping; } // [ property ]
95
96 void SetTwistLimitMode(plJoltConstraintLimitMode::Enum mode); // [ property ]
97 plJoltConstraintLimitMode::Enum GetTwistLimitMode() const { return m_TwistLimitMode; } // [ property ]
98
99 void SetLowerTwistLimit(plAngle f); // [ property ]
100 plAngle GetLowerTwistLimit() const { return m_LowerTwistLimit; } // [ property ]
101
102 void SetUpperTwistLimit(plAngle f); // [ property ]
103 plAngle GetUpperTwistLimit() const { return m_UpperTwistLimit; } // [ property ]
104
105 void SetTwistStiffness(float f); // [ property ]
106 float GetTwistStiffness() const { return m_fTwistStiffness; } // [ property ]
107
108 void SetTwistDamping(float f); // [ property ]
109 float GetTwistDamping() const { return m_fTwistDamping; } // [ property ]
110
111protected:
112 plBitflags<plJoltAxis> m_FreeLinearAxis;
113
114 plEnum<plJoltConstraintLimitMode> m_LinearLimitMode;
115
116 float m_fLinearStiffness = 0.0f;
117 float m_fLinearDamping = 0.0f;
118
119 plVec2 m_vLinearRangeX = plVec2::MakeZero();
120 plVec2 m_vLinearRangeY = plVec2::MakeZero();
121 plVec2 m_vLinearRangeZ = plVec2::MakeZero();
122
123 plBitflags<plJoltAxis> m_FreeAngularAxis;
124
125 plEnum<plJoltConstraintLimitMode> m_SwingLimitMode;
126 plAngle m_SwingLimit;
127
128 float m_fSwingStiffness = 0.0f; // [ property ]
129 float m_fSwingDamping = 0.0f; // [ property ]
130
131 plEnum<plJoltConstraintLimitMode> m_TwistLimitMode;
132 plAngle m_LowerTwistLimit;
133 plAngle m_UpperTwistLimit;
134
135 float m_fTwistStiffness = 0.0f; // [ property ]
136 float m_fTwistDamping = 0.0f; // [ property ]
137};
138
139#endif
plAngle
Float wrapper struct for a safe usage and conversions of angles.
Definition Angle.h:10
plComponentManager
Definition ComponentManager.h:88
plJoltConstraintComponent
Base class for all Jolt physics joints (constraints).
Definition JoltConstraintComponent.h:73
plVec2Template< float >::MakeZero
static constexpr plVec2Template< float > MakeZero()
Definition Vec2.h:49
plWorldReader
Reads a world description from a stream. Allows to instantiate that world multiple times in different...
Definition WorldReader.h:47
plWorldWriter
Stores an entire plWorld in a stream.
Definition WorldWriter.h:13
plBitflags
The plBitflags class allows you to work with type-safe bitflags.
Definition Bitflags.h:82
plEnum
A custom enum implementation that allows to define the underlying storage type to control its memory ...
Definition Enum.h:37
plJoltConstraintLimitMode::Enum
Enum
Definition JoltConstraintComponent.h:24