qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added an example that shows how to consume texture providers from C++. 

And how to use use two textures in the same material.

Change-Id: Idcc618ed359422c2a104eeed105b7c4f5086ee4e
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
This commit is contained in:
Gunnar Sletta 2014-08-22 16:52:05 +02:00
parent 3035fd9ad9
commit 1075dca1b5
10 changed files with 610 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
examples/quick/scenegraph/scenegraph.pro
View File

@ -6,4 +6,5 @@ SUBDIRS += \
simplematerial \
textureinsgnode \
textureinthread \
threadedanimation
threadedanimation \
twotextureproviders

BIN
examples/quick/scenegraph/twotextureproviders/doc/images/twotextureproviders-example.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 44 KiB

36
examples/quick/scenegraph/twotextureproviders/doc/src/twotextureproviders.qdoc Normal file
View File

@ -0,0 +1,36 @@
/****************************************************************************
**
** Copyright (C) 2014 Gunnar Sletta <gunnar@sletta.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Free Documentation License Usage
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file. Please review the following information to ensure
** the GNU Free Documentation License version 1.3 requirements
** will be met: http://www.gnu.org/copyleft/fdl.html.
** $QT_END_LICENSE$
**
****************************************************************************/
/*!
\example scenegraph/twotextureproviders
\title Scene Graph - Two Texture Providers
\ingroup qtquickexamples
\brief Shows how to combine two textures from two texture providers in a custom scene graph node.
\image twotextureproviders-example.jpg
*/

59
examples/quick/scenegraph/twotextureproviders/main.cpp Normal file
View File

