OilfieldToolsNet/ResInsight
4
0 Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2026-10-25 06:38:13 -05:00
Code Issues Packages Projects Releases Wiki Activity

#11371 Remove GLEW dependency and use Qt's QOpenGLFunctions (#13631)

Browse Source 
* #11371 Remove GLEW dependency and use Qt's QOpenGLFunctions

Replace embedded GLEW library with Qt's native OpenGL function loading
(QOpenGLFunctions/QOpenGLExtraFunctions) to resolve Qt 6 compatibility
warnings about GLEW conflicts with qopenglfunctions.h.

- Update CVF_CALLSITE_OPENGL macro to provide QOpenGLExtraFunctions pointer
- Replace GLEW initialization with Qt OpenGL context validation
- Keep direct calls for fixed-function GL (glBegin, glEnd, glMatrixMode, etc.)
- Remove glew/ directory containing embedded GLEW source

* #11371 Remove GLU dependency to fix Windows build error

GL/glu.h conflicts with Qt's OpenGL headers on Windows due to APIENTRY
redefinition. Replace gluBuild2DMipmaps with glTexImage2D + glGenerateMipmap,
and gluOrtho2D with glOrtho.
This commit is contained in:
Kristian Bendiksen authored and GitHub committed 2026-04-09 10:34:15 +02:00
1 parent 68b193cd56
commit 7897e41c63
50 files changed
+605 -34657
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

