Support glow effect in 3D line overlays

interface/src/ui/overlays/Line3DOverlay.cpp

@@ -55,12 +55,14 @@ void Line3DOverlay::render(RenderArgs* args) {
         batch->setModelTransform(_transform);
 
         auto geometryCache = DependencyManager::get<GeometryCache>();
-        geometryCache->bindSimpleProgram(*batch, false, false, true, true);
         if (getIsDashedLine()) {
             // TODO: add support for color to renderDashedLine()
+            geometryCache->bindSimpleProgram(*batch, false, false, true, true);
             geometryCache->renderDashedLine(*batch, _start, _end, colorv4, _geometryCacheID);
+        } else if (_glow > 0.0f) {
+            geometryCache->renderGlowLine(*batch, _start, _end, colorv4, _glow, _glowWidth, _geometryCacheID);
         } else {
-
+            geometryCache->bindSimpleProgram(*batch, false, false, true, true);
             geometryCache->renderLine(*batch, _start, _end, colorv4, _geometryCacheID);
         }
     }
@@ -68,7 +70,7 @@ void Line3DOverlay::render(RenderArgs* args) {
 
 const render::ShapeKey Line3DOverlay::getShapeKey() {
     auto builder = render::ShapeKey::Builder().withOwnPipeline();
-    if (getAlpha() != 1.0f) {
+    if (getAlpha() != 1.0f || _glow > 0.0f) {
         builder.withTranslucent();
     }
     return builder.build();
@@ -94,6 +96,19 @@ void Line3DOverlay::setProperties(const QVariantMap& properties) {
     if (end.isValid()) {
         setEnd(vec3FromVariant(end));
     }
+
+    auto glow = properties["glow"];
+    if (glow.isValid()) {
+        setGlow(glow.toFloat());
+        if (_glow > 0.0f) {
+            _alpha = 0.5f;
+        }
+    }
+
+    auto glowWidth = properties["glow"];
+    if (glowWidth.isValid()) {
+        setGlow(glowWidth.toFloat());
+    }
 }
 
 QVariant Line3DOverlay::getProperty(const QString& property) {

interface/src/ui/overlays/Line3DOverlay.h

@@ -30,10 +30,14 @@ public:
     // getters
     const glm::vec3& getStart() const { return _start; }
     const glm::vec3& getEnd() const { return _end; }
+    const float& getGlow() const { return _glow; }
+    const float& getGlowWidth() const { return _glowWidth; }
 
     // setters
     void setStart(const glm::vec3& start) { _start = start; }
     void setEnd(const glm::vec3& end) { _end = end; }
+    void setGlow(const float& glow) { _glow = glow; }
+    void setGlowWidth(const float& glowWidth) { _glowWidth = glowWidth; }
 
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
@@ -43,6 +47,8 @@ public:
 protected:
     glm::vec3 _start;
     glm::vec3 _end;
+    float _glow { 0.0 };
+    float _glowWidth { 0.0 };
     int _geometryCacheID;
 };
 

libraries/render-utils/src/GeometryCache.cpp

@@ -15,6 +15,7 @@
 
 #include <QNetworkReply>
 #include <QThreadPool>
+#include <QtCore/QFileInfo>
 
 #include <FSTReader.h>
 #include <NumericalConstants.h>
@@ -33,6 +34,9 @@
 #include "simple_vert.h"
 #include "simple_textured_frag.h"
 #include "simple_textured_unlit_frag.h"
+#include "glowLine_vert.h"
+#include "glowLine_geom.h"
+#include "glowLine_frag.h"
 
 #include "grid_frag.h"
 
@@ -312,8 +316,7 @@ render::ShapePipelinePointer GeometryCache::_simplePipeline;
 render::ShapePipelinePointer GeometryCache::_simpleWirePipeline;
 
 GeometryCache::GeometryCache() :
-    _nextID(0)
-{
+_nextID(0) {
     buildShapes();
     GeometryCache::_simplePipeline =
         std::make_shared<render::ShapePipeline>(getSimplePipeline(), nullptr,
@@ -1233,8 +1236,7 @@ GeometryCache::BatchItemDetails::BatchItemDetails() :
 stream(NULL),
 vertices(0),
 vertexSize(0),
-    isCreated(false)
-{
+isCreated(false) {
     population++;
 #ifdef WANT_DEBUG
     qCDebug(renderutils) << "BatchItemDetails()... population:" << population << "**********************************";
@@ -1248,8 +1250,7 @@ GeometryCache::BatchItemDetails::BatchItemDetails(const GeometryCache::BatchItem
 stream(other.stream),
 vertices(other.vertices),
 vertexSize(other.vertexSize),
-    isCreated(other.isCreated)
-{
+isCreated(other.isCreated) {
     population++;
 #ifdef WANT_DEBUG
     qCDebug(renderutils) << "BatchItemDetails()... population:" << population << "**********************************";
@@ -1445,6 +1446,96 @@ void GeometryCache::renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm
     batch.draw(gpu::LINES, 2, 0);
 }
 
+
+void GeometryCache::renderGlowLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
+    const glm::vec4& color, float glowIntensity, float glowWidth, int id) {
+    if (glowIntensity <= 0) {
+        renderLine(batch, p1, p2, color, id);
+        return;
+    }
+
+    // Compile the shaders
+    static std::once_flag once;
+    std::call_once(once, [&] {
+        auto state = std::make_shared<gpu::State>();
+        auto VS = gpu::Shader::createVertex(std::string(glowLine_vert));
+        auto GS = gpu::Shader::createGeometry(std::string(glowLine_geom));
+        auto PS = gpu::Shader::createPixel(std::string(glowLine_frag));
+        auto program = gpu::Shader::createProgram(VS, GS, PS);
+        state->setCullMode(gpu::State::CULL_BACK);
+        state->setDepthTest(true, true, gpu::LESS_EQUAL);
+        state->setDepthBias(1.0f);
+        state->setDepthBiasSlopeScale(1.0f);
+        state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA);
+        gpu::Shader::BindingSet slotBindings;
+        slotBindings.insert(gpu::Shader::Binding(std::string("normalFittingMap"), render::ShapePipeline::Slot::MAP::NORMAL_FITTING));
+        gpu::Shader::makeProgram(*program, slotBindings);
+        _glowLinePipeline = gpu::Pipeline::create(program, state);
+    });
+
+    batch.setPipeline(_glowLinePipeline);
+
+    Vec3Pair key(p1, p2);
+    bool registered = (id != UNKNOWN_ID);
+    BatchItemDetails& details = registered ? _registeredLine3DVBOs[id] : _line3DVBOs[key];
+
+    int compactColor = ((int(color.x * 255.0f) & 0xFF)) |
+        ((int(color.y * 255.0f) & 0xFF) << 8) |
+        ((int(color.z * 255.0f) & 0xFF) << 16) |
+        ((int(color.w * 255.0f) & 0xFF) << 24);
+
+    // if this is a registered quad, and we have buffers, then check to see if the geometry changed and rebuild if needed
+    if (registered && details.isCreated) {
+        Vec3Pair& lastKey = _lastRegisteredLine3D[id];
+        if (lastKey != key) {
+            details.clear();
+            _lastRegisteredLine3D[id] = key;
+        }
+    }
+
+    const int FLOATS_PER_VERTEX = 3 + 3; // vertices + normals
+    const int NUM_POS_COORDS = 3;
+    const int VERTEX_NORMAL_OFFSET = NUM_POS_COORDS * sizeof(float);
+    const int vertices = 2;
+    if (!details.isCreated) {
+        details.isCreated = true;
+        details.vertices = vertices;
+        details.vertexSize = FLOATS_PER_VERTEX;
+
+        auto verticesBuffer = std::make_shared<gpu::Buffer>();
+        auto colorBuffer = std::make_shared<gpu::Buffer>();
+        auto streamFormat = std::make_shared<gpu::Stream::Format>();
+        auto stream = std::make_shared<gpu::BufferStream>();
+
+        details.verticesBuffer = verticesBuffer;
+        details.colorBuffer = colorBuffer;
+        details.streamFormat = streamFormat;
+        details.stream = stream;
+
+        details.streamFormat->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
+        details.streamFormat->setAttribute(gpu::Stream::NORMAL, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), VERTEX_NORMAL_OFFSET);
+        details.streamFormat->setAttribute(gpu::Stream::COLOR, 1, gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA));
+
+        details.stream->addBuffer(details.verticesBuffer, 0, details.streamFormat->getChannels().at(0)._stride);
+        details.stream->addBuffer(details.colorBuffer, 0, details.streamFormat->getChannels().at(1)._stride);
+
+        const glm::vec3 NORMAL(1.0f, 0.0f, 0.0f);
+        float vertexBuffer[vertices * FLOATS_PER_VERTEX] = {
+            p1.x, p1.y, p1.z, NORMAL.x, NORMAL.y, NORMAL.z,
+            p2.x, p2.y, p2.z, NORMAL.x, NORMAL.y, NORMAL.z };
+
+        const int NUM_COLOR_SCALARS = 2;
+        int colors[NUM_COLOR_SCALARS] = { compactColor, compactColor };
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
+    }
+
+    // this is what it takes to render a quad
+    batch.setInputFormat(details.streamFormat);
+    batch.setInputStream(0, *details.stream);
+    batch.draw(gpu::LINES, 2, 0);
+}
+
 void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch, bool noBlend) {
     if (!_standardDrawPipeline) {
         auto vs = gpu::Shader::createVertex(std::string(standardTransformPNTC_vert));

libraries/render-utils/src/GeometryCache.h

@@ -259,6 +259,9 @@ public:
     void renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2, 
                     const glm::vec4& color1, const glm::vec4& color2, int id = UNKNOWN_ID);
 
+    void renderGlowLine(gpu::Batch& batch, const glm::vec3& p1, const glm::vec3& p2,
+                    const glm::vec4& color, float glowIntensity = 1.0f, float glowWidth = 0.05f, int id = UNKNOWN_ID);
+
     void renderDashedLine(gpu::Batch& batch, const glm::vec3& start, const glm::vec3& end, const glm::vec4& color,
                           int id = UNKNOWN_ID)
                           { renderDashedLine(batch, start, end, color, 0.05f, 0.025f, id); }
@@ -403,6 +406,7 @@ private:
     gpu::ShaderPointer _unlitShader;
     static render::ShapePipelinePointer _simplePipeline;
     static render::ShapePipelinePointer _simpleWirePipeline;
+    gpu::PipelinePointer _glowLinePipeline;
     QHash<SimpleProgramKey, gpu::PipelinePointer> _simplePrograms;
 };
 

libraries/render-utils/src/glowLine.slf

@@ -0,0 +1,32 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Created by Bradley Austin Davis on 2016/07/05
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+layout(location = 0) in vec4 inColor;
+layout(location = 1) in vec3 inLineDistance;
+
+out vec4 _fragColor;
+
+void main(void) {
+    vec2 d = inLineDistance.xy;
+    d.y = abs(d.y);
+    d.x = abs(d.x);
+    if (d.x > 1.0) {
+        d.x = (d.x - 1.0) / 0.02;
+    } else { 
+        d.x = 0.0; 
+    }
+    float alpha = 1.0 - length(d);
+    if (alpha < 0.01) {
+        discard;
+    }
+    alpha = pow(alpha, 10.0);
+    _fragColor = vec4(inColor.rgb, alpha);
+}

libraries/render-utils/src/glowLine.slg

@@ -0,0 +1,127 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Created by Bradley Austin Davis on 2016/07/05
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#extension GL_EXT_geometry_shader4 : enable
+
+layout(location = 0) in vec4 inColor[];
+
+layout(location = 0) out vec4 outColor;
+layout(location = 1) out vec3 outLineDistance;
+
+layout(lines) in;
+layout(triangle_strip, max_vertices = 24) out;
+
+struct TransformCamera {
+    mat4 _view;
+    mat4 _viewInverse;
+    mat4 _projectionViewUntranslated;
+    mat4 _projection;
+    mat4 _projectionInverse;
+    vec4 _viewport;
+};
+
+layout(std140) uniform transformCameraBuffer {
+    TransformCamera _camera;
+};
+
+TransformCamera getTransformCamera() {
+    return _camera;
+}
+
+vec3 getEyeWorldPos() {
+    return _camera._viewInverse[3].xyz;
+}
+
+
+
+
+vec3 ndcToEyeSpace(in vec4 v) {
+    TransformCamera cam = getTransformCamera();
+    vec4 u = cam._projectionInverse * v;
+    return u.xyz / u.w;
+}
+
+vec2 toScreenSpace(in vec4 v)
+{
+    TransformCamera cam = getTransformCamera();
+    vec4 u = cam._projection * cam._view * v;
+    return u.xy / u.w;
+}
+
+vec3[2] getOrthogonals(in vec3 n, float scale) {
+    float yDot = abs(dot(n, vec3(0, 1, 0)));
+
+    vec3 result[2];
+    if (yDot < 0.9) {
+        result[0] = normalize(cross(n, vec3(0, 1, 0)));
+    } else {
+        result[0] = normalize(cross(n, vec3(1, 0, 0)));
+    }
+    // The cross of result[0] and n is orthogonal to both, which are orthogonal to each other
+    result[1] = cross(result[0], n);
+    result[0] *= scale;
+    result[1] *= scale;
+    return result;
+}
+
+
+vec2 orthogonal(vec2 v) {
+    vec2 result = v.yx;
+    result.y *= -1.0;
+    return result;
+}
+
+void main() {
+    vec2 endpoints[2];
+    vec3 eyeSpace[2];
+    TransformCamera cam = getTransformCamera();
+    for (int i = 0; i < 2; ++i) {
+        eyeSpace[i] = ndcToEyeSpace(gl_PositionIn[i]);
+        endpoints[i] = gl_PositionIn[i].xy / gl_PositionIn[i].w;
+    }
+    vec2 lineNormal = normalize(endpoints[1] - endpoints[0]);
+    vec2 lineOrthogonal = orthogonal(lineNormal);
+    lineNormal *= 0.02;
+    lineOrthogonal *= 0.02;
+
+    gl_Position = gl_PositionIn[0];
+    gl_Position.xy -= lineNormal;
+    gl_Position.xy -= lineOrthogonal;
+    outColor = inColor[0];
+    outLineDistance = vec3(-1.02, -1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[0];
+    gl_Position.xy -= lineNormal;
+    gl_Position.xy += lineOrthogonal;
+    outColor = inColor[0];
+    outLineDistance = vec3(-1.02, 1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[1];
+    gl_Position.xy += lineNormal;
+    gl_Position.xy -= lineOrthogonal;
+    outColor = inColor[1];
+    outLineDistance = vec3(1.02, -1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[1];
+    gl_Position.xy += lineNormal;
+    gl_Position.xy += lineOrthogonal;
+    outColor = inColor[1];
+    outLineDistance = vec3(1.02, 1, gl_Position.z);
+    EmitVertex();
+
+    EndPrimitive();
+}
+
+
+
+

libraries/render-utils/src/glowLine.slv

@@ -0,0 +1,26 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Created by Bradley Austin Davis on 2016/07/05
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Inputs.slh@>
+<@include gpu/Color.slh@>
+<@include gpu/Transform.slh@>
+<$declareStandardTransform()$>
+
+layout(location = 0) out vec4 _color;
+
+void main(void) {
+    _color = inColor;
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToClipPos(cam, obj, inPosition, gl_Position)$>
+}