add initial examples, replacing the 'Demos/Demos3'. Will make it work cross-platform, OpenGL3/OpenGL2 and add more examples to it.

examples/OpenGLWindow/CMakeLists.txt

@@ -0,0 +1,65 @@
+
+INCLUDE_DIRECTORIES(
+	..
+	../../src
+)
+
+FILE(GLOB OpenGLWindow_HDRS "*.h" )
+
+FILE(GLOB OpenGLWindowMac_CPP "Mac*.mm")
+FILE(GLOB OpenGLWindowWin32_CPP "Win32*.cpp")
+FILE(GLOB OpenGLWindowLinux_CPP "X11*.cpp")
+
+FILE(GLOB OpenGLWindowCommon_CPP "*.cpp" )
+
+LIST(REMOVE_ITEM OpenGLWindowCommon_CPP ${OpenGLWindowMac_CPP} )
+LIST(REMOVE_ITEM OpenGLWindowCommon_CPP ${OpenGLWindowWin32_CPP} )
+LIST(REMOVE_ITEM OpenGLWindowCommon_CPP ${OpenGLWindowLinux_CPP} )
+LIST(REMOVE_ITEM OpenGLWindowCommon_CPP X11OpenGLWindow.cpp )
+#MESSAGE (${OpenGLWindowCommon_CPP})
+
+IF (WIN32)
+	SET(OpenGLWindow_SRCS GlewWindows/glew.c ${OpenGLWindowWin32_CPP} ${OpenGLWindowCommon_CPP})	
+	INCLUDE_DIRECTORIES(
+				GlewWindows
+	)
+	ADD_DEFINITIONS(-DGLEW_STATIC)
+ENDIF(WIN32)
+
+IF (APPLE)
+	SET(OpenGLWindow_SRCS ${OpenGLWindowMac_CPP} ${OpenGLWindowCommon_CPP} )
+ENDIF(APPLE)
+
+#no Linux detection?
+IF(NOT WIN32 AND NOT APPLE)
+	INCLUDE_DIRECTORIES(
+                                GlewWindows
+        )
+        ADD_DEFINITIONS(-DGLEW_STATIC)
+	ADD_DEFINITIONS("-DGLEW_INIT_OPENGL11_FUNCTIONS=1")
+        ADD_DEFINITIONS("-DGLEW_DYNAMIC_LOAD_ALL_GLX_FUNCTIONS=1")
+
+	SET(OpenGLWindow_SRCS ${OpenGLWindowLinux_CPP} GlewWindows/glew.c ${OpenGLWindowCommon_CPP} )
+ENDIF()
+
+
+
+ADD_LIBRARY(OpenGLWindow ${OpenGLWindow_SRCS} ${OpenGLWindow_HDRS})
+if (UNIX AND NOT APPLE)
+  target_link_libraries(OpenGLWindow X11)
+elseif (APPLE)
+  target_link_libraries(OpenGLWindow ${COCOA_LIBRARY})
+endif ()
+
+if (BUILD_SHARED_LIBS)
+  target_link_libraries(OpenGLWindow Bullet3Common)
+  if (WIN32 OR APPLE)
+   target_link_libraries(OpenGLWindow ${OPENGL_gl_LIBRARY})
+  else()
+	set (CMAKE_THREAD_PREFER_PTHREAD TRUE)
+        FIND_PACKAGE(Threads)
+   	target_link_libraries(OpenGLWindow ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+endif()
+
+#target_link_libraries(OpenGLWindow ${OPENGL_gl_LIBRARY})

examples/OpenGLWindow/GLInstanceGraphicsShape.h

@@ -0,0 +1,22 @@
+#ifndef GL_INSTANCE_GRAPHICS_SHAPE_H
+#define GL_INSTANCE_GRAPHICS_SHAPE_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+struct GLInstanceVertex
+{
+	float xyzw[4];
+	float normal[3];
+	float uv[2];
+};
+struct GLInstanceGraphicsShape
+{
+	b3AlignedObjectArray<GLInstanceVertex>*	m_vertices;
+	int				m_numvertices;
+	b3AlignedObjectArray<int>* 		m_indices;
+	int				m_numIndices;
+	float			m_scaling[4];
+};
+
+#endif //GL_INSTANCE_GRAPHICS_SHAPE_H
+

examples/OpenGLWindow/GLInstanceRendererInternalData.h

@@ -0,0 +1,20 @@
+#ifndef GL_INSTANCE_RENDERER_INTERNAL_DATA_H
+#define GL_INSTANCE_RENDERER_INTERNAL_DATA_H
+
+#include "OpenGLInclude.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+
+struct GLInstanceRendererInternalData
+{
+	
+	b3AlignedObjectArray<GLfloat> m_instance_positions_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_quaternion_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_colors_ptr;
+	b3AlignedObjectArray<GLfloat> m_instance_scale_ptr;
+
+	int 								m_vboSize;
+	GLuint								m_vbo;
+	int									m_totalNumInstances;
+};
+
+#endif //GL_INSTANCE_RENDERER_INTERNAL_DATA_H

examples/OpenGLWindow/GLInstancingRenderer.h

@@ -0,0 +1,174 @@
+/*
+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 GL_INSTANCING_RENDERER_H
+#define GL_INSTANCING_RENDERER_H
+
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "../CommonInterfaces/CommonRenderInterface.h"
+
+
+void b3DefaultMouseButtonCallback( int button, int state, float x, float y);
+void b3DefaultMouseMoveCallback(  float x, float y);
+void b3DefaultKeyboardCallback(int key, int state);
+void b3DefaultWheelCallback( float deltax, float deltay);
+
+
+
+class GLInstancingRenderer : public CommonRenderInterface
+{
+	
+	b3AlignedObjectArray<struct b3GraphicsInstance*> m_graphicsInstances;
+
+	int		m_maxNumObjectCapacity;
+	int		m_maxShapeCapacityInBytes;
+	struct InternalDataRenderer* m_data;
+
+	bool m_textureenabled;
+	bool m_textureinitialized;
+
+	int m_screenWidth;
+	int m_screenHeight;
+	
+	int m_upAxis;
+    bool m_enableBlend;
+    
+	void renderSceneInternal(int renderMode=B3_DEFAULT_RENDERMODE);
+
+	
+public:
+	GLInstancingRenderer(int m_maxObjectCapacity, int maxShapeCapacityInBytes = 56*1024*1024);
+	virtual ~GLInstancingRenderer();
+
+	virtual void init();
+
+	virtual void renderScene();
+
+	void InitShaders();
+	void CleanupShaders();
+	void removeAllInstances();
+
+	virtual void updateShape(int shapeIndex, const float* vertices);
+
+	///vertices must be in the format x,y,z, nx,ny,nz, u,v
+	virtual int registerShape(const float* vertices, int numvertices, const int* indices, int numIndices, int primitiveType=B3_GL_TRIANGLES, int textureIndex=-1);
+	
+	virtual int	registerTexture(const unsigned char* texels, int width, int height);
+
+	///position x,y,z, quaternion x,y,z,w, color r,g,b,a, scaling x,y,z
+	virtual int registerGraphicsInstance(int shapeIndex, const float* position, const float* quaternion, const float* color, const float* scaling);
+	virtual int registerGraphicsInstance(int shapeIndex, const double* position, const double* quaternion, const double* color, const double* scaling);
+
+	void writeTransforms();
+
+	virtual void writeSingleInstanceTransformToCPU(const float* position, const float* orientation, int srcIndex);
+	virtual void writeSingleInstanceTransformToCPU(const double* position, const double* orientation, int srcIndex)
+    {
+        float pos[4];
+        float orn[4];
+        pos[0] = (float)position[0];
+        pos[1] = (float)position[1];
+        pos[2] = (float)position[2];
+        pos[3] = (float)position[3];
+        orn[0] =(float)orientation[0];
+        orn[1] =(float)orientation[1];
+        orn[2] =(float)orientation[2];
+        orn[3] =(float)orientation[3];
+        writeSingleInstanceTransformToCPU(pos,orn,srcIndex);
+
+    }
+
+	virtual void writeSingleInstanceTransformToGPU(float* position, float* orientation, int srcIndex);
+
+	virtual void writeSingleInstanceColorToCPU(float* color, int srcIndex);
+	virtual void writeSingleInstanceColorToCPU(double* color, int srcIndex);
+
+	virtual void getMouseDirection(float* dir, int mouseX, int mouseY);
+
+	struct	GLInstanceRendererInternalData* getInternalData();
+
+	virtual void drawLine(const float from[4], const float to[4], const float color[4], float lineWidth=1);
+	virtual void drawLine(const double from[4], const double to[4], const double color[4], double lineWidth=1);
+	virtual void drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize);
+	virtual void drawPoints(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, float pointDrawSize);
+	virtual void drawPoint(const float* position, const float color[4], float pointSize=1);
+	virtual void drawPoint(const double* position, const double color[4], double pointDrawSize=1);
+	virtual void updateCamera(int upAxis=1);
+
+	virtual void	getCameraPosition(float cameraPos[4]);
+	virtual void	getCameraPosition(double cameraPos[4])
+    {
+        float campos[4];
+        getCameraPosition(campos);
+        cameraPos[0] = campos[0];
+        cameraPos[1] = campos[1];
+        cameraPos[2] = campos[2];
+        cameraPos[3] = campos[3];
+    }
+
+	virtual void	setCameraDistance(float dist);
+	virtual float	getCameraDistance() const;
+
+	//set the camera 'target'
+	virtual void	setCameraTargetPosition(float x, float y, float z);
+	virtual void	setCameraTargetPosition(float cameraPos[4]);
+	virtual void	getCameraTargetPosition(float cameraPos[4]) const;
+    virtual void	getCameraTargetPosition(double cameraPos[4]) const
+    {
+        float campos[4];
+        getCameraTargetPosition(campos);
+        cameraPos[0] = campos[0];
+        cameraPos[1] = campos[1];
+        cameraPos[2] = campos[2];
+        cameraPos[3] = campos[3];
+        
+    }
+	
+	virtual void	setCameraYaw(float yaw);
+	virtual void	setCameraPitch(float pitch);
+	virtual float	getCameraYaw() const;
+	virtual float	getCameraPitch() const;
+
+	virtual void	getCameraViewMatrix(float viewMat[16]) const;
+	virtual void	getCameraProjectionMatrix(float projMat[16]) const;
+
+
+	virtual void	resize(int width, int height);
+	virtual int	getScreenWidth()
+	{
+		return m_screenWidth;
+	}
+	virtual int getScreenHeight()
+	{
+		return m_screenHeight;
+	}
+
+	virtual int getMaxShapeCapacity() const
+	{
+		return m_maxShapeCapacityInBytes;
+	}
+	virtual int getInstanceCapacity() const
+	{
+		return m_maxNumObjectCapacity;
+	}
+	virtual void enableShadowMap();
+    virtual void enableBlend(bool blend)
+    {
+        m_enableBlend = blend;
+    }
+
+};
+
+#endif //GL_INSTANCING_RENDERER_H

examples/OpenGLWindow/GLPrimInternalData.h

@@ -0,0 +1,21 @@
+#ifndef PRIM_INTERNAL_DATA
+#define PRIM_INTERNAL_DATA
+
+#include "OpenGLInclude.h"
+
+struct PrimInternalData
+{
+	GLuint m_shaderProg;
+	GLint m_viewmatUniform;
+	GLint m_projMatUniform;
+    GLint m_positionUniform;
+    GLint m_colourAttribute;
+    GLint m_positionAttribute;
+    GLint m_textureAttribute;
+    GLuint m_vertexBuffer;
+    GLuint m_vertexArrayObject;
+    GLuint  m_indexBuffer;
+    GLuint m_texturehandle;
+};
+
+#endif //PRIM_INTERNAL_DATA

examples/OpenGLWindow/GLPrimitiveRenderer.cpp

@@ -0,0 +1,322 @@
+#include "GLPrimitiveRenderer.h"
+#include "GLPrimInternalData.h"
+
+#include "LoadShader.h"
+
+#include <assert.h>
+
+static const char* vertexShader3D= \
+"#version 150   \n"
+"\n"
+"uniform mat4 viewMatrix, projMatrix;\n"
+"in vec4 position;\n"
+"in vec4 colour;\n"
+"out vec4 colourV;\n"
+"\n"
+"in vec2 texuv;\n"
+"out vec2 texuvV;\n"
+"\n"
+"\n"
+"void main (void)\n"
+"{\n"
+"    colourV = colour;\n"
+"   gl_Position = projMatrix * viewMatrix * position ;\n"
+"	texuvV=texuv;\n"
+"}\n";
+
+static const char* fragmentShader3D= \
+"#version 150\n"
+"\n"
+"uniform vec2 p;\n"
+"in vec4 colourV;\n"
+"out vec4 fragColour;\n"
+"in vec2 texuvV;\n"
+"\n"
+"uniform sampler2D Diffuse;\n"
+"\n"
+"void main(void)\n"
+"{\n"
+"	vec4 texcolor = texture(Diffuse,texuvV);\n"
+"  if (p.x==0.f)\n"
+"  {\n"
+"		texcolor = vec4(1,1,1,texcolor.x);\n"
+"  }\n"
+"   fragColour = colourV*texcolor;\n"
+"}\n";
+
+
+
+static unsigned int s_indexData[6] = {0,1,2,0,2,3};
+
+
+   
+
+
+GLPrimitiveRenderer::GLPrimitiveRenderer(int screenWidth, int screenHeight)
+:m_screenWidth(screenWidth),
+m_screenHeight(screenHeight)
+{
+    
+	m_data = new PrimInternalData;
+
+    m_data->m_shaderProg = gltLoadShaderPair(vertexShader3D,fragmentShader3D);
+	
+	m_data->m_viewmatUniform = glGetUniformLocation(m_data->m_shaderProg,"viewMatrix");
+	if (m_data->m_viewmatUniform < 0) {
+		assert(0);
+	}
+	m_data->m_projMatUniform = glGetUniformLocation(m_data->m_shaderProg,"projMatrix");
+	if (m_data->m_projMatUniform < 0) {
+		assert(0);
+	}
+    m_data->m_positionUniform = glGetUniformLocation(m_data->m_shaderProg, "p");
+    if (m_data->m_positionUniform < 0) {
+		assert(0);
+	}
+	m_data->m_colourAttribute = glGetAttribLocation(m_data->m_shaderProg, "colour");
+	if (m_data->m_colourAttribute < 0) {
+        assert(0);
+    }
+	m_data->m_positionAttribute = glGetAttribLocation(m_data->m_shaderProg, "position");
+	if (m_data->m_positionAttribute < 0) {
+		assert(0);
+  	}
+	m_data->m_textureAttribute = glGetAttribLocation(m_data->m_shaderProg,"texuv");
+	if (m_data->m_textureAttribute < 0) {
+		assert(0);
+	}
+
+    loadBufferData();
+    
+}
+
+void GLPrimitiveRenderer::loadBufferData()
+{
+    
+    PrimVertex vertexData[4] = {
+        { PrimVec4(-1, -1, 0.0, 1.0 ), PrimVec4( 1.0, 0.0, 0.0, 1.0 ) ,PrimVec2(0,0)},
+        { PrimVec4(-1,  1, 0.0, 1.0 ), PrimVec4( 0.0, 1.0, 0.0, 1.0 ) ,PrimVec2(0,1)},
+        { PrimVec4( 1,  1, 0.0, 1.0 ), PrimVec4( 0.0, 0.0, 1.0, 1.0 ) ,PrimVec2(1,1)},
+        { PrimVec4( 1, -1, 0.0, 1.0 ), PrimVec4( 1.0, 1.0, 1.0, 1.0 ) ,PrimVec2(1,0)}
+    };
+    
+        
+    glGenVertexArrays(1, &m_data->m_vertexArrayObject);
+    glBindVertexArray(m_data->m_vertexArrayObject);
+    
+    glGenBuffers(1, &m_data->m_vertexBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(PrimVertex), vertexData, GL_DYNAMIC_DRAW);
+    
+    assert(glGetError()==GL_NO_ERROR);
+    
+    
+    
+    glGenBuffers(1, &m_data->m_indexBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_data->m_indexBuffer);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER,6*sizeof(int), s_indexData,GL_STATIC_DRAW);
+    
+    glEnableVertexAttribArray(m_data->m_positionAttribute);
+    glEnableVertexAttribArray(m_data->m_colourAttribute);
+	assert(glGetError()==GL_NO_ERROR);
+    
+	glEnableVertexAttribArray(m_data->m_textureAttribute);
+    
+    glVertexAttribPointer(m_data->m_positionAttribute, 4, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)0);
+    glVertexAttribPointer(m_data->m_colourAttribute  , 4, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)sizeof(PrimVec4));
+    glVertexAttribPointer(m_data->m_textureAttribute , 2, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)(sizeof(PrimVec4)+sizeof(PrimVec4)));
+	assert(glGetError()==GL_NO_ERROR);
+    
+    
+    
+    
+    
+    
+    
+    glActiveTexture(GL_TEXTURE0);
+    
+    GLubyte*	image=new GLubyte[256*256*3];
+    for(int y=0;y<256;++y)
+    {
+     //   const int	t=y>>5;
+        GLubyte*	pi=image+y*256*3;
+        for(int x=0;x<256;++x)
+        {
+            if (x<y)//x<2||y<2||x>253||y>253)
+            {
+                pi[0]=255;
+                pi[1]=0;
+                pi[2]=0;
+            } else
+			
+            {
+                pi[0]=255;
+                pi[1]=255;
+                pi[2]=255;
+            }
+            
+            pi+=3;
+        }
+    }
+    
+    glGenTextures(1,(GLuint*)&m_data->m_texturehandle);
+    glBindTexture(GL_TEXTURE_2D,m_data->m_texturehandle);
+    
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256,256,0,GL_RGB,GL_UNSIGNED_BYTE,image);
+    glGenerateMipmap(GL_TEXTURE_2D);
+    
+    assert(glGetError()==GL_NO_ERROR);
+    
+    delete[] image;
+    
+    
+}
+
+
+
+GLPrimitiveRenderer::~GLPrimitiveRenderer()
+{
+	glBindTexture(GL_TEXTURE_2D,0);
+	glUseProgram(0);
+	 glBindTexture(GL_TEXTURE_2D,0);
+    glDeleteProgram(m_data->m_shaderProg);
+	delete m_data;
+}
+
+void GLPrimitiveRenderer::drawLine()
+{
+
+}
+
+void GLPrimitiveRenderer::drawRect(float x0, float y0, float x1, float y1, float color[4])
+{
+	assert(glGetError()==GL_NO_ERROR);
+	glActiveTexture(GL_TEXTURE0);
+	assert(glGetError()==GL_NO_ERROR);
+	
+	 glBindTexture(GL_TEXTURE_2D,m_data->m_texturehandle);
+	assert(glGetError()==GL_NO_ERROR);
+	drawTexturedRect(x0,y0,x1,y1,color,0,0,1,1);
+	assert(glGetError()==GL_NO_ERROR);
+
+}
+
+
+void GLPrimitiveRenderer::drawTexturedRect3D(const PrimVertex& v0,const PrimVertex& v1,const PrimVertex& v2,const PrimVertex& v3,float viewMat[16],float projMat[16], bool useRGBA)
+{
+	
+    assert(glGetError()==GL_NO_ERROR);
+   
+    
+    glUseProgram(m_data->m_shaderProg);
+ 
+	glUniformMatrix4fv(m_data->m_viewmatUniform, 1, false, viewMat);
+	glUniformMatrix4fv(m_data->m_projMatUniform, 1, false, projMat);
+
+    assert(glGetError()==GL_NO_ERROR);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vertexBuffer);
+    glBindVertexArray(m_data->m_vertexArrayObject);
+    
+	bool useFiltering = false;
+	if (useFiltering)
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	} else
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	}
+
+	   PrimVertex vertexData[4] = {
+		   v0,v1,v2,v3
+		};
+    
+	   glBufferSubData(GL_ARRAY_BUFFER, 0,4 * sizeof(PrimVertex), vertexData);
+
+
+
+    
+    
+    
+    assert(glGetError()==GL_NO_ERROR);
+    
+    PrimVec2 p( 0.f,0.f);//?b?0.5f * sinf(timeValue), 0.5f * cosf(timeValue) );
+	if (useRGBA)
+	{
+		p.p[0] = 1.f;
+		p.p[1] = 1.f;
+	}
+
+    glUniform2fv(m_data->m_positionUniform, 1, (const GLfloat *)&p);
+    
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+    assert(glGetError()==GL_NO_ERROR);
+    
+    glEnableVertexAttribArray(m_data->m_positionAttribute);
+	assert(glGetError()==GL_NO_ERROR);
+    
+    glEnableVertexAttribArray(m_data->m_colourAttribute);
+	assert(glGetError()==GL_NO_ERROR);
+    
+	glEnableVertexAttribArray(m_data->m_textureAttribute);
+    
+    glVertexAttribPointer(m_data->m_positionAttribute, 4, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)0);
+    glVertexAttribPointer(m_data->m_colourAttribute  , 4, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)sizeof(PrimVec4));
+    glVertexAttribPointer(m_data->m_textureAttribute , 2, GL_FLOAT, GL_FALSE, sizeof(PrimVertex), (const GLvoid *)(sizeof(PrimVec4)+sizeof(PrimVec4)));
+	assert(glGetError()==GL_NO_ERROR);
+    
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_data->m_indexBuffer);
+    
+    //glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    int indexCount = 6;
+    assert(glGetError()==GL_NO_ERROR);
+    
+	
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
+    assert(glGetError()==GL_NO_ERROR);
+	
+	
+    glBindVertexArray(0);
+    assert(glGetError()==GL_NO_ERROR);
+
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+    assert(glGetError()==GL_NO_ERROR);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    assert(glGetError()==GL_NO_ERROR);
+
+	//glDisableVertexAttribArray(m_data->m_textureAttribute);
+    assert(glGetError()==GL_NO_ERROR);
+
+	glUseProgram(0);
+   
+    assert(glGetError()==GL_NO_ERROR);
+
+}
+
+
+void GLPrimitiveRenderer::drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0,float v0, float u1, float v1, int useRGBA)
+{
+    float identity[16]={1,0,0,0,
+						0,1,0,0,
+						0,0,1,0,
+						0,0,0,1};
+	   PrimVertex vertexData[4] = {
+        { PrimVec4(-1.f+2.f*x0/float(m_screenWidth), 1.f-2.f*y0/float(m_screenHeight), 0.f, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v0)},
+        { PrimVec4(-1.f+2.f*x0/float(m_screenWidth),  1.f-2.f*y1/float(m_screenHeight), 0.f, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v1)},
+        { PrimVec4( -1.f+2.f*x1/float(m_screenWidth),  1.f-2.f*y1/float(m_screenHeight), 0.f, 1.f ), PrimVec4(color[0], color[1], color[2], color[3]) ,PrimVec2(u1,v1)},
+        { PrimVec4( -1.f+2.f*x1/float(m_screenWidth), 1.f-2.f*y0/float(m_screenHeight), 0.f, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u1,v0)}
+    };
+    
+	drawTexturedRect3D(vertexData[0],vertexData[1],vertexData[2],vertexData[3],identity,identity,useRGBA);
+}
+
+void GLPrimitiveRenderer::setScreenSize(int width, int height)
+{
+	m_screenWidth = width;
+	m_screenHeight = height;
+    
+}

examples/OpenGLWindow/GLPrimitiveRenderer.h

@@ -0,0 +1,67 @@
+#ifndef _GL_PRIMITIVE_RENDERER_H
+#define _GL_PRIMITIVE_RENDERER_H
+
+//#include "OpenGLInclude.h"
+
+struct PrimVec2
+{
+	PrimVec2(float x, float y)
+	{
+		p[0] = x;
+		p[1] = y;
+	}
+	float p[2];
+};
+
+struct PrimVec4
+{
+	PrimVec4() {}
+	PrimVec4(float x,float y, float z, float w)
+	{
+		p[0] = x;
+		p[1] = y;
+		p[2] = z;
+		p[3] = w;
+        
+	}
+    
+	float p[4];
+};
+
+typedef struct
+{
+    PrimVec4 position;
+    PrimVec4 colour;
+	PrimVec2 uv;
+} PrimVertex;
+
+
+class GLPrimitiveRenderer
+{
+    int m_screenWidth;
+    int m_screenHeight;
+
+	struct PrimInternalData*	m_data;
+    
+    void loadBufferData();
+    
+public:
+    
+    GLPrimitiveRenderer(int screenWidth, int screenHeight);
+    virtual ~GLPrimitiveRenderer();
+	
+	void drawRect(float x0, float y0, float x1, float y1, float color[4]);
+    void drawTexturedRect(float x0, float y0, float x1, float y1, float color[4], float u0,float v0, float u1, float v1, int useRGBA=0);
+	void drawTexturedRect3D(const PrimVertex& v0,const PrimVertex& v1,const PrimVertex& v2,const PrimVertex& v3,float viewMat[16],float projMat[16], bool useRGBA = true);
+    void drawLine();//float from[4], float to[4], float color[4]);
+    void setScreenSize(int width, int height);
+    
+	PrimInternalData*	getData()
+	{
+		return m_data;
+	}
+
+};
+
+#endif//_GL_PRIMITIVE_RENDERER_H
+

examples/OpenGLWindow/GLRenderToTexture.cpp

@@ -0,0 +1,135 @@
+
+///See http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
+
+
+#include "GLRenderToTexture.h"
+#include "Bullet3Common/b3Scalar.h" // for b3Assert
+#include <string.h>
+#include <stdio.h>
+
+bool gIntelLinuxglDrawBufferWorkaround=false;
+
+GLRenderToTexture::GLRenderToTexture()
+:m_framebufferName(0)
+{
+#if !defined(_WIN32) && !defined(__APPLE__)
+ const GLubyte* ven = glGetString(GL_VENDOR);
+	printf("ven = %s\n",ven);
+
+ if (strncmp((const char*)ven,"Intel",5)==0)
+       {
+               printf("Workaround for some crash in the Intel OpenGL driver on Linux/Ubuntu\n");
+               gIntelLinuxglDrawBufferWorkaround=true;
+       }
+#endif//!defined(_WIN32) && !defined(__APPLE__)
+
+}
+
+void GLRenderToTexture::init(int width, int height, GLuint textureId, int renderTextureType)
+{
+	m_renderTextureType = renderTextureType;
+
+	glGenFramebuffers(1, &m_framebufferName);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_framebufferName);
+
+
+
+	// The depth buffer
+//	glGenRenderbuffers(1, &m_depthrenderbuffer);
+
+//	glBindRenderbuffer(GL_RENDERBUFFER, m_depthrenderbuffer);
+//	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
+//	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthrenderbuffer);
+
+		switch (m_renderTextureType)
+	{
+	case RENDERTEXTURE_COLOR:
+		{
+			glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureId, 0);
+			break;
+		}
+		case RENDERTEXTURE_DEPTH:
+		{
+			glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, textureId, 0);
+			break;
+		}
+		default:
+			{
+			b3Assert(0);
+			}
+	};
+
+
+	glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+
+
+}
+
+bool GLRenderToTexture::enable()
+{
+	bool status = false;
+
+	glBindFramebuffer(GL_FRAMEBUFFER, m_framebufferName);
+
+
+	switch (m_renderTextureType)
+	{
+	case RENDERTEXTURE_COLOR:
+		{
+			// Set the list of draw buffers.
+			GLenum drawBuffers[2] = {GL_COLOR_ATTACHMENT0,0};
+			glDrawBuffers(1, drawBuffers);
+			break;
+		}
+		case RENDERTEXTURE_DEPTH:
+		{
+			//Intel OpenGL driver crashes when using GL_NONE for glDrawBuffer on Linux, so use a workaround
+			if (gIntelLinuxglDrawBufferWorkaround)
+			{
+				GLenum drawBuffers[2] = { GL_COLOR_ATTACHMENT0,0};
+                glDrawBuffers(1, drawBuffers);
+			} else
+			{
+				glDrawBuffer(GL_NONE);
+			}
+			break;
+		}
+		default:
+			{
+			b3Assert(0);
+			}
+	};
+
+
+	// Always check that our framebuffer is ok
+	if(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE)
+	{
+		status = true;
+	}
+
+
+	return status;
+
+}
+
+void GLRenderToTexture::disable()
+{
+	glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+}
+
+GLRenderToTexture::~GLRenderToTexture()
+{
+	glBindFramebuffer( GL_FRAMEBUFFER, 0 );
+
+	if (m_depthrenderbuffer)
+	{
+		glDeleteRenderbuffers(1,&m_depthrenderbuffer);
+	}
+
+
+	if( m_framebufferName)
+	{
+		glDeleteFramebuffers(1, &m_framebufferName);
+	}
+}
+

examples/OpenGLWindow/GLRenderToTexture.h

@@ -0,0 +1,32 @@
+
+#ifndef GL_RENDER_TO_TEXTURE_H
+#define GL_RENDER_TO_TEXTURE_H
+
+///See http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
+#include "OpenGLInclude.h"
+
+enum 
+{
+	RENDERTEXTURE_COLOR=1,
+	RENDERTEXTURE_DEPTH,
+};
+struct GLRenderToTexture
+{
+	GLuint m_framebufferName;
+	GLuint	m_depthrenderbuffer;
+	bool	m_initialized;
+	int		m_renderTextureType;
+public:
+	GLRenderToTexture();
+	
+	void init(int width, int height, GLuint textureId, int renderTextureType=RENDERTEXTURE_COLOR);
+	bool	enable();
+	void	disable();
+	
+	virtual ~GLRenderToTexture();
+	
+};
+
+
+#endif //GL_RENDER_TO_TEXTURE_H
+

examples/OpenGLWindow/GwenOpenGL3CoreRenderer.h

@@ -0,0 +1,393 @@
+
+#ifndef __GWEN_OPENGL3_CORE_RENDERER_H
+#define __GWEN_OPENGL3_CORE_RENDERER_H
+
+#include "Gwen/Gwen.h"
+#include "Gwen/BaseRender.h"
+#include "GLPrimitiveRenderer.h"
+#include "../OpenGLWindow/OpenGLInclude.h"
+
+struct sth_stash;
+#include "fontstash.h"
+#include "Gwen/Texture.h"
+
+#include "TwFonts.h"
+static float extraSpacing = 0.;//6f;
+#include <assert.h>
+#include <math.h>
+
+template <class T>
+inline void MyClamp(T& a, const T& lb, const T& ub) 
+{
+	if (a < lb) 
+	{
+		a = lb; 
+	}
+	else if (ub < a) 
+	{
+		a = ub;
+	}
+}
+
+
+static GLuint BindFont(const CTexFont *_Font)
+{
+    GLuint TexID = 0;
+    glGenTextures(1, &TexID);
+    glBindTexture(GL_TEXTURE_2D, TexID);
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, _Font->m_TexWidth, _Font->m_TexHeight, 0, GL_RED, GL_UNSIGNED_BYTE, _Font->m_TexBytes);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    return TexID;
+}
+
+struct MyTextureLoader
+{
+	virtual ~MyTextureLoader()
+	{
+	}
+	virtual void LoadTexture( Gwen::Texture* pTexture ) = 0;
+	virtual void FreeTexture( Gwen::Texture* pTexture )=0;
+};
+
+class GwenOpenGL3CoreRenderer : public Gwen::Renderer::Base
+{
+	GLPrimitiveRenderer* m_primitiveRenderer;
+	float m_currentColor[4];
+	float m_yOffset;
+    sth_stash* m_font;
+    float m_screenWidth;
+    float m_screenHeight;
+    float m_fontScaling;
+    float m_retinaScale;
+	bool	m_useTrueTypeFont;
+	const CTexFont* m_currentFont;
+	
+	GLuint	m_fontTextureId;
+	MyTextureLoader* m_textureLoader;
+public:
+	GwenOpenGL3CoreRenderer (GLPrimitiveRenderer* primRender, sth_stash* font,float screenWidth, float screenHeight, float retinaScale, MyTextureLoader* loader=0)
+		:m_primitiveRenderer(primRender),
+    m_font(font),
+    m_screenWidth(screenWidth),
+    m_screenHeight(screenHeight),
+    m_retinaScale(retinaScale),
+	m_useTrueTypeFont(false),
+	m_textureLoader(loader)
+	{
+		///only enable true type fonts on Macbook Retina, it looks gorgeous
+		if (retinaScale==2.0f)
+		{
+			m_useTrueTypeFont = true;
+		}
+		m_currentColor[0] = 1;
+		m_currentColor[1] = 1;
+		m_currentColor[2] = 1;
+		m_currentColor[3] = 1;
+        
+        m_fontScaling = 16.f*m_retinaScale;
+		
+		TwGenerateDefaultFonts();
+
+		m_currentFont = g_DefaultNormalFont;
+		//m_currentFont = g_DefaultNormalFontAA;
+
+		//m_currentFont = g_DefaultLargeFont;
+		m_fontTextureId = BindFont(m_currentFont);
+		
+	}
+
+	virtual ~GwenOpenGL3CoreRenderer()
+	{
+		TwDeleteDefaultFonts();
+	}
+	virtual void Resize(int width, int height)
+	{
+		m_screenWidth = width;
+		m_screenHeight = height;
+	}
+	
+	virtual void Begin()
+	{
+		m_yOffset=0;
+		glEnable(GL_BLEND);
+	  assert(glGetError()==GL_NO_ERROR);
+
+
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		
+		assert(glGetError()==GL_NO_ERROR);
+
+		assert(glGetError()==GL_NO_ERROR);
+        
+		glDisable(GL_DEPTH_TEST);
+		assert(glGetError()==GL_NO_ERROR);      
+		//glColor4ub(255,0,0,255);
+		
+		
+		
+		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+	//	saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight);
+			
+		assert(glGetError()==GL_NO_ERROR);
+			
+
+		glDisable(GL_CULL_FACE);
+
+		glDisable(GL_DEPTH_TEST);
+		assert(glGetError()==GL_NO_ERROR);
+
+		        
+		glEnable(GL_BLEND);
+
+		assert(glGetError()==GL_NO_ERROR);        
+	}
+	virtual void End()
+	{
+		glDisable(GL_BLEND);
+		
+	}
+
+	virtual void StartClip()
+	{
+		if (m_useTrueTypeFont)
+			sth_flush_draw(m_font);
+		Gwen::Rect rect = ClipRegion();
+
+		// OpenGL's coords are from the bottom left
+		// so we need to translate them here.
+		{
+			GLint view[4];
+			glGetIntegerv( GL_VIEWPORT, &view[0] );
+			rect.y = view[3]/m_retinaScale - (rect.y + rect.h);
+		}
+
+		glScissor( m_retinaScale * rect.x * Scale(), m_retinaScale * rect.y * Scale(), m_retinaScale * rect.w * Scale(), m_retinaScale * rect.h * Scale() );
+		glEnable( GL_SCISSOR_TEST );
+		//glDisable( GL_SCISSOR_TEST );
+		
+	};
+
+	virtual void EndClip()
+	{
+		if (m_useTrueTypeFont)
+			sth_flush_draw(m_font);
+		glDisable( GL_SCISSOR_TEST );
+	};
+
+	virtual void SetDrawColor( Gwen::Color color )
+	{
+		m_currentColor[0] = color.r/256.f;
+		m_currentColor[1] = color.g/256.f;
+		m_currentColor[2] = color.b/256.f;
+		m_currentColor[3] = color.a/256.f;
+
+	}
+	virtual void DrawFilledRect( Gwen::Rect rect )
+	{
+		Translate( rect );
+
+		m_primitiveRenderer->drawRect(rect.x, rect.y+m_yOffset, rect.x+rect.w, rect.y+rect.h+m_yOffset, m_currentColor);
+//		m_yOffset+=rect.h+10;
+
+	}
+    
+    void RenderText( Gwen::Font* pFont, Gwen::Point rasterPos, const Gwen::UnicodeString& text )
+    {
+		
+        Gwen::String str = Gwen::Utility::UnicodeToString(text);
+        const char* unicodeText = (const char*)str.c_str();
+        
+        Gwen::Rect r;
+        r.x = rasterPos.x;
+        r.y = rasterPos.y;
+        r.w = 0;
+        r.h = 0;
+    
+        
+      //
+        //printf("str = %s\n",unicodeText);
+        //int xpos=0;
+        //int ypos=0;
+        float dx;
+        
+        int measureOnly=0;
+        
+		if (m_useTrueTypeFont)
+		{
+			
+			float yoffset = 0.f;
+			if (m_retinaScale==2.0f)
+			{
+				yoffset = -12;
+			}
+			Translate(r);
+			sth_draw_text(m_font,
+                      1,m_fontScaling,
+                      r.x,r.y+yoffset,
+                      unicodeText,&dx, m_screenWidth,m_screenHeight,measureOnly,m_retinaScale);
+			 
+		} else
+		{
+			//float width = 0.f;
+			int pos=0;
+			//float color[]={0.2f,0.2,0.2f,1.f};
+		
+			glBindTexture(GL_TEXTURE_2D,m_fontTextureId);
+			float width = r.x;
+			while (unicodeText[pos])
+			{
+				int c = unicodeText[pos];
+				r.h = m_currentFont->m_CharHeight;
+				r.w = m_currentFont->m_CharWidth[c]+extraSpacing;
+				Gwen::Rect rect = r;
+				Translate( rect );
+
+				m_primitiveRenderer->drawTexturedRect(rect.x, rect.y+m_yOffset, rect.x+rect.w, rect.y+rect.h+m_yOffset, m_currentColor,m_currentFont->m_CharU0[c],m_currentFont->m_CharV0[c],m_currentFont->m_CharU1[c],m_currentFont->m_CharV1[c]);
+
+				//DrawTexturedRect(0,r,m_currentFont->m_CharU0[c],m_currentFont->m_CharV0[c],m_currentFont->m_CharU1[c],m_currentFont->m_CharV1[c]);
+			//	DrawFilledRect(r);
+
+			
+			
+				width += r.w;
+				r.x = width;
+				pos++;
+				
+			}
+			glBindTexture(GL_TEXTURE_2D,0);
+		}
+
+    }
+    Gwen::Point MeasureText( Gwen::Font* pFont, const Gwen::UnicodeString& text )
+    {
+        Gwen::String str = Gwen::Utility::UnicodeToString(text);
+        const char* unicodeText = (const char*)str.c_str();
+        
+       // printf("str = %s\n",unicodeText);
+        int xpos=0;
+        int ypos=0;
+        
+        
+        int measureOnly=1;
+		float dx=0;
+		if (m_useTrueTypeFont)
+		{
+			sth_draw_text(m_font,
+                      1,m_fontScaling,
+                      xpos,ypos,
+                      unicodeText,&dx, m_screenWidth,m_screenHeight,measureOnly);
+		
+			Gwen::Point pt;
+			
+			if (m_retinaScale==2.0f)
+			{
+				pt.x = dx*Scale()/2.f;
+				pt.y = m_fontScaling/2*Scale()+1;
+			}
+			else
+			{
+				pt.x = dx*Scale();
+				pt.y = m_fontScaling*Scale()+1;
+			}
+			return pt;
+		}
+		else
+		{
+			float width = 0.f;
+			int pos=0;
+			while (unicodeText[pos])
+			{
+				width += m_currentFont->m_CharWidth[(int)unicodeText[pos]]+extraSpacing;
+				pos++;
+			}
+			Gwen::Point pt;
+			int fontHeight = m_currentFont->m_CharHeight;
+
+
+			pt.x = width*Scale();
+			pt.y = (fontHeight+2) * Scale();
+
+			return pt;
+		}
+
+		return Gwen::Renderer::Base::MeasureText(pFont,text);
+    }
+
+	
+	virtual void LoadTexture( Gwen::Texture* pTexture )
+	{
+		if (m_textureLoader)
+			m_textureLoader->LoadTexture(pTexture);
+	}
+	virtual void FreeTexture( Gwen::Texture* pTexture )
+	{
+		if (m_textureLoader)
+			m_textureLoader->FreeTexture(pTexture);
+
+	}
+	
+	
+	virtual void DrawTexturedRect( Gwen::Texture* pTexture, Gwen::Rect rect, float u1=0.0f, float v1=0.0f, float u2=1.0f, float v2=1.0f )
+	{
+
+		Translate( rect );
+
+		//float eraseColor[4] = {0,0,0,0};
+		//m_primitiveRenderer->drawRect(rect.x, rect.y+m_yOffset, rect.x+rect.w, rect.y+rect.h+m_yOffset, eraseColor);
+
+		GLint texHandle = (GLint) pTexture->m_intData;
+		//if (!texHandle)
+		//	return;
+		
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,texHandle);
+//		glDisable(GL_DEPTH_TEST);
+
+		assert(glGetError()==GL_NO_ERROR);
+		
+	
+/*	bool useFiltering = true;
+	if (useFiltering)
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	} else
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	}
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+*/
+	
+	//glEnable(GL_TEXTURE_2D);
+	
+		
+		
+//	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE );
+	static float add=0.0;
+	//add+=1./512.;//0.01;
+	float color[4]={1,1,1,1};
+
+	m_primitiveRenderer->drawTexturedRect(rect.x, rect.y+m_yOffset, rect.x+rect.w, rect.y+rect.h+m_yOffset, color,0+add,0,1+add,1,true);
+
+		
+				assert(glGetError()==GL_NO_ERROR);
+
+		
+		
+	}
+			
+};
+#endif //__GWEN_OPENGL3_CORE_RENDERER_H

