Recent changes to bugs

Re-organize source into seperate files

Daniel Kramer — Thu, 23 Feb 2006 05:13:12 -0000

It's going to be difficult to work on the solver as a
group the way it's organized. Ideally we'd break the
source up in logical chunks to different files to allow
parts of the code to version seperatly

Generate Contact Data

Daniel Kramer — Thu, 23 Feb 2006 05:10:36 -0000

I notice you don't create SIM_Impacts data on the
objects. This is fine, and I don't even know if the ODE
Solver is able
to provide equivalent information. But if it is
possible, outputting
impacts into SIM_Impacts data would allow the ODE
Solver to work with
the SOP Solver to do denting and other such effects.
You also need to be
able to generate and respond to SIM_Impacts data to
work with other
solvers (like the cloth solver). But given the way ODE
handles
constraints, I don't know how much luck you'll have
generating the
impact information you need when one of the objects in
the collision is
cloth (a deforming triangle mesh). But this is all
definitely more
advanced funcitonality which is not required for just a
solid RBD Solver.

Split up Constraint/Force Code

Daniel Kramer — Thu, 23 Feb 2006 05:09:35 -0000

I would definitely split processSubData into two functions,
processConstraints and procesForces. processConstraints
should be
something like:

// Initialize all constraints. This gives constraints a
chance to
// prepare themselves for use, such as by looking up their
// goal objects.
SIM_ConstraintIterator::initConstraints(*object, time);

SIM_DataFilterByType anchorFilter("SIM_ConAnchor");
SIM_ConstratinIterator conit(*object, 0, &anchorFilter,
&anchorFilter, time);

for (conit.rewind(); !conit.atEnd(); conit.advance())
{
SIM_ConRel *conrel;
const SIM_ConAnchorSpatial *spanchor,
*goalspanchor;
const SIM_ConAnchorRotational *rotanchor,
*goalrotanchor;

conrel = conit.getRelationship();
spanchor = SIM_DATA_CASTCONST(it.getCurrentAnchor(),

SIM_ConAnchorSpatial);
goalspanchor =
SIM_DATA_CASTCONST(it.getGoalAnchor(),

SIM_ConAnchorSpatial);
if( spanchor && goalspanchor )
{
// Handle spatial constraints.
}

rotanchor =
SIM_DATA_CASTCONST(it.getCurrentAnchor(),

SIM_ConAnchorRotational);
goalrotanchor =
SIM_DATA_CASTCONST(it.getGoalAnchor(),

SIM_ConAnchorRotational);
if( rotanchor && goalrotanchor )
{
// Handle Rotational constraints.
}
}

As for forces, you don't need to handle each force type
individually.
You should use the functions on the SIM_Force base
class. Also, there
are functions for making a calback for all data that
matches a
particular data type. So processForces would look
something like:

///
/// This is a helper class to iterate over all the
forces on an object
/// and sum them up.
///
class ODE_EachForceCallback : public SIM_EachDataCallback
{
public:
ODE_EachForceCallback(const
UT_Vector3 &pos,
const
UT_Vector3 &vel,
const
UT_Vector3 &angvel,
const fpreal
mass,
UT_Vector3
&force,
UT_Vector3
&torque)
: myPosition(pos),
myVelocity(vel),
myAngVel(angvel),
myMass(mass),
myForce(force),
myTorque(torque)
{ }
virtual ~ODE_EachForceCallback()
{ }

virtual void callbackConst(const
SIM_Data *data,
const
char *name);

private:
UT_Vector3 myPosition;
UT_Vector3 myVelocity;
UT_Vector3 myAngVel;
fpreal myMass;
UT_Vector3 &myForce;
UT_Vector3 &myTorque;
};

void
ODE_EachForceCallback::callbackConst(const SIM_Data
*data, const char *)
{
const SIM_Force *forcedata =
SIM_DATA_CASTCONST(data,

SIM_Force);
UT_Vector3 force, torque;

forcedata->getForce(myPosition, myVelocity, myAngVel,
myMass, force, torque);
myForce += force;
myTorque += torque;
}

processForces(SIM_Object *object)
{
// Grab the velocity, angular velocity, mass,
and center of
// mass fromthe object (from the Position data).

UT_Vector3 sumforces(0.0, 0.0, 0.0);
UT_Vector3 sumtorque(0.0, 0.0, 0.0);
ODE_EachForceCallback callback(com,
vel,
angvel,
mass,
sumforces,
sumtorques);

object->getObject()->forEachConstSubData(callback,

SIM_DataFilterByType("SIM_Force"),
SIM_FORCES_DATANAME,
SIM_DataFilterNone());

// Apply sumforces and sumtorques to object...
}

