add RenderInstancingDemo

allow to use OpenGL2 or OpenGL3 in same binary (will add command-line switch)

btgui/OpenGLWindow/CommonRenderInterface.h

@@ -54,6 +54,7 @@ struct CommonRenderInterface
 	virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex)=0;
 	virtual void writeSingleInstanceColorToCPU(float* color, int srcIndex)=0;
 	virtual void writeSingleInstanceColorToCPU(double* color, int srcIndex)=0;
+    
 	virtual void writeTransforms()=0;
     virtual void enableBlend(bool blend)=0;
 };

btgui/OpenGLWindow/OpenGL2Include.h

@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2012 Advanced Micro Devices, Inc.
+
+This software is provided 'as-is', without any express or implied warranty.
+In no event will the authors be held liable for any damages arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it freely,
+subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+*/
+//Originally written by Erwin Coumans
+
+
+#ifndef __OPENGL_INCLUDE_H
+#define __OPENGL_INCLUDE_H
+
+
+//think different
+#if defined(__APPLE__) && !defined (VMDMESA)
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#else
+
+#include "GlewWindows/GL/glew.h"
+
+#ifdef _WINDOWS
+#include <windows.h>
+//#include <GL/gl.h>
+//#include <GL/glu.h>
+#else
+//#include <GL/gl.h>
+//#include <GL/glu.h>
+#endif //_WINDOWS
+#endif //APPLE
+
+//disable glGetError
+//#undef glGetError
+//#define glGetError MyGetError
+//
+//GLenum inline MyGetError()
+//{
+//	return 0;
+//}
+
+///on Linux only glDrawElementsInstancedARB is defined?!?
+//#ifdef __linux
+//#define glDrawElementsInstanced glDrawElementsInstancedARB
+//
+//#endif //__linux
+
+#endif //__OPENGL_INCLUDE_H
+

btgui/OpenGLWindow/SimpleOpenGL2App.cpp

@@ -194,3 +194,14 @@ void SimpleOpenGL2App::drawText( const char* txt, int posX, int posY)
 {
 
 }
+
+void SimpleOpenGL2App::drawText3D( const char* txt, float posX, float posZY, float posZ, float size)
+{
+
+}
+
+void SimpleOpenGL2App::registerGrid(int xres, int yres, float color0[4], float color1[4])
+{
+    
+}
+

btgui/OpenGLWindow/SimpleOpenGL2App.h

@@ -27,5 +27,9 @@ public:
 	{
 		return 0;
 	}
+    virtual void drawText3D( const char* txt, float posX, float posZY, float posZ, float size);
+    virtual void registerGrid(int xres, int yres, float color0[4], float color1[4]);
+
+    
 };
 #endif //SIMPLE_OPENGL2_APP_H

btgui/OpenGLWindow/SimpleOpenGL2Renderer.cpp

