Merged with master. Had to add back shaders and code

libraries/render-utils/src/DeferredGlobalLight.slh

@@ -204,6 +204,13 @@ vec3 evalGlobalLightingAlphaBlended(mat4 invViewMat, float shadowAttenuation, fl
     return color;
 }
 
+<@endfunc@>
+
+<@func declareEvalGlobalLightingAlphaBlendedWithHaze()@>
+
+<$declareLightingAmbient(1, 1, 1)$>
+<$declareLightingDirectional()$>
+
 vec3 evalGlobalLightingAlphaBlendedWithHaze(
     mat4 invViewMat, float shadowAttenuation, float obscurance, vec3 position, vec3 normal, 
     vec3 albedo, vec3 fresnel, float metallic, vec3 emissive, float roughness, float opacity) 

libraries/render-utils/src/RenderPipelines.cpp

@@ -31,6 +31,7 @@
 #include "model_lightmap_normal_map_fade_vert.h"
 #include "model_translucent_vert.h"
 #include "model_translucent_fade_vert.h"
+#include "model_translucent_normal_map_vert.h"
 #include "skin_model_fade_vert.h"
 #include "skin_model_normal_map_fade_vert.h"
 
@@ -73,12 +74,14 @@
 #include "model_lightmap_specular_map_frag.h"
 #include "model_translucent_frag.h"
 #include "model_translucent_unlit_frag.h"
+#include "model_translucent_normal_map_frag.h"
 
 #include "model_lightmap_fade_frag.h"
 #include "model_lightmap_normal_map_fade_frag.h"
 #include "model_lightmap_normal_specular_map_fade_frag.h"
 #include "model_lightmap_specular_map_fade_frag.h"
 #include "model_translucent_fade_frag.h"
+#include "model_translucent_normal_map_fade_frag.h"
 #include "model_translucent_unlit_fade_frag.h"
 
 #include "overlay3D_vert.h"
@@ -191,6 +194,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelLightmapVertex = gpu::Shader::createVertex(std::string(model_lightmap_vert));
     auto modelLightmapNormalMapVertex = gpu::Shader::createVertex(std::string(model_lightmap_normal_map_vert));
     auto modelTranslucentVertex = gpu::Shader::createVertex(std::string(model_translucent_vert));
+    auto modelTranslucentNormalMapVertex = gpu::Shader::createVertex(std::string(model_translucent_normal_map_vert));
     auto modelTranslucentFadeVertex = gpu::Shader::createVertex(std::string(model_translucent_fade_vert));
     auto modelShadowVertex = gpu::Shader::createVertex(std::string(model_shadow_vert));
     auto skinModelVertex = gpu::Shader::createVertex(std::string(skin_model_vert));
@@ -220,6 +224,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelSpecularMapPixel = gpu::Shader::createPixel(std::string(model_specular_map_frag));
     auto modelNormalSpecularMapPixel = gpu::Shader::createPixel(std::string(model_normal_specular_map_frag));
     auto modelTranslucentPixel = gpu::Shader::createPixel(std::string(model_translucent_frag));
+    auto modelTranslucentNormalMapPixel = gpu::Shader::createPixel(std::string(model_translucent_normal_map_frag));
     auto modelTranslucentUnlitPixel = gpu::Shader::createPixel(std::string(model_translucent_unlit_frag));
     auto modelShadowPixel = gpu::Shader::createPixel(std::string(model_shadow_frag));
     auto modelLightmapPixel = gpu::Shader::createPixel(std::string(model_lightmap_frag));
@@ -238,6 +243,7 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
     auto modelNormalSpecularMapFadePixel = gpu::Shader::createPixel(std::string(model_normal_specular_map_fade_frag));
     auto modelShadowFadePixel = gpu::Shader::createPixel(std::string(model_shadow_fade_frag));
     auto modelTranslucentFadePixel = gpu::Shader::createPixel(std::string(model_translucent_fade_frag));
+    auto modelTranslucentNormalMapFadePixel = gpu::Shader::createPixel(std::string(model_translucent_normal_map_fade_frag));
     auto modelTranslucentUnlitFadePixel = gpu::Shader::createPixel(std::string(model_translucent_unlit_fade_frag));
     auto simpleFadePixel = gpu::Shader::createPixel(std::string(simple_textured_fade_frag));
     auto simpleUnlitFadePixel = gpu::Shader::createPixel(std::string(simple_textured_unlit_fade_frag));
