QT_BEGIN_NAMESPACE
-static bool nodeLessThan(QSGGeometryNode *a, QSGGeometryNode *b)
+static bool nodeLessThan(QSGNode *nodeA, QSGNode *nodeB)
{
+ if (nodeA->type() != nodeB->type())
+ return nodeA->type() < nodeB->type();
+ if (nodeA->type() != QSGNode::GeometryNodeType)
+ return nodeA < nodeB;
+ QSGGeometryNode *a = static_cast<QSGGeometryNode *>(nodeA);
+ QSGGeometryNode *b = static_cast<QSGGeometryNode *>(nodeA);
+
// Sort by clip...
if (a->clipList() != b->clipList())
return a->clipList() < b->clipList();
return a->matrix() < b->matrix();
}
-static bool nodeLessThanWithRenderOrder(QSGGeometryNode *a, QSGGeometryNode *b)
+static bool nodeLessThanWithRenderOrder(QSGNode *nodeA, QSGNode *nodeB)
{
+ if (nodeA->type() != nodeB->type())
+ return nodeA->type() < nodeB->type();
+ if (nodeA->type() != QSGNode::GeometryNodeType)
+ return nodeA < nodeB;
+ QSGGeometryNode *a = static_cast<QSGGeometryNode *>(nodeA);
+ QSGGeometryNode *b = static_cast<QSGGeometryNode *>(nodeA);
+
// Sort by clip...
if (a->clipList() != b->clipList())
return a->clipList() < b->clipList();
}
-QSGDefaultRenderer::IndexGeometryNodePair::IndexGeometryNodePair(int i, QSGGeometryNode *node)
- : QPair<int, QSGGeometryNode *>(i, node)
+QSGDefaultRenderer::IndexNodePair::IndexNodePair(int i, QSGNode *node)
+ : QPair<int, QSGNode *>(i, node)
{
}
-bool QSGDefaultRenderer::IndexGeometryNodePair::operator < (const QSGDefaultRenderer::IndexGeometryNodePair &other) const
+bool QSGDefaultRenderer::IndexNodePair::operator < (const QSGDefaultRenderer::IndexNodePair &other) const
{
return nodeLessThan(second, other.second);
}
-QSGDefaultRenderer::IndexGeometryNodePairHeap::IndexGeometryNodePairHeap()
+QSGDefaultRenderer::IndexNodePairHeap::IndexNodePairHeap()
: v(64)
{
}
-void QSGDefaultRenderer::IndexGeometryNodePairHeap::insert(const QSGDefaultRenderer::IndexGeometryNodePair &x)
+void QSGDefaultRenderer::IndexNodePairHeap::insert(const QSGDefaultRenderer::IndexNodePair &x)
{
int i = v.size();
v.add(x);
}
}
-QSGDefaultRenderer::IndexGeometryNodePair QSGDefaultRenderer::IndexGeometryNodePairHeap::pop()
+QSGDefaultRenderer::IndexNodePair QSGDefaultRenderer::IndexNodePairHeap::pop()
{
- IndexGeometryNodePair x = top();
+ IndexNodePair x = top();
if (v.size() > 1)
qSwap(v.first(), v.last());
v.pop_back();
, m_opaqueNodes(64)
, m_transparentNodes(64)
, m_tempNodes(64)
+ , m_renderGroups(4)
, m_rebuild_lists(false)
, m_needs_sorting(false)
, m_sort_front_to_back(false)
+ , m_render_node_added(false)
, m_currentRenderOrder(1)
{
QStringList args = qApp->arguments();
if (m_rebuild_lists) {
m_opaqueNodes.reset();
m_transparentNodes.reset();
+ m_renderGroups.reset();
m_currentRenderOrder = 1;
buildLists(rootNode());
m_rebuild_lists = false;
+ m_render_node_added = false;
+ RenderGroup group = { m_opaqueNodes.size(), m_transparentNodes.size() };
+ m_renderGroups.add(group);
}
#ifdef RENDERER_DEBUG
int debugtimeLists = debugTimer.elapsed();
#endif
-
if (m_needs_sorting) {
if (!m_opaqueNodes.isEmpty()) {
- qSort(&m_opaqueNodes.first(), &m_opaqueNodes.first() + m_opaqueNodes.size(),
- m_sort_front_to_back
- ? nodeLessThanWithRenderOrder
- : nodeLessThan);
+ bool (*lessThan)(QSGNode *, QSGNode *);
+ lessThan = m_sort_front_to_back ? nodeLessThanWithRenderOrder : nodeLessThan;
+ int start = 0;
+ for (int i = 0; i < m_renderGroups.size(); ++i) {
+ int end = m_renderGroups.at(i).opaqueEnd;
+ if (end != start)
+ qSort(&m_opaqueNodes.first() + start, &m_opaqueNodes.first() + end, lessThan);
+ start = end;
+ }
}
m_needs_sorting = false;
}
m_renderOrderMatrix.setToIdentity();
m_renderOrderMatrix.scale(1, 1, qreal(1) / m_currentRenderOrder);
- glDisable(GL_BLEND);
- glDepthMask(true);
+ int opaqueStart = 0;
+ int transparentStart = 0;
+ for (int i = 0; i < m_renderGroups.size(); ++i) {
+ int opaqueEnd = m_renderGroups.at(i).opaqueEnd;
+ int transparentEnd = m_renderGroups.at(i).transparentEnd;
+
+ glDisable(GL_BLEND);
+ glDepthMask(true);
#ifdef QML_RUNTIME_TESTING
- if (m_render_opaque_nodes)
+ if (m_render_opaque_nodes)
#endif
- {
+ {
#if defined (QML_RUNTIME_TESTING)
- if (dumpTree)
- qDebug() << "Opaque Nodes:";
-#endif
- renderNodes(m_opaqueNodes);
- }
-
-#ifdef RENDERER_DEBUG
- int debugtimeOpaque = debugTimer.elapsed();
- int opaqueNodes = geometryNodesDrawn;
- int opaqueMaterialChanges = materialChanges;
+ if (dumpTree)
+ qDebug() << "Opaque Nodes:";
#endif
+ if (opaqueEnd != opaqueStart)
+ renderNodes(&m_opaqueNodes.first() + opaqueStart, opaqueEnd - opaqueStart);
+ }
- glEnable(GL_BLEND);
- glDepthMask(false);
+ glEnable(GL_BLEND);
+ glDepthMask(false);
#ifdef QML_RUNTIME_TESTING
- if (m_render_alpha_nodes)
+ if (m_render_alpha_nodes)
#endif
- {
+ {
#if defined (QML_RUNTIME_TESTING)
- if (dumpTree)
- qDebug() << "Alpha Nodes:";
+ if (dumpTree)
+ qDebug() << "Alpha Nodes:";
#endif
- renderNodes(m_transparentNodes);
+ if (transparentEnd != transparentStart)
+ renderNodes(&m_transparentNodes.first() + transparentStart, transparentEnd - transparentStart);
+ }
+
+ opaqueStart = opaqueEnd;
+ transparentStart = transparentEnd;
}
#ifdef RENDERER_DEBUG
- int debugtimeAlpha = debugTimer.elapsed();
+ int debugtimeRender = debugTimer.elapsed();
#endif
-
if (m_currentProgram)
m_currentProgram->deactivate();
#ifdef RENDERER_DEBUG
if (debugTimer.elapsed() > DEBUG_THRESHOLD) {
printf(" --- Renderer breakdown:\n"
- " - setup=%d, clear=%d, building=%d, sorting=%d, opaque=%d, alpha=%d\n"
- " - material changes: opaque=%d, alpha=%d, total=%d\n"
- " - geometry ndoes: opaque=%d, alpha=%d, total=%d\n",
+ " - setup=%d, clear=%d, building=%d, sorting=%d, render=%d\n"
+ " - material changes: total=%d\n"
+ " - geometry nodes: total=%d\n",
debugtimeSetup,
debugtimeClear - debugtimeSetup,
debugtimeLists - debugtimeClear,
debugtimeSorting - debugtimeLists,
- debugtimeOpaque - debugtimeSorting,
- debugtimeAlpha - debugtimeOpaque,
- opaqueMaterialChanges, materialChanges - opaqueMaterialChanges, materialChanges,
- opaqueNodes, geometryNodesDrawn - opaqueNodes, geometryNodesDrawn);
+ debugtimeRender - debugtimeSorting,
+ materialChanges,
+ geometryNodesDrawn);
}
#endif
geomNode->setRenderOrder(m_currentRenderOrder - 1);
m_transparentNodes.add(geomNode);
} else {
+ if (m_render_node_added) {
+ // Start new group of nodes so that this opaque node is render on top of the
+ // render node.
+ RenderGroup group = { m_opaqueNodes.size(), m_transparentNodes.size() };
+ m_renderGroups.add(group);
+ m_render_node_added = false;
+ }
geomNode->setRenderOrder(m_currentRenderOrder);
m_opaqueNodes.add(geomNode);
m_currentRenderOrder += 2;
}
+ } else if (node->type() == QSGNode::RenderNodeType) {
+ QSGRenderNode *renderNode = static_cast<QSGRenderNode *>(node);
+ m_transparentNodes.add(renderNode);
+ m_render_node_added = true;
}
if (!node->firstChild())
QVarLengthArray<int, 16> beginIndices;
QVarLengthArray<int, 16> endIndices;
int baseCount = m_transparentNodes.size();
+ int baseGroupCount = m_renderGroups.size();
int count = 0;
for (QSGNode *c = node->firstChild(); c; c = c->nextSibling()) {
beginIndices.append(m_transparentNodes.size());
}
int childNodeCount = m_transparentNodes.size() - baseCount;
- if (childNodeCount) {
+ // Don't reorder if new render groups were added.
+ if (m_renderGroups.size() == baseGroupCount && childNodeCount) {
m_tempNodes.reset();
m_tempNodes.reserve(childNodeCount);
while (childNodeCount) {
for (int i = 0; i < count; ++i) {
if (beginIndices[i] != endIndices[i])
- m_heap.insert(IndexGeometryNodePair(i, m_transparentNodes.at(beginIndices[i]++)));
+ m_heap.insert(IndexNodePair(i, m_transparentNodes.at(beginIndices[i]++)));
}
while (!m_heap.isEmpty()) {
- IndexGeometryNodePair pair = m_heap.pop();
+ IndexNodePair pair = m_heap.pop();
m_tempNodes.add(pair.second);
--childNodeCount;
int i = pair.first;
if (beginIndices[i] != endIndices[i] && !nodeLessThan(m_transparentNodes.at(beginIndices[i]), pair.second))
- m_heap.insert(IndexGeometryNodePair(i, m_transparentNodes.at(beginIndices[i]++)));
+ m_heap.insert(IndexNodePair(i, m_transparentNodes.at(beginIndices[i]++)));
}
}
Q_ASSERT(m_tempNodes.size() == m_transparentNodes.size() - baseCount);
}
}
-void QSGDefaultRenderer::renderNodes(const QDataBuffer<QSGGeometryNode *> &list)
+void QSGDefaultRenderer::renderNodes(QSGNode *const *nodes, int count)
{
const float scale = 1.0f / m_currentRenderOrder;
- int count = list.size();
int currentRenderOrder = 0x80000000;
- m_current_projection_matrix.setColumn(2, scale * projectionMatrix().column(2));
+ ClipType currentClipType = NoClip;
+ QMatrix4x4 projection = projectionMatrix();
+ m_current_projection_matrix.setColumn(2, scale * projection.column(2));
//int clipChangeCount = 0;
//int programChangeCount = 0;
//int materialChangeCount = 0;
for (int i = 0; i < count; ++i) {
- QSGGeometryNode *geomNode = list.at(i);
+ if (nodes[i]->type() == QSGNode::RenderNodeType) {
+ QSGRenderNode *renderNode = static_cast<QSGRenderNode *>(nodes[i]);
+
+ if (m_currentProgram)
+ m_currentProgram->deactivate();
+ m_currentMaterial = 0;
+ m_currentProgram = 0;
+ m_currentMatrix = 0;
+ currentRenderOrder = 0x80000000;
- QSGMaterialShader::RenderState::DirtyStates updates;
+ bool changeClip = renderNode->clipList() != m_currentClip;
+ // The clip function relies on there not being any depth testing..
+ glDisable(GL_DEPTH_TEST);
+ if (changeClip) {
+ currentClipType = updateStencilClip(renderNode->clipList());
+ m_currentClip = renderNode->clipList();
+ //++clipChangeCount;
+ }
+
+ glDepthMask(false);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+ QSGRenderNode::RenderState state;
+ state.projectionMatrix = &projection;
+ state.scissorEnabled = currentClipType & ScissorClip;
+ state.stencilEnabled = currentClipType & StencilClip;
+ state.scissorRect = m_current_scissor_rect;
+ state.stencilValue = m_current_stencil_value;
+
+ renderNode->render(state);
+
+ QSGRenderNode::StateFlags changes = renderNode->changedStates();
+ if (changes & QSGRenderNode::ViewportState) {
+ QRect r = viewportRect();
+ glViewport(r.x(), deviceRect().bottom() - r.bottom(), r.width(), r.height());
+ }
+ if (changes & QSGRenderNode::StencilState) {
+ glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+ glStencilMask(0xff);
+ glDisable(GL_STENCIL_TEST);
+ }
+ if (changes & (QSGRenderNode::StencilState | QSGRenderNode::ScissorState)) {
+ glDisable(GL_SCISSOR_TEST);
+ m_currentClip = 0;
+ currentClipType = NoClip;
+ }
+ if (changes & QSGRenderNode::DepthState) {
+#if defined(QT_OPENGL_ES)
+ glClearDepthf(0);
+#else
+ glClearDepth(0);
+#endif
+ if (m_clear_mode & QSGRenderer::ClearDepthBuffer) {
+ glDepthMask(true);
+ glClear(GL_DEPTH_BUFFER_BIT);
+ }
+ glDepthMask(false);
+ glDepthFunc(GL_GREATER);
+ }
+ if (changes & QSGRenderNode::ColorState)
+ bindable()->reactivate();
+ if (changes & QSGRenderNode::BlendState) {
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+ }
+ if (changes & QSGRenderNode::CullState) {
+ glFrontFace(isMirrored() ? GL_CW : GL_CCW);
+ glDisable(GL_CULL_FACE);
+ }
+
+ glEnable(GL_DEPTH_TEST);
+
+ m_current_model_view_matrix.setToIdentity();
+ m_current_determinant = 1;
+ } else if (nodes[i]->type() == QSGNode::GeometryNodeType) {
+ QSGGeometryNode *geomNode = static_cast<QSGGeometryNode *>(nodes[i]);
+
+ QSGMaterialShader::RenderState::DirtyStates updates;
#if defined (QML_RUNTIME_TESTING)
- static bool dumpTree = qApp->arguments().contains(QLatin1String("--dump-tree"));
- if (dumpTree)
- qDebug() << geomNode;
+ static bool dumpTree = qApp->arguments().contains(QLatin1String("--dump-tree"));
+ if (dumpTree)
+ qDebug() << geomNode;
#endif
- bool changeMatrix = m_currentMatrix != geomNode->matrix();
+ bool changeMatrix = m_currentMatrix != geomNode->matrix();
- if (changeMatrix) {
- m_currentMatrix = geomNode->matrix();
- if (m_currentMatrix)
- m_current_model_view_matrix = *m_currentMatrix;
- else
- m_current_model_view_matrix.setToIdentity();
- m_current_determinant = m_current_model_view_matrix.determinant();
- updates |= QSGMaterialShader::RenderState::DirtyMatrix;
- }
+ if (changeMatrix) {
+ m_currentMatrix = geomNode->matrix();
+ if (m_currentMatrix)
+ m_current_model_view_matrix = *m_currentMatrix;
+ else
+ m_current_model_view_matrix.setToIdentity();
+ m_current_determinant = m_current_model_view_matrix.determinant();
+ updates |= QSGMaterialShader::RenderState::DirtyMatrix;
+ }
- bool changeOpacity = m_current_opacity != geomNode->inheritedOpacity();
- if (changeOpacity) {
- updates |= QSGMaterialShader::RenderState::DirtyOpacity;
- m_current_opacity = geomNode->inheritedOpacity();
- }
+ bool changeOpacity = m_current_opacity != geomNode->inheritedOpacity();
+ if (changeOpacity) {
+ updates |= QSGMaterialShader::RenderState::DirtyOpacity;
+ m_current_opacity = geomNode->inheritedOpacity();
+ }
- Q_ASSERT(geomNode->activeMaterial());
+ Q_ASSERT(geomNode->activeMaterial());
- QSGMaterial *material = geomNode->activeMaterial();
- QSGMaterialShader *program = m_context->prepareMaterial(material);
- Q_ASSERT(program->program()->isLinked());
+ QSGMaterial *material = geomNode->activeMaterial();
+ QSGMaterialShader *program = m_context->prepareMaterial(material);
+ Q_ASSERT(program->program()->isLinked());
- bool changeClip = geomNode->clipList() != m_currentClip;
- QSGRenderer::ClipType clipType = QSGRenderer::NoClip;
- if (changeClip) {
- // The clip function relies on there not being any depth testing..
- glDisable(GL_DEPTH_TEST);
- clipType = updateStencilClip(geomNode->clipList());
- glEnable(GL_DEPTH_TEST);
- m_currentClip = geomNode->clipList();
+ bool changeClip = geomNode->clipList() != m_currentClip;
+ if (changeClip) {
+ // The clip function relies on there not being any depth testing..
+ glDisable(GL_DEPTH_TEST);
+ currentClipType = updateStencilClip(geomNode->clipList());
+ glEnable(GL_DEPTH_TEST);
+ m_currentClip = geomNode->clipList();
#ifdef FORCE_NO_REORDER
- glDepthMask(false);
+ glDepthMask(false);
#else
- glDepthMask((material->flags() & QSGMaterial::Blending) == 0 && m_current_opacity == 1);
+ glDepthMask((material->flags() & QSGMaterial::Blending) == 0 && m_current_opacity == 1);
#endif
- //++clipChangeCount;
- }
+ //++clipChangeCount;
+ }
- bool changeProgram = (changeClip && clipType == QSGRenderer::StencilClip) || m_currentProgram != program;
- if (changeProgram) {
- if (m_currentProgram)
- m_currentProgram->deactivate();
- m_currentProgram = program;
- m_currentProgram->activate();
- //++programChangeCount;
- updates |= (QSGMaterialShader::RenderState::DirtyMatrix | QSGMaterialShader::RenderState::DirtyOpacity);
+ bool changeProgram = (changeClip && (currentClipType & StencilClip)) || m_currentProgram != program;
+ if (changeProgram) {
+ if (m_currentProgram)
+ m_currentProgram->deactivate();
+ m_currentProgram = program;
+ m_currentProgram->activate();
+ //++programChangeCount;
+ updates |= (QSGMaterialShader::RenderState::DirtyMatrix | QSGMaterialShader::RenderState::DirtyOpacity);
#ifdef RENDERER_DEBUG
- materialChanges++;
+ materialChanges++;
#endif
- }
+ }
- bool changeRenderOrder = currentRenderOrder != geomNode->renderOrder();
- if (changeRenderOrder) {
- currentRenderOrder = geomNode->renderOrder();
- m_current_projection_matrix.setColumn(3, projectionMatrix().column(3)
- + currentRenderOrder
- * m_current_projection_matrix.column(2));
- updates |= QSGMaterialShader::RenderState::DirtyMatrix;
- }
+ bool changeRenderOrder = currentRenderOrder != geomNode->renderOrder();
+ if (changeRenderOrder) {
+ currentRenderOrder = geomNode->renderOrder();
+ m_current_projection_matrix.setColumn(3, projection.column(3)
+ + currentRenderOrder
+ * m_current_projection_matrix.column(2));
+ updates |= QSGMaterialShader::RenderState::DirtyMatrix;
+ }
- if (changeProgram || m_currentMaterial != material) {
- program->updateState(state(updates), material, changeProgram ? 0 : m_currentMaterial);
- m_currentMaterial = material;
- //++materialChangeCount;
- }
+ if (changeProgram || m_currentMaterial != material) {
+ program->updateState(state(updates), material, changeProgram ? 0 : m_currentMaterial);
+ m_currentMaterial = material;
+ //++materialChangeCount;
+ }
- //glDepthRange((geomNode->renderOrder() + 0.1) * scale, (geomNode->renderOrder() + 0.9) * scale);
+ //glDepthRange((geomNode->renderOrder() + 0.1) * scale, (geomNode->renderOrder() + 0.9) * scale);
- const QSGGeometry *g = geomNode->geometry();
- draw(program, g);
+ const QSGGeometry *g = geomNode->geometry();
+ draw(program, g);
#ifdef RENDERER_DEBUG
- geometryNodesDrawn++;
+ geometryNodesDrawn++;
#endif
+ }
}
//qDebug("Clip: %i, shader program: %i, material: %i times changed while drawing %s items",
// clipChangeCount, programChangeCount, materialChangeCount,
#include "qsgrenderer_p.h"
#include <QtGui/private/qdatabuffer_p.h>
+#include "qsgrendernode_p.h"
QT_BEGIN_HEADER
{
Q_OBJECT
public:
- class IndexGeometryNodePair : public QPair<int, QSGGeometryNode *>
+ class IndexNodePair : public QPair<int, QSGNode *>
{
public:
- IndexGeometryNodePair(int i, QSGGeometryNode *n);
- bool operator < (const IndexGeometryNodePair &other) const;
+ IndexNodePair(int i, QSGNode *n);
+ bool operator < (const IndexNodePair &other) const;
};
// Minimum heap.
- class IndexGeometryNodePairHeap
+ class IndexNodePairHeap
{
public:
- IndexGeometryNodePairHeap();
- void insert(const IndexGeometryNodePair &x);
- const IndexGeometryNodePair &top() const { return v.first(); }
- IndexGeometryNodePair pop();
+ IndexNodePairHeap();
+ void insert(const IndexNodePair &x);
+ const IndexNodePair &top() const { return v.first(); }
+ IndexNodePair pop();
bool isEmpty() const { return v.isEmpty(); }
private:
static int parent(int i) { return (i - 1) >> 1; }
static int left(int i) { return (i << 1) | 1; }
static int right(int i) { return (i + 1) << 1; }
- QDataBuffer<IndexGeometryNodePair> v;
+ QDataBuffer<IndexNodePair> v;
};
QSGDefaultRenderer(QSGContext *context);
private:
void buildLists(QSGNode *node);
- void renderNodes(const QDataBuffer<QSGGeometryNode *> &list);
+ void renderNodes(QSGNode *const *nodes, int count);
const QSGClipNode *m_currentClip;
QSGMaterial *m_currentMaterial;
QSGMaterialShader *m_currentProgram;
const QMatrix4x4 *m_currentMatrix;
QMatrix4x4 m_renderOrderMatrix;
- QDataBuffer<QSGGeometryNode *> m_opaqueNodes;
- QDataBuffer<QSGGeometryNode *> m_transparentNodes;
- QDataBuffer<QSGGeometryNode *> m_tempNodes;
- IndexGeometryNodePairHeap m_heap;
+ QDataBuffer<QSGNode *> m_opaqueNodes;
+ QDataBuffer<QSGNode *> m_transparentNodes;
+ QDataBuffer<QSGNode *> m_tempNodes;
+ struct RenderGroup { int opaqueEnd, transparentEnd; };
+ QDataBuffer<RenderGroup> m_renderGroups;
+ IndexNodePairHeap m_heap;
bool m_rebuild_lists;
bool m_needs_sorting;
bool m_sort_front_to_back;
+ bool m_render_node_added;
int m_currentRenderOrder;
#ifdef QML_RUNTIME_TESTING
, m_lastChild(0)
, m_nextSibling(0)
, m_previousSibling(0)
- , m_subtreeGeometryCount(0)
+ , m_subtreeRenderableCount(0)
, m_nodeFlags(OwnedByParent)
, m_dirtyState(0)
{
, m_lastChild(0)
, m_nextSibling(0)
, m_previousSibling(0)
- , m_subtreeGeometryCount(type == GeometryNodeType ? 1 : 0)
+ , m_subtreeRenderableCount(type == GeometryNodeType || type == RenderNodeType ? 1 : 0)
, m_nodeFlags(OwnedByParent)
, m_dirtyState(0)
{
bool QSGNode::isSubtreeBlocked() const
{
- return m_subtreeGeometryCount == 0;
+ return m_subtreeRenderableCount == 0;
}
/*!
DirtyState subtreeBits = DirtyState((bits & DirtyPropagationMask) << 16);
- int geometryCountDiff = 0;
+ int renderableCountDiff = 0;
if (bits & DirtyNodeAdded)
- geometryCountDiff += m_subtreeGeometryCount;
+ renderableCountDiff += m_subtreeRenderableCount;
if (bits & DirtyNodeRemoved)
- geometryCountDiff -= m_subtreeGeometryCount;
+ renderableCountDiff -= m_subtreeRenderableCount;
QSGNode *p = m_parent;
while (p) {
p->m_dirtyState |= subtreeBits;
- p->m_subtreeGeometryCount += geometryCountDiff;
+ p->m_subtreeRenderableCount += renderableCountDiff;
if (p->type() == RootNodeType)
static_cast<QSGRootNode *>(p)->notifyNodeChange(this, bits);
p = p->m_parent;
TransformNodeType,
ClipNodeType,
OpacityNodeType,
+#ifndef Q_QDOC
+ RenderNodeType, // internal
+#endif
UserNodeType = 1024
};
QSGNode *m_lastChild;
QSGNode *m_nextSibling;
QSGNode *m_previousSibling;
- int m_subtreeGeometryCount;
+ int m_subtreeRenderableCount;
Flags m_nodeFlags;
DirtyState m_dirtyState;
****************************************************************************/
#include "qsgnodeupdater_p.h"
+#include "qsgnode.h"
+#include "qsgrendernode_p.h"
QT_BEGIN_NAMESPACE
#endif
}
+void QSGNodeUpdater::enterRenderNode(QSGRenderNode *r)
+{
+#ifdef QSG_UPDATER_DEBUG
+ qDebug() << "enter render:" << r;
+#endif
+
+ r->m_matrix = m_combined_matrix_stack.isEmpty() ? 0 : m_combined_matrix_stack.last();
+ r->m_clip_list = m_current_clip;
+ r->setInheritedOpacity(m_opacity_stack.last());
+}
+
+void QSGNodeUpdater::leaveRenderNode(QSGRenderNode *r)
+{
+#ifdef QSG_UPDATER_DEBUG
+ qDebug() << "leave render" << r;
+#else
+ Q_UNUSED(r)
+#endif
+}
+
void QSGNodeUpdater::enterOpacityNode(QSGOpacityNode *o)
{
if (o->dirtyState() & QSGNode::DirtyOpacity)
visitChildren(g);
leaveGeometryNode(g);
break; }
+ case QSGNode::RenderNodeType: {
+ QSGRenderNode *r = static_cast<QSGRenderNode *>(n);
+ enterRenderNode(r);
+ visitChildren(r);
+ leaveRenderNode(r);
+ break; }
case QSGNode::ClipNodeType: {
QSGClipNode *c = static_cast<QSGClipNode *>(n);
enterClipNode(c);
#ifndef NODEUPDATER_P_H
#define NODEUPDATER_P_H
-#include "qsgnode.h"
+#include <QtQuick/qtquickglobal.h>
#include <QtGui/private/qdatabuffer_p.h>
+QT_BEGIN_HEADER
+
QT_BEGIN_NAMESPACE
+class QSGNode;
+class QSGTransformNode;
+class QSGClipNode;
+class QSGOpacityNode;
+class QSGGeometryNode;
+class QMatrix4x4;
+class QSGRenderNode;
+
class Q_QUICK_EXPORT QSGNodeUpdater
{
public:
void leaveOpacityNode(QSGOpacityNode *o);
void enterGeometryNode(QSGGeometryNode *);
void leaveGeometryNode(QSGGeometryNode *);
+ void enterRenderNode(QSGRenderNode *);
+ void leaveRenderNode(QSGRenderNode *);
void visitNode(QSGNode *n);
void visitChildren(QSGNode *n);
QT_END_NAMESPACE
+QT_END_HEADER
+
#endif // NODEUPDATER_P_H
, m_clear_mode(ClearColorBuffer | ClearDepthBuffer)
, m_current_opacity(1)
, m_current_determinant(1)
+ , m_current_stencil_value(0)
, m_context(context)
, m_root_node(0)
, m_node_updater(0)
return NoClip;
}
- bool stencilEnabled = false;
- bool scissorEnabled = false;
+ ClipType clipType = NoClip;
glDisable(GL_SCISSOR_TEST);
- int clipDepth = 0;
- QRect clipRect;
+ m_current_stencil_value = 0;
+ m_current_scissor_rect = QRect();
while (clip) {
QMatrix4x4 m = m_current_projection_matrix;
if (clip->matrix())
GLint ix2 = qRound((fx2 + 1) * m_device_rect.width() * qreal(0.5));
GLint iy2 = qRound((fy2 + 1) * m_device_rect.height() * qreal(0.5));
- if (!scissorEnabled) {
- clipRect = QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
+ if (!(clipType & ScissorClip)) {
+ m_current_scissor_rect = QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
glEnable(GL_SCISSOR_TEST);
- scissorEnabled = true;
+ clipType |= ScissorClip;
} else {
- clipRect &= QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
+ m_current_scissor_rect &= QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
}
-
- glScissor(clipRect.x(), clipRect.y(), clipRect.width(), clipRect.height());
+ glScissor(m_current_scissor_rect.x(), m_current_scissor_rect.y(),
+ m_current_scissor_rect.width(), m_current_scissor_rect.height());
} else {
- if (!stencilEnabled) {
+ if (!(clipType & StencilClip)) {
if (!m_clip_program.isLinked()) {
m_clip_program.addShaderFromSourceCode(QOpenGLShader::Vertex,
"attribute highp vec4 vCoord; \n"
m_clip_matrix_id = m_clip_program.uniformLocation("matrix");
}
- glStencilMask(0xff); // write mask
glClearStencil(0);
glClear(GL_STENCIL_BUFFER_BIT);
glEnable(GL_STENCIL_TEST);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_FALSE);
+ if (m_vertex_buffer_bound) {
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ m_vertex_buffer_bound = false;
+ }
+ if (m_index_buffer_bound) {
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ m_index_buffer_bound = false;
+ }
+
m_clip_program.bind();
m_clip_program.enableAttributeArray(0);
- stencilEnabled = true;
+ clipType |= StencilClip;
}
- glStencilFunc(GL_EQUAL, clipDepth, 0xff); // stencil test, ref, test mask
+ glStencilFunc(GL_EQUAL, m_current_stencil_value, 0xff); // stencil test, ref, test mask
glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); // stencil fail, z fail, z pass
const QSGGeometry *g = clip->geometry();
glDrawArrays(g->drawingMode(), 0, g->vertexCount());
}
- ++clipDepth;
+ ++m_current_stencil_value;
}
clip = clip->clipList();
}
- if (stencilEnabled) {
+ if (clipType & StencilClip) {
m_clip_program.disableAttributeArray(0);
- glStencilFunc(GL_EQUAL, clipDepth, 0xff); // stencil test, ref, test mask
+ glStencilFunc(GL_EQUAL, m_current_stencil_value, 0xff); // stencil test, ref, test mask
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // stencil fail, z fail, z pass
- glStencilMask(0); // write mask
bindable()->reactivate();
} else {
glDisable(GL_STENCIL_TEST);
}
- if (!scissorEnabled)
- glDisable(GL_SCISSOR_TEST);
-
- return stencilEnabled ? StencilClip : ScissorClip;
+ return clipType;
}
{
Q_OBJECT
public:
- enum ClipType
+ enum ClipTypeBit
{
- NoClip,
- ScissorClip,
- StencilClip
+ NoClip = 0x00,
+ ScissorClip = 0x01,
+ StencilClip = 0x02
};
+ Q_DECLARE_FLAGS(ClipType, ClipTypeBit)
enum ClearModeBit
{
QMatrix4x4 m_current_model_view_matrix;
qreal m_current_opacity;
qreal m_current_determinant;
+ QRect m_current_scissor_rect;
+ int m_current_stencil_value;
QSGContext *m_context;
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsgrendernode_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QSGRenderNode::QSGRenderNode()
+ : QSGNode(RenderNodeType)
+ , m_matrix(0)
+ , m_clip_list(0)
+ , m_opacity(1)
+{
+}
+
+void QSGRenderNode::setInheritedOpacity(qreal opacity)
+{
+ Q_ASSERT(opacity >= 0 && opacity <= 1);
+ m_opacity = opacity;
+}
+
+/*!
+ \fn QSGRenderNode::StateFlags QSGRenderNode::changedStates()
+
+ This function should return a mask where each bit represents OpenGL states changed by
+ the \l render() function:
+ \list
+ \o DepthState - depth write mask, depth test enabled, depth comparison function
+ \o StencilState - stencil write masks, stencil test enabled, stencil operations,
+ stencil comparison functions
+ \o ScissorState - scissor enabled, scissor test enabled
+ \o ColorState - clear color, color write mask
+ \o BlendState - blend enabled, blend function
+ \o CullState - front face, cull face enabled
+ \o ViewportState - viewport
+ \endlist
+
+ The function is called by the renderer so it can reset the OpenGL states after rendering this
+ node.
+
+ \internal
+ */
+
+/*!
+ \fn void QSGRenderNode::render(const RenderState &state)
+
+ This function is called by the renderer and should paint this node with OpenGL commands.
+
+ The states necessary for clipping has already been set before the function is called.
+ The clip is a combination of a stencil clip and scissor clip. Information about the clip is
+ found in \a state.
+
+ The effective opacity can be retrieved with \l inheritedOpacity().
+
+ The projection matrix is available through \a state, while the model-view matrix can be
+ fetched with \l matrix(). The combined matrix is then the projection matrix times the
+ model-view matrix.
+
+ The following states are set before this function is called:
+ \list
+ \o glDepthMask(false)
+ \o glDisable(GL_DEPTH_TEST)
+ \o glStencilMask(0)
+ \o glEnable(GL_STENCIL_TEST)/glDisable(GL_STENCIL_TEST) depending on clip
+ \o glStencilFunc(GL_EQUAL, state.stencilValue, 0xff) depending on clip
+ \o glEnable(GL_SCISSOR_TEST)/glDisable(GL_SCISSOR_TEST) depending on clip
+ \o glScissor(state.scissorRect.x(), state.scissorRect.y(),
+ state.scissorRect.width(), state.scissorRect.height()) depending on clip
+ \o glEnable(GL_BLEND)
+ \o glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)
+ \o glDisable(GL_CULL_FACE)
+ \endlist
+
+ States that are not listed above, but are included in \l StateFlags, can have arbitrary
+ values.
+
+ \l changedStates() should return which states this function has changed. If a state is not
+ covered by \l StateFlags, the state should be set to the default value according to the
+ OpenGL specification.
+
+ \internal
+ */
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSGRENDERNODE_P_H
+#define QSGRENDERNODE_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsgnode.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_EXPORT QSGRenderNode : public QSGNode
+{
+public:
+ enum StateFlag
+ {
+ DepthState = 0x01, // depth mask, depth test enable, depth func, clear depth
+ StencilState = 0x02, // stencil mask, stencil test enable, stencil op, stencil func, clear stencil
+ ScissorState = 0x04, // scissor enable, scissor test enable
+ ColorState = 0x08, // clear color, color mask
+ BlendState = 0x10, // blend enable, blend func
+ CullState = 0x20, // front face, cull face enable
+ ViewportState = 0x40 // viewport
+ };
+ Q_DECLARE_FLAGS(StateFlags, StateFlag)
+
+ struct RenderState
+ {
+ // The model-view matrix can be retrieved with matrix().
+ // The opacity can be retrieved with inheritedOpacity().
+ const QMatrix4x4 *projectionMatrix;
+ QRect scissorRect;
+ int stencilValue;
+
+ bool stencilEnabled;
+ bool scissorEnabled;
+ };
+
+ QSGRenderNode();
+
+ virtual StateFlags changedStates() = 0;
+ virtual void render(const RenderState &state) = 0;
+
+ const QMatrix4x4 *matrix() const { return m_matrix; }
+ const QSGClipNode *clipList() const { return m_clip_list; }
+
+ void setInheritedOpacity(qreal opacity);
+ qreal inheritedOpacity() const { return m_opacity; }
+
+private:
+ friend class QSGNodeUpdater;
+
+ const QMatrix4x4 *m_matrix;
+ const QSGClipNode *m_clip_list;
+ qreal m_opacity;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QSGRenderNode::StateFlags)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
$$PWD/coreapi/qsgnode.h \
$$PWD/coreapi/qsgnodeupdater_p.h \
$$PWD/coreapi/qsgrenderer_p.h \
+ $$PWD/coreapi/qsgrendernode_p.h \
$$PWD/coreapi/qsggeometry_p.h
SOURCES += \
$$PWD/coreapi/qsgmaterial.cpp \
$$PWD/coreapi/qsgnode.cpp \
$$PWD/coreapi/qsgnodeupdater.cpp \
- $$PWD/coreapi/qsgrenderer.cpp
+ $$PWD/coreapi/qsgrenderer.cpp \
+ $$PWD/coreapi/qsgrendernode.cpp
# Util API
HEADERS += \
examples \
geometry \
nodes \
+ rendernode \
qdeclarativepixmapcache
# This test requires the qtconcurrent module
--- /dev/null
+import QtQuick 2.0
+import Test 1.0
+
+Rectangle {
+ width: 200
+ height: 200
+ color: "black"
+ Rectangle {
+ width: 200
+ height: 100
+ anchors.centerIn: parent
+ clip: true
+ color: "white"
+ Rectangle {
+ width: 100
+ height: 100
+ anchors.centerIn: parent
+ rotation: 45
+ color: "blue"
+ clip: true
+ MessUpItem {
+ anchors.fill: parent
+ }
+ Rectangle {
+ anchors.fill: parent
+ anchors.margins: -50
+ color: "red"
+ opacity: 0.5
+ }
+ }
+ }
+}
--- /dev/null
+import QtQuick 2.0
+import Test 1.0
+
+Rectangle {
+ id: root
+
+ width: 200
+ height: 200
+ color: "black"
+
+ Rectangle {
+ width: 100
+ height: 100
+ anchors.top: parent.top
+ anchors.left: parent.left
+ color: "red"
+ opacity: 0.5
+ }
+
+ Rectangle {
+ width: 100
+ height: 100
+ anchors.bottom: parent.bottom
+ anchors.left: parent.left
+ color: "red"
+ }
+
+ ClearItem {
+ width: 100
+ height: 100
+ anchors.centerIn: parent
+ color: "white"
+ clip: true
+ }
+
+ Rectangle {
+ width: 100
+ height: 100
+ anchors.top: parent.top
+ anchors.right: parent.right
+ color: "blue"
+ }
+
+ Rectangle {
+ width: 100
+ height: 100
+ anchors.bottom: parent.bottom
+ anchors.right: parent.right
+ color: "blue"
+ opacity: 0.5
+ }
+
+}
--- /dev/null
+CONFIG += testcase
+TARGET = tst_rendernode
+SOURCES += tst_rendernode.cpp
+
+macx:CONFIG -= app_bundle
+
+testDataFiles.files = data
+testDataFiles.path = .
+DEPLOYMENT += testDataFiles
+
+include(../../shared/util.pri)
+
+CONFIG += parallel_test
+QT += core-private gui-private v8-private declarative-private quick-private testlib
+
+OTHER_FILES += \
+ data/RenderOrder.qml \
+ data/MessUpState.qml \
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qtest.h>
+
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/qquickview.h>
+#include <QtGui/qopenglcontext.h>
+#include <private/qsgrendernode_p.h>
+
+#include "../../shared/util.h"
+
+class tst_rendernode: public QDeclarativeDataTest
+{
+ Q_OBJECT
+public:
+ tst_rendernode();
+
+ QImage runTest(const QString &url)
+ {
+ QQuickView view;
+ view.setSource(QUrl(url));
+
+ view.show();
+ QTest::qWaitForWindowShown(&view);
+
+ return view.grabFrameBuffer();
+ }
+
+private slots:
+ void renderOrder();
+ void messUpState();
+};
+
+class ClearNode : public QSGRenderNode
+{
+public:
+ virtual StateFlags changedStates()
+ {
+ return ColorState;
+ }
+
+ virtual void render(const RenderState &)
+ {
+ // If clip has been set, scissoring will make sure the right area is cleared.
+ glClearColor(color.redF(), color.greenF(), color.blueF(), 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ }
+
+ QColor color;
+};
+
+class ClearItem : public QQuickItem
+{
+ Q_OBJECT
+ Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
+public:
+ ClearItem() : m_color(Qt::black)
+ {
+ setFlag(ItemHasContents, true);
+ }
+
+ QColor color() const { return m_color; }
+ void setColor(const QColor &color)
+ {
+ if (color == m_color)
+ return;
+ m_color = color;
+ emit colorChanged();
+ }
+
+protected:
+ virtual QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+ {
+ ClearNode *node = static_cast<ClearNode *>(oldNode);
+ if (!node)
+ node = new ClearNode;
+ node->color = m_color;
+ return node;
+ }
+
+Q_SIGNALS:
+ void colorChanged();
+
+private:
+ QColor m_color;
+};
+
+class MessUpNode : public QSGRenderNode
+{
+public:
+ virtual StateFlags changedStates()
+ {
+ return StateFlags(DepthState) | StencilState | ScissorState | ColorState | BlendState
+ | CullState | ViewportState;
+ }
+
+ virtual void render(const RenderState &)
+ {
+ // Don't draw anything, just mess up the state
+ glViewport(10, 10, 10, 10);
+ glDisable(GL_SCISSOR_TEST);
+ glDepthMask(true);
+ glEnable(GL_DEPTH_TEST);
+ glDepthFunc(GL_EQUAL);
+#if defined(QT_OPENGL_ES)
+ glClearDepthf(1);
+#else
+ glClearDepth(1);
+#endif
+ glClearStencil(42);
+ glClearColor(1.0f, 0.5f, 1.0f, 0.0f);
+ glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(190, 190, 10, 10);
+ glStencilFunc(GL_EQUAL, 28, 0xff);
+ glBlendFunc(GL_ZERO, GL_ZERO);
+ GLint frontFace;
+ glGetIntegerv(GL_FRONT_FACE, &frontFace);
+ glFrontFace(frontFace == GL_CW ? GL_CCW : GL_CW);
+ glEnable(GL_CULL_FACE);
+ }
+};
+
+class MessUpItem : public QQuickItem
+{
+ Q_OBJECT
+public:
+ MessUpItem()
+ {
+ setFlag(ItemHasContents, true);
+ }
+
+protected:
+ virtual QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+ {
+ MessUpNode *node = static_cast<MessUpNode *>(oldNode);
+ if (!node)
+ node = new MessUpNode;
+ return node;
+ }
+};
+
+tst_rendernode::tst_rendernode()
+{
+ qmlRegisterType<ClearItem>("Test", 1, 0, "ClearItem");
+ qmlRegisterType<MessUpItem>("Test", 1, 0, "MessUpItem");
+}
+
+static void fuzzyCompareColor(QRgb x, QRgb y)
+{
+ QVERIFY(qAbs(qRed(x) - qRed(y)) < 4);
+ QVERIFY(qAbs(qGreen(x) - qGreen(y)) < 4);
+ QVERIFY(qAbs(qBlue(x) - qBlue(y)) < 4);
+}
+
+void tst_rendernode::renderOrder()
+{
+ QImage fb = runTest(testFile("RenderOrder.qml"));
+ int x1 = fb.width() / 8;
+ int x2 = fb.width() * 3 / 8;
+ int x3 = fb.width() * 5 / 8;
+ int x4 = fb.width() * 7 / 8;
+ int y1 = fb.height() / 8;
+ int y2 = fb.height() * 3 / 8;
+ int y3 = fb.height() * 5 / 8;
+ int y4 = fb.height() * 7 / 8;
+
+ fuzzyCompareColor(fb.pixel(x1, y1), qRgb(0x7f, 0x00, 0x00));
+ QCOMPARE(fb.pixel(x2, y2), qRgb(0xff, 0xff, 0xff));
+ QCOMPARE(fb.pixel(x3, y2), qRgb(0x00, 0x00, 0xff));
+ QCOMPARE(fb.pixel(x4, y1), qRgb(0x00, 0x00, 0xff));
+ QCOMPARE(fb.pixel(x1, y4), qRgb(0xff, 0x00, 0x00));
+ QCOMPARE(fb.pixel(x2, y3), qRgb(0xff, 0xff, 0xff));
+ fuzzyCompareColor(fb.pixel(x3, y3), qRgb(0x7f, 0x7f, 0xff));
+ fuzzyCompareColor(fb.pixel(x4, y4), qRgb(0x00, 0x00, 0x7f));
+}
+
+void tst_rendernode::messUpState()
+{
+ QImage fb = runTest(testFile("MessUpState.qml"));
+ int x1 = 0;
+ int x2 = fb.width() / 2;
+ int x3 = fb.width() - 1;
+ int y1 = 0;
+ int y2 = fb.height() * 3 / 16;
+ int y3 = fb.height() / 2;
+ int y4 = fb.height() * 13 / 16;
+ int y5 = fb.height() - 1;
+
+ QCOMPARE(fb.pixel(x1, y3), qRgb(0xff, 0xff, 0xff));
+ QCOMPARE(fb.pixel(x3, y3), qRgb(0xff, 0xff, 0xff));
+
+ QCOMPARE(fb.pixel(x2, y1), qRgb(0x00, 0x00, 0x00));
+ QCOMPARE(fb.pixel(x2, y2), qRgb(0x00, 0x00, 0x00));
+ fuzzyCompareColor(fb.pixel(x2, y3), qRgb(0x7f, 0x00, 0x7f));
+ QCOMPARE(fb.pixel(x2, y4), qRgb(0x00, 0x00, 0x00));
+ QCOMPARE(fb.pixel(x2, y5), qRgb(0x00, 0x00, 0x00));
+}
+
+
+QTEST_MAIN(tst_rendernode)
+
+#include "tst_rendernode.moc"
projects / konrad/qtdeclarative.git / commitdiff