lightmap support direct / indirect and high precision data, optimize shader code and macro names (#13468)

* new version of light map for shaders

* code optimization, rename LIGHT_MAP_TYPE and REFLECTION_PROBE_TYPE, extract standard common lighting functions

# Conflicts:
#	editor/assets/chunks/builtin/uniforms/cc-reflection-probe.chunk
#	editor/assets/chunks/common/texture/cubemap.chunk
#	editor/assets/chunks/legacy/shading-standard-base.chunk
#	editor/assets/chunks/lighting-models/lighting-flow/common-flow.chunk
#	editor/assets/chunks/lighting-models/model-functions/standard.chunk

* fix conflict

* add GetPlanarReflectScreenUV

* fix cr

* fix compilation error

* reflection probe type defines

* fix CC_SURFACES_USE_LIGHT_MAP value

* fix lightmap indirect calculations
This commit is contained in:
jk20012001
2022-11-22 16:00:44 +08:00
committed by GitHub
parent 620c94ae14
commit e120dda07f
19 changed files with 233 additions and 196 deletions
@@ -1,7 +1,4 @@
// Copyright (c) 2017-2020 Xiamen Yaji Software Co., Ltd.
#pragma define REFLECTION_PROBE_NONE 0
#pragma define REFLECTION_PROBE_CUBE 1
#pragma define REFLECTION_PROBE_PLANAR 2
#pragma builtin(local)
layout(set = 2, binding = 14) uniform samplerCube cc_reflectionProbeCubemap;
@@ -43,9 +43,14 @@
#pragma define CC_HANDLE_GET_CLIP_FLIP(uv) uv = cc_cameraPos.w == 0.0 ? vec2(uv.x, -uv.y) : uv
// CC_USE_LIGHTMAP Values
#define CC_LIGHTMAP_DISABLED 0
#define CC_LIGHTMAP_ALL_IN_ONE 1
#define CC_LIGHTMAP_INDIRECT_OCCLUSION 2
#define LIGHT_MAP_TYPE_DISABLED 0
#define LIGHT_MAP_TYPE_ALL_IN_ONE 1
#define LIGHT_MAP_TYPE_INDIRECT_OCCLUSION 2
// CC_USE_REFLECTION_PROBE Values
#define REFLECTION_PROBE_TYPE_NONE 0
#define REFLECTION_PROBE_TYPE_CUBE 1
#define REFLECTION_PROBE_TYPE_PLANAR 2
// Light Type
#define LIGHT_TYPE_DIRECTIONAL 0.0
@@ -1,14 +1,35 @@
vec4 GetLightMapColor(sampler2D lightingMap, vec2 luv, float lum)
// for legacy effects
void SampleAndDecodeLightMapColor(out vec3 lightmapColor, out float dirShadow, out float ao, sampler2D lightingMap, vec2 luv, float lum, vec3 worldNormal)
{
// has radiant basis
#if CC_LIGHT_MAP_VERSION > 2
// has high precision data
#elif CC_LIGHT_MAP_VERSION > 1
luv.x *= 0.5;
vec4 dataLow = texture(lightingMap, luv);
vec4 dataHigh = texture(lightingMap, luv + vec2(0.5, 0.0));
lightmapColor.xyz = dataLow + dataHigh * 0.00392156862745098;
lightmapColor.rgb *= lum;
dirShadow = dataLow.a;
ao = dataHigh.a;
#else
vec4 lightmap = texture(lightingMap, luv);
lightmap.rgb *= lum;
lightmapColor = lightmap.rgb * lum;
dirShadow = lightmap.a;
ao = 1.0;
#endif
}
// for surface shader
void GetLightMapColor(out vec3 lightmapColor, out float dirShadow, out float ao, sampler2D lightingMap, vec2 luv, float lum, vec3 worldNormal)
{
vec4 lightmap;
vec2 occlusion;
SampleAndDecodeLightMapColor(lightmapColor, dirShadow, ao, lightingMap, luv, lum, worldNormal);
#if CC_USE_HDR
// convert from standard camera exposure parameters to current exposure value
// baked in LDR scene still regarded as exposured with standard camera parameters
lightmap.rgb *= cc_exposure.w * cc_exposure.x;
lightmapColor.rgb *= cc_exposure.w * cc_exposure.x;
#endif
return lightmap;
}
@@ -12,6 +12,15 @@ vec2 GetScreenUV(vec3 worldPos, mat4 matViewProj, float flipNDCSign)
return screenUV;
}
vec2 GetPlanarReflectScreenUV(vec3 worldPos, mat4 matVirtualCameraViewProj, float flipNDCSign, vec3 viewDir, vec3 reflectDir)
{
vec4 clipPos = matVirtualCameraViewProj * vec4(worldPos, 1.0);
vec2 screenUV = clipPos.xy / clipPos.w * 0.5 + 0.5;
screenUV = vec2(1.0 - screenUV.x, screenUV.y);
CC_HANDLE_NDC_SAMPLE_FLIP(screenUV, flipNDCSign);
return screenUV;
}
// depthHS = ndc depth(-1 ~ +1)
float GetCameraDepthRH(float depthHS, mat4 matProj)
{
@@ -39,7 +39,7 @@
vec3 rotationDir = RotationVecFromAxisY(R.xyz, cc_surfaceTransform.z, cc_surfaceTransform.w);
vec4 envmap = fragTextureLod(tex, rotationDir, roughness * (mipCount - 1.0));
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_NONE
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_TYPE_NONE
return unpackRGBE(envmap);
#else
return SRGBToLinear(envmap.rgb);
@@ -1,2 +1,3 @@
in vec3 v_luv;
#include <builtin/uniforms/cc-light-map>
#include <builtin/uniforms/cc-light-map>
#include <common/lighting/light-map>
@@ -55,10 +55,10 @@ vec3 BRDFApprox (vec3 specular, float roughness, float NoV) {
float mipBias = mix(0.0, 5.0, clamp(delta, 0.0, 1.0));
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_CUBE
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
vec4 biased = fragTextureLod(cc_reflectionProbeCubemap, R, mip + mipBias);
vec4 filtered = texture(cc_reflectionProbeCubemap, R);
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_PLANAR
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_PLANAR
vec4 biased = fragTextureLod(cc_reflectionProbePlanarMap, screenUV, mip + mipBias);
vec4 filtered = texture(cc_reflectionProbePlanarMap, screenUV);
#else
@@ -66,8 +66,8 @@ vec3 BRDFApprox (vec3 specular, float roughness, float NoV) {
vec4 filtered = texture(cc_environment, R);
#endif
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_NONE
biased.rgb = unpackRGBE(biased);
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_TYPE_NONE
biased.rgb = unpackRGBE(biased);
filtered.rgb = unpackRGBE(filtered);
#else
biased.rgb = SRGBToLinear(biased.rgb);
@@ -119,7 +119,7 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
float NL = max(dot(N, L), 0.0);
float shadow = 1.0;
#if !CC_USE_LIGHTMAP && CC_RECEIVE_SHADOW && CC_SHADOW_TYPE == CC_SHADOW_MAP
#if CC_USE_LIGHTMAP != LIGHT_MAP_TYPE_ALL_IN_ONE && CC_RECEIVE_SHADOW && CC_SHADOW_TYPE == CC_SHADOW_MAP
if (NL > 0.0 && cc_mainLitDir.w > 0.0) {
if (cc_shadowLPNNInfo.w > 0.0) {
#if CC_DIR_LIGHT_SHADOW_TYPE == CC_DIR_LIGHT_SHADOW_CASCADED
@@ -141,15 +141,16 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
// baked in LDR scene still regarded as exposured with standard camera parameters
lightmap.rgb *= cc_exposure.w * cc_exposure.x;
#endif
#if CC_USE_LIGHT_MAP == CC_LIGHTMAP_INDIRECT_OCCLUSION
#if CC_USE_LIGHTMAP == LIGHT_MAP_TYPE_INDIRECT_OCCLUSION
shadow *= s.lightmap.a; // apply baked shadows for real-time lighting
s.occlusion *= s.lightmap_test;
finalColor += diffuse * lightmap.rgb;
#else
finalColor += diffuse * lightmap.rgb * shadow; // apply real-time shadows for baked color
#endif
#endif
#if CC_USE_LIGHTMAP != CC_LIGHTMAP_ALL_IN_ONE
#if CC_USE_LIGHTMAP != LIGHT_MAP_TYPE_ALL_IN_ONE
float NV = max(abs(dot(N, V)), 0.0);
specular = BRDFApprox(specular, s.roughness, NV);
@@ -189,7 +190,7 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
#else
vec4 envmap = fragTextureLod(cc_environment, rotationDir, s.roughness * (cc_ambientGround.w - 1.0));
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_NONE
#if CC_USE_IBL == IBL_RGBE || CC_USE_REFLECTION_PROBE != REFLECTION_PROBE_TYPE_NONE
env = unpackRGBE(envmap);
#else
env = SRGBToLinear(envmap.rgb);
@@ -199,11 +200,12 @@ vec4 CCStandardShadingBase (StandardSurface s, vec4 shadowPos) {
#endif
#if CC_USE_REFLECTION_PROBE
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_CUBE
vec4 probe = fragTextureLod(cc_reflectionProbeCubemap, R, s.roughness * (cc_ambientGround.w - 1.0));
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_PLANAR
vec2 screenUV = GetScreenUV(s.position, cc_matViewProj, cc_cameraPos.w);
vec4 probe = texture(cc_reflectionProbePlanarMap, screenUV);
vec4 probe = vec4(0.0);
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
probe = fragTextureLod(cc_reflectionProbeCubemap, R, s.roughness * (cc_ambientGround.w - 1.0));
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_PLANAR
vec2 screenUV = GetPlanarReflectScreenUV(s.position, cc_matViewProj, cc_cameraPos.w, V, R);
probe = texture(cc_reflectionProbePlanarMap, screenUV);
#endif
env = unpackRGBE(probe);
#endif
@@ -77,7 +77,7 @@
// CCSurfacesLightingCalculateShadow:
lightingResult.shadow = 1.0;
#if !CC_SURFACES_USE_LIGHT_MAP && CC_RECEIVE_SHADOW && CC_SHADOW_TYPE == CC_SHADOW_MAP
#if CC_SURFACES_USE_LIGHT_MAP != LIGHT_MAP_TYPE_ALL_IN_ONE && CC_RECEIVE_SHADOW && CC_SHADOW_TYPE == CC_SHADOW_MAP
if (cc_mainLitDir.w > 0.0) {
vec4 shadowPos = vec4(0.0), shadowNDCPosWithBias = vec4(0.0);
if (CCSurfacesLightingEnableShadow(lightingData.NoL)) {
@@ -103,17 +103,18 @@
// CCSurfacesLightingCalculateBaked:
lightingResult.lightmapColor = vec3(0.0);
#if CC_SURFACES_USE_LIGHT_MAP && !CC_FORWARD_ADD
vec4 lightmap = GetLightMapColor(cc_lightingMap, FSInput_lightMapUV.xy, FSInput_lightMapUV.z);
lightingResult.lightmapColor = lightmap.rgb;
#if CC_SURFACES_USE_LIGHT_MAP == CC_LIGHTMAP_INDIRECT_OCCLUSION
lightingResult.shadow *= lightmap.a;
float lightmapShadow, lightmapAO;
GetLightMapColor(lightingResult.lightmapColor, lightmapShadow, lightmapAO, cc_lightingMap, FSInput_lightMapUV.xy, FSInput_lightMapUV.z, surfaceData.worldNormal);
#if CC_SURFACES_USE_LIGHT_MAP == LIGHT_MAP_TYPE_INDIRECT_OCCLUSION
lightingResult.shadow *= lightmapShadow;
lightingResult.ao *= lightmapAO;
#endif
#endif
// dynamic & stationary dir light
lightingResult.directDiffuse = lightingResult.directSpecular = vec3(0.0);
#if CC_SURFACES_USE_LIGHT_MAP != CC_LIGHTMAP_ALL_IN_ONE && !CC_FORWARD_ADD
#if CC_SURFACES_USE_LIGHT_MAP != LIGHT_MAP_TYPE_ALL_IN_ONE && !CC_FORWARD_ADD
CCSurfacesLightingCalculateColorWithLighting(lightingResult.diffuseColorWithLighting, lightingResult.specularColorWithLighting, surfaceData, lightingData);
CCSurfacesLightingCalculateDirect(lightingResult.directDiffuse, lightingResult.directSpecular, lightingData, cc_mainLitColor);
@@ -0,0 +1,131 @@
#include <common/lighting/brdf>
#include <common/lighting/functions>
void LightingCalculateDirect(out vec3 lightingDiffuse, out vec3 lightingSpecular, in LightingIntermediateData lightingData, in vec4 lightSourceColorAndIntensity)
{
vec3 irradiance = vec3(lightingData.NoLSat) * lightSourceColorAndIntensity.rgb * lightSourceColorAndIntensity.w;
lightingDiffuse = irradiance * DiffuseCoefficient_EnergyConservation;
float roughness = lightingData.specularParam;
#if CC_SURFACES_LIGHTING_ANISOTROPIC
float rT, rB;
GetAnisotropicRoughness(roughness, lightingData.anisotropyShape, rT, rB);
float calcSpec = D_GGXAniso(rT, rB, lightingData.NoHSat, lightingData.H, lightingData.T, lightingData.B);
#else
#if CC_SURFACES_USE_LEGACY_COMPATIBLE_LIGHTING
float calcSpec = (roughness * 0.25 + 0.25) * D_GGXMobile(roughness, lightingData.NoHSat);
#else
float calcSpec = D_GGX(roughness, lightingData.NoHSat);
#endif
#endif
lightingSpecular = irradiance * calcSpec;
}
#if CC_SURFACES_LIGHTING_ANISOTROPIC && CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
vec3 EnvAnisotropicReflection(samplerCube tex, vec3 R, float roughness, float mipCount, float anisotropyShape, vec3 V, vec3 N, vec3 T, vec3 B) {
R = normalize(R);
float integratedBRDF = 0.0;
vec3 envSpec = vec3(0.0);
// One direction sample count
const int SAMPLE_STEP_COUNT = CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT;
float sampleAngleRange = PI * abs(anisotropyShape);
vec3 anisoDirection = anisotropyShape < 0.0 ? T : B;
vec3 ROnNormalPlane = normalize(R - anisoDirection * dot(R, anisoDirection));
//ROnTangentPlane = R; //for example: cross-style
vec3 stepOffset = normalize(ROnNormalPlane - N) * (sampleAngleRange / float(SAMPLE_STEP_COUNT * 2));
for (int i = -SAMPLE_STEP_COUNT; i <= SAMPLE_STEP_COUNT; ++i)
{
float rT, rB;
GetAnisotropicRoughness(roughness, anisotropyShape, rT, rB);
#if CC_IBL_CONVOLUTED
float coef = abs(float(i)) / float(SAMPLE_STEP_COUNT) * float(SAMPLE_STEP_COUNT);
#else
float coef = pow(abs(float(i)) / float(SAMPLE_STEP_COUNT), 1.3) * float(SAMPLE_STEP_COUNT);
#endif
vec3 H = normalize(N + stepOffset * sign(float(i)) * coef);
vec3 L = reflect(-V, H);
float NoHSat = saturate(dot(N, H));
float calcSpec = D_GGXAniso(rT, rB, NoHSat, H, T, B);
envSpec += calcSpec * EnvReflection(tex, L, roughness, mipCount);
integratedBRDF += calcSpec;
}
envSpec /= integratedBRDF;
return envSpec;
}
#endif
vec3 SampleEnvironmentSpecular(samplerCube tex, in LightingIntermediateData lightingData, float mipCount)
{
vec3 envSpec = vec3(0.0);
float roughness = lightingData.specularParam;
#if CC_SURFACES_LIGHTING_ANISOTROPIC && !CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
vec3 R = GetAnisotropicReflect(roughness, lightingData.anisotropyShape, lightingData.V, lightingData.N, lightingData.T, lightingData.B);
#else
vec3 R = reflect(-lightingData.V, lightingData.N);
#endif
#if CC_SURFACES_LIGHTING_ANISOTROPIC && CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
envSpec = EnvAnisotropicReflection(tex, R, roughness, mipCount, lightingData.anisotropyShape, lightingData.V, lightingData.N, lightingData.T, lightingData.B);
#else
#if CC_SURFACES_USE_REFLECTION_DENOISE && !CC_IBL_CONVOLUTED
envSpec = EnvReflectionWithMipFiltering(normalize(R), roughness, mipCount, 0.6);
#else
envSpec = EnvReflection(tex, R, roughness, mipCount);
#endif
#endif
return envSpec;
}
vec3 CalculateEnvironmentDiffuse(in LightingIntermediateData lightingData, float lightIntensity)
{
// Hemisphere Lighting
float fAmb = 0.5 - lightingData.N.y * 0.5;
vec3 ambDiff = mix(cc_ambientSky.rgb, cc_ambientGround.rgb, fAmb);
// Diffuse Map
#if CC_USE_IBL
#if CC_USE_DIFFUSEMAP && !CC_USE_LIGHT_PROBE
// Diffuse irradiance
vec4 diffuseMap = texture(cc_diffuseMap, lightingData.N);
#if CC_USE_DIFFUSEMAP == IBL_RGBE
ambDiff = unpackRGBE(diffuseMap);
#else
ambDiff = SRGBToLinear(diffuseMap.rgb);
#endif
#endif
#endif
ambDiff.rgb *= lightIntensity;
// Probe
#if CC_USE_LIGHT_PROBE
ambDiff.rgb += SHEvaluate(lightingData.N);
#endif
return ambDiff.rgb;
}
vec3 CalculateEnvironmentSpecular(in LightingIntermediateData lightingData, float lightIntensity)
{
vec3 envSpec = vec3(0.0);
#if CC_USE_IBL
envSpec = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w);
#endif
#if CC_USE_REFLECTION_PROBE
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_CUBE
envSpec = SampleEnvironmentSpecular(cc_reflectionProbeCubemap, lightingData, cc_ambientGround.w);
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_TYPE_PLANAR
vec3 R = normalize(reflect(-lightingData.V, lightingData.N));
vec2 screenUV = GetPlanarReflectScreenUV(lightingData.worldPosition, cc_matViewProj, cc_cameraPos.w, lightintData.V, R);
envSpec = fragTextureLod(cc_reflectionProbePlanarMap, screenUV, cc_ambientGround.w).xyz;
#endif
#endif
return envSpec * lightIntensity;
}
@@ -0,0 +1,9 @@
{
"ver": "1.0.7",
"importer": "effect-header",
"imported": true,
"uuid": "5e057755-d68b-41d1-b089-ed7f7f65f2b8",
"files": [],
"subMetas": {},
"userData": {}
}
@@ -1,5 +1,6 @@
#include <common/lighting/brdf>
#include <common/lighting/functions>
#include <lighting-models/model-functions/standard-common>
bool CCSurfacesLightingEnableShadow(in float NoL)
{
@@ -18,132 +19,10 @@ float CCSurfacesLightingCalculateAngleAttenuation(in LightingIntermediateData li
void CCSurfacesLightingCalculateDirect(out vec3 lightingDiffuse, out vec3 lightingSpecular, in LightingIntermediateData lightingData, in vec4 lightSourceColorAndIntensity)
{
vec3 irradiance = vec3(lightingData.NoLSat) * lightSourceColorAndIntensity.rgb * lightSourceColorAndIntensity.w;
lightingDiffuse = irradiance * DiffuseCoefficient_EnergyConservation;
float roughness = lightingData.specularParam;
#if CC_SURFACES_LIGHTING_ANISOTROPIC
float rT, rB;
GetAnisotropicRoughness(roughness, lightingData.anisotropyShape, rT, rB);
float calcSpec = D_GGXAniso(rT, rB, lightingData.NoHSat, lightingData.H, lightingData.T, lightingData.B);
#else
#if CC_SURFACES_USE_LEGACY_COMPATIBLE_LIGHTING
float calcSpec = (roughness * 0.25 + 0.25) * D_GGXMobile(roughness, lightingData.NoHSat);
#else
float calcSpec = D_GGX(roughness, lightingData.NoHSat);
#endif
#endif
lightingSpecular = irradiance * calcSpec;
LightingCalculateDirect(lightingDiffuse, lightingSpecular, lightingData, lightSourceColorAndIntensity);
}
#if CC_SURFACES_LIGHTING_ANISOTROPIC && CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
vec3 EnvAnisotropicReflection(samplerCube tex, vec3 R, float roughness, float mipCount, float anisotropyShape, vec3 V, vec3 N, vec3 T, vec3 B) {
R = normalize(R);
float integratedBRDF = 0.0;
vec3 envSpec = vec3(0.0);
// One direction sample count
const int SAMPLE_STEP_COUNT = CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT;
float sampleAngleRange = PI * abs(anisotropyShape);
vec3 anisoDirection = anisotropyShape < 0.0 ? T : B;
vec3 ROnNormalPlane = normalize(R - anisoDirection * dot(R, anisoDirection));
//ROnTangentPlane = R; //for example: cross-style
vec3 stepOffset = normalize(ROnNormalPlane - N) * (sampleAngleRange / float(SAMPLE_STEP_COUNT * 2));
for (int i = -SAMPLE_STEP_COUNT; i <= SAMPLE_STEP_COUNT; ++i)
{
float rT, rB;
GetAnisotropicRoughness(roughness, anisotropyShape, rT, rB);
#if CC_IBL_CONVOLUTED
float coef = abs(float(i)) / float(SAMPLE_STEP_COUNT) * float(SAMPLE_STEP_COUNT);
#else
float coef = pow(abs(float(i)) / float(SAMPLE_STEP_COUNT), 1.3) * float(SAMPLE_STEP_COUNT);
#endif
vec3 H = normalize(N + stepOffset * sign(float(i)) * coef);
vec3 L = reflect(-V, H);
float NoHSat = saturate(dot(N, H));
float calcSpec = D_GGXAniso(rT, rB, NoHSat, H, T, B);
envSpec += calcSpec * EnvReflection(tex, L, roughness, mipCount);
integratedBRDF += calcSpec;
}
envSpec /= integratedBRDF;
return envSpec;
}
#endif
vec3 SampleEnvironmentSpecular(samplerCube tex, in LightingIntermediateData lightingData, float mipCount)
{
vec3 envSpec = vec3(0.0);
float roughness = lightingData.specularParam;
#if CC_SURFACES_LIGHTING_ANISOTROPIC && !CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
vec3 R = GetAnisotropicReflect(roughness, lightingData.anisotropyShape, lightingData.V, lightingData.N, lightingData.T, lightingData.B);
#else
vec3 R = reflect(-lightingData.V, lightingData.N);
#endif
#if CC_SURFACES_LIGHTING_ANISOTROPIC && CC_SURFACES_LIGHTING_ANISOTROPIC_ENVCONVOLUTION_COUNT
envSpec = EnvAnisotropicReflection(tex, R, roughness, mipCount, lightingData.anisotropyShape, lightingData.V, lightingData.N, lightingData.T, lightingData.B);
#else
#if CC_SURFACES_USE_REFLECTION_DENOISE && !CC_IBL_CONVOLUTED
envSpec = EnvReflectionWithMipFiltering(normalize(R), roughness, mipCount, 0.6);
#else
envSpec = EnvReflection(tex, R, roughness, mipCount);
#endif
#endif
return envSpec;
}
vec3 CalculateEnvironmentDiffuse(in LightingIntermediateData lightingData, float lightIntensity)
{
// Hemisphere Lighting
float fAmb = 0.5 - lightingData.N.y * 0.5;
vec3 ambDiff = mix(cc_ambientSky.rgb, cc_ambientGround.rgb, fAmb);
// Diffuse Map
#if CC_USE_IBL
#if CC_USE_DIFFUSEMAP && !CC_USE_LIGHT_PROBE
// Diffuse irradiance
vec4 diffuseMap = texture(cc_diffuseMap, lightingData.N);
#if CC_USE_DIFFUSEMAP == IBL_RGBE
ambDiff = unpackRGBE(diffuseMap);
#else
ambDiff = SRGBToLinear(diffuseMap.rgb);
#endif
#endif
#endif
ambDiff.rgb *= lightIntensity;
// Probe
#if CC_USE_LIGHT_PROBE
ambDiff.rgb += SHEvaluate(lightingData.N);
#endif
return ambDiff.rgb;
}
vec3 CalculateEnvironmentSpecular(in LightingIntermediateData lightingData, float lightIntensity)
{
vec3 envSpec = vec3(0.0);
#if CC_USE_IBL
envSpec = SampleEnvironmentSpecular(cc_environment, lightingData, cc_ambientGround.w);
#endif
#if CC_USE_REFLECTION_PROBE
#if CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_CUBE
envSpec = SampleEnvironmentSpecular(cc_reflectionProbeCubemap, lightingData, cc_ambientGround.w);
#elif CC_USE_REFLECTION_PROBE == REFLECTION_PROBE_PLANAR
vec2 screenUV = GetScreenUV(lightingData.worldPosition, cc_matViewProj, cc_cameraPos.w);
envSpec = fragTextureLod(cc_reflectionProbePlanarMap, screenUV, cc_ambientGround.w).xyz;
#endif
#endif
return envSpec * lightIntensity;
}
void CCSurfacesLightingCalculateEnvironment(out vec3 lightingDiffuse, out vec3 lightingSpecular, in LightingIntermediateData lightingData, float lightIntensity)
{
lightingDiffuse = CalculateEnvironmentDiffuse(lightingData, lightIntensity);
@@ -22,13 +22,11 @@
#define CC_SURFACES_TRANSFER_LOCAL_POS 0
#endif
// Can force CC_SURFACES_USE_LIGHT_MAP to 0, can not force to 1
#if CC_USE_LIGHTMAP
#ifndef CC_SURFACES_USE_LIGHT_MAP
#define CC_SURFACES_USE_LIGHT_MAP 1
#endif
#else
#ifndef CC_SURFACES_USE_LIGHT_MAP
// force CC_SURFACES_USE_LIGHT_MAP to 0 is valid, force to 1 is invalid
#ifndef CC_SURFACES_USE_LIGHT_MAP
#ifdef CC_USE_LIGHTMAP
#define CC_SURFACES_USE_LIGHT_MAP CC_USE_LIGHTMAP
#else
#define CC_SURFACES_USE_LIGHT_MAP 0
#endif
#endif
@@ -6,8 +6,6 @@
#define CC_SURFACES_USE_SECOND_UV 0
#define CC_SURFACES_USE_TWO_SIDED 0
#define CC_SURFACES_USE_LIGHT_MAP CC_USE_LIGHTMAP
// vs-fs varing addon data
#define CC_SURFACES_TRANSFER_LOCAL_POS 1
@@ -151,9 +151,9 @@ vec4 CCSurfacesShading(in SurfacesMaterialData surfaceData, in LightingResult li
)
* lightingResult.shadow;
#if CC_SURFACES_USE_LIGHT_MAP == CC_LIGHTMAP_ALL_IN_ONE
#if CC_SURFACES_USE_LIGHT_MAP == LIGHT_MAP_TYPE_ALL_IN_ONE
color.xyz += lightingResult.lightmapColor * lightingResult.diffuseColorWithLighting * lightingResult.shadow; //apply real-time shadows
#elif CC_SURFACES_USE_LIGHT_MAP == CC_LIGHTMAP_INDIRECT_OCCLUSION
#elif CC_SURFACES_USE_LIGHT_MAP == LIGHT_MAP_TYPE_INDIRECT_OCCLUSION
color.xyz += lightingResult.lightmapColor * lightingResult.diffuseColorWithLighting;
#endif
@@ -186,12 +186,6 @@ CCProgram standard-fs %{
if (s.albedo.ALPHA_TEST_CHANNEL < albedoScaleAndCutoff.w) discard;
#endif
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
vec4 lightColor = texture(cc_lightingMap, v_luv);
s.lightmap.rgb = lightColor.xyz;
s.lightmap.a = lightColor.a;
#endif
s.normal = v_normal;
#if USE_NORMAL_MAP
vec3 nmmp = texture(normalMap, NORMAL_UV).xyz - vec3(0.5);
@@ -201,6 +195,10 @@ CCProgram standard-fs %{
nmmp.z * normalize(s.normal);
#endif
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
SampleAndDecodeLightMapColor(s.lightmap.rgb, s.lightmap.a, s.lightmap_test, cc_lightingMap, v_luv.xy, v_luv.z, s.normal);
#endif
HIGHP_VALUE_TO_STRUCT_DEFINED(v_position, s.position);
vec4 pbr = pbrParams;
@@ -252,13 +252,6 @@ CCProgram standard-fs %{
if (s.albedo.ALPHA_TEST_CHANNEL < albedoScaleAndCutoff.w) discard;
#endif
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
vec4 lightColor = texture(cc_lightingMap, v_luv.xy);
s.lightmap.a = lightColor.a;
s.lightmap.rgb = lightColor.xyz * v_luv.z;
s.lightmap_test = v_luv.z; /*lum*/
#endif
s.normal = v_normal;
#if CC_RECEIVE_SHADOW
@@ -274,6 +267,10 @@ CCProgram standard-fs %{
nmmp.z * normalize(s.normal);
#endif
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
SampleAndDecodeLightMapColor(s.lightmap.rgb, s.lightmap.a, s.lightmap_test, cc_lightingMap, v_luv.xy, v_luv.z, s.normal);
#endif
HIGHP_VALUE_TO_STRUCT_DEFINED(v_position, s.position);
vec4 pbr = pbrParams;
+1 -4
View File
@@ -262,10 +262,7 @@ CCProgram terrain-fs %{
s.emissive = vec3(0.0, 0.0, 0.0);
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
vec4 lightColor = texture(cc_lightingMap, luv.xy);
s.lightmap.a = lightColor.a;
s.lightmap.rgb = lightColor.xyz * luv.z;
s.lightmap_test = luv.z; /*lum*/
SampleAndDecodeLightMapColor(s.lightmap.rgb, s.lightmap.a, s.lightmap_test, cc_lightingMap, v_luv.xy, v_luv.z, s.normal);
#endif
}
@@ -340,13 +340,6 @@ CCProgram standard-fs %{
/////////////////////////////
s.albedo = baseColor;
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
vec4 lightColor = texture(cc_lightingMap, v_luv.xy);
s.lightmap.a = lightColor.a;
s.lightmap.rgb = lightColor.xyz * v_luv.z;
s.lightmap_test = v_luv.z; /*lum*/
#endif
s.normal = v_normal;
#if CC_RECEIVE_SHADOW
@@ -361,6 +354,10 @@ CCProgram standard-fs %{
nmmp.z * normalize(s.normal);
#endif
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
SampleAndDecodeLightMapColor(s.lightmap.rgb, s.lightmap.a, s.lightmap_test, cc_lightingMap, v_luv.xy, v_luv.z, s.normal);
#endif
HIGHP_VALUE_TO_STRUCT_DEFINED(v_position, s.position);
s.specularIntensity = 0.5;
@@ -401,10 +401,7 @@ CCProgram standard-fs %{
s.emissive = emissiveColor.rgb;
#if CC_USE_LIGHTMAP && !CC_FORWARD_ADD
vec4 lightColor = texture(cc_lightingMap, v_luv.xy);
s.lightmap.a = lightColor.a;
s.lightmap.rgb = lightColor.xyz * v_luv.z;
s.lightmap_test = v_luv.z; /*lum*/
SampleAndDecodeLightMapColor(s.lightmap.rgb, s.lightmap.a, s.lightmap_test, cc_lightingMap, v_luv.xy, v_luv.z, s.normal);
#endif
}