summaryrefslogtreecommitdiff
path: root/libs/ode-0.16.1/ode/demo/demo_heightfield.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libs/ode-0.16.1/ode/demo/demo_heightfield.cpp')
-rw-r--r--libs/ode-0.16.1/ode/demo/demo_heightfield.cpp714
1 files changed, 714 insertions, 0 deletions
diff --git a/libs/ode-0.16.1/ode/demo/demo_heightfield.cpp b/libs/ode-0.16.1/ode/demo/demo_heightfield.cpp
new file mode 100644
index 0000000..d68cb6a
--- /dev/null
+++ b/libs/ode-0.16.1/ode/demo/demo_heightfield.cpp
@@ -0,0 +1,714 @@
+/*************************************************************************
+ * *
+ * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. *
+ * All rights reserved. Email: russ@q12.org Web: www.q12.org *
+ * *
+ * This library is free software; you can redistribute it and/or *
+ * modify it under the terms of EITHER: *
+ * (1) The GNU Lesser General Public License as published by the Free *
+ * Software Foundation; either version 2.1 of the License, or (at *
+ * your option) any later version. The text of the GNU Lesser *
+ * General Public License is included with this library in the *
+ * file LICENSE.TXT. *
+ * (2) The BSD-style license that is included with this library in *
+ * the file LICENSE-BSD.TXT. *
+ * *
+ * This library is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files *
+ * LICENSE.TXT and LICENSE-BSD.TXT for more details. *
+ * *
+ *************************************************************************/
+
+#include <ode/ode.h>
+#include <drawstuff/drawstuff.h>
+#include "texturepath.h"
+#include "bunny_geom.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4305) // for VC++, no precision loss complaints
+#endif
+
+
+#define DEGTORAD 0.01745329251994329577f //!< PI / 180.0, convert degrees to radians
+
+int g_allow_trimesh;
+
+// Our heightfield geom
+dGeomID gheight;
+
+
+
+// Heightfield dimensions
+
+#define HFIELD_WSTEP 15 // Vertex count along edge >= 2
+#define HFIELD_DSTEP 31
+
+#define HFIELD_WIDTH REAL( 4.0 )
+#define HFIELD_DEPTH REAL( 8.0 )
+
+#define HFIELD_WSAMP ( HFIELD_WIDTH / ( HFIELD_WSTEP-1 ) )
+#define HFIELD_DSAMP ( HFIELD_DEPTH / ( HFIELD_DSTEP-1 ) )
+
+
+
+//<---- Convex Object
+dReal planes[]= // planes for a cube
+ {
+ 1.0f ,0.0f ,0.0f ,0.25f,
+ 0.0f ,1.0f ,0.0f ,0.25f,
+ 0.0f ,0.0f ,1.0f ,0.25f,
+ 0.0f ,0.0f ,-1.0f,0.25f,
+ 0.0f ,-1.0f,0.0f ,0.25f,
+ -1.0f,0.0f ,0.0f ,0.25f
+ /*
+ 1.0f ,0.0f ,0.0f ,2.0f,
+ 0.0f ,1.0f ,0.0f ,1.0f,
+ 0.0f ,0.0f ,1.0f ,1.0f,
+ 0.0f ,0.0f ,-1.0f,1.0f,
+ 0.0f ,-1.0f,0.0f ,1.0f,
+ -1.0f,0.0f ,0.0f ,0.0f
+ */
+ };
+const unsigned int planecount=6;
+
+dReal points[]= // points for a cube
+ {
+ 0.25f,0.25f,0.25f, // point 0
+ -0.25f,0.25f,0.25f, // point 1
+
+ 0.25f,-0.25f,0.25f, // point 2
+ -0.25f,-0.25f,0.25f,// point 3
+
+ 0.25f,0.25f,-0.25f, // point 4
+ -0.25f,0.25f,-0.25f,// point 5
+
+ 0.25f,-0.25f,-0.25f,// point 6
+ -0.25f,-0.25f,-0.25f,// point 7
+ };
+const unsigned int pointcount=8;
+unsigned int polygons[] = //Polygons for a cube (6 squares)
+ {
+ 4,0,2,6,4, // positive X
+ 4,1,0,4,5, // positive Y
+ 4,0,1,3,2, // positive Z
+ 4,3,1,5,7, // negative X
+ 4,2,3,7,6, // negative Y
+ 4,5,4,6,7, // negative Z
+ };
+//----> Convex Object
+
+// select correct drawing functions
+
+#ifdef dDOUBLE
+#define dsDrawBox dsDrawBoxD
+#define dsDrawSphere dsDrawSphereD
+#define dsDrawCylinder dsDrawCylinderD
+#define dsDrawCapsule dsDrawCapsuleD
+#define dsDrawConvex dsDrawConvexD
+#define dsDrawTriangle dsDrawTriangleD
+#endif
+
+
+// some constants
+
+#define NUM 100 // max number of objects
+#define DENSITY (5.0) // density of all objects
+#define GPB 3 // maximum number of geometries per body
+#define MAX_CONTACTS 64 // maximum number of contact points per body
+
+
+// dynamics and collision objects
+
+struct MyObject {
+ dBodyID body; // the body
+ dGeomID geom[GPB]; // geometries representing this body
+
+ // Trimesh only - double buffered matrices for 'last transform' setup
+ dReal matrix_dblbuff[ 16 * 2 ];
+ int last_matrix_index;
+};
+
+static int num=0; // number of objects in simulation
+static int nextobj=0; // next object to recycle if num==NUM
+static dWorldID world;
+static dSpaceID space;
+static MyObject obj[NUM];
+static dJointGroupID contactgroup;
+static int selected = -1; // selected object
+static int show_aabb = 0; // show geom AABBs?
+static int show_contacts = 0; // show contact points?
+static int random_pos = 1; // drop objects from random position?
+static int write_world = 0;
+
+
+
+
+//============================
+
+dGeomID TriMesh1;
+dGeomID TriMesh2;
+//static dTriMeshDataID TriData1, TriData2; // reusable static trimesh data
+
+//============================
+
+
+dReal heightfield_callback( void*, int x, int z )
+{
+ dReal fx = ( ((dReal)x) - ( HFIELD_WSTEP-1 )/2 ) / (dReal)( HFIELD_WSTEP-1 );
+ dReal fz = ( ((dReal)z) - ( HFIELD_DSTEP-1 )/2 ) / (dReal)( HFIELD_DSTEP-1 );
+
+ // Create an interesting 'hump' shape
+ dReal h = REAL( 1.0 ) + ( REAL( -16.0 ) * ( fx*fx*fx + fz*fz*fz ) );
+
+ return h;
+}
+
+
+
+
+// this is called by dSpaceCollide when two objects in space are
+// potentially colliding.
+
+static void nearCallback (void *, dGeomID o1, dGeomID o2)
+{
+ int i;
+ // if (o1->body && o2->body) return;
+
+ // exit without doing anything if the two bodies are connected by a joint
+ dBodyID b1 = dGeomGetBody(o1);
+ dBodyID b2 = dGeomGetBody(o2);
+ if (b1 && b2 && dAreConnectedExcluding(b1,b2,dJointTypeContact))
+ return;
+
+ dContact contact[MAX_CONTACTS]; // up to MAX_CONTACTS contacts per box-box
+ for (i=0; i<MAX_CONTACTS; i++) {
+ contact[i].surface.mode = dContactBounce | dContactSoftCFM;
+ contact[i].surface.mu = dInfinity;
+ contact[i].surface.mu2 = 0;
+ contact[i].surface.bounce = 0.1;
+ contact[i].surface.bounce_vel = 0.1;
+ contact[i].surface.soft_cfm = 0.01;
+ }
+ if (int numc = dCollide(o1,o2,MAX_CONTACTS,&contact[0].geom,
+ sizeof(dContact))) {
+ dMatrix3 RI;
+ dRSetIdentity(RI);
+ const dReal ss[3] = {0.02,0.02,0.02};
+ for (i=0; i<numc; i++) {
+ dJointID c = dJointCreateContact(world,contactgroup,contact+i);
+ dJointAttach(c,b1,b2);
+ if (show_contacts) {
+ dsSetColor(0,0,1);
+ dsDrawBox(contact[i].geom.pos,RI,ss);
+ }
+ }
+ }
+}
+
+
+// start simulation - set viewpoint
+
+static void start()
+{
+ dAllocateODEDataForThread(dAllocateMaskAll);
+
+ static float xyz[3] = {2.1640f,-1.3079f,1.7600f};
+ static float hpr[3] = {125.5000f,-17.0000f,0.0000f};
+ dsSetViewpoint (xyz,hpr);
+ printf("To drop another object, press:\n");
+ printf(" b for box.\n");
+ printf(" s for sphere.\n");
+ printf(" c for capsule.\n");
+ printf(" y for cylinder.\n");
+ printf(" v for a convex object.\n");
+ printf(" x for a composite object.\n");
+ if ( g_allow_trimesh )
+ printf(" m for a trimesh.\n");
+ printf("To select an object, press space.\n");
+ printf("To disable the selected object, press d.\n");
+ printf("To enable the selected object, press e.\n");
+ printf("To toggle showing the geom AABBs, press a.\n");
+ printf("To toggle showing the contact points, press t.\n");
+ printf("To toggle dropping from random position/orientation, press r.\n");
+ printf("To save the current state to 'state.dif', press 1.\n");
+}
+
+
+char locase(char c)
+{
+ if (c >= 'A' && c <= 'Z') return c - ('a'-'A');
+ else return c;
+}
+
+
+// called when a key pressed
+
+static void command(int cmd)
+{
+ dsizeint i;
+ int j,k;
+ dReal sides[3];
+ dMass m;
+ bool setBody = false;
+
+ cmd = locase (cmd);
+
+
+ //
+ // Geom Creation
+ //
+
+ if ( cmd == 'b' || cmd == 's' || cmd == 'c' || ( cmd == 'm' && g_allow_trimesh ) ||
+ cmd == 'x' || cmd == 'y' || cmd == 'v' ) {
+
+ if ( num < NUM ) {
+ i = num;
+ num++;
+ } else {
+ i = nextobj++;
+ nextobj %= num;
+
+ // destroy the body and geoms for slot i
+ dBodyDestroy(obj[i].body);
+ obj[i].body = 0;
+
+ for (k=0; k < GPB; k++)
+ if (obj[i].geom[k]) {
+ dGeomDestroy(obj[i].geom[k]);
+ obj[i].geom[k] = 0;
+ }
+ }
+
+ obj[i].body = dBodyCreate(world);
+ for (k=0; k<3; k++)
+ sides[k] = dRandReal()*0.5+0.1;
+
+ dMatrix3 R;
+ if (random_pos) {
+ dBodySetPosition(obj[i].body,
+ (dRandReal()-0.5)*HFIELD_WIDTH*0.75,
+ (dRandReal()-0.5)*HFIELD_DEPTH*0.75,
+ dRandReal() + 2 );
+ dRFromAxisAndAngle(R,dRandReal()*2.0-1.0,dRandReal()*2.0-1.0,
+ dRandReal()*2.0-1.0,dRandReal()*10.0-5.0);
+ } else {
+ dReal maxheight = 0;
+ for (k=0; k<num; k++) {
+ const dReal *pos = dBodyGetPosition(obj[k].body);
+ if (pos[2] > maxheight)
+ maxheight = pos[2];
+ }
+ dBodySetPosition(obj[i].body, 0,maxheight+1,0);
+ dRFromAxisAndAngle(R,0,0,1,dRandReal()*10.0-5.0);
+ }
+
+ dBodySetRotation(obj[i].body,R);
+
+ if (cmd == 'b') {
+
+ dMassSetBox(&m,DENSITY,sides[0],sides[1],sides[2]);
+ obj[i].geom[0] = dCreateBox(space,sides[0],sides[1],sides[2]);
+
+ } else if (cmd == 'c') {
+
+ sides[0] *= 0.5;
+ dMassSetCapsule(&m,DENSITY,3,sides[0],sides[1]);
+ obj[i].geom[0] = dCreateCapsule(space,sides[0],sides[1]);
+
+ } else if (cmd == 'v') {
+
+ dMassSetBox (&m,DENSITY,0.25,0.25,0.25);
+ obj[i].geom[0] = dCreateConvex(space,
+ planes,
+ planecount,
+ points,
+ pointcount,
+ polygons);
+
+ } else if (cmd == 'y') {
+
+ dMassSetCylinder(&m,DENSITY,3,sides[0],sides[1]);
+ obj[i].geom[0] = dCreateCylinder(space,sides[0],sides[1]);
+
+ } else if (cmd == 's') {
+
+ sides[0] *= 0.5;
+ dMassSetSphere(&m,DENSITY,sides[0]);
+ obj[i].geom[0] = dCreateSphere(space,sides[0]);
+
+ } else if (cmd == 'm' && g_allow_trimesh) {
+
+ dTriMeshDataID new_tmdata = dGeomTriMeshDataCreate();
+ dGeomTriMeshDataBuildSingle(new_tmdata, &Vertices[0], 3 * sizeof(float), VertexCount,
+ &Indices[0], IndexCount, 3 * sizeof(dTriIndex));
+ dGeomTriMeshDataPreprocess2(new_tmdata, (1U << dTRIDATAPREPROCESS_BUILD_FACE_ANGLES), NULL);
+
+ obj[i].geom[0] = dCreateTriMesh(space, new_tmdata, 0, 0, 0);
+
+ dMassSetTrimesh( &m, DENSITY, obj[i].geom[0] );
+ printf("mass at %f %f %f\n", m.c[0], m.c[1], m.c[2]);
+ dGeomSetPosition(obj[i].geom[0], -m.c[0], -m.c[1], -m.c[2]);
+ dMassTranslate(&m, -m.c[0], -m.c[1], -m.c[2]);
+
+ } else if (cmd == 'x') {
+
+ setBody = 1;
+ // start accumulating masses for the composite geometries
+ dMass m2;
+ dMassSetZero (&m);
+
+ dReal dpos[GPB][3]; // delta-positions for composite geometries
+ dMatrix3 drot[GPB];
+
+ // set random delta positions
+ for (j=0; j<GPB; j++)
+ for (k=0; k<3; k++)
+ dpos[j][k] = dRandReal()*0.3-0.15;
+
+ for (k=0; k<GPB; k++) {
+ if (k==0) {
+ dReal radius = dRandReal()*0.25+0.05;
+ obj[i].geom[k] = dCreateSphere (space,radius);
+ dMassSetSphere (&m2,DENSITY,radius);
+ }
+ else if (k==1) {
+ obj[i].geom[k] = dCreateBox(space,sides[0],sides[1],sides[2]);
+ dMassSetBox(&m2,DENSITY,sides[0],sides[1],sides[2]);
+ } else {
+ dReal radius = dRandReal()*0.1+0.05;
+ dReal length = dRandReal()*1.0+0.1;
+ obj[i].geom[k] = dCreateCapsule(space,radius,length);
+ dMassSetCapsule(&m2,DENSITY,3,radius,length);
+ }
+
+ dRFromAxisAndAngle(drot[k],dRandReal()*2.0-1.0,dRandReal()*2.0-1.0,
+ dRandReal()*2.0-1.0,dRandReal()*10.0-5.0);
+ dMassRotate(&m2,drot[k]);
+
+ dMassTranslate(&m2,dpos[k][0],dpos[k][1],dpos[k][2]);
+
+ // add to the total mass
+ dMassAdd(&m,&m2);
+
+ }
+ for (k=0; k<GPB; k++) {
+ dGeomSetBody(obj[i].geom[k],obj[i].body);
+ dGeomSetOffsetPosition(obj[i].geom[k],
+ dpos[k][0]-m.c[0],
+ dpos[k][1]-m.c[1],
+ dpos[k][2]-m.c[2]);
+ dGeomSetOffsetRotation(obj[i].geom[k], drot[k]);
+ }
+ dMassTranslate(&m,-m.c[0],-m.c[1],-m.c[2]);
+ dBodySetMass(obj[i].body,&m);
+
+ }
+
+ if (!setBody) { // avoid calling for composite geometries
+ for (k=0; k < GPB; k++)
+ if (obj[i].geom[k])
+ dGeomSetBody(obj[i].geom[k],obj[i].body);
+
+ dBodySetMass(obj[i].body,&m);
+ }
+ }
+
+
+ //
+ // Control Commands
+ //
+
+ if (cmd == ' ') {
+
+ selected++;
+ if (selected >= num)
+ selected = 0;
+ if (selected < -1)
+ selected = 0;
+
+ } else if (cmd == 'd' && selected >= 0 && selected < num) {
+
+ dBodyDisable(obj[selected].body);
+
+ } else if (cmd == 'e' && selected >= 0 && selected < num) {
+
+ dBodyEnable(obj[selected].body);
+
+ } else if (cmd == 'a') {
+
+ show_aabb = !show_aabb;
+
+ } else if (cmd == 't') {
+
+ show_contacts = !show_contacts;
+
+ } else if (cmd == 'r') {
+
+ random_pos = !random_pos;
+
+ } else if (cmd == '1') {
+
+ write_world = 1;
+
+ }
+}
+
+
+// draw a geom
+
+void drawGeom (dGeomID g, const dReal *pos, const dReal *R, int show_aabb)
+{
+ if (!g)
+ return;
+ if (!pos)
+ pos = dGeomGetPosition(g);
+ if (!R)
+ R = dGeomGetRotation(g);
+
+ int type = dGeomGetClass(g);
+ if (type == dBoxClass) {
+
+ dVector3 sides;
+ dGeomBoxGetLengths(g,sides);
+ dsDrawBox(pos,R,sides);
+
+ } else if (type == dSphereClass) {
+
+ dsDrawSphere(pos,R,dGeomSphereGetRadius(g));
+
+ } else if (type == dCapsuleClass) {
+
+ dReal radius,length;
+ dGeomCapsuleGetParams(g,&radius,&length);
+ dsDrawCapsule(pos,R,length,radius);
+
+ } else if (type == dConvexClass) {
+
+ //dVector3 sides={0.50,0.50,0.50};
+ dsDrawConvex(pos,R,planes,
+ planecount,
+ points,
+ pointcount,
+ polygons);
+
+ } else if (type == dCylinderClass) {
+
+ dReal radius,length;
+ dGeomCylinderGetParams(g,&radius,&length);
+ dsDrawCylinder(pos,R,length,radius);
+
+ } else if (type == dTriMeshClass) {
+
+ dTriIndex* Indices = (dTriIndex*)::Indices;
+
+ // assume all trimeshes are drawn as bunnies
+ for (int ii = 0; ii < IndexCount / 3; ii++) {
+ const dReal v[9] = { // explicit conversion from float to dReal
+ Vertices[Indices[ii * 3 + 0] * 3 + 0],
+ Vertices[Indices[ii * 3 + 0] * 3 + 1],
+ Vertices[Indices[ii * 3 + 0] * 3 + 2],
+ Vertices[Indices[ii * 3 + 1] * 3 + 0],
+ Vertices[Indices[ii * 3 + 1] * 3 + 1],
+ Vertices[Indices[ii * 3 + 1] * 3 + 2],
+ Vertices[Indices[ii * 3 + 2] * 3 + 0],
+ Vertices[Indices[ii * 3 + 2] * 3 + 1],
+ Vertices[Indices[ii * 3 + 2] * 3 + 2]
+ };
+ dsDrawTriangle(pos, R, &v[0], &v[3], &v[6], 1);
+ }
+
+ } else if (type == dHeightfieldClass) {
+
+ // Set ox and oz to zero for DHEIGHTFIELD_CORNER_ORIGIN mode.
+ int ox = (int) ( -HFIELD_WIDTH/2 );
+ int oz = (int) ( -HFIELD_DEPTH/2 );
+
+ // for ( int tx = -1; tx < 2; ++tx )
+ // for ( int tz = -1; tz < 2; ++tz )
+ dsSetColorAlpha (0.5,1,0.5,0.5);
+ dsSetTexture( DS_WOOD );
+
+ for ( int i = 0; i < HFIELD_WSTEP - 1; ++i )
+ for ( int j = 0; j < HFIELD_DSTEP - 1; ++j ) {
+ dReal a[3], b[3], c[3], d[3];
+
+ a[ 0 ] = ox + ( i ) * HFIELD_WSAMP;
+ a[ 1 ] = heightfield_callback( NULL, i, j );
+ a[ 2 ] = oz + ( j ) * HFIELD_DSAMP;
+
+ b[ 0 ] = ox + ( i + 1 ) * HFIELD_WSAMP;
+ b[ 1 ] = heightfield_callback( NULL, i + 1, j );
+ b[ 2 ] = oz + ( j ) * HFIELD_DSAMP;
+
+ c[ 0 ] = ox + ( i ) * HFIELD_WSAMP;
+ c[ 1 ] = heightfield_callback( NULL, i, j + 1 );
+ c[ 2 ] = oz + ( j + 1 ) * HFIELD_DSAMP;
+
+ d[ 0 ] = ox + ( i + 1 ) * HFIELD_WSAMP;
+ d[ 1 ] = heightfield_callback( NULL, i + 1, j + 1 );
+ d[ 2 ] = oz + ( j + 1 ) * HFIELD_DSAMP;
+
+ dsDrawTriangle( pos, R, a, c, b, 1 );
+ dsDrawTriangle( pos, R, b, c, d, 1 );
+ }
+
+ }
+
+ if (show_aabb) {
+ // draw the bounding box for this geom
+ dReal aabb[6];
+ dGeomGetAABB(g,aabb);
+ dVector3 bbpos;
+ for (int i=0; i<3; i++)
+ bbpos[i] = 0.5*(aabb[i*2] + aabb[i*2+1]);
+ dVector3 bbsides;
+ for (int i=0; i<3; i++)
+ bbsides[i] = aabb[i*2+1] - aabb[i*2];
+ dMatrix3 RI;
+ dRSetIdentity(RI);
+ dsSetColorAlpha(1,0,0,0.5);
+ dsDrawBox(bbpos,RI,bbsides);
+ }
+
+}
+
+// simulation loop
+
+static void simLoop (int pause)
+{
+ int i,j;
+
+ dSpaceCollide(space,0,&nearCallback);
+
+ if (!pause)
+ dWorldQuickStep(world,0.05);
+
+
+ if (write_world) {
+ FILE *f = fopen ("state.dif","wt");
+ if (f) {
+ dWorldExportDIF(world,f,"X");
+ fclose (f);
+ }
+ write_world = 0;
+ }
+
+ // remove all contact joints
+ dJointGroupEmpty(contactgroup);
+
+
+
+ //
+ // Draw Heightfield
+ //
+
+ drawGeom(gheight, 0, 0, 0);
+
+
+
+ dsSetColor (1,1,0);
+ dsSetTexture (DS_WOOD);
+ for (i=0; i<num; i++) {
+ for (j=0; j < GPB; j++) {
+ if (i==selected) {
+ dsSetColor (0,0.7,1);
+ } else if (! dBodyIsEnabled (obj[i].body)) {
+ dsSetColor (1,0.8,0);
+ } else {
+ dsSetColor (1,1,0);
+ }
+
+ drawGeom (obj[i].geom[j],0,0,show_aabb);
+ }
+ }
+
+}
+
+
+int main (int argc, char **argv)
+{
+ printf("ODE configuration: %s\n", dGetConfiguration());
+
+ // Is trimesh support built into this ODE?
+ g_allow_trimesh = dCheckConfiguration( "ODE_EXT_trimesh" );
+
+ // setup pointers to drawstuff callback functions
+ dsFunctions fn;
+ fn.version = DS_VERSION;
+ fn.start = &start;
+ fn.step = &simLoop;
+ fn.command = &command;
+ fn.stop = 0;
+ fn.path_to_textures = DRAWSTUFF_TEXTURE_PATH;
+
+ // create world
+ dInitODE2(0);
+ world = dWorldCreate();
+ space = dHashSpaceCreate (0);
+ contactgroup = dJointGroupCreate (0);
+ dWorldSetGravity(world,0,0,-0.05);
+ dWorldSetCFM(world,1e-5);
+ dWorldSetAutoDisableFlag(world,1);
+ dWorldSetContactMaxCorrectingVel(world,0.1);
+ dWorldSetContactSurfaceLayer(world,0.001);
+ memset(obj,0,sizeof(obj));
+
+ dWorldSetAutoDisableAverageSamplesCount( world, 1 );
+
+ // base plane to catch overspill
+ dCreatePlane( space, 0, 0, 1, 0 );
+
+
+ // our heightfield floor
+
+ dHeightfieldDataID heightid = dGeomHeightfieldDataCreate();
+
+ // Create an finite heightfield.
+ dGeomHeightfieldDataBuildCallback( heightid, NULL, heightfield_callback,
+ HFIELD_WIDTH, HFIELD_DEPTH, HFIELD_WSTEP, HFIELD_DSTEP,
+ REAL( 1.0 ), REAL( 0.0 ), REAL( 0.0 ), 0 );
+
+ // Give some very bounds which, while conservative,
+ // makes AABB computation more accurate than +/-INF.
+ dGeomHeightfieldDataSetBounds( heightid, REAL( -4.0 ), REAL( +6.0 ) );
+
+ gheight = dCreateHeightfield( space, heightid, 1 );
+
+ dVector3 pos;
+ pos[ 0 ] = 0;
+ pos[ 1 ] = 0;
+ pos[ 2 ] = 0;
+
+ // Rotate so Z is up, not Y (which is the default orientation)
+ dMatrix3 R;
+ dRSetIdentity( R );
+ dRFromAxisAndAngle( R, 1, 0, 0, DEGTORAD * 90 );
+
+ // Place it.
+ dGeomSetRotation( gheight, R );
+ dGeomSetPosition( gheight, pos[0], pos[1], pos[2] );
+
+ dThreadingImplementationID threading = dThreadingAllocateMultiThreadedImplementation();
+ dThreadingThreadPoolID pool = dThreadingAllocateThreadPool(4, 0, dAllocateFlagBasicData, NULL);
+ dThreadingThreadPoolServeMultiThreadedImplementation(pool, threading);
+ // dWorldSetStepIslandsProcessingMaxThreadCount(world, 1);
+ dWorldSetStepThreadingImplementation(world, dThreadingImplementationGetFunctions(threading), threading);
+
+ // run simulation
+ dsSimulationLoop (argc,argv,352,288,&fn);
+
+ dThreadingImplementationShutdownProcessing(threading);
+ dThreadingFreeThreadPool(pool);
+ dWorldSetStepThreadingImplementation(world, NULL, NULL);
+ dThreadingFreeImplementation(threading);
+
+ dJointGroupDestroy (contactgroup);
+ dSpaceDestroy (space);
+ dWorldDestroy (world);
+
+ // destroy heightfield data, because _we_ own it not ODE
+ dGeomHeightfieldDataDestroy( heightid );
+
+ dCloseODE();
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-01 02:18:42 +0000