---

MdtTypes.h

Go to the documentation of this file.

#ifndef _MDTTYPES_H
#define _MDTTYPES_H
/*
  Copyright MathEngine PLC 2000

  $Name: t-release-0-0-5-msvcrt $:

  $Id: MdtTypes.h,v 1.37 2000/09/09 00:02:03 michaelc Exp $
*/

/** @file
 * Declares all the high level data structures used by the
 * Mdt library.
 */

typedef struct MdtConstraintHeader MdtConstraintHeader;

typedef struct MdtWorld          MdtWorld;
typedef struct MdtBody           MdtBody;
typedef struct MdtContact        MdtContact;
typedef struct MdtBSJoint        MdtBSJoint;
typedef struct MdtHinge          MdtHinge;
typedef struct MdtPrismatic      MdtPrismatic;
typedef struct MdtCarWheel       MdtCarWheel;
typedef struct MdtFixedPath      MdtFixedPath;
typedef struct MdtFPFOJoint      MdtFPFOJoint;
typedef struct MdtUniversal      MdtUniversal;
typedef struct MdtLinear1        MdtLinear1;
typedef struct MdtLinear2        MdtLinear2;
typedef struct MdtBaseConstraint MdtBaseConstraint;

typedef struct MdtCListNode      MdtCListNode;

/** MdtWorld identifier */
typedef MdtWorld                 *MdtWorldID;
/** MdtBody identifier */
typedef MdtBody                  *MdtBodyID;
/** MdtContact identifier */
typedef MdtContact               *MdtContactID;
/** MdtBSJoint ball and socket joint identifier */
typedef MdtBSJoint               *MdtBSJointID;
/** MdtHinge identifier */
typedef MdtHinge                 *MdtHingeID;
/** MdtPrismatic identifier */
typedef MdtPrismatic             *MdtPrismaticID;
/** MdtCarWheel identifier */
typedef MdtCarWheel              *MdtCarWheelID;
/** MdtFixedPath identifier */
typedef MdtFixedPath             *MdtFixedPathID;
/** MdtFPFOJoint fixed path fixed orientation identifier */
typedef MdtFPFOJoint             *MdtFPFOJointID;
/** MdtUniversal identifier */
typedef MdtUniversal             *MdtUniversalID;
/** MdtLinear1 identifier */
typedef MdtLinear1               *MdtLinear1ID;
/** MdtLinear2 identifier */
typedef MdtLinear2               *MdtLinear2ID;

/**
 * Genereal MdtConstraint identifier.
 * Use appropriate 'Qua' function to convert a specific type of constraint
 * (eg. MdtContactID or MdtHingeID) to an MdtConstraintID.
 */
typedef MdtBaseConstraint        *MdtConstraintID;

/** MdtBclLimit joint limit identifier */
typedef MdtBclLimit              *MdtLimitID;
/** MdtBclSingleLimit joint stop identifier */
typedef MdtBclSingleLimit        *MdtSingleLimitID;
/** MdtBclContactParams contact parameters identifier */
typedef MdtBclContactParams      *MdtContactParamsID;


typedef union MdtConstraintUnion MdtConstraintUnion;

/**
 * Dynamics Event Manager mode of operation.
 */

typedef enum
{
    /** Partition scene and AutoDisable objects. */
    MdtDEMModePartitionAutoDisable,

    /** Partition scene but dont AutoDisable objects. */
    MdtDEMModePartitionNoAutoDisable,

    /** 
     * Don't partition or AutoDisable objects. All bodies
     * are simulated regardless of whether they are enabled
     * or disabled. 
     */
    MdtDEMModeNoPartition       
}
MdtDEMMode;

/**
 * Memory Pool Overflow Callback
 * If the memory pool is found to be too small when trying to solve
 * a system during MdtWorldStep, the user may specify a callback that
 * will be executed, allowing the user to change the size of the
 * pool. The first parameter is the current memory pool, the second is
 * the current pool size and the third is the size of the pool required
 * to solve the system. The callback should call MdtWorldSetMemoryPool
 * to change the memory pool to a sufficiantly large size, but should not
 * call any other Mdt functions.
 */
typedef void
(*MdtMemoryPoolOverflowCB)(MdtWorldID w, void *m, int current_size, int required_size);

/*
   Data Structures
*/

/**
 * Mdt Constraint Header.
 *
 * Contains data common to all constraints.
 */
struct MdtConstraintHeader
{
    /** The world the constraint is in. */
    MdtWorldID          world;

    /** Pointer to next constraint. */
    MdtBaseConstraint   *next;
    /** Address of the 'next' pointer in the previous constraint. */
    MdtBaseConstraint   **tome;

    /** User data. This will not be changed from with the toolkit*/
    void                *userData;

    /** The (up to) 4 constrained bodies. */
    MdtBody             *body[4];

