truck_rendimpl/
instance_creator.rs

1use crate::*;
2
3impl PolygonShaders {
4    /// Constructor
5    /// # Parameters
6    /// - `vertex_module`: vertex shader module
7    /// - `vertex_entry`: entry point of vertex shader module
8    /// - `fragment_module`: fragment shader module without texture
9    /// - `fragment_entry`: entry point of fragment shader module without texture
10    /// - `tex_fragment_module`: fragment shader module with texture
11    /// - `tex_fragment_entry`: entry point of fragment shader module with texture
12    #[inline(always)]
13    pub const fn new(
14        vertex_module: Arc<ShaderModule>,
15        vertex_entry: &'static str,
16        fragment_module: Arc<ShaderModule>,
17        fragment_entry: &'static str,
18        tex_fragment_module: Arc<ShaderModule>,
19        tex_fragment_entry: &'static str,
20    ) -> Self {
21        Self {
22            vertex_module,
23            vertex_entry,
24            fragment_module,
25            fragment_entry,
26            tex_fragment_module,
27            tex_fragment_entry,
28        }
29    }
30
31    /// Creates default polygon shaders.
32    #[inline(always)]
33    pub fn default(device: &Device) -> Self {
34        let source = include_str!("shaders/microfacet-module.wgsl").to_string()
35            + include_str!("shaders/polygon.wgsl");
36        let shader_module = Arc::new(device.create_shader_module(ShaderModuleDescriptor {
37            source: ShaderSource::Wgsl(source.into()),
38            label: None,
39        }));
40        Self::new(
41            Arc::clone(&shader_module),
42            "vs_main",
43            Arc::clone(&shader_module),
44            "nontex_main",
45            Arc::clone(&shader_module),
46            "tex_main",
47        )
48    }
49}
50
51impl WireShaders {
52    /// Constructor
53    /// # Parameters
54    /// - `vertex_module`: vertex shader module
55    /// - `vertex_entry`: entry point of vertex shader module
56    /// - `fragment_module`: fragment shader module without texture
57    /// - `fragment_entry`: entry point of fragment shader module without texture
58    #[inline(always)]
59    pub const fn new(
60        vertex_module: Arc<ShaderModule>,
61        vertex_entry: &'static str,
62        fragment_module: Arc<ShaderModule>,
63        fragment_entry: &'static str,
64    ) -> Self {
65        Self {
66            vertex_module,
67            vertex_entry,
68            fragment_module,
69            fragment_entry,
70        }
71    }
72
73    /// Creates default wireframe shaders
74    #[inline(always)]
75    fn default(device: &Device) -> Self {
76        let shader_module = Arc::new(device.create_shader_module(ShaderModuleDescriptor {
77            source: ShaderSource::Wgsl(include_str!("shaders/line.wgsl").into()),
78            label: None,
79        }));
80        Self::new(
81            Arc::clone(&shader_module),
82            "vs_main",
83            shader_module,
84            "fs_main",
85        )
86    }
87}
88
89impl CreatorCreator for DeviceHandler {
90    #[inline(always)]
91    fn instance_creator(&self) -> InstanceCreator {
92        InstanceCreator {
93            handler: self.clone(),
94            polygon_shaders: PolygonShaders::default(self.device()),
95            wire_shaders: WireShaders::default(self.device()),
96        }
97    }
98}
99
100impl CreatorCreator for Scene {
101    #[inline(always)]
102    fn instance_creator(&self) -> InstanceCreator { self.device_handler().instance_creator() }
103}
104
105impl InstanceCreator {
106    /// Creates Instance from object.
107    #[inline(always)]
108    pub fn create_instance<I, T>(&self, object: &T, state: &T::State) -> I
109    where
110        T: ToInstance<I>,
111        I: Instance, {
112        object.to_instance(&self.handler, &I::standard_shaders(self), state)
113    }
114    /// Creates `Texture` for attaching faces.
115    #[inline(always)]
116    pub fn create_texture(&self, image: &DynamicImage) -> Arc<Texture> {
117        Arc::new(image2texture::image2texture(&self.handler, image))
118    }
119}