minor cleanup of btgui/demo3 stuff, much more demo cleanup is needed

moved some files in btgui/Bullet3AppSupport

btgui/Bullet3AppSupport/Bullet2RigidBodyDemo.cpp

@@ -0,0 +1,318 @@
+#include "Bullet2RigidBodyDemo.h"
+#include "btBulletDynamicsCommon.h"
+#include "OpenGLWindow/SimpleOpenGL3App.h"
+#include "BulletCollision/CollisionShapes/btShapeHull.h"//to create a tesselation of a generic btConvexShape
+#include "MyDebugDrawer.h"
+struct GraphicsVertex
+{
+	float pos[4];
+	float normal[3];
+	float texcoord[2];
+};
+
+
+struct MyGraphicsPhysicsBridge : public GraphicsPhysicsBridge
+{
+	SimpleOpenGL3App* m_glApp;
+	MyDebugDrawer* m_debugDraw;
+
+	MyGraphicsPhysicsBridge(SimpleOpenGL3App* glApp)
+		:m_glApp(glApp), m_debugDraw(0)
+	{
+	}
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color)
+	{
+	    createCollisionObjectGraphicsObject(body,color);
+	}
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* body, const btVector3& color)
+	{
+		btCollisionShape* shape = body->getCollisionShape();
+		btTransform startTransform = body->getWorldTransform();
+		int graphicsShapeId = shape->getUserIndex();
+		btAssert(graphicsShapeId >= 0);
+		btVector3 localScaling = shape->getLocalScaling();
+		int graphicsInstanceId = m_glApp->m_instancingRenderer->registerGraphicsInstance(graphicsShapeId, startTransform.getOrigin(), startTransform.getRotation(), color, localScaling);
+		body->setUserIndex(graphicsInstanceId);
+	}
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape)
+	{
+		//already has a graphics object?
+		if (collisionShape->getUserIndex()>=0)
+			return;
+
+		//todo: support all collision shape types
+		switch (collisionShape->getShapeType())
+		{
+		case BOX_SHAPE_PROXYTYPE:
+		{
+			btBoxShape* box = (btBoxShape*)collisionShape;
+			btVector3 halfExtents = box->getHalfExtentsWithMargin();
+			int cubeShapeId = m_glApp->registerCubeShape(halfExtents.x(), halfExtents.y(), halfExtents.z());
+			box->setUserIndex(cubeShapeId);
+			break;
+		}
+		case TRIANGLE_MESH_SHAPE_PROXYTYPE:
+		{
+
+			break;
+		}
+		default:
+		{
+			if (collisionShape->isConvex())
+			{
+				btConvexShape* convex = (btConvexShape*)collisionShape;
+				{
+					btShapeHull* hull = new btShapeHull(convex);
+					hull->buildHull(0.0);
+
+					{
+						//int strideInBytes = 9*sizeof(float);
+						//int numVertices = hull->numVertices();
+						//int numIndices =hull->numIndices();
+
+						btAlignedObjectArray<GraphicsVertex> gvertices;
+						btAlignedObjectArray<int> indices;
+
+						for (int t=0;t<hull->numTriangles();t++)
+						{
+
+							btVector3 triNormal;
+
+							int index0 = hull->getIndexPointer()[t*3+0];
+							int index1 = hull->getIndexPointer()[t*3+1];
+							int index2 = hull->getIndexPointer()[t*3+2];
+							btVector3 pos0 =hull->getVertexPointer()[index0];
+							btVector3 pos1 =hull->getVertexPointer()[index1];
+							btVector3 pos2 =hull->getVertexPointer()[index2];
+							triNormal = (pos1-pos0).cross(pos2-pos0);
+							triNormal.normalize();
+
+							for (int v=0;v<3;v++)
+							{
+								int index = hull->getIndexPointer()[t*3+v];
+								GraphicsVertex vtx;
+								btVector3 pos =hull->getVertexPointer()[index];
+								vtx.pos[0] = pos.x();
+								vtx.pos[1] = pos.y();
+								vtx.pos[2] = pos.z();
+								vtx.pos[3] = 0.f;
+
+								vtx.normal[0] =triNormal.x();
+								vtx.normal[1] =triNormal.y();
+								vtx.normal[2] =triNormal.z();
+
+								vtx.texcoord[0] = 0.5f;
+								vtx.texcoord[1] = 0.5f;
+
+								indices.push_back(gvertices.size());
+								gvertices.push_back(vtx);
+							}
+						}
+
+
+						int shapeId = m_glApp->m_instancingRenderer->registerShape(&gvertices[0].pos[0],gvertices.size(),&indices[0],indices.size());
+						convex->setUserIndex(shapeId);
+					}
+				}
+			} else
+			{
+				btAssert(0);
+			}
+		}
+		};
+	}
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld)
+	{
+		int numCollisionObjects = rbWorld->getNumCollisionObjects();
+		for (int i = 0; i<numCollisionObjects; i++)
+		{
+			btCollisionObject* colObj = rbWorld->getCollisionObjectArray()[i];
+			btVector3 pos = colObj->getWorldTransform().getOrigin();
+			btQuaternion orn = colObj->getWorldTransform().getRotation();
+			int index = colObj->getUserIndex();
+			if (index >= 0)
+			{
+				m_glApp->m_instancingRenderer->writeSingleInstanceTransformToCPU(pos, orn, index);
+			}
+		}
+		m_glApp->m_instancingRenderer->writeTransforms();
+	}
+
+	virtual void createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld)
+	{
+	    btAssert(rbWorld);
+        m_debugDraw = new MyDebugDrawer(m_glApp);
+        rbWorld->setDebugDrawer(m_debugDraw );
+
+
+        m_debugDraw->setDebugMode(
+            btIDebugDraw::DBG_DrawWireframe
+            +btIDebugDraw::DBG_DrawAabb
+            //btIDebugDraw::DBG_DrawContactPoints
+            );
+
+	}
+
+	virtual CommonParameterInterface* getParameterInterface()
+	{
+		return m_glApp->m_parameterInterface;
+	}
+
+	virtual void setUpAxis(int axis)
+	{
+		m_glApp->setUpAxis(axis);
+	}
+};
+
+Bullet2RigidBodyDemo::Bullet2RigidBodyDemo(SimpleOpenGL3App* app, CommonPhysicsSetup* physicsSetup)
+	:	m_physicsSetup(physicsSetup),
+	m_controlPressed(false),
+	m_altPressed(false),
+	m_glApp(app)
+{
+
+}
+void Bullet2RigidBodyDemo::initPhysics()
+{
+	MyGraphicsPhysicsBridge glBridge(m_glApp);
+	glBridge.setUpAxis(1);
+	m_physicsSetup->initPhysics(glBridge);
+	m_glApp->m_instancingRenderer->writeTransforms();
+
+}
+
+void Bullet2RigidBodyDemo::exitPhysics()
+{
+
+	m_physicsSetup->exitPhysics();
+
+}
+
+void	Bullet2RigidBodyDemo::stepSimulation(float deltaTime)
+{
+	m_physicsSetup->stepSimulation(deltaTime);
+
+}
+
+void Bullet2RigidBodyDemo::renderScene()
+{
+	//sync graphics -> physics world transforms
+
+	MyGraphicsPhysicsBridge glBridge(m_glApp);
+	m_physicsSetup->syncPhysicsToGraphics(glBridge);
+
+	m_glApp->m_instancingRenderer->renderScene();
+
+}
+
+void	Bullet2RigidBodyDemo::physicsDebugDraw()
+{
+    m_physicsSetup->debugDraw();
+}
+
+Bullet2RigidBodyDemo::~Bullet2RigidBodyDemo()
+{
+}
+
+btVector3	Bullet2RigidBodyDemo::getRayTo(int x,int y)
+{
+	if (!m_glApp->m_instancingRenderer)
+	{
+		btAssert(0);
+		return btVector3(0,0,0);
+	}
+
+	float top = 1.f;
+	float bottom = -1.f;
+	float nearPlane = 1.f;
+	float tanFov = (top-bottom)*0.5f / nearPlane;
+	float fov = b3Scalar(2.0) * b3Atan(tanFov);
+
+	btVector3 camPos,camTarget;
+	m_glApp->m_instancingRenderer->getCameraPosition(camPos);
+	m_glApp->m_instancingRenderer->getCameraTargetPosition(camTarget);
+
+	btVector3	rayFrom = camPos;
+	btVector3 rayForward = (camTarget-camPos);
+	rayForward.normalize();
+	float farPlane = 10000.f;
+	rayForward*= farPlane;
+
+	btVector3 rightOffset;
+	btVector3 cameraUp=btVector3(0,0,0);
+	cameraUp[m_glApp->getUpAxis()]=1;
+
+	btVector3 vertical = cameraUp;
+
+	btVector3 hor;
+	hor = rayForward.cross(vertical);
+	hor.normalize();
+	vertical = hor.cross(rayForward);
+	vertical.normalize();
+
+	float tanfov = tanf(0.5f*fov);
+
+
+	hor *= 2.f * farPlane * tanfov;
+	vertical *= 2.f * farPlane * tanfov;
+
+	b3Scalar aspect;
+	float width = m_glApp->m_instancingRenderer->getScreenWidth();
+	float height = m_glApp->m_instancingRenderer->getScreenHeight();
+
+	aspect =  width / height;
+
+	hor*=aspect;
+
+
+	btVector3 rayToCenter = rayFrom + rayForward;
+	btVector3 dHor = hor * 1.f/width;
+	btVector3 dVert = vertical * 1.f/height;
+
+
+	btVector3 rayTo = rayToCenter - 0.5f * hor + 0.5f * vertical;
+	rayTo += btScalar(x) * dHor;
+	rayTo -= btScalar(y) * dVert;
+	return rayTo;
+}
+
+
+bool	Bullet2RigidBodyDemo::mouseMoveCallback(float x,float y)
+{
+	btVector3 rayTo = getRayTo(x, y);
+	btVector3 rayFrom;
+	m_glApp->m_instancingRenderer->getCameraPosition(rayFrom);
+	m_physicsSetup->movePickedBody(rayFrom,rayTo);
+
+	return false;
+}
+
+bool	Bullet2RigidBodyDemo::mouseButtonCallback(int button, int state, float x, float y)
+{
+
+	if (state==1)
+	{
+		if(button==0 && (!m_altPressed && !m_controlPressed))
+		{
+			btVector3 camPos;
+			m_glApp->m_instancingRenderer->getCameraPosition(camPos);
+
+			btVector3 rayFrom = camPos;
+			btVector3 rayTo = getRayTo(x,y);
+
+			m_physicsSetup->pickBody(rayFrom, rayTo);
+
+
+		}
+	} else
+	{
+		if (button==0)
+		{
+			m_physicsSetup->removePickingConstraint();
+			//remove p2p
+		}
+	}
+
+	//printf("button=%d, state=%d\n",button,state);
+	return false;
+}

