Address PR feedback, ensure all ASV tests pass

Signed-off-by: Jeremy Ong <jcong@amazon.com>
monroegm-disable-blank-issue-2
Jeremy Ong 4 years ago
parent 7aace39c2f
commit 4bcc83e7ac

@ -116,19 +116,19 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace)
float2 baseColorUv = IN.m_uv[MaterialSrg::m_baseColorMapUvIndex];
float3 sampledColor = GetBaseColorInput(MaterialSrg::m_baseColorMap, MaterialSrg::m_sampler, baseColorUv, MaterialSrg::m_baseColor.rgb, o_baseColor_useTexture);
surface.baseColor = BlendBaseColor(sampledColor, MaterialSrg::m_baseColor.rgb, MaterialSrg::m_baseColorFactor, o_baseColorTextureBlendMode, o_baseColor_useTexture);
float3 baseColor = BlendBaseColor(sampledColor, MaterialSrg::m_baseColor.rgb, MaterialSrg::m_baseColorFactor, o_baseColorTextureBlendMode, o_baseColor_useTexture);
// ------- Metallic -------
float2 metallicUv = IN.m_uv[MaterialSrg::m_metallicMapUvIndex];
surface.metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
float metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
// ------- Specular -------
float2 specularUv = IN.m_uv[MaterialSrg::m_specularF0MapUvIndex];
float specularF0Factor = GetSpecularInput(MaterialSrg::m_specularF0Map, MaterialSrg::m_sampler, specularUv, MaterialSrg::m_specularF0Factor, o_specularF0_useTexture);
surface.SetAlbedoAndSpecularF0(specularF0Factor);
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
// ------- Roughness -------

@ -6,6 +6,10 @@
*
*/
#ifdef SHADOWS
#include <Atom/Features/Shadow/Shadow.azsli>
#endif
struct VSInput
{
float3 m_position : POSITION;
@ -113,9 +117,12 @@ PSDepthOutput MainPS(VSDepthOutput IN, bool isFrontFace : SV_IsFrontFace)
SetPixelDepth(IN.m_worldPosition, IN.m_normal, tangents, bitangents, IN.m_uv, isFrontFace, OUT.m_depth);
#endif
#ifdef SHADOW
OUT.m_depth += PdoShadowMapBias;
#endif
}
#ifndef MULTILAYER
#ifndef DEACTIVATE_ALPHA_CLIP
GetAlphaAndClip(IN.m_uv);
#endif

@ -16,4 +16,4 @@
#include "MaterialFunctions/ParallaxDepth.azsli"
#include "MaterialFunctions/StandardGetAlphaAndClip.azsli"
#include "DepthPass_WithPS.azsl"
#include "DepthPass_WithPS.azsli"

@ -43,4 +43,4 @@ COMMON_OPTIONS_DETAIL_MAPS()
#include "MaterialFunctions/StandardTransformDetailUvs.azsli"
#include "MaterialFunctions/StandardTransformUvs.azsli"
#include "EnhancedSurface_ForwardPass.azsl"
#include "EnhancedSurface_ForwardPass.azsli"

@ -23,4 +23,5 @@
#include "MaterialFunctions/ParallaxDepth.azsli"
#include "MaterialFunctions/StandardGetAlphaAndClip.azsli"
#include "ShadowMap_WithPS.azsl"
#define SHADOWS
#include "DepthPass_WithPS.azsli"