examples/OpenGLWindow/LoadShader.cpp

@@ -0,0 +1,111 @@
+#include "LoadShader.h"
+#include "OpenGLInclude.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// Load the shader from the source text
+void gltLoadShaderSrc(const char *szShaderSrc, GLuint shader)
+{
+	GLchar *fsStringPtr[1];
+
+	fsStringPtr[0] = (GLchar *)szShaderSrc;
+	glShaderSource(shader, 1, (const GLchar **)fsStringPtr, NULL);
+}
+
+
+GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
+{
+
+  assert(glGetError()==GL_NO_ERROR);
+
+	// Temporary Shader objects
+	GLuint hVertexShader;
+	GLuint hFragmentShader;
+	GLuint hReturn = 0;
+	GLint testVal;
+
+	// Create shader objects
+	hVertexShader = glCreateShader(GL_VERTEX_SHADER);
+	hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+
+	gltLoadShaderSrc(szVertexProg, hVertexShader);
+	gltLoadShaderSrc(szFragmentProg, hFragmentShader);
+
+	// Compile them
+	glCompileShader(hVertexShader);
+  assert(glGetError()==GL_NO_ERROR);
+
+	glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal);
+	if(testVal == GL_FALSE)
+	{
+        char temp[256] = "";
+        glGetShaderInfoLog( hVertexShader, 256, NULL, temp);
+        fprintf( stderr, "Compile failed:\n%s\n", temp);
+        assert(0);
+        return 0;
+		glDeleteShader(hVertexShader);
+		glDeleteShader(hFragmentShader);
+		return (GLuint)NULL;
+	}
+
+  assert(glGetError()==GL_NO_ERROR);
+
+    glCompileShader(hFragmentShader);
+    assert(glGetError()==GL_NO_ERROR);
+
+    glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal);
+	if(testVal == GL_FALSE)
+	{
+        char temp[256] = "";
+        glGetShaderInfoLog( hFragmentShader, 256, NULL, temp);
+        fprintf( stderr, "Compile failed:\n%s\n", temp);
+        assert(0);
+        exit(0);
+		glDeleteShader(hVertexShader);
+		glDeleteShader(hFragmentShader);
+		return (GLuint)NULL;
+	}
+
+    assert(glGetError()==GL_NO_ERROR);
+
+	// Check for errors
+
+
+
+
+	// Link them - assuming it works...
+	hReturn = glCreateProgram();
+	glAttachShader(hReturn, hVertexShader);
+	glAttachShader(hReturn, hFragmentShader);
+
+	glLinkProgram(hReturn);
+
+	// These are no longer needed
+	glDeleteShader(hVertexShader);
+	glDeleteShader(hFragmentShader);
+
+	// Make sure link worked too
+	glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal);
+	if(testVal == GL_FALSE)
+	{
+		GLsizei maxLen = 4096;
+		GLchar infoLog[4096];
+		GLsizei actualLen;
+
+		glGetProgramInfoLog(	hReturn,
+								maxLen,
+								 &actualLen,
+								 infoLog);
+
+		printf("Warning/Error in GLSL shader:\n");
+		printf("%s\n",infoLog);
+		glDeleteProgram(hReturn);
+		return (GLuint)NULL;
+	}
+
+	return hReturn;
+}
+
+

examples/OpenGLWindow/LoadShader.h

@@ -0,0 +1,18 @@
+#ifndef _LOAD_SHADER_H
+#define _LOAD_SHADER_H
+
+#include "OpenGLInclude.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif//__cplusplus
+
+GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg);
+
+#ifdef __cplusplus
+}
+#endif//__cplusplus
+
+#endif//_LOAD_SHADER_H
+
+

examples/OpenGLWindow/MacOpenGLWindow.h

@@ -0,0 +1,105 @@
+#ifndef MAC_OPENGL_WINDOW_H
+#define MAC_OPENGL_WINDOW_H
+
+#include "b3gWindowInterface.h"
+
+#define b3gDefaultOpenGLWindow MacOpenGLWindow
+
+class MacOpenGLWindow : public b3gWindowInterface
+{
+    struct MacOpenGLWindowInternalData* m_internalData;
+    float m_mouseX;
+    float m_mouseY;
+   int m_modifierFlags;
+   
+    b3MouseButtonCallback m_mouseButtonCallback;
+    b3MouseMoveCallback m_mouseMoveCallback;
+    b3WheelCallback m_wheelCallback;
+    b3KeyboardCallback m_keyboardCallback;
+	b3RenderCallback m_renderCallback;
+	
+    float m_retinaScaleFactor;
+public:
+    
+    MacOpenGLWindow();
+    virtual ~MacOpenGLWindow();
+    
+    void init(int width, int height, const char* windowTitle);
+
+    void closeWindow();
+    
+    void startRendering();
+    
+    void endRendering();//swap buffers
+    
+  	virtual bool	requestedExit() const;
+
+	virtual	void	setRequestExit();
+    
+    void getMouseCoordinates(int& x, int& y);
+    
+    void runMainLoop();
+    
+    void setMouseButtonCallback(b3MouseButtonCallback	mouseCallback)
+    {
+        m_mouseButtonCallback = mouseCallback;
+    }
+
+    void setMouseMoveCallback(b3MouseMoveCallback	mouseCallback)
+    {
+        m_mouseMoveCallback = mouseCallback;
+    }
+    
+    void setResizeCallback(b3ResizeCallback resizeCallback);
+    
+	void setKeyboardCallback( b3KeyboardCallback	keyboardCallback)
+    {
+        m_keyboardCallback = keyboardCallback;
+    }
+
+	virtual b3MouseMoveCallback getMouseMoveCallback()
+	{
+		return m_mouseMoveCallback;
+	}
+	virtual b3MouseButtonCallback getMouseButtonCallback()
+	{
+		return m_mouseButtonCallback;
+	}
+	virtual b3ResizeCallback getResizeCallback();
+	virtual b3WheelCallback getWheelCallback()
+	{
+		return m_wheelCallback;
+	}
+
+    b3KeyboardCallback getKeyboardCallback()
+	{
+		return m_keyboardCallback;
+	}
+    
+	void setWheelCallback (b3WheelCallback wheelCallback)
+    {
+        m_wheelCallback = wheelCallback;
+    }
+
+    float getRetinaScale() const
+    {
+        return m_retinaScaleFactor;
+    }
+	
+	virtual	void	createWindow(const b3gWindowConstructionInfo& ci);
+	
+	virtual	float	getTimeInSeconds();
+	
+
+	
+	virtual void setRenderCallback( b3RenderCallback renderCallback);
+	
+	virtual void setWindowTitle(const char* title);
+
+    int fileOpenDialog(char* filename, int maxNameLength);
+
+};
+
+
+#endif
+

examples/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 "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
+

examples/OpenGLWindow/OpenGLInclude.h

