Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

latest 0.5 changes from Steven Baker, and fixed Windows MSVC compiling issues

Browse Source
This commit is contained in:
ejcoumans
2006-09-19 17:10:30 +00:00
parent eb6664f7c2
commit 4970e86100
12 changed files with 445 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
Extras/GPUphysics/GPU_physics_demo.cxx
View File

@@ -1,17 +1,4 @@
#ifndef WIN32
#include <sys/time.h>
#endif
#include <assert.h>
#include <GL/glew.h>
//think different
#if defined(__APPLE__) && !defined (VMDMESA)
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#include <GL/gl.h>
#endif
#include "GPU_physics.h"
#include "fboSupport.h"
#include "shaderSupport.h"
@@ -25,7 +12,49 @@ enum DebugOptions
} ;
DebugOptions debugOpt = DRAW_ALL ;
static float *positionData = NULL ;
static float *rotationData = NULL ;
static bool noVertexTextureSupport = false ;
static DebugOptions debugOpt = DRAW_ALL ;
void checkVertexTextureSupport ( bool disableVertexTextureSupport )
{
GLint nVertTextures ;
GLint nFragTextures ;
GLint nCombTextures ;
glGetIntegerv ( GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, & nVertTextures ) ;
glGetIntegerv ( GL_MAX_TEXTURE_IMAGE_UNITS, & nFragTextures ) ;
glGetIntegerv ( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, & nCombTextures ) ;
fprintf(stderr, "INFO: This hardware supports at most:\n"
" %2d vert texture samplers\n"
" %2d frag texture samplers\n"
" %2d total texture samplers\n",
nVertTextures, nFragTextures, nCombTextures ) ;
noVertexTextureSupport = ( nVertTextures < 2 ) ;
if ( noVertexTextureSupport && debugOpt != DRAW_WITHOUT_SHADERS )
{
fprintf ( stderr, "\n"
"********************************************\n"
"* *\n"
"* WARNING: This graphics card doesn't have *\n"
"* vertex shader texture support - a work- *\n"
"* around will be used - but this demo will *\n"
"* be much less impressive as a result! *\n"
"* *\n"
"********************************************\n\n" ) ;
}
if ( ! noVertexTextureSupport && disableVertexTextureSupport )
{
fprintf ( stderr, "WARNING: Vertex Texture Support has"
"been disabled from the command line.\n" ) ;
noVertexTextureSupport = true ;
}
}
float frand ( float max )
@@ -33,6 +62,7 @@ float frand ( float max )
return (float)(rand() % 32767) * max / 32767.0f ;
}
static GLSL_ShaderPair *velocityGenerator ;
static GLSL_ShaderPair *positionGenerator ;
static GLSL_ShaderPair *collisionGenerator ;
@@ -44,6 +74,7 @@ static FrameBufferObject *velocity ;
static FrameBufferObject *rotvelocity ;
static FrameBufferObject *force ;
static FrameBufferObject *mass ;
static FrameBufferObject *old ;
#define TEX_SIZE 128
#define NUM_CUBES ( TEX_SIZE * TEX_SIZE )
@@ -77,7 +108,9 @@ void reshape ( int wid, int ht )
}
void initGLcontext ( int argc, char **argv, void (*display)(void) )
void initGLcontext ( int argc, char **argv,
void (*display)(void),
bool disableVertexTextureSupport )
{
glutInit ( &argc, argv ) ;
glutInitDisplayMode ( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE ) ;
@@ -88,6 +121,8 @@ void initGLcontext ( int argc, char **argv, void (*display)(void) )
glutReshapeFunc ( reshape ) ;
glewInit () ;
checkVertexTextureSupport ( disableVertexTextureSupport ) ;
}
@@ -97,6 +132,7 @@ void initMotionTextures ()
position = new FrameBufferObject ( TEX_SIZE, TEX_SIZE, 3, FBO_FLOAT ) ;
rotation = new FrameBufferObject ( TEX_SIZE, TEX_SIZE, 3, FBO_FLOAT ) ;
old = new FrameBufferObject ( TEX_SIZE, TEX_SIZE, 3, FBO_FLOAT ) ;
if ( debugOpt == DRAW_WITHOUT_PHYSICS )
{
@@ -122,8 +158,9 @@ void initMotionTextures ()
}
}
float *positionData = new float [ TEX_SIZE * TEX_SIZE * 3 ] ;
float *rotationData = new float [ TEX_SIZE * TEX_SIZE * 3 ] ;
positionData = new float [ TEX_SIZE * TEX_SIZE * 3 ] ;
rotationData = new float [ TEX_SIZE * TEX_SIZE * 3 ] ;
float *velocityData ;
float *rotvelocityData ;
float *forceData ;
@@ -175,9 +212,9 @@ void initMotionTextures ()
if ( debugOpt != DRAW_WITHOUT_PHYSICS )
{
/* Random (but predominantly upwards) velocities. */
velocityData [ (i*TEX_SIZE + j) * 3 + 0 ] = frand ( 10.0f ) ;
velocityData [ (i*TEX_SIZE + j) * 3 + 0 ] = frand ( 10.0f ) - 5.0f;
velocityData [ (i*TEX_SIZE + j) * 3 + 1 ] = frand ( 100.0f ) ;
velocityData [ (i*TEX_SIZE + j) * 3 + 2 ] = frand ( 10.0f ) ;
velocityData [ (i*TEX_SIZE + j) * 3 + 2 ] = frand ( 10.0f ) - 5.0f;
/* Random rotational velocities */
rotvelocityData [ (i*TEX_SIZE + j) * 3 + 0 ] = frand ( 3.0f ) ;
@@ -201,6 +238,7 @@ void initMotionTextures ()
position -> fillTexture ( positionData ) ;
rotation -> fillTexture ( rotationData ) ;
old -> fillTexture ( positionData ) ; // Doesn't really need it...
if ( debugOpt != DRAW_WITHOUT_PHYSICS )
{
@@ -237,15 +275,14 @@ void initPhysicsShaders ()
velocityGenerator = new GLSL_ShaderPair (
"VelocityGenerator",
NULL, NULL,
"uniform float delta_T ;"
"uniform vec3 g ;"
"uniform vec4 g_dt ;"
"uniform sampler2D old_velocity ;"
"uniform sampler2D force ;"
"uniform sampler2D mass ;"
"void main() {"
" gl_FragColor = vec4 ("
" texture2D ( old_velocity, gl_TexCoord[0].st ).xyz +"
" delta_T * ( g +"
" g_dt.w * ( g_dt.xyz +"
" texture2D ( force , gl_TexCoord[0].st ).xyz /"
" texture2D ( mass , gl_TexCoord[0].st ).x),"
" 1.0 ) ; }",
@@ -290,7 +327,7 @@ void initPhysicsShaders ()
"void main() {"
" vec3 pos = texture2D ( position , gl_TexCoord[0].st ).xyz ;"
" vec3 vel = texture2D ( old_velocity, gl_TexCoord[0].st ).xyz ;"
" if ( pos [ 1 ] < 0.0 ) vel [ 1 ] *= -0.90 ;"
" if ( pos [ 1 ] < 0.0 ) vel *= vec3(0.90,-0.90,0.90) ;"
" gl_FragColor = vec4 ( vel, 1.0 ) ; }",
"CollisionGenerator Frag Shader" ) ;
assert ( collisionGenerator -> compiledOK () ) ;
@@ -303,15 +340,17 @@ void initCubeVBO ()
float *p = vertices ;
float *t = texcoords ;
float *c = colours ;
int nverts = 0 ;
for ( int k = 0 ; k < NUM_CUBES * STRIPS_PER_CUBE ; k++ )
for ( int k = 0 ;
k < (noVertexTextureSupport ? 1 : NUM_CUBES) * STRIPS_PER_CUBE ; k++ )
{
starts [ k ] = k * VERTS_PER_STRIP ;
lengths [ k ] = VERTS_PER_STRIP ;
}
for ( int i = 0 ; i < TEX_SIZE ; i++ )
for ( int j = 0 ; j < TEX_SIZE ; j++ )
for ( int i = 0 ; i < (noVertexTextureSupport ? 1 : TEX_SIZE) ; i++ )
for ( int j = 0 ; j < (noVertexTextureSupport ? 1 : TEX_SIZE) ; j++ )
{
int n = i * TEX_SIZE + j ;
@@ -363,21 +402,23 @@ void initCubeVBO ()
*p++ = +1 + dx ; *p++ = -1 + dy ; *p++ = +1 + dz ;
*p++ = +1 + dx ; *p++ = +1 + dy ; *p++ = -1 + dz ;
*p++ = +1 + dx ; *p++ = +1 + dy ; *p++ = +1 + dz ;
nverts += STRIPS_PER_CUBE * VERTS_PER_STRIP ;
}
glGenBuffersARB ( 1, & vbo_vx ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, vbo_vx ) ;
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, NUM_VERTS * 3 * sizeof(float),
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, nverts * 3 * sizeof(float),
vertices, GL_STATIC_DRAW_ARB ) ;
glGenBuffersARB ( 1, & vbo_tx ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, vbo_tx ) ;
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, NUM_VERTS * 2 * sizeof(float),
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, nverts * 2 * sizeof(float),
texcoords, GL_STATIC_DRAW_ARB ) ;
glGenBuffersARB ( 1, & vbo_co ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, vbo_co ) ;
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, NUM_VERTS * 4 * sizeof(float),
glBufferDataARB ( GL_ARRAY_BUFFER_ARB, nverts * 4 * sizeof(float),
colours, GL_STATIC_DRAW_ARB ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, 0 ) ;
@@ -386,15 +427,89 @@ void initCubeVBO ()
cubeShader = NULL ;
else
{
cubeShader = new GLSL_ShaderPair ( "CubeShader", "cubeShader.vert",
"cubeShader.frag" ) ;
if ( noVertexTextureSupport )
cubeShader = new GLSL_ShaderPair ( "CubeShader", "cubeShaderNoTexture.vert",
"cubeShader.frag" ) ;
else
cubeShader = new GLSL_ShaderPair ( "CubeShader", "cubeShader.vert",
"cubeShader.frag" ) ;
assert ( cubeShader -> compiledOK () ) ;
}
}
void drawCubesTheHardWay ()
{
/*
Without vertex texture support, we have to read the position/rotation
data back from the hardware every frame and render each cube individually.
*/
float p0 = positionData [ 0 ] ;
float p1 = positionData [ 1 ] ;
float p2 = positionData [ 2 ] ;
position -> fetchTexture ( positionData ) ;
rotation -> fetchTexture ( rotationData ) ;
if ( positionData [ 0 ] == p0 &&
positionData [ 1 ] == p1 &&
positionData [ 2 ] == p2 )
{
fprintf ( stderr, "WARNING: If nothing seems to be working, you may\n"
"have an old version of the nVidia driver.\n"
"Version 76.76 is known to be bad.\n" ) ;
}
cubeShader -> use () ; /* Math = Cube shader */
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT ) ;
glDisableClientState ( GL_TEXTURE_COORD_ARRAY ) ;
glEnableClientState ( GL_COLOR_ARRAY ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, vbo_co ) ;
glColorPointer ( 4, GL_FLOAT, 0, vbo_co ? NULL : colours ) ;
glEnableClientState ( GL_VERTEX_ARRAY ) ;
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, vbo_vx ) ;
glVertexPointer ( 3, GL_FLOAT, 0, vbo_vx ? NULL : vertices ) ;
for ( int i = 0 ; i < TEX_SIZE ; i++ )
for ( int j = 0 ; j < TEX_SIZE ; j++ )
{
float *pos = & positionData [ (i*TEX_SIZE + j) * 3 ] ;
float *rot = & rotationData [ (i*TEX_SIZE + j) * 3 ] ;
glPushMatrix () ;
glTranslatef ( pos [ 0 ], pos [ 1 ], pos [ 2 ] ) ;
glRotatef ( rot [ 0 ] * 180.0f / 3.14159f, 0, 1, 0 ) ;
glRotatef ( rot [ 1 ] * 180.0f / 3.14159f, 1, 0, 0 ) ;
glRotatef ( rot [ 2 ] * 180.0f / 3.14159f, 0, 0, 1 ) ;
glMultiDrawArraysEXT ( GL_TRIANGLE_STRIP, (GLint*)starts, (GLint*)lengths,
STRIPS_PER_CUBE ) ;
glPopMatrix () ;
}
glBindBufferARB ( GL_ARRAY_BUFFER_ARB, 0 ) ;
glPopClientAttrib () ;
}
void drawCubeVBO ()
{
/*
With vertex texture support, we can leave the position/rotation
data on the hardware and render all of the cubes in one big VBO!
*/
if ( debugOpt != DRAW_WITHOUT_SHADERS )
{
cubeShader -> use () ; /* Math = Cube shader */
cubeShader -> applyTexture ( "position", position, 0 ) ;
cubeShader -> applyTexture ( "rotation", rotation, 1 ) ;
}
glPushClientAttrib ( GL_CLIENT_VERTEX_ARRAY_BIT ) ;
glEnableClientState ( GL_TEXTURE_COORD_ARRAY ) ;
@@ -437,12 +552,17 @@ void drawCubes ()
glClearColor ( 0.7f, 0.7f, 0.7f, 1.0f ) ;
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ;
drawCubeVBO () ;
if ( noVertexTextureSupport )
drawCubesTheHardWay () ;
else
drawCubeVBO () ;
}
void display ( void )
{
FrameBufferObject *tmp ;
if ( debugOpt != DRAW_WITHOUT_SHADERS &&
debugOpt != DRAW_WITHOUT_PHYSICS )
{
@@ -450,31 +570,50 @@ void display ( void )
if ( debugOpt != DRAW_WITHOUT_FORCES )
{
/* Copy old velocity into old. */
tmp = old ;
old = velocity ;
velocity = tmp ;
velocityGenerator -> use () ;
velocityGenerator -> applyTexture ( "old_velocity", velocity, 0 ) ;
velocityGenerator -> applyTexture ( "old_velocity", old , 0 ) ;
velocityGenerator -> applyTexture ( "force" , force , 1 ) ;
velocityGenerator -> applyTexture ( "mass" , mass , 2 ) ;
velocityGenerator -> setUniform1f ( "delta_T" , 0.016f ) ;
velocityGenerator -> setUniform3f ( "g", 0.0f, -9.8f, 0.0f ) ;
velocityGenerator -> setUniform4f ( "g_dt", 0.0f, -9.8f, 0.0f, 0.016f ) ;
velocity -> paint () ;
}
/* Copy old position into old. */
tmp = old ;
old = position ;
position = tmp ;
positionGenerator -> use () ;
positionGenerator -> applyTexture ( "old_position", position, 0 ) ;
positionGenerator -> applyTexture ( "old_position", old , 0 ) ;
positionGenerator -> applyTexture ( "velocity" , velocity, 1 ) ;
positionGenerator -> setUniform1f ( "delta_T", 0.016f ) ;
position -> paint () ;
if ( debugOpt != DRAW_WITHOUT_COLLISIONS )
{
/* Copy old velocity into old. */
tmp = old ;
old = velocity ;
velocity = tmp ;
collisionGenerator -> use () ;
collisionGenerator -> applyTexture ( "position" , position, 0 ) ;
collisionGenerator -> applyTexture ( "old_velocity", velocity, 1 ) ;
collisionGenerator -> applyTexture ( "old_velocity", old , 1 ) ;
velocity -> paint () ;
}
/* Copy old rotation into old. */
tmp = old ;
old = rotation ;
rotation = tmp ;
positionGenerator -> use () ;
positionGenerator -> applyTexture ( "old_position", rotation , 0 ) ;
positionGenerator -> applyTexture ( "old_position", old , 0 ) ;
positionGenerator -> applyTexture ( "velocity" , rotvelocity, 1 ) ;
positionGenerator -> setUniform1f ( "delta_T", 0.016f ) ;
rotation -> paint () ;
@@ -486,13 +625,6 @@ void display ( void )
glViewport ( 0, 0, win_width, win_height ) ;
if ( debugOpt != DRAW_WITHOUT_SHADERS )
{
cubeShader -> use () ; /* Math = Cube shader */
cubeShader -> applyTexture ( "position", position, 0 ) ;
cubeShader -> applyTexture ( "rotation", rotation, 1 ) ;
}
drawCubes () ;
/* All done! */
@@ -505,19 +637,22 @@ void display ( void )
void help ()
{
fprintf ( stderr, "GPUphysics: Usage -\n\n" ) ;
fprintf ( stderr, " GPUphysics_demo [-c][-p][-v][-a]\n\n" ) ;
fprintf ( stderr, " GPUphysics_demo [-c][-p][-v][-a][-v]\n\n" ) ;
fprintf ( stderr, "Where:\n" ) ;
fprintf ( stderr, " -s -- Draw with shaders at all\n" ) ;
fprintf ( stderr, " -p -- Draw with shaders but no physics\n" ) ;
fprintf ( stderr, " -c -- Draw with physics but no ground collisions\n" ) ;
fprintf ( stderr, " -f -- Draw with physics but no forces\n" ) ;
fprintf ( stderr, " -a -- Draw with all features enabled [default]\n" ) ;
fprintf ( stderr, " -v -- Disable vertex textures even if "
"they are supported in hardware\n" ) ;
fprintf ( stderr, "\n" ) ;
}
int main ( int argc, char **argv )
{
bool disableVertexTextureSupport = false ;
debugOpt = DRAW_ALL ;
for ( int i = 1 ; i < argc ; i++ )
@@ -532,6 +667,7 @@ int main ( int argc, char **argv )
case 'f' : debugOpt = DRAW_WITHOUT_FORCES ; break ;
case 'a' : debugOpt = DRAW_ALL ; break ;
case 'v' : disableVertexTextureSupport = true ; break ;
default : help () ; exit ( 0 ) ;
}
else
@@ -541,8 +677,7 @@ int main ( int argc, char **argv )
}
}
initGLcontext ( argc, argv, display ) ;
initGLcontext ( argc, argv, display, disableVertexTextureSupport ) ;
initMotionTextures () ;
initPhysicsShaders () ;
initCubeVBO () ;