@ -146,6 +146,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
}
}
SurfaceSettings surfaceSettings;
Surface surface;
surface.vertexNormal = vertexNormal;
surface.position = IN.m_worldPosition;
@ -154,7 +155,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// TODO: this often invokes a separate sample of the base color texture which is wasteful
float alpha = GetAlphaAndClip(IN.m_uv);
EvaluateEnhancedSurface(IN.m_normal, IN.m_uv, IN.m_detailUv, tangents, bitangents, isFrontFace, displacementIsClipped, surface);
EvaluateEnhancedSurface(IN.m_normal, IN.m_uv, IN.m_detailUv, tangents, bitangents, isFrontFace, displacementIsClipped, surface, surfaceSettings);
// ------- Lighting Data -------
@ -222,7 +223,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// values close to 1.0, that indicates the absence of a surface entirely, so this effect should
// not apply.
float fresnelAlpha = FresnelSchlickWithRoughness(lightingData.NdotV, alpha, surface.roughnessLinear).x;
alpha = lerp(fresnelAlpha, alpha, surface.opacityAffectsSpecularFactor);
alpha = lerp(fresnelAlpha, alpha, surfaceSettings.opacityAffectsSpecularFactor);
}
// Note: lightingOutput rendertargets are not always used as named, particularly m_diffuseColor (target 0) and
@ -241,7 +242,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// Add specular. m_opacityAffectsSpecularFactor controls how much the alpha masks out specular contribution.
float3 specular = lightingOutput.m_specularColor.rgb;
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surface.opacityAffectsSpecularFactor);
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surfaceSettings.opacityAffectsSpecularFactor);
lightingOutput.m_diffuseColor.rgb += specular;
lightingOutput.m_diffuseColor.w = alpha;
@ -264,7 +265,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// Add specular. m_opacityAffectsSpecularFactor controls how much the alpha masks out specular contribution.
float3 specular = lightingOutput.m_specularColor.rgb;
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surface.opacityAffectsSpecularFactor);
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surfaceSettings.opacityAffectsSpecularFactor);
lightingOutput.m_diffuseColor.rgb += specular;
lightingOutput.m_specularColor.rgb = surface.baseColor * (1.0 - alpha);
@ -272,9 +273,9 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
else
{
// Pack factor and quality, drawback: because of precision limit of float16 cannot represent exact 1, maximum representable value is 0.9961
uint factorAndQuality = dot(round(float2(saturate(surface.subsurfaceScatteringFactor), surface.subsurfaceScatteringQuality) * 255), float2(256, 1));
uint factorAndQuality = dot(round(float2(saturate(surface.subsurfaceScatteringFactor), surfaceSettings.subsurfaceScatteringQuality) * 255), float2(256, 1));
lightingOutput.m_diffuseColor.w = factorAndQuality * (o_enableSubsurfaceScattering ? 1.0 : -1.0);
lightingOutput.m_scatterDistance = surface.scatterDistance;
lightingOutput.m_scatterDistance = surfaceSettings.scatterDistance;
}
return lightingOutput;