@@ -0,0 +1,62 @@
+/*
+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>
+//#include <OpenGL/glu.h>
+//#import <Cocoa/Cocoa.h>
+#ifdef USE_OPENGL2
+#include <OpenGL/gl.h>
+#else
+#include <OpenGL/gl3.h>
+#endif
+#else
+
+#include "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
+

examples/OpenGLWindow/Shaders/createShadowMapInstancingPS.glsl

@@ -0,0 +1,10 @@
+#version 330
+precision highp float;
+
+
+layout(location = 0) out float fragmentdepth;
+
+void main(void)
+{
+	fragmentdepth = gl_FragCoord.z;
+}

examples/OpenGLWindow/Shaders/createShadowMapInstancingPS.h

@@ -0,0 +1,10 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* createShadowMapInstancingFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout(location = 0) out float fragmentdepth;\n"
+"void main(void)\n"
+"{\n"
+"	fragmentdepth = gl_FragCoord.z;\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/createShadowMapInstancingVS.glsl

@@ -0,0 +1,55 @@
+#version 330
+precision highp float;
+
+
+layout (location = 0) in vec4 position;
+layout (location = 1) in vec4 instance_position;
+layout (location = 2) in vec4 instance_quaternion;
+layout (location = 3) in vec2 uvcoords;
+layout (location = 4) in vec3 vertexnormal;
+layout (location = 5) in vec4 instance_color;
+layout (location = 6) in vec3 instance_scale;
+
+
+uniform mat4 depthMVP;
+
+
+vec4 quatMul ( in vec4 q1, in vec4 q2 )
+{
+    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );
+    vec4  dt = q1 * q2;
+    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );
+    return vec4 ( im, re );
+}
+
+vec4 quatFromAxisAngle(vec4 axis, in float angle)
+{
+    float cah = cos(angle*0.5);
+    float sah = sin(angle*0.5);
+	float d = inversesqrt(dot(axis,axis));
+	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);
+	return q;
+}
+//
+// vector rotation via quaternion
+//
+vec4 quatRotate3 ( in vec3 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+vec4 quatRotate ( in vec4 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, p );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+
+
+void main(void)
+{
+	vec4 q = instance_quaternion;
+	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);
+	vec4 vertexPos = depthMVP * vec4( (instance_position+localcoord).xyz,1);
+	gl_Position = vertexPos;
+}
+

examples/OpenGLWindow/Shaders/createShadowMapInstancingVS.h

@@ -0,0 +1,48 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* createShadowMapInstancingVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec3 instance_scale;\n"
+"uniform mat4 depthMVP;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);\n"
+"	vec4 vertexPos = depthMVP * vec4( (instance_position+localcoord).xyz,1);\n"
+"	gl_Position = vertexPos;\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/instancingPS.glsl

@@ -0,0 +1,36 @@
+#version 330
+precision highp float;
+
+in Fragment
+{
+     vec4 color;
+} fragment;
+
+in Vert
+{
+	vec2 texcoord;
+} vert;
+
+uniform sampler2D Diffuse;
+in vec3 lightDir,normal,ambient;
+out vec4 color;
+
+void main_textured(void)
+{
+   color  = vec4(0.1,0.2,0.3,0.3);
+}
+
+void main(void)
+{
+    vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;
+	vec3 ct,cf;
+	float intensity,at,af;
+	intensity = max(dot(lightDir,normalize(normal)),0);
+	cf = intensity*vec3(1.0,1.0,1.0)+ambient;
+	af = 1.0;
+		
+	ct = texel.rgb;
+	at = texel.a;
+		
+	color  = vec4(ct * cf, at * af);	
+}

examples/OpenGLWindow/Shaders/instancingPS.h

@@ -0,0 +1,34 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* instancingFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"uniform sampler2D Diffuse;\n"
+"in vec3 lightDir,normal,ambient;\n"
+"out vec4 color;\n"
+"void main_textured(void)\n"
+"{\n"
+"   color  = vec4(0.1,0.2,0.3,0.3);\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"    vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;\n"
+"	vec3 ct,cf;\n"
+"	float intensity,at,af;\n"
+"	intensity = max(dot(lightDir,normalize(normal)),0);\n"
+"	cf = intensity*vec3(1.0,1.0,1.0)+ambient;\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+"	color  = vec4(ct * cf, at * af);	\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/instancingVS.glsl

@@ -0,0 +1,82 @@
+#version 330
+precision highp float;
+
+
+layout (location = 0) in vec4 position;
+layout (location = 1) in vec4 instance_position;
+layout (location = 2) in vec4 instance_quaternion;
+layout (location = 3) in vec2 uvcoords;
+layout (location = 4) in vec3 vertexnormal;
+layout (location = 5) in vec4 instance_color;
+layout (location = 6) in vec3 instance_scale;
+
+
+uniform mat4 ModelViewMatrix;
+uniform mat4 ProjectionMatrix;
+
+out Fragment
+{
+     vec4 color;
+} fragment;
+
+out Vert
+{
+	vec2 texcoord;
+} vert;
+
+
+vec4 quatMul ( in vec4 q1, in vec4 q2 )
+{
+    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );
+    vec4  dt = q1 * q2;
+    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );
+    return vec4 ( im, re );
+}
+
+vec4 quatFromAxisAngle(vec4 axis, in float angle)
+{
+    float cah = cos(angle*0.5);
+    float sah = sin(angle*0.5);
+	float d = inversesqrt(dot(axis,axis));
+	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);
+	return q;
+}
+//
+// vector rotation via quaternion
+//
+vec4 quatRotate3 ( in vec3 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+vec4 quatRotate ( in vec4 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, p );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+
+out vec3 lightDir,normal,ambient;
+
+void main(void)
+{
+	vec4 q = instance_quaternion;
+	ambient = vec3(0.3,.3,0.3);
+		
+		
+	vec4 local_normal = (quatRotate3( vertexnormal,q));
+	vec3 light_pos = vec3(-0.3,0.1,0.1);
+	normal = local_normal.xyz;//normalize(ModelViewMatrix * local_normal).xyz;
+
+	lightDir = normalize(light_pos);//gl_LightSource[0].position.xyz));
+//	lightDir = normalize(vec3(gl_LightSource[0].position));
+		
+	vec4 axis = vec4(1,1,1,0);
+	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);
+	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position+localcoord);
+
+	gl_Position = vertexPos;
+	
+	fragment.color = instance_color;
+	vert.texcoord = uvcoords;
+}
+

examples/OpenGLWindow/Shaders/instancingVS.h

@@ -0,0 +1,71 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* instancingVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec3 instance_scale;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"out Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"out vec3 lightDir,normal,ambient;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	ambient = vec3(0.3,.3,0.3);\n"
+"		\n"
+"		\n"
+"	vec4 local_normal = (quatRotate3( vertexnormal,q));\n"
+"	vec3 light_pos = vec3(-0.3,0.1,0.1);\n"
+"	normal = local_normal.xyz;//normalize(ModelViewMatrix * local_normal).xyz;\n"
+"	lightDir = normalize(light_pos);//gl_LightSource[0].position.xyz));\n"
+"//	lightDir = normalize(vec3(gl_LightSource[0].position));\n"
+"		\n"
+"	vec4 axis = vec4(1,1,1,0);\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);\n"
+"	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position+localcoord);\n"
+"	gl_Position = vertexPos;\n"
+"	\n"
+"	fragment.color = instance_color;\n"
+"	vert.texcoord = uvcoords;\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/linesPS.glsl

@@ -0,0 +1,10 @@
+
+#version 150
+
+in vec4 colourV;
+out vec4 fragColour;
+
+void main(void)
+{
+    fragColour = colourV;
+}

examples/OpenGLWindow/Shaders/linesPS.h

@@ -0,0 +1,10 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* linesFragmentShader= \
+"#version 150\n"
+"in vec4 colourV;\n"
+"out vec4 fragColour;\n"
+"void main(void)\n"
+"{\n"
+"    fragColour = colourV;\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/linesVS.glsl

@@ -0,0 +1,17 @@
+#version 150   
+
+uniform mat4 ModelViewMatrix;
+uniform mat4 ProjectionMatrix;
+uniform vec4 colour;
+
+in vec4 position;
+
+
+out vec4 colourV;
+
+void main (void)
+{
+    colourV = colour;
+		gl_Position = ProjectionMatrix * ModelViewMatrix * position;
+		
+}

examples/OpenGLWindow/Shaders/linesVS.h

@@ -0,0 +1,15 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* linesVertexShader= \
+"#version 150   \n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"uniform vec4 colour;\n"
+"in vec4 position;\n"
+"out vec4 colourV;\n"
+"void main (void)\n"
+"{\n"
+"    colourV = colour;\n"
+"		gl_Position = ProjectionMatrix * ModelViewMatrix * position;\n"
+"		\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/pointSpritePS.glsl

@@ -0,0 +1,37 @@
+
+#version 330
+precision highp float;
+
+in Fragment
+{
+     vec4 color;
+} fragment;
+
+
+in vec3 ambient;
+
+out vec4 color;
+
+void main_textured(void)
+{
+    color =  fragment.color;//texture2D(Diffuse,vert.texcoord);//fragment.color;
+}
+
+void main(void)
+{
+	vec3 N;
+	N.xy = gl_PointCoord.st*vec2(2.0, -2.0) + vec2(-1.0, 1.0);
+    float mag = dot(N.xy, N.xy);
+    if (mag > 1.0) discard; 
+    vec4 texel = fragment.color;//vec4(1,0,0,1);//fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;
+	vec3 ct;
+	float at,af;
+	af = 1.0;
+		
+	ct = texel.rgb;
+	at = texel.a;
+		
+ vec3 lightDir= vec3(1,0,0);
+	float diffuse = max(0.0, dot(lightDir, N));
+	color  = vec4(ct * diffuse, at * af);	
+}

examples/OpenGLWindow/Shaders/pointSpritePS.h

@@ -0,0 +1,33 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* pointSpriteFragmentShader= \
+"#version 330\n"
+"precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in vec3 ambient;\n"
+"out vec4 color;\n"
+"void main_textured(void)\n"
+"{\n"
+"    color =  fragment.color;//texture2D(Diffuse,vert.texcoord);//fragment.color;\n"
+"}\n"
+"void main(void)\n"
+"{\n"
+"	vec3 N;\n"
+"	N.xy = gl_PointCoord.st*vec2(2.0, -2.0) + vec2(-1.0, 1.0);\n"
+"    float mag = dot(N.xy, N.xy);\n"
+"    if (mag > 1.0) discard; \n"
+"    vec4 texel = fragment.color;//vec4(1,0,0,1);//fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;\n"
+"	vec3 ct;\n"
+"	float at,af;\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+" vec3 lightDir= vec3(1,0,0);\n"
+"	float diffuse = max(0.0, dot(lightDir, N));\n"
+"	color  = vec4(ct * diffuse, at * af);	\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/pointSpriteVS.glsl

@@ -0,0 +1,46 @@
+#version 330
+precision highp float;
+
+
+
+layout (location = 0) in vec4 position;
+layout (location = 1) in vec4 instance_position;
+layout (location = 3) in vec2 uvcoords;
+layout (location = 4) in vec3 vertexnormal;
+layout (location = 5) in vec4 instance_color;
+layout (location = 6) in vec3 instance_scale;
+
+
+uniform float screenWidth = 700.f;
+uniform mat4 ModelViewMatrix;
+uniform mat4 ProjectionMatrix;
+
+out Fragment
+{
+     vec4 color;
+} fragment;
+
+
+
+//
+// vector rotation via quaternion
+//
+
+out vec3 ambient;
+
+void main(void)
+{
+	ambient = vec3(0.3,.3,0.3);
+		
+		
+	vec4 axis = vec4(1,1,1,0);
+	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position);
+	vec3 posEye = vec3(ModelViewMatrix * vec4(instance_position.xyz, 1.0));
+   float dist = length(posEye);
+	float pointRadius = 1.f;
+    gl_PointSize = instance_scale.x * pointRadius * (screenWidth / dist);
+
+	gl_Position = vertexPos;
+	
+	fragment.color = instance_color;
+}

examples/OpenGLWindow/Shaders/pointSpriteVS.h

@@ -0,0 +1,37 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* pointSpriteVertexShader= \
+"#version 330\n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec3 instance_scale;\n"
+"uniform float screenWidth = 700.f;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"out vec3 ambient;\n"
+"void main(void)\n"
+"{\n"
+"	ambient = vec3(0.3,.3,0.3);\n"
+"		\n"
+"		\n"
+"	vec4 axis = vec4(1,1,1,0);\n"
+"	vec4 vertexPos = ProjectionMatrix * ModelViewMatrix *(instance_position);\n"
+"	vec3 posEye = vec3(ModelViewMatrix * vec4(instance_position.xyz, 1.0));\n"
+"   float dist = length(posEye);\n"
+"	float pointRadius = 1.f;\n"
+"    gl_PointSize = instance_scale.x * pointRadius * (screenWidth / dist);\n"
+"	gl_Position = vertexPos;\n"
+"	\n"
+"	fragment.color = instance_color;\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/useShadowMapInstancingPS.glsl

@@ -0,0 +1,56 @@
+#version 330 core
+//precision highp float;
+
+in Fragment
+{
+     vec4 color;
+} fragment;
+
+in Vert
+{
+	vec2 texcoord;
+} vert;
+
+uniform sampler2D Diffuse;
+uniform sampler2DShadow shadowMap;
+
+in vec3 lightDir,normal,ambient;
+in vec4 ShadowCoord;
+
+out vec4 color;
+
+
+
+void main(void)
+{
+    vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;
+	vec3 ct,cf;
+	float intensity,at,af;
+	
+	intensity = clamp( dot( normalize(normal),lightDir ), 0,1 );
+	
+	cf = ambient;
+	af = 1.0;
+		
+	ct = texel.rgb;
+	at = texel.a;
+		
+	//float bias = 0.005f;
+	
+	float bias = 0.0001*tan(acos(intensity));
+	bias = clamp(bias, 0,0.01);
+
+
+	float visibility = texture(shadowMap, vec3(ShadowCoord.xy,(ShadowCoord.z-bias)/ShadowCoord.w));
+	
+	intensity*=2;
+	if (intensity>1)
+		intensity=1.f;
+	
+	visibility *= intensity;
+	
+	if (visibility<0.6)
+		visibility=0.6f;
+		
+	color  = vec4(ct * visibility, fragment.color.w);
+}

examples/OpenGLWindow/Shaders/useShadowMapInstancingPS.h

@@ -0,0 +1,49 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* useShadowMapInstancingFragmentShader= \
+"#version 330 core\n"
+"//precision highp float;\n"
+"in Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"in Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"uniform sampler2D Diffuse;\n"
+"uniform sampler2DShadow shadowMap;\n"
+"in vec3 lightDir,normal,ambient;\n"
+"in vec4 ShadowCoord;\n"
+"out vec4 color;\n"
+"void main(void)\n"
+"{\n"
+"    vec4 texel = fragment.color*texture(Diffuse,vert.texcoord);//fragment.color;\n"
+"	vec3 ct,cf;\n"
+"	float intensity,at,af;\n"
+"	\n"
+"	intensity = clamp( dot( normalize(normal),lightDir ), 0,1 );\n"
+"	\n"
+"	cf = ambient;\n"
+"	af = 1.0;\n"
+"		\n"
+"	ct = texel.rgb;\n"
+"	at = texel.a;\n"
+"		\n"
+"	//float bias = 0.005f;\n"
+"	\n"
+"	float bias = 0.0001*tan(acos(intensity));\n"
+"	bias = clamp(bias, 0,0.01);\n"
+"	float visibility = texture(shadowMap, vec3(ShadowCoord.xy,(ShadowCoord.z-bias)/ShadowCoord.w));\n"
+"	\n"
+"	intensity*=2;\n"
+"	if (intensity>1)\n"
+"		intensity=1.f;\n"
+"	\n"
+"	visibility *= intensity;\n"
+"	\n"
+"	if (visibility<0.6)\n"
+"		visibility=0.6f;\n"
+"		\n"
+"	color  = vec4(ct * visibility, fragment.color.w);\n"
+"}\n"
+;

examples/OpenGLWindow/Shaders/useShadowMapInstancingVS.glsl

@@ -0,0 +1,86 @@
+#version 330 
+precision highp float;
+
+
+layout (location = 0) in vec4 position;
+layout (location = 1) in vec4 instance_position;
+layout (location = 2) in vec4 instance_quaternion;
+layout (location = 3) in vec2 uvcoords;
+layout (location = 4) in vec3 vertexnormal;
+layout (location = 5) in vec4 instance_color;
+layout (location = 6) in vec3 instance_scale;
+
+
+uniform mat4 ModelViewMatrix;
+uniform mat4 ProjectionMatrix;
+uniform mat4 DepthBiasModelViewProjectionMatrix;
+uniform mat4 MVP;
+uniform vec3 lightDirIn;
+
+out vec4 ShadowCoord;
+
+out Fragment
+{
+     vec4 color;
+} fragment;
+
+out Vert
+{
+	vec2 texcoord;
+} vert;
+
+
+vec4 quatMul ( in vec4 q1, in vec4 q2 )
+{
+    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );
+    vec4  dt = q1 * q2;
+    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );
+    return vec4 ( im, re );
+}
+
+vec4 quatFromAxisAngle(vec4 axis, in float angle)
+{
+    float cah = cos(angle*0.5);
+    float sah = sin(angle*0.5);
+	float d = inversesqrt(dot(axis,axis));
+	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);
+	return q;
+}
+//
+// vector rotation via quaternion
+//
+vec4 quatRotate3 ( in vec3 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+vec4 quatRotate ( in vec4 p, in vec4 q )
+{
+    vec4 temp = quatMul ( q, p );
+    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );
+}
+
+out vec3 lightDir,normal,ambient;
+
+void main(void)
+{
+	vec4 q = instance_quaternion;
+	ambient = vec3(0.3,.3,0.3);
+			
+	vec4 worldNormal = (quatRotate3( vertexnormal,q));
+	
+	normal = normalize(worldNormal).xyz;
+
+	lightDir = lightDirIn;
+		
+	vec4 axis = vec4(1,1,1,0);
+	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);
+	vec4 vertexPos = MVP* vec4((instance_position+localcoord).xyz,1);
+
+	gl_Position = vertexPos;
+	ShadowCoord = DepthBiasModelViewProjectionMatrix * vec4((instance_position+localcoord).xyz,1);
+
+	fragment.color = instance_color;
+	vert.texcoord = uvcoords;
+}
+

examples/OpenGLWindow/Shaders/useShadowMapInstancingVS.h

@@ -0,0 +1,73 @@
+//this file is autogenerated using stringify.bat (premake --stringify) in the build folder of this project
+static const char* useShadowMapInstancingVertexShader= \
+"#version 330 \n"
+"precision highp float;\n"
+"layout (location = 0) in vec4 position;\n"
+"layout (location = 1) in vec4 instance_position;\n"
+"layout (location = 2) in vec4 instance_quaternion;\n"
+"layout (location = 3) in vec2 uvcoords;\n"
+"layout (location = 4) in vec3 vertexnormal;\n"
+"layout (location = 5) in vec4 instance_color;\n"
+"layout (location = 6) in vec3 instance_scale;\n"
+"uniform mat4 ModelViewMatrix;\n"
+"uniform mat4 ProjectionMatrix;\n"
+"uniform mat4 DepthBiasModelViewProjectionMatrix;\n"
+"uniform mat4 MVP;\n"
+"uniform vec3 lightDirIn;\n"
+"out vec4 ShadowCoord;\n"
+"out Fragment\n"
+"{\n"
+"     vec4 color;\n"
+"} fragment;\n"
+"out Vert\n"
+"{\n"
+"	vec2 texcoord;\n"
+"} vert;\n"
+"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"
+"{\n"
+"    vec3  im = q1.w * q2.xyz + q1.xyz * q2.w + cross ( q1.xyz, q2.xyz );\n"
+"    vec4  dt = q1 * q2;\n"
+"    float re = dot ( dt, vec4 ( -1.0, -1.0, -1.0, 1.0 ) );\n"
+"    return vec4 ( im, re );\n"
+"}\n"
+"vec4 quatFromAxisAngle(vec4 axis, in float angle)\n"
+"{\n"
+"    float cah = cos(angle*0.5);\n"
+"    float sah = sin(angle*0.5);\n"
+"	float d = inversesqrt(dot(axis,axis));\n"
+"	vec4 q = vec4(axis.x*sah*d,axis.y*sah*d,axis.z*sah*d,cah);\n"
+"	return q;\n"
+"}\n"
+"//\n"
+"// vector rotation via quaternion\n"
+"//\n"
+"vec4 quatRotate3 ( in vec3 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, vec4 ( p, 0.0 ) );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"vec4 quatRotate ( in vec4 p, in vec4 q )\n"
+"{\n"
+"    vec4 temp = quatMul ( q, p );\n"
+"    return quatMul ( temp, vec4 ( -q.x, -q.y, -q.z, q.w ) );\n"
+"}\n"
+"out vec3 lightDir,normal,ambient;\n"
+"void main(void)\n"
+"{\n"
+"	vec4 q = instance_quaternion;\n"
+"	ambient = vec3(0.3,.3,0.3);\n"
+"			\n"
+"	vec4 worldNormal = (quatRotate3( vertexnormal,q));\n"
+"	\n"
+"	normal = normalize(worldNormal).xyz;\n"
+"	lightDir = lightDirIn;\n"
+"		\n"
+"	vec4 axis = vec4(1,1,1,0);\n"
+"	vec4 localcoord = quatRotate3( position.xyz*instance_scale,q);\n"
+"	vec4 vertexPos = MVP* vec4((instance_position+localcoord).xyz,1);\n"
+"	gl_Position = vertexPos;\n"
+"	ShadowCoord = DepthBiasModelViewProjectionMatrix * vec4((instance_position+localcoord).xyz,1);\n"
+"	fragment.color = instance_color;\n"
+"	vert.texcoord = uvcoords;\n"
+"}\n"
+;

examples/OpenGLWindow/SimpleCamera.cpp

@@ -0,0 +1,260 @@
+#include "SimpleCamera.h"
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Quaternion.h"
+#include "Bullet3Common/b3Matrix3x3.h"
+
+struct SimpleCameraInternalData
+{
+	SimpleCameraInternalData()
+		:m_cameraTargetPosition(b3MakeVector3(0,0,0)),
+		m_cameraDistance(20),
+		m_cameraUp(b3MakeVector3(0,1,0)),
+		m_cameraUpAxis(1),
+		m_cameraForward(b3MakeVector3(1,0,0)),
+		m_frustumZNear(1),
+		m_frustumZFar(10000),
+		m_yaw(20),
+		m_pitch(0),
+		m_aspect(1)
+	{
+	}
+	b3Vector3 m_cameraTargetPosition;
+	float m_cameraDistance;
+	b3Vector3 m_cameraUp;
+	b3Vector3 m_cameraForward;
+	int m_cameraUpAxis;
+	//the m_cameraPosition is a cached value, recomputed from other values
+	b3Vector3 m_cameraPosition;
+	float m_yaw;
+	
+	float m_pitch;
+	float m_aspect;
+	float m_frustumZNear;
+    float m_frustumZFar;
+};
+
+
+
+
+SimpleCamera::SimpleCamera()
+{
+	m_data = new SimpleCameraInternalData;
+}
+SimpleCamera::~SimpleCamera()
+{
+	delete m_data;
+}
+
+
+
+
+static void    b3CreateFrustum(
+                        float left,
+                        float right,
+                        float bottom,
+                        float top,
+                        float nearVal,
+                        float farVal,
+                        float frustum[16])
+{
+
+    frustum[0*4+0] = (float(2) * nearVal) / (right - left);
+    frustum[0*4+1] = float(0);
+    frustum[0*4+2] = float(0);
+    frustum[0*4+3] = float(0);
+
+    frustum[1*4+0] = float(0);
+    frustum[1*4+1] = (float(2) * nearVal) / (top - bottom);
+    frustum[1*4+2] = float(0);
+    frustum[1*4+3] = float(0);
+
+    frustum[2*4+0] = (right + left) / (right - left);
+    frustum[2*4+1] = (top + bottom) / (top - bottom);
+    frustum[2*4+2] = -(farVal + nearVal) / (farVal - nearVal);
+    frustum[2*4+3] = float(-1);
+
+    frustum[3*4+0] = float(0);
+    frustum[3*4+1] = float(0);
+    frustum[3*4+2] = -(float(2) * farVal * nearVal) / (farVal - nearVal);
+    frustum[3*4+3] = float(0);
+
+}
+
+
+
+
+static void b3CreateDiagonalMatrix(float value, float result[4][4])
+{
+	for (int i=0;i<4;i++)
+	{
+		for (int j=0;j<4;j++)
+		{
+			if (i==j)
+			{
+				result[i][j] = value;
+			} else
+			{
+				result[i][j] = 0.f;
+			}
+		}
+	}
+}
+
+static void b3CreateOrtho(float left, float right, float bottom, float top, float zNear, float zFar, float result[4][4])
+{
+	b3CreateDiagonalMatrix(1.f,result);
+
+	result[0][0] = 2.f / (right - left);
+	result[1][1] = 2.f / (top - bottom);
+	result[2][2] = - 2.f / (zFar - zNear);
+	result[3][0] = - (right + left) / (right - left);
+	result[3][1] = - (top + bottom) / (top - bottom);
+	result[3][2] = - (zFar + zNear) / (zFar - zNear);
+}
+
+static void    b3CreateLookAt(const b3Vector3& eye, const b3Vector3& center,const b3Vector3& up, float result[16])
+{
+    b3Vector3 f = (center - eye).normalized();
+    b3Vector3 u = up.normalized();
+    b3Vector3 s = (f.cross(u)).normalized();
+    u = s.cross(f);
+
+    result[0*4+0] = s.x;
+    result[1*4+0] = s.y;
+    result[2*4+0] = s.z;
+
+	result[0*4+1] = u.x;
+    result[1*4+1] = u.y;
+    result[2*4+1] = u.z;
+
+    result[0*4+2] =-f.x;
+    result[1*4+2] =-f.y;
+    result[2*4+2] =-f.z;
+
+	result[0*4+3] = 0.f;
+    result[1*4+3] = 0.f;
+    result[2*4+3] = 0.f;
+
+    result[3*4+0] = -s.dot(eye);
+    result[3*4+1] = -u.dot(eye);
+    result[3*4+2] = f.dot(eye);
+    result[3*4+3] = 1.f;
+}
+
+void SimpleCamera::setCameraUpAxis(int upAxis)
+{
+	m_data->m_cameraUpAxis = upAxis;
+
+	update();
+}
+
+void SimpleCamera::update()
+{
+
+	int forwardAxis(-1);
+	switch (m_data->m_cameraUpAxis)
+	{
+    case 1:
+    	forwardAxis = 2;
+    	m_data->m_cameraUp = b3MakeVector3(0,1,0);
+    	//gLightPos = b3MakeVector3(-50.f,100,30);
+    	break;
+    case 2:
+		forwardAxis = 1;
+		m_data->m_cameraUp = b3MakeVector3(0,0,1);
+		//gLightPos = b3MakeVector3(-50.f,30,100);
+		break;
+    default:
+		{
+			b3Assert(0);
+			return;
+		}
+	};
+
+	b3Vector3 eyePos = b3MakeVector3(0,0,0);
+	eyePos[forwardAxis] = -m_data->m_cameraDistance;
+
+	m_data->m_cameraForward = b3MakeVector3(eyePos[0],eyePos[1],eyePos[2]);
+	if (m_data->m_cameraForward.length2() < B3_EPSILON)
+	{
+		m_data->m_cameraForward.setValue(1.f,0.f,0.f);
+	} else
+	{
+		m_data->m_cameraForward.normalize();
+	}
+	
+
+//    m_azi=m_azi+0.01;
+	b3Scalar rele = m_data->m_yaw * b3Scalar(0.01745329251994329547);// rads per deg
+	b3Scalar razi = m_data->m_pitch * b3Scalar(0.01745329251994329547);// rads per deg
+
+
+	b3Quaternion rot(m_data->m_cameraUp,razi);
+
+	
+	b3Vector3 right = m_data->m_cameraUp.cross(m_data->m_cameraForward);
+	b3Quaternion roll(right,-rele);
+
+	eyePos = b3Matrix3x3(rot) * b3Matrix3x3(roll) * eyePos;
+
+	m_data->m_cameraPosition = eyePos;
+	m_data->m_cameraPosition+= m_data->m_cameraTargetPosition;
+
+}
+
+void SimpleCamera::getCameraProjectionMatrix(float projectionMatrix[16]) const
+{
+	b3CreateFrustum(-m_data->m_aspect * m_data->m_frustumZNear, m_data->m_aspect * m_data->m_frustumZNear, -m_data->m_frustumZNear,m_data->m_frustumZNear, m_data->m_frustumZNear, m_data->m_frustumZFar,projectionMatrix);
+}
+void SimpleCamera::getCameraViewMatrix(float viewMatrix[16]) const
+{
+	b3CreateLookAt(m_data->m_cameraPosition,m_data->m_cameraTargetPosition,m_data->m_cameraUp,viewMatrix);
+}
+
+void SimpleCamera::getCameraTargetPosition(float pos[3]) const
+{
+	pos[0] =m_data->m_cameraTargetPosition[0];
+	pos[1] =m_data->m_cameraTargetPosition[1];
+	pos[2] =m_data->m_cameraTargetPosition[2];
+}
+void SimpleCamera::getCameraPosition(float pos[3]) const
+{
+	pos[0] =m_data->m_cameraPosition[0];
+	pos[1] =m_data->m_cameraPosition[1];
+	pos[2] =m_data->m_cameraPosition[2];
+}
+
+void	SimpleCamera::setCameraTargetPosition(float x,float y,float z)
+{
+	m_data->m_cameraTargetPosition.setValue(x,y,z);
+	update();
+}
+void	SimpleCamera::setCameraDistance(float dist)
+{
+	m_data->m_cameraDistance = dist;
+	update();
+}
+void	SimpleCamera::setCameraUpVector(float x,float y ,float z)
+{
+	m_data->m_cameraUp.setValue(x,y,z);
+	update();
+}
+
+void	SimpleCamera::setCameraYaw(float yaw)
+{
+	m_data->m_yaw = yaw;
+	update();
+}
+
+void	SimpleCamera::setCameraPitch(float pitch)
+{
+	m_data->m_pitch = pitch;
+	update();
+}
+
+void	SimpleCamera::setAspectRatio(float ratio)
+{
+	m_data->m_aspect = ratio;
+	update();
+}

examples/OpenGLWindow/SimpleCamera.h

@@ -0,0 +1,36 @@
+#ifndef SIMPLE_CAMERA_H
+#define SIMPLE_CAMERA_H
+
+struct CommonCameraInterface
+{
+	virtual void getCameraProjectionMatrix(float m[16])const = 0;
+	virtual void getCameraViewMatrix(float m[16]) const = 0;
+};
+
+struct SimpleCamera : public CommonCameraInterface
+{
+	struct SimpleCameraInternalData* m_data;
+
+	SimpleCamera();
+	virtual ~SimpleCamera();
+
+	void update();
+	virtual void getCameraProjectionMatrix(float m[16]) const;
+	virtual void getCameraViewMatrix(float m[16]) const;
+	
+	virtual void getCameraTargetPosition(float pos[3]) const;
+	virtual void getCameraPosition(float pos[3]) const;
+
+	virtual void	setCameraTargetPosition(float x,float y,float z);
+	virtual void	setCameraDistance(float dist);
+	virtual void	setCameraUpVector(float x,float y, float z);
+	///the setCameraUpAxis will call the 'setCameraUpVector' and 'setCameraForwardVector'
+	virtual void	setCameraUpAxis(int axis);
+	virtual void	setCameraYaw(float yaw);
+	
+	virtual void	setCameraPitch(float pitch);
+	virtual void	setAspectRatio(float ratio);
+
+};
+
+#endif //SIMPLE_CAMERA_H

examples/OpenGLWindow/SimpleOpenGL2App.cpp

@@ -0,0 +1,207 @@
+#include "SimpleOpenGL2App.h"
+#include "OpenGLInclude.h"
+
+#include "Bullet3Common/b3Logging.h"//b3Assert?
+#include "Bullet3Common/b3Scalar.h"
+#include "Bullet3Common/b3AlignedObjectArray.h"
+#include "Bullet3Common/b3Vector3.h"
+
+
+#include "stdlib.h"
+
+#ifdef __APPLE__
+#include "MacOpenGLWindow.h"
+#else
+
+#include "GL/glew.h"
+//#include "GL/glew.h"
+#ifdef _WIN32
+#include "Win32OpenGLWindow.h"
+#else
+//let's cross the fingers it is Linux/X11
+#include "X11OpenGLWindow.h"
+#endif //_WIN32
+#endif//__APPLE__
+#include <stdio.h>
+#include "../CommonInterfaces/CommonRenderInterface.h"
+
+struct SimpleOpenGL2AppInternalData
+{
+
+};
+
+SimpleOpenGL2App::SimpleOpenGL2App(const char* title, int width, int height)
+{
+	m_data = new SimpleOpenGL2AppInternalData;
+
+	m_window = new b3gDefaultOpenGLWindow();
+	b3gWindowConstructionInfo ci;
+	ci.m_title = title;
+	ci.m_openglVersion = 2;
+	ci.m_width = width;
+	ci.m_height = height;
+	m_window->createWindow(ci);
+
+	m_window->setWindowTitle(title);
+
+#ifndef __APPLE__
+#ifndef _WIN32
+//some Linux implementations need the 'glewExperimental' to be true
+    glewExperimental = GL_TRUE;
+#endif
+
+
+    if (glewInit() != GLEW_OK)
+	{
+        b3Error("glewInit failed");
+		exit(1);
+	}
+    if (!GLEW_VERSION_2_1)  // check that the machine supports the 2.1 API.
+	{
+		b3Error("GLEW_VERSION_2_1 needs to support 2_1");
+		exit(1); // or handle the error in a nicer way
+	}
+
+#endif
+    glGetError();//don't remove this call, it is needed for Ubuntu
+	glClearColor(0.9,0.9,1,1);
+
+    b3Assert(glGetError() ==GL_NO_ERROR);
+
+	//m_primRenderer = new GLPrimitiveRenderer(width,height);
+	m_parameterInterface = 0;
+
+    b3Assert(glGetError() ==GL_NO_ERROR);
+
+	//m_instancingRenderer = new GLInstancingRenderer(128*1024,32*1024*1024);
+	//m_instancingRenderer->init();
+	//m_instancingRenderer->resize(width,height);
+
+	b3Assert(glGetError() ==GL_NO_ERROR);
+
+	//m_instancingRenderer->InitShaders();
+
+}
+
+SimpleOpenGL2App::~SimpleOpenGL2App()
+{
+	delete m_data;
+}
+
+void SimpleOpenGL2App::drawGrid(DrawGridData data)
+{
+	 int gridSize = data.gridSize;
+    float upOffset = data.upOffset;
+    int upAxis = data.upAxis;
+    float gridColor[4];
+    gridColor[0] = data.gridColor[0];
+    gridColor[1] = data.gridColor[1];
+    gridColor[2] = data.gridColor[2];
+    gridColor[3] = data.gridColor[3];
+
+	int sideAxis=-1;
+	int forwardAxis=-1;
+
+	switch (upAxis)
+	{
+		case 1:
+			forwardAxis=2;
+			sideAxis=0;
+			break;
+		case 2:
+			forwardAxis=1;
+			sideAxis=0;
+			break;
+		default:
+			b3Assert(0);
+	};
+	//b3Vector3 gridColor = b3MakeVector3(0.5,0.5,0.5);
+
+	 b3AlignedObjectArray<unsigned int> indices;
+		 b3AlignedObjectArray<b3Vector3> vertices;
+	int lineIndex=0;
+	for(int i=-gridSize;i<=gridSize;i++)
+	{
+		{
+			b3Assert(glGetError() ==GL_NO_ERROR);
+			b3Vector3 from = b3MakeVector3(0,0,0);
+			from[sideAxis] = float(i);
+			from[upAxis] = upOffset;
+			from[forwardAxis] = float(-gridSize);
+			b3Vector3 to=b3MakeVector3(0,0,0);
+			to[sideAxis] = float(i);
+			to[upAxis] = upOffset;
+			to[forwardAxis] = float(gridSize);
+			vertices.push_back(from);
+			indices.push_back(lineIndex++);
+			vertices.push_back(to);
+			indices.push_back(lineIndex++);
+		//	m_renderer->drawLine(from,to,gridColor);
+		}
+
+		b3Assert(glGetError() ==GL_NO_ERROR);
+		{
+
+			b3Assert(glGetError() ==GL_NO_ERROR);
+			b3Vector3 from=b3MakeVector3(0,0,0);
+			from[sideAxis] = float(-gridSize);
+			from[upAxis] = upOffset;
+			from[forwardAxis] = float(i);
+			b3Vector3 to=b3MakeVector3(0,0,0);
+			to[sideAxis] = float(gridSize);
+			to[upAxis] = upOffset;
+			to[forwardAxis] = float(i);
+			vertices.push_back(from);
+			indices.push_back(lineIndex++);
+			vertices.push_back(to);
+			indices.push_back(lineIndex++);
+		//	m_renderer->drawLine(from,to,gridColor);
+		}
+
+	}
+
+
+	m_renderer->drawLines(&vertices[0].x,
+			gridColor,
+			vertices.size(),sizeof(b3Vector3),&indices[0],indices.size(),1);
+	
+
+	m_renderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(1,0,0),b3MakeVector3(1,0,0),3);
+	m_renderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(0,1,0),b3MakeVector3(0,1,0),3);
+	m_renderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(0,0,1),b3MakeVector3(0,0,1),3);
+
+//	void GLInstancingRenderer::drawPoints(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, float pointDrawSize)
+
+	//we don't use drawPoints because all points would have the same color
+//	b3Vector3 points[3] = { b3MakeVector3(1, 0, 0), b3MakeVector3(0, 1, 0), b3MakeVector3(0, 0, 1) };
+//	m_instancingRenderer->drawPoints(&points[0].x, b3MakeVector3(1, 0, 0), 3, sizeof(b3Vector3), 6);
+}
+void SimpleOpenGL2App::setUpAxis(int axis)
+{
+}
+int SimpleOpenGL2App::getUpAxis() const
+{
+	return 1;
+}
+	
+void SimpleOpenGL2App::swapBuffer()
+{
+	m_window->endRendering();
+	m_window->startRendering();
+
+}
+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])
+{
+    
+}
+

examples/OpenGLWindow/SimpleOpenGL2App.h

@@ -0,0 +1,35 @@
+#ifndef SIMPLE_OPENGL2_APP_H
+#define SIMPLE_OPENGL2_APP_H
+
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+
+class SimpleOpenGL2App : public CommonGraphicsApp
+{
+protected:
+	struct SimpleOpenGL2AppInternalData*	m_data;
+
+public:
+	SimpleOpenGL2App(const char* title, int width, int height);
+	virtual ~SimpleOpenGL2App();
+
+	virtual void drawGrid(DrawGridData data=DrawGridData());
+	virtual void setUpAxis(int axis);
+	virtual int getUpAxis() const;
+	
+	virtual void swapBuffer();
+	virtual void drawText( const char* txt, int posX, int posY);
+
+	virtual int	registerCubeShape(float halfExtentsX,float halfExtentsY, float halfExtentsZ)
+	{
+		return 0;
+	}
+	virtual int	registerGraphicsSphereShape(float radius, bool usePointSprites, int largeSphereThreshold, int mediumSphereThreshold)
+	{
+		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

examples/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)
+{
+}

examples/OpenGLWindow/SimpleOpenGL2Renderer.h

@@ -0,0 +1,81 @@
+
+#ifndef SIMPLE_OPENGL2_RENDERER_H
+#define SIMPLE_OPENGL2_RENDERER_H
+
+#include "../CommonInterfaces/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

examples/OpenGLWindow/SimpleOpenGL3App.cpp

@@ -0,0 +1,824 @@
+#include "SimpleOpenGL3App.h"
+#include "ShapeData.h"
+#ifdef __APPLE__
+#include "MacOpenGLWindow.h"
+#else
+
+#include "GL/glew.h"
+//#include "GL/glew.h"
+#ifdef _WIN32
+#include "Win32OpenGLWindow.h"
+#else
+//let's cross the fingers it is Linux/X11
+#include "X11OpenGLWindow.h"
+#endif //_WIN32
+#endif//__APPLE__
+#include <stdio.h>
+
+#include "GLPrimitiveRenderer.h"
+#include "GLInstancingRenderer.h"
+
+#include "Bullet3Common/b3Vector3.h"
+#include "Bullet3Common/b3Logging.h"
+
+#include "fontstash.h"
+#include "TwFonts.h"
+#include "opengl_fontstashcallbacks.h"
+#include <assert.h>
+#include "GLRenderToTexture.h"
+#include "Bullet3Common/b3Quaternion.h"
+
+#ifdef _WIN32
+    #define popen _popen
+    #define pclose _pclose
+#endif // _WIN32
+
+struct SimpleInternalData
+{
+	GLuint m_fontTextureId;
+	GLuint m_largeFontTextureId;
+	struct sth_stash* m_fontStash;
+	OpenGL2RenderCallbacks*		m_renderCallbacks;
+	int m_droidRegular;
+	const char* m_frameDumpPngFileName;
+	FILE* m_ffmpegFile;
+	GLRenderToTexture*  m_renderTexture;
+	void* m_userPointer;
+	int m_upAxis;//y=1 or z=2 is supported
+
+};
+
+static SimpleOpenGL3App* gApp=0;
+
+static void SimpleResizeCallback( float widthf, float heightf)
+{
+	int width = (int)widthf;
+	int height = (int)heightf;
+	gApp->m_instancingRenderer->resize(width,height);
+	gApp->m_primRenderer->setScreenSize(width,height);
+
+}
+
+static void SimpleKeyboardCallback(int key, int state)
+{
+    if (key==B3G_ESCAPE && gApp && gApp->m_window)
+    {
+        gApp->m_window->setRequestExit();
+    } else
+    {
+        b3DefaultKeyboardCallback(key,state);
+    }
+}
+
+
+
+
+static GLuint BindFont(const CTexFont *_Font)
+{
+    GLuint TexID = 0;
+    glGenTextures(1, &TexID);
+    glBindTexture(GL_TEXTURE_2D, TexID);
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, _Font->m_TexWidth, _Font->m_TexHeight, 0, GL_RED, GL_UNSIGNED_BYTE, _Font->m_TexBytes);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    return TexID;
+}
+
+extern unsigned char OpenSansData[];
+
+SimpleOpenGL3App::SimpleOpenGL3App(	const char* title, int width,int height)
+{
+	gApp = this;
+	m_data = new SimpleInternalData;
+	m_data->m_frameDumpPngFileName = 0;
+	m_data->m_renderTexture = 0;
+	m_data->m_ffmpegFile = 0;
+	m_data->m_userPointer = 0;
+	m_data->m_upAxis = 1;
+
+	m_window = new b3gDefaultOpenGLWindow();
+	b3gWindowConstructionInfo ci;
+	ci.m_title = title;
+	ci.m_width = width;
+	ci.m_height = height;
+	m_window->createWindow(ci);
+
+	m_window->setWindowTitle(title);
+
+	b3Assert(glGetError() ==GL_NO_ERROR);
+
+	glClearColor(0.9,0.9,1,1);
+	m_window->startRendering();
+	b3Assert(glGetError() ==GL_NO_ERROR);
+
+#ifndef __APPLE__
+#ifndef _WIN32
+//some Linux implementations need the 'glewExperimental' to be true
+    glewExperimental = GL_TRUE;
+#endif
+
+
+    if (glewInit() != GLEW_OK)
+        exit(1); // or handle the error in a nicer way
+    if (!GLEW_VERSION_2_1)  // check that the machine supports the 2.1 API.
+        exit(1); // or handle the error in a nicer way
+
+#endif
+    glGetError();//don't remove this call, it is needed for Ubuntu
+
+    b3Assert(glGetError() ==GL_NO_ERROR);
+
+	m_primRenderer = new GLPrimitiveRenderer(width,height);
+	m_parameterInterface = 0;
+
+    b3Assert(glGetError() ==GL_NO_ERROR);
+
+	m_instancingRenderer = new GLInstancingRenderer(128*1024,64*1024*1024);
+	m_renderer = m_instancingRenderer ;
+	m_instancingRenderer->init();
+	m_instancingRenderer->resize(width,height);
+
+	b3Assert(glGetError() ==GL_NO_ERROR);
+
+	m_instancingRenderer->InitShaders();
+
+	m_window->setMouseMoveCallback(b3DefaultMouseMoveCallback);
+	m_window->setMouseButtonCallback(b3DefaultMouseButtonCallback);
+    m_window->setKeyboardCallback(SimpleKeyboardCallback);
+    m_window->setWheelCallback(b3DefaultWheelCallback);
+	m_window->setResizeCallback(SimpleResizeCallback);
+
+	TwGenerateDefaultFonts();
+	m_data->m_fontTextureId = BindFont(g_DefaultNormalFont);
+	m_data->m_largeFontTextureId = BindFont(g_DefaultLargeFont);
+	
+
+
+	{
+
+
+
+	m_data->m_renderCallbacks = new OpenGL2RenderCallbacks(m_primRenderer);
+	m_data->m_fontStash = sth_create(512,512,m_data->m_renderCallbacks);//256,256);//,1024);//512,512);
+    b3Assert(glGetError() ==GL_NO_ERROR);
+
+	if (!m_data->m_fontStash)
+	{
+		b3Warning("Could not create stash");
+		//fprintf(stderr, "Could not create stash.\n");
+	}
+
+
+	unsigned char* data2 = OpenSansData;
+	unsigned char* data = (unsigned char*) data2;
+	if (!(m_data->m_droidRegular = sth_add_font_from_memory(m_data->m_fontStash, data)))
+	{
+		b3Warning("error!\n");
+	}
+    b3Assert(glGetError() ==GL_NO_ERROR);
+	}
+}
+
+
+struct sth_stash* SimpleOpenGL3App::getFontStash()
+{
+	return m_data->m_fontStash;
+}
+
+void SimpleOpenGL3App::drawText3D( const char* txt, float worldPosX, float worldPosY, float worldPosZ, float size1)
+{
+
+	float viewMat[16];
+	float projMat[16];
+	m_instancingRenderer->getCameraViewMatrix(viewMat);
+	m_instancingRenderer->getCameraProjectionMatrix(projMat);
+
+	
+	float camPos[4];
+	this->m_instancingRenderer->getCameraPosition(camPos);
+	b3Vector3 cp= b3MakeVector3(camPos[0],camPos[2],camPos[1]);
+	b3Vector3 p = b3MakeVector3(worldPosX,worldPosY,worldPosZ);
+	//float dist = (cp-p).length();
+	//float dv = 0;//dist/1000.f;
+    //
+    //printf("str = %s\n",unicodeText);
+
+    float dx=0;
+
+    //int measureOnly=0;
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	int viewport[4]={0,0,m_instancingRenderer->getScreenWidth(),m_instancingRenderer->getScreenHeight()};
+
+	float posX = 450.f;
+	float posY = 100.f;
+	float winx,winy, winz;
+
+	if (!projectWorldCoordToScreen(worldPosX, worldPosY, worldPosZ,viewMat,projMat,viewport,&winx, &winy, &winz))
+	{
+		return;
+	}
+	posX = winx;
+	posY = m_instancingRenderer->getScreenHeight()/2+(m_instancingRenderer->getScreenHeight()/2)-winy;
+
+	
+	if (0)//m_useTrueTypeFont)
+	{
+		bool measureOnly = false;
+
+		float fontSize= 32;//64;//512;//128;
+		sth_draw_text(m_data->m_fontStash,
+                    m_data->m_droidRegular,fontSize,posX,posY,
+					txt,&dx, this->m_instancingRenderer->getScreenWidth(),this->m_instancingRenderer->getScreenHeight(),measureOnly,m_window->getRetinaScale());
+		sth_end_draw(m_data->m_fontStash);
+		sth_flush_draw(m_data->m_fontStash);
+	} else
+	{
+		//float width = 0.f;
+		int pos=0;
+		//float color[]={0.2f,0.2,0.2f,1.f};
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,m_data->m_largeFontTextureId);
+
+		//float width = r.x;
+		//float extraSpacing = 0.;
+
+		float startX = posX;
+		float startY = posY-g_DefaultLargeFont->m_CharHeight*size1;
+		
+
+		while (txt[pos])
+		{
+			int c = txt[pos];
+			//r.h = g_DefaultNormalFont->m_CharHeight;
+			//r.w = g_DefaultNormalFont->m_CharWidth[c]+extraSpacing;
+			float endX = startX+g_DefaultLargeFont->m_CharWidth[c]*size1;
+			float endY = posY;
+
+
+			float currentColor[]={1.f,0.2,0.2f,1.f};
+
+		//	m_primRenderer->drawTexturedRect(startX, startY, endX, endY, currentColor,g_DefaultLargeFont->m_CharU0[c],g_DefaultLargeFont->m_CharV0[c],g_DefaultLargeFont->m_CharU1[c],g_DefaultLargeFont->m_CharV1[c]);
+			float u0 = g_DefaultLargeFont->m_CharU0[c];
+			float u1 = g_DefaultLargeFont->m_CharU1[c];
+			float v0 = g_DefaultLargeFont->m_CharV0[c];
+			float v1 = g_DefaultLargeFont->m_CharV1[c];
+			float color[4] = {currentColor[0],currentColor[1],currentColor[2],currentColor[3]};
+			float x0 = startX;
+			float x1 = endX;
+			float y0 = startY;
+			float y1 = endY;
+			int screenWidth = m_instancingRenderer->getScreenWidth();
+			int screenHeight = m_instancingRenderer->getScreenHeight();
+
+			float z = 2.f*winz-1.f;//*(far
+			 float identity[16]={1,0,0,0,
+						0,1,0,0,
+						0,0,1,0,
+						0,0,0,1};
+				   PrimVertex vertexData[4] = {
+					{ PrimVec4(-1.f+2.f*x0/float(screenWidth), 1.f-2.f*y0/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v0)},
+					{ PrimVec4(-1.f+2.f*x0/float(screenWidth),  1.f-2.f*y1/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v1)},
+					{ PrimVec4( -1.f+2.f*x1/float(screenWidth),  1.f-2.f*y1/float(screenHeight), z, 1.f ), PrimVec4(color[0], color[1], color[2], color[3]) ,PrimVec2(u1,v1)},
+					{ PrimVec4( -1.f+2.f*x1/float(screenWidth), 1.f-2.f*y0/float(screenHeight), z, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u1,v0)}
+				};
+    
+				m_primRenderer->drawTexturedRect3D(vertexData[0],vertexData[1],vertexData[2],vertexData[3],identity,identity,false);
+
+			//DrawTexturedRect(0,r,g_DefaultNormalFont->m_CharU0[c],g_DefaultNormalFont->m_CharV0[c],g_DefaultNormalFont->m_CharU1[c],g_DefaultNormalFont->m_CharV1[c]);
+		//	DrawFilledRect(r);
+
+			startX = endX;
+			//startY = endY;
+
+			pos++;
+
+		}
+		glBindTexture(GL_TEXTURE_2D,0);
+	}
+
+	glDisable(GL_BLEND);
+
+
+#if 0
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+
+	int pos=0;
+	//float color[]={0.2f,0.2,0.2f,1.f};
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D,m_data->m_largeFontTextureId);
+
+	//float width = r.x;
+	//float extraSpacing = 0.;
+
+	float startX = posX;
+	float startY = posY;
+
+
+	while (txt[pos])
+	{
+			float scaling = 0.02;
+
+		int c = txt[pos];
+		//r.h = g_DefaultNormalFont->m_CharHeight;
+		//r.w = g_DefaultNormalFont->m_CharWidth[c]+extraSpacing;
+		float endX = startX-float(g_DefaultLargeFont->m_CharWidth[c])*scaling;
+		float endY = startY-float(g_DefaultLargeFont->m_CharHeight)*scaling;
+	
+
+		float currentColor[]={0.2f,0.2,0.2f,1.f};
+
+		float u0  = g_DefaultLargeFont->m_CharU0[c];
+		float v0 = g_DefaultLargeFont->m_CharV0[c];
+		float u1 = g_DefaultLargeFont->m_CharU1[c];
+		float v1 = g_DefaultLargeFont->m_CharV1[c];
+		float color[4] = {0,0,0,1};
+
+		PrimVertex vertexData[4] = {
+				{ PrimVec4(startX, startY, 0, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v0)},
+				{ PrimVec4(startX, endY, 0 , 1.f), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u0,v1)},
+				{ PrimVec4(endX, endY,0.f, 1.f ), PrimVec4(color[0], color[1], color[2], color[3]) ,PrimVec2(u1,v1)},
+				{ PrimVec4(endX,startY, 0.f, 1.f ), PrimVec4( color[0], color[1], color[2], color[3] ) ,PrimVec2(u1,v0)}
+		};
+		float viewMat[16];
+		float projMat[16];
+		m_instancingRenderer->getCameraViewMatrix(viewMat);
+		m_instancingRenderer->getCameraProjectionMatrix(projMat);
+
+		m_primRenderer->drawTexturedRect3D(vertexData[0],vertexData[1],vertexData[2],vertexData[3],viewMat,projMat,false);
+
+		//DrawTexturedRect(0,r,g_DefaultNormalFont->m_CharU0[c],g_DefaultNormalFont->m_CharV0[c],g_DefaultNormalFont->m_CharU1[c],g_DefaultNormalFont->m_CharV1[c]);
+	//	DrawFilledRect(r);
+
+		startX = endX;
+		//startY = endY;
+
+		pos++;
+
+	}
+	glBindTexture(GL_TEXTURE_2D,0);
+
+	glDisable(GL_BLEND);
+#endif
+
+}
+
+
+void SimpleOpenGL3App::drawText( const char* txt, int posXi, int posYi)
+{
+
+	float posX = (float)posXi;
+	float posY = (float) posYi;
+
+
+    //
+    //printf("str = %s\n",unicodeText);
+
+    float dx=0;
+
+    //int measureOnly=0;
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+
+	if (1)//m_useTrueTypeFont)
+	{
+		bool measureOnly = false;
+
+		float fontSize= 64;//512;//128;
+		sth_draw_text(m_data->m_fontStash,
+                    m_data->m_droidRegular,fontSize,posX,posY,
+					txt,&dx, this->m_instancingRenderer->getScreenWidth(),
+					this->m_instancingRenderer->getScreenHeight(),
+					measureOnly,
+					m_window->getRetinaScale());
+					
+		sth_end_draw(m_data->m_fontStash);
+		sth_flush_draw(m_data->m_fontStash);
+	} else
+	{
+		//float width = 0.f;
+		int pos=0;
+		//float color[]={0.2f,0.2,0.2f,1.f};
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D,m_data->m_largeFontTextureId);
+
+		//float width = r.x;
+		//float extraSpacing = 0.;
+
+		float startX = posX;
+		float startY = posY;
+
+
+		while (txt[pos])
+		{
+			int c = txt[pos];
+			//r.h = g_DefaultNormalFont->m_CharHeight;
+			//r.w = g_DefaultNormalFont->m_CharWidth[c]+extraSpacing;
+			float endX = startX+g_DefaultLargeFont->m_CharWidth[c];
+			float endY = startY+g_DefaultLargeFont->m_CharHeight;
+
+
+			float currentColor[]={0.2f,0.2,0.2f,1.f};
+
+			m_primRenderer->drawTexturedRect(startX, startY, endX, endY, currentColor,g_DefaultLargeFont->m_CharU0[c],g_DefaultLargeFont->m_CharV0[c],g_DefaultLargeFont->m_CharU1[c],g_DefaultLargeFont->m_CharV1[c]);
+
+			//DrawTexturedRect(0,r,g_DefaultNormalFont->m_CharU0[c],g_DefaultNormalFont->m_CharV0[c],g_DefaultNormalFont->m_CharU1[c],g_DefaultNormalFont->m_CharV1[c]);
+		//	DrawFilledRect(r);
+
+			startX = endX;
+			//startY = endY;
+
+			pos++;
+
+		}
+		glBindTexture(GL_TEXTURE_2D,0);
+	}
+
+	glDisable(GL_BLEND);
+}
+
+struct GfxVertex
+	{
+		float x,y,z,w;
+		float nx,ny,nz;
+		float u,v;
+	};
+
+int	SimpleOpenGL3App::registerCubeShape(float halfExtentsX,float halfExtentsY, float halfExtentsZ)
+{
+
+
+	int strideInBytes = 9*sizeof(float);
+	int numVertices = sizeof(cube_vertices)/strideInBytes;
+	int numIndices = sizeof(cube_indices)/sizeof(int);
+
+	b3AlignedObjectArray<GfxVertex> verts;
+	verts.resize(numVertices);
+	for (int i=0;i<numVertices;i++)
+	{
+		verts[i].x = halfExtentsX*cube_vertices[i*9];
+		verts[i].y = halfExtentsY*cube_vertices[i*9+1];
+		verts[i].z = halfExtentsZ*cube_vertices[i*9+2];
+		verts[i].w = cube_vertices[i*9+3];
+		verts[i].nx = cube_vertices[i*9+4];
+		verts[i].ny = cube_vertices[i*9+5];
+		verts[i].nz = cube_vertices[i*9+6];
+		verts[i].u = cube_vertices[i*9+7];
+		verts[i].v = cube_vertices[i*9+8];
+	}
+	
+	int shapeId = m_instancingRenderer->registerShape(&verts[0].x,numVertices,cube_indices,numIndices);
+	return shapeId;
+}
+
+void SimpleOpenGL3App::registerGrid(int cells_x, int cells_z, float color0[4], float color1[4])
+{
+	b3Vector3 cubeExtents=b3MakeVector3(0.5,0.5,0.5);
+	cubeExtents[m_data->m_upAxis] = 0;
+	int cubeId = registerCubeShape(cubeExtents[0],cubeExtents[1],cubeExtents[2]);
+
+	b3Quaternion orn(0,0,0,1);
+	b3Vector3 center=b3MakeVector3(0,0,0,1);
+	b3Vector3 scaling=b3MakeVector3(1,1,1,1);
+
+	for ( int i = 0; i < cells_x; i++) 
+	{
+		for (int j = 0; j < cells_z; j++) 
+		{
+			float* color =0;
+			if ((i + j) % 2 == 0) 
+			{
+				color = (float*)color0;
+			} else {
+				color = (float*)color1;
+			}
+			if (this->m_data->m_upAxis==1)
+			{
+				center =b3MakeVector3((i + 0.5f) - cells_x * 0.5f, 0.f, (j + 0.5f) - cells_z * 0.5f);
+			} else
+			{
+				center =b3MakeVector3((i + 0.5f) - cells_x * 0.5f, (j + 0.5f) - cells_z * 0.5f,0.f );
+			}
+			m_instancingRenderer->registerGraphicsInstance(cubeId,center,orn,color,scaling);
+		}
+	}
+	
+}
+
+
+int	SimpleOpenGL3App::registerGraphicsSphereShape(float radius, bool usePointSprites, int largeSphereThreshold, int mediumSphereThreshold)
+{
+
+	int strideInBytes = 9*sizeof(float);
+
+	int graphicsShapeIndex = -1;
+
+	if (radius>=largeSphereThreshold)
+	{
+		int numVertices = sizeof(detailed_sphere_vertices)/strideInBytes;
+		int numIndices = sizeof(detailed_sphere_indices)/sizeof(int);
+		graphicsShapeIndex = m_instancingRenderer->registerShape(&detailed_sphere_vertices[0],numVertices,detailed_sphere_indices,numIndices);
+	} else
+	{
+
+		if (usePointSprites)
+		{
+			int numVertices = sizeof(point_sphere_vertices)/strideInBytes;
+			int numIndices = sizeof(point_sphere_indices)/sizeof(int);
+			graphicsShapeIndex = m_instancingRenderer->registerShape(&point_sphere_vertices[0],numVertices,point_sphere_indices,numIndices,B3_GL_POINTS);
+		} else
+		{
+			if (radius>=mediumSphereThreshold)
+			{
+				int numVertices = sizeof(medium_sphere_vertices)/strideInBytes;
+				int numIndices = sizeof(medium_sphere_indices)/sizeof(int);
+				graphicsShapeIndex = m_instancingRenderer->registerShape(&medium_sphere_vertices[0],numVertices,medium_sphere_indices,numIndices);
+			} else
+			{
+				int numVertices = sizeof(low_sphere_vertices)/strideInBytes;
+				int numIndices = sizeof(low_sphere_indices)/sizeof(int);
+				graphicsShapeIndex = m_instancingRenderer->registerShape(&low_sphere_vertices[0],numVertices,low_sphere_indices,numIndices);
+			}
+		}
+	}
+	return graphicsShapeIndex;
+}
+
+
+void SimpleOpenGL3App::drawGrid(DrawGridData data)
+{
+    int gridSize = data.gridSize;
+    float upOffset = data.upOffset;
+    int upAxis = data.upAxis;
+    float gridColor[4];
+    gridColor[0] = data.gridColor[0];
+    gridColor[1] = data.gridColor[1];
+    gridColor[2] = data.gridColor[2];
+    gridColor[3] = data.gridColor[3];
+
+	int sideAxis=-1;
+	int forwardAxis=-1;
+
+	switch (upAxis)
+	{
+		case 1:
+			forwardAxis=2;
+			sideAxis=0;
+			break;
+		case 2:
+			forwardAxis=1;
+			sideAxis=0;
+			break;
+		default:
+			b3Assert(0);
+	};
+	//b3Vector3 gridColor = b3MakeVector3(0.5,0.5,0.5);
+
+	 b3AlignedObjectArray<unsigned int> indices;
+		 b3AlignedObjectArray<b3Vector3> vertices;
+	int lineIndex=0;
+	for(int i=-gridSize;i<=gridSize;i++)
+	{
+		{
+			b3Assert(glGetError() ==GL_NO_ERROR);
+			b3Vector3 from = b3MakeVector3(0,0,0);
+			from[sideAxis] = float(i);
+			from[upAxis] = upOffset;
+			from[forwardAxis] = float(-gridSize);
+			b3Vector3 to=b3MakeVector3(0,0,0);
+			to[sideAxis] = float(i);
+			to[upAxis] = upOffset;
+			to[forwardAxis] = float(gridSize);
+			vertices.push_back(from);
+			indices.push_back(lineIndex++);
+			vertices.push_back(to);
+			indices.push_back(lineIndex++);
+			m_instancingRenderer->drawLine(from,to,gridColor);
+		}
+
+		b3Assert(glGetError() ==GL_NO_ERROR);
+		{
+
+			b3Assert(glGetError() ==GL_NO_ERROR);
+			b3Vector3 from=b3MakeVector3(0,0,0);
+			from[sideAxis] = float(-gridSize);
+			from[upAxis] = upOffset;
+			from[forwardAxis] = float(i);
+			b3Vector3 to=b3MakeVector3(0,0,0);
+			to[sideAxis] = float(gridSize);
+			to[upAxis] = upOffset;
+			to[forwardAxis] = float(i);
+			vertices.push_back(from);
+			indices.push_back(lineIndex++);
+			vertices.push_back(to);
+			indices.push_back(lineIndex++);
+			m_instancingRenderer->drawLine(from,to,gridColor);
+		}
+
+	}
+
+
+	/*m_instancingRenderer->drawLines(&vertices[0].x,
+			gridColor,
+			vertices.size(),sizeof(b3Vector3),&indices[0],indices.size(),1);
+	*/
+
+	m_instancingRenderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(1,0,0),b3MakeVector3(1,0,0),3);
+	m_instancingRenderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(0,1,0),b3MakeVector3(0,1,0),3);
+	m_instancingRenderer->drawLine(b3MakeVector3(0,0,0),b3MakeVector3(0,0,1),b3MakeVector3(0,0,1),3);
+
+//	void GLInstancingRenderer::drawPoints(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, float pointDrawSize)
+
+	//we don't use drawPoints because all points would have the same color
+//	b3Vector3 points[3] = { b3MakeVector3(1, 0, 0), b3MakeVector3(0, 1, 0), b3MakeVector3(0, 0, 1) };
+//	m_instancingRenderer->drawPoints(&points[0].x, b3MakeVector3(1, 0, 0), 3, sizeof(b3Vector3), 6);
+
+	m_instancingRenderer->drawPoint(b3MakeVector3(1,0,0),b3MakeVector3(1,0,0),6);
+	m_instancingRenderer->drawPoint(b3MakeVector3(0,1,0),b3MakeVector3(0,1,0),6);
+	m_instancingRenderer->drawPoint(b3MakeVector3(0,0,1),b3MakeVector3(0,0,1),6);
+}
+
+SimpleOpenGL3App::~SimpleOpenGL3App()
+{
+	delete m_primRenderer ;
+
+	m_window->closeWindow();
+	delete m_window;
+	delete m_data ;
+}
+
+//#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+static void writeTextureToFile(int textureWidth, int textureHeight, const char* fileName, FILE* ffmpegVideo)
+{
+	int numComponents = 4;
+	//glPixelStorei(GL_PACK_ALIGNMENT,1);
+	
+	b3Assert(glGetError()==GL_NO_ERROR);
+	//glReadBuffer(GL_BACK);//COLOR_ATTACHMENT0);
+	
+	float* orgPixels = (float*)malloc(textureWidth*textureHeight*numComponents*4);
+	glReadPixels(0,0,textureWidth, textureHeight, GL_RGBA, GL_FLOAT, orgPixels);
+	//it is useful to have the actual float values for debugging purposes
+
+	//convert float->char
+	char* pixels = (char*)malloc(textureWidth*textureHeight*numComponents);
+	assert(glGetError()==GL_NO_ERROR);
+
+	for (int j=0;j<textureHeight;j++)
+	{
+		for (int i=0;i<textureWidth;i++)
+		{
+			pixels[(j*textureWidth+i)*numComponents] = char(orgPixels[(j*textureWidth+i)*numComponents]*255.f);
+			pixels[(j*textureWidth+i)*numComponents+1]=char(orgPixels[(j*textureWidth+i)*numComponents+1]*255.f);
+			pixels[(j*textureWidth+i)*numComponents+2]=char(orgPixels[(j*textureWidth+i)*numComponents+2]*255.f);
+			pixels[(j*textureWidth+i)*numComponents+3]=char(orgPixels[(j*textureWidth+i)*numComponents+3]*255.f);
+		}
+	}
+
+
+
+    if (ffmpegVideo)
+    {
+        fwrite(pixels, textureWidth*textureHeight*numComponents, 1, ffmpegVideo);
+        //fwrite(pixels, 100,1,ffmpegVideo);//textureWidth*textureHeight*numComponents, 1, ffmpegVideo);
+    } else
+    {
+        if (1)
+        {
+            //swap the pixels
+            unsigned char tmp;
+
+            for (int j=0;j<textureHeight/2;j++)
+            {
+                for (int i=0;i<textureWidth;i++)
+                {
+                    for (int c=0;c<numComponents;c++)
+                    {
+                        tmp = pixels[(j*textureWidth+i)*numComponents+c];
+                        pixels[(j*textureWidth+i)*numComponents+c]=
+                        pixels[((textureHeight-j-1)*textureWidth+i)*numComponents+c];
+                        pixels[((textureHeight-j-1)*textureWidth+i)*numComponents+c] = tmp;
+                    }
+                }
+            }
+        }
+        stbi_write_png(fileName, textureWidth,textureHeight, numComponents, pixels, textureWidth*numComponents);
+    }
+
+
+	free(pixels);
+	free(orgPixels);
+
+}
+
+
+void SimpleOpenGL3App::swapBuffer()
+{
+	m_window->endRendering();
+	if (m_data->m_frameDumpPngFileName)
+    {
+        writeTextureToFile((int)m_window->getRetinaScale()*m_instancingRenderer->getScreenWidth(),
+                          (int) m_window->getRetinaScale()*this->m_instancingRenderer->getScreenHeight(),m_data->m_frameDumpPngFileName,
+                          m_data->m_ffmpegFile);
+        //m_data->m_renderTexture->disable();
+        //if (m_data->m_ffmpegFile==0)
+        //{
+        //    m_data->m_frameDumpPngFileName = 0;
+        //}
+    }
+	m_window->startRendering();
+}
+
+// see also http://blog.mmacklin.com/2013/06/11/real-time-video-capture-with-ffmpeg/
+void SimpleOpenGL3App::dumpFramesToVideo(const char* mp4FileName)
+{
+    int width = (int)m_window->getRetinaScale()*m_instancingRenderer->getScreenWidth();
+    int height = (int)m_window->getRetinaScale()*m_instancingRenderer->getScreenHeight();
+    char cmd[8192];
+
+#ifdef _WIN32
+    sprintf(cmd, "ffmpeg -r 60 -f rawvideo -pix_fmt rgba   -s %dx%d -i - "
+    		"-y -crf 0  -b:v 1500000 -an -vcodec h264 -vf vflip  %s", width, height, mp4FileName);
+#else
+   
+   sprintf(cmd, "ffmpeg -r 60 -f rawvideo -pix_fmt rgba -s %dx%d -i - "
+    		"-threads 0 -y -crf 0 -b 50000k -vf vflip %s", width, height, mp4FileName);
+#endif
+    
+    //sprintf(cmd,"ffmpeg -r 60 -f rawvideo -pix_fmt rgba -s %dx%d -i - "
+     //            "-threads 0 -y -crf 0 -b 50000k -vf vflip %s",width,height,mp4FileName);
+
+    //              sprintf(cmd,"ffmpeg -r 60 -f rawvideo -pix_fmt rgba -s %dx%d -i - "
+    //              "-threads 0 -preset fast -y -crf 21 -vf vflip %s",width,height,mp4FileName);
+
+    if (m_data->m_ffmpegFile)
+    {
+        pclose(m_data->m_ffmpegFile);
+    }
+    m_data->m_ffmpegFile = popen(cmd, "w");
+
+    m_data->m_frameDumpPngFileName = mp4FileName;
+}
+void SimpleOpenGL3App::dumpNextFrameToPng(const char* filename)
+{
+
+    // open pipe to ffmpeg's stdin in binary write mode
+
+    m_data->m_frameDumpPngFileName = filename;
+
+//you could use m_renderTexture to allow to render at higher resolutions, such as 4k or so
+    /*if (!m_data->m_renderTexture)
+    {
+            m_data->m_renderTexture = new GLRenderToTexture();
+            GLuint renderTextureId;
+            glGenTextures(1, &renderTextureId);
+
+            // "Bind" the newly created texture : all future texture functions will modify this texture
+            glBindTexture(GL_TEXTURE_2D, renderTextureId);
+
+            // Give an empty image to OpenGL ( the last "0" )
+            //glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_UNSIGNED_BYTE, 0);
+            //glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F, g_OpenGLWidth,g_OpenGLHeight, 0,GL_RGBA, GL_FLOAT, 0);
+            glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA32F,
+                         m_instancingRenderer->getScreenWidth(),m_instancingRenderer->getScreenHeight()
+                         , 0,GL_RGBA, GL_FLOAT, 0);
+
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+            //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+            m_data->m_renderTexture->init(m_instancingRenderer->getScreenWidth(),this->m_instancingRenderer->getScreenHeight(),renderTextureId, RENDERTEXTURE_COLOR);
+    }
+
+    bool result = m_data->m_renderTexture->enable();
+*/
+}
+
+void SimpleOpenGL3App::setUpAxis(int axis)
+{
+	b3Assert((axis == 1)||(axis==2));//only Y or Z is supported at the moment
+	m_data->m_upAxis = axis;
+}
+int SimpleOpenGL3App::getUpAxis() const
+{
+	return m_data->m_upAxis;
+}
+
+