btgui/Bullet3AppSupport/Bullet2RigidBodyDemo.h

@@ -0,0 +1,55 @@
+#ifndef BULLET2_RIGIDBODY_DEMO_H
+#define BULLET2_RIGIDBODY_DEMO_H
+
+#include "LinearMath/btVector3.h"
+
+#include "BulletDemoInterface.h"
+#include "OpenGLWindow/b3gWindowInterface.h"
+#include "CommonPhysicsSetup.h"
+
+
+class Bullet2RigidBodyDemo : public BulletDemoInterface
+{
+	CommonPhysicsSetup* m_physicsSetup;
+
+public:
+
+    bool    m_controlPressed;
+    bool    m_altPressed;
+
+public:
+
+	struct SimpleOpenGL3App* m_glApp;
+
+	Bullet2RigidBodyDemo(SimpleOpenGL3App* app, CommonPhysicsSetup* physicsSetup);
+	virtual void initPhysics();
+	virtual void exitPhysics();
+	virtual void	renderScene();
+    virtual void	physicsDebugDraw();
+	virtual void	stepSimulation(float dt);
+	virtual CommonPhysicsSetup* getPhysicsSetup()
+	{
+		return m_physicsSetup;
+	}
+
+	virtual ~Bullet2RigidBodyDemo();
+	btVector3	getRayTo(int x,int y);
+	virtual bool	mouseMoveCallback(float x,float y);
+	virtual bool	mouseButtonCallback(int button, int state, float x, float y);
+	virtual bool	keyboardCallback(int key, int state)
+	{
+        if (key==B3G_CONTROL)
+        {
+            m_controlPressed = (state==1);
+        }
+        if (key==B3G_ALT)
+        {
+            m_altPressed = (state==1);
+        }
+		return false;
+	}
+
+
+};
+
+#endif //BULLET2_RIGIDBODY_DEMO_H

btgui/Bullet3AppSupport/BulletDemoInterface.h

@@ -0,0 +1,66 @@
+#ifndef DEMO_INTERFACE_H
+#define DEMO_INTERFACE_H
+
+struct SimpleOpenGL3App;
+
+class BulletDemoInterface
+{
+public:
+
+	typedef class BulletDemoInterface* (CreateFunc)(SimpleOpenGL3App* app);
+
+	virtual ~BulletDemoInterface()
+	{
+	}
+
+	virtual void    initPhysics()=0;
+	virtual void    exitPhysics()=0;
+	virtual void	stepSimulation(float deltaTime)=0;
+	virtual void	renderScene()=0;
+	virtual void	physicsDebugDraw()=0;
+	virtual bool	mouseMoveCallback(float x,float y)=0;
+	virtual bool	mouseButtonCallback(int button, int state, float x, float y)=0;
+	virtual bool	keyboardCallback(int key, int state)=0;
+
+};
+
+class EmptyBulletDemo : public BulletDemoInterface
+{
+public:
+	static BulletDemoInterface* MyCreateFunc(SimpleOpenGL3App* app)
+	{
+		return new EmptyBulletDemo();
+	}
+
+	virtual void    initPhysics()
+	{
+	}
+	virtual void    exitPhysics()
+	{
+	}
+	virtual void	stepSimulation(float deltaTime)
+	{
+	}
+	virtual void	renderScene()
+	{
+	}
+	virtual void	physicsDebugDraw()
+	{
+	}
+	virtual bool	mouseMoveCallback(float x,float y)
+	{
+		return false;
+	}
+	virtual bool	mouseButtonCallback(int button, int state, float x, float y)
+	{
+		return false;
+	}
+	virtual bool	keyboardCallback(int key, int state)
+	{
+		return false;
+	}
+};
+
+
+#endif //DEMO_INTERFACE_H
+

btgui/Bullet3AppSupport/CMakeLists.txt

@@ -0,0 +1,30 @@
+
+INCLUDE_DIRECTORIES(
+	${BULLET_PHYSICS_SOURCE_DIR}/src
+	${BULLET_PHYSICS_SOURCE_DIR}/btgui
+)
+
+FILE(GLOB Bullet3AppSupport_HDRS "*.h" )
+FILE(GLOB Bullet3AppSupport_SRCS "*.cpp" )
+
+IF (WIN32)
+	ADD_DEFINITIONS(-DGLEW_STATIC)
+ENDIF(WIN32)
+IF(NOT WIN32 AND NOT APPLE)
+        ADD_DEFINITIONS(-DGLEW_STATIC)
+	ADD_DEFINITIONS("-DGLEW_INIT_OPENGL11_FUNCTIONS=1")
+        ADD_DEFINITIONS("-DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1")
+ENDIF()
+
+ADD_LIBRARY(Bullet3AppSupport ${Bullet3AppSupport_SRCS} ${Bullet3AppSupport_HDRS})
+if (UNIX AND NOT APPLE)
+  target_link_libraries(Bullet3AppSupport X11)
+elseif (APPLE)
+  target_link_libraries(Bullet3AppSupport ${COCOA_LIBRARY})
+endif ()
+
+if (BUILD_SHARED_LIBS)
+  target_link_libraries(Bullet3AppSupport OpenGLWindow Bullet3Common)
+endif()
+
+target_link_libraries(Bullet3AppSupport ${OPENGL_gl_LIBRARY})

btgui/Bullet3AppSupport/CommonMultiBodySetup.h

@@ -0,0 +1,298 @@
+
+#ifndef COMMON_MULTI_BODY_SETUP_H
+#define COMMON_MULTI_BODY_SETUP_H
+
+//todo: replace this 'btBulletDynamicsCommon.h' header with specific used header files
+#include "btBulletDynamicsCommon.h"
+#include "CommonPhysicsSetup.h"
+#include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h"
+#include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h"
+#include "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h"
+#include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
+
+struct CommonMultiBodySetup : public CommonPhysicsSetup
+{
+		//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+	btBroadphaseInterface*	m_broadphase;
+	btCollisionDispatcher*	m_dispatcher;
+	btMultiBodyConstraintSolver*	m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btMultiBodyDynamicsWorld* m_dynamicsWorld;
+
+	//data for picking objects
+	class btRigidBody*	m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	class btMultiBodyPoint2Point*		m_pickingMultiBodyPoint2Point;
+
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+	bool m_prevCanSleep;
+
+	CommonMultiBodySetup()
+	:m_broadphase(0),
+		m_dispatcher(0),
+		m_solver(0),
+		m_collisionConfiguration(0),
+		m_dynamicsWorld(0),
+		m_pickedBody(0),
+		m_pickedConstraint(0),
+		m_pickingMultiBodyPoint2Point(0),
+		m_prevCanSleep(false)
+	{
+	}
+
+	virtual void createEmptyDynamicsWorld()
+	{
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);
+
+		m_broadphase = new btDbvtBroadphase();
+
+		m_solver = new btMultiBodyConstraintSolver;
+
+		m_dynamicsWorld = new btMultiBodyDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration);
+
+		m_dynamicsWorld->setGravity(btVector3(0, -10, 0));
+	}
+
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+
+		if (m_dynamicsWorld)
+		{
+
+            int i;
+            for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+            {
+                m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+            }
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j<m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+
+		delete m_solver;
+
+		delete m_broadphase;
+
+		delete m_dispatcher;
+
+		delete m_collisionConfiguration;
+	}
+
+	virtual void syncPhysicsToGraphics(GraphicsPhysicsBridge& gfxBridge)
+	{
+		if (m_dynamicsWorld)
+		{
+			gfxBridge.syncPhysicsToGraphics(m_dynamicsWorld);
+		}
+	}
+
+    virtual void    debugDraw()
+    {
+     	if (m_dynamicsWorld)
+        {
+            m_dynamicsWorld->debugDrawWorld();
+        }
+
+    }
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld==0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			} else
+			{
+				btMultiBodyLinkCollider* multiCol = (btMultiBodyLinkCollider*)btMultiBodyLinkCollider::upcast(rayCallback.m_collisionObject);
+				if (multiCol && multiCol->m_multiBody)
+				{
+						
+					m_prevCanSleep = multiCol->m_multiBody->getCanSleep();
+					multiCol->m_multiBody->setCanSleep(false);
+
+					btVector3 pivotInA = multiCol->m_multiBody->worldPosToLocal(multiCol->m_link, pickPos);
+
+					btMultiBodyPoint2Point* p2p = new btMultiBodyPoint2Point(multiCol->m_multiBody,multiCol->m_link,0,pivotInA,pickPos);
+					//if you add too much energy to the system, causing high angular velocities, simulation 'explodes'
+					//see also http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=4&t=949
+					//so we try to avoid it by clamping the maximum impulse (force) that the mouse pick can apply
+					//it is not satisfying, hopefully we find a better solution (higher order integrator, using joint friction using a zero-velocity target motor with limited force etc?)
+					btScalar scaling=1;
+					p2p->setMaxAppliedImpulse(2*scaling);
+		
+					btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*) m_dynamicsWorld;
+					world->addMultiBodyConstraint(p2p);
+					m_pickingMultiBodyPoint2Point =p2p; 
+				}
+			}
+
+
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody  && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+		
+				btVector3 dir = rayToWorld-rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				btVector3 newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+			}
+		}
+		
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			//keep it at the same picking distance
+
+		
+			btVector3 dir = rayToWorld-rayFromWorld;
+			dir.normalize();
+			dir *= m_oldPickingDist;
+
+			btVector3 newPivotB = rayFromWorld + dir;
+			
+			m_pickingMultiBodyPoint2Point->setPivotInB(newPivotB);
+		}
+		
+		return false;
+	}
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+		if (m_pickingMultiBodyPoint2Point)
+		{
+			m_pickingMultiBodyPoint2Point->getMultiBodyA()->setCanSleep(m_prevCanSleep);
+			btMultiBodyDynamicsWorld* world = (btMultiBodyDynamicsWorld*) m_dynamicsWorld;
+			world->removeMultiBodyConstraint(m_pickingMultiBodyPoint2Point);
+			delete m_pickingMultiBodyPoint2Point;
+			m_pickingMultiBodyPoint2Point = 0;
+		}
+	}
+
+
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	btRigidBody*	createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape,  const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif//
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+};
+
+#endif //COMMON_MULTI_BODY_SETUP_H
+

btgui/Bullet3AppSupport/CommonParameterInterface.h

