nightshade 0.13.0

A cross-platform data-oriented game engine.
Documentation 
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

use super::super::types::BlendedIblViews;
use super::SkinnedMeshPass;

impl SkinnedMeshPass {
    pub fn update_ibl_textures_for_world(
        &mut self,
        world_id: u64,
        brdf_lut_view: wgpu::TextureView,
        irradiance_view: wgpu::TextureView,
        prefiltered_view: wgpu::TextureView,
    ) {
        if let Some(world_state) = self.world_states.get_mut(&world_id) {
            world_state.ibl_brdf_lut_view = Some(brdf_lut_view);
            world_state.ibl_irradiance_view = Some(irradiance_view);
            world_state.ibl_prefiltered_view = Some(prefiltered_view);
        }
    }

    pub fn update_ibl_textures_blended_for_world(&mut self, world_id: u64, views: BlendedIblViews) {
        if let Some(world_state) = self.world_states.get_mut(&world_id) {
            world_state.ibl_brdf_lut_view = Some(views.brdf_lut);
            world_state.ibl_irradiance_view = Some(views.irradiance_a);
            world_state.ibl_prefiltered_view = Some(views.prefiltered_a);
            world_state.ibl_irradiance_b_view = Some(views.irradiance_b);
            world_state.ibl_prefiltered_b_view = Some(views.prefiltered_b);
            world_state.ibl_blend_factor = views.blend_factor;
        }
    }

    pub fn set_ibl_textures(
        &mut self,
        brdf_lut_view: wgpu::TextureView,
        irradiance_map_view: wgpu::TextureView,
        prefiltered_env_view: wgpu::TextureView,
    ) {
        self.brdf_lut_view = Some(brdf_lut_view);
        self.irradiance_map_view = Some(irradiance_map_view);
        self.prefiltered_env_view = Some(prefiltered_env_view);
    }

    pub fn update_point_shadow_cubemap(&mut self, view: wgpu::TextureView) {
        self.point_shadow_cubemap_view = view;
    }

    pub fn cleanup_stale_world_states(&mut self) {
        const STALE_THRESHOLD_FRAMES: u64 = 300;
        let current_frame = self.frame_counter;
        self.world_states.retain(|world_id, state| {
            let is_current = *world_id == self.current_world_id;
            let is_recent =
                current_frame.saturating_sub(state.last_used_frame) < STALE_THRESHOLD_FRAMES;
            is_current || is_recent
        });
    }

    pub fn resize_oit_textures(&mut self, device: &wgpu::Device, width: u32, height: u32) {
        if self.oit_texture_size == (width, height) || width == 0 || height == 0 {
            return;
        }

        self.oit_accum_texture = device.create_texture(&wgpu::TextureDescriptor {
            label: Some("Skinned Mesh OIT Accum Texture"),
            size: wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba16Float,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
            view_formats: &[],
        });
        self.oit_accum_view = self
            .oit_accum_texture
            .create_view(&wgpu::TextureViewDescriptor::default());

        self.oit_reveal_texture = device.create_texture(&wgpu::TextureDescriptor {
            label: Some("Skinned Mesh OIT Reveal Texture"),
            size: wgpu::Extent3d {
                width,
                height,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::R16Float,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
            view_formats: &[],
        });
        self.oit_reveal_view = self
            .oit_reveal_texture
            .create_view(&wgpu::TextureViewDescriptor::default());

        self.oit_texture_size = (width, height);
    }
}