Add support for drop-shadows for text

Task-number: QT3DS-2644
Change-Id: I19d3b8e77d50e4817b83c528383bbe0e1931fdc9
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

5 files changed, 106 insertions, 12 deletions

diff --git a/src/runtime/q3dstextrenderer.cpp b/src/runtime/q3dstextrenderer.cpp
index e55fec9..2a46f33 100644
--- a/src/runtime/q3dstextrenderer.cpp
+++ b/src/runtime/q3dstextrenderer.cpp
@@ -193,6 +193,7 @@ void Q3DSTextRenderer::renderText(QPainter *painter, Q3DSTextNode *text3DS)
 
     updateFontInfo(font, text3DS);
 
+    int shadowRgb = int(2.55f * (100 - int(text3DS->shadowStrength())));
     QFontMetricsF fm(font->font);
     const QStringList lineList = text3DS->text().split('\n');
     QVector<float> lineWidths;
@@ -216,10 +217,36 @@ void Q3DSTextRenderer::renderText(QPainter *painter, Q3DSTextNode *text3DS)
     case Q3DSTextNode::Right:
         tracking += qreal(text3DS->tracking());
         break;
-    default:
+    case Q3DSTextNode::Left:
         break;
     }
 
+    qreal shadowOffsetX = 0.;
+    qreal shadowOffsetY = 0.;
+    if (text3DS->shadow()) {
+        const qreal offset = qreal(text3DS->shadowOffset()) / 10.;
+        switch (text3DS->shadowHorizontalAlignment()) {
+        case Q3DSTextNode::Left:
+            shadowOffsetX = -offset;
+            break;
+        case Q3DSTextNode::Right:
+            shadowOffsetX = offset;
+            break;
+        case Q3DSTextNode::Center:
+            break;
+        }
+        switch (text3DS->shadowVerticalAlignment()) {
+        case Q3DSTextNode::Top:
+            shadowOffsetY = -offset;
+            break;
+        case Q3DSTextNode::Bottom:
+            shadowOffsetY = offset;
+            break;
+        case Q3DSTextNode::Middle:
+            break;
+        }
+    }
+
     const qreal lineHeight = fm.height();
     qreal nextHeight = 0.0;
     for (int i = 0; i < lineList.size(); ++i) {
@@ -232,12 +259,22 @@ void Q3DSTextRenderer::renderText(QPainter *painter, Q3DSTextNode *text3DS)
         case Q3DSTextNode::Right:
             xTranslation += boundingBox.width() - qreal(lineWidths.at(i));
             break;
-        default:
+        case Q3DSTextNode::Left:
             break;
         }
         QRectF bound(xTranslation, nextHeight, qreal(lineWidths.at(i)), lineHeight);
         QRectF actualBound;
-        painter->drawText(bound, mapVertAlign(text3DS) | Qt::TextDontClip | Qt::AlignLeft, line, &actualBound);
+        if (text3DS->shadow()) {
+            QRectF boundShadow(xTranslation + shadowOffsetX, nextHeight + shadowOffsetY,
+                               qreal(lineWidths.at(i)), lineHeight);
+            // shadow is a darker shade of the given font color
+            painter->setPen(QColor(shadowRgb, shadowRgb, shadowRgb));
+            painter->drawText(boundShadow, mapVertAlign(text3DS) | Qt::TextDontClip | Qt::AlignLeft,
+                              line, &actualBound);
+            painter->setPen(Qt::white); // coloring is done in the shader
+        }
+        painter->drawText(bound, mapVertAlign(text3DS) | Qt::TextDontClip | Qt::AlignLeft, line,
+                          &actualBound);
         nextHeight += lineHeight + qreal(text3DS->leading());
     }
 }
diff --git a/src/runtime/q3dsuippresentation.cpp b/src/runtime/q3dsuippresentation.cpp
index b2fb022..ff3ae7f 100644
--- a/src/runtime/q3dsuippresentation.cpp
+++ b/src/runtime/q3dsuippresentation.cpp
@@ -3462,6 +3462,11 @@ void Q3DSTextNode::setProps(const V &attrs, PropSetFlags flags)
     parseProperty(attrs, flags, typeName, QStringLiteral("vertalign"), &m_vertAlign);
     parseProperty(attrs, flags, typeName, QStringLiteral("leading"), &m_leading);
     parseProperty(attrs, flags, typeName, QStringLiteral("tracking"), &m_tracking);