@ -17,7 +17,8 @@ void EvaluateEnhancedSurface(
float3 bitangents[UvSetCount],
bool isFrontFace,
bool displacementIsClipped,
inout Surface surface)
inout Surface surface,
out SurfaceSettings surfaceSettings)
{
// ------- Detail Layer Setup -------
@ -52,22 +53,22 @@ void EvaluateEnhancedSurface(
float detailLayerBaseColorFactor = MaterialSrg::m_detail_baseColor_factor * detailLayerBlendFactor;
float2 baseColorUv = uvs[MaterialSrg::m_baseColorMapUvIndex];
surface.baseColor = GetDetailedBaseColorInput(
float3 baseColor = GetDetailedBaseColorInput(
MaterialSrg::m_baseColorMap, MaterialSrg::m_sampler, baseColorUv, o_baseColor_useTexture, MaterialSrg::m_baseColor, MaterialSrg::m_baseColorFactor, o_baseColorTextureBlendMode,
MaterialSrg::m_detail_baseColor_texture, MaterialSrg::m_sampler, detailUv, o_detail_baseColor_useTexture, detailLayerBaseColorFactor);
if(o_parallax_highlightClipping && displacementIsClipped)
{
ApplyParallaxClippingHighlight(surface.baseColor);
ApplyParallaxClippingHighlight(baseColor);
}
// ------- Metallic -------
surface.metallic = 0;
float metallic = 0;
if(!o_enableSubsurfaceScattering) // If subsurface scattering is enabled skip texture lookup for metallic, as this quantity won't be used anyway
{
float2 metallicUv = uvs[MaterialSrg::m_metallicMapUvIndex];
surface.metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
}
// ------- Specular -------
@ -75,7 +76,7 @@ void EvaluateEnhancedSurface(
float2 specularUv = uvs[MaterialSrg::m_specularF0MapUvIndex];
float specularF0Factor = GetSpecularInput(MaterialSrg::m_specularF0Map, MaterialSrg::m_sampler, specularUv, MaterialSrg::m_specularF0Factor, o_specularF0_useTexture);
surface.SetAlbedoAndSpecularF0(specularF0Factor);
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
// ------- Roughness -------
@ -88,8 +89,8 @@ void EvaluateEnhancedSurface(
float2 subsurfaceUv = uvs[MaterialSrg::m_subsurfaceScatteringInfluenceMapUvIndex];
surface.subsurfaceScatteringFactor = GetSubsurfaceInput(MaterialSrg::m_subsurfaceScatteringInfluenceMap, MaterialSrg::m_sampler, subsurfaceUv, MaterialSrg::m_subsurfaceScatteringFactor);
surface.subsurfaceScatteringQuality = MaterialSrg::m_subsurfaceScatteringQuality;
surface.scatterDistance = MaterialSrg::m_scatterDistance;
surfaceSettings.subsurfaceScatteringQuality = MaterialSrg::m_subsurfaceScatteringQuality;
surfaceSettings.scatterDistance = MaterialSrg::m_scatterDistance;
// ------- Transmission -------
@ -144,5 +145,5 @@ void EvaluateEnhancedSurface(
surface.specularF0 = lerp(surface.specularF0, f0 * f0, surface.clearCoat.factor);
}
surface.opacityAffectsSpecularFactor = MaterialSrg::m_opacityAffectsSpecularFactor;
surfaceSettings.opacityAffectsSpecularFactor = MaterialSrg::m_opacityAffectsSpecularFactor;
}

@ -16,7 +16,8 @@ void EvaluateStandardSurface(
float3 bitangents[UvSetCount],
bool isFrontFace,
bool displacementIsClipped,
inout Surface surface)
inout Surface surface,
out SurfaceSettings surfaceSettings)
{
// ------- Normal -------
@ -29,24 +30,24 @@ void EvaluateStandardSurface(
float2 baseColorUv = uv[MaterialSrg::m_baseColorMapUvIndex];
float3 sampledColor = GetBaseColorInput(MaterialSrg::m_baseColorMap, MaterialSrg::m_sampler, baseColorUv, MaterialSrg::m_baseColor.rgb, o_baseColor_useTexture);
surface.baseColor = BlendBaseColor(sampledColor, MaterialSrg::m_baseColor.rgb, MaterialSrg::m_baseColorFactor, o_baseColorTextureBlendMode, o_baseColor_useTexture);
float3 baseColor = BlendBaseColor(sampledColor, MaterialSrg::m_baseColor.rgb, MaterialSrg::m_baseColorFactor, o_baseColorTextureBlendMode, o_baseColor_useTexture);
if(o_parallax_highlightClipping && displacementIsClipped)
{
ApplyParallaxClippingHighlight(surface.baseColor);
ApplyParallaxClippingHighlight(baseColor);
}
// ------- Metallic -------
float2 metallicUv = uv[MaterialSrg::m_metallicMapUvIndex];
surface.metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
float metallic = GetMetallicInput(MaterialSrg::m_metallicMap, MaterialSrg::m_sampler, metallicUv, MaterialSrg::m_metallicFactor, o_metallic_useTexture);
// ------- Specular -------
float2 specularUv = uv[MaterialSrg::m_specularF0MapUvIndex];
float specularF0Factor = GetSpecularInput(MaterialSrg::m_specularF0Map, MaterialSrg::m_sampler, specularUv, MaterialSrg::m_specularF0Factor, o_specularF0_useTexture);
surface.SetAlbedoAndSpecularF0(specularF0Factor);
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
// ------- Roughness -------
@ -90,5 +91,5 @@ void EvaluateStandardSurface(
}
// ------- Opacity -------
surface.opacityAffectsSpecularFactor = MaterialSrg::m_opacityAffectsSpecularFactor;
surfaceSettings.opacityAffectsSpecularFactor = MaterialSrg::m_opacityAffectsSpecularFactor;
}

@ -27,7 +27,7 @@ void EvaluateTangentFrame(
}
else
{
SurfaceGradientNormalMapping_Init(normal, worldPosition, !isFrontFace); \
SurfaceGradientNormalMapping_GenerateTB(uv, OUT_tangent, OUT_bitangent); \
SurfaceGradientNormalMapping_Init(normal, worldPosition, !isFrontFace);
SurfaceGradientNormalMapping_GenerateTB(uv, OUT_tangent, OUT_bitangent);
}
}

@ -11,7 +11,7 @@
#include <Atom/Features/MatrixUtility.azsli>
void MultilayerSetPixelDepth(
float blendMask,
float3 blendMask,
float3 worldPosition,
float3 normal,
float3 tangents[UvSetCount],

@ -1,126 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <scenesrg.srgi>
#include <Atom/Features/Shadow/Shadow.azsli>
struct VertexInput
{
float3 m_position : POSITION;
float2 m_uv0 : UV0;
float2 m_uv1 : UV1;
// only used for parallax depth calculation
float3 m_normal : NORMAL;
float4 m_tangent : TANGENT;
float3 m_bitangent : BITANGENT;
#ifdef MULTILAYER
// This gets set automatically by the system at runtime only if it's available.
// There is a soft naming convention that associates this with o_blendMask_isBound, which will be set to true whenever m_optional_blendMask is available.
// (search "m_optional_" in ShaderVariantAssetBuilder for details on the naming convention).
// [GFX TODO][ATOM-14475]: Come up with a more elegant way to associate the isBound flag with the input stream.
float4 m_optional_blendMask : COLOR0;
#endif
};
struct VertexOutput
{
// "centroid" is needed for SV_Depth to compile
linear centroid float4 m_position : SV_Position;
float2 m_uv[UvSetCount] : UV1;
// only used for parallax depth calculation
float3 m_normal : NORMAL;
float3 m_tangent : TANGENT;
float3 m_bitangent : BITANGENT;
float3 m_worldPosition : UV0;
#ifdef MULTILAYER
float3 m_blendMask : UV3;
#endif
};
VertexOutput MainVS(VertexInput IN)
{
const float4x4 objectToWorld = GetObjectToWorld();
VertexOutput OUT;
const float3 worldPosition = mul(objectToWorld, float4(IN.m_position, 1.0)).xyz;
OUT.m_position = mul(ViewSrg::m_viewProjectionMatrix, float4(worldPosition, 1.0));
float2 uv[UvSetCount] = { IN.m_uv0, IN.m_uv1 };
TransformUvs(uv, OUT.m_uv);
if(ShouldHandleParallaxInDepthShaders())
{
OUT.m_worldPosition = worldPosition.xyz;
float3x3 objectToWorldIT = GetNormalToWorld();
ConstructTBN(IN.m_normal, IN.m_tangent, IN.m_bitangent, objectToWorld, objectToWorldIT, OUT.m_normal, OUT.m_tangent, OUT.m_bitangent);
}
#ifdef MULTILAYER
if(o_blendMask_isBound)
{
OUT.m_blendMask = IN.m_optional_blendMask.rgb;
}
else
{
OUT.m_blendMask = float3(0,0,0);
}
#endif
return OUT;
}
struct PSDepthOutput
{
float m_depth : SV_Depth;
};
PSDepthOutput MainPS(VertexOutput IN, bool isFrontFace : SV_IsFrontFace)
{
PSDepthOutput OUT;
OUT.m_depth = IN.m_position.z;
if(ShouldHandleParallaxInDepthShaders())
{
float3 tangents[UvSetCount] = { IN.m_tangent, IN.m_tangent };
float3 bitangents[UvSetCount] = { IN.m_bitangent, IN.m_bitangent };
for (int i = 0; i != UvSetCount; ++i)
{
EvaluateTangentFrame(
IN.m_normal,
IN.m_worldPosition,
isFrontFace,
IN.m_uv[i],
i,
IN.m_tangent,
IN.m_bitangent,
tangents[i],
bitangents[i]);
}
#ifdef MULTILAYER
MultilayerSetPixelDepth(IN.m_blendMask, IN.m_worldPosition, IN.m_normal, tangents, bitangents, IN.m_uv, isFrontFace, OUT.m_depth);
#else
SetPixelDepth(IN.m_worldPosition, IN.m_normal, tangents, bitangents, IN.m_uv, isFrontFace, OUT.m_depth);
#endif
OUT.m_depth += PdoShadowMapBias;
}
#ifndef MULTILAYER
GetAlphaAndClip(IN.m_uv);
#endif
return OUT;
}

@ -28,4 +28,5 @@ COMMON_OPTIONS_PARALLAX(o_layer3_)
#include "MaterialFunctions/MultilayerParallaxDepth.azsli"
#define MULTILAYER
#include "DepthPass_WithPS.azsl"
#define DEACTIVATE_ALPHA_CLIP
#include "DepthPass_WithPS.azsli"

@ -450,16 +450,16 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// ------- Combine Albedo, roughness, specular, roughness ---------
surface.baseColor = BlendLayers(lightingInputLayer1.m_baseColor, lightingInputLayer2.m_baseColor, lightingInputLayer3.m_baseColor, blendWeights);
float3 baseColor = BlendLayers(lightingInputLayer1.m_baseColor, lightingInputLayer2.m_baseColor, lightingInputLayer3.m_baseColor, blendWeights);
float specularF0Factor = BlendLayers(lightingInputLayer1.m_specularF0Factor, lightingInputLayer2.m_specularF0Factor, lightingInputLayer3.m_specularF0Factor, blendWeights);
surface.metallic = BlendLayers(lightingInputLayer1.m_metallic, lightingInputLayer2.m_metallic, lightingInputLayer3.m_metallic, blendWeights);
float metallic = BlendLayers(lightingInputLayer1.m_metallic, lightingInputLayer2.m_metallic, lightingInputLayer3.m_metallic, blendWeights);
if(o_parallax_highlightClipping && displacementIsClipped)
{
ApplyParallaxClippingHighlight(surface.baseColor);
ApplyParallaxClippingHighlight(baseColor);
}
surface.SetAlbedoAndSpecularF0(specularF0Factor);
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
surface.roughnessLinear = BlendLayers(lightingInputLayer1.m_roughness, lightingInputLayer2.m_roughness, lightingInputLayer3.m_roughness, blendWeights);
surface.CalculateRoughnessA();

@ -28,4 +28,5 @@ COMMON_OPTIONS_PARALLAX(o_layer3_)
#include "MaterialFunctions/MultilayerParallaxDepth.azsli"
#define MULTILAYER
#include "ShadowMap_WithPS.azsl"
#define DEACTIVATE_ALPHA_CLIP
#include "DepthPass_WithPS.azsli"

@ -16,4 +16,4 @@
#include "MaterialFunctions/StandardTransformUvs.azsli"
#include "MaterialFunctions/ParallaxDepth.azsli"
#include "DepthPass_WithPS.azsl"
#include "DepthPass_WithPS.azsli"

@ -35,4 +35,4 @@ COMMON_OPTIONS_EMISSIVE()
#include "MaterialFunctions/StandardGetAlphaAndClip.azsli"
#include "MaterialFunctions/StandardTransformUvs.azsli"
#include "StandardSurface_ForwardPass.azsl"
#include "StandardSurface_ForwardPass.azsli"

@ -1,13 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
// NOTE: This file is a temporary workaround until .shader files can #define macros for their .azsl files
#define QUALITY_LOW_END 1
#include "StandardPBR_ForwardPass.azsl"

@ -5,7 +5,9 @@
// DrawListTag. If your pipeline doesn't have a "lowEndForward" DrawListTag, no draw items
// for this shader will be created.
"Source" : "./StandardPBR_LowEndForward.azsl",
"Source" : "./StandardPBR_ForwardPass.azsl",
"Definitions": [ "QUALITY_LOW_END=1" ],
"DepthStencilState" :
{

@ -5,7 +5,9 @@
// DrawListTag. If your pipeline doesn't have a "lowEndForward" DrawListTag, no draw items
// for this shader will be created.
"Source" : "./StandardPBR_LowEndForward.azsl",
"Source" : "./StandardPBR_ForwardPass.azsl",
"Definitions": [ "QUALITY_LOW_END=1" ],
"DepthStencilState" :
{

@ -20,4 +20,5 @@
#include "MaterialFunctions/EvaluateTangentFrame.azsli"
#include "MaterialFunctions/ParallaxDepth.azsli"
#include "ShadowMap_WithPS.azsl"
#define SHADOWS
#include "DepthPass_WithPS.azsli"

@ -143,6 +143,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
}
}
SurfaceSettings surfaceSettings;
Surface surface;
surface.vertexNormal = vertexNormal;
surface.position = IN.m_worldPosition.xyz;
@ -151,7 +152,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// TODO: this often invokes a separate sample of the base color texture which is wasteful
float alpha = GetAlphaAndClip(IN.m_uv);
EvaluateStandardSurface(IN.m_normal, IN.m_uv, tangents, bitangents, isFrontFace, displacementIsClipped, surface);
EvaluateStandardSurface(IN.m_normal, IN.m_uv, tangents, bitangents, isFrontFace, displacementIsClipped, surface, surfaceSettings);
// ------- Lighting Data -------
@ -209,7 +210,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// values close to 1.0, that indicates the absence of a surface entirely, so this effect should
// not apply.
float fresnelAlpha = FresnelSchlickWithRoughness(lightingData.NdotV, alpha, surface.roughnessLinear).x;
alpha = lerp(fresnelAlpha, alpha, surface.opacityAffectsSpecularFactor);
alpha = lerp(fresnelAlpha, alpha, surfaceSettings.opacityAffectsSpecularFactor);
}
if (o_opacity_mode == OpacityMode::Blended)
@ -225,7 +226,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// Add specular. m_opacityAffectsSpecularFactor controls how much the alpha masks out specular contribution.
float3 specular = lightingOutput.m_specularColor.rgb;
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surface.opacityAffectsSpecularFactor);
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surfaceSettings.opacityAffectsSpecularFactor);
lightingOutput.m_diffuseColor.rgb += specular;
lightingOutput.m_diffuseColor.w = alpha;
@ -248,7 +249,7 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
// Add specular. m_opacityAffectsSpecularFactor controls how much the alpha masks out specular contribution.
float3 specular = lightingOutput.m_specularColor.rgb;
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surface.opacityAffectsSpecularFactor);
specular = lerp(specular, specular * lightingOutput.m_diffuseColor.w, surfaceSettings.opacityAffectsSpecularFactor);
lightingOutput.m_diffuseColor.rgb += specular;
lightingOutput.m_specularColor.rgb = surface.baseColor * (1.0 - alpha);

