ugo_zapad/horror
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Kirill Yurkin
2024-06-10 12:48:14 +03:00
commit d54c9805b3
1398 changed files with 739400 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

714
thirdparty/ode-0.16.5/ode/demo/demo_heightfield.cpp vendored Normal file
View File

@@ -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();
}