- Main Page
- Modules
- Data Structures
- Files

# common.h

    00001 /*************************************************************************
    00002  *                                                                       *
    00003  * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith.       *
    00004  * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
    00005  *                                                                       *
    00006  * This library is free software; you can redistribute it and/or         *
    00007  * modify it under the terms of EITHER:                                  *
    00008  *   (1) The GNU Lesser General Public License as published by the Free  *
    00009  *       Software Foundation; either version 2.1 of the License, or (at  *
    00010  *       your option) any later version. The text of the GNU Lesser      *
    00011  *       General Public License is included with this library in the     *
    00012  *       file LICENSE.TXT.                                               *
    00013  *   (2) The BSD-style license that is included with this library in     *
    00014  *       the file LICENSE-BSD.TXT.                                       *
    00015  *                                                                       *
    00016  * This library is distributed in the hope that it will be useful,       *
    00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
    00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
    00019  * LICENSE.TXT and LICENSE-BSD.TXT for more details.                     *
    00020  *                                                                       *
    00021  *************************************************************************/
    00022
    00023 #ifndef _ODE_COMMON_H_
    00024 #define _ODE_COMMON_H_
    00025 #include <ode/config.h>
    00026 #include <ode/error.h>
    00027 #include <math.h>
    00028
    00029 #ifdef __cplusplus
    00030 extern "C" {
    00031 #endif
    00032
    00033
    00034 /* configuration stuff */
    00035
    00036 /* the efficient alignment. most platforms align data structures to some
    00037  * number of bytes, but this is not always the most efficient alignment.
    00038  * for example, many x86 compilers align to 4 bytes, but on a pentium it
    00039  * is important to align doubles to 8 byte boundaries (for speed), and
    00040  * the 4 floats in a SIMD register to 16 byte boundaries. many other
    00041  * platforms have similar behavior. setting a larger alignment can waste
    00042  * a (very) small amount of memory. NOTE: this number must be a power of
    00043  * two. this is set to 16 by default.
    00044  */
    00045 #define EFFICIENT_ALIGNMENT 16
    00046
    00047
    00048 /* constants */
    00049
    00050 /* pi and 1/sqrt(2) are defined here if necessary because they don't get
    00051  * defined in <math.h> on some platforms (like MS-Windows)
    00052  */
    00053
    00054 #ifndef M_PI
    00055 #define M_PI REAL(3.1415926535897932384626433832795029)
    00056 #endif
    00057 #ifndef M_SQRT1_2
    00058 #define M_SQRT1_2 REAL(0.7071067811865475244008443621048490)
    00059 #endif
    00060
    00061
    00062 /* debugging:
    00063  *   IASSERT  is an internal assertion, i.e. a consistency check. if it fails
    00064  *            we want to know where.
    00065  *   UASSERT  is a user assertion, i.e. if it fails a nice error message
    00066  *            should be printed for the user.
    00067  *   AASSERT  is an arguments assertion, i.e. if it fails "bad argument(s)"
    00068  *            is printed.
    00069  *   DEBUGMSG just prints out a message
    00070  */
    00071
    00072 #ifndef dNODEBUG
    00073 #ifdef __GNUC__
    00074 #define dIASSERT(a) if (!(a)) dDebug (d_ERR_IASSERT, \
    00075   "assertion \"" #a "\" failed in %s() [%s]",__FUNCTION__,__FILE__);
    00076 #define dUASSERT(a,msg) if (!(a)) dDebug (d_ERR_UASSERT, \
    00077   msg " in %s()", __FUNCTION__);
    00078 #define dDEBUGMSG(msg) dMessage (d_ERR_UASSERT,          \
    00079 msg " in %s() File %s Line %d", __FUNCTION__, __FILE__,__LINE__);
    00080 #else
    00081 #define dIASSERT(a) if (!(a)) dDebug (d_ERR_IASSERT, \
    00082   "assertion \"" #a "\" failed in %s:%d",__FILE__,__LINE__);
    00083 #define dUASSERT(a,msg) if (!(a)) dDebug (d_ERR_UASSERT, \
    00084   msg " (%s:%d)", __FILE__,__LINE__);
    00085 #define dDEBUGMSG(msg) dMessage (d_ERR_UASSERT, \
    00086   msg " (%s:%d)", __FILE__,__LINE__);
    00087 #endif
    00088 #else
    00089 #define dIASSERT(a) ;
    00090 #define dUASSERT(a,msg) ;
    00091 #define dDEBUGMSG(msg) ;
    00092 #endif
    00093 #define dAASSERT(a) dUASSERT(a,"Bad argument(s)")
    00094
    00095 /* floating point data type, vector, matrix and quaternion types */
    00096
    00097 #if defined(dSINGLE)
    00098 typedef float dReal;
    00099 #ifdef dDOUBLE
    00100 #error You can only #define dSINGLE or dDOUBLE, not both.
    00101 #endif // dDOUBLE
    00102 #elif defined(dDOUBLE)
    00103 typedef double dReal;
    00104 #else
    00105 #error You must #define dSINGLE or dDOUBLE
    00106 #endif
    00107
    00108
    00109 /* round an integer up to a multiple of 4, except that 0 and 1 are unmodified
    00110  * (used to compute matrix leading dimensions)
    00111  */
    00112 #define dPAD(a) (((a) > 1) ? ((((a)-1)|3)+1) : (a))
    00113
    00114 /* these types are mainly just used in headers */
    00115 typedef dReal dVector3[4];
    00116 typedef dReal dVector4[4];
    00117 typedef dReal dMatrix3[4*3];
    00118 typedef dReal dMatrix4[4*4];
    00119 typedef dReal dMatrix6[8*6];
    00120 typedef dReal dQuaternion[4];
    00121
    00122
    00123 /* precision dependent scalar math functions */
    00124
    00125 #if defined(dSINGLE)
    00126
    00127 #define REAL(x) (x ## f)               /* form a constant */
    00128 #define dRecip(x) ((1.0f/(x)))            /* reciprocal */
    00129 #define dSqrt(x) (sqrtf(x))         /* square root */
    00130 #define dRecipSqrt(x) ((1.0f/sqrtf(x)))      /* reciprocal square root */
    00131 #define dSin(x) (sinf(x))           /* sine */
    00132 #define dCos(x) (cosf(x))           /* cosine */
    00133 #define dFabs(x) (fabsf(x))         /* absolute value */
    00134 #define dAtan2(y,x) (atan2f(y,x))      /* arc tangent with 2 args */
    00135 #define dFMod(a,b) (fmodf(a,b))     /* modulo */
    00136
    00137 #ifdef HAVE___ISNANF
    00138 #define dIsNan(x) (__isnanf(x))
    00139 #elif defined(HAVE__ISNANF)
    00140 #define dIsNan(x) (_isnanf(x))
    00141 #elif defined(HAVE_ISNANF)
    00142 #define dIsNan(x) (isnanf(x))
    00143 #else
    00144   /*
    00145      fall back to _isnan which is the VC way,
    00146      this may seem redundant since we already checked
    00147      for _isnan before, but if isnan is detected by
    00148      configure but is not found during compilation
    00149      we should always make sure we check for __isnanf,
    00150      _isnanf and isnanf in that order before falling
    00151      back to a default
    00152   */
    00153 #define dIsNan(x) (_isnan(x))
    00154 #endif
    00155
    00156 #define dCopySign(a,b) ((dReal)copysignf(a,b))
    00157
    00158 #elif defined(dDOUBLE)
    00159
    00160 #define REAL(x) (x)
    00161 #define dRecip(x) (1.0/(x))
    00162 #define dSqrt(x) sqrt(x)
    00163 #define dRecipSqrt(x) (1.0/sqrt(x))
    00164 #define dSin(x) sin(x)
    00165 #define dCos(x) cos(x)
    00166 #define dFabs(x) fabs(x)
    00167 #define dAtan2(y,x) atan2((y),(x))
    00168 #define dFMod(a,b) (fmod((a),(b)))
    00169 #ifdef HAVE___ISNAN
    00170 #define dIsNan(x) (__isnan(x))
    00171 #elif defined(HAVE__ISNAN)
    00172 #define dIsNan(x) (_isnan(x))
    00173 #elif defined(HAVE_ISNAN)
    00174 #define dIsNan(x) (isnan(x))
    00175 #else
    00176 #define dIsNan(x) (_isnan(x))
    00177 #endif
    00178
    00179 #define dCopySign(a,b) (copysign((a),(b)))
    00180
    00181 #else
    00182 #error You must #define dSINGLE or dDOUBLE
    00183 #endif
    00184
    00185
    00186 /* utility */
    00187
    00188
    00189 /* round something up to be a multiple of the EFFICIENT_ALIGNMENT */
    00190
    00191 #define dEFFICIENT_SIZE(x) ((((x)-1)|(EFFICIENT_ALIGNMENT-1))+1)
    00192
    00193
    00194 /* alloca aligned to the EFFICIENT_ALIGNMENT. note that this can waste
    00195  * up to 15 bytes per allocation, depending on what alloca() returns.
    00196  */
    00197
    00198 #define dALLOCA16(n) \
    00199   ((char*)dEFFICIENT_SIZE(((size_t)(alloca((n)+(EFFICIENT_ALIGNMENT-1))))))
    00200
    00201
    00202 // Use the error-checking memory allocation system.  Because this system uses heap
    00203 //  (malloc) instead of stack (alloca), it is slower.  However, it allows you to
    00204 //  simulate larger scenes, as well as handle out-of-memory errors in a somewhat
    00205 //  graceful manner
    00206
    00207 // #define dUSE_MALLOC_FOR_ALLOCA
    00208
    00209 #ifdef dUSE_MALLOC_FOR_ALLOCA
    00210 enum {
    00211   d_MEMORY_OK = 0,      /* no memory errors */
    00212   d_MEMORY_OUT_OF_MEMORY   /* malloc failed due to out of memory error */
    00213 };
    00214
    00215 #endif
    00216
    00217
    00218
    00219 /* internal object types (all prefixed with `dx') */
    00220
    00221 struct dxWorld;      /* dynamics world */
    00222 struct dxSpace;      /* collision space */
    00223 struct dxBody;    /* rigid body (dynamics object) */
    00224 struct dxGeom;    /* geometry (collision object) */
    00225 struct dxJoint;
    00226 struct dxJointNode;
    00227 struct dxJointGroup;
    00228
    00229 typedef struct dxWorld *dWorldID;
    00230 typedef struct dxSpace *dSpaceID;
    00231 typedef struct dxBody *dBodyID;
    00232 typedef struct dxGeom *dGeomID;
    00233 typedef struct dxJoint *dJointID;
    00234 typedef struct dxJointGroup *dJointGroupID;
    00235
    00236
    00237 /* error numbers */
    00238
    00239 enum {
    00240   d_ERR_UNKNOWN = 0,    /* unknown error */
    00241   d_ERR_IASSERT,     /* internal assertion failed */
    00242   d_ERR_UASSERT,     /* user assertion failed */
    00243   d_ERR_LCP       /* user assertion failed */
    00244 };
    00245
    00246
    00247 /* joint type numbers */
    00248
    00249 enum {
    00250   dJointTypeNone = 0,      /* or "unknown" */
    00251   dJointTypeBall,
    00252   dJointTypeHinge,
    00253   dJointTypeSlider,
    00254   dJointTypeContact,
    00255   dJointTypeUniversal,
    00256   dJointTypeHinge2,
    00257   dJointTypeFixed,
    00258   dJointTypeNull,
    00259   dJointTypeAMotor,
    00260   dJointTypeLMotor,
    00261   dJointTypePlane2D,
    00262   dJointTypePR
    00263 };
    00264
    00265
    00266 /* an alternative way of setting joint parameters, using joint parameter
    00267  * structures and member constants. we don't actually do this yet.
    00268  */
    00269
    00270 /*
    00271 typedef struct dLimot {
    00272   int mode;
    00273   dReal lostop, histop;
    00274   dReal vel, fmax;
    00275   dReal fudge_factor;
    00276   dReal bounce, soft;
    00277   dReal suspension_erp, suspension_cfm;
    00278 } dLimot;
    00279
    00280 enum {
    00281   dLimotLoStop    = 0x0001,
    00282   dLimotHiStop    = 0x0002,
    00283   dLimotVel    = 0x0004,
    00284   dLimotFMax      = 0x0008,
    00285   dLimotFudgeFactor  = 0x0010,
    00286   dLimotBounce    = 0x0020,
    00287   dLimotSoft      = 0x0040
    00288 };
    00289 */
    00290
    00291
    00292 /* standard joint parameter names. why are these here? - because we don't want
    00293  * to include all the joint function definitions in joint.cpp. hmmmm.
    00294  * MSVC complains if we call D_ALL_PARAM_NAMES_X with a blank second argument,
    00295  * which is why we have the D_ALL_PARAM_NAMES macro as well. please copy and
    00296  * paste between these two.
    00297  */
    00298
    00299 #define D_ALL_PARAM_NAMES(start) \
    00300   /* parameters for limits and motors */ \
    00301   dParamLoStop = start, \
    00302   dParamHiStop, \
    00303   dParamVel, \
    00304   dParamFMax, \
    00305   dParamFudgeFactor, \
    00306   dParamBounce, \
    00307   dParamCFM, \
    00308   dParamStopERP, \
    00309   dParamStopCFM, \
    00310   /* parameters for suspension */ \
    00311   dParamSuspensionERP, \
    00312   dParamSuspensionCFM,
    00313
    00314 #define D_ALL_PARAM_NAMES_X(start,x) \
    00315   /* parameters for limits and motors */ \
    00316   dParamLoStop ## x = start, \
    00317   dParamHiStop ## x, \
    00318   dParamVel ## x, \
    00319   dParamFMax ## x, \
    00320   dParamFudgeFactor ## x, \
    00321   dParamBounce ## x, \
    00322   dParamCFM ## x, \
    00323   dParamStopERP ## x, \
    00324   dParamStopCFM ## x, \
    00325   /* parameters for suspension */ \
    00326   dParamSuspensionERP ## x, \
    00327   dParamSuspensionCFM ## x,
    00328
    00329 enum {
    00330   D_ALL_PARAM_NAMES(0)
    00331   D_ALL_PARAM_NAMES_X(0x100,2)
    00332   D_ALL_PARAM_NAMES_X(0x200,3)
    00333
    00334   /* add a multiple of this constant to the basic parameter numbers to get
    00335    * the parameters for the second, third etc axes.
    00336    */
    00337   dParamGroup=0x100
    00338 };
    00339
    00340
    00341 /* angular motor mode numbers */
    00342
    00343 enum{
    00344   dAMotorUser = 0,
    00345   dAMotorEuler = 1
    00346 };
    00347
    00348
    00349 /* joint force feedback information */
    00350
    00351 typedef struct dJointFeedback {
    00352   dVector3 f1;    /* force applied to body 1 */
    00353   dVector3 t1;    /* torque applied to body 1 */
    00354   dVector3 f2;    /* force applied to body 2 */
    00355   dVector3 t2;    /* torque applied to body 2 */
    00356 } dJointFeedback;
    00357
    00358
    00359 /* private functions that must be implemented by the collision library:
    00360  * (1) indicate that a geom has moved, (2) get the next geom in a body list.
    00361  * these functions are called whenever the position of geoms connected to a
    00362  * body have changed, e.g. with dBodySetPosition(), dBodySetRotation(), or
    00363  * when the ODE step function updates the body state.
    00364  */
    00365
    00366 void dGeomMoved (dGeomID);
    00367 dGeomID dGeomGetBodyNext (dGeomID);
    00368
    00369
    00370 #ifdef __cplusplus
    00371 }
    00372 #endif
    00373
    00374 #endif