AGX Dynamics 2.42.3.1
Loading...
Searching...
No Matches
BinaryConstraintEntity.h
Go to the documentation of this file.
1/*
2Copyright 2007-2025. Algoryx Simulation AB.
3
4All AGX source code, intellectual property, documentation, sample code,
5tutorials, scene files and technical white papers, are copyrighted, proprietary
6and confidential material of Algoryx Simulation AB. You may not download, read,
7store, distribute, publish, copy or otherwise disseminate, use or expose this
8material unless having a written signed agreement with Algoryx Simulation AB, or
9having been advised so by Algoryx Simulation AB for a time limited evaluation,
10or having purchased a valid commercial license from Algoryx Simulation AB.
11
12Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
13from using this software, unless otherwise stated in written agreements with
14Algoryx Simulation AB.
15*/
16
18// AUTOMATICALLY GENERATED ENTITY, DO NOT EDIT! //
20
21#ifndef GENERATED_AGX_PHYSICS_BINARYCONSTRAINT_H_PLUGIN
22#define GENERATED_AGX_PHYSICS_BINARYCONSTRAINT_H_PLUGIN
23
24#define AGX_ENTITY_WRAPPER 1
25
26
27#ifdef _MSC_VER
28# pragma warning(push)
29// warning C4505: 'agxData::VectorAttributeT<T>::print' : unreferenced local function has been removed
30# pragma warning( disable : 4505 )
31// warning C4251: 'X' : class 'Y' needs to have dll-interface to be used by clients of class 'Z'
32# pragma warning( disable : 4251 )
33// warning C4355: 'this' : used in base member initializer list
34# pragma warning( disable : 4355 )
35// marked as __forceinline not inlined
36# pragma warning( disable: 4714 )
37#endif
38
39#include <agxData/EntityModel.h>
41#include <agxData/EntityRef.h>
42#include <agxData/EntityPtr.h>
44#include <agx/Integer.h>
45#include <agx/Real.h>
46#include <agx/macros.h>
48#include <agx/Integer.h>
49
50
51namespace agx
52{
53 namespace Physics
54 {
55
56 class BinaryConstraintModel;
57 class BinaryConstraintData;
58 class BinaryConstraintPtr;
59 class BinaryConstraintInstance;
60 class BinaryConstraintSemantics;
61
62
64
69 {
70 public:
72
73 BinaryConstraintModel(const agx::String& name = "BinaryConstraint");
74
77
80
83
85 virtual void shutdownCleanup() override;
86
87
88
89 /* Attributes */
92
93 protected:
95 virtual agxData::EntityData* createData(agxData::EntityStorage* storage) override;
96 virtual void configure(agx::TiXmlElement* eEntity) override;
97 virtual void initAttributeAccessors() override;
98 virtual void construct(agxData::EntityPtr instance) override;
100 };
101
102
104 #ifndef AGX_PHYSICS_BINARYCONSTRAINT_DATA_SET_OVERRIDE
105 #define AGX_PHYSICS_BINARYCONSTRAINT_DATA_SET
106 class AGXPHYSICS_EXPORT BinaryConstraintData : public agx::Physics::ConstraintBaseData
107 {
108 public:
109 BinaryConstraintInstance operator[] (size_t index);
110
111 public:
115
116 public:
117 typedef agx::UInt body1Type;
118 typedef agx::UInt body2Type;
119
120 public:
121 BinaryConstraintData(agxData::EntityStorage* storage);
122 BinaryConstraintData();
123
124 protected:
125 virtual ~BinaryConstraintData() {}
126 virtual void setNumElements(agx::Index numElements) override;
127
128 private:
129 BinaryConstraintData& operator= (const BinaryConstraintData&) { return *this; }
130
131 };
132 #endif
134
135
137 class AGXPHYSICS_EXPORT BinaryConstraintSemantics : public agx::Physics::ConstraintBaseSemantics
138 {
139 public:
140
141 // Automatic getters
142 agx::UInt const& getBody1() const;
143 agx::UInt const& getBody2() const;
144
145 // Semantics defined by explicit kernels
146
147 // Automatic setters
148 void setBody1(agx::UInt const& value);
149 void setBody2(agx::UInt const& value);
150
151
152 protected:
153 friend class BinaryConstraintPtr;
154 friend class BinaryConstraintInstance;
155 BinaryConstraintSemantics();
156 };
158
159
160
164 {
165 public:
167 typedef BinaryConstraintData DataType;
168 typedef BinaryConstraintInstance InstanceType;
169
170 public:
177 AGXPHYSICS_EXPORT BinaryConstraintInstance instance();
178 AGXPHYSICS_EXPORT const BinaryConstraintInstance instance() const;
179
180 AGXPHYSICS_EXPORT BinaryConstraintSemantics* operator->();
181 AGXPHYSICS_EXPORT const BinaryConstraintSemantics* operator->() const;
182
183 BinaryConstraintData* getData();
184 const BinaryConstraintData* getData() const;
185
186
191
196
197 };
198
199
201 class AGXPHYSICS_EXPORT BinaryConstraintInstance : public agx::Physics::ConstraintBaseInstance
202 {
203 public:
204 BinaryConstraintInstance();
205 BinaryConstraintInstance(BinaryConstraintData* data, agx::Index index);
206 BinaryConstraintInstance(agxData::EntityStorage *storage, agx::Index index);
207 BinaryConstraintInstance(const agxData::EntityInstance& other);
208 BinaryConstraintInstance(const agxData::EntityPtr& ptr);
209
210 BinaryConstraintData* getData();
211 const BinaryConstraintData* getData() const;
212
213 public:
215 agx::UInt& body1();
217 agx::UInt const& body1() const;
218
220 agx::UInt& body2();
222 agx::UInt const& body2() const;
223
224 };
226
227
228
231
232
233
235 /* Implementation */
236 //-----------------------------------------------------------------------------------------------------
237 //-----------------------------------------------------------------------------------------------------
238 inline BinaryConstraintInstance agx::Physics::BinaryConstraintData::operator[] (size_t index) { return BinaryConstraintInstance(this, (agx::Index)index); }
239 //-----------------------------------------------------------------------------------------------------
241 AGX_FORCE_INLINE BinaryConstraintPtr::BinaryConstraintPtr(agxData::EntityStorage* storage, agx::Index id) : agx::Physics::ConstraintBasePtr(storage, id) {}
242 AGX_FORCE_INLINE BinaryConstraintPtr::BinaryConstraintPtr(const agxData::EntityPtr& ptr) : agx::Physics::ConstraintBasePtr(ptr)
243 {
245 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
246 EntityPtr::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
247 }
248
249 AGX_FORCE_INLINE BinaryConstraintPtr::BinaryConstraintPtr(const agxData::EntityInstance& instance) : agx::Physics::ConstraintBasePtr(instance)
250 {
252 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
253 EntityPtr::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
254 }
255
256 AGX_FORCE_INLINE BinaryConstraintPtr& BinaryConstraintPtr::operator= (const agxData::EntityPtr& ptr)
257 {
259 agxAssertN(!ptr || ptr.isInstanceOf(BinaryConstraintModel::instance()),
260 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
261 EntityPtr::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
262 return *this;
263 }
264
265 AGX_FORCE_INLINE BinaryConstraintPtr& BinaryConstraintPtr::operator= (const agxData::EntityInstance& instance)
266 {
268 agxAssertN(!instance || instance.isInstanceOf(BinaryConstraintModel::instance()),
269 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
270 EntityPtr::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
271 return *this;
272 }
273
274 inline BinaryConstraintInstance BinaryConstraintPtr::instance() { return agxData::EntityPtr::instance(); }
275 inline const BinaryConstraintInstance BinaryConstraintPtr::instance() const { return agxData::EntityPtr::instance(); }
276 AGX_FORCE_INLINE BinaryConstraintSemantics* BinaryConstraintPtr::operator->() { return (BinaryConstraintSemantics* )this; }
277 AGX_FORCE_INLINE const BinaryConstraintSemantics* BinaryConstraintPtr::operator->() const { return (const BinaryConstraintSemantics* )this; }
278 AGX_FORCE_INLINE BinaryConstraintData* BinaryConstraintPtr::getData() { return static_cast<BinaryConstraintData* >(agxData::EntityPtr::getData()); }
279 AGX_FORCE_INLINE const BinaryConstraintData* BinaryConstraintPtr::getData() const { return static_cast<const BinaryConstraintData* >(agxData::EntityPtr::getData()); }
280
281 AGX_FORCE_INLINE agx::UInt& BinaryConstraintPtr::body1() { verifyIndex(); return getData()->body1[calculateIndex()]; }
282 AGX_FORCE_INLINE agx::UInt const& BinaryConstraintPtr::body1() const { verifyIndex(); return getData()->body1[calculateIndex()]; }
283
284 AGX_FORCE_INLINE agx::UInt& BinaryConstraintPtr::body2() { verifyIndex(); return getData()->body2[calculateIndex()]; }
285 AGX_FORCE_INLINE agx::UInt const& BinaryConstraintPtr::body2() const { verifyIndex(); return getData()->body2[calculateIndex()]; }
286
287 //-----------------------------------------------------------------------------------------------------
288 AGX_FORCE_INLINE BinaryConstraintInstance::BinaryConstraintInstance() {}
289 AGX_FORCE_INLINE BinaryConstraintInstance::BinaryConstraintInstance(BinaryConstraintData* data, agx::Index index) : agx::Physics::ConstraintBaseInstance(data, index) {}
290 AGX_FORCE_INLINE BinaryConstraintInstance::BinaryConstraintInstance(agxData::EntityStorage* storage, agx::Index index) : agx::Physics::ConstraintBaseInstance(storage, index) {}
291 AGX_FORCE_INLINE BinaryConstraintInstance::BinaryConstraintInstance(const agxData::EntityInstance& other) : agx::Physics::ConstraintBaseInstance(other)
292 {
294 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
295 EntityInstance::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
296 }
297
298 AGX_FORCE_INLINE BinaryConstraintInstance::BinaryConstraintInstance(const agxData::EntityPtr& ptr) : agx::Physics::ConstraintBaseInstance(ptr)
299 {
301 "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",
302 EntityInstance::getModel()->fullPath().c_str(), BinaryConstraintModel::instance()->fullPath().c_str());
303 }
304
305
306 AGX_FORCE_INLINE BinaryConstraintData* BinaryConstraintInstance::getData() { return static_cast<BinaryConstraintData* >(agxData::EntityInstance::getData()); }
307 AGX_FORCE_INLINE const BinaryConstraintData* BinaryConstraintInstance::getData() const { return static_cast<const BinaryConstraintData* >(agxData::EntityInstance::getData()); }
308
309 AGX_FORCE_INLINE agx::UInt& BinaryConstraintInstance::body1() { verifyIndex(); return getData()->body1[getIndex()]; }
310 AGX_FORCE_INLINE agx::UInt const& BinaryConstraintInstance::body1() const { verifyIndex(); return getData()->body1[getIndex()]; }
311
312 AGX_FORCE_INLINE agx::UInt& BinaryConstraintInstance::body2() { verifyIndex(); return getData()->body2[getIndex()]; }
313 AGX_FORCE_INLINE agx::UInt const& BinaryConstraintInstance::body2() const { verifyIndex(); return getData()->body2[getIndex()]; }
314
315 //-----------------------------------------------------------------------------------------------------
316 AGX_FORCE_INLINE BinaryConstraintSemantics::BinaryConstraintSemantics() {}
317 //-----------------------------------------------------------------------------------------------------
319 }
320}
321
322AGX_TYPE_BINDING(agx::Physics::BinaryConstraintPtr, "Physics.BinaryConstraintPtr")
323AGX_TYPE_BINDING(agx::Physics::BinaryConstraintInstance, "Physics.BinaryConstraintInstance")
324
325#ifdef _MSC_VER
326# pragma warning(pop)
327#endif
328
329#undef AGX_ENTITY_WRAPPER
330#undef AGX_ENTITY_NAMESPACE
331#endif
332
#define AGX_DECLARE_POINTER_TYPES(type)
Definition: Referenced.h:254
#define AGX_TYPE_BINDING(_Type, _Name)
Definition: Type.h:179
#define AGXPHYSICS_EXPORT
Type-specific Array used for fast access into the data held by a Buffer.
Definition: Array.h:107
Entity instance provides access to a single instance in an EntityStorage.
bool isInstanceOf(agxData::EntityModel *model) const
agxData::EntityData * getData()
Accessor to a entity instance stored in a EntityStorage, to allow SOA (structure of arrays) data to b...
Definition: EntityPtr.h:52
EntityPtr & operator=(const EntityPtr &other)=default
bool isInstanceOf(agxData::EntityModel *model) const
agxData::EntityData * getData()
agxData::EntityInstance instance()
Definition: EntityPtr.h:269
Data storage for a collection of entity instances of a specified EntityModel.
Definition: EntityStorage.h:73
agx::String fullPath() const
Abstract description of the data attributes for the Physics.BinaryConstraint entity.
static agxData::ScalarAttributeT< agx::UInt > * body1Attribute
virtual void construct(agxData::EntityPtr instance) override
static BinaryConstraintModel * instance()
virtual void configure(agx::TiXmlElement *eEntity) override
virtual agxData::EntityData * createData(agxData::EntityStorage *storage) override
BinaryConstraintModel(const agx::String &name="BinaryConstraint")
virtual void shutdownCleanup() override
This is part of internal cleanup and should not be called by users.
static agxData::EntityStorage * defaultStorage()
static agxData::ScalarAttributeT< agx::UInt > * body2Attribute
virtual void initAttributeAccessors() override
void construct(agx::Physics::BinaryConstraintPtr binaryConstraint)
static BinaryConstraintPtr createInstance()
Create and return a pointer to a new instance in the default storage for this entity model.
Pointer to a entity instance of type Physics.BinaryConstraint.
BinaryConstraintData * getData()
AGXPHYSICS_EXPORT const BinaryConstraintSemantics * operator->() const
AGXPHYSICS_EXPORT BinaryConstraintPtr(const agxData::EntityPtr &ptr)
AGXPHYSICS_EXPORT BinaryConstraintInstance instance()
AGXPHYSICS_EXPORT agx::UInt const & body2() const
AGXPHYSICS_EXPORT BinaryConstraintSemantics * operator->()
AGXPHYSICS_EXPORT BinaryConstraintPtr(const agxData::EntityInstance &instance)
AGXPHYSICS_EXPORT agx::UInt const & body1() const
AGXPHYSICS_EXPORT const BinaryConstraintInstance instance() const
const BinaryConstraintData * getData() const
AGXPHYSICS_EXPORT agx::UInt & body1()
AGXPHYSICS_EXPORT BinaryConstraintPtr(agxData::EntityStorage *storage, agx::Index id)
AGXPHYSICS_EXPORT agx::UInt & body2()
AGXPHYSICS_EXPORT BinaryConstraintPtr()
Abstract description of the data attributes for the Physics.ConstraintBase entity.
Pointer to a entity instance of type Physics.ConstraintBase.
Vector containing 'raw' data.
Definition: agx/Vector.h:246
#define agxAssertN(expr, format,...)
Definition: debug.h:145
#define DOXYGEN_END_INTERNAL_BLOCK()
Definition: macros.h:89
#define CALLABLE
Definition: macros.h:72
#define DOXYGEN_START_INTERNAL_BLOCK()
Definition: macros.h:88
#define AGX_FORCE_INLINE
Definition: macros.h:58
Contains classes for low level data storage for AGX.
Definition: Container.h:23
The agx namespace contains the dynamics/math part of the AGX Dynamics API.
uint64_t UInt
Definition: Integer.h:27
UInt32 Index
Definition: Integer.h:44