@@ -307,13 +313,13 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
         simpleVertex, simpleTranslucentUnlitPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents(),
-        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentNormalMapVertex, modelTranslucentNormalMapPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withSpecular(),
         modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents().withSpecular(),
-        modelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        modelTranslucentNormalMapVertex, modelTranslucentNormalMapPixel, nullptr, nullptr);
     addPipeline(
         // FIXME: Ignore lightmap for translucents meshpart
         Key::Builder().withMaterial().withTranslucent().withLightmap(),
@@ -333,13 +339,13 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
         simpleFadeVertex, simpleTranslucentUnlitFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents().withFade(),
-        modelNormalMapFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
+        modelTranslucentNormalMapVertex, modelTranslucentNormalMapFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withSpecular().withFade(),
         modelFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withTranslucent().withTangents().withSpecular().withFade(),
-        modelNormalMapFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
+        modelTranslucentNormalMapVertex, modelTranslucentNormalMapFadePixel, batchSetter, itemSetter);
     addPipeline(
         // FIXME: Ignore lightmap for translucents meshpart
         Key::Builder().withMaterial().withTranslucent().withLightmap().withFade(),
@@ -405,26 +411,26 @@ void initDeferredPipelines(render::ShapePlumber& plumber, const render::ShapePip
         skinModelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents(),
-        skinModelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelNormalMapTranslucentVertex, modelTranslucentNormalMapPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withSpecular(),
         skinModelTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents().withSpecular(),
-        skinModelNormalMapTranslucentVertex, modelTranslucentPixel, nullptr, nullptr);
+        skinModelNormalMapTranslucentVertex, modelTranslucentNormalMapPixel, nullptr, nullptr);
     // Same thing but with Fade on
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withFade(),
         skinModelFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents().withFade(),
-        skinModelNormalMapFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
+        skinModelNormalMapFadeVertex, modelTranslucentNormalMapFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withSpecular().withFade(),
         skinModelFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
     addPipeline(
         Key::Builder().withMaterial().withSkinned().withTranslucent().withTangents().withSpecular().withFade(),
-        skinModelNormalMapFadeVertex, modelTranslucentFadePixel, batchSetter, itemSetter);
+        skinModelNormalMapFadeVertex, modelTranslucentNormalMapFadePixel, batchSetter, itemSetter);
 
     // Depth-only
     addPipeline(

libraries/render-utils/src/model_translucent.slf

@@ -16,7 +16,7 @@
 
 <@include DeferredGlobalLight.slh@>
 
-<$declareEvalGlobalLightingAlphaBlended()$>
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
 
 <@include LightLocal.slh@>
 

libraries/render-utils/src/model_translucent_fade.slf

@@ -16,7 +16,7 @@
 
 <@include DeferredGlobalLight.slh@>
 
-<$declareEvalGlobalLightingAlphaBlended()$>
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
 
 <@include LightLocal.slh@>
 

libraries/render-utils/src/model_translucent_normal_map.slf

@@ -0,0 +1,91 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  model_translucent_normal_map.frag
+//  fragment shader
+//
+//  Created by Olivier Prat on 23/01/2018.
+//  Copyright 2018 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 graphics/Material.slh@>
+
+<@include DeferredGlobalLight.slh@>
+
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
+
+<@include LightLocal.slh@>
+
+<@include gpu/Transform.slh@>
+<$declareStandardCameraTransform()$>
+
+<@include MaterialTextures.slh@>
+<$declareMaterialTextures(ALBEDO, ROUGHNESS, NORMAL, _SCRIBE_NULL, EMISSIVE, OCCLUSION)$>
+
+in vec2 _texCoord0;
+in vec2 _texCoord1;
+in vec4 _position;
+in vec4 _worldPosition;
+in vec3 _normal;
+in vec3 _tangent;
+in vec3 _color;
+in float _alpha;
+
+out vec4 _fragColor;
+
+void main(void) {
+    Material mat = getMaterial();
+    int matKey = getMaterialKey(mat);
+    <$fetchMaterialTexturesCoord0(matKey, _texCoord0, albedoTex, roughnessTex, normalTex, _SCRIBE_NULL, emissiveTex)$>
+    <$fetchMaterialTexturesCoord1(matKey, _texCoord1, occlusionTex)$>
+
+    float opacity = getMaterialOpacity(mat) * _alpha;
+    <$evalMaterialOpacity(albedoTex.a, opacity, matKey, opacity)$>;
+
+    vec3 albedo = getMaterialAlbedo(mat);
+    <$evalMaterialAlbedo(albedoTex, albedo, matKey, albedo)$>;
+    albedo *= _color;
+
+    float roughness = getMaterialRoughness(mat);
+    <$evalMaterialRoughness(roughnessTex, roughness, matKey, roughness)$>;
+
+    float metallic = getMaterialMetallic(mat);
+    vec3 fresnel = getFresnelF0(metallic, albedo);
+
+    vec3 emissive = getMaterialEmissive(mat);
+    <$evalMaterialEmissive(emissiveTex, emissive, matKey, emissive)$>;
+
+    vec3 fragPosition = _position.xyz;
+    vec3 fragNormal;
+    <$tangentToViewSpaceLOD(_position, normalTex, _normal, _tangent, fragNormal)$>
+
+    TransformCamera cam = getTransformCamera();
+    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+    vec3 fragEyeDir = normalize(fragEyeVector);
+    SurfaceData surface = initSurfaceData(roughness, fragNormal, fragEyeDir);
+
+    vec4 localLighting = vec4(0.0);
+
+    <$fetchClusterInfo(_worldPosition)$>;
+    if (hasLocalLights(numLights, clusterPos, dims)) {
+        localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, surface,
+                                          metallic, fresnel, albedo, 0.0,
+                                          vec4(0), vec4(0), opacity);
+    }
+
+    _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
+        cam._viewInverse,
+        1.0,
+        occlusionTex,
+        fragPosition,
+        albedo,
+        fresnel,
+        metallic,
+        emissive,
+        surface, opacity, localLighting.rgb),
+        opacity);
+}