@@ -0,0 +1,43 @@
+
+#ifndef PARAM_INTERFACE_H
+#define PARAM_INTERFACE_H
+
+#pragma once
+
+typedef void (*SliderParamChangedCallback) (float newVal);
+#include "LinearMath/btScalar.h"
+
+struct SliderParams
+{
+	const char* m_name;
+	float m_minVal;
+	float m_maxVal;
+	SliderParamChangedCallback m_callback;
+	btScalar* m_paramValuePointer;
+	void* m_userPointer;
+	bool m_clampToNotches;
+
+	SliderParams(const char* name, btScalar* targetValuePointer)
+	:m_name(name),
+	m_minVal(-100),
+	m_maxVal(100),
+	m_callback(0),
+	m_paramValuePointer(targetValuePointer),
+	m_userPointer(0),
+	m_clampToNotches(false)
+	{
+	}
+
+};
+
+
+struct CommonParameterInterface
+{
+	virtual void registerSliderFloatParameter(SliderParams& params)=0;
+	virtual void syncParameters()=0;
+	virtual void removeAllParameters()=0;
+    virtual void setSliderValue(int sliderIndex, double sliderValue)=0;
+
+};
+	
+#endif //PARAM_INTERFACE_H

btgui/Bullet3AppSupport/CommonPhysicsSetup.h

@@ -0,0 +1,77 @@
+
+#ifndef COMMON_PHYSICS_SETUP_H
+#define COMMON_PHYSICS_SETUP_H
+
+class btRigidBody;
+class btCollisionObject;
+class btBoxShape;
+class btTransform;
+class btCollisionShape;
+#include "LinearMath/btVector3.h"
+#include "CommonParameterInterface.h"
+
+class btDiscreteDynamicsWorld;
+
+///The GraphicsPhysicsBridge let's the graphics engine create graphics representation and synchronize
+struct GraphicsPhysicsBridge
+{
+
+	virtual void createRigidBodyGraphicsObject(btRigidBody* body,const btVector3& color)
+	{
+	}
+
+	virtual void createCollisionObjectGraphicsObject(btCollisionObject* obj,const btVector3& color)
+	{
+	}
+	virtual void createCollisionShapeGraphicsObject(btCollisionShape* collisionShape)
+	{
+	}
+	virtual void syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld)
+	{
+	}
+	virtual void createPhysicsDebugDrawer( btDiscreteDynamicsWorld* rbWorld)
+	{
+	}
+
+	virtual CommonParameterInterface* getParameterInterface()
+	{
+		return 0;
+	}
+
+	virtual void setUpAxis(int axis)
+	{
+	}
+
+};
+
+struct CommonPhysicsSetup
+{
+public:
+
+	virtual ~CommonPhysicsSetup() {}
+
+	virtual void initPhysics(GraphicsPhysicsBridge& gfxBridge) = 0;
+
+	virtual void exitPhysics()=0;
+
+	virtual void stepSimulation(float deltaTime)=0;
+
+    virtual void    debugDraw()=0;
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld) = 0;
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)=0;
+	virtual void removePickingConstraint() = 0;
+
+	virtual void syncPhysicsToGraphics(GraphicsPhysicsBridge& gfxBridge) = 0;
+/*
+	virtual btRigidBody*	createRigidBody(float mass, const btTransform& startTransform,btCollisionShape* shape, const btVector4& color=btVector4(1,0,0,1))=0;
+
+	virtual btBoxShape* createBoxShape(const btVector3& halfExtents)=0;
+ */
+};
+
+
+
+#endif //COMMON_PHYSICS_SETUP_H
+
+

btgui/Bullet3AppSupport/CommonRigidBodySetup.h

@@ -0,0 +1,247 @@
+
+#ifndef COMMON_RIGID_BODY_SETUP_H
+#define COMMON_RIGID_BODY_SETUP_H
+
+//todo: replace this 'btBulletDynamicsCommon.h' header with specific used header files
+#include "btBulletDynamicsCommon.h"
+#include "CommonPhysicsSetup.h"
+
+struct CommonRigidBodySetup : public CommonPhysicsSetup
+{
+		//keep the collision shapes, for deletion/cleanup
+	btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
+	btBroadphaseInterface*	m_broadphase;
+	btCollisionDispatcher*	m_dispatcher;
+	btConstraintSolver*	m_solver;
+	btDefaultCollisionConfiguration* m_collisionConfiguration;
+	btDiscreteDynamicsWorld* m_dynamicsWorld;
+
+	//data for picking objects
+	class btRigidBody*	m_pickedBody;
+	class btTypedConstraint* m_pickedConstraint;
+	btVector3 m_oldPickingPos;
+	btVector3 m_hitPos;
+	btScalar m_oldPickingDist;
+
+	CommonRigidBodySetup()
+	:m_broadphase(0),
+		m_dispatcher(0),
+		m_solver(0),
+		m_collisionConfiguration(0),
+		m_dynamicsWorld(0),
+		m_pickedBody(0),
+		m_pickedConstraint(0)
+	{
+	}
+
+	virtual void createEmptyDynamicsWorld()
+	{
+		///collision configuration contains default setup for memory, collision setup
+		m_collisionConfiguration = new btDefaultCollisionConfiguration();
+		//m_collisionConfiguration->setConvexConvexMultipointIterations();
+
+		///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
+		m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);
+
+		m_broadphase = new btDbvtBroadphase();
+
+		///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
+		btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
+		m_solver = sol;
+
+		m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration);
+
+		m_dynamicsWorld->setGravity(btVector3(0, -10, 0));
+	}
+
+
+	virtual void stepSimulation(float deltaTime)
+	{
+		if (m_dynamicsWorld)
+		{
+			m_dynamicsWorld->stepSimulation(deltaTime);
+		}
+	}
+
+
+	virtual void exitPhysics()
+	{
+		removePickingConstraint();
+		//cleanup in the reverse order of creation/initialization
+
+		//remove the rigidbodies from the dynamics world and delete them
+		
+		if (m_dynamicsWorld)
+		{
+
+            int i;
+            for (i = m_dynamicsWorld->getNumConstraints() - 1; i >= 0; i--)
+            {
+                m_dynamicsWorld->removeConstraint(m_dynamicsWorld->getConstraint(i));
+            }
+			for (i = m_dynamicsWorld->getNumCollisionObjects() - 1; i >= 0; i--)
+			{
+				btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
+				btRigidBody* body = btRigidBody::upcast(obj);
+				if (body && body->getMotionState())
+				{
+					delete body->getMotionState();
+				}
+				m_dynamicsWorld->removeCollisionObject(obj);
+				delete obj;
+			}
+		}
+		//delete collision shapes
+		for (int j = 0; j<m_collisionShapes.size(); j++)
+		{
+			btCollisionShape* shape = m_collisionShapes[j];
+			delete shape;
+		}
+		m_collisionShapes.clear();
+
+		delete m_dynamicsWorld;
+
+		delete m_solver;
+
+		delete m_broadphase;
+
+		delete m_dispatcher;
+
+		delete m_collisionConfiguration;
+	}
+
+	virtual void syncPhysicsToGraphics(GraphicsPhysicsBridge& gfxBridge)
+	{
+		if (m_dynamicsWorld)
+		{
+			gfxBridge.syncPhysicsToGraphics(m_dynamicsWorld);
+		}
+	}
+
+    virtual void    debugDraw()
+    {
+     	if (m_dynamicsWorld)
+        {
+            m_dynamicsWorld->debugDrawWorld();
+        }
+
+    }
+
+	virtual bool pickBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_dynamicsWorld==0)
+			return false;
+
+		btCollisionWorld::ClosestRayResultCallback rayCallback(rayFromWorld, rayToWorld);
+
+		m_dynamicsWorld->rayTest(rayFromWorld, rayToWorld, rayCallback);
+		if (rayCallback.hasHit())
+		{
+
+			btVector3 pickPos = rayCallback.m_hitPointWorld;
+			btRigidBody* body = (btRigidBody*)btRigidBody::upcast(rayCallback.m_collisionObject);
+			if (body)
+			{
+				//other exclusions?
+				if (!(body->isStaticObject() || body->isKinematicObject()))
+				{
+					m_pickedBody = body;
+					m_pickedBody->setActivationState(DISABLE_DEACTIVATION);
+					//printf("pickPos=%f,%f,%f\n",pickPos.getX(),pickPos.getY(),pickPos.getZ());
+					btVector3 localPivot = body->getCenterOfMassTransform().inverse() * pickPos;
+					btPoint2PointConstraint* p2p = new btPoint2PointConstraint(*body, localPivot);
+					m_dynamicsWorld->addConstraint(p2p, true);
+					m_pickedConstraint = p2p;
+					btScalar mousePickClamping = 30.f;
+					p2p->m_setting.m_impulseClamp = mousePickClamping;
+					//very weak constraint for picking
+					p2p->m_setting.m_tau = 0.001f;
+				}
+			}
+
+
+			//					pickObject(pickPos, rayCallback.m_collisionObject);
+			m_oldPickingPos = rayToWorld;
+			m_hitPos = pickPos;
+			m_oldPickingDist = (pickPos - rayFromWorld).length();
+			//					printf("hit !\n");
+			//add p2p
+		}
+		return false;
+	}
+	virtual bool movePickedBody(const btVector3& rayFromWorld, const btVector3& rayToWorld)
+	{
+		if (m_pickedBody  && m_pickedConstraint)
+		{
+			btPoint2PointConstraint* pickCon = static_cast<btPoint2PointConstraint*>(m_pickedConstraint);
+			if (pickCon)
+			{
+				//keep it at the same picking distance
+
+				btVector3 newPivotB;
+
+				btVector3 dir = rayToWorld - rayFromWorld;
+				dir.normalize();
+				dir *= m_oldPickingDist;
+
+				newPivotB = rayFromWorld + dir;
+				pickCon->setPivotB(newPivotB);
+				return true;
+			}
+		}
+		return false;
+	}
+	virtual void removePickingConstraint()
+	{
+		if (m_pickedConstraint)
+		{
+			m_dynamicsWorld->removeConstraint(m_pickedConstraint);
+			delete m_pickedConstraint;
+			m_pickedConstraint = 0;
+			m_pickedBody = 0;
+		}
+	}
+
+
+
+	btBoxShape* createBoxShape(const btVector3& halfExtents)
+	{
+		btBoxShape* box = new btBoxShape(halfExtents);
+		return box;
+	}
+
+	btRigidBody*	createRigidBody(float mass, const btTransform& startTransform, btCollisionShape* shape,  const btVector4& color = btVector4(1, 0, 0, 1))
+	{
+		btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
+
+		//rigidbody is dynamic if and only if mass is non zero, otherwise static
+		bool isDynamic = (mass != 0.f);
+
+		btVector3 localInertia(0, 0, 0);
+		if (isDynamic)
+			shape->calculateLocalInertia(mass, localInertia);
+
+		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
+
+#define USE_MOTIONSTATE 1
+#ifdef USE_MOTIONSTATE
+		btDefaultMotionState* myMotionState = new btDefaultMotionState(startTransform);
+
+		btRigidBody::btRigidBodyConstructionInfo cInfo(mass, myMotionState, shape, localInertia);
+
+		btRigidBody* body = new btRigidBody(cInfo);
+		//body->setContactProcessingThreshold(m_defaultContactProcessingThreshold);
+
+#else
+		btRigidBody* body = new btRigidBody(mass, 0, shape, localInertia);
+		body->setWorldTransform(startTransform);
+#endif//
+
+		body->setUserIndex(-1);
+		m_dynamicsWorld->addRigidBody(body);
+		return body;
+	}
+};
+
+#endif //COMMON_RIGID_BODY_SETUP_H
+

