use super::environment;
use super::fields::{Field, Flow};
use super::phong::{self, LightDesc};
use super::physical::{self, Physical};
use super::toon;
use super::transmission;
use super::{Blending, MaterialKind, MeshBasicNodeMaterial, Side, ToneMapping};
use crate::lights::LightKind;
use crate::nodes::node::{Type, UniformGroup, UniformSource};
use crate::nodes::tsl::FogNode;
use crate::nodes::tsl::*;
use crate::nodes::{MaterialFlow, NodeRef};
#[derive(Clone, Debug, Default, Hash)]
#[doc(hidden)]
pub struct SetupContext {
pub environment: Option<environment::Environment>,
pub instance_count: Option<usize>,
pub instanced: bool,
pub instance_color: Option<usize>,
pub lights: Vec<LightDesc>,
pub morph: Option<crate::nodes::morph::MorphEntry>,
pub skin: Option<crate::nodes::skinning::SkinEntry>,
pub batch: Option<crate::nodes::batch::BatchEntry>,
pub sprite: bool,
pub mrt: Option<MrtContext>,
pub vertex_color_size: usize,
pub lighting_disabled: bool,
pub geometry_missing_normal: bool,
pub has_tangent_attribute: bool,
pub geometry_attributes: Vec<crate::core::AttributeDesc>,
pub viewport_opaque_mip: Option<transmission::OpaqueFrame>,
pub output: Option<OutputContext>,
pub array_cameras: usize,
pub orthographic: bool,
pub ambient_occlusion: Option<AoContext>,
#[doc(hidden)]
pub clipping: Option<std::rc::Rc<crate::nodes::clipping::ClippingContext>>,
}
impl SetupContext {
pub(crate) fn has_geometry_attribute(&self, name: &str) -> bool {
self.geometry_attributes
.iter()
.any(|desc| desc.name == name)
}
}
#[derive(Clone, Debug)]
#[doc(hidden)]
pub struct AoContext {
pub node: NodeRef,
}
impl std::hash::Hash for AoContext {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.node.key().hash(state);
}
}
#[derive(Clone, Debug)]
#[doc(hidden)]
pub struct OutputContext {
pub node: NodeRef,
}
impl std::hash::Hash for OutputContext {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.node.key().hash(state);
}
}
#[derive(Clone, Debug, Default, Hash)]
#[doc(hidden)]
pub struct MrtContext {
pub node: crate::nodes::MrtNode,
pub attachments: Vec<String>,
pub output_types: Vec<crate::nodes::Type>,
}
impl MrtContext {
pub fn for_target(
node: crate::nodes::MrtNode,
render_target: &crate::renderer::RenderTarget,
) -> Self {
Self {
node,
attachments: render_target.attachment_names(),
output_types: render_target.output_types(),
}
}
}
#[doc(hidden)]
pub fn shadow_material(source: &MeshBasicNodeMaterial) -> MeshBasicNodeMaterial {
shadow_material_for(source, crate::lights::ShadowMapType::Pcf)
}
#[doc(hidden)]
pub fn shadow_material_for(
source: &MeshBasicNodeMaterial,
shadow_type: crate::lights::ShadowMapType,
) -> MeshBasicNodeMaterial {
let mut material = MeshBasicNodeMaterial::new();
material.name = "ShadowMaterial";
material.blending = Blending::No;
material.fog = false;
material.transparent = source.transparent;
material.side = match (shadow_type.resolved(), source.side) {
(crate::lights::ShadowMapType::Vsm, side) => side,
(_, Side::Front) => Side::Back,
(_, Side::Back) => Side::Front,
(_, Side::Double) => Side::Double,
};
let cast = &source.cast_shadow_node;
material.color_node = Some(
match (&source.color_node, &source.map, &source.mask_node, cast) {
(None, None, None, None) => vec4(0.0, 0.0, 0.0, 1.0),
(color, map, _, cast) => {
let (rgb, alpha) = match cast {
Some(cast) => (cast.clone().rgb(), to_vec4(cast.clone()).w()),
None => (vec3(0.0, 0.0, 0.0), float(1.0)),
};
let alpha = match (color, map) {
(Some(color), _) => alpha.mul(to_vec4(color.clone()).w()),
(None, Some(map)) => alpha.mul(texture(map).a()),
(None, None) => alpha,
};
vec4_join(vec![rgb, alpha])
}
},
);
material.alpha_test = source.alpha_test;
material.alpha_map = source.alpha_map.clone();
material.mask_node = source.mask_node.clone();
material
}
fn material_opacity_for(material: &MeshBasicNodeMaterial) -> NodeRef {
match &material.alpha_map {
Some(map) => material_opacity().mul(texture(map)),
None => material_opacity(),
}
}
fn to_vec4(node: NodeRef) -> NodeRef {
match node.ty() {
Type::Vec4 => node,
Type::Vec3 => vec4_join(vec![node, float(1.0)]),
_ => node.to(Type::Vec4),
}
}
fn setup_diffuse_color(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fragment: &mut Vec<NodeRef>,
) {
let color = match &material.color_node {
Some(node) => to_vec4(resolve_fn_call(node)),
None => {
let base = material_color();
match &material.map {
Some(map) => base.mul(texture(map)),
None => base,
}
}
};
let color = match material.vertex_colors && material.kind != MaterialKind::Line2 {
true => color.mul(vertex_color(ctx.vertex_color_size)),
false => color,
};
let color = match ctx.instance_color {
Some(count) => instance_color(count).mul(color),
None => color,
};
let color = match ctx.batch.as_ref().and_then(|b| b.colors.as_ref()) {
Some(_) => crate::nodes::batch::batch_color().mul(color),
None => color,
};
fragment.push(diffuse_color().assign(color));
let opacity = match &material.opacity_node {
Some(node) => to_float(node.clone()),
None => material_opacity_for(material),
};
fragment.push(diffuse_color().w().assign(diffuse_color().w().mul(opacity)));
let alpha_test = match &material.alpha_test_node {
Some(node) => Some(to_float(node.clone())),
None if material.alpha_test > 0.0 => Some(material_alpha_test()),
None => None,
};
if let Some(alpha_test) = alpha_test {
fragment.push(if_then(
diffuse_color().w().less_than_equal(alpha_test),
vec![discard()],
));
}
if material.alpha_hash {
fragment.push(if_then(
diffuse_color()
.w()
.less_than(crate::nodes::alpha_hash::get_alpha_hash_threshold(
position_local(),
)),
vec![discard()],
));
}
if material.is_opaque() {
fragment.push(diffuse_color().w().assign(float(1.0)));
}
if material.kind == MaterialKind::Line2 && ctx.has_geometry_attribute("instanceStart") {
crate::materials::line2::setup_diffuse_color(
material.alpha_to_coverage,
material.world_units,
material.vertex_colors && ctx.has_geometry_attribute("instanceColorStart"),
fragment,
);
}
}
fn to_float(node: NodeRef) -> NodeRef {
match node.ty() {
Type::F32 => node,
Type::Vec2 | Type::Vec3 | Type::Vec4 => node.x(),
_ => node.to(Type::F32),
}
}
#[doc(hidden)]
pub fn setup(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fog: Option<&FogNode>,
) -> MaterialFlow {
crate::nodes::tsl::with_orthographic_camera(ctx.orthographic, || {
with_tangent_attribute(ctx.has_tangent_attribute, || {
setup_tangent(material, ctx, fog)
})
})
}
fn setup_tangent(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fog: Option<&FogNode>,
) -> MaterialFlow {
crate::nodes::tsl::with_override_nodes(material.context_overrides.as_ref(), || {
let _context = material
.context_node
.as_ref()
.map(crate::nodes::builder::push_context_value);
setup_overridden(material, ctx, fog)
})
}
fn setup_overridden(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fog: Option<&FogNode>,
) -> MaterialFlow {
let normal = with_material_side(material.side, || {
match (
&material.normal_node,
&material.normal_map,
&material.bump_map,
) {
(Some(node), _, _) => Some(node.clone()),
(None, Some(map), _) => Some(normal_map_scaled(texture(map), material_normal_scale())),
(None, None, Some(bump)) => Some(bump_map(bump, material_bump_scale())),
(None, None, None) => None,
}
});
let position_view = match material.kind {
MaterialKind::Sprite => Some(setup_position_view_sprite(material, ctx.sprite)),
MaterialKind::Points => Some(setup_position_view_points(material)),
_ => None,
};
let clearcoat_normal = with_material_side(material.side, || {
material
.clearcoat_normal_map
.as_ref()
.map(|map| normal_map_scaled(texture(map), material_clearcoat_normal_scale()))
});
let reference = |node: NodeRef| context(node, crate::nodes::node::ContextValue::new());
let metalness_value = match &material.metalness_map {
Some(map) => reference(material_metalness().mul(texture(map).z())),
None => material_metalness(),
};
let roughness_value = match &material.roughness_map {
Some(map) => reference(material_roughness().mul(texture(map).y())),
None => material_roughness(),
};
with_material_normal(normal, material.flat_shading, material.side, || {
with_clearcoat_normal(clearcoat_normal, || {
with_material_values(metalness_value, roughness_value, || {
with_material_position_view(position_view, || setup_inner(material, ctx, fog))
})
})
})
}
fn setup_inner(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fog: Option<&FogNode>,
) -> MaterialFlow {
let mut pre_vertex = Vec::new();
let mut fragment = Vec::new();
if material.kind == MaterialKind::Line2 && ctx.has_geometry_attribute("instanceStart") {
pre_vertex.push(crate::materials::line2::setup_position(
material.world_units,
));
}
if let Some(entry) = &ctx.morph {
pre_vertex.extend(crate::nodes::morph::morph_reference(entry));
}
if let Some(entry) = &ctx.skin {
pre_vertex.extend(crate::nodes::skinning::skinning(entry));
}
if let Some(node) = &material.position_node {
pre_vertex.push(position_local().assign(to_vec3(node.clone())));
}
if let Some(entry) = &ctx.batch {
pre_vertex.extend(crate::nodes::batch::batch(entry));
}
if let Some(count) = ctx.instance_count {
let matrix = instance_matrix(count);
pre_vertex.push(
position_local().assign(
matrix
.mul(vec4_join(vec![position_local(), float(1.0)]))
.xyz(),
),
);
let m3 = join(
Type::Mat3,
vec![
matrix.element(0).xyz(),
matrix.element(1).xyz(),
matrix.element(2).xyz(),
],
);
let inv_t = transpose(inverse(m3));
pre_vertex.push(normal_local().assign(inv_t.mul(normal_local()).normalize()));
}
let clipping = crate::nodes::clipping::MaterialClipping::new(
ctx.clipping.as_deref(),
material.alpha_to_coverage
&& crate::nodes::builder::current_context(|cx| cx.alpha_to_coverage_samples),
);
fragment.extend(clipping.first);
let clip_alpha = clipping.alpha;
if let Some(mask) = &material.mask_node {
fragment.push(discard_if(mask.clone()));
}
let output = if let Some(fragment_node) = &material.fragment_node {
fragment_node.clone()
} else {
match material.kind.table().flow {
Flow::Phong { specular } => {
setup_phong(material, ctx, specular, clip_alpha, &mut fragment)
}
Flow::Physical => setup_standard(material, ctx, clip_alpha, &mut fragment),
Flow::Normal => setup_normal_flow(material, ctx, clip_alpha, &mut fragment),
Flow::Unlit => setup_unlit_flow(material, ctx, clip_alpha, &mut fragment),
}
};
let output = match fog.filter(|_| material.fog) {
Some(fog) => {
fragment.push(output_property().assign(output));
let mixed = vec4_join(vec![
mix(
output_property().xyz(),
fog.color.clone(),
crate::nodes::tsl::resolve_fog_factor(&fog.factor),
),
output_property().w(),
]);
mixed
}
None => output,
};
let output = if material.premultiplied_alpha {
premultiply_alpha(output)
} else {
output
};
let mrt = ctx.mrt.as_ref().map(|context| {
let merged = match &material.mrt_node {
Some(material_mrt) => context.node.merge(material_mrt),
None => context.node.clone(),
};
merged.members(&context.attachments, &context.output_types)
});
let position = match &material.vertex_node {
Some(node) => node.clone(),
None => model_view_projection(),
};
let position = if material.kind == MaterialKind::Points && ctx.sprite {
setup_vertex_sprite(material, position)
} else {
position
};
let material_output = material
.output_node
.as_ref()
.map(crate::nodes::tsl::resolve_fn_call);
let (mrt, material_output) = match material_output {
Some(node) => match node.node() {
crate::nodes::Node::OutputStruct { members } => (
Some(members.iter().map(|m| (m.clone(), m.ty())).collect()),
None,
),
_ => (mrt, Some(node)),
},
None => (mrt, None),
};
let (output_assign, output_node) = match &ctx.output {
Some(context) => (
Some(material_output.unwrap_or_else(|| output.clone())),
Some(context.node.clone()),
),
None => (None, material_output),
};
MaterialFlow {
pre_vertex_statements: pre_vertex,
depth: material
.depth_node
.clone()
.filter(|_| material.depth_write || material.depth_test),
fragment_statements: fragment,
output,
output_assign,
output_node,
mrt,
emit_output_property: material.fragment_node.is_none(),
vertex_statements: clipping.hardware.iter().map(|(l, _)| l.clone()).collect(),
position,
geometry_has_tangent: ctx.has_tangent_attribute,
geometry_attributes: ctx.geometry_attributes.clone(),
clip_distances: clipping.hardware.map_or(0, |(_, count)| count),
}
}
fn to_vec3(node: NodeRef) -> NodeRef {
match node.ty() {
Type::Vec3 => node,
Type::Vec4 => node.xyz(),
_ => node.to(Type::Vec3),
}
}
fn to_vec2(node: NodeRef) -> NodeRef {
match node.ty() {
Type::Vec2 => node,
Type::Vec3 | Type::Vec4 => node.xy(),
_ => node.to(Type::Vec2),
}
}
fn setup_position_view_sprite(material: &MeshBasicNodeMaterial, has_center: bool) -> NodeRef {
let position = match &material.position_node {
Some(node) => to_vec3(node.clone()),
None => vec3(0.0, 0.0, 0.0),
};
let mv_position = model_view_matrix().mul(position);
let mut scale = join(
Type::Vec2,
vec![
length(model_world_matrix().element(0).xyz()),
length(model_world_matrix().element(1).xyz()),
],
);
if let Some(scale_node) = &material.scale_node {
scale = scale.mul(to_vec2(scale_node.clone()));
}
if !material.size_attenuation {
scale = scale.mul(mv_position.z().negate());
}
let mut aligned = position_geometry().xy();
if has_center {
let center = uniform(
UniformSource::ObjectCenter,
Type::Vec2,
UniformGroup::Object,
None,
);
aligned = aligned.sub(center.sub(0.5));
}
let aligned = aligned.mul(scale);
let rotation = match &material.rotation_node {
Some(node) => node.clone(),
None => material_rotation(),
};
join(
Type::Vec4,
vec![
mv_position.xy().add(rotate(aligned, rotation)),
mv_position.zw(),
],
)
}
fn setup_vertex_sprite(material: &MeshBasicNodeMaterial, mvp: NodeRef) -> NodeRef {
let size = match &material.size_node {
Some(node) => to_vec2(node.clone()),
None => vec2(1.0, 1.0),
};
let mut point_size = size.mul(to_vec2(screen_dpr()));
if let Some(scale) = &material.scale_node {
point_size = point_size.mul(to_vec2(scale.clone()));
}
let mut offset = position_geometry().xy();
if let Some(rotation) = &material.rotation_node {
offset = rotate(offset, rotation.clone());
}
let offset = offset
.mul(point_size)
.div(viewport().zw().div(vec2(2.0, 2.0)))
.mul(to_vec2(mvp.w()));
mvp.add(vec4_join(vec![offset, float(0.0), float(0.0)]))
}
fn setup_position_view_points(material: &MeshBasicNodeMaterial) -> NodeRef {
let position = match &material.position_node {
Some(node) => to_vec3(node.clone()),
None => position_local(),
};
model_view_matrix()
.mul(vec4_join(vec![position, float(1.0)]))
.xyz()
}
#[doc(hidden)]
pub fn background_color_node(map: &crate::textures::CubeTexture) -> NodeRef {
let dir = material_env_rotation()
.mul(background_rotation().mul(vec4_join(vec![normal_world_geometry(), float(1.0)])));
let sample = cube_texture_level(map, dir, background_blurriness());
sample.mul(background_intensity())
}
#[doc(hidden)]
pub fn background_pmrem_color_node(pmrem: &crate::materials::environment::PmremHandle) -> NodeRef {
let uv = background_rotation().mul(vec4_join(vec![normal_world_geometry(), float(1.0)]));
background_node_color_node(pmrem.sample(uv, background_blurriness()))
}
#[doc(hidden)]
pub fn background_environment_color_node(
node: &crate::materials::environment::EnvironmentNode,
) -> NodeRef {
let uv = background_rotation().mul(vec4_join(vec![normal_world_geometry(), float(1.0)]));
background_node_color_node(node.sample(uv, background_blurriness()))
}
#[doc(hidden)]
pub fn background_node_color_node(node: NodeRef) -> NodeRef {
if let crate::nodes::Node::Call { def, args } = node.node() {
if !def.layout && args.is_empty() {
let deferred = node.clone();
return call(
&inline_fn(0, Type::Vec4, move |_| {
background_node_color_node(resolve_fn_call(&deferred))
}),
Vec::new(),
);
}
}
let color = match node.ty() {
Type::Vec4 => node,
_ => vec4_join(vec![node, float(1.0)]),
};
color.mul(background_intensity())
}
#[doc(hidden)]
pub fn background_vertex_node() -> NodeRef {
let is_ortho = camera_projection_matrix()
.element(3)
.element(3)
.equal(float(1.0));
let ortho_scale = float(1.0)
.div(camera_projection_matrix().element(1).element(1))
.mul(float(3.0));
let modified = is_ortho.select(position_local().mul(ortho_scale), position_local());
let view_position = model_view_matrix().mul(vec4_join(vec![modified, float(0.0)]));
let view_proj =
camera_projection_matrix().mul(vec4_join(vec![view_position.xyz(), float(1.0)]));
view_proj.set_z(view_proj.w())
}
#[doc(hidden)]
pub fn quad_vertex_node() -> NodeRef {
let x = const_array(vec![-1.0, -1.0, 3.0]).element_node(vertex_index());
let y = const_array(vec![3.0, -1.0, -1.0]).element_node(vertex_index());
join(Type::Vec4, vec![x, y, float(0.0), float(1.0)])
}
pub fn instanced_range(
min: impl Into<crate::nodes::tsl::RangeValue>,
max: impl Into<crate::nodes::tsl::RangeValue>,
count: usize,
) -> NodeRef {
crate::nodes::tsl::instanced_range(min, max, count)
}
#[doc(hidden)]
pub fn output_fragment_node(
framebuffer: &crate::textures::Texture,
tone_mapping: ToneMapping,
) -> NodeRef {
let coord = frag_coord().xy().div(viewport_size());
let color = texture_uv(framebuffer, coord);
render_output(color, tone_mapping)
}
pub fn render_output(color: NodeRef, tone_mapping: ToneMapping) -> NodeRef {
let clamped = vec4_join(vec![color.rgb(), color.a().clamp(float(0.0), float(1.0))]);
let unpremultiplied = unpremultiply_alpha(clamped);
let mapped = tone_mapping_node(tone_mapping, tone_mapping_exposure(), unpremultiplied);
let encoded = vec4_join(vec![srgb_transfer_oetf(mapped.clone().rgb()), mapped.a()]);
premultiply_alpha(encoded)
}
pub fn tone_mapping_node(mode: ToneMapping, exposure: NodeRef, color: NodeRef) -> NodeRef {
match mode {
ToneMapping::None => color,
ToneMapping::Linear => vec4_join(vec![
linear_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
ToneMapping::Reinhard => vec4_join(vec![
reinhard_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
ToneMapping::AcesFilmic => vec4_join(vec![
aces_filmic_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
ToneMapping::Neutral => vec4_join(vec![
neutral_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
ToneMapping::AgX => vec4_join(vec![
agx_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
ToneMapping::Cineon => vec4_join(vec![
cineon_tone_mapping(color.clone().rgb(), exposure),
color.a(),
]),
}
}
#[inline(never)]
fn setup_normal_flow(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
clip_alpha: Vec<NodeRef>,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
let opacity = match &material.opacity_node {
Some(node) => to_float(node.clone()),
None => material_opacity_for(material),
};
fragment.push(diffuse_color().assign(srgb_to_working(vec4_join(vec![
pack_normal_to_rgb(normal_view()),
opacity,
]))));
setup_ambient_occlusion(material, ctx, fragment);
fragment.extend(clip_alpha);
vec4_join(vec![diffuse_color().xyz(), diffuse_color().w()]).max(float(0.0))
}
#[inline(never)]
fn setup_unlit_flow(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
clip_alpha: Vec<NodeRef>,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
setup_diffuse_color(material, ctx, fragment);
let has_ao = setup_ambient_occlusion(material, ctx, fragment);
let basic_ao = has_ao && material.kind == MaterialKind::Basic && !ctx.lighting_disabled;
let basic_env_map = material
.env_map
.as_ref()
.filter(|_| material.kind.table().reads(Field::EnvMap));
let custom_lighting = material.lighting_model.as_ref().and_then(|model| {
let lights = (material.lights && !ctx.lighting_disabled) || material.lights_node.is_some();
let list = material_lights(material, ctx);
(lights && !list.is_empty()).then_some((model, list))
});
let basic_lit = !ctx.lighting_disabled && !material_lights(material, ctx).is_empty();
let outgoing = if let Some((model, lights)) = custom_lighting {
crate::materials::lighting_model::lights_node(
model.as_ref(),
&lights,
material.received_shadow_position_node.as_ref(),
&|base| backdrop_blend(material, base),
fragment,
)
} else if basic_env_map.is_some() || basic_ao || (material.backdrop_node.is_some() && basic_lit)
{
if basic_ao {
ao_lighting_node(fragment);
}
fragment.push(indirect_diffuse().assign(vec4(0.0, 0.0, 0.0, 0.0).xyz()));
fragment.push(
indirect_diffuse().assign(
vec4_join(vec![indirect_diffuse(), float(1.0)])
.add(vec4(1.0, 1.0, 1.0, 0.0))
.xyz(),
),
);
fragment.push(indirect_diffuse().assign(indirect_diffuse().mul(ambient_occlusion())));
fragment.push(indirect_diffuse().assign(indirect_diffuse().mul(diffuse_color().xyz())));
fragment.push(total_diffuse().assign(backdrop_blend(
material,
direct_diffuse().add(indirect_diffuse()),
)));
fragment.push(total_specular().assign(direct_specular().add(indirect_specular())));
fragment.push(outgoing_light().assign(total_diffuse().add(total_specular())));
if let Some(env_map) = basic_env_map {
let dir = material_env_rotation().mul(vec4_join(vec![reflect_vector(), float(1.0)]));
let env = cube_texture(env_map, dir);
fragment.push(outgoing_light().assign(mix(
outgoing_light(),
outgoing_light().mul(env.xyz()),
float(1.0).mul(material_reflectivity()),
)));
}
outgoing_light()
} else {
backdrop_blend(material, diffuse_color().xyz())
};
let outgoing = match &material.emissive_node {
Some(node) => {
fragment.push(emissive_color().assign(to_vec3(node.clone())));
outgoing.add(emissive_color())
}
None => outgoing,
};
fragment.extend(clip_alpha);
vec4_join(vec![outgoing, diffuse_color().w()]).max(float(0.0))
}
fn setup_phong(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
specular: bool,
clip_alpha: Vec<NodeRef>,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
setup_diffuse_color(material, ctx, fragment);
let has_ao = setup_ambient_occlusion(material, ctx, fragment);
if specular {
fragment.push(shininess().assign(max(material_shininess(), float(0.0001))));
let specular_value = match &material.specular_node {
Some(node) => node.clone().xyz(),
None => material_specular(),
};
fragment.push(specular_color().assign(specular_value));
}
fragment.push(emissive_color().assign(material_emissive_value(material)));
fragment.extend(clip_alpha);
let outgoing = if material.lights {
let lights = material_lights(material, ctx);
let ambient: Vec<usize> = lights
.iter()
.filter(|light| light.kind == LightKind::Ambient)
.map(|light| light.index)
.collect();
if !ambient.is_empty() {
phong::ambient_lights(&ambient, fragment);
}
for light in &lights {
if light.kind == LightKind::Ambient {
continue;
}
if material.kind == MaterialKind::Toon {
toon::direct_light(
light,
material.received_shadow_position_node.as_ref(),
material.gradient_map.as_ref(),
fragment,
);
} else {
phong::direct_light(
light,
material.received_shadow_position_node.as_ref(),
specular,
fragment,
);
}
}
if has_ao && !ctx.lighting_disabled {
ao_lighting_node(fragment);
}
fragment.push(
indirect_diffuse().assign(
vec4_join(vec![indirect_diffuse(), float(1.0)])
.add(
vec4_join(vec![irradiance(), float(1.0)])
.mul(diffuse_color().mul(phong::RECIPROCAL_PI)),
)
.xyz(),
),
);
fragment.push(indirect_diffuse().assign(indirect_diffuse().mul(ambient_occlusion())));
fragment.push(total_diffuse().assign(backdrop_blend(
material,
direct_diffuse().add(indirect_diffuse()),
)));
fragment.push(total_specular().assign(direct_specular().add(indirect_specular())));
fragment.push(outgoing_light().assign(total_diffuse().add(total_specular())));
outgoing_light()
} else {
diffuse_color().xyz()
};
vec4_join(vec![outgoing.add(emissive_color()), diffuse_color().w()]).max(float(0.0))
}
fn backdrop_blend(material: &MeshBasicNodeMaterial, base: NodeRef) -> NodeRef {
let Some(backdrop) = &material.backdrop_node else {
return base;
};
let blended = match &material.backdrop_alpha_node {
Some(alpha) if backdrop.ty().components() == 4 => mix(
vec4_join(vec![base, float(1.0)]),
backdrop.clone(),
alpha.clone(),
),
Some(alpha) => mix(base, backdrop.clone(), alpha.clone()),
None => backdrop.clone(),
};
to_vec3(blended)
}
fn material_lights(material: &MeshBasicNodeMaterial, ctx: &SetupContext) -> Vec<LightDesc> {
match &material.lights_node {
Some(subset) => ctx
.lights
.iter()
.filter(|light| subset.contains(&light.index))
.cloned()
.collect(),
None => ctx.lights.clone(),
}
}
fn setup_ambient_occlusion(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
fragment: &mut Vec<NodeRef>,
) -> bool {
let map_ao = material.ao_map.as_ref().map(|_| material_ao(material));
let context_ao = ctx
.ambient_occlusion
.as_ref()
.filter(|_| !material.transparent)
.map(|ao| ao.node.clone());
let ao_node = match (map_ao, context_ao) {
(Some(map_ao), Some(context_ao)) => map_ao.mul(context_ao),
(Some(ao), None) | (None, Some(ao)) => ao,
(None, None) => return false,
};
fragment.push(ambient_occlusion_property().assign(ao_node));
true
}
fn ao_lighting_node(fragment: &mut Vec<NodeRef>) {
fragment
.push(ambient_occlusion().assign(ambient_occlusion().mul(ambient_occlusion_property())));
}
fn material_emissive_value(material: &MeshBasicNodeMaterial) -> NodeRef {
if let Some(node) = &material.emissive_node {
return to_vec3(node.clone());
}
let emissive = material_emissive().mul(material_emissive_intensity());
match &material.emissive_map {
Some(map) => vec4_join(vec![emissive, float(1.0)])
.mul(texture(map))
.xyz(),
None => emissive,
}
}
fn setup_standard(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
clip_alpha: Vec<NodeRef>,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
setup_diffuse_color(material, ctx, fragment);
let has_ao = setup_ambient_occlusion(material, ctx, fragment);
let metalness_node = match &material.metalness_node {
Some(node) => node.to_float(),
None => material_metalness_value(),
};
fragment.push(metalness().assign(metalness_node.clone()));
let roughness_node = match &material.roughness_node {
Some(node) => node.to_float(),
None => material_roughness_value(),
};
fragment.push(roughness().assign(physical::get_roughness(
roughness_node,
!ctx.geometry_missing_normal,
)));
let table = material.kind.table();
if table.reads(Field::Ior) {
fragment.push(ior().assign(material_ior()));
let f0 = to_var(None, ior().sub(float(1.0)).div(ior().add(float(1.0))));
let specular = match &material.specular_color_map {
Some(map) => material_specular_color().mul(texture(map).xyz()),
None => material_specular_color(),
};
fragment.push(
specular_color().assign(
f0.clone()
.mul(f0)
.mul(specular)
.min(vec3(1.0, 1.0, 1.0))
.mul(material_specular_intensity()),
),
);
fragment.push(specular_color_blended().assign(mix(
specular_color(),
diffuse_color().xyz(),
metalness(),
)));
fragment.push(specular_f90().assign(mix(
material_specular_intensity(),
float(1.0),
metalness(),
)));
} else {
fragment.push(specular_color().assign(vec3(0.04, 0.04, 0.04)));
fragment.push(specular_color_blended().assign(mix(
vec3(0.04, 0.04, 0.04),
diffuse_color().rgb(),
metalness(),
)));
fragment.push(specular_f90().assign(float(1.0)));
}
fragment
.push(diffuse_contribution().assign(diffuse_color().rgb().mul(metalness_node.one_minus())));
let use_diffuse_roughness =
table.reads(Field::DiffuseRoughness) && material.diffuse_roughness > 0.0;
if use_diffuse_roughness {
fragment.push(diffuse_roughness().assign(material_diffuse_roughness().clamp(0.0, 1.0)));
}
let use_clearcoat = table.reads(Field::Clearcoat) && material.clearcoat > 0.0;
let use_anisotropy = table.reads(Field::Anisotropy) && material.anisotropy > 0.0;
if use_clearcoat {
let clearcoat_value = match &material.clearcoat_map {
Some(map) => material_clearcoat().mul(texture(map).x()),
None => material_clearcoat(),
};
let clearcoat_roughness_value = match &material.clearcoat_roughness_map {
Some(map) => material_clearcoat_roughness().mul(texture(map).y()),
None => material_clearcoat_roughness(),
};
fragment.push(clearcoat().assign(clearcoat_value));
fragment.push(clearcoat_roughness().assign(physical::get_roughness(
clearcoat_roughness_value,
!ctx.geometry_missing_normal,
)));
}
let use_sheen = table.reads(Field::Sheen) && material.sheen > 0.0;
if use_sheen {
fragment.push(sheen().assign(material_sheen_color().mul(material_sheen())));
fragment.push(sheen_roughness().assign(material_sheen_roughness().clamp(0.0001, 1.0)));
}
let use_iridescence = table.reads(Field::Iridescence) && material.iridescence > 0.0;
if use_iridescence {
fragment.push(iridescence().assign(material_iridescence()));
fragment.push(iridescence_ior().assign(material_iridescence_ior()));
let thickness_value = match &material.iridescence_thickness_map {
Some(map) => {
let minimum = material_iridescence_thickness_min();
material_iridescence_thickness_max()
.sub(minimum.clone())
.mul(texture(map).y())
.add(minimum)
}
None => material_iridescence_thickness_max(),
};
fragment.push(iridescence_thickness().assign(thickness_value));
}
if use_anisotropy {
let anisotropy_v = to_var(None, material_anisotropy(material));
fragment.push(anisotropy().assign(length(anisotropy_v.clone())));
fragment.push(if_else(
anisotropy().equal(float(0.0)),
vec![anisotropy_v.assign(vec2(1.0, 0.0))],
vec![
anisotropy_v.assign(anisotropy_v.div(anisotropy())),
anisotropy().assign(anisotropy().clamp(0.0, 1.0)),
],
));
fragment.push(alpha_t().assign(mix(
roughness().mul(roughness()),
float(1.0),
anisotropy().mul(anisotropy()),
)));
fragment.push(
anisotropy_t().assign(
tbn_view_matrix()
.element(0)
.mul(anisotropy_v.clone().x())
.add(tbn_view_matrix().element(1).mul(anisotropy_v.clone().y())),
),
);
fragment.push(
anisotropy_b().assign(
tbn_view_matrix()
.element(1)
.mul(anisotropy_v.clone().x())
.sub(tbn_view_matrix().element(0).mul(anisotropy_v.y())),
),
);
}
let opaque_frame = if table.reads(Field::Transmission) && material.transmission > 0.0 {
ctx.viewport_opaque_mip.as_ref()
} else {
None
};
if opaque_frame.is_some() {
let transmission_value = match &material.transmission_map {
Some(map) => material_transmission().mul(texture(map).x()),
None => material_transmission(),
};
fragment.push(transmission().assign(transmission_value));
let thickness_value = match &material.thickness_map {
Some(map) => material_thickness().mul(texture(map).y()),
None => material_thickness(),
};
fragment.push(thickness().assign(thickness_value));
fragment.push(attenuation_distance().assign(material_attenuation_distance()));
fragment.push(attenuation_color().assign(material_attenuation_color()));
}
fragment.push(emissive_color().assign(material_emissive_value(material)));
fragment.extend(clip_alpha);
let scene_lighting = material.lights && !ctx.lighting_disabled;
let material_environment = material
.pmrem_env
.clone()
.map(environment::Environment::Pmrem);
let environment = material_environment
.as_ref()
.or(ctx.environment.as_ref())
.filter(|_| scene_lighting);
let lights = if scene_lighting {
material_lights(material, ctx)
} else {
Vec::new()
};
let outgoing = if scene_lighting && (environment.is_some() || has_ao || !lights.is_empty()) {
let model = Physical::start(
use_sheen,
use_clearcoat,
use_diffuse_roughness,
use_iridescence,
opaque_frame,
fragment,
);
fragment.push(direct_diffuse());
fragment.push(direct_specular());
fragment.push(irradiance());
fragment.push(indirect_diffuse());
fragment.push(indirect_specular());
for light in &lights {
physical::direct_light(
&model,
light,
material.received_shadow_position_node.as_ref(),
fragment,
);
}
model.indirect_diffuse(fragment);
if let Some(environment) = environment {
environment::setup(environment, use_anisotropy, use_clearcoat, fragment);
}
if has_ao {
ao_lighting_node(fragment);
}
model.indirect_specular(
environment.is_some(),
material.environment_specular,
fragment,
);
model.ambient_occlusion(has_ao, fragment);
let direct_plus_indirect = direct_diffuse().add(indirect_diffuse());
let total = if model.backdrop.is_some() {
model.total_diffuse(direct_plus_indirect)
} else {
backdrop_blend(material, direct_plus_indirect)
};
fragment.push(total_diffuse().assign(total));
fragment.push(total_specular().assign(direct_specular().add(indirect_specular())));
fragment.push(outgoing_light().assign(total_diffuse().add(total_specular())));
model.finish(fragment);
outgoing_light()
} else {
diffuse_color().xyz()
};
vec4_join(vec![outgoing.add(emissive_color()), diffuse_color().w()]).max(float(0.0))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::math::Color;
use crate::nodes::NodeBuilder;
use crate::renderer::RenderTarget;
use crate::textures::Texture;
fn ao_context() -> AoContext {
let target = RenderTarget::new(16, 16);
target.texture().set_format(wgpu::TextureFormat::R8Unorm);
AoContext {
node: texture_uv(&target.texture(), screen_uv()).x(),
}
}
fn lit(ambient_occlusion: Option<AoContext>) -> SetupContext {
SetupContext {
lights: vec![LightDesc {
index: 0,
kind: LightKind::Directional,
shadow_map: None,
}],
ambient_occlusion,
..SetupContext::default()
}
}
fn fragment(material: &MeshBasicNodeMaterial, ctx: &SetupContext) -> String {
NodeBuilder::new()
.build(&setup(material, ctx, None))
.fragment_wgsl
}
fn standard() -> MeshBasicNodeMaterial {
MeshBasicNodeMaterial::standard(Color::from_hex(0xe0d8d0), 0.9, 0.0)
}
const AO_LIGHTING: &str = "ambientOcclusion = ( ambientOcclusion * AmbientOcclusion );";
fn lines(wgsl: &str) -> Vec<&str> {
wgsl.lines().map(str::trim).collect()
}
fn position(lines: &[&str], needle: &str) -> usize {
lines
.iter()
.position(|line| line.contains(needle))
.unwrap_or_else(|| panic!("no line contains {needle:?}"))
}
#[test]
fn builtin_ao_context_occludes_a_standard_material() {
let wgsl = fragment(&standard(), &lit(Some(ao_context())));
let body = lines(&wgsl);
let alpha = position(&body, "DiffuseColor.w = 1.0;");
let tap = position(&body, "( fragCoord.xy / render.");
assert!(
body[tap].starts_with("nodeVar0 = textureSample( "),
"{wgsl}"
);
assert_eq!(tap, alpha + 1, "{wgsl}");
assert!(
body[tap + 1].starts_with("AmbientOcclusion = nodeVar0"),
"{wgsl}"
);
let ao = position(&body, AO_LIGHTING);
assert_eq!(body[ao - 1], "ambientOcclusion = 1.0;", "{wgsl}");
let indirect = position(
&body,
"indirectDiffuse = ( indirectDiffuse * vec3<f32>( ambientOcclusion ) );",
);
assert!(ao < indirect, "{wgsl}");
assert_eq!(wgsl.matches("ambientOcclusion = 1.0;").count(), 1, "{wgsl}");
}
#[test]
fn builtin_ao_context_skips_transparent_materials() {
let mut material = standard();
material.transparent = true;
let wgsl = fragment(&material, &lit(Some(ao_context())));
assert!(!wgsl.contains("AmbientOcclusion = "), "{wgsl}");
assert!(!wgsl.contains(AO_LIGHTING), "{wgsl}");
assert!(!wgsl.contains("fragCoord.xy / render."), "{wgsl}");
assert_eq!(wgsl, fragment(&material, &lit(None)));
}
#[test]
fn builtin_ao_context_multiplies_into_an_ao_map() {
let mut material = standard();
material.ao_map = Some(Texture::new(4, 4, None));
let map_only = fragment(&material, &lit(None));
assert!(
map_only.contains("AmbientOcclusion = ( ( ( nodeVar0.x - 1.0 ) * object."),
"{map_only}"
);
assert!(map_only.contains(AO_LIGHTING), "{map_only}");
assert!(!map_only.contains("fragCoord.xy / render."), "{map_only}");
let both = fragment(&material, &lit(Some(ao_context())));
let line = lines(&both)
.into_iter()
.find(|line| line.starts_with("AmbientOcclusion = "))
.expect("AmbientOcclusion is assigned")
.to_owned();
assert!(
line.contains("* object.") && line.contains(") * nodeVar"),
"{line}"
);
assert!(both.contains(AO_LIGHTING), "{both}");
material.transparent = true;
let transparent = fragment(&material, &lit(Some(ao_context())));
assert_eq!(transparent, fragment(&material, &lit(None)));
}
#[test]
fn builtin_ao_context_occludes_phong_and_basic() {
let phong = MeshBasicNodeMaterial::phong(Color::from_hex(0x808080));
let wgsl = fragment(&phong, &lit(Some(ao_context())));
let body = lines(&wgsl);
let ao = position(&body, AO_LIGHTING);
let indirect = position(
&body,
"indirectDiffuse = ( indirectDiffuse * vec3<f32>( ambientOcclusion ) );",
);
assert!(
position(&body, "AmbientOcclusion = nodeVar") < ao && ao < indirect,
"{wgsl}"
);
let basic = MeshBasicNodeMaterial::new();
let wgsl = fragment(
&basic,
&SetupContext {
ambient_occlusion: Some(ao_context()),
..SetupContext::default()
},
);
assert!(wgsl.contains(AO_LIGHTING), "{wgsl}");
assert!(
wgsl.contains("indirectDiffuse = ( indirectDiffuse * vec3<f32>( ambientOcclusion ) );"),
"{wgsl}"
);
assert!(!fragment(&basic, &SetupContext::default()).contains("ambientOcclusion"));
}
#[test]
fn builtin_ao_context_is_part_of_the_cache_key() {
use std::hash::{BuildHasher, RandomState};
let hasher = RandomState::new();
let ao = ao_context();
let with = hasher.hash_one(lit(Some(ao.clone())));
assert_eq!(with, hasher.hash_one(lit(Some(ao.clone()))));
assert_ne!(with, hasher.hash_one(lit(None)));
assert_ne!(with, hasher.hash_one(lit(Some(ao_context()))));
drop(ao);
}
#[test]
fn env_map_is_sampled_by_basic_only() {
use crate::nodes::builder::BindingDesc;
use crate::nodes::node::TextureSource;
use crate::textures::{CubeTexture, Image};
let cube = CubeTexture::new(
(0..6)
.map(|_| Image::rgba8(1, 1, vec![255, 255, 255, 255]))
.collect(),
);
let binds_cube = |material: &MeshBasicNodeMaterial| {
let program =
NodeBuilder::new().build(&setup(material, &SetupContext::default(), None));
let bound = program.groups.iter().flatten().any(|binding| {
matches!(
binding,
BindingDesc::Texture {
source: TextureSource::Cube(_),
..
}
)
});
(bound, program.fragment_wgsl)
};
let mut basic = MeshBasicNodeMaterial::new();
basic.env_map = Some(cube.clone());
let (bound, wgsl) = binds_cube(&basic);
assert!(bound && wgsl.contains("texture_cube"), "{wgsl}");
for mut material in [
MeshBasicNodeMaterial::sprite(),
MeshBasicNodeMaterial::points(),
MeshBasicNodeMaterial::line2(Color::from_hex(0xffffff)),
] {
material.env_map = Some(cube.clone());
let kind = material.kind;
let (bound, wgsl) = binds_cube(&material);
assert!(!bound, "{kind:?} binds the env map");
assert!(!wgsl.contains("texture_cube"), "{kind:?}:\n{wgsl}");
assert!(!wgsl.contains("Reflectivity"), "{kind:?}:\n{wgsl}");
assert_eq!(material.unsupported_fields(), ["envMap"]);
material.env_map = None;
assert_eq!(wgsl, binds_cube(&material).1, "{kind:?}");
}
}
}