Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of https://github.com/bulletphysics/bullet3

Browse Source
This commit is contained in:
Erwin Coumans
2014-06-24 20:27:40 -07:00
parent fd7a2b3a17 b063cfc509
commit 4bace5ca7e
6 changed files with 479 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
btgui/OpenGLWindow/GLInstancingRenderer.cpp
View File

@@ -1,10 +1,10 @@
/* /*
Copyright (c) 2012 Advanced Micro Devices, Inc. Copyright (c) 2012 Advanced Micro Devices, Inc.
This software is provided 'as-is', without any express or implied warranty. 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. 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, Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely, including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions: 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. 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.
@@ -15,7 +15,7 @@ subject to the following restrictions:
///todo: make this configurable in the gui ///todo: make this configurable in the gui
bool useShadowMap=true; bool useShadowMap=true;//false;//true;
float shadowMapWidth=8192; float shadowMapWidth=8192;
float shadowMapHeight=8192; float shadowMapHeight=8192;
float shadowMapWorldSize=200; float shadowMapWorldSize=200;
@@ -79,7 +79,7 @@ struct b3GraphicsInstance
int m_numVertices; int m_numVertices;
int m_numGraphicsInstances; int m_numGraphicsInstances;
int m_instanceOffset; int m_instanceOffset;
int m_vertexArrayOffset; int m_vertexArrayOffset;
int m_primitiveType; int m_primitiveType;
@@ -139,11 +139,11 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
int m_leftMouseButton; int m_leftMouseButton;
int m_middleMouseButton; int m_middleMouseButton;
int m_rightMouseButton; int m_rightMouseButton;
int m_altPressed; int m_altPressed;
int m_controlPressed; int m_controlPressed;
GLuint m_defaultTexturehandle; GLuint m_defaultTexturehandle;
b3AlignedObjectArray<GLuint> m_textureHandles; b3AlignedObjectArray<GLuint> m_textureHandles;
@@ -167,7 +167,7 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
m_altPressed(0), m_altPressed(0),
m_controlPressed(0) m_controlPressed(0)
{ {
} }
@@ -210,7 +210,7 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
{ {
float xDelta = x-m_mouseXpos; float xDelta = x-m_mouseXpos;
float yDelta = y-m_mouseYpos; float yDelta = y-m_mouseYpos;
if (m_leftMouseButton) if (m_leftMouseButton)
{ {
// if (b3Fabs(xDelta)>b3Fabs(yDelta)) // if (b3Fabs(xDelta)>b3Fabs(yDelta))
@@ -225,7 +225,7 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
{ {
m_cameraTargetPosition += m_cameraUp * yDelta*0.01; m_cameraTargetPosition += m_cameraUp * yDelta*0.01;
b3Vector3 fwd = m_cameraTargetPosition-m_cameraPosition; b3Vector3 fwd = m_cameraTargetPosition-m_cameraPosition;
b3Vector3 side = m_cameraUp.cross(fwd); b3Vector3 side = m_cameraUp.cross(fwd);
side.normalize(); side.normalize();
@@ -253,7 +253,7 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
void mouseButtonCallback(int button, int state, float x, float y) void mouseButtonCallback(int button, int state, float x, float y)
{ {
if (button==0) if (button==0)
m_leftMouseButton=state; m_leftMouseButton=state;
if (button==1) if (button==1)
@@ -261,7 +261,7 @@ struct InternalDataRenderer : public GLInstanceRendererInternalData
if (button==2) if (button==2)
m_rightMouseButton=state; m_rightMouseButton=state;
m_mouseXpos = x; m_mouseXpos = x;
m_mouseYpos = y; m_mouseYpos = y;
m_mouseInitialized = true; m_mouseInitialized = true;
@@ -493,7 +493,7 @@ void GLInstancingRenderer::writeTransforms()
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
glFlush(); glFlush();
@@ -503,7 +503,7 @@ void GLInstancingRenderer::writeTransforms()
char* orgBase = (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_READ_WRITE); char* orgBase = (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_READ_WRITE);
if (orgBase) if (orgBase)
{ {
int totalNumInstances= 0; int totalNumInstances= 0;
@@ -520,7 +520,7 @@ void GLInstancingRenderer::writeTransforms()
//int k=0; //int k=0;
b3GraphicsInstance* gfxObj = m_graphicsInstances[k]; b3GraphicsInstance* gfxObj = m_graphicsInstances[k];
int POSITION_BUFFER_SIZE = (totalNumInstances*sizeof(float)*4); int POSITION_BUFFER_SIZE = (totalNumInstances*sizeof(float)*4);
int ORIENTATION_BUFFER_SIZE = (totalNumInstances*sizeof(float)*4); int ORIENTATION_BUFFER_SIZE = (totalNumInstances*sizeof(float)*4);
@@ -561,7 +561,7 @@ void GLInstancingRenderer::writeTransforms()
scaling[srcIndex*3]=m_data->m_instance_scale_ptr[srcIndex*3]; scaling[srcIndex*3]=m_data->m_instance_scale_ptr[srcIndex*3];
scaling[srcIndex*3+1]=m_data->m_instance_scale_ptr[srcIndex*3+1]; scaling[srcIndex*3+1]=m_data->m_instance_scale_ptr[srcIndex*3+1];
scaling[srcIndex*3+2]=m_data->m_instance_scale_ptr[srcIndex*3+2]; scaling[srcIndex*3+2]=m_data->m_instance_scale_ptr[srcIndex*3+2];
} }
} }
} else } else
@@ -579,7 +579,7 @@ void GLInstancingRenderer::writeTransforms()
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
} }
int GLInstancingRenderer::registerGraphicsInstance(int shapeIndex, const double* pos1, const double* orn1, const double* color1, const double* scaling1) int GLInstancingRenderer::registerGraphicsInstance(int shapeIndex, const double* pos1, const double* orn1, const double* color1, const double* scaling1)
@@ -600,7 +600,7 @@ int GLInstancingRenderer::registerGraphicsInstance(int shapeIndex, const float*
b3GraphicsInstance* gfxObj = m_graphicsInstances[shapeIndex]; b3GraphicsInstance* gfxObj = m_graphicsInstances[shapeIndex];
int index = gfxObj->m_numGraphicsInstances + gfxObj->m_instanceOffset; int index = gfxObj->m_numGraphicsInstances + gfxObj->m_instanceOffset;
int maxElements = m_data->m_instance_positions_ptr.size(); int maxElements = m_data->m_instance_positions_ptr.size();
if (index*4<maxElements) if (index*4<maxElements)
{ {
@@ -643,14 +643,14 @@ int GLInstancingRenderer::registerTexture(const unsigned char* texels, int width
GLuint textureHandle; GLuint textureHandle;
glGenTextures(1,(GLuint*)&textureHandle); glGenTextures(1,(GLuint*)&textureHandle);
glBindTexture(GL_TEXTURE_2D,textureHandle); glBindTexture(GL_TEXTURE_2D,textureHandle);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width,height,0,GL_RGB,GL_UNSIGNED_BYTE,image); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width,height,0,GL_RGB,GL_UNSIGNED_BYTE,image);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -658,7 +658,7 @@ int GLInstancingRenderer::registerTexture(const unsigned char* texels, int width
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
m_data->m_textureHandles.push_back(textureHandle); m_data->m_textureHandles.push_back(textureHandle);
return textureIndex; return textureIndex;
} }
@@ -679,14 +679,14 @@ void GLInstancingRenderer::updateShape(int shapeIndex, const float* vertices)
int GLInstancingRenderer::registerShape(const float* vertices, int numvertices, const int* indices, int numIndices,int primitiveType, int textureId) int GLInstancingRenderer::registerShape(const float* vertices, int numvertices, const int* indices, int numIndices,int primitiveType, int textureId)
{ {
b3GraphicsInstance* gfxObj = new b3GraphicsInstance; b3GraphicsInstance* gfxObj = new b3GraphicsInstance;
if (textureId>=0) if (textureId>=0)
{ {
gfxObj->m_texturehandle = m_data->m_textureHandles[textureId]; gfxObj->m_texturehandle = m_data->m_textureHandles[textureId];
} }
gfxObj->m_primitiveType = primitiveType; gfxObj->m_primitiveType = primitiveType;
if (m_graphicsInstances.size()) if (m_graphicsInstances.size())
{ {
b3GraphicsInstance* prevObj = m_graphicsInstances[m_graphicsInstances.size()-1]; b3GraphicsInstance* prevObj = m_graphicsInstances[m_graphicsInstances.size()-1];
@@ -700,15 +700,15 @@ int GLInstancingRenderer::registerShape(const float* vertices, int numvertices,
m_graphicsInstances.push_back(gfxObj); m_graphicsInstances.push_back(gfxObj);
gfxObj->m_numIndices = numIndices; gfxObj->m_numIndices = numIndices;
gfxObj->m_numVertices = numvertices; gfxObj->m_numVertices = numvertices;
glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY
int vertexStrideInBytes = 9*sizeof(float); int vertexStrideInBytes = 9*sizeof(float);
int sz = numvertices*vertexStrideInBytes; int sz = numvertices*vertexStrideInBytes;
int totalUsed = vertexStrideInBytes*gfxObj->m_vertexArrayOffset+sz; int totalUsed = vertexStrideInBytes*gfxObj->m_vertexArrayOffset+sz;
b3Assert(totalUsed<this->m_maxShapeCapacityInBytes); b3Assert(totalUsed<this->m_maxShapeCapacityInBytes);
memcpy(dest+vertexStrideInBytes*gfxObj->m_vertexArrayOffset,vertices,sz); memcpy(dest+vertexStrideInBytes*gfxObj->m_vertexArrayOffset,vertices,sz);
glUnmapBuffer( GL_ARRAY_BUFFER); glUnmapBuffer( GL_ARRAY_BUFFER);
@@ -720,7 +720,7 @@ int GLInstancingRenderer::registerShape(const float* vertices, int numvertices,
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSizeInBytes, NULL, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSizeInBytes, NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSizeInBytes,indices); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSizeInBytes,indices);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glGenVertexArrays(1, &gfxObj->m_cube_vao); glGenVertexArrays(1, &gfxObj->m_cube_vao);
glBindVertexArray(gfxObj->m_cube_vao); glBindVertexArray(gfxObj->m_cube_vao);
glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
@@ -728,7 +728,7 @@ int GLInstancingRenderer::registerShape(const float* vertices, int numvertices,
glBindBuffer(GL_ARRAY_BUFFER,0); glBindBuffer(GL_ARRAY_BUFFER,0);
glBindVertexArray(0); glBindVertexArray(0);
return m_graphicsInstances.size()-1; return m_graphicsInstances.size()-1;
} }
@@ -737,7 +737,7 @@ int GLInstancingRenderer::registerShape(const float* vertices, int numvertices,
void GLInstancingRenderer::InitShaders() void GLInstancingRenderer::InitShaders()
{ {
int POSITION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int POSITION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4);
int ORIENTATION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int ORIENTATION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4);
int COLOR_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int COLOR_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4);
@@ -757,12 +757,12 @@ void GLInstancingRenderer::InitShaders()
glGenBuffers(1, &linesVertexBufferObject); glGenBuffers(1, &linesVertexBufferObject);
glGenBuffers(1, &linesIndexVbo); glGenBuffers(1, &linesIndexVbo);
int sz = MAX_LINES_IN_BATCH*sizeof(b3Vector3); int sz = MAX_LINES_IN_BATCH*sizeof(b3Vector3);
glBindVertexArray(linesVertexArrayObject); glBindVertexArray(linesVertexArrayObject);
glBindBuffer(GL_ARRAY_BUFFER, linesVertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, linesVertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW);
glBindVertexArray(0); glBindVertexArray(0);
} }
{ {
@@ -771,23 +771,23 @@ void GLInstancingRenderer::InitShaders()
glGenBuffers(1, &lineVertexBufferObject); glGenBuffers(1, &lineVertexBufferObject);
glGenBuffers(1, &lineIndexVbo); glGenBuffers(1, &lineIndexVbo);
int sz = MAX_POINTS_IN_BATCH*sizeof(b3Vector3); int sz = MAX_POINTS_IN_BATCH*sizeof(b3Vector3);
glBindVertexArray(lineVertexArrayObject); glBindVertexArray(lineVertexArrayObject);
glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW);
glBindVertexArray(0); glBindVertexArray(0);
} }
//glGetIntegerv(GL_ALIASED_LINE_WIDTH_RANGE, range); //glGetIntegerv(GL_ALIASED_LINE_WIDTH_RANGE, range);
glGetIntegerv(GL_SMOOTH_LINE_WIDTH_RANGE, lineWidthRange); glGetIntegerv(GL_SMOOTH_LINE_WIDTH_RANGE, lineWidthRange);
useShadowMapInstancingShader = gltLoadShaderPair(useShadowMapInstancingVertexShader,useShadowMapInstancingFragmentShader); useShadowMapInstancingShader = gltLoadShaderPair(useShadowMapInstancingVertexShader,useShadowMapInstancingFragmentShader);
glLinkProgram(useShadowMapInstancingShader); glLinkProgram(useShadowMapInstancingShader);
glUseProgram(useShadowMapInstancingShader); glUseProgram(useShadowMapInstancingShader);
useShadow_ModelViewMatrix = glGetUniformLocation(useShadowMapInstancingShader, "ModelViewMatrix"); useShadow_ModelViewMatrix = glGetUniformLocation(useShadowMapInstancingShader, "ModelViewMatrix");
@@ -803,9 +803,8 @@ void GLInstancingRenderer::InitShaders()
glUseProgram(createShadowMapInstancingShader); glUseProgram(createShadowMapInstancingShader);
createShadow_depthMVP = glGetUniformLocation(createShadowMapInstancingShader, "depthMVP"); createShadow_depthMVP = glGetUniformLocation(createShadowMapInstancingShader, "depthMVP");
glUseProgram(0); glUseProgram(0);
instancingShader = gltLoadShaderPair(instancingVertexShader,instancingFragmentShader); instancingShader = gltLoadShaderPair(instancingVertexShader,instancingFragmentShader);
glLinkProgram(instancingShader); glLinkProgram(instancingShader);
glUseProgram(instancingShader); glUseProgram(instancingShader);
@@ -813,13 +812,13 @@ void GLInstancingRenderer::InitShaders()
ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix");
uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse");
glUseProgram(0); glUseProgram(0);
instancingShaderPointSprite = gltLoadShaderPair(pointSpriteVertexShader,pointSpriteFragmentShader); instancingShaderPointSprite = gltLoadShaderPair(pointSpriteVertexShader,pointSpriteFragmentShader);
glUseProgram(instancingShaderPointSprite); glUseProgram(instancingShaderPointSprite);
ModelViewMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ModelViewMatrix"); ModelViewMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ModelViewMatrix");
ProjectionMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ProjectionMatrix"); ProjectionMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ProjectionMatrix");
screenWidthPointSprite = glGetUniformLocation(instancingShaderPointSprite, "screenWidth"); screenWidthPointSprite = glGetUniformLocation(instancingShaderPointSprite, "screenWidth");
glUseProgram(0); glUseProgram(0);
//GLuint offset = 0; //GLuint offset = 0;
@@ -839,7 +838,7 @@ void GLInstancingRenderer::InitShaders()
glBindVertexArray(0); glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
} }
@@ -850,25 +849,25 @@ void GLInstancingRenderer::init()
{ {
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS); glDepthFunc(GL_LESS);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
// glClearColor(float(0.),float(0.),float(0.4),float(0)); // glClearColor(float(0.),float(0.),float(0.4),float(0));
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
{ {
B3_PROFILE("texture"); B3_PROFILE("texture");
if(m_textureenabled) if(m_textureenabled)
@@ -898,7 +897,7 @@ void GLInstancingRenderer::init()
/* /*
const int s=x>>5; const int s=x>>5;
const GLubyte b=180; const GLubyte b=180;
GLubyte c=b+((s+t&1)&1)*(255-b); GLubyte c=b+((s+t&1)&1)*(255-b);
pi[0]=c; pi[0]=c;
pi[1]=c; pi[1]=c;
@@ -918,44 +917,44 @@ void GLInstancingRenderer::init()
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
#endif #endif
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256,256,0,GL_RGB,GL_UNSIGNED_BYTE,image); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256,256,0,GL_RGB,GL_UNSIGNED_BYTE,image);
glGenerateMipmap(GL_TEXTURE_2D); glGenerateMipmap(GL_TEXTURE_2D);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
delete[] image; delete[] image;
m_textureinitialized=true; m_textureinitialized=true;
} }
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glBindTexture(GL_TEXTURE_2D,m_data->m_defaultTexturehandle); glBindTexture(GL_TEXTURE_2D,m_data->m_defaultTexturehandle);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
} else } else
{ {
@@ -965,7 +964,7 @@ void GLInstancingRenderer::init()
} }
} }
//glEnable(GL_COLOR_MATERIAL); //glEnable(GL_COLOR_MATERIAL);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -983,27 +982,27 @@ void b3CreateFrustum(
float farVal, float farVal,
float frustum[16]) float frustum[16])
{ {
frustum[0*4+0] = (float(2) * nearVal) / (right - left); frustum[0*4+0] = (float(2) * nearVal) / (right - left);
frustum[0*4+1] = float(0); frustum[0*4+1] = float(0);
frustum[0*4+2] = float(0); frustum[0*4+2] = float(0);
frustum[0*4+3] = float(0); frustum[0*4+3] = float(0);
frustum[1*4+0] = float(0); frustum[1*4+0] = float(0);
frustum[1*4+1] = (float(2) * nearVal) / (top - bottom); frustum[1*4+1] = (float(2) * nearVal) / (top - bottom);
frustum[1*4+2] = float(0); frustum[1*4+2] = float(0);
frustum[1*4+3] = float(0); frustum[1*4+3] = float(0);
frustum[2*4+0] = (right + left) / (right - left); frustum[2*4+0] = (right + left) / (right - left);
frustum[2*4+1] = (top + bottom) / (top - bottom); frustum[2*4+1] = (top + bottom) / (top - bottom);
frustum[2*4+2] = -(farVal + nearVal) / (farVal - nearVal); frustum[2*4+2] = -(farVal + nearVal) / (farVal - nearVal);
frustum[2*4+3] = float(-1); frustum[2*4+3] = float(-1);
frustum[3*4+0] = float(0); frustum[3*4+0] = float(0);
frustum[3*4+1] = float(0); frustum[3*4+1] = float(0);
frustum[3*4+2] = -(float(2) * farVal * nearVal) / (farVal - nearVal); frustum[3*4+2] = -(float(2) * farVal * nearVal) / (farVal - nearVal);
frustum[3*4+3] = float(0); frustum[3*4+3] = float(0);
} }
@@ -1057,11 +1056,11 @@ void b3CreateLookAt(const b3Vector3& eye, const b3Vector3& center,const b3Vec
b3Vector3 u = up.normalized(); b3Vector3 u = up.normalized();
b3Vector3 s = (f.cross(u)).normalized(); b3Vector3 s = (f.cross(u)).normalized();
u = s.cross(f); u = s.cross(f);
result[0*4+0] = s.x; result[0*4+0] = s.x;
result[1*4+0] = s.y; result[1*4+0] = s.y;
result[2*4+0] = s.z; result[2*4+0] = s.z;
result[0*4+1] = u.x; result[0*4+1] = u.x;
result[1*4+1] = u.y; result[1*4+1] = u.y;
result[2*4+1] = u.z; result[2*4+1] = u.z;
@@ -1069,7 +1068,7 @@ void b3CreateLookAt(const b3Vector3& eye, const b3Vector3& center,const b3Vec
result[0*4+2] =-f.x; result[0*4+2] =-f.x;
result[1*4+2] =-f.y; result[1*4+2] =-f.y;
result[2*4+2] =-f.z; result[2*4+2] =-f.z;
result[0*4+3] = 0.f; result[0*4+3] = 0.f;
result[1*4+3] = 0.f; result[1*4+3] = 0.f;
result[2*4+3] = 0.f; result[2*4+3] = 0.f;
@@ -1087,18 +1086,18 @@ void GLInstancingRenderer::resize(int width, int height)
m_screenHeight = height; m_screenHeight = height;
} }
void GLInstancingRenderer::updateCamera() void GLInstancingRenderer::updateCamera()
{ {
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
int m_forwardAxis(2); int m_forwardAxis(2);
float m_frustumZNear=1; float m_frustumZNear=1;
float m_frustumZFar=10000.f; float m_frustumZFar=10000.f;
// m_azi=m_azi+0.01; // m_azi=m_azi+0.01;
b3Scalar rele = m_data->m_ele * b3Scalar(0.01745329251994329547);// rads per deg b3Scalar rele = m_data->m_ele * b3Scalar(0.01745329251994329547);// rads per deg
@@ -1135,7 +1134,7 @@ void GLInstancingRenderer::updateCamera()
aspect = m_screenWidth / (b3Scalar)m_screenHeight; aspect = m_screenWidth / (b3Scalar)m_screenHeight;
extents.setValue(aspect * 1.0f, 1.0f,0); extents.setValue(aspect * 1.0f, 1.0f,0);
if (m_screenWidth > m_screenHeight) if (m_screenWidth > m_screenHeight)
{ {
b3CreateFrustum(-aspect * m_frustumZNear, aspect * m_frustumZNear, -m_frustumZNear, m_frustumZNear, m_frustumZNear, m_frustumZFar,projectionMatrix); b3CreateFrustum(-aspect * m_frustumZNear, aspect * m_frustumZNear, -m_frustumZNear, m_frustumZNear, m_frustumZNear, m_frustumZFar,projectionMatrix);
@@ -1145,8 +1144,8 @@ void GLInstancingRenderer::updateCamera()
} }
b3CreateLookAt(m_data->m_cameraPosition,m_data->m_cameraTargetPosition,m_data->m_cameraUp,modelviewMatrix); b3CreateLookAt(m_data->m_cameraPosition,m_data->m_cameraTargetPosition,m_data->m_cameraUp,modelviewMatrix);
} }
@@ -1230,9 +1229,9 @@ void GLInstancingRenderer::getMouseDirection(float* dir, int x, int y)
vertical *= 2.f * farPlane * tanfov; vertical *= 2.f * farPlane * tanfov;
b3Scalar aspect; b3Scalar aspect;
aspect = m_screenWidth / (b3Scalar)m_screenHeight; aspect = m_screenWidth / (b3Scalar)m_screenHeight;
hor*=aspect; hor*=aspect;
@@ -1262,7 +1261,7 @@ void writeTextureToPng(int textureWidth, int textureHeight, const char* fileName
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glPixelStorei(GL_PACK_ALIGNMENT,4); glPixelStorei(GL_PACK_ALIGNMENT,4);
glReadBuffer(GL_NONE); glReadBuffer(GL_NONE);
float* orgPixels = (float*)malloc(textureWidth*textureHeight*numComponents*4); float* orgPixels = (float*)malloc(textureWidth*textureHeight*numComponents*4);
char* pixels = (char*)malloc(textureWidth*textureHeight*numComponents*4); char* pixels = (char*)malloc(textureWidth*textureHeight*numComponents*4);
@@ -1284,7 +1283,7 @@ void writeTextureToPng(int textureWidth, int textureHeight, const char* fileName
pixels[(j*textureWidth+i)*numComponents+2]=0;//255.f; pixels[(j*textureWidth+i)*numComponents+2]=0;//255.f;
pixels[(j*textureWidth+i)*numComponents+3]=255; pixels[(j*textureWidth+i)*numComponents+3]=255;
//pixels[(j*textureWidth+i)*+1]=val; //pixels[(j*textureWidth+i)*+1]=val;
//pixels[(j*textureWidth+i)*numComponents+2]=val; //pixels[(j*textureWidth+i)*numComponents+2]=val;
//pixels[(j*textureWidth+i)*numComponents+3]=255; //pixels[(j*textureWidth+i)*numComponents+3]=255;
@@ -1301,7 +1300,7 @@ void writeTextureToPng(int textureWidth, int textureHeight, const char* fileName
{ {
//swap the pixels //swap the pixels
unsigned char tmp; unsigned char tmp;
for (int j=0;j<textureHeight/2;j++) for (int j=0;j<textureHeight/2;j++)
{ {
for (int i=0;i<textureWidth;i++) for (int i=0;i<textureWidth;i++)
@@ -1316,9 +1315,9 @@ void writeTextureToPng(int textureWidth, int textureHeight, const char* fileName
} }
} }
} }
stbi_write_png(fileName, textureWidth,textureHeight, numComponents, pixels, textureWidth*numComponents); stbi_write_png(fileName, textureWidth,textureHeight, numComponents, pixels, textureWidth*numComponents);
free(pixels); free(pixels);
} }
@@ -1326,14 +1325,14 @@ void writeTextureToPng(int textureWidth, int textureHeight, const char* fileName
void GLInstancingRenderer::renderScene() void GLInstancingRenderer::renderScene()
{ {
if (useShadowMap) if (useShadowMap)
{ {
float color[4]={1,1,1,1}; float color[4]={1,1,1,1};
renderSceneInternal(B3_CREATE_SHADOWMAP_RENDERMODE); renderSceneInternal(B3_CREATE_SHADOWMAP_RENDERMODE);
// glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
renderSceneInternal(B3_USE_SHADOWMAP_RENDERMODE); renderSceneInternal(B3_USE_SHADOWMAP_RENDERMODE);
} else } else
{ {
renderSceneInternal(); renderSceneInternal();
@@ -1357,10 +1356,10 @@ void GLInstancingRenderer::drawPoints(const float* positions, const float color[
glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &projectionMatrix[0]); glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &projectionMatrix[0]);
glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]); glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]);
glUniform4f(lines_colour,color[0],color[1],color[2],color[3]); glUniform4f(lines_colour,color[0],color[1],color[2],color[3]);
glPointSize(pointDrawSize); glPointSize(pointDrawSize);
glBindVertexArray(lineVertexArrayObject); glBindVertexArray(lineVertexArrayObject);
glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject);
int maxPointsInBatch = MAX_POINTS_IN_BATCH; int maxPointsInBatch = MAX_POINTS_IN_BATCH;
@@ -1385,21 +1384,21 @@ void GLInstancingRenderer::drawPoints(const float* positions, const float color[
break; break;
} }
} }
glBindVertexArray(0); glBindVertexArray(0);
glPointSize(1); glPointSize(1);
} }
void GLInstancingRenderer::drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize) void GLInstancingRenderer::drawLines(const float* positions, const float color[4], int numPoints, int pointStrideInBytes, const unsigned int* indices, int numIndices, float pointDrawSize)
{ {
glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,0); glBindTexture(GL_TEXTURE_2D,0);
int curOffset = 0; int curOffset = 0;
@@ -1409,13 +1408,13 @@ void GLInstancingRenderer::drawLines(const float* positions, const float color[4
glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &projectionMatrix[0]); glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &projectionMatrix[0]);
glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]); glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]);
glUniform4f(lines_colour,color[0],color[1],color[2],color[3]); glUniform4f(lines_colour,color[0],color[1],color[2],color[3]);
// glPointSize(pointDrawSize); // glPointSize(pointDrawSize);
glBindVertexArray(linesVertexArrayObject); glBindVertexArray(linesVertexArrayObject);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glBindBuffer(GL_ARRAY_BUFFER, linesVertexBufferObject); glBindBuffer(GL_ARRAY_BUFFER, linesVertexBufferObject);
{ {
@@ -1463,23 +1462,23 @@ void GLInstancingRenderer::drawLines(const float* positions, const float color[4
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
} }
void GLInstancingRenderer::drawLine(const float from[4], const float to[4], const float color[4], float lineWidth) void GLInstancingRenderer::drawLine(const float from[4], const float to[4], const float color[4], float lineWidth)
{ {
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,0); glBindTexture(GL_TEXTURE_2D,0);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
int curOffset = 0; int curOffset = 0;
glUseProgram(linesShader); glUseProgram(linesShader);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1487,7 +1486,7 @@ void GLInstancingRenderer::drawLine(const float from[4], const float to[4], cons
glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]); glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &modelviewMatrix[0]);
glUniform4f(lines_colour,color[0],color[1],color[2],color[3]); glUniform4f(lines_colour,color[0],color[1],color[2],color[3]);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1499,10 +1498,10 @@ void GLInstancingRenderer::drawLine(const float from[4], const float to[4], cons
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
b3Clamp(lineWidth,(float)lineWidthRange[0],(float)lineWidthRange[1]); b3Clamp(lineWidth,(float)lineWidthRange[0],(float)lineWidthRange[1]);
glLineWidth(lineWidth); glLineWidth(lineWidth);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1515,12 +1514,12 @@ void GLInstancingRenderer::drawLine(const float from[4], const float to[4], cons
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
{ {
glBufferSubData(GL_ARRAY_BUFFER, 0,sz, vertexPositions); glBufferSubData(GL_ARRAY_BUFFER, 0,sz, vertexPositions);
} }
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1538,18 +1537,18 @@ void GLInstancingRenderer::drawLine(const float from[4], const float to[4], cons
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
glBindVertexArray(0); glBindVertexArray(0);
glLineWidth(1); glLineWidth(1);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
} }
void GLInstancingRenderer::renderSceneInternal(int renderMode) void GLInstancingRenderer::renderSceneInternal(int renderMode)
{ {
// glEnable(GL_DEPTH_TEST); // glEnable(GL_DEPTH_TEST);
GLint dims[4]; GLint dims[4];
@@ -1557,7 +1556,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
//we need to get the viewport dims, because on Apple Retina the viewport dimension is different from screenWidth //we need to get the viewport dims, because on Apple Retina the viewport dimension is different from screenWidth
//printf("dims=%d,%d,%d,%d\n",dims[0],dims[1],dims[2],dims[3]); //printf("dims=%d,%d,%d,%d\n",dims[0],dims[1],dims[2],dims[3]);
// Accept fragment if it closer to the camera than the former one // Accept fragment if it closer to the camera than the former one
//glDepthFunc(GL_LESS); //glDepthFunc(GL_LESS);
// Cull triangles which normal is not towards the camera // Cull triangles which normal is not towards the camera
//glEnable(GL_CULL_FACE); //glEnable(GL_CULL_FACE);
@@ -1570,8 +1569,8 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
B3_PROFILE("init"); B3_PROFILE("init");
init(); init();
} }
GLint err = glGetError(); GLint err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1585,7 +1584,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
{ {
glEnable(GL_CULL_FACE); glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT); glCullFace(GL_FRONT);
if (!m_data->m_shadowMap) if (!m_data->m_shadowMap)
{ {
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
@@ -1595,7 +1594,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
//glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT16,m_screenWidth,m_screenHeight,0,GL_DEPTH_COMPONENT,GL_FLOAT,0); //glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT16,m_screenWidth,m_screenHeight,0,GL_DEPTH_COMPONENT,GL_FLOAT,0);
//glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT32,m_screenWidth,m_screenHeight,0,GL_DEPTH_COMPONENT,GL_FLOAT,0); //glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT32,m_screenWidth,m_screenHeight,0,GL_DEPTH_COMPONENT,GL_FLOAT,0);
glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, shadowMapWidth, shadowMapHeight, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0); glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, shadowMapWidth, shadowMapHeight, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -1628,7 +1627,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
{ {
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
//glCullFace(GL_BACK); //glCullFace(GL_BACK);
} }
static b3Vector3 lightPos = b3MakeVector3(-5.f,200,-40);//20,15,10);//-13,6,2);// = b3Vector3(0.5f,2,2); static b3Vector3 lightPos = b3MakeVector3(-5.f,200,-40);//20,15,10);//-13,6,2);// = b3Vector3(0.5f,2,2);
// lightPos.y+=0.1f; // lightPos.y+=0.1f;
@@ -1643,12 +1642,12 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
b3CreateDiagonalMatrix(1.f,depthModelMatrix); b3CreateDiagonalMatrix(1.f,depthModelMatrix);
b3Matrix4x4Mul(depthViewMatrix, depthModelMatrix, depthModelViewMatrix); b3Matrix4x4Mul(depthViewMatrix, depthModelMatrix, depthModelViewMatrix);
GLfloat depthMVP[4][4]; GLfloat depthMVP[4][4];
b3Matrix4x4Mul(depthProjectionMatrix,depthModelViewMatrix,depthMVP); b3Matrix4x4Mul(depthProjectionMatrix,depthModelViewMatrix,depthMVP);
GLfloat biasMatrix[4][4]={ GLfloat biasMatrix[4][4]={
0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0 0.5, 0.5, 0.5, 1.0
@@ -1657,14 +1656,14 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
GLfloat depthBiasMVP[4][4]; GLfloat depthBiasMVP[4][4];
b3Matrix4x4Mul(biasMatrix,depthMVP,depthBiasMVP); b3Matrix4x4Mul(biasMatrix,depthMVP,depthBiasMVP);
//float m_frustumZNear=0.1; //float m_frustumZNear=0.1;
//float m_frustumZFar=100.f; //float m_frustumZFar=100.f;
//b3CreateFrustum(-m_frustumZNear, m_frustumZNear, -m_frustumZNear, m_frustumZNear, m_frustumZNear, m_frustumZFar,(float*)depthProjectionMatrix); //b3CreateFrustum(-m_frustumZNear, m_frustumZNear, -m_frustumZNear, m_frustumZNear, m_frustumZNear, m_frustumZFar,(float*)depthProjectionMatrix);
//b3CreateLookAt(lightPos,m_data->m_cameraTargetPosition,b3Vector3(0,0,1),(float*)depthModelViewMatrix); //b3CreateLookAt(lightPos,m_data->m_cameraTargetPosition,b3Vector3(0,0,1),(float*)depthModelViewMatrix);
@@ -1675,7 +1674,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
// glBindBuffer(GL_ARRAY_BUFFER, 0); // glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -1687,7 +1686,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
} }
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
int totalNumInstances = 0; int totalNumInstances = 0;
@@ -1702,7 +1701,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
for (int i=0;i<m_graphicsInstances.size();i++) for (int i=0;i<m_graphicsInstances.size();i++)
{ {
b3GraphicsInstance* gfxObj = m_graphicsInstances[i]; b3GraphicsInstance* gfxObj = m_graphicsInstances[i];
if (gfxObj->m_numGraphicsInstances) if (gfxObj->m_numGraphicsInstances)
{ {
@@ -1730,7 +1729,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
glBindVertexArray(gfxObj->m_cube_vao); glBindVertexArray(gfxObj->m_cube_vao);
int vertexStride = 9*sizeof(float); int vertexStride = 9*sizeof(float);
int vertexBase = gfxObj->m_vertexArrayOffset*vertexStride; int vertexBase = gfxObj->m_vertexArrayOffset*vertexStride;
@@ -1759,26 +1758,26 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
glVertexAttribDivisorARB(4, 0); glVertexAttribDivisorARB(4, 0);
glVertexAttribDivisorARB(5, 1); glVertexAttribDivisorARB(5, 1);
glVertexAttribDivisorARB(6, 1); glVertexAttribDivisorARB(6, 1);
int indexCount = gfxObj->m_numIndices; int indexCount = gfxObj->m_numIndices;
int indexOffset = 0; int indexOffset = 0;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gfxObj->m_index_vbo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gfxObj->m_index_vbo);
{ {
B3_PROFILE("glDrawElementsInstanced"); B3_PROFILE("glDrawElementsInstanced");
if (gfxObj->m_primitiveType==B3_GL_POINTS) if (gfxObj->m_primitiveType==B3_GL_POINTS)
{ {
glUseProgram(instancingShaderPointSprite); glUseProgram(instancingShaderPointSprite);
glUniformMatrix4fv(ProjectionMatrixPointSprite, 1, false, &projectionMatrix[0]); glUniformMatrix4fv(ProjectionMatrixPointSprite, 1, false, &projectionMatrix[0]);
glUniformMatrix4fv(ModelViewMatrixPointSprite, 1, false, &modelviewMatrix[0]); glUniformMatrix4fv(ModelViewMatrixPointSprite, 1, false, &modelviewMatrix[0]);
glUniform1f(screenWidthPointSprite,m_screenWidth); glUniform1f(screenWidthPointSprite,m_screenWidth);
//glUniform1i(uniform_texture_diffusePointSprite, 0); //glUniform1i(uniform_texture_diffusePointSprite, 0);
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
@@ -1807,6 +1806,12 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
} }
case B3_CREATE_SHADOWMAP_RENDERMODE: case B3_CREATE_SHADOWMAP_RENDERMODE:
{ {
/*printf("createShadowMapInstancingShader=%d\n",createShadowMapInstancingShader);
printf("createShadow_depthMVP=%d\n",createShadow_depthMVP);
printf("indexOffset=%d\n",indexOffset);
printf("gfxObj->m_numGraphicsInstances=%d\n",gfxObj->m_numGraphicsInstances);
printf("indexCount=%d\n",indexCount);
*/
glUseProgram(createShadowMapInstancingShader); glUseProgram(createShadowMapInstancingShader);
glUniformMatrix4fv(createShadow_depthMVP, 1, false, &depthMVP[0][0]); glUniformMatrix4fv(createShadow_depthMVP, 1, false, &depthMVP[0][0]);
glDrawElementsInstanced(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (void*)indexOffset, gfxObj->m_numGraphicsInstances); glDrawElementsInstanced(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, (void*)indexOffset, gfxObj->m_numGraphicsInstances);
@@ -1835,7 +1840,7 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
}; };
} }
//glDrawElementsInstanced(GL_LINE_LOOP, indexCount, GL_UNSIGNED_INT, (void*)indexOffset, gfxObj->m_numGraphicsInstances); //glDrawElementsInstanced(GL_LINE_LOOP, indexCount, GL_UNSIGNED_INT, (void*)indexOffset, gfxObj->m_numGraphicsInstances);
} }
} }
@@ -1862,13 +1867,13 @@ void GLInstancingRenderer::renderSceneInternal(int renderMode)
glBindBuffer(GL_ARRAY_BUFFER,0); glBindBuffer(GL_ARRAY_BUFFER,0);
glBindVertexArray(0); glBindVertexArray(0);
} }
err = glGetError(); err = glGetError();
b3Assert(err==GL_NO_ERROR); b3Assert(err==GL_NO_ERROR);
} }