btgui/Bullet3AppSupport/GraphingTexture.cpp

@@ -0,0 +1,189 @@
+#include "GraphingTexture.h"
+#include "OpenGLWindow/OpenGLInclude.h"
+#include <assert.h>
+
+GraphingTexture::GraphingTexture()
+:m_textureId(0),
+m_width(0),
+m_height(0)
+{
+}
+
+GraphingTexture::~GraphingTexture()
+{
+	destroy();
+}
+
+void GraphingTexture::destroy()
+{
+	//TODO(erwincoumans) release memory etc...
+	m_width = 0;
+	m_height=0;
+	glDeleteTextures(1,(GLuint*)&m_textureId);
+	m_textureId=0;
+}
+
+bool GraphingTexture::create(int texWidth, int texHeight)
+{
+	m_width = texWidth;
+	m_height = texHeight;
+	glActiveTexture(GL_TEXTURE0);
+	
+	m_imageData.resize(texWidth*texHeight*4);
+	for(int y=0;y<texHeight;++y)
+	{
+		//					const int	t=y>>5;
+		GLubyte*	pi=&m_imageData[y*texWidth*4];
+		for(int x=0;x<texWidth;++x)
+		{
+			if (x>=y)//x<2||y<2||x>253||y>253)
+			{
+				pi[0]=0;
+				pi[1]=0;
+				pi[2]=255;
+				pi[3]=255;
+			} else
+			{
+				pi[0]=255;
+				pi[1]=0;
+				pi[2]=0;
+				pi[3]=255;
+			}
+			
+			pi+=4;
+		}
+	}
+	
+	
+	glGenTextures(1,(GLuint*)&m_textureId);
+	
+	uploadImageData();
+	return true;
+}
+
+void GraphingTexture::uploadImageData()
+{
+	glBindTexture(GL_TEXTURE_2D,m_textureId);
+	assert(glGetError()==GL_NO_ERROR);
+	
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width,m_height,0,GL_RGBA,GL_UNSIGNED_BYTE,&m_imageData[0]);
+	glGenerateMipmap(GL_TEXTURE_2D);
+	
+	assert(glGetError()==GL_NO_ERROR);
+	
+	
+}
+
+#if 0
+//shift the image one pixel
+for(int y=0;y<texHeight;++y)
+{
+	//					const int	t=y>>5;
+	for(int x=1;x<texWidth;++x)
+	{
+		GLubyte*	org=image+(x+y*texWidth)*4;
+		
+		GLubyte*	dst=image+(x-1+y*texWidth)*4;
+		
+		dst[0] = org[0];
+		dst[1] = org[1];
+		dst[2] = org[2];
+		dst[3] = org[3];
+	}
+}
+//render a new row at the right
+for(int y=0;y<texHeight;++y)
+{
+	GLubyte*	pi=image+(texWidth-1+y*texWidth)*4;
+	pi[0]=255;
+	pi[1]=255;
+	pi[2]=255;
+	pi[3]=255;
+	if (y==texHeight*0.5)
+	{
+		pi[0]=200;
+		pi[1]=200;
+		pi[2]=200;
+		pi[3]=255;
+	}
+	
+}
+
+{
+	static float timer = 0.f;
+	static int prevValue=0;
+	timer+= 0.01;
+	float value = 128+100*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 0;
+	org[2] = 0;
+	org[3] = 255;
+	
+	if (prevValue<value)
+	{
+		
+	} else
+	{
+		
+	}
+	
+}
+
+{
+	static float timer = 1.4f;
+	timer+= 0.04;
+	float value = 128+150*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 255;
+	org[2] = 0;
+	org[3] = 255;
+}
+
+{
+	static float timer = 1.4f;
+	timer+= 0.02;
+	float value =256+400*sinf(timer);
+	MyClamp(value,0.f,float(texHeight-1));
+	static int prevValue = 0;
+	
+	GLubyte*	org=image+(texWidth-1+(int)value*texWidth)*4;
+	org[0] = 0;
+	org[1] = 0;
+	org[2] = 255;
+	org[3] = 255;
+	
+	if (prevValue<value)
+	{
+		for (int i=prevValue;i<value;i++)
+		{
+			GLubyte*	org=image+(texHeight-1+(int)i*texWidth)*4;
+			org[0] = 0;
+			org[1] = 0;
+			org[2] = 255;
+			org[3] = 255;
+		}
+	} else
+	{
+		for (int i=value;i<prevValue;i++)
+		{
+			GLubyte*	org=image+(texHeight-1+(int)i*texWidth)*4;
+			org[0] = 0;
+			org[1] = 0;
+			org[2] = 255;
+			org[3] = 255;
+		}
+	}
+	prevValue = value;
+}
+
+
+glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texWidth,texHeight,0,GL_RGBA,GL_UNSIGNED_BYTE,image);
+glGenerateMipmap(GL_TEXTURE_2D);
+
+#endif
+

btgui/Bullet3AppSupport/GraphingTexture.h

@@ -0,0 +1,36 @@
+#ifndef GRAPHING_TEXTURE_H
+#define GRAPHING_TEXTURE_H
+#include "LinearMath/btAlignedObjectArray.h"
+
+struct GraphingTexture
+{
+	int m_textureId;
+	//assume rgba (8 bit per component, total of 32bit per pixel, for m_width*m_height pixels)
+	btAlignedObjectArray<unsigned char> m_imageData;
+	int m_width;
+	int m_height;
+	
+	GraphingTexture();
+	virtual ~GraphingTexture();
+	
+	bool create(int texWidth, int texHeight);
+	void  destroy();
+	
+	void setPixel(int x, int y, unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha)
+	{
+		m_imageData[x*4+y*4*m_width+0] = red;
+		m_imageData[x*4+y*4*m_width+1] = green;
+		m_imageData[x*4+y*4*m_width+2] = blue;
+		m_imageData[x*4+y*4*m_width+3] = alpha;
+	}
+	
+	void uploadImageData();
+	
+	int getTextureId()
+	{
+		return m_textureId;
+	}
+};
+
+#endif //GRAPHING_TEXTURE_H
+

btgui/Bullet3AppSupport/GwenParameterInterface.cpp

@@ -0,0 +1,161 @@
+#include "GwenParameterInterface.h"
+#include "gwenInternalData.h"
+
+
+
+template<typename T>
+struct MySliderEventHandler : public Gwen::Event::Handler
+{
+	Gwen::Controls::TextBox* m_label;
+	Gwen::Controls::Slider* m_pSlider;
+	char m_variableName[1024];
+	T* m_targetValue;
+
+	MySliderEventHandler(const char* varName, Gwen::Controls::TextBox* label, Gwen::Controls::Slider* pSlider,T* target)
+		:m_label(label),
+		m_pSlider(pSlider),
+		m_targetValue(target)
+	{
+		memcpy(m_variableName,varName,strlen(varName)+1);
+	}
+
+
+	void SliderMoved( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)pControl;
+		//printf("value = %f\n", pSlider->GetValue());//UnitPrint( Utility::Format( L"Slider Value: %.2f", pSlider->GetValue() ) );
+		float bla = pSlider->GetValue();
+		T v = T(bla);
+		SetValue(v);
+
+	}
+
+	void	SetValue(T v)
+	{
+		if (v < m_pSlider->GetRangeMin())
+		{
+			printf("?\n");
+		}
+
+		if (v > m_pSlider->GetRangeMax())
+		{
+						printf("?\n");
+
+		}
+		m_pSlider->SetValue(v,true);
+		(*m_targetValue) = v;
+		float val = float(v);//todo: specialize on template type
+		char txt[1024];
+		sprintf(txt,"%s : %.3f", m_variableName,val);
+		m_label->SetText(txt);
+
+	}
+};
+
+
+struct  GwenParameters
+{
+	b3AlignedObjectArray<MySliderEventHandler<btScalar>*> m_sliderEventHandlers;
+	b3AlignedObjectArray<Gwen::Controls::HorizontalSlider*> m_sliders;
+	b3AlignedObjectArray<Gwen::Controls::TextBox*> m_textLabels;
+	int m_savedYposition;
+};
+
+GwenParameterInterface::GwenParameterInterface(GwenInternalData* gwenInternalData)
+:m_gwenInternalData(gwenInternalData)
+{
+	m_paramInternalData = new GwenParameters;
+	m_paramInternalData->m_savedYposition = m_gwenInternalData->m_curYposition;
+
+}
+
+GwenParameterInterface::~GwenParameterInterface()
+{
+
+	removeAllParameters();
+	delete m_paramInternalData;
+}
+
+
+void GwenParameterInterface::setSliderValue(int sliderIndex, double sliderValue)
+{
+    int sliderCapped = sliderValue+4;
+    sliderCapped /= 8;
+    sliderCapped *= 8;
+    
+    if (sliderIndex>=0 && sliderIndex<m_paramInternalData->m_sliders.size())
+    {
+        m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin();
+        
+        m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax();
+        float mappedValue =m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin()+
+        (m_paramInternalData->m_sliders[sliderIndex]->GetRangeMax()-
+         m_paramInternalData->m_sliders[sliderIndex]->GetRangeMin())*sliderCapped/128.f;
+        printf("mappedValue = %f\n",mappedValue);
+        m_paramInternalData->m_sliders[sliderIndex]->SetValue(mappedValue);
+    }
+}
+
+#include <stdio.h>
+void GwenParameterInterface::registerSliderFloatParameter(SliderParams& params)
+{
+	Gwen::Controls::TextBox* label = new Gwen::Controls::TextBox(m_gwenInternalData->m_demoPage->GetPage());
+	m_paramInternalData->m_textLabels.push_back(label);
+	//m_data->m_myControls.push_back(label);
+	label->SetText( params.m_name);
+	label->SetPos( 10, 10 + 25 );
+	label->SetWidth(110);
+	label->SetPos(10,m_gwenInternalData->m_curYposition);
+	m_gwenInternalData->m_curYposition+=22;
+
+	Gwen::Controls::HorizontalSlider* pSlider = new Gwen::Controls::HorizontalSlider( m_gwenInternalData->m_demoPage->GetPage());
+	m_paramInternalData->m_sliders.push_back(pSlider);
+	//m_data->m_myControls.push_back(pSlider);
+	pSlider->SetPos( 10, m_gwenInternalData->m_curYposition );
+	pSlider->SetSize( 100, 20 );
+	pSlider->SetRange( params.m_minVal, params.m_maxVal);
+	pSlider->SetNotchCount(128);//float(params.m_maxVal-params.m_minVal)/100.f);
+	pSlider->SetClampToNotches( params.m_clampToNotches );
+	pSlider->SetValue( *params.m_paramValuePointer);//dimensions[i] );
+	char labelName[1024];
+	sprintf(labelName,"%s",params.m_name);//axisNames[0]);
+	MySliderEventHandler<btScalar>* handler = new MySliderEventHandler<btScalar>(labelName,label,pSlider,params.m_paramValuePointer);
+	m_paramInternalData->m_sliderEventHandlers.push_back(handler);
+
+	pSlider->onValueChanged.Add( handler, &MySliderEventHandler<btScalar>::SliderMoved );
+	handler->SliderMoved(pSlider);
+//	float v = pSlider->GetValue();
+	m_gwenInternalData->m_curYposition+=22;
+}
+
+void GwenParameterInterface::syncParameters()
+{
+	for (int i=0;i<m_paramInternalData->m_sliderEventHandlers.size();i++)
+	{
+		MySliderEventHandler<btScalar>* handler = m_paramInternalData->m_sliderEventHandlers[i];
+		handler->m_pSlider->SetValue(*handler->m_targetValue,true);
+	}
+}
+
+void GwenParameterInterface::removeAllParameters()
+{
+	for (int i=0;i<m_paramInternalData->m_sliders.size();i++)
+	{
+		delete m_paramInternalData->m_sliders[i];
+	}
+	m_paramInternalData->m_sliders.clear();
+
+	for (int i=0;i<m_paramInternalData->m_sliderEventHandlers.size();i++)
+	{
+		delete m_paramInternalData->m_sliderEventHandlers[i];
+	}
+	m_paramInternalData->m_sliderEventHandlers.clear();
+	
+	for (int i=0;i<m_paramInternalData->m_textLabels.size();i++)
+	{
+		delete m_paramInternalData->m_textLabels[i];
+	}
+	m_paramInternalData->m_textLabels.clear();
+	
+	m_gwenInternalData->m_curYposition = this->m_paramInternalData->m_savedYposition;
+}

