rafx-api 0.0.16

Rendering framework built on an extensible asset pipeline
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::*;
use crate::vulkan::{RafxDeviceContextVulkan, RafxRenderpassVulkan};
use crate::*;
use fnv::FnvHasher;
use std::hash::{Hash, Hasher};

pub(crate) struct RafxFramebufferVulkanCache {
    cache: LruCache<RafxFramebufferVulkan>,
}

impl RafxFramebufferVulkanCache {
    pub(crate) fn new(max_count: usize) -> Self {
        RafxFramebufferVulkanCache {
            cache: LruCache::new(max_count),
        }
    }

    pub(crate) fn clear(&mut self) {
        self.cache.clear();
    }

    pub(crate) fn framebuffer_hash(
        color_targets: &[RafxColorRenderTargetBinding],
        depth_target: Option<&RafxDepthStencilRenderTargetBinding>,
    ) -> u64 {
        let mut hasher = FnvHasher::default();
        for color_target in color_targets {
            color_target
                .texture
                .vk_texture()
                .unwrap()
                .texture_id()
                .hash(&mut hasher);
            color_target.mip_slice.hash(&mut hasher);
            color_target.array_slice.hash(&mut hasher);

            if let Some(resolve_target) = color_target.resolve_target {
                resolve_target
                    .vk_texture()
                    .unwrap()
                    .texture_id()
                    .hash(&mut hasher);
                color_target.resolve_mip_slice.hash(&mut hasher);
                color_target.resolve_array_slice.hash(&mut hasher);
            }
        }

        if let Some(depth_target) = &depth_target {
            depth_target
                .texture
                .vk_texture()
                .unwrap()
                .texture_id()
                .hash(&mut hasher);
            depth_target.mip_slice.hash(&mut hasher);
            depth_target.array_slice.hash(&mut hasher);
        }
        hasher.finish()
    }

    pub(crate) fn create_framebuffer(
        device_context: &RafxDeviceContextVulkan,
        renderpass: &RafxRenderpassVulkan,
        color_targets: &[RafxColorRenderTargetBinding],
        depth_target: Option<&RafxDepthStencilRenderTargetBinding>,
    ) -> RafxResult<RafxFramebufferVulkan> {
        let mut color_attachments = Vec::with_capacity(color_targets.len());
        let mut resolve_attachments = Vec::with_capacity(color_targets.len());

        for color_target in color_targets {
            color_attachments.push(RafxFramebufferVulkanAttachment {
                texture: color_target.texture.vk_texture().unwrap().clone(),
                array_slice: color_target.array_slice,
                mip_slice: color_target.mip_slice,
            });

            if let Some(resolve_target) = color_target.resolve_target {
                resolve_attachments.push(RafxFramebufferVulkanAttachment {
                    texture: resolve_target.vk_texture().unwrap().clone(),
                    array_slice: color_target.resolve_array_slice,
                    mip_slice: color_target.resolve_mip_slice,
                })
            }
        }

        RafxFramebufferVulkan::new(
            device_context,
            &RafxFramebufferVulkanDef {
                renderpass: renderpass.clone(),
                color_attachments,
                resolve_attachments,
                depth_stencil_attachment: depth_target.as_ref().map(|x| {
                    RafxFramebufferVulkanAttachment {
                        texture: x.texture.vk_texture().unwrap().clone(),
                        array_slice: x.array_slice,
                        mip_slice: x.mip_slice,
                    }
                }),
            },
        )
    }

    pub(crate) fn get_or_create_framebuffer(
        &mut self,
        device_context: &RafxDeviceContextVulkan,
        renderpass: &RafxRenderpassVulkan,
        color_targets: &[RafxColorRenderTargetBinding],
        depth_target: Option<&RafxDepthStencilRenderTargetBinding>,
    ) -> RafxResult<RafxFramebufferVulkan> {
        //
        // Hash it
        //
        let hash = Self::framebuffer_hash(color_targets, depth_target);

        self.cache.get_or_create(hash, || {
            Self::create_framebuffer(device_context, renderpass, color_targets, depth_target)
        })
    }
}