@ -13,6 +13,21 @@
#include <Atom/Features/PBR/Surfaces/ClearCoatSurfaceData.azsli>
#include <Atom/Features/PBR/Surfaces/TransmissionSurfaceData.azsli>
// This data varies across different surfaces, but is uniform within a surface
class SurfaceSettings
{
//! Subsurface scattering parameters
float subsurfaceScatteringQuality;
float3 scatterDistance;
// Increase opacity at grazing angles for surfaces with a low m_opacityAffectsSpecularFactor.
// For m_opacityAffectsSpecularFactor values close to 0, that indicates a transparent surface
// like glass, so it becomes less transparent at grazing angles. For m_opacityAffectsSpecularFactor
// values close to 1.0, that indicates the absence of a surface entirely, so this effect should
// not apply.
float opacityAffectsSpecularFactor;
};
class Surface
{
AnisotropicSurfaceData anisotropy;
@ -29,18 +44,7 @@ class Surface
float roughnessLinear; //!< Perceptually linear roughness value authored by artists. Must be remapped to roughnessA before use
float roughnessA; //!< Actual roughness value ( a.k.a. "alpha roughness") to be used in microfacet calculations
float roughnessA2; //!< Alpha roughness ^ 2 (i.e. roughnessA * roughnessA), used in GGX, cached here for perfromance
//! Subsurface scattering parameters
float subsurfaceScatteringFactor;
float subsurfaceScatteringQuality;
float3 scatterDistance;
// Increase opacity at grazing angles for surfaces with a low m_opacityAffectsSpecularFactor.
// For m_opacityAffectsSpecularFactor values close to 0, that indicates a transparent surface
// like glass, so it becomes less transparent at grazing angles. For m_opacityAffectsSpecularFactor
// values close to 1.0, that indicates the absence of a surface entirely, so this effect should
// not apply.
float opacityAffectsSpecularFactor;
//! Surface lighting inputs
float3 albedo; //!< Albedo color of the non-metallic material, will be multiplied against the diffuse lighting value
@ -56,7 +60,7 @@ class Surface
void CalculateRoughnessA();
//! Sets albedo and specularF0 using metallic workflow
void SetAlbedoAndSpecularF0(float specularF0Factor);
void SetAlbedoAndSpecularF0(float3 baseColor, float specularF0Factor, float metallic);
};
@ -95,12 +99,13 @@ void Surface::CalculateRoughnessA()
}
}
void Surface::SetAlbedoAndSpecularF0(float specularF0Factor)
void Surface::SetAlbedoAndSpecularF0(float3 newBaseColor, float specularF0Factor, float newMetallic)
{
baseColor = newBaseColor;
metallic = newMetallic;
float3 dielectricSpecularF0 = MaxDielectricSpecularF0 * specularF0Factor;
// Compute albedo and specularF0 based on metalness
albedo = lerp(baseColor, float3(0.0f, 0.0f, 0.0f), metallic);
specularF0 = lerp(dielectricSpecularF0, baseColor, metallic);
}

