1 /*************************************************************************/ 2 /* slider_joint_sw.h */ 3 /*************************************************************************/ 4 /* This file is part of: */ 5 /* GODOT ENGINE */ 6 /* https://godotengine.org */ 7 /*************************************************************************/ 8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ 9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */ 10 /* */ 11 /* Permission is hereby granted, free of charge, to any person obtaining */ 12 /* a copy of this software and associated documentation files (the */ 13 /* "Software"), to deal in the Software without restriction, including */ 14 /* without limitation the rights to use, copy, modify, merge, publish, */ 15 /* distribute, sublicense, and/or sell copies of the Software, and to */ 16 /* permit persons to whom the Software is furnished to do so, subject to */ 17 /* the following conditions: */ 18 /* */ 19 /* The above copyright notice and this permission notice shall be */ 20 /* included in all copies or substantial portions of the Software. */ 21 /* */ 22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ 23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ 24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ 25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ 26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ 27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ 28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ 29 /*************************************************************************/ 30 31 /* 32 Adapted to Godot from the Bullet library. 33 */ 34 35 #ifndef SLIDER_JOINT_SW_H 36 #define SLIDER_JOINT_SW_H 37 38 #include "servers/physics/joints/jacobian_entry_sw.h" 39 #include "servers/physics/joints_sw.h" 40 41 /* 42 Bullet Continuous Collision Detection and Physics Library 43 Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/ 44 45 This software is provided 'as-is', without any express or implied warranty. 46 In no event will the authors be held liable for any damages arising from the use of this software. 47 Permission is granted to anyone to use this software for any purpose, 48 including commercial applications, and to alter it and redistribute it freely, 49 subject to the following restrictions: 50 51 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 52 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 53 3. This notice may not be removed or altered from any source distribution. 54 */ 55 56 /* 57 Added by Roman Ponomarev (rponom@gmail.com) 58 April 04, 2008 59 60 */ 61 62 #define SLIDER_CONSTRAINT_DEF_SOFTNESS (real_t(1.0)) 63 #define SLIDER_CONSTRAINT_DEF_DAMPING (real_t(1.0)) 64 #define SLIDER_CONSTRAINT_DEF_RESTITUTION (real_t(0.7)) 65 66 //----------------------------------------------------------------------------- 67 68 class SliderJointSW : public JointSW { 69 protected: 70 union { 71 struct { 72 BodySW *A; 73 BodySW *B; 74 }; 75 76 BodySW *_arr[2]; 77 }; 78 79 Transform m_frameInA; 80 Transform m_frameInB; 81 82 // linear limits 83 real_t m_lowerLinLimit; 84 real_t m_upperLinLimit; 85 // angular limits 86 real_t m_lowerAngLimit; 87 real_t m_upperAngLimit; 88 // softness, restitution and damping for different cases 89 // DirLin - moving inside linear limits 90 // LimLin - hitting linear limit 91 // DirAng - moving inside angular limits 92 // LimAng - hitting angular limit 93 // OrthoLin, OrthoAng - against constraint axis 94 real_t m_softnessDirLin; 95 real_t m_restitutionDirLin; 96 real_t m_dampingDirLin; 97 real_t m_softnessDirAng; 98 real_t m_restitutionDirAng; 99 real_t m_dampingDirAng; 100 real_t m_softnessLimLin; 101 real_t m_restitutionLimLin; 102 real_t m_dampingLimLin; 103 real_t m_softnessLimAng; 104 real_t m_restitutionLimAng; 105 real_t m_dampingLimAng; 106 real_t m_softnessOrthoLin; 107 real_t m_restitutionOrthoLin; 108 real_t m_dampingOrthoLin; 109 real_t m_softnessOrthoAng; 110 real_t m_restitutionOrthoAng; 111 real_t m_dampingOrthoAng; 112 113 // for interlal use 114 bool m_solveLinLim; 115 bool m_solveAngLim; 116 117 JacobianEntrySW m_jacLin[3]; 118 real_t m_jacLinDiagABInv[3]; 119 120 JacobianEntrySW m_jacAng[3]; 121 122 real_t m_timeStep; 123 Transform m_calculatedTransformA; 124 Transform m_calculatedTransformB; 125 126 Vector3 m_sliderAxis; 127 Vector3 m_realPivotAInW; 128 Vector3 m_realPivotBInW; 129 Vector3 m_projPivotInW; 130 Vector3 m_delta; 131 Vector3 m_depth; 132 Vector3 m_relPosA; 133 Vector3 m_relPosB; 134 135 real_t m_linPos; 136 137 real_t m_angDepth; 138 real_t m_kAngle; 139 140 bool m_poweredLinMotor; 141 real_t m_targetLinMotorVelocity; 142 real_t m_maxLinMotorForce; 143 real_t m_accumulatedLinMotorImpulse; 144 145 bool m_poweredAngMotor; 146 real_t m_targetAngMotorVelocity; 147 real_t m_maxAngMotorForce; 148 real_t m_accumulatedAngMotorImpulse; 149 150 //------------------------ 151 void initParams(); 152 153 public: 154 // constructors 155 SliderJointSW(BodySW *rbA, BodySW *rbB, const Transform &frameInA, const Transform &frameInB); 156 //SliderJointSW(); 157 // overrides 158 159 // access getRigidBodyA()160 const BodySW *getRigidBodyA() const { return A; } getRigidBodyB()161 const BodySW *getRigidBodyB() const { return B; } getCalculatedTransformA()162 const Transform &getCalculatedTransformA() const { return m_calculatedTransformA; } getCalculatedTransformB()163 const Transform &getCalculatedTransformB() const { return m_calculatedTransformB; } getFrameOffsetA()164 const Transform &getFrameOffsetA() const { return m_frameInA; } getFrameOffsetB()165 const Transform &getFrameOffsetB() const { return m_frameInB; } getFrameOffsetA()166 Transform &getFrameOffsetA() { return m_frameInA; } getFrameOffsetB()167 Transform &getFrameOffsetB() { return m_frameInB; } getLowerLinLimit()168 real_t getLowerLinLimit() { return m_lowerLinLimit; } setLowerLinLimit(real_t lowerLimit)169 void setLowerLinLimit(real_t lowerLimit) { m_lowerLinLimit = lowerLimit; } getUpperLinLimit()170 real_t getUpperLinLimit() { return m_upperLinLimit; } setUpperLinLimit(real_t upperLimit)171 void setUpperLinLimit(real_t upperLimit) { m_upperLinLimit = upperLimit; } getLowerAngLimit()172 real_t getLowerAngLimit() { return m_lowerAngLimit; } setLowerAngLimit(real_t lowerLimit)173 void setLowerAngLimit(real_t lowerLimit) { m_lowerAngLimit = lowerLimit; } getUpperAngLimit()174 real_t getUpperAngLimit() { return m_upperAngLimit; } setUpperAngLimit(real_t upperLimit)175 void setUpperAngLimit(real_t upperLimit) { m_upperAngLimit = upperLimit; } 176 getSoftnessDirLin()177 real_t getSoftnessDirLin() { return m_softnessDirLin; } getRestitutionDirLin()178 real_t getRestitutionDirLin() { return m_restitutionDirLin; } getDampingDirLin()179 real_t getDampingDirLin() { return m_dampingDirLin; } getSoftnessDirAng()180 real_t getSoftnessDirAng() { return m_softnessDirAng; } getRestitutionDirAng()181 real_t getRestitutionDirAng() { return m_restitutionDirAng; } getDampingDirAng()182 real_t getDampingDirAng() { return m_dampingDirAng; } getSoftnessLimLin()183 real_t getSoftnessLimLin() { return m_softnessLimLin; } getRestitutionLimLin()184 real_t getRestitutionLimLin() { return m_restitutionLimLin; } getDampingLimLin()185 real_t getDampingLimLin() { return m_dampingLimLin; } getSoftnessLimAng()186 real_t getSoftnessLimAng() { return m_softnessLimAng; } getRestitutionLimAng()187 real_t getRestitutionLimAng() { return m_restitutionLimAng; } getDampingLimAng()188 real_t getDampingLimAng() { return m_dampingLimAng; } getSoftnessOrthoLin()189 real_t getSoftnessOrthoLin() { return m_softnessOrthoLin; } getRestitutionOrthoLin()190 real_t getRestitutionOrthoLin() { return m_restitutionOrthoLin; } getDampingOrthoLin()191 real_t getDampingOrthoLin() { return m_dampingOrthoLin; } getSoftnessOrthoAng()192 real_t getSoftnessOrthoAng() { return m_softnessOrthoAng; } getRestitutionOrthoAng()193 real_t getRestitutionOrthoAng() { return m_restitutionOrthoAng; } getDampingOrthoAng()194 real_t getDampingOrthoAng() { return m_dampingOrthoAng; } setSoftnessDirLin(real_t softnessDirLin)195 void setSoftnessDirLin(real_t softnessDirLin) { m_softnessDirLin = softnessDirLin; } setRestitutionDirLin(real_t restitutionDirLin)196 void setRestitutionDirLin(real_t restitutionDirLin) { m_restitutionDirLin = restitutionDirLin; } setDampingDirLin(real_t dampingDirLin)197 void setDampingDirLin(real_t dampingDirLin) { m_dampingDirLin = dampingDirLin; } setSoftnessDirAng(real_t softnessDirAng)198 void setSoftnessDirAng(real_t softnessDirAng) { m_softnessDirAng = softnessDirAng; } setRestitutionDirAng(real_t restitutionDirAng)199 void setRestitutionDirAng(real_t restitutionDirAng) { m_restitutionDirAng = restitutionDirAng; } setDampingDirAng(real_t dampingDirAng)200 void setDampingDirAng(real_t dampingDirAng) { m_dampingDirAng = dampingDirAng; } setSoftnessLimLin(real_t softnessLimLin)201 void setSoftnessLimLin(real_t softnessLimLin) { m_softnessLimLin = softnessLimLin; } setRestitutionLimLin(real_t restitutionLimLin)202 void setRestitutionLimLin(real_t restitutionLimLin) { m_restitutionLimLin = restitutionLimLin; } setDampingLimLin(real_t dampingLimLin)203 void setDampingLimLin(real_t dampingLimLin) { m_dampingLimLin = dampingLimLin; } setSoftnessLimAng(real_t softnessLimAng)204 void setSoftnessLimAng(real_t softnessLimAng) { m_softnessLimAng = softnessLimAng; } setRestitutionLimAng(real_t restitutionLimAng)205 void setRestitutionLimAng(real_t restitutionLimAng) { m_restitutionLimAng = restitutionLimAng; } setDampingLimAng(real_t dampingLimAng)206 void setDampingLimAng(real_t dampingLimAng) { m_dampingLimAng = dampingLimAng; } setSoftnessOrthoLin(real_t softnessOrthoLin)207 void setSoftnessOrthoLin(real_t softnessOrthoLin) { m_softnessOrthoLin = softnessOrthoLin; } setRestitutionOrthoLin(real_t restitutionOrthoLin)208 void setRestitutionOrthoLin(real_t restitutionOrthoLin) { m_restitutionOrthoLin = restitutionOrthoLin; } setDampingOrthoLin(real_t dampingOrthoLin)209 void setDampingOrthoLin(real_t dampingOrthoLin) { m_dampingOrthoLin = dampingOrthoLin; } setSoftnessOrthoAng(real_t softnessOrthoAng)210 void setSoftnessOrthoAng(real_t softnessOrthoAng) { m_softnessOrthoAng = softnessOrthoAng; } setRestitutionOrthoAng(real_t restitutionOrthoAng)211 void setRestitutionOrthoAng(real_t restitutionOrthoAng) { m_restitutionOrthoAng = restitutionOrthoAng; } setDampingOrthoAng(real_t dampingOrthoAng)212 void setDampingOrthoAng(real_t dampingOrthoAng) { m_dampingOrthoAng = dampingOrthoAng; } setPoweredLinMotor(bool onOff)213 void setPoweredLinMotor(bool onOff) { m_poweredLinMotor = onOff; } getPoweredLinMotor()214 bool getPoweredLinMotor() { return m_poweredLinMotor; } setTargetLinMotorVelocity(real_t targetLinMotorVelocity)215 void setTargetLinMotorVelocity(real_t targetLinMotorVelocity) { m_targetLinMotorVelocity = targetLinMotorVelocity; } getTargetLinMotorVelocity()216 real_t getTargetLinMotorVelocity() { return m_targetLinMotorVelocity; } setMaxLinMotorForce(real_t maxLinMotorForce)217 void setMaxLinMotorForce(real_t maxLinMotorForce) { m_maxLinMotorForce = maxLinMotorForce; } getMaxLinMotorForce()218 real_t getMaxLinMotorForce() { return m_maxLinMotorForce; } setPoweredAngMotor(bool onOff)219 void setPoweredAngMotor(bool onOff) { m_poweredAngMotor = onOff; } getPoweredAngMotor()220 bool getPoweredAngMotor() { return m_poweredAngMotor; } setTargetAngMotorVelocity(real_t targetAngMotorVelocity)221 void setTargetAngMotorVelocity(real_t targetAngMotorVelocity) { m_targetAngMotorVelocity = targetAngMotorVelocity; } getTargetAngMotorVelocity()222 real_t getTargetAngMotorVelocity() { return m_targetAngMotorVelocity; } setMaxAngMotorForce(real_t maxAngMotorForce)223 void setMaxAngMotorForce(real_t maxAngMotorForce) { m_maxAngMotorForce = maxAngMotorForce; } getMaxAngMotorForce()224 real_t getMaxAngMotorForce() { return m_maxAngMotorForce; } getLinearPos()225 real_t getLinearPos() { return m_linPos; } 226 227 // access for ODE solver getSolveLinLimit()228 bool getSolveLinLimit() { return m_solveLinLim; } getLinDepth()229 real_t getLinDepth() { return m_depth[0]; } getSolveAngLimit()230 bool getSolveAngLimit() { return m_solveAngLim; } getAngDepth()231 real_t getAngDepth() { return m_angDepth; } 232 // shared code used by ODE solver 233 void calculateTransforms(void); 234 void testLinLimits(void); 235 void testAngLimits(void); 236 // access for PE Solver 237 Vector3 getAncorInA(void); 238 Vector3 getAncorInB(void); 239 240 void set_param(PhysicsServer::SliderJointParam p_param, float p_value); 241 float get_param(PhysicsServer::SliderJointParam p_param) const; 242 243 bool setup(float p_step); 244 void solve(float p_step); 245 get_type()246 virtual PhysicsServer::JointType get_type() const { return PhysicsServer::JOINT_SLIDER; } 247 }; 248 249 #endif // SLIDER_JOINT_SW_H 250