examples/OpenGLWindow/SimpleOpenGL3App.h

@@ -0,0 +1,40 @@
+#ifndef SIMPLE_OPENGL3_APP_H
+#define SIMPLE_OPENGL3_APP_H
+
+#include "../OpenGLWindow/GLInstancingRenderer.h"
+#include "../OpenGLWindow/GLPrimitiveRenderer.h"
+#include "../OpenGLWindow/b3gWindowInterface.h"
+
+#include "../CommonInterfaces/CommonGraphicsAppInterface.h"
+
+
+struct SimpleOpenGL3App : public CommonGraphicsApp
+{
+	struct SimpleInternalData* m_data;
+
+	class GLPrimitiveRenderer*	m_primRenderer;
+	class GLInstancingRenderer* m_instancingRenderer;
+	
+
+	SimpleOpenGL3App(const char* title, int width,int height);
+	virtual ~SimpleOpenGL3App();
+
+	virtual int	registerCubeShape(float halfExtentsX=1.f,float halfExtentsY=1.f, float halfExtentsZ = 1.f);
+	virtual int	registerGraphicsSphereShape(float radius, bool usePointSprites=true, int largeSphereThreshold=100, int mediumSphereThreshold=10);
+	virtual void registerGrid(int xres, int yres, float color0[4], float color1[4]);
+    void dumpNextFrameToPng(const char* pngFilename);
+    void dumpFramesToVideo(const char* mp4Filename);
+    
+	void drawGrid(DrawGridData data=DrawGridData());
+	virtual void setUpAxis(int axis);
+	virtual int getUpAxis() const;
+	
+	virtual void swapBuffer();
+	virtual void drawText( const char* txt, int posX, int posY);
+	virtual void drawText3D( const char* txt, float posX, float posZY, float posZ, float size);
+	struct sth_stash* getFontStash();
+
+
+};
+
+#endif //SIMPLE_OPENGL3_APP_H

