Skip to main content

blade_render/
dummy.rs

1use std::ptr;
2
3pub struct DummyResources {
4    pub size: blade_graphics::Extent,
5    pub white_texture: blade_graphics::Texture,
6    pub white_view: blade_graphics::TextureView,
7    pub black_texture: blade_graphics::Texture,
8    pub black_view: blade_graphics::TextureView,
9    pub red_texture: blade_graphics::Texture,
10    pub red_view: blade_graphics::TextureView,
11    staging_buf: blade_graphics::Buffer,
12}
13
14impl DummyResources {
15    pub fn new(
16        command_encoder: &mut blade_graphics::CommandEncoder,
17        gpu: &blade_graphics::Context,
18    ) -> Self {
19        let size = blade_graphics::Extent {
20            width: 1,
21            height: 1,
22            depth: 1,
23        };
24        let white_texture = gpu.create_texture(blade_graphics::TextureDesc {
25            name: "dummy/white",
26            format: blade_graphics::TextureFormat::Rgba8Unorm,
27            size,
28            array_layer_count: 1,
29            mip_level_count: 1,
30            dimension: blade_graphics::TextureDimension::D2,
31            usage: blade_graphics::TextureUsage::COPY | blade_graphics::TextureUsage::RESOURCE,
32            sample_count: 1,
33            external: None,
34        });
35        let white_view = gpu.create_texture_view(
36            white_texture,
37            blade_graphics::TextureViewDesc {
38                name: "dummy/white",
39                format: blade_graphics::TextureFormat::Rgba8Unorm,
40                dimension: blade_graphics::ViewDimension::D2,
41                subresources: &blade_graphics::TextureSubresources::default(),
42            },
43        );
44        let black_texture = gpu.create_texture(blade_graphics::TextureDesc {
45            name: "dummy/black",
46            format: blade_graphics::TextureFormat::Rgba8Unorm,
47            size,
48            array_layer_count: 1,
49            mip_level_count: 1,
50            dimension: blade_graphics::TextureDimension::D2,
51            usage: blade_graphics::TextureUsage::COPY | blade_graphics::TextureUsage::RESOURCE,
52            sample_count: 1,
53            external: None,
54        });
55        let black_view = gpu.create_texture_view(
56            black_texture,
57            blade_graphics::TextureViewDesc {
58                name: "dummy/black",
59                format: blade_graphics::TextureFormat::Rgba8Unorm,
60                dimension: blade_graphics::ViewDimension::D2,
61                subresources: &blade_graphics::TextureSubresources::default(),
62            },
63        );
64        let red_texture = gpu.create_texture(blade_graphics::TextureDesc {
65            name: "dummy/red",
66            format: blade_graphics::TextureFormat::Rgba8Unorm,
67            size,
68            array_layer_count: 1,
69            mip_level_count: 1,
70            dimension: blade_graphics::TextureDimension::D2,
71            usage: blade_graphics::TextureUsage::COPY | blade_graphics::TextureUsage::RESOURCE,
72            sample_count: 1,
73            external: None,
74        });
75        let red_view = gpu.create_texture_view(
76            red_texture,
77            blade_graphics::TextureViewDesc {
78                name: "dummy/red",
79                format: blade_graphics::TextureFormat::Rgba8Unorm,
80                dimension: blade_graphics::ViewDimension::D2,
81                subresources: &blade_graphics::TextureSubresources::default(),
82            },
83        );
84
85        command_encoder.init_texture(white_texture);
86        command_encoder.init_texture(black_texture);
87        command_encoder.init_texture(red_texture);
88        let mut transfers = command_encoder.transfer("init dummy");
89        let staging_buf = gpu.create_buffer(blade_graphics::BufferDesc {
90            name: "dummy/staging",
91            size: 4 * 3,
92            memory: blade_graphics::Memory::Upload,
93        });
94        unsafe {
95            ptr::write(
96                staging_buf.data() as *mut _,
97                [!0u8, !0, !0, !0, 0, 0, 0, 0, !0, 0, 0, 0],
98            );
99        }
100        transfers.copy_buffer_to_texture(staging_buf.at(0), 4, white_texture.into(), size);
101        transfers.copy_buffer_to_texture(staging_buf.at(4), 4, black_texture.into(), size);
102        transfers.copy_buffer_to_texture(staging_buf.at(8), 4, red_texture.into(), size);
103
104        Self {
105            size,
106            white_texture,
107            white_view,
108            black_texture,
109            black_view,
110            red_texture,
111            red_view,
112            staging_buf,
113        }
114    }
115
116    pub fn destroy(&mut self, gpu: &blade_graphics::Context) {
117        gpu.destroy_texture_view(self.white_view);
118        gpu.destroy_texture(self.white_texture);
119        gpu.destroy_texture_view(self.black_view);
120        gpu.destroy_texture(self.black_texture);
121        gpu.destroy_texture_view(self.red_view);
122        gpu.destroy_texture(self.red_texture);
123        gpu.destroy_buffer(self.staging_buf);
124    }
125}