QQuickShaderEffectTexture::QQuickShaderEffectTexture(QQuickItem *shaderSource)
: QSGDynamicTexture()
, m_item(0)
+ , m_device_pixel_ratio(1)
, m_format(GL_RGBA)
, m_renderer(0)
, m_fbo(0)
m_renderer = m_context->createRenderer();
connect(m_renderer, SIGNAL(sceneGraphChanged()), this, SLOT(markDirtyTexture()));
}
+ m_renderer->setDevicePixelRatio(m_device_pixel_ratio);
m_renderer->setRootNode(static_cast<QSGRootNode *>(root));
bool deleteFboLater = false;
: m_textureSize;
Q_ASSERT(!textureSize.isEmpty());
+ QQuickItemPrivate *d = static_cast<QQuickItemPrivate *>(QObjectPrivate::get(this));
+
// Crate large textures on high-dpi displays.
- if (sourceItem() && sourceItem()->window())
- textureSize *= sourceItem()->window()->devicePixelRatio();
+ if (sourceItem())
+ textureSize *= d->window->devicePixelRatio();
- 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())
while (textureSize.height() < minTextureSize.height())
textureSize.rheight() *= 2;
+ m_texture->setDevicePixelRatio(d->window->devicePixelRatio());
m_texture->setSize(textureSize);
m_texture->setRecursive(m_recursive);
m_texture->setFormat(GLenum(m_format));
bool recursive() const { return bool(m_recursive); }
void setRecursive(bool recursive);
+ void setDevicePixelRatio(qreal ratio) { m_device_pixel_ratio = ratio; }
+
void scheduleUpdate();
QImage toImage() const;
QSGNode *m_item;
QRectF m_rect;
QSize m_size;
+ qreal m_device_pixel_ratio;
GLenum m_format;
QSGRenderer *m_renderer;
renderer->setViewportRect(QRect(QPoint(0, 0), size * devicePixelRatio));
}
renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), size));
+ renderer->setDevicePixelRatio(q->devicePixelRatio());
context->renderNextFrame(renderer, fboId);
emit q->afterRendering();
return static_cast<const QSGRenderer *>(m_data)->currentCombinedMatrix();
}
+float QSGMaterialShader::RenderState::devicePixelRatio() const
+{
+ Q_ASSERT(m_data);
+ return static_cast<const QSGRenderer *>(m_data)->devicePixelRatio();
+}
+
/*!
QRect viewportRect() const;
QRect deviceRect() const;
float determinant() const;
+ float devicePixelRatio() const;
QOpenGLContext *context() const;
, m_clear_mode(ClearColorBuffer | ClearDepthBuffer)
, m_current_opacity(1)
, m_current_determinant(1)
+ , m_device_pixel_ratio(1)
, m_current_stencil_value(0)
, m_context(context)
, m_root_node(0)
qreal currentOpacity() const { return m_current_opacity; }
qreal determinant() const { return m_current_determinant; }
+ void setDevicePixelRatio(qreal ratio) { m_device_pixel_ratio = ratio; }
+ qreal devicePixelRatio() const { return m_device_pixel_ratio; }
+
void setProjectionMatrixToDeviceRect();
virtual void setProjectionMatrixToRect(const QRectF &rect);
void setProjectionMatrix(const QMatrix4x4 &matrix);
QMatrix4x4 m_current_model_view_matrix;
qreal m_current_opacity;
qreal m_current_determinant;
+ qreal m_device_pixel_ratio;
QRect m_current_scissor_rect;
int m_current_stencil_value;
#include <QtQuick/private/qsgdistancefieldutil_p.h>
#include <QtQuick/private/qsgtexture_p.h>
#include <QtGui/qopenglfunctions.h>
+#include <QtGui/qsurface.h>
+#include <QtGui/qwindow.h>
#include <qmath.h>
QT_BEGIN_NAMESPACE
float combinedScale = m_fontScale * m_matrixScale;
float base = thresholdFunc(combinedScale);
float range = spreadFunc(combinedScale);
-
float alphaMin = qMax(0.0f, base - range);
float alphaMax = qMin(base + range, 1.0f);
program()->setUniformValue(m_alphaMin_id, GLfloat(alphaMin));
}
if (state.isMatrixDirty()) {
program()->setUniformValue(m_matrix_id, state.combinedMatrix());
- m_matrixScale = qSqrt(qAbs(state.determinant()));
+ m_matrixScale = qSqrt(qAbs(state.determinant())) * state.devicePixelRatio();
updateRange = true;
}
if (updateRange) {