examples/OpenGLWindow/TwFonts.h

@@ -0,0 +1,67 @@
+//  ---------------------------------------------------------------------------
+//
+//  @file       TwFonts.h
+//  @brief      Bitmaps fonts
+//  @author     Philippe Decaudin - http://www.antisphere.com
+//  @license    This file is part of the AntTweakBar library.
+//              For conditions of distribution and use, see License.txt
+//
+//  note:       Private header
+//
+//  ---------------------------------------------------------------------------
+
+
+#if !defined ANT_TW_FONTS_INCLUDED
+#define ANT_TW_FONTS_INCLUDED
+
+//#include <AntTweakBar.h>
+
+/*
+A source bitmap includes 224 characters starting from ascii char 32 (i.e. space) to ascii char 255:
+  
+ !"#$%&'()*+,-./0123456789:;<=>?
+@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
+`abcdefghijklmnopqrstuvwxyz{|}~
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+First column of a source bitmap is a delimiter with color=zero at the end of each line of characters.
+Last row of a line of characters is a delimiter with color=zero at the last pixel of each character.
+
+*/
+
+
+struct CTexFont
+{
+    unsigned char * m_TexBytes;
+    int             m_TexWidth;     // power of 2
+    int             m_TexHeight;    // power of 2
+    float           m_CharU0[256];
+    float           m_CharV0[256];
+    float           m_CharU1[256];
+    float           m_CharV1[256];
+    int             m_CharWidth[256];
+    int             m_CharHeight;
+    int             m_NbCharRead;
+
+    CTexFont();
+    ~CTexFont();
+};
+
+
+CTexFont *TwGenerateFont(const unsigned char *_Bitmap, int _BmWidth, int _BmHeight);
+
+
+extern CTexFont *g_DefaultSmallFont;
+extern CTexFont *g_DefaultNormalFont;
+extern CTexFont	*g_DefaultNormalFontAA;
+extern CTexFont *g_DefaultLargeFont;
+extern CTexFont *g_DefaultFixed1Font;
+
+void TwGenerateDefaultFonts();
+void TwDeleteDefaultFonts();
+
+
+#endif  // !defined ANT_TW_FONTS_INCLUDED

examples/OpenGLWindow/Win32InternalWindowData.h

@@ -0,0 +1,68 @@
+
+#ifndef WIN32_INTERNAL_WINDOW_DATA_H
+#define WIN32_INTERNAL_WINDOW_DATA_H
+
+#include <windows.h>
+
+
+struct InternalData2
+{
+	HWND m_hWnd;;
+	int m_fullWindowWidth;//includes borders etc
+	int m_fullWindowHeight;
+
+	int m_openglViewportWidth;//just the 3d viewport/client area
+	int m_openglViewportHeight;
+
+	HDC m_hDC;
+	HGLRC m_hRC;
+	bool m_OpenGLInitialized;
+	int m_oldScreenWidth;
+	int m_oldHeight;
+	int m_oldBitsPerPel;
+	bool m_quit;
+	int m_mouseLButton;
+	int m_mouseRButton;
+	int m_mouseMButton;
+	int m_mouseXpos;
+	int m_mouseYpos;
+
+	int m_internalKeyModifierFlags;
+
+	b3WheelCallback m_wheelCallback;
+	b3MouseMoveCallback	m_mouseMoveCallback;
+	b3MouseButtonCallback	m_mouseButtonCallback;
+	b3ResizeCallback		m_resizeCallback;
+	b3KeyboardCallback	m_keyboardCallback;
+
+	
+	
+	InternalData2()
+	{
+		m_hWnd = 0;
+		m_mouseLButton=0;
+		m_mouseRButton=0;
+		m_mouseMButton=0;
+		m_internalKeyModifierFlags = 0;
+		m_fullWindowWidth = 0;
+		m_fullWindowHeight= 0;
+		m_openglViewportHeight=0;
+		m_openglViewportWidth=0;
+		m_hDC = 0;
+		m_hRC = 0;
+		m_OpenGLInitialized = false;
+		m_oldScreenWidth = 0;
+		m_oldHeight = 0;
+		m_oldBitsPerPel = 0;
+		m_quit = false;
+
+		m_keyboardCallback = 0;
+		m_mouseMoveCallback = 0;
+		m_mouseButtonCallback = 0;
+		m_resizeCallback = 0;
+		m_wheelCallback = 0;
+
+	}
+};
+
+#endif //WIN32_INTERNAL_WINDOW_DATA_H

examples/OpenGLWindow/Win32OpenGLWindow.cpp