    /**
     * Pointers to this constraints entries in its bodies
     * lists. This is kept so these references can be removed
     * when the constraint is Disabled.
     */
    MdtCListNode*        cNode[4];

    /** Set by the event manager during constraint graph traversal. */
    int                 flag;

    /*
      Output Applied Forces - READ ONLY!
    */

    /**
     * Force applied to each of the constraints bodies by this
     * constraint.
     */
    MeVector4           resultForce[3];

    /**
     * Torque applied to each of the constraints bodies by this constraint
     */
    MeVector4           resultTorque[3];
};

/**
 * World Struct contains simulation-wide parameters.
 *
 * vel_thresh, velrot_thresh, acc_thresh, accrot_thresh and alive_window
 * are used for determining when bodies are at rest. A body at rest is
 * not processed by the solver till reenabled by a force or collision
 * event. A body is disabled if it falls below all of the 4 threshhold
 * values.

 * force_thresh and torque_thresh are threshholds for waking up resting
 * bodies.  If the force on a body is more than the force that was
 * applied to it when it was disabled plus the force threshold, then the
 * body is awakened.
 */

struct MdtWorld
{
    /** Kea body list. */
    MdtBody             *bodyHead;

    /** Constraint list for all constraint types. */
    MdtBaseConstraint   *constraintHead;

    /** Kea memory - used during keaStep only. */
    void                *keaMemoryBase;
    /** Kea memory - above pointer shifted up to be quad-word aligned */
    void                *keaMemoryBaseAligned;
    /** Size of Kea memory. */
    int                 keaMemorySize;
    /** Size of aligned Kea memory. */
    int                 keaMemorySizeAligned;
    /** Optional callback in case Kea memory pool is too small */
    MdtMemoryPoolOverflowCB keaMemoryOverflowCallback;

    /**
     * Maximum amount of the kea memory pool used during simulation so
     * far.
     */
    int                 maxKeaMemoryUsed;

    /** Maximum number of bodies allowed in this world. */
    int                 maxBodies;
    /** Number of bodies in existence (enabled and disabled). */
    int                 nBodies;
    /** Total count of enabled bodies in the world*/
    int                 nEnabledBodies;
    /** Number of bodies simulated in the current partition. */
    int                 activeBodies;

    /** Pool of MdtBodies. */
    MdtBody             *bodyArray;
    /** Stack of pointers to free bodies. */
    MdtBody             **freeBodyStack;
    /** Indicates next pointer in stack. */
    int                 nextFreeBody;
    /** Contiguous array of keaBodies - passed into Kea. */
    MdtKeaBody          *keabodyArray;
    /** Contiguous array of keaTransformations - passed into Kea. */
    MdtKeaTransformation *keatmArray;

    /** Maximum number of constraints allowed in this world. */
    int                 maxConstraints;
    /** Total count of enabled constraints in the world. */
    int                 nEnabledConstraints;

    /** Pool of constraints. */
    MdtConstraintUnion  *constraintArray;
    /** Stack of pointers to free constraint structs. */
    MdtConstraintUnion  **freeConstraintStack;
    /** Integer indicating next pointer in stack. */
    int                 nextFreeConstraint;

    /** Pool of CListNodes, used for keeping a bodies list of constraints. */
    MdtCListNode         *cNodeArray;
    /** Stack of pointer to free CListNodes. */
    MdtCListNode         **freeCNodeStack;
    /** Indicates next pointer on stack. */
    int                  nextFreeCNode;

    /**
     * Structure filled in with low-level constraint information each
     * time step by MdtBcl functions and passed as input to Kea.
     * See MdtKea.h
     */
    MdtKeaConstraints   constraints;

    /*
      Partition Information.

      This is the outputted by the partitioner and used by the
      keaConstraint maker.
    */

    /**
     * Constraint pointers to be processed by Kea, grouped into
     * partitions.
     */
    MdtBaseConstraint   **partitionConstraints;
    /** Integers, the number of constraints in each partition. */
    int                 *partitionSizes;
    /** Number of partitions. */
    int                 nPartitions;

    /**
     * If set to 1 the data passed to Kea will be outputted using the
     * default handler for MeInfo.
     *
     * To log the output to disk redefine your own handler for MeInfo.
     */
    int                 logKeaSystem;

    /** Numerical tolerance used by matrix solver. */
    MeReal              epsilon;
    /** Relaxation rate. */
    MeReal              gamma;

    /** Gravity vector. */
    MeVector4           gravity;

    /** Dynamics Event Manager operation mode. */
    MdtDEMMode          demMode;

    /*
      Parameters for auto-disabling - disable body  it if it 
      falls below all of these.
    */

    /** Sum-squared velocity threshold. */
    MeReal              vel_thresh;
    /** Sum-squared rotational velocity threshold. */
    MeReal              velrot_thresh;
    /** Sum-squared acceleration threshold. */
    MeReal              acc_thresh;
    /** Sum-squared rotation acceleration threshold. */
    MeReal              accrot_thresh;