@ -0,0 +1,59 @@
/****************************************************************************
**
** Copyright (C) 2014 Gunnar Sletta <gunnar@sletta.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
** of its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QGuiApplication>
#include <QtQuick/QQuickView>
#include "xorblender.h"
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
qmlRegisterType<XorBlender>("SceneGraphRendering", 1, 0, "XorBlender");
QQuickView view;
view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl("qrc:///scenegraph/twotextureproviders/main.qml"));
view.show();
return app.exec();
}

146
examples/quick/scenegraph/twotextureproviders/main.qml Normal file
View File

@ -0,0 +1,146 @@
/****************************************************************************
**
** Copyright (C) 2014 Gunnar Sletta <gunnar@sletta.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
** of its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
import QtQuick 2.2
import SceneGraphRendering 1.0
Item {
id: root
// The checkers background
ShaderEffect {
anchors.fill: parent
property real tileSize: 16
property color color1: Qt.rgba(0.9, 0.9, 0.9, 1);
property color color2: Qt.rgba(0.8, 0.8, 0.8, 1);
property size pixelSize: Qt.size(width / tileSize, height / tileSize);
fragmentShader:
"
uniform lowp vec4 color1;
uniform lowp vec4 color2;
uniform highp vec2 pixelSize;
varying highp vec2 qt_TexCoord0;
void main() {
highp vec2 tc = sign(sin(3.14152 * qt_TexCoord0 * pixelSize));
if (tc.x != tc.y)
gl_FragColor = color1;
else
gl_FragColor = color2;
}
"
}
width: 320
height: 480
Item {
id: box
width: root.width * 0.9
height: width
Rectangle {
anchors.centerIn: parent
width: parent.width * 0.9
height: parent.width * 0.4
radius: width * 0.1;
gradient: Gradient {
GradientStop { position: 0; color: Qt.hsla(0.6, 0.9, 0.9, 1); }
GradientStop { position: 1; color: Qt.hsla(0.6, 0.6, 0.3, 1); }
}
RotationAnimator on rotation { from: 0; to: 360; duration: 10000; loops: Animation.Infinite }
}
visible: false
layer.enabled: true
}
Item {
id: text
width: box.width
height: width
Text {
anchors.centerIn: parent
color: "black" // Qt.hsla(0.8, 0.8, 0.8);
text: "Qt\nQuick"
horizontalAlignment: Text.AlignHCenter
font.bold: true
font.pixelSize: text.width * 0.25
RotationAnimator on rotation { from: 360; to: 0; duration: 9000; loops: Animation.Infinite }
}
visible: false
layer.enabled: true
}
XorBlender {
anchors.horizontalCenter: parent.horizontalCenter
y: root.height * 0.05;
width: box.width
height: box.height
source1: box
source2: text
}
Rectangle {
id: labelFrame
anchors.margins: -10
radius: 10
color: "white"
border.color: "black"
opacity: 0.8
anchors.fill: description
}
Text {
id: description
anchors.left: parent.left
anchors.right: parent.right
anchors.bottom: parent.bottom
anchors.margins: 20
wrapMode: Text.WordWrap
text: "This example creates two animated items and sets 'layer.enabled: true' on both of them. " +
"This turns the items into texture providers and we can access their texture from C++ in a custom material. " +
"The XorBlender is a custom C++ item which uses performs an Xor blend between them."
}
}

12
examples/quick/scenegraph/twotextureproviders/twotextureproviders.pro Normal file
View File

@ -0,0 +1,12 @@
QT += qml quick
HEADERS += xorblender.h
SOURCES += xorblender.cpp main.cpp
RESOURCES += twotextureproviders.qrc
target.path = $$[QT_INSTALL_EXAMPLES]/quick/scenegraph/twotextureproviders
INSTALLS += target
OTHER_FILES += \
main.qml

5
examples/quick/scenegraph/twotextureproviders/twotextureproviders.qrc Normal file
View File

@ -0,0 +1,5 @@
<RCC>
<qresource prefix="/scenegraph/twotextureproviders">
<file>main.qml</file>
</qresource>
</RCC>

272
examples/quick/scenegraph/twotextureproviders/xorblender.cpp Normal file
View File

@ -0,0 +1,272 @@
/****************************************************************************
**
** Copyright (C) 2014 Gunnar Sletta <gunnar@sletta.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
** of its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "xorblender.h"
#include <QtCore/QPointer>
#include <QtGui/QOpenGLContext>
#include <QtGui/QOpenGLFunctions>
#include <QtQuick/QSGSimpleMaterial>
#include <QtQuick/QSGTexture>
#include <QtQuick/QSGGeometryNode>
#include <QtQuick/QSGTextureProvider>
/* This example could just as well have been implemented all in QML using
* a ShaderEffect, and for 90% of all usecases, using a ShaderEffect will
* be sufficient. This example exists to illustrate how to consume
* texture providers from C++ and how to use multiple texture sources in
* a custom material.
*/
struct XorBlendState {
QSGTexture *texture1;
QSGTexture *texture2;
};
class XorBlendShader : public QSGSimpleMaterialShader<XorBlendState>
{
QSG_DECLARE_SIMPLE_SHADER(XorBlendShader, XorBlendState)
public:
const char *vertexShader() const {
return
"attribute highp vec4 aVertex; \n"
"attribute highp vec2 aTexCoord; \n"
"uniform highp mat4 qt_Matrix; \n"
"varying highp vec2 vTexCoord; \n"
"void main() { \n"
" gl_Position = qt_Matrix * aVertex; \n"
" vTexCoord = aTexCoord; \n"
"}";
}
const char *fragmentShader() const {
return
"uniform lowp float qt_Opacity; \n"
"uniform lowp sampler2D uSource1; \n"
"uniform lowp sampler2D uSource2; \n"
"varying highp vec2 vTexCoord; \n"
"void main() { \n"
" lowp vec4 p1 = texture2D(uSource1, vTexCoord); \n"
" lowp vec4 p2 = texture2D(uSource2, vTexCoord); \n"
" gl_FragColor = (p1 * (1.0 - p2.a) + p2 * (1.0 - p1.a)) * qt_Opacity; \n"
"}";
}
QList<QByteArray> attributes() const {
return QList<QByteArray>() << "aVertex" << "aTexCoord";
}
void updateState(const XorBlendState *state, const XorBlendState *) {
QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
// We bind the textures in inverse order so that we leave the updateState
// function with GL_TEXTURE0 as the active texture unit. This is maintain
// the "contract" that updateState should not mess up the GL state beyond
// what is needed for this material.
f->glActiveTexture(GL_TEXTURE1);
state->texture2->bind();
f->glActiveTexture(GL_TEXTURE0);
state->texture1->bind();
}
void resolveUniforms() {
// The texture units never change, only the texturess we bind to them so
// we set these once and for all here.
program()->setUniformValue("uSource1", 0); // GL_TEXTURE0
program()->setUniformValue("uSource2", 1); // GL_TEXTURE1
}
};
/* The rendering is split into two nodes. The top-most node is not actually
* rendering anything, but is responsible for managing the texture providers.
* The XorNode also has a geometry node internally which it uses to render
* the texture providers using the XorBlendShader when all providers and
* textures are all present.
*
* The texture providers are updated solely on the render thread (when rendering
* is happening on a separate thread). This is why we are using preprocess
* and direct signals between the the texture providers and the node rather
* than updating state in updatePaintNode.
*/
class XorNode : public QObject, public QSGNode
{
Q_OBJECT
public:
XorNode(QSGTextureProvider *p1, QSGTextureProvider *p2)
: m_provider1(p1)
, m_provider2(p2)
{
setFlag(QSGNode::UsePreprocess, true);
// Set up material so it is all set for later..
m_material = XorBlendShader::createMaterial();
m_material->state()->texture1 = 0;
m_material->state()->texture2 = 0;
m_material->setFlag(QSGMaterial::Blending);
m_node.setMaterial(m_material);
m_node.setFlag(QSGNode::OwnsMaterial);
// Set up geometry, actual vertices will be initialized in updatePaintNode
m_node.setGeometry(new QSGGeometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4));
m_node.setFlag(QSGNode::OwnsGeometry);
// If this node is used as in a shader effect source, we need to propegate
// changes that will occur in this node outwards.
connect(m_provider1, SIGNAL(textureChanged()), this, SLOT(textureChange()), Qt::DirectConnection);
connect(m_provider2, SIGNAL(textureChanged()), this, SLOT(textureChange()), Qt::DirectConnection);
}
void preprocess() {
XorBlendState *state = m_material->state();
// Update the textures from the providers, calling into QSGDynamicTexture if required
if (m_provider1) {
state->texture1 = m_provider1->texture();
if (QSGDynamicTexture *dt1 = qobject_cast<QSGDynamicTexture *>(state->texture1))
dt1->updateTexture();
}
if (m_provider2) {
state->texture2 = m_provider2->texture();
if (QSGDynamicTexture *dt2 = qobject_cast<QSGDynamicTexture *>(state->texture2))
dt2->updateTexture();
}
// Remove node from the scene graph if it is there and either texture is missing...
if (m_node.parent() && (!state->texture1 || !state->texture2))
removeChildNode(&m_node);
// Add it if it is not already there and both textures are present..
else if (!m_node.parent() && state->texture1 && state->texture2)
appendChildNode(&m_node);
}
void setRect(const QRectF &rect) {
// Update geometry if it has changed and mark the change in the scene graph.
if (m_rect != rect) {
m_rect = rect;
QSGGeometry::updateTexturedRectGeometry(m_node.geometry(), m_rect, QRectF(0, 0, 1, 1));
m_node.markDirty(QSGNode::DirtyGeometry);
}
}
public slots:
void textureChange() {
// When our sources change, we will look different, so signal the change to the
// scene graph.
markDirty(QSGNode::DirtyMaterial);
}
private:
QRectF m_rect;
QSGSimpleMaterial<XorBlendState> *m_material;
QSGGeometryNode m_node;
QPointer<QSGTextureProvider> m_provider1;
QPointer<QSGTextureProvider> m_provider2;
};
XorBlender::XorBlender(QQuickItem *parent)
: QQuickItem(parent)
, m_source1(0)
, m_source2(0)
, m_source1Changed(false)
, m_source2Changed(false)
{
setFlag(ItemHasContents, true);
}
void XorBlender::setSource1(QQuickItem *i)
{
if (i == m_source1)
return;
m_source1 = i;
emit source1Changed(m_source1);
m_source1Changed = true;
update();
}
void XorBlender::setSource2(QQuickItem *i)
{
if (i == m_source2)
return;
m_source2 = i;
emit source2Changed(m_source2);
m_source2Changed = true;
update();
}
QSGNode *XorBlender::updatePaintNode(QSGNode *old, UpdatePaintNodeData *)
{
// Check if our input is valid and abort if not, deleting the old node.
bool abort = false;
if (!m_source1 || !m_source1->isTextureProvider()) {
qDebug() << "source1 is missing or not a texture provider";
abort = true;
}
if (!m_source2 || !m_source2->isTextureProvider()) {
qDebug() << "source2 is missing or not a texture provider";
abort = true;
}
if (abort) {
delete old;
return 0;
}
XorNode *node = static_cast<XorNode *>(old);
// If the sources have changed, recreate the nodes
if (m_source1Changed || m_source2Changed) {
delete node;
node = 0;
m_source1Changed = false;
m_source2Changed = false;
}
// Create a new XorNode for us to render with.
if (!node)
node = new XorNode(m_source1->textureProvider(), m_source2->textureProvider());
// Update the geometry of the node to match the new bounding rect
node->setRect(boundingRect());
return node;
}
#include "xorblender.moc"