ApplicationLibCode/ModelVisualization/WindowEdgeAxesOverlayItem/RivWindowEdgeAxesOverlayItem.cpp
+12 -12
View File
@@ -540,9 +540,9 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
// Frame vertices
std::array<Vec3f, 8> vertexArray = frameVertexArray();
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glEnableVertexAttribArray( ShaderProgram::VERTEX );
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray.data() );
cvfGL->glBindBuffer( GL_ARRAY_BUFFER, 0 );
cvfGL->glEnableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray.data() );
// Draw frame background
@@ -553,7 +553,7 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
static const ushort backgroundTriangleIndices[] = { 0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 3, 0, 4, 3, 4, 7, 2, 3, 6, 3, 7, 6 };
glDrawRangeElements( GL_TRIANGLES, 0, 7, 24, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
cvfGL->glDrawRangeElements( GL_TRIANGLES, 0, 7, 24, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
// Draw frame border lines
@@ -562,7 +562,7 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
static const ushort frameLineIndices[] = { 7, 4, 4, 5, 5, 6, 6, 7 };
glDrawRangeElements( GL_LINES, 0, 7, 8, GL_UNSIGNED_SHORT, frameLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 7, 8, GL_UNSIGNED_SHORT, frameLineIndices );
// Render tickmarks
@@ -579,7 +579,7 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
vertexArray[1][0] = (float)txpos;
vertexArray[1][1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
}
else
{
@@ -588,14 +588,14 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
vertexArray[1][0] = (float)txpos;
vertexArray[1][1] = m_frameBorderHeight - m_tickLineLength;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
vertexArray[0][0] = (float)txpos;
vertexArray[0][1] = m_windowSize.y() - m_frameBorderHeight;
vertexArray[1][0] = (float)txpos;
vertexArray[1][1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
}
}
@@ -609,7 +609,7 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
vertexArray[0][1] = (float)typos;
vertexArray[1][0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
vertexArray[1][1] = (float)typos;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
}
else
{
@@ -618,18 +618,18 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
vertexArray[1][0] = m_frameBorderWidth - m_tickLineLength;
vertexArray[1][1] = (float)typos;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
vertexArray[0][0] = m_windowSize.x() - m_frameBorderWidth;
vertexArray[0][1] = (float)typos;
vertexArray[1][0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
vertexArray[1][1] = (float)typos;
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
}
}
glDisableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glDisableVertexAttribArray( ShaderProgram::VERTEX );
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
cvf::ShaderProgram::useNoProgram( oglContext );
Fwk/AppFwk/cafVizExtensions/cafCategoryLegend.cpp
+8 -8
View File
@@ -280,9 +280,9 @@ void CategoryLegend::renderLegendUsingShaders( OpenGLContext* ogl
shaderProgram->applyFixedUniforms( oglContext, matrixState );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glEnableVertexAttribArray( ShaderProgram::VERTEX );
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
cvfGL->glBindBuffer( GL_ARRAY_BUFFER, 0 );
cvfGL->glEnableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
// Render color bar as one colored quad per pixel
@@ -308,9 +308,9 @@ void CategoryLegend::renderLegendUsingShaders( OpenGLContext* ogl
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, trianglesConnects );
cvfGL->glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, trianglesConnects );
#else
glDrawRangeElements( GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects );
cvfGL->glDrawRangeElements( GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects );
#endif
}
}
@@ -332,13 +332,13 @@ void CategoryLegend::renderLegendUsingShaders( OpenGLContext* ogl
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_LINES, 8, GL_UNSIGNED_SHORT, frameConnects );
cvfGL->glDrawElements( GL_LINES, 8, GL_UNSIGNED_SHORT, frameConnects );
#else
glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects );
cvfGL->glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects );
#endif
}
glDisableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glDisableVertexAttribArray( ShaderProgram::VERTEX );
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
shaderProgram->useNoProgram( oglContext );
Fwk/AppFwk/cafVizExtensions/cafInternalLegendRenderTools.cpp
+6 -6
View File
@@ -89,9 +89,9 @@ void InternalLegendRenderTools::renderBackgroundUsingShaders( OpenGLContext*
Vec3f( 1, size.y(), 0.0f ),
};
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glEnableVertexAttribArray( ShaderProgram::VERTEX );
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray.data() );
cvfGL->glBindBuffer( GL_ARRAY_BUFFER, 0 );
cvfGL->glEnableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray.data() );
// Draw frame background
@@ -102,7 +102,7 @@ void InternalLegendRenderTools::renderBackgroundUsingShaders( OpenGLContext*
static const ushort backgroundTriangleIndices[] = { 0, 1, 2, 2, 3, 0 };
glDrawRangeElements( GL_TRIANGLES, 0, 3, 6, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
cvfGL->glDrawRangeElements( GL_TRIANGLES, 0, 3, 6, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
// Draw frame border lines
@@ -111,9 +111,9 @@ void InternalLegendRenderTools::renderBackgroundUsingShaders( OpenGLContext*
static const ushort frameLineIndices[] = { 0, 1, 1, 2, 2, 3, 3, 0 };
glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameLineIndices );
cvfGL->glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameLineIndices );
glDisableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glDisableVertexAttribArray( ShaderProgram::VERTEX );
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
shaderProgram->useNoProgram( oglContext );
Fwk/AppFwk/cafVizExtensions/cafOverlayScalarMapperLegend.cpp
+10 -10
View File
@@ -341,9 +341,9 @@ void OverlayScalarMapperLegend::renderLegendUsingShaders( OpenGLContext*
shaderProgram->applyFixedUniforms( oglContext, matrixState );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glEnableVertexAttribArray( ShaderProgram::VERTEX );
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
cvfGL->glBindBuffer( GL_ARRAY_BUFFER, 0 );
cvfGL->glEnableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
// Render color bar as one colored quad per pixel
@@ -369,9 +369,9 @@ void OverlayScalarMapperLegend::renderLegendUsingShaders( OpenGLContext*
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, trianglesConnects );
cvfGL->glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, trianglesConnects );
#else
glDrawRangeElements( GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects );
cvfGL->glDrawRangeElements( GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects );
#endif
}
}
@@ -393,9 +393,9 @@ void OverlayScalarMapperLegend::renderLegendUsingShaders( OpenGLContext*
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_LINES, 8, GL_UNSIGNED_SHORT, frameConnects );
cvfGL->glDrawElements( GL_LINES, 8, GL_UNSIGNED_SHORT, frameConnects );
#else
glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects );
cvfGL->glDrawRangeElements( GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects );
#endif
}
@@ -436,14 +436,14 @@ void OverlayScalarMapperLegend::renderLegendUsingShaders( OpenGLContext*
}
#ifdef CVF_OPENGL_ES
glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, linesConnects );
cvfGL->glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, linesConnects );
#else
glDrawRangeElements( GL_LINES, 0, 4, 2, GL_UNSIGNED_SHORT, linesConnects );
cvfGL->glDrawRangeElements( GL_LINES, 0, 4, 2, GL_UNSIGNED_SHORT, linesConnects );
#endif
}
}
glDisableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glDisableVertexAttribArray( ShaderProgram::VERTEX );
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
shaderProgram->useNoProgram( oglContext );
Fwk/AppFwk/cafVizExtensions/cafOverlayScaleLegend.cpp
+8 -8
View File
@@ -351,9 +351,9 @@ void OverlayScaleLegend::renderLegendUsingShaders( OpenGLContext* oglContext, La
shaderProgram->applyFixedUniforms( oglContext, matrixState );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glEnableVertexAttribArray( ShaderProgram::VERTEX );
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
cvfGL->glBindBuffer( GL_ARRAY_BUFFER, 0 );
cvfGL->glEnableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray );
// Draw axis
{
@@ -377,9 +377,9 @@ void OverlayScaleLegend::renderLegendUsingShaders( OpenGLContext* oglContext, La
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, axisConnects );
cvfGL->glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, axisConnects );
#else
glDrawRangeElements( GL_LINES, 0, 3, 2, GL_UNSIGNED_SHORT, axisConnects );
cvfGL->glDrawRangeElements( GL_LINES, 0, 3, 2, GL_UNSIGNED_SHORT, axisConnects );
#endif
}
@@ -409,13 +409,13 @@ void OverlayScaleLegend::renderLegendUsingShaders( OpenGLContext* oglContext, La
shaderProgram->applyUniform( oglContext, uniformColor );
#ifdef CVF_OPENGL_ES
glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, axisConnects );
cvfGL->glDrawElements( GL_LINES, 2, GL_UNSIGNED_SHORT, axisConnects );
#else
glDrawRangeElements( GL_LINES, 0, 3, 2, GL_UNSIGNED_SHORT, tickConnects );
cvfGL->glDrawRangeElements( GL_LINES, 0, 3, 2, GL_UNSIGNED_SHORT, tickConnects );
#endif
}
glDisableVertexAttribArray( ShaderProgram::VERTEX );
cvfGL->glDisableVertexAttribArray( ShaderProgram::VERTEX );
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
shaderProgram->useNoProgram( oglContext );
Fwk/VizFwk/LibRender/CMakeLists.txt
+3 -7
View File
@@ -15,13 +15,6 @@ if (CMAKE_COMPILER_IS_GNUCXX)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas -Wno-deprecated -Wno-deprecated-declarations")
endif()
# For now, remove pedantic flag for OSX since it clashes with glew
if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
string(REPLACE "-pedantic" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
endif()
include_directories(glew)
set(CEE_HEADER_FILES
@@ -190,9 +183,12 @@ target_include_directories(${PROJECT_NAME}
${CMAKE_CURRENT_SOURCE_DIR}
)
find_package(Qt6 REQUIRED COMPONENTS OpenGL)
target_link_libraries ( ${PROJECT_NAME}
LibCore
LibGeometry
Qt6::OpenGL
)
set(PROJECT_FILES ${CEE_HEADER_FILES} ${CEE_SOURCE_FILES})
Fwk/VizFwk/LibRender/cvfBufferObjectManaged.cpp
+12 -12
View File
@@ -86,27 +86,27 @@ ref<BufferObjectManaged> BufferObjectManaged::create(OpenGLContext* oglContext,
CVF_CALLSITE_OPENGL(oglContext);
OglId id = 0;
glGenBuffers(1, &id);
cvfGL->glGenBuffers(1, &id);
if (id == 0)
{
return NULL;
}
glBindBuffer(target, id);
cvfGL->glBindBuffer(target, id);
// Allocate memory for buffer object AND copy data into it
// Currently we always use the GL_STATIC_DRAW usage hint for our buffers!
glBufferData(target, static_cast<GLsizeiptr>(sizeInBytes), data, GL_STATIC_DRAW);
cvfGL->glBufferData(target, static_cast<GLsizeiptr>(sizeInBytes), data, GL_STATIC_DRAW);
// Do we want to unbind after each call?
glBindBuffer(target, 0);
cvfGL->glBindBuffer(target, 0);
// Should we always do a check here?
// Should we always do a check here?
// Only way to detect out-of-memory issues, but not very performance friendly. Is there a better way of detecting errors for this case?
cvfGLenum err = glGetError();
cvfGLenum err = cvfGL->glGetError();
if (err != GL_NO_ERROR)
{
glDeleteBuffers(1, &id);
cvfGL->glDeleteBuffers(1, &id);
return NULL;
}
@@ -143,7 +143,7 @@ bool BufferObjectManaged::bindBuffer(OpenGLContext* oglContext) const
if (m_bufferId != 0)
{
glBindBuffer(m_target, m_bufferId);
cvfGL->glBindBuffer(m_target, m_bufferId);
// We can probably skip OpenGL error checking here.
// The only errors resulting from glBindBuffer relate to illegal use of target and calling between glBegin()/glEnd()
@@ -161,7 +161,7 @@ bool BufferObjectManaged::bindBuffer(OpenGLContext* oglContext) const
void BufferObjectManaged::unbindBuffer(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
glBindBuffer(m_target, 0);
cvfGL->glBindBuffer(m_target, 0);
}
@@ -171,8 +171,8 @@ void BufferObjectManaged::unbindBuffer(OpenGLContext* oglContext) const
void BufferObjectManaged::unbindAllBuffers(OpenGLContext* oglContext)
{
CVF_CALLSITE_OPENGL(oglContext);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
@@ -194,7 +194,7 @@ void BufferObjectManaged::deleteBuffer(OpenGLContext* oglContext)
if (m_bufferId != 0)
{
glDeleteBuffers(1, &m_bufferId);
cvfGL->glDeleteBuffers(1, &m_bufferId);
m_bufferId = 0;
}
Fwk/VizFwk/LibRender/cvfDrawableText.cpp
+6 -5
View File
@@ -443,10 +443,11 @@ bool DrawableText::labelAnchorVisible(OpenGLContext* oglContext, const Vec3d win
// Read out current z buffer contents
GLubyte bufferBefore[9*4];
glReadPixels(coord.x() - 1, coord.y() - 1, 3, 3, GL_RGBA, GL_UNSIGNED_BYTE, bufferBefore);
cvfGL->glReadPixels(coord.x() - 1, coord.y() - 1, 3, 3, GL_RGBA, GL_UNSIGNED_BYTE, bufferBefore);
if (softwareRendering)
{
// Fixed-function calls - use direct OpenGL calls (not through cvfGL)
glPointSize(3);
glColor3f(0.02f, 0.02f, 0.02f);
glBegin(GL_POINTS);
@@ -455,15 +456,15 @@ bool DrawableText::labelAnchorVisible(OpenGLContext* oglContext, const Vec3d win
}
else
{
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, worldCoord.ptr());
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, worldCoord.ptr());
glDrawArrays(GL_POINTS, 0, 1);
cvfGL->glDrawArrays(GL_POINTS, 0, 1);
}
// Now compare with previous z buffer contents to see if marker is visible
GLubyte bufferAfter[9*4];
glReadPixels(coord.x() - 1, coord.y() - 1, 3, 3, GL_RGBA, GL_UNSIGNED_BYTE, bufferAfter);
cvfGL->glReadPixels(coord.x() - 1, coord.y() - 1, 3, 3, GL_RGBA, GL_UNSIGNED_BYTE, bufferAfter);
size_t j;
for (j = 0; j < 9*4; j++)
Fwk/VizFwk/LibRender/cvfDrawableVectors.cpp
+20 -18
View File
@@ -190,22 +190,22 @@ void DrawableVectors::render(OpenGLContext* oglContext, ShaderProgram* shaderPro
// Bind VBO for vertex and normal data
m_glyphVerticesAndNormalsBO->bindBuffer(oglContext);
glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, (void*)(sizeof(float)*3));
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, 0);
glEnableVertexAttribArray(ShaderProgram::NORMAL);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, (void*)(sizeof(float)*3));
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, sizeof(float)*6, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::NORMAL);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
m_indicesBO->bindBuffer(oglContext);
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, m_vectorGlyph->normalArray()->ptr()->ptr());
glEnableVertexAttribArray(ShaderProgram::NORMAL);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, m_vectorGlyph->vertexArray()->ptr()->ptr());
glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, m_vectorGlyph->normalArray()->ptr()->ptr());
cvfGL->glEnableVertexAttribArray(ShaderProgram::NORMAL);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, m_vectorGlyph->vertexArray()->ptr()->ptr());
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
ptrOrOffset = m_vectorGlyphPrimSet->indices()->ptr();
}
@@ -224,7 +224,7 @@ void DrawableVectors::render(OpenGLContext* oglContext, ShaderProgram* shaderPro
// Set the single color to use
if (m_colorArray.isNull())
{
glUniform3fv(colorUniformLocation, 1, m_singleColor.ptr());
cvfGL->glUniform3fv(colorUniformLocation, 1, m_singleColor.ptr());
}
float vectorMat[16];
@@ -236,20 +236,20 @@ void DrawableVectors::render(OpenGLContext* oglContext, ShaderProgram* shaderPro
vectorMatrix(i, vectorMat);
// Set this as a uniform to the shader program
glUniformMatrix4fv(vectorMatrixUniformLocation, 1, GL_FALSE, vectorMat);
cvfGL->glUniformMatrix4fv(vectorMatrixUniformLocation, 1, GL_FALSE, vectorMat);
if (m_colorArray.notNull())
{
glUniform3fv(colorUniformLocation, 1, m_colorArray->get(i).ptr());
cvfGL->glUniform3fv(colorUniformLocation, 1, m_colorArray->get(i).ptr());
}
// Draw the arrow
glDrawRangeElements(GL_TRIANGLES, minIndex, maxIndex, indexCount, GL_UNSIGNED_SHORT, ptrOrOffset);
cvfGL->glDrawRangeElements(GL_TRIANGLES, minIndex, maxIndex, indexCount, GL_UNSIGNED_SHORT, ptrOrOffset);
}
// Cleanup
glDisableVertexAttribArray(ShaderProgram::VERTEX);
glDisableVertexAttribArray(ShaderProgram::NORMAL);
cvfGL->glDisableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glDisableVertexAttribArray(ShaderProgram::NORMAL);
CVF_CHECK_OGL(oglContext);
@@ -269,10 +269,11 @@ void DrawableVectors::render(OpenGLContext* oglContext, ShaderProgram* shaderPro
//--------------------------------------------------------------------------------------------------
void DrawableVectors::renderFixedFunction(OpenGLContext* oglContext, const MatrixState& matrixState)
{
CVF_ASSERT(oglContext);
CVF_UNUSED(oglContext);
CVF_ASSERT(m_vertexArray->size() == m_vectorArray->size());
CVF_ASSERT(m_vectorGlyph.notNull());
// Fixed-function calls - use direct OpenGL calls (not through cvfGL)
glEnable(GL_NORMALIZE);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
@@ -315,10 +316,11 @@ void DrawableVectors::renderFixedFunction(OpenGLContext* oglContext, const Matri
//--------------------------------------------------------------------------------------------------
void DrawableVectors::renderImmediateMode(OpenGLContext* oglContext, const MatrixState& matrixState)
{
CVF_ASSERT(oglContext);
CVF_UNUSED(oglContext);
CVF_ASSERT(m_vertexArray->size() == m_vectorArray->size());
CVF_ASSERT(m_vectorGlyph.notNull());
// Fixed-function calls - use direct OpenGL calls (not through cvfGL)
glEnable(GL_NORMALIZE);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
Fwk/VizFwk/LibRender/cvfFramebufferObject.cpp
+16 -14
View File
@@ -271,7 +271,7 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
}
}
glFramebufferRenderbuffer(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_RENDERBUFFER, renderBuffer->renderbufferOglId());
cvfGL->glFramebufferRenderbuffer(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_RENDERBUFFER, renderBuffer->renderbufferOglId());
setColorBufferVersionTick(i, renderBuffer->versionTick());
attachmentsModified = true;
@@ -302,17 +302,17 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
if (faceIt != m_colorCubeMapFaces.end())
{
glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIt->second), texture->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIt->second), texture->textureOglId(), 0);
}
else
{
if (texture->textureType() == Texture::TEXTURE_RECTANGLE)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_TEXTURE_RECTANGLE, texture->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_TEXTURE_RECTANGLE, texture->textureOglId(), 0);
}
else
{
glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_TEXTURE_2D, texture->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i), GL_TEXTURE_2D, texture->textureOglId(), 0);
}
}
@@ -355,12 +355,13 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
}
}
glDrawBuffers(static_cast<GLsizei>(maxAttachmentIndex), drawBuffers);
cvfGL->glDrawBuffers(static_cast<GLsizei>(maxAttachmentIndex), drawBuffers);
delete[] drawBuffers;
}
else
{
// glDrawBuffer is not in QOpenGLFunctions, use direct call
glDrawBuffer(GL_NONE);
}
}
@@ -380,7 +381,7 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
}
}
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthRenderBuffer->renderbufferOglId());
cvfGL->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthRenderBuffer->renderbufferOglId());
m_depthAttachmentVersionTick = m_depthRenderBuffer->versionTick();
}
@@ -400,11 +401,11 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
if (m_depthTexture2d->textureType() == Texture::TEXTURE_2D)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthTexture2d->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthTexture2d->textureOglId(), 0);
}
else if (m_depthTexture2d->textureType() == Texture::TEXTURE_RECTANGLE)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE, m_depthTexture2d->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE, m_depthTexture2d->textureOglId(), 0);
}
else
{
@@ -427,7 +428,7 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
}
}
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderBuffer->renderbufferOglId());
cvfGL->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderBuffer->renderbufferOglId());
m_depthAttachmentVersionTick = m_depthStencilRenderBuffer->versionTick();
}
@@ -447,11 +448,11 @@ void FramebufferObject::applyOpenGL(OpenGLContext* oglContext)
if (m_depthStencilTexture2d->textureType() == Texture::TEXTURE_2D)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_depthStencilTexture2d->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_depthStencilTexture2d->textureOglId(), 0);
}
else if (m_depthStencilTexture2d->textureType() == Texture::TEXTURE_RECTANGLE)
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_RECTANGLE, m_depthStencilTexture2d->textureOglId(), 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_RECTANGLE, m_depthStencilTexture2d->textureOglId(), 0);
}
else
{
@@ -474,7 +475,7 @@ void FramebufferObject::bind(OpenGLContext* oglContext) const
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcBuffer.p()) != 0);
glBindFramebuffer(GL_FRAMEBUFFER, m_oglRcBuffer->oglId());
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_oglRcBuffer->oglId());
}
@@ -486,10 +487,11 @@ void FramebufferObject::useDefaultWindowFramebuffer(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
const OglId defaultFBO = oglContext->defaultFramebufferObject();
glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
if (defaultFBO == 0)
{
// glDrawBuffer is not in QOpenGLFunctions, use direct call
glDrawBuffer(GL_BACK);
}
@@ -584,7 +586,7 @@ bool FramebufferObject::isFramebufferComplete(OpenGLContext* oglContext, String*
CVF_CALLSITE_OPENGL(oglContext);
bind(oglContext);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
GLenum status = cvfGL->glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
Fwk/VizFwk/LibRender/cvfOglRc.cpp
+16 -12
View File
@@ -137,7 +137,7 @@ ref<OglRcShader> OglRcShader::create(OpenGLContext* oglContext, cvfGLenum shader
CVF_CALLSITE_OPENGL(oglContext);
ref<OglRcShader> rcObj = new OglRcShader;
rcObj->m_openGLObjId = glCreateShader(shaderType);
rcObj->m_openGLObjId = cvfGL->glCreateShader(shaderType);
if (rcObj->m_openGLObjId != 0)
{
return rcObj;
@@ -156,7 +156,7 @@ void OglRcShader::deleteResource(OpenGLContext* oglContext)
if (m_openGLObjId != 0)
{
glDeleteShader(m_openGLObjId);
cvfGL->glDeleteShader(m_openGLObjId);
m_openGLObjId = 0;
}
}
@@ -180,7 +180,7 @@ ref<OglRcProgram> OglRcProgram::create(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
ref<OglRcProgram> rcObj = new OglRcProgram;
rcObj->m_openGLObjId = glCreateProgram();
rcObj->m_openGLObjId = cvfGL->glCreateProgram();
if (rcObj->m_openGLObjId != 0)
{
return rcObj;
@@ -199,7 +199,7 @@ void OglRcProgram::deleteResource(OpenGLContext* oglContext)
if (m_openGLObjId != 0)
{
glDeleteProgram(m_openGLObjId);
cvfGL->glDeleteProgram(m_openGLObjId);
m_openGLObjId = 0;
}
}
@@ -218,10 +218,12 @@ void OglRcProgram::deleteResource(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
ref<OglRcTexture> OglRcTexture::create(OpenGLContext* /*oglContext*/)
ref<OglRcTexture> OglRcTexture::create(OpenGLContext* oglContext)
{
CVF_CALLSITE_OPENGL(oglContext);
ref<OglRcTexture> rcObj = new OglRcTexture;
glGenTextures(1, &rcObj->m_openGLObjId);
cvfGL->glGenTextures(1, &rcObj->m_openGLObjId);
if (rcObj->m_openGLObjId != 0)
{
return rcObj;
@@ -234,11 +236,13 @@ ref<OglRcTexture> OglRcTexture::create(OpenGLContext* /*oglContext*/)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OglRcTexture::deleteResource(OpenGLContext* /*oglContext*/)
void OglRcTexture::deleteResource(OpenGLContext* oglContext)
{
CVF_CALLSITE_OPENGL(oglContext);
if (m_openGLObjId != 0)
{
glDeleteTextures(1, &m_openGLObjId);
cvfGL->glDeleteTextures(1, &m_openGLObjId);
m_openGLObjId = 0;
}
}
@@ -262,7 +266,7 @@ ref<OglRcRenderbuffer> OglRcRenderbuffer::create(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
ref<OglRcRenderbuffer> rcObj = new OglRcRenderbuffer;
glGenRenderbuffers(1, &rcObj->m_openGLObjId);
cvfGL->glGenRenderbuffers(1, &rcObj->m_openGLObjId);
if (rcObj->m_openGLObjId != 0)
{
return rcObj;
@@ -281,7 +285,7 @@ void OglRcRenderbuffer::deleteResource(OpenGLContext* oglContext)
if (m_openGLObjId != 0)
{
glDeleteRenderbuffers(1, &m_openGLObjId);
cvfGL->glDeleteRenderbuffers(1, &m_openGLObjId);
m_openGLObjId = 0;
}
}
@@ -305,7 +309,7 @@ ref<OglRcFramebuffer> OglRcFramebuffer::create(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
ref<OglRcFramebuffer> rcObj = new OglRcFramebuffer;
glGenFramebuffers(1, &rcObj->m_openGLObjId);
cvfGL->glGenFramebuffers(1, &rcObj->m_openGLObjId);
if (rcObj->m_openGLObjId != 0)
{
return rcObj;
@@ -324,7 +328,7 @@ void OglRcFramebuffer::deleteResource(OpenGLContext* oglContext)
if (m_openGLObjId != 0)
{
glDeleteFramebuffers(1, &m_openGLObjId);
cvfGL->glDeleteFramebuffers(1, &m_openGLObjId);
m_openGLObjId = 0;
}
}
Fwk/VizFwk/LibRender/cvfOpenGL.cpp
+12 -26
View File
@@ -39,20 +39,6 @@
#include "cvfOpenGL.h"
#include "cvfSystem.h"
// Get rid of warnings from glew
#ifdef WIN32
#pragma warning (disable: 4706 4365 4191 4668)
#endif
CVF_GCC_DIAGNOSTIC_IGNORE("-Wconversion")
#undef glewGetContext
extern "C"
{
#include "glew/glew.c"
}
namespace cvf {
@@ -63,14 +49,14 @@ namespace cvf {
/// \class cvf::OpenGL
/// \ingroup Render
///
/// Static class providing OpenGL wrappers and helpers
///
/// Static class providing OpenGL wrappers and helpers
///
//==================================================================================================
bool OpenGL::m_enableCheckOgl = true;
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool OpenGL::hasOpenGLError(OpenGLContext* oglContext)
{
@@ -98,7 +84,7 @@ bool OpenGL::hasOpenGLError(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void OpenGL::clearOpenGLError(OpenGLContext* oglContext)
{
@@ -108,7 +94,7 @@ void OpenGL::clearOpenGLError(OpenGLContext* oglContext)
CVF_UNUSED(oglContext);
cvfGLenum err = glGetError();
// Empty all error flags
while (err != GL_NO_ERROR)
{
@@ -118,7 +104,7 @@ void OpenGL::clearOpenGLError(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
String OpenGL::mapOpenGLErrorToString(cvfGLenum errorCode)
{
@@ -181,7 +167,7 @@ bool OpenGL::testAndReportOpenGLError(OpenGLContext* oglContext, const char* ope
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void OpenGL::cvf_check_ogl(OpenGLContext* oglContext, const CodeLocation& codeLocation)
{
@@ -210,19 +196,19 @@ void OpenGL::cvf_check_ogl(OpenGLContext* oglContext, const CodeLocation& codeLo
}
}
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void OpenGL::enableCheckOgl(bool enable)
{
m_enableCheckOgl = enable;
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool OpenGL::isCheckOglEnabled()
{
Fwk/VizFwk/LibRender/cvfOpenGL.h
+17 -43
View File
@@ -38,50 +38,25 @@
#pragma once
// Currently we utilize GLEW everywhere
#define CVF_USE_GLEW
#ifdef CVF_USE_GLEW
// Define GLEW_MX for thread safe multi OpenGL context use in GLEW.
// On WIN32 the GLEW_MX define causes GLEW to store both the function pointers and the GLEW
// vars (such as __GLEW_VERSION_1_1 and __GLEW_ARB_draw_buffers) inside GLEWContextStruct.
// On other platforms GLEW stores the function pointers in global variables while the GLEW vars
// are stored inside the GLEWContextStruct.
// We also need to define the glewGetContext() macro - see definition of the CVF_CALLSITE_OPENGL macro above
#define GLEW_MX
#define glewGetContext() (cvfLocGLEWCtxPtr)
// Need to define GLEW_STATIC since we're not using GLEW as a DLL
#define GLEW_STATIC
#include "glew/GL/glew.h"
#endif // CVF_USE_GLEW
// Define macros that must be used wherever we're going to do OpenGL calls (via GLEW)
// Use CVF_CALLSITE_OPENGL when you're going to call OpenGL functions. If you're going
// to query GLEW variables (and possibly do OpenGL calls), use CVF_CALLSITE_GLEW instead
// The reason for having two macros is that most of the time we don't need the pointer
// to the GLEW structure on non-WIN32 platforms since the actual function pointers
// are stored in global variables and only the GLEW vars are stored in the struct.
#define CVF_CALLSITE_GLEW(CURR_OGL_CTX_PTR) \
GLEWContextStruct* cvfLocGLEWCtxPtr = CURR_OGL_CTX_PTR->group()->glewContextStruct()
#ifdef WIN32
#define CVF_CALLSITE_OPENGL(CURR_OGL_CTX_PTR) CVF_CALLSITE_GLEW(CURR_OGL_CTX_PTR)
#else
#define CVF_CALLSITE_OPENGL(CURR_OGL_CTX_PTR) CVF_UNUSED(CURR_OGL_CTX_PTR)
#endif
#include <QOpenGLContext>
#include <QOpenGLFunctions>
#include <QOpenGLExtraFunctions>
// Define macros that must be used wherever we're going to do OpenGL calls
// The macro provides a QOpenGLExtraFunctions pointer named cvfGL that can be used to call OpenGL functions
// Use CVF_CALLSITE_OPENGL when you're going to call OpenGL functions.
#define CVF_CALLSITE_OPENGL(CURR_OGL_CTX_PTR) \
CVF_UNUSED(CURR_OGL_CTX_PTR); \
QOpenGLExtraFunctions* cvfGL = QOpenGLContext::currentContext()->extraFunctions()
// Include standard OpenGL headers for constants and basic types
// Note: Qt's QOpenGLFunctions headers already include the platform GL headers,
// but we include them explicitly for clarity. GLU is not used.
#if defined(WIN32) || defined(CVF_LINUX)
// Windows and Linux includes
#include <GL/gl.h>
#include <GL/glu.h>
#elif defined(CVF_ANDROID)
@@ -99,16 +74,15 @@
// Mac OSX includes
#include "OpenGL/gl.h"
#include "OpenGL/glu.h"
#endif
#endif
#include "cvfOpenGLTypes.h"
#include "cvfString.h"
#include "cvfCodeLocation.h"
// As long as we're using GLEW we will almost always need the context and context group when doing OpenGL calls
// Include context and context group for convenience
#include "cvfOpenGLContext.h"
#include "cvfOpenGLContextGroup.h"
@@ -118,10 +92,10 @@ namespace cvf {
//==================================================================================================
//
// Static class providing OpenGL wrappers and helpers
// Static class providing OpenGL wrappers and helpers
//
//==================================================================================================
class OpenGL
class OpenGL
{
public:
static bool hasOpenGLError(OpenGLContext* oglContext);
@@ -131,7 +105,7 @@ public:
static bool testAndReportOpenGLError(OpenGLContext* oglContext, const char* operation, const CodeLocation& codeLocation);
static void cvf_check_ogl(OpenGLContext* oglContext, const CodeLocation& codeLocation);
static void enableCheckOgl(bool enable);
static bool isCheckOglEnabled();
Fwk/VizFwk/LibRender/cvfOpenGLContextGroup.cpp
+73 -178
View File
@@ -44,14 +44,8 @@
#include "cvfLogManager.h"
#include "cvfTrace.h"
#include <memory.h>
#ifdef WIN32
#pragma warning (push)
#pragma warning (disable: 4668)
#include "glew/GL/wglew.h"
#pragma warning (pop)
#endif
#include <QOpenGLContext>
#include <QSurfaceFormat>
namespace cvf {
@@ -65,27 +59,25 @@ namespace cvf {
/// A context group associates OpenGLContext instances that share OpenGL resources such as
/// shader objects, textures and buffer objects. Contexts added to the group must be compatible from
/// OpenGL's perspective - that is they must use identical (pixel) formats.
///
///
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
OpenGLContextGroup::OpenGLContextGroup()
: m_isInitialized(false),
m_glewContextStruct(NULL),
m_wglewContextStruct(NULL)
: m_isInitialized(false)
{
//Trace::show("OpenGLContextGroup constructor");
m_resourceManager = new OpenGLResourceManager;
m_logger = CVF_GET_LOGGER("cee.cvf.OpenGL");
m_logger = CVF_GET_LOGGER("cee.cvf.OpenGL");
m_capabilities = new OpenGLCapabilities;
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
OpenGLContextGroup::~OpenGLContextGroup()
{
@@ -116,7 +108,7 @@ OpenGLContextGroup::~OpenGLContextGroup()
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool OpenGLContextGroup::isContextGroupInitialized() const
{
@@ -143,25 +135,13 @@ bool OpenGLContextGroup::initializeContextGroup(OpenGLContext* currentContext)
if (!m_isInitialized)
{
#ifdef CVF_USE_GLEW
if (!initializeGLEW(currentContext))
if (!initializeOpenGLFunctions(currentContext))
{
CVF_LOG_ERROR(m_logger.p(), "Failed to intitialize GLEW in context group");
CVF_LOG_ERROR(m_logger.p(), "Failed to initialize OpenGL functions in context group");
return false;
}
configureCapabilitiesFromGLEW(currentContext);
#ifdef WIN32
if (!initializeWGLEW(currentContext))
{
CVF_LOG_ERROR(m_logger.p(), "Failed to intitialize WGLEW in context group");
return false;
}
#endif
#endif
configureCapabilities(currentContext);
CVF_LOG_DEBUG(m_logger.p(), "OpenGL initialized in context group");
CVF_LOG_DEBUG(m_logger.p(), " version: " + m_info.version());
@@ -176,7 +156,7 @@ bool OpenGLContextGroup::initializeContextGroup(OpenGLContext* currentContext)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void OpenGLContextGroup::uninitializeContextGroup()
{
@@ -188,16 +168,6 @@ void OpenGLContextGroup::uninitializeContextGroup()
// Just replace capabilities with a new object
m_capabilities = new OpenGLCapabilities;
#ifdef CVF_USE_GLEW
delete m_glewContextStruct;
#ifdef WIN32
delete m_wglewContextStruct;
#endif
#endif
m_glewContextStruct = NULL;
m_wglewContextStruct = NULL;
m_isInitialized = false;
}
@@ -234,7 +204,7 @@ void OpenGLContextGroup::contextAboutToBeShutdown(OpenGLContext* currentContextT
// If the ref count on the context is down to 1, there is probably something strange going on.
// Since one reference to the context is being held by this context group, this means that the
// caller isn't holding a reference to the context. In this case the context object will evaporate
// caller isn't holding a reference to the context. In this case the context object will evaporate
// during the call below, and the caller will most likely get a nasty surprise
CVF_ASSERT(currentContextToShutdown->refCount() > 1);
@@ -252,145 +222,111 @@ void OpenGLContextGroup::contextAboutToBeShutdown(OpenGLContext* currentContextT
//--------------------------------------------------------------------------------------------------
/// Initializes GLEW for this context group
/// Initializes OpenGL functions for this context group using Qt
///
/// \warning The context passed in \a currentContext must be current!
//--------------------------------------------------------------------------------------------------
bool OpenGLContextGroup::initializeGLEW(OpenGLContext* currentContext)
bool OpenGLContextGroup::initializeOpenGLFunctions(OpenGLContext* currentContext)
{
//Trace::show("OpenGLContextGroup::initializeGLEW()");
//Trace::show("OpenGLContextGroup::initializeOpenGLFunctions()");
CVF_ASSERT(currentContext);
CVF_ASSERT(m_glewContextStruct == NULL);
#ifdef CVF_USE_GLEW
QOpenGLContext* qtCtx = QOpenGLContext::currentContext();
if (!qtCtx || !qtCtx->isValid())
{
CVF_LOG_ERROR(m_logger, "Error initializing OpenGL functions, no valid Qt OpenGL context is current");
return false;
}
// Initialize extra functions (OpenGL 3.0+)
QOpenGLExtraFunctions* extraFuncs = qtCtx->extraFunctions();
if (!extraFuncs)
{
CVF_LOG_ERROR(m_logger, "Error initializing OpenGL extra functions");
return false;
}
extraFuncs->initializeOpenGLFunctions();
CVF_CHECK_OGL(currentContext);
// Query OpenGL info strings
const char* versionStr = reinterpret_cast<const char*>(glGetString(GL_VERSION));
const char* vendorStr = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
const char* rendererStr = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
String sVersion = versionStr ? versionStr : "";
String sVendor = vendorStr ? vendorStr : "";
String sRenderer = rendererStr ? rendererStr : "";
// Usage of GLEW requires that we have a standard OpenGL implementation available (not any Qt wrapper etc)
// Supposedly the version string should always contain at least one '.'
// Try and test this by querying the OpenGL version number and assume that there is no OpenGL available if it fails
const String sVersion(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
if (sVersion.find(".") == String::npos)
{
CVF_LOG_ERROR(m_logger, "Error initializing OpenGL functions, probe for OpenGL version failed. No valid OpenGL context is current");
return false;
}
// Since we're sometimes (when using Core OpenGL) seeing some OGL errors from GLEW, check before and after call to help find them
CVF_CHECK_OGL(currentContext);
// Must allocate memory for struct first since glewInit() call below will try and retrieve it
GLEWContextStruct* theContextStruct = new GLEWContextStruct;
memset(theContextStruct, 0, sizeof(GLEWContextStruct));
GLenum err = glewContextInit(theContextStruct);
if (err != GLEW_OK)
{
CVF_LOG_ERROR(m_logger, String("Error initializing GLEW, glewContextInit() returned %1").arg(err));
delete theContextStruct;
return false;
}
m_glewContextStruct = theContextStruct;
CVF_CHECK_OGL(currentContext);
String sVendor(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
String sRenderer(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
m_info.setOpenGLStrings(sVersion, sVendor, sRenderer);
#else
CVF_FAIL_MSG("Not implemented");
#endif
CVF_CHECK_OGL(currentContext);
return true;
}
//--------------------------------------------------------------------------------------------------
/// Initializes GLEW for this context group
/// Configures the capabilities of this context group by querying Qt
///
/// \warning The context passed in \a currentContext must be current!
/// \warning The passed context must be current!
//--------------------------------------------------------------------------------------------------
bool OpenGLContextGroup::initializeWGLEW(OpenGLContext* currentContext)
void OpenGLContextGroup::configureCapabilities(OpenGLContext* currentContext)
{
CVF_ASSERT(currentContext);
CVF_ASSERT(m_wglewContextStruct == NULL);
CVF_UNUSED(currentContext);
#if defined(CVF_USE_GLEW) && defined(WIN32)
// Since we're sometimes (when using Core OpenGL) seeing some OGL errors from GLEW, check before and after call to help find them
CVF_CHECK_OGL(currentContext);
// Must allocate memory for struct first since glewInit() call below will try and retrieve it
WGLEWContextStruct* theContextStruct = new WGLEWContextStruct;
memset(theContextStruct, 0, sizeof(WGLEWContextStruct));
GLenum err = wglewContextInit(theContextStruct);
if (err != GLEW_OK)
QOpenGLContext* qtCtx = QOpenGLContext::currentContext();
if (!qtCtx)
{
delete theContextStruct;
return false;
return;
}
m_wglewContextStruct = theContextStruct;
CVF_CHECK_OGL(currentContext);
#else
CVF_FAIL_MSG("Not implemented");
#endif
return true;
}
//--------------------------------------------------------------------------------------------------
/// Configures the capabilities of this context group by querying GLEW
///
/// \warning The passed context must be current and GLEW must already be initialized!
//--------------------------------------------------------------------------------------------------
void OpenGLContextGroup::configureCapabilitiesFromGLEW(OpenGLContext* currentContext)
{
#ifdef CVF_USE_GLEW
CVF_CALLSITE_GLEW(currentContext);
CVF_ASSERT(m_glewContextStruct);
QSurfaceFormat fmt = qtCtx->format();
int majorVer = fmt.majorVersion();
// Simplified config for now, we only differentiate between 1, 2, and 3
uint majorVer = 1;
if (GLEW_VERSION_2_0) majorVer = 2;
if (GLEW_VERSION_3_0) majorVer = 3;
m_capabilities->configureOpenGLSupport(majorVer);
uint capMajorVer = 1;
if (majorVer >= 2) capMajorVer = 2;
if (majorVer >= 3) capMajorVer = 3;
m_capabilities->configureOpenGLSupport(capMajorVer);
m_capabilities->setSupportsFixedFunction(true);
if (GLEW_VERSION_3_0 || GLEW_ARB_framebuffer_object)
// Check for framebuffer object support
if (majorVer >= 3 || qtCtx->hasExtension("GL_ARB_framebuffer_object"))
{
m_capabilities->addCapablity(OpenGLCapabilities::FRAMEBUFFER_OBJECT);
m_capabilities->addCapablity(OpenGLCapabilities::GENERATE_MIPMAP_FUNC);
}
if (GLEW_VERSION_3_0 || GLEW_ARB_texture_float)
// Check for texture float support
if (majorVer >= 3 || qtCtx->hasExtension("GL_ARB_texture_float"))
{
m_capabilities->addCapablity(OpenGLCapabilities::TEXTURE_FLOAT);
}
if (GLEW_VERSION_3_0 || GLEW_ARB_texture_rg)
// Check for texture RG support
if (majorVer >= 3 || qtCtx->hasExtension("GL_ARB_texture_rg"))
{
m_capabilities->addCapablity(OpenGLCapabilities::TEXTURE_RG);
}
if (GLEW_VERSION_3_1 || GLEW_ARB_texture_rectangle)
// Check for texture rectangle support
if (majorVer >= 3 || qtCtx->hasExtension("GL_ARB_texture_rectangle"))
{
m_capabilities->addCapablity(OpenGLCapabilities::TEXTURE_RECTANGLE);
}
#endif
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
size_t OpenGLContextGroup::contextCount() const
{
@@ -399,7 +335,7 @@ size_t OpenGLContextGroup::contextCount() const
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
cvf::OpenGLContext* OpenGLContextGroup::context(size_t index)
{
@@ -408,7 +344,7 @@ cvf::OpenGLContext* OpenGLContextGroup::context(size_t index)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool OpenGLContextGroup::containsContext(const OpenGLContext* context) const
{
@@ -427,9 +363,9 @@ bool OpenGLContextGroup::containsContext(const OpenGLContext* context) const
//--------------------------------------------------------------------------------------------------
/// Add an OpenGLContext to this group
///
///
/// \warning It is the caller's responsibility to ensure that the context being added is actually
/// capable of sharing OpenGL resources (display lists etc) with the contexts that are
/// capable of sharing OpenGL resources (display lists etc) with the contexts that are
/// already in the group. This function will not do any verifications to assert whether this is true.
//--------------------------------------------------------------------------------------------------
void OpenGLContextGroup::addContext(OpenGLContext* contextToAdd)
@@ -449,7 +385,7 @@ void OpenGLContextGroup::addContext(OpenGLContext* contextToAdd)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
OpenGLResourceManager* OpenGLContextGroup::resourceManager()
{
@@ -459,7 +395,7 @@ OpenGLResourceManager* OpenGLContextGroup::resourceManager()
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
Logger* OpenGLContextGroup::logger()
{
@@ -468,7 +404,7 @@ Logger* OpenGLContextGroup::logger()
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
OpenGLCapabilities* OpenGLContextGroup::capabilities()
{
@@ -478,7 +414,7 @@ OpenGLCapabilities* OpenGLContextGroup::capabilities()
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
OpenGLInfo OpenGLContextGroup::info() const
{
@@ -486,45 +422,4 @@ OpenGLInfo OpenGLContextGroup::info() const
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
GLEWContextStruct* OpenGLContextGroup::glewContextStruct()
{
#ifdef CVF_USE_GLEW
CVF_TIGHT_ASSERT(this);
CVF_TIGHT_ASSERT(m_glewContextStruct);
return m_glewContextStruct;
#else
CVF_FAIL_MSG("Not implemented");
return NULL;
#endif
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
WGLEWContextStruct* OpenGLContextGroup::wglewContextStruct()
{
#if defined(CVF_USE_GLEW) && defined(WIN32)
CVF_TIGHT_ASSERT(this);
CVF_TIGHT_ASSERT(m_wglewContextStruct);
return m_wglewContextStruct;
#else
CVF_FAIL_MSG("Not implemented");
return NULL;
#endif
}
} // namespace cvf
Fwk/VizFwk/LibRender/cvfOpenGLContextGroup.h
+3 -12
View File
@@ -43,9 +43,6 @@
#include "cvfOpenGLCapabilities.h"
#include "cvfOpenGLInfo.h"
struct GLEWContextStruct;
struct WGLEWContextStruct;
namespace cvf {
class OpenGLContext;
@@ -54,7 +51,7 @@ class OpenGLResourceManager;
//==================================================================================================
//
//
//
//
//==================================================================================================
class OpenGLContextGroup : public Object
@@ -76,15 +73,11 @@ public:
OpenGLCapabilities* capabilities();
OpenGLInfo info() const;
GLEWContextStruct* glewContextStruct();
WGLEWContextStruct* wglewContextStruct();
private:
void uninitializeContextGroup();
bool initializeGLEW(OpenGLContext* currentContext);
bool initializeWGLEW(OpenGLContext* currentContext);
void configureCapabilitiesFromGLEW(OpenGLContext* currentContext);
bool initializeOpenGLFunctions(OpenGLContext* currentContext);
void configureCapabilities(OpenGLContext* currentContext);
void addContext(OpenGLContext* contextToAdd);
private:
@@ -94,8 +87,6 @@ private:
ref<Logger> m_logger;
ref<OpenGLCapabilities> m_capabilities; // Capabilities of the contexts in this group context
OpenGLInfo m_info;
GLEWContextStruct* m_glewContextStruct; // Pointer to the GLEW context struct
WGLEWContextStruct* m_wglewContextStruct; // Pointer to the GLEW context struct
friend class OpenGLContext;
};
Fwk/VizFwk/LibRender/cvfOpenGLUtils.cpp
+8 -6
View File
@@ -50,13 +50,13 @@ namespace cvf {
/// \class cvf::OpenGLUtils
/// \ingroup Render
///
/// Static class providing OpenGL helpers
///
/// Static class providing OpenGL helpers
///
//==================================================================================================
//--------------------------------------------------------------------------------------------------
/// Store the current OpenGL context settings by using OpenGL's built in push methods.
///
///
/// Note: This call MUST be matched with a corresponding popOpenGLState() call.
//--------------------------------------------------------------------------------------------------
void OpenGLUtils::pushOpenGLState(OpenGLContext* oglContext)
@@ -72,6 +72,7 @@ void OpenGLUtils::pushOpenGLState(OpenGLContext* oglContext)
CVF_CHECK_OGL(oglContext);
// Fixed-function calls - use direct OpenGL calls (not through cvfGL)
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
CVF_CHECK_OGL(oglContext);
@@ -86,7 +87,7 @@ void OpenGLUtils::pushOpenGLState(OpenGLContext* oglContext)
// Note: Only preserves matrix stack for texture unit 0
if (oglCaps->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
glMatrixMode(GL_TEXTURE);
glPushMatrix();
@@ -104,7 +105,7 @@ void OpenGLUtils::pushOpenGLState(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
/// Set back the stored OpenGL context settings by using OpenGL's built in pop methods.
///
///
/// Note: This call MUST be matched with a corresponding pushOpenGLState() call.
//--------------------------------------------------------------------------------------------------
void OpenGLUtils::popOpenGLState(OpenGLContext* oglContext)
@@ -123,8 +124,9 @@ void OpenGLUtils::popOpenGLState(OpenGLContext* oglContext)
// Note: Only preserves matrix stack for texture unit 0
if (oglCaps->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
// Fixed-function calls - use direct OpenGL calls (not through cvfGL)
glMatrixMode(GL_TEXTURE);
glPopMatrix();
CVF_CHECK_OGL(oglContext);
Fwk/VizFwk/LibRender/cvfOverlayColorLegend.cpp
+6 -6
View File
@@ -389,9 +389,9 @@ void OverlayColorLegend::renderLegend(OpenGLContext* oglContext, OverlayColorLeg
shaderProgram->applyFixedUniforms(oglContext, matrixState);
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
// Render colored quads and lines
size_t numColors = m_levelColors.size();
@@ -418,7 +418,7 @@ void OverlayColorLegend::renderLegend(OpenGLContext* oglContext, OverlayColorLeg
UniformFloat uniformColor("u_color", Color4f(Color3f(clr)));
shaderProgram->applyUniform(oglContext, uniformColor);
glDrawRangeElements(GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects);
cvfGL->glDrawRangeElements(GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects);
}
// Draw legend lines
@@ -428,11 +428,11 @@ void OverlayColorLegend::renderLegend(OpenGLContext* oglContext, OverlayColorLeg
UniformFloat uniformColor("u_color", Color4f(m_lineColor));
shaderProgram->applyUniform(oglContext, uniformColor);
glDrawRangeElements(GL_LINES, 0, 5, 8, GL_UNSIGNED_SHORT, linesConnects);
cvfGL->glDrawRangeElements(GL_LINES, 0, 5, 8, GL_UNSIGNED_SHORT, linesConnects);
}
}
glDisableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glDisableVertexAttribArray(ShaderProgram::VERTEX);
CVF_TIGHT_ASSERT(shaderProgram.notNull());
shaderProgram->useNoProgram(oglContext);
Fwk/VizFwk/LibRender/cvfOverlayImage.cpp
+8 -8
View File
@@ -208,11 +208,11 @@ void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, cons
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
cvfGL->glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
if (m_shaderProgram.isNull())
{
@@ -302,7 +302,7 @@ void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, cons
m_shaderProgram->applyUniform(oglContext, alphaUniform);
}
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
cvfGL->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
if (m_blendMode != NO_BLENDING)
@@ -322,8 +322,8 @@ void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, cons
if (!software)
{
glDisableVertexAttribArray(ShaderProgram::VERTEX);
glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
cvfGL->glDisableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
}
}
Fwk/VizFwk/LibRender/cvfOverlayScalarMapperLegend.cpp
+7 -7
View File
@@ -406,9 +406,9 @@ void OverlayScalarMapperLegend::renderLegend(OpenGLContext* oglContext, OverlayC
shaderProgram->applyFixedUniforms(oglContext, matrixState);
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
// Render color bar as one colored quad per pixel
@@ -431,7 +431,7 @@ void OverlayScalarMapperLegend::renderLegend(OpenGLContext* oglContext, OverlayC
UniformFloat uniformColor("u_color", Color4f(Color3f(clr)));
shaderProgram->applyUniform(oglContext, uniformColor);
glDrawRangeElements(GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects);
cvfGL->glDrawRangeElements(GL_TRIANGLES, 0, 4, 6, GL_UNSIGNED_SHORT, trianglesConnects);
}
}
}
@@ -451,7 +451,7 @@ void OverlayScalarMapperLegend::renderLegend(OpenGLContext* oglContext, OverlayC
UniformFloat uniformColor("u_color", Color4f(m_lineColor));
shaderProgram->applyUniform(oglContext, uniformColor);
glDrawRangeElements(GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects);
cvfGL->glDrawRangeElements(GL_LINES, 0, 3, 8, GL_UNSIGNED_SHORT, frameConnects);
}
// Render tickmarks
@@ -490,11 +490,11 @@ void OverlayScalarMapperLegend::renderLegend(OpenGLContext* oglContext, OverlayC
linesConnects = tickLinesWoLabel;
}
glDrawRangeElements(GL_LINES, 0, 4, 2, GL_UNSIGNED_SHORT, linesConnects);
cvfGL->glDrawRangeElements(GL_LINES, 0, 4, 2, GL_UNSIGNED_SHORT, linesConnects);
}
}
glDisableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glDisableVertexAttribArray(ShaderProgram::VERTEX);
CVF_TIGHT_ASSERT(shaderProgram.notNull());
shaderProgram->useNoProgram(oglContext);
Fwk/VizFwk/LibRender/cvfOverlayTextBox.cpp
+5 -5
View File
@@ -191,9 +191,9 @@ void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
backgroundShader = oglContext->resourceManager()->getLinkedUnlitColorShaderProgram(oglContext);
if (backgroundShader->useProgram(oglContext))
@@ -234,7 +234,7 @@ void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const
// Draw background
UniformFloat backgroundColor("u_color", Color4f(m_backgroundColor));
backgroundShader->applyUniform(oglContext, backgroundColor);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
cvfGL->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
}
@@ -259,7 +259,7 @@ void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const
line.applyOpenGL(oglContext);
// Draw border
glDrawArrays(GL_LINE_LOOP, 0, 4);
cvfGL->glDrawArrays(GL_LINE_LOOP, 0, 4);
RenderStateLine resetLine;
resetLine.applyOpenGL(oglContext);
Fwk/VizFwk/LibRender/cvfPrimitiveSetIndexedUInt.cpp
+2 -2
View File
@@ -118,11 +118,11 @@ void PrimitiveSetIndexedUInt::render(OpenGLContext* oglContext) const
}
else
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
ptrOrOffset = m_indices->ptr();
}
glDrawRangeElements(primitiveTypeOpenGL(), m_minIndex, m_maxIndex, numIndices, GL_UNSIGNED_INT, ptrOrOffset);
cvfGL->glDrawRangeElements(primitiveTypeOpenGL(), m_minIndex, m_maxIndex, numIndices, GL_UNSIGNED_INT, ptrOrOffset);
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfPrimitiveSetIndexedUIntScoped.cpp
+2 -2
View File
@@ -105,11 +105,11 @@ void PrimitiveSetIndexedUIntScoped::render(OpenGLContext* oglContext) const
}
else
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
ptrOrOffset = m_indices->ptr() + m_firstElement;
}
glDrawElements(primitiveTypeOpenGL(), numIndices, GL_UNSIGNED_INT, ptrOrOffset);
cvfGL->glDrawElements(primitiveTypeOpenGL(), numIndices, GL_UNSIGNED_INT, ptrOrOffset);
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfPrimitiveSetIndexedUShort.cpp
+2 -2
View File
@@ -117,11 +117,11 @@ void PrimitiveSetIndexedUShort::render(OpenGLContext* oglContext) const
}
else
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
ptrOrOffset = m_indices->ptr();
}
glDrawRangeElements(primitiveTypeOpenGL(), m_minIndex, m_maxIndex, numIndices, GL_UNSIGNED_SHORT, ptrOrOffset);
cvfGL->glDrawRangeElements(primitiveTypeOpenGL(), m_minIndex, m_maxIndex, numIndices, GL_UNSIGNED_SHORT, ptrOrOffset);
}
Fwk/VizFwk/LibRender/cvfPrimitiveSetIndexedUShortScoped.cpp
+2 -2
View File
@@ -105,11 +105,11 @@ void PrimitiveSetIndexedUShortScoped::render(OpenGLContext* oglContext) const
}
else
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
ptrOrOffset = m_indices->ptr() + m_firstElement;
}
glDrawElements(primitiveTypeOpenGL(), numIndices, GL_UNSIGNED_SHORT, ptrOrOffset);
cvfGL->glDrawElements(primitiveTypeOpenGL(), numIndices, GL_UNSIGNED_SHORT, ptrOrOffset);
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfRenderStateBlending.cpp
+7 -7
View File
@@ -166,22 +166,22 @@ void RenderStateBlending::applyOpenGL(OpenGLContext* oglContext) const
if (m_enableBlending)
{
glEnable(GL_BLEND);
cvfGL->glEnable(GL_BLEND);
}
else
{
glDisable(GL_BLEND);
cvfGL->glDisable(GL_BLEND);
}
if ((m_funcSourceRGB == m_funcSourceAlpha) && (m_funcDestinationRGB == m_funcDestinationAlpha))
{
glBlendFunc(blendFuncOpenGL(m_funcSourceRGB), blendFuncOpenGL(m_funcDestinationRGB));
cvfGL->glBlendFunc(blendFuncOpenGL(m_funcSourceRGB), blendFuncOpenGL(m_funcDestinationRGB));
}
else
{
if (openGL2Support)
{
glBlendFuncSeparate(blendFuncOpenGL(m_funcSourceRGB), blendFuncOpenGL(m_funcDestinationRGB), blendFuncOpenGL(m_funcSourceAlpha), blendFuncOpenGL(m_funcDestinationAlpha));
cvfGL->glBlendFuncSeparate(blendFuncOpenGL(m_funcSourceRGB), blendFuncOpenGL(m_funcDestinationRGB), blendFuncOpenGL(m_funcSourceAlpha), blendFuncOpenGL(m_funcDestinationAlpha));
}
else
{
@@ -193,14 +193,14 @@ void RenderStateBlending::applyOpenGL(OpenGLContext* oglContext) const
{
if (m_equationRGB == m_equationAlpha)
{
glBlendEquation(blendEquationOpenGL(m_equationRGB));
cvfGL->glBlendEquation(blendEquationOpenGL(m_equationRGB));
}
else
{
glBlendEquationSeparate(blendEquationOpenGL(m_equationRGB), blendEquationOpenGL(m_equationAlpha));
cvfGL->glBlendEquationSeparate(blendEquationOpenGL(m_equationRGB), blendEquationOpenGL(m_equationAlpha));
}
glBlendColor(m_blendColor.r(), m_blendColor.g(), m_blendColor.b(), m_blendColor.a());
cvfGL->glBlendColor(m_blendColor.r(), m_blendColor.g(), m_blendColor.b(), m_blendColor.a());
}
else
{
Fwk/VizFwk/LibRender/cvfRenderStateCullFace.cpp
+8 -6
View File
@@ -107,26 +107,28 @@ RenderStateCullFace::Mode RenderStateCullFace::mode() const
//--------------------------------------------------------------------------------------------------
void RenderStateCullFace::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
if (m_enableCulling)
{
if (m_faceMode == BACK)
if (m_faceMode == BACK)
{
glCullFace(GL_BACK);
cvfGL->glCullFace(GL_BACK);
}
else if (m_faceMode == FRONT)
{
glCullFace(GL_FRONT);
cvfGL->glCullFace(GL_FRONT);
}
else
{
glCullFace(GL_FRONT_AND_BACK);
cvfGL->glCullFace(GL_FRONT_AND_BACK);
}
glEnable(GL_CULL_FACE);
cvfGL->glEnable(GL_CULL_FACE);
}
else
{
glDisable(GL_CULL_FACE);
cvfGL->glDisable(GL_CULL_FACE);
}
CVF_CHECK_OGL(oglContext);
Fwk/VizFwk/LibRender/cvfRenderStateFrontFace.cpp
+6 -4
View File
@@ -89,13 +89,15 @@ RenderStateFrontFace::Mode RenderStateFrontFace::mode() const
//--------------------------------------------------------------------------------------------------
void RenderStateFrontFace::applyOpenGL(OpenGLContext* oglContext) const
{
if (m_faceMode == CW)
CVF_CALLSITE_OPENGL(oglContext);
if (m_faceMode == CW)
{
glFrontFace(GL_CW);
cvfGL->glFrontFace(GL_CW);
}
else
else
{
glFrontFace(GL_CCW);
cvfGL->glFrontFace(GL_CCW);
}
CVF_CHECK_OGL(oglContext);
Fwk/VizFwk/LibRender/cvfRenderStateLine.cpp
+4 -4
View File
@@ -106,17 +106,17 @@ bool RenderStateLine::isSmoothEnabled() const
//--------------------------------------------------------------------------------------------------
void RenderStateLine::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_UNUSED(oglContext);
CVF_CALLSITE_OPENGL(oglContext);
glLineWidth(m_lineWidth);
cvfGL->glLineWidth(m_lineWidth);
if (m_smooth)
{
glEnable(GL_LINE_SMOOTH);
cvfGL->glEnable(GL_LINE_SMOOTH);
}
else
{
glDisable(GL_LINE_SMOOTH);
cvfGL->glDisable(GL_LINE_SMOOTH);
}
}
Fwk/VizFwk/LibRender/cvfRenderStatePoint.cpp
+8 -5
View File
@@ -135,16 +135,17 @@ void RenderStatePoint::applyOpenGL(OpenGLContext* oglContext) const
{
if (openGL2Support)
{
glDisable(GL_PROGRAM_POINT_SIZE);
cvfGL->glDisable(GL_PROGRAM_POINT_SIZE);
}
// glPointSize is not in QOpenGLFunctions, use direct call
glPointSize(m_pointSize);
}
else
{
if (openGL2Support)
{
glEnable(GL_PROGRAM_POINT_SIZE);
cvfGL->glEnable(GL_PROGRAM_POINT_SIZE);
}
else
{
@@ -156,10 +157,12 @@ void RenderStatePoint::applyOpenGL(OpenGLContext* oglContext) const
{
if (m_pointSprite)
{
// GL_POINT_SPRITE is fixed-function, use direct calls
glEnable(GL_POINT_SPRITE);
glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
// Note: glPointParameteri for GL_POINT_SPRITE_COORD_ORIGIN requires extension loading
// which was previously handled by GLEW. Point sprites are deprecated in modern OpenGL.
}
else
else
{
glDisable(GL_POINT_SPRITE);
}
Fwk/VizFwk/LibRender/cvfRenderStatePolygonOffset.cpp
+11 -9
View File
@@ -187,22 +187,24 @@ void RenderStatePolygonOffset::configureLineNegativeOffset()
//--------------------------------------------------------------------------------------------------
void RenderStatePolygonOffset::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
if (m_enableFillMode ||
m_enableLineMode ||
m_enablePointMode)
{
glPolygonOffset(m_factor, m_units);
cvfGL->glPolygonOffset(m_factor, m_units);
}
if (m_enableFillMode) glEnable(GL_POLYGON_OFFSET_FILL);
else glDisable(GL_POLYGON_OFFSET_FILL);
if (m_enableLineMode) glEnable(GL_POLYGON_OFFSET_LINE);
else glDisable(GL_POLYGON_OFFSET_LINE);
if (m_enableFillMode) cvfGL->glEnable(GL_POLYGON_OFFSET_FILL);
else cvfGL->glDisable(GL_POLYGON_OFFSET_FILL);
if (m_enableLineMode) cvfGL->glEnable(GL_POLYGON_OFFSET_LINE);
else cvfGL->glDisable(GL_POLYGON_OFFSET_LINE);
if (m_enablePointMode) cvfGL->glEnable(GL_POLYGON_OFFSET_POINT);
else cvfGL->glDisable(GL_POLYGON_OFFSET_POINT);
if (m_enablePointMode) glEnable(GL_POLYGON_OFFSET_POINT);
else glDisable(GL_POLYGON_OFFSET_POINT);
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfRenderStateStencil.cpp
+8 -6
View File
@@ -108,23 +108,25 @@ void RenderStateStencil::setOperation(Operation stencilFails, Operation stencilP
//--------------------------------------------------------------------------------------------------
void RenderStateStencil::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
if (m_enable)
{
GLenum funcOGL = functionOpenGL(m_function);
glStencilFunc(funcOGL, m_functionRefValue, m_functionMask);
cvfGL->glStencilFunc(funcOGL, m_functionRefValue, m_functionMask);
const GLenum stencilFailsOGL = operationOpenGL(m_opStencilFails);
const GLenum stencilPassesDepthFails = operationOpenGL(m_opStencilPassesDepthFails);
const GLenum stencilPassesDepthPasses = operationOpenGL(m_opStencilPassesDepthPasses);
glStencilOp(stencilFailsOGL, stencilPassesDepthFails, stencilPassesDepthPasses);
const GLenum stencilPassesDepthPasses = operationOpenGL(m_opStencilPassesDepthPasses);
cvfGL->glStencilOp(stencilFailsOGL, stencilPassesDepthFails, stencilPassesDepthPasses);
glEnable(GL_STENCIL_TEST);
cvfGL->glEnable(GL_STENCIL_TEST);
}
else
{
glDisable(GL_STENCIL_TEST);
cvfGL->glDisable(GL_STENCIL_TEST);
}
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfRenderStateTextureBindings.cpp
+4 -4
View File
@@ -174,7 +174,7 @@ void RenderStateTextureBindings::setupTextures(OpenGLContext* oglContext)
return;
}
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
int i;
for (i = 0; i < m_bindingCount; i++)
@@ -183,7 +183,7 @@ void RenderStateTextureBindings::setupTextures(OpenGLContext* oglContext)
if (texture->textureOglId() == 0)
{
glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
cvfGL->glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
texture->setupTexture(oglContext);
CVF_CHECK_OGL(oglContext);
}
@@ -196,7 +196,7 @@ void RenderStateTextureBindings::setupTextures(OpenGLContext* oglContext)
{
if (oglCaps->hasCapability(OpenGLCapabilities::GENERATE_MIPMAP_FUNC))
{
glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
cvfGL->glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
texture->generateMipmap(oglContext);
CVF_CHECK_OGL(oglContext);
}
@@ -237,7 +237,7 @@ void RenderStateTextureBindings::applyOpenGL(OpenGLContext* oglContext) const
const Sampler* sampler = m_bindings[i].sampler.p();
CVF_ASSERT(texture && sampler);
glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
cvfGL->glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
texture->bind(oglContext);
texture->setupTextureParamsFromSampler(oglContext, *sampler);
Fwk/VizFwk/LibRender/cvfRenderState_FF.cpp
+13 -5
View File
@@ -150,7 +150,9 @@ Color3f RenderStateLighting_FF::ambientIntensity() const
//--------------------------------------------------------------------------------------------------
void RenderStateLighting_FF::applyOpenGL(OpenGLContext* oglContext) const
{
if (m_enableLighting)
CVF_CALLSITE_OPENGL(oglContext);
if (m_enableLighting)
{
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, m_twoSided ? 1 : 0);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, m_localViewer ? 1 : 0);
@@ -419,17 +421,19 @@ bool RenderStateMaterial_FF::isColorMaterialEnabled() const
//--------------------------------------------------------------------------------------------------
void RenderStateMaterial_FF::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
Color4f ambient(m_ambient, m_alpha);
Color4f diffuse(m_diffuse, m_alpha);
Color4f emission(m_emission, m_alpha);
Color4f specular(m_specular, m_alpha);
CVF_ASSERT(ambient.isValid());
CVF_ASSERT(diffuse.isValid());
CVF_ASSERT(emission.isValid());
CVF_ASSERT(specular.isValid());
CVF_ASSERT(Math::valueInRange(m_shininess, 0.0f, 128.0f));
if (m_enableColorMaterial)
{
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
@@ -506,6 +510,8 @@ bool RenderStateNormalize_FF::isEnabled() const
//--------------------------------------------------------------------------------------------------
void RenderStateNormalize_FF::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
if (m_enable)
{
glEnable(GL_NORMALIZE);
@@ -616,7 +622,7 @@ void RenderStateTextureMapping_FF::setupTexture(OpenGLContext* oglContext)
{
if (oglContext->capabilities()->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
m_texture->setupTexture(oglContext);
@@ -636,7 +642,7 @@ void RenderStateTextureMapping_FF::applyOpenGL(OpenGLContext* oglContext) const
if (oglContext->capabilities()->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
if (m_texture.notNull() && m_texture->textureOglId() != 0)
@@ -750,6 +756,8 @@ void RenderStateClipPlanes_FF::removeAllPlanes()
//--------------------------------------------------------------------------------------------------
void RenderStateClipPlanes_FF::applyOpenGL(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
for (size_t idx = 0; idx < m_clipPlanes.size(); idx++)
{
if (idx > 5)
Fwk/VizFwk/LibRender/cvfRenderbufferObject.cpp
+2 -2
View File
@@ -121,8 +121,8 @@ bool RenderbufferObject::create(OpenGLContext* oglContext)
m_oglRcBuffer = oglContext->resourceManager()->createOglRcRenderbuffer(oglContext);
OglId myOglId = OglRc::safeOglId(m_oglRcBuffer.p());
glBindRenderbuffer(GL_RENDERBUFFER, myOglId);
glRenderbufferStorage(GL_RENDERBUFFER, intenalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height));
cvfGL->glBindRenderbuffer(GL_RENDERBUFFER, myOglId);
cvfGL->glRenderbufferStorage(GL_RENDERBUFFER, intenalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height));
if (CVF_TEST_AND_REPORT_OPENGL_ERROR(oglContext, "Allocate render buffer storage"))
{
Fwk/VizFwk/LibRender/cvfShader.cpp
+8 -8
View File
@@ -124,7 +124,7 @@ bool Shader::compile(OpenGLContext* oglContext)
#ifdef _DEBUG
uint myOglId = OglRc::safeOglId(m_oglRcShader.p());
GLint status;
glGetShaderiv(myOglId, GL_COMPILE_STATUS, &status);
cvfGL->glGetShaderiv(myOglId, GL_COMPILE_STATUS, &status);
CVF_ASSERT(status == GL_TRUE);
#endif
@@ -169,13 +169,13 @@ bool Shader::compile(OpenGLContext* oglContext)
const char* stringArray[1];
stringArray[0] = charArr.ptr();
glShaderSource(myOglId, 1, stringArray, NULL);
cvfGL->glShaderSource(myOglId, 1, stringArray, NULL);
CVF_CHECK_OGL(oglContext);
glCompileShader(myOglId);
cvfGL->glCompileShader(myOglId);
GLint iCompileStatus = 0;
glGetShaderiv(myOglId, GL_COMPILE_STATUS, &iCompileStatus);
cvfGL->glGetShaderiv(myOglId, GL_COMPILE_STATUS, &iCompileStatus);
if (iCompileStatus != GL_TRUE)
{
String errStr = String("Error compiling shader: '%1'\n").arg(m_shaderName);
@@ -262,13 +262,13 @@ String Shader::shaderInfoLog(OpenGLContext* oglContext) const
return "Shader object not created.";
}
if (!glIsShader(myOglId))
if (!cvfGL->glIsShader(myOglId))
{
return "Shader object identifier does not correspond to a shader object.";
}
GLint reqBufferSize = 0;
glGetShaderiv(myOglId, GL_INFO_LOG_LENGTH, &reqBufferSize);
GLint reqBufferSize = 0;
cvfGL->glGetShaderiv(myOglId, GL_INFO_LOG_LENGTH, &reqBufferSize);
if (reqBufferSize > 0)
{
@@ -276,7 +276,7 @@ String Shader::shaderInfoLog(OpenGLContext* oglContext) const
// This is a good place for using CharArray
std::vector<GLchar> charBuffer;
charBuffer.resize(static_cast<size_t>(reqBufferSize + 1));
glGetShaderInfoLog(myOglId, reqBufferSize, NULL, &charBuffer[0]);
cvfGL->glGetShaderInfoLog(myOglId, reqBufferSize, NULL, &charBuffer[0]);
String logString(&charBuffer[0]);
return logString;
Fwk/VizFwk/LibRender/cvfShaderProgram.cpp
+39 -39
View File
@@ -190,7 +190,7 @@ bool ShaderProgram::linkProgram(OpenGLContext* oglContext)
}
CVF_ASSERT(shader->shaderOglId() != 0);
glAttachShader(m_oglRcProgram->oglId(), shader->shaderOglId());
cvfGL->glAttachShader(m_oglRcProgram->oglId(), shader->shaderOglId());
CVF_CHECK_OGL(oglContext);
m_linkedShaderVersionTicks[i] = shader->compiledVersionTick();
@@ -198,7 +198,7 @@ bool ShaderProgram::linkProgram(OpenGLContext* oglContext)
bindFixedAttributes(oglContext);
glLinkProgram(m_oglRcProgram->oglId());
cvfGL->glLinkProgram(m_oglRcProgram->oglId());
//Trace::show("%d", glGetAttribLocation(m_programObjID, "cvfa_vertex"));
//Trace::show("%d", glGetAttribLocation(m_programObjID, "cvfa_normal"));
@@ -206,7 +206,7 @@ bool ShaderProgram::linkProgram(OpenGLContext* oglContext)
//Trace::show(programInfoLog().toAscii().ptr());
GLint iLinkStatus = 0;
glGetProgramiv(m_oglRcProgram->oglId(), GL_LINK_STATUS, &iLinkStatus);
cvfGL->glGetProgramiv(m_oglRcProgram->oglId(), GL_LINK_STATUS, &iLinkStatus);
if (iLinkStatus != GL_TRUE)
{
CVF_LOG_RENDER_ERROR(oglContext, String("Error linking shader program '%1', GLSL details:\n%2").arg(programName()).arg(programInfoLog(oglContext)));
@@ -294,7 +294,7 @@ bool ShaderProgram::useProgram(OpenGLContext* oglContext) const
// will make this method return false.
CVF_CLEAR_OGL_ERROR(oglContext);
glUseProgram(m_oglRcProgram->oglId());
cvfGL->glUseProgram(m_oglRcProgram->oglId());
// TODO
// Is there any lightweight way to check if the glUseCall was successful
@@ -315,7 +315,7 @@ void ShaderProgram::useNoProgram(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(ShaderProgram::supportedOpenGL(oglContext));
glUseProgram(0);
cvfGL->glUseProgram(0);
}
@@ -389,10 +389,10 @@ bool ShaderProgram::validateProgram(OpenGLContext* oglContext) const
return false;
}
glValidateProgram(m_oglRcProgram->oglId());
cvfGL->glValidateProgram(m_oglRcProgram->oglId());
GLint validateStatus = GL_FALSE;
glGetProgramiv(m_oglRcProgram->oglId(), GL_VALIDATE_STATUS, &validateStatus);
cvfGL->glGetProgramiv(m_oglRcProgram->oglId(), GL_VALIDATE_STATUS, &validateStatus);
if (validateStatus == GL_TRUE)
{
return true;
@@ -421,13 +421,13 @@ String ShaderProgram::programInfoLog(OpenGLContext* oglContext) const
return "Program object not created.";
}
if (!glIsProgram(myOglId))
if (!cvfGL->glIsProgram(myOglId))
{
return "Program object identifier does not correspond to a shader program object.";
}
GLint reqBufferSize = 0;
glGetProgramiv(myOglId, GL_INFO_LOG_LENGTH, &reqBufferSize);
GLint reqBufferSize = 0;
cvfGL->glGetProgramiv(myOglId, GL_INFO_LOG_LENGTH, &reqBufferSize);
if (reqBufferSize > 0)
{
@@ -435,7 +435,7 @@ String ShaderProgram::programInfoLog(OpenGLContext* oglContext) const
// This is a good place for using CharArray
std::vector<GLchar> charBuffer;
charBuffer.resize(static_cast<size_t>(reqBufferSize + 1));
glGetProgramInfoLog(myOglId, reqBufferSize, NULL, &charBuffer[0]);
cvfGL->glGetProgramInfoLog(myOglId, reqBufferSize, NULL, &charBuffer[0]);
String logString(&charBuffer[0]);
return logString;
@@ -507,13 +507,13 @@ void ShaderProgram::applyUniformAtLocation(OpenGLContext* oglContext, int locati
switch (uniform.type())
{
case Uniform::INT: glUniform1iv(location, valCount, uniform.intPtr()); break;
case Uniform::FLOAT: glUniform1fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC2: glUniform2fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC3: glUniform3fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC4: glUniform4fv(location, valCount, uniform.floatPtr()); break;
case Uniform::INT: cvfGL->glUniform1iv(location, valCount, uniform.intPtr()); break;
case Uniform::FLOAT: cvfGL->glUniform1fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC2: cvfGL->glUniform2fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC3: cvfGL->glUniform3fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_VEC4: cvfGL->glUniform4fv(location, valCount, uniform.floatPtr()); break;
case Uniform::FLOAT_MAT4: glUniformMatrix4fv(location, valCount, GL_FALSE, uniform.floatPtr()); break;
case Uniform::FLOAT_MAT4: cvfGL->glUniformMatrix4fv(location, valCount, GL_FALSE, uniform.floatPtr()); break;
case Uniform::UNDEFINED: CVF_FAIL_MSG("Unhandled type");
}
@@ -615,25 +615,25 @@ void ShaderProgram::applyFixedUniforms(OpenGLContext* oglContext, const MatrixSt
FixedUniform fixedUniform = it->first;
switch (fixedUniform)
{
case PROJECTION_MATRIX: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.projectionMatrix().ptr()); break;
case PROJECTION_MATRIX: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.projectionMatrix().ptr()); break;
case VIEW_MATRIX: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.viewMatrix().ptr()); break;
case VIEW_MATRIX_INVERSE: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.viewMatrixInverse().ptr()); break;
case VIEW_MATRIX: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.viewMatrix().ptr()); break;
case VIEW_MATRIX_INVERSE: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.viewMatrixInverse().ptr()); break;
case MODEL_MATRIX: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrix().ptr()); break;
case MODEL_MATRIX_INVERSE: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrixInverse().ptr()); break;
case MODEL_MATRIX_INVERSE_TRANSPOSE: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrixInverseTranspose().ptr()); break;
case MODEL_MATRIX: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrix().ptr()); break;
case MODEL_MATRIX_INVERSE: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrixInverse().ptr()); break;
case MODEL_MATRIX_INVERSE_TRANSPOSE: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelMatrixInverseTranspose().ptr()); break;
case MODEL_VIEW_MATRIX: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewMatrix().ptr()); break;
case MODEL_VIEW_MATRIX_INVERSE: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewMatrixInverse().ptr()); break;
case MODEL_VIEW_MATRIX: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewMatrix().ptr()); break;
case MODEL_VIEW_MATRIX_INVERSE: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewMatrixInverse().ptr()); break;
case MODEL_VIEW_PROJECTION_MATRIX: glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewProjectionMatrix().ptr()); break;
case MODEL_VIEW_PROJECTION_MATRIX: cvfGL->glUniformMatrix4fv(location, 1, GL_FALSE, matrixState.modelViewProjectionMatrix().ptr()); break;
case NORMAL_MATRIX: glUniformMatrix3fv(location, 1, GL_FALSE, matrixState.normalMatrix().ptr()); break;
case NORMAL_MATRIX: cvfGL->glUniformMatrix3fv(location, 1, GL_FALSE, matrixState.normalMatrix().ptr()); break;
case VIEWPORT_WIDTH: glUniform1i(location, static_cast<GLint>(matrixState.viewportSize().x())); break;
case VIEWPORT_HEIGHT: glUniform1i(location, static_cast<GLint>(matrixState.viewportSize().y())); break;
case PIXEL_HEIGHT_AT_UNIT_DISTANCE: glUniform1f(location, matrixState.pixelHeightAtUnitDistance()); break;
case VIEWPORT_WIDTH: cvfGL->glUniform1i(location, static_cast<GLint>(matrixState.viewportSize().x())); break;
case VIEWPORT_HEIGHT: cvfGL->glUniform1i(location, static_cast<GLint>(matrixState.viewportSize().y())); break;
case PIXEL_HEIGHT_AT_UNIT_DISTANCE: cvfGL->glUniform1f(location, matrixState.pixelHeightAtUnitDistance()); break;
default:
CVF_FAIL_MSG("Unhandled fixed uniform");
@@ -745,8 +745,8 @@ void ShaderProgram::discoverActiveUniforms(OpenGLContext* oglContext)
GLint numActiveUniforms = 0;
GLint maxUniformNameLength = 0;
glGetProgramiv(m_oglRcProgram->oglId(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
glGetProgramiv(m_oglRcProgram->oglId(), GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformNameLength);
cvfGL->glGetProgramiv(m_oglRcProgram->oglId(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
cvfGL->glGetProgramiv(m_oglRcProgram->oglId(), GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformNameLength);
if (numActiveUniforms <= 0 || maxUniformNameLength <= 0)
{
return;
@@ -761,7 +761,7 @@ void ShaderProgram::discoverActiveUniforms(OpenGLContext* oglContext)
GLsizei numCharsInName = 0;
GLint uniformSize = 0;
GLenum uniformDataType = 0;
glGetActiveUniform(m_oglRcProgram->oglId(), i, bufferSize, &numCharsInName, &uniformSize, &uniformDataType, uniformNameBuffer.ptr());
cvfGL->glGetActiveUniform(m_oglRcProgram->oglId(), i, bufferSize, &numCharsInName, &uniformSize, &uniformDataType, uniformNameBuffer.ptr());
CVF_CHECK_OGL(oglContext);
//Trace::show("%d: uniformSize=%d uniformDataType=%d uniformName=%s", i, uniformSize, uniformDataType, uniformNameBuffer.ptr());
@@ -777,7 +777,7 @@ void ShaderProgram::discoverActiveUniforms(OpenGLContext* oglContext)
uniformName.resize(bracketPos);
}
int location = glGetUniformLocation(m_oglRcProgram->oglId(), uniformName.c_str());
int location = cvfGL->glGetUniformLocation(m_oglRcProgram->oglId(), uniformName.c_str());
CVF_CHECK_OGL(oglContext);
@@ -846,7 +846,7 @@ int ShaderProgram::attributeLocation(OpenGLContext* oglContext, const char* name
if (OglRc::safeOglId(m_oglRcProgram.p()) != 0)
{
GLint attribIndex = glGetAttribLocation(m_oglRcProgram->oglId(), name);
GLint attribIndex = cvfGL->glGetAttribLocation(m_oglRcProgram->oglId(), name);
return attribIndex;
}
@@ -862,10 +862,10 @@ void ShaderProgram::bindFixedAttributes(OpenGLContext* oglContext)
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcProgram.p()) != 0);
glBindAttribLocation(m_oglRcProgram->oglId(), VERTEX, "cvfa_vertex");
glBindAttribLocation(m_oglRcProgram->oglId(), NORMAL, "cvfa_normal");
glBindAttribLocation(m_oglRcProgram->oglId(), COLOR, "cvfa_color");
glBindAttribLocation(m_oglRcProgram->oglId(), TEX_COORD_2F_0,"cvfa_texCoord");
cvfGL->glBindAttribLocation(m_oglRcProgram->oglId(), VERTEX, "cvfa_vertex");
cvfGL->glBindAttribLocation(m_oglRcProgram->oglId(), NORMAL, "cvfa_normal");
cvfGL->glBindAttribLocation(m_oglRcProgram->oglId(), COLOR, "cvfa_color");
cvfGL->glBindAttribLocation(m_oglRcProgram->oglId(), TEX_COORD_2F_0,"cvfa_texCoord");
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfTextDrawer.cpp
+13 -13
View File
@@ -318,7 +318,7 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
// Must be set before any texture related OpenGL calls
if (oglContext->capabilities()->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
// Will get turned on during rendering of text, but must be off for background and border
@@ -328,9 +328,9 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(ShaderProgram::VERTEX);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray);
}
// Use a fixed line spacing
@@ -401,7 +401,7 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
backgroundShader->applyUniform(oglContext, backgroundColor);
// Draw background
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, connects);
cvfGL->glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, connects);
}
}
@@ -423,7 +423,7 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
backgroundShader->applyUniform(oglContext, borderColor);
// Draw border
glDrawElements(GL_LINES, 8, GL_UNSIGNED_SHORT, lineConnects);
cvfGL->glDrawElements(GL_LINES, 8, GL_UNSIGNED_SHORT, lineConnects);
}
}
}
@@ -457,11 +457,11 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
textShader->applyUniform(oglContext, uniformTexture);
}
glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
cvfGL->glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
cvfGL->glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords);
// Setup texture, Note: Each glyph will do additional setup
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
RenderStateBlending blending;
@@ -558,7 +558,7 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
}
else
{
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, connects);
cvfGL->glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, connects);
}
// Jump to the next character in the string, if any
@@ -591,10 +591,10 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix
RenderStateLighting_FF light;
light.applyOpenGL(oglContext);
}
else
else
{
glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
glDisableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
cvfGL->glDisableVertexAttribArray(ShaderProgram::VERTEX);
ShaderProgram::useNoProgram(oglContext);
}
Fwk/VizFwk/LibRender/cvfTexture.cpp
+39 -37
View File
@@ -257,35 +257,35 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
{
CVF_ASSERT(m_image.isNull());
CVF_ASSERT(!m_enableMipmapGeneration);
glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
cvfGL->glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
}
else if (m_internalFormat == DEPTH24_STENCIL8)
{
CVF_ASSERT(m_image.isNull());
CVF_ASSERT(!m_enableMipmapGeneration);
glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
cvfGL->glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 0);
}
else
{
if (!supportsGenerateMipmapFunc)
{
// Explicit mipmap generation not supported so must configure before specifying texture image
if (m_enableMipmapGeneration && m_image.notNull())
if (m_enableMipmapGeneration && m_image.notNull())
{
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
m_hasMipmaps = true;
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
}
}
glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image.notNull() ? m_image->ptr() : 0);
cvfGL->glTexImage2D(GL_TEXTURE_2D, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image.notNull() ? m_image->ptr() : 0);
if (supportsGenerateMipmapFunc && m_enableMipmapGeneration && m_image.notNull())
{
glGenerateMipmap(GL_TEXTURE_2D);
cvfGL->glGenerateMipmap(GL_TEXTURE_2D);
m_hasMipmaps = true;
}
}
@@ -300,11 +300,11 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
if (m_internalFormat == DEPTH_COMPONENT16 || m_internalFormat == DEPTH_COMPONENT24 || m_internalFormat == DEPTH_COMPONENT32)
{
CVF_ASSERT(m_image.isNull());
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
}
else
{
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image.notNull() ? m_image->ptr() : 0);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image.notNull() ? m_image->ptr() : 0);
}
break;
@@ -317,7 +317,7 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
uint i;
for (i = 0; i < 6; i++)
{
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
cvfGL->glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
}
}
else
@@ -326,12 +326,12 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
{
if (m_enableMipmapGeneration)
{
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_TRUE);
cvfGL->glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_TRUE);
m_hasMipmaps = true;
}
else
{
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_FALSE);
cvfGL->glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_FALSE);
}
}
@@ -342,12 +342,12 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
ref<TextureImage> img = m_cubeMapImages[i];
CVF_ASSERT(img.notNull());
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, img->ptr());
cvfGL->glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormatOpenGL(), static_cast<GLsizei>(m_width), static_cast<GLsizei>(m_height), 0, GL_RGBA, GL_UNSIGNED_BYTE, img->ptr());
}
if (supportsGenerateMipmapFunc && m_enableMipmapGeneration)
{
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
cvfGL->glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
m_hasMipmaps = true;
}
}
@@ -369,27 +369,29 @@ bool Texture::setupTexture(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void Texture::bind(OpenGLContext* /*oglContext*/) const
void Texture::bind(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcTexture.p()) != 0);
glBindTexture(textureTypeOpenGL(), m_oglRcTexture->oglId());
cvfGL->glBindTexture(textureTypeOpenGL(), m_oglRcTexture->oglId());
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool Texture::isBound(OpenGLContext* /*oglContext*/) const
bool Texture::isBound(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
GLint currentTextureBinding = 0;
switch (m_textureType)
{
case TEXTURE_2D: glGetIntegerv(GL_TEXTURE_BINDING_2D, &currentTextureBinding); break;
case TEXTURE_RECTANGLE: glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE, &currentTextureBinding); break;
case TEXTURE_CUBE_MAP: glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &currentTextureBinding); break;
case TEXTURE_2D: cvfGL->glGetIntegerv(GL_TEXTURE_BINDING_2D, &currentTextureBinding); break;
case TEXTURE_RECTANGLE: cvfGL->glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE, &currentTextureBinding); break;
case TEXTURE_CUBE_MAP: cvfGL->glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &currentTextureBinding); break;
}
if (currentTextureBinding != 0)
@@ -405,11 +407,11 @@ bool Texture::isBound(OpenGLContext* /*oglContext*/) const
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void Texture::setupTextureParamsFromSampler(OpenGLContext* oglContext, const Sampler& sampler) const
{
CVF_ASSERT(oglContext);
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(isBound(oglContext));
cvfGLint oglWrapS = GL_CLAMP_TO_EDGE;
@@ -447,27 +449,27 @@ void Texture::setupTextureParamsFromSampler(OpenGLContext* oglContext, const Sam
{
case Sampler::NEAREST: oglMagFilter = GL_NEAREST; break;
case Sampler::LINEAR: oglMagFilter = GL_LINEAR; break;
case Sampler::NEAREST_MIPMAP_NEAREST:
case Sampler::NEAREST_MIPMAP_LINEAR:
case Sampler::LINEAR_MIPMAP_NEAREST:
case Sampler::NEAREST_MIPMAP_NEAREST:
case Sampler::NEAREST_MIPMAP_LINEAR:
case Sampler::LINEAR_MIPMAP_NEAREST:
case Sampler::LINEAR_MIPMAP_LINEAR: CVF_FAIL_MSG("Illegal mag format"); break;
}
cvfGLenum textureType = textureTypeOpenGL();
glTexParameteri(textureType, GL_TEXTURE_WRAP_S, oglWrapS);
glTexParameteri(textureType, GL_TEXTURE_WRAP_T, oglWrapT);
glTexParameteri(textureType, GL_TEXTURE_MIN_FILTER, oglMinFilter);
glTexParameteri(textureType, GL_TEXTURE_MAG_FILTER, oglMagFilter);
cvfGL->glTexParameteri(textureType, GL_TEXTURE_WRAP_S, oglWrapS);
cvfGL->glTexParameteri(textureType, GL_TEXTURE_WRAP_T, oglWrapT);
cvfGL->glTexParameteri(textureType, GL_TEXTURE_MIN_FILTER, oglMinFilter);
cvfGL->glTexParameteri(textureType, GL_TEXTURE_MAG_FILTER, oglMagFilter);
// HACK
if (m_internalFormat == DEPTH_COMPONENT16 || m_internalFormat == DEPTH_COMPONENT24 || m_internalFormat == DEPTH_COMPONENT32)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
}
// Set these to openGL
// TODO TEXTURE_WRAP_R, TEXTURE_BORDER_COLOR, TEXTURE_MIN_LOD, TEXTURE_MAX_LOD, TEXTURE_LOD_BIAS,
// Set these to openGL
// TODO TEXTURE_WRAP_R, TEXTURE_BORDER_COLOR, TEXTURE_MIN_LOD, TEXTURE_MAX_LOD, TEXTURE_LOD_BIAS,
// TEXTURE_COMPARE_MODE, TEXTURE_COMPARE_FUNC
CVF_CHECK_OGL(oglContext);
@@ -591,12 +593,12 @@ void Texture::generateMipmap(OpenGLContext* oglContext)
if (m_textureType == TEXTURE_2D)
{
glGenerateMipmap(GL_TEXTURE_2D);
cvfGL->glGenerateMipmap(GL_TEXTURE_2D);
m_hasMipmaps = true;
}
else if (m_textureType == TEXTURE_CUBE_MAP)
{
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
cvfGL->glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
m_hasMipmaps = true;
}
else
Fwk/VizFwk/LibRender/cvfTexture2D_FF.cpp
+15 -14
View File
@@ -133,11 +133,11 @@ void Texture2D_FF::setMagFilter(Filter magFilter)
//--------------------------------------------------------------------------------------------------
bool Texture2D_FF::setupTexture(OpenGLContext* oglContext)
{
CVF_ASSERT(oglContext);
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcTexture.p()) == 0);
CVF_CLEAR_OGL_ERROR(oglContext);
m_oglRcTexture = oglContext->resourceManager()->createOglRcTexture(oglContext);
bind(oglContext);
CVF_CHECK_OGL(oglContext);
@@ -146,9 +146,8 @@ bool Texture2D_FF::setupTexture(OpenGLContext* oglContext)
GLsizei width = static_cast<GLsizei>(m_image->width());
GLsizei height = static_cast<GLsizei>(m_image->height());
CVF_ASSERT(height > 0 && width > 0);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image->ptr());
// Note: gluBuild2DMipmaps will scale the image to the closest power of 2 dimension, which is required by the software renderer
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, GL_RGBA, GL_UNSIGNED_BYTE, m_image->ptr());
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_image->ptr());
cvfGL->glGenerateMipmap(GL_TEXTURE_2D);
if (CVF_TEST_AND_REPORT_OPENGL_ERROR(oglContext, "Setup texture"))
{
@@ -163,20 +162,22 @@ bool Texture2D_FF::setupTexture(OpenGLContext* oglContext)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Texture2D_FF::bind(OpenGLContext* /*oglContext*/) const
void Texture2D_FF::bind(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(OglRc::safeOglId(m_oglRcTexture.p()) != 0);
glBindTexture(GL_TEXTURE_2D, m_oglRcTexture->oglId());
cvfGL->glBindTexture(GL_TEXTURE_2D, m_oglRcTexture->oglId());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Texture2D_FF::isBound(OpenGLContext* /*oglContext*/) const
bool Texture2D_FF::isBound(OpenGLContext* oglContext) const
{
CVF_CALLSITE_OPENGL(oglContext);
GLint currentTextureBinding = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &currentTextureBinding);
cvfGL->glGetIntegerv(GL_TEXTURE_BINDING_2D, &currentTextureBinding);
if (currentTextureBinding != 0)
{
@@ -195,7 +196,7 @@ bool Texture2D_FF::isBound(OpenGLContext* /*oglContext*/) const
//--------------------------------------------------------------------------------------------------
void Texture2D_FF::setupTextureParams(OpenGLContext* oglContext) const
{
CVF_ASSERT(oglContext);
CVF_CALLSITE_OPENGL(oglContext);
CVF_ASSERT(isBound(oglContext));
cvfGLint oglWrap = GL_REPEAT;
@@ -208,10 +209,10 @@ void Texture2D_FF::setupTextureParams(OpenGLContext* oglContext) const
cvfGLint oglMinFilter = filterTypeOpenGL(m_minFilter);
cvfGLint oglMagFilter = filterTypeOpenGL(m_magFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, oglWrap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, oglWrap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, oglMinFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, oglMagFilter);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, oglWrap);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, oglWrap);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, oglMinFilter);
cvfGL->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, oglMagFilter);
CVF_CHECK_OGL(oglContext);
}
Fwk/VizFwk/LibRender/cvfVertexAttribute.cpp
+8 -8
View File
@@ -94,7 +94,7 @@ void AttribSetupStrategyNormFloat::setupFromBufferObject(OpenGLContext* oglConte
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsOpenGL2());
glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_TRUE, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
cvfGL->glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_TRUE, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
}
@@ -107,7 +107,7 @@ void AttribSetupStrategyNormFloat::setupFromClientMemory(OpenGLContext* oglConte
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsOpenGL2());
glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_TRUE, 0, ptr);
cvfGL->glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_TRUE, 0, ptr);
}
@@ -133,7 +133,7 @@ void AttribSetupStrategyDirectFloat::setupFromBufferObject(OpenGLContext* oglCon
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsOpenGL2());
glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_FALSE, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
cvfGL->glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_FALSE, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
}
@@ -146,7 +146,7 @@ void AttribSetupStrategyDirectFloat::setupFromClientMemory(OpenGLContext* oglCon
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsOpenGL2());
glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_FALSE, 0, ptr);
cvfGL->glVertexAttribPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, GL_FALSE, 0, ptr);
}
@@ -175,7 +175,7 @@ void AttribSetupStrategyInt::setupFromBufferObject(OpenGLContext* oglContext, ui
if (oglContext->capabilities()->supportsOpenGLVer(3))
{
glVertexAttribIPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
cvfGL->glVertexAttribIPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, static_cast<GLsizei>(strideInBytes), CVF_OGL_BUFFER_OFFSET(bufferOffsetInBytes));
}
else
{
@@ -186,16 +186,16 @@ void AttribSetupStrategyInt::setupFromBufferObject(OpenGLContext* oglContext, ui
//--------------------------------------------------------------------------------------------------
/// Sets up vertex attribute pointer from client memory
///
///
/// \warning The caller must ensure that no buffer object is currently bound
//--------------------------------------------------------------------------------------------------
void AttribSetupStrategyInt::setupFromClientMemory(OpenGLContext* oglContext, uint vertexAttributeIndex, uint compCount, cvfGLenum compTypeOpenGL, const void* ptr)
void AttribSetupStrategyInt::setupFromClientMemory(OpenGLContext* oglContext, uint vertexAttributeIndex, uint compCount, cvfGLenum compTypeOpenGL, const void* ptr)
{
CVF_CALLSITE_OPENGL(oglContext);
if (oglContext->capabilities()->supportsOpenGLVer(3))
{
glVertexAttribIPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, 0, ptr);
cvfGL->glVertexAttribIPointer(static_cast<GLuint>(vertexAttributeIndex), static_cast<GLint>(compCount), compTypeOpenGL, 0, ptr);
}
else
{
Fwk/VizFwk/LibRender/cvfVertexBundle.cpp
+26 -26
View File
@@ -467,17 +467,17 @@ void VertexBundle::useBundle(OpenGLContext* oglContext, VertexBundleUsage* bundl
if (m_boVertices.notNull() && m_boVertices->isUploaded())
{
m_boVertices->bindBuffer(oglContext);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, 0);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, 0);
//m_attribVertices->setupAttribPointerBufferObject(oglContext, ShaderProgram::VERTEX, 0, 0);
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, m_attribVertices->arrayDataPtrVoid());
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, m_attribVertices->arrayDataPtrVoid());
//m_attribVertices->setupAttribPointerClientMemory(oglContext, ShaderProgram::VERTEX);
}
glEnableVertexAttribArray(ShaderProgram::VERTEX);
cvfGL->glEnableVertexAttribArray(ShaderProgram::VERTEX);
}
// Normals
@@ -486,17 +486,17 @@ void VertexBundle::useBundle(OpenGLContext* oglContext, VertexBundleUsage* bundl
if (m_boNormals.notNull() && m_boNormals->isUploaded())
{
m_boNormals->bindBuffer(oglContext);
glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, 0);
cvfGL->glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, 0);
//m_attribNormals->setupAttribPointerBufferObject(oglContext, ShaderProgram::NORMAL, 0, 0);
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, m_attribNormals->arrayDataPtrVoid());
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glVertexAttribPointer(ShaderProgram::NORMAL, 3, GL_FLOAT, GL_FALSE, 0, m_attribNormals->arrayDataPtrVoid());
//m_attribNormals->setupAttribPointerClientMemory(oglContext, ShaderProgram::NORMAL);
}
glEnableVertexAttribArray(ShaderProgram::NORMAL);
cvfGL->glEnableVertexAttribArray(ShaderProgram::NORMAL);
}
// TextureCoords
@@ -509,11 +509,11 @@ void VertexBundle::useBundle(OpenGLContext* oglContext, VertexBundleUsage* bundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
m_attribTextureCoords->setupAttribPointerClientMemory(oglContext, ShaderProgram::TEX_COORD_2F_0);
}
glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
cvfGL->glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0);
}
// Colors
@@ -526,11 +526,11 @@ void VertexBundle::useBundle(OpenGLContext* oglContext, VertexBundleUsage* bundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
m_attribColors->setupAttribPointerClientMemory(oglContext, ShaderProgram::COLOR);
}
glEnableVertexAttribArray(ShaderProgram::COLOR);
cvfGL->glEnableVertexAttribArray(ShaderProgram::COLOR);
}
// Setup the generic vertex attributes
@@ -552,11 +552,11 @@ void VertexBundle::useBundle(OpenGLContext* oglContext, VertexBundleUsage* bundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
va->setupAttribPointerClientMemory(oglContext, static_cast<uint>(attribLocationIndex));
}
glEnableVertexAttribArray(static_cast<GLuint>(attribLocationIndex));
cvfGL->glEnableVertexAttribArray(static_cast<GLuint>(attribLocationIndex));
bundleUsage->registerUsedGenAttrib(attribLocationIndex);
}
}
@@ -590,7 +590,7 @@ void VertexBundle::useBundleFixedFunction(OpenGLContext* oglContext, VertexBundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
const GLvoid* ptrOrOffset = m_attribVertices->arrayDataPtrVoid();
CVF_TIGHT_ASSERT(ptrOrOffset);
glVertexPointer(3, GL_FLOAT, 0, ptrOrOffset);
@@ -608,7 +608,7 @@ void VertexBundle::useBundleFixedFunction(OpenGLContext* oglContext, VertexBundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
const GLvoid* ptrOrOffset = m_attribNormals->arrayDataPtrVoid();
CVF_TIGHT_ASSERT(ptrOrOffset);
glNormalPointer(GL_FLOAT, 0, ptrOrOffset);
@@ -626,7 +626,7 @@ void VertexBundle::useBundleFixedFunction(OpenGLContext* oglContext, VertexBundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
const GLvoid* ptrOrOffset = m_attribTextureCoords->arrayDataPtrVoid();
CVF_TIGHT_ASSERT(ptrOrOffset);
glTexCoordPointer(2, GL_FLOAT, 0, ptrOrOffset);
@@ -644,12 +644,12 @@ void VertexBundle::useBundleFixedFunction(OpenGLContext* oglContext, VertexBundl
}
else
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, 0);
const GLvoid* ptrOrOffset = m_attribColors->arrayDataPtrVoid();
CVF_TIGHT_ASSERT(ptrOrOffset);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, ptrOrOffset);
}
glEnableClientState(GL_COLOR_ARRAY);
}
@@ -663,11 +663,12 @@ void VertexBundle::useBundleFixedFunction(OpenGLContext* oglContext, VertexBundl
void VertexBundle::finishUseBundle(OpenGLContext* oglContext, VertexBundleUsage* bundleUsage) const
{
CVF_TIGHT_ASSERT(bundleUsage);
CVF_CALLSITE_OPENGL(oglContext);
if (bundleUsage->fixedFunction())
{
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsFixedFunction());
if (m_vertexCount > 0) glDisableClientState(GL_VERTEX_ARRAY);
if (m_hasNormals) glDisableClientState(GL_NORMAL_ARRAY);
if (m_hasTexCoords) glDisableClientState(GL_TEXTURE_COORD_ARRAY);
@@ -675,19 +676,18 @@ void VertexBundle::finishUseBundle(OpenGLContext* oglContext, VertexBundleUsage*
}
else
{
CVF_CALLSITE_OPENGL(oglContext);
CVF_TIGHT_ASSERT(oglContext->capabilities()->supportsOpenGL2());
if (m_vertexCount > 0) glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::VERTEX));
if (m_hasNormals) glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::NORMAL));
if (m_hasTexCoords) glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::TEX_COORD_2F_0));
if (m_hasColors) glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::COLOR));
if (m_vertexCount > 0) cvfGL->glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::VERTEX));
if (m_hasNormals) cvfGL->glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::NORMAL));
if (m_hasTexCoords) cvfGL->glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::TEX_COORD_2F_0));
if (m_hasColors) cvfGL->glDisableVertexAttribArray(static_cast<GLuint>(ShaderProgram::COLOR));
if (m_hasGenericAttribs)
{
for (size_t i = 0; i < bundleUsage->usedGenAttribCount(); i++)
{
glDisableVertexAttribArray(static_cast<GLuint>(bundleUsage->usedGenAttrib(i)));
cvfGL->glDisableVertexAttribArray(static_cast<GLuint>(bundleUsage->usedGenAttrib(i)));
}
}
}
Fwk/VizFwk/LibRender/glew/GL/glew.h
-15507
View File
File diff suppressed because it is too large. Load diff
Fwk/VizFwk/LibRender/glew/GL/glxew.h
-1568
View File
File diff suppressed because it is too large. Load diff
Fwk/VizFwk/LibRender/glew/GL/wglew.h
-1361
View File
File diff suppressed because it is too large. Load diff
Fwk/VizFwk/LibRender/glew/glew.c
-15490
View File
File diff suppressed because it is too large. Load diff
Fwk/VizFwk/LibViewing/cvfRenderSequence.cpp
+6 -6
View File
@@ -323,15 +323,15 @@ void RenderSequence::preRenderApplyExpectedOpenGLState(OpenGLContext* oglContext
// ------------------------------------------------
if (oglCaps->supportsOpenGL2())
{
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
cvfGL->glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
glDisable(GL_STENCIL_TEST);
glDisable(GL_SCISSOR_TEST);
cvfGL->glDisable(GL_CULL_FACE);
cvfGL->glDisable(GL_BLEND);
cvfGL->glDisable(GL_STENCIL_TEST);
cvfGL->glDisable(GL_SCISSOR_TEST);
CVF_CHECK_OGL(oglContext);
Fwk/VizFwk/TestApps/Win32/Win32SnippetRunner/Win32SnippetRunner.cpp
-1
View File
@@ -43,7 +43,6 @@
#include "Win32PropertiesPanel.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include "SnippetFactoryBasis.h"
Fwk/VizFwk/Tests/SnippetsBasis/snipDepthPeelingFront.cpp
+84 -84
View File
@@ -227,73 +227,73 @@ void DepthPeelingFront::initRenderTargets(int width, int height)
{
CVF_CALLSITE_OPENGL(m_openGLContext.p());
glGenTextures(2, m_frontDepthTexId);
glGenTextures(2, m_frontColorTexId);
glGenFramebuffers(2, m_frontFboId);
cvfGL->glGenTextures(2, m_frontDepthTexId);
cvfGL->glGenTextures(2, m_frontColorTexId);
cvfGL->glGenFramebuffers(2, m_frontFboId);
for (int i = 0; i < 2; i++)
{
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[i]);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT32F, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[i]);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT32F, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
CVF_CHECK_OGL(m_openGLContext.p());
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontColorTexId[i]);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontColorTexId[i]);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
CVF_CHECK_OGL(m_openGLContext.p());
glBindFramebuffer(GL_FRAMEBUFFER, m_frontFboId[i]);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[i], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_frontColorTexId[i], 0);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_frontFboId[i]);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[i], 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_frontColorTexId[i], 0);
CVF_CHECK_OGL(m_openGLContext.p());
}
glGenTextures(1, &m_frontColorBlenderTexId);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontColorBlenderTexId);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
cvfGL->glGenTextures(1, &m_frontColorBlenderTexId);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_frontColorBlenderTexId);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
CVF_CHECK_OGL(m_openGLContext.p());
glGenFramebuffers(1, &m_frontColorBlenderFboId);
glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_frontColorBlenderTexId, 0);
cvfGL->glGenFramebuffers(1, &m_frontColorBlenderFboId);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_frontDepthTexId[0], 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_frontColorBlenderTexId, 0);
// Setup textures and frame/depth buffer for the opaque model
// -------------------------------------------------------------------------
glGenTextures(1, &m_solidModelDepthTexId);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_solidModelDepthTexId);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT32F, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
cvfGL->glGenTextures(1, &m_solidModelDepthTexId);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_solidModelDepthTexId);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT32F, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
CVF_CHECK_OGL(m_openGLContext.p());
glGenTextures(1, &m_solidModelColorTexId);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_solidModelColorTexId);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
cvfGL->glGenTextures(1, &m_solidModelColorTexId);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, m_solidModelColorTexId);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
cvfGL->glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
cvfGL->glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, 0);
CVF_CHECK_OGL(m_openGLContext.p());
glGenFramebuffers(1, &m_solidModelFboId);
glBindFramebuffer(GL_FRAMEBUFFER, m_solidModelFboId);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_solidModelDepthTexId, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_solidModelColorTexId, 0);
cvfGL->glGenFramebuffers(1, &m_solidModelFboId);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_solidModelFboId);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE_ARB, m_solidModelDepthTexId, 0);
cvfGL->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, m_solidModelColorTexId, 0);
CVF_CHECK_OGL(m_openGLContext.p());
}
@@ -365,35 +365,35 @@ void DepthPeelingFront::renderFrontToBackPeeling()
Color3f m_backgroundColor(1.0f, 1.0f, 1.0f);
// Some Qt versions leave this on!!
glDisable(GL_BLEND);
cvfGL->glDisable(GL_BLEND);
// ---------------------------------------------------------------------
// 0. Render solid model
// ---------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, m_solidModelFboId);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_solidModelFboId);
CVF_CHECK_OGL(m_openGLContext.p());
glDrawBuffer(GL_COLOR_ATTACHMENT0);
cvfGL->glDrawBuffer(GL_COLOR_ATTACHMENT0);
glClearColor(m_backgroundColor.r(), m_backgroundColor.g(), m_backgroundColor.b(), 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cvfGL->glClearColor(m_backgroundColor.r(), m_backgroundColor.g(), m_backgroundColor.b(), 1);
cvfGL->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
cvfGL->glEnable(GL_DEPTH_TEST);
m_progOpaque->useProgram(m_openGLContext.p());
drawModel(m_solidModel.p(), m_progOpaque.p());
glUseProgram(0);
cvfGL->glUseProgram(0);
// ---------------------------------------------------------------------
// 1. Initialize Min Depth Buffer
// ---------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
cvfGL->glDrawBuffer(GL_COLOR_ATTACHMENT0);
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cvfGL->glClearColor(0, 0, 0, 1);
cvfGL->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
cvfGL->glEnable(GL_DEPTH_TEST);
m_progInit->useProgram(m_openGLContext.p());
// Not accepted by llvm-gcc-4.2: m_progInit->applyUniform(UniformFloat("Alpha", m_opacity));
@@ -402,28 +402,28 @@ void DepthPeelingFront::renderFrontToBackPeeling()
bindTextureRECT(m_progInit.p(), "SolidDepthTex", m_solidModelDepthTexId, 0);
drawModel(m_transparentModel.p(), m_progInit.p());
glUseProgram(0);
cvfGL->glUseProgram(0);
CVF_CHECK_OGL(m_openGLContext.p());
// ---------------------------------------------------------------------
// 2. Depth Peeling + Blending
// ---------------------------------------------------------------------
for (int layer = 1; layer < m_numPasses; layer++)
for (int layer = 1; layer < m_numPasses; layer++)
{
// Peel one more layer
// ---------------------------------------------------------------------
int currId = layer % 2;
int prevId = 1 - currId;
glBindFramebuffer(GL_FRAMEBUFFER, m_frontFboId[currId]);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_frontFboId[currId]);
cvfGL->glDrawBuffer(GL_COLOR_ATTACHMENT0);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cvfGL->glClearColor(0, 0, 0, 0);
cvfGL->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
cvfGL->glDisable(GL_BLEND);
cvfGL->glEnable(GL_DEPTH_TEST);
m_progPeel->useProgram(m_openGLContext.p());
bindTextureRECT(m_progPeel.p(), "SolidDepthTex", m_solidModelDepthTexId, 0);
@@ -432,27 +432,27 @@ void DepthPeelingFront::renderFrontToBackPeeling()
UniformFloat uniform("Alpha", m_opacity);
m_progPeel->applyUniform(m_openGLContext.p(), uniform);
drawModel(m_transparentModel.p(), m_progPeel.p());
glUseProgram(0);
cvfGL->glUseProgram(0);
CVF_CHECK_OGL(m_openGLContext.p());
// Blend result
// ---------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_frontColorBlenderFboId);
cvfGL->glDrawBuffer(GL_COLOR_ATTACHMENT0);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
cvfGL->glDisable(GL_DEPTH_TEST);
cvfGL->glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFuncSeparate(GL_DST_ALPHA, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
cvfGL->glBlendEquation(GL_FUNC_ADD);
cvfGL->glBlendFuncSeparate(GL_DST_ALPHA, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
m_progBlend->useProgram(m_openGLContext.p());
bindTextureRECT(m_progBlend.p(), "TempTex", m_frontColorTexId[currId], 0);
drawQuad();
glUseProgram(0);
cvfGL->glUseProgram(0);
glDisable(GL_BLEND);
cvfGL->glDisable(GL_BLEND);
CVF_CHECK_OGL(m_openGLContext.p());
}
@@ -461,15 +461,15 @@ void DepthPeelingFront::renderFrontToBackPeeling()
// 3. Final Pass
// ---------------------------------------------------------------------
glBindFramebuffer(GL_FRAMEBUFFER, m_openGLContext->defaultFramebufferObject());
glDrawBuffer(GL_BACK);
glDisable(GL_DEPTH_TEST);
cvfGL->glBindFramebuffer(GL_FRAMEBUFFER, m_openGLContext->defaultFramebufferObject());
cvfGL->glDrawBuffer(GL_BACK);
cvfGL->glDisable(GL_DEPTH_TEST);
m_progFinal->useProgram(m_openGLContext.p());
bindTextureRECT(m_progFinal.p(), "ColorTex", m_frontColorBlenderTexId, 0);
bindTextureRECT(m_progFinal.p(), "BackgroundAndOpaqueTex", m_solidModelColorTexId, 1);
drawQuad();
glUseProgram(0);
cvfGL->glUseProgram(0);
CVF_CHECK_OGL(m_openGLContext.p());
}
@@ -482,14 +482,14 @@ void DepthPeelingFront::bindTextureRECT(ShaderProgram* shaderProgram, const char
{
CVF_CALLSITE_OPENGL(m_openGLContext.p());
glActiveTexture(GL_TEXTURE0 + texunit);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texid);
cvfGL->glActiveTexture(GL_TEXTURE0 + texunit);
cvfGL->glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texid);
// Not accepted by llvm-gcc-4.2: Not accepted by llvm-gcc-4.2: shaderProgram->applyUniform(UniformInt(texname, texunit));
UniformInt uniform(texname, texunit);
shaderProgram->applyUniform(m_openGLContext.p(), uniform);
glActiveTexture(GL_TEXTURE0);
cvfGL->glActiveTexture(GL_TEXTURE0);
}
@@ -536,7 +536,7 @@ void DepthPeelingFront::drawQuad()
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0.0, 1.0, 0.0, 1.0);
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glBegin(GL_QUADS);
{
glVertex2f(0.0, 0.0);
Fwk/VizFwk/Tests/SnippetsBasis/snipImmediateVbo.cpp
+9 -9
View File
@@ -87,18 +87,18 @@ ImmVbo::ImmVbo(OpenGLContext* oglContext)
ImmVbo::~ImmVbo()
{
CVF_CALLSITE_OPENGL(m_ctx);
glDeleteBuffers(1, &m_vboId);
cvfGL->glDeleteBuffers(1, &m_vboId);
}
void ImmVbo::init(unsigned int sizeInBytes)
{
CVF_CALLSITE_OPENGL(m_ctx);
glGenBuffers(1, &m_vboId);
cvfGL->glGenBuffers(1, &m_vboId);
glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
glBufferData(GL_ARRAY_BUFFER, sizeInBytes, NULL, GL_STATIC_DRAW);
cvfGL->glBufferData(GL_ARRAY_BUFFER, sizeInBytes, NULL, GL_STATIC_DRAW);
m_vboSize = sizeInBytes;
}
@@ -114,16 +114,16 @@ void* ImmVbo::mapWrite(unsigned int sizeInBytes)
return NULL;
}
glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
if (m_nextOffset + paddedSize >= m_vboSize)
{
glBufferData(GL_ARRAY_BUFFER, m_vboSize, NULL, GL_STATIC_DRAW);
cvfGL->glBufferData(GL_ARRAY_BUFFER, m_vboSize, NULL, GL_STATIC_DRAW);
m_nextOffset = 0;
m_lastOffset = 0;
}
void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, m_nextOffset, paddedSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
void* ptr = cvfGL->glMapBufferRange(GL_ARRAY_BUFFER, m_nextOffset, paddedSize, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
//void* ptr = glMapBufferRange(GL_ARRAY_BUFFER, m_nextOffset, paddedSize, GL_MAP_WRITE_BIT);
m_lastOffset = m_nextOffset;
@@ -138,9 +138,9 @@ void* ImmVbo::mapWrite(unsigned int sizeInBytes)
void ImmVbo::unmap()
{
CVF_CALLSITE_OPENGL(m_ctx);
glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
cvfGL->glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
glUnmapBuffer(GL_ARRAY_BUFFER);
cvfGL->glUnmapBuffer(GL_ARRAY_BUFFER);
}
Fwk/VizFwk/Tests/SnippetsBasis/snipIncrementalRenderer.cpp
+23 -23
View File
@@ -103,9 +103,9 @@ bool IncrementalRenderer::onInitialize()
}
// Create a frame-buffer object and a render-buffer object...
glGenFramebuffersEXT( 1, &m_frameBuffer );
glGenRenderbuffersEXT( 1, &m_depthRenderBuffer );
glGenTextures( 1, &m_dynamicTextureID);
cvfGL->glGenFramebuffers( 1, &m_frameBuffer );
cvfGL->glGenRenderbuffers( 1, &m_depthRenderBuffer );
cvfGL->glGenTextures( 1, &m_dynamicTextureID);
CVF_CHECK_OGL(m_openGLContext.p());
return true;
@@ -173,27 +173,27 @@ void IncrementalRenderer::onPaintEvent(PostEventAction* postEventAction)
// but without it the geometry will not be sorted properly.
if (m_renderBuffersDirty)
{
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_depthRenderBuffer );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, vpWidth, vpHeight);
cvfGL->glBindRenderbuffer( GL_RENDERBUFFER, m_depthRenderBuffer );
cvfGL->glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, vpWidth, vpHeight);
CVF_CHECK_OGL(m_openGLContext.p());
// Now, create our dynamic texture. It doesn't actually get loaded with any
// Now, create our dynamic texture. It doesn't actually get loaded with any
// pixel data, but its texture ID becomes associated with the pixel data
// contained in the frame-buffer object. This allows us to bind to this data
// like we would any regular texture.
glBindTexture( GL_TEXTURE_2D, m_dynamicTextureID);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vpWidth, vpHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
cvfGL->glBindTexture( GL_TEXTURE_2D, m_dynamicTextureID);
cvfGL->glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, vpWidth, vpHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0 );
cvfGL->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
cvfGL->glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
CVF_CHECK_OGL(m_openGLContext.p());
}
// Bind the frame-buffer object and attach to it a render-buffer object set up as a depth-buffer.
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_frameBuffer );
cvfGL->glBindFramebuffer( GL_FRAMEBUFFER, m_frameBuffer );
CVF_CHECK_OGL(m_openGLContext.p());
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthRenderBuffer );
cvfGL->glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthRenderBuffer );
CVF_CHECK_OGL(m_openGLContext.p());
glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_dynamicTextureID, 0 );
cvfGL->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_dynamicTextureID, 0 );
CVF_CHECK_OGL(m_openGLContext.p());
//
@@ -202,7 +202,7 @@ void IncrementalRenderer::onPaintEvent(PostEventAction* postEventAction)
m_renderSequence->render(m_openGLContext.p());
CVF_CHECK_OGL(m_openGLContext.p());
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
cvfGL->glBindFramebuffer( GL_FRAMEBUFFER, 0 );
CVF_CHECK_OGL(m_openGLContext.p());
// vp->set(0, 0, vpWidth, vpHeight);
@@ -213,26 +213,26 @@ void IncrementalRenderer::onPaintEvent(PostEventAction* postEventAction)
//glViewport(0, 0, vpWidth, vpHeight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, vpWidth, 0, vpHeight);
glOrtho(0, vpWidth, 0, vpHeight, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
glBindTexture( GL_TEXTURE_2D, m_dynamicTextureID );
glEnable(GL_TEXTURE_2D);
cvfGL->glDisable(GL_DEPTH_TEST);
cvfGL->glDisable(GL_CULL_FACE);
cvfGL->glDisable(GL_LIGHTING);
cvfGL->glBindTexture( GL_TEXTURE_2D, m_dynamicTextureID );
cvfGL->glEnable(GL_TEXTURE_2D);
CVF_CHECK_OGL(m_openGLContext.p());
glColor3f(1, 1, 1);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(1, 0);
glVertex2f((GLfloat)vp->width(), 0);