libraries/render-utils/src/model_translucent_normal_map.slv

@@ -0,0 +1,46 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  model_translucent_normal_map.slv
+//  vertex shader
+//
+//  Created by Olivier Prat on 23/01/18.
+//  Copyright 2018 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()$>
+
+<@include MaterialTextures.slh@>
+<$declareMaterialTexMapArrayBuffer()$>
+
+out float _alpha;
+out vec2 _texCoord0;
+out vec2 _texCoord1;
+out vec4 _position;
+out vec4 _worldPosition;
+out vec3 _normal;
+out vec3 _tangent;
+out vec3 _color;
+
+void main(void) {
+    _color = colorToLinearRGB(inColor.xyz);
+    _alpha = inColor.w;
+
+    TexMapArray texMapArray = getTexMapArray();
+    <$evalTexMapArrayTexcoord0(texMapArray, inTexCoord0, _texCoord0)$>
+    <$evalTexMapArrayTexcoord1(texMapArray, inTexCoord0, _texCoord1)$>
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToEyeAndClipPos(cam, obj, inPosition, _position, gl_Position)$>
+    <$transformModelToWorldPos(obj, inPosition, _worldPosition)$>
+    <$transformModelToWorldDir(cam, obj, inNormal.xyz, _normal)$>
+    <$transformModelToWorldDir(cam, obj, inTangent.xyz, _tangent)$>
+}

libraries/render-utils/src/model_translucent_normal_map_fade.slf