76
examples/quick/scenegraph/twotextureproviders/xorblender.h Normal file
View File

@ -0,0 +1,76 @@
/****************************************************************************
**
** Copyright (C) 2014 Gunnar Sletta <gunnar@sletta.org>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
** of its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef XORBLENDER_H
#define XORBLENDER_H
#include <QQuickItem>
class XorBlender : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QQuickItem *source1 READ source1 WRITE setSource1 NOTIFY source1Changed)
Q_PROPERTY(QQuickItem *source2 READ source2 WRITE setSource2 NOTIFY source2Changed)
public:
explicit XorBlender(QQuickItem *parent = 0);
QQuickItem *source1() const { return m_source1; }
QQuickItem *source2() const { return m_source2; }
void setSource1(QQuickItem *i);
void setSource2(QQuickItem *i);
protected:
QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
signals:
void source1Changed(QQuickItem *item);
void source2Changed(QQuickItem *item);
private:
QQuickItem *m_source1;
QQuickItem *m_source2;
bool m_source1Changed;
bool m_source2Changed;
};
#endif // XORBLENDER_H

2
src/quick/scenegraph/util/qsgtextureprovider.cpp
View File

@ -40,6 +40,8 @@ QT_BEGIN_NAMESPACE
\brief The QSGTextureProvider class encapsulates texture based entities in QML.
The QSGTextureProvider lives primarily in the scene graph rendering thread.
\sa {Scene Graph - Two Texture Providers}
*/