FCL/sf/mw/qt: comparison src/opengl/gl2paintengineex/qglengineshadermanager.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:2f34d5167611
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
 **
 // Compile up the simple shader:
 source.clear();
 source.append(qShaderSnippets[MainVertexShader]);
 source.append(qShaderSnippets[PositionOnlyVertexShader]);
 vertexShader = new QGLShader(QGLShader::Vertex, context, this);
-vertexShader->compileSourceCode(source);
+if (!vertexShader->compileSourceCode(source))
+qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile");
 source.clear();
 source.append(qShaderSnippets[MainFragmentShader]);
 source.append(qShaderSnippets[ShockingPinkSrcFragmentShader]);
 fragShader = new QGLShader(QGLShader::Fragment, context, this);
-fragShader->compileSourceCode(source);
+if (!fragShader->compileSourceCode(source))
+qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
 simpleShaderProg = new QGLShaderProgram(context, this);
 simpleShaderProg->addShader(vertexShader);
 simpleShaderProg->addShader(fragShader);
 simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
 simpleShaderProg->link();
 if (!simpleShaderProg->isLinked()) {
 qCritical() << "Errors linking simple shader:"
 << simpleShaderProg->log();
 }
 // Compile the blit shader:
 source.clear();
 source.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
 source.append(qShaderSnippets[UntransformedPositionVertexShader]);
 vertexShader = new QGLShader(QGLShader::Vertex, context, this);
-vertexShader->compileSourceCode(source);
+if (!vertexShader->compileSourceCode(source))
+qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile");
 source.clear();
 source.append(qShaderSnippets[MainFragmentShader]);
 source.append(qShaderSnippets[ImageSrcFragmentShader]);
 fragShader = new QGLShader(QGLShader::Fragment, context, this);
-fragShader->compileSourceCode(source);
+if (!fragShader->compileSourceCode(source))
+qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
 blitShaderProg = new QGLShaderProgram(context, this);
 blitShaderProg->addShader(vertexShader);
 blitShaderProg->addShader(fragShader);
 blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
 << simpleShaderProg->log();
 }
 }
+QGLEngineSharedShaders::~QGLEngineSharedShaders()
+{
+QList<QGLEngineShaderProg*>::iterator itr;
+for (itr = cachedPrograms.begin(); itr != cachedPrograms.end(); ++itr)
+delete *itr;
+if (blitShaderProg) {
+delete blitShaderProg;
+blitShaderProg = 0;
+}
+if (simpleShaderProg) {
+delete simpleShaderProg;
+simpleShaderProg = 0;
+}
+}
 #if defined (QT_DEBUG)
 QByteArray QGLEngineSharedShaders::snippetNameStr(SnippetName name)
 {
 QMetaEnum m = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("SnippetName"));
 return QByteArray(m.valueToKey(name));
 cachedPrograms.move(i, 0);
 return cachedProg;
 }
 }