4
btgui/OpenGLWindow/GLRenderToTexture.cpp
View File

@@ -66,7 +66,9 @@ bool GLRenderToTexture::enable()
} }
case RENDERTEXTURE_DEPTH: case RENDERTEXTURE_DEPTH:
{ {
glDrawBuffer(GL_NONE); GLenum drawBuffers[2] = { GL_NONE, 0 };// GL_DEPTH_ATTACHMENT, 0};
glDrawBuffers(1, drawBuffers);
// glDrawBuffer(GL_NONE);
break; break;
} }
default: default:

50
btgui/OpenGLWindow/LoadShader.cpp
View File

@@ -9,7 +9,7 @@
void gltLoadShaderSrc(const char *szShaderSrc, GLuint shader) void gltLoadShaderSrc(const char *szShaderSrc, GLuint shader)
{ {
GLchar *fsStringPtr[1]; GLchar *fsStringPtr[1];
fsStringPtr[0] = (GLchar *)szShaderSrc; fsStringPtr[0] = (GLchar *)szShaderSrc;
glShaderSource(shader, 1, (const GLchar **)fsStringPtr, NULL); glShaderSource(shader, 1, (const GLchar **)fsStringPtr, NULL);
} }
@@ -17,29 +17,27 @@ void gltLoadShaderSrc(const char *szShaderSrc, GLuint shader)
GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg) GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
{ {
GLuint err = glGetError();
assert(err==GL_NO_ERROR);
// Temporary Shader objects // Temporary Shader objects
GLuint hVertexShader; GLuint hVertexShader;
GLuint hFragmentShader; GLuint hFragmentShader;
GLuint hReturn = 0; GLuint hReturn = 0;
GLint testVal; GLint testVal;
// Create shader objects // Create shader objects
hVertexShader = glCreateShader(GL_VERTEX_SHADER); hVertexShader = glCreateShader(GL_VERTEX_SHADER);
hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER); hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
gltLoadShaderSrc(szVertexProg, hVertexShader); gltLoadShaderSrc(szVertexProg, hVertexShader);
gltLoadShaderSrc(szFragmentProg, hFragmentShader); gltLoadShaderSrc(szFragmentProg, hFragmentShader);
// Compile them // Compile them
glCompileShader(hVertexShader); glCompileShader(hVertexShader);
GLuint err = glGetError();
assert(err==GL_NO_ERROR);
glCompileShader(hFragmentShader);
err = glGetError(); err = glGetError();
assert(err==GL_NO_ERROR);
// Check for errors
glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal); glGetShaderiv(hVertexShader, GL_COMPILE_STATUS, &testVal);
if(testVal == GL_FALSE) if(testVal == GL_FALSE)
{ {
@@ -52,8 +50,13 @@ GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
glDeleteShader(hFragmentShader); glDeleteShader(hFragmentShader);
return (GLuint)NULL; return (GLuint)NULL;
} }
glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal); assert(err==GL_NO_ERROR);
glCompileShader(hFragmentShader);
err = glGetError();
glGetShaderiv(hFragmentShader, GL_COMPILE_STATUS, &testVal);
if(testVal == GL_FALSE) if(testVal == GL_FALSE)
{ {
char temp[256] = ""; char temp[256] = "";
@@ -65,18 +68,25 @@ GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
glDeleteShader(hFragmentShader); glDeleteShader(hFragmentShader);
return (GLuint)NULL; return (GLuint)NULL;
} }
assert(err==GL_NO_ERROR);
// Check for errors
// Link them - assuming it works... // Link them - assuming it works...
hReturn = glCreateProgram(); hReturn = glCreateProgram();
glAttachShader(hReturn, hVertexShader); glAttachShader(hReturn, hVertexShader);
glAttachShader(hReturn, hFragmentShader); glAttachShader(hReturn, hFragmentShader);
glLinkProgram(hReturn); glLinkProgram(hReturn);
// These are no longer needed // These are no longer needed
glDeleteShader(hVertexShader); glDeleteShader(hVertexShader);
glDeleteShader(hFragmentShader); glDeleteShader(hFragmentShader);
// Make sure link worked too // Make sure link worked too
glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal); glGetProgramiv(hReturn, GL_LINK_STATUS, &testVal);
if(testVal == GL_FALSE) if(testVal == GL_FALSE)
@@ -84,7 +94,7 @@ GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
GLsizei maxLen = 4096; GLsizei maxLen = 4096;
GLchar infoLog[4096]; GLchar infoLog[4096];
GLsizei actualLen; GLsizei actualLen;
glGetProgramInfoLog( hReturn, glGetProgramInfoLog( hReturn,
maxLen, maxLen,
&actualLen, &actualLen,
@@ -95,8 +105,8 @@ GLuint gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
glDeleteProgram(hReturn); glDeleteProgram(hReturn);
return (GLuint)NULL; return (GLuint)NULL;
} }
return hReturn; return hReturn;
} }

