truck_rendimpl/
instance_creator.rs1use crate::*;
2
3impl PolygonShaders {
4 #[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 #[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 #[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 #[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 #[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 #[inline(always)]
116 pub fn create_texture(&self, image: &DynamicImage) -> Arc<Texture> {
117 Arc::new(image2texture::image2texture(&self.handler, image))
118 }
119}