btgui/Bullet3AppSupport/GwenParameterInterface.h

@@ -0,0 +1,21 @@
+#ifndef GWEN_PARAMETER_INTERFACE_H
+#define GWEN_PARAMETER_INTERFACE_H
+
+#include "CommonParameterInterface.h"
+
+struct GwenParameterInterface : public CommonParameterInterface
+{
+	struct GwenInternalData* m_gwenInternalData;
+
+	struct GwenParameters*	m_paramInternalData;
+
+	GwenParameterInterface(struct GwenInternalData* gwenInternalData);
+	virtual ~GwenParameterInterface();
+	virtual void registerSliderFloatParameter(SliderParams& params);
+    virtual void setSliderValue(int sliderIndex, double sliderValue);
+	virtual void syncParameters();
+	virtual void removeAllParameters();
+
+};
+
+#endif//GWEN_PARAMETER_INTERFACE_H

btgui/Bullet3AppSupport/GwenProfileWindow.cpp

@@ -0,0 +1,292 @@
+#include "GwenProfileWindow.h"
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "LinearMath/btQuickprof.h"
+
+
+
+
+
+class MyProfileWindow : public Gwen::Controls::WindowControl
+{
+	
+	//		Gwen::Controls::TabControl*	m_TabControl;
+	//Gwen::Controls::ListBox*	m_TextOutput;
+	unsigned int				m_iFrames;
+	float						m_fLastSecond;
+	
+	Gwen::Controls::TreeNode* m_node;
+	Gwen::Controls::TreeControl* m_ctrl;
+	
+	
+protected:
+	
+	void onButtonA( Gwen::Controls::Base* pControl )
+	{
+        //		OpenTissue::glut::toggleIdle();
+	}
+	
+	void SliderMoved(Gwen::Controls::Base* pControl )
+	{
+	//	Gwen::Controls::Slider* pSlider = (Gwen::Controls::Slider*)pControl;
+		//this->m_app->scaleYoungModulus(pSlider->GetValue());
+		//	printf("Slider Value: %.2f", pSlider->GetValue() );
+	}
+	
+	
+	void	OnCheckChangedStiffnessWarping (Gwen::Controls::Base* pControl)
+	{
+	//	Gwen::Controls::CheckBox* labeled = (Gwen::Controls::CheckBox* )pControl;
+//		bool checked = labeled->IsChecked();
+		//m_app->m_stiffness_warp_on  = checked;
+	}
+public:
+	
+  
+	CProfileIterator* profIter;
+	
+	MyProfileWindow (	Gwen::Controls::Base* pParent)
+    : Gwen::Controls::WindowControl( pParent ),
+	profIter(0)
+	{
+		SetTitle( L"Time Profiler" );
+		
+		SetSize( 450, 450 );
+		this->SetPos(10,400);
+		
+        //		this->Dock( Gwen::Pos::Bottom);
+		
+		
+		
+		{
+			m_ctrl = new Gwen::Controls::TreeControl( this );
+			m_node = m_ctrl->AddNode( L"Total Parent Time" );
+			
+			
+			//Gwen::Controls::TreeNode* pNode = ctrl->AddNode( L"Node Two" );
+			//pNode->AddNode( L"Node Two Inside" );
+			//pNode->AddNode( L"Eyes" );
+			//pNode->AddNode( L"Brown" )->AddNode( L"Node Two Inside" )->AddNode( L"Eyes" )->AddNode( L"Brown" );
+			//Gwen::Controls::TreeNode* node = ctrl->AddNode( L"Node Three" );
+			
+			
+			
+			//m_ctrl->Dock(Gwen::Pos::Bottom);
+			
+			m_ctrl->ExpandAll();
+            m_ctrl->SetKeyboardInputEnabled(true);
+			m_ctrl->SetBounds( this->GetInnerBounds().x,this->GetInnerBounds().y,this->GetInnerBounds().w,this->GetInnerBounds().h);
+			
+		}
+		
+		
+		
+	}
+	
+	
+	float	dumpRecursive(CProfileIterator* profileIterator, Gwen::Controls::TreeNode* parentNode)
+	{
+		profileIterator->First();
+		if (profileIterator->Is_Done())
+			return 0.f;
+		
+		float accumulated_time=0,parent_time = profileIterator->Is_Root() ? CProfileManager::Get_Time_Since_Reset() : profileIterator->Get_Current_Parent_Total_Time();
+		int i;
+		int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset();
+		
+		//printf("Profiling: %s (total running time: %.3f ms) ---\n",	profileIterator->Get_Current_Parent_Name(), parent_time );
+		float totalTime = 0.f;
+		
+		
+		int numChildren = 0;
+		Gwen::UnicodeString txt;
+		std::vector<Gwen::Controls::TreeNode*> nodes;
+		
+		for (i = 0; !profileIterator->Is_Done(); i++,profileIterator->Next())
+		{
+			numChildren++;
+			float current_total_time = profileIterator->Get_Current_Total_Time();
+			accumulated_time += current_total_time;
+			double fraction = parent_time > SIMD_EPSILON ? (current_total_time / parent_time) * 100 : 0.f;
+			
+			Gwen::String name(profileIterator->Get_Current_Name());
+#ifdef _WIN32
+			Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
+			
+			txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",uname.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
+			
+#else
+			txt = Gwen::Utility::Format(L"%s (%.2f %%) :: %.3f ms / frame (%d calls)",name.c_str(), fraction,(current_total_time / (double)frames_since_reset),profileIterator->Get_Current_Total_Calls());
+			
+#endif
+			
+			Gwen::Controls::TreeNode* childNode = (Gwen::Controls::TreeNode*)profileIterator->Get_Current_UserPointer();
+			if (!childNode)
+			{
+                childNode = parentNode->AddNode(L"");
+                profileIterator->Set_Current_UserPointer(childNode);
+			}
+			childNode->SetText(txt);
+			nodes.push_back(childNode);
+			
+			totalTime += current_total_time;
+			//recurse into children
+		}
+		
+		for (i=0;i<numChildren;i++)
+		{
+			profileIterator->Enter_Child(i);
+			Gwen::Controls::TreeNode* curNode = nodes[i];
+			
+			dumpRecursive(profileIterator, curNode);
+			
+			profileIterator->Enter_Parent();
+		}
+		return accumulated_time;
+		
+	}
+	
+	void	UpdateText(CProfileIterator*  profileIterator, bool idle)
+	{
+		
+	//	static bool update=true;
+		
+        m_ctrl->SetBounds(0,0,this->GetInnerBounds().w,this->GetInnerBounds().h);
+		
+        //		if (!update)
+        //			return;
+	//	update=false;
+		
+		
+		static int test = 1;
+		test++;
+		
+		static double time_since_reset = 0.f;
+		if (!idle)
+		{
+			time_since_reset = CProfileManager::Get_Time_Since_Reset();
+		}
+		
+		//Gwen::UnicodeString txt = Gwen::Utility::Format( L"FEM Settings  %i fps", test );
+		{
+            //recompute profiling data, and store profile strings
+			
+         //   char blockTime[128];
+			
+           // double totalTime = 0;
+			
+          //  int frames_since_reset = CProfileManager::Get_Frame_Count_Since_Reset();
+			
+            profileIterator->First();
+			
+            double parent_time = profileIterator->Is_Root() ? time_since_reset : profileIterator->Get_Current_Parent_Total_Time();
+			
+			
+         //   Gwen::Controls::TreeNode* curParent = m_node;
+			
+            double accumulated_time = dumpRecursive(profileIterator,m_node);
+			
+            const char* name = profileIterator->Get_Current_Parent_Name();
+#ifdef _WIN32
+            Gwen::UnicodeString uname = Gwen::Utility::StringToUnicode(name);
+            Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", uname.c_str(), parent_time ,
+                                                            parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
+#else
+            Gwen::UnicodeString txt = Gwen::Utility::Format( L"Profiling: %s total time: %.3f ms, unaccounted %.3f %% :: %.3f ms", name, parent_time ,
+                                                            parent_time > SIMD_EPSILON ? ((parent_time - accumulated_time) / parent_time) * 100 : 0.f, parent_time - accumulated_time);
+#endif
+            //sprintf(blockTime,"--- Profiling: %s (total running time: %.3f ms) ---",	profileIterator->Get_Current_Parent_Name(), parent_time );
+            //displayProfileString(xOffset,yStart,blockTime);
+            m_node->SetText(txt);
+			
+			
+			//printf("%s (%.3f %%) :: %.3f ms\n", "Unaccounted:",);
+			
+			
+		}
+		
+		static int counter=10;
+		if (counter)
+		{
+            counter--;
+			m_ctrl->ExpandAll();
+		}
+		
+	}
+	void PrintText( const Gwen::UnicodeString& str )
+	{
+		
+	}
+	
+	void Render( Gwen::Skin::Base* skin )
+	{
+		m_iFrames++;
+		
+		if ( m_fLastSecond < Gwen::Platform::GetTimeInSeconds() )
+		{
+			SetTitle( Gwen::Utility::Format( L"Profiler  %i fps", m_iFrames ) );
+			
+			m_fLastSecond = Gwen::Platform::GetTimeInSeconds() + 1.0f;
+			m_iFrames = 0;
+		}
+		
+		Gwen::Controls::WindowControl::Render( skin );
+		
+	}
+	
+	
+};
+
+class MyMenuItems :  public Gwen::Controls::Base
+{
+	
+public:
+	
+	class MyProfileWindow* m_profWindow;
+    MyMenuItems() :Gwen::Controls::Base(0)
+    {
+    }
+   
+    void MenuItemSelect(Gwen::Controls::Base* pControl)
+    {
+		if (m_profWindow->Hidden())
+		{
+			m_profWindow->SetHidden(false);
+		} else
+		{
+			m_profWindow->SetHidden(true);
+		}
+		
+    }
+};
+
+
+MyProfileWindow* setupProfileWindow(GwenInternalData* data)
+{
+	MyMenuItems* menuItems = new MyMenuItems;
+	MyProfileWindow* profWindow = new MyProfileWindow(data->pCanvas);
+	//profWindow->SetHidden(true);	
+	profWindow->profIter = CProfileManager::Get_Iterator();
+	data->m_viewMenu->GetMenu()->AddItem( L"Profiler", menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::MenuItemSelect);
+	menuItems->m_profWindow = profWindow;
+	return profWindow;
+}
+
+
+void	processProfileData( MyProfileWindow* profWindow, bool idle)
+{
+	if (profWindow)
+	{
+		
+		profWindow->UpdateText(profWindow->profIter, idle);
+	}	
+}
+
+void profileWindowSetVisible(MyProfileWindow* window, bool visible)
+{
+	window->SetHidden(!visible);
+}
+void destroyProfileWindow(MyProfileWindow* window)
+{
+	delete window;
+}

