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
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use rin_material::{BasicMaterial, Property};
use super::{
    into_gl_property, MaterialTransparency, ProgramSettings, Shader, PropertyChanged
};
use rin_gl as gl;

impl super::Material for BasicMaterial{
    fn properties(&self) -> PropertyChanged<Vec<glin::Property>>{
        if self.properties.has_changed(){
            let properties = self.properties.iter()
                .flat_map(|p| if let Property::PointSize(point_size) = p {
                        #[cfg(not(any(feature="gles", feature="webgl")))]
                        let props = vec![
                            glin::Property::ProgramPointSize(true),
                            glin::Property::PointSize(*point_size)
                        ];

                        #[cfg(any(feature="gles", feature="webgl"))]
                        let props = vec![];

                        props
                    }else{
                        vec![
                            into_gl_property(p)
                        ]
                    }).collect();
            PropertyChanged::New(properties)
        }else{
            PropertyChanged::Old
        }
    }

    fn transparency(&self) -> PropertyChanged<MaterialTransparency>{
        if self.alpha_type.has_changed() || self.base_color.has_changed() {
            PropertyChanged::New(MaterialTransparency{
                alpha_type: *self.alpha_type,
                is_translucent: if let Some(alpha) = self.base_color.get().map(|c| c.a){
                    alpha > 0. && alpha < 1.
                }else{
                    false
                },
                is_visible: if let Some(alpha) = self.base_color.get().map(|c| c.a){
                    alpha > 0.
                }else{
                    true
                },
                priority: None,
            })
        }else{
            PropertyChanged::Old
        }
    }

    fn shaders(&self) -> PropertyChanged<Vec<Shader>>{
        PropertyChanged::Always(vec![
            gl::vertex_shader!("shaders/basic_material.vs.glsl"),
            gl::fragment_shader!("shaders/basic_material.fs.glsl")
        ])
    }

    fn program_settings(&self) -> PropertyChanged<ProgramSettings>{
        let get_point_size = || {
            self.properties.iter()
                .filter_map(|p| if let Property::PointSize(size) = p {
                    Some(size)
                }else{
                    None
                }).next()
        };
        let point_size_changed = if self.properties.has_changed() {
            get_point_size()
        }else{
            None
        };
        if self.base_color.option_changed() || self.texture.option_changed() || point_size_changed.is_some() {
            let use_global_color = (self.base_color.is_some() as u8).to_string();
            let use_texture = (self.texture.is_some() as u8).to_string();
            let point_size = if point_size_changed.is_none(){
                get_point_size()
            }else{
                point_size_changed
            };
            let debug_texcoords = (*self.debug_texcoords.get() as u8).to_string();
            let debug_normals = (*self.debug_normals.get() as u8).to_string();
            if *self.debug_texcoords.get() && *self.debug_normals.get() {
                panic!("Debug normals and debug texcoords can't be true simulataneously")
            }
            let output_linear_colors = (*self.output_linear_colors.get() as u8).to_string();
            if let Some(point_size) = point_size {
                let point_size = point_size.to_string();
                PropertyChanged::New(ProgramSettings{
                    defines: vec![
                        ("USE_GLOBAL_COLOR".to_owned(),         use_global_color),
                        ("HAS_COLOR_TEXTURE".to_owned(),        use_texture),
                        ("USE_BGR".to_owned(),                  "0".to_owned()),
                        ("POINT_SIZE".to_owned(),               point_size),
                        ("DEBUG_TEXCOORDS".to_owned(),          debug_texcoords),
                        ("DEBUG_NORMALS".to_owned(),            debug_normals),
                        ("MANUAL_SRGB".to_owned(),              output_linear_colors),
                        ("SRGB_FAST_APPROXIMATION".to_owned(),  "1".to_owned()),
                    ],
                    .. Default::default()
                })
            }else{
                PropertyChanged::New(ProgramSettings{
                    defines: vec![
                        ("USE_GLOBAL_COLOR".to_owned(),        use_global_color),
                        ("HAS_COLOR_TEXTURE".to_owned(),       use_texture),
                        ("USE_BGR".to_owned(),                 "0".to_owned()),
                        ("DEBUG_TEXCOORDS".to_owned(),         debug_texcoords),
                        ("DEBUG_NORMALS".to_owned(),           debug_normals),
                        ("MANUAL_SRGB".to_owned(),             output_linear_colors),
                        ("SRGB_FAST_APPROXIMATION".to_owned(), "1".to_owned()),
                    ],
                    .. Default::default()
                })
            }
        }else{
            PropertyChanged::Old
        }
    }
}