mod atmosphere;
mod basic;
mod depth;
mod lambert;
mod line;
mod matcap;
mod normal_mat;
mod phong;
mod physical;
mod points_mat;
pub mod presets;
pub(crate) mod shader_material;
pub mod shared_passes;
pub mod shared_shader;
mod sprite_mat;
mod standard;
mod toon;
pub(crate) fn env_lookup_rows(rotation: crate::math::Euler) -> [[f32; 4]; 3] {
let e = crate::math::Euler {
x: -rotation.x,
..rotation
};
let m = crate::math::Matrix4::from_quaternion(crate::math::Quaternion::from_euler(e)).elements;
std::array::from_fn(|r| [-m[r], m[4 + r], m[8 + r], 0.0])
}
pub(crate) fn pmrem_lookup_rows(rotation: crate::math::Euler) -> [[f32; 4]; 3] {
let e = crate::math::Euler {
x: -rotation.x,
y: -rotation.y,
z: -rotation.z,
..rotation
};
let m = crate::math::Matrix4::from_quaternion(crate::math::Quaternion::from_euler(e)).elements;
std::array::from_fn(|r| [m[r], m[4 + r], m[8 + r], 0.0])
}
pub fn environment_lookup_rows(rotation: crate::math::Euler, raw_cube: bool) -> [[f32; 4]; 3] {
let mut rows = pmrem_lookup_rows(rotation);
if raw_cube {
rows[0] = rows[0].map(|v| -v);
}
rows
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Combine {
#[default]
Multiply = 0,
Mix = 1,
Add = 2,
}
pub use atmosphere::AtmosphereMaterial;
pub use basic::BasicMaterial;
pub use depth::DepthMaterial;
pub use lambert::LambertMaterial;
pub use line::LineBasicMaterial;
pub use matcap::MatcapMaterial;
pub use normal_mat::NormalMaterial;
pub use phong::PhongMaterial;
pub use physical::PhysicalMaterial;
pub use points_mat::PointsMaterial;
pub use shader_material::{ShaderLive, ShaderMaterial};
pub use shared_shader::SharedShader;
pub use sprite_mat::SpriteMaterial;
pub use standard::StandardMaterial;
pub use toon::ToonMaterial;
use crate::math::{Color, Vector2};
use crate::textures::Texture;
use std::sync::Arc;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct PolygonOffset {
pub factor: f32,
pub units: f32,
}
impl PolygonOffset {
pub const fn new(factor: f32, units: f32) -> Self {
Self { factor, units }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(u8)]
pub enum DepthFunc {
Never = 0,
Always = 1,
Less = 2,
#[default]
LessEqual = 3,
Equal = 4,
GreaterEqual = 5,
Greater = 6,
NotEqual = 7,
}
impl DepthFunc {
pub fn from_three(value: u32) -> Option<Self> {
Some(match value {
0 => Self::Never,
1 => Self::Always,
2 => Self::Less,
3 => Self::LessEqual,
4 => Self::Equal,
5 => Self::GreaterEqual,
6 => Self::Greater,
7 => Self::NotEqual,
_ => return None,
})
}
pub fn reversed(self) -> Self {
match self {
Self::Less => Self::Greater,
Self::LessEqual => Self::GreaterEqual,
Self::Greater => Self::Less,
Self::GreaterEqual => Self::LessEqual,
other => other,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum Blending {
#[default]
Normal,
Additive,
}
impl Blending {
pub fn from_three(value: u32) -> Option<Self> {
match value {
1 => Some(Self::Normal),
2 => Some(Self::Additive),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RenderState {
pub depth_test: bool,
pub depth_write: Option<bool>,
pub depth_func: DepthFunc,
pub color_write: bool,
pub blending: Blending,
}
impl Default for RenderState {
fn default() -> Self {
Self::DEFAULT
}
}
impl RenderState {
pub const DEFAULT: Self = Self {
depth_test: true,
depth_write: None,
depth_func: DepthFunc::LessEqual,
color_write: true,
blending: Blending::Normal,
};
pub fn is_default(&self) -> bool {
*self == Self::default()
}
pub fn effective_func(&self) -> DepthFunc {
if self.depth_test {
self.depth_func
} else {
DepthFunc::Always
}
}
pub fn effective_write(&self, default_write: bool) -> bool {
self.depth_test && self.depth_write.unwrap_or(default_write)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TransparencyMode {
#[default]
Blend,
Glass,
Oit,
Refract,
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone)]
pub enum Material {
Basic(BasicMaterial),
Lambert(LambertMaterial),
Phong(PhongMaterial),
Standard(StandardMaterial),
Physical(PhysicalMaterial),
Normal(NormalMaterial),
Depth(DepthMaterial),
Toon(ToonMaterial),
Matcap(MatcapMaterial),
Line(LineBasicMaterial),
Points(PointsMaterial),
Sprite(SpriteMaterial),
Distance(DistanceMaterial),
Sky(SkyMaterial),
Mirror(MirrorMaterial),
Shader(ShaderMaterial),
Atmosphere(AtmosphereMaterial),
}
#[derive(Debug, Clone)]
pub struct MirrorMaterial {
pub color: Color,
pub map: Option<Arc<Texture>>,
pub texture_matrix: [f32; 16],
pub side: u32,
pub render_state: RenderState,
}
impl Default for MirrorMaterial {
fn default() -> Self {
Self {
color: Color::WHITE,
map: None,
texture_matrix: [
1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
],
side: 0,
render_state: RenderState::default(),
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct SkyMaterial {
pub sun_position: crate::math::Vector3,
pub turbidity: f32,
pub rayleigh: f32,
pub mie_coefficient: f32,
pub mie_directional_g: f32,
pub render_state: RenderState,
}
impl Default for SkyMaterial {
fn default() -> Self {
Self {
sun_position: crate::math::Vector3::new(0.0, 1.0, 0.0),
turbidity: 10.0,
rayleigh: 3.0,
mie_coefficient: 0.005,
mie_directional_g: 0.7,
render_state: RenderState::default(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum MaterialKind {
Basic = 0,
Lambert = 1,
Phong = 2,
Standard = 3,
Physical = 4,
Normal = 5,
Depth = 6,
Toon = 7,
Matcap = 8,
Line = 9,
Points = 10,
Sprite = 11,
Distance = 12,
Sky = 13,
Mirror = 14,
Shader = 15,
Atmosphere = 16,
}
#[derive(Debug, Clone)]
pub struct DistanceMaterial {
pub reference_position: crate::math::Vector3,
pub near_distance: f32,
pub far_distance: f32,
pub render_state: RenderState,
}
impl Default for DistanceMaterial {
fn default() -> Self {
Self {
reference_position: crate::math::Vector3::ZERO,
near_distance: 1.0,
far_distance: 1000.0,
render_state: RenderState::default(),
}
}
}
impl DistanceMaterial {
pub fn new(reference_position: crate::math::Vector3, near: f32, far: f32) -> Self {
Self {
reference_position,
near_distance: near.max(0.0),
far_distance: far.max(near + 0.001),
render_state: RenderState::default(),
}
}
}
fn lit_slots(
map: &Option<Arc<Texture>>,
emissive: &Option<Arc<Texture>>,
normal: &Option<Arc<Texture>>,
ao: &Option<Arc<Texture>>,
displacement: &Option<Arc<Texture>>,
alpha: &Option<Arc<Texture>>,
) -> MaterialTextureSlots {
MaterialTextureSlots {
map: map.clone(),
alpha_map: alpha.clone(),
emissive_map: emissive.clone(),
normal_map: normal.clone(),
ao_map: ao.clone(),
displacement_map: displacement.clone(),
..Default::default()
}
}
#[derive(Default, Clone)]
pub struct MaterialTextureSlots {
pub map: Option<Arc<Texture>>,
pub normal_map: Option<Arc<Texture>>,
pub roughness_map: Option<Arc<Texture>>,
pub metalness_map: Option<Arc<Texture>>,
pub ao_map: Option<Arc<Texture>>,
pub emissive_map: Option<Arc<Texture>>,
pub matcap_map: Option<Arc<Texture>>,
pub gradient_map: Option<Arc<Texture>>,
pub displacement_map: Option<Arc<Texture>>,
pub cloud_shadow_map: Option<Arc<Texture>>,
pub iridescence_thickness_map: Option<Arc<Texture>>,
pub alpha_map: Option<Arc<Texture>>,
pub light_map: Option<Arc<Texture>>,
pub bump_map: Option<Arc<Texture>>,
pub specular_map: Option<Arc<Texture>>,
pub env_map: Option<Arc<crate::textures::CubeTexture>>,
pub pbr_env_map: Option<Arc<crate::textures::CubeTexture>>,
pub specular_intensity_map: Option<Arc<Texture>>,
pub specular_color_map: Option<Arc<Texture>>,
pub clearcoat_map: Option<Arc<Texture>>,
pub clearcoat_roughness_map: Option<Arc<Texture>>,
pub clearcoat_normal_map: Option<Arc<Texture>>,
pub iridescence_map: Option<Arc<Texture>>,
pub sheen_color_map: Option<Arc<Texture>>,
pub sheen_roughness_map: Option<Arc<Texture>>,
pub transmission_map: Option<Arc<Texture>>,
pub thickness_map: Option<Arc<Texture>>,
pub anisotropy_map: Option<Arc<Texture>>,
}
impl MaterialTextureSlots {
pub fn sampler_source(&self) -> Option<&Arc<Texture>> {
self.map
.as_ref()
.or(self.matcap_map.as_ref())
.or(self.emissive_map.as_ref())
.or(self.normal_map.as_ref())
.or(self.ao_map.as_ref())
.or(self.roughness_map.as_ref())
.or(self.metalness_map.as_ref())
.or(self.displacement_map.as_ref())
}
}
impl Material {
pub fn color(&self) -> Color {
match self {
Material::Basic(m) => m.color,
Material::Lambert(m) => m.color,
Material::Phong(m) => m.color,
Material::Standard(m) => m.color,
Material::Physical(m) => m.color,
Material::Normal(_) => Color::WHITE,
Material::Depth(_) => Color::WHITE,
Material::Toon(m) => m.color,
Material::Matcap(m) => m.color,
Material::Line(m) => m.color,
Material::Points(m) => m.color,
Material::Sprite(m) => m.color,
Material::Distance(_) => Color::WHITE,
Material::Sky(_) => Color::WHITE,
Material::Mirror(m) => m.color,
Material::Atmosphere(m) => m.color,
Material::Shader(m) => m.fallback_color,
}
}
pub fn wireframe(&self) -> bool {
match self {
Material::Basic(m) => m.wireframe,
Material::Lambert(m) => m.wireframe,
Material::Phong(m) => m.wireframe,
Material::Standard(m) => m.wireframe,
Material::Physical(m) => m.wireframe,
Material::Normal(m) => m.wireframe,
Material::Depth(m) => m.wireframe,
Material::Toon(m) => m.wireframe,
Material::Matcap(m) => m.wireframe,
_ => false,
}
}
pub fn transparent(&self) -> bool {
match self {
Material::Basic(m) => m.transparent,
Material::Physical(m) => {
(m.transmission > 0.0 && m.transparency != TransparencyMode::Blend)
|| m.transparent.unwrap_or(m.opacity < 1.0)
}
Material::Shader(m) => m.transparent || m.opacity < 1.0,
Material::Atmosphere(_) => true,
_ => self
.explicit_transparent()
.unwrap_or_else(|| self.opacity() < 1.0),
}
}
fn explicit_transparent(&self) -> Option<bool> {
match self {
Material::Lambert(m) => m.transparent,
Material::Phong(m) => m.transparent,
Material::Standard(m) => m.transparent,
Material::Toon(m) => m.transparent,
Material::Matcap(m) => m.transparent,
Material::Normal(m) => m.transparent,
Material::Depth(m) => m.transparent,
Material::Line(m) => m.transparent,
Material::Points(m) => m.transparent,
Material::Sprite(m) => Some(m.transparent.unwrap_or(true)),
_ => None,
}
}
pub fn polygon_offset(&self) -> Option<PolygonOffset> {
match self {
Material::Basic(m) => m.polygon_offset,
Material::Lambert(m) => m.polygon_offset,
Material::Phong(m) => m.polygon_offset,
Material::Standard(m) => m.polygon_offset,
Material::Physical(m) => m.polygon_offset,
Material::Toon(m) => m.polygon_offset,
Material::Normal(m) => m.polygon_offset,
Material::Matcap(m) => m.polygon_offset,
Material::Depth(m) => m.polygon_offset,
_ => None,
}
.filter(|o| o.factor != 0.0 || o.units != 0.0)
}
pub fn tone_mapped(&self) -> bool {
match self {
Material::Basic(m) => m.tone_mapped,
Material::Lambert(m) => m.tone_mapped,
Material::Phong(m) => m.tone_mapped,
Material::Standard(m) => m.tone_mapped,
Material::Physical(m) => m.tone_mapped,
Material::Toon(m) => m.tone_mapped,
Material::Matcap(m) => m.tone_mapped,
Material::Line(m) => m.tone_mapped,
Material::Points(m) => m.tone_mapped,
Material::Sprite(m) => m.tone_mapped,
Material::Shader(m) => m.tone_mapped,
Material::Normal(_) | Material::Depth(_) | Material::Distance(_) => false,
_ => true,
}
}
pub fn set_tone_mapped(&mut self, on: bool) {
match self {
Material::Basic(m) => m.tone_mapped = on,
Material::Lambert(m) => m.tone_mapped = on,
Material::Phong(m) => m.tone_mapped = on,
Material::Standard(m) => m.tone_mapped = on,
Material::Physical(m) => m.tone_mapped = on,
Material::Toon(m) => m.tone_mapped = on,
Material::Matcap(m) => m.tone_mapped = on,
Material::Line(m) => m.tone_mapped = on,
Material::Points(m) => m.tone_mapped = on,
Material::Sprite(m) => m.tone_mapped = on,
Material::Shader(m) => m.tone_mapped = on,
_ => {}
}
}
pub fn render_state(&self) -> RenderState {
match self {
Material::Basic(m) => m.render_state,
Material::Lambert(m) => m.render_state,
Material::Phong(m) => m.render_state,
Material::Standard(m) => m.render_state,
Material::Physical(m) => m.render_state,
Material::Normal(m) => m.render_state,
Material::Depth(m) => m.render_state,
Material::Toon(m) => m.render_state,
Material::Matcap(m) => m.render_state,
Material::Line(m) => m.render_state,
Material::Points(m) => m.render_state,
Material::Sprite(m) => m.render_state,
Material::Distance(m) => m.render_state,
Material::Sky(m) => m.render_state,
Material::Mirror(m) => m.render_state,
Material::Shader(m) => m.render_state,
Material::Atmosphere(m) => m.render_state,
}
}
pub fn render_state_mut(&mut self) -> &mut RenderState {
match self {
Material::Basic(m) => &mut m.render_state,
Material::Lambert(m) => &mut m.render_state,
Material::Phong(m) => &mut m.render_state,
Material::Standard(m) => &mut m.render_state,
Material::Physical(m) => &mut m.render_state,
Material::Normal(m) => &mut m.render_state,
Material::Depth(m) => &mut m.render_state,
Material::Toon(m) => &mut m.render_state,
Material::Matcap(m) => &mut m.render_state,
Material::Line(m) => &mut m.render_state,
Material::Points(m) => &mut m.render_state,
Material::Sprite(m) => &mut m.render_state,
Material::Distance(m) => &mut m.render_state,
Material::Sky(m) => &mut m.render_state,
Material::Mirror(m) => &mut m.render_state,
Material::Shader(m) => &mut m.render_state,
Material::Atmosphere(m) => &mut m.render_state,
}
}
pub fn depth_test(&self) -> bool {
self.render_state().depth_test
}
pub fn transmissive(&self) -> bool {
matches!(self, Material::Physical(m) if m.transmission > 0.0 && m.transparency == TransparencyMode::Blend)
}
pub fn transparency_mode(&self) -> TransparencyMode {
match self {
Material::Physical(m) => m.transparency,
_ => TransparencyMode::Blend,
}
}
pub fn set_opacity(&mut self, v: f32) {
match self {
Material::Basic(m) => m.opacity = v,
Material::Lambert(m) => m.opacity = v,
Material::Phong(m) => m.opacity = v,
Material::Standard(m) => m.opacity = v,
Material::Physical(m) => m.opacity = v,
Material::Normal(m) => m.opacity = v,
Material::Depth(m) => m.opacity = v,
Material::Toon(m) => m.opacity = v,
Material::Matcap(m) => m.opacity = v,
Material::Line(m) => m.opacity = v,
Material::Points(m) => m.opacity = v,
Material::Sprite(m) => m.opacity = v,
Material::Atmosphere(m) => m.opacity = v,
Material::Shader(m) => m.opacity = v,
Material::Distance(_) | Material::Sky(_) | Material::Mirror(_) => {}
}
}
pub fn opacity(&self) -> f32 {
match self {
Material::Basic(m) => m.opacity,
Material::Lambert(m) => m.opacity,
Material::Phong(m) => m.opacity,
Material::Standard(m) => m.opacity,
Material::Physical(m) => m.opacity,
Material::Normal(m) => m.opacity,
Material::Depth(m) => m.opacity,
Material::Toon(m) => m.opacity,
Material::Matcap(m) => m.opacity,
Material::Line(m) => m.opacity,
Material::Points(m) => m.opacity,
Material::Sprite(m) => m.opacity,
Material::Distance(_) => 1.0,
Material::Sky(_) => 1.0,
Material::Mirror(_) => 1.0,
Material::Atmosphere(m) => m.opacity,
Material::Shader(m) => m.opacity,
}
}
pub fn alpha_test(&self) -> f32 {
match self {
Material::Basic(m) => m.alpha_test,
Material::Lambert(m) => m.alpha_test,
Material::Phong(m) => m.alpha_test,
Material::Standard(m) => m.alpha_test,
Material::Physical(m) => m.alpha_test,
Material::Toon(m) => m.alpha_test,
Material::Matcap(m) => m.alpha_test,
Material::Normal(m) => m.alpha_test,
Material::Depth(m) => m.alpha_test,
Material::Line(m) => m.alpha_test,
Material::Points(m) => m.alpha_test,
Material::Sprite(m) => m.alpha_test,
_ => 0.0,
}
}
pub fn set_alpha_test(&mut self, value: f32) {
let v = value.max(0.0);
match self {
Material::Basic(m) => m.alpha_test = v,
Material::Lambert(m) => m.alpha_test = v,
Material::Phong(m) => m.alpha_test = v,
Material::Standard(m) => m.alpha_test = v,
Material::Physical(m) => m.alpha_test = v,
Material::Toon(m) => m.alpha_test = v,
Material::Matcap(m) => m.alpha_test = v,
Material::Normal(m) => m.alpha_test = v,
Material::Depth(m) => m.alpha_test = v,
Material::Line(m) => m.alpha_test = v,
Material::Points(m) => m.alpha_test = v,
Material::Sprite(m) => m.alpha_test = v,
_ => {}
}
}
pub fn set_transparent(&mut self, transparent: bool) {
let t = Some(transparent);
match self {
Material::Basic(m) => m.transparent = transparent,
Material::Shader(m) => m.transparent = transparent,
Material::Lambert(m) => m.transparent = t,
Material::Phong(m) => m.transparent = t,
Material::Standard(m) => m.transparent = t,
Material::Physical(m) => m.transparent = t,
Material::Toon(m) => m.transparent = t,
Material::Matcap(m) => m.transparent = t,
Material::Normal(m) => m.transparent = t,
Material::Depth(m) => m.transparent = t,
Material::Line(m) => m.transparent = t,
Material::Points(m) => m.transparent = t,
Material::Sprite(m) => m.transparent = t,
_ => {}
}
}
pub fn shadow_only(&self) -> bool {
match self {
Material::Basic(m) => m.shadow_only,
_ => false,
}
}
pub fn emissive(&self) -> Color {
match self {
Material::Lambert(m) => m.emissive,
Material::Phong(m) => m.emissive,
Material::Standard(m) => Color::new(
m.emissive.r * m.emissive_intensity,
m.emissive.g * m.emissive_intensity,
m.emissive.b * m.emissive_intensity,
),
Material::Physical(m) => Color::new(
m.emissive.r * m.emissive_intensity,
m.emissive.g * m.emissive_intensity,
m.emissive.b * m.emissive_intensity,
),
Material::Toon(m) => m.emissive,
_ => Color::BLACK,
}
}
pub fn specular(&self) -> Color {
match self {
Material::Phong(m) => m.specular,
_ => Color::BLACK,
}
}
pub fn side(&self) -> u32 {
match self {
Material::Basic(m) => m.side,
Material::Lambert(m) => m.side,
Material::Phong(m) => m.side,
Material::Standard(m) => m.side,
Material::Physical(m) => m.side,
Material::Toon(m) => m.side,
Material::Matcap(_) => 0,
Material::Normal(_) => 0,
Material::Depth(_) => 0,
Material::Distance(_) => 0,
Material::Line(_) => 0,
Material::Points(_) => 0,
Material::Sprite(_) => 0,
Material::Sky(_) => 1, Material::Mirror(m) => m.side,
Material::Atmosphere(_) => 0,
Material::Shader(m) => m.side,
}
}
pub fn set_side(&mut self, side: u32) {
match self {
Material::Basic(m) => m.side = side,
Material::Lambert(m) => m.side = side,
Material::Phong(m) => m.side = side,
Material::Standard(m) => m.side = side,
Material::Physical(m) => m.side = side,
Material::Toon(m) => m.side = side,
Material::Mirror(m) => m.side = side,
Material::Shader(m) => m.side = side,
_ => {}
}
}
pub fn shininess(&self) -> f32 {
match self {
Material::Phong(m) => m.shininess,
_ => 0.0,
}
}
pub fn roughness(&self) -> f32 {
match self {
Material::Standard(m) => m.roughness,
Material::Physical(m) => m.roughness,
_ => 1.0,
}
}
pub fn metalness(&self) -> f32 {
match self {
Material::Standard(m) => m.metalness,
Material::Physical(m) => m.metalness,
_ => 0.0,
}
}
pub fn ao_intensity(&self) -> f32 {
match self {
Material::Standard(m) => m.ao_intensity,
Material::Physical(m) => m.ao_intensity,
Material::Lambert(m) => m.ao_intensity,
Material::Phong(m) => m.ao_intensity,
Material::Toon(m) => m.ao_intensity,
_ => 1.0,
}
}
pub fn normal_scale(&self) -> Vector2 {
match self {
Material::Standard(m) => m.normal_scale,
Material::Physical(m) => m.normal_scale,
Material::Lambert(m) => m.normal_scale,
Material::Phong(m) => m.normal_scale,
Material::Toon(m) => m.normal_scale,
_ => Vector2::ONE,
}
}
pub fn atmosphere_params(&self) -> [f32; 4] {
match self {
Material::Standard(m) => [m.cloud_height, m.cloud_shadow, m.cloud_rotation, m.twilight],
Material::Physical(m) => [m.cloud_height, m.cloud_shadow, m.cloud_rotation, m.twilight],
_ => [0.0; 4],
}
}
pub fn eclipse(&self) -> ([f32; 4], f32) {
match self {
Material::Standard(m) => (m.eclipse_occluder.unwrap_or([0.0; 4]), m.sun_angular_radius),
Material::Physical(m) => (m.eclipse_occluder.unwrap_or([0.0; 4]), m.sun_angular_radius),
_ => ([0.0; 4], 0.0),
}
}
pub fn scatter_params(&self) -> [f32; 4] {
match self {
Material::Standard(m) => [m.cloud_scatter, m.cloud_anisotropy, 0.0, 0.0],
Material::Physical(m) => [m.cloud_scatter, m.cloud_anisotropy, 0.0, 0.0],
Material::Atmosphere(m) => [0.0, 0.0, m.ozone, m.aurora],
_ => [0.0; 4],
}
}
pub fn aurora_params(&self) -> [f32; 4] {
match self {
Material::Atmosphere(m) => {
let c = m.aurora_color;
[c.r, c.g, c.b, m.aurora_colatitude]
}
_ => [0.0; 4],
}
}
pub fn twilight_color(&self) -> Color {
match self {
Material::Standard(m) => m.twilight_color,
Material::Physical(m) => m.twilight_color,
_ => Color::BLACK,
}
}
pub fn emissive_night_side(&self) -> f32 {
match self {
Material::Standard(m) => m.emissive_night_side,
_ => 0.0,
}
}
pub fn displacement(&self) -> (f32, f32) {
match self {
Material::Standard(m) => (m.displacement_scale, m.displacement_bias),
Material::Physical(m) => (m.displacement_scale, m.displacement_bias),
Material::Lambert(m) => (m.displacement_scale, m.displacement_bias),
Material::Phong(m) => (m.displacement_scale, m.displacement_bias),
Material::Toon(m) => (m.displacement_scale, m.displacement_bias),
_ => (0.0, 0.0),
}
}
pub fn depth_range(&self) -> (f32, f32) {
match self {
Material::Depth(m) => (m.near, m.far),
_ => (0.0, 0.0),
}
}
pub fn point_size(&self) -> f32 {
match self {
Material::Points(m) => m.size,
_ => 1.0,
}
}
pub fn point_size_attenuation(&self) -> bool {
match self {
Material::Points(m) => m.size_attenuation,
_ => false,
}
}
pub fn kind(&self) -> MaterialKind {
match self {
Material::Basic(_) => MaterialKind::Basic,
Material::Lambert(_) => MaterialKind::Lambert,
Material::Phong(_) => MaterialKind::Phong,
Material::Standard(_) => MaterialKind::Standard,
Material::Physical(_) => MaterialKind::Physical,
Material::Normal(_) => MaterialKind::Normal,
Material::Depth(_) => MaterialKind::Depth,
Material::Toon(_) => MaterialKind::Toon,
Material::Matcap(_) => MaterialKind::Matcap,
Material::Line(_) => MaterialKind::Line,
Material::Points(_) => MaterialKind::Points,
Material::Sprite(_) => MaterialKind::Sprite,
Material::Distance(_) => MaterialKind::Distance,
Material::Sky(_) => MaterialKind::Sky,
Material::Mirror(_) => MaterialKind::Mirror,
Material::Atmosphere(_) => MaterialKind::Atmosphere,
Material::Shader(_) => MaterialKind::Shader,
}
}
pub fn pbr_env(&self) -> Option<(&Arc<crate::textures::CubeTexture>, f32, crate::math::Euler)> {
match self {
Material::Standard(m) => m
.env_map
.as_ref()
.map(|e| (e, m.env_map_intensity, m.env_map_rotation)),
Material::Physical(m) => m
.env_map
.as_ref()
.map(|e| (e, m.env_map_intensity, m.env_map_rotation)),
_ => None,
}
}
pub fn map_uniforms(&self) -> [[f32; 4]; 6] {
let (light, bump) = match self {
Material::Basic(m) => (m.light_map_intensity, 1.0),
Material::Lambert(m) => (m.light_map_intensity, m.bump_scale),
Material::Phong(m) => (m.light_map_intensity, m.bump_scale),
Material::Toon(m) => (m.light_map_intensity, m.bump_scale),
Material::Standard(m) => (m.light_map_intensity, m.bump_scale),
Material::Physical(m) => (m.light_map_intensity, m.bump_scale),
_ => (1.0, 1.0),
};
let env = match self {
Material::Basic(m) => Some((
&m.env_map,
m.combine,
m.reflectivity,
m.refraction_ratio,
m.env_map_rotation,
)),
Material::Lambert(m) => Some((
&m.env_map,
m.combine,
m.reflectivity,
m.refraction_ratio,
m.env_map_rotation,
)),
Material::Phong(m) => Some((
&m.env_map,
m.combine,
m.reflectivity,
m.refraction_ratio,
m.env_map_rotation,
)),
_ => None,
};
let (params, rows) = match env {
Some((map, combine, reflectivity, ratio, rotation)) => {
let refraction = map
.as_ref()
.is_some_and(|c| c.mapping == crate::textures::CubeMapping::Refraction);
(
[
combine as u32 as f32,
reflectivity,
ratio,
refraction as u32 as f32,
],
env_lookup_rows(rotation),
)
}
None => (
[0.0, 1.0, 0.98, 0.0],
env_lookup_rows(crate::math::Euler::default()),
),
};
let (thickness_min, cc_scale) = match self {
Material::Physical(m) => (m.iridescence_thickness_range[0], m.clearcoat_normal_scale),
_ => (0.0, crate::math::Vector2::new(1.0, 1.0)),
};
[
[light, bump, thickness_min, 0.0],
params,
rows[0],
rows[1],
rows[2],
[cc_scale.x, cc_scale.y, 0.0, 0.0],
]
}
pub fn map_slot_mut(&mut self, name: &str) -> Option<&mut Option<Arc<Texture>>> {
macro_rules! lit {
($m:expr) => {
match name {
"map" => Some(&mut $m.map),
"alphaMap" => Some(&mut $m.alpha_map),
"aoMap" => Some(&mut $m.ao_map),
"emissiveMap" => Some(&mut $m.emissive_map),
"normalMap" => Some(&mut $m.normal_map),
"displacementMap" => Some(&mut $m.displacement_map),
"lightMap" => Some(&mut $m.light_map),
"bumpMap" => Some(&mut $m.bump_map),
_ => None,
}
};
}
macro_rules! pbr {
($m:expr) => {
match name {
"roughnessMap" => Some(&mut $m.roughness_map),
"metalnessMap" => Some(&mut $m.metalness_map),
"cloudShadowMap" => Some(&mut $m.cloud_shadow_map),
_ => lit!($m),
}
};
}
match self {
Material::Lambert(m) => match name {
"specularMap" => Some(&mut m.specular_map),
_ => lit!(m),
},
Material::Phong(m) => match name {
"specularMap" => Some(&mut m.specular_map),
_ => lit!(m),
},
Material::Toon(m) => match name {
"gradientMap" => Some(&mut m.gradient_map),
_ => lit!(m),
},
Material::Standard(m) => pbr!(m),
Material::Physical(m) => match name {
"specularIntensityMap" => Some(&mut m.specular_intensity_map),
"specularColorMap" => Some(&mut m.specular_color_map),
"clearcoatMap" => Some(&mut m.clearcoat_map),
"clearcoatRoughnessMap" => Some(&mut m.clearcoat_roughness_map),
"clearcoatNormalMap" => Some(&mut m.clearcoat_normal_map),
"iridescenceMap" => Some(&mut m.iridescence_map),
"iridescenceThicknessMap" => Some(&mut m.iridescence_thickness_map),
"sheenColorMap" => Some(&mut m.sheen_color_map),
"sheenRoughnessMap" => Some(&mut m.sheen_roughness_map),
"transmissionMap" => Some(&mut m.transmission_map),
"thicknessMap" => Some(&mut m.thickness_map),
"anisotropyMap" => Some(&mut m.anisotropy_map),
_ => pbr!(m),
},
Material::Basic(m) => match name {
"map" => Some(&mut m.map),
"alphaMap" => Some(&mut m.alpha_map),
"lightMap" => Some(&mut m.light_map),
"specularMap" => Some(&mut m.specular_map),
_ => None,
},
Material::Points(m) => match name {
"map" => Some(&mut m.map),
"alphaMap" => Some(&mut m.alpha_map),
_ => None,
},
Material::Sprite(m) => match name {
"map" => Some(&mut m.map),
"alphaMap" => Some(&mut m.alpha_map),
_ => None,
},
Material::Matcap(m) => match name {
"matcap" => Some(&mut m.matcap),
"map" => Some(&mut m.map),
"alphaMap" => Some(&mut m.alpha_map),
_ => None,
},
_ => None,
}
}
pub fn texture_slots(&self) -> MaterialTextureSlots {
match self {
Material::Standard(m) => MaterialTextureSlots {
cloud_shadow_map: m.cloud_shadow_map.clone(),
iridescence_thickness_map: None,
map: m.map.clone(),
normal_map: m.normal_map.clone(),
roughness_map: m.roughness_map.clone(),
metalness_map: m.metalness_map.clone(),
ao_map: m.ao_map.clone(),
emissive_map: m.emissive_map.clone(),
displacement_map: m.displacement_map.clone(),
alpha_map: m.alpha_map.clone(),
light_map: m.light_map.clone(),
bump_map: m.bump_map.clone(),
pbr_env_map: m.env_map.clone(),
matcap_map: None,
..Default::default()
},
Material::Physical(m) => MaterialTextureSlots {
cloud_shadow_map: m.cloud_shadow_map.clone(),
iridescence_thickness_map: m.iridescence_thickness_map.clone(),
map: m.map.clone(),
normal_map: m.normal_map.clone(),
roughness_map: m.roughness_map.clone(),
metalness_map: m.metalness_map.clone(),
ao_map: m.ao_map.clone(),
emissive_map: m.emissive_map.clone(),
displacement_map: m.displacement_map.clone(),
alpha_map: m.alpha_map.clone(),
light_map: m.light_map.clone(),
bump_map: m.bump_map.clone(),
pbr_env_map: m.env_map.clone(),
matcap_map: None,
specular_intensity_map: m.specular_intensity_map.clone(),
specular_color_map: m.specular_color_map.clone(),
clearcoat_map: m.clearcoat_map.clone(),
clearcoat_roughness_map: m.clearcoat_roughness_map.clone(),
clearcoat_normal_map: m.clearcoat_normal_map.clone(),
iridescence_map: m.iridescence_map.clone(),
sheen_color_map: m.sheen_color_map.clone(),
sheen_roughness_map: m.sheen_roughness_map.clone(),
transmission_map: m.transmission_map.clone(),
thickness_map: m.thickness_map.clone(),
anisotropy_map: m.anisotropy_map.clone(),
..Default::default()
},
Material::Matcap(m) => MaterialTextureSlots {
matcap_map: m.matcap.clone(),
map: m.map.clone(),
alpha_map: m.alpha_map.clone(),
..Default::default()
},
Material::Lambert(m) => MaterialTextureSlots {
env_map: m.env_map.clone(),
light_map: m.light_map.clone(),
bump_map: m.bump_map.clone(),
specular_map: m.specular_map.clone(),
..lit_slots(
&m.map,
&m.emissive_map,
&m.normal_map,
&m.ao_map,
&m.displacement_map,
&m.alpha_map,
)
},
Material::Phong(m) => MaterialTextureSlots {
env_map: m.env_map.clone(),
light_map: m.light_map.clone(),
bump_map: m.bump_map.clone(),
specular_map: m.specular_map.clone(),
..lit_slots(
&m.map,
&m.emissive_map,
&m.normal_map,
&m.ao_map,
&m.displacement_map,
&m.alpha_map,
)
},
Material::Toon(m) => MaterialTextureSlots {
gradient_map: m.gradient_map.clone(),
light_map: m.light_map.clone(),
bump_map: m.bump_map.clone(),
..lit_slots(
&m.map,
&m.emissive_map,
&m.normal_map,
&m.ao_map,
&m.displacement_map,
&m.alpha_map,
)
},
Material::Points(m) => MaterialTextureSlots {
map: m.map.clone(),
alpha_map: m.alpha_map.clone(),
..Default::default()
},
Material::Sprite(m) => MaterialTextureSlots {
map: m.map.clone(),
alpha_map: m.alpha_map.clone(),
..Default::default()
},
Material::Basic(m) => MaterialTextureSlots {
env_map: m.env_map.clone(),
map: m.map.clone(),
alpha_map: m.alpha_map.clone(),
light_map: m.light_map.clone(),
specular_map: m.specular_map.clone(),
..Default::default()
},
Material::Mirror(m) => MaterialTextureSlots {
map: m.map.clone(),
..Default::default()
},
_ => MaterialTextureSlots::default(),
}
}
}
impl From<BasicMaterial> for Material {
fn from(m: BasicMaterial) -> Self {
Material::Basic(m)
}
}
impl From<LambertMaterial> for Material {
fn from(m: LambertMaterial) -> Self {
Material::Lambert(m)
}
}
impl From<PhongMaterial> for Material {
fn from(m: PhongMaterial) -> Self {
Material::Phong(m)
}
}
impl From<StandardMaterial> for Material {
fn from(m: StandardMaterial) -> Self {
Material::Standard(m)
}
}
impl From<PhysicalMaterial> for Material {
fn from(m: PhysicalMaterial) -> Self {
Material::Physical(m)
}
}
impl From<NormalMaterial> for Material {
fn from(m: NormalMaterial) -> Self {
Material::Normal(m)
}
}
impl From<DepthMaterial> for Material {
fn from(m: DepthMaterial) -> Self {
Material::Depth(m)
}
}
impl From<ToonMaterial> for Material {
fn from(m: ToonMaterial) -> Self {
Material::Toon(m)
}
}
impl From<MatcapMaterial> for Material {
fn from(m: MatcapMaterial) -> Self {
Material::Matcap(m)
}
}
impl From<LineBasicMaterial> for Material {
fn from(m: LineBasicMaterial) -> Self {
Material::Line(m)
}
}
impl From<PointsMaterial> for Material {
fn from(m: PointsMaterial) -> Self {
Material::Points(m)
}
}
impl From<SpriteMaterial> for Material {
fn from(m: SpriteMaterial) -> Self {
Material::Sprite(m)
}
}
impl From<DistanceMaterial> for Material {
fn from(m: DistanceMaterial) -> Self {
Material::Distance(m)
}
}
impl From<SkyMaterial> for Material {
fn from(m: SkyMaterial) -> Self {
Material::Sky(m)
}
}
impl From<MirrorMaterial> for Material {
fn from(m: MirrorMaterial) -> Self {
Material::Mirror(m)
}
}
impl From<ShaderMaterial> for Material {
fn from(m: ShaderMaterial) -> Self {
Material::Shader(m)
}
}