The Importance of GGX – Flash Sword Master – Bloggarden (CNblogs.com)

Reflection equation

Specular portion

Simplified partition summation approximation

Environmental BRDF

We substitute F Fresnel equation to simplify the equation
Since f(p, omega I, omega O) already contains the f terms, they’re divided, and there’s no f terms in f here. It has nothing to do with F of a particular material, it has nothing to do with metal or non-metal, it has nothing to do with roughness

Environmental BRDF

float lod             = getMipLevelFromRoughness(roughness);
vec3 prefilteredColor = textureCubeLod(PrefilteredEnvMap, refVec, lod); //roughnesss
vec2 envBRDF          = texture2D(BRDFIntegrationMap, vec2(NdotV, roughness)).rg; //brdf
vec3 indirectSpecular = prefilteredColor * (F * envBRDF.x + envBRDF.y)  //fr
Copy the code

It can be obtained from the graph and formula

The X-axis is the Angle dot of the normal to the Angle of view, and the Y-axis is the roughness
It depends on the elevation Angle θ, the roughness α and the Fresnel term F.
The Schlick approximation is usually used to approximate F, which parameterizes only over a single value F0, thus making Rspec a function of three parameters (elevation θ (NdotV), roughness α, and F0).
Green is G>R, red is R>G
The bigger the Angle, the smaller the dot, the closer to 0
2D lookup texture storage is Fresnel response coefficient (R channel) and deviation value (G channel)
```
vec3 indirectSpecular = prefilteredColor * (F * envBRDF.x + envBRDF.y)  //fr
Copy the code
```

Known concept

