#version 450
#extension GL_GOOGLE_cpp_style_line_directive : enable
#extension GL_GOOGLE_include_directive : enable
#include "include/light.glsl"

const float M_PI = 3.141592653589793;
const float c_MinRoughness = 0.04;

#define ONLY_SH false

layout (constant_id = 0) const int SHADOW_MAP_CASCADE_COUNT = 4;
layout (constant_id = 1) const int enablePCF = 1;

layout (set = 0, binding = 0) uniform UniformBufferObject 
{
	mat4 proj;
    mat4 view;
	vec3 camPos;
	float pad;
} ubo;

layout(set = 0, binding = 1) uniform UniformBufferMaterial
{
	vec4 baseColorFactor; 				// 基础颜色系数
	vec4 emissiveFactor;				// 自发光系数
	// -1.无贴图 0.使用UV0 1.使用UV1
	int baseColorTextureSet;			
	int physicalDescriptorTextureSet;
	int normalTextureSet;	
	int occlusionTextureSet;
	int emissiveTextureSet;

	float metallicFactor;	// 金属度
	float roughnessFactor;	// 粗糙度
	float alphaMask;		// 透明度裁剪
	float alphaMaskCutoff;	// 丢弃阈值
	float emissiveStrength; // 自发光强度
	vec2 pad;
} material;

layout(set = 0, binding = 2) uniform UniformBufferPass
{
	float exposure;					// 曝光度
	float gamma;					// gamma校正
	float prefilteredCubeMipLevels; // 预过滤的立方体贴图级数
	float scaleIBLAmbient;			// ibl环境光系数
    vec4 sh[9];						// 球谐漫反射
	vec4 cascadeSplits;				// 级联分割
	float debugViewInputs;
    Light light[NUM_LIGHT];
} pass;

layout (set = 0, binding = 3) uniform UniformBufferCascade
{
	mat4 viewProj[SHADOW_MAP_CASCADE_COUNT];
} cascade;

// 依赖pass
#include "include/tonemap.glsl"

// 预过滤镜面环境贴图（ibl）
layout (set = 0, binding = 4) uniform samplerCube prefilteredMap;
// BRDF 积分查找表
layout (set = 0, binding = 5) uniform sampler2D samplerBRDFLUT;
// 阴影贴图
layout (set = 0, binding = 6) uniform sampler2DArray shadowMap;

layout(set = 1, binding = 0) uniform sampler2D diffuseMap;  // 漫反射
layout(set = 1, binding = 1) uniform sampler2D physicalMap; // 物理
layout(set = 1, binding = 2) uniform sampler2D normalMap;   // 法线
layout(set = 1, binding = 3) uniform sampler2D aoMap;       // 环境光遮蔽
layout(set = 1, binding = 4) uniform sampler2D emissiveMap; // 自发光

layout (location = 0) in vec3 inPosition;
layout (location = 1) in vec3 inNormal;
layout (location = 2) in vec2 inUV0;
layout (location = 3) in vec2 inUV1;
layout (location = 4) in vec4 inColor;
layout (location = 5) in vec3 inViewPos;

layout(location = 0) out vec4 outColor;

// 计算中间值
struct PbrInfo
{
	float NdotL;                  // 法线 · 光照方向 夹角余弦
	float NdotV;                  // 法线 · 视角方向 夹角余弦
	float NdotH;                  // 法线 · 半角向量 夹角余弦
	float LdotH;                  // 光照方向 · 半角向量 夹角余弦
	float VdotH;                  // 视角方向 · 半角向量 夹角余弦
	float perceptualRoughness;    // 感知粗糙度（美术编辑的原始值）
	float metalness;              // 金属度
	vec3 reflectance0;            // 0度入射角 反射率（垂直入射）
	vec3 reflectance90;           // 90度入射角 反射率（掠射入射）
	float alphaRoughness;         // 物理粗糙度（perceptualRoughness²，用于光照计算）
	vec3 diffuseColor;            // 漫反射颜色
	vec3 specularColor;           // 高光反射颜色
};

