use super::environment;
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 line_segments: Option<crate::nodes::lines::LineSegmentsAttributes>,
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 instanced_attributes: Vec<String>,
pub viewport_opaque_mip: Option<transmission::OpaqueFrame>,
pub output: Option<OutputContext>,
pub array_cameras: usize,
}
#[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>,
}
#[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(node.clone()),
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 {
if let Some(attributes) = &ctx.line_segments {
crate::materials::line2::setup_diffuse_color(
material.alpha_to_coverage,
material.world_units,
material.vertex_colors,
attributes,
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 {
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(), || {
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()))
});
with_material_normal(normal, material.flat_shading, material.side, || {
with_clearcoat_normal(clearcoat_normal, || {
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 {
if let Some(attributes) = &ctx.line_segments {
pre_vertex.push(crate::materials::line2::setup_position(
attributes,
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()));
}
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 if material.kind == MaterialKind::Phong {
setup_phong(material, ctx, true, &mut fragment)
} else if material.kind == MaterialKind::Lambert || material.kind == MaterialKind::Toon {
setup_phong(material, ctx, false, &mut fragment)
} else if material.kind == MaterialKind::Standard || material.kind == MaterialKind::Physical {
setup_standard(material, ctx, &mut fragment)
} else if material.kind == MaterialKind::Normal {
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,
]))));
vec4_join(vec![diffuse_color().xyz(), diffuse_color().w()]).max(float(0.0))
} else {
setup_diffuse_color(material, ctx, &mut fragment);
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 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(),
&mut fragment,
)
} else if let Some(env_map) = &material.env_map {
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(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())));
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 {
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,
};
vec4_join(vec![outgoing, diffuse_color().w()]).max(float(0.0))
};
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)
});
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 (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: Vec::new(),
position,
}
}
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 {
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(),
]),
}
}
fn setup_phong(
material: &MeshBasicNodeMaterial,
ctx: &SetupContext,
specular: bool,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
setup_diffuse_color(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)));
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);
}
fragment.push(direct_diffuse().assign(vec3(0.0, 0.0, 0.0)));
if specular {
fragment.push(direct_specular().assign(vec3(0.0, 0.0, 0.0)));
}
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,
);
}
}
fragment.push(indirect_diffuse().assign(vec3(0.0, 0.0, 0.0)));
if ambient.is_empty() {
fragment.push(irradiance().assign(vec3(0.0, 0.0, 0.0)));
}
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(direct_diffuse().add(indirect_diffuse())));
if !specular {
fragment.push(direct_specular().assign(vec3(0.0, 0.0, 0.0)));
fragment.push(indirect_specular().assign(vec3(0.0, 0.0, 0.0)));
}
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 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, fragment: &mut Vec<NodeRef>) {
let Some(map) = &material.ao_map else {
return;
};
fragment.push(
ambient_occlusion_property().assign(
texture(map)
.x()
.sub(float(1.0))
.mul(material_ao_map_intensity())
.add(float(1.0)),
),
);
}
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,
fragment: &mut Vec<NodeRef>,
) -> NodeRef {
setup_diffuse_color(material, ctx, fragment);
setup_ambient_occlusion(material, fragment);
let metalness_node = match (&material.metalness_node, &material.metalness_map) {
(Some(node), _) => node.to_float(),
(None, Some(map)) => material_metalness().mul(texture(map).z()),
(None, None) => material_metalness(),
};
fragment.push(metalness().assign(metalness_node.clone()));
let roughness_node = match (&material.roughness_node, &material.roughness_map) {
(Some(node), _) => node.to_float(),
(None, Some(map)) => material_roughness().mul(texture(map).y()),
(None, None) => material_roughness(),
};
fragment.push(roughness().assign(physical::get_roughness(
roughness_node,
!ctx.geometry_missing_normal,
)));
if material.kind == MaterialKind::Physical {
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 =
material.kind == MaterialKind::Physical && 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 = material.kind == MaterialKind::Physical && material.clearcoat > 0.0;
let use_anisotropy = material.kind == MaterialKind::Physical && 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 = material.kind == MaterialKind::Physical && 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)));
}
if use_anisotropy {
let anisotropy_v = match &material.anisotropy_map {
Some(map) => {
let polar = texture(map);
let v = material_anisotropy_vector();
let rotation = join(
Type::Mat2,
vec![v.clone().x(), v.clone().y(), v.clone().y().negate(), v.x()],
);
rotation.mul(
polar
.clone()
.xy()
.mul(2.0)
.sub(vec2(1.0, 1.0))
.normalize()
.mul(polar.z()),
)
}
None => material_anisotropy_vector(),
};
let anisotropy_v = to_var(None, anisotropy_v);
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 material.kind == MaterialKind::Physical && material.transmission > 0.0 {
ctx.viewport_opaque_mip.as_ref()
} else {
None
};
if opaque_frame.is_some() {
fragment.push(transmission().assign(material_transmission()));
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)));
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() || !lights.is_empty()) {
let model = Physical::start(
use_sheen,
use_clearcoat,
use_diffuse_roughness,
opaque_frame,
fragment,
);
fragment.push(direct_diffuse().assign(vec3(0.0, 0.0, 0.0)));
fragment.push(direct_specular().assign(vec3(0.0, 0.0, 0.0)));
fragment.push(irradiance().assign(vec3(0.0, 0.0, 0.0)));
fragment.push(indirect_diffuse().assign(vec3(0.0, 0.0, 0.0)));
fragment.push(indirect_specular().assign(vec3(0.0, 0.0, 0.0)));
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 material.ao_map.is_some() {
fragment.push(
ambient_occlusion().assign(ambient_occlusion().mul(ambient_occlusion_property())),
);
}
model.indirect_specular(environment.is_some(), fragment);
model.ambient_occlusion(material.ao_map.is_some(), fragment);
fragment.push(
total_diffuse().assign(model.total_diffuse(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())));
model.finish(fragment);
outgoing_light()
} else {
diffuse_color().xyz()
};
vec4_join(vec![outgoing.add(emissive_color()), diffuse_color().w()]).max(float(0.0))
}