`lygia`

/`lighting`

/`common`

/`ggx`

)Dependencies:

```
#ifndef FNC_GGX
#define FNC_GGX
// Walter et al. 2007, "Microfacet Models for Refraction through Rough Surfaces"
// This one is not great on mediump. Read next comment
float GGX(const in float NoH, const in float roughness) {
float oneMinusNoHSquared = 1.0 - NoH * NoH;
float a = NoH * roughness;
float k = roughness / (oneMinusNoHSquared + a * a);
float d = k * k * INV_PI;
return saturateMediump(d);
}
float GGX(const in vec3 N, const in vec3 H, const in float NoH, float roughness) {
#if defined(TARGET_MOBILE) || defined(PLATFORM_RPI) || defined(PLATFORM_WEBGL)
// In mediump, there are two problems computing 1.0 - NoH^2
// 1) 1.0 - NoH^2 suffers floating point cancellation when NoH^2 is close to 1 (highlights)
// 2) NoH doesn't have enough precision around 1.0
// Both problem can be fixed by computing 1-NoH^2 in highp and providing NoH in highp as well
// However, we can do better using Lagrange's identity:
// ||a x b||^2 = ||a||^2 ||b||^2 - (a . b)^2
// since N and H are unit vectors: ||N x H||^2 = 1.0 - NoH^2
// This computes 1.0 - NoH^2 directly (which is close to zero in the highlights and has
// enough precision).
// Overall this yields better performance, keeping all computations in mediump
vec3 NxH = cross(N, H);
float oneMinusNoHSquared = dot(NxH, NxH);
#else
float oneMinusNoHSquared = 1.0 - NoH * NoH;
#endif
float a = NoH * roughness;
float k = roughness / (oneMinusNoHSquared + a * a);
float d = k * k * INV_PI;
return saturateMediump(d);
}
#endif
```

Dependencies:

```
#ifndef FNC_COMMON_GGX
#define FNC_COMMON_GGX
// Walter et al. 2007, "Microfacet Models for Refraction through Rough Surfaces"
// In mediump, there are two problems computing 1.0 - NoH^2
// 1) 1.0 - NoH^2 suffers floating point cancellation when NoH^2 is close to 1 (highlights)
// 2) NoH doesn't have enough precision around 1.0
// Both problem can be fixed by computing 1-NoH^2 in highp and providing NoH in highp as well
// However, we can do better using Lagrange's identity:
// ||a x b||^2 = ||a||^2 ||b||^2 - (a . b)^2
// since N and H are unit vectors: ||N x H||^2 = 1.0 - NoH^2
// This computes 1.0 - NoH^2 directly (which is close to zero in the highlights and has
// enough precision).
// Overall this yields better performance, keeping all computations in mediump
float GGX(float NoH, float linearRoughness) {
float oneMinusNoHSquared = 1.0 - NoH * NoH;
float a = NoH * linearRoughness;
float k = linearRoughness / (oneMinusNoHSquared + a * a);
float d = k * k * INV_PI;
return saturateMediump(d);
}
float GGX(float3 N, float3 H, float NoH, float linearRoughness) {
float3 NxH = cross(N, H);
float oneMinusNoHSquared = dot(NxH, NxH);
float a = NoH * linearRoughness;
float k = linearRoughness / (oneMinusNoHSquared + a * a);
float d = k * k * INV_PI;
return saturateMediump(d);
}
#endif
```

```
fn GGX(N: vec3f, H: vec3f, NoH: f32, roughness: f32) -> f32 {
let NxH = cross(N, H);
let oneMinusNoHSquared = dot(NxH, NxH);
// let oneMinusNoHSquared = 1.0 - NoH * NoH;
let a = NoH * roughness;
let k = roughness / (oneMinusNoHSquared + a * a);
let d = (k * k) * 0.31830988618379067153776752674503; // 1/PI
return min(d, 65504.0);
}
```

LYGIA is dual-licensed under the Prosperity License and the Patron License for sponsors and contributors.

Sponsors and contributors are automatically added to the Patron License and they can ignore the any non-commercial rule of the Prosperity Licensed software (please take a look to the exception).

It's also possible to get a permanent comercial license hook to a single and specific version of LYGIA.

Sign up for the news letter bellow, joing the LYGIA's channel on Discord or follow the Github repository