The hemispherical and directional reflectance of the specular reflectance can be understood as the Environment BRDF.
The BRDF integral map is from the lookup table
The BRDF integral map is unchanged by default
Envbrdf.xy may not be accurate enough in webgl1 (there is a solution in osg.
There are two ways to calculate BRDF integral map: one is the default method; UE4 uses the Trike method;

BRDF calculation

float G_SchlicksmithGGX(float dotNL, float dotNV, float roughness)
{
	float r = (roughness + 1.0);
	float k = (r*r) / 8.0;
	float GL = dotNL / (dotNL * (1.0 - k) + k);
	float GV = dotNV / (dotNV * (1.0 - k) + k);
	return GL * GV;
}
Copy the code

vec2 BRDF(float NoV, float roughness)
{
	// For 2D lookups, the normal is always along the z axis
	const vec3 N = vec3(0.0.0.0.1.0);
	vec3 V = vec3(sqrt(1.0 - NoV*NoV), 0.0, NoV);

	vec2 LUT = vec2(0.0);
	for(uint i = 0u; i < NUM_SAMPLES; i++) {
		vec2 Xi = hammersley2d(i, NUM_SAMPLES);
		vec3 H = importanceSample_GGX(Xi, roughness, N);
		vec3 L = 2.0 * dot(V, H) * H - V;

		float dotNL = max(dot(N, L), 0.0);
		float dotNV = max(dot(N, V), 0.0);
		float dotVH = max(dot(V, H), 0.0); 
		float dotNH = max(dot(H, N), 0.0);

		if (dotNL > 0.0) {
			float G = G_SchlicksmithGGX(dotNL, dotNV, roughness);
			float G_Vis = (G * dotVH) / (dotNH * dotNV);
			float Fc = pow(1.0 - dotVH, 5.0);
			LUT += vec2((1.0- Fc) * G_Vis, Fc * G_Vis); }}return LUT / float(NUM_SAMPLES);
}

void main() 
{
	outColor = vec4(BRDF(inUV.s, 1.0-inUV.t), 0.0.1.0);
}
Copy the code

#version 450

layout (location = 0) in vec3 inWorldPos;
layout (location = 1) in vec3 inNormal;
layout (location = 2) in vec2 inUV;

layout (binding = 0) uniform UBO {
	mat4 projection;
	mat4 model;
	mat4 view;
	vec3 camPos;
} ubo;

layout (binding = 1) uniform UBOParams {
	vec4 lights[4];
	float exposure;
	float gamma;
} uboParams;

layout(push_constant) uniform PushConsts {
	layout(offset = 12) float roughness;
	layout(offset = 16) float metallic;
	layout(offset = 20) float specular;
	layout(offset = 24) float r;
	layout(offset = 28) float g;
	layout(offset = 32) float b;
} material;

layout (binding = 2) uniform samplerCube samplerIrradiance;
layout (binding = 3) uniform sampler2D samplerBRDFLUT;
layout (binding = 4) uniform samplerCube prefilteredMap;

layout (location = 0) out vec4 outColor;

# define PI (3.1415926535897932384626433832795)
#define ALBEDO vec3(material.r, material.g, material.b)

float D_GGX(float dotNH, float roughness)
{
	float alpha = roughness * roughness;
	float alpha2 = alpha * alpha;
	float denom = dotNH * dotNH * (alpha2 - 1.0) + 1.0;
	return (alpha2)/(PI * denom*denom); 
}

float G_SchlicksmithGGX(float dotNL, float dotNV, float roughness)
{
	float r = (roughness + 1.0);
	float k = (r*r) / 8.0;
	float GL = dotNL / (dotNL * (1.0 - k) + k);
	float GV = dotNV / (dotNV * (1.0 - k) + k);
	return GL * GV;
}

vec3 F_SchlickR(float cosTheta, vec3 F0, float roughness)
{
	return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
}

// Pre-filtered linear sampling
vec3 prefilteredReflection(vec3 R, float roughness)
{
	const float MAX_REFLECTION_LOD = 9.0; 
	float lod = roughness * MAX_REFLECTION_LOD;
	float lodf = floor(lod);
	float lodc = ceil(lod);
	vec3 a = textureLod(prefilteredMap, R, lodf).rgb;
	vec3 b = textureLod(prefilteredMap, R, lodc).rgb;
	return mix(a, b, lod - lodf);
}

/ / source BRDF
vec3 specularContribution(vec3 L, vec3 V, vec3 N, vec3 F0, float metallic, float roughness)
{
	vec3 H = normalize (V + L);
	float dotNH = clamp(dot(N, H), 0.0.1.0);
	float dotNV = clamp(dot(N, V), 0.0.1.0);
	float dotNL = clamp(dot(N, L), 0.0.1.0);

	vec3 lightColor = vec3(1.0);
	vec3 color = vec3(0.0);

	if (dotNL > 0.0) {
		float D = D_GGX(dotNH, roughness); 
		float G = G_SchlicksmithGGX(dotNL, dotNV, roughness);
		vec3 F = F_Schlick(dotNV, F0);		
		vec3 spec = D * F * G / (4.0 * dotNL * dotNV + 0.001);		
		vec3 kD = (vec3(1.0) - F) * (1.0 - metallic);			
		color += (kD * ALBEDO / PI + spec) * dotNL;
	}

	return color;
}

void main()
{		
	vec3 N = normalize(inNormal);
	vec3 V = normalize(ubo.camPos - inWorldPos);
	vec3 R = reflect(-V, N); 

	float metallic = material.metallic;
	float roughness = material.roughness;

	vec3 F0 = vec3(0.04); 
	F0 = mix(F0, ALBEDO, metallic);
	/ / light
	vec3 Lo = vec3(0.0);
 	for(int i = 0; i < uboParams.lights[i].length(a); i++) {vec3 L = normalize(uboParams.lights[i].xyz - inWorldPos);
 		Lo += specularContribution(L, V, N, F0, metallic, roughness);
 	}   
	
	vec2 brdf = texture(samplerBRDFLUT, vec2(max(dot(N, V), 0.0), roughness)).rg;
	vec3 reflection = prefilteredReflection(R, roughness).rgb;	
	vec3 irradiance = texture(samplerIrradiance, N).rgb;

	// Diffuse irradiance (1)
	vec3 diffuse = irradiance * ALBEDO;	

	vec3 F = F_SchlickR(max(dot(N, V), 0.0), F0, roughness);

	// Mirror reflection (bottom)
	vec3 specular = reflection * (F * brdf.x + brdf.y);

	// Part of the environment
	vec3 kD = 1.0 - F;
	kD *= 1.0 - metallic;	  
	vec3 ambient = (kD * diffuse + specular);
	
	vec3 color = ambient + Lo;

	// Color mapping
	color = vec3(1.0) - exp(-color * uboParams.exposure);	
	// Gamma correction
	color = pow(color, vec3(1.0f / uboParams.gamma));

	outColor = vec4(color, 1.0);
}

Copy the code

mo4tech.com (Moment For Technology) is a global community with thousands techies from across the global hang out!Passionate technologists, be it gadget freaks, tech enthusiasts, coders, technopreneurs, or CIOs, you would find them all here.

PBR BRDF

Reflection equation

Specular portion

Simplified partition summation approximation

Environmental BRDF

Environmental BRDF

It can be obtained from the graph and formula

Known concept

BRDF calculation

PBR BRDF

Reflection equation

Specular portion

Simplified partition summation approximation

Environmental BRDF

Environmental BRDF

It can be obtained from the graph and formula

Known concept

BRDF calculation

Related Posts

Multiple chatrooms based on socket. IO support independent creation of ~

Say goodbye to the concept of death, and understand “anti-shake and Throttling” in plain English

Simple and useful CSS property: border