Open Dynamics Engine: common.h Source File

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 // Macro used to suppress unused variable warning
-00096 #define dVARIABLEUSED(a) ((void)a)
-00097 
-00098 /* floating point data type, vector, matrix and quaternion types */
-00099 
-00100 #if defined(dSINGLE)
-00101 typedef float dReal;
-00102 #ifdef dDOUBLE
-00103 #error You can only #define dSINGLE or dDOUBLE, not both.
-00104 #endif // dDOUBLE
-00105 #elif defined(dDOUBLE)
-00106 typedef double dReal;
-00107 #else
-00108 #error You must #define dSINGLE or dDOUBLE
-00109 #endif
-00110 
-00111 // Detect if we've got both trimesh engines enabled.
-00112 #if dTRIMESH_ENABLED
-00113 #if dTRIMESH_OPCODE && dTRIMESH_GIMPACT
-00114 #error You can only #define dTRIMESH_OPCODE or dTRIMESH_GIMPACT, not both.
-00115 #endif
-00116 #endif // dTRIMESH_ENABLED
-00117 
-00118 /* round an integer up to a multiple of 4, except that 0 and 1 are unmodified
-00119  * (used to compute matrix leading dimensions)
-00120  */
-00121 #define dPAD(a) (((a) > 1) ? ((((a)-1)|3)+1) : (a))
-00122 
-00123 /* these types are mainly just used in headers */
-00124 typedef dReal dVector3[4];
-00125 typedef dReal dVector4[4];
-00126 typedef dReal dMatrix3[4*3];
-00127 typedef dReal dMatrix4[4*4];
-00128 typedef dReal dMatrix6[8*6];
-00129 typedef dReal dQuaternion[4];
-00130 
-00131 
-00132 /* precision dependent scalar math functions */
-00133 
-00134 #if defined(dSINGLE)
-00135 
-00136 #define REAL(x) (x ## f)               /* form a constant */
-00137 #define dRecip(x) ((1.0f/(x)))            /* reciprocal */
-00138 #define dSqrt(x) (sqrtf(x))         /* square root */
-00139 #define dRecipSqrt(x) ((1.0f/sqrtf(x)))      /* reciprocal square root */
-00140 #define dSin(x) (sinf(x))           /* sine */
-00141 #define dCos(x) (cosf(x))           /* cosine */
-00142 #define dFabs(x) (fabsf(x))         /* absolute value */
-00143 #define dAtan2(y,x) (atan2f(y,x))      /* arc tangent with 2 args */
-00144 #define dFMod(a,b) (fmodf(a,b))     /* modulo */
-00145 #define dFloor(x) floorf(x)         /* floor */
-00146 
-00147 #ifdef HAVE___ISNANF
-00148 #define dIsNan(x) (__isnanf(x))
-00149 #elif defined(HAVE__ISNANF)
-00150 #define dIsNan(x) (_isnanf(x))
-00151 #elif defined(HAVE_ISNANF)
-00152 #define dIsNan(x) (isnanf(x))
-00153 #else
-00154   /*
-00155      fall back to _isnan which is the VC way,
-00156      this may seem redundant since we already checked
-00157      for _isnan before, but if isnan is detected by
-00158      configure but is not found during compilation
-00159      we should always make sure we check for __isnanf,
-00160      _isnanf and isnanf in that order before falling
-00161      back to a default
-00162   */
-00163 #define dIsNan(x) (_isnan(x))
-00164 #endif
-00165 
-00166 #define dCopySign(a,b) ((dReal)copysignf(a,b))
-00167 
-00168 #elif defined(dDOUBLE)
-00169 
-00170 #define REAL(x) (x)
-00171 #define dRecip(x) (1.0/(x))
-00172 #define dSqrt(x) sqrt(x)
-00173 #define dRecipSqrt(x) (1.0/sqrt(x))
-00174 #define dSin(x) sin(x)
-00175 #define dCos(x) cos(x)
-00176 #define dFabs(x) fabs(x)
-00177 #define dAtan2(y,x) atan2((y),(x))
-00178 #define dFMod(a,b) (fmod((a),(b)))
-00179 #define dFloor(x) floor(x)
-00180 
-00181 #ifdef HAVE___ISNAN
-00182 #define dIsNan(x) (__isnan(x))
-00183 #elif defined(HAVE__ISNAN)
-00184 #define dIsNan(x) (_isnan(x))
-00185 #elif defined(HAVE_ISNAN)
-00186 #define dIsNan(x) (isnan(x))
-00187 #else
-00188 #define dIsNan(x) (_isnan(x))
-00189 #endif
-00190 
-00191 #define dCopySign(a,b) (copysign((a),(b)))
-00192 
-00193 #else
-00194 #error You must #define dSINGLE or dDOUBLE
-00195 #endif
-00196 
-00197 
-00198 /* utility */
-00199 
-00200 
-00201 /* round something up to be a multiple of the EFFICIENT_ALIGNMENT */
-00202 
-00203 #define dEFFICIENT_SIZE(x) ((((x)-1)|(EFFICIENT_ALIGNMENT-1))+1)
-00204 
-00205 
-00206 /* alloca aligned to the EFFICIENT_ALIGNMENT. note that this can waste
-00207  * up to 15 bytes per allocation, depending on what alloca() returns.
-00208  */
-00209 
-00210 #define dALLOCA16(n) \
-00211   ((char*)dEFFICIENT_SIZE(((size_t)(alloca((n)+(EFFICIENT_ALIGNMENT-1))))))
-00212 
-00213 
-00214 // Use the error-checking memory allocation system.  Because this system uses heap
-00215 //  (malloc) instead of stack (alloca), it is slower.  However, it allows you to
-00216 //  simulate larger scenes, as well as handle out-of-memory errors in a somewhat
-00217 //  graceful manner
-00218 
-00219 // #define dUSE_MALLOC_FOR_ALLOCA
-00220 
-00221 #ifdef dUSE_MALLOC_FOR_ALLOCA
-00222 enum {
-00223   d_MEMORY_OK = 0,      /* no memory errors */
-00224   d_MEMORY_OUT_OF_MEMORY   /* malloc failed due to out of memory error */
-00225 };
-00226 
-00227 #endif
-00228 
-00229 
-00230 
-00231 /* internal object types (all prefixed with `dx') */
-00232 
-00233 struct dxWorld;      /* dynamics world */
-00234 struct dxSpace;      /* collision space */
-00235 struct dxBody;    /* rigid body (dynamics object) */
-00236 struct dxGeom;    /* geometry (collision object) */
-00237 struct dxJoint;
-00238 struct dxJointNode;
-00239 struct dxJointGroup;
-00240 
-00241 typedef struct dxWorld *dWorldID;
-00242 typedef struct dxSpace *dSpaceID;
-00243 typedef struct dxBody *dBodyID;
-00244 typedef struct dxGeom *dGeomID;
-00245 typedef struct dxJoint *dJointID;
-00246 typedef struct dxJointGroup *dJointGroupID;
-00247 
-00248 
-00249 /* error numbers */
-00250 
-00251 enum {
-00252   d_ERR_UNKNOWN = 0,    /* unknown error */
-00253   d_ERR_IASSERT,     /* internal assertion failed */
-00254   d_ERR_UASSERT,     /* user assertion failed */
-00255   d_ERR_LCP       /* user assertion failed */
-00256 };
-00257 
-00258 
-00259 /* joint type numbers */
-00260 
-00261 enum {
-00262   dJointTypeNone = 0,      /* or "unknown" */
-00263   dJointTypeBall,
-00264   dJointTypeHinge,
-00265   dJointTypeSlider,
-00266   dJointTypeContact,
-00267   dJointTypeUniversal,
-00268   dJointTypeHinge2,
-00269   dJointTypeFixed,
-00270   dJointTypeNull,
-00271   dJointTypeAMotor,
-00272   dJointTypeLMotor,
-00273   dJointTypePlane2D,
-00274   dJointTypePR
-00275 };
-00276 
-00277 
-00278 /* an alternative way of setting joint parameters, using joint parameter
-00279  * structures and member constants. we don't actually do this yet.
-00280  */
-00281 
-00282 /*
-00283 typedef struct dLimot {
-00284   int mode;
-00285   dReal lostop, histop;
-00286   dReal vel, fmax;
-00287   dReal fudge_factor;
-00288   dReal bounce, soft;
-00289   dReal suspension_erp, suspension_cfm;
-00290 } dLimot;
-00291 
-00292 enum {
-00293   dLimotLoStop    = 0x0001,
-00294   dLimotHiStop    = 0x0002,
-00295   dLimotVel    = 0x0004,
-00296   dLimotFMax      = 0x0008,
-00297   dLimotFudgeFactor  = 0x0010,
-00298   dLimotBounce    = 0x0020,
-00299   dLimotSoft      = 0x0040
-00300 };
-00301 */
-00302 
-00303 
-00304 /* standard joint parameter names. why are these here? - because we don't want
-00305  * to include all the joint function definitions in joint.cpp. hmmmm.
-00306  * MSVC complains if we call D_ALL_PARAM_NAMES_X with a blank second argument,
-00307  * which is why we have the D_ALL_PARAM_NAMES macro as well. please copy and
-00308  * paste between these two.
-00309  */
-00310 
-00311 #define D_ALL_PARAM_NAMES(start) \
-00312   /* parameters for limits and motors */ \
-00313   dParamLoStop = start, \
-00314   dParamHiStop, \
-00315   dParamVel, \
-00316   dParamFMax, \
-00317   dParamFudgeFactor, \
-00318   dParamBounce, \
-00319   dParamCFM, \
-00320   dParamStopERP, \
-00321   dParamStopCFM, \
-00322   /* parameters for suspension */ \
-00323   dParamSuspensionERP, \
-00324   dParamSuspensionCFM, \
-00325   dParamERP, \
-00326 
-00327 #define D_ALL_PARAM_NAMES_X(start,x) \
-00328   /* parameters for limits and motors */ \
-00329   dParamLoStop ## x = start, \
-00330   dParamHiStop ## x, \
-00331   dParamVel ## x, \
-00332   dParamFMax ## x, \
-00333   dParamFudgeFactor ## x, \
-00334   dParamBounce ## x, \
-00335   dParamCFM ## x, \
-00336   dParamStopERP ## x, \
-00337   dParamStopCFM ## x, \
-00338   /* parameters for suspension */ \
-00339   dParamSuspensionERP ## x, \
-00340   dParamSuspensionCFM ## x, \
-00341   dParamERP ## x,
-00342 
-00343 enum {
-00344   D_ALL_PARAM_NAMES(0)
-00345   D_ALL_PARAM_NAMES_X(0x100,2)
-00346   D_ALL_PARAM_NAMES_X(0x200,3)
-00347 
-00348   /* add a multiple of this constant to the basic parameter numbers to get
-00349    * the parameters for the second, third etc axes.
-00350    */
-00351   dParamGroup=0x100
-00352 };
-00353 
-00354 
-00355 /* angular motor mode numbers */
-00356 
-00357 enum{
-00358   dAMotorUser = 0,
-00359   dAMotorEuler = 1
-00360 };
-00361 
-00362 
-00363 /* joint force feedback information */
-00364 
-00365 typedef struct dJointFeedback {
-00366   dVector3 f1;    /* force applied to body 1 */
-00367   dVector3 t1;    /* torque applied to body 1 */
-00368   dVector3 f2;    /* force applied to body 2 */
-00369   dVector3 t2;    /* torque applied to body 2 */
-00370 } dJointFeedback;
-00371 
-00372 
-00373 /* private functions that must be implemented by the collision library:
-00374  * (1) indicate that a geom has moved, (2) get the next geom in a body list.
-00375  * these functions are called whenever the position of geoms connected to a
-00376  * body have changed, e.g. with dBodySetPosition(), dBodySetRotation(), or
-00377  * when the ODE step function updates the body state.
-00378  */
-00379 
-00380 void dGeomMoved (dGeomID);
-00381 dGeomID dGeomGetBodyNext (dGeomID);
-00382 
-00383 
-00384 #ifdef __cplusplus
-00385 }
-00386 #endif
-00387 
-00388 #endif
-