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

Generated on Tue Sep 4 10:05:19 2007 for Open Dynamics Engine by  doxygen 1.5.3