1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*************************************************************************
* *
* Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. *
* All rights reserved. Email: russ@q12.org Web: www.q12.org *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of EITHER: *
* (1) The GNU Lesser General Public License as published by the Free *
* Software Foundation; either version 2.1 of the License, or (at *
* your option) any later version. The text of the GNU Lesser *
* General Public License is included with this library in the *
* file LICENSE.TXT. *
* (2) The BSD-style license that is included with this library in *
* the file LICENSE-BSD.TXT. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files *
* LICENSE.TXT and LICENSE-BSD.TXT for more details. *
* *
*************************************************************************/
// object, body, and world structs.
#ifndef _ODE__PRIVATE_OBJECTS_H_
#define _ODE__PRIVATE_OBJECTS_H_
#include <ode/common.h>
#include <ode/memory.h>
#include <ode/mass.h>
#include "error.h"
#include "array.h"
#include "common.h"
#include "threading_base.h"
struct dxJointNode;
class dxStepWorkingMemory;
class dxWorldProcessContext;
// some body flags
enum {
dxBodyFlagFiniteRotation = 1, // use finite rotations
dxBodyFlagFiniteRotationAxis = 2, // use finite rotations only along axis
dxBodyDisabled = 4, // body is disabled
dxBodyNoGravity = 8, // body is not influenced by gravity
dxBodyAutoDisable = 16, // enable auto-disable on body
dxBodyLinearDamping = 32, // use linear damping
dxBodyAngularDamping = 64, // use angular damping
dxBodyMaxAngularSpeed = 128,// use maximum angular speed
dxBodyGyroscopic = 256 // use gyroscopic term
};
// base class that does correct object allocation / deallocation
struct dBase {
void *operator new (size_t size) { return dAlloc (size); }
void *operator new (size_t, void *p) { return p; }
void operator delete (void *ptr, size_t size) { dFree (ptr,size); }
void *operator new[] (size_t size) { return dAlloc (size); }
void operator delete[] (void *ptr, size_t size) { dFree (ptr,size); }
};
// base class for bodies and joints
struct dObject : public dBase {
dxWorld *world; // world this object is in
dObject *next; // next object of this type in list
dObject **tome; // pointer to previous object's next ptr
int tag; // used by dynamics algorithms
void *userdata; // user settable data
explicit dObject(dxWorld *w): world(w), next(NULL), tome(NULL), tag(0), userdata(NULL) {}
virtual ~dObject();
};
// auto disable parameters
struct dxAutoDisable {
dReal idle_time; // time the body needs to be idle to auto-disable it
int idle_steps; // steps the body needs to be idle to auto-disable it
unsigned int average_samples; // size of the average_lvel and average_avel buffers
dReal linear_average_threshold; // linear (squared) average velocity threshold
dReal angular_average_threshold; // angular (squared) average velocity threshold
dxAutoDisable() {}
explicit dxAutoDisable(void *);
};
// damping parameters
struct dxDampingParameters {
dReal linear_scale; // multiply the linear velocity by (1 - scale)
dReal angular_scale; // multiply the angular velocity by (1 - scale)
dReal linear_threshold; // linear (squared) average speed threshold
dReal angular_threshold; // angular (squared) average speed threshold
dxDampingParameters() {}
explicit dxDampingParameters(void *);
};
// quick-step parameters
struct dxQuickStepParameters {
int num_iterations; // number of SOR iterations to perform
dReal w; // the SOR over-relaxation parameter
dxQuickStepParameters() {}
explicit dxQuickStepParameters(void *);
};
// contact generation parameters
struct dxContactParameters {
dReal max_vel; // maximum correcting velocity
dReal min_depth; // thickness of 'surface layer'
dxContactParameters() {}
explicit dxContactParameters(void *);
};
// position vector and rotation matrix for geometry objects that are not
// connected to bodies.
struct dxPosR {
dVector3 pos;
dMatrix3 R;
};
struct dxBody : public dObject {
dxJointNode *firstjoint; // list of attached joints
unsigned flags; // some dxBodyFlagXXX flags
dGeomID geom; // first collision geom associated with body
dMass mass; // mass parameters about POR
dMatrix3 invI; // inverse of mass.I
dReal invMass; // 1 / mass.mass
dxPosR posr; // position and orientation of point of reference
dQuaternion q; // orientation quaternion
dVector3 lvel,avel; // linear and angular velocity of POR
dVector3 facc,tacc; // force and torque accumulators
dVector3 finite_rot_axis; // finite rotation axis, unit length or 0=none
// auto-disable information
dxAutoDisable adis; // auto-disable parameters
dReal adis_timeleft; // time left to be idle
int adis_stepsleft; // steps left to be idle
dVector3* average_lvel_buffer; // buffer for the linear average velocity calculation
dVector3* average_avel_buffer; // buffer for the angular average velocity calculation
unsigned int average_counter; // counter/index to fill the average-buffers
int average_ready; // indicates ( with = 1 ), if the Body's buffers are ready for average-calculations
void (*moved_callback)(dxBody*); // let the user know the body moved
dxDampingParameters dampingp; // damping parameters, depends on flags
dReal max_angular_speed; // limit the angular velocity to this magnitude
dxBody(dxWorld *w);
};
struct dxWorld : public dBase, public dxThreadingBase, private dxIThreadingDefaultImplProvider {
dxBody *firstbody; // body linked list
dxJoint *firstjoint; // joint linked list
int nb,nj; // number of bodies and joints in lists
dVector3 gravity; // gravity vector (m/s/s)
dReal global_erp; // global error reduction parameter
dReal global_cfm; // global constraint force mixing parameter
dxAutoDisable adis; // auto-disable parameters
int body_flags; // flags for new bodies
unsigned islands_max_threads; // maximum threads to allocate for island processing
dxStepWorkingMemory *wmem; // Working memory object for dWorldStep/dWorldQuickStep
dxQuickStepParameters qs;
dxContactParameters contactp;
dxDampingParameters dampingp; // damping parameters
dReal max_angular_speed; // limit the angular velocity to this magnitude
void* userdata;
dxWorld();
virtual ~dxWorld(); // Compilers issue warnings if a class with virtual methods does not have a virtual destructor :(
void assignThreadingImpl(const dxThreadingFunctionsInfo *functions_info, dThreadingImplementationID threading_impl);
unsigned calculateIslandProcessingMaxThreadCount(unsigned *ptrOut_activeThreadCount=NULL) const
{
unsigned activeThreadCount, *ptrActiveThreadCountToUse = ptrOut_activeThreadCount != NULL ? &activeThreadCount : NULL;
unsigned limitedCount = calculateThreadingLimitedThreadCount(islands_max_threads, false, ptrActiveThreadCountToUse);
if (ptrOut_activeThreadCount != NULL) {
*ptrOut_activeThreadCount = dMACRO_MAX(activeThreadCount, 1U);
}
return dMACRO_MAX(limitedCount, 1U);
}
dxWorldProcessContext *unsafeGetWorldProcessingContext() const;
private: // dxIThreadingDefaultImplProvider
virtual const dxThreadingFunctionsInfo *retrieveThreadingDefaultImpl(dThreadingImplementationID &out_defaultImpl);
};
#endif // #ifndef _ODE__PRIVATE_OBJECTS_H_
|