@ -8,11 +8,21 @@
#pragma once
#include <Atom/Features/PBR/Surfaces/AnisotropicSurfaceData.azsli>
#include <Atom/Features/PBR/Surfaces/BasePbrSurfaceData.azsli>
#include <Atom/Features/PBR/Surfaces/ClearCoatSurfaceData.azsli>
#include <Atom/Features/PBR/Surfaces/TransmissionSurfaceData.azsli>
// This data varies across different surfaces, but is uniform within a surface
class SurfaceSettings
{
// Increase opacity at grazing angles for surfaces with a low m_opacityAffectsSpecularFactor.
// For m_opacityAffectsSpecularFactor values close to 0, that indicates a transparent surface
// like glass, so it becomes less transparent at grazing angles. For m_opacityAffectsSpecularFactor
// values close to 1.0, that indicates the absence of a surface entirely, so this effect should
// not apply.
float opacityAffectsSpecularFactor;
};
class Surface
{
@ -51,8 +61,8 @@ class Surface
//! Calculates roughnessA and roughnessA2 after roughness has been set
void CalculateRoughnessA();
//! Sets albedo and specularF0 using metallic workflow
void SetAlbedoAndSpecularF0(float specularF0Factor);
//! Sets albedo, base color, specularF0, and metallic properties using metallic workflow
void SetAlbedoAndSpecularF0(float3 baseColor, float specularF0Factor, float metallic);
};
// Specular Anti-Aliasing technique from this paper:
@ -89,12 +99,14 @@ void Surface::CalculateRoughnessA()
}
}
void Surface::SetAlbedoAndSpecularF0(float specularF0Factor)
void Surface::SetAlbedoAndSpecularF0(float3 newBaseColor, float specularF0Factor, float newMetallic)
{
baseColor = newBaseColor;
metallic = newMetallic;
float3 dielectricSpecularF0 = MaxDielectricSpecularF0 * specularF0Factor;
// Compute albedo and specularF0 based on metalness
albedo = lerp(baseColor, float3(0.0f, 0.0f, 0.0f), metallic);
specularF0 = lerp(dielectricSpecularF0, baseColor, metallic);
}

