diff --git a/Examples/Jamfile b/Examples/Jamfile new file mode 100644 index 000000000..93cbb6fcb --- /dev/null +++ b/Examples/Jamfile @@ -0,0 +1,3 @@ +SubDir TOP Examples ; + +SubInclude TOP Examples TestBed ; diff --git a/Examples/TestBed/FrameWork/Jamfile b/Examples/TestBed/FrameWork/Jamfile new file mode 100644 index 000000000..5409e131f --- /dev/null +++ b/Examples/TestBed/FrameWork/Jamfile @@ -0,0 +1,3 @@ +SubDir TOP Examples TestBed Framework ; + +BulletDemo FrameWork : [ Wildcard *.h *.cpp ] ; diff --git a/Examples/TestBed/FrameWork/Main.cpp b/Examples/TestBed/FrameWork/Main.cpp new file mode 100644 index 000000000..31bf5e246 --- /dev/null +++ b/Examples/TestBed/FrameWork/Main.cpp @@ -0,0 +1,285 @@ +/* +* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely, subject to the following restrictions: +* 1. The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software +* in a product, an acknowledgment in the product documentation would be +* appreciated but is not required. +* 2. Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* 3. This notice may not be removed or altered from any source distribution. +*/ + +#include + +#include "glui/GL/glui.h" +#include "LinearMath/btScalar.h" +#include "LinearMath/btMinMax.h" + +#include "Render.h" +#include "Test.h" + +namespace +{ + int testIndex = 0; + int testSelection = 0; + TestEntry* entry; + Test* test; + Settings settings; + int width = 640; + int height = 480; + int framePeriod = 16; + int mainWindow; + GLUI *glui; + float viewZoom = 20.0f; + float viewX = 0.0f; + float viewY = 0.0f; + int tx, ty, tw, th; +} + +void Resize(int w, int h) +{ + width = w; + height = h; + + GLUI_Master.get_viewport_area( &tx, &ty, &tw, &th ); + glViewport( tx, ty, tw, th ); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + double ratio = (double)tw / (double)th; + + gluOrtho2D(viewZoom * (viewX - ratio), viewZoom * (ratio + viewX), + viewZoom * (viewY - 0.1), viewZoom * (viewY + 1.9)); +} + +/*b2Vec2 ConvertScreenToWorld(int x, int y) +{ + b2Vec2 p; + + float ratio = float(tw) / float(th); + float u = x / float(tw); + float v = (th - y) / float(th); + p.x = viewZoom * (viewX - ratio) * (1.0f - u) + viewZoom * (ratio + viewX) * u; + p.y = viewZoom * (viewY - 0.1f) * (1.0f - v) + viewZoom * (viewY + 1.9f) * v; + return p; +} +*/ + +// This is used to control the frame rate (60Hz). +void Timer(int) +{ + glutSetWindow(mainWindow); + glutPostRedisplay(); + glutTimerFunc(framePeriod, Timer, 0); +} + +void SimulationLoop() +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + test->SetTextLine(30); + test->Step(&settings); + +/// DrawString(5, 15, entry->name); + + glutSwapBuffers(); + + if (testSelection != testIndex) + { + testIndex = testSelection; + delete test; + entry = g_testEntries + testIndex; + test = entry->createFcn(); + viewZoom = 20.0f; + viewX = 0.0f; + viewY = 0.0f; + Resize(width, height); + } +} + +void Keyboard(unsigned char key, int x, int y) +{ + + switch (key) + { + case 27: + exit(0); + break; + + // Press 'a' to zoom in. + case 'a': + viewZoom = btMax(viewZoom - 1.0f, 1.0f); + Resize(width, height); + break; + + // Press 'z' to zoom out. + case 'z': + viewZoom = btMin(viewZoom + 1.0f, 100.0f); + Resize(width, height); + break; + + // Press 'r' to reset. + case 'r': + delete test; + test = entry->createFcn(); + break; + + // Press space to launch a bomb. + case ' ': + if (test) + { + test->LaunchBomb(); + } + break; + + case 'h': + settings.pause = !settings.pause; + break; + + default: + if (test) + { + test->Keyboard(key); + } + } +} + +void KeyboardSpecial(int key, int x, int y) +{ + + switch (key) + { + // Press left to pan left. + case GLUT_KEY_LEFT: + viewX += 0.1f; + Resize(width, height); + break; + + // Press right to pan right. + case GLUT_KEY_RIGHT: + viewX -= 0.1f; + Resize(width, height); + break; + + // Press down to pan down. + case GLUT_KEY_DOWN: + viewY += 0.1f; + Resize(width, height); + break; + + // Press up to pan up. + case GLUT_KEY_UP: + viewY -= 0.1f; + Resize(width, height); + break; + + // Press home to reset the view. + case GLUT_KEY_HOME: + viewZoom = 20.0f; + viewX = 0.0f; + viewY = 0.0f; + Resize(width, height); + break; + } +} + +void Mouse(int button, int state, int x, int y) +{ + // Use the mouse to move things around. + if (button == GLUT_LEFT_BUTTON) + { + if (state == GLUT_DOWN) + { + // b2Vec2 p = ConvertScreenToWorld(x, y); + // test->MouseDown(p); + } + + if (state == GLUT_UP) + { + test->MouseUp(); + } + } +} + +void MouseMotion(int x, int y) +{ +// b2Vec2 p = ConvertScreenToWorld(x, y); +// test->MouseMove(p); +} + +int main(int argc, char** argv) +{ + entry = g_testEntries + testIndex; + test = entry->createFcn(); + + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); + glutInitWindowSize(width, height); + mainWindow = glutCreateWindow("http://bulletphysics.com"); + //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); + + glutDisplayFunc(SimulationLoop); + GLUI_Master.set_glutReshapeFunc(Resize); + GLUI_Master.set_glutKeyboardFunc(Keyboard); + GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); + GLUI_Master.set_glutMouseFunc(Mouse); + glutMotionFunc(MouseMotion); + + glui = GLUI_Master.create_glui_subwindow( mainWindow, + GLUI_SUBWINDOW_RIGHT ); + + glui->add_statictext("Tests"); + GLUI_Listbox* testList = + glui->add_listbox("", &testSelection); + + glui->add_separator(); + + GLUI_Spinner* iterationSpinner = + glui->add_spinner("Iterations", GLUI_SPINNER_INT, &settings.iterationCount); + iterationSpinner->set_int_limits(1, 100); + + GLUI_Spinner* hertzSpinner = + glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settings.hz); + hertzSpinner->set_float_limits(5.0f, 200.0f); + + glui->add_checkbox("Position Correction", &settings.enablePositionCorrection); + glui->add_checkbox("Warm Starting", &settings.enablePositionCorrection); + + glui->add_separator(); + + GLUI_Panel* drawPanel = glui->add_panel("Draw"); + glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); + glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); + glui->add_checkbox_to_panel(drawPanel, "Contacts", &settings.drawContacts); + glui->add_checkbox_to_panel(drawPanel, "Impulses", &settings.drawImpulses); + glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); + + int testCount = 0; + TestEntry* e = g_testEntries; + while (e->createFcn) + { + testList->add_item(testCount, e->name); + ++testCount; + ++e; + } + + glui->add_button("Quit", 0,(GLUI_Update_CB)exit); + glui->set_main_gfx_window( mainWindow ); + + // Use a timer to control the frame rate. + glutTimerFunc(framePeriod, Timer, 0); + + glutMainLoop(); + + return 0; +} diff --git a/Examples/TestBed/FrameWork/Render.cpp b/Examples/TestBed/FrameWork/Render.cpp new file mode 100644 index 000000000..95277dbd2 --- /dev/null +++ b/Examples/TestBed/FrameWork/Render.cpp @@ -0,0 +1,67 @@ +/* +* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely, subject to the following restrictions: +* 1. The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software +* in a product, an acknowledgment in the product documentation would be +* appreciated but is not required. +* 2. Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "Render.h" + +//#include "freeglut/gl/glut.h" +//think different +#if defined(__APPLE__) && !defined (VMDMESA) +#include +#include +#include +#else +#include +#endif + +#include +#include +#include + +void DrawString(int x, int y, const char *string, ...) +{ + char buffer[128]; + + va_list arg; + va_start(arg, string); + vsprintf(buffer, string, arg); + va_end(arg); + + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glLoadIdentity(); + int w = glutGet(GLUT_WINDOW_WIDTH); + int h = glutGet(GLUT_WINDOW_HEIGHT); + gluOrtho2D(0, w, h, 0); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glLoadIdentity(); + + glColor3f(0.9f, 0.6f, 0.6f); + glRasterPos2i(x, y); + int length = (int)strlen(buffer); + for (int i = 0; i < length; ++i) + { + glutBitmapCharacter(GLUT_BITMAP_8_BY_13, buffer[i]); + } + + glPopMatrix(); + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glMatrixMode(GL_MODELVIEW); +} + diff --git a/Examples/TestBed/FrameWork/Render.h b/Examples/TestBed/FrameWork/Render.h new file mode 100644 index 000000000..d2bcd8f06 --- /dev/null +++ b/Examples/TestBed/FrameWork/Render.h @@ -0,0 +1,32 @@ +/* +* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely, subject to the following restrictions: +* 1. The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software +* in a product, an acknowledgment in the product documentation would be +* appreciated but is not required. +* 2. Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef RENDER_H +#define RENDER_H + +#include "LinearMath/btScalar.h" + +struct Color +{ + Color() { cx = 1.0f; cy = 1.0f; cz = 1.0f; } + Color(float x, float y, float z) { cx = x; cy = y; cz = z; } + float cx, cy, cz; +}; + + +#endif diff --git a/Examples/TestBed/FrameWork/Test.cpp b/Examples/TestBed/FrameWork/Test.cpp new file mode 100644 index 000000000..77ce173ac --- /dev/null +++ b/Examples/TestBed/FrameWork/Test.cpp @@ -0,0 +1,331 @@ +/* +* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely, subject to the following restrictions: +* 1. The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software +* in a product, an acknowledgment in the product documentation would be +* appreciated but is not required. +* 2. Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* 3. This notice may not be removed or altered from any source distribution. +*/ + +#include "Test.h" +#include "Render.h" + +//#include "freeglut/gl/glut.h" +//think different +#if defined(__APPLE__) && !defined (VMDMESA) +#include +#include +#include +#else +#include +#endif + +#include + + +Test::Test() +{ + m_textLine = 30; + +} + +Test::~Test() +{ + // By deleting the world, we delete the bomb, mouse joint, etc. +} +/* +void Test::MouseDown(const b2Vec2& p) +{ + b2Assert(m_mouseJoint == NULL); + + // Make a small box. + b2AABB aabb; + b2Vec2 d; + d.Set(0.001f, 0.001f); + aabb.minVertex = p - d; + aabb.maxVertex = p + d; + + // Query the world for overlapping shapes. + const int32 k_maxCount = 10; + b2Shape* shapes[k_maxCount]; + int32 count = m_world->Query(aabb, shapes, k_maxCount); + b2Body* body = NULL; + for (int32 i = 0; i < count; ++i) + { + if (shapes[i]->m_body->IsStatic() == false) + { + bool inside = shapes[i]->TestPoint(p); + if (inside) + { + body = shapes[i]->m_body; + break; + } + } + } + + if (body) + { + b2MouseJointDef md; + md.body1 = m_world->m_groundBody; + md.body2 = body; + md.target = p; + md.motorForce = 400.0f * body->m_mass; + m_mouseJoint = (b2MouseJoint*)m_world->CreateJoint(&md); + body->WakeUp(); + } +} +*/ + +void Test::MouseUp() +{ +/* + if (m_mouseJoint) + { + m_world->DestroyJoint(m_mouseJoint); + m_mouseJoint = NULL; + } +*/ +} + +/*void Test::MouseMove(const b2Vec2& p) +{ + + if (m_mouseJoint) + { + m_mouseJoint->SetTarget(p); + } + +} +*/ + +void Test::LaunchBomb() +{ +/* + if (m_bomb) + { + m_world->DestroyBody(m_bomb); + m_bomb = NULL; + } + + b2BoxDef sd; + float32 a = 0.5f; + sd.type = e_boxShape; + sd.extents.Set(a, a); + sd.density = 20.0f; + + b2BodyDef bd; + bd.AddShape(&sd); + bd.allowSleep = true; + bd.position.Set(b2Random(-15.0f, 15.0f), 30.0f); + bd.rotation = b2Random(-1.5f, 1.5f); + bd.linearVelocity = -1.0f * bd.position; + bd.angularVelocity = b2Random(-20.0f, 20.0f); + + m_bomb = m_world->CreateBody(&bd); +*/ +} + +//typedef const char *(APIENTRY * WGLGETEXTENSIONSSTRINGEXT_T)( void ); + +void Test::Step(const Settings* settings) +{ +/* + float32 timeStep = settings->hz > 0.0f ? 1.0f / settings->hz : 0.0f; + + if (settings->pause) + { + timeStep = 0.0f; + } + + b2World::s_enableWarmStarting = settings->enableWarmStarting; + b2World::s_enablePositionCorrection = settings->enablePositionCorrection; + + m_world->Step(timeStep, settings->iterationCount); + + m_world->m_broadPhase->Validate(); + + for (b2Body* b = m_world->m_bodyList; b; b = b->m_next) + { + for (b2Shape* s = b->m_shapeList; s; s = s->m_next) + { + if (b->IsStatic()) + { + DrawShape(s, Color(0.5f, 0.9f, 0.5f)); + } + else if (b->IsSleeping()) + { + DrawShape(s, Color(0.5f, 0.5f, 0.9f)); + } + else if (b == m_bomb) + { + DrawShape(s, Color(0.9f, 0.9f, 0.4f)); + } + else + { + DrawShape(s, Color(0.9f, 0.9f, 0.9f)); + } + } + } + + for (b2Joint* j = m_world->m_jointList; j; j = j->m_next) + { + if (j != m_mouseJoint) + { + DrawJoint(j); + } + } + + if (settings->drawContacts) + { + for (b2Contact* c = m_world->m_contactList; c; c = c->m_next) + { + b2Manifold* ms = c->GetManifolds(); + for (int32 i = 0; i < c->GetManifoldCount(); ++i) + { + b2Manifold* m = ms + i; + glPointSize(4.0f); + glColor3f(1.0f, 0.0f, 0.0f); + glBegin(GL_POINTS); + for (int j = 0; j < m->pointCount; ++j) + { + b2Vec2 v = m->points[j].position; + glVertex2f(v.x, v.y); + } + glEnd(); + glPointSize(1.0f); + } + } + } + + if (settings->drawImpulses) + { + for (b2Contact* c = m_world->m_contactList; c; c = c->m_next) + { + b2Manifold* ms = c->GetManifolds(); + for (int32 i = 0; i < c->GetManifoldCount(); ++i) + { + b2Manifold* m = ms + i; + + glColor3f(0.9f, 0.9f, 0.3f); + glBegin(GL_LINES); + for (int32 j = 0; j < m->pointCount; ++j) + { + b2Vec2 v1 = m->points[j].position; + b2Vec2 v2 = v1 + m->points[j].normalImpulse * m->normal; + glVertex2f(v1.x, v1.y); + glVertex2f(v2.x, v2.y); + } + glEnd(); + } + } + } + + if (settings->drawPairs) + { + b2BroadPhase* bp = m_world->m_broadPhase; + b2Vec2 invQ; + invQ.Set(1.0f / bp->m_quantizationFactor.x, 1.0f / bp->m_quantizationFactor.y); + glColor3f(0.9f, 0.9f, 0.3f); + glBegin(GL_LINES); + for (int32 i = 0; i < bp->m_pairManager.m_pairCount; ++i) + { + b2Pair* pair = bp->m_pairManager.m_pairs + i; + uint16 id1 = pair->proxyId1; + uint16 id2 = pair->proxyId2; + b2Proxy* p1 = bp->m_proxyPool + id1; + b2Proxy* p2 = bp->m_proxyPool + id2; + + b2AABB b1, b2; + b1.minVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p1->lowerBounds[0]].value; + b1.minVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p1->lowerBounds[1]].value; + b1.maxVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p1->upperBounds[0]].value; + b1.maxVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p1->upperBounds[1]].value; + b2.minVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p2->lowerBounds[0]].value; + b2.minVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p2->lowerBounds[1]].value; + b2.maxVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p2->upperBounds[0]].value; + b2.maxVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p2->upperBounds[1]].value; + + b2Vec2 x1 = 0.5f * (b1.minVertex + b1.maxVertex); + b2Vec2 x2 = 0.5f * (b2.minVertex + b2.maxVertex); + + glVertex2f(x1.x, x1.y); + glVertex2f(x2.x, x2.y); + } + glEnd(); + } + + if (settings->drawAABBs) + { + b2BroadPhase* bp = m_world->m_broadPhase; + b2Vec2 invQ; + invQ.Set(1.0f / bp->m_quantizationFactor.x, 1.0f / bp->m_quantizationFactor.y); + glColor3f(0.9f, 0.3f, 0.9f); + for (int32 i = 0; i < b2_maxProxies; ++i) + { + b2Proxy* p = bp->m_proxyPool + i; + if (p->IsValid() == false) + { + continue; + } + + b2AABB b; + b.minVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p->lowerBounds[0]].value; + b.minVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p->lowerBounds[1]].value; + b.maxVertex.x = bp->m_worldAABB.minVertex.x + invQ.x * bp->m_bounds[0][p->upperBounds[0]].value; + b.maxVertex.y = bp->m_worldAABB.minVertex.y + invQ.y * bp->m_bounds[1][p->upperBounds[1]].value; + + glBegin(GL_LINE_LOOP); + glVertex2f(b.minVertex.x, b.minVertex.y); + glVertex2f(b.maxVertex.x, b.minVertex.y); + glVertex2f(b.maxVertex.x, b.maxVertex.y); + glVertex2f(b.minVertex.x, b.maxVertex.y); + glEnd(); + } + } + + if (settings->drawStats) + { + DrawString(5, m_textLine, "proxies(max) = %d(%d), pairs(max) = %d(%d)", + m_world->m_broadPhase->m_proxyCount, b2_maxProxies, + m_world->m_broadPhase->m_pairManager.m_pairCount, b2_maxPairs); + + m_textLine += 15; + + DrawString(5, m_textLine, "bodies/contacts/joints = %d/%d/%d", + m_world->m_bodyCount, m_world->m_contactCount, m_world->m_jointCount); + + m_textLine += 15; + } + + if (m_mouseJoint) + { + b2Body* body = m_mouseJoint->m_body2; + b2Vec2 p1 = body->m_position + b2Mul(body->m_R, m_mouseJoint->m_localAnchor); + b2Vec2 p2 = m_mouseJoint->m_target; + + glPointSize(4.0f); + glColor3f(0.0f, 1.0f, 0.0f); + glBegin(GL_POINTS); + glVertex2f(p1.x, p1.y); + glVertex2f(p2.x, p2.y); + glEnd(); + glPointSize(1.0f); + + glColor3f(0.8f, 0.8f, 0.8f); + glBegin(GL_LINES); + glVertex2f(p1.x, p1.y); + glVertex2f(p2.x, p2.y); + glEnd(); + } +*/ + +} diff --git a/Examples/TestBed/FrameWork/Test.h b/Examples/TestBed/FrameWork/Test.h new file mode 100644 index 000000000..2e24dcb6e --- /dev/null +++ b/Examples/TestBed/FrameWork/Test.h @@ -0,0 +1,89 @@ +/* +* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com +* +* This software is provided 'as-is', without any express or implied +* warranty. In no event will the authors be held liable for any damages +* arising from the use of this software. +* Permission is granted to anyone to use this software for any purpose, +* including commercial applications, and to alter it and redistribute it +* freely, subject to the following restrictions: +* 1. The origin of this software must not be misrepresented; you must not +* claim that you wrote the original software. If you use this software +* in a product, an acknowledgment in the product documentation would be +* appreciated but is not required. +* 2. Altered source versions must be plainly marked as such, and must not be +* misrepresented as being the original software. +* 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef TEST_H +#define TEST_H + + +class Test; +struct Settings; +#include + +typedef Test* TestCreateFcn(); + +struct Settings +{ + Settings() : + hz(60.0f), + iterationCount(10), + drawStats(0), + drawContacts(0), + drawImpulses(0), + drawAABBs(0), + drawPairs(0), + enableWarmStarting(1), + enablePositionCorrection(1), + pause(0) + {} + + float hz; + int iterationCount; + int drawStats; + int drawContacts; + int drawImpulses; + int drawAABBs; + int drawPairs; + int enableWarmStarting; + int enablePositionCorrection; + int pause; +}; + +struct TestEntry +{ + const char *name; + TestCreateFcn *createFcn; +}; + +extern TestEntry g_testEntries[]; + + +class Test +{ +public: + + Test(); + virtual ~Test(); + + void SetTextLine(int line) { m_textLine = line; } + virtual void Step(const Settings* settings); + virtual void Keyboard(unsigned char key) { +} +// void MouseDown(const b2Vec2& p); + void MouseUp(); +// void MouseMove(const b2Vec2& p); + void LaunchBomb(); + +protected: + + int m_textLine; +// b2World* m_world; +// b2Body* m_bomb; +// b2MouseJoint* m_mouseJoint; +}; + +#endif diff --git a/Examples/TestBed/Jamfile b/Examples/TestBed/Jamfile new file mode 100644 index 000000000..10caa1b50 --- /dev/null +++ b/Examples/TestBed/Jamfile @@ -0,0 +1,21 @@ +SubDir TOP Examples TestBed ; + +if $(GLUT.AVAILABLE) = "yes" +{ + # All demo apps have a lot in common, so use this rule to simply things + rule BulletDemo + { + Application $(<) : $(>) : noinstall console nomanifest ; + LinkWith $(<) : Tests bulletdynamics bulletcollision bulletmath glui ; + CFlags $(<) : + [ FIncludes $(TOP)/Extras ] + ; + MsvcIncDirs $(<) : + "../../Extras" + "../../src" ; + } +} + + +SubInclude TOP Examples TestBed FrameWork ; +SubInclude TOP Examples TestBed Tests ; diff --git a/Examples/TestBed/Tests/CollisionProcessing.h b/Examples/TestBed/Tests/CollisionProcessing.h new file mode 100644 index 000000000..10aaeefb9 --- /dev/null +++ b/Examples/TestBed/Tests/CollisionProcessing.h @@ -0,0 +1,20 @@ +#ifndef COLLISION_PROCESSING_H +#define COLLISION_PROCESSING_H + +#include "../FrameWork/Test.h" + +class CollisionProcessing : public Test +{ +public: +void Step(Settings* settings) +{ + +} +static Test* Create() +{ +return new CollisionProcessing; +} +}; + +#endif // + diff --git a/Examples/TestBed/Tests/Jamfile b/Examples/TestBed/Tests/Jamfile new file mode 100644 index 000000000..9857de618 --- /dev/null +++ b/Examples/TestBed/Tests/Jamfile @@ -0,0 +1,18 @@ +SubDir TOP Examples TestBed Tests ; + +if $(GLUT.AVAILABLE) = "yes" +{ + + + Description Tests : "Bullet Tests" ; + Library Tests : + [ Wildcard *.h *.cpp ] : noinstall +; + +CFlags Tests : +; + +LibDepends Tests : bulletdynamics ; + + ExternalLibs Tests : GLUT ; +} diff --git a/Examples/TestBed/Tests/TestEntries.cpp b/Examples/TestBed/Tests/TestEntries.cpp new file mode 100644 index 000000000..923028221 --- /dev/null +++ b/Examples/TestBed/Tests/TestEntries.cpp @@ -0,0 +1,10 @@ + + +#include "../FrameWork/Test.h" +#include "CollisionProcessing.h" + +TestEntry g_testEntries[] = +{ + {"Collision Processing", CollisionProcessing::Create} +}; + diff --git a/Extras/glui/Jamfile b/Extras/glui/Jamfile index 75a8564ec..43ceb3569 100644 --- a/Extras/glui/Jamfile +++ b/Extras/glui/Jamfile @@ -12,7 +12,7 @@ if $(GLUT.AVAILABLE) = "yes" CFlags glui : ; -LibDepends glui : ; +LibDepends glui : ; - ExternalLibs bulletopenglsupport : GLUT ; + ExternalLibs glui : GLUT ; } diff --git a/src/BulletCollision/CollisionShapes/btBoxShape.h b/src/BulletCollision/CollisionShapes/btBoxShape.h index dd6d9098b..98f1bd34b 100644 --- a/src/BulletCollision/CollisionShapes/btBoxShape.h +++ b/src/BulletCollision/CollisionShapes/btBoxShape.h @@ -20,7 +20,7 @@ subject to the following restrictions: #include "btCollisionMargin.h" #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" #include "LinearMath/btPoint3.h" -#include "LinearMath/btSimdMinMax.h" +#include "LinearMath/btMinMax.h" ///btBoxShape implements both a feature based (vertex/edge/plane) and implicit (getSupportingVertex) Box class btBoxShape: public btPolyhedralConvexShape diff --git a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp b/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp index bb3fe8325..158842850 100644 --- a/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp +++ b/src/BulletDynamics/ConstraintSolver/btContactConstraint.cpp @@ -192,8 +192,8 @@ btScalar resolveSingleFriction( j1 = -vrel * cpd->m_jacDiagABInvTangent0; btScalar oldTangentImpulse = cpd->m_accumulatedTangentImpulse0; cpd->m_accumulatedTangentImpulse0 = oldTangentImpulse + j1; - GEN_set_min(cpd->m_accumulatedTangentImpulse0, limit); - GEN_set_max(cpd->m_accumulatedTangentImpulse0, -limit); + btSetMin(cpd->m_accumulatedTangentImpulse0, limit); + btSetMax(cpd->m_accumulatedTangentImpulse0, -limit); j1 = cpd->m_accumulatedTangentImpulse0 - oldTangentImpulse; } @@ -206,8 +206,8 @@ btScalar resolveSingleFriction( j2 = -vrel * cpd->m_jacDiagABInvTangent1; btScalar oldTangentImpulse = cpd->m_accumulatedTangentImpulse1; cpd->m_accumulatedTangentImpulse1 = oldTangentImpulse + j2; - GEN_set_min(cpd->m_accumulatedTangentImpulse1, limit); - GEN_set_max(cpd->m_accumulatedTangentImpulse1, -limit); + btSetMin(cpd->m_accumulatedTangentImpulse1, limit); + btSetMax(cpd->m_accumulatedTangentImpulse1, -limit); j2 = cpd->m_accumulatedTangentImpulse1 - oldTangentImpulse; } @@ -270,8 +270,8 @@ btScalar resolveSingleFrictionOriginal( // calculate j that moves us to zero relative velocity btScalar j = -vrel * cpd->m_jacDiagABInvTangent0; btScalar total = cpd->m_accumulatedTangentImpulse0 + j; - GEN_set_min(total, limit); - GEN_set_max(total, -limit); + btSetMin(total, limit); + btSetMax(total, -limit); j = total - cpd->m_accumulatedTangentImpulse0; cpd->m_accumulatedTangentImpulse0 = total; body1.applyImpulse(j * cpd->m_frictionWorldTangential0, rel_pos1); @@ -290,8 +290,8 @@ btScalar resolveSingleFrictionOriginal( // calculate j that moves us to zero relative velocity btScalar j = -vrel * cpd->m_jacDiagABInvTangent1; btScalar total = cpd->m_accumulatedTangentImpulse1 + j; - GEN_set_min(total, limit); - GEN_set_max(total, -limit); + btSetMin(total, limit); + btSetMax(total, -limit); j = total - cpd->m_accumulatedTangentImpulse1; cpd->m_accumulatedTangentImpulse1 = total; body1.applyImpulse(j * cpd->m_frictionWorldTangential1, rel_pos1); @@ -388,8 +388,8 @@ btScalar resolveSingleCollisionCombined( (body1.getInvMass() + body2.getInvMass() + lat_vel.dot(temp1.cross(rel_pos1) + temp2.cross(rel_pos2))); btScalar normal_impulse = cpd->m_appliedImpulse * combinedFriction; - GEN_set_min(friction_impulse, normal_impulse); - GEN_set_max(friction_impulse, -normal_impulse); + btSetMin(friction_impulse, normal_impulse); + btSetMax(friction_impulse, -normal_impulse); body1.applyImpulse(lat_vel * -friction_impulse, rel_pos1); body2.applyImpulse(lat_vel * friction_impulse, rel_pos2); } diff --git a/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp b/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp index ec008ab0a..be3afaa41 100644 --- a/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp +++ b/src/BulletDynamics/Vehicle/btRaycastVehicle.cpp @@ -508,8 +508,8 @@ btScalar calcRollingFriction(btWheelContactPoint& contactPoint) // calculate j that moves us to zero relative velocity j1 = -vrel * contactPoint.m_jacDiagABInv; - GEN_set_min(j1, maxImpulse); - GEN_set_max(j1, -maxImpulse); + btSetMin(j1, maxImpulse); + btSetMax(j1, -maxImpulse); return j1; } diff --git a/src/LinearMath/btAabbUtil2.h b/src/LinearMath/btAabbUtil2.h index 429163c81..9b320961b 100644 --- a/src/LinearMath/btAabbUtil2.h +++ b/src/LinearMath/btAabbUtil2.h @@ -18,11 +18,9 @@ subject to the following restrictions: #define AABB_UTIL2 #include "btVector3.h" -#include "btSimdMinMax.h" +#include "btMinMax.h" -#define btMin(a,b) ((a < b ? a : b)) -#define btMax(a,b) ((a > b ? a : b)) /// conservative test for overlap between two aabbs diff --git a/src/LinearMath/btMinMax.h b/src/LinearMath/btMinMax.h index 1b8a3633f..5e27d62a4 100644 --- a/src/LinearMath/btMinMax.h +++ b/src/LinearMath/btMinMax.h @@ -18,15 +18,15 @@ subject to the following restrictions: #define GEN_MINMAX_H template -SIMD_FORCE_INLINE const T& GEN_min(const T& a, const T& b) +SIMD_FORCE_INLINE const T& btMin(const T& a, const T& b) { - return b < a ? b : a; + return a < b ? a : b ; } template -SIMD_FORCE_INLINE const T& GEN_max(const T& a, const T& b) +SIMD_FORCE_INLINE const T& btMax(const T& a, const T& b) { - return a < b ? b : a; + return a > b ? a : b; } template @@ -36,7 +36,7 @@ SIMD_FORCE_INLINE const T& GEN_clamped(const T& a, const T& lb, const T& ub) } template -SIMD_FORCE_INLINE void GEN_set_min(T& a, const T& b) +SIMD_FORCE_INLINE void btSetMin(T& a, const T& b) { if (b < a) { @@ -45,7 +45,7 @@ SIMD_FORCE_INLINE void GEN_set_min(T& a, const T& b) } template -SIMD_FORCE_INLINE void GEN_set_max(T& a, const T& b) +SIMD_FORCE_INLINE void btSetMax(T& a, const T& b) { if (a < b) { diff --git a/src/LinearMath/btQuadWord.h b/src/LinearMath/btQuadWord.h index f0eda5f6e..2e5950ebd 100644 --- a/src/LinearMath/btQuadWord.h +++ b/src/LinearMath/btQuadWord.h @@ -17,7 +17,7 @@ subject to the following restrictions: #define SIMD_QUADWORD_H #include "btScalar.h" -#include "btSimdMinMax.h" +#include "btMinMax.h" //ATTRIBUTE_ALIGNED16(class) btQuadWordStorage //some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. todo: look into this diff --git a/src/LinearMath/btSimdMinMax.h b/src/LinearMath/btSimdMinMax.h deleted file mode 100644 index a220aad54..000000000 --- a/src/LinearMath/btSimdMinMax.h +++ /dev/null @@ -1,76 +0,0 @@ -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/ - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - - - -#ifndef SIMD_MINMAX_H -#define SIMD_MINMAX_H -#include "btScalar.h" - -template -SIMD_FORCE_INLINE const T& btMin(const T& a, const T& b) { - return b < a ? b : a; -} - -template -SIMD_FORCE_INLINE const T& btMax(const T& a, const T& b) { - return a < b ? b : a; -} - -template -SIMD_FORCE_INLINE void btSetMin(T& a, const T& b) { - if (a > b) a = b; -} - -template -SIMD_FORCE_INLINE void btSetMax(T& a, const T& b) { - if (a < b) a = b; -} - -// Specialize on float/double for platforms that have btFsel natively -#ifdef BT_HAVE_NATIVE_FSEL -SIMD_FORCE_INLINE float btMin( float a, float b) { - return (float)btFsel((a-b), b, a); -} - -SIMD_FORCE_INLINE float btMax( float a, float b) { - return (float)btFsel((a-b), a, b); -} - -SIMD_FORCE_INLINE void btSetMin(float& a, float b) { - a = (float)btFsel((a-b), b, a); -} - -SIMD_FORCE_INLINE void btSetMax(float& a, float b) { - a = (float)btFsel((a-b), a, b); -} - -SIMD_FORCE_INLINE double btMin( double a, double b) { - return btFsel((a-b), b, a); -} - -SIMD_FORCE_INLINE double btMax( double a, double b) { - return btFsel((a-b), a, b); -} - -SIMD_FORCE_INLINE void btSetMin(double& a, double b) { - a = btFsel((a-b), b, a); -} - -SIMD_FORCE_INLINE void btSetMax(double& a, double b) { - a = btFsel((a-b), a, b); -} -#endif - -#endif