btgui/Bullet3AppSupport/GwenProfileWindow.h

@@ -0,0 +1,11 @@
+#ifndef GWEN_PROFILE_WINDOW_H
+#define GWEN_PROFILE_WINDOW_H
+
+class MyProfileWindow* setupProfileWindow(struct GwenInternalData* data);
+void processProfileData(MyProfileWindow* window, bool idle);
+void profileWindowSetVisible(MyProfileWindow* window, bool visible);
+void destroyProfileWindow(MyProfileWindow* window);
+
+#endif//GWEN_PROFILE_WINDOW_H
+
+

btgui/Bullet3AppSupport/GwenTextureWindow.cpp

@@ -0,0 +1,100 @@
+#include "GwenTextureWindow.h"
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "Gwen/Controls/ImagePanel.h"
+
+
+
+class MyGraphWindow : public Gwen::Controls::WindowControl
+{
+	Gwen::Controls::ImagePanel* m_imgPanel;
+
+public:
+	
+	class MyMenuItems2* m_menuItems;
+	
+	MyGraphWindow (	const MyGraphInput& input)
+    : Gwen::Controls::WindowControl( input.m_data->pCanvas ),
+	m_menuItems(0)
+	{
+		Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
+		SetTitle( str );
+
+
+		SetPos(input.m_xPos,input.m_yPos);
+		SetSize( 12+input.m_width+2*input.m_borderWidth, 30+input.m_height+2*input.m_borderWidth );
+		
+		m_imgPanel = new Gwen::Controls::ImagePanel( this );
+		if (input.m_texName)
+		{
+			Gwen::UnicodeString texName = Gwen::Utility::StringToUnicode(input.m_texName);
+			m_imgPanel->SetImage( texName );
+		}
+		m_imgPanel->SetBounds( input.m_borderWidth, input.m_borderWidth, 
+							  input.m_width, 
+							  input.m_height );
+        //		this->Dock( Gwen::Pos::Bottom);
+	}
+	virtual ~MyGraphWindow()
+	{
+		delete m_imgPanel;
+	}
+
+
+};
+
+class MyMenuItems2 :  public Gwen::Controls::Base
+{
+	MyGraphWindow* m_graphWindow;
+	
+public:
+	
+	Gwen::Controls::MenuItem* m_item;
+	
+    MyMenuItems2(MyGraphWindow* graphWindow) 
+	:Gwen::Controls::Base(0),
+	m_graphWindow(graphWindow),
+	m_item(0)
+    {
+    }
+	
+    void MenuItemSelect(Gwen::Controls::Base* pControl)
+    {
+		if (m_graphWindow->Hidden())
+		{
+			m_graphWindow->SetHidden(false);
+			//@TODO(erwincoumans) setCheck/SetCheckable drawing is broken, need to see what's wrong
+//			if (m_item)
+//				m_item->SetCheck(false);
+			
+		} else
+		{
+			m_graphWindow->SetHidden(true);
+//			if (m_item)
+//				m_item->SetCheck(true);
+			
+		}
+		
+    }
+};
+
+MyGraphWindow* setupTextureWindow(const MyGraphInput& input)
+{
+	MyGraphWindow* graphWindow = new MyGraphWindow(input);
+	MyMenuItems2* menuItems = new MyMenuItems2(graphWindow);
+	graphWindow->m_menuItems = menuItems;
+	
+	Gwen::UnicodeString str = Gwen::Utility::StringToUnicode(input.m_name);
+	menuItems->m_item = input.m_data->m_viewMenu->GetMenu()->AddItem( str, menuItems,(Gwen::Event::Handler::Function)&MyMenuItems2::MenuItemSelect);
+//	menuItems->m_item->SetCheckable(true);
+
+	return graphWindow;
+	
+}
+
+void destroyTextureWindow(MyGraphWindow* window)
+{
+	delete window->m_menuItems->m_item;
+	delete window->m_menuItems;
+	delete window;
+}

btgui/Bullet3AppSupport/GwenTextureWindow.h

@@ -0,0 +1,32 @@
+
+
+#ifndef GWEN_TEXTURE_WINDOW_H
+#define GWEN_TEXTURE_WINDOW_H
+
+struct MyGraphInput
+{
+	struct GwenInternalData* m_data;
+	int m_xPos;
+	int m_yPos;
+	int m_width;
+	int m_height;
+	int m_borderWidth;
+	const char* m_name;
+	const char* m_texName;
+	MyGraphInput(struct GwenInternalData* data)
+	:m_data(data),
+	m_xPos(0),
+	m_yPos(0),
+	m_width(400),
+	m_height(400),
+	m_borderWidth(0),
+	m_name("GraphWindow"),
+	m_texName(0)
+	{
+	}
+};
+class MyGraphWindow* setupTextureWindow(const MyGraphInput& input);
+void destroyTextureWindow(MyGraphWindow* window);
+
+
+#endif //GWEN_TEXTURE_WINDOW_H

btgui/Bullet3AppSupport/MyDebugDrawer.h

@@ -0,0 +1,107 @@
+#ifndef MY_DEBUG_DRAWER_H
+#define MY_DEBUG_DRAWER_H
+
+#include "LinearMath/btIDebugDraw.h"
+#include "LinearMath/btAlignedObjectArray.h"
+#define BT_LINE_BATCH_SIZE 512
+
+struct MyDebugVec3
+{
+	MyDebugVec3(const btVector3& org)
+	:x(org.x()),
+	y(org.y()),
+	z(org.z())
+	{
+	}
+
+	float x;
+	float y;
+	float z;
+};
+class MyDebugDrawer : public btIDebugDraw
+{
+	SimpleOpenGL3App* m_glApp;
+	int m_debugMode;
+
+    btAlignedObjectArray<MyDebugVec3> m_linePoints;
+    btAlignedObjectArray<unsigned int> m_lineIndices;
+    btVector3 m_currentLineColor;
+
+public:
+
+	MyDebugDrawer(SimpleOpenGL3App* app)
+		: m_glApp(app)
+		,m_debugMode(btIDebugDraw::DBG_DrawWireframe|btIDebugDraw::DBG_DrawAabb),
+		m_currentLineColor(-1,-1,-1)
+	{
+
+	}
+	virtual void	drawLine(const btVector3& from1,const btVector3& to1,const btVector3& color1)
+	{
+        //float from[4] = {from1[0],from1[1],from1[2],from1[3]};
+        //float to[4] = {to1[0],to1[1],to1[2],to1[3]};
+        //float color[4] = {color1[0],color1[1],color1[2],color1[3]};
+		//m_glApp->m_instancingRenderer->drawLine(from,to,color);
+		if (m_currentLineColor!=color1 || m_linePoints.size() >= BT_LINE_BATCH_SIZE)
+        {
+            flushLines();
+            m_currentLineColor = color1;
+        }
+		MyDebugVec3 from(from1);
+		MyDebugVec3 to(to1);
+			
+		m_linePoints.push_back(from);
+		m_linePoints.push_back(to);
+
+		m_lineIndices.push_back(m_lineIndices.size());
+		m_lineIndices.push_back(m_lineIndices.size());
+
+	}
+
+	virtual void	drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color)
+	{
+        drawLine(PointOnB,PointOnB+normalOnB,color);
+	}
+     
+
+	virtual void	reportErrorWarning(const char* warningString)
+	{
+	}
+
+	virtual void	draw3dText(const btVector3& location,const char* textString)
+	{
+	}
+
+	virtual void	setDebugMode(int debugMode)
+	{
+		m_debugMode = debugMode;
+	}
+
+	virtual int		getDebugMode() const
+	{
+		return m_debugMode;
+	}
+
+    virtual void flushLines()
+	{
+	    int sz = m_linePoints.size();
+	    if (sz)
+        {
+	    float debugColor[4];
+	debugColor[0] = m_currentLineColor.x();
+	debugColor[1] = m_currentLineColor.y();
+	debugColor[2] = m_currentLineColor.z();
+	debugColor[3] = 1.f;
+            m_glApp->m_instancingRenderer->drawLines(&m_linePoints[0].x,debugColor,
+                                                     m_linePoints.size(),sizeof(MyDebugVec3),
+                                                     &m_lineIndices[0],
+                                                     m_lineIndices.size(),
+                                                     1);
+            m_linePoints.clear();
+            m_lineIndices.clear();
+        }
+	}
+
+};
+
+#endif //MY_DEBUG_DRAWER_H