+    parseProperty(attrs, flags, typeName, QStringLiteral("dropshadow"), &m_shadow);
+    parseProperty(attrs, flags, typeName, QStringLiteral("dropshadowstrength"), &m_shadowStrength);
+    parseProperty(attrs, flags, typeName, QStringLiteral("dropshadowoffset"), &m_shadowOffset);
+    parseProperty(attrs, flags, typeName, QStringLiteral("dropshadowhorzalign"), &m_shadowHorzAlign);
+    parseProperty(attrs, flags, typeName, QStringLiteral("dropshadowvertalign"), &m_shadowVertAlign);
 
     // Different default value.
     parseProperty(attrs, flags, typeName, QStringLiteral("name"), &m_name);
@@ -3483,13 +3488,18 @@ int Q3DSTextNode::mapChangeFlags(const Q3DSPropertyChangeList &changeList) const
 {
     int changeFlags = Q3DSNode::mapChangeFlags(changeList);
     for (auto it = changeList.cbegin(), itEnd = changeList.cend(); it != itEnd; ++it) {
-        if (it->nameStr() == QStringLiteral("textstring")
-                || it->nameStr() == QStringLiteral("leading")
-                || it->nameStr() == QStringLiteral("tracking")
-                || it->nameStr() == QStringLiteral("size")
-                || it->nameStr() == QStringLiteral("font")
-                || it->nameStr() == QStringLiteral("horzalign")
-                || it->nameStr() == QStringLiteral("vertalign"))
+        if (it->nameStr() == QLatin1String("textstring")
+                || it->nameStr() == QLatin1String("leading")
+                || it->nameStr() == QLatin1String("tracking")
+                || it->nameStr() == QLatin1String("dropshadow")
+                || it->nameStr() == QLatin1String("dropshadowstrength")
+                || it->nameStr() == QLatin1String("dropshadowoffset")
+                || it->nameStr() == QLatin1String("dropshadowhorzalign")
+                || it->nameStr() == QLatin1String("dropshadowvertalign")
+                || it->nameStr() == QLatin1String("size")
+                || it->nameStr() == QLatin1String("font")
+                || it->nameStr() == QLatin1String("horzalign")
+                || it->nameStr() == QLatin1String("vertalign"))
         {
             changeFlags |= TextureImageDepChanges;
         }
@@ -3537,6 +3547,31 @@ Q3DSPropertyChange Q3DSTextNode::setTracking(float v)
     return createPropSetter(m_tracking, v, "tracking");
 }
 
+Q3DSPropertyChange Q3DSTextNode::setShadow(bool v)
+{
+    return createPropSetter(m_shadow, v, "dropshadow");
+}
+
+Q3DSPropertyChange Q3DSTextNode::setShadowStrength(float v)
+{
+    return createPropSetter(m_shadowStrength, v, "dropshadowstrength");
+}
+
+Q3DSPropertyChange Q3DSTextNode::setShadowOffset(float v)
+{
+    return createPropSetter(m_shadowOffset, v, "dropshadowoffset");
+}
+
+Q3DSPropertyChange Q3DSTextNode::setShadowHorizontalAlignment(HorizontalAlignment v)
+{
+    return createPropSetter(m_shadowHorzAlign, v, "dropshadowhorzalign");
+}
+
+Q3DSPropertyChange Q3DSTextNode::setShadowVerticalAlignment(VerticalAlignment v)
+{
+    return createPropSetter(m_shadowVertAlign, v, "dropshadowvertalign");
+}
+
 Q3DSAliasNode::Q3DSAliasNode()
     : Q3DSNode(Q3DSNode::Alias)
 {
diff --git a/src/runtime/q3dsuippresentation_p.h b/src/runtime/q3dsuippresentation_p.h
index 3a2381d..e0de77b 100644
--- a/src/runtime/q3dsuippresentation_p.h
+++ b/src/runtime/q3dsuippresentation_p.h
@@ -1540,6 +1540,13 @@ class Q3DSV_PRIVATE_EXPORT Q3DSTextNode : public Q3DSNode
     Q_PROPERTY(VerticalAlignment vertalign READ verticalAlignment WRITE setVerticalAlignment)
     Q_PROPERTY(float leading READ leading WRITE setLeading)
     Q_PROPERTY(float tracking READ tracking WRITE setTracking)
+    Q_PROPERTY(bool shadow READ shadow WRITE setShadow)
+    Q_PROPERTY(float shadowStrength READ shadowStrength WRITE setShadowStrength)
+    Q_PROPERTY(float shadowOffset READ shadowOffset WRITE setShadowOffset)
+    Q_PROPERTY(HorizontalAlignment shadowHorzAlign READ shadowHorizontalAlignment
+               WRITE setShadowHorizontalAlignment)
+    Q_PROPERTY(VerticalAlignment shadowVertAlign READ shadowVerticalAlignment
+               WRITE setShadowVerticalAlignment)
 public:
     enum HorizontalAlignment {
         Left = 0,
@@ -1574,6 +1581,11 @@ public:
     VerticalAlignment verticalAlignment() const { return m_vertAlign; }
     float leading() const { return m_leading; }
     float tracking() const { return m_tracking; }
+    bool shadow() const { return m_shadow; }
+    float shadowStrength() const { return m_shadowStrength; }
+    float shadowOffset() const { return m_shadowOffset; }
+    HorizontalAlignment shadowHorizontalAlignment() const { return m_shadowHorzAlign; }
+    VerticalAlignment shadowVerticalAlignment() const { return m_shadowVertAlign; }
 
     Q3DSPropertyChange setText(const QString &v);
     Q3DSPropertyChange setColor(const QColor &v);
@@ -1583,6 +1595,11 @@ public:
     Q3DSPropertyChange setVerticalAlignment(VerticalAlignment v);
     Q3DSPropertyChange setLeading(float v);
     Q3DSPropertyChange setTracking(float v);
+    Q3DSPropertyChange setShadow(bool v);
+    Q3DSPropertyChange setShadowStrength(float v);
+    Q3DSPropertyChange setShadowOffset(float v);
+    Q3DSPropertyChange setShadowHorizontalAlignment(HorizontalAlignment v);
+    Q3DSPropertyChange setShadowVerticalAlignment(VerticalAlignment v);
 
 private:
     Q_DISABLE_COPY(Q3DSTextNode)
@@ -1596,6 +1613,11 @@ private:
     VerticalAlignment m_vertAlign = Middle;
     float m_leading = 0;
     float m_tracking = 0;
+    bool m_shadow = false;
+    float m_shadowStrength = 80;
+    float m_shadowOffset = 10;
+    HorizontalAlignment m_shadowHorzAlign = Right;
+    VerticalAlignment m_shadowVertAlign = Bottom;
 };
 
 class Q3DSV_PRIVATE_EXPORT Q3DSDefaultMaterial : public Q3DSGraphObject
diff --git a/src/runtime/shaders/text.frag b/src/runtime/shaders/text.frag
index 34b3394..b074948 100644
--- a/src/runtime/shaders/text.frag
+++ b/src/runtime/shaders/text.frag
@@ -9,5 +9,5 @@ uniform vec3 color;
 void main()
 {
     vec4 c = texture2D(tex, vec2(texCoord.x, 1.0 - texCoord.y));
-    gl_FragColor = vec4(c.aaa * color, c.a) * opacity;
+    gl_FragColor = vec4(mix(c.aaa, c.rgb, c.a) * color, c.a) * opacity;
 }
diff --git a/src/runtime/shaders/text_core.frag b/src/runtime/shaders/text_core.frag
index a614bb1..8029ecd 100644
--- a/src/runtime/shaders/text_core.frag
+++ b/src/runtime/shaders/text_core.frag
@@ -11,5 +11,5 @@ out vec4 fragColor;
 void main()
 {
     vec4 c = texture(tex, vec2(texCoord.x, 1.0 - texCoord.y));
-    fragColor = vec4(c.aaa * color, c.a) * opacity;
+    fragColor = vec4(mix(c.aaa, c.rgb, c.a) * color, c.a) * opacity;
 }