@@ -0,0 +1,101 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  model_translucent_normal_map_fade.frag
+//  fragment shader
+//
+//  Created by Olivier Prat on 23/01/18.
+//  Copyright 2018 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 graphics/Material.slh@>
+
+<@include DeferredGlobalLight.slh@>
+
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
+
+<@include LightLocal.slh@>
+
+<@include gpu/Transform.slh@>
+<$declareStandardCameraTransform()$>
+
+<@include MaterialTextures.slh@>
+<$declareMaterialTextures(ALBEDO, ROUGHNESS, NORMAL, _SCRIBE_NULL, EMISSIVE, OCCLUSION)$>
+
+<@include Fade.slh@>
+<$declareFadeFragment()$>
+
+in vec2 _texCoord0;
+in vec2 _texCoord1;
+in vec4 _position;
+in vec3 _normal;
+in vec3 _tangent;
+in vec3 _color;
+in float _alpha;
+in vec4 _worldPosition;
+
+out vec4 _fragColor;
+
+void main(void) {
+    vec3 fadeEmissive;
+    FadeObjectParams fadeParams;
+
+    <$fetchFadeObjectParams(fadeParams)$>
+    applyFade(fadeParams, _worldPosition.xyz, fadeEmissive);
+
+    Material mat = getMaterial();
+    int matKey = getMaterialKey(mat);
+    <$fetchMaterialTexturesCoord0(matKey, _texCoord0, albedoTex, roughnessTex, normalTex, _SCRIBE_NULL, emissiveTex)$>
+    <$fetchMaterialTexturesCoord1(matKey, _texCoord1, occlusionTex)$>
+
+    float opacity = getMaterialOpacity(mat) * _alpha;
+    <$evalMaterialOpacity(albedoTex.a, opacity, matKey, opacity)$>;
+
+    vec3 albedo = getMaterialAlbedo(mat);
+    <$evalMaterialAlbedo(albedoTex, albedo, matKey, albedo)$>;
+    albedo *= _color;
+
+    float roughness = getMaterialRoughness(mat);
+    <$evalMaterialRoughness(roughnessTex, roughness, matKey, roughness)$>;
+
+    float metallic = getMaterialMetallic(mat);
+    vec3 fresnel = getFresnelF0(metallic, albedo);
+
+    vec3 emissive = getMaterialEmissive(mat);
+    <$evalMaterialEmissive(emissiveTex, emissive, matKey, emissive)$>;
+
+    vec3 fragPosition = _position.xyz;
+    // Lighting is done in world space
+    vec3 fragNormal;
+    <$tangentToViewSpaceLOD(_position, normalTex, _normal, _tangent, fragNormal)$>
+
+    TransformCamera cam = getTransformCamera();
+    vec3 fragEyeVector = vec3(cam._viewInverse * vec4(-fragPosition, 0.0));
+    vec3 fragEyeDir = normalize(fragEyeVector);
+    SurfaceData surface = initSurfaceData(roughness, fragNormal, fragEyeDir);
+
+    vec4 localLighting = vec4(0.0);
+
+    <$fetchClusterInfo(_worldPosition)$>;
+    if (hasLocalLights(numLights, clusterPos, dims)) {
+        localLighting = evalLocalLighting(cluster, numLights, _worldPosition.xyz, surface,
+                                          metallic, fresnel, albedo, 0.0,
+                                          vec4(0), vec4(0), opacity);
+    }
+
+    _fragColor =  vec4(evalGlobalLightingAlphaBlendedWithHaze(
+        cam._viewInverse,
+        1.0,
+        occlusionTex,
+        fragPosition,
+        albedo,
+        fresnel,
+        metallic,
+        emissive+fadeEmissive,
+        surface, opacity, localLighting.rgb),
+        opacity);
+}

libraries/render-utils/src/overlay3D_model_translucent.slf

@@ -11,7 +11,7 @@
 //
 
 <@include DeferredGlobalLight.slh@>
-<$declareEvalGlobalLightingAlphaBlended()$>
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
 
 <@include graphics/Material.slh@>
 

libraries/render-utils/src/simple_transparent_textured.slf

@@ -16,7 +16,7 @@
 
 <@include DeferredBufferWrite.slh@>
 <@include DeferredGlobalLight.slh@>
-<$declareEvalGlobalLightingAlphaBlended()$>
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
 
 <@include gpu/Transform.slh@>
 <$declareStandardCameraTransform()$>

libraries/render-utils/src/simple_transparent_textured_fade.slf

@@ -16,7 +16,7 @@
 
 <@include DeferredBufferWrite.slh@>
 <@include DeferredGlobalLight.slh@>
-<$declareEvalGlobalLightingAlphaBlended()$>
+<$declareEvalGlobalLightingAlphaBlendedWithHaze()$>
 
 <@include gpu/Transform.slh@>
 <$declareStandardCameraTransform()$>