btgui/Bullet3AppSupport/gwenInternalData.h

@@ -0,0 +1,56 @@
+#ifndef GWEN_INTERNAL_DATA_H
+#define GWEN_INTERNAL_DATA_H
+
+#include "OpenGLWindow/GwenOpenGL3CoreRenderer.h"
+#include "OpenGLWindow/GLPrimitiveRenderer.h"
+#include "Gwen/Platform.h"
+#include "Gwen/Controls/TreeControl.h"
+#include "Gwen/Controls/RadioButtonController.h"
+#include "Gwen/Controls/VerticalSlider.h"
+#include "Gwen/Controls/HorizontalSlider.h"
+#include "Gwen/Controls/GroupBox.h"
+#include "Gwen/Controls/CheckBox.h"
+#include "Gwen/Controls/StatusBar.h"
+#include "Gwen/Controls/Button.h"
+#include "Gwen/Controls/ComboBox.h"
+#include "Gwen/Controls/MenuStrip.h"
+#include "Gwen/Controls/Slider.h"
+#include "Gwen/Controls/Property/Text.h"
+#include "Gwen/Controls/SplitterBar.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Gwen/Gwen.h"
+#include "Gwen/Align.h"
+#include "Gwen/Utility.h"
+#include "Gwen/Controls/WindowControl.h"
+#include "Gwen/Controls/TabControl.h"
+#include "Gwen/Controls/ListBox.h"
+#include "Gwen/Skins/Simple.h"
+//#include "Gwen/Skins/TexturedBase.h"
+#include "gwenUserInterface.h"
+
+
+struct GwenInternalData
+{
+	struct sth_stash;
+	class GwenOpenGL3CoreRenderer*	pRenderer;
+	Gwen::Skin::Simple				skin;
+	Gwen::Controls::Canvas*			pCanvas;
+	GLPrimitiveRenderer* m_primRenderer;
+	Gwen::Controls::TabButton*		m_demoPage;
+	Gwen::Controls::TabButton*		m_explorerPage;
+	Gwen::Controls::TreeControl*	m_explorerTreeCtrl;
+	Gwen::Controls::MenuItem*		m_viewMenu;
+    class MyMenuItems*                    m_menuItems;
+
+	int		m_curYposition;
+
+	Gwen::Controls::Label* m_rightStatusBar;
+	Gwen::Controls::Label* m_leftStatusBar;
+	b3AlignedObjectArray<class Gwen::Event::Handler*>	m_handlers;
+	b3ToggleButtonCallback			m_toggleButtonCallback;
+	b3ComboBoxCallback				m_comboBoxCallback;
+	
+
+};
+
+#endif//GWEN_INTERNAL_DATA_H

btgui/Bullet3AppSupport/gwenUserInterface.cpp

@@ -0,0 +1,446 @@
+
+#include "gwenUserInterface.h"
+#include "gwenInternalData.h"
+#include "Gwen/Controls/ImagePanel.h"
+
+class MyGraphWindow* graphWindow = 0;
+
+
+
+GwenUserInterface::GwenUserInterface()
+{
+	m_data = new GwenInternalData();
+	m_data->m_toggleButtonCallback = 0;
+	m_data->m_comboBoxCallback = 0;
+
+}
+
+GwenUserInterface::~GwenUserInterface()
+{
+	for (int i=0;i<m_data->m_handlers.size();i++)
+	{
+		delete m_data->m_handlers[i];
+	}
+
+	m_data->m_handlers.clear();
+
+
+	delete m_data->pCanvas;
+
+	GLPrimitiveRenderer* prim = m_data->m_primRenderer;
+	GwenOpenGL3CoreRenderer* coreRend = m_data->pRenderer;
+
+	delete m_data;
+
+	delete prim;
+	delete coreRend;
+
+}
+
+
+
+
+class MyMenuItems :  public Gwen::Controls::Base
+{
+public:
+
+    b3FileOpenCallback m_fileOpenCallback;
+    
+    MyMenuItems() :Gwen::Controls::Base(0),m_fileOpenCallback(0)
+    {
+    }
+    void myQuitApp( Gwen::Controls::Base* pControl )
+    {
+        exit(0);
+    }
+    void fileOpen( Gwen::Controls::Base* pControl )
+    {
+        if (m_fileOpenCallback)
+        {
+            (*m_fileOpenCallback)();
+        }
+    }
+    
+};
+
+struct MyTestMenuBar : public Gwen::Controls::MenuStrip
+{
+
+	Gwen::Controls::MenuItem* m_fileMenu;
+	Gwen::Controls::MenuItem* m_viewMenu;
+    MyMenuItems*                m_menuItems;
+
+	MyTestMenuBar(Gwen::Controls::Base* pParent)
+		:Gwen::Controls::MenuStrip(pParent)
+	{
+//		Gwen::Controls::MenuStrip* menu = new Gwen::Controls::MenuStrip( pParent );
+		{
+			m_menuItems = new MyMenuItems();
+            m_menuItems->m_fileOpenCallback = 0;
+
+			m_fileMenu = AddItem( L"File" );
+			
+            m_fileMenu->GetMenu()->AddItem(L"Open",m_menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::fileOpen);
+            m_fileMenu->GetMenu()->AddItem(L"Quit",m_menuItems,(Gwen::Event::Handler::Function)&MyMenuItems::myQuitApp);
+            m_viewMenu = AddItem( L"View" );
+			
+		}
+	}
+
+};
+
+void	GwenUserInterface::resize(int width, int height)
+{
+	m_data->pCanvas->SetSize(width,height);
+}
+
+
+struct MyComboBoxHander   :public Gwen::Event::Handler
+{
+	GwenInternalData*	m_data;
+	int					m_buttonId;
+
+	MyComboBoxHander  (GwenInternalData* data, int buttonId)
+		:m_data(data),
+		m_buttonId(buttonId)
+	{
+	}
+
+	void onSelect( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::ComboBox* but = (Gwen::Controls::ComboBox*) pControl;
+
+
+
+		Gwen::String str = Gwen::Utility::UnicodeToString(	but->GetSelectedItem()->GetText());
+
+		if (m_data->m_comboBoxCallback)
+			(*m_data->m_comboBoxCallback)(m_buttonId,str.c_str());
+	}
+
+};
+
+struct MyButtonHander   :public Gwen::Event::Handler
+{
+	GwenInternalData*	m_data;
+	int					m_buttonId;
+
+	MyButtonHander  (GwenInternalData* data, int buttonId)
+		:m_data(data),
+		m_buttonId(buttonId)
+	{
+	}
+
+	void onButtonA( Gwen::Controls::Base* pControl )
+	{
+		Gwen::Controls::Button* but = (Gwen::Controls::Button*) pControl;
+//		int dep = but->IsDepressed();
+		int tog = but->GetToggleState();
+		if (m_data->m_toggleButtonCallback)
+			(*m_data->m_toggleButtonCallback)(m_buttonId,tog);
+	}
+
+};
+
+
+void	GwenUserInterface::setStatusBarMessage(const char* message, bool isLeft)
+{
+	Gwen::UnicodeString msg = Gwen::Utility::StringToUnicode(message);
+	if (isLeft)
+	{
+		m_data->m_leftStatusBar->SetText( msg);
+	} else
+	{
+		m_data->m_rightStatusBar->SetText( msg);
+
+	}
+}
+
+void GwenUserInterface::registerFileOpenCallback(b3FileOpenCallback callback)
+{
+    m_data->m_menuItems->m_fileOpenCallback = callback;
+}
+
+void	GwenUserInterface::init(int width, int height,struct sth_stash* stash,float retinaScale)
+{
+	m_data->m_curYposition = 20;
+	m_data->m_primRenderer = new GLPrimitiveRenderer(width,height);
+	m_data->pRenderer = new GwenOpenGL3CoreRenderer(m_data->m_primRenderer,stash,width,height,retinaScale);
+
+	m_data->skin.SetRender( m_data->pRenderer );
+
+	m_data->pCanvas= new Gwen::Controls::Canvas( &m_data->skin );
+	m_data->pCanvas->SetSize( width,height);
+	m_data->pCanvas->SetDrawBackground( false);
+	m_data->pCanvas->SetBackgroundColor( Gwen::Color( 150, 170, 170, 255 ) );
+
+	MyTestMenuBar* menubar = new MyTestMenuBar(m_data->pCanvas);
+	m_data->m_viewMenu = menubar->m_viewMenu;
+    m_data->m_menuItems = menubar->m_menuItems;
+    
+    
+    
+	Gwen::Controls::StatusBar* bar = new Gwen::Controls::StatusBar(m_data->pCanvas);
+	m_data->m_rightStatusBar = new Gwen::Controls::Label( bar );
+	m_data->m_rightStatusBar->SetWidth(width/2);
+	//m_data->m_rightStatusBar->SetText( L"Label Added to Right" );
+	bar->AddControl( m_data->m_rightStatusBar, true );
+
+	m_data->m_leftStatusBar = new Gwen::Controls::Label( bar );
+	//m_data->m_leftStatusBar->SetText( L"Label Added to Left" );
+	m_data->m_leftStatusBar->SetWidth(width/2);
+	bar->AddControl( m_data->m_leftStatusBar,false);
+	//Gwen::KeyboardFocus
+	/*Gwen::Controls::GroupBox* box = new Gwen::Controls::GroupBox(m_data->pCanvas);
+	box->SetText("text");
+	box->SetName("name");
+	box->SetHeight(500);
+	*/
+	Gwen::Controls::ScrollControl* windowRight= new Gwen::Controls::ScrollControl(m_data->pCanvas);
+	windowRight->Dock(Gwen::Pos::Right);
+	windowRight->SetWidth(150);
+	windowRight->SetHeight(250);
+	windowRight->SetScroll(false,true);
+
+
+
+	//windowLeft->SetSkin(
+	Gwen::Controls::TabControl* tab = new Gwen::Controls::TabControl(windowRight);
+
+	//tab->SetHeight(300);
+	tab->SetWidth(140);
+	tab->SetHeight(250);
+	//tab->Dock(Gwen::Pos::Left);
+	tab->Dock( Gwen::Pos::Fill );
+	//tab->SetMargin( Gwen::Margin( 2, 2, 2, 2 ) );
+
+	Gwen::UnicodeString str1(L"Params");
+	m_data->m_demoPage = tab->AddPage(str1);
+
+
+
+
+//	Gwen::UnicodeString str2(L"OpenCL");
+//	tab->AddPage(str2);
+	//Gwen::UnicodeString str3(L"page3");
+//	tab->AddPage(str3);
+
+
+
+	//but->onPress.Add(handler, &MyHander::onButtonA);
+
+
+
+	//box->Dock(Gwen::Pos::Left);
+
+	/*Gwen::Controls::WindowControl* windowBottom = new Gwen::Controls::WindowControl(m_data->pCanvas);
+	windowBottom->SetHeight(100);
+	windowBottom->Dock(Gwen::Pos::Bottom);
+	windowBottom->SetTitle("bottom");
+	*/
+//	Gwen::Controls::Property::Text* prop = new Gwen::Controls::Property::Text(m_data->pCanvas);
+	//prop->Dock(Gwen::Pos::Bottom);
+	/*Gwen::Controls::SplitterBar* split = new Gwen::Controls::SplitterBar(m_data->pCanvas);
+	split->Dock(Gwen::Pos::Center);
+	split->SetHeight(300);
+	split->SetWidth(300);
+	*/
+	/*
+
+
+	*/
+
+	Gwen::Controls::ScrollControl* windowLeft = new Gwen::Controls::ScrollControl(m_data->pCanvas);
+	windowLeft->Dock(Gwen::Pos::Left);
+	//	windowLeft->SetTitle("title");
+	windowLeft->SetScroll(false, false);
+	windowLeft->SetWidth(250);
+	windowLeft->SetPos(50, 50);
+	windowLeft->SetHeight(500);
+	//windowLeft->SetClosable(false);
+	//	windowLeft->SetShouldDrawBackground(true);
+	windowLeft->SetTabable(true);
+
+	Gwen::Controls::TabControl* explorerTab = new Gwen::Controls::TabControl(windowLeft);
+
+	//tab->SetHeight(300);
+//	explorerTab->SetWidth(230);
+	explorerTab->SetHeight(250);
+	//tab->Dock(Gwen::Pos::Left);
+	explorerTab->Dock(Gwen::Pos::Fill);
+
+	Gwen::UnicodeString explorerStr1(L"Explorer");
+	m_data->m_explorerPage = explorerTab->AddPage(explorerStr1);
+	Gwen::UnicodeString shapesStr1(L"Shapes");
+	explorerTab->AddPage(shapesStr1);
+	Gwen::UnicodeString testStr1(L"Test");
+	explorerTab->AddPage(testStr1);
+
+	Gwen::Controls::TreeControl* ctrl = new Gwen::Controls::TreeControl(m_data->m_explorerPage->GetPage());
+	m_data->m_explorerTreeCtrl = ctrl;
+	ctrl->SetKeyboardInputEnabled(true);
+	ctrl->Focus();
+	ctrl->SetBounds(2, 10, 236, 400);
+
+   
+}
+
+b3ToggleButtonCallback	GwenUserInterface::getToggleButtonCallback()
+{
+	return m_data->m_toggleButtonCallback;
+}
+
+void	GwenUserInterface::setToggleButtonCallback(b3ToggleButtonCallback callback)
+{
+	m_data->m_toggleButtonCallback = callback;
+}
+void	GwenUserInterface::registerToggleButton(int buttonId, const char* name)
+{
+	assert(m_data);
+	assert(m_data->m_demoPage);
+
+	Gwen::Controls::Button* but = new Gwen::Controls::Button(m_data->m_demoPage->GetPage());
+
+	///some heuristic to find the button location
+	int ypos = m_data->m_curYposition;
+	but->SetPos(10, ypos );
+	but->SetWidth( 100 );
+	//but->SetBounds( 200, 30, 300, 200 );
+
+	MyButtonHander* handler = new MyButtonHander(m_data, buttonId);
+	m_data->m_handlers.push_back(handler);
+	m_data->m_curYposition+=22;
+	but->onToggle.Add(handler, &MyButtonHander::onButtonA);
+	but->SetIsToggle(true);
+	but->SetToggleState(false);
+	but->SetText(name);
+
+}
+
+void	GwenUserInterface::setComboBoxCallback(b3ComboBoxCallback callback)
+{
+	m_data->m_comboBoxCallback = callback;
+}
+
+b3ComboBoxCallback GwenUserInterface::getComboBoxCallback()
+{
+	return m_data->m_comboBoxCallback;
+}
+void	GwenUserInterface::registerComboBox(int comboboxId, int numItems, const char** items, int startItem)
+{
+	Gwen::Controls::ComboBox* combobox = new Gwen::Controls::ComboBox(m_data->m_demoPage->GetPage());
+	MyComboBoxHander* handler = new MyComboBoxHander(m_data, comboboxId);
+	m_data->m_handlers.push_back(handler);
+
+	combobox->onSelection.Add(handler,&MyComboBoxHander::onSelect);
+	int ypos = m_data->m_curYposition;
+	combobox->SetPos(10, ypos );
+	combobox->SetWidth( 100 );
+	//box->SetPos(120,130);
+	for (int i=0;i<numItems;i++)
+	{
+		Gwen::Controls::MenuItem* item = combobox->AddItem(Gwen::Utility::StringToUnicode(items[i]));
+		if (i==startItem)
+			combobox->OnItemSelected(item);
+	}
+
+	m_data->m_curYposition+=22;
+
+
+
+}
+
+void	GwenUserInterface::draw(int width, int height)
+{
+
+//	printf("width = %d, height=%d\n", width,height);
+	if (m_data->pCanvas)
+	{
+		m_data->pCanvas->SetSize(width,height);
+		m_data->m_primRenderer->setScreenSize(width,height);
+		m_data->pRenderer->Resize(width,height);
+		m_data->pCanvas->RenderCanvas();
+		//restoreOpenGLState();
+	}
+
+}
+
+bool	GwenUserInterface::mouseMoveCallback( float x, float y)
+{
+	bool handled  = false;
+
+	static int m_lastmousepos[2] = {0,0};
+	static bool isInitialized = false;
+	if (m_data->pCanvas)
+	{
+		if (!isInitialized)
+		{
+			isInitialized = true;
+			m_lastmousepos[0] = x+1;
+			m_lastmousepos[1] = y+1;
+		}
+		handled = m_data->pCanvas->InputMouseMoved(x,y,m_lastmousepos[0],m_lastmousepos[1]);
+	}
+	return handled;
+
+}
+#include "OpenGLWindow/b3gWindowInterface.h"
+
+bool	GwenUserInterface::keyboardCallback(int bulletKey, int state)
+{
+	int key = -1;
+	if (m_data->pCanvas)
+	{
+		//convert 'Bullet' keys into 'Gwen' keys
+		switch (bulletKey)
+		{
+		case B3G_RETURN:
+		{
+				   key = Gwen::Key::Return;
+				   break;
+		}
+		case 	B3G_LEFT_ARROW:
+			key = Gwen::Key::Left;
+			break;
+		case B3G_RIGHT_ARROW:
+			key = Gwen::Key::Right;
+			break;
+
+		case	B3G_UP_ARROW:
+			key = Gwen::Key::Up;
+			break;
+		case B3G_DOWN_ARROW:
+			key = Gwen::Key::Down;
+			break;
+		default:
+		{
+
+		}
+		};
+		bool bDown = (state == 1);
+
+		return m_data->pCanvas->InputKey(key, bDown);
+	}
+	return false;
+}
+
+
+bool	GwenUserInterface::mouseButtonCallback(int button, int state, float x, float y)
+{
+	bool handled = false;
+	if (m_data->pCanvas)
+	{
+		handled = m_data->pCanvas->InputMouseMoved(x,y,x, y);
+
+		if (button>=0)
+		{
+			handled = m_data->pCanvas->InputMouseButton(button,(bool)state);
+			if (handled)
+			{
+				//if (!state)
+				//	return false;
+			}
+		}
+	}
+	return handled;
+}

