Big cleanup of unecessary shaders and legacy from deferred lighting, and messing around with the stencil

libraries/gpu/src/gpu/DrawVertexPosition.slv

@@ -0,0 +1,19 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+// Draw the fed vertex position, pass straight as clip pos
+// Output the clip position
+//
+//  Created by Sam Gateau on 5/30/2017
+//  Copyright 2017 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 inPosition;
+
+void main(void) {
+    gl_Position = inPosition;
+}

libraries/gpu/src/gpu/StandardShaderLib.cpp

@@ -16,6 +16,7 @@
 #include "DrawTransformUnitQuad_vert.h"
 #include "DrawTexcoordRectTransformUnitQuad_vert.h"
 #include "DrawViewportQuadTransformTexcoord_vert.h"
+#include "DrawVertexPosition_vert.h"
 #include "DrawTransformVertexPosition_vert.h"
 #include "DrawWhite_frag.h"
 #include "DrawTexture_frag.h"
@@ -28,6 +29,7 @@ ShaderPointer StandardShaderLib::_drawUnitQuadTexcoordVS;
 ShaderPointer StandardShaderLib::_drawTransformUnitQuadVS;
 ShaderPointer StandardShaderLib::_drawTexcoordRectTransformUnitQuadVS;
 ShaderPointer StandardShaderLib::_drawViewportQuadTransformTexcoordVS;
+ShaderPointer StandardShaderLib::_drawVertexPositionVS;
 ShaderPointer StandardShaderLib::_drawTransformVertexPositionVS;
 ShaderPointer StandardShaderLib::_drawWhitePS;
 ShaderPointer StandardShaderLib::_drawTexturePS;
@@ -88,6 +90,14 @@ ShaderPointer StandardShaderLib::getDrawViewportQuadTransformTexcoordVS() {
     }
     return _drawViewportQuadTransformTexcoordVS;
 }