@@ -0,0 +1,182 @@
+/*
+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
+
+
+#include "Win32OpenGLWindow.h"
+
+#include "OpenGLInclude.h"
+
+//#include "Bullet3Common/b3Vector3.h"
+
+#include "Win32InternalWindowData.h"
+#include <stdio.h>
+
+static void printGLString(const char *name, GLenum s) {
+    const char *v = (const char *) glGetString(s);
+  printf("%s = %s\n",name, v);
+}
+
+bool sOpenGLVerbose = true;
+
+void Win32OpenGLWindow::enableOpenGL()
+{
+
+	PIXELFORMATDESCRIPTOR pfd;
+	int format;
+	
+	// get the device context (DC)
+	m_data->m_hDC = GetDC( m_data->m_hWnd );
+	
+	// set the pixel format for the DC
+	ZeroMemory( &pfd, sizeof( pfd ) );
+	pfd.nSize = sizeof( pfd );
+	pfd.nVersion = 1;
+	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+	pfd.iPixelType = PFD_TYPE_RGBA;
+	pfd.cColorBits = 32;
+	pfd.cRedBits = 8;
+    pfd.cGreenBits = 8;
+    pfd.cBlueBits = 8;
+    pfd.cAlphaBits = 8;
+
+	pfd.cDepthBits = 24;
+	pfd.cStencilBits = 8;//1;
+	pfd.iLayerType = PFD_MAIN_PLANE;
+	format = ChoosePixelFormat( m_data->m_hDC, &pfd );
+	SetPixelFormat( m_data->m_hDC, format, &pfd );
+	
+	// create and enable the render context (RC)
+	m_data->m_hRC = wglCreateContext( m_data->m_hDC );
+	wglMakeCurrent( m_data->m_hDC, m_data->m_hRC );
+
+	if (sOpenGLVerbose)
+	{
+		 printGLString("Version", GL_VERSION);
+		printGLString("Vendor", GL_VENDOR);
+		printGLString("Renderer", GL_RENDERER);
+	}
+    //printGLString("Extensions", GL_EXTENSIONS);
+
+}
+
+
+
+void Win32OpenGLWindow::disableOpenGL()
+{
+	wglMakeCurrent( NULL, NULL );
+	wglDeleteContext( m_data->m_hRC );
+//	ReleaseDC( m_data->m_hWnd, m_data->m_hDC );
+
+}
+
+
+
+
+
+void	Win32OpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci)
+{
+	Win32Window::createWindow(ci);
+
+	//VideoDriver = video::createOpenGLDriver(CreationParams, FileSystem, this);
+	enableOpenGL();
+
+}
+
+
+
+
+Win32OpenGLWindow::Win32OpenGLWindow()
+{
+	
+	
+}
+
+Win32OpenGLWindow::~Win32OpenGLWindow()
+{
+	
+}
+
+
+void	Win32OpenGLWindow::closeWindow()
+{
+	disableOpenGL();
+
+	Win32Window::closeWindow();
+}
+
+
+
+void	Win32OpenGLWindow::startRendering()
+{
+		pumpMessage();
+		//don't clear all 3 buffers because some AMD drivers are buggy
+		//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		
+
+		//glCullFace(GL_BACK);
+		//glFrontFace(GL_CCW);
+		glEnable(GL_DEPTH_TEST);
+
+}
+
+
+void	Win32OpenGLWindow::renderAllObjects()
+{
+}
+
+void	Win32OpenGLWindow::endRendering()
+ {
+	SwapBuffers( m_data->m_hDC );
+
+}
+
+int Win32OpenGLWindow::fileOpenDialog(char* fileName, int maxFileNameLength)
+{
+	//wchar_t wideChars[1024];
+
+		OPENFILENAME ofn ;
+	ZeroMemory( &ofn , sizeof( ofn));
+	ofn.lStructSize = sizeof ( ofn );
+	ofn.hwndOwner = NULL  ;
+
+#ifdef UNICODE
+	WCHAR bla[1024];
+	ofn.lpstrFile = bla;
+	ofn.lpstrFile[0] = '\0';
+	ofn.nMaxFile = 1023;
+	ofn.lpstrFilter = L"URDF\0*.urdf\0";
+#else
+	ofn.lpstrFile = fileName;
+	ofn.lpstrFile[0] = '\0';
+	ofn.nMaxFile = 1023;
+	//ofn.lpstrFilter = "All\0*.*\0Text\0*.TXT\0";
+	ofn.lpstrFilter = "URDF\0*.urdf\0";
+	
+#endif
+
+	ofn.nFilterIndex =1;
+	ofn.lpstrFileTitle = NULL ;
+	ofn.nMaxFileTitle = 0 ;
+	ofn.lpstrInitialDir=NULL ;
+	ofn.Flags = OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST ;
+	GetOpenFileName( &ofn );
+	return strlen(fileName);
+
+
+	//return 0;
+}
+
+	

examples/OpenGLWindow/Win32OpenGLWindow.h

@@ -0,0 +1,60 @@
+/*
+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 _WIN32_OPENGL_RENDER_MANAGER_H
+#define _WIN32_OPENGL_RENDER_MANAGER_H
+
+
+
+#include "Win32Window.h"
+
+#define b3gDefaultOpenGLWindow Win32OpenGLWindow
+
+class Win32OpenGLWindow : public Win32Window
+{
+	bool m_OpenGLInitialized;
+
+	protected:
+		
+		
+	void enableOpenGL();
+		
+	void disableOpenGL();
+
+public:
+
+	Win32OpenGLWindow();
+
+	virtual ~Win32OpenGLWindow();
+
+	virtual	void	createWindow(const b3gWindowConstructionInfo& ci);
+	
+	virtual	void	closeWindow();
+
+	virtual	void	startRendering();
+
+	virtual	void	renderAllObjects();
+
+	virtual	void	endRendering();
+
+	virtual float getRetinaScale() const {return 1.f;}
+
+	virtual int fileOpenDialog(char* fileName, int maxFileNameLength);
+};
+
+
+
+#endif //_WIN32_OPENGL_RENDER_MANAGER_H

examples/OpenGLWindow/Win32Window.cpp

@@ -0,0 +1,798 @@
+/*
+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
+
+
+#include "Win32Window.h"
+
+#include "OpenGLInclude.h"
+
+#include <wchar.h>
+static InternalData2* sData = 0;
+
+#include "Win32InternalWindowData.h"
+
+
+enum 
+{
+	INTERNAL_SHIFT_MODIFIER=1,
+	INTERNAL_ALT_MODIFIER=2,
+	INTERNAL_CONTROL_MODIFIER=4,
+};
+
+void Win32Window::pumpMessage()
+{
+	MSG msg;
+		// check for messages
+	//'if' instead of 'while' can make mainloop smoother. 
+	//@todo: use separate threads for input and rendering
+		while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE )  )
+		{
+			
+			// handle or dispatch messages
+			if ( msg.message == WM_QUIT ) 
+			{
+				m_data->m_quit = TRUE;
+			} 
+			else 
+			{
+				TranslateMessage( &msg );
+				DispatchMessage( &msg );
+			}
+			
+//			gDemoApplication->displayCallback();
+			
+
+		};
+}
+
+int getAsciiCodeFromVirtualKeycode(int virtualKeyCode)
+{
+	int keycode = 0xffffffff;
+	if (virtualKeyCode >= '0' &&  virtualKeyCode <= '9')
+	{
+		return virtualKeyCode;
+	}
+	if (virtualKeyCode >= 'a' &&  virtualKeyCode <= 'z')
+	{
+		return virtualKeyCode;
+	}
+	if (virtualKeyCode >= 'A' &&  virtualKeyCode <= 'Z')
+	{
+		return virtualKeyCode+32;//todo: fix the ascii A vs a input
+	}
+	switch (virtualKeyCode)
+	{
+		case VK_RETURN: {keycode = B3G_RETURN; break; };
+		case VK_F1: {keycode = B3G_F1; break;}
+		case VK_F2: {keycode = B3G_F2; break;}
+		case VK_F3: {keycode = B3G_F3; break;}
+		case VK_F4: {keycode = B3G_F4; break;}
+		case VK_F5: {keycode = B3G_F5; break;}
+		case VK_F6: {keycode = B3G_F6; break;}
+		case VK_F7: {keycode = B3G_F7; break;}
+		case VK_F8: {keycode = B3G_F8; break;}
+		case VK_F9: {keycode = B3G_F9; break;}
+		case VK_F10: {keycode= B3G_F10; break;}
+
+		//case VK_SPACE: {keycode= ' '; break;}
+		
+		case VK_NEXT:	{keycode= B3G_PAGE_DOWN; break;}
+		case VK_PRIOR:	{keycode= B3G_PAGE_UP; break;}
+		
+		case VK_INSERT: {keycode= B3G_INSERT; break;}
+		case VK_BACK: {keycode= B3G_BACKSPACE; break;}
+		case VK_DELETE: {keycode= B3G_DELETE; break;}
+
+		case VK_END:{keycode= B3G_END; break;}
+		case VK_HOME:{keycode= B3G_HOME; break;}
+		case VK_LEFT:{keycode= B3G_LEFT_ARROW; break;}
+		case VK_UP:{keycode= B3G_UP_ARROW; break;}
+		case VK_RIGHT:{keycode= B3G_RIGHT_ARROW; break;}
+		case VK_DOWN:{keycode= B3G_DOWN_ARROW; break;}
+		case VK_SHIFT:{keycode=B3G_SHIFT;break;}
+		case VK_MENU:{keycode=B3G_ALT;break;}
+		case VK_CONTROL:{keycode=B3G_CONTROL;break;}
+		default:
+			{
+				//keycode = MapVirtualKey( virtualKeyCode, MAPVK_VK_TO_CHAR ) & 0x0000FFFF;
+			}
+	};
+
+	return keycode;
+}
+
+bool Win32Window::isModifiedKeyPressed(int key)
+{
+	bool isPressed = false;
+
+	switch (key)
+	{
+		case B3G_ALT:
+		{
+			isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_ALT_MODIFIER)!=0);
+			break;
+		};
+		case B3G_SHIFT:
+		{
+			isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_SHIFT_MODIFIER)!=0);
+			break;
+		};
+		case B3G_CONTROL:
+		{
+			isPressed = ((sData->m_internalKeyModifierFlags&INTERNAL_CONTROL_MODIFIER)!=0);
+			break;
+		};
+
+		default:
+		{
+		}
+	};
+	return isPressed;//m_internalKeyModifierFlags
+}
+
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	//printf("msg = %d\n", message);
+	switch (message)
+	{
+		
+	case WM_PAINT:
+		{
+			PAINTSTRUCT ps;
+			BeginPaint(hWnd, &ps);
+			EndPaint(hWnd, &ps);
+		}
+		return 1;
+
+	case WM_ERASEBKGND:
+		return 1;
+	
+	case WM_CLOSE:
+		if (sData)
+			sData->m_quit = true;
+		//PostQuitMessage(0);
+		return 1;
+
+	case WM_DESTROY:
+		if (sData)
+			sData->m_quit = true;
+		//PostQuitMessage(0);
+		return 1;
+
+	case WM_SYSKEYUP:
+	case WM_KEYUP:
+	{
+
+			int keycode = getAsciiCodeFromVirtualKeycode(wParam);
+			switch (keycode)
+			{
+				case B3G_ALT:
+				{
+					sData->m_internalKeyModifierFlags&=~INTERNAL_ALT_MODIFIER;
+					break;
+				};
+				case B3G_SHIFT:
+				{
+					sData->m_internalKeyModifierFlags &= ~INTERNAL_SHIFT_MODIFIER;
+					break;
+				};
+				case B3G_CONTROL:
+				{
+					sData->m_internalKeyModifierFlags &=~INTERNAL_CONTROL_MODIFIER;
+					break;
+				};
+			}
+
+			if (keycode>=0 && sData && sData->m_keyboardCallback )
+			{
+				int state=0;
+				(*sData->m_keyboardCallback)(keycode,state);
+			}
+			return 0;
+		}
+	case WM_CHAR:
+		{
+			//skip 'enter' key, it is processed in WM_KEYUP/WM_KEYDOWN 
+			int keycode = getAsciiCodeFromVirtualKeycode(wParam);
+			if (keycode < 0)
+			{
+				if (sData && sData->m_keyboardCallback && ((HIWORD(lParam) & KF_REPEAT) == 0))
+				{
+					int state = 1;
+					(*sData->m_keyboardCallback)(wParam, state);
+				}
+			}
+			return 0;
+		}
+	case WM_SYSKEYDOWN:
+	case WM_KEYDOWN:
+		{
+			int keycode = getAsciiCodeFromVirtualKeycode(wParam);
+			switch (keycode)
+			{
+				case B3G_ALT:
+				{
+					sData->m_internalKeyModifierFlags|=INTERNAL_ALT_MODIFIER;
+					break;
+				};
+				case B3G_SHIFT:
+				{
+					sData->m_internalKeyModifierFlags |= INTERNAL_SHIFT_MODIFIER;
+					break;
+				};
+				case B3G_CONTROL:
+				{
+					sData->m_internalKeyModifierFlags |=INTERNAL_CONTROL_MODIFIER;
+					break;
+				};
+			}
+			if (keycode>=0 && sData && sData->m_keyboardCallback)// && ((HIWORD(lParam) & KF_REPEAT) == 0))
+			{
+				int state = 1;
+				(*sData->m_keyboardCallback)(keycode,state);
+				return 1;
+			}
+			return 0;
+		}
+
+		case WM_MBUTTONUP:
+	{
+			int xPos = LOWORD(lParam); 
+			int yPos = HIWORD(lParam); 
+			if (sData)
+			{
+				sData->m_mouseMButton=0;
+				sData->m_mouseXpos = xPos;
+				sData->m_mouseYpos = yPos;
+				if (sData && sData->m_mouseButtonCallback)
+					(*sData->m_mouseButtonCallback)(1,0,xPos,yPos);
+			}
+		break;
+	}
+	case WM_MBUTTONDOWN:
+	{
+			int xPos = LOWORD(lParam); 
+			int yPos = HIWORD(lParam); 
+			if (sData)
+			{
+				sData->m_mouseMButton=1;
+				sData->m_mouseXpos = xPos;
+				sData->m_mouseYpos = yPos;
+				if (sData && sData->m_mouseButtonCallback)
+					(*sData->m_mouseButtonCallback)(1,1,xPos,yPos);
+			}
+		break;
+	}
+
+	case WM_LBUTTONUP:
+	{
+			int xPos = LOWORD(lParam); 
+			int yPos = HIWORD(lParam); 
+			if (sData)
+			{
+				sData->m_mouseLButton=0;
+				sData->m_mouseXpos = xPos;
+				sData->m_mouseYpos = yPos;
+				
+				if (sData && sData->m_mouseButtonCallback)
+					(*sData->m_mouseButtonCallback)(0,0,xPos,yPos);
+
+			}
+		//	gDemoApplication->mouseFunc(0,1,xPos,yPos);
+		break;
+	}
+	case WM_LBUTTONDOWN:
+		{
+				int xPos = LOWORD(lParam); 
+				int yPos = HIWORD(lParam); 
+			if (sData)
+			{
+				sData->m_mouseLButton=1;
+				sData->m_mouseXpos = xPos;
+				sData->m_mouseYpos = yPos;
+
+				if (sData && sData->m_mouseButtonCallback)
+					(*sData->m_mouseButtonCallback)(0,1,xPos,yPos);
+			}
+			break;
+		}
+
+	case 0x020e://WM_MOUSEWHEEL_LEFT_RIGHT
+	{
+
+		int  zDelta = (short)HIWORD(wParam);
+		int xPos = LOWORD(lParam); 
+		int yPos = HIWORD(lParam); 
+		//m_cameraDistance -= zDelta*0.01;
+		if (sData && sData->m_wheelCallback)
+			(*sData->m_wheelCallback)(-float(zDelta)*0.05f,0);
+		return 1;
+		break;
+	}
+	case 0x020A://WM_MOUSEWHEEL:
+	{
+		
+		int  zDelta = (short)HIWORD(wParam);
+		int xPos = LOWORD(lParam); 
+		int yPos = HIWORD(lParam); 
+		//m_cameraDistance -= zDelta*0.01;
+		if (sData && sData->m_wheelCallback)
+			(*sData->m_wheelCallback)(0,float(zDelta)*0.05f);
+		return 1;
+		break;
+	}
+
+	case WM_MOUSEMOVE:
+		{
+				int xPos = LOWORD(lParam); 
+				int yPos = HIWORD(lParam); 
+				sData->m_mouseXpos = xPos;
+				sData->m_mouseYpos = yPos;
+
+				if (sData && sData->m_mouseMoveCallback)
+					(*sData->m_mouseMoveCallback)(xPos,yPos);
+
+			break;
+		}
+	case WM_RBUTTONUP:
+	{
+			int xPos = LOWORD(lParam); 
+			int yPos = HIWORD(lParam); 
+			sData->m_mouseRButton = 1;
+
+			if (sData && sData->m_mouseButtonCallback)
+				(*sData->m_mouseButtonCallback)(2,0,sData->m_mouseXpos,sData->m_mouseYpos);
+
+			//gDemoApplication->mouseFunc(2,1,xPos,yPos);
+		break;
+	}
+	case WM_RBUTTONDOWN:
+	{
+			int xPos = LOWORD(lParam); 
+			int yPos = HIWORD(lParam); 
+			sData->m_mouseRButton = 0;
+			if (sData && sData->m_mouseButtonCallback)
+				(*sData->m_mouseButtonCallback)(2,1,sData->m_mouseXpos,sData->m_mouseYpos);
+
+		break;
+	}
+	case WM_QUIT:
+		{
+			return 0;
+			break;
+		}
+	case WM_SIZE:													// Size Action Has Taken Place
+
+			RECT clientRect;
+			GetClientRect(hWnd,&clientRect);
+
+			switch (wParam)												// Evaluate Size Action
+			{
+
+				case SIZE_MINIMIZED:									// Was Window Minimized?
+				return 0;												// Return
+
+				case SIZE_MAXIMIZED:									// Was Window Maximized?
+				case SIZE_RESTORED:										// Was Window Restored?
+					RECT wr;
+					GetWindowRect(hWnd,&wr);
+					
+					sData->m_fullWindowWidth = wr.right-wr.left;
+					sData->m_fullWindowHeight = wr.bottom-wr.top;//LOWORD (lParam) HIWORD (lParam);
+					sData->m_openglViewportWidth = clientRect.right;
+					sData->m_openglViewportHeight = clientRect.bottom;
+					glViewport(0, 0, sData->m_openglViewportWidth, sData->m_openglViewportHeight);
+
+					if (sData->m_resizeCallback)
+						(*sData->m_resizeCallback)(sData->m_openglViewportWidth,sData->m_openglViewportHeight);
+					//if (sOpenGLInitialized)
+					//{
+					//	//gDemoApplication->reshape(sWidth,sHeight);
+					//}
+				return 0;												// Return
+			}
+		break;
+
+	default:{
+				
+
+			}
+	};
+
+	return DefWindowProc(hWnd, message, wParam, lParam);
+}
+
+
+
+void Win32Window::setWindowTitle(const char* titleChar)
+{
+	
+	wchar_t  windowTitle[1024];
+	swprintf(windowTitle, 1024, L"%hs", titleChar);
+
+	DWORD dwResult;
+
+#ifdef _WIN64
+		SetWindowTextW(m_data->m_hWnd, windowTitle);
+#else
+		SendMessageTimeoutW(m_data->m_hWnd, WM_SETTEXT, 0,
+				reinterpret_cast<LPARAM>(windowTitle),
+				SMTO_ABORTIFHUNG, 2000, &dwResult);
+#endif
+}
+
+void	Win32Window::createWindow(const b3gWindowConstructionInfo& ci)
+{
+	int oglViewportWidth = ci.m_width;
+	int oglViewportHeight = ci.m_height;
+	bool fullscreen = ci.m_fullscreen;
+	int colorBitsPerPixel = ci.m_colorBitsPerPixel;
+	void* windowHandle = ci.m_windowHandle;
+
+	// get handle to exe file
+	HINSTANCE hInstance = GetModuleHandle(0);
+
+
+	// create the window if we need to and we do not use the null device
+	if (!windowHandle)
+	{
+#ifdef UNICODE
+		const wchar_t * ClassName = L"DeviceWin32";
+		const wchar_t*  emptyString= L"";
+#else
+		const char* ClassName = "DeviceWin32";
+		const char* emptyString = "";
+#endif
+		// Register Class
+		WNDCLASSEX wcex;
+		wcex.cbSize		= sizeof(WNDCLASSEX);
+		wcex.style		= CS_HREDRAW | CS_VREDRAW;
+		wcex.lpfnWndProc	= WndProc;
+		wcex.cbClsExtra		= 0;
+		wcex.cbWndExtra		= 0;
+		wcex.hInstance		= hInstance;
+		wcex.hIcon		= LoadIcon( NULL, IDI_APPLICATION ); //(HICON)LoadImage(hInstance, "bullet_ico.ico", IMAGE_ICON, 0,0, LR_LOADTRANSPARENT);//LR_LOADFROMFILE);
+		wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
+		wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
+		wcex.lpszMenuName	= 0;
+		wcex.lpszClassName	= ClassName;
+		wcex.hIconSm		= 0;
+
+		// if there is an icon, load it
+//		wcex.hIcon = (HICON)LoadImage(hInstance, "bullet.ico", IMAGE_ICON, 0,0, LR_LOADFROMFILE);
+
+		RegisterClassEx(&wcex);
+
+		// calculate client size
+
+		RECT clientSize;
+		clientSize.top = 0;
+		clientSize.left = 0;
+		clientSize.right = oglViewportWidth;
+		clientSize.bottom = oglViewportHeight;
+
+		DWORD style = WS_POPUP;
+
+		if (!fullscreen)
+			style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
+
+		AdjustWindowRect(&clientSize, style, false);
+		
+		m_data->m_fullWindowWidth = clientSize.right - clientSize.left;
+		m_data->m_fullWindowHeight = clientSize.bottom - clientSize.top;
+
+		int windowLeft = (GetSystemMetrics(SM_CXSCREEN) - m_data->m_fullWindowWidth) / 2;
+		int windowTop = (GetSystemMetrics(SM_CYSCREEN) - m_data->m_fullWindowHeight) / 2;
+
+		if (fullscreen)
+		{
+			windowLeft = 0;
+			windowTop = 0;
+		}
+
+		// create window
+
+		m_data->m_hWnd = CreateWindow( ClassName, emptyString, style, windowLeft, windowTop,
+			m_data->m_fullWindowWidth, m_data->m_fullWindowHeight,NULL, NULL, hInstance, NULL);
+
+		
+		RECT clientRect;
+		GetClientRect(m_data->m_hWnd,&clientRect);
+
+
+
+		ShowWindow(m_data->m_hWnd, SW_SHOW);
+		UpdateWindow(m_data->m_hWnd);
+
+		MoveWindow(m_data->m_hWnd, windowLeft, windowTop, m_data->m_fullWindowWidth, m_data->m_fullWindowHeight, TRUE);
+
+		GetClientRect(m_data->m_hWnd,&clientRect);
+		int w = clientRect.right-clientRect.left;
+		int h = clientRect.bottom-clientRect.top;
+//		printf("actual client OpenGL viewport width / height = %d, %d\n",w,h);
+		m_data->m_openglViewportHeight = h;
+		m_data->m_openglViewportWidth = w;
+		
+	}
+	else if (windowHandle)
+	{
+		// attach external window
+		m_data->m_hWnd = static_cast<HWND>(windowHandle);
+		RECT r;
+		GetWindowRect(m_data->m_hWnd, &r);
+		m_data->m_fullWindowWidth = r.right - r.left;
+		m_data->m_fullWindowHeight= r.bottom - r.top;
+
+
+		//sFullScreen = false;
+		//sExternalWindow = true;
+	}
+
+
+	if (fullscreen)
+	{
+		DEVMODE dm;
+		memset(&dm, 0, sizeof(dm));
+		dm.dmSize = sizeof(dm);
+		// use default values from current setting
+		EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
+		m_data->m_oldScreenWidth = dm.dmPelsWidth;
+		m_data->m_oldHeight = dm.dmPelsHeight;
+		m_data->m_oldBitsPerPel = dm.dmBitsPerPel;
+
+		dm.dmPelsWidth = oglViewportWidth;
+		dm.dmPelsHeight = oglViewportHeight;
+		if (colorBitsPerPixel)
+		{
+			dm.dmBitsPerPel = colorBitsPerPixel;
+		}
+		dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+
+		LONG res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
+		if (res != DISP_CHANGE_SUCCESSFUL)
+		{ // try again without forcing display frequency
+			dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
+			res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
+		}
+
+	}
+
+
+}
+
+
+void	Win32Window::switchFullScreen(bool fullscreen,int width,int height,int colorBitsPerPixel)
+{
+	
+	LONG res;
+	DEVMODE dm;
+	memset(&dm, 0, sizeof(dm));
+	dm.dmSize = sizeof(dm);
+	// use default values from current setting
+	EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
+
+	dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+
+	if (fullscreen && !m_data->m_oldScreenWidth)
+	{
+		m_data->m_oldScreenWidth = dm.dmPelsWidth;
+		m_data->m_oldHeight = dm.dmPelsHeight;
+		m_data->m_oldBitsPerPel = dm.dmBitsPerPel;
+
+		if (width && height)
+		{
+			dm.dmPelsWidth = width;
+			dm.dmPelsHeight = height;
+		} else
+		{
+			dm.dmPelsWidth = m_data->m_fullWindowWidth;
+			dm.dmPelsHeight = m_data->m_fullWindowHeight;
+		}
+		if (colorBitsPerPixel)
+		{
+			dm.dmBitsPerPel = colorBitsPerPixel;
+		}
+	} else
+	{
+		if (m_data->m_oldScreenWidth)
+		{
+			dm.dmPelsWidth =	m_data->m_oldScreenWidth;
+			dm.dmPelsHeight=	m_data->m_oldHeight;
+			dm.dmBitsPerPel =   m_data->m_oldBitsPerPel;
+		}
+	}
+
+	if (fullscreen)
+	{
+
+		res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
+		if (!res)
+		{
+			dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
+			res = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
+		}
+
+		DWORD style = WS_POPUP;
+		SetWindowLong(m_data->m_hWnd,  GWL_STYLE, style);
+
+		MoveWindow(m_data->m_hWnd, 0, 0, m_data->m_fullWindowWidth, m_data->m_fullWindowHeight, TRUE);
+		
+		SetWindowPos(m_data->m_hWnd, NULL,0,0, (int)width, (int)height,
+                         SWP_FRAMECHANGED |SWP_SHOWWINDOW);//|SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOOWNERZORDER | SWP_NOREPOSITION | SWP_NOZORDER);
+
+
+	} else
+	{
+		res = ChangeDisplaySettings(&dm, 0);
+
+		DWORD style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
+		SetWindowLong(m_data->m_hWnd,  GWL_STYLE, style);
+
+		SetWindowPos(m_data->m_hWnd, NULL,0,0, (int)width, (int)height,
+                         SWP_FRAMECHANGED |SWP_SHOWWINDOW);
+		//|SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOOWNERZORDER | SWP_NOREPOSITION | SWP_NOZORDER);
+
+	}
+
+
+}
+
+
+
+Win32Window::Win32Window()
+{
+	m_data = new InternalData2();
+	sData = m_data;
+	
+}
+
+Win32Window::~Win32Window()
+{
+	setKeyboardCallback(0);
+	setMouseMoveCallback(0);
+	setMouseButtonCallback(0);
+	setWheelCallback(0);
+	setResizeCallback(0);
+	
+	sData = 0;
+	delete m_data;
+	
+}
+
+void Win32Window::setRenderCallback( b3RenderCallback renderCallback)
+{
+
+}
+
+void	Win32Window::closeWindow()
+{
+	setKeyboardCallback(0);
+	setMouseMoveCallback(0);
+	setMouseButtonCallback(0);
+	setWheelCallback(0);
+	setResizeCallback(0);
+	setRenderCallback(0);
+	
+	
+	DestroyWindow(this->m_data->m_hWnd);
+}
+
+void Win32Window::getMouseCoordinates(int& x, int& y)
+{
+	x = m_data->m_mouseXpos;
+	y = m_data->m_mouseYpos;
+
+}
+
+void Win32Window::runMainLoop()
+{
+
+}
+
+
+void	Win32Window::startRendering()
+{
+		pumpMessage();
+
+//		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);	//clear buffers
+		
+		//glCullFace(GL_BACK);
+		//glFrontFace(GL_CCW);
+	//	glEnable(GL_DEPTH_TEST);
+
+
+
+}
+
+
+void	Win32Window::renderAllObjects()
+{
+}
+
+void	Win32Window::endRendering()
+{
+	SwapBuffers( m_data->m_hDC );
+}
+
+float	Win32Window::getTimeInSeconds()
+{
+	return 0.f;
+}
+
+void	Win32Window::setDebugMessage(int x,int y,const char* message)
+{
+}
+
+void	Win32Window::setRequestExit()
+{
+	m_data->m_quit = true;
+}
+bool Win32Window::requestedExit() const
+{
+	return m_data->m_quit;
+}
+
+void Win32Window::setWheelCallback(b3WheelCallback wheelCallback)
+{
+	m_data->m_wheelCallback = wheelCallback;
+}
+
+void Win32Window::setMouseMoveCallback(b3MouseMoveCallback	mouseCallback)
+{
+	m_data->m_mouseMoveCallback = mouseCallback;
+}
+
+void Win32Window::setMouseButtonCallback(b3MouseButtonCallback	mouseCallback)
+{
+	m_data->m_mouseButtonCallback = mouseCallback;
+}
+
+void Win32Window::setResizeCallback(b3ResizeCallback	resizeCallback)
+{
+	m_data->m_resizeCallback = resizeCallback;
+	if (m_data->m_resizeCallback)
+		(*m_data->m_resizeCallback)(m_data->m_openglViewportWidth,m_data->m_openglViewportHeight);
+}
+
+void Win32Window::setKeyboardCallback( b3KeyboardCallback	keyboardCallback)
+{
+	m_data->m_keyboardCallback = keyboardCallback;
+	
+}
+
+b3KeyboardCallback	Win32Window::getKeyboardCallback()
+{
+	return m_data->m_keyboardCallback;
+}
+
+b3MouseMoveCallback Win32Window::getMouseMoveCallback()
+{
+	return m_data->m_mouseMoveCallback;
+}
+b3MouseButtonCallback Win32Window::getMouseButtonCallback()
+{
+	return m_data->m_mouseButtonCallback;
+}
+b3ResizeCallback Win32Window::getResizeCallback()
+{
+	return m_data->m_resizeCallback;
+}
+b3WheelCallback Win32Window::getWheelCallback()
+{
+	return m_data->m_wheelCallback;
+}
+
+	

examples/OpenGLWindow/Win32Window.h

@@ -0,0 +1,86 @@
+/*
+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 _WIN32_WINDOW_H
+#define _WIN32_WINDOW_H
+
+
+
+struct InternalData2;
+
+#include "b3gWindowInterface.h"
+
+class Win32Window : public b3gWindowInterface
+{
+	protected:
+		
+		struct InternalData2*	m_data;
+		
+
+		void pumpMessage();
+	
+		
+	
+public:
+
+	Win32Window();
+
+	virtual ~Win32Window();
+
+	virtual	void	createWindow(const b3gWindowConstructionInfo& ci);
+	
+	virtual void	switchFullScreen(bool fullscreen,int width=0,int height=0,int colorBitsPerPixel=0);
+
+	virtual	void	closeWindow();
+
+	virtual void	runMainLoop();
+
+	virtual	void	startRendering();
+
+	virtual	void	renderAllObjects();
+
+	virtual	void	endRendering();
+
+	virtual	float	getTimeInSeconds();
+
+	virtual void	setDebugMessage(int x,int y,const char* message);
+	
+	virtual bool	requestedExit() const;
+	
+	virtual	void	setRequestExit();
+
+	virtual void getMouseCoordinates(int& x, int& y);
+
+	virtual	void setMouseMoveCallback(b3MouseMoveCallback	mouseCallback);
+	virtual	void setMouseButtonCallback(b3MouseButtonCallback	mouseCallback);
+	virtual	void setResizeCallback(b3ResizeCallback	resizeCallback);
+	virtual	void setWheelCallback(b3WheelCallback wheelCallback);
+	virtual	void setKeyboardCallback( b3KeyboardCallback	keyboardCallback);
+
+	virtual b3MouseMoveCallback getMouseMoveCallback();
+	virtual b3MouseButtonCallback getMouseButtonCallback();
+	virtual b3ResizeCallback getResizeCallback();
+	virtual b3WheelCallback getWheelCallback();
+	virtual b3KeyboardCallback	getKeyboardCallback();
+
+	virtual void setRenderCallback( b3RenderCallback renderCallback);
+
+	virtual	void setWindowTitle(const char* title);
+
+	virtual bool	isModifiedKeyPressed(int key);
+};
+
+#endif //_WIN32_WINDOW_H

examples/OpenGLWindow/X11OpenGLWindow.h

@@ -0,0 +1,72 @@
+#ifndef X11_OPENGL_WINDOW_H
+#define X11_OPENGL_WINDOW_H
+
+#define b3gDefaultOpenGLWindow X11OpenGLWindow
+
+#include "b3gWindowInterface.h"
+
+class X11OpenGLWindow : public b3gWindowInterface
+{
+
+	struct InternalData2*   m_data;
+        bool m_OpenGLInitialized;
+	bool m_requestedExit;
+
+protected:
+
+        void enableOpenGL();
+
+        void disableOpenGL();
+
+        void pumpMessage();
+
+        int getAsciiCodeFromVirtualKeycode(int orgCode);
+
+public:
+
+        X11OpenGLWindow();
+
+        virtual ~X11OpenGLWindow();
+
+        virtual void    createWindow(const b3gWindowConstructionInfo& ci);
+
+        virtual void    closeWindow();
+
+        virtual void    startRendering();
+
+        virtual void    renderAllObjects();
+
+        virtual void    endRendering();
+
+        virtual float getRetinaScale() const {return 1.f;}
+
+
+	virtual void    runMainLoop();
+        virtual float   getTimeInSeconds();
+
+        virtual bool    requestedExit() const;
+        virtual void    setRequestExit() ;
+
+
+        virtual void setMouseMoveCallback(b3MouseMoveCallback   mouseCallback);
+        virtual void setMouseButtonCallback(b3MouseButtonCallback       mouseCallback);
+        virtual void setResizeCallback(b3ResizeCallback resizeCallback);
+        virtual void setWheelCallback(b3WheelCallback wheelCallback);
+        virtual void setKeyboardCallback( b3KeyboardCallback    keyboardCallback);
+        
+		virtual b3MouseMoveCallback getMouseMoveCallback();
+		virtual b3MouseButtonCallback getMouseButtonCallback();
+		virtual b3ResizeCallback getResizeCallback();
+		virtual b3WheelCallback getWheelCallback();
+		virtual b3KeyboardCallback      getKeyboardCallback();
+
+        virtual void setRenderCallback( b3RenderCallback renderCallback);
+
+        virtual void setWindowTitle(const char* title);
+
+	int fileOpenDialog(char* filename, int maxNameLength);
+};
+
+
+#endif
+

examples/OpenGLWindow/b3gWindowInterface.h

@@ -0,0 +1,126 @@
+#ifndef B3G_WINDOW_INTERFACE_H
+#define B3G_WINDOW_INTERFACE_H
+
+
+typedef void (*b3WheelCallback)(float deltax, float deltay);
+typedef void (*b3ResizeCallback)( float width, float height);
+typedef void (*b3MouseMoveCallback)( float x, float y);
+typedef void (*b3MouseButtonCallback)(int button, int state, float x, float y);
+typedef void (*b3KeyboardCallback)(int keycode, int state);
+typedef void (*b3RenderCallback) ();
+
+enum {
+	B3G_ESCAPE = 27,
+	B3G_F1 = 0xff00,
+	B3G_F2,
+	B3G_F3,
+	B3G_F4,
+	B3G_F5,
+	B3G_F6,
+	B3G_F7,
+	B3G_F8,
+	B3G_F9,
+	B3G_F10,
+	B3G_F11,
+	B3G_F12,
+	B3G_F13,
+	B3G_F14,
+	B3G_F15,
+	B3G_LEFT_ARROW,
+	B3G_RIGHT_ARROW,
+	B3G_UP_ARROW,
+	B3G_DOWN_ARROW,
+	B3G_PAGE_UP,
+	B3G_PAGE_DOWN,
+	B3G_END,
+	B3G_HOME,
+	B3G_INSERT,
+	B3G_DELETE,
+	B3G_BACKSPACE,
+	B3G_SHIFT,
+	B3G_CONTROL,
+	B3G_ALT,
+	B3G_RETURN
+};
+
+struct b3gWindowConstructionInfo
+{
+		int m_width;
+		int m_height;
+		bool m_fullscreen;
+		int m_colorBitsPerPixel;
+		void* m_windowHandle;
+		const char* m_title;
+		int m_openglVersion;
+    
+
+		b3gWindowConstructionInfo(int width=1024, int height=768)
+		:m_width(width),
+			m_height(height),
+			m_fullscreen(false),
+			m_colorBitsPerPixel(32),
+			m_windowHandle(0),
+			m_title("title"),
+			m_openglVersion(3)
+			{
+			}
+};
+
+
+class b3gWindowInterface
+{
+	public:
+		
+		virtual ~b3gWindowInterface()
+		{
+		}
+
+		virtual void	createDefaultWindow(int width, int height, const char* title)
+		{
+			b3gWindowConstructionInfo ci(width,height);
+			ci.m_title = title;
+			createWindow(ci);
+		}
+
+		virtual	void	createWindow(const b3gWindowConstructionInfo& ci)=0;
+		
+		virtual void	closeWindow()=0;
+
+		virtual void	runMainLoop()=0;
+		virtual	float	getTimeInSeconds()=0;
+
+		virtual bool	requestedExit() const = 0;
+		virtual	void	setRequestExit() = 0;
+
+		virtual	void	startRendering()=0;
+
+		virtual	void	endRendering()=0;
+
+		virtual bool	isModifiedKeyPressed(int key) = 0;
+		
+		virtual void setMouseMoveCallback(b3MouseMoveCallback	mouseCallback)=0;
+		virtual b3MouseMoveCallback getMouseMoveCallback()=0;
+		
+		virtual void setMouseButtonCallback(b3MouseButtonCallback	mouseCallback)=0;
+		virtual b3MouseButtonCallback getMouseButtonCallback()=0;
+
+		virtual void setResizeCallback(b3ResizeCallback	resizeCallback)=0;
+		virtual b3ResizeCallback getResizeCallback()=0;
+		
+		virtual void setWheelCallback(b3WheelCallback wheelCallback)=0;
+		virtual b3WheelCallback getWheelCallback()=0;
+		
+		virtual void setKeyboardCallback( b3KeyboardCallback	keyboardCallback)=0;
+		virtual b3KeyboardCallback	getKeyboardCallback()=0;
+
+		virtual void setRenderCallback( b3RenderCallback renderCallback) = 0;
+	
+		virtual void setWindowTitle(const char* title)=0;
+
+		virtual	float	getRetinaScale() const =0;
+
+        virtual int fileOpenDialog(char* fileName, int maxFileNameLength) = 0;
+    
+};
+
+#endif //B3G_WINDOW_INTERFACE_H

examples/OpenGLWindow/fontstash.cpp

@@ -0,0 +1,818 @@
+//
+// Copyright (c) 2011 Andreas Krinke andreas.krinke@gmx.de
+// Copyright (c) 2009 Mikko Mononen memon@inside.org
+//
+// 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.
+//
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include "fontstash.h"
+
+
+
+#define BORDER_X_LEFT 2
+#define BORDER_X_RIGHT 2
+#define BORDER_Y_TOP 2
+#define BORDER_Y_BOTTOM 2
+#define ADDITIONAL_HEIGHT 2
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_malloc(x,u)    malloc(x)
+#define STBTT_free(x,u)      free(x)
+#include "stb_truetype.h"
+
+#define HASH_LUT_SIZE 256
+
+
+
+#define TTFONT_FILE 1
+#define TTFONT_MEM  2
+#define BMFONT      3
+
+static int idx = 1;
+static float s_retinaScale = 1;
+
+static unsigned int hashint(unsigned int a)
+{
+	a += ~(a<<15);
+	a ^=  (a>>10);
+	a +=  (a<<3);
+	a ^=  (a>>6);
+	a += ~(a<<11);
+	a ^=  (a>>16);
+	return a;
+}
+
+
+
+struct sth_font
+{
+	int idx;
+	int type;
+	stbtt_fontinfo font;
+	unsigned char* data;
+	struct sth_glyph* glyphs;
+	int lut[HASH_LUT_SIZE];
+	int nglyphs;
+	float ascender;
+	float descender;
+	float lineh;
+	struct sth_font* next;
+};
+
+
+
+
+
+struct sth_stash
+{
+	int tw,th;
+	float itw,ith;
+	struct sth_texture* textures;
+	struct sth_font* fonts;
+	int drawing;
+
+	RenderCallbacks*	m_renderCallbacks;
+};
+
+
+
+// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
+
+#define UTF8_ACCEPT 0
+#define UTF8_REJECT 1
+
+static const unsigned char utf8d[] = {
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
+	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
+	7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
+	8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
+	0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
+	0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
+	0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
+	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
+	1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
+	1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
+	1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
+};
+
+static unsigned int decutf8(unsigned int* state, unsigned int* codep, unsigned int byte)
+{
+	unsigned int type = utf8d[byte];
+	*codep = (*state != UTF8_ACCEPT) ?
+		(byte & 0x3fu) | (*codep << 6) :
+		(0xff >> type) & (byte);
+	*state = utf8d[256 + *state*16 + type];
+	return *state;
+}
+
+
+
+struct sth_stash* sth_create(int cachew, int cacheh, RenderCallbacks* renderCallbacks)
+{
+	struct sth_stash* stash = NULL;
+	struct sth_texture* texture = NULL;
+
+	// Allocate memory for the font stash.
+	stash = (struct sth_stash*)malloc(sizeof(struct sth_stash));
+	if (stash == NULL)
+    {
+        assert(0);
+        return NULL;
+    }
+	memset(stash,0,sizeof(struct sth_stash));
+
+	stash->m_renderCallbacks = renderCallbacks;
+
+	// Allocate memory for the first texture
+	texture = (struct sth_texture*)malloc(sizeof(struct sth_texture));
+	if (texture == NULL)
+    {
+        assert(0);
+        free(stash);
+    }
+    memset(texture,0,sizeof(struct sth_texture));
+
+	// Create first texture for the cache.
+	stash->tw = cachew;
+	stash->th = cacheh;
+	stash->itw = 1.0f/cachew;
+	stash->ith = 1.0f/cacheh;
+	stash->textures = texture;
+
+	stash->m_renderCallbacks->updateTexture(texture, 0, stash->tw, stash->th);
+
+	return stash;
+
+}
+
+int sth_add_font_from_memory(struct sth_stash* stash, unsigned char* buffer)
+{
+	int i, ascent, descent, fh, lineGap;
+	struct sth_font* fnt = NULL;
+
+	fnt = (struct sth_font*)malloc(sizeof(struct sth_font));
+	if (fnt == NULL) goto error;
+	memset(fnt,0,sizeof(struct sth_font));
+
+
+	// Init hash lookup.
+	for (i = 0; i < HASH_LUT_SIZE; ++i)
+        fnt->lut[i] = -1;
+
+	fnt->data = buffer;
+
+	// Init stb_truetype
+	if (!stbtt_InitFont(&fnt->font, fnt->data, 0))
+        goto error;
+
+
+	// Store normalized line height. The real line height is got
+	// by multiplying the lineh by font size.
+	stbtt_GetFontVMetrics(&fnt->font, &ascent, &descent, &lineGap);
+
+	fh = ascent - descent;
+	fnt->ascender = (float)ascent / (float)fh;
+	fnt->descender = (float)descent / (float)fh;
+	fnt->lineh = (float)(fh + lineGap) / (float)fh;
+
+	fnt->idx = idx;
+	fnt->type = TTFONT_MEM;
+	fnt->next = stash->fonts;
+	stash->fonts = fnt;
+
+
+	return idx++;
+
+error:
+	if (fnt) {
+		if (fnt->glyphs) free(fnt->glyphs);
+		free(fnt);
+	}
+	return 0;
+}
+
+int sth_add_font(struct sth_stash* stash, const char* path)
+{
+	FILE* fp = 0;
+	int datasize;
+	unsigned char* data = NULL;
+	int idx=0;
+
+	// Read in the font data.
+	fp = fopen(path, "rb");
+	if (!fp) goto error;
+	fseek(fp,0,SEEK_END);
+	datasize = (int)ftell(fp);
+	fseek(fp,0,SEEK_SET);
+	data = (unsigned char*)malloc(datasize);
+	if (data == NULL) goto error;
+	int bytesRead;
+	bytesRead = fread(data, 1, datasize, fp);
+	if (bytesRead)
+	{
+		idx = sth_add_font_from_memory(stash, data);
+	}
+	fclose(fp);
+	fp = 0;
+
+	
+	// Modify type of the loaded font.
+	if (idx)
+		stash->fonts->type = TTFONT_FILE;
+	else
+		free(data);
+
+	return idx;
+
+error:
+	if (data) free(data);
+	if (fp) fclose(fp);
+	return 0;
+}
+
+int sth_add_bitmap_font(struct sth_stash* stash, int ascent, int descent, int line_gap)
+{
+	int i, fh;
+	struct sth_font* fnt = NULL;
+
+	fnt = (struct sth_font*)malloc(sizeof(struct sth_font));
+	if (fnt == NULL) goto error;
+	memset(fnt,0,sizeof(struct sth_font));
+
+	// Init hash lookup.
+	for (i = 0; i < HASH_LUT_SIZE; ++i) fnt->lut[i] = -1;
+
+	// Store normalized line height. The real line height is got
+	// by multiplying the lineh by font size.
+	fh = ascent - descent;
+	fnt->ascender = (float)ascent / (float)fh;
+	fnt->descender = (float)descent / (float)fh;
+	fnt->lineh = (float)(fh + line_gap) / (float)fh;
+
+	fnt->idx = idx;
+	fnt->type = BMFONT;
+	fnt->next = stash->fonts;
+	stash->fonts = fnt;
+
+	return idx++;
+
+error:
+	if (fnt) free(fnt);
+	return 0;
+}
+
+/*void sth_add_glyph(struct sth_stash* stash,
+                  int idx,
+                  unsigned int id1,
+                  const char* s,
+                  short size, short base,
+                  int x, int y, int w, int h,
+                  float xoffset, float yoffset, float xadvance)
+{
+	struct sth_texture* texture = NULL;
+	struct sth_font* fnt = NULL;
+	struct sth_glyph* glyph = NULL;
+	unsigned int codepoint;
+	unsigned int state = 0;
+
+	if (stash == NULL) return;
+	texture = stash->textures;
+	while (texture != NULL && texture->id != id)
+		texture = texture->next;
+
+	if (texture == NULL)
+	{
+		// Create new texture
+		texture = (struct sth_texture*)malloc(sizeof(struct sth_texture));
+		if (texture == NULL) return;
+		memset(texture, 0, sizeof(struct sth_texture));
+		texture->id = id;
+		texture->next = stash->textures;
+		stash->textures = texture;
+	}
+
+	fnt = stash->fonts;
+	while (fnt != NULL && fnt->idx != idx) fnt = fnt->next;
+	if (fnt == NULL) return;
+	if (fnt->type != BMFONT) return;
+
+	for (; *s; ++s)
+	{
+		if (!decutf8(&state, &codepoint, *(unsigned char*)s)) break;
+	}
+	if (state != UTF8_ACCEPT) return;
+
+	// Alloc space for new glyph.
+	fnt->nglyphs++;
+	fnt->glyphs = (sth_glyph*)realloc(fnt->glyphs, fnt->nglyphs*sizeof(struct sth_glyph));
+	if (!fnt->glyphs) return;
+
+	// Init glyph.
+	glyph = &fnt->glyphs[fnt->nglyphs-1];
+	memset(glyph, 0, sizeof(struct sth_glyph));
+	glyph->codepoint = codepoint;
+	glyph->size = size;
+	glyph->texture = texture;
+	glyph->x0_ = x;
+	glyph->y0 = y;
+	glyph->x1 = glyph->x0_+w;
+	glyph->y1 = glyph->y0+h;
+	glyph->xoff = xoffset;
+	glyph->yoff = yoffset - base;
+	glyph->xadv = xadvance;
+
+	// Find code point and size.
+	h = hashint(codepoint) & (HASH_LUT_SIZE-1);
+	// Insert char to hash lookup.
+	glyph->next = fnt->lut[h];
+	fnt->lut[h] = fnt->nglyphs-1;
+}
+*/
+
+static struct sth_glyph* get_glyph(struct sth_stash* stash, struct sth_font* fnt, unsigned int codepoint, short isize)
+{
+	int i,g,advance,lsb,x0,y0,x1,y1,gw,gh;
+	float scale;
+	struct sth_texture* texture = NULL;
+	struct sth_glyph* glyph = NULL;
+
+	unsigned int h;
+	float size = isize/10.0f;
+	int rh;
+	struct sth_row* br = NULL;
+
+	// Find code point and size.
+	h = hashint(codepoint) & (HASH_LUT_SIZE-1);
+	i = fnt->lut[h];
+	while (i != -1)
+	{
+		if (fnt->glyphs[i].codepoint == codepoint && (fnt->type == BMFONT || fnt->glyphs[i].size == isize))
+			return &fnt->glyphs[i];
+		i = fnt->glyphs[i].next;
+	}
+	// Could not find glyph.
+
+	// For bitmap fonts: ignore this glyph.
+	if (fnt->type == BMFONT) return 0;
+
+	// For truetype fonts: create this glyph.
+	scale = stbtt_ScaleForPixelHeight(&fnt->font, size);
+	g = stbtt_FindGlyphIndex(&fnt->font, codepoint);
+	stbtt_GetGlyphHMetrics(&fnt->font, g, &advance, &lsb);
+	stbtt_GetGlyphBitmapBox(&fnt->font, g, scale,scale, &x0,&y0,&x1,&y1);
+	gw = x1-x0;
+	gh = y1-y0;
+
+    // Check if glyph is larger than maximum texture size
+	if (gw >= stash->tw || gh >= stash->th)
+		return 0;
+
+	// Find texture and row where the glyph can be fit.
+	br = NULL;
+	rh = (gh+7) & ~7;
+	texture = stash->textures;
+	while(br == NULL)
+	{
+		for (i = 0; i < texture->nrows; ++i)
+		{
+			if (texture->rows[i].h >= rh && texture->rows[i].x+gw+1 <= stash->tw)
+				br = &texture->rows[i];
+		}
+
+		// If no row is found, there are 3 possibilities:
+		//   - add new row
+		//   - try next texture
+		//   - create new texture
+		if (br == NULL)
+		{
+			short py = BORDER_Y_TOP;
+			// Check that there is enough space.
+			if (texture->nrows)
+			{
+				py = texture->rows[texture->nrows-1].y + texture->rows[texture->nrows-1].h+1;
+				if (py+rh > stash->th)
+				{
+					if (texture->next != NULL)
+					{
+						texture = texture->next;
+					}
+					else
+					{
+						// Create new texture
+						texture->next = (struct sth_texture*)malloc(sizeof(struct sth_texture));
+						texture = texture->next;
+						if (texture == NULL) goto error;
+						memset(texture,0,sizeof(struct sth_texture));
+
+						stash->m_renderCallbacks->updateTexture(texture,0,stash->tw,stash->th);
+
+
+					}
+					continue;
+				}
+			}
+			// Init and add row
+			br = &texture->rows[texture->nrows];
+			br->x = BORDER_X_LEFT;
+			br->y = py+BORDER_Y_BOTTOM;
+			br->h = rh+ADDITIONAL_HEIGHT;
+			texture->nrows++;
+		}
+	}
+
+	// Alloc space for new glyph.
+	fnt->nglyphs++;
+	fnt->glyphs = (sth_glyph*)realloc(fnt->glyphs, fnt->nglyphs*sizeof(struct sth_glyph));
+	if (!fnt->glyphs) return 0;
+
+	// Init glyph.
+	glyph = &fnt->glyphs[fnt->nglyphs-1];
+	memset(glyph, 0, sizeof(struct sth_glyph));
+	glyph->codepoint = codepoint;
+	glyph->size = isize;
+	glyph->texture = texture;
+	glyph->x0_ = br->x;
+	glyph->y0 = br->y;
+	glyph->x1 = glyph->x0_+gw;
+	glyph->y1 = glyph->y0+gh;
+	glyph->xadv = scale * advance;
+	glyph->xoff = (float)x0;
+	glyph->yoff = (float)y0;
+	glyph->next = 0;
+
+	// Advance row location.
+	br->x += gw+BORDER_X_RIGHT;
+
+	// Insert char to hash lookup.
+	glyph->next = fnt->lut[h];
+	fnt->lut[h] = fnt->nglyphs-1;
+
+	// Rasterize
+	{
+		unsigned char* ptr = texture->m_texels+glyph->x0_+glyph->y0*stash->tw;
+		stbtt_MakeGlyphBitmap(&fnt->font,ptr , gw,gh,stash->tw, scale,scale, g);
+
+		stash->m_renderCallbacks->updateTexture(texture,glyph, stash->tw, stash->th);
+
+	}
+
+	return glyph;
+
+error:
+	if (texture)
+		free(texture);
+	return 0;
+}
+
+static int get_quad(struct sth_stash* stash, struct sth_font* fnt, struct sth_glyph* glyph, short isize, float* x, float* y, struct sth_quad* q)
+{
+	float rx,ry;
+	float scale = 1.f/s_retinaScale;//1.0f;
+
+	if (fnt->type == BMFONT)
+        scale = isize/(glyph->size*10.0f);
+
+	rx = (*x + scale * float(glyph->xoff));
+	ry = (*y + scale * float(glyph->yoff));
+
+	q->x0 = rx;
+    q->y0 = ry + 1.5f*0.5f*float(isize)/10.f;
+
+	q->x1 = rx + scale * float(glyph->x1 - glyph->x0_);
+    q->y1 = ry + scale * float(glyph->y1 - glyph->y0)+ 1.5f*0.5f*float(isize)/10.f;
+
+	q->s0 = float(glyph->x0_) * stash->itw;
+	q->t0 = float(glyph->y0) * stash->ith;
+	q->s1 = float(glyph->x1) * stash->itw;
+	q->t1 = float(glyph->y1) * stash->ith;
+
+	*x += scale * glyph->xadv;
+
+	return 1;
+}
+
+static Vertex* setv(Vertex* v, float x, float y, float s, float t, float width, float height)
+{
+	bool scale=true;
+	if (scale)
+	{
+		v->position.p[0] = (x*2-width)/(width);
+		v->position.p[1] = 1-(y)/(height/2);
+	} else
+	{
+		v->position.p[0] = (x-width)/(width);
+		v->position.p[1] = (height-y)/(height);
+	}
+    v->position.p[2] = 0.f;
+    v->position.p[3] = 1.f;
+
+	v->uv.p[0] = s;
+    v->uv.p[1] = t;
+
+    v->colour.p[0] = 0.1f;//1.f;
+    v->colour.p[1] = 0.1f;
+    v->colour.p[2] = 0.1f;
+    v->colour.p[3] = 1.f;
+
+	return v+1;
+}
+
+
+
+
+static void flush_draw(struct sth_stash* stash)
+{
+	struct sth_texture* texture = stash->textures;
+	while (texture)
+	{
+		if (texture->nverts > 0)
+		{
+			stash->m_renderCallbacks->render(texture);
+			texture->nverts = 0;
+		}
+		texture = texture->next;
+	}
+}
+
+
+void sth_begin_draw(struct sth_stash* stash)
+{
+	if (stash == NULL) return;
+	if (stash->drawing)
+		flush_draw(stash);
+	stash->drawing = 1;
+}
+
+void sth_end_draw(struct sth_stash* stash)
+{
+	if (stash == NULL) return;
+	if (!stash->drawing) return;
+
+/*
+	// Debug dump.
+	if (stash->nverts+6 < VERT_COUNT)
+	{
+		float x = 500, y = 100;
+		float* v = &stash->verts[stash->nverts*4];
+
+		v = setv(v, x, y, 0, 0);
+		v = setv(v, x+stash->tw, y, 1, 0);
+		v = setv(v, x+stash->tw, y+stash->th, 1, 1);
+
+		v = setv(v, x, y, 0, 0);
+		v = setv(v, x+stash->tw, y+stash->th, 1, 1);
+		v = setv(v, x, y+stash->th, 0, 1);
+
+		stash->nverts += 6;
+	}
+*/
+
+	flush_draw(stash);
+	stash->drawing = 0;
+}
+
+void sth_draw_texture(struct sth_stash* stash,
+				   int idx, float size,
+				   float x, float y,
+				   int screenwidth, int screenheight,
+				   const char* s, float* dx)
+{
+	int width = stash->tw;
+	int height=stash->th;
+
+	unsigned int codepoint;
+	struct sth_glyph* glyph = NULL;
+	struct sth_texture* texture = NULL;
+	unsigned int state = 0;
+	struct sth_quad q;
+	short isize = (short)(size*10.0f);
+	Vertex* v;
+	struct sth_font* fnt = NULL;
+
+	if (stash == NULL) return;
+
+	if (!stash->textures) return;
+	fnt = stash->fonts;
+	while(fnt != NULL && fnt->idx != idx) fnt = fnt->next;
+	if (fnt == NULL) return;
+	if (fnt->type != BMFONT && !fnt->data) return;
+
+	int once = true;
+	for (; once; ++s)
+	{
+		once=false;
+		if (decutf8(&state, &codepoint, *(unsigned char*)s))
+			continue;
+		glyph = get_glyph(stash, fnt, codepoint, isize);
+		if (!glyph)
+			continue;
+		texture = glyph->texture;
+		if (texture->nverts+6 >= VERT_COUNT)
+			flush_draw(stash);
+
+		if (!get_quad(stash, fnt, glyph, isize, &x, &y, &q))
+			continue;
+
+		v = &texture->newverts[texture->nverts];
+		q.x0 = 0;
+		q.y0 = 0;
+		q.x1 = q.x0+width;
+		q.y1 = q.y0+height;
+
+		v = setv(v, q.x0, q.y0, 0,0,(float)screenwidth,(float)screenheight);
+		v = setv(v, q.x1, q.y0, 1,0,(float)screenwidth,(float)screenheight);
+		v = setv(v, q.x1, q.y1, 1,1,(float)screenwidth,(float)screenheight);
+
+		v = setv(v, q.x0, q.y0, 0,0,(float)screenwidth,(float)screenheight);
+		v = setv(v, q.x1, q.y1, 1,1,(float)screenwidth,(float)screenheight);
+		v = setv(v, q.x0, q.y1, 0,1,(float)screenwidth,(float)screenheight);
+		texture->nverts += 6;
+	}
+
+	flush_draw(stash);
+
+
+
+
+	if (dx) *dx = x;
+}
+
+void sth_flush_draw(struct sth_stash* stash)
+{
+	flush_draw(stash);
+}
+void sth_draw_text(struct sth_stash* stash,
+				   int idx, float size,
+				   float x, float y,
+				   const char* s, float* dx, int screenwidth, int screenheight, int measureOnly, float retinaScale)
+{
+
+	unsigned int codepoint;
+	struct sth_glyph* glyph = NULL;
+	struct sth_texture* texture = NULL;
+	unsigned int state = 0;
+	struct sth_quad q;
+	short isize = (short)(size*10.0f);
+	Vertex* v;
+	struct sth_font* fnt = NULL;
+
+    s_retinaScale = retinaScale;
+	if (stash == NULL) return;
+
+	if (!stash->textures) return;
+	fnt = stash->fonts;
+	while(fnt != NULL && fnt->idx != idx) fnt = fnt->next;
+	if (fnt == NULL) return;
+	if (fnt->type != BMFONT && !fnt->data) return;
+
+	for (; *s; ++s)
+	{
+		if (decutf8(&state, &codepoint, *(unsigned char*)s))
+			continue;
+		glyph = get_glyph(stash, fnt, codepoint, isize);
+		if (!glyph) continue;
+		texture = glyph->texture;
+
+        if (!measureOnly)
+        {
+            if (texture->nverts+6 >= VERT_COUNT)
+                flush_draw(stash);
+		}
+
+		if (!get_quad(stash, fnt, glyph, isize, &x, &y, &q)) continue;
+
+        if (!measureOnly)
+        {
+            v = &texture->newverts[texture->nverts];
+
+            v = setv(v, q.x0, q.y0, q.s0, q.t0,(float)screenwidth,(float)screenheight);
+            v = setv(v, q.x1, q.y0, q.s1, q.t0,(float)screenwidth,(float)screenheight);
+            v = setv(v, q.x1, q.y1, q.s1, q.t1,(float)screenwidth,(float)screenheight);
+
+            v = setv(v, q.x0, q.y0, q.s0, q.t0,(float)screenwidth,(float)screenheight);
+            v = setv(v, q.x1, q.y1, q.s1, q.t1,(float)screenwidth,(float)screenheight);
+            v = setv(v, q.x0, q.y1, q.s0, q.t1,(float)screenwidth,(float)screenheight);
+
+            texture->nverts += 6;
+        }
+	}
+
+	if (dx) *dx = x;
+}
+
+void sth_dim_text(struct sth_stash* stash,
+				  int idx, float size,
+				  const char* s,
+				  float* minx, float* miny, float* maxx, float* maxy)
+{
+	unsigned int codepoint;
+	struct sth_glyph* glyph = NULL;
+	unsigned int state = 0;
+	struct sth_quad q;
+	short isize = (short)(size*10.0f);
+	struct sth_font* fnt = NULL;
+	float x = 0, y = 0;
+
+	if (stash == NULL)
+		return;
+	if (!stash->textures)
+		return;
+	fnt = stash->fonts;
+	while(fnt != NULL && fnt->idx != idx) fnt = fnt->next;
+	if (fnt == NULL) return;
+	if (fnt->type != BMFONT && !fnt->data) return;
+
+	*minx = *maxx = x;
+	*miny = *maxy = y;
+
+	for (; *s; ++s)
+	{
+		if (decutf8(&state, &codepoint, *(unsigned char*)s)) continue;
+		glyph = get_glyph(stash, fnt, codepoint, isize);
+		if (!glyph) continue;
+		if (!get_quad(stash, fnt, glyph, isize, &x, &y, &q)) continue;
+		if (q.x0 < *minx) *minx = q.x0;
+		if (q.x1 > *maxx) *maxx = q.x1;
+		if (q.y1 < *miny) *miny = q.y1;
+		if (q.y0 > *maxy) *maxy = q.y0;
+	}
+}
+
+void sth_vmetrics(struct sth_stash* stash,
+				  int idx, float size,
+				  float* ascender, float* descender, float* lineh)
+{
+	struct sth_font* fnt = NULL;
+
+	if (stash == NULL) return;
+	if (!stash->textures) return;
+	fnt = stash->fonts;
+	while(fnt != NULL && fnt->idx != idx) fnt = fnt->next;
+	if (fnt == NULL) return;
+	if (fnt->type != BMFONT && !fnt->data) return;
+	if (ascender)
+		*ascender = fnt->ascender*size;
+	if (descender)
+		*descender = fnt->descender*size;
+	if (lineh)
+		*lineh = fnt->lineh*size;
+}
+
+void sth_delete(struct sth_stash* stash)
+{
+	struct sth_texture* tex = NULL;
+	struct sth_texture* curtex = NULL;
+	struct sth_font* fnt = NULL;
+	struct sth_font* curfnt = NULL;
+
+	if (!stash) return;
+
+	tex = stash->textures;
+	while(tex != NULL) {
+		curtex = tex;
+		delete tex->m_texels;
+		tex->m_texels=0;
+		tex = tex->next;
+		stash->m_renderCallbacks->updateTexture(curtex,0,0,0);
+		free(curtex);
+	}
+
+	fnt = stash->fonts;
+	while(fnt != NULL) {
+		curfnt = fnt;
+		fnt = fnt->next;
+		if (curfnt->glyphs)
+		{
+			free(curfnt->glyphs);
+		}
+		if (curfnt->type == TTFONT_FILE && curfnt->data)
+		{
+			free(curfnt->data);
+		}
+		free(curfnt);
+	}
+	free(stash);
+}

