libprocessing/crates/processing_render/src/material/pbr.rs at 51726f84656a332ddd75697ff08e7d5db814edf5 · catilac/libprocessing · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
use bevy::prelude::*;

use super::MaterialValue;
use crate::error::{ProcessingError, Result};

/// Set a property on a StandardMaterial by name.
pub fn set_property(
    material: &mut StandardMaterial,
    name: &str,
    value: &MaterialValue,
) -> Result<()> {
    match name {
        "base_color" | "color" => {
            let MaterialValue::Float4(c) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float4, got {value:?}"
                )));
            };
            material.base_color = Color::srgba(c[0], c[1], c[2], c[3]);
        }
        "metallic" => {
            let MaterialValue::Float(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float, got {value:?}"
                )));
            };
            material.metallic = *v;
        }
        "roughness" | "perceptual_roughness" => {
            let MaterialValue::Float(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float, got {value:?}"
                )));
            };
            material.perceptual_roughness = *v;
        }
        "reflectance" => {
            let MaterialValue::Float(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float, got {value:?}"
                )));
            };
            material.reflectance = *v;
        }
        "emissive" => {
            let MaterialValue::Float4(c) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float4, got {value:?}"
                )));
            };
            material.emissive = LinearRgba::new(c[0], c[1], c[2], c[3]);
        }
        "unlit" => {
            let MaterialValue::Float(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float, got {value:?}"
                )));
            };
            material.unlit = *v > 0.5;
        }
        "double_sided" => {
            let MaterialValue::Float(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Float, got {value:?}"
                )));
            };
            material.double_sided = *v > 0.5;
        }
        "alpha_mode" => {
            let MaterialValue::Int(v) = value else {
                return Err(ProcessingError::InvalidArgument(format!(
                    "'{name}' expects Int, got {value:?}"
                )));
            };
            material.alpha_mode = match v {
                0 => AlphaMode::Opaque,
                // TODO: allow configuring the alpha cutoff value
                1 => AlphaMode::Mask(0.5),
                2 => AlphaMode::Blend,
                3 => AlphaMode::Premultiplied,
                4 => AlphaMode::Add,
                5 => AlphaMode::Multiply,
                _ => {
                    return Err(ProcessingError::InvalidArgument(format!(
                        "unknown alpha_mode value: {v}"
                    )));
                }
            };
        }
        _ => {
            return Err(ProcessingError::UnknownMaterialProperty(name.to_string()));
        }
    }
    Ok(())
}