    /**
     * Minimum number of steps to keep an object alive for.
     *
     * This is needed to give an object enough time to gain
     * a minimum velocity after it has been awakened.
     */
    int                 alive_window;
};


/**
 * MdtBody represents a physical body in a world simulation.
 */
struct MdtBody
{
    /** Kea body data. */
    MdtKeaBody           keaBody;

    /** 4x4 transformation matrix */
    MdtKeaTransformation TM;


    /**
     * Linear Impulse accumulator.
     * Converted to force and added to force accumulator at step time
     */
    MeVector4 impulseLinear;

    /**
     * Angular Impulse accumulator.
     * Converted to torque and added to torque accumulator at step time
     */
    MeVector4 impulseAngular;

    /**
     * Flag to indicate an impulse has been added to this body this
     * time-step.
     */
    int impulseAdded;

    /** The world the body is in. */
    MdtWorldID          world;

    /** Next MdtBody. */
    MdtBody             *next;
    /** Address of the next pointer in the previous MdtBody. */
    MdtBody             **tome;

    /** User data. This will not be changed from within the toolkit */
    void                *userData;
    /** The user can optionally give the body a name. This is very useful
        when used in conjunction with the logging functions. */
    char                name[32];

    /** Index into the corresponding Kea body array. */
    int                 arrayId;

    /** Mass in kilogrammes. */
    MeReal              mass;

    /** Velocity damping: 0 for no damping. */
    MeReal              damping;
    /** Angular velocity damping: 0 for no damping. */
    MeReal              angularDamping;

    /** A body's constraints may include joints or contacts. */
    MdtCListNode        *constraintList;

    /**
     * Number of steps that a body has been enabled; -1 if object is
     * disabled.
     */
    int                 enabledTime;
};

/**
 * A 'null' empty constraint, containing only data common to all
 * constraints.
 */
struct MdtBaseConstraint
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL constraint header. */
    MdtBclConstraintHeader bclH;
};

/**
 * Contact constraint.
 */
struct MdtContact
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL contact structure. */
    MdtBclContact       bclContact;

    /**
     * Depending on the order that the bodies are set, the normal might
     * need to be inverted.
     */
    int                 switchNormal;

    /**
     * Used by collision to create a list of contacts associated with a
     * pair of bodies.
     */
    MdtContactID        nextContact;
};

/**
 * Ball and Socket joint constraint
 */
struct MdtBSJoint
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL ball and socket structure. */
    MdtBclBSJoint       bclBSJoint;
};

/**
 * Hinge joint constraint.
 */
struct MdtHinge
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL hinge structure. */
    MdtBclHinge         bclHinge;
};

/**
 * Prismatic joint constraint.
 */
struct MdtPrismatic
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL prismatic structure. */
    MdtBclPrismatic     bclPrismatic;
};

/**
 * Wheel constraint.
 */
struct MdtCarWheel
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL car wheel joint struct. */
    MdtBclCarWheel      bclCarWheel;
};


/**
 * Fixed Path Joint.
 */
struct MdtFixedPath
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL fixed path joint structure. */
    MdtBclFixedPath     bclFixedPath;
};

/**
 * Fixed Path, Fixed Orientation Joint.
 */
struct MdtFPFOJoint
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL fixed path fixed orientation structure. */
    MdtBclFPFOJoint     bclFPFOJoint;
};

/**
 * Universal Joint.
 */
struct MdtUniversal
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL universal joint structure. */
    MdtBclUniversal     bclUniversal;
};

/**
 * Linear1 Joint.
 */
struct MdtLinear1
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL linear 1 structure. */
    MdtBclLinear1       bclLinear1;
};

/**
 * Linear2 Joint.
 */
struct MdtLinear2
{
    /** common to all constraints */
    MdtConstraintHeader head;

    /** BCL linear 2 structure. */
    MdtBclLinear2       bclLinear2;
};

/**
 * An element used for keep each bodies linked list of constraints.
 */
struct MdtCListNode
{
    /** Pointer to specific constraint */
    MdtBaseConstraint   *constraint;

    /** Next CListNode  in linked list */
    MdtCListNode        *next;

    /** Pointer to the next pointer in the previous node */
    MdtCListNode        **tome;
};

/**
 * Union of all constraint types.
 * Used for determining maximum size of a constraint struct when
 * allocating pools on world creation.
 */
union MdtConstraintUnion
{
    MdtBaseConstraint   base;
    MdtContact          contact;
    MdtBSJoint          bsjoint;
    MdtHinge            hinge;
    MdtPrismatic        prism;
    MdtCarWheel         carwheel;
    MdtFixedPath        fpjoint;
    MdtFPFOJoint        fpfojoint;
    MdtUniversal        univjoint;
    MdtLinear1          linear1;
    MdtLinear2          linear2;
};

#endif

---