31:T687,The BRDF has three important physical properties: - ${tex`f_r(\mathrm{p}, \omega_o, \omega_i) \geq 0`}: *Positivity*—The BRDF is never negative. - ${tex`f_r(\mathrm{p}, \omega_o, \omega_i)=f_r(\mathrm{p}, \omega_i, \omega_o)`}: *[Helmholtz Reciprocity](https://en.wikipedia.org/wiki/Helmholtz_reciprocity "Wikipedia: Helmholtz Reciprocity")*— The direction of the calculation does not matter (swapping the position of the sensor and light source does not affect the reflectivity). - ${tex`\int_\Omega f_r(\mathrm{p}, \omega_o, \omega)\left(\mathrm{\mathbf{n}} \cdot \omega\right)d\omega \leq 1`}: *Energy Conservation*—The BRDF does not introduce energy, regardless of the outgoing angle ${tex`\omega_o`}. For computer graphics, the BRDF encodes (most of) the important properties for our materials: - *Color*: The BRDF modulates the incoming light's spectrum by the response of the surface. Under white light, this modulation provides the object's "color". - *Reflectivity*: The BRDF indicates if reflected light is focused in a direction (specular) or spread out (diffuse). With modifications, a bidirectional transmission distribution function (BTFD) can be defined to indicate how light passes through an object. - *Roughness*: The BRDF can model how light interacts with rough surfaces at a micro-facet level. - *Anistropy*: While the BRDFs discussed below are isotropic (do not vary based on direction), reflectivity that varies on direction can be introduced. The BRDF does not capture every phenomena—e.g. volumetric transport such as sub-surface scattering—but it is a versatile tool.32:T56d,This substitution works because as ${tex`\omega_i`} approaches the reflection direction ${tex`\omega_r`}, ${tex`\omega_h`} approaches the normal until is is fully aligned when ${tex`\omega_i=\omega_r`}. However, the angles beteween ${tex`\omega_i, \omega_r`} and ${tex`\mathbf{\mathrm n}, \omega_h`} are not equal and do not change at the same rate; thus, the specular exponent ${tex`s'`} for Blinn-Phong must be strictly greater than that used by Phong to look equivalent. In the original Phong paper, ${tex`1 \leq s \leq 10`}; Blinn recommends ${tex`50 \leq s' \leq 60`}.

Why ${tex`\omega_h`}?

If both Phong and Blinn-Phong produce similar results (with adjusted ${tex`s'`}), why introduce Blinn-Phong? Blinn notes that for far away directional lights, ${tex`\omega_i`} is constant on flat surfaces; in addition, for distant views, then ${tex`\omega_o`} is also constant. Thus, ${tex`\omega_h`} is effectively constant for that surface; others have used this fact to argue for using ${tex`\omega_h`}. However, this argument also holds for ${tex`\omega_r`} for distant viewers, so it could be cached instead. Blinn uses the half-way vector because microfacet models (below) use that vector to measure alignment with the surface normal which determines the glossy spread.

33:T1149,{ const fig_width = Math.min(300, width); const offset = 0.5 * width - 0.5 * fig_width; const surf_start = 0.75 * Math.round(width / 3 ); const black_arrow_id = DOM.uid("arrow"); const slategray_arrow_id = DOM.uid("sg_arrow"); const lslategray_arrow_id = DOM.uid("lsg_arrow"); const fig = svg``; const figdiv = html`

${fig} ${tex`\omega_o`} ${tex`\omega_r`} ${tex`\omega_i`} ${tex`\omega_h`}

` return html`

${figdiv}

The change in ${tex`\left(\mathrm{\mathbf n} \cdot \omega_h\right)`} is similar to that of ${tex`\left(\omega_r \cdot \omega_i\right)`} but not equal.

`; }34:T6f4,### Rough Diffuse (Oren-Nayar) Many diffuse surfaces are not ideally Lambertian: Sandpaper, for example, has angular dependent reflectance due to its roughness. To model this, Oren and Nayar introduced microfacets for diffuse surfaces. Microfacets are much smaller differential areas that are part of a larger macrosurface. Each microfacet is a diffuse or specular reflector individually; their arrangement (indicated by a statistical average of each microfacet normal, the normal distribution function) with the overall surface normal indicates how smooth the surface is. A smooth surface has most of the microfacets aligned with the macrosurface normal (it is essentially flat), whereas a rough surface has very few aligned normals. Another part of microsurface modelling captures what happens to light entering the microfacets. A microfacet can be in *shadow* if another blocks the incoming light; similarly, it can be *masked* if another microfacet blocks the view in the outgoing direction. Finally, *interreflection* captures light bouncing from other microfacets towards the outgoing direction. These aspects are captured by a geometric attenuation function. Oren and Nayar's model assumes the a rough diffuse surface is represented by a collection of diffuse microfacets. Each microfacet—in the shape of a "V"—is individually a perfect Lambertian reflector. However, the distribution of the facets will make the overall appearance change as the light aligns or misaligns itself with the microfacets. Thus, the overall surface is non-Lambertian. Oren and Nayar derive a variety of BRDFs under different assumptions, but the most general—ignoring terms with diminishing importance such as interreflections— is: 35:T467,### Rough Specular (Torrance-Sparrow) Rough specular reflections are more diffuse than small glossy reflections, but at the microfacet scale are still pure specular. This diffuse nature has lead some papers to call this type of reflection directional diffuse as it is still spread out like diffuse reflections, but favors some specific angles. We will use rough specular as our term. Microfacet reflection models have been used since the 18th century, and were first utilized for rough specular reflections by Torrance and Sparrow in 1967; this model has been refined by Torrance a few times hence (Cook-Torrance and He-Torrance). Their microfacet model uses specular microfacets (as opposed to the diffuse ones used by Oren-Nayar) distributed probabilistically to model how a reflection is spread as the alignment of the facets change. Their BRDF is composed of the normal distribution (*how aligned with the surface normal are the microfacet normals*), the geometric attenuation function (*how much masking, shadowing, and interreflection is there due to the facet distribution*), and a Fresnel reflectance term:36:T508,{ drawDiffuseAlone.regl.clear({ color: whitesmoke }); drawSpecularAlone.regl.clear({ color: whitesmoke }); drawGlossyAlone.regl.clear({ color: whitesmoke }); drawRoughDiffuseAlone.regl.clear({ color: whitesmoke }); drawRoughSpecularAlone.regl.clear({ color: whitesmoke }); const light_pos = [Math.sin((light_phi) * Math.PI / 180) * Math.sin(light_theta * Math.PI / 180), Math.cos(light_theta * Math.PI / 180), Math.cos((light_phi) * Math.PI / 180) * Math.sin(light_theta * Math.PI / 180)]; drawDiffuseAlone({light_pos: light_pos, reflectivity: diffuse_r, flat: 0, view: {x: (width - width/3)/2, width: width/3}}); drawGlossyAlone({light_pos: light_pos, k: ks, s: bp_shininess, flat: 0, view: {x: (width - width/3)/2, width: width/3}}); drawSpecularAlone({light_pos: light_pos, reflectivity: f0, flat: 0, view: {x: (width - width/3)/2, width: width/3}}); drawRoughDiffuseAlone({light_pos: light_pos, reflectivity: diffuse_r, roughness: on_roughness * Math.PI / 180, flat: 0, view: {x: (width - width/3)/2, width: width/3}}); drawRoughSpecularAlone({light_pos: light_pos, reflectivity: f0, roughness: tr_alpha, flat: 0, view: {x: (width - width/3)/2, width: width/3}}); return `Demos Drawn`; }37:T9d6,diffuse_config = Object({ vert: ` precision mediump float; attribute vec2 position; void main () { gl_Position = vec4(position, 0, 1); }`, attributes: { position: [[-1, -1], [+1, -1], [+1, +1], [-1, +1]] }, primitive: "triangles", elements: [0, 1, 2, 0, 2, 3], viewport: { x: (ctx, {view}) => view.x, y: 0, width: (ctx, {view}) => view.width, height: width/3 }, uniforms: { sphere: (ctx, {flat}) => 1 - flat, center: (ctx, {view}) => [view.x + view.width / 2, width / 6], radius: (ctx, {view}) => Math.min(view.width / 2, width / 6), reflectivity: (ctx, {reflectivity}) => reflectivity, light_pos: (ctx, {light_pos}) => light_pos }, frag: ` precision mediump float; uniform vec3 light_pos; uniform float reflectivity; uniform float sphere; uniform vec2 center; uniform float radius; const float pi = 3.14159; vec3 gamma(vec3 color) { // sRGB gamma correction float exp = 1.0/2.4; if(color.r < 0.0031308) color.r *= 12.92; else color.r = 1.055 * pow(color.r, exp) - 0.055; if(color.g < 0.0031308) color.g *= 12.92; else color.g = 1.055 * pow(color.g, exp) - 0.055; if(color.b < 0.0031308) color.b *= 12.92; else color.b = 1.055 * pow(color.b, exp) - 0.055; return color; } void main () { vec3 n = vec3(0., 0., 1.); vec3 l = normalize(light_pos - vec3(gl_FragCoord.xy, 0)); if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) < 0.) { gl_FragColor = vec4(gamma(vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); n = normalize(pt - sphere_center); // For sphere, use directional light l = light_pos; } if(dot(n,l) <= 0.) { gl_FragColor = vec4(gamma(vec3(0.)), 1.0); return; } // Note, we do not divide by pi as we are sampling once over the entire hemisphere // Assume we have done the integration float c = reflectivity * dot(l, n) * max(dot(l, n), 0.); gl_FragColor = vec4(gamma(vec3(c)), 1.0); }`, })38:Td96,spec_config = Object({ vert: ` precision mediump float; attribute vec2 position; void main () { gl_Position = vec4(position, 0, 1); }`, attributes: { position: [[-1, -1], [+1, -1], [+1, +1], [-1, +1]] }, primitive: "triangles", elements: [0, 1, 2, 0, 2, 3], viewport: { x: (ctx, {view}) => view.x, y: 0, width: (ctx, {view}) => view.width, height: width/3 }, uniforms: { sphere: (ctx, {flat}) => 1 - flat, center: (ctx, {view}) => [view.x + view.width / 2, width / 6], radius: (ctx, {view}) => Math.min(view.width / 2, width / 6), reflectivity: (ctx, {reflectivity}) => reflectivity, light_pos: (ctx, {light_pos}) => light_pos }, frag: ` precision mediump float; uniform vec3 light_pos; uniform float reflectivity; uniform float sphere; uniform vec2 center; uniform float radius; vec3 gamma(vec3 color) { // sRGB gamma correction float exp = 1.0/2.4; if(color.r < 0.0031308) color.r *= 12.92; else color.r = 1.055 * pow(color.r, exp) - 0.055; if(color.g < 0.0031308) color.g *= 12.92; else color.g = 1.055 * pow(color.g, exp) - 0.055; if(color.b < 0.0031308) color.b *= 12.92; else color.b = 1.055 * pow(color.b, exp) - 0.055; return color; } // A hack for educational purposes! void main () { vec3 n = vec3(0., 0., 1.); vec3 v = normalize(vec3(${width/2}, ${width/6}, light_pos.z) - vec3(gl_FragCoord.xy, 0.)); vec3 l = normalize(light_pos - vec3(gl_FragCoord.xy, 0.)); vec3 h = normalize(v+l); if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) < 0.) { gl_FragColor = vec4(gamma(vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); v = normalize(vec3(0., 0., radius) - pt); n = normalize(pt - sphere_center); // For sphere, use directional light l = vec3(0., 0., 1.); h = normalize(v+l); } if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) < 0.) { gl_FragColor = vec4(gamma(vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); v = normalize(vec3(0., 0., radius) - pt); n = normalize(pt - sphere_center); // For sphere, use directional light l = light_pos; } if(dot(n,l) <= 0. || dot(n,v) <= 0.) { gl_FragColor = vec4(gamma(vec3(0.)), 1.0); return; } // Assume further than 1degree is too far float f = reflectivity + (1. - reflectivity) * pow(1. - dot(n,reflect(-v, n)), 5.); float how_spec = dot(reflect(-v, n), l); float stop = cos(2. / 180. * 3.14159); float c = step(stop, how_spec) * mix(0., 1., (how_spec - stop) / (1. - stop)) ; gl_FragColor = vec4(gamma(vec3(c * f / dot(n, reflect(-v, n)))), 1.0); }`, })39:T99f,glossy_config = Object({ vert: ` precision mediump float; attribute vec2 position; void main () { gl_Position = vec4(position, 0, 1); }`, attributes: { position: [[-1, -1], [+1, -1], [+1, +1], [-1, +1]] }, primitive: "triangles", elements: [0, 1, 2, 0, 2, 3], viewport: { x: (ctx, {view}) => view.x, y: 0, width: (ctx, {view}) => view.width, height: width/3 }, uniforms: { sphere: (ctx, {flat}) => 1 - flat, center: (ctx, {view}) => [view.x + view.width / 2, width / 6], radius: (ctx, {view}) => Math.min(view.width / 2, width / 6), k: (ctx, {k}) => k, light_pos: (ctx, {light_pos}) => light_pos, s: (ctx, {s}) => s, }, frag: ` precision mediump float; uniform vec3 light_pos; uniform float k; uniform float sphere; uniform vec2 center; uniform float radius; uniform float s; vec3 gamma(vec3 color) { // sRGB gamma correction float exp = 1.0/2.4; if(color.r < 0.0031308) color.r *= 12.92; else color.r = 1.055 * pow(color.r, exp) - 0.055; if(color.g < 0.0031308) color.g *= 12.92; else color.g = 1.055 * pow(color.g, exp) - 0.055; if(color.b < 0.0031308) color.b *= 12.92; else color.b = 1.055 * pow(color.b, exp) - 0.055; return color; } // A hack for educational purposes! void main () { vec3 n = vec3(0., 0., 1.); vec3 v = normalize(vec3(${width/2}, ${width/6}, light_pos.z) - vec3(gl_FragCoord.xy, 0.)); vec3 l = normalize(light_pos - vec3(gl_FragCoord.xy, 0.)); vec3 h = normalize(v+l); if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) < 0.) { gl_FragColor = vec4(gamma(vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); v = normalize(vec3(0., 0., radius) - pt); n = normalize(pt - sphere_center); // For sphere, use directional light l = light_pos; h = normalize(v+l); } float c = k * pow(dot(n,h), s); gl_FragColor = vec4(gamma(vec3(c)), 1.0); }`, })3a:Te0a,rough_diffuse_config = Object({ vert: ` precision mediump float; attribute vec2 position; void main () { gl_Position = vec4(position, 0, 1); }`, attributes: { position: [[-1, -1], [+1, -1], [+1, +1], [-1, +1]] }, primitive: "triangles", elements: [0, 1, 2, 0, 2, 3], viewport: { x: (ctx, {view}) => view.x, y: 0, width: (ctx, {view}) => view.width, height: width/3 }, uniforms: { sphere: (ctx, {flat}) => 1 - flat, center: (ctx, {view}) => [view.x + view.width / 2, width / 6], radius: (ctx, {view}) => Math.min(view.width / 2, width / 6), reflectivity: (ctx, {reflectivity}) => reflectivity, light_pos: (ctx, {light_pos}) => light_pos, roughness: (ctx, {roughness}) => roughness }, frag: ` precision mediump float; uniform vec3 light_pos; uniform float reflectivity; uniform float roughness; uniform float sphere; uniform vec2 center; uniform float radius; vec3 gamma(vec3 color) { // sRGB gamma correction float exp = 1.0/2.4; if(color.r < 0.0031308) color.r *= 12.92; else color.r = 1.055 * pow(color.r, exp) - 0.055; if(color.g < 0.0031308) color.g *= 12.92; else color.g = 1.055 * pow(color.g, exp) - 0.055; if(color.b < 0.0031308) color.b *= 12.92; else color.b = 1.055 * pow(color.b, exp) - 0.055; return color; } void main () { vec3 n = vec3(0., 0., 1.); vec3 v = normalize(vec3(${width/2}, ${width/6}, light_pos.z) - vec3(gl_FragCoord.xy, 0.)); vec3 l = normalize(light_pos - vec3(gl_FragCoord.xy, 0.)); if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) <= 0.) { gl_FragColor = vec4(gamma(vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); v = normalize(vec3(0., 0., radius) - pt); n = normalize(pt - sphere_center); // For sphere, use directional light l = light_pos; } // After Pharr et al.'s implementation from pbrt // https://www.pbr-book.org/3ed-2018/Reflection_Models/Microfacet_Models float theta_v = abs(acos(dot(n,v))); float theta_l = abs(acos(dot(n,l))); float sin_theta_v = sqrt(1. - dot(n,v) * dot(n,v)); float cosphi_v = clamp(v.x / sin_theta_v, -1., 1.); float sinphi_v = clamp(v.y / sin_theta_v, -1., 1.); float sin_theta_l = sqrt(1. - dot(n,l) * dot(n,l)); float cosphi_l = clamp(l.x / sin_theta_l, -1., 1.); float sinphi_l = clamp(l.y / sin_theta_l, -1., 1.); float alpha = max(theta_v, theta_l); float beta = min(theta_v, theta_l); float r2 = roughness * roughness; float a = 1. - r2 / (2.*(r2 + 0.33)); float b = 0.45 * r2 / (r2 + 0.09); float sin_alpha = 0.; float tan_beta = 0.; if(abs(l.z) > abs(v.z)) { sin_alpha = sin_theta_v; tan_beta = sin_theta_l / abs(l.z); } else { sin_alpha = sin_theta_l; tan_beta = sin_theta_v / abs(v.z); } float c = reflectivity * dot(n, l) * (a + b * max(0., cosphi_v * cosphi_l + sinphi_v * sinphi_l)*sin_alpha*tan_beta); gl_FragColor = vec4(gamma(vec3(c)), 1.); }`, })3b:Td73,rough_spec_config = Object({ vert: ` precision mediump float; attribute vec2 position; void main () { gl_Position = vec4(position, 0, 1); }`, attributes: { position: [[-1, -1], [+1, -1], [+1, +1], [-1, +1]] }, primitive: "triangles", elements: [0, 1, 2, 0, 2, 3], viewport: { x: (ctx, {view}) => view.x, y: 0, width: (ctx, {view}) => view.width, height: width/3 }, uniforms: { sphere: (ctx, {flat}) => 1 - flat, center: (ctx, {view}) => [view.x + view.width / 2, width / 6], radius: (ctx, {view}) => Math.min(view.width / 2, width / 6), reflectivity: (ctx, {reflectivity}) => reflectivity, light_pos: (ctx, {light_pos}) => light_pos, roughness: (ctx, {roughness}) => roughness }, frag: ` precision mediump float; uniform vec3 light_pos; uniform float reflectivity; uniform float roughness; uniform float sphere; uniform vec2 center; uniform float radius; vec3 gamma(vec3 color) { // sRGB gamma correction float exp = 1.0/2.4; if(color.r < 0.0031308) color.r *= 12.92; else color.r = 1.055 * pow(color.r, exp) - 0.055; if(color.g < 0.0031308) color.g *= 12.92; else color.g = 1.055 * pow(color.g, exp) - 0.055; if(color.b < 0.0031308) color.b *= 12.92; else color.b = 1.055 * pow(color.b, exp) - 0.055; return color; } // There are many D & G to choose from. void main () { vec3 n = vec3(0., 0., 1.); vec3 v = normalize(vec3(${width/2}, ${width/6}, light_pos.z) - vec3(gl_FragCoord.xy, 0.)); vec3 l = normalize(light_pos - vec3(gl_FragCoord.xy, 0.)); vec3 h = normalize(v+l); if(sphere > 0.) { vec3 sphere_center = vec3(0., 0., -radius); float x = gl_FragCoord.x - center.x; float y = gl_FragCoord.y - center.y; if((radius * radius - x * x - y * y) <= 0.) { gl_FragColor = vec4((vec3(${whitesmoke[0]})), 1.0); return; } vec3 pt = vec3(x, y, sqrt(radius * radius - x * x - y * y) - radius); v = normalize(vec3(0., 0., radius) - pt); n = normalize(pt - sphere_center); // For sphere, use directional light l = light_pos; h = normalize(v+l); } float alpha = roughness * roughness; float theta_v = abs(acos(dot(n,v))); float theta_l = abs(acos(dot(n,l))); float g = 1. / (1. + 0.5 * (sqrt(1. + alpha * alpha * tan(theta_v) * tan(theta_v))-1.) + 0.5 * (sqrt(1. + alpha * alpha * tan(theta_l) * tan(theta_l))-1.)); //testing g = abs(dot(n,v)) * max(0.,dot(n,l)) / (dot(n,v)*(1.-pow(alpha+1.,2.)/8.) + pow(alpha+1.,2.)/8.) / (dot(n,l)*(1.-pow(alpha+1.,2.)/8.) + pow(alpha+1.,2.)/8.); float theta_h = acos(dot(n, h)); float spec = (1. + tan(theta_h) * tan(theta_h) / alpha / alpha); float d = 1. / 3.14159 / alpha / alpha / pow(dot(n, h), 4.) / spec / spec; // testing d = alpha * alpha / (3.14159 * pow(pow(dot(n, h), 2.) * (alpha*alpha-1.) + 1., 2.)); float f = reflectivity + (1. - reflectivity) * pow(1. - dot(v, h), 5.); float c = max(0., d * g * f / 4. / abs(dot(v, n)) / abs(dot(n, l)) * dot(n, l)); gl_FragColor = vec4(gamma(vec3(c)), 1.); }`, })3c:[] 2f:{"title":"Lighting & Shading II: Materials","cells":[{"id":0,"value":"# Lighting & Shading II: Materials\n\nOur materials model describes how we capture the behavior of surfaces under lighting. As we know from radiometry, to find the radiance outgoing ${tex`L_o`} from a point ${tex`\\mathrm{p}`} in a sample direction ${tex`\\omega_o`}, we must collect all the light that is being emitted ${tex`L_e`} and reflected in that direction: ${tex`L_r`}:","pinned":false,"hidden":false,"mode":"md"},{"id":8,"value":"tex.block`L_o\\left(\\mathrm{p}, \\omega_o\\right) = L_e\\left(\\mathrm{p}, \\omega_o\\right) \n + L_r\\left(\\mathrm{p}, \\omega_o\\right) `","pinned":false,"hidden":false,"mode":"ojs"},{"id":13,"value":"Emitted light, while a \"material\" property, does not need special attention—one just adds the appropriate radiance. However, the reflected radiance is intrinsic to our material as it directly captures how incoming radiance from all directions is transformed by the object. To calculate the reflected radiance, knowing it captures the contribution of incoming radiance ${tex`L_i`} from differential direction ${tex`d\\omega`} over the object, we need a way to indicate how the energy is absorbed and reflected—we need the **bidirectional reflectance distribution function** ${tex`f_r`}.","pinned":false,"hidden":false,"mode":"md"},{"id":862,"value":"toc({\n headers: \"h2,h3,h4\",\n title: null\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":22,"value":"## The BRDF (${tex`f_r`})\n\n

The Great ${tex`\\rho\\ `} Shift

Some (older) references use ${tex`\\rho`} for the BRDF. This seems to be the convention in physics, but computer graphics papers shifted to ${tex`f_r`} sometime in the late 2000's–early 2010's where ${tex`\\rho`} shifted to represent non-angular reflectivity.\n

\n \nTo preserve energy, the (differential) amount of outgoing radiance from ${tex`\\mathrm{p}`} towards ${tex`\\omega_o`} is proportional to the amount of radiance contributed from ${tex`\\omega_i`} projected onto differential area at ${tex`\\mathrm{p}`}:","pinned":false,"hidden":false,"mode":"md"},{"id":28,"value":"tex.block`f_r(\\mathrm{p}, \\omega_o, \\omega_i) \n = \\frac{dL_o(\\mathrm{p}, \\omega_o)}\n {L_i\\left(\\mathrm{p}, \\omega_i\\right)\\left(\\mathrm{\\mathbf{n}} \\cdot \\omega_i\\right) d\\omega_i}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":26,"value":"The bidirectional reflectance distribution function (BRDF) ${tex`f_r(\\mathrm{p}, \\omega_o, \\omega_i)`} thus encapsulates how energy is reflected from a differential direction to a different direction. It can vary at every location, and can have a different response depending on **both** the incoming and outgoing direction: e.g. a mirror reflects strongest when looking *at* a reflected light *from* a direction perfectly mirrored about the mirror's normal.","pinned":false,"hidden":false,"mode":"md"},{"id":50,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":64,"value":"fig = {\n const canvas = html`