3
btgui/OpenGLWindow/Shaders/createShadowMapInstancingVS.h
View File

@@ -5,9 +5,6 @@ static const char* createShadowMapInstancingVertexShader= \
"layout (location = 0) in vec4 position;\n" "layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec4 instance_position;\n" "layout (location = 1) in vec4 instance_position;\n"
"layout (location = 2) in vec4 instance_quaternion;\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" "layout (location = 6) in vec3 instance_scale;\n"
"uniform mat4 depthMVP;\n" "uniform mat4 depthMVP;\n"
"vec4 quatMul ( in vec4 q1, in vec4 q2 )\n" "vec4 quatMul ( in vec4 q1, in vec4 q2 )\n"

30
btgui/OpenGLWindow/SimpleOpenGL3App.cpp
View File

@@ -1,6 +1,5 @@
#include "SimpleOpenGL3App.h" #include "SimpleOpenGL3App.h"
#include "ShapeData.h" #include "ShapeData.h"
#ifdef __APPLE__ #ifdef __APPLE__
#include "OpenGLWindow/MacOpenGLWindow.h" #include "OpenGLWindow/MacOpenGLWindow.h"
#else #else
@@ -78,17 +77,44 @@ SimpleOpenGL3App::SimpleOpenGL3App( const char* title, int width,int height)
m_window->createWindow(ci); m_window->createWindow(ci);
m_window->setWindowTitle(title); m_window->setWindowTitle(title);
GLuint err = glGetError();
assert(err==GL_NO_ERROR);
glClearColor(1,1,1,1); glClearColor(1,1,1,1);
m_window->startRendering(); m_window->startRendering();
err = glGetError();
assert(err==GL_NO_ERROR);
#ifndef __APPLE__ #ifndef __APPLE__
glewInit(); #ifndef _WIN32
//some Linux implementations need the 'glewExperimental' to be true
glewExperimental = GL_TRUE;
#endif #endif
err = glewInit();
if (err != 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
err = glGetError();
err = glGetError();
assert(err==GL_NO_ERROR);
m_primRenderer = new GLPrimitiveRenderer(width,height); m_primRenderer = new GLPrimitiveRenderer(width,height);
err = glGetError();
assert(err==GL_NO_ERROR);
m_instancingRenderer = new GLInstancingRenderer(128*1024,4*1024*1024); m_instancingRenderer = new GLInstancingRenderer(128*1024,4*1024*1024);
m_instancingRenderer->init(); m_instancingRenderer->init();
m_instancingRenderer->resize(width,height); m_instancingRenderer->resize(width,height);
err = glGetError();
assert(err==GL_NO_ERROR);
m_instancingRenderer->InitShaders(); m_instancingRenderer->InitShaders();
m_window->setMouseMoveCallback(b3DefaultMouseMoveCallback); m_window->setMouseMoveCallback(b3DefaultMouseMoveCallback);

298
btgui/OpenGLWindow/X11OpenGLWindow.cpp
View File

@@ -10,11 +10,14 @@
//#include<GL/glu.h> //#include<GL/glu.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h> #include <pthread.h>
GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None }; GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
static bool forceOpenGL3 = true;
struct InternalData2 struct InternalData2
{ {
@@ -27,6 +30,7 @@ struct InternalData2
GLXContext m_glc; GLXContext m_glc;
XWindowAttributes m_gwa; XWindowAttributes m_gwa;
XEvent m_xev; XEvent m_xev;
GLXFBConfig m_bestFbc;
b3WheelCallback m_wheelCallback; b3WheelCallback m_wheelCallback;
b3MouseMoveCallback m_mouseMoveCallback; b3MouseMoveCallback m_mouseMoveCallback;
@@ -47,6 +51,49 @@ struct InternalData2
} }
}; };
#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
// Helper to check for extension string presence. Adapted from:
// http://www.opengl.org/resources/features/OGLextensions/
static bool isExtensionSupported(const char *extList, const char *extension)
{
const char *start;
const char *where, *terminator;
/* Extension names should not have spaces. */
where = strchr(extension, ' ');
if (where || *extension == '\0')
return false;
/* It takes a bit of care to be fool-proof about parsing the
OpenGL extensions string. Don't be fooled by sub-strings,
etc. */
for (start=extList;;) {
where = strstr(start, extension);
if (!where)
break;
terminator = where + strlen(extension);
if ( where == start || *(where - 1) == ' ' )
if ( *terminator == ' ' || *terminator == '\0' )
return true;
start = terminator;
}
return false;
}
static bool ctxErrorOccurred = false;
static int ctxErrorHandler( Display *dpy, XErrorEvent *ev )
{
ctxErrorOccurred = true;
return 0;
}
@@ -73,9 +120,117 @@ X11OpenGLWindow::~X11OpenGLWindow()
void X11OpenGLWindow::enableOpenGL() void X11OpenGLWindow::enableOpenGL()
{ {
m_data->m_glc = glXCreateContext(m_data->m_dpy, m_data->m_vi, NULL, GL_TRUE); if (forceOpenGL3)
glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc); {
// Get the default screen's GLX extension list
const char *glxExts = glXQueryExtensionsString( m_data->m_dpy,
DefaultScreen( m_data->m_dpy ) );
// NOTE: It is not necessary to create or make current to a context before
// calling glXGetProcAddressARB
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)
glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
GLXContext ctx = 0;
// Install an X error handler so the application won't exit if GL 3.0
// context allocation fails.
//
// Note this error handler is global. All display connections in all threads
// of a process use the same error handler, so be sure to guard against other
// threads issuing X commands while this code is running.
ctxErrorOccurred = false;
int (*oldHandler)(Display*, XErrorEvent*) =
XSetErrorHandler(&ctxErrorHandler);
// Check for the GLX_ARB_create_context extension string and the function.
// If either is not present, use GLX 1.3 context creation method.
if ( !isExtensionSupported( glxExts, "GLX_ARB_create_context" ) ||
!glXCreateContextAttribsARB )
{
printf( "glXCreateContextAttribsARB() not found"
" ... using old-style GLX context\n" );
ctx = glXCreateNewContext( m_data->m_dpy, m_data->m_bestFbc, GLX_RGBA_TYPE, 0, True );
}
// If it does, try to get a GL 3.0 context!
else
{
int context_attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB ,3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_DEBUG_BIT_ARB,
GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,None
};
/*
int context_attribs[] =
{
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 2,
//GLX_CONTEXT_FLAGS_ARB , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
None
};
*/
printf( "Creating context\n" );
ctx = glXCreateContextAttribsARB( m_data->m_dpy, m_data->m_bestFbc, 0,
True, context_attribs );
// Sync to ensure any errors generated are processed.
XSync( m_data->m_dpy, False );
if ( !ctxErrorOccurred && ctx )
printf( "Created GL 3.0 context\n" );
else
{
// Couldn't create GL 3.0 context. Fall back to old-style 2.x context.
// When a context version below 3.0 is requested, implementations will
// return the newest context version compatible with OpenGL versions less
// than version 3.0.
// GLX_CONTEXT_MAJOR_VERSION_ARB = 1
context_attribs[1] = 1;
// GLX_CONTEXT_MINOR_VERSION_ARB = 0
context_attribs[3] = 0;
ctxErrorOccurred = false;
printf( "Failed to create GL 3.0 context"
" ... using old-style GLX context\n" );
ctx = glXCreateContextAttribsARB( m_data->m_dpy, m_data->m_bestFbc, 0,
True, context_attribs );
}
}
// Sync to ensure any errors generated are processed.
XSync( m_data->m_dpy, False );
// Restore the original error handler
XSetErrorHandler( oldHandler );
if ( ctxErrorOccurred || !ctx )
{
printf( "Failed to create an OpenGL context\n" );
exit(1);
}
// Verifying that context is a direct context
if ( ! glXIsDirect ( m_data->m_dpy, ctx ) )
{
printf( "Indirect GLX rendering context obtained\n" );
}
else
{
printf( "Direct GLX rendering context obtained\n" );
}
printf( "Making context current\n" );
glXMakeCurrent( m_data->m_dpy, m_data->m_win, ctx );
} else
{
m_data->m_glc = glXCreateContext(m_data->m_dpy, m_data->m_vi, NULL, GL_TRUE);
glXMakeCurrent(m_data->m_dpy, m_data->m_win, m_data->m_glc);
}
const GLubyte* ven = glGetString(GL_VENDOR); const GLubyte* ven = glGetString(GL_VENDOR);
printf("GL_VENDOR=%s\n", ven); printf("GL_VENDOR=%s\n", ven);
const GLubyte* ren = glGetString(GL_RENDERER); const GLubyte* ren = glGetString(GL_RENDERER);
@@ -104,6 +259,7 @@ void X11OpenGLWindow::disableOpenGL()
void X11OpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci) void X11OpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci)
{ {
printf("createWindow\n");
m_data->m_dpy = XOpenDisplay(NULL); m_data->m_dpy = XOpenDisplay(NULL);
if(m_data->m_dpy == NULL) { if(m_data->m_dpy == NULL) {
@@ -111,29 +267,123 @@ void X11OpenGLWindow::createWindow(const b3gWindowConstructionInfo& ci)
exit(0); exit(0);
} }
m_data->m_root = DefaultRootWindow(m_data->m_dpy); m_data->m_root = DefaultRootWindow(m_data->m_dpy);
m_data->m_vi = glXChooseVisual(m_data->m_dpy, 0, att);
if(m_data->m_vi == NULL) {
printf("\n\tno appropriate visual found\n\n"); if (forceOpenGL3)
{
int glxMinor, glxMajor;
if (!glXQueryVersion(m_data->m_dpy,&glxMajor,&glxMinor) || (((glxMajor==1)&&(glxMinor<3)) || (glxMajor<1)))
{
printf("Invalid GLX version: major %d, minor %d\n",glxMajor,glxMinor);
exit(0); exit(0);
} }
else {
printf("\n\tvisual %p selected\n", (void *)m_data->m_vi->visualid); /* %p creates hexadecimal output like in glxinfo */ static int visual_attribs[] =
} {
GLX_X_RENDERABLE , True,
GLX_DRAWABLE_TYPE , GLX_WINDOW_BIT,
GLX_RENDER_TYPE , GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE , GLX_TRUE_COLOR,
GLX_RED_SIZE , 8,
GLX_GREEN_SIZE , 8,
GLX_BLUE_SIZE , 8,
GLX_ALPHA_SIZE , 8,
GLX_DEPTH_SIZE , 24,
GLX_STENCIL_SIZE , 8,
GLX_DOUBLEBUFFER , True,
None
};
int fbcount;
GLXFBConfig* fbc = glXChooseFBConfig(m_data->m_dpy, DefaultScreen(m_data->m_dpy), visual_attribs, &fbcount);
if (!fbc)
{
printf( "Failed to retrieve a framebuffer config\n" );
exit(1);
}
int best_fbc = -1, worst_fbc = -1, best_num_samp = -1, worst_num_samp = 999;
int i;
for (i=0; i<fbcount; ++i)
{
XVisualInfo *vi = glXGetVisualFromFBConfig( m_data->m_dpy, fbc[i] );
if ( vi )
{
int samp_buf, samples;
glXGetFBConfigAttrib( m_data->m_dpy, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf );
glXGetFBConfigAttrib( m_data->m_dpy, fbc[i], GLX_SAMPLES , &samples );
//printf( " Matching fbconfig %d, visual ID 0x%2x: SAMPLE_BUFFERS = %d,"
// " SAMPLES = %d\n",
// i, vi -> visualid, samp_buf, samples );
if ( best_fbc < 0 || samp_buf && samples > best_num_samp )
best_fbc = i, best_num_samp = samples;
if ( worst_fbc < 0 || !samp_buf || samples < worst_num_samp )
worst_fbc = i, worst_num_samp = samples;
}
XFree( vi );
}
m_data->m_bestFbc = fbc[ best_fbc ];
// Be sure to free the FBConfig list allocated by glXChooseFBConfig()
XFree( fbc );
m_data->m_vi = glXGetVisualFromFBConfig( m_data->m_dpy, m_data->m_bestFbc );
m_data->m_cmap = XCreateColormap(m_data->m_dpy, m_data->m_root, m_data->m_vi->visual, AllocNone); m_data->m_swa.colormap = m_data->m_cmap = XCreateColormap( m_data->m_dpy,
RootWindow( m_data->m_dpy, m_data->m_vi->screen ),
m_data->m_vi->visual, AllocNone );
m_data->m_swa.background_pixmap = None ;
m_data->m_swa.border_pixel = 0;
m_data->m_swa.event_mask = ExposureMask | KeyReleaseMask | KeyPressMask |ButtonPressMask | ButtonReleaseMask |PointerMotionMask|StructureNotifyMask;
;
m_data->m_root = RootWindow( m_data->m_dpy, m_data->m_vi->screen );
m_data->m_swa.colormap = m_data->m_cmap; m_data->m_win = XCreateWindow( m_data->m_dpy, m_data->m_root,
m_data->m_swa.event_mask = ExposureMask | KeyReleaseMask | KeyPressMask |ButtonPressMask | ButtonReleaseMask |PointerMotionMask|StructureNotifyMask; 0, 0, ci.m_width, ci.m_height, 0, m_data->m_vi->depth, InputOutput,
m_data->m_vi->visual,
CWBorderPixel|CWColormap|CWEventMask, &m_data->m_swa );
m_data->m_win = XCreateWindow(m_data->m_dpy, m_data->m_root, 0, 0, ci.m_width, ci.m_height, 0, m_data->m_vi->depth, InputOutput, m_data->m_vi->visual, CWColormap | CWEventMask, &m_data->m_swa); //m_data->m_win = XCreateWindow(m_data->m_dpy, m_data->m_root, 0, 0, ci.m_width, ci.m_height, 0, m_data->m_vi->depth, InputOutput, m_data->m_vi->visual, CWColormap | CWEventMask, &m_data->m_swa);
XMapWindow(m_data->m_dpy, m_data->m_win);
XStoreName(m_data->m_dpy, m_data->m_win, "VERY SIMPLE APPLICATION");
if (!m_data->m_win)
{
printf("Cannot create window\n");
exit(0);
}
XMapWindow(m_data->m_dpy, m_data->m_win);
XStoreName(m_data->m_dpy, m_data->m_win, "OpenGL3 Window");
} else
{
m_data->m_vi = glXChooseVisual(m_data->m_dpy, 0, att);
if(m_data->m_vi == NULL) {
printf("\n\tno appropriate visual found\n\n");
exit(0);
}
else {
printf("\n\tvisual %p selected\n", (void *)m_data->m_vi->visualid); /* %p creates hexadecimal output like in glxinfo */
}
m_data->m_cmap = XCreateColormap(m_data->m_dpy, m_data->m_root, m_data->m_vi->visual, AllocNone);
m_data->m_swa.colormap = m_data->m_cmap;
m_data->m_swa.event_mask = ExposureMask | KeyReleaseMask | KeyPressMask |ButtonPressMask | ButtonReleaseMask |PointerMotionMask|StructureNotifyMask;
m_data->m_win = XCreateWindow(m_data->m_dpy, m_data->m_root, 0, 0, ci.m_width, ci.m_height, 0, m_data->m_vi->depth, InputOutput, m_data->m_vi->visual, CWColormap | CWEventMask, &m_data->m_swa);
XMapWindow(m_data->m_dpy, m_data->m_win);
XStoreName(m_data->m_dpy, m_data->m_win, "OpenGL3 Window");
}
enableOpenGL(); enableOpenGL();
} }
@@ -153,13 +403,19 @@ int X11OpenGLWindow::getAsciiCodeFromVirtualKeycode(int keycode)
switch( key ) switch( key )
{ {
case XK_Escape: return B3G_ESCAPE; case XK_Escape: return B3G_ESCAPE;
case XK_Return: return B3G_RETURN;
case XK_Control_L: case XK_Control_L:
case XK_Control_R: { case XK_Control_R: {
return B3G_CONTROL; return B3G_CONTROL;
} }
case XK_Alt_L: case XK_Left: return B3G_LEFT_ARROW;
case XK_Alt_R: case XK_Right: return B3G_RIGHT_ARROW;
case XK_Up: return B3G_UP_ARROW;
case XK_Down: return B3G_DOWN_ARROW;
case XK_Alt_L:
case XK_Alt_R:
{ {
return B3G_ALT; return B3G_ALT;
} }