+
+ShaderPointer StandardShaderLib::getDrawVertexPositionVS() {
+    if (!_drawVertexPositionVS) {
+        _drawVertexPositionVS = gpu::Shader::createVertex(std::string(DrawVertexPosition_vert));
+    }
+    return _drawVertexPositionVS;
+}
+
 ShaderPointer StandardShaderLib::getDrawTransformVertexPositionVS() {
     if (!_drawTransformVertexPositionVS) {
         _drawTransformVertexPositionVS = gpu::Shader::createVertex(std::string(DrawTransformVertexPosition_vert));

libraries/gpu/src/gpu/StandardShaderLib.h

@@ -39,6 +39,7 @@ public:
 
     // Shader draw the fed vertex position and transform it by the full model transform stack (Model, View, Proj).
     // simply output the world pos and the clip pos to the next stage
+    static ShaderPointer getDrawVertexPositionVS();
     static ShaderPointer getDrawTransformVertexPositionVS();
 
     static ShaderPointer getDrawWhitePS();
@@ -56,6 +57,8 @@ protected:
     static ShaderPointer _drawTransformUnitQuadVS;
     static ShaderPointer _drawTexcoordRectTransformUnitQuadVS;
     static ShaderPointer _drawViewportQuadTransformTexcoordVS;
+
+    static ShaderPointer _drawVertexPositionVS;
     static ShaderPointer _drawTransformVertexPositionVS;
 
     static ShaderPointer _drawWhitePS;

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -27,18 +27,15 @@
 #include "deferred_light_point_vert.h"
 #include "deferred_light_spot_vert.h"
 
-#include "directional_light_frag.h"
 #include "directional_ambient_light_frag.h"
 #include "directional_skybox_light_frag.h"
 
-#include "directional_light_shadow_frag.h"
 #include "directional_ambient_light_shadow_frag.h"
 #include "directional_skybox_light_shadow_frag.h"
 
 #include "local_lights_shading_frag.h"
 #include "local_lights_drawOutline_frag.h"
-#include "point_light_frag.h"
+
-#include "spot_light_frag.h"
 
 using namespace render;
 
@@ -82,48 +79,26 @@ enum DeferredShader_BufferSlot {
 };
 
 static void loadLightProgram(const char* vertSource, const char* fragSource, bool lightVolume, gpu::PipelinePointer& program, LightLocationsPtr& locations);
-static void loadLightVolumeProgram(const char* vertSource, const char* fragSource, bool front, gpu::PipelinePointer& program, LightLocationsPtr& locations);
-
-const char no_light_frag[] =
-R"SCRIBE(
-out vec4 _fragColor;
-
-void main(void) {
-    _fragColor = vec4(1.0, 1.0, 1.0, 1.0);
-}
-)SCRIBE"
-;
 
 void DeferredLightingEffect::init() {
-    _directionalLightLocations = std::make_shared<LightLocations>();
     _directionalAmbientSphereLightLocations = std::make_shared<LightLocations>();
     _directionalSkyboxLightLocations = std::make_shared<LightLocations>();
 
-    _directionalLightShadowLocations = std::make_shared<LightLocations>();
     _directionalAmbientSphereLightShadowLocations = std::make_shared<LightLocations>();
     _directionalSkyboxLightShadowLocations = std::make_shared<LightLocations>();
 
     _localLightLocations = std::make_shared<LightLocations>();
     _localLightOutlineLocations = std::make_shared<LightLocations>();
-    _pointLightLocations = std::make_shared<LightLocations>();
-    _spotLightLocations = std::make_shared<LightLocations>();
 
-    loadLightProgram(deferred_light_vert, directional_light_frag, false, _directionalLight, _directionalLightLocations);
     loadLightProgram(deferred_light_vert, directional_ambient_light_frag, false, _directionalAmbientSphereLight, _directionalAmbientSphereLightLocations);
     loadLightProgram(deferred_light_vert, directional_skybox_light_frag, false, _directionalSkyboxLight, _directionalSkyboxLightLocations);
 
-    loadLightProgram(deferred_light_vert, directional_light_shadow_frag, false, _directionalLightShadow, _directionalLightShadowLocations);
     loadLightProgram(deferred_light_vert, directional_ambient_light_shadow_frag, false, _directionalAmbientSphereLightShadow, _directionalAmbientSphereLightShadowLocations);
     loadLightProgram(deferred_light_vert, directional_skybox_light_shadow_frag, false, _directionalSkyboxLightShadow, _directionalSkyboxLightShadowLocations);
 
     loadLightProgram(deferred_light_vert, local_lights_shading_frag, true, _localLight, _localLightLocations);
     loadLightProgram(deferred_light_vert, local_lights_drawOutline_frag, true, _localLightOutline, _localLightOutlineLocations);
 
-    loadLightVolumeProgram(deferred_light_point_vert, no_light_frag, false, _pointLightBack, _pointLightLocations);
-    loadLightVolumeProgram(deferred_light_point_vert, no_light_frag, true, _pointLightFront, _pointLightLocations);
-    loadLightVolumeProgram(deferred_light_spot_vert, no_light_frag, false, _spotLightBack, _spotLightLocations);
-    loadLightVolumeProgram(deferred_light_spot_vert, no_light_frag, true, _spotLightFront, _spotLightLocations);
-
     // Light Stage and clusters
     _lightStage = std::make_shared<LightStage>();
     
@@ -290,39 +265,6 @@ static void loadLightProgram(const char* vertSource, const char* fragSource, boo
 
 }
 
-
-static void loadLightVolumeProgram(const char* vertSource, const char* fragSource, bool front, gpu::PipelinePointer& pipeline, LightLocationsPtr& locations) {
-    gpu::ShaderPointer program = makeLightProgram(vertSource, fragSource, locations);
-
-    auto state = std::make_shared<gpu::State>();
-
-    // Stencil test all the light passes for objects pixels only, not the background
-
-    if (front) {
-        state->setCullMode(gpu::State::CULL_BACK);
-        state->setDepthTest(true, false, gpu::LESS_EQUAL);
-        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(0, 0xFF, gpu::NOT_EQUAL, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_DECR, gpu::State::STENCIL_OP_KEEP));
-
-      //  state->setDepthClampEnable(true);
-        // TODO: We should use DepthClamp and avoid changing geometry for inside /outside cases
-        // additive blending
-       // state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
-
-        //state->setColorWriteMask(true, true, true, false);
-        state->setColorWriteMask(false, false, false, false);
-    } else {
-        state->setCullMode(gpu::State::CULL_FRONT);
-        state->setDepthTest(true, false, gpu::LESS_EQUAL);
-        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(0, 0xFF, gpu::NOT_EQUAL, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_INCR, gpu::State::STENCIL_OP_KEEP));
-        // additive blending
-       // state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
-        // state->setColorWriteMask(true, true, true, false);
-        state->setColorWriteMask(false, false, false, false);
-    }
-    pipeline = gpu::Pipeline::create(program, state);
-
-}
-
 void DeferredLightingEffect::setGlobalLight(const model::LightPointer& light) {
  /*   auto globalLight = _allocatedLights.front();
     globalLight->setDirection(light->getDirection());
@@ -535,7 +477,7 @@ void PrepareDeferred::run(const RenderContextPointer& renderContext, const Input
             gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_COLOR1 | gpu::Framebuffer::BUFFER_COLOR2 | gpu::Framebuffer::BUFFER_COLOR3 |
             gpu::Framebuffer::BUFFER_DEPTH |
             gpu::Framebuffer::BUFFER_STENCIL,
-            vec4(vec3(0), 0), 1.0, 0.0, true);
+            vec4(vec3(0), 0), 1.0, 0, true);
 
         // For the rest of the rendering, bind the lighting model
         batch.setUniformBuffer(LIGHTING_MODEL_BUFFER_SLOT, lightingModel->getParametersBuffer());
@@ -619,8 +561,8 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
             batch.setResourceTexture(SHADOW_MAP_UNIT, globalShadow->map);
         }
 
-        auto& program = deferredLightingEffect->_shadowMapEnabled ? deferredLightingEffect->_directionalLightShadow : deferredLightingEffect->_directionalLight;
+        auto& program = deferredLightingEffect->_directionalSkyboxLight;
-        LightLocationsPtr locations = deferredLightingEffect->_shadowMapEnabled ? deferredLightingEffect->_directionalLightShadowLocations : deferredLightingEffect->_directionalLightLocations;
+        LightLocationsPtr locations = deferredLightingEffect->_directionalSkyboxLightLocations;
         const auto& keyLight = deferredLightingEffect->_allocatedLights[deferredLightingEffect->_globalLights.front()];
 
         // Setup the global directional pass pipeline

libraries/render-utils/src/DeferredLightingEffect.h

@@ -82,32 +82,21 @@ private:
 
     gpu::PipelinePointer _directionalSkyboxLight;
     gpu::PipelinePointer _directionalAmbientSphereLight;
-    gpu::PipelinePointer _directionalLight;
 
     gpu::PipelinePointer _directionalSkyboxLightShadow;
     gpu::PipelinePointer _directionalAmbientSphereLightShadow;
-    gpu::PipelinePointer _directionalLightShadow;
 
     gpu::PipelinePointer _localLight;
     gpu::PipelinePointer _localLightOutline;
 
-    gpu::PipelinePointer _pointLightBack;
-    gpu::PipelinePointer _pointLightFront;
-    gpu::PipelinePointer _spotLightBack;
-    gpu::PipelinePointer _spotLightFront;
-
     LightLocationsPtr _directionalSkyboxLightLocations;
     LightLocationsPtr _directionalAmbientSphereLightLocations;
-    LightLocationsPtr _directionalLightLocations;
 
     LightLocationsPtr _directionalSkyboxLightShadowLocations;
     LightLocationsPtr _directionalAmbientSphereLightShadowLocations;
-    LightLocationsPtr _directionalLightShadowLocations;
 
     LightLocationsPtr _localLightLocations;
     LightLocationsPtr _localLightOutlineLocations;
-    LightLocationsPtr _pointLightLocations;
-    LightLocationsPtr _spotLightLocations;
 
     using Lights = std::vector<model::LightPointer>;
 

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -85,7 +85,8 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
     const auto deferredFramebuffer = prepareDeferredOutputs.getN<PrepareDeferred::Outputs>(0);
     const auto lightingFramebuffer = prepareDeferredOutputs.getN<PrepareDeferred::Outputs>(1);
 
-    // draw a stencil mask in hidden regions of the frmaebuffer.
+    // draw a stencil mask in hidden regions of the framebuffer.
+    task.addJob<PrepareStencil>("PrepareStencil", primaryFramebuffer);
 
     // Render opaque objects in DeferredBuffer
     const auto opaqueInputs = DrawStateSortDeferred::Inputs(opaques, lightingModel).hasVarying();
@@ -93,7 +94,6 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
 
     // Once opaque is all rendered create stencil background
     task.addJob<DrawStencilDeferred>("DrawOpaqueStencil", deferredFramebuffer);
-    task.addJob<PrepareStencil>("PrepareStencil", primaryFramebuffer);
 
     task.addJob<EndGPURangeTimer>("OpaqueRangeTimer", opaqueRangeTimer);
 
@@ -401,7 +401,7 @@ gpu::PipelinePointer DrawStencilDeferred::getOpaquePipeline() {
 
         auto state = std::make_shared<gpu::State>();
         state->setDepthTest(true, false, gpu::LESS_EQUAL);
-        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(STENCIL_OPAQUE, 0xFF, gpu::ALWAYS, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_KEEP));
+        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(STENCIL_OPAQUE, 0xFF, gpu::ALWAYS, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP));
         state->setColorWriteMask(0);
 
         _opaquePipeline = gpu::Pipeline::create(program, state);
@@ -410,6 +410,7 @@ gpu::PipelinePointer DrawStencilDeferred::getOpaquePipeline() {
 }
 
 void DrawStencilDeferred::run(const RenderContextPointer& renderContext, const DeferredFramebufferPointer& deferredFramebuffer) {
+  //  return;
     assert(renderContext->args);
     assert(renderContext->args->hasViewFrustum());
 
@@ -474,15 +475,14 @@ void DrawBackgroundDeferred::run(const RenderContextPointer& renderContext, cons
 
 gpu::PipelinePointer PrepareStencil::getDrawStencilPipeline() {
     if (!_drawStencilPipeline) {
-        const gpu::int8 STENCIL_OPAQUE = 1;
+        auto vs = gpu::StandardShaderLib::getDrawVertexPositionVS();
-        auto vs = gpu::StandardShaderLib::getDrawTransformVertexPositionVS();
         auto ps = gpu::StandardShaderLib::getDrawWhitePS();
         auto program = gpu::Shader::createProgram(vs, ps);
         gpu::Shader::makeProgram((*program));
 
         auto state = std::make_shared<gpu::State>();
-        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(0, 0xFF, gpu::ALWAYS, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_KEEP));
+        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(STENCIL_MASK, 0xFF, gpu::ALWAYS, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_REPLACE, gpu::State::STENCIL_OP_REPLACE));
-        state->setColorWriteMask(0);
+     //   state->setColorWriteMask(0);
 
         _drawStencilPipeline = gpu::Pipeline::create(program, state);
     }
@@ -499,9 +499,7 @@ model::MeshPointer PrepareStencil::getMesh() {
             { 1.0f, -1.0f, 0.0f }, { 0.0f, -1.0f, 0.0f } };
 
         std::vector<uint32_t> indices { 0, 7, 1, 1, 3, 2, 3, 5, 4, 5, 7, 6 };
-
         _mesh = model::Mesh::createIndexedTriangles_P3F((uint32_t) vertices.size(), (uint32_t) indices.size(), vertices.data(), indices.data());
-
     }
     return _mesh;
 }
@@ -514,19 +512,14 @@ void PrepareStencil::run(const RenderContextPointer& renderContext, const gpu::F
     RenderArgs* args = renderContext->args;
     doInBatch(args->_context, [&](gpu::Batch& batch) {
         args->_batch = &batch;
+        batch.enableStereo(false);
 
         batch.setViewportTransform(args->_viewport);
-        batch.setStateScissorRect(args->_viewport);
-
-        batch.resetViewTransform();
-        batch.setModelTransform(Transform());
-        glm::mat4 proj;
-        batch.setProjectionTransform(proj);
 
         batch.setPipeline(getDrawStencilPipeline());
 
         auto mesh = getMesh();
-        batch.setIndexBuffer(gpu::UINT32, (mesh->getIndexBuffer()._buffer), 0);
+        batch.setIndexBuffer(mesh->getIndexBuffer());
         batch.setInputFormat((mesh->getVertexFormat()));
         batch.setInputStream(0, mesh->getVertexStream());
 

libraries/render-utils/src/RenderDeferredTask.h

@@ -191,6 +191,9 @@ public:
     using JobModel = render::Job::ModelI<PrepareStencil, gpu::FramebufferPointer>;
 
     void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& dstFramebuffer);
+
+    static const gpu::int8 STENCIL_MASK = 64;
+
 private:
     gpu::PipelinePointer _drawStencilPipeline;
     gpu::PipelinePointer getDrawStencilPipeline();

libraries/render-utils/src/RenderPipelines.cpp

@@ -330,6 +330,7 @@ void addPlumberPipeline(ShapePlumber& plumber,
         bool isWireframed = (i & 4);
 
         auto state = std::make_shared<gpu::State>();
+        state->setStencilTest(true, 0xFF, gpu::State::StencilTest(0, 0xFF, gpu::GREATER, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_KEEP, gpu::State::STENCIL_OP_INCR_SAT));
 
         // Depth test depends on transparency
         state->setDepthTest(true, !key.isTranslucent(), gpu::LESS_EQUAL);

libraries/render-utils/src/directional_light.slf

@@ -1,47 +0,0 @@
-<@include gpu/Config.slh@>
-<$VERSION_HEADER$>
-//  Generated on <$_SCRIBE_DATE$>
-//
-//  directional_light.frag
-//  fragment shader
-//
-//  Created by Andrzej Kapolka on 9/3/14.
-//  Copyright 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 DeferredBufferRead.slh@>
-<@include DeferredGlobalLight.slh@>
-
-<$declareEvalLightmappedColor()$>
-<$declareEvalAmbientGlobalColor()$>
-
-in vec2 _texCoord0;
-out vec4 _fragColor;
-
-void main(void) {
-    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
-    DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
-
-    float shadowAttenuation = 1.0;
-
-    if (frag.mode == FRAG_MODE_UNLIT) {
-        discard;
-    } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
-        discard;
-    } else {
-        vec3 color =  evalAmbientGlobalColor(
-                        getViewInverse(),
-                        shadowAttenuation,
-                        frag.obscurance,
-                        frag.position.xyz,
-                        frag.normal,
-                        frag.albedo,
-                        frag.fresnel,
-                        frag.metallic,
-                        frag.roughness);
-        _fragColor = vec4(color, 1.0);
-    }
-}

libraries/render-utils/src/directional_light_shadow.slf

@@ -1,49 +0,0 @@
-<@include gpu/Config.slh@>
-<$VERSION_HEADER$>
-//  Generated on <$_SCRIBE_DATE$>
-//
-//  directional_light_shadow.frag
-//  fragment shader
-//
-//  Created by Zach Pomerantz on 1/18/2016.
-//  Copyright 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 Shadow.slh@>
-<@include DeferredBufferRead.slh@>
-<@include DeferredGlobalLight.slh@>
-
-<$declareEvalLightmappedColor()$>
-<$declareEvalAmbientGlobalColor()$>
-
-in vec2 _texCoord0;
-out vec4 _fragColor;
-
-void main(void) {
-    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
-    DeferredFragment frag = unpackDeferredFragment(deferredTransform, _texCoord0);
-
-    vec4 worldPos = getViewInverse() * vec4(frag.position.xyz, 1.0);
-    float shadowAttenuation = evalShadowAttenuation(worldPos);
-
-    if (frag.mode == FRAG_MODE_UNLIT) {
-        discard;
-    } else if (frag.mode == FRAG_MODE_LIGHTMAPPED) {
-        discard;
-    } else {
-        vec3 color =  evalAmbientGlobalColor(
-                        getViewInverse(),
-                        shadowAttenuation,
-                        frag.obscurance,
-                        frag.position.xyz,
-                        frag.normal,
-                        frag.albedo,
-                        frag.fresnel,
-                        frag.metallic,
-                        frag.roughness);
-        _fragColor = vec4(color, 1.0);
-    }
-}

libraries/render-utils/src/point_light.slf

@@ -1,85 +0,0 @@
-<@include gpu/Config.slh@>
-<$VERSION_HEADER$>
-//  Generated on <$_SCRIBE_DATE$>
-//
-//  point_light.frag
-//  fragment shader
-//
-//  Created by Sam Gateau on 9/18/15.
-//  Copyright 2014 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
-//
-<!
-// Everything about deferred buffer
-<@include DeferredBufferRead.slh@>
-
-<$declareDeferredCurvature()$>
-
-// Everything about light
-<@include model/Light.slh@>
-<$declareLightBuffer()$>
-
-<@include LightingModel.slh@>
-
-<@include LightPoint.slh@>
-<$declareLightingPoint(supportScattering)$>
-
-
-uniform vec4 texcoordFrameTransform;
-
-in vec4 _texCoord0;!>
-out vec4 _fragColor;
-
-void main(void) {
-    _fragColor = vec4(1.0, 1.0, 1.0, 1.0);
-
-    <!
-    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
-
-    // Grab the fragment data from the uv
-    vec2 texCoord = _texCoord0.st / _texCoord0.q;
-    texCoord *= texcoordFrameTransform.zw;
-    texCoord += texcoordFrameTransform.xy;
-
-    DeferredFragment frag = unpackDeferredFragment(deferredTransform, texCoord);
-
-    if (frag.mode == FRAG_MODE_UNLIT) {
-        discard;
-    }
-
-    // Need the light now
-    Light light = getLight();
-
-    // Frag pos in world
-    mat4 invViewMat = getViewInverse();
-    vec4 fragPos = invViewMat * frag.position;
-
-    // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
-    vec4 fragLightVecLen2;
-    if (!lightVolume_clipFragToLightVolumePoint(light.volume, fragPos.xyz, fragLightVecLen2)) {
-        discard;
-    }
-
-    // Frag to eye vec
-    vec4 fragEyeVector = invViewMat * vec4(-frag.position.xyz, 0.0);
-    vec3 fragEyeDir = normalize(fragEyeVector.xyz);
-
-
-    vec3 diffuse;
-    vec3 specular;
-    vec4 midNormalCurvature;
-    vec4 lowNormalCurvature;
-    if (frag.mode == FRAG_MODE_SCATTERING) {
-        unpackMidLowNormalCurvature(texCoord, midNormalCurvature, lowNormalCurvature);
-    }
-    evalLightingPoint(diffuse, specular, light,
-        fragLightVecLen2.xyz, fragEyeDir, frag.normal, frag.roughness,
-        frag.metallic, frag.fresnel, frag.albedo, 1.0,
-        frag.scattering, midNormalCurvature, lowNormalCurvature);
-
-    _fragColor.rgb += diffuse;
-    _fragColor.rgb += specular;
-    !>
-}

libraries/render-utils/src/spot_light.slf

@@ -1,115 +0,0 @@
-<@include gpu/Config.slh@>
-<$VERSION_HEADER$>
-//  Generated on <$_SCRIBE_DATE$>
-//
-//  spot_light.frag
-//  fragment shader
-//
-//  Created by Sam Gateau on 9/18/15.
-//  Copyright 2014 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
-//
-
-// Everything about deferred buffer
-<!<@include DeferredBufferRead.slh@>
-
-<$declareDeferredCurvature()$>
-
-// Everything about light
-<@include model/Light.slh@>
-<$declareLightBuffer(256)$>
-uniform lightIndexBuffer {
-    int lightIndex[256];
-};
-<@include LightingModel.slh@>
-
-<@include LightPoint.slh@>
-<$declareLightingPoint(supportScattering)$>
-<@include LightSpot.slh@>
-<$declareLightingSpot(supportScattering)$>
-
-//uniform vec4 texcoordFrameTransform;
-!>
-
-
-//in vec4 _texCoord0;
-//flat in int instanceID;
-out vec4 _fragColor;
-
-void main(void) {
-    _fragColor = vec4(1.0, 1.0, 1.0, 1.0);
-
-//    DeferredFrameTransform deferredTransform = getDeferredFrameTransform();
-    
-    // Grab the fragment data from the uv
-    //vec2 texCoord = _texCoord0.st;/* / _texCoord0.q;
-    /*texCoord *= texcoordFrameTransform.zw;
-    texCoord += texcoordFrameTransform.xy;*/
-    /*
-    vec4 fragPosition = unpackDeferredPositionFromZeye(texCoord);
-    DeferredFragment frag = unpackDeferredFragmentNoPosition(texCoord);
-
-    if (frag.mode == FRAG_MODE_UNLIT) {
-        discard;
-    }
-
-
-   // frag.depthVal = depthValue;
-    frag.position = fragPosition;
-
-    vec4 midNormalCurvature;
-    vec4 lowNormalCurvature;
-    if (frag.mode == FRAG_MODE_SCATTERING) {
-        unpackMidLowNormalCurvature(texCoord, midNormalCurvature, lowNormalCurvature);
-    }
-
-    // Frag pos in world
-    mat4 invViewMat = getViewInverse();
-    vec4 fragPos = invViewMat * fragPosition;
-
-    // Frag to eye vec
-    vec4 fragEyeVector = invViewMat * vec4(-frag.position.xyz, 0.0);
-    vec3 fragEyeDir = normalize(fragEyeVector.xyz);
-
-    int numLights = lightIndex[0];
-    for (int i = 0; i < numLights; i++) {
-        // Need the light now
-        Light light = getLight(lightIndex[i + 1]);
-        bool isSpot = light_isSpot(light);
-        // Clip againgst the light volume and Make the Light vector going from fragment to light center in world space
-        vec4 fragLightVecLen2;
-        vec4 fragLightDirLen;
-        float cosSpotAngle;
-        if (isSpot) {
-            if (!clipFragToLightVolumeSpot(light, fragPos.xyz, fragLightVecLen2, fragLightDirLen, cosSpotAngle)) {
-                continue;
-            }
-        } else {
-            if (!clipFragToLightVolumePoint(light, fragPos.xyz, fragLightVecLen2)) {
-                continue;
-            }
-        }
-
-        vec3 diffuse;
-        vec3 specular;
-
-        if (isSpot) {
-            evalLightingSpot(diffuse, specular, light,
-                fragLightDirLen.xyzw, cosSpotAngle, fragEyeDir, frag.normal, frag.roughness,
-                frag.metallic, frag.fresnel, frag.albedo, 1.0,
-                frag.scattering, midNormalCurvature, lowNormalCurvature);
-        } else {
-            evalLightingPoint(diffuse, specular, light,
-                fragLightVecLen2.xyz, fragEyeDir, frag.normal, frag.roughness,
-                frag.metallic, frag.fresnel, frag.albedo, 1.0,
-                frag.scattering, midNormalCurvature, lowNormalCurvature);
-        }
-
-        _fragColor.rgb += diffuse;
-        _fragColor.rgb += specular;
-    }
-    */
-}
-