-QByteArray source;
+QGLShader *vertexShader = 0;
-source.append(qShaderSnippets[prog.mainFragShader]);
+QGLShader *fragShader = 0;
-source.append(qShaderSnippets[prog.srcPixelFragShader]);
+QGLEngineShaderProg *newProg = 0;
-if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
+bool success = false;
-source.append(prog.customStageSource);
-if (prog.compositionFragShader)
+do {
-source.append(qShaderSnippets[prog.compositionFragShader]);
+QByteArray source;
-if (prog.maskFragShader)
+source.append(qShaderSnippets[prog.mainFragShader]);
-source.append(qShaderSnippets[prog.maskFragShader]);
+source.append(qShaderSnippets[prog.srcPixelFragShader]);
-QGLShader* fragShader = new QGLShader(QGLShader::Fragment, ctxGuard.context(), this);
+if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
-fragShader->compileSourceCode(source);
+source.append(prog.customStageSource);
+if (prog.compositionFragShader)
-source.clear();
+source.append(qShaderSnippets[prog.compositionFragShader]);
-source.append(qShaderSnippets[prog.mainVertexShader]);
+if (prog.maskFragShader)
-source.append(qShaderSnippets[prog.positionVertexShader]);
+source.append(qShaderSnippets[prog.maskFragShader]);
-QGLShader* vertexShader = new QGLShader(QGLShader::Vertex, ctxGuard.context(), this);
+fragShader = new QGLShader(QGLShader::Fragment, ctxGuard.context(), this);
-vertexShader->compileSourceCode(source);
+QByteArray description;
 #if defined(QT_DEBUG)
-// Name the shaders for easier debugging
+// Name the shader for easier debugging
-QByteArray description;
+description.append("Fragment shader: main=");
-description.append("Fragment shader: main=");
+description.append(snippetNameStr(prog.mainFragShader));
-description.append(snippetNameStr(prog.mainFragShader));
+description.append(", srcPixel=");
-description.append(", srcPixel=");
+description.append(snippetNameStr(prog.srcPixelFragShader));
-description.append(snippetNameStr(prog.srcPixelFragShader));
+if (prog.compositionFragShader) {
-if (prog.compositionFragShader) {
+description.append(", composition=");
-description.append(", composition=");
+description.append(snippetNameStr(prog.compositionFragShader));
-description.append(snippetNameStr(prog.compositionFragShader));
+}
-}
+if (prog.maskFragShader) {
-if (prog.maskFragShader) {
+description.append(", mask=");
-description.append(", mask=");
+description.append(snippetNameStr(prog.maskFragShader));
-description.append(snippetNameStr(prog.maskFragShader));
+}
-}
+fragShader->setObjectName(QString::fromLatin1(description));
-fragShader->setObjectName(QString::fromLatin1(description));
-description.clear();
-description.append("Vertex shader: main=");
-description.append(snippetNameStr(prog.mainVertexShader));
-description.append(", position=");
-description.append(snippetNameStr(prog.positionVertexShader));
-vertexShader->setObjectName(QString::fromLatin1(description));
 #endif
+if (!fragShader->compileSourceCode(source)) {
-QGLEngineShaderProg* newProg = new QGLEngineShaderProg(prog);
+qWarning() << "Warning:" << description << "failed to compile!";
+break;
-// If the shader program's not found in the cache, create it now.
+}
-newProg->program = new QGLShaderProgram(ctxGuard.context(), this);
-newProg->program->addShader(vertexShader);
+source.clear();
-newProg->program->addShader(fragShader);
+source.append(qShaderSnippets[prog.mainVertexShader]);
+source.append(qShaderSnippets[prog.positionVertexShader]);
-// We have to bind the vertex attribute names before the program is linked:
+vertexShader = new QGLShader(QGLShader::Vertex, ctxGuard.context(), this);
-newProg->program->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
-if (newProg->useTextureCoords)
-newProg->program->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
-if (newProg->useOpacityAttribute)
-newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
-newProg->program->link();
-if (!newProg->program->isLinked()) {
-QLatin1String none("none");
-QLatin1String br("\n");
-QString error;
-error = QLatin1String("Shader program failed to link,")
 #if defined(QT_DEBUG)
-+ br
+// Name the shader for easier debugging
-+ QLatin1String("  Shaders Used:") + br
+description.clear();
-+ QLatin1String("    ") + vertexShader->objectName() + QLatin1String(": ") + br
+description.append("Vertex shader: main=");
-+ QLatin1String(vertexShader->sourceCode()) + br
+description.append(snippetNameStr(prog.mainVertexShader));
-+ QLatin1String("    ") + fragShader->objectName() + QLatin1String(": ") + br
+description.append(", position=");
-+ QLatin1String(fragShader->sourceCode()) + br
+description.append(snippetNameStr(prog.positionVertexShader));
+vertexShader->setObjectName(QString::fromLatin1(description));
 #endif
-+ QLatin1String("  Error Log:\n")
+if (!vertexShader->compileSourceCode(source)) {
-+ QLatin1String("    ") + newProg->program->log();
+qWarning() << "Warning:" << description << "failed to compile!";
-qWarning() << error;
+break;
-delete newProg; // Deletes the QGLShaderProgram in it's destructor
+}
-newProg = 0;
-}
+newProg = new QGLEngineShaderProg(prog);
-else {
+// If the shader program's not found in the cache, create it now.
+newProg->program = new QGLShaderProgram(ctxGuard.context(), this);
+newProg->program->addShader(vertexShader);
+newProg->program->addShader(fragShader);
+// We have to bind the vertex attribute names before the program is linked:
+newProg->program->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
+if (newProg->useTextureCoords)
+newProg->program->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
+if (newProg->useOpacityAttribute)
+newProg->program->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
+if (newProg->usePmvMatrix) {
+newProg->program->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
+newProg->program->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
+newProg->program->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
+}
+newProg->program->link();
+if (!newProg->program->isLinked()) {
+QLatin1String none("none");
+QLatin1String br("\n");
+QString error;
+error = QLatin1String("Shader program failed to link,")
+#if defined(QT_DEBUG)
++ br
++ QLatin1String("  Shaders Used:") + br
++ QLatin1String("    ") + vertexShader->objectName() + QLatin1String(": ") + br
++ QLatin1String(vertexShader->sourceCode()) + br
++ QLatin1String("    ") + fragShader->objectName() + QLatin1String(": ") + br
++ QLatin1String(fragShader->sourceCode()) + br
+#endif
++ QLatin1String("  Error Log:\n")
++ QLatin1String("    ") + newProg->program->log();
+qWarning() << error;
+break;
+}
 if (cachedPrograms.count() > 30) {
 // The cache is full, so delete the last 5 programs in the list.
 // These programs will be least used, as a program us bumped to
 // the top of the list when it's used.
 for (int i = 0; i < 5; ++i) {
 cachedPrograms.removeLast();
 }
 }
 cachedPrograms.insert(0, newProg);
+success = true;
+} while (false);
+// Clean up everything if we weren't successful
+if (!success) {
+if (newProg) {
+delete newProg; // Also deletes the QGLShaderProgram which in turn deletes the QGLShaders
+newProg = 0;
+}
+else {
+if (vertexShader)
+delete vertexShader;
+if (fragShader)
+delete fragShader;
+}
 }
 return newProg;
 }
 {
 //###
 removeCustomStage();
 }