examples/OpenGLWindow/fontstash.h

@@ -0,0 +1,146 @@
+//
+// Copyright (c) 2011 Andreas Krinke andreas.krinke@gmx.de
+// Copyright (c) 2009 Mikko Mononen memon@inside.org
+//
+// This software is provided 'as-is', without any express or implied
+// warranty.  In no event will the authors be held liable for any damages
+// arising from the use of this software.
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would be
+//    appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+//
+
+#ifndef FONTSTASH_H
+#define FONTSTASH_H
+
+
+#define MAX_ROWS 128
+#define VERT_COUNT (6*128)
+#define INDEX_COUNT (VERT_COUNT*2)
+
+
+struct vec2
+{
+	vec2(float x, float y)
+	{
+		p[0] = x;
+		p[1] = y;
+	}
+	float p[2];
+};
+
+struct vec4
+{
+	vec4(float x,float y, float z, float w)
+	{
+		p[0] = x;
+		p[1] = y;
+		p[2] = z;
+		p[3] = w;
+        
+	}
+    
+	float p[4];
+};
+
+typedef struct
+{
+    vec4 position;
+    vec4 colour;
+	vec2 uv;
+} Vertex;
+
+struct sth_quad
+{
+	float x0,y0,s0,t0;
+	float x1,y1,s1,t1;
+};
+
+struct sth_row
+{
+	short x,y,h;
+};
+
+struct sth_glyph
+{
+	unsigned int codepoint;
+	short size;
+	struct sth_texture* texture;
+	int x0_,y0,x1,y1;
+	float xadv,xoff,yoff;
+	int next;
+};
+
+
+struct sth_texture
+{
+	union
+	{
+		void* m_userData;
+		int m_userId;
+	};
+	
+	unsigned char* m_texels;
+    
+	// TODO: replace rows with pointer
+	struct sth_row rows[MAX_ROWS];
+	int nrows;
+	int nverts;
+	
+    Vertex newverts[VERT_COUNT];
+  	struct sth_texture* next;
+};
+
+
+struct	RenderCallbacks
+{
+	virtual ~RenderCallbacks() {}
+	virtual void updateTexture(sth_texture* texture, sth_glyph* glyph, int textureWidth, int textureHeight)=0;
+	virtual void render(sth_texture* texture)=0;
+};
+
+struct sth_stash* sth_create(int cachew, int cacheh, RenderCallbacks* callbacks);
+
+int sth_add_font(struct sth_stash* stash, const char* path);
+int sth_add_font_from_memory(struct sth_stash* stash, unsigned char* buffer);
+
+int sth_add_bitmap_font(struct sth_stash* stash, int ascent, int descent, int line_gap);
+/*void sth_add_glyph(struct sth_stash* stash, int idx, unsigned int uid, const char* s,
+                  short size, short base, int x, int y, int w, int h,
+                  float xoffset, float yoffset, float xadvance);
+				  */
+
+void sth_begin_draw(struct sth_stash* stash);
+void sth_end_draw(struct sth_stash* stash);
+
+void sth_draw_texture(struct sth_stash* stash,
+				   int idx, float size,
+				   float x, float y,
+				   int screenwidth, int screenheight,
+				   const char* s, float* dx);
+
+void sth_flush_draw(struct sth_stash* stash);
+
+void sth_draw_text(struct sth_stash* stash,
+				   int idx, float size,
+				   float x, float y, const char* string, float* dx, int screenwidth, int screenheight, int measureOnly=0, float retinaScale=1);
+
+void sth_dim_text(struct sth_stash* stash, int idx, float size, const char* string,
+				  float* minx, float* miny, float* maxx, float* maxy);
+
+void sth_vmetrics(struct sth_stash* stash,
+				  int idx, float size,
+				  float* ascender, float* descender, float * lineh);
+
+void sth_delete(struct sth_stash* stash);
+
+
+
+#endif // FONTSTASH_H

examples/OpenGLWindow/opengl_fontstashcallbacks.cpp