//  从顶点或贴图获取法线（世界坐标系）
vec3 getNormal()
{
	vec3 tangentNormal = texture(normalMap, material.normalTextureSet == 0 ? inUV0 : inUV1).xyz * 2.0 - 1.0;

	// dFdx的返回值表示当前片元在屏幕空间x方向上的局部偏导数
	// 即当屏幕坐标x增加1个像素时，输入变量的变化率。
	// 它通常在GPU的2x2像素块内计算，通过相邻像素的值差来获得。
	vec3 q1 = dFdx(inPosition);
	vec3 q2 = dFdy(inPosition);
	vec2 st1 = dFdx(inUV0);
	vec2 st2 = dFdy(inUV0);

	// N 向上（模型表面法线）
	// T 向右（切线 纹理 U 方向）
	// B 向前（副切线 纹理 V 方向）
	vec3 N = normalize(inNormal);
	vec3 T = normalize(q1 * st2.t - q2 * st1.t);
	vec3 B = normalize(cross(N, T));
	mat3 TBN = mat3(T, B, N);

	return normalize(TBN * tangentNormal);
}

vec4 SRGBtoLINEAR(vec4 srgbIn)
{
	//#define MANUAL_SRGB 1
	#ifdef MANUAL_SRGB
	#ifdef SRGB_FAST_APPROXIMATION
	vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
	#else //SRGB_FAST_APPROXIMATION
	vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
	vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
	#endif //SRGB_FAST_APPROXIMATION
	return vec4(linOut,srgbIn.w);;
	#else //MANUAL_SRGB
	return srgbIn;
	#endif //MANUAL_SRGB
}

// F 菲涅尔函数
vec3 specularReflection(PbrInfo pbrInputs)
{
	// reflectance0：垂直入射反射率
	// reflectance90：掠射入射反射率
	// VdotH：视线与半角向量夹角
	// 公式效果：角度越偏，反射越强
	return pbrInputs.reflectance0 + (pbrInputs.reflectance90 - pbrInputs.reflectance0) * pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);
}

// G 几何遮蔽函数
float geometricOcclusion(PbrInfo pbrInputs)
{
	// 粗糙表面会自己遮挡自己 → 让高光更真实、不刺眼
	// 越粗糙 → G 值越小 → 高光越暗
	float NdotL = pbrInputs.NdotL;
	float NdotV = pbrInputs.NdotV;
	float r = pbrInputs.alphaRoughness;

	// 计算光方向的遮蔽
	// 计算视线方向的遮蔽
	// 相乘得到总遮蔽
	float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
	float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
	return attenuationL * attenuationV;
}

// D 微表面分布函数
float microfacetDistribution(PbrInfo pbrInputs)
{
	// 控制高光的形状与大小
	// 光滑 → D 值高 → 小而亮的高光
	// 粗糙 → D 值低 → 大而散的高光
	float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;
	float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;
	return roughnessSq / (M_PI * f * f);
}

// 漫反射率，能量守恒所以除以PI
vec3 diffuse(PbrInfo pbrInputs)
{
    // 漫反射率 = 漫反射颜色 / π
	return pbrInputs.diffuseColor / M_PI;
}

