开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
hkpConstraintAtom.h
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：48k
源码类别：

其他游戏

开发平台：

Visual C++

hkpConstraintAtom.h：源码内容
  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  9. #ifndef HK_DYNAMICS2_CONSTRAINT_ATOM_H
  10. #define HK_DYNAMICS2_CONSTRAINT_ATOM_H
  13. #include <Common/Base/hkBase.h>
  14. #include <Physics/ConstraintSolver/Constraint/Contact/hkpSimpleContactConstraintInfo.h>
  15. #include <Common/Base/Types/Physics/ContactPoint/hkContactPoint.h>
  16. #include <Physics/Dynamics/Constraint/hkpConstraintData.h>
  18. HK_REFLECTION_CLASSFILE_DESTINATION("../../../Dynamics/Constraint/Atom");
  20. class hkContactPoint;
  21. class hkpConstraintMotor;
  22. class hkpContactPointPropertiesStream;
  24. #define HK_CONSTRAINT_FILL_PADDING_WITH_ZERO(fromAfter, to) { for (hkUint8* ptr = reinterpret_cast<hkUint8*>(fromAfter.next()); ptr < reinterpret_cast<hkUint8*>(&to); *(ptr++) = 0) { } }
  27.   /// Constraint atoms are building blocks that specify hkConstraintDatas.
  28.   ///
  29.   /// hkConstraintDatas either use hkpBridgeAtoms, which allow them to implement their custom logic, or use a set of generic hkConstraintAtoms
  30.   /// to describe the geometry of the constraint.
  31.   ///
  32.   /// Each hkpConstraintAtom is used to specify a constraint's orientation in space or to create one or more solver-constraints of a given type.
  33.   /// During simulation, hkConstraintAtoms are processed in the order in which they're organized in a hkpConstraintData.
  34.   ///
  35.   /// Generally the first constraint in a list is one that specifies the local bases of the constraint in each of the constrained bodies' spaces.
  36.   /// Those bases are persistent throughout processing of a list of atoms. The following atoms apply a kind of a constraint (linear, angular,
  37.   /// limit, motor, etc.) in relation to one or more of the axes of the specified local bases. See individual descriptions of atoms for more info.
  38.   ///
  39.   ///
  40. struct hkpConstraintAtom
  41. {
  42. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpConstraintAtom );
  43. HK_DECLARE_REFLECTION();
  45. public:
  46. enum AtomType
  47. {
  48. TYPE_INVALID = 0,
  50. TYPE_BRIDGE,
  52. TYPE_SET_LOCAL_TRANSFORMS,
  53. TYPE_SET_LOCAL_TRANSLATIONS,
  54. TYPE_SET_LOCAL_ROTATIONS,
  56. TYPE_BALL_SOCKET,
  57. TYPE_STIFF_SPRING,
  59. TYPE_LIN,
  60. TYPE_LIN_SOFT,
  61. TYPE_LIN_LIMIT,
  62. TYPE_LIN_FRICTION,
  63. TYPE_LIN_MOTOR,
  65. TYPE_2D_ANG,
  67. TYPE_ANG,
  68. TYPE_ANG_LIMIT,
  69. TYPE_TWIST_LIMIT,
  70. TYPE_CONE_LIMIT,
  71. TYPE_ANG_FRICTION,
  72. TYPE_ANG_MOTOR,
  74. TYPE_RAGDOLL_MOTOR,
  76. TYPE_PULLEY,
  77. TYPE_OVERWRITE_PIVOT,
  79. TYPE_CONTACT,
  81. //
  82. // modifiers, must be the end of the list
  83. //
  84. TYPE_MODIFIER_SOFT_CONTACT, // not supported by the spu
  85. TYPE_MODIFIER_MASS_CHANGER, // spu supported
  86. TYPE_MODIFIER_VISCOUS_SURFACE, // not supported by the spu
  87. TYPE_MODIFIER_MOVING_SURFACE, // spu supported
  88. TYPE_MODIFIER_IGNORE_CONSTRAINT,  // spu supported
  89. TYPE_MODIFIER_CENTER_OF_MASS_CHANGER, // not supported by the spu
  91. TYPE_MAX
  92. };
  94. // flag indicating whether this constraint needs some special callback treatment
  95. // those flags can be combined
  96. enum CallbackRequest
  97. {
  98. CALLBACK_REQUEST_NONE = 0,
  99. CALLBACK_REQUEST_NEW_CONTACT_POINT = 1,
  100. CALLBACK_REQUEST_SETUP_PPU_ONLY = 2,
  101. CALLBACK_REQUEST_SETUP_CALLBACK = 4
  102. };
  104. public:
  105. HK_FORCE_INLINE enum AtomType getType() const { return m_type; }
  107. HK_FORCE_INLINE int isModifierType() const { return m_type >= TYPE_MODIFIER_SOFT_CONTACT; }
  109. protected:
  110. hkpConstraintAtom(enum AtomType type) : m_type(type) {}
  111. public:
  112. hkpConstraintAtom(hkFinishLoadedObjectFlag f) {}
  115. private:
  116. // Illegal constructor
  117. hkpConstraintAtom();
  119. public:
  120. hkEnum<AtomType,hkUint16> m_type;
  121. };
  124. typedef void (HK_CALL *hkConstraintAtomBuildJacobianFunc) ( class hkpConstraintData* m_constraintData, const hkpConstraintQueryIn &in, hkpConstraintQueryOut &out );
  126. /// This atom is used to allow to call the old hkpConstraintData classes
  127. struct hkpBridgeConstraintAtom: public hkpConstraintAtom
  128. {
  129. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpBridgeConstraintAtom );
  130. HK_DECLARE_REFLECTION();
  132. hkpBridgeConstraintAtom(  ): hkpConstraintAtom( TYPE_BRIDGE ){ }
  134. hkpBridgeConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f)
  135. {
  136. if( f.m_finishing )
  137. {
  138. init(m_constraintData);
  139. }
  140. }
  142. // call this to do stuff not done in the constructor yet
  143. void init (class hkpConstraintData* m_constraintData);
  145. HK_FORCE_INLINE hkpConstraintAtom* next() { return (this+1); }
  147. // bridge atoms are always the last atom, so no need to increment solver result, just make sure the
  148. // program crashes if the result of this function is used
  149. HK_FORCE_INLINE int numSolverResults() const    { return 100000; }
  151. // addToConstraintInfo not needed
  153. hkConstraintAtomBuildJacobianFunc       m_buildJacobianFunc; //+nosave +overridetype(void*)
  155. class hkpConstraintData* m_constraintData;
  156. };
  158. struct hkpBridgeAtoms
  159. {
  160. HK_DECLARE_REFLECTION();
  161. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpBridgeAtoms );
  163. struct hkpBridgeConstraintAtom m_bridgeAtom;
  165. hkpBridgeAtoms(){}
  167. hkpBridgeAtoms(hkFinishLoadedObjectFlag f) : m_bridgeAtom(f) {}
  169. // get a pointer to the first atom
  170. const hkpConstraintAtom* getAtoms() const { return &m_bridgeAtom; }
  172. // get the size of all atoms (we can't use sizeof(*this) because of align16 padding)
  173. int getSizeOfAllAtoms() const               { return hkGetByteOffsetInt(this, &m_bridgeAtom+1); }
  174. };
  177. /// hkpSimpleContactConstraintAtom holds contact information for a single hkpSimpleContactConstraintData.
  178. ///
  179. /// It is for internal use only and is unique in the following ways:
  180. ///  - it is not a member of the owning hkpConstraintData, it is allocated externally
  181. ///  - its size is dynamic and varies depending on the number of contact points in the constraint
  182. ///  - it is a stand-alone constraint, therefore it derives from hkpConstraintAtom and cannot be followed by any other atom
  183. struct hkpSimpleContactConstraintAtom : public hkpConstraintAtom
  184. {
  185. HK_DECLARE_REFLECTION();
  187. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpSimpleContactConstraintAtom );
  189. public:
  190. // Size of hkpSimpleContactConstraintAtom is dynamically changed by the engine. It holds up to 256 contact points.
  191. // We initialize the size of the atom to what it is when no contact points are present.
  192. hkpSimpleContactConstraintAtom() : hkpConstraintAtom(TYPE_CONTACT) {}
  194. hkpSimpleContactConstraintAtom(hkFinishLoadedObjectFlag f);
  196. HK_FORCE_INLINE hkContactPoint* getContactPoints() const { return const_cast<hkContactPoint*>( reinterpret_cast<const hkContactPoint*>( this+1 ) ); }
  197. HK_FORCE_INLINE int getContactPointPropertiesStriding() const;
  198. HK_FORCE_INLINE hkpContactPointPropertiesStream* getContactPointPropertiesStream() const { return const_cast<hkpContactPointPropertiesStream*>( reinterpret_cast<const hkpContactPointPropertiesStream*>( hkAddByteOffsetConst( getContactPoints(), sizeof(hkContactPoint) * m_numReservedContactPoints ) ) ); }
  199. HK_FORCE_INLINE hkpContactPointPropertiesStream* getContactPointPropertiesStream(int i) const;
  201. public:
  202. HK_FORCE_INLINE hkpConstraintAtom* next() const { HK_ASSERT2(0x5b5a6955, false, "Not implemented. Need to compute the entire size of contact points & properties."); return HK_NULL; }
  203. HK_FORCE_INLINE int numSolverResults() const    { return m_numContactPoints+3; }
  205. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const
  206. {
  207. int size = m_numContactPoints;
  209. infoOut.m_sizeOfSchemas    += HK_SIZE_OF_JACOBIAN_HEADER_SCHEMA 
  210. + (size >> 1) * HK_SIZE_OF_JACOBIAN_PAIR_CONTACT_SCHEMA 
  211.                         + (size & 1) * HK_SIZE_OF_JACOBIAN_SINGLE_CONTACT_SCHEMA 
  212. + HK_SIZE_OF_JACOBIAN_2D_FRICTION_SCHEMA;
  214. infoOut.m_maxSizeOfSchema = infoOut.m_sizeOfSchemas + (HK_SIZE_OF_JACOBIAN_3D_FRICTION_SCHEMA - HK_SIZE_OF_JACOBIAN_2D_FRICTION_SCHEMA);
  215. infoOut.m_numSolverResults   += size + 2;
  216. infoOut.m_numSolverElemTemps += size + (2 + 1); // extra one for friction
  218. if ( size >= 2 )
  219. {
  220. infoOut.m_sizeOfSchemas   += HK_SIZE_OF_JACOBIAN_3D_FRICTION_SCHEMA - HK_SIZE_OF_JACOBIAN_2D_FRICTION_SCHEMA;
  221. infoOut.m_numSolverResults   += 1; // is that needed ?? solver results are stroed in the info struct
  222. infoOut.m_numSolverElemTemps += 1 + 0; // just one elem for both 2d & 3d friction anyways.
  223. }
  225. #if defined HK_ENABLE_ROLLING_FRICITON_CODE
  226. if (m_info.m_rollingFrictionMultiplier != 0.0f)
  227. {
  228. infoOut.m_sizeOfSchemas += HK_SIZE_OF_JACOBIAN_2D_ROLLING_FRICTION_SCHEMA;
  229. infoOut.m_maxSizeOfSchema += HK_SIZE_OF_JACOBIAN_2D_ROLLING_FRICTION_SCHEMA;
  230. infoOut.m_numSolverResults += 2; 
  231. infoOut.m_numSolverElemTemps += 2 * (1 + 1);
  232. }
  233. #endif
  234. }
  236. public:
  237. hkUint16 m_sizeOfAllAtoms;
  238. hkUint16 m_numContactPoints;
  239. hkUint16 m_numReservedContactPoints;
  241. // 8 bytes left from here
  243. // Extra storage for bodyA. Holds hkpShapeKey hierarchy, by default.
  244. hkUint8 m_numUserDatasForBodyA;
  246. // Extra storage for bodyA. Holds hkpShapeKey hierarchy, by default.
  247. hkUint8 m_numUserDatasForBodyB;
  249. // store striding in here to avoid recomputing in getContactPointPropsStriding()..
  250. hkUint8 m_contactPointPropertiesStriding;
  252. // Maximum number for contact points. The limitation is driven by buffer size on SPU, and by contactPointProperties size.
  253. hkUint16 m_maxNumContactPoints; // -- this will not be cross-platform, and will use problems with contact points saved on PC, and to be loaded on PS3 <ag.todo.b>
  256. HK_ALIGN16(class hkpSimpleContactConstraintDataInfo m_info);
  258. };
  261. // Only include it after the hkpSimpleContactConstraintAtom is defined
  262. #include <Physics/ConstraintSolver/Constraint/Contact/hkpContactPointProperties.h>
  264. HK_FORCE_INLINE int hkpSimpleContactConstraintAtom::getContactPointPropertiesStriding() const { return m_contactPointPropertiesStriding; }
  265. HK_FORCE_INLINE hkpContactPointPropertiesStream* hkpSimpleContactConstraintAtom::getContactPointPropertiesStream(int i) const 
  266. {
  267. const hkContactPoint* endContactPoint = hkAddByteOffsetConst( getContactPoints(), sizeof(hkContactPoint) * m_numReservedContactPoints);
  268. const hkpContactPointPropertiesStream* beginningOfProperties = reinterpret_cast<const hkpContactPointPropertiesStream*>( endContactPoint );
  269. return const_cast<hkpContactPointPropertiesStream*>( hkAddByteOffsetConst(  beginningOfProperties, HK_HINT_SIZE16(i) * HK_HINT_SIZE16( getContactPointPropertiesStriding())  ) );
  270. }
  274. # define HK_GET_LOCAL_CONTACT_ATOM(ATOM) ATOM
  275. # define HK_CONTACT_ATOM_SET_PPU(ATOM)
  278. /// Fully eliminates relative linear movement of bodies' pivots.
  279. ///
  280. /// This is the most common atom. It is advised to place it at the end of the list of atoms to minimize results error.
  281. /// This atom eliminates 3 degrees of freedom and returns 3 solver results. It has no parameters.
  282. struct hkpBallSocketConstraintAtom : public hkpConstraintAtom
  283. {
  284. //+version(1)
  285. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpBallSocketConstraintAtom );
  286. HK_DECLARE_REFLECTION();
  288. public:
  290. hkpBallSocketConstraintAtom() : hkpConstraintAtom(TYPE_BALL_SOCKET), m_bodiesToNotify(0), m_stabilizationFactor(1.0f), m_maxImpulse(HK_REAL_MAX) {}
  292. hkpBallSocketConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  294. /// Return the next atom after this.
  295. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  296. /// This tells how many solver-constraints this atom generates and how may solver-results slots it requires.
  297. HK_FORCE_INLINE int numSolverResults() const    { return 3; }
  298. /// This tells how much memory the system will need to store solver schemas and jacobians for this atom.
  299. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( 3 * HK_SIZE_OF_JACOBIAN_1D_BILATERAL_SCHEMA, 3, 3 ); }
  300. /// Marks the body to be notified when the m_maxImpulse is breached.
  301. hkUint8 m_bodiesToNotify; //+default(0)
  302. /// This sets the multiplier that's used to add bodies' velocities to the solver's jacobians RHS.
  303. /// This defaults to 1.0f and results in the constraints positional constraint being slightly violated for the advantage of 
  304. /// extra stabilization. At low (low frame rate, few solver iterations) this setting can cause uncontrollable jitter however.
  305. /// In such cases disable it setting the factor to lower values or zero.
  306. hkUFloat8 m_stabilizationFactor; //+default(1.0f)
  307. /// Maximum impulse applied by each of the three resulting 1d bilinear constraints.
  308. /// When any of the three limits is breached and the constraint has runtime allocated, a constraint-impulse-limit breached callback is triggered.
  309. hkReal m_maxImpulse; //+default(HK_REAL_MAX)
  310. };
  312. /// Enforces a constant distance between the pivot points of linked bodies.
  313. struct hkpStiffSpringConstraintAtom : public hkpConstraintAtom
  314. {
  315. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpStiffSpringConstraintAtom );
  316. HK_DECLARE_REFLECTION();
  318. public:
  319. hkpStiffSpringConstraintAtom() : hkpConstraintAtom(TYPE_STIFF_SPRING) {}
  320. hkpStiffSpringConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  322. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  323. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  324. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_BILATERAL_SCHEMA, 1, 1 ); }
  326. /// The rest length / distance between pivot points.
  327. hkReal m_length;
  328. };
  330. /// This specifies constraint spaces and pivot points in the local spaces of each body.
  331. ///
  332. /// Pivot points are stored in the translation part of the transforms.
  333. struct hkpSetLocalTransformsConstraintAtom : public hkpConstraintAtom
  334. {
  335. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpSetLocalTransformsConstraintAtom );
  336. HK_DECLARE_REFLECTION();
  338. hkpSetLocalTransformsConstraintAtom() : hkpConstraintAtom(TYPE_SET_LOCAL_TRANSFORMS) {}
  339. hkpSetLocalTransformsConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  340. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  341. HK_FORCE_INLINE int numSolverResults() const    { return 0; }
  342. // addToConstraintInfo not needed
  344. /// Constraint orientation and origin/pivot point in bodyA's local space.
  345. hkTransform m_transformA;
  346. /// Constraint orientation and origin/pivot point in bodyB's local space.
  347. hkTransform m_transformB;
  348. };
  350. /// This specifies pivot points in the local spaces of each body.
  351. ///
  352. /// Note that this does not overwrite the constraint space's orientation.
  353. /// This is used when constraint orientation is irrelevant, e.g. in hkpBallAndSocketConstraintData.
  354. struct hkpSetLocalTranslationsConstraintAtom : public hkpConstraintAtom
  355. {
  356. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpSetLocalTranslationsConstraintAtom );
  357. HK_DECLARE_REFLECTION();
  359. hkpSetLocalTranslationsConstraintAtom() : hkpConstraintAtom(TYPE_SET_LOCAL_TRANSLATIONS) {}
  360. hkpSetLocalTranslationsConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  361. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  362. HK_FORCE_INLINE int numSolverResults() const    { return 0; }
  363. // addToConstraintInfo not needed
  365. /// Pivot point in bodyA's local space.
  366. hkVector4 m_translationA;
  367. /// Pivot point in bodyB's local space.
  368. hkVector4 m_translationB;
  369. };
  371. /// This specifies constraint spaces in the local spaces of each body.
  372. ///
  373. /// Note that this does not overwrite the pivot points.
  374. /// This is used when the constraint space must be reoriented for some atoms in more complex hkConstraintDatas, e.g. in the hkpWheelConstraintData.
  375. struct hkpSetLocalRotationsConstraintAtom : public hkpConstraintAtom
  376. {
  377. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpSetLocalRotationsConstraintAtom );
  378. HK_DECLARE_REFLECTION();
  380. hkpSetLocalRotationsConstraintAtom() : hkpConstraintAtom(TYPE_SET_LOCAL_ROTATIONS) {}
  381. hkpSetLocalRotationsConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  382. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  383. HK_FORCE_INLINE int numSolverResults() const    { return 0; }
  384. // addToConstraintInfo not needed
  386. /// Constraint orientation in bodyA's local space.
  387. hkRotation m_rotationA;
  388. /// Constraint orientation in bodyB's local space.
  389. hkRotation m_rotationB;
  390. };
  392. struct hkpOverwritePivotConstraintAtom : public hkpConstraintAtom
  393. {
  394. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpOverwritePivotConstraintAtom );
  395. HK_DECLARE_REFLECTION();
  397. hkpOverwritePivotConstraintAtom() : hkpConstraintAtom(TYPE_OVERWRITE_PIVOT), m_copyToPivotBFromPivotA(true) { }
  398. hkpOverwritePivotConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  399. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  400. HK_FORCE_INLINE int numSolverResults() const    { return 0; }
  402. hkUint8 m_copyToPivotBFromPivotA;
  403. };
  405. /// Eliminates relative linear velocity of bodies' pivot points along one specified axis.
  406. ///
  407. /// This is used when relative linear movement is only partly constrained as it is in e.g. prismatic or point-to-plane constraints.
  408. struct hkpLinConstraintAtom : public hkpConstraintAtom
  409. {
  410. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpLinConstraintAtom );
  411. HK_DECLARE_REFLECTION();
  413. hkpLinConstraintAtom() : hkpConstraintAtom(TYPE_LIN) {}
  414. hkpLinConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  415. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  416. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  417. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_BILATERAL_SCHEMA, 1, 1 ); }
  419. /// Specifies the index of the axis of the bodyB's constraint base, that will be constrained.
  420. hkUint8 m_axisIndex;
  421. };
  423. /// Softens/controls relative linear velocity of bodies' pivot points along one specified axis.
  424. ///
  425. /// This results in a spring-like reaction, it's used in the hkpWheelConstraintData.
  426. struct hkpLinSoftConstraintAtom : public hkpConstraintAtom
  427. {
  428. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpLinSoftConstraintAtom );
  429. HK_DECLARE_REFLECTION();
  431. hkpLinSoftConstraintAtom() : hkpConstraintAtom(TYPE_LIN_SOFT) {}
  432. hkpLinSoftConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  433. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  434. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  435. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_BILATERAL_USER_TAU_SCHEMA, 1, 1 ); }
  437. /// Specifies the index of the axis of the bodyB's constraint base, that will be constrained.
  438. hkUint8 m_axisIndex;
  439. /// Specifies a custom value for the tau parameter used by the solver.
  440. hkReal m_tau;
  441. /// Specifies a custom value for the damping parameter used by the solver.
  442. hkReal m_damping;
  443. };
  445. /// Limits allowed relative distance between bodies' pivot points along one specified axis.
  446. ///
  447. /// This allows unconstrained movement within the specified range, and applies hard limits at its ends.
  448. struct hkpLinLimitConstraintAtom : public hkpConstraintAtom
  449. {
  450. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpLinLimitConstraintAtom );
  451. HK_DECLARE_REFLECTION();
  453. hkpLinLimitConstraintAtom() : hkpConstraintAtom(TYPE_LIN_LIMIT) {}
  454. hkpLinLimitConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  455. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  456. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  457. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_LINEAR_LIMIT_SCHEMA, 1, 1 ); }
  459. /// The index of the axis of the bodyB's constraint base, that will be limited.
  460. hkUint8 m_axisIndex;
  461. /// Minimum distance along the axis (may be negative).
  462. hkReal m_min;
  463. /// Maximum distance along the axis (may be negative).
  464. hkReal m_max;
  465. };
  467. /// Eliminates two degrees of freedom of angular movement and allows relative rotation along a specified axis only.
  468. ///
  469. /// Angular-constraint atoms are often combined with linear-constraint atoms, e.g. this atoms combined with the ball-and-socket
  470. /// atom forms a hkpHingeConstraintData.
  471. struct hkp2dAngConstraintAtom : public hkpConstraintAtom
  472. {
  473. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkp2dAngConstraintAtom );
  474. HK_DECLARE_REFLECTION();
  476. hkp2dAngConstraintAtom() : hkpConstraintAtom(TYPE_2D_ANG) {}
  477. hkp2dAngConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  478. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  479. HK_FORCE_INLINE int numSolverResults() const    { return 2; }
  480. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( 2 * HK_SIZE_OF_JACOBIAN_1D_BILATERAL_SCHEMA, 2, 2 ); }
  482. /// Specifies the index of the unconstrained axis of relative rotation in bodyB's constraint base.
  483. hkUint8 m_freeRotationAxis;
  484. };
  487. /// Eliminates one, two, or three degrees of freedom of angular movement.
  488. ///
  489. /// Note: this is only tested for eliminating three degrees of freedom.
  490. struct hkpAngConstraintAtom : public hkpConstraintAtom
  491. {
  492. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpAngConstraintAtom );
  493. HK_DECLARE_REFLECTION();
  495. hkpAngConstraintAtom() : hkpConstraintAtom(TYPE_ANG) {}
  496. hkpAngConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  497. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  498. HK_FORCE_INLINE int numSolverResults() const    { return m_numConstrainedAxes; }
  499. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( m_numConstrainedAxes * HK_SIZE_OF_JACOBIAN_1D_BILATERAL_SCHEMA, m_numConstrainedAxes, m_numConstrainedAxes ); }
  501. /// Index of the first axis to constrain, in bodyA's constraint base.
  502. hkUint8 m_firstConstrainedAxis;
  504. /// Number of subsequent base axes to constrain.
  505. hkUint8 m_numConstrainedAxes;
  506. };
  509. /// Limits allowed relative angle between bodies' rotations along one specified rotation axis.
  510. ///
  511. /// This allows unconstrained movement within the specified range, and applies hard limits at its ends.
  512. struct hkpAngLimitConstraintAtom : public hkpConstraintAtom
  513. {
  514. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpAngLimitConstraintAtom );
  515. HK_DECLARE_REFLECTION();
  517. hkpAngLimitConstraintAtom() : hkpConstraintAtom(TYPE_ANG_LIMIT), m_isEnabled(true) {}
  518. hkpAngLimitConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  519. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  520. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  521. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_ANGULAR_LIMITS_SCHEMA, 1, 1 ); }
  523. /// Tells whether the atom should be handled by the solver.
  524. ///
  525. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  526. hkUint8 m_isEnabled;
  528. /// The index of the axis in the bodyA's constraint base, that will be limited.
  529. hkUint8 m_limitAxis;
  531. /// Mininum angle value in radians (may be negative).
  532. hkReal m_minAngle;
  534. /// Maximum angle value in radians (may be negative).
  535. hkReal m_maxAngle;
  537. /// A stiffness factor [0..1] used by the solver; defaults to 1.0.
  538. hkReal m_angularLimitsTauFactor; //+default(1.0) +absmin(0) +absmax(1)
  539. };
  542. /// Limits allowed relative angle between bodies' rotations along one specified rotation axis.
  543. ///
  544. /// This constraint allows unconstrained movement within the specified range, and applies hard limits at its ends.
  545. struct hkpTwistLimitConstraintAtom : public hkpConstraintAtom
  546. {
  547. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpTwistLimitConstraintAtom );
  548. HK_DECLARE_REFLECTION();
  550. hkpTwistLimitConstraintAtom() : hkpConstraintAtom(TYPE_TWIST_LIMIT), m_isEnabled(true) {}
  551. hkpTwistLimitConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  552. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  553. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  554. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_ANGULAR_LIMITS_SCHEMA, 1, 1 ); }
  556. /// Tells whether the atom should be handled by the solver.
  557. ///
  558. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  559. hkUint8 m_isEnabled;
  561. /// The index of the axis in the bodyA's constraint base, that will be limited.
  562. hkUint8 m_twistAxis;
  564. /// The index of a perpendicular axis used as a reference to measure the angle.
  565. hkUint8 m_refAxis;
  567. /// Mininum angle value in radians (may be negative).
  568. hkReal m_minAngle;
  570. /// Maximum angle value in radians (may be negative).
  571. hkReal m_maxAngle;
  573. /// A stiffness factor [0..1] used by the solver; defaults to 1.0.
  574. hkReal m_angularLimitsTauFactor; //+default(1.0) +absmin(0) +absmax(1)
  575. };
  577. /// Limits allowed relative angle between bodies' rotations as measured between two chosen axes.
  578. ///
  579. /// This allows unconstrained movement within the specified range, and applies hard limits at its ends.
  580. struct hkpConeLimitConstraintAtom : public hkpConstraintAtom
  581. {
  582. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpConeLimitConstraintAtom );
  583. HK_DECLARE_REFLECTION();
  585. hkpConeLimitConstraintAtom() : hkpConstraintAtom(TYPE_CONE_LIMIT), m_isEnabled(true), m_memOffsetToAngleOffset(0) {}
  586. hkpConeLimitConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  587. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  588. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  589. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_ANGULAR_LIMITS_SCHEMA, 1, 1 ); }
  591. /// Tells whether the atom should be handled by the solver.
  592. ///
  593. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  594. hkUint8 m_isEnabled;
  596. /// The index of the axis in the bodyA's constraint base, that will be used as a reference vector and constrained to lie within the limit cone.
  597. hkUint8 m_twistAxisInA;
  599. /// The index of the axis in the bodyB's constraint base, that will be used as a reference and limit-cone axis.
  600. hkUint8 m_refAxisInB;
  602. /// Specifies how the angle between the two reference vectors is measured.
  603. enum MeasurementMode
  604. {
  605. // Do not change enumeration values! They're used in calculations.
  607. /// Zero-angle corresponds to situation where the two vectors are aligned.
  608. ZERO_WHEN_VECTORS_ALIGNED = 0,
  609. /// Zero-angle corresponds to situation where the two vectors are perpendicular, and (+)90-degree corresponds to vectors being aligned.
  610. ZERO_WHEN_VECTORS_PERPENDICULAR = 1
  611. };
  613. /// Specifies how the angle between the two reference vectors is measured.
  614. hkEnum<MeasurementMode, hkUint8> m_angleMeasurementMode;
  616. /// Memory offset to location in runtime where m_coneAngleOffset is stored.
  617. /// That is used to stablize the constraint.
  618. /// Zero offset means, that no extra stabilization is done.
  619. hkUint8 m_memOffsetToAngleOffset; //+default(1)
  621. /// Mininum angle value in radians (may be negative).
  622. hkReal m_minAngle;
  624. /// Maximum angle value in radians (may be negative).
  625. hkReal m_maxAngle;
  627. /// A stiffness factor [0..1] used by the solver; defaults to 1.0.
  628. hkReal m_angularLimitsTauFactor; //+default(1.0) +absmin(0) +absmax(1)
  629. };
  631. /// Applies friction torque along one, two, or three specified rotation axes.
  632. struct hkpAngFrictionConstraintAtom : public hkpConstraintAtom
  633. {
  634. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpAngFrictionConstraintAtom );
  635. HK_DECLARE_REFLECTION();
  637. hkpAngFrictionConstraintAtom() : hkpConstraintAtom(TYPE_ANG_FRICTION), m_isEnabled(true), m_numFrictionAxes(1) {}
  638. hkpAngFrictionConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  639. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  640. HK_FORCE_INLINE int numSolverResults() const    { return m_numFrictionAxes; }
  641. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( m_numFrictionAxes * HK_SIZE_OF_JACOBIAN_1D_ANGULAR_FRICTION_SCHEMA, m_numFrictionAxes, (1+1) * m_numFrictionAxes ); }
  643. /// Tells whether the atom should be handled by the solver.
  644. ///
  645. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  646. hkUint8 m_isEnabled;
  648. /// Index of the first axis to apply friction along, in bodyA's constraint base.
  649. hkUint8 m_firstFrictionAxis;
  651. /// Number of subsequent base axes to constrain.
  652. hkUint8 m_numFrictionAxes;
  654. /// Maximum allowed torque to be applied due to friction.
  655. hkReal m_maxFrictionTorque;
  656. };
  658. /// Controls relative rotation angle between bodies around a specified rotation axes.
  659. ///
  660. /// Note that motor atoms require access to external variables stored in hkpConstraintInstance's runtime.
  661. /// The atom accesses those variables using memory offsets (stored in the atom's members).
  662. /// Also when the motor is to operate in a range exceeding the [-Pi, Pi] range it must have a reference
  663. /// onto solver results of a corresponding hkpAngLimitConstraintAtom to retrieve the proper angle value.
  664. struct hkpAngMotorConstraintAtom : public hkpConstraintAtom
  665. {
  666. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpAngMotorConstraintAtom );
  667. HK_DECLARE_REFLECTION();
  669. hkpAngMotorConstraintAtom() : hkpConstraintAtom(TYPE_ANG_MOTOR) { m_isEnabled = true; m_initializedOffset = 0; m_previousTargetAngleOffset = 0; }
  670. hkpAngMotorConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  671. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  672. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  673. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_ANGULAR_MOTOR_SCHEMA, 1, (1+2) ); }
  675. /// Tells whether the atom should be handled by the solver.
  676. ///
  677. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  678. hkBool m_isEnabled;
  680. /// The index of the axis in the bodyA's constraint base, that will be controlled.
  681. hkUint8 m_motorAxis;
  683. /// Memory offset from atom's solver results to runtime's m_initialized member.
  684. hkInt16 m_initializedOffset;
  686. /// Memory offset from atom's solver results to runtime's m_previousTargetAngle member
  687. hkInt16 m_previousTargetAngleOffset;
  689. /// This is an optional offset to solver results of an angular limit atom.
  690. /// The results store the actual angle from the last frame, and are needed if the motor
  691. /// is to allow 'screw' functionality (ie. orientation is not represented by a cyclic
  692. /// [-180deg, 180deg] range, but as an unlimited number of degrees/rotations).
  693. hkInt16 m_correspondingAngLimitSolverResultOffset;
  695. /// The target angle for the motor.
  696. hkReal m_targetAngle;
  698. /// Motor; note that it is reference counted and should be handled by the owning constraint's get/set methods.
  699. HK_CPU_PTR(class hkpConstraintMotor*) m_motor;
  700. };
  702. /// Controls relative rotation angle between bodies in three dimensiond; used by the hkpRagdollConstraintData.
  703. ///
  704. /// Note that motor atoms require access to external variables stored in hkpConstraintInstance's runtime.
  705. /// The atom accesses those variables using memory offsets (stored in the atom's members).
  706. struct hkpRagdollMotorConstraintAtom : public hkpConstraintAtom
  707. {
  708. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpRagdollMotorConstraintAtom );
  709. HK_DECLARE_REFLECTION();
  711. hkpRagdollMotorConstraintAtom() : hkpConstraintAtom(TYPE_RAGDOLL_MOTOR) { m_isEnabled = true; m_initializedOffset = 0; m_previousTargetAnglesOffset = 0; }
  712. hkpRagdollMotorConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  713. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  714. HK_FORCE_INLINE int numSolverResults() const    { return 3; }
  715. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( 3 * HK_SIZE_OF_JACOBIAN_1D_ANGULAR_MOTOR_SCHEMA, 3, (1+2) * 3 ); }
  717. /// Tells whether the atom should be handled by the solver.
  718. ///
  719. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  720. hkBool m_isEnabled;
  722. /// Memory offset from atom's solver results to runtime's m_initialized member.
  723. hkInt16 m_initializedOffset;
  725. /// Memory offset from atom's solver results to runtime's m_previousTargetAngle member.
  726. hkInt16 m_previousTargetAnglesOffset;
  728. /// The target relative rotation the motors will try to match.
  729. /// This is the target rotation from bodyA's constraint space into the bodyB's (non-constraint) space. 
  730. hkMatrix3 m_target_bRca;
  732. /// Three motors; note that they are reference counted and should be handled by the owning constraint's get/set methods.
  733. HK_CPU_PTR(class hkpConstraintMotor*) m_motors[3];
  734. };
  736. /// Applies friction force along a specified axes.
  737. struct hkpLinFrictionConstraintAtom : public hkpConstraintAtom
  738. {
  739. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpLinFrictionConstraintAtom );
  740. HK_DECLARE_REFLECTION();
  742. hkpLinFrictionConstraintAtom() : hkpConstraintAtom(TYPE_LIN_FRICTION), m_isEnabled(true) {}
  743. hkpLinFrictionConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  744. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  745. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  746. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_FRICTION_SCHEMA, 1, (1+1) ); }
  748. /// Tells whether the atom should be handled by the solver.
  749. ///
  750. /// Note that if it is not, the atom's corresponding hkpSolverResults are not updated.
  751. hkUint8 m_isEnabled;
  753. /// Index of the axis to apply friction along, in bodyB's constraint base.
  754. hkUint8 m_frictionAxis;
  756. /// Maximum allowed force to be applied due to friction.
  757. hkReal m_maxFrictionForce;
  758. };
  760. /// Controls relative velocity of bodies along a specified axis.
  761. ///
  762. /// Note that motor atoms require access to external variables stored in hkpConstraintInstance's runtime.
  763. /// The atom accesses those variables using memory offsets (stored in the atom's members).
  764. struct hkpLinMotorConstraintAtom : public hkpConstraintAtom
  765. {
  766. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpLinMotorConstraintAtom );
  767. HK_DECLARE_REFLECTION();
  769. hkpLinMotorConstraintAtom() : hkpConstraintAtom(TYPE_LIN_MOTOR) { m_isEnabled = true; m_initializedOffset = 0; m_previousTargetPositionOffset = 0; }
  770. hkpLinMotorConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  771. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  772. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  773. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_LINEAR_MOTOR_SCHEMA, 1, (1+2) ); }
  775. /// A flag saying whether the motor is active
  776. hkBool  m_isEnabled;
  778. /// The index of the axis in the bodyB's constraint base, that will be controlled.
  779. hkUint8 m_motorAxis;
  781. /// Memory offset from atom's solver results to runtime's m_initialized member.
  782. hkInt16 m_initializedOffset;
  784. /// Memory offset from atom's solver results to runtime's m_previousTargetPosition member.
  785. hkInt16 m_previousTargetPositionOffset;
  787. /// The target position for the motor.
  788. hkReal m_targetPosition;
  790. /// Motor; note that it is reference counted and should be handled by the owning constraint's get/set methods.
  791. HK_CPU_PTR(class hkpConstraintMotor*) m_motor;
  792. };
  794. /// This implements a functionality of a pulley, where bodies are attached to a rope, and the rope is lead through two pulley wheels at fixed world positions.
  795. struct hkpPulleyConstraintAtom : public hkpConstraintAtom
  796. {
  797. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT, hkpPulleyConstraintAtom );
  798. HK_DECLARE_REFLECTION();
  800. hkpPulleyConstraintAtom() : hkpConstraintAtom(TYPE_PULLEY) { }
  801. hkpPulleyConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  802. HK_FORCE_INLINE hkpConstraintAtom* next() const { return const_cast<hkpConstraintAtom*>( static_cast<const hkpConstraintAtom*>(this+1) ); }
  803. HK_FORCE_INLINE int numSolverResults() const    { return 1; }
  804. HK_FORCE_INLINE void addToConstraintInfo(hkpConstraintInfo& infoOut) const { infoOut.add( HK_SIZE_OF_JACOBIAN_1D_PULLEY_SCHEMA, 1, 1 ); }
  807. /// Pulley's first fixed pivot point.
  808. hkVector4 m_fixedPivotAinWorld;
  809. /// Pulley's second fixed pivot point.
  810. hkVector4 m_fixedPivotBinWorld;
  812. /// The rest length (equal to ((BodyA's rope) + leverageOnBodyB * (BodyB's rope length)) )
  813. hkReal m_ropeLength;
  814. /// Leverage ratio: e.g. value of 2 means that bodyA's rope length changes by twice as much as bodyB's,
  815. /// and the constraint exerts twice as big forces upon bodyB.
  816. hkReal m_leverageOnBodyB;
  817. };
  822. //
  823. // Atom Modifiers
  824. //
  825. struct hkpModifierConstraintAtom : public hkpConstraintAtom
  826. {
  827. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpModifierConstraintAtom );
  828. HK_DECLARE_REFLECTION();
  830. public:
  831. // adds the constraintInfo of one modifier to cinfo and returns the hkpConstraintAtom::CallbackRequest
  832. int addModifierDataToConstraintInfo( hkpConstraintInfo& cinfo ) const;
  834. // adds its constraintInfo of all linked modifiers to cinfo and returns the hkpConstraintAtom::CallbackRequest
  835. static int HK_CALL addAllModifierDataToConstraintInfo( hkpModifierConstraintAtom* firstModifier, hkpConstraintInfo& cinfo );
  837. protected:
  839. hkpModifierConstraintAtom(enum AtomType type, int size) : hkpConstraintAtom(type), m_modifierAtomSize( hkUint16(size)) {}
  841. public:
  843. hkpModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpConstraintAtom(f) {}
  846. public:
  848. HK_ALIGN16( hkUint16   m_modifierAtomSize );
  849. hkUint16                      m_childSize;
  850. HK_CPU_PTR(hkpConstraintAtom*) m_child;
  851. hkUint32 m_pad[2];
  852. };
  854. // ************************ Soft Contact **************************
  855. // ************************ Soft Contact **************************
  856. // ************************ Soft Contact **************************
  858. struct hkpSoftContactModifierConstraintAtom : public hkpModifierConstraintAtom
  859. {
  860. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpSoftContactModifierConstraintAtom );
  861. HK_DECLARE_REFLECTION();
  863. public:
  865. hkpSoftContactModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_SOFT_CONTACT, sizeof(hkpSoftContactModifierConstraintAtom)),  m_tau(0.1f), m_maxAcceleration( 20.0f) { }
  866. hkpSoftContactModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  868. void collisionResponseBeginCallback( const hkContactPoint& cp, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  869. void collisionResponseEndCallback(   const hkContactPoint& cp, hkReal impulseApplied, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  870. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  872. int getConstraintInfo( hkpConstraintInfo& info ) const { return hkpConstraintAtom::CALLBACK_REQUEST_SETUP_PPU_ONLY; }
  874. public:
  876. hkReal m_tau;
  878. /// The maximum acceleration, the solver will apply
  879. hkReal m_maxAcceleration;
  880. };
  882. // ************************ Mass Changer **************************
  883. // ************************ Mass Changer **************************
  884. // ************************ Mass Changer **************************
  886. struct hkpMassChangerModifierConstraintAtom : public hkpModifierConstraintAtom
  887. {
  888. //+version(1)
  889. HK_DECLARE_REFLECTION();
  890. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpMassChangerModifierConstraintAtom );
  892. public:
  894. hkpMassChangerModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_MASS_CHANGER, sizeof(hkpMassChangerModifierConstraintAtom)) {}
  895. hkpMassChangerModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  897. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  899. void collisionResponseBeginCallback( const hkContactPoint& cp, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  900. void collisionResponseEndCallback(   const hkContactPoint& cp, hkReal impulseApplied, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  902. int getConstraintInfo( hkpConstraintInfo& info ) const
  903. {
  904. info.m_sizeOfSchemas   += 2 * HK_SIZE_OF_JACOBIAN_SET_MASS_SCHEMA  + HK_SIZE_OF_JACOBIAN_HEADER_SCHEMA;
  905. return hkpConstraintAtom::CALLBACK_REQUEST_SETUP_PPU_ONLY;
  906. }
  908. public:
  910. hkVector4 m_factorA;
  911. hkVector4 m_factorB;
  912. };
  915. // ************************ Center of Mass Modifier **************************
  916. // ************************ Center of Mass Modifier **************************
  917. // ************************ Center of Mass Modifier **************************
  919. struct hkpCenterOfMassChangerModifierConstraintAtom : public hkpModifierConstraintAtom
  920. {
  921. HK_DECLARE_REFLECTION();
  922. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpMassChangerModifierConstraintAtom );
  924. public:
  926. hkpCenterOfMassChangerModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_CENTER_OF_MASS_CHANGER, sizeof(hkpCenterOfMassChangerModifierConstraintAtom)) {}
  927. hkpCenterOfMassChangerModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  929. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  931. void collisionResponseBeginCallback( const hkContactPoint& cp, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  932. void collisionResponseEndCallback(   const hkContactPoint& cp, hkReal impulseApplied, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  934. int getConstraintInfo( hkpConstraintInfo& info ) const
  935. {
  936. info.m_sizeOfSchemas   += 2 * HK_SIZE_OF_JACOBIAN_ADD_ANGULAR_VELOCITY_SCHEMA  + HK_SIZE_OF_JACOBIAN_HEADER_SCHEMA;
  937. return hkpConstraintAtom::CALLBACK_REQUEST_NONE;
  938. }
  940. public:
  942. // Two displacements in local space of each of the bodies
  943. hkVector4 m_displacementA;
  944. hkVector4 m_displacementB;
  945. };
  950. // ************************ Viscous Surface **************************
  951. // ************************ Viscous Surface **************************
  952. // ************************ Viscous Surface **************************
  954. struct hkpViscousSurfaceModifierConstraintAtom : public hkpModifierConstraintAtom
  955. {
  956. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpViscousSurfaceModifierConstraintAtom );
  957. HK_DECLARE_REFLECTION();
  959. public:
  961. hkpViscousSurfaceModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_VISCOUS_SURFACE, sizeof(hkpViscousSurfaceModifierConstraintAtom)) { }
  963. hkpViscousSurfaceModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  965. int getConstraintInfo( hkpConstraintInfo& info ) const { return hkpConstraintAtom::CALLBACK_REQUEST_SETUP_PPU_ONLY; }
  967. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  968. };
  973. // ************************ Moving Surface **************************
  974. // ************************ Moving Surface **************************
  975. // ************************ Moving Surface **************************
  977. struct hkpMovingSurfaceModifierConstraintAtom : public hkpModifierConstraintAtom
  978. {
  979. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpMovingSurfaceModifierConstraintAtom );
  980. HK_DECLARE_REFLECTION();
  982. public:
  984. hkpMovingSurfaceModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_MOVING_SURFACE, sizeof(hkpMovingSurfaceModifierConstraintAtom)) { }
  985. hkpMovingSurfaceModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  987. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  989. int getConstraintInfo( hkpConstraintInfo& info ) const
  990. {
  991. info.m_sizeOfSchemas   += 2 * HK_SIZE_OF_JACOBIAN_ADD_VELOCITY_SCHEMA + HK_SIZE_OF_JACOBIAN_HEADER_SCHEMA;
  992. return hkpConstraintAtom::CALLBACK_REQUEST_NONE;
  993. }
  995. void collisionResponseBeginCallback( const hkContactPoint& cp, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  996. void collisionResponseEndCallback(   const hkContactPoint& cp, hkReal impulseApplied, struct hkpSimpleConstraintInfoInitInput& inA, struct hkpBodyVelocity& velA, hkpSimpleConstraintInfoInitInput& inB, hkpBodyVelocity& velB);
  998. hkVector4& getVelocity() { return m_velocity; }
  999. const hkVector4& getVelocity() const { return m_velocity; }
  1001. public:
  1003.   hkVector4 m_velocity;
  1004. };
  1007. // ************************ Ignore Constraint **************************
  1008. // ************************ Ignore Constraint **************************
  1009. // ************************ Ignore Constraint **************************
  1011. struct hkpIgnoreModifierConstraintAtom : public hkpModifierConstraintAtom
  1012. {
  1013. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CONSTRAINT, hkpIgnoreModifierConstraintAtom );
  1014. HK_DECLARE_REFLECTION();
  1016. public:
  1018. hkpIgnoreModifierConstraintAtom() : hkpModifierConstraintAtom(TYPE_MODIFIER_IGNORE_CONSTRAINT, sizeof(hkpIgnoreModifierConstraintAtom)) { }
  1019. hkpIgnoreModifierConstraintAtom(hkFinishLoadedObjectFlag f) : hkpModifierConstraintAtom(f) {}
  1021. HK_FORCE_INLINE int numSolverResults() const { return 0; }
  1023. int getConstraintInfo( hkpConstraintInfo& info ) const;
  1024. };
  1030. #endif // HK_DYNAMICS2_CONSTRAINT_ATOM_H
  1032. /*
  1033. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  1034. * 
  1035. * Confidential Information of Havok.  (C) Copyright 1999-2009
  1036. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  1037. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  1038. * rights, and intellectual property rights in the Havok software remain in
  1039. * Havok and/or its suppliers.
  1040. * 
  1041. * Use of this software for evaluation purposes is subject to and indicates
  1042. * acceptance of the End User licence Agreement for this product. A copy of
  1043. * the license is included with this software and is also available at www.havok.com/tryhavok.
  1044. * 
  1045. */