btgui/Bullet3AppSupport/gwenUserInterface.h

@@ -0,0 +1,55 @@
+#ifndef _GWEN_USER_INTERFACE_H
+#define _GWEN_USER_INTERFACE_H
+
+struct GwenInternalData;
+
+typedef void (*b3ComboBoxCallback) (int combobox, const char* item);
+typedef void (*b3ToggleButtonCallback)(int button, int state);
+typedef void (*b3FileOpenCallback)();
+
+
+class GwenUserInterface
+{
+	GwenInternalData*	m_data;
+
+	public:
+		
+		GwenUserInterface();
+		
+		virtual ~GwenUserInterface();
+		
+		void	init(int width, int height,struct sth_stash* stash,float retinaScale);
+		
+		void	draw(int width, int height);
+
+		void	resize(int width, int height);
+				
+		bool	mouseMoveCallback( float x, float y);
+		bool	mouseButtonCallback(int button, int state, float x, float y);
+		bool	keyboardCallback(int key, int state);
+
+
+		void	setToggleButtonCallback(b3ToggleButtonCallback callback);
+		b3ToggleButtonCallback getToggleButtonCallback();
+
+		void	registerToggleButton(int buttonId, const char* name);
+
+		void	setComboBoxCallback(b3ComboBoxCallback callback);
+		b3ComboBoxCallback getComboBoxCallback();
+		void	registerComboBox(int buttonId, int numItems, const char** items, int startItem = 0);
+		
+		void	setStatusBarMessage(const char* message, bool isLeft=true);
+
+        void    registerFileOpenCallback(b3FileOpenCallback callback);
+    
+		GwenInternalData* getInternalData()
+		{
+			return m_data;
+		}
+
+};
+
+
+
+#endif //_GWEN_USER_INTERFACE_H
+

btgui/Bullet3AppSupport/premake4.lua

@@ -0,0 +1,26 @@
+	
+		project "Bullet3AppSupport"
+	
+		language "C++"
+				
+		kind "StaticLib"
+
+		initOpenGL()
+		initGlew()
+
+		includedirs {
+		 	"..",
+		 	"../../src",
+		}
+		
+		--links {
+		--}
+		
+		files {
+			"*.cpp",
+			"*.h",
+		}
+
+		if os.is("Linux") then
+			initX11()
+		end

btgui/CMakeLists.txt

@@ -1,3 +1,3 @@
 if (OPENGL_FOUND)
-SUBDIRS(  Gwen OpenGLWindow lua-5.2.3)
+SUBDIRS(  Bullet3AppSupport Gwen OpenGLWindow lua-5.2.3)
 endif(OPENGL_FOUND)

btgui/GwenOpenGLTest/premake4.lua

@@ -37,8 +37,8 @@
 		"../OpenGLWindow/fontstash.h",
 		"../OpenGLWindow/opengl_fontstashcallbacks.cpp",
  		"../OpenGLWindow/opengl_fontstashcallbacks.h",
-		"../../btgui/Timing/b3Clock.cpp",
-		"../../btgui/Timing/b3Clock.h",
+		"../Bullet3AppSupport/b3Clock.cpp",
+		"../Bullet3AppSupport/b3Clock.h",
 		"**.cpp",
 		"**.h",
 	}