#include "include/tocubemap.glsl"
// 球谐函数
vec3 irradianceFromSH(vec3 i_normal)
{
	vec3 normal = tocubemap(i_normal);
    vec3 result =
        pass.sh[0].xyz +
        pass.sh[1].xyz * normal.y +
        pass.sh[2].xyz * normal.z +
        pass.sh[3].xyz * normal.x +
        pass.sh[4].xyz * normal.y * normal.x +
        pass.sh[5].xyz * normal.y * normal.z +
        pass.sh[6].xyz * (1.0 - 3.0*normal.z*normal.z) +
        pass.sh[7].xyz * normal.z * normal.x +
        pass.sh[8].xyz * (normal.x*normal.x - normal.y*normal.y);
    return result * 0.282095;
}
// 计算IBL环境光照
vec3 getIBLContribution(PbrInfo pbrInputs, vec3 n, vec3 reflection)
{
	vec3 cubeVec = tocubemap(reflection);

	float lod = (pbrInputs.perceptualRoughness * pass.prefilteredCubeMipLevels);
	// 从 BRDF LUT 获取缩放和偏移
	vec3 brdf = (texture(samplerBRDFLUT, vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
	// 球谐函数 计算漫反射环境光
	vec3 diffuseLight = irradianceFromSH(n);
	// 镜面反射：采样预过滤贴图
	vec3 specularLight = tonemap(textureLod(prefilteredMap, cubeVec, lod)).rgb;
	// 漫反射 + 镜面反射 计算
	vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;
	vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);

	// 环境光强度缩放
	diffuse *= pass.scaleIBLAmbient;
	if(ONLY_SH)
		return diffuse;

	specular *= pass.scaleIBLAmbient;

	return diffuse + specular;
}

#define ambient 0.3

float textureProj(vec4 shadowCoord, vec2 offset, uint cascadeIndex)
{
	float shadow = 1.0;
	float bias = 0.005;

	if ( shadowCoord.z > 0 && shadowCoord.z < 1.0 ) 
	{
		float dist = texture(shadowMap, vec3(shadowCoord.st + offset, cascadeIndex)).r;
		// 从光看 dist
		// 同一个点，但是主相机看 shadowCoord.z
		// 如果光看到的更小，则说明被遮挡
		if (shadowCoord.w > 0 && dist < shadowCoord.z - bias)
		{
			shadow = ambient;
		}
	}
	return shadow;
}
// 百分比渐进过滤
float filterPCF(vec4 sc, uint cascadeIndex)
{
	ivec2 texDim = textureSize(shadowMap, 0).xy;
	float scale = 0.75;
	float dx = scale * 1.0 / float(texDim.x);
	float dy = scale * 1.0 / float(texDim.y);

	float shadowFactor = 0.0;
	int count = 0;
	int range = 1;
	
	for (int x = -range; x <= range; x++) 
	{
		for (int y = -range; y <= range; y++) 
		{
			shadowFactor += textureProj(sc, vec2(dx*x, dy*y), cascadeIndex);
			count++;
		}
	}
	return shadowFactor / count;
}
const mat4 biasMat = mat4( 
	0.5, 0.0, 0.0, 0.0,
	0.0, 0.5, 0.0, 0.0,
	0.0, 0.0, 1.0, 0.0,
	0.5, 0.5, 0.0, 1.0 
);

void main() 
{
	float perceptualRoughness;
	float metallic;
	vec3 diffuseColor;
	vec4 baseColor;
	// 基础反射值
	vec3 f0 = vec3(0.04);

	// 透明度裁剪
	if (material.alphaMask == 1.0f) 
	{
		if (material.baseColorTextureSet > -1) 
		{
			baseColor = SRGBtoLINEAR(texture(diffuseMap, material.baseColorTextureSet == 0 ? inUV0 : inUV1)) * material.baseColorFactor;
		}
		else 
		{
			baseColor = material.baseColorFactor;
		}
		if (baseColor.a < material.alphaMaskCutoff) 
		{
			discard;
		}
	}
		
    // 粗糙度（基础值）
    perceptualRoughness = material.roughnessFactor;
    // 金属度（基础值）
	metallic = material.metallicFactor;
	// 采样 粗糙度和金属度
	if (material.physicalDescriptorTextureSet > -1) 
	{
		// R 通道 = 环境光遮蔽 AO (Occlusion)
		// G 通道 = 粗糙度 (Roughness)
		// B 通道 = 金属度 (Metallic)
		vec4 mrSample = texture(physicalMap, material.physicalDescriptorTextureSet == 0 ? inUV0 : inUV1);
		perceptualRoughness = mrSample.g * perceptualRoughness;
		metallic = mrSample.b * metallic;
	} 
	else 
	{
		perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
		metallic = clamp(metallic, 0.0, 1.0);
	}

	// 采样 基础颜色
	if (material.baseColorTextureSet > -1) 
	{
		baseColor = SRGBtoLINEAR(texture(diffuseMap, material.baseColorTextureSet == 0 ? inUV0 : inUV1)) * material.baseColorFactor;
	} 
	else
	{
		baseColor = material.baseColorFactor;
	}

    baseColor *= inColor;

    diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
	diffuseColor *= 1.0 - metallic;

	// 粗糙度的平方（人眼对粗糙的感受不是线性的）
	float alphaRoughness = perceptualRoughness * perceptualRoughness;


	//--------------------------------------------------------------------------
	// 高光颜色
	// 它决定了：
	// 物体反光有多亮
	// 反光是什么颜色
	// 金属 / 非金属的反光区别
	vec3 specularColor = mix(f0, baseColor.rgb, metallic);
	// 计算反射率基准值
	float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);

	// 计算90°掠射时的反射强度（菲涅尔上限）
	float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);

	// 定义菲涅尔的两个关键参数：垂直入射(R0) / 掠射入射(R90)
	vec3 specularEnvironmentR0 = specularColor.rgb;
	vec3 specularEnvironmentR90 = vec3(1.0) * reflectance90;

	//--------------------------------------------------------------------------
	// 1. 获取最终表面法线（纹理法线 / 模型法线）
	vec3 n = (material.normalTextureSet > -1) ? getNormal() : normalize(inNormal);
	// 2. 计算PBR核心方向向量
	vec3 v = normalize(ubo.camPos - inPosition);    // 点 -> 相机
	vec3 l = normalize(-pass.light[0].direction);   // 点 -> 光源（平行光需要取反）
	vec3 h = normalize(l+v);                        // 半角向量：光线+视角的中间方向

	// 相机 -> 点 转换为 点 -> 光
	vec3 reflection = normalize(reflect(-v, n));    // 环境反射向量（用于环境贴图采样）

	// 3. 计算PBR必需的点积（全部钳位避免除零/负数）
	float NdotL = clamp(dot(n, l), 0.001, 1.0);  		// 法线·光线
	float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);  	// 法线·视角（取绝对值）
	float NdotH = clamp(dot(n, h), 0.0, 1.0);    		// 法线·半角向量
	float LdotH = clamp(dot(l, h), 0.0, 1.0);    		// 光线·半角向量
	float VdotH = clamp(dot(v, h), 0.0, 1.0);    		// 视角·半角向量

	PbrInfo pbrInputs = PbrInfo(
		NdotL,
		NdotV,
		NdotH,
		LdotH,
		VdotH,
		perceptualRoughness,
		metallic,
		specularEnvironmentR0,
		specularEnvironmentR90,
		alphaRoughness,
		diffuseColor,
		specularColor
	);

	// 计算参数
	vec3 F = specularReflection(pbrInputs);
	float G = geometricOcclusion(pbrInputs);
	float D = microfacetDistribution(pbrInputs);

	const vec3 u_LightColor = pass.light[0].strength;

	// 计算光照结果
	// 漫反射
	vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);
	// 高光部分
	vec3 specContrib = F * G * D / (4.0 * NdotL * NdotV);
	// 最终光照 = 漫反射 + 高光，受法线与灯光夹角影响
	vec3 color = NdotL * u_LightColor * (diffuseContrib + specContrib);
	
	if(ONLY_SH)
		color = diffuseContrib;

	//----------------------------------阴影计算
	// 返回所在级联
	uint cascadeIndex = 0;
	for(uint i = 0; i < SHADOW_MAP_CASCADE_COUNT - 1; ++i) 
	{
		if(inViewPos.z < pass.cascadeSplits[i])
		{	
			cascadeIndex = i + 1;
		}
	}

	// 所在贴图位置
	vec4 shadowCoord = (biasMat * cascade.viewProj[cascadeIndex]) * vec4(inPosition, 1.0);	
	// xy 纹理坐标 
	// z 点到光源的距离
	shadowCoord.xyz /= shadowCoord.w;

	float shadow = 0;
	if (enablePCF == 1) 
	{
		shadow = filterPCF(shadowCoord, cascadeIndex);
	} 
	else 
	{
		shadow = textureProj(shadowCoord, vec2(0.0), cascadeIndex);
	}
	// 只影响直射光
	if(!ONLY_SH)
		color *= shadow;


	// 计算ibl光照
	color += getIBLContribution(pbrInputs, n, reflection);

	const float u_OcclusionStrength = 1.0f;
	// 采样 环境光遮蔽
	if (material.occlusionTextureSet > -1) 
	{
		float ao = texture(aoMap, (material.occlusionTextureSet == 0 ? inUV0 : inUV1)).r;
		color = mix(color, color * ao, u_OcclusionStrength);
	}
	// 采样 自发光
	vec3 emissive = material.emissiveFactor.rgb * material.emissiveStrength;
	if (material.emissiveTextureSet > -1)
	 {
		emissive *= SRGBtoLINEAR(texture(emissiveMap, material.emissiveTextureSet == 0 ? inUV0 : inUV1)).rgb;
	};
	if(!ONLY_SH)
		color += emissive;

	outColor = vec4(color, baseColor.a);

	// --------------------------------调试绘图-------------------------------
	if (pass.debugViewInputs > 0.0)
	 {
		int index = int(pass.debugViewInputs);
		switch (index)
		 {
			case 1:
				outColor.rgba = material.baseColorTextureSet > -1 ? texture(diffuseMap, material.baseColorTextureSet == 0 ? inUV0 : inUV1) : vec4(1.0f);
				break;
			case 2:
				outColor.rgb = (material.normalTextureSet > -1) ? texture(normalMap, material.normalTextureSet == 0 ? inUV0 : inUV1).rgb : inNormal;
				break;
			case 3:
				outColor.rgb = (material.occlusionTextureSet > -1) ? texture(aoMap, material.occlusionTextureSet == 0 ? inUV0 : inUV1).rrr : vec3(0.0f);
				break;
			case 4:
				outColor.rgb = (material.emissiveTextureSet > -1) ? texture(emissiveMap, material.emissiveTextureSet == 0 ? inUV0 : inUV1).rgb : vec3(0.0f);
				break;
			case 5: // 金属度
				outColor.rgb = texture(physicalMap, inUV0).bbb;
				break;
			case 6: // 粗糙度
				outColor.rgb = texture(physicalMap, inUV0).ggg;
				break;
			// PBR 光照方程 调试可视化
			case 10:
				outColor.rgb = diffuseContrib; // 漫反射
				break;
			case 11:
				outColor.rgb = F; // 菲涅尔
				break;
			case 12:
				outColor.rgb = vec3(G); // 几何遮蔽
				break;
			case 13: 
				outColor.rgb = vec3(D); // 微表面分布
				break;
			case 14:
				outColor.rgb = specContrib; // 高光
				break;	
			case 15:// 点 -> 光
				outColor.rgb = reflection; // 反射向量
				break;	
			// 级联阴影
			case 20:
			{
				switch(cascadeIndex)
				{
				case 0 : 
					outColor.rgb *= vec3(1.0f, 0.25f, 0.25f);
					break;
				case 1 : 
					outColor.rgb *= vec3(0.25f, 1.0f, 0.25f);
					break;
				case 2 : 
					outColor.rgb *= vec3(0.25f, 0.25f, 1.0f);
					break;
				case 3 : 
					outColor.rgb *= vec3(1.0f, 1.0f, 0.25f);
					break;
				}
			}
			break;
			case 21: 
				outColor.rgb = shadowCoord.xxx; // 采样坐标
				break;
			case 22: 
				outColor.rgb = shadowCoord.zzz; //当前点 到光源的距离（深度）
				break;
			case 23: 
				// 把屏幕UV直接当阴影贴图UV，全屏展示阴影贴图
				vec2 uv = gl_FragCoord.xy / vec2(1280.0, 720.0); // 换成你屏幕分辨率
				float depth = texture(shadowMap, vec3(uv, cascadeIndex)).r;
				
				// 直接把阴影贴图的深度值画出来
				outColor = vec4(vec3(depth), 1.0);
				break;
		}	
	}
}