@ -10,12 +10,24 @@ set(FILES
Materials/Special/ShadowCatcher.azsl
Materials/Special/ShadowCatcher.materialtype
Materials/Special/ShadowCatcher.shader
Materials/Types/MaterialFunctions/EnhancedParallaxDepth.azsli
Materials/Types/MaterialFunctions/EvaluateEnhancedSurface.azsli
Materials/Types/MaterialFunctions/EvaluateStandardSurface.azsli
Materials/Types/MaterialFunctions/EvaluateTangentFrame.azsli
Materials/Types/MaterialFunctions/MultilayerParallaxDepth.azsli
Materials/Types/MaterialFunctions/ParallaxDepth.azsli
Materials/Types/MaterialFunctions/StandardGetAlphaAndClip.azsli
Materials/Types/MaterialFunctions/StandardGetNormalToWorld.azsli
Materials/Types/MaterialFunctions/StandardGetObjectToWorld.azsli
Materials/Types/MaterialFunctions/StandardTransformDetailUvs.azsli
Materials/Types/MaterialFunctions/StandardTransformUvs.azsli
Materials/Types/BasePBR.materialtype
Materials/Types/BasePBR_Common.azsli
Materials/Types/BasePBR_ForwardPass.azsl
Materials/Types/BasePBR_ForwardPass.shader
Materials/Types/BasePBR_LowEndForward.azsl
Materials/Types/BasePBR_LowEndForward.shader
Materials/Types/DepthPass_WithPS.azsli
Materials/Types/EnhancedPBR.materialtype
Materials/Types/EnhancedPBR_Common.azsli
Materials/Types/EnhancedPBR_DepthPass_WithPS.azsl
@ -26,6 +38,7 @@ set(FILES
Materials/Types/EnhancedPBR_Shadowmap_WithPS.azsl
Materials/Types/EnhancedPBR_Shadowmap_WithPS.shader
Materials/Types/EnhancedPBR_SubsurfaceState.lua
Materials/Types/EnhancedSurface_ForwardPass.azsli
Materials/Types/Skin.azsl
Materials/Types/Skin.materialtype
Materials/Types/Skin.shader
@ -56,7 +69,6 @@ set(FILES
Materials/Types/StandardPBR_ForwardPass_EDS.shader
Materials/Types/StandardPBR_HandleOpacityDoubleSided.lua
Materials/Types/StandardPBR_HandleOpacityMode.lua
Materials/Types/StandardPBR_LowEndForward.azsl
Materials/Types/StandardPBR_LowEndForward.shader
Materials/Types/StandardPBR_LowEndForward_EDS.shader
Materials/Types/StandardPBR_Metallic.lua
@ -65,6 +77,7 @@ set(FILES
Materials/Types/StandardPBR_ShaderEnable.lua
Materials/Types/StandardPBR_Shadowmap_WithPS.azsl
Materials/Types/StandardPBR_Shadowmap_WithPS.shader
Materials/Types/StandardSurface_ForwardPass.azsli
Materials/Types/MaterialInputs/AlphaInput.azsli
Materials/Types/MaterialInputs/BaseColorInput.azsli
Materials/Types/MaterialInputs/ClearCoatInput.azsli

@ -145,19 +145,17 @@ ForwardPassOutput AutoBrick_ForwardPassPS(VSOutput IN)
IN.m_uv += tangentOffset.m_offsetTS.xy;
Surface surface;
surface.baseColor = float3(1,1,1);
float3 baseColor = float3(1,1,1);
const float noise = AutoBrickSrg::m_noise.Sample(AutoBrickSrg::m_sampler, IN.m_uv).r;
float distanceFromBrick = GetNormalizedDistanceFromBrick(IN.m_uv);
if(distanceFromBrick > AutoBrickSrg::m_brickColorBleed)
{
surface.baseColor = AutoBrickSrg::m_lineColor * lerp(1.0, noise, AutoBrickSrg::m_lineNoiseFactor);
baseColor = AutoBrickSrg::m_lineColor * lerp(1.0, noise, AutoBrickSrg::m_lineNoiseFactor);
}
else
{
surface.baseColor = AutoBrickSrg::m_brickColor * lerp(1.0, noise, AutoBrickSrg::m_brickNoiseFactor);
baseColor = AutoBrickSrg::m_brickColor * lerp(1.0, noise, AutoBrickSrg::m_brickNoiseFactor);
}
float surfaceDepth;
@ -167,6 +165,8 @@ ForwardPassOutput AutoBrick_ForwardPassPS(VSOutput IN)
// ------- Surface -------
Surface surface;
// Position, Normal, Roughness
surface.position = IN.m_worldPosition.xyz;
surface.normal = normalize(normal);
@ -175,9 +175,9 @@ ForwardPassOutput AutoBrick_ForwardPassPS(VSOutput IN)
surface.CalculateRoughnessA();
// Albedo, SpecularF0
surface.metallic = 0.0f;
float specularF0Factor = 0.5f;
surface.SetAlbedoAndSpecularF0(specularF0Factor);
const float metallic = 0.0f;
const float specularF0Factor = 0.5f;
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
// Clear Coat
surface.clearCoat.InitializeToZero();

@ -68,10 +68,10 @@ ForwardPassOutput MinimalPBR_MainPassPS(VSOutput IN)
surface.CalculateRoughnessA();
// Albedo, SpecularF0
surface.baseColor = MinimalPBRSrg::m_baseColor;
surface.metallic = MinimalPBRSrg::m_metallic;
float3 baseColor = MinimalPBRSrg::m_baseColor;
float metallic = MinimalPBRSrg::m_metallic;
float specularF0Factor = 0.5f;
surface.SetAlbedoAndSpecularF0(specularF0Factor);
surface.SetAlbedoAndSpecularF0(baseColor, specularF0Factor, metallic);
// Clear Coat
surface.clearCoat.InitializeToZero();

Loading…
Cancel
Save