@@ -0,0 +1,199 @@
+
+#include "SimpleOpenGL2Renderer.h"
+#include "OpenGL2Include.h"
+#include "Bullet3Common/b3Vector3.h"
+
+
+SimpleOpenGL2Renderer::SimpleOpenGL2Renderer(int width, int height)
+ :m_width(width),
+ m_height(height)
+{
+    
+}
+
+void SimpleOpenGL2Renderer::init()
+{
+}
+
+void SimpleOpenGL2Renderer::updateCamera(int upAxis)
+{
+    float projection[16];
+    float view[16];
+    m_camera.setAspectRatio((float)m_width/(float)m_height);
+    m_camera.update();
+    m_camera.getCameraProjectionMatrix(projection);
+    m_camera.getCameraViewMatrix(view);
+    GLfloat projMat[16];
+    GLfloat viewMat[16];
+    for (int i=0;i<16;i++)
+    {
+        viewMat[i] = view[i];
+        projMat[i] = projection[i];
+    }
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMultMatrixf(projMat);
+    
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glMultMatrixf(viewMat);
+}
+
+void SimpleOpenGL2Renderer::removeAllInstances()
+{
+}
+
+void SimpleOpenGL2Renderer::setCameraDistance(float dist)
+{
+    m_camera.setCameraDistance(dist);
+}
+
+void SimpleOpenGL2Renderer::setCameraPitch(float pitch)
+{
+    m_camera.setCameraPitch(pitch);
+}
+
+void SimpleOpenGL2Renderer::setCameraTargetPosition(float x, float y, float z)
+{
+    m_camera.setCameraTargetPosition(x,y,z);
+}
+    
+void	SimpleOpenGL2Renderer::getCameraPosition(float cameraPos[4])
+{
+    float pos[3];
+    m_camera.getCameraPosition(pos);
+    cameraPos[0] = pos[0];
+    cameraPos[1] = pos[1];
+    cameraPos[2] = pos[2];
+    
+}
+
+void	SimpleOpenGL2Renderer::getCameraPosition(double cameraPos[4])
+{
+    float pos[3];
+    m_camera.getCameraPosition(pos);
+    cameraPos[0] = pos[0];
+    cameraPos[1] = pos[1];
+    cameraPos[2] = pos[2];
+}
+    
+void	SimpleOpenGL2Renderer::setCameraTargetPosition(float cameraPos[4])
+{
+    m_camera.setCameraTargetPosition(cameraPos[0],cameraPos[1],cameraPos[2]);
+}
+
+void	SimpleOpenGL2Renderer::getCameraTargetPosition(float cameraPos[4]) const
+{
+    m_camera.getCameraTargetPosition(cameraPos);
+}
+
+void	SimpleOpenGL2Renderer::getCameraTargetPosition(double cameraPos[4]) const
+{
+    cameraPos[0] = 1;
+    cameraPos[1] = 1;
+    cameraPos[2] = 1;
+}
+
+void SimpleOpenGL2Renderer::writeSingleInstanceColorToCPU(float* color, int srcIndex)
+{
+}
+void SimpleOpenGL2Renderer::writeSingleInstanceColorToCPU(double* color, int srcIndex)
+{
+    
+}
+void	SimpleOpenGL2Renderer::getCameraViewMatrix(float viewMat[16]) const
+{
+    b3Assert(0);
+}
+void	SimpleOpenGL2Renderer::getCameraProjectionMatrix(float projMat[16]) const
+{
+    b3Assert(0);
+    
+}
+
+
+void SimpleOpenGL2Renderer::renderScene()
+{
+}
+    
+    
+
+
+int SimpleOpenGL2Renderer::registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling)
+{
+    return 0;
+}
+
+int SimpleOpenGL2Renderer::registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling)
+{
+    return 0;
+}
+
+void SimpleOpenGL2Renderer::drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize)
+{
+    int pointStrideInFloats = pointStrideInBytes/4;
+    glLineWidth(pointDrawSize);
+    for (int i=0;i<numIndices;i+=2)
+    {
+        int index0 = indices[i];
+        int index1 = indices[i+1];
+        
+        b3Vector3 fromColor = b3MakeVector3(color[0],color[1],color[2]);
+        b3Vector3 toColor = b3MakeVector3(color[0],color[1],color[2]);
+        
+        b3Vector3 from= b3MakeVector3(positions[index0*pointStrideInFloats],positions[index0*pointStrideInFloats+1],positions[index0*pointStrideInFloats+2]);
+        b3Vector3 to= b3MakeVector3(positions[index1*pointStrideInFloats],positions[index1*pointStrideInFloats+1],positions[index1*pointStrideInFloats+2]);
+        
+        glBegin(GL_LINES);
+        glColor3f(fromColor.getX(), fromColor.getY(), fromColor.getZ());
+        glVertex3d(from.getX(), from.getY(), from.getZ());
+        glColor3f(toColor.getX(), toColor.getY(), toColor.getZ());
+        glVertex3d(to.getX(), to.getY(), to.getZ());
+        glEnd();
+        
+    }
+}
+
+void SimpleOpenGL2Renderer::drawLine(const float from[4], const float to[4], const float color[4], float lineWidth)
+{
+        glLineWidth(lineWidth);
+        glBegin(GL_LINES);
+        glColor3f(color[0],color[1],color[2]);
+        glVertex3d(from[0],from[1],from[2]);
+        glVertex3d(to[0],to[1],to[2]);
+        glEnd();
+}
+int SimpleOpenGL2Renderer::registerShape(const float* vertices, int numvertices, const int* indices, int numIndices,int primitiveType, int textureIndex)
+{
+    return 0;
+}
+
+void SimpleOpenGL2Renderer::writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex)
+{
+}
+void SimpleOpenGL2Renderer::writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex)
+{
+}
+void SimpleOpenGL2Renderer::writeTransforms()
+{
+}
+
+
+void SimpleOpenGL2Renderer::drawLine(const double from[4], const double to[4], const double color[4], double lineWidth)
+{
+    
+}
+void SimpleOpenGL2Renderer::drawPoint(const float* position, const float color[4], float pointDrawSize)
+{
+}
+void SimpleOpenGL2Renderer::drawPoint(const double* position, const double color[4], double pointDrawSize)
+{
+}
+
+void SimpleOpenGL2Renderer::updateShape(int shapeIndex, const float* vertices)
+{
+}
+
+void SimpleOpenGL2Renderer::enableBlend(bool blend)
+{
+}

