**
****************************************************************************/
-#include "qsgshadereffectsource_p.h"
+#include "qquickshadereffectsource_p.h"
-#include "qsgitem_p.h"
-#include "qsgcanvas_p.h"
+#include "qquickitem_p.h"
+#include "qquickcanvas_p.h"
#include <private/qsgadaptationlayer_p.h>
#include <private/qsgrenderer_p.h>
DEFINE_BOOL_CONFIG_OPTION(qmlFboOverlay, QML_FBO_OVERLAY)
-class QSGShaderEffectSourceTextureProvider : public QSGTextureProvider
+class QQuickShaderEffectSourceTextureProvider : public QSGTextureProvider
{
Q_OBJECT
public:
- QSGShaderEffectSourceTextureProvider()
+ QQuickShaderEffectSourceTextureProvider()
: sourceTexture(0)
{
}
return sourceTexture;
}
- QSGShaderEffectTexture *sourceTexture;
+ QQuickShaderEffectTexture *sourceTexture;
QSGTexture::Filtering mipmapFiltering;
QSGTexture::Filtering filtering;
QSGTexture::WrapMode horizontalWrap;
QSGTexture::WrapMode verticalWrap;
};
-#include "qsgshadereffectsource.moc"
+#include "qquickshadereffectsource.moc"
-QSGShaderEffectSourceNode::QSGShaderEffectSourceNode()
+QQuickShaderEffectSourceNode::QQuickShaderEffectSourceNode()
{
setFlag(UsePreprocess, true);
}
-void QSGShaderEffectSourceNode::markDirtyTexture()
+void QQuickShaderEffectSourceNode::markDirtyTexture()
{
markDirty(DirtyMaterial);
}
-QSGShaderEffectTexture::QSGShaderEffectTexture(QSGItem *shaderSource)
+QQuickShaderEffectTexture::QQuickShaderEffectTexture(QQuickItem *shaderSource)
: QSGDynamicTexture()
, m_item(0)
, m_format(GL_RGBA)
#ifdef QSG_DEBUG_FBO_OVERLAY
, m_debugOverlay(0)
#endif
- , m_context(QSGItemPrivate::get(shaderSource)->sceneGraphContext())
+ , m_context(QQuickItemPrivate::get(shaderSource)->sceneGraphContext())
, m_mipmap(false)
, m_live(true)
, m_recursive(false)
{
}
-QSGShaderEffectTexture::~QSGShaderEffectTexture()
+QQuickShaderEffectTexture::~QQuickShaderEffectTexture()
{
delete m_renderer;
delete m_fbo;
#endif
}
-int QSGShaderEffectTexture::textureId() const
+int QQuickShaderEffectTexture::textureId() const
{
return m_fbo ? m_fbo->texture() : 0;
}
-bool QSGShaderEffectTexture::hasAlphaChannel() const
+bool QQuickShaderEffectTexture::hasAlphaChannel() const
{
return m_format != GL_RGB;
}
-bool QSGShaderEffectTexture::hasMipmaps() const
+bool QQuickShaderEffectTexture::hasMipmaps() const
{
return m_mipmap;
}
-void QSGShaderEffectTexture::bind()
+void QQuickShaderEffectTexture::bind()
{
#ifndef QT_NO_DEBUG
if (!m_recursive && m_fbo && ((m_multisampling && m_secondaryFbo->isBound()) || m_fbo->isBound()))
updateBindOptions();
}
-bool QSGShaderEffectTexture::updateTexture()
+bool QQuickShaderEffectTexture::updateTexture()
{
if ((m_live || m_grab) && m_dirtyTexture) {
grab();
return false;
}
-void QSGShaderEffectTexture::setHasMipmaps(bool mipmap)
+void QQuickShaderEffectTexture::setHasMipmaps(bool mipmap)
{
if (mipmap == m_mipmap)
return;
}
-void QSGShaderEffectTexture::setItem(QSGNode *item)
+void QQuickShaderEffectTexture::setItem(QSGNode *item)
{
if (item == m_item)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setRect(const QRectF &rect)
+void QQuickShaderEffectTexture::setRect(const QRectF &rect)
{
if (rect == m_rect)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setSize(const QSize &size)
+void QQuickShaderEffectTexture::setSize(const QSize &size)
{
if (size == m_size)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setFormat(GLenum format)
+void QQuickShaderEffectTexture::setFormat(GLenum format)
{
if (format == m_format)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::setLive(bool live)
+void QQuickShaderEffectTexture::setLive(bool live)
{
if (live == m_live)
return;
markDirtyTexture();
}
-void QSGShaderEffectTexture::scheduleUpdate()
+void QQuickShaderEffectTexture::scheduleUpdate()
{
if (m_grab)
return;
emit textureChanged();
}
-void QSGShaderEffectTexture::setRecursive(bool recursive)
+void QQuickShaderEffectTexture::setRecursive(bool recursive)
{
m_recursive = recursive;
}
-void QSGShaderEffectTexture::markDirtyTexture()
+void QQuickShaderEffectTexture::markDirtyTexture()
{
m_dirtyTexture = true;
if (m_live || m_grab)
emit textureChanged();
}
-void QSGShaderEffectTexture::grab()
+void QQuickShaderEffectTexture::grab()
{
if (!m_item || m_size.isNull()) {
delete m_fbo;
markDirtyTexture(); // Continuously update if 'live' and 'recursive'.
}
-QImage QSGShaderEffectTexture::toImage() const
+QImage QQuickShaderEffectTexture::toImage() const
{
if (m_fbo)
return m_fbo->toImage();
}
/*!
- \qmlclass ShaderEffectSource QSGShaderEffectSource
+ \qmlclass ShaderEffectSource QQuickShaderEffectSource
\since 5.0
\ingroup qml-basic-visual-elements
\brief The ShaderEffectSource element renders a QML element into a texture
but not multisampled framebuffer objects.
*/
-QSGShaderEffectSource::QSGShaderEffectSource(QSGItem *parent)
- : QSGItem(parent)
+QQuickShaderEffectSource::QQuickShaderEffectSource(QQuickItem *parent)
+ : QQuickItem(parent)
, m_provider(0)
, m_texture(0)
, m_wrapMode(ClampToEdge)
setFlag(ItemHasContents);
}
-QSGShaderEffectSource::~QSGShaderEffectSource()
+QQuickShaderEffectSource::~QQuickShaderEffectSource()
{
if (m_texture)
m_texture->deleteLater();
m_provider->deleteLater();
if (m_sourceItem)
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
}
-void QSGShaderEffectSource::ensureTexture()
+void QQuickShaderEffectSource::ensureTexture()
{
if (m_texture)
return;
- Q_ASSERT_X(QSGItemPrivate::get(this)->canvas
- && QSGItemPrivate::get(this)->sceneGraphContext()
- && QThread::currentThread() == QSGItemPrivate::get(this)->sceneGraphContext()->thread(),
- "QSGShaderEffectSource::ensureTexture",
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ && QQuickItemPrivate::get(this)->sceneGraphContext()
+ && QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
+ "QQuickShaderEffectSource::ensureTexture",
"Cannot be used outside the rendering thread");
- m_texture = new QSGShaderEffectTexture(this);
+ m_texture = new QQuickShaderEffectTexture(this);
connect(m_texture, SIGNAL(textureChanged()), this, SLOT(update()));
}
-QSGTextureProvider *QSGShaderEffectSource::textureProvider() const
+QSGTextureProvider *QQuickShaderEffectSource::textureProvider() const
{
if (!m_provider) {
// Make sure it gets thread affinity on the rendering thread so deletion works properly..
- Q_ASSERT_X(QSGItemPrivate::get(this)->canvas
- && QSGItemPrivate::get(this)->sceneGraphContext()
- && QThread::currentThread() == QSGItemPrivate::get(this)->sceneGraphContext()->thread(),
- "QSGShaderEffectSource::textureProvider",
+ Q_ASSERT_X(QQuickItemPrivate::get(this)->canvas
+ && QQuickItemPrivate::get(this)->sceneGraphContext()
+ && QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphContext()->thread(),
+ "QQuickShaderEffectSource::textureProvider",
"Cannot be used outside the rendering thread");
- const_cast<QSGShaderEffectSource *>(this)->m_provider = new QSGShaderEffectSourceTextureProvider();
+ const_cast<QQuickShaderEffectSource *>(this)->m_provider = new QQuickShaderEffectSourceTextureProvider();
- const_cast<QSGShaderEffectSource *>(this)->ensureTexture();
+ const_cast<QQuickShaderEffectSource *>(this)->ensureTexture();
connect(m_texture, SIGNAL(textureChanged()), m_provider, SIGNAL(textureChanged()), Qt::DirectConnection);
m_provider->sourceTexture = m_texture;
}
wrap mode with non-power-of-two textures.
*/
-QSGShaderEffectSource::WrapMode QSGShaderEffectSource::wrapMode() const
+QQuickShaderEffectSource::WrapMode QQuickShaderEffectSource::wrapMode() const
{
return m_wrapMode;
}
-void QSGShaderEffectSource::setWrapMode(WrapMode mode)
+void QQuickShaderEffectSource::setWrapMode(WrapMode mode)
{
if (mode == m_wrapMode)
return;
This property holds the element to be rendered into the texture.
*/
-QSGItem *QSGShaderEffectSource::sourceItem() const
+QQuickItem *QQuickShaderEffectSource::sourceItem() const
{
return m_sourceItem;
}
-void QSGShaderEffectSource::setSourceItem(QSGItem *item)
+void QQuickShaderEffectSource::setSourceItem(QQuickItem *item)
{
if (item == m_sourceItem)
return;
if (m_sourceItem)
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
m_sourceItem = item;
if (m_sourceItem) {
// TODO: Find better solution.
m_sourceItem->setParentItem(this);
m_sourceItem->setVisible(false);
}
- QSGItemPrivate::get(m_sourceItem)->refFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->refFromEffectItem(m_hideSource);
}
update();
emit sourceItemChanged();
the whole \l sourceItem is rendered to texture.
*/
-QRectF QSGShaderEffectSource::sourceRect() const
+QRectF QQuickShaderEffectSource::sourceRect() const
{
return m_sourceRect;
}
-void QSGShaderEffectSource::setSourceRect(const QRectF &rect)
+void QQuickShaderEffectSource::setSourceRect(const QRectF &rect)
{
if (rect == m_sourceRect)
return;
size.
*/
-QSize QSGShaderEffectSource::textureSize() const
+QSize QQuickShaderEffectSource::textureSize() const
{
return m_textureSize;
}
-void QSGShaderEffectSource::setTextureSize(const QSize &size)
+void QQuickShaderEffectSource::setTextureSize(const QSize &size)
{
if (size == m_textureSize)
return;
\note Some OpenGL implementations do not support the GL_ALPHA format.
*/
-QSGShaderEffectSource::Format QSGShaderEffectSource::format() const
+QQuickShaderEffectSource::Format QQuickShaderEffectSource::format() const
{
return m_format;
}
-void QSGShaderEffectSource::setFormat(QSGShaderEffectSource::Format format)
+void QQuickShaderEffectSource::setFormat(QQuickShaderEffectSource::Format format)
{
if (format == m_format)
return;
\l sourceItem. The property is true by default.
*/
-bool QSGShaderEffectSource::live() const
+bool QQuickShaderEffectSource::live() const
{
return m_live;
}
-void QSGShaderEffectSource::setLive(bool live)
+void QQuickShaderEffectSource::setLive(bool live)
{
if (live == m_live)
return;
and meant to replace the \l sourceItem.
*/
-bool QSGShaderEffectSource::hideSource() const
+bool QQuickShaderEffectSource::hideSource() const
{
return m_hideSource;
}
-void QSGShaderEffectSource::setHideSource(bool hide)
+void QQuickShaderEffectSource::setHideSource(bool hide)
{
if (hide == m_hideSource)
return;
if (m_sourceItem) {
- QSGItemPrivate::get(m_sourceItem)->refFromEffectItem(hide);
- QSGItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
+ QQuickItemPrivate::get(m_sourceItem)->refFromEffectItem(hide);
+ QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
}
m_hideSource = hide;
update();
non-power-of-two textures.
*/
-bool QSGShaderEffectSource::mipmap() const
+bool QQuickShaderEffectSource::mipmap() const
{
return m_mipmap;
}
-void QSGShaderEffectSource::setMipmap(bool enabled)
+void QQuickShaderEffectSource::setMipmap(bool enabled)
{
if (enabled == m_mipmap)
return;
updating it means that it immediately becomes dirty again.
*/
-bool QSGShaderEffectSource::recursive() const
+bool QQuickShaderEffectSource::recursive() const
{
return m_recursive;
}
-void QSGShaderEffectSource::setRecursive(bool enabled)
+void QQuickShaderEffectSource::setRecursive(bool enabled)
{
if (enabled == m_recursive)
return;
Use this to update the texture when \l live is false.
*/
-void QSGShaderEffectSource::scheduleUpdate()
+void QQuickShaderEffectSource::scheduleUpdate()
{
if (m_grab)
return;
update();
}
-static void get_wrap_mode(QSGShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap)
+static void get_wrap_mode(QQuickShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap)
{
switch (mode) {
- case QSGShaderEffectSource::RepeatHorizontally:
+ case QQuickShaderEffectSource::RepeatHorizontally:
*hWrap = QSGTexture::Repeat;
*vWrap = QSGTexture::ClampToEdge;
break;
- case QSGShaderEffectSource::RepeatVertically:
+ case QQuickShaderEffectSource::RepeatVertically:
*vWrap = QSGTexture::Repeat;
*hWrap = QSGTexture::ClampToEdge;
break;
- case QSGShaderEffectSource::Repeat:
+ case QQuickShaderEffectSource::Repeat:
*hWrap = *vWrap = QSGTexture::Repeat;
break;
default:
- // QSGShaderEffectSource::ClampToEdge
+ // QQuickShaderEffectSource::ClampToEdge
*hWrap = *vWrap = QSGTexture::ClampToEdge;
break;
}
}
-QSGNode *QSGShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+QSGNode *QQuickShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
if (!m_sourceItem || m_sourceItem->width() == 0 || m_sourceItem->height() == 0) {
delete oldNode;
ensureTexture();
- QSGShaderEffectTexture *tex = qobject_cast<QSGShaderEffectTexture *>(m_texture);
+ QQuickShaderEffectTexture *tex = qobject_cast<QQuickShaderEffectTexture *>(m_texture);
tex->setLive(m_live);
- tex->setItem(QSGItemPrivate::get(m_sourceItem)->itemNode());
+ tex->setItem(QQuickItemPrivate::get(m_sourceItem)->itemNode());
QRectF sourceRect = m_sourceRect.width() == 0 || m_sourceRect.height() == 0
? QRectF(0, 0, m_sourceItem->width(), m_sourceItem->height())
: m_sourceRect;
? QSize(qCeil(qAbs(sourceRect.width())), qCeil(qAbs(sourceRect.height())))
: m_textureSize;
Q_ASSERT(!textureSize.isEmpty());
- QSGItemPrivate *d = static_cast<QSGItemPrivate *>(QObjectPrivate::get(this));
+ QQuickItemPrivate *d = static_cast<QQuickItemPrivate *>(QObjectPrivate::get(this));
const QSize minTextureSize = d->sceneGraphContext()->minimumFBOSize();
// Keep power-of-two by doubling the size.
while (textureSize.width() < minTextureSize.width())
tex->scheduleUpdate();
m_grab = false;
- QSGTexture::Filtering filtering = QSGItemPrivate::get(this)->smooth
+ QSGTexture::Filtering filtering = QQuickItemPrivate::get(this)->smooth
? QSGTexture::Linear
: QSGTexture::Nearest;
QSGTexture::Filtering mmFiltering = m_mipmap ? filtering : QSGTexture::None;
return 0;
}
- QSGShaderEffectSourceNode *node = static_cast<QSGShaderEffectSourceNode *>(oldNode);
+ QQuickShaderEffectSourceNode *node = static_cast<QQuickShaderEffectSourceNode *>(oldNode);
if (!node) {
- node = new QSGShaderEffectSourceNode;
+ node = new QQuickShaderEffectSourceNode;
node->setTexture(m_texture);
connect(m_texture, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()), Qt::DirectConnection);
}
projects / profile / ivi / qtdeclarative.git / blobdiff