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

use super::d3d12;
use crate::dx12::{Dx12DescriptorId, RafxDeviceContextDx12};
use crate::{RafxCompareOp, RafxFilterType, RafxMipMapMode, RafxResult, RafxSamplerDef};
use std::sync::Arc;

#[derive(Debug)]
pub struct RafxSamplerDx12Inner {
    device_context: RafxDeviceContextDx12,
    sampler_desc: d3d12::D3D12_SAMPLER_DESC,
    sampler_descriptor: Dx12DescriptorId,
}

impl Drop for RafxSamplerDx12Inner {
    fn drop(&mut self) {
        self.device_context
            .inner
            .heaps
            .sampler_heap
            .free(self.sampler_descriptor, 1);
    }
}

#[derive(Debug, Clone)]
pub struct RafxSamplerDx12 {
    inner: Arc<RafxSamplerDx12Inner>,
}

impl RafxSamplerDx12 {
    pub fn dx12_sampler_descriptor(&self) -> Dx12DescriptorId {
        self.inner.sampler_descriptor
    }

    pub fn dx12_sampler_desc(&self) -> &d3d12::D3D12_SAMPLER_DESC {
        &self.inner.sampler_desc
    }

    pub fn new(
        device_context: &RafxDeviceContextDx12,
        sampler_def: &RafxSamplerDef,
    ) -> RafxResult<RafxSamplerDx12> {
        let mut filter: d3d12::D3D12_FILTER = d3d12::D3D12_FILTER(0);

        // Assume defines from https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_filter
        if sampler_def.max_anisotropy > 0.0 {
            // d3d12 defines assume trilinear if anisotropy is set
            filter.0 |= d3d12::D3D12_FILTER_ANISOTROPIC.0;
        } else {
            if sampler_def.min_filter == RafxFilterType::Linear {
                filter.0 |= 0x1 << 4;
            }

            if sampler_def.mag_filter == RafxFilterType::Linear {
                filter.0 |= 0x1 << 2;
            }

            if sampler_def.mip_map_mode == RafxMipMapMode::Linear {
                filter.0 |= 0x1 << 0;
            }
        }

        if sampler_def.compare_op != RafxCompareOp::Never {
            filter.0 |= 0x1 << 7;
        }

        let max_lod = match sampler_def.mip_map_mode {
            RafxMipMapMode::Nearest => 0.0,
            RafxMipMapMode::Linear => f32::MAX,
        };

        let sampler_desc = d3d12::D3D12_SAMPLER_DESC {
            Filter: filter,
            AddressU: sampler_def.address_mode_u.into(),
            AddressV: sampler_def.address_mode_v.into(),
            AddressW: sampler_def.address_mode_w.into(),
            MipLODBias: sampler_def.mip_lod_bias,
            MaxAnisotropy: (sampler_def.max_anisotropy as u32).max(1),
            ComparisonFunc: sampler_def.compare_op.into(),
            BorderColor: [0.0, 0.0, 0.0, 0.0],
            MinLOD: 0.0,
            MaxLOD: max_lod,
        };

        let sampler_heap = &device_context.inner.heaps.sampler_heap;
        let sampler_descriptor = device_context
            .inner
            .heaps
            .sampler_heap
            .allocate(device_context.d3d12_device(), 1)?;
        unsafe {
            device_context.d3d12_device().CreateSampler(
                &sampler_desc,
                sampler_heap.id_to_cpu_handle(sampler_descriptor),
            )
        };

        let inner = RafxSamplerDx12Inner {
            sampler_descriptor,
            sampler_desc,
            device_context: device_context.clone(),
        };

        Ok(RafxSamplerDx12 {
            inner: Arc::new(inner),
        })
    }
}