I also noticed you calling getNthConstSubData to grab
the force and
constraint data. You should avoid this function
whenever possible. If
you call this function for each subdata, you've created
an O(n^2)
algorithm on the number of subdata.

Simplify Constraint/Force Iteration

Daniel Kramer — Thu, 23 Feb 2006 05:08:31 -0000

You can probably simplify the code for dealing with
constraints a lot by using the SIM_ConstraintIterator
class. It provides
an interface to loop through all constraints of a
particular type. It
should be easier than looping through the constraints
yourself. You
should also never have to go through the
"getQueryObject" functionin the
solver code. You have the following code:

goalAnchor->getQueryObject().getFieldString ("Options",
0, "objectname",
goalObjName);

Which works fine, but is much slower than:

goalobj = goalAnchor->getReferencedObject(time);

Deleting ODE World and Bodies

Daniel Kramer — Thu, 23 Feb 2006 05:06:46 -0000

I also notice that m_odeBodies.clear() probably doesn't
free the ODE
bodies, and deleting m_odeGlobals doesn't delete the
ODE World. That
should probably be fixed too in the clear() function...

mySIM_Geometry on line 351

Daniel Kramer — Thu, 23 Feb 2006 05:05:42 -0000

As a final note on mySIM_Geometry, on line 351 you cast
a "const
SIM_Geometry *" to a "mySIM_Geometry *", which you
should never ever do
with the SIM library. Even though in this case the cast to
mySIM_Geometry is safe (since mySIM_Geometry has no
virtual functions or
member data), the casting away of the const is a mortal
sin in DOPs.
Doing so lets you modify data that is shared by
mutliple objects, or
used inthe cache (so you are modifying data back in
time). If you do
find that you need the funtionality provided by
mySIM_Geometry::setGdp,
I would suggest you use code like this:

SIM_GeometryCopy *modgeo;

modgeo = SIM_DATA_CREATE(*currObject,
SIM_GEOMETRY_DATANAME,
SIM_GeometryCopy, SIM_DATA_RETURN_EXISTING |
SIM_DATA_ADOPT_EXISTING_ON_DELETE);
if( modgeo )
{
GU_Detail *modgdp = modgeo->lockGeometry();
// modify modgdp any way you want
modgeo->releaseGeometry();
}

Remove Global Data

Daniel Kramer — Thu, 23 Feb 2006 04:59:51 -0000

Currently we're defining global data for "m_odeGlobals"
and "m_odeBodies". These should be defined as SubData
to allow for multiple ODESolvers to run in a hip sim.

Here's some advice from Mark Tucker:

I would suggest creating a SIM_Data subclass to hold
this information instead. Somthing like this:

class SIM_OdeWorldData : public SIM_Data
{
public:
odeGlobals &getOrCreateOdeGlobals()
{ return m_odeGlobals; }
std::map<int, odeBody> &getOdeBodies()
{ return m_odeBodies; }

protected:
explicit SIM_OdeWorldData(const SIM_DataFactory
*factory)
: BaseClass(factory),
m_odeBodies(0),
m_odeGlobals(0),
m_shareCount(0)
{ }
virtual ~SIM_OdeWorldData()
{ clear(); }

// This ensures that this data is always kept in
RAM, even when
// the cache runs out of space and writes out
the simulation
// step to disk. This is necessary because the
ODE data can't
// be written to disk.
virtual bool getCanBeSavedToDiskSubclass() const
{ return false; }

// Start fro scratch. We create a brand new world.
virtual void initiailizeSubclass()
{
clear();
m_odeBodies = new
std::map<int,

odeBody>();
m_odeGlobals = new
odeGlobals();
m_shareCount = new int(1);
}

// To make one world equal to another, copythe
data exactly.
// The share count lets several of these data
share the same
// ODE world and bodies without worrying that
the ODE data
// will get deleted as long as any
SIM_OdeWorldData is holding
// onto it.
virtual void makeEqualSubclass(const SIM_Data *src)
{
SIM_OdeWorldData *world;
world = SIM_DATA_CASTCONST(src,
SIM_OdeWorldData);
if( world )
{
clear();
m_shareCount =
world->m_shareCount;
m_odeBodies =
world->m_odeBodies;
m_odeGlobals =
world->m_odeGlobals;
(*m_shareCount)++;
}
}

private:
void clear()
{
if( m_shareCount )
{
(*m_shareCount)--;
if(*m_shareCount
== 0)
{

m_odeBodies.clear();
delete
m_odeGlobals;
delete
m_shareCount;
}
}
m_shareCount = 0;
m_odeGlobals = 0;
m_odeBodies = 0;
}

std::map<int, odeBody> *m_odeBodies;
odeGlobals *m_odeGlobals;
int *m_shareCount;
}