text: #include "OpenGLGuiHelper.h"
  
  #include "btBulletDynamicsCommon.h"
  #include "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h"
  #include "../CommonInterfaces/CommonGraphicsAppInterface.h"
  #include "../CommonInterfaces/CommonRenderInterface.h"
  #include "Bullet3Common/b3Scalar.h"
  #include "CollisionShape2TriangleMesh.h"
  #include "BulletSoftBody/btSoftBodyHelpers.h"
  
  #include "../OpenGLWindow/ShapeData.h"
  
  #include "../OpenGLWindow/SimpleCamera.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;
  };
  
  ATTRIBUTE_ALIGNED16(class)
  MyDebugDrawer : public btIDebugDraw
  {
  	CommonGraphicsApp* m_glApp;
  	int m_debugMode;
  
  	btAlignedObjectArray<MyDebugVec3> m_linePoints;
  	btAlignedObjectArray<unsigned int> m_lineIndices;
  
  	btVector3 m_currentLineColor;
  	DefaultColors m_ourColors;
  
  public:
  	BT_DECLARE_ALIGNED_ALLOCATOR();
  
  	MyDebugDrawer(CommonGraphicsApp * app)
  		: m_glApp(app), m_debugMode(btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawAabb), m_currentLineColor(-1, -1, -1)
  	{
  	}
  
  	virtual ~MyDebugDrawer()
  	{
  	}
  	virtual DefaultColors getDefaultColors() const
  	{
  		return m_ourColors;
  	}
  	///the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors.
  	virtual void setDefaultColors(const DefaultColors& colors)
  	{
  		m_ourColors = colors;
  	}
  
  	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 * distance, color);
  		btVector3 ncolor(0, 0, 0);
  		drawLine(PointOnB, PointOnB + normalOnB * 0.01, ncolor);
  	}
  
  	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_renderer->drawLines(&m_linePoints[0].x, debugColor,
  										   m_linePoints.size(), sizeof(MyDebugVec3),
  										   &m_lineIndices[0],
  										   m_lineIndices.size(),
  										   1);
  			m_linePoints.clear();
  			m_lineIndices.clear();
  		}
  	}
  };
  
  static btVector4 sColors[4] =
  	{
  		btVector4(60. / 256., 186. / 256., 84. / 256., 1),
  		btVector4(244. / 256., 194. / 256., 13. / 256., 1),
  		btVector4(219. / 256., 50. / 256., 54. / 256., 1),
  		btVector4(72. / 256., 133. / 256., 237. / 256., 1),
  
  		//btVector4(1,1,0,1),
  };
  
  struct MyHashShape
  {
  	int m_shapeKey;
  	int m_shapeType;
  	btVector3 m_sphere0Pos;
  	btVector3 m_sphere1Pos;
  	btScalar m_radius0;
  	btScalar m_radius1;
  	btTransform m_childTransform;
  	int m_deformFunc;
  	int m_upAxis;
  	btScalar m_halfHeight;
  
  	MyHashShape()
  		: m_shapeKey(0),
  		  m_shapeType(0),
  		  m_sphere0Pos(btVector3(0, 0, 0)),
  		  m_sphere1Pos(btVector3(0, 0, 0)),
  		  m_radius0(0),
  		  m_radius1(0),
  		  m_deformFunc(0),
  		  m_upAxis(-1),
  		  m_halfHeight(0)
  	{
  		m_childTransform.setIdentity();
  	}
  
  	bool equals(const MyHashShape& other) const
  	{
  		bool sameShapeType = m_shapeType == other.m_shapeType;
  		bool sameSphere0 = m_sphere0Pos == other.m_sphere0Pos;
  		bool sameSphere1 = m_sphere1Pos == other.m_sphere1Pos;
  		bool sameRadius0 = m_radius0 == other.m_radius0;
  		bool sameRadius1 = m_radius1 == other.m_radius1;
  		bool sameTransform = m_childTransform == other.m_childTransform;
  		bool sameUpAxis = m_upAxis == other.m_upAxis;
  		bool sameHalfHeight = m_halfHeight == other.m_halfHeight;
  		return sameShapeType && sameSphere0 && sameSphere1 && sameRadius0 && sameRadius1 && sameTransform && sameUpAxis && sameHalfHeight;
  	}
  	//to our success
  	SIMD_FORCE_INLINE unsigned int getHash() const
  	{
  		unsigned int key = m_shapeKey;
  		// Thomas Wang's hash
  		key += ~(key << 15);
  		key ^= (key >> 10);
  		key += (key << 3);
  		key ^= (key >> 6);
  		key += ~(key << 11);
  		key ^= (key >> 16);
  
  		return key;
  	}
  };
  
  struct OpenGLGuiHelperInternalData
  {
  	struct CommonGraphicsApp* m_glApp;
  	class MyDebugDrawer* m_debugDraw;
  	bool m_vrMode;
  	int m_vrSkipShadowPass;
  
  	btAlignedObjectArray<unsigned char> m_rgbaPixelBuffer1;
  	btAlignedObjectArray<float> m_depthBuffer1;
  	btAlignedObjectArray<int> m_segmentationMaskBuffer;
  	btHashMap<MyHashShape, int> m_hashShapes;
  
  	VisualizerFlagCallback m_visualizerFlagCallback;
  
  	int m_checkedTexture;
  	int m_checkedTextureGrey;
  
  	OpenGLGuiHelperInternalData()
  		: m_vrMode(false),
  		  m_vrSkipShadowPass(0),
  		  m_visualizerFlagCallback(0),
  		  m_checkedTexture(-1),
  		  m_checkedTextureGrey(-1)
  	{
  	}
  };
  
  void OpenGLGuiHelper::setVRMode(bool vrMode)
  {
  	m_data->m_vrMode = vrMode;
  	m_data->m_vrSkipShadowPass = 0;
  }
  
  OpenGLGuiHelper::OpenGLGuiHelper(CommonGraphicsApp* glApp, bool useOpenGL2)
  {
  	m_data = new OpenGLGuiHelperInternalData;
  	m_data->m_glApp = glApp;
  	m_data->m_debugDraw = 0;
  }
  
  OpenGLGuiHelper::~OpenGLGuiHelper()
  {
  	delete m_data->m_debugDraw;
  
  	delete m_data;
  }
  
  struct CommonRenderInterface* OpenGLGuiHelper::getRenderInterface()
  {
  	return m_data->m_glApp->m_renderer;
  }
  
  const struct CommonRenderInterface* OpenGLGuiHelper::getRenderInterface() const
  {
  	return m_data->m_glApp->m_renderer;
  }
  
  void OpenGLGuiHelper::createRigidBodyGraphicsObject(btRigidBody* body, const btVector3& color)
  {
  	createCollisionObjectGraphicsObject(body, color);
  }
  
  
  class MyTriangleCollector2 : public btTriangleCallback
  {
  public:
  	btAlignedObjectArray<GLInstanceVertex>* m_pVerticesOut;
  	btAlignedObjectArray<int>* m_pIndicesOut;
  
  	MyTriangleCollector2()
  	{
  		m_pVerticesOut = 0;
  		m_pIndicesOut = 0;
  	}
  
  	virtual void processTriangle(btVector3* tris, int partId, int triangleIndex)
  	{
  		for (int k = 0; k < 3; k++)
  		{
  			GLInstanceVertex v;
  			v.xyzw[3] = 0;
  			v.uv[0] = v.uv[1] = 0.5f;
  			btVector3 normal = (tris[0] - tris[1]).cross(tris[0] - tris[2]);
  			normal.safeNormalize();
  			for (int l = 0; l < 3; l++)
  			{
  				v.xyzw[l] = tris[k][l];
  				v.normal[l] = normal[l];
  			}
  			m_pIndicesOut->push_back(m_pVerticesOut->size());
  			m_pVerticesOut->push_back(v);
  		}
  	}
  };
  void OpenGLGuiHelper::createCollisionObjectGraphicsObject(btCollisionObject* body, const btVector3& color)
  {
  	if (body->getUserIndex() < 0)
  	{
  		btCollisionShape* shape = body->getCollisionShape();
  		btTransform startTransform = body->getWorldTransform();
  		int graphicsShapeId = shape->getUserIndex();
  		if (graphicsShapeId >= 0)
  		{
  			//	btAssert(graphicsShapeId >= 0);
  			//the graphics shape is already scaled
  			btVector3 localScaling(1, 1, 1);
  			int graphicsInstanceId = m_data->m_glApp->m_renderer->registerGraphicsInstance(graphicsShapeId, startTransform.getOrigin(), startTransform.getRotation(), color, localScaling);
  			body->setUserIndex(graphicsInstanceId);
  		}
  	}
  }
  
  int OpenGLGuiHelper::registerTexture(const unsigned char* texels, int width, int height)
  {
  	int textureId = m_data->m_glApp->m_renderer->registerTexture(texels, width, height);
  	return textureId;
  }
  
  void OpenGLGuiHelper::removeTexture(int textureUid)
  {
  	m_data->m_glApp->m_renderer->removeTexture(textureUid);
  }
  
  void OpenGLGuiHelper::changeTexture(int textureUniqueId, const unsigned char* rgbTexels, int width, int height)
  {
  	bool flipPixelsY = true;
  	m_data->m_glApp->m_renderer->updateTexture(textureUniqueId, rgbTexels, flipPixelsY);
  }
  
  int OpenGLGuiHelper::registerGraphicsShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType, int textureId)
  {
  	if (textureId == -2)
  	{
  		if (m_data->m_checkedTextureGrey < 0)
  		{
  			m_data->m_checkedTextureGrey = createCheckeredTexture(192, 192, 192);
  		}
  		textureId = m_data->m_checkedTextureGrey;
  	}
  
  	int shapeId = m_data->m_glApp->m_renderer->registerShape(vertices, numvertices, indices, numIndices, primitiveType, textureId);
  	return shapeId;
  }
  
  int OpenGLGuiHelper::registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling)
  {
  	return m_data->m_glApp->m_renderer->registerGraphicsInstance(shapeIndex, position, quaternion, color, scaling);
  }
  
  void OpenGLGuiHelper::removeAllGraphicsInstances()
  {
  	m_data->m_hashShapes.clear();
  	m_data->m_glApp->m_renderer->removeAllInstances();
  }
  
  void OpenGLGuiHelper::removeGraphicsInstance(int graphicsUid)
  {
  	if (graphicsUid >= 0)
  	{
  		m_data->m_glApp->m_renderer->removeGraphicsInstance(graphicsUid);
  	};
  }
  
  int OpenGLGuiHelper::getShapeIndexFromInstance(int instanceUid)
  {
  	return m_data->m_glApp->m_renderer->getShapeIndexFromInstance(instanceUid);
  }
  
  void OpenGLGuiHelper::replaceTexture(int shapeIndex, int textureUid)
  {
  	if (shapeIndex >= 0)
  	{
  		m_data->m_glApp->m_renderer->replaceTexture(shapeIndex, textureUid);
  	};
  }
  void OpenGLGuiHelper::changeRGBAColor(int instanceUid, const double rgbaColor[4])
  {
  	if (instanceUid >= 0)
  	{
  		m_data->m_glApp->m_renderer->writeSingleInstanceColorToCPU(rgbaColor, instanceUid);
  	};
  }
  void OpenGLGuiHelper::changeSpecularColor(int instanceUid, const double specularColor[3])
  {
  	if (instanceUid >= 0)
  	{
  		m_data->m_glApp->m_renderer->writeSingleInstanceSpecularColorToCPU(specularColor, instanceUid);
  	};
  }
  int OpenGLGuiHelper::createCheckeredTexture(int red, int green, int blue)
  {
  	int texWidth = 1024;
  	int texHeight = 1024;
  	btAlignedObjectArray<unsigned char> texels;
  	texels.resize(texWidth * texHeight * 3);
  	for (int i = 0; i < texWidth * texHeight * 3; i++)
  		texels[i] = 255;
  
  	for (int i = 0; i < texWidth; i++)
  	{
  		for (int j = 0; j < texHeight; j++)
  		{
  			int a = i < texWidth / 2 ? 1 : 0;
  			int b = j < texWidth / 2 ? 1 : 0;
  
  			if (a == b)
  			{
  				texels[(i + j * texWidth) * 3 + 0] = red;
  				texels[(i + j * texWidth) * 3 + 1] = green;
  				texels[(i + j * texWidth) * 3 + 2] = blue;
  				//					texels[(i+j*texWidth)*4+3] = 255;
  			}
  			/*else
  				{
  					texels[i*3+0+j*texWidth] = 255;
  					texels[i*3+1+j*texWidth] = 255;
  					texels[i*3+2+j*texWidth] = 255;
  				}
  				*/
  		}
  	}
  
  	int texId = registerTexture(&texels[0], texWidth, texHeight);
  	return texId;
  }
  
  void OpenGLGuiHelper::createCollisionShapeGraphicsObject(btCollisionShape* collisionShape)
  {
  	//already has a graphics object?
  	if (collisionShape->getUserIndex() >= 0)
  		return;
  
  	if (m_data->m_checkedTexture < 0)
  	{
  		m_data->m_checkedTexture = createCheckeredTexture(192, 192, 255);
  	}
  
  	if (m_data->m_checkedTextureGrey < 0)
  	{
  		m_data->m_checkedTextureGrey = createCheckeredTexture(192, 192, 192);
  	}
  
  	btAlignedObjectArray<GLInstanceVertex> gfxVertices;
  	btAlignedObjectArray<int> indices;
  	int strideInBytes = 9 * sizeof(float);
  	//if (collisionShape->getShapeType()==BOX_SHAPE_PROXYTYPE)
  	{
  	}
  
  
  	if (collisionShape->getShapeType() == TERRAIN_SHAPE_PROXYTYPE)
  	{
  		const btHeightfieldTerrainShape* heightField = static_cast<const btHeightfieldTerrainShape*>(collisionShape);
  		MyTriangleCollector2  col;
  		col.m_pVerticesOut = &gfxVertices;
  		col.m_pIndicesOut = &indices;
  		btVector3 aabbMin, aabbMax;
  		for (int k = 0; k < 3; k++)
  		{
  			aabbMin[k] = -BT_LARGE_FLOAT;
  			aabbMax[k] = BT_LARGE_FLOAT;
  		}
  		heightField->processAllTriangles(&col, aabbMin, aabbMax);
  		if (gfxVertices.size() && indices.size())
  		{
  			int shapeId = m_data->m_glApp->m_renderer->registerShape(&gfxVertices[0].xyzw[0], gfxVertices.size(), &indices[0], indices.size());
  			collisionShape->setUserIndex(shapeId);
  		}
  		return;
  	}
  
  
  	if (collisionShape->getShapeType() == SOFTBODY_SHAPE_PROXYTYPE)
  	{
  		computeSoftBodyVertices(collisionShape, gfxVertices, indices);
  		if (gfxVertices.size() && indices.size())
  		{
  			int shapeId = registerGraphicsShape(&gfxVertices[0].xyzw[0], gfxVertices.size(), &indices[0], indices.size(), B3_GL_TRIANGLES,
  												m_data->m_checkedTexture);
  
  			b3Assert(shapeId >= 0);
  			collisionShape->setUserIndex(shapeId);
  		}
  	}
  	if (collisionShape->getShapeType() == MULTI_SPHERE_SHAPE_PROXYTYPE)
  	{
  		btMultiSphereShape* ms = (btMultiSphereShape*)collisionShape;
  		if (ms->getSphereCount() == 2)
  		{
  			btAlignedObjectArray<float> transformedVertices;
  			int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  			transformedVertices.resize(numVertices * 9);
  			btVector3 sphere0Pos = ms->getSpherePosition(0);
  			btVector3 sphere1Pos = ms->getSpherePosition(1);
  			btVector3 fromTo = sphere1Pos - sphere0Pos;
  			MyHashShape shape;
  			shape.m_sphere0Pos = sphere0Pos;
  			shape.m_sphere1Pos = sphere1Pos;
  			shape.m_radius0 = 2. * ms->getSphereRadius(0);
  			shape.m_radius1 = 2. * ms->getSphereRadius(1);
  			shape.m_deformFunc = 1;  //vert.dot(fromTo)
  			int graphicsShapeIndex = -1;
  			int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  			if (graphicsShapeIndexPtr)
  			{
  				//cache hit
  				graphicsShapeIndex = *graphicsShapeIndexPtr;
  			}
  			else
  			{
  				//cache miss
  				for (int i = 0; i < numVertices; i++)
  				{
  					btVector3 vert;
  					vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  								  textured_detailed_sphere_vertices[i * 9 + 1],
  								  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  					btVector3 trVer(0, 0, 0);
  
  					if (vert.dot(fromTo) > 0)
  					{
  						btScalar radiusScale = 2. * ms->getSphereRadius(1);
  						trVer = radiusScale * vert;
  						trVer += sphere1Pos;
  					}
  					else
  					{
  						btScalar radiusScale = 2. * ms->getSphereRadius(0);
  						trVer = radiusScale * vert;
  						trVer += sphere0Pos;
  					}
  
  					transformedVertices[i * 9 + 0] = trVer[0];
  					transformedVertices[i * 9 + 1] = trVer[1];
  					transformedVertices[i * 9 + 2] = trVer[2];
  					transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  					transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  					transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  					transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  					transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  					transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  				}
  
  				int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  				graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  
  				m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  			}
  			collisionShape->setUserIndex(graphicsShapeIndex);
  			return;
  		}
  	}
  
  	if (collisionShape->getShapeType() == SPHERE_SHAPE_PROXYTYPE)
  	{
  		btSphereShape* sphereShape = (btSphereShape*)collisionShape;
  		btScalar radius = sphereShape->getRadius();
  		btScalar sphereSize = 2. * radius;
  		btVector3 radiusScale(sphereSize, sphereSize, sphereSize);
  		btAlignedObjectArray<float> transformedVertices;
  
  		MyHashShape shape;
  		shape.m_radius0 = sphereSize;
  		shape.m_deformFunc = 0;  ////no deform
  		int graphicsShapeIndex = -1;
  		int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  		if (graphicsShapeIndexPtr)
  		{
  			graphicsShapeIndex = *graphicsShapeIndexPtr;
  		}
  		else
  		{
  			int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  			transformedVertices.resize(numVertices * 9);
  			for (int i = 0; i < numVertices; i++)
  			{
  				btVector3 vert;
  				vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  							  textured_detailed_sphere_vertices[i * 9 + 1],
  							  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  				btVector3 trVer = radiusScale * vert;
  				transformedVertices[i * 9 + 0] = trVer[0];
  				transformedVertices[i * 9 + 1] = trVer[1];
  				transformedVertices[i * 9 + 2] = trVer[2];
  				transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  				transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  				transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  				transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  				transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  				transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  			}
  
  			int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  			graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  			m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  		}
  
  		collisionShape->setUserIndex(graphicsShapeIndex);
  		return;
  	}
  	if (collisionShape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE)
  	{
  		btCompoundShape* compound = (btCompoundShape*)collisionShape;
  		if (compound->getNumChildShapes() == 1)
  		{
  			if (compound->getChildShape(0)->getShapeType() == SPHERE_SHAPE_PROXYTYPE)
  			{
  				btSphereShape* sphereShape = (btSphereShape*)compound->getChildShape(0);
  				btScalar radius = sphereShape->getRadius();
  				btScalar sphereSize = 2. * radius;
  				btVector3 radiusScale(sphereSize, sphereSize, sphereSize);
  
  				MyHashShape shape;
  				shape.m_radius0 = sphereSize;
  				shape.m_deformFunc = 0;  //no deform
  				shape.m_childTransform = compound->getChildTransform(0);
  
  				int graphicsShapeIndex = -1;
  				int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  				if (graphicsShapeIndexPtr)
  				{
  					graphicsShapeIndex = *graphicsShapeIndexPtr;
  				}
  				else
  				{
  					btAlignedObjectArray<float> transformedVertices;
  					int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  					transformedVertices.resize(numVertices * 9);
  					for (int i = 0; i < numVertices; i++)
  					{
  						btVector3 vert;
  						vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  									  textured_detailed_sphere_vertices[i * 9 + 1],
  									  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  						btVector3 trVer = compound->getChildTransform(0) * (radiusScale * vert);
  						transformedVertices[i * 9 + 0] = trVer[0];
  						transformedVertices[i * 9 + 1] = trVer[1];
  						transformedVertices[i * 9 + 2] = trVer[2];
  						transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  						transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  						transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  						transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  						transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  						transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  					}
  
  					int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  					graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  					m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  				}
  
  				collisionShape->setUserIndex(graphicsShapeIndex);
  				return;
  			}
  			if (compound->getChildShape(0)->getShapeType() == CAPSULE_SHAPE_PROXYTYPE)
  			{
  				btCapsuleShape* sphereShape = (btCapsuleShape*)compound->getChildShape(0);
  				int up = sphereShape->getUpAxis();
  				btScalar halfHeight = sphereShape->getHalfHeight();
  
  				btScalar radius = sphereShape->getRadius();
  				btScalar sphereSize = 2. * radius;
  
  				btVector3 radiusScale = btVector3(sphereSize, sphereSize, sphereSize);
  
  				MyHashShape shape;
  				shape.m_radius0 = sphereSize;
  				shape.m_deformFunc = 2;  //no deform
  				shape.m_childTransform = compound->getChildTransform(0);
  				shape.m_upAxis = up;
  
  				int graphicsShapeIndex = -1;
  				int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  				if (graphicsShapeIndexPtr)
  				{
  					graphicsShapeIndex = *graphicsShapeIndexPtr;
  				}
  				else
  				{
  					btAlignedObjectArray<float> transformedVertices;
  					int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  					transformedVertices.resize(numVertices * 9);
  					for (int i = 0; i < numVertices; i++)
  					{
  						btVector3 vert;
  						vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  									  textured_detailed_sphere_vertices[i * 9 + 1],
  									  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  						btVector3 trVer = (radiusScale * vert);
  						if (trVer[up] > 0)
  							trVer[up] += halfHeight;
  						else
  							trVer[up] -= halfHeight;
  
  						trVer = compound->getChildTransform(0) * trVer;
  
  						transformedVertices[i * 9 + 0] = trVer[0];
  						transformedVertices[i * 9 + 1] = trVer[1];
  						transformedVertices[i * 9 + 2] = trVer[2];
  						transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  						transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  						transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  						transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  						transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  						transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  					}
  
  					int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  					graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  					m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  				}
  
  				collisionShape->setUserIndex(graphicsShapeIndex);
  				return;
  			}
  
  			if (compound->getChildShape(0)->getShapeType() == MULTI_SPHERE_SHAPE_PROXYTYPE)
  			{
  				btMultiSphereShape* ms = (btMultiSphereShape*)compound->getChildShape(0);
  				if (ms->getSphereCount() == 2)
  				{
  					btAlignedObjectArray<float> transformedVertices;
  					int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  					transformedVertices.resize(numVertices * 9);
  					btVector3 sphere0Pos = ms->getSpherePosition(0);
  					btVector3 sphere1Pos = ms->getSpherePosition(1);
  					btVector3 fromTo = sphere1Pos - sphere0Pos;
  					btScalar radiusScale1 = 2.0 * ms->getSphereRadius(1);
  					btScalar radiusScale0 = 2.0 * ms->getSphereRadius(0);
  
  					MyHashShape shape;
  					shape.m_radius0 = radiusScale0;
  					shape.m_radius1 = radiusScale1;
  					shape.m_deformFunc = 4;
  					shape.m_sphere0Pos = sphere0Pos;
  					shape.m_sphere1Pos = sphere1Pos;
  					shape.m_childTransform = compound->getChildTransform(0);
  
  					int graphicsShapeIndex = -1;
  					int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  					if (graphicsShapeIndexPtr)
  					{
  						graphicsShapeIndex = *graphicsShapeIndexPtr;
  					}
  					else
  					{
  						for (int i = 0; i < numVertices; i++)
  						{
  							btVector3 vert;
  							vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  										  textured_detailed_sphere_vertices[i * 9 + 1],
  										  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  							btVector3 trVer(0, 0, 0);
  							if (vert.dot(fromTo) > 0)
  							{
  								trVer = vert * radiusScale1;
  								trVer += sphere1Pos;
  								trVer = compound->getChildTransform(0) * trVer;
  							}
  							else
  							{
  								trVer = vert * radiusScale0;
  								trVer += sphere0Pos;
  								trVer = compound->getChildTransform(0) * trVer;
  							}
  
  							transformedVertices[i * 9 + 0] = trVer[0];
  							transformedVertices[i * 9 + 1] = trVer[1];
  							transformedVertices[i * 9 + 2] = trVer[2];
  							transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  							transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  							transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  							transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  							transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  							transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  						}
  
  						int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  						graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  						m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  					}
  					collisionShape->setUserIndex(graphicsShapeIndex);
  					return;
  				}
  			}
  		}
  	}
  	if (collisionShape->getShapeType() == CAPSULE_SHAPE_PROXYTYPE)
  	{
  		btCapsuleShape* sphereShape = (btCapsuleShape*)collisionShape;  //Y up
  		int up = sphereShape->getUpAxis();
  		btScalar halfHeight = sphereShape->getHalfHeight();
  
  		btScalar radius = sphereShape->getRadius();
  		btScalar sphereSize = 2. * radius;
  		btVector3 radiusScale(sphereSize, sphereSize, sphereSize);
  
  		MyHashShape shape;
  		shape.m_radius0 = sphereSize;
  		shape.m_deformFunc = 3;
  		shape.m_upAxis = up;
  		shape.m_halfHeight = halfHeight;
  		int graphicsShapeIndex = -1;
  		int* graphicsShapeIndexPtr = m_data->m_hashShapes[shape];
  
  		if (graphicsShapeIndexPtr)
  		{
  			graphicsShapeIndex = *graphicsShapeIndexPtr;
  		}
  		else
  		{
  			btAlignedObjectArray<float> transformedVertices;
  			int numVertices = sizeof(textured_detailed_sphere_vertices) / strideInBytes;
  			transformedVertices.resize(numVertices * 9);
  			for (int i = 0; i < numVertices; i++)
  			{
  				btVector3 vert;
  				vert.setValue(textured_detailed_sphere_vertices[i * 9 + 0],
  							  textured_detailed_sphere_vertices[i * 9 + 1],
  							  textured_detailed_sphere_vertices[i * 9 + 2]);
  
  				btVector3 trVer = radiusScale * vert;
  				if (trVer[up] > 0)
  					trVer[up] += halfHeight;
  				else
  					trVer[up] -= halfHeight;
  
  				transformedVertices[i * 9 + 0] = trVer[0];
  				transformedVertices[i * 9 + 1] = trVer[1];
  				transformedVertices[i * 9 + 2] = trVer[2];
  				transformedVertices[i * 9 + 3] = textured_detailed_sphere_vertices[i * 9 + 3];
  				transformedVertices[i * 9 + 4] = textured_detailed_sphere_vertices[i * 9 + 4];
  				transformedVertices[i * 9 + 5] = textured_detailed_sphere_vertices[i * 9 + 5];
  				transformedVertices[i * 9 + 6] = textured_detailed_sphere_vertices[i * 9 + 6];
  				transformedVertices[i * 9 + 7] = textured_detailed_sphere_vertices[i * 9 + 7];
  				transformedVertices[i * 9 + 8] = textured_detailed_sphere_vertices[i * 9 + 8];
  			}
  
  			int numIndices = sizeof(textured_detailed_sphere_indices) / sizeof(int);
  			graphicsShapeIndex = registerGraphicsShape(&transformedVertices[0], numVertices, textured_detailed_sphere_indices, numIndices, B3_GL_TRIANGLES, m_data->m_checkedTextureGrey);
  			m_data->m_hashShapes.insert(shape, graphicsShapeIndex);
  		}
  		collisionShape->setUserIndex(graphicsShapeIndex);
  		return;
  	}
  	if (collisionShape->getShapeType() == STATIC_PLANE_PROXYTYPE)
  	{
  		const btStaticPlaneShape* staticPlaneShape = static_cast<const btStaticPlaneShape*>(collisionShape);
  		btScalar planeConst = staticPlaneShape->getPlaneConstant();
  		const btVector3& planeNormal = staticPlaneShape->getPlaneNormal();
  		btVector3 planeOrigin = planeNormal * planeConst;
  		btVector3 vec0, vec1;
  		btPlaneSpace1(planeNormal, vec0, vec1);
  
  		btScalar vecLen = 128;
  		btVector3 verts[4];
  
  		verts[0] = planeOrigin + vec0 * vecLen + vec1 * vecLen;
  		verts[1] = planeOrigin - vec0 * vecLen + vec1 * vecLen;
  		verts[2] = planeOrigin - vec0 * vecLen - vec1 * vecLen;
  		verts[3] = planeOrigin + vec0 * vecLen - vec1 * vecLen;
  
  		int startIndex = 0;
  		indices.push_back(startIndex + 0);
  		indices.push_back(startIndex + 1);
  		indices.push_back(startIndex + 2);
  		indices.push_back(startIndex + 0);
  		indices.push_back(startIndex + 2);
  		indices.push_back(startIndex + 3);
  		btTransform parentTransform;
  		parentTransform.setIdentity();
  		btVector3 triNormal = parentTransform.getBasis() * planeNormal;
  
  		gfxVertices.resize(4);
  
  		for (int i = 0; i < 4; i++)
  		{
  			btVector3 vtxPos;
  			btVector3 pos = parentTransform * verts[i];
  
  			gfxVertices[i].xyzw[0] = pos[0];
  			gfxVertices[i].xyzw[1] = pos[1];
  			gfxVertices[i].xyzw[2] = pos[2];
  			gfxVertices[i].xyzw[3] = 1;
  			gfxVertices[i].normal[0] = triNormal[0];
  			gfxVertices[i].normal[1] = triNormal[1];
  			gfxVertices[i].normal[2] = triNormal[2];
  		}
  
  		//verts[0] = planeOrigin + vec0*vecLen + vec1*vecLen;
  		//verts[1] = planeOrigin - vec0*vecLen + vec1*vecLen;
  		//verts[2] = planeOrigin - vec0*vecLen - vec1*vecLen;
  		//verts[3] = planeOrigin + vec0*vecLen - vec1*vecLen;
  
  		gfxVertices[0].uv[0] = vecLen / 2;
  		gfxVertices[0].uv[1] = vecLen / 2;
  		gfxVertices[1].uv[0] = -vecLen / 2;
  		gfxVertices[1].uv[1] = vecLen / 2;
  		gfxVertices[2].uv[0] = -vecLen / 2;
  		gfxVertices[2].uv[1] = -vecLen / 2;
  		gfxVertices[3].uv[0] = vecLen / 2;
  		gfxVertices[3].uv[1] = -vecLen / 2;
  
  		int shapeId = registerGraphicsShape(&gfxVertices[0].xyzw[0], gfxVertices.size(), &indices[0], indices.size(), B3_GL_TRIANGLES, m_data->m_checkedTexture);
  		collisionShape->setUserIndex(shapeId);
  		return;
  	}
  
  	btTransform startTrans;
  	startTrans.setIdentity();
  	//todo: create some textured objects for popular objects, like plane, cube, sphere, capsule
  
  	{
  		btAlignedObjectArray<btVector3> vertexPositions;
  		btAlignedObjectArray<btVector3> vertexNormals;
  		CollisionShape2TriangleMesh(collisionShape, startTrans, vertexPositions, vertexNormals, indices);
  		gfxVertices.resize(vertexPositions.size());
  		for (int i = 0; i < vertexPositions.size(); i++)
  		{
  			for (int j = 0; j < 4; j++)
  			{
  				gfxVertices[i].xyzw[j] = vertexPositions[i][j];
  			}
  			for (int j = 0; j < 3; j++)
  			{
  				gfxVertices[i].normal[j] = vertexNormals[i][j];
  			}
  			for (int j = 0; j < 2; j++)
  			{
  				gfxVertices[i].uv[j] = 0.5;  //we don't have UV info...
  			}
  		}
  	}
  
  	if (gfxVertices.size() && indices.size())
  	{
  		int shapeId = registerGraphicsShape(&gfxVertices[0].xyzw[0], gfxVertices.size(), &indices[0], indices.size(), B3_GL_TRIANGLES, -1);
  		collisionShape->setUserIndex(shapeId);
  	}
  }
  void OpenGLGuiHelper::syncPhysicsToGraphics(const btDiscreteDynamicsWorld* rbWorld)
  {
  	//in VR mode, we skip the synchronization for the second eye
  	if (m_data->m_vrMode && m_data->m_vrSkipShadowPass == 1)
  		return;
  
  	int numCollisionObjects = rbWorld->getNumCollisionObjects();
  	{
  		B3_PROFILE("write all InstanceTransformToCPU");
  		for (int i = 0; i < numCollisionObjects; i++)
  		{
  			//B3_PROFILE("writeSingleInstanceTransformToCPU");
  			btCollisionObject* colObj = rbWorld->getCollisionObjectArray()[i];
  			btCollisionShape* collisionShape = colObj->getCollisionShape();
  			if (collisionShape->getShapeType() == SOFTBODY_SHAPE_PROXYTYPE && collisionShape->getUserIndex() >= 0)
  			{
  				btAlignedObjectArray<GLInstanceVertex> gfxVertices;
  				btAlignedObjectArray<int> indices;
  				computeSoftBodyVertices(collisionShape, gfxVertices, indices);
  				m_data->m_glApp->m_renderer->updateShape(collisionShape->getUserIndex(), &gfxVertices[0].xyzw[0]);
  				continue;
  			}
  			btVector3 pos = colObj->getWorldTransform().getOrigin();
  			btQuaternion orn = colObj->getWorldTransform().getRotation();
  			int index = colObj->getUserIndex();
  			if (index >= 0)
  			{
  				m_data->m_glApp->m_renderer->writeSingleInstanceTransformToCPU(pos, orn, index);
  			}
  		}
  	}
  	{
  		B3_PROFILE("writeTransforms");
  		m_data->m_glApp->m_renderer->writeTransforms();
  	}
  }
  
  void OpenGLGuiHelper::render(const btDiscreteDynamicsWorld* rbWorld)
  {
  	if (m_data->m_vrMode)
  	{
  		//in VR, we skip the shadow generation for the second eye
  
  		if (m_data->m_vrSkipShadowPass >= 1)
  		{
  			m_data->m_glApp->m_renderer->renderSceneInternal(B3_USE_SHADOWMAP_RENDERMODE);
  			m_data->m_vrSkipShadowPass = 0;
  		}
  		else
  		{
  			m_data->m_glApp->m_renderer->renderScene();
  			m_data->m_vrSkipShadowPass++;
  		}
  	}
  	else
  	{
  		m_data->m_glApp->m_renderer->renderScene();
  	}
  }
  void OpenGLGuiHelper::createPhysicsDebugDrawer(btDiscreteDynamicsWorld* rbWorld)
  {
  	btAssert(rbWorld);
  	if (m_data->m_debugDraw)
  	{
  		delete m_data->m_debugDraw;
  		m_data->m_debugDraw = 0;
  	}
  
  	m_data->m_debugDraw = new MyDebugDrawer(m_data->m_glApp);
  	rbWorld->setDebugDrawer(m_data->m_debugDraw);
  
  	m_data->m_debugDraw->setDebugMode(
  		btIDebugDraw::DBG_DrawWireframe + btIDebugDraw::DBG_DrawAabb
  		//btIDebugDraw::DBG_DrawContactPoints
  	);
  }
  
  struct Common2dCanvasInterface* OpenGLGuiHelper::get2dCanvasInterface()
  {
  	return m_data->m_glApp->m_2dCanvasInterface;
  }
  
  CommonParameterInterface* OpenGLGuiHelper::getParameterInterface()
  {
  	return m_data->m_glApp->m_parameterInterface;
  }
  
  void OpenGLGuiHelper::setUpAxis(int axis)
  {
  	m_data->m_glApp->setUpAxis(axis);
  }
  
  void OpenGLGuiHelper::setVisualizerFlagCallback(VisualizerFlagCallback callback)
  {
  	m_data->m_visualizerFlagCallback = callback;
  }
  
  void OpenGLGuiHelper::setVisualizerFlag(int flag, int enable)
  {
  	if (getRenderInterface() && flag == 16)  //COV_ENABLE_PLANAR_REFLECTION
  	{
  		getRenderInterface()->setPlaneReflectionShapeIndex(enable);
  	}
  	if (m_data->m_visualizerFlagCallback)
  		(m_data->m_visualizerFlagCallback)(flag, enable != 0);
  }
  
  void OpenGLGuiHelper::resetCamera(float camDist, float yaw, float pitch, float camPosX, float camPosY, float camPosZ)
  {
  	if (getRenderInterface() && getRenderInterface()->getActiveCamera())
  	{
  		getRenderInterface()->getActiveCamera()->setCameraDistance(camDist);
  		getRenderInterface()->getActiveCamera()->setCameraPitch(pitch);
  		getRenderInterface()->getActiveCamera()->setCameraYaw(yaw);
  		getRenderInterface()->getActiveCamera()->setCameraTargetPosition(camPosX, camPosY, camPosZ);
  	}
  }
  
  bool OpenGLGuiHelper::getCameraInfo(int* width, int* height, float viewMatrix[16], float projectionMatrix[16], float camUp[3], float camForward[3], float hor[3], float vert[3], float* yaw, float* pitch, float* camDist, float cameraTarget[3]) const
  {
  	if (getRenderInterface() && getRenderInterface()->getActiveCamera())
  	{
  		*width = m_data->m_glApp->m_window->getWidth();
  		*height = m_data->m_glApp->m_window->getHeight();
  		getRenderInterface()->getActiveCamera()->getCameraViewMatrix(viewMatrix);
  		getRenderInterface()->getActiveCamera()->getCameraProjectionMatrix(projectionMatrix);
  		getRenderInterface()->getActiveCamera()->getCameraUpVector(camUp);
  		getRenderInterface()->getActiveCamera()->getCameraForwardVector(camForward);
  
  		float top = 1.f;
  		float bottom = -1.f;
  		float tanFov = (top - bottom) * 0.5f / 1;
  		float fov = btScalar(2.0) * btAtan(tanFov);
  		btVector3 camPos, camTarget;
  		getRenderInterface()->getActiveCamera()->getCameraPosition(camPos);
  		getRenderInterface()->getActiveCamera()->getCameraTargetPosition(camTarget);
  		btVector3 rayFrom = camPos;
  		btVector3 rayForward = (camTarget - camPos);
  		rayForward.normalize();
  		float farPlane = 10000.f;
  		rayForward *= farPlane;
  
  		btVector3 rightOffset;
  		btVector3 cameraUp = btVector3(camUp[0], camUp[1], camUp[2]);
  		btVector3 vertical = cameraUp;
  		btVector3 hori;
  		hori = rayForward.cross(vertical);
  		hori.normalize();
  		vertical = hori.cross(rayForward);
  		vertical.normalize();
  		float tanfov = tanf(0.5f * fov);
  		hori *= 2.f * farPlane * tanfov;
  		vertical *= 2.f * farPlane * tanfov;
  		btScalar aspect = float(*width) / float(*height);
  		hori *= aspect;
  		//compute 'hor' and 'vert' vectors, useful to generate raytracer rays
  		hor[0] = hori[0];
  		hor[1] = hori[1];
  		hor[2] = hori[2];
  		vert[0] = vertical[0];
  		vert[1] = vertical[1];
  		vert[2] = vertical[2];
  
  		*yaw = getRenderInterface()->getActiveCamera()->getCameraYaw();
  		*pitch = getRenderInterface()->getActiveCamera()->getCameraPitch();
  		*camDist = getRenderInterface()->getActiveCamera()->getCameraDistance();
  		cameraTarget[0] = camTarget[0];
  		cameraTarget[1] = camTarget[1];
  		cameraTarget[2] = camTarget[2];
  		return true;
  	}
  	return false;
  }
  
  void OpenGLGuiHelper::setProjectiveTextureMatrices(const float viewMatrix[16], const float projectionMatrix[16])
  {
  	m_data->m_glApp->m_renderer->setProjectiveTextureMatrices(viewMatrix, projectionMatrix);
  }
  
  void OpenGLGuiHelper::setProjectiveTexture(bool useProjectiveTexture)
  {
  	m_data->m_glApp->m_renderer->setProjectiveTexture(useProjectiveTexture);
  }
  
  void OpenGLGuiHelper::copyCameraImageData(const float viewMatrix[16], const float projectionMatrix[16],
  										  unsigned char* pixelsRGBA, int rgbaBufferSizeInPixels,
  										  float* depthBuffer, int depthBufferSizeInPixels,
  										  int* segmentationMaskBuffer, int segmentationMaskBufferSizeInPixels,
  										  int startPixelIndex, int destinationWidth,
  										  int destinationHeight, int* numPixelsCopied)
  {
  	int sourceWidth = btMin(destinationWidth, (int)(m_data->m_glApp->m_window->getWidth() * m_data->m_glApp->m_window->getRetinaScale()));
  	int sourceHeight = btMin(destinationHeight, (int)(m_data->m_glApp->m_window->getHeight() * m_data->m_glApp->m_window->getRetinaScale()));
  	m_data->m_glApp->setViewport(sourceWidth, sourceHeight);
  
  	if (numPixelsCopied)
  		*numPixelsCopied = 0;
  
  	int numTotalPixels = destinationWidth * destinationHeight;
  	int numRemainingPixels = numTotalPixels - startPixelIndex;
  	int numBytesPerPixel = 4;  //RGBA
  	int numRequestedPixels = btMin(rgbaBufferSizeInPixels, numRemainingPixels);
  	if (numRequestedPixels)
  	{
  		if (startPixelIndex == 0)
  		{
  			CommonCameraInterface* oldCam = getRenderInterface()->getActiveCamera();
  			SimpleCamera tempCam;
  			getRenderInterface()->setActiveCamera(&tempCam);
  			getRenderInterface()->getActiveCamera()->setVRCamera(viewMatrix, projectionMatrix);
  			{
  				BT_PROFILE("renderScene");
  				getRenderInterface()->renderScene();
  			}
  
  			{
  				BT_PROFILE("copy pixels");
  				btAlignedObjectArray<unsigned char> sourceRgbaPixelBuffer;
  				btAlignedObjectArray<float> sourceDepthBuffer;
  				//copy the image into our local cache
  				sourceRgbaPixelBuffer.resize(sourceWidth * sourceHeight * numBytesPerPixel);
  				sourceDepthBuffer.resize(sourceWidth * sourceHeight);
  				{
  					BT_PROFILE("getScreenPixels");
  					m_data->m_glApp->getScreenPixels(&(sourceRgbaPixelBuffer[0]), sourceRgbaPixelBuffer.size(), &sourceDepthBuffer[0], sizeof(float) * sourceDepthBuffer.size());
  				}
  
  				m_data->m_rgbaPixelBuffer1.resize(destinationWidth * destinationHeight * numBytesPerPixel);
  				m_data->m_depthBuffer1.resize(destinationWidth * destinationHeight);
  				//rescale and flip
  				{
  					BT_PROFILE("resize and flip");
  					for (int j = 0; j < destinationHeight; j++)
  					{
  						for (int i = 0; i < destinationWidth; i++)
  						{
  							int xIndex = int(float(i) * (float(sourceWidth) / float(destinationWidth)));
  							int yIndex = int(float(destinationHeight - 1 - j) * (float(sourceHeight) / float(destinationHeight)));
  							btClamp(xIndex, 0, sourceWidth);
  							btClamp(yIndex, 0, sourceHeight);
  							int bytesPerPixel = 4;  //RGBA
  
  							int sourcePixelIndex = (xIndex + yIndex * sourceWidth) * bytesPerPixel;
  							int sourceDepthIndex = xIndex + yIndex * sourceWidth;
  #define COPY4PIXELS 1
  #ifdef COPY4PIXELS
  							int* dst = (int*)&m_data->m_rgbaPixelBuffer1[(i + j * destinationWidth) * 4 + 0];
  							int* src = (int*)&sourceRgbaPixelBuffer[sourcePixelIndex + 0];
  							*dst = *src;
  
  #else
  							m_data->m_rgbaPixelBuffer1[(i + j * destinationWidth) * 4 + 0] = sourceRgbaPixelBuffer[sourcePixelIndex + 0];
  							m_data->m_rgbaPixelBuffer1[(i + j * destinationWidth) * 4 + 1] = sourceRgbaPixelBuffer[sourcePixelIndex + 1];
  							m_data->m_rgbaPixelBuffer1[(i + j * destinationWidth) * 4 + 2] = sourceRgbaPixelBuffer[sourcePixelIndex + 2];
  							m_data->m_rgbaPixelBuffer1[(i + j * destinationWidth) * 4 + 3] = 255;
  #endif
  							if (depthBuffer)
  							{
  								m_data->m_depthBuffer1[i + j * destinationWidth] = sourceDepthBuffer[sourceDepthIndex];
  							}
  						}
  					}
  				}
  			}
  
  			//segmentation mask
  
  			if (segmentationMaskBuffer)
  			{
  				{
  					m_data->m_glApp->m_window->startRendering();
  					m_data->m_glApp->setViewport(sourceWidth, sourceHeight);
  					BT_PROFILE("renderScene");
  					getRenderInterface()->renderSceneInternal(B3_SEGMENTATION_MASK_RENDERMODE);
  				}
  
  				{
  					BT_PROFILE("copy pixels");
  					btAlignedObjectArray<unsigned char> sourceRgbaPixelBuffer;
  					btAlignedObjectArray<float> sourceDepthBuffer;
  					//copy the image into our local cache
  					sourceRgbaPixelBuffer.resize(sourceWidth * sourceHeight * numBytesPerPixel);
  					sourceDepthBuffer.resize(sourceWidth * sourceHeight);
  					{
  						BT_PROFILE("getScreenPixelsSegmentationMask");
  						m_data->m_glApp->getScreenPixels(&(sourceRgbaPixelBuffer[0]), sourceRgbaPixelBuffer.size(), &sourceDepthBuffer[0], sizeof(float) * sourceDepthBuffer.size());
  					}
  					m_data->m_segmentationMaskBuffer.resize(destinationWidth * destinationHeight, -1);
  
  					//rescale and flip
  					{
  						BT_PROFILE("resize and flip segmentation mask");
  						for (int j = 0; j < destinationHeight; j++)
  						{
  							for (int i = 0; i < destinationWidth; i++)
  							{
  								int xIndex = int(float(i) * (float(sourceWidth) / float(destinationWidth)));
  								int yIndex = int(float(destinationHeight - 1 - j) * (float(sourceHeight) / float(destinationHeight)));
  								btClamp(xIndex, 0, sourceWidth);
  								btClamp(yIndex, 0, sourceHeight);
  								int bytesPerPixel = 4;  //RGBA
  								int sourcePixelIndex = (xIndex + yIndex * sourceWidth) * bytesPerPixel;
  								int sourceDepthIndex = xIndex + yIndex * sourceWidth;
  
  								if (segmentationMaskBuffer)
  								{
  									float depth = sourceDepthBuffer[sourceDepthIndex];
  									if (depth < 1)
  									{
  										int segMask = sourceRgbaPixelBuffer[sourcePixelIndex + 0] + 256 * (sourceRgbaPixelBuffer[sourcePixelIndex + 1]) + 256 * 256 * (sourceRgbaPixelBuffer[sourcePixelIndex + 2]);
  										m_data->m_segmentationMaskBuffer[i + j * destinationWidth] = segMask;
  									}
  									else
  									{
  										m_data->m_segmentationMaskBuffer[i + j * destinationWidth] = -1;
  									}
  								}
  							}
  						}
  					}
  				}
  			}
  
  			getRenderInterface()->setActiveCamera(oldCam);
  
  			if (1)
  			{
  				getRenderInterface()->getActiveCamera()->disableVRCamera();
  				DrawGridData dg;
  				dg.upAxis = m_data->m_glApp->getUpAxis();
  				getRenderInterface()->updateCamera(dg.upAxis);
  				m_data->m_glApp->m_window->startRendering();
  			}
  		}
  		if (pixelsRGBA)
  		{
  			BT_PROFILE("copy rgba pixels");
  
  			for (int i = 0; i < numRequestedPixels * numBytesPerPixel; i++)
  			{
  				pixelsRGBA[i] = m_data->m_rgbaPixelBuffer1[i + startPixelIndex * numBytesPerPixel];
  			}
  		}
  		if (depthBuffer)
  		{
  			BT_PROFILE("copy depth buffer pixels");
  
  			for (int i = 0; i < numRequestedPixels; i++)
  			{
  				depthBuffer[i] = m_data->m_depthBuffer1[i + startPixelIndex];
  			}
  		}
  		if (segmentationMaskBuffer)
  		{
  			BT_PROFILE("copy segmentation mask pixels");
  			for (int i = 0; i < numRequestedPixels; i++)
  			{
  				segmentationMaskBuffer[i] = m_data->m_segmentationMaskBuffer[i + startPixelIndex];
  			}
  		}
  		if (numPixelsCopied)
  			*numPixelsCopied = numRequestedPixels;
  	}
  
  	m_data->m_glApp->setViewport(-1, -1);
  }
  
  struct MyConvertPointerSizeT
  {
  	union {
  		const void* m_ptr;
  		size_t m_int;
  	};
  };
  bool shapePointerCompareFunc(const btCollisionObject* colA, const btCollisionObject* colB)
  {
  	MyConvertPointerSizeT a, b;
  	a.m_ptr = colA->getCollisionShape();
  	b.m_ptr = colB->getCollisionShape();
  	return (a.m_int < b.m_int);
  }
  
  void OpenGLGuiHelper::autogenerateGraphicsObjects(btDiscreteDynamicsWorld* rbWorld)
  {
  	//sort the collision objects based on collision shape, the gfx library requires instances that re-use a shape to be added after eachother
  
  	btAlignedObjectArray<btCollisionObject*> sortedObjects;
  	sortedObjects.reserve(rbWorld->getNumCollisionObjects());
  	for (int i = 0; i < rbWorld->getNumCollisionObjects(); i++)
  	{
  		btCollisionObject* colObj = rbWorld->getCollisionObjectArray()[i];
  		sortedObjects.push_back(colObj);
  	}
  	sortedObjects.quickSort(shapePointerCompareFunc);
  	for (int i = 0; i < sortedObjects.size(); i++)
  	{
  		btCollisionObject* colObj = sortedObjects[i];
  		//btRigidBody* body = btRigidBody::upcast(colObj);
  		//does this also work for btMultiBody/btMultiBodyLinkCollider?
  		btSoftBody* sb = btSoftBody::upcast(colObj);
  		if (sb)
  		{
  			colObj->getCollisionShape()->setUserPointer(sb);
  		}
  		createCollisionShapeGraphicsObject(colObj->getCollisionShape());
  		int colorIndex = colObj->getBroadphaseHandle()->getUid() & 3;
  
  		btVector4 color;
  		color = sColors[colorIndex];
  		if (colObj->getCollisionShape()->getShapeType() == STATIC_PLANE_PROXYTYPE)
  		{
  			color.setValue(1, 1, 1, 1);
  		}
  		createCollisionObjectGraphicsObject(colObj, color);
  	}
  }
  
  void OpenGLGuiHelper::drawText3D(const char* txt, float position[3], float orientation[4], float color[4], float size, int optionFlags)
  {
  	B3_PROFILE("OpenGLGuiHelper::drawText3D");
  
  	btAssert(m_data->m_glApp);
  	m_data->m_glApp->drawText3D(txt, position, orientation, color, size, optionFlags);
  }
  
  void OpenGLGuiHelper::drawText3D(const char* txt, float posX, float posY, float posZ, float size)
  {
  	B3_PROFILE("OpenGLGuiHelper::drawText3D");
  
  	btAssert(m_data->m_glApp);
  	m_data->m_glApp->drawText3D(txt, posX, posY, posZ, size);
  }
  
  struct CommonGraphicsApp* OpenGLGuiHelper::getAppInterface()
  {
  	return m_data->m_glApp;
  }
  
  void OpenGLGuiHelper::dumpFramesToVideo(const char* mp4FileName)
  {
  	if (m_data->m_glApp)
  	{
  		m_data->m_glApp->dumpFramesToVideo(mp4FileName);
  	}
  }
  
  void OpenGLGuiHelper::computeSoftBodyVertices(btCollisionShape* collisionShape,
  											  btAlignedObjectArray<GLInstanceVertex>& gfxVertices,
  											  btAlignedObjectArray<int>& indices)
  {
  	if (collisionShape->getUserPointer() == 0)
  		return;
  	b3Assert(collisionShape->getUserPointer());
  	btSoftBody* psb = (btSoftBody*)collisionShape->getUserPointer();
  	gfxVertices.resize(psb->m_faces.size() * 3);
  
  	for (int i = 0; i < psb->m_faces.size(); i++)  // Foreach face
  	{
  		for (int k = 0; k < 3; k++)  // Foreach vertex on a face
  		{
  			int currentIndex = i * 3 + k;
  			for (int j = 0; j < 3; j++)
  			{
  				gfxVertices[currentIndex].xyzw[j] = psb->m_faces[i].m_n[k]->m_x[j];
  			}
  			for (int j = 0; j < 3; j++)
  			{
  				gfxVertices[currentIndex].normal[j] = psb->m_faces[i].m_n[k]->m_n[j];
  			}
  			for (int j = 0; j < 2; j++)
  			{
  				gfxVertices[currentIndex].uv[j] = 0.5;  //we don't have UV info...
  			}
  			indices.push_back(currentIndex);
  		}
  	}
  }
  