wgpu-core 26.0.1

Core implementation logic of wgpu, the cross-platform, safe, pure-rust graphics API
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

use thiserror::Error;
use wgt::error::{ErrorType, WebGpuError};

use crate::{
    command::{CommandBuffer, CommandEncoderError, EncoderStateError},
    device::DeviceError,
    global::Global,
    id::{BufferId, CommandEncoderId, TextureId},
    resource::{InvalidResourceError, ParentDevice},
    track::ResourceUsageCompatibilityError,
};

impl Global {
    pub fn command_encoder_transition_resources(
        &self,
        command_encoder_id: CommandEncoderId,
        buffer_transitions: impl Iterator<Item = wgt::BufferTransition<BufferId>>,
        texture_transitions: impl Iterator<Item = wgt::TextureTransition<TextureId>>,
    ) -> Result<(), EncoderStateError> {
        profiling::scope!("CommandEncoder::transition_resources");

        let hub = &self.hub;

        // Lock command encoder for recording
        let cmd_buf = hub
            .command_buffers
            .get(command_encoder_id.into_command_buffer_id());
        let mut cmd_buf_data = cmd_buf.data.lock();
        cmd_buf_data.record_with(|cmd_buf_data| -> Result<(), CommandEncoderError> {
            // Get and lock device
            let device = &cmd_buf.device;
            device.check_is_valid()?;
            let snatch_guard = &device.snatchable_lock.read();

            let mut usage_scope = device.new_usage_scope();
            let indices = &device.tracker_indices;
            usage_scope.buffers.set_size(indices.buffers.size());
            usage_scope.textures.set_size(indices.textures.size());

            // Process buffer transitions
            for buffer_transition in buffer_transitions {
                let buffer = hub.buffers.get(buffer_transition.buffer).get()?;
                buffer.same_device_as(cmd_buf.as_ref())?;

                usage_scope
                    .buffers
                    .merge_single(&buffer, buffer_transition.state)?;
            }

            // Process texture transitions
            for texture_transition in texture_transitions {
                let texture = hub.textures.get(texture_transition.texture).get()?;
                texture.same_device_as(cmd_buf.as_ref())?;

                unsafe {
                    usage_scope.textures.merge_single(
                        &texture,
                        texture_transition.selector,
                        texture_transition.state,
                    )
                }?;
            }

            // Record any needed barriers based on tracker data
            let cmd_buf_raw = cmd_buf_data.encoder.open()?;
            CommandBuffer::insert_barriers_from_scope(
                cmd_buf_raw,
                &mut cmd_buf_data.trackers,
                &usage_scope,
                snatch_guard,
            );
            Ok(())
        })
    }
}

/// Error encountered while attempting to perform [`Global::command_encoder_transition_resources`].
#[derive(Clone, Debug, Error)]
#[non_exhaustive]
pub enum TransitionResourcesError {
    #[error(transparent)]
    Device(#[from] DeviceError),
    #[error(transparent)]
    EncoderState(#[from] EncoderStateError),
    #[error(transparent)]
    InvalidResource(#[from] InvalidResourceError),
    #[error(transparent)]
    ResourceUsage(#[from] ResourceUsageCompatibilityError),
}

impl WebGpuError for TransitionResourcesError {
    fn webgpu_error_type(&self) -> ErrorType {
        let e: &dyn WebGpuError = match self {
            Self::Device(e) => e,
            Self::EncoderState(e) => e,
            Self::InvalidResource(e) => e,
            Self::ResourceUsage(e) => e,
        };
        e.webgpu_error_type()
    }
}