-uint QGLEngineShaderManager::getUniformLocation(Uniform id)
+GLuint QGLEngineShaderManager::getUniformLocation(Uniform id)
 {
+if (!currentShaderProg)
+return 0;
 QVector<uint> &uniformLocations = currentShaderProg->uniformLocations;
 if (uniformLocations.isEmpty())
 uniformLocations.fill(GLuint(-1), NumUniforms);
 static const char *uniformNames[] = {
 "imageTexture",
 "patternColor",
 "globalOpacity",
 "depth",
-"pmvMatrix",
 "maskTexture",
 "fragmentColor",
 "linearData",
 "angle",
 "halfViewportSize",
 return uniformLocations.at(id);
 }
-void QGLEngineShaderManager::optimiseForBrushTransform(const QTransform &transform)
+void QGLEngineShaderManager::optimiseForBrushTransform(QTransform::TransformationType transformType)
 {
-Q_UNUSED(transform); // Currently ignored
+Q_UNUSED(transformType); // Currently ignored
 }
 void QGLEngineShaderManager::setDirty()
 {
 shaderProgNeedsChanging = true;
 shaderProgNeedsChanging = true;
 }
 QGLShaderProgram* QGLEngineShaderManager::currentProgram()
 {
-return currentShaderProg->program;
+if (currentShaderProg)
+return currentShaderProg->program;
+else
+return sharedShaders->simpleProgram();
+}
+void QGLEngineShaderManager::useSimpleProgram()
+{
+sharedShaders->simpleProgram()->bind();
+QGLContextPrivate* ctx_d = ctx->d_func();
+ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
+ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+shaderProgNeedsChanging = true;
+}
+void QGLEngineShaderManager::useBlitProgram()
+{
+sharedShaders->blitProgram()->bind();
+QGLContextPrivate* ctx_d = ctx->d_func();
+ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, true);
+ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
+shaderProgNeedsChanging = true;
 }
 QGLShaderProgram* QGLEngineShaderManager::simpleProgram()
 {
 return sharedShaders->simpleProgram();
 } else {
 requiredProgram.mainVertexShader = QGLEngineSharedShaders::MainVertexShader;
 }
 requiredProgram.useTextureCoords = texCoords;
 requiredProgram.useOpacityAttribute = (opacityMode == AttributeOpacity);
+requiredProgram.usePmvMatrix = true;
 // At this point, requiredProgram is fully populated so try to find the program in the cache
 currentShaderProg = sharedShaders->findProgramInCache(requiredProgram);
 if (currentShaderProg) {
 currentShaderProg->program->bind();
 if (useCustomSrc)
 customSrcStage->setUniforms(currentShaderProg->program);
 }
+// Make sure all the vertex attribute arrays the program uses are enabled (and the ones it
+// doesn't use are disabled)
+QGLContextPrivate* ctx_d = ctx->d_func();
+ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
+ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, currentShaderProg->useTextureCoords);
+ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, currentShaderProg->useOpacityAttribute);
 shaderProgNeedsChanging = false;
 return true;
 }
 QT_END_NAMESPACE

changeset 18	2f34d5167611
parent 3	41300fa6a67c
child 25	e24348a560a6