github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[rs] implement debug for public types

Browse Source 
Signed-off-by: Andrea Nardi <buongiorno19972@gmail.com>
This commit is contained in:
Andrea Nardi
2020-07-22 05:17:45 +02:00
parent 98fbdb4ea4
commit 050abe522f
3 changed files with 195 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
wgpu/src/backend/direct.rs
View File

@@ -9,26 +9,16 @@ use crate::{
use arrayvec::ArrayVec;
use futures::future::{ready, Ready};
use smallvec::SmallVec;
use std::{ffi::CString, marker::PhantomData, ops::Range, ptr, slice};
use std::{ffi::CString, fmt, marker::PhantomData, ops::Range, ptr, slice};
use typed_arena::Arena;
macro_rules! gfx_select {
($id:expr => $global:ident.$method:ident( $($param:expr),+ )) => {
match $id.backend() {
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "vulkan-portability"))]
wgt::Backend::Vulkan => $global.$method::<wgc::backend::Vulkan>( $($param),+ ),
#[cfg(any(target_os = "ios", target_os = "macos"))]
wgt::Backend::Metal => $global.$method::<wgc::backend::Metal>( $($param),+ ),
#[cfg(windows)]
wgt::Backend::Dx12 => $global.$method::<wgc::backend::Dx12>( $($param),+ ),
#[cfg(windows)]
wgt::Backend::Dx11 => $global.$method::<wgc::backend::Dx11>( $($param),+ ),
_ => unreachable!()
}
};
}
pub struct Context(pub wgc::hub::Global<wgc::hub::IdentityManagerFactory>);
pub type Context = wgc::hub::Global<wgc::hub::IdentityManagerFactory>;
impl fmt::Debug for Context {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Context").field("type", &"Native").finish()
}
}
mod pass_impl {
use super::Context;
@@ -485,21 +475,25 @@ impl crate::Context for Context {
type MapAsyncFuture = native_gpu_future::GpuFuture<Result<(), crate::BufferAsyncError>>;
fn init(backends: wgt::BackendBit) -> Self {
wgc::hub::Global::new("wgpu", wgc::hub::IdentityManagerFactory, backends)
Self(wgc::hub::Global::new(
"wgpu",
wgc::hub::IdentityManagerFactory,
backends,
))
}
fn instance_create_surface(
&self,
handle: &impl raw_window_handle::HasRawWindowHandle,
) -> Self::SurfaceId {
self.instance_create_surface(handle, PhantomData)
self.0.instance_create_surface(handle, PhantomData)
}
fn instance_request_adapter(
&self,
options: &crate::RequestAdapterOptions,
) -> Self::RequestAdapterFuture {
let id = self.pick_adapter(
let id = self.0.pick_adapter(
&wgc::instance::RequestAdapterOptions {
power_preference: options.power_preference,
compatible_surface: options.compatible_surface.map(|surface| surface.id),
@@ -515,24 +509,29 @@ impl crate::Context for Context {
desc: &crate::DeviceDescriptor,
trace_dir: Option<&std::path::Path>,
) -> Self::RequestDeviceFuture {
let device_id = gfx_select!(*adapter => self.adapter_request_device(*adapter, desc, trace_dir, PhantomData)).unwrap();
let global = &self.0;
let device_id = wgc::gfx_select!(*adapter => global.adapter_request_device(*adapter, desc, trace_dir, PhantomData)).unwrap();
ready(Ok((device_id, device_id)))
}
fn adapter_features(&self, adapter: &Self::AdapterId) -> Features {
gfx_select!(*adapter => self.adapter_features(*adapter))
let global = &self.0;
wgc::gfx_select!(*adapter => global.adapter_features(*adapter))
}
fn adapter_limits(&self, adapter: &Self::AdapterId) -> Limits {
gfx_select!(*adapter => self.adapter_limits(*adapter))
let global = &self.0;
wgc::gfx_select!(*adapter => global.adapter_limits(*adapter))
}
fn device_features(&self, device: &Self::DeviceId) -> Features {
gfx_select!(*device => self.device_features(*device))
let global = &self.0;
wgc::gfx_select!(*device => global.device_features(*device))
}
fn device_limits(&self, device: &Self::DeviceId) -> Limits {
gfx_select!(*device => self.device_limits(*device))
let global = &self.0;
wgc::gfx_select!(*device => global.device_limits(*device))
}
fn device_create_swap_chain(
@@ -541,7 +540,8 @@ impl crate::Context for Context {
surface: &Self::SurfaceId,
desc: &wgt::SwapChainDescriptor,
) -> Self::SwapChainId {
gfx_select!(*device => self.device_create_swap_chain(*device, *surface, desc))
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_swap_chain(*device, *surface, desc))
}
fn device_create_shader_module(
@@ -553,7 +553,8 @@ impl crate::Context for Context {
ShaderModuleSource::SpirV(ref spv) => wgc::pipeline::ShaderModuleSource::SpirV(spv),
ShaderModuleSource::Wgsl(ref code) => wgc::pipeline::ShaderModuleSource::Wgsl(code),
};
gfx_select!(*device => self.device_create_shader_module(*device, desc, PhantomData))
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_shader_module(*device, desc, PhantomData))
}
fn device_create_bind_group_layout(
@@ -561,7 +562,8 @@ impl crate::Context for Context {
device: &Self::DeviceId,
desc: &BindGroupLayoutDescriptor,
) -> Self::BindGroupLayoutId {
gfx_select!(*device => self.device_create_bind_group_layout(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_bind_group_layout(
*device,
desc,
PhantomData
@@ -607,7 +609,8 @@ impl crate::Context for Context {
})
.collect::<Vec<_>>();
gfx_select!(*device => self.device_create_bind_group(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_bind_group(
*device,
&bm::BindGroupDescriptor {
label: desc.label,
@@ -641,7 +644,8 @@ impl crate::Context for Context {
.map(|bgl| bgl.id)
.collect::<ArrayVec<[_; wgc::MAX_BIND_GROUPS]>>();
gfx_select!(*device => self.device_create_pipeline_layout(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_pipeline_layout(
*device,
&wgt::PipelineLayoutDescriptor {
bind_group_layouts: &temp_layouts,
@@ -672,7 +676,8 @@ impl crate::Context for Context {
entry_point: fs.entry_point,
});
gfx_select!(*device => self.device_create_render_pipeline(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_render_pipeline(
*device,
&pipe::RenderPipelineDescriptor {
layout: desc.layout.id,
@@ -699,7 +704,8 @@ impl crate::Context for Context {
) -> Self::ComputePipelineId {
use wgc::pipeline as pipe;
gfx_select!(*device => self.device_create_compute_pipeline(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_compute_pipeline(
*device,
&pipe::ComputePipelineDescriptor {
layout: desc.layout.id,
@@ -719,7 +725,9 @@ impl crate::Context for Context {
desc: &BufferDescriptor,
) -> Self::BufferId {
let owned_label = OwnedLabel::new(desc.label.as_deref());
gfx_select!(*device => self.device_create_buffer(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_buffer(
*device,
&desc.map_label(|_| owned_label.as_ptr()),
PhantomData
@@ -733,7 +741,9 @@ impl crate::Context for Context {
desc: &TextureDescriptor,
) -> Self::TextureId {
let owned_label = OwnedLabel::new(desc.label.as_deref());
gfx_select!(*device => self.device_create_texture(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_texture(
*device,
&desc.map_label(|_| owned_label.as_ptr()),
PhantomData
@@ -747,7 +757,9 @@ impl crate::Context for Context {
desc: &SamplerDescriptor,
) -> Self::SamplerId {
let owned_label = OwnedLabel::new(desc.label.as_deref());
gfx_select!(*device => self.device_create_sampler(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_sampler(
*device,
&desc.map_label(|_| owned_label.as_ptr()),
PhantomData
@@ -760,7 +772,9 @@ impl crate::Context for Context {
desc: &CommandEncoderDescriptor,
) -> Self::CommandEncoderId {
let owned_label = OwnedLabel::new(desc.label.as_deref());
gfx_select!(*device => self.device_create_command_encoder(
let global = &self.0;
wgc::gfx_select!(*device => global.device_create_command_encoder(
*device,
&wgt::CommandEncoderDescriptor {
label: owned_label.as_ptr(),
@@ -779,15 +793,22 @@ impl crate::Context for Context {
fn device_drop(&self, device: &Self::DeviceId) {
#[cfg(not(target_arch = "wasm32"))]
gfx_select!(*device => self.device_poll(*device, true)).unwrap();
{
let global = &self.0;
wgc::gfx_select!(*device => global.device_poll(*device, true)).unwrap();
}
//TODO: make this work in general
#[cfg(not(target_arch = "wasm32"))]
#[cfg(feature = "metal-auto-capture")]
gfx_select!(*device => self.device_destroy(*device));
{
let global = &self.0;
wgc::gfx_select!(*device => global.device_destroy(*device));
}
}
fn device_poll(&self, device: &Self::DeviceId, maintain: crate::Maintain) {
gfx_select!(*device => self.device_poll(
let global = &self.0;
wgc::gfx_select!(*device => global.device_poll(
*device,
match maintain {
crate::Maintain::Poll => false,
@@ -827,7 +848,9 @@ impl crate::Context for Context {
callback: buffer_map_future_wrapper,
user_data: completion.to_raw() as _,
};
gfx_select!(*buffer => self.buffer_map_async(*buffer, range, operation)).unwrap();
let global = &self.0;
wgc::gfx_select!(*buffer => global.buffer_map_async(*buffer, range, operation)).unwrap();
future
}
@@ -838,7 +861,8 @@ impl crate::Context for Context {
sub_range: Range<wgt::BufferAddress>,
) -> &[u8] {
let size = sub_range.end - sub_range.start;
let ptr = gfx_select!(*buffer => self.buffer_get_mapped_range(
let global = &self.0;
let ptr = wgc::gfx_select!(*buffer => global.buffer_get_mapped_range(
*buffer,
sub_range.start,
wgt::BufferSize::new(size)
@@ -853,7 +877,8 @@ impl crate::Context for Context {
sub_range: Range<wgt::BufferAddress>,
) -> &mut [u8] {
let size = sub_range.end - sub_range.start;
let ptr = gfx_select!(*buffer => self.buffer_get_mapped_range(
let global = &self.0;
let ptr = wgc::gfx_select!(*buffer => global.buffer_get_mapped_range(
*buffer,
sub_range.start,
wgt::BufferSize::new(size)
@@ -863,7 +888,8 @@ impl crate::Context for Context {
}
fn buffer_unmap(&self, buffer: &Self::BufferId) {
gfx_select!(*buffer => self.buffer_unmap(*buffer)).unwrap();
let global = &self.0;
wgc::gfx_select!(*buffer => global.buffer_unmap(*buffer)).unwrap();
}
fn swap_chain_get_current_texture_view(
@@ -874,8 +900,9 @@ impl crate::Context for Context {
SwapChainStatus,
Self::SwapChainOutputDetail,
) {
let global = &self.0;
let wgc::swap_chain::SwapChainOutput { status, view_id } =
gfx_select!(*swap_chain => self.swap_chain_get_current_texture_view(*swap_chain, PhantomData)).unwrap();
wgc::gfx_select!(*swap_chain => global.swap_chain_get_current_texture_view(*swap_chain, PhantomData)).unwrap();
(
view_id,
@@ -887,7 +914,8 @@ impl crate::Context for Context {
}
fn swap_chain_present(&self, view: &Self::TextureViewId, detail: &Self::SwapChainOutputDetail) {
gfx_select!(*view => self.swap_chain_present(detail.swap_chain_id)).unwrap();
let global = &self.0;
wgc::gfx_select!(*view => global.swap_chain_present(detail.swap_chain_id)).unwrap();
}
fn texture_create_view(
@@ -897,44 +925,57 @@ impl crate::Context for Context {
) -> Self::TextureViewId {
let owned_label = OwnedLabel::new(desc.and_then(|d| d.label.as_deref()));
let descriptor = desc.map(|d| d.map_label(|_| owned_label.as_ptr()));
gfx_select!(*texture => self.texture_create_view(*texture, descriptor.as_ref(), PhantomData))
let global = &self.0;
wgc::gfx_select!(*texture => global.texture_create_view(*texture, descriptor.as_ref(), PhantomData))
}
fn texture_drop(&self, texture: &Self::TextureId) {
gfx_select!(*texture => self.texture_destroy(*texture))
let global = &self.0;
wgc::gfx_select!(*texture => global.texture_destroy(*texture))
}
fn texture_view_drop(&self, texture_view: &Self::TextureViewId) {
gfx_select!(*texture_view => self.texture_view_destroy(*texture_view))
let global = &self.0;
wgc::gfx_select!(*texture_view => global.texture_view_destroy(*texture_view))
}
fn sampler_drop(&self, sampler: &Self::SamplerId) {
gfx_select!(*sampler => self.sampler_destroy(*sampler))
let global = &self.0;
wgc::gfx_select!(*sampler => global.sampler_destroy(*sampler))
}
fn buffer_drop(&self, buffer: &Self::BufferId) {
gfx_select!(*buffer => self.buffer_destroy(*buffer))
let global = &self.0;
wgc::gfx_select!(*buffer => global.buffer_destroy(*buffer))
}
fn bind_group_drop(&self, bind_group: &Self::BindGroupId) {
gfx_select!(*bind_group => self.bind_group_destroy(*bind_group))
let global = &self.0;
wgc::gfx_select!(*bind_group => global.bind_group_destroy(*bind_group))
}
fn bind_group_layout_drop(&self, bind_group_layout: &Self::BindGroupLayoutId) {
gfx_select!(*bind_group_layout => self.bind_group_layout_destroy(*bind_group_layout))
let global = &self.0;
wgc::gfx_select!(*bind_group_layout => global.bind_group_layout_destroy(*bind_group_layout))
}
fn pipeline_layout_drop(&self, pipeline_layout: &Self::PipelineLayoutId) {
gfx_select!(*pipeline_layout => self.pipeline_layout_destroy(*pipeline_layout))
let global = &self.0;
wgc::gfx_select!(*pipeline_layout => global.pipeline_layout_destroy(*pipeline_layout))
}
fn shader_module_drop(&self, shader_module: &Self::ShaderModuleId) {
gfx_select!(*shader_module => self.shader_module_destroy(*shader_module))
let global = &self.0;
wgc::gfx_select!(*shader_module => global.shader_module_destroy(*shader_module))
}
fn command_buffer_drop(&self, command_buffer: &Self::CommandBufferId) {
gfx_select!(*command_buffer => self.command_buffer_destroy(*command_buffer))
let global = &self.0;
wgc::gfx_select!(*command_buffer => global.command_buffer_destroy(*command_buffer))
}
fn render_bundle_drop(&self, render_bundle: &Self::RenderBundleId) {
gfx_select!(*render_bundle => self.render_bundle_destroy(*render_bundle))
let global = &self.0;
wgc::gfx_select!(*render_bundle => global.render_bundle_destroy(*render_bundle))
}
fn compute_pipeline_drop(&self, pipeline: &Self::ComputePipelineId) {
gfx_select!(*pipeline => self.compute_pipeline_destroy(*pipeline))
let global = &self.0;
wgc::gfx_select!(*pipeline => global.compute_pipeline_destroy(*pipeline))
}
fn render_pipeline_drop(&self, pipeline: &Self::RenderPipelineId) {
gfx_select!(*pipeline => self.render_pipeline_destroy(*pipeline))
let global = &self.0;
wgc::gfx_select!(*pipeline => global.render_pipeline_destroy(*pipeline))
}
fn command_encoder_copy_buffer_to_buffer(
@@ -946,7 +987,8 @@ impl crate::Context for Context {
destination_offset: wgt::BufferAddress,
copy_size: wgt::BufferAddress,
) {
gfx_select!(*encoder => self.command_encoder_copy_buffer_to_buffer(
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_copy_buffer_to_buffer(
*encoder,
*source,
source_offset,
@@ -964,7 +1006,8 @@ impl crate::Context for Context {
destination: crate::TextureCopyView,
copy_size: wgt::Extent3d,
) {
gfx_select!(*encoder => self.command_encoder_copy_buffer_to_texture(
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_copy_buffer_to_texture(
*encoder,
&map_buffer_copy_view(source),
&map_texture_copy_view(destination),
@@ -980,7 +1023,8 @@ impl crate::Context for Context {
destination: crate::BufferCopyView,
copy_size: wgt::Extent3d,
) {
gfx_select!(*encoder => self.command_encoder_copy_texture_to_buffer(
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_copy_texture_to_buffer(
*encoder,
&map_texture_copy_view(source),
&map_buffer_copy_view(destination),
@@ -996,7 +1040,8 @@ impl crate::Context for Context {
destination: crate::TextureCopyView,
copy_size: wgt::Extent3d,
) {
gfx_select!(*encoder => self.command_encoder_copy_texture_to_texture(
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_copy_texture_to_texture(
*encoder,
&map_texture_copy_view(source),
&map_texture_copy_view(destination),
@@ -1017,7 +1062,9 @@ impl crate::Context for Context {
encoder: &Self::CommandEncoderId,
pass: &mut Self::ComputePassId,
) {
gfx_select!(*encoder => self.command_encoder_run_compute_pass(*encoder, pass)).unwrap()
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_run_compute_pass(*encoder, pass))
.unwrap()
}
fn command_encoder_begin_render_pass<'a>(
@@ -1058,12 +1105,15 @@ impl crate::Context for Context {
encoder: &Self::CommandEncoderId,
pass: &mut Self::RenderPassId,
) {
gfx_select!(*encoder => self.command_encoder_run_render_pass(*encoder, pass)).unwrap()
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_run_render_pass(*encoder, pass))
.unwrap()
}
fn command_encoder_finish(&self, encoder: &Self::CommandEncoderId) -> Self::CommandBufferId {
let desc = wgt::CommandBufferDescriptor::default();
gfx_select!(*encoder => self.command_encoder_finish(*encoder, &desc)).unwrap()
let global = &self.0;
wgc::gfx_select!(*encoder => global.command_encoder_finish(*encoder, &desc)).unwrap()
}
fn render_bundle_encoder_finish(
@@ -1072,7 +1122,8 @@ impl crate::Context for Context {
desc: &crate::RenderBundleDescriptor,
) -> Self::RenderBundleId {
let owned_label = OwnedLabel::new(desc.label.as_deref());
gfx_select!(encoder.parent() => self.render_bundle_encoder_finish(
let global = &self.0;
wgc::gfx_select!(encoder.parent() => global.render_bundle_encoder_finish(
encoder,
&desc.map_label(|_| owned_label.as_ptr()),
PhantomData
@@ -1087,7 +1138,8 @@ impl crate::Context for Context {
offset: wgt::BufferAddress,
data: &[u8],
) {
gfx_select!(*queue => self.queue_write_buffer(*queue, *buffer, offset, data))
let global = &self.0;
wgc::gfx_select!(*queue => global.queue_write_buffer(*queue, *buffer, offset, data))
}
fn queue_write_texture(
@@ -1098,7 +1150,8 @@ impl crate::Context for Context {
data_layout: wgt::TextureDataLayout,
size: wgt::Extent3d,
) {
gfx_select!(*queue => self.queue_write_texture(
let global = &self.0;
wgc::gfx_select!(*queue => global.queue_write_texture(
*queue,
&map_texture_copy_view(texture),
data,
@@ -1114,7 +1167,8 @@ impl crate::Context for Context {
) {
let temp_command_buffers = command_buffers.collect::<SmallVec<[_; 4]>>();
gfx_select!(*queue => self.queue_submit(*queue, &temp_command_buffers)).unwrap()
let global = &self.0;
wgc::gfx_select!(*queue => global.queue_submit(*queue, &temp_command_buffers)).unwrap()
}
}

19
wgpu/src/backend/web.rs
View File

@@ -7,6 +7,7 @@ use crate::{
use futures::FutureExt;
use std::{
fmt,
future::Future,
marker::PhantomData,
ops::Range,
@@ -23,14 +24,26 @@ use wasm_bindgen::prelude::*;
// type is (for now) harmless. Eventually wasm32 will support threading, and depending on how this
// is integrated (or not integrated) with values like those in webgpu, this may become unsound.
#[derive(Debug, Clone)]
//forse run from integration system
#[derive(Clone, Debug)]
pub(crate) struct Sendable<T>(T);
unsafe impl<T> Send for Sendable<T> {}
unsafe impl<T> Sync for Sendable<T> {}
pub(crate) type Context = Sendable<web_sys::Gpu>;
pub(crate) struct Context(web_sys::Gpu);
unsafe impl Send for Context {}
unsafe impl Sync for Context {}
impl fmt::Debug for Context {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Context").field("type", &"Web").finish()
}
}
#[derive(Debug)]
pub(crate) struct ComputePass(web_sys::GpuComputePassEncoder);
#[derive(Debug)]
pub(crate) struct RenderPass(web_sys::GpuRenderPassEncoder);
// We need to assert that any future we return is Send to match the native API.
@@ -700,7 +713,7 @@ impl crate::Context for Context {
type MapAsyncFuture = MakeSendFuture<MapFuture<()>>;
fn init(_backends: wgt::BackendBit) -> Self {
Sendable(web_sys::window().unwrap().navigator().gpu())
Context(web_sys::window().unwrap().navigator().gpu())
}
fn instance_create_surface(

85
wgpu/src/lib.rs
View File

@@ -146,28 +146,28 @@ trait RenderPassInner<Ctx: Context>: RenderInner<Ctx> {
);
}
trait Context: Sized {
type AdapterId: Send + Sync + 'static;
type DeviceId: Send + Sync + 'static;
type QueueId: Send + Sync + 'static;
type ShaderModuleId: Send + Sync + 'static;
type BindGroupLayoutId: Send + Sync + 'static;
type BindGroupId: Send + Sync + 'static;
type TextureViewId: Send + Sync + 'static;
type SamplerId: Send + Sync + 'static;
type BufferId: Send + Sync + 'static;
type TextureId: Send + Sync + 'static;
type PipelineLayoutId: Send + Sync + 'static;
type RenderPipelineId: Send + Sync + 'static;
type ComputePipelineId: Send + Sync + 'static;
type CommandEncoderId;
type ComputePassId: ComputePassInner<Self>;
type RenderPassId: RenderPassInner<Self>;
type CommandBufferId: Send + Sync;
trait Context: Debug + Send + Sized + Sync {
type AdapterId: Debug + Send + Sync + 'static;
type DeviceId: Debug + Send + Sync + 'static;
type QueueId: Debug + Send + Sync + 'static;
type ShaderModuleId: Debug + Send + Sync + 'static;
type BindGroupLayoutId: Debug + Send + Sync + 'static;
type BindGroupId: Debug + Send + Sync + 'static;
type TextureViewId: Debug + Send + Sync + 'static;
type SamplerId: Debug + Send + Sync + 'static;
type BufferId: Debug + Send + Sync + 'static;
type TextureId: Debug + Send + Sync + 'static;
type PipelineLayoutId: Debug + Send + Sync + 'static;
type RenderPipelineId: Debug + Send + Sync + 'static;
type ComputePipelineId: Debug + Send + Sync + 'static;
type CommandEncoderId: Debug;
type ComputePassId: Debug + ComputePassInner<Self>;
type RenderPassId: Debug + RenderPassInner<Self>;
type CommandBufferId: Debug + Send + Sync;
type RenderBundleEncoderId: RenderInner<Self>;
type RenderBundleId: Send + Sync + 'static;
type SurfaceId: Send + Sync + 'static;
type SwapChainId: Send + Sync + 'static;
type RenderBundleId: Debug + Send + Sync + 'static;
type SurfaceId: Debug + Send + Sync + 'static;
type SwapChainId: Debug + Send + Sync + 'static;
type SwapChainOutputDetail: Send;
@@ -390,6 +390,7 @@ trait Context: Sized {
/// Its primary use is to create [`Adapter`]s and [`Surface`]s.
///
/// Does not have to be kept alive.
#[derive(Debug)]
pub struct Instance {
context: Arc<C>,
}
@@ -400,6 +401,7 @@ pub struct Instance {
/// on the host system by using [`Adapter::request_device`].
///
/// Does not have to be kept alive.
#[derive(Debug)]
pub struct Adapter {
context: Arc<C>,
id: <C as Context>::AdapterId,
@@ -411,6 +413,7 @@ pub struct Adapter {
/// These are then used in commands, which are submitted to a [`Queue`].
///
/// A device may be requested from an adapter with [`Adapter::request_device`].
#[derive(Debug)]
pub struct Device {
context: Arc<C>,
id: <C as Context>::DeviceId,
@@ -490,6 +493,7 @@ impl MapContext {
/// Handle to a GPU-accessible buffer.
///
/// Created with [`Device::create_buffer`] or [`Device::create_buffer_with_data`]
#[derive(Debug)]
pub struct Buffer {
context: Arc<C>,
id: <C as Context>::BufferId,
@@ -502,7 +506,7 @@ pub struct Buffer {
/// Created by calling [`Buffer::slice`]. To use the whole buffer, call with unbounded slice:
///
/// `buffer.slice(..)`
#[derive(Copy, Clone)]
#[derive(Copy, Clone, Debug)]
pub struct BufferSlice<'a> {
buffer: &'a Buffer,
offset: BufferAddress,
@@ -512,6 +516,7 @@ pub struct BufferSlice<'a> {
/// Handle to a texture on the GPU.
///
/// Created by calling [`Device::create_texture`]
#[derive(Debug)]
pub struct Texture {
context: Arc<C>,
id: <C as Context>::TextureId,
@@ -522,6 +527,7 @@ pub struct Texture {
///
/// A `TextureView` object describes a texture and associated metadata needed by a
/// [`RenderPipeline`] or [`BindGroup`].
#[derive(Debug)]
pub struct TextureView {
context: Arc<C>,
id: <C as Context>::TextureViewId,
@@ -533,6 +539,7 @@ pub struct TextureView {
/// A `Sampler` object defines how a pipeline will sample from a [`TextureView`]. Samplers define
/// image filters (including anisotropy) and address (wrapping) modes, among other things. See
/// the documentation for [`SamplerDescriptor`] for more information.
#[derive(Debug)]
pub struct Sampler {
context: Arc<C>,
id: <C as Context>::SamplerId,
@@ -550,6 +557,7 @@ impl Drop for Sampler {
///
/// A `Surface` represents a platform-specific surface (e.g. a window) onto which rendered images may
/// be presented. A `Surface` may be created with the unsafe function [`Instance::create_surface`].
#[derive(Debug)]
pub struct Surface {
id: <C as Context>::SurfaceId,
}
@@ -558,6 +566,7 @@ pub struct Surface {
///
/// A `SwapChain` represents the image or series of images that will be presented to a [`Surface`].
/// A `SwapChain` may be created with [`Device::create_swap_chain`].
#[derive(Debug)]
pub struct SwapChain {
context: Arc<C>,
id: <C as Context>::SwapChainId,
@@ -569,6 +578,7 @@ pub struct SwapChain {
/// create a [`BindGroupDescriptor`] object, which in turn can be used to create a [`BindGroup`]
/// object with [`Device::create_bind_group`]. A series of `BindGroupLayout`s can also be used to
/// create a [`PipelineLayoutDescriptor`], which can be used to create a [`PipelineLayout`].
#[derive(Debug)]
pub struct BindGroupLayout {
context: Arc<C>,
id: <C as Context>::BindGroupLayoutId,
@@ -588,6 +598,7 @@ impl Drop for BindGroupLayout {
/// [`BindGroupLayout`]. It can be created with [`Device::create_bind_group`]. A `BindGroup` can
/// be bound to a particular [`RenderPass`] with [`RenderPass::set_bind_group`], or to a
/// [`ComputePass`] with [`ComputePass::set_bind_group`].
#[derive(Debug)]
pub struct BindGroup {
context: Arc<C>,
id: <C as Context>::BindGroupId,
@@ -606,6 +617,7 @@ impl Drop for BindGroup {
/// A `ShaderModule` represents a compiled shader module on the GPU. It can be created by passing
/// valid SPIR-V source code to [`Device::create_shader_module`]. Shader modules are used to define
/// programmable stages of a pipeline.
#[derive(Debug)]
pub struct ShaderModule {
context: Arc<C>,
id: <C as Context>::ShaderModuleId,
@@ -638,6 +650,7 @@ pub enum ShaderModuleSource<'a> {
/// Handle to a pipeline layout.
///
/// A `PipelineLayout` object describes the available binding groups of a pipeline.
#[derive(Debug)]
pub struct PipelineLayout {
context: Arc<C>,
id: <C as Context>::PipelineLayoutId,
@@ -655,6 +668,7 @@ impl Drop for PipelineLayout {
///
/// A `RenderPipeline` object represents a graphics pipeline and its stages, bindings, vertex
/// buffers and targets. A `RenderPipeline` may be created with [`Device::create_render_pipeline`].
#[derive(Debug)]
pub struct RenderPipeline {
context: Arc<C>,
id: <C as Context>::RenderPipelineId,
@@ -672,6 +686,7 @@ impl Drop for RenderPipeline {
///
/// A `ComputePipeline` object represents a compute pipeline and its single shader stage.
/// A `ComputePipeline` may be created with [`Device::create_compute_pipeline`].
#[derive(Debug)]
pub struct ComputePipeline {
context: Arc<C>,
id: <C as Context>::ComputePipelineId,
@@ -690,6 +705,7 @@ impl Drop for ComputePipeline {
/// A `CommandBuffer` represents a complete sequence of commands that may be submitted to a command
/// queue with [`Queue::submit`]. A `CommandBuffer` is obtained by recording a series of commands to
/// a [`CommandEncoder`] and then calling [`CommandEncoder::finish`].
#[derive(Debug)]
pub struct CommandBuffer {
context: Arc<C>,
id: Option<<C as Context>::CommandBufferId>,
@@ -712,6 +728,7 @@ impl Drop for CommandBuffer {
///
/// When finished recording, call [`CommandEncoder::finish`] to obtain a [`CommandBuffer`] which may
/// be submitted for execution.
#[derive(Debug)]
pub struct CommandEncoder {
context: Arc<C>,
id: <C as Context>::CommandEncoderId,
@@ -721,12 +738,14 @@ pub struct CommandEncoder {
}
/// In-progress recording of a render pass.
#[derive(Debug)]
pub struct RenderPass<'a> {
id: <C as Context>::RenderPassId,
parent: &'a mut CommandEncoder,
}
/// In-progress recording of a compute pass.
#[derive(Debug)]
pub struct ComputePass<'a> {
id: <C as Context>::ComputePassId,
parent: &'a mut CommandEncoder,
@@ -753,6 +772,7 @@ pub struct RenderBundleEncoder<'a> {
/// can be executed onto a [`CommandEncoder`] using [`RenderPass::execute_bundles`].
///
/// Executing a [`RenderBundle`] is often more efficient then issuing the underlying commands manually.
#[derive(Debug)]
pub struct RenderBundle {
context: Arc<C>,
id: <C as Context>::RenderBundleId,
@@ -770,6 +790,7 @@ impl Drop for RenderBundle {
///
/// A `Queue` executes recorded [`CommandBuffer`] objects and provides convenience methods
/// for writing to [buffers](Queue::write_buffer) and [textures](Queue::write_texture).
#[derive(Debug)]
pub struct Queue {
context: Arc<C>,
id: <C as Context>::QueueId,
@@ -839,7 +860,7 @@ impl<V: Default> Default for Operations<V> {
}
/// Describes a color attachment to a [`RenderPass`].
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct RenderPassColorAttachmentDescriptor<'a> {
/// The view to use as an attachment.
pub attachment: &'a TextureView,
@@ -850,7 +871,7 @@ pub struct RenderPassColorAttachmentDescriptor<'a> {
}
/// Describes a depth/stencil attachment to a [`RenderPass`].
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct RenderPassDepthStencilAttachmentDescriptor<'a> {
/// The view to use as an attachment.
pub attachment: &'a TextureView,
@@ -934,6 +955,7 @@ pub use wgt::TextureCopyView as TextureCopyViewBase;
pub type TextureCopyView<'a> = TextureCopyViewBase<&'a Texture>;
/// Swap chain image that can be rendered to.
#[derive(Debug)]
pub struct SwapChainTexture {
/// Accessible view of the frame.
pub view: TextureView,
@@ -941,6 +963,7 @@ pub struct SwapChainTexture {
}
/// Result of a successful call to [`SwapChain::get_next_frame`].
#[derive(Debug)]
pub struct SwapChainFrame {
/// The texture into which the next frame should be rendered.
pub output: SwapChainTexture,
@@ -997,6 +1020,7 @@ impl Instance {
pub fn enumerate_adapters(&self, backends: BackendBit) -> impl Iterator<Item = Adapter> {
let context = Arc::clone(&self.context);
self.context
.0
.enumerate_adapters(wgc::instance::AdapterInputs::Mask(backends, |_| {
PhantomData
}))
@@ -1049,13 +1073,13 @@ impl Instance {
let surface = wgc::instance::Surface {
#[cfg(feature = "vulkan-portability")]
vulkan: None, //TODO: create_surface_from_layer ?
metal: self.context.instance.metal.as_ref().map(|inst| {
metal: self.context.0.instance.metal.as_ref().map(|inst| {
inst.create_surface_from_layer(layer as *mut _, cfg!(debug_assertions))
}),
};
crate::Surface {
id: self.context.surfaces.register_identity(
id: self.context.0.surfaces.register_identity(
PhantomData,
surface,
&mut wgc::hub::Token::root(),
@@ -1122,8 +1146,8 @@ impl Adapter {
/// Get info about the adapter itself.
#[cfg(not(target_arch = "wasm32"))]
pub fn get_info(&self) -> AdapterInfo {
let context = &self.context;
wgc::gfx_select!(self.id => context.adapter_get_info(self.id))
let global = &self.context.0;
wgc::gfx_select!(self.id => global.adapter_get_info(self.id))
}
}
@@ -1248,7 +1272,8 @@ impl Device {
mapped_at_creation: true,
});
let range = Context::buffer_get_mapped_range_mut(&*self.context, &buffer.id, 0..padded_size);
let range =
Context::buffer_get_mapped_range_mut(&*self.context, &buffer.id, 0..padded_size);
range[0..unpadded_size as usize].copy_from_slice(&data);
for i in unpadded_size..padded_size {
range[i as usize] = 0;
@@ -1352,12 +1377,14 @@ fn range_to_offset_size<S: RangeBounds<BufferAddress>>(
}
/// Read only view into a mapped buffer.
#[derive(Debug)]
pub struct BufferView<'a> {
slice: BufferSlice<'a>,
data: &'a [u8],
}
/// Write only view into mapped buffer.
#[derive(Debug)]
pub struct BufferViewMut<'a> {
slice: BufferSlice<'a>,
data: &'a mut [u8],