btgui/OpenGLWindow/SimpleOpenGL2Renderer.h

@@ -0,0 +1,81 @@
+
+#ifndef SIMPLE_OPENGL2_RENDERER_H
+#define SIMPLE_OPENGL2_RENDERER_H
+
+#include "CommonRenderInterface.h"
+#include "SimpleCamera.h"
+
+struct SimpleOpenGL2Renderer : public CommonRenderInterface
+{
+    int m_width;
+    int m_height;
+    SimpleCamera	m_camera;
+    
+    SimpleOpenGL2Renderer(int width, int height);
+    
+    virtual void init();
+    
+    virtual void updateCamera(int upAxis);
+    
+    virtual void removeAllInstances();
+    
+    virtual void setCameraDistance(float dist);
+    
+    virtual void setCameraPitch(float pitch);
+    
+    virtual void setCameraTargetPosition(float x, float y, float z);
+    
+    virtual void	getCameraPosition(float cameraPos[4]);
+    
+    virtual void	getCameraPosition(double cameraPos[4]);
+    
+    virtual void	setCameraTargetPosition(float cameraPos[4]);
+    
+    virtual void	getCameraTargetPosition(float cameraPos[4]) const;
+    
+    virtual void	getCameraTargetPosition(double cameraPos[4]) const;
+    
+    virtual void writeSingleInstanceColorToCPU(float* color, int srcIndex);
+    virtual void writeSingleInstanceColorToCPU(double* color, int srcIndex);
+    virtual void	getCameraViewMatrix(float viewMat[16]) const;
+    virtual void	getCameraProjectionMatrix(float projMat[16]) const;
+
+    
+    virtual void renderScene();
+    
+    virtual int getScreenWidth()
+    {
+        return m_width;
+    }
+    virtual int getScreenHeight()
+    {
+        return m_height;
+    }
+    virtual int registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling);
+    
+    virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+    
+    virtual void drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize);
+    
+    virtual void drawLine(const float from[4], const float to[4], const float color[4], float lineWidth);
+    
+    virtual int registerShape(const float* vertices, int numvertices, const int* indices, int numIndices,int primitiveType=B3_GL_TRIANGLES, int textureIndex=-1);
+    
+    virtual void writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex);
+    
+    virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex);
+    
+    virtual void writeTransforms();
+    
+    virtual void drawLine(const double from[4], const double to[4], const double color[4], double lineWidth);
+    
+    virtual void drawPoint(const float* position, const float color[4], float pointDrawSize);
+    
+    virtual void drawPoint(const double* position, const double color[4], double pointDrawSize);
+    
+    virtual void updateShape(int shapeIndex, const float* vertices);
+    
+    virtual void enableBlend(bool blend);
+    
+};
+#endif //SIMPLE_OPENGL2_RENDERER_H