@@ -0,0 +1,252 @@
+#include "opengl_fontstashcallbacks.h"
+#include "../OpenGLWindow/GLPrimitiveRenderer.h"
+#include "../OpenGLWindow/GLPrimInternalData.h"
+
+#include "fontstash.h"
+#include "../OpenGLWindow/OpenGLInclude.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+
+static unsigned int s_indexData[INDEX_COUNT];
+GLuint s_indexArrayObject, s_indexBuffer;
+GLuint s_vertexArrayObject,s_vertexBuffer;
+
+OpenGL2RenderCallbacks::OpenGL2RenderCallbacks(GLPrimitiveRenderer* primRender)
+	:m_primRender2(primRender)
+{
+
+}
+OpenGL2RenderCallbacks::~OpenGL2RenderCallbacks()
+{
+}
+
+PrimInternalData* OpenGL2RenderCallbacks::getData()
+{
+	return m_primRender2->getData();
+}
+InternalOpenGL2RenderCallbacks::~InternalOpenGL2RenderCallbacks()
+{
+
+}
+
+void InternalOpenGL2RenderCallbacks::display2() 
+{
+    
+    assert(glGetError()==GL_NO_ERROR);
+   // glViewport(0,0,10,10);
+    
+	//const float timeScale = 0.008f;
+	PrimInternalData* data = getData();
+
+    glUseProgram(data->m_shaderProg);
+    glBindBuffer(GL_ARRAY_BUFFER, s_vertexBuffer);
+    glBindVertexArray(s_vertexArrayObject);
+    
+      assert(glGetError()==GL_NO_ERROR);
+  
+    
+    //   glBindTexture(GL_TEXTURE_2D,m_texturehandle);
+    
+    
+       assert(glGetError()==GL_NO_ERROR);
+  
+    vec2 p( 0.f,0.f);//?b?0.5f * sinf(timeValue), 0.5f * cosf(timeValue) );
+    glUniform2fv(data->m_positionUniform, 1, (const GLfloat *)&p);
+    
+     assert(glGetError()==GL_NO_ERROR);
+   
+    glEnableVertexAttribArray(data->m_positionAttribute);
+    assert(glGetError()==GL_NO_ERROR);
+    
+    glEnableVertexAttribArray(data->m_colourAttribute);
+    assert(glGetError()==GL_NO_ERROR);
+    
+	glEnableVertexAttribArray(data->m_textureAttribute);
+    
+    glVertexAttribPointer(data->m_positionAttribute, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid *)0);
+    glVertexAttribPointer(data->m_colourAttribute  , 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid *)sizeof(vec4));
+    glVertexAttribPointer(data->m_textureAttribute , 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid *)(sizeof(vec4)+sizeof(vec4)));
+    assert(glGetError()==GL_NO_ERROR);
+/*    
+ 
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);
+    //glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    int indexCount = 6;
+    err = glGetError();
+    assert(err==GL_NO_ERROR);
+    
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
+    err = glGetError();
+    assert(err==GL_NO_ERROR);
+  */
+
+    //	glutSwapBuffers();
+}
+
+
+
+void InternalOpenGL2RenderCallbacks::updateTexture(sth_texture* texture, sth_glyph* glyph, int textureWidth, int textureHeight)
+{
+    assert(glGetError()==GL_NO_ERROR);
+
+
+	if (glyph)
+	{
+		// Update texture (entire texture, could use glyph to update partial texture using glTexSubImage2D)
+		GLuint* gltexture = (GLuint*) texture->m_userData;
+		
+		glBindTexture(GL_TEXTURE_2D, *gltexture);
+		glPixelStorei(GL_UNPACK_ALIGNMENT,1);
+    assert(glGetError()==GL_NO_ERROR);
+
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, textureWidth, textureHeight, 0, GL_RED, GL_UNSIGNED_BYTE, texture->m_texels);
+	
+    assert(glGetError()==GL_NO_ERROR);
+
+	} else
+	{
+		if (textureWidth && textureHeight)
+		{
+			GLuint* texId = new GLuint;
+			texture->m_userData = texId;
+
+
+			//create new texture
+			glGenTextures(1, texId);
+    assert(glGetError()==GL_NO_ERROR);
+
+			
+	
+			glBindTexture(GL_TEXTURE_2D, *texId);
+			texture->m_texels = (unsigned char*)malloc(textureWidth*textureHeight);
+			memset(texture->m_texels,0,textureWidth*textureHeight);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, textureWidth, textureHeight, 0, GL_RED, GL_UNSIGNED_BYTE, texture->m_texels);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	    assert(glGetError()==GL_NO_ERROR);
+
+			////////////////////////////
+			//create the other data
+			{
+				glGenVertexArrays(1, &s_vertexArrayObject);
+				glBindVertexArray(s_vertexArrayObject);
+        
+				glGenBuffers(1, &s_vertexBuffer);
+				glBindBuffer(GL_ARRAY_BUFFER, s_vertexBuffer);
+				glBufferData(GL_ARRAY_BUFFER, VERT_COUNT * sizeof(Vertex), texture->newverts, GL_DYNAMIC_DRAW);
+				assert(glGetError()==GL_NO_ERROR);
+        
+				for (int i=0;i<INDEX_COUNT;i++)
+				{
+					s_indexData[i] = i;
+				}
+            
+				glGenBuffers(1, &s_indexBuffer);
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s_indexBuffer);
+				glBufferData(GL_ELEMENT_ARRAY_BUFFER,INDEX_COUNT*sizeof(int), s_indexData,GL_STATIC_DRAW);
+        
+		    assert(glGetError()==GL_NO_ERROR);
+	}
+		} else
+		{
+			//delete texture
+			if (texture->m_userData)
+			{
+				
+				GLuint* id = (GLuint*)texture->m_userData;
+
+				glDeleteTextures(1, id);
+				//delete id;
+				delete id;//texture->m_userData;
+				texture->m_userData = 0;
+			}
+
+		}
+
+	}
+}
+
+void InternalOpenGL2RenderCallbacks::render(sth_texture* texture)
+{
+	display2();
+		
+
+	GLuint* texId = (GLuint*) texture->m_userData;
+
+    assert(glGetError()==GL_NO_ERROR);
+            
+    glActiveTexture(GL_TEXTURE0);
+    assert(glGetError()==GL_NO_ERROR);
+
+	glBindTexture(GL_TEXTURE_2D, *texId);
+	bool useFiltering = false;
+	if (useFiltering)
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	} else
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	}
+    assert(glGetError()==GL_NO_ERROR);
+     glBindBuffer(GL_ARRAY_BUFFER, s_vertexBuffer);
+     glBindVertexArray(s_vertexArrayObject);
+    glBufferData(GL_ARRAY_BUFFER, texture->nverts * sizeof(Vertex), &texture->newverts[0].position.p[0], GL_DYNAMIC_DRAW);
+
+    assert(glGetError()==GL_NO_ERROR);
+            
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s_indexBuffer);
+            
+    //glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    int indexCount = texture->nverts;
+    assert(glGetError()==GL_NO_ERROR);
+            
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
+    assert(glGetError()==GL_NO_ERROR);
+		
+	 glBindVertexArray(0);
+
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+	 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+//	 glDisableVertexAttribArray(m_textureAttribute);
+	 glUseProgram(0);
+
+}
+
+
+void dumpTextureToPng(int textureWidth, int textureHeight, const char* fileName)
+{
+	glPixelStorei(GL_PACK_ALIGNMENT,1);
+	unsigned char* pixels = (unsigned char*)malloc(textureWidth*textureHeight);
+	glReadPixels(0,0,textureWidth, textureHeight, GL_RED, GL_UNSIGNED_BYTE, pixels);
+	//swap the pixels
+	unsigned char* tmp = (unsigned char*)malloc(textureWidth);
+	for (int j=0;j<textureHeight;j++)
+	{
+			pixels[j*textureWidth+j]=255;
+	}
+	if (0)
+	{
+		for (int j=0;j<textureHeight/2;j++)
+		{
+			for (int i=0;i<textureWidth;i++)
+			{
+				tmp[i] = pixels[j*textureWidth+i];
+				pixels[j*textureWidth+i]=pixels[(textureHeight-j-1)*textureWidth+i];
+				pixels[(textureHeight-j-1)*textureWidth+i] = tmp[i];
+			}
+			}
+	}
+	
+	int comp=1;//1=Y
+	stbi_write_png(fileName, textureWidth,textureHeight, comp, pixels, textureWidth);
+	
+	free(pixels);
+
+}

examples/OpenGLWindow/opengl_fontstashcallbacks.h

@@ -0,0 +1,55 @@
+#ifndef _OPENGL_FONTSTASH_CALLBACKS_H
+#define _OPENGL_FONTSTASH_CALLBACKS_H
+
+#include "fontstash.h"
+struct PrimInternalData;
+class GLPrimitiveRenderer;
+
+struct	InternalOpenGL2RenderCallbacks : public RenderCallbacks
+{
+
+	virtual PrimInternalData* getData()=0;
+
+	virtual ~InternalOpenGL2RenderCallbacks();
+
+	virtual void updateTexture(sth_texture* texture, sth_glyph* glyph, int textureWidth, int textureHeight);
+	virtual void render(sth_texture* texture);
+	
+	void display2();
+	
+};
+
+void dumpTextureToPng( int screenWidth, int screenHeight, const char* fileName);
+
+struct SimpleOpenGL2RenderCallbacks : public InternalOpenGL2RenderCallbacks
+{
+	PrimInternalData* m_data;
+	virtual PrimInternalData* getData()
+	{
+		return m_data;
+	}
+	SimpleOpenGL2RenderCallbacks(PrimInternalData* data)
+		:m_data(data)
+	{
+	}
+	virtual ~SimpleOpenGL2RenderCallbacks()
+	{
+	}
+};
+
+
+struct	OpenGL2RenderCallbacks : public InternalOpenGL2RenderCallbacks
+{
+	GLPrimitiveRenderer* m_primRender2;
+	virtual PrimInternalData* getData();
+	
+	OpenGL2RenderCallbacks(GLPrimitiveRenderer* primRender);
+	virtual ~OpenGL2RenderCallbacks();
+
+	
+};
+
+
+
+#endif//_OPENGL_FONTSTASH_CALLBACKS_H
+

examples/OpenGLWindow/premake4.lua

@@ -0,0 +1,50 @@
+	
+		project "OpenGL_Window"
+	
+		language "C++"
+				
+		kind "StaticLib"
+
+		initOpenGL()
+		initGlew()
+
+		includedirs {
+		 	
+		 	"../../src",
+		}
+		
+		--links {
+		--}
+		
+		files {
+			"*.cpp",
+			"*.h",
+			"OpenGLWindow/*.c",
+			"OpenGLWindow/*.h",
+			"OpenGLWindow/GL/*.h"
+		}
+
+		if not os.is("Windows") then 
+			excludes {  
+				"Win32OpenGLWindow.cpp",
+      	"Win32OpenGLWindow.h",
+      	"Win32Window.cpp",
+      	"Win32Window.h",
+			}
+		end
+		if os.is("Linux") then
+			initX11()
+		end
+		if not os.is("Linux") then
+			excludes {
+				"X11OpenGLWindow.cpp",
+				"X11OpenGLWindows.h"
+			}
+		end
+		if os.is("MacOSX") then
+			files
+			{
+					"../OpenGLWindow/MacOpenGLWindow.h",
+					"../OpenGLWindow/MacOpenGLWindow.mm",
+			} 
+		end

examples/OpenGLWindow/stb_image_write.h

@@ -0,0 +1,511 @@
+/* stbiw-0.92 - public domain - http://nothings.org/stb/stb_image_write.h
+   writes out PNG/BMP/TGA images to C stdio - Sean Barrett 2010
+                            no warranty implied; use at your own risk
+
+
+Before including,
+
+    #define STB_IMAGE_WRITE_IMPLEMENTATION
+
+in the file that you want to have the implementation.
+
+
+ABOUT:
+
+   This header file is a library for writing images to C stdio. It could be
+   adapted to write to memory or a general streaming interface; let me know.
+
+   The PNG output is not optimal; it is 20-50% larger than the file
+   written by a decent optimizing implementation. This library is designed
+   for source code compactness and simplicitly, not optimal image file size
+   or run-time performance.
+
+USAGE:
+
+   There are three functions, one for each image file format:
+
+     int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+     int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+     int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+   Each function returns 0 on failure and non-0 on success.
+   
+   The functions create an image file defined by the parameters. The image
+   is a rectangle of pixels stored from left-to-right, top-to-bottom.
+   Each pixel contains 'comp' channels of data stored interleaved with 8-bits
+   per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is
+   monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall.
+   The *data pointer points to the first byte of the top-left-most pixel.
+   For PNG, "stride_in_bytes" is the distance in bytes from the first byte of
+   a row of pixels to the first byte of the next row of pixels.
+
+   PNG creates output files with the same number of components as the input.
+   The BMP and TGA formats expand Y to RGB in the file format. BMP does not
+   output alpha.
+   
+   PNG supports writing rectangles of data even when the bytes storing rows of
+   data are not consecutive in memory (e.g. sub-rectangles of a larger image),
+   by supplying the stride between the beginning of adjacent rows. The other
+   formats do not. (Thus you cannot write a native-format BMP through the BMP
+   writer, both because it is in BGR order and because it may have padding
+   at the end of the line.)
+*/
+
+#ifndef INCLUDE_STB_IMAGE_WRITE_H
+#define INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
+extern int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data);
+extern int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif//INCLUDE_STB_IMAGE_WRITE_H
+
+#ifdef STB_IMAGE_WRITE_IMPLEMENTATION
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+typedef unsigned int stbiw_uint32;
+typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1];
+
+static void writefv(FILE *f, const char *fmt, va_list v)
+{
+   while (*fmt) {
+      switch (*fmt++) {
+         case ' ': break;
+         case '1': { unsigned char x = (unsigned char) va_arg(v, int); fputc(x,f); break; }
+         case '2': { int x = va_arg(v,int); unsigned char b[2];
+                     b[0] = (unsigned char) x; b[1] = (unsigned char) (x>>8);
+                     fwrite(b,2,1,f); break; }
+         case '4': { stbiw_uint32 x = va_arg(v,int); unsigned char b[4];
+                     b[0]=(unsigned char)x; b[1]=(unsigned char)(x>>8);
+                     b[2]=(unsigned char)(x>>16); b[3]=(unsigned char)(x>>24);
+                     fwrite(b,4,1,f); break; }
+         default:
+            assert(0);
+            return;
+      }
+   }
+}
+
+static void write3(FILE *f, unsigned char a, unsigned char b, unsigned char c)
+{
+   unsigned char arr[3];
+   arr[0] = a, arr[1] = b, arr[2] = c;
+   fwrite(arr, 3, 1, f);
+}
+
+static void write_pixels(FILE *f, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad)
+{
+   unsigned char bg[3] = { 255, 0, 255}, px[3];
+   stbiw_uint32 zero = 0;
+   int i,j,k, j_end;
+
+   if (y <= 0)
+      return;
+
+   if (vdir < 0) 
+      j_end = -1, j = y-1;
+   else
+      j_end =  y, j = 0;
+
+   for (; j != j_end; j += vdir) {
+      for (i=0; i < x; ++i) {
+         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
+         if (write_alpha < 0)
+            fwrite(&d[comp-1], 1, 1, f);
+         switch (comp) {
+            case 1:
+            case 2: write3(f, d[0],d[0],d[0]);
+                    break;
+            case 4:
+               if (!write_alpha) {
+                  // composite against pink background
+                  for (k=0; k < 3; ++k)
+                     px[k] = bg[k] + ((d[k] - bg[k]) * d[3])/255;
+                  write3(f, px[1-rgb_dir],px[1],px[1+rgb_dir]);
+                  break;
+               }
+               /* FALLTHROUGH */
+            case 3:
+               write3(f, d[1-rgb_dir],d[1],d[1+rgb_dir]);
+               break;
+         }
+         if (write_alpha > 0)
+            fwrite(&d[comp-1], 1, 1, f);
+      }
+      fwrite(&zero,scanline_pad,1,f);
+   }
+}
+
+static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
+{
+   FILE *f;
+   if (y < 0 || x < 0) return 0;
+   f = fopen(filename, "wb");
+   if (f) {
+      va_list v;
+      va_start(v, fmt);
+      writefv(f, fmt, v);
+      va_end(v);
+      write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad);
+      fclose(f);
+   }
+   return f != NULL;
+}
+
+int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
+{
+   int pad = (-x*3) & 3;
+   return outfile(filename,-1,-1,x,y,comp,(void *) data,0,pad,
+           "11 4 22 4" "4 44 22 444444",
+           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
+            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
+}
+
+int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
+{
+   int has_alpha = !(comp & 1);
+   return outfile(filename, -1,-1, x, y, comp, (void *) data, has_alpha, 0,
+                  "111 221 2222 11", 0,0,2, 0,0,0, 0,0,x,y, 24+8*has_alpha, 8*has_alpha);
+}
+
+// stretchy buffer; stbi__sbpush() == vector<>::push_back() -- stbi__sbcount() == vector<>::size()
+#define stbi__sbraw(a) ((int *) (a) - 2)
+#define stbi__sbm(a)   stbi__sbraw(a)[0]
+#define stbi__sbn(a)   stbi__sbraw(a)[1]
+
+#define stbi__sbneedgrow(a,n)  ((a)==0 || stbi__sbn(a)+n >= stbi__sbm(a))
+#define stbi__sbmaybegrow(a,n) (stbi__sbneedgrow(a,(n)) ? stbi__sbgrow(a,n) : 0)
+#define stbi__sbgrow(a,n)  stbi__sbgrowf((void **) &(a), (n), sizeof(*(a)))
+
+#define stbi__sbpush(a, v)      (stbi__sbmaybegrow(a,1), (a)[stbi__sbn(a)++] = (v))
+#define stbi__sbcount(a)        ((a) ? stbi__sbn(a) : 0)
+#define stbi__sbfree(a)         ((a) ? free(stbi__sbraw(a)),0 : 0)
+
+static void *stbi__sbgrowf(void **arr, int increment, int itemsize)
+{
+   int m = *arr ? 2*stbi__sbm(*arr)+increment : increment+1;
+   void *p = realloc(*arr ? stbi__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
+   assert(p);
+   if (p) {
+      if (!*arr) ((int *) p)[1] = 0;
+      *arr = (void *) ((int *) p + 2);
+      stbi__sbm(*arr) = m;
+   }
+   return *arr;
+}
+
+static unsigned char *stbi__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
+{
+   while (*bitcount >= 8) {
+      stbi__sbpush(data, (unsigned char) *bitbuffer);
+      *bitbuffer >>= 8;
+      *bitcount -= 8;
+   }
+   return data;
+}
+
+static int stbi__zlib_bitrev(int code, int codebits)
+{
+   int res=0;
+   while (codebits--) {
+      res = (res << 1) | (code & 1);
+      code >>= 1;
+   }
+   return res;
+}
+
+static unsigned int stbi__zlib_countm(unsigned char *a, unsigned char *b, int limit)
+{
+   int i;
+   for (i=0; i < limit && i < 258; ++i)
+      if (a[i] != b[i]) break;
+   return i;
+}
+
+static unsigned int stbi__zhash(unsigned char *data)
+{
+   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
+   hash ^= hash << 3;
+   hash += hash >> 5;
+   hash ^= hash << 4;
+   hash += hash >> 17;
+   hash ^= hash << 25;
+   hash += hash >> 6;
+   return hash;
+}
+
+#define stbi__zlib_flush() (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))
+#define stbi__zlib_add(code,codebits) \
+      (bitbuf |= (code) << bitcount, bitcount += (codebits), stbi__zlib_flush())
+#define stbi__zlib_huffa(b,c)  stbi__zlib_add(stbi__zlib_bitrev(b,c),c)
+// default huffman tables
+#define stbi__zlib_huff1(n)  stbi__zlib_huffa(0x30 + (n), 8)
+#define stbi__zlib_huff2(n)  stbi__zlib_huffa(0x190 + (n)-144, 9)
+#define stbi__zlib_huff3(n)  stbi__zlib_huffa(0 + (n)-256,7)
+#define stbi__zlib_huff4(n)  stbi__zlib_huffa(0xc0 + (n)-280,8)
+#define stbi__zlib_huff(n)  ((n) <= 143 ? stbi__zlib_huff1(n) : (n) <= 255 ? stbi__zlib_huff2(n) : (n) <= 279 ? stbi__zlib_huff3(n) : stbi__zlib_huff4(n))
+#define stbi__zlib_huffb(n) ((n) <= 143 ? stbi__zlib_huff1(n) : stbi__zlib_huff2(n))
+
+#define stbi__ZHASH   16384
+
+unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
+{
+   static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
+   static unsigned char  lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5,  0 };
+   static unsigned short distc[]   = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
+   static unsigned char  disteb[]  = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
+   unsigned int bitbuf=0;
+   int i,j, bitcount=0;
+   unsigned char *out = NULL;
+   unsigned char **hash_table[stbi__ZHASH]; // 64KB on the stack!
+   if (quality < 5) quality = 5;
+
+   stbi__sbpush(out, 0x78);   // DEFLATE 32K window
+   stbi__sbpush(out, 0x5e);   // FLEVEL = 1
+   stbi__zlib_add(1,1);  // BFINAL = 1
+   stbi__zlib_add(1,2);  // B3YPE = 1 -- fixed huffman
+
+   for (i=0; i < stbi__ZHASH; ++i)
+      hash_table[i] = NULL;
+
+   i=0;
+   while (i < data_len-3) {
+      // hash next 3 bytes of data to be compressed 
+      int h = stbi__zhash(data+i)&(stbi__ZHASH-1), best=3;
+      unsigned char *bestloc = 0;
+      unsigned char **hlist = hash_table[h];
+      int n = stbi__sbcount(hlist);
+      for (j=0; j < n; ++j) {
+         if (hlist[j]-data > i-32768) { // if entry lies within window
+            int d = stbi__zlib_countm(hlist[j], data+i, data_len-i);
+            if (d >= best) best=d,bestloc=hlist[j];
+         }
+      }
+      // when hash table entry is too long, delete half the entries
+      if (hash_table[h] && stbi__sbn(hash_table[h]) == 2*quality) {
+         memcpy(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
+         stbi__sbn(hash_table[h]) = quality;
+      }
+      stbi__sbpush(hash_table[h],data+i);
+
+      if (bestloc) {
+         // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal
+         h = stbi__zhash(data+i+1)&(stbi__ZHASH-1);
+         hlist = hash_table[h];
+         n = stbi__sbcount(hlist);
+         for (j=0; j < n; ++j) {
+            if (hlist[j]-data > i-32767) {
+               int e = stbi__zlib_countm(hlist[j], data+i+1, data_len-i-1);
+               if (e > best) { // if next match is better, bail on current match
+                  bestloc = NULL;
+                  break;
+               }
+            }
+         }
+      }
+
+      if (bestloc) {
+         int d = data+i - bestloc; // distance back
+         assert(d <= 32767 && best <= 258);
+         for (j=0; best > lengthc[j+1]-1; ++j);
+         stbi__zlib_huff(j+257);
+         if (lengtheb[j]) stbi__zlib_add(best - lengthc[j], lengtheb[j]);
+         for (j=0; d > distc[j+1]-1; ++j);
+         stbi__zlib_add(stbi__zlib_bitrev(j,5),5);
+         if (disteb[j]) stbi__zlib_add(d - distc[j], disteb[j]);
+         i += best;
+      } else {
+         stbi__zlib_huffb(data[i]);
+         ++i;
+      }
+   }
+   // write out final bytes
+   for (;i < data_len; ++i)
+      stbi__zlib_huffb(data[i]);
+   stbi__zlib_huff(256); // end of block
+   // pad with 0 bits to byte boundary
+   while (bitcount)
+      stbi__zlib_add(0,1);
+
+   for (i=0; i < stbi__ZHASH; ++i)
+      (void) stbi__sbfree(hash_table[i]);
+
+   {
+      // compute adler32 on input
+      unsigned int i=0, s1=1, s2=0, blocklen = data_len % 5552;
+      int j=0;
+      while (j < data_len) {
+         for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
+         s1 %= 65521, s2 %= 65521;
+         j += blocklen;
+         blocklen = 5552;
+      }
+      stbi__sbpush(out, (unsigned char) (s2 >> 8));
+      stbi__sbpush(out, (unsigned char) s2);
+      stbi__sbpush(out, (unsigned char) (s1 >> 8));
+      stbi__sbpush(out, (unsigned char) s1);
+   }
+   *out_len = stbi__sbn(out);
+   // make returned pointer freeable
+   memmove(stbi__sbraw(out), out, *out_len);
+   return (unsigned char *) stbi__sbraw(out);
+}
+
+unsigned int stbi__crc32(unsigned char *buffer, int len)
+{
+   static unsigned int crc_table[256];
+   unsigned int crc = ~0u;
+   int i,j;
+   if (crc_table[1] == 0)
+      for(i=0; i < 256; i++)
+         for (crc_table[i]=i, j=0; j < 8; ++j)
+            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
+   for (i=0; i < len; ++i)
+      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
+   return ~crc;
+}
+
+#define stbi__wpng4(o,a,b,c,d) ((o)[0]=(unsigned char)(a),(o)[1]=(unsigned char)(b),(o)[2]=(unsigned char)(c),(o)[3]=(unsigned char)(d),(o)+=4)
+#define stbi__wp32(data,v) stbi__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v));
+#define stbi__wptag(data,s) stbi__wpng4(data, s[0],s[1],s[2],s[3])
+
+static void stbi__wpcrc(unsigned char **data, int len)
+{
+   unsigned int crc = stbi__crc32(*data - len - 4, len+4);
+   stbi__wp32(*data, crc);
+}
+
+static unsigned char stbi__paeth(int a, int b, int c)
+{
+   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return (unsigned char) a;
+   if (pb <= pc) return (unsigned char) b;
+   return (unsigned char) c;
+}
+
+unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
+{
+   int ctype[5] = { -1, 0, 4, 2, 6 };
+   unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
+   unsigned char *out,*o, *filt, *zlib;
+   signed char *line_buffer;
+   int i,j,k,p,zlen;
+
+   if (stride_bytes == 0)
+      stride_bytes = x * n;
+
+   filt = (unsigned char *) malloc((x*n+1) * y); if (!filt) return 0;
+   line_buffer = (signed char *) malloc(x * n); if (!line_buffer) { free(filt); return 0; }
+   for (j=0; j < y; ++j) {
+      static int mapping[] = { 0,1,2,3,4 };
+      static int firstmap[] = { 0,1,0,5,6 };
+      int *mymap = j ? mapping : firstmap;
+      int best = 0, bestval = 0x7fffffff;
+      for (p=0; p < 2; ++p) {
+         for (k= p?best:0; k < 5; ++k) {
+            int type = mymap[k],est=0;
+            unsigned char *z = pixels + stride_bytes*j;
+            for (i=0; i < n; ++i)
+               switch (type) {
+                  case 0: line_buffer[i] = z[i]; break;
+                  case 1: line_buffer[i] = z[i]; break;
+                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
+                  case 3: line_buffer[i] = z[i] - (z[i-stride_bytes]>>1); break;
+                  case 4: line_buffer[i] = (signed char) (z[i] - stbi__paeth(0,z[i-stride_bytes],0)); break;
+                  case 5: line_buffer[i] = z[i]; break;
+                  case 6: line_buffer[i] = z[i]; break;
+               }
+            for (i=n; i < x*n; ++i) {
+               switch (type) {
+                  case 0: line_buffer[i] = z[i]; break;
+                  case 1: line_buffer[i] = z[i] - z[i-n]; break;
+                  case 2: line_buffer[i] = z[i] - z[i-stride_bytes]; break;
+                  case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-stride_bytes])>>1); break;
+                  case 4: line_buffer[i] = z[i] - stbi__paeth(z[i-n], z[i-stride_bytes], z[i-stride_bytes-n]); break;
+                  case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
+                  case 6: line_buffer[i] = z[i] - stbi__paeth(z[i-n], 0,0); break;
+               }
+            }
+            if (p) break;
+            for (i=0; i < x*n; ++i)
+               est += abs((signed char) line_buffer[i]);
+            if (est < bestval) { bestval = est; best = k; }
+         }
+      }
+      // when we get here, best contains the filter type, and line_buffer contains the data
+      filt[j*(x*n+1)] = (unsigned char) best;
+      memcpy(filt+j*(x*n+1)+1, line_buffer, x*n);
+   }
+   free(line_buffer);
+   zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, 8); // increase 8 to get smaller but use more memory
+   free(filt);
+   if (!zlib) return 0;
+
+   // each tag requires 12 bytes of overhead
+   out = (unsigned char *) malloc(8 + 12+13 + 12+zlen + 12); 
+   if (!out) return 0;
+   *out_len = 8 + 12+13 + 12+zlen + 12;
+
+   o=out;
+   memcpy(o,sig,8); o+= 8;
+   stbi__wp32(o, 13); // header length
+   stbi__wptag(o, "IHDR");
+   stbi__wp32(o, x);
+   stbi__wp32(o, y);
+   *o++ = 8;
+   *o++ = (unsigned char) ctype[n];
+   *o++ = 0;
+   *o++ = 0;
+   *o++ = 0;
+   stbi__wpcrc(&o,13);
+
+   stbi__wp32(o, zlen);
+   stbi__wptag(o, "IDAT");
+   memcpy(o, zlib, zlen); o += zlen; free(zlib);
+   stbi__wpcrc(&o, zlen);
+
+   stbi__wp32(o,0);
+   stbi__wptag(o, "IEND");
+   stbi__wpcrc(&o,0);
+
+   assert(o == out + *out_len);
+
+   return out;
+}
+
+int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
+{
+   FILE *f;
+   int len;
+   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
+   if (!png) return 0;
+   f = fopen(filename, "wb");
+   if (!f) { free(png); return 0; }
+   fwrite(png, 1, len, f);
+   fclose(f);
+   free(png);
+   return 1;
+}
+#endif // STB_IMAGE_WRITE_IMPLEMENTATION
+
+/* Revision history
+
+      0.92 (2010-08-01)
+             casts to unsigned char to fix warnings
+      0.91 (2010-07-17)
+             first public release
+      0.90   first internal release
+*/