357: Explicit Global hubs r=grovesNL a=kvark

Fixes #354

Co-authored-by: Dzmitry Malyshau <kvarkus@gmail.com>
This commit is contained in:
bors[bot]andDzmitry Malyshau authored and GitHub committed 2019-10-25 02:08:56 +00:00
commit c8d0da65ad
22 files changed
+729 -477

No files matched your search

+1 -1
View File
@@ -58,7 +58,7 @@ before_install:
script:
- cargo test
# TODO: enable GL backend
#- (cd wgpu-native && cargo check --features local,glutin)
- (cd wgpu-native && cargo check --features local)
- if [[ $TRAVIS_OS_NAME == "osx" ]]; then (cd wgpu-native && cargo check --features gfx-backend-vulkan); fi
- if [[ $TRAVIS_OS_NAME == "linux" ]]; then cargo check --release; fi
- if [[ $TRAVIS_RUST_VERSION == "nightly" ]]; then cargo +nightly install cbindgen; fi
+1 -1
View File
@@ -44,7 +44,7 @@ clear:
$(CLEAN_FFI_DIR)
lib-native: Cargo.lock wgpu-native/Cargo.toml $(WILDCARD_WGPU_NATIVE)
cargo build --manifest-path wgpu-native/Cargo.toml
cargo build --manifest-path wgpu-native/Cargo.toml --features local
lib-remote: Cargo.lock wgpu-remote/Cargo.toml $(WILDCARD_WGPU_NATIVE_AND_REMOTE)
cargo build --manifest-path wgpu-remote/Cargo.toml
+102 -22
View File
@@ -665,71 +665,97 @@ typedef struct {
uint32_t array_layer_count;
} WGPUTextureViewDescriptor;
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUDeviceId wgpu_adapter_request_device(WGPUAdapterId adapter_id,
const WGPUDeviceDescriptor *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_bind_group_destroy(WGPUBindGroupId bind_group_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_buffer_destroy(WGPUBufferId buffer_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_buffer_map_read_async(WGPUBufferId buffer_id,
WGPUBufferAddress start,
WGPUBufferAddress size,
WGPUBufferMapReadCallback callback,
uint8_t *userdata);
#endif
#if defined(WGPU_LOCAL)
void wgpu_buffer_map_write_async(WGPUBufferId buffer_id,
WGPUBufferAddress start,
WGPUBufferAddress size,
WGPUBufferMapWriteCallback callback,
uint8_t *userdata);
#endif
#if defined(WGPU_LOCAL)
void wgpu_buffer_unmap(WGPUBufferId buffer_id);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUComputePassId wgpu_command_encoder_begin_compute_pass(WGPUCommandEncoderId encoder_id,
const WGPUComputePassDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPURenderPassId wgpu_command_encoder_begin_render_pass(WGPUCommandEncoderId encoder_id,
const WGPURenderPassDescriptor *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_command_encoder_copy_buffer_to_buffer(WGPUCommandEncoderId command_encoder_id,
WGPUBufferId source,
WGPUBufferAddress source_offset,
WGPUBufferId destination,
WGPUBufferAddress destination_offset,
WGPUBufferAddress size);
#endif
#if defined(WGPU_LOCAL)
void wgpu_command_encoder_copy_buffer_to_texture(WGPUCommandEncoderId command_encoder_id,
const WGPUBufferCopyView *source,
const WGPUTextureCopyView *destination,
WGPUExtent3d copy_size);
#endif
#if defined(WGPU_LOCAL)
void wgpu_command_encoder_copy_texture_to_buffer(WGPUCommandEncoderId command_encoder_id,
const WGPUTextureCopyView *source,
const WGPUBufferCopyView *destination,
WGPUExtent3d copy_size);
#endif
#if defined(WGPU_LOCAL)
void wgpu_command_encoder_copy_texture_to_texture(WGPUCommandEncoderId command_encoder_id,
const WGPUTextureCopyView *source,
const WGPUTextureCopyView *destination,
WGPUExtent3d copy_size);
#endif
#if defined(WGPU_LOCAL)
WGPUCommandBufferId wgpu_command_encoder_finish(WGPUCommandEncoderId encoder_id,
const WGPUCommandBufferDescriptor *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_compute_pass_dispatch(WGPUComputePassId pass_id, uint32_t x, uint32_t y, uint32_t z);
#endif
#if defined(WGPU_LOCAL)
void wgpu_compute_pass_dispatch_indirect(WGPUComputePassId pass_id,
WGPUBufferId indirect_buffer_id,
WGPUBufferAddress indirect_offset);
#endif
#if defined(WGPU_LOCAL)
void wgpu_compute_pass_end_pass(WGPUComputePassId pass_id);
#endif
void wgpu_compute_pass_insert_debug_marker(WGPUComputePassId _pass_id, WGPURawString _label);
@@ -737,160 +763,205 @@ void wgpu_compute_pass_pop_debug_group(WGPUComputePassId _pass_id);
void wgpu_compute_pass_push_debug_group(WGPUComputePassId _pass_id, WGPURawString _label);
#if defined(WGPU_LOCAL)
void wgpu_compute_pass_set_bind_group(WGPUComputePassId pass_id,
uint32_t index,
WGPUBindGroupId bind_group_id,
const WGPUBufferAddress *offsets,
uintptr_t offsets_length);
#endif
#if defined(WGPU_LOCAL)
void wgpu_compute_pass_set_pipeline(WGPUComputePassId pass_id, WGPUComputePipelineId pipeline_id);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSurfaceId wgpu_create_surface_from_metal_layer(void *layer);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSurfaceId wgpu_create_surface_from_windows_hwnd(void *_hinstance, void *hwnd);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSurfaceId wgpu_create_surface_from_xlib(const void **display, uint64_t window);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUBindGroupId wgpu_device_create_bind_group(WGPUDeviceId device_id,
const WGPUBindGroupDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUBindGroupLayoutId wgpu_device_create_bind_group_layout(WGPUDeviceId device_id,
const WGPUBindGroupLayoutDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUBufferId wgpu_device_create_buffer(WGPUDeviceId device_id, const WGPUBufferDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUBufferId wgpu_device_create_buffer_mapped(WGPUDeviceId device_id,
const WGPUBufferDescriptor *desc,
uint8_t **mapped_ptr_out);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUCommandEncoderId wgpu_device_create_command_encoder(WGPUDeviceId device_id,
const WGPUCommandEncoderDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUComputePipelineId wgpu_device_create_compute_pipeline(WGPUDeviceId device_id,
const WGPUComputePipelineDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUPipelineLayoutId wgpu_device_create_pipeline_layout(WGPUDeviceId device_id,
const WGPUPipelineLayoutDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPURenderPipelineId wgpu_device_create_render_pipeline(WGPUDeviceId device_id,
const WGPURenderPipelineDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSamplerId wgpu_device_create_sampler(WGPUDeviceId device_id, const WGPUSamplerDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUShaderModuleId wgpu_device_create_shader_module(WGPUDeviceId device_id,
const WGPUShaderModuleDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSwapChainId wgpu_device_create_swap_chain(WGPUDeviceId device_id,
WGPUSurfaceId surface_id,
const WGPUSwapChainDescriptor *desc);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUTextureId wgpu_device_create_texture(WGPUDeviceId device_id, const WGPUTextureDescriptor *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_device_destroy(WGPUDeviceId device_id);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
void wgpu_device_get_limits(WGPUDeviceId _device_id, WGPULimits *limits);
#endif
#if defined(WGPU_LOCAL)
WGPUQueueId wgpu_device_get_queue(WGPUDeviceId device_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_device_poll(WGPUDeviceId device_id, bool force_wait);
#endif
#if defined(WGPU_LOCAL)
void wgpu_queue_submit(WGPUQueueId queue_id,
const WGPUCommandBufferId *command_buffers,
uintptr_t command_buffers_length);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_draw(WGPURenderPassId pass_id,
uint32_t vertex_count,
uint32_t instance_count,
uint32_t first_vertex,
uint32_t first_instance);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_draw_indexed(WGPURenderPassId pass_id,
uint32_t index_count,
uint32_t instance_count,
uint32_t first_index,
int32_t base_vertex,
uint32_t first_instance);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_draw_indexed_indirect(WGPURenderPassId pass_id,
WGPUBufferId indirect_buffer_id,
WGPUBufferAddress indirect_offset);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_draw_indirect(WGPURenderPassId pass_id,
WGPUBufferId indirect_buffer_id,
WGPUBufferAddress indirect_offset);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_end_pass(WGPURenderPassId pass_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_execute_bundles(WGPURenderPassId _pass_id,
const WGPURenderBundleId *_bundles,
uintptr_t _bundles_length);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_insert_debug_marker(WGPURenderPassId _pass_id, WGPURawString _label);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_pop_debug_group(WGPURenderPassId _pass_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_push_debug_group(WGPURenderPassId _pass_id, WGPURawString _label);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_bind_group(WGPURenderPassId pass_id,
uint32_t index,
WGPUBindGroupId bind_group_id,
const WGPUBufferAddress *offsets,
uintptr_t offsets_length);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_blend_color(WGPURenderPassId pass_id, const WGPUColor *color);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_index_buffer(WGPURenderPassId pass_id,
WGPUBufferId buffer_id,
WGPUBufferAddress offset);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_pipeline(WGPURenderPassId pass_id, WGPURenderPipelineId pipeline_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_scissor_rect(WGPURenderPassId pass_id,
uint32_t x,
uint32_t y,
uint32_t w,
uint32_t h);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_stencil_reference(WGPURenderPassId pass_id, uint32_t value);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_vertex_buffers(WGPURenderPassId pass_id,
uint32_t start_slot,
const WGPUBufferId *buffers,
const WGPUBufferAddress *offsets,
uintptr_t length);
#endif
#if defined(WGPU_LOCAL)
void wgpu_render_pass_set_viewport(WGPURenderPassId pass_id,
float x,
float y,
@@ -898,24 +969,33 @@ void wgpu_render_pass_set_viewport(WGPURenderPassId pass_id,
float h,
float min_depth,
float max_depth);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUAdapterId wgpu_request_adapter(const WGPURequestAdapterOptions *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_sampler_destroy(WGPUSamplerId sampler_id);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUSwapChainOutput wgpu_swap_chain_get_next_texture(WGPUSwapChainId swap_chain_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_swap_chain_present(WGPUSwapChainId swap_chain_id);
#endif
#if !defined(WGPU_REMOTE)
#if defined(WGPU_LOCAL)
WGPUTextureViewId wgpu_texture_create_view(WGPUTextureId texture_id,
const WGPUTextureViewDescriptor *desc);
#endif
#if defined(WGPU_LOCAL)
void wgpu_texture_destroy(WGPUTextureId texture_id);
#endif
#if defined(WGPU_LOCAL)
void wgpu_texture_view_destroy(WGPUTextureViewId texture_view_id);
#endif
+2 -2
View File
@@ -17,7 +17,7 @@ crate-type = ["lib", "cdylib", "staticlib"]
[features]
default = []
remote = ["serde"]
local = ["lazy_static"]
metal-auto-capture = ["gfx-backend-metal/auto-capture"]
#NOTE: glutin feature is not stable, use at your own risk
#glutin = ["gfx-backend-gl/glutin"]
@@ -26,7 +26,7 @@ metal-auto-capture = ["gfx-backend-metal/auto-capture"]
arrayvec = "0.5"
bitflags = "1.0"
copyless = "0.1"
lazy_static = "1.1.0"
lazy_static = { version = "1.1.0", optional = true }
log = "0.4"
hal = { package = "gfx-hal", git = "https://github.com/gfx-rs/gfx", rev = "3d5db15661127c8cad8d85522a68ec36c82f6e69" }
gfx-backend-empty = { git = "https://github.com/gfx-rs/gfx", rev = "3d5db15661127c8cad8d85522a68ec36c82f6e69" }
+3
View File
@@ -15,6 +15,9 @@ exclude = ["BufferMapResult"]
[parse]
parse_deps = false
[parse.expand]
features = ["local"]
[fn]
[struct]
+10 -3
View File
@@ -3,10 +3,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use super::CommandBuffer;
use crate::{hub::GfxBackend, track::TrackerSet, DeviceId, Features, LifeGuard, Stored, SubmissionIndex};
use crate::{
hub::GfxBackend,
track::TrackerSet,
DeviceId,
Features,
LifeGuard,
Stored,
SubmissionIndex,
};
use hal::{command::CommandBuffer as _, device::Device as _, pool::CommandPool as _};
use log::trace;
use parking_lot::Mutex;
use std::{collections::HashMap, sync::atomic::Ordering, thread};
@@ -127,7 +134,7 @@ impl<B: GfxBackend> CommandAllocator<B> {
.load(Ordering::Acquire);
if index <= last_done {
let cmd_buf = inner.pending.swap_remove(i);
trace!(
log::trace!(
"recycling comb submitted in {} when {} is done",
index,
last_done
+14 -15
View File
@@ -12,7 +12,6 @@ use crate::{
Stored,
};
use log::trace;
use smallvec::{smallvec, SmallVec};
use std::convert::identity;
@@ -36,9 +35,7 @@ pub enum LayoutChange<'a> {
#[derive(Debug)]
pub enum Provision {
Unchanged,
Changed {
was_compatible: bool,
},
Changed { was_compatible: bool },
}
struct TakeSome<I> {
@@ -95,9 +92,7 @@ impl BindGroupEntry {
self.dynamic_offsets.clear();
self.dynamic_offsets.extend_from_slice(offsets);
Provision::Changed {
was_compatible,
}
Provision::Changed { was_compatible }
}
pub fn expect_layout(&mut self, bind_group_layout_id: BindGroupLayoutId) -> LayoutChange {
@@ -108,8 +103,9 @@ impl BindGroupEntry {
Some(BindGroupPair {
layout_id,
ref group_id,
}) if layout_id == bind_group_layout_id =>
LayoutChange::Match(group_id.value, &self.dynamic_offsets),
}) if layout_id == bind_group_layout_id => {
LayoutChange::Match(group_id.value, &self.dynamic_offsets)
}
Some(_) | None => LayoutChange::Mismatch,
}
} else {
@@ -148,7 +144,7 @@ impl Binder {
pub(crate) fn new(max_bind_groups: u32) -> Self {
Self {
pipeline_layout_id: None,
entries: smallvec![Default::default(); max_bind_groups as usize]
entries: smallvec![Default::default(); max_bind_groups as usize],
}
}
@@ -174,7 +170,7 @@ impl Binder {
impl 'a + Iterator<Item = BindGroupId>,
impl 'a + Iterator<Item = &'a BufferAddress>,
)> {
trace!("\tBinding [{}] = group {:?}", index, bind_group_id);
log::trace!("\tBinding [{}] = group {:?}", index, bind_group_id);
debug_assert_eq!(B::VARIANT, bind_group_id.backend());
match self.entries[index].provide(bind_group_id, bind_group, offsets) {
@@ -182,9 +178,12 @@ impl Binder {
Provision::Changed { was_compatible, .. } => {
let compatible_count = self.compatible_count();
if index < compatible_count {
let end = compatible_count
.min(if was_compatible { index + 1 } else { self.entries.len() });
trace!("\t\tbinding up to {}", end);
let end = compatible_count.min(if was_compatible {
index + 1
} else {
self.entries.len()
});
log::trace!("\t\tbinding up to {}", end);
Some((
self.pipeline_layout_id?,
TakeSome {
@@ -197,7 +196,7 @@ impl Binder {
.flat_map(|entry| entry.dynamic_offsets.as_slice()),
))
} else {
trace!("\t\tskipping above compatible {}", compatible_count);
log::trace!("\t\tskipping above compatible {}", compatible_count);
None
}
}
+34 -19
View File
@@ -5,8 +5,7 @@
use crate::{
command::bind::{Binder, LayoutChange},
device::all_buffer_stages,
gfx_select,
hub::{GfxBackend, Token},
hub::{GfxBackend, Global, Token},
track::{Stitch, TrackerSet},
BindGroupId,
BufferAddress,
@@ -20,11 +19,14 @@ use crate::{
Stored,
BIND_BUFFER_ALIGNMENT,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL};
use hal::{self, command::CommandBuffer as _};
use log::trace;
use std::{iter, slice};
use std::iter;
#[cfg(feature = "local")]
use std::slice;
#[derive(Debug)]
pub struct ComputePass<B: hal::Backend> {
@@ -52,9 +54,9 @@ impl<B: hal::Backend> ComputePass<B> {
// Common routines between render/compute
pub fn compute_pass_end_pass<B: GfxBackend>(pass_id: ComputePassId) {
pub fn compute_pass_end_pass<B: GfxBackend>(global: &Global, pass_id: ComputePassId) {
let mut token = Token::root();
let hub = B::hub();
let hub = B::hub(global);
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
let (pass, _) = hub.compute_passes.unregister(pass_id, &mut token);
let cmb = &mut cmb_guard[pass.cmb_id.value];
@@ -65,18 +67,20 @@ pub fn compute_pass_end_pass<B: GfxBackend>(pass_id: ComputePassId) {
cmb.raw.push(pass.raw);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_compute_pass_end_pass(pass_id: ComputePassId) {
gfx_select!(pass_id => compute_pass_end_pass(pass_id))
gfx_select!(pass_id => compute_pass_end_pass(&*GLOBAL, pass_id))
}
pub fn compute_pass_set_bind_group<B: GfxBackend>(
global: &Global,
pass_id: ComputePassId,
index: u32,
bind_group_id: BindGroupId,
offsets: &[BufferAddress],
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
@@ -109,7 +113,7 @@ pub fn compute_pass_set_bind_group<B: GfxBackend>(
let (buffer_guard, mut token) = hub.buffers.read(&mut token);
let (texture_guard, _) = hub.textures.read(&mut token);
trace!(
log::trace!(
"Encoding barriers on binding of {:?} in pass {:?}",
bind_group_id,
pass_id
@@ -143,6 +147,7 @@ pub fn compute_pass_set_bind_group<B: GfxBackend>(
};
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_compute_pass_set_bind_group(
pass_id: ComputePassId,
@@ -156,7 +161,7 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
} else {
&[]
};
gfx_select!(pass_id => compute_pass_set_bind_group(pass_id, index, bind_group_id, offsets))
gfx_select!(pass_id => compute_pass_set_bind_group(&*GLOBAL, pass_id, index, bind_group_id, offsets))
}
#[no_mangle]
@@ -179,8 +184,14 @@ pub extern "C" fn wgpu_compute_pass_insert_debug_marker(
// Compute-specific routines
pub fn compute_pass_dispatch<B: GfxBackend>(pass_id: ComputePassId, x: u32, y: u32, z: u32) {
let hub = B::hub();
pub fn compute_pass_dispatch<B: GfxBackend>(
global: &Global,
pass_id: ComputePassId,
x: u32,
y: u32,
z: u32,
) {
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.compute_passes.write(&mut token);
unsafe {
@@ -188,17 +199,19 @@ pub fn compute_pass_dispatch<B: GfxBackend>(pass_id: ComputePassId, x: u32, y: u
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_compute_pass_dispatch(pass_id: ComputePassId, x: u32, y: u32, z: u32) {
gfx_select!(pass_id => compute_pass_dispatch(pass_id, x, y, z))
gfx_select!(pass_id => compute_pass_dispatch(&*GLOBAL, pass_id, x, y, z))
}
pub fn compute_pass_dispatch_indirect<B: GfxBackend>(
global: &Global,
pass_id: ComputePassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (buffer_guard, _) = hub.buffers.read(&mut token);
let (mut pass_guard, _) = hub.compute_passes.write(&mut token);
@@ -229,20 +242,22 @@ pub fn compute_pass_dispatch_indirect<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_compute_pass_dispatch_indirect(
pass_id: ComputePassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
gfx_select!(pass_id => compute_pass_dispatch_indirect(pass_id, indirect_buffer_id, indirect_offset))
gfx_select!(pass_id => compute_pass_dispatch_indirect(&*GLOBAL, pass_id, indirect_buffer_id, indirect_offset))
}
pub fn compute_pass_set_pipeline<B: GfxBackend>(
global: &Global,
pass_id: ComputePassId,
pipeline_id: ComputePipelineId,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token);
@@ -282,8 +297,7 @@ pub fn compute_pass_set_pipeline<B: GfxBackend>(
);
}
}
LayoutChange::Match(..) |
LayoutChange::Unchanged => {}
LayoutChange::Match(..) | LayoutChange::Unchanged => {}
LayoutChange::Mismatch => {
is_compatible = false;
}
@@ -292,10 +306,11 @@ pub fn compute_pass_set_pipeline<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_compute_pass_set_pipeline(
pass_id: ComputePassId,
pipeline_id: ComputePipelineId,
) {
gfx_select!(pass_id => compute_pass_set_pipeline(pass_id, pipeline_id))
gfx_select!(pass_id => compute_pass_set_pipeline(&*GLOBAL, pass_id, pipeline_id))
}
+105 -97
View File
@@ -22,8 +22,7 @@ use crate::{
RenderPassContext,
RenderPassKey,
},
gfx_select,
hub::{GfxBackend, Storage, Token},
hub::{GfxBackend, Global, Storage, Token},
id::{Input, Output},
resource::TextureViewInner,
track::{Stitch, TrackerSet},
@@ -43,22 +42,15 @@ use crate::{
TextureUsage,
TextureViewId,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL};
use arrayvec::ArrayVec;
use hal::{adapter::PhysicalDevice as _, command::CommandBuffer as _, device::Device as _};
use log::trace;
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
use std::marker::PhantomData;
use std::{
borrow::Borrow,
collections::hash_map::Entry,
iter,
mem,
ptr,
slice,
thread::ThreadId,
};
use std::{borrow::Borrow, collections::hash_map::Entry, iter, mem, ptr, slice, thread::ThreadId};
pub struct RenderBundle<B: hal::Backend> {
@@ -136,7 +128,7 @@ impl<B: GfxBackend> CommandBuffer<B> {
buffer_guard: &Storage<Buffer<B>, BufferId>,
texture_guard: &Storage<Texture<B>, TextureId>,
) {
trace!("\tstitch {:?}", stitch);
log::trace!("\tstitch {:?}", stitch);
debug_assert_eq!(B::VARIANT, base.backend());
debug_assert_eq!(B::VARIANT, head.backend());
@@ -144,7 +136,7 @@ impl<B: GfxBackend> CommandBuffer<B> {
.buffers
.merge_replace(&head.buffers, stitch)
.map(|pending| {
trace!("\tbuffer -> {:?}", pending);
log::trace!("\tbuffer -> {:?}", pending);
hal::memory::Barrier::Buffer {
states: pending.to_states(),
target: &buffer_guard[pending.id].raw,
@@ -156,7 +148,7 @@ impl<B: GfxBackend> CommandBuffer<B> {
.textures
.merge_replace(&head.textures, stitch)
.map(|pending| {
trace!("\ttexture -> {:?}", pending);
log::trace!("\ttexture -> {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture_guard[pending.id].raw,
@@ -194,10 +186,11 @@ pub struct CommandBufferDescriptor {
}
pub fn command_encoder_finish<B: GfxBackend>(
global: &Global,
encoder_id: CommandEncoderId,
_desc: &CommandBufferDescriptor,
) -> CommandBufferId {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
//TODO: actually close the last recorded command buffer
let (mut comb_guard, _) = hub.command_buffers.write(&mut token);
@@ -211,21 +204,23 @@ pub fn command_encoder_finish<B: GfxBackend>(
encoder_id
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_finish(
encoder_id: CommandEncoderId,
desc: Option<&CommandBufferDescriptor>,
) -> CommandBufferId {
let desc = &desc.cloned().unwrap_or_default();
gfx_select!(encoder_id => command_encoder_finish(encoder_id, desc))
gfx_select!(encoder_id => command_encoder_finish(&*GLOBAL, encoder_id, desc))
}
pub fn command_encoder_begin_render_pass<B: GfxBackend>(
global: &Global,
encoder_id: CommandEncoderId,
desc: &RenderPassDescriptor,
id_in: Input<RenderPassId>,
) -> Output<RenderPassId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (adapter_guard, mut token) = hub.adapters.read(&mut token);
@@ -270,7 +265,7 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
"Attachment sample_count must be supported by physical device limits"
);
trace!(
log::trace!(
"Encoding render pass begin in command buffer {:?}",
encoder_id
);
@@ -289,17 +284,15 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
}
let texture_id = match view.inner {
TextureViewInner::Native { ref source_id, .. } => source_id.value,
TextureViewInner::SwapChain {..} =>
panic!("Unexpected depth/stencil use of swapchain image!"),
TextureViewInner::SwapChain { .. } => {
panic!("Unexpected depth/stencil use of swapchain image!")
}
};
let texture = &texture_guard[texture_id];
assert!(texture.usage.contains(TextureUsage::OUTPUT_ATTACHMENT));
let old_layout = match trackers
.textures
.query(texture_id, view.range.clone())
{
let old_layout = match trackers.textures.query(texture_id, view.range.clone()) {
Some(usage) => {
conv::map_texture_state(
usage,
@@ -318,7 +311,7 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
);
barriers.extend(pending.map(|pending| {
trace!("\tdepth-stencil {:?}", pending);
log::trace!("\tdepth-stencil {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture.raw,
@@ -352,40 +345,42 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
view.samples, sample_count,
"All attachments must have the same sample_count"
);
let first_use = trackers.views
.init(at.attachment, &view.life_guard.ref_count, (), ());
let first_use =
trackers
.views
.init(at.attachment, &view.life_guard.ref_count, (), ());
let layouts = match view.inner {
TextureViewInner::Native { ref source_id, .. } => {
let texture = &texture_guard[source_id.value];
assert!(texture.usage.contains(TextureUsage::OUTPUT_ATTACHMENT));
let old_layout = match trackers
.textures
.query(source_id.value, view.range.clone())
{
Some(usage) => conv::map_texture_state(usage, hal::format::Aspects::COLOR).1,
None => {
// Required sub-resources have inconsistent states, we need to
// issue individual barriers instead of relying on the render pass.
let pending = trackers.textures.change_replace(
source_id.value,
&texture.life_guard.ref_count,
view.range.clone(),
TextureUsage::OUTPUT_ATTACHMENT,
);
barriers.extend(pending.map(|pending| {
trace!("\tcolor {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture.raw,
families: None,
range: pending.selector,
}
}));
hal::image::Layout::ColorAttachmentOptimal
}
};
let old_layout =
match trackers.textures.query(source_id.value, view.range.clone()) {
Some(usage) => {
conv::map_texture_state(usage, hal::format::Aspects::COLOR).1
}
None => {
// Required sub-resources have inconsistent states, we need to
// issue individual barriers instead of relying on the render pass.
let pending = trackers.textures.change_replace(
source_id.value,
&texture.life_guard.ref_count,
view.range.clone(),
TextureUsage::OUTPUT_ATTACHMENT,
);
barriers.extend(pending.map(|pending| {
log::trace!("\tcolor {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture.raw,
families: None,
range: pending.selector,
}
}));
hal::image::Layout::ColorAttachmentOptimal
}
};
old_layout .. hal::image::Layout::ColorAttachmentOptimal
}
TextureViewInner::SwapChain { .. } => {
@@ -400,7 +395,11 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
}
let end = hal::image::Layout::Present;
let start = if first_use { hal::image::Layout::Undefined } else { end };
let start = if first_use {
hal::image::Layout::Undefined
} else {
end
};
start .. end
}
};
@@ -424,40 +423,42 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
view.samples, 1,
"All resolve_targets must have a sample_count of 1"
);
let first_use = trackers.views
.init(resolve_target, &view.life_guard.ref_count, (), ());
let first_use =
trackers
.views
.init(resolve_target, &view.life_guard.ref_count, (), ());
let layouts = match view.inner {
TextureViewInner::Native { ref source_id, .. } => {
let texture = &texture_guard[source_id.value];
assert!(texture.usage.contains(TextureUsage::OUTPUT_ATTACHMENT));
let old_layout = match trackers
.textures
.query(source_id.value, view.range.clone())
{
Some(usage) => conv::map_texture_state(usage, hal::format::Aspects::COLOR).1,
None => {
// Required sub-resources have inconsistent states, we need to
// issue individual barriers instead of relying on the render pass.
let pending = trackers.textures.change_replace(
source_id.value,
&texture.life_guard.ref_count,
view.range.clone(),
TextureUsage::OUTPUT_ATTACHMENT,
);
barriers.extend(pending.map(|pending| {
trace!("\tresolve {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture.raw,
families: None,
range: pending.selector,
}
}));
hal::image::Layout::ColorAttachmentOptimal
}
};
let old_layout =
match trackers.textures.query(source_id.value, view.range.clone()) {
Some(usage) => {
conv::map_texture_state(usage, hal::format::Aspects::COLOR).1
}
None => {
// Required sub-resources have inconsistent states, we need to
// issue individual barriers instead of relying on the render pass.
let pending = trackers.textures.change_replace(
source_id.value,
&texture.life_guard.ref_count,
view.range.clone(),
TextureUsage::OUTPUT_ATTACHMENT,
);
barriers.extend(pending.map(|pending| {
log::trace!("\tresolve {:?}", pending);
hal::memory::Barrier::Image {
states: pending.to_states(),
target: &texture.raw,
families: None,
range: pending.selector,
}
}));
hal::image::Layout::ColorAttachmentOptimal
}
};
old_layout .. hal::image::Layout::ColorAttachmentOptimal
}
TextureViewInner::SwapChain { .. } => {
@@ -472,7 +473,11 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
}
let end = hal::image::Layout::Present;
let start = if first_use { hal::image::Layout::Undefined } else { end };
let start = if first_use {
hal::image::Layout::Undefined
} else {
end
};
start .. end
}
};
@@ -601,12 +606,16 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
let fb = {
let attachments = e.key().all().map(|&id| match view_guard[id].inner {
TextureViewInner::Native { ref raw, .. } => raw,
TextureViewInner::SwapChain { ref image, .. } => Borrow::borrow(image),
TextureViewInner::SwapChain { ref image, .. } => {
Borrow::borrow(image)
}
});
unsafe {
device
.raw
.create_framebuffer(&render_pass, attachments, extent.unwrap())
device.raw.create_framebuffer(
&render_pass,
attachments,
extent.unwrap(),
)
}
.unwrap()
};
@@ -652,9 +661,7 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
uint32: conv::map_color_u32(&at.clear_color),
},
};
Some(hal::command::ClearValue {
color: value,
})
Some(hal::command::ClearValue { color: value })
}
}
})
@@ -718,21 +725,22 @@ pub fn command_encoder_begin_render_pass<B: GfxBackend>(
hub.render_passes.register_identity(id_in, pass, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_begin_render_pass(
encoder_id: CommandEncoderId,
desc: &RenderPassDescriptor,
) -> RenderPassId {
gfx_select!(encoder_id => command_encoder_begin_render_pass(encoder_id, desc, PhantomData))
gfx_select!(encoder_id => command_encoder_begin_render_pass(&*GLOBAL, encoder_id, desc, PhantomData))
}
pub fn command_encoder_begin_compute_pass<B: GfxBackend>(
global: &Global,
encoder_id: CommandEncoderId,
_desc: &ComputePassDescriptor,
id_in: Input<ComputePassId>,
) -> Output<ComputePassId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
@@ -750,12 +758,12 @@ pub fn command_encoder_begin_compute_pass<B: GfxBackend>(
.register_identity(id_in, pass, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_begin_compute_pass(
encoder_id: CommandEncoderId,
desc: Option<&ComputePassDescriptor>,
) -> ComputePassId {
let desc = &desc.cloned().unwrap_or_default();
gfx_select!(encoder_id => command_encoder_begin_compute_pass(encoder_id, desc, PhantomData))
gfx_select!(encoder_id => command_encoder_begin_compute_pass(&*GLOBAL, encoder_id, desc, PhantomData))
}
+72 -38
View File
@@ -6,8 +6,7 @@ use crate::{
command::bind::{Binder, LayoutChange},
conv,
device::{RenderPassContext, BIND_BUFFER_ALIGNMENT, MAX_VERTEX_BUFFERS},
gfx_select,
hub::{GfxBackend, Token},
hub::{GfxBackend, Global, Token},
pipeline::{IndexFormat, InputStepMode, PipelineFlags},
resource::BufferUsage,
track::{Stitch, TrackerSet},
@@ -17,17 +16,18 @@ use crate::{
Color,
CommandBuffer,
CommandBufferId,
RawString,
RenderBundleId,
RenderPassId,
RenderPipelineId,
Stored,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL, RawString, RenderBundleId};
use hal::command::CommandBuffer as _;
use log::trace;
use std::{iter, ops::Range, slice};
#[cfg(feature = "local")]
use std::slice;
use std::{iter, ops::Range};
#[derive(Debug, PartialEq)]
enum OptionalState {
@@ -181,8 +181,8 @@ impl<B: GfxBackend> RenderPass<B> {
// Common routines between render/compute
pub fn render_pass_end_pass<B: GfxBackend>(pass_id: RenderPassId) {
let hub = B::hub();
pub fn render_pass_end_pass<B: GfxBackend>(global: &Global, pass_id: RenderPassId) {
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
let (mut pass, mut token) = hub.render_passes.unregister(pass_id, &mut token);
@@ -196,7 +196,7 @@ pub fn render_pass_end_pass<B: GfxBackend>(pass_id: RenderPassId) {
match cmb.raw.last_mut() {
Some(last) => {
trace!("Encoding barriers before pass {:?}", pass_id);
log::trace!("Encoding barriers before pass {:?}", pass_id);
CommandBuffer::insert_barriers(
last,
&mut cmb.trackers,
@@ -215,18 +215,20 @@ pub fn render_pass_end_pass<B: GfxBackend>(pass_id: RenderPassId) {
cmb.raw.push(pass.raw);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_end_pass(pass_id: RenderPassId) {
gfx_select!(pass_id => render_pass_end_pass(pass_id))
gfx_select!(pass_id => render_pass_end_pass(&*GLOBAL, pass_id))
}
pub fn render_pass_set_bind_group<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
index: u32,
bind_group_id: BindGroupId,
offsets: &[BufferAddress],
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token);
@@ -276,6 +278,7 @@ pub fn render_pass_set_bind_group<B: GfxBackend>(
};
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_bind_group(
pass_id: RenderPassId,
@@ -289,19 +292,22 @@ pub extern "C" fn wgpu_render_pass_set_bind_group(
} else {
&[]
};
gfx_select!(pass_id => render_pass_set_bind_group(pass_id, index, bind_group_id, offsets))
gfx_select!(pass_id => render_pass_set_bind_group(&*GLOBAL, pass_id, index, bind_group_id, offsets))
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_push_debug_group(_pass_id: RenderPassId, _label: RawString) {
//TODO
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_pop_debug_group(_pass_id: RenderPassId) {
//TODO
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_insert_debug_marker(_pass_id: RenderPassId, _label: RawString) {
//TODO
@@ -310,11 +316,12 @@ pub extern "C" fn wgpu_render_pass_insert_debug_marker(_pass_id: RenderPassId, _
// Render-specific routines
pub fn render_pass_set_index_buffer<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
buffer_id: BufferId,
offset: BufferAddress,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, mut token) = hub.render_passes.write(&mut token);
let (buffer_guard, _) = hub.buffers.read(&mut token);
@@ -342,22 +349,24 @@ pub fn render_pass_set_index_buffer<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_index_buffer(
pass_id: RenderPassId,
buffer_id: BufferId,
offset: BufferAddress,
) {
gfx_select!(pass_id => render_pass_set_index_buffer(pass_id, buffer_id, offset))
gfx_select!(pass_id => render_pass_set_index_buffer(&*GLOBAL, pass_id, buffer_id, offset))
}
pub fn render_pass_set_vertex_buffers<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
start_slot: u32,
buffers: &[BufferId],
offsets: &[BufferAddress],
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
assert_eq!(buffers.len(), offsets.len());
@@ -391,6 +400,7 @@ pub fn render_pass_set_vertex_buffers<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_vertex_buffers(
pass_id: RenderPassId,
@@ -401,17 +411,18 @@ pub extern "C" fn wgpu_render_pass_set_vertex_buffers(
) {
let buffers = unsafe { slice::from_raw_parts(buffers, length) };
let offsets = unsafe { slice::from_raw_parts(offsets, length) };
gfx_select!(pass_id => render_pass_set_vertex_buffers(pass_id, start_slot, buffers, offsets))
gfx_select!(pass_id => render_pass_set_vertex_buffers(&*GLOBAL, pass_id, start_slot, buffers, offsets))
}
pub fn render_pass_draw<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
vertex_count: u32,
instance_count: u32,
first_vertex: u32,
first_instance: u32,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -434,6 +445,7 @@ pub fn render_pass_draw<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_draw(
pass_id: RenderPassId,
@@ -442,15 +454,16 @@ pub extern "C" fn wgpu_render_pass_draw(
first_vertex: u32,
first_instance: u32,
) {
gfx_select!(pass_id => render_pass_draw(pass_id, vertex_count, instance_count, first_vertex, first_instance))
gfx_select!(pass_id => render_pass_draw(&*GLOBAL, pass_id, vertex_count, instance_count, first_vertex, first_instance))
}
pub fn render_pass_draw_indirect<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let (buffer_guard, _) = hub.buffers.read(&mut token);
@@ -474,16 +487,18 @@ pub fn render_pass_draw_indirect<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_draw_indirect(
pass_id: RenderPassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
gfx_select!(pass_id => render_pass_draw_indirect(pass_id, indirect_buffer_id, indirect_offset))
gfx_select!(pass_id => render_pass_draw_indirect(&*GLOBAL, pass_id, indirect_buffer_id, indirect_offset))
}
pub fn render_pass_draw_indexed<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
index_count: u32,
instance_count: u32,
@@ -491,7 +506,7 @@ pub fn render_pass_draw_indexed<B: GfxBackend>(
base_vertex: i32,
first_instance: u32,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -516,6 +531,7 @@ pub fn render_pass_draw_indexed<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_draw_indexed(
pass_id: RenderPassId,
@@ -525,15 +541,16 @@ pub extern "C" fn wgpu_render_pass_draw_indexed(
base_vertex: i32,
first_instance: u32,
) {
gfx_select!(pass_id => render_pass_draw_indexed(pass_id, index_count, instance_count, first_index, base_vertex, first_instance))
gfx_select!(pass_id => render_pass_draw_indexed(&*GLOBAL, pass_id, index_count, instance_count, first_index, base_vertex, first_instance))
}
pub fn render_pass_draw_indexed_indirect<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let (buffer_guard, _) = hub.buffers.read(&mut token);
@@ -558,20 +575,22 @@ pub fn render_pass_draw_indexed_indirect<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_draw_indexed_indirect(
pass_id: RenderPassId,
indirect_buffer_id: BufferId,
indirect_offset: BufferAddress,
) {
gfx_select!(pass_id => render_pass_draw_indexed_indirect(pass_id, indirect_buffer_id, indirect_offset))
gfx_select!(pass_id => render_pass_draw_indexed_indirect(&*GLOBAL, pass_id, indirect_buffer_id, indirect_offset))
}
pub fn render_pass_set_pipeline<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
pipeline_id: RenderPipelineId,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token);
@@ -625,8 +644,7 @@ pub fn render_pass_set_pipeline<B: GfxBackend>(
);
}
}
LayoutChange::Match(..) |
LayoutChange::Unchanged => {}
LayoutChange::Match(..) | LayoutChange::Unchanged => {}
LayoutChange::Mismatch => {
is_compatible = false;
}
@@ -675,16 +693,21 @@ pub fn render_pass_set_pipeline<B: GfxBackend>(
pass.vertex_state.update_limits();
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_pipeline(
pass_id: RenderPassId,
pipeline_id: RenderPipelineId,
) {
gfx_select!(pass_id => render_pass_set_pipeline(pass_id, pipeline_id))
gfx_select!(pass_id => render_pass_set_pipeline(&*GLOBAL, pass_id, pipeline_id))
}
pub fn render_pass_set_blend_color<B: GfxBackend>(pass_id: RenderPassId, color: &Color) {
let hub = B::hub();
pub fn render_pass_set_blend_color<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
color: &Color,
) {
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -696,13 +719,18 @@ pub fn render_pass_set_blend_color<B: GfxBackend>(pass_id: RenderPassId, color:
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_blend_color(pass_id: RenderPassId, color: &Color) {
gfx_select!(pass_id => render_pass_set_blend_color(pass_id, color))
gfx_select!(pass_id => render_pass_set_blend_color(&*GLOBAL, pass_id, color))
}
pub fn render_pass_set_stencil_reference<B: GfxBackend>(pass_id: RenderPassId, value: u32) {
let hub = B::hub();
pub fn render_pass_set_stencil_reference<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
value: u32,
) {
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -714,12 +742,14 @@ pub fn render_pass_set_stencil_reference<B: GfxBackend>(pass_id: RenderPassId, v
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_stencil_reference(pass_id: RenderPassId, value: u32) {
gfx_select!(pass_id => render_pass_set_stencil_reference(pass_id, value))
gfx_select!(pass_id => render_pass_set_stencil_reference(&*GLOBAL, pass_id, value))
}
pub fn render_pass_set_viewport<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
x: f32,
y: f32,
@@ -728,7 +758,7 @@ pub fn render_pass_set_viewport<B: GfxBackend>(
min_depth: f32,
max_depth: f32,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -752,6 +782,7 @@ pub fn render_pass_set_viewport<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_viewport(
pass_id: RenderPassId,
@@ -762,17 +793,18 @@ pub extern "C" fn wgpu_render_pass_set_viewport(
min_depth: f32,
max_depth: f32,
) {
gfx_select!(pass_id => render_pass_set_viewport(pass_id, x, y, w, h, min_depth, max_depth))
gfx_select!(pass_id => render_pass_set_viewport(&*GLOBAL, pass_id, x, y, w, h, min_depth, max_depth))
}
pub fn render_pass_set_scissor_rect<B: GfxBackend>(
global: &Global,
pass_id: RenderPassId,
x: u32,
y: u32,
w: u32,
h: u32,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut pass_guard, _) = hub.render_passes.write(&mut token);
let pass = &mut pass_guard[pass_id];
@@ -793,6 +825,7 @@ pub fn render_pass_set_scissor_rect<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_set_scissor_rect(
pass_id: RenderPassId,
@@ -801,9 +834,10 @@ pub extern "C" fn wgpu_render_pass_set_scissor_rect(
w: u32,
h: u32,
) {
gfx_select!(pass_id => render_pass_set_scissor_rect(pass_id, x, y, w, h))
gfx_select!(pass_id => render_pass_set_scissor_rect(&*GLOBAL, pass_id, x, y, w, h))
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_render_pass_execute_bundles(
_pass_id: RenderPassId,
+19 -6
View File
@@ -5,8 +5,7 @@
use crate::{
conv,
device::{all_buffer_stages, all_image_stages},
gfx_select,
hub::{GfxBackend, Token},
hub::{GfxBackend, Global, Token},
BufferAddress,
BufferId,
BufferUsage,
@@ -16,6 +15,8 @@ use crate::{
TextureId,
TextureUsage,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL};
use hal::command::CommandBuffer as _;
@@ -65,6 +66,7 @@ impl TextureCopyView {
}
pub fn command_encoder_copy_buffer_to_buffer<B: GfxBackend>(
global: &Global,
command_encoder_id: CommandEncoderId,
source: BufferId,
source_offset: BufferAddress,
@@ -72,7 +74,7 @@ pub fn command_encoder_copy_buffer_to_buffer<B: GfxBackend>(
destination_offset: BufferAddress,
size: BufferAddress,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
@@ -124,6 +126,7 @@ pub fn command_encoder_copy_buffer_to_buffer<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_copy_buffer_to_buffer(
command_encoder_id: CommandEncoderId,
@@ -134,6 +137,7 @@ pub extern "C" fn wgpu_command_encoder_copy_buffer_to_buffer(
size: BufferAddress,
) {
gfx_select!(command_encoder_id => command_encoder_copy_buffer_to_buffer(
&*GLOBAL,
command_encoder_id,
source, source_offset,
destination,
@@ -142,12 +146,13 @@ pub extern "C" fn wgpu_command_encoder_copy_buffer_to_buffer(
}
pub fn command_encoder_copy_buffer_to_texture<B: GfxBackend>(
global: &Global,
command_encoder_id: CommandEncoderId,
source: &BufferCopyView,
destination: &TextureCopyView,
copy_size: Extent3d,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
let cmb = &mut cmb_guard[command_encoder_id];
@@ -215,6 +220,7 @@ pub fn command_encoder_copy_buffer_to_texture<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_copy_buffer_to_texture(
command_encoder_id: CommandEncoderId,
@@ -223,6 +229,7 @@ pub extern "C" fn wgpu_command_encoder_copy_buffer_to_texture(
copy_size: Extent3d,
) {
gfx_select!(command_encoder_id => command_encoder_copy_buffer_to_texture(
&*GLOBAL,
command_encoder_id,
source,
destination,
@@ -230,12 +237,13 @@ pub extern "C" fn wgpu_command_encoder_copy_buffer_to_texture(
}
pub fn command_encoder_copy_texture_to_buffer<B: GfxBackend>(
global: &Global,
command_encoder_id: CommandEncoderId,
source: &TextureCopyView,
destination: &BufferCopyView,
copy_size: Extent3d,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
let cmb = &mut cmb_guard[command_encoder_id];
@@ -305,6 +313,7 @@ pub fn command_encoder_copy_texture_to_buffer<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_copy_texture_to_buffer(
command_encoder_id: CommandEncoderId,
@@ -313,6 +322,7 @@ pub extern "C" fn wgpu_command_encoder_copy_texture_to_buffer(
copy_size: Extent3d,
) {
gfx_select!(command_encoder_id => command_encoder_copy_texture_to_buffer(
&*GLOBAL,
command_encoder_id,
source,
destination,
@@ -320,12 +330,13 @@ pub extern "C" fn wgpu_command_encoder_copy_texture_to_buffer(
}
pub fn command_encoder_copy_texture_to_texture<B: GfxBackend>(
global: &Global,
command_encoder_id: CommandEncoderId,
source: &TextureCopyView,
destination: &TextureCopyView,
copy_size: Extent3d,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
@@ -393,6 +404,7 @@ pub fn command_encoder_copy_texture_to_texture<B: GfxBackend>(
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_command_encoder_copy_texture_to_texture(
command_encoder_id: CommandEncoderId,
@@ -401,6 +413,7 @@ pub extern "C" fn wgpu_command_encoder_copy_texture_to_texture(
copy_size: Extent3d,
) {
gfx_select!(command_encoder_id => command_encoder_copy_texture_to_texture(
&*GLOBAL,
command_encoder_id,
source,
destination,
+17 -10
View File
@@ -311,7 +311,10 @@ fn map_stencil_operation(stencil_operation: pipeline::StencilOperation) -> hal::
}
}
pub(crate) fn map_texture_format(texture_format: resource::TextureFormat, features: Features) -> hal::format::Format {
pub(crate) fn map_texture_format(
texture_format: resource::TextureFormat,
features: Features,
) -> hal::format::Format {
use crate::resource::TextureFormat as Tf;
use hal::format::Format as H;
match texture_format {
@@ -371,16 +374,20 @@ pub(crate) fn map_texture_format(texture_format: resource::TextureFormat, featur
// Depth and stencil formats
Tf::Depth32Float => H::D32Sfloat,
Tf::Depth24Plus => if features.supports_texture_d24_s8 {
H::D24UnormS8Uint
} else {
H::D32Sfloat
Tf::Depth24Plus => {
if features.supports_texture_d24_s8 {
H::D24UnormS8Uint
} else {
H::D32Sfloat
}
}
Tf::Depth24PlusStencil8 => {
if features.supports_texture_d24_s8 {
H::D24UnormS8Uint
} else {
H::D32SfloatS8Uint
}
}
Tf::Depth24PlusStencil8 => if features.supports_texture_d24_s8 {
H::D24UnormS8Uint
} else {
H::D32SfloatS8Uint
},
}
}
+195 -131
View File
@@ -2,16 +2,13 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#[cfg(not(feature = "remote"))]
use crate::{
instance::Limits,
};
#[cfg(feature = "local")]
use crate::instance::Limits;
use crate::{
binding_model,
command,
conv,
gfx_select,
hub::{GfxBackend, Token, GLOBAL},
hub::{GfxBackend, Global, Token},
id::{Input, Output},
pipeline,
resource,
@@ -46,6 +43,8 @@ use crate::{
TextureUsage,
TextureViewId,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL};
use arrayvec::ArrayVec;
use copyless::VecHelper as _;
@@ -61,7 +60,7 @@ use parking_lot::Mutex;
use rendy_descriptor::{DescriptorAllocator, DescriptorRanges, DescriptorSet};
use rendy_memory::{Block, Heaps, MemoryBlock};
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
use std::marker::PhantomData;
use std::{
collections::hash_map::Entry,
@@ -70,7 +69,7 @@ use std::{
ops::Range,
ptr,
slice,
sync::atomic::{Ordering},
sync::atomic::Ordering,
};
@@ -275,7 +274,12 @@ impl<B: GfxBackend> PendingResources<B> {
last_done
}
fn triage_referenced(&mut self, trackers: &mut TrackerSet, mut token: &mut Token<Device<B>>) {
fn triage_referenced(
&mut self,
global: &Global,
trackers: &mut TrackerSet,
mut token: &mut Token<Device<B>>,
) {
// Before destruction, a resource is expected to have the following strong refs:
// - in resource itself
// - in the device tracker
@@ -286,7 +290,7 @@ impl<B: GfxBackend> PendingResources<B> {
return;
}
let hub = B::hub();
let hub = B::hub(global);
//TODO: lock less, if possible
let (mut bind_group_guard, mut token) = hub.bind_groups.write(&mut token);
let (mut buffer_guard, mut token) = hub.buffers.write(&mut token);
@@ -310,14 +314,14 @@ impl<B: GfxBackend> PendingResources<B> {
}
trackers.buffers.remove(id);
let buf = buffer_guard.remove(id).unwrap();
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
hub.buffers.identity.lock().free(id);
(buf.life_guard, NativeResource::Buffer(buf.raw, buf.memory))
}
ResourceId::Texture(id) => {
trackers.textures.remove(id);
let tex = texture_guard.remove(id).unwrap();
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
hub.textures.identity.lock().free(id);
(tex.life_guard, NativeResource::Image(tex.raw, tex.memory))
}
@@ -328,14 +332,14 @@ impl<B: GfxBackend> PendingResources<B> {
resource::TextureViewInner::Native { raw, .. } => raw,
resource::TextureViewInner::SwapChain { .. } => unreachable!(),
};
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
hub.texture_views.identity.lock().free(id);
(view.life_guard, NativeResource::ImageView(raw))
}
ResourceId::BindGroup(id) => {
trackers.bind_groups.remove(id);
let bind_group = bind_group_guard.remove(id).unwrap();
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
hub.bind_groups.identity.lock().free(id);
(
bind_group.life_guard,
@@ -345,7 +349,7 @@ impl<B: GfxBackend> PendingResources<B> {
ResourceId::Sampler(id) => {
trackers.samplers.remove(id);
let sampler = sampler_guard.remove(id).unwrap();
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
hub.samplers.identity.lock().free(id);
(sampler.life_guard, NativeResource::Sampler(sampler.raw))
}
@@ -362,11 +366,11 @@ impl<B: GfxBackend> PendingResources<B> {
}
}
fn triage_mapped(&mut self, token: &mut Token<Device<B>>) {
fn triage_mapped(&mut self, global: &Global, token: &mut Token<Device<B>>) {
if self.mapped.is_empty() {
return;
}
let (buffer_guard, _) = B::hub().buffers.read(token);
let (buffer_guard, _) = B::hub(global).buffers.read(token);
for stored in self.mapped.drain(..) {
let resource_id = stored.value;
@@ -390,10 +394,11 @@ impl<B: GfxBackend> PendingResources<B> {
fn triage_framebuffers(
&mut self,
global: &Global,
framebuffers: &mut FastHashMap<FramebufferKey, B::Framebuffer>,
token: &mut Token<Device<B>>,
) {
let (texture_view_guard, _) = B::hub().texture_views.read(token);
let (texture_view_guard, _) = B::hub(global).texture_views.read(token);
let remove_list = framebuffers
.keys()
.filter_map(|key| {
@@ -428,13 +433,14 @@ impl<B: GfxBackend> PendingResources<B> {
fn handle_mapping(
&mut self,
global: &Global,
raw: &B::Device,
token: &mut Token<Device<B>>,
) -> Vec<BufferMapPendingCallback> {
if self.ready_to_map.is_empty() {
return Vec::new();
}
let (mut buffer_guard, _) = B::hub().buffers.write(token);
let (mut buffer_guard, _) = B::hub(global).buffers.write(token);
self.ready_to_map
.drain(..)
.map(|buffer_id| {
@@ -562,24 +568,29 @@ impl<B: GfxBackend> Device<B> {
features: Features {
max_bind_groups,
supports_texture_d24_s8,
}
},
}
}
fn maintain(&self, force_wait: bool, token: &mut Token<Self>) -> Vec<BufferMapPendingCallback> {
fn maintain(
&self,
global: &Global,
force_wait: bool,
token: &mut Token<Self>,
) -> Vec<BufferMapPendingCallback> {
let mut pending = self.pending.lock();
let mut trackers = self.trackers.lock();
pending.triage_referenced(&mut *trackers, token);
pending.triage_mapped(token);
pending.triage_framebuffers(&mut *self.framebuffers.lock(), token);
pending.triage_referenced(global, &mut *trackers, token);
pending.triage_mapped(global, token);
pending.triage_framebuffers(global, &mut *self.framebuffers.lock(), token);
let last_done = pending.cleanup(
&self.raw,
&self.mem_allocator,
&self.desc_allocator,
force_wait,
);
let callbacks = pending.handle_mapping(&self.raw, token);
let callbacks = pending.handle_mapping(global, &self.raw, token);
unsafe {
self.desc_allocator.lock().cleanup(&self.raw);
@@ -678,7 +689,9 @@ impl<B: GfxBackend> Device<B> {
// Ensure `D24Plus` textures cannot be copied
match desc.format {
TextureFormat::Depth24Plus | TextureFormat::Depth24PlusStencil8 => {
assert!(!desc.usage.intersects(TextureUsage::COPY_SRC | TextureUsage::COPY_DST));
assert!(!desc
.usage
.intersects(TextureUsage::COPY_SRC | TextureUsage::COPY_DST));
}
_ => {}
}
@@ -755,7 +768,7 @@ impl<B: GfxBackend> Device<B> {
}
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_get_limits(_device_id: DeviceId, limits: &mut Limits) {
*limits = Limits::default(); // TODO
@@ -767,11 +780,12 @@ pub struct ShaderModule<B: hal::Backend> {
}
pub fn device_create_buffer<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &resource::BufferDescriptor,
id_in: Input<BufferId>,
) -> Output<BufferId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, _) = hub.devices.read(&mut token);
@@ -791,22 +805,23 @@ pub fn device_create_buffer<B: GfxBackend>(
id_out
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_buffer(
device_id: DeviceId,
desc: &resource::BufferDescriptor,
) -> BufferId {
gfx_select!(device_id => device_create_buffer(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_buffer(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_buffer_mapped<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &resource::BufferDescriptor,
mapped_ptr_out: *mut *mut u8,
id_in: Input<BufferId>,
) -> Output<BufferId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let mut desc = desc.clone();
desc.usage |= resource::BufferUsage::MAP_WRITE;
@@ -840,18 +855,18 @@ pub fn device_create_buffer_mapped<B: GfxBackend>(
id_out
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_buffer_mapped(
device_id: DeviceId,
desc: &resource::BufferDescriptor,
mapped_ptr_out: *mut *mut u8,
) -> BufferId {
gfx_select!(device_id => device_create_buffer_mapped(device_id, desc, mapped_ptr_out, PhantomData))
gfx_select!(device_id => device_create_buffer_mapped(&*GLOBAL, device_id, desc, mapped_ptr_out, PhantomData))
}
pub fn buffer_destroy<B: GfxBackend>(buffer_id: BufferId) {
let hub = B::hub();
pub fn buffer_destroy<B: GfxBackend>(global: &Global, buffer_id: BufferId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let (buffer_guard, _) = hub.buffers.read(&mut token);
@@ -862,17 +877,19 @@ pub fn buffer_destroy<B: GfxBackend>(buffer_id: BufferId) {
);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_buffer_destroy(buffer_id: BufferId) {
gfx_select!(buffer_id => buffer_destroy(buffer_id))
gfx_select!(buffer_id => buffer_destroy(&*GLOBAL, buffer_id))
}
pub fn device_create_texture<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &resource::TextureDescriptor,
id_in: Input<TextureId>,
) -> Output<TextureId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, _) = hub.devices.read(&mut token);
@@ -892,21 +909,22 @@ pub fn device_create_texture<B: GfxBackend>(
id_out
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_texture(
device_id: DeviceId,
desc: &resource::TextureDescriptor,
) -> TextureId {
gfx_select!(device_id => device_create_texture(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_texture(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn texture_create_view<B: GfxBackend>(
global: &Global,
texture_id: TextureId,
desc: Option<&resource::TextureViewDescriptor>,
id_in: Input<TextureViewId>,
) -> Output<TextureViewId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -990,17 +1008,17 @@ pub fn texture_create_view<B: GfxBackend>(
id_out
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_texture_create_view(
texture_id: TextureId,
desc: Option<&resource::TextureViewDescriptor>,
) -> TextureViewId {
gfx_select!(texture_id => texture_create_view(texture_id, desc, PhantomData))
gfx_select!(texture_id => texture_create_view(&*GLOBAL, texture_id, desc, PhantomData))
}
pub fn texture_destroy<B: GfxBackend>(texture_id: TextureId) {
let hub = B::hub();
pub fn texture_destroy<B: GfxBackend>(global: &Global, texture_id: TextureId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -1015,23 +1033,24 @@ pub fn texture_destroy<B: GfxBackend>(texture_id: TextureId) {
);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_texture_destroy(texture_id: TextureId) {
gfx_select!(texture_id => texture_destroy(texture_id))
gfx_select!(texture_id => texture_destroy(&*GLOBAL, texture_id))
}
pub fn texture_view_destroy<B: GfxBackend>(texture_view_id: TextureViewId) {
let hub = B::hub();
pub fn texture_view_destroy<B: GfxBackend>(global: &Global, texture_view_id: TextureViewId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let (texture_guard, mut token) = hub.textures.read(&mut token);
let (texture_view_guard, _) = hub.texture_views.read(&mut token);
let view = &texture_view_guard[texture_view_id];
let device_id = match view.inner {
resource::TextureViewInner::Native { ref source_id, .. } =>
texture_guard[source_id.value].device_id.value,
resource::TextureViewInner::SwapChain { .. } =>
panic!("Can't destroy a swap chain image"),
resource::TextureViewInner::Native { ref source_id, .. } => {
texture_guard[source_id.value].device_id.value
}
resource::TextureViewInner::SwapChain { .. } => panic!("Can't destroy a swap chain image"),
};
device_guard[device_id].pending.lock().destroy(
ResourceId::TextureView(texture_view_id),
@@ -1039,17 +1058,19 @@ pub fn texture_view_destroy<B: GfxBackend>(texture_view_id: TextureViewId) {
);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_texture_view_destroy(texture_view_id: TextureViewId) {
gfx_select!(texture_view_id => texture_view_destroy(texture_view_id))
gfx_select!(texture_view_id => texture_view_destroy(&*GLOBAL, texture_view_id))
}
pub fn device_create_sampler<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &resource::SamplerDescriptor,
id_in: Input<SamplerId>,
) -> Output<SamplerId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let device = &device_guard[device_id];
@@ -1086,17 +1107,17 @@ pub fn device_create_sampler<B: GfxBackend>(
hub.samplers.register_identity(id_in, sampler, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_sampler(
device_id: DeviceId,
desc: &resource::SamplerDescriptor,
) -> SamplerId {
gfx_select!(device_id => device_create_sampler(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_sampler(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn sampler_destroy<B: GfxBackend>(sampler_id: SamplerId) {
let hub = B::hub();
pub fn sampler_destroy<B: GfxBackend>(global: &Global, sampler_id: SamplerId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let (sampler_guard, _) = hub.samplers.read(&mut token);
@@ -1110,18 +1131,20 @@ pub fn sampler_destroy<B: GfxBackend>(sampler_id: SamplerId) {
);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_sampler_destroy(sampler_id: SamplerId) {
gfx_select!(sampler_id => sampler_destroy(sampler_id))
gfx_select!(sampler_id => sampler_destroy(&*GLOBAL, sampler_id))
}
pub fn device_create_bind_group_layout<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &binding_model::BindGroupLayoutDescriptor,
id_in: Input<BindGroupLayoutId>,
) -> Output<BindGroupLayoutId> {
let mut token = Token::root();
let hub = B::hub();
let hub = B::hub(global);
let bindings = unsafe { slice::from_raw_parts(desc.bindings, desc.bindings_length) };
let raw_bindings = bindings
@@ -1154,21 +1177,22 @@ pub fn device_create_bind_group_layout<B: GfxBackend>(
.register_identity(id_in, layout, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_bind_group_layout(
device_id: DeviceId,
desc: &binding_model::BindGroupLayoutDescriptor,
) -> BindGroupLayoutId {
gfx_select!(device_id => device_create_bind_group_layout(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_bind_group_layout(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_pipeline_layout<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &binding_model::PipelineLayoutDescriptor,
id_in: Input<PipelineLayoutId>,
) -> Output<PipelineLayoutId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -1197,21 +1221,22 @@ pub fn device_create_pipeline_layout<B: GfxBackend>(
.register_identity(id_in, layout, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_pipeline_layout(
device_id: DeviceId,
desc: &binding_model::PipelineLayoutDescriptor,
) -> PipelineLayoutId {
gfx_select!(device_id => device_create_pipeline_layout(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_pipeline_layout(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_bind_group<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &binding_model::BindGroupDescriptor,
id_in: Input<BindGroupId>,
) -> Output<BindGroupId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -1276,7 +1301,11 @@ pub fn device_create_bind_group<B: GfxBackend>(
.buffers
.use_extend(&*buffer_guard, bb.buffer, (), usage)
.unwrap();
assert!(buffer.usage.contains(usage), "Expected buffer usage {:?}", usage);
assert!(
buffer.usage.contains(usage),
"Expected buffer usage {:?}",
usage
);
let end = if bb.size == 0 {
None
@@ -1296,7 +1325,8 @@ pub fn device_create_bind_group<B: GfxBackend>(
}
binding_model::BindingResource::Sampler(id) => {
assert_eq!(decl.ty, binding_model::BindingType::Sampler);
let sampler = used.samplers
let sampler = used
.samplers
.use_extend(&*sampler_guard, id, (), ())
.unwrap();
hal::pso::Descriptor::Sampler(&sampler.raw)
@@ -1317,21 +1347,26 @@ pub fn device_create_bind_group<B: GfxBackend>(
.use_extend(&*texture_view_guard, id, (), ())
.unwrap();
match view.inner {
resource::TextureViewInner::Native { ref raw, ref source_id } => {
let texture = used.textures
.use_extend(
&*texture_guard,
source_id.value,
view.range.clone(),
usage,
)
.unwrap();
assert!(texture.usage.contains(usage));
resource::TextureViewInner::Native {
ref raw,
ref source_id,
} => {
let texture = used
.textures
.use_extend(
&*texture_guard,
source_id.value,
view.range.clone(),
usage,
)
.unwrap();
assert!(texture.usage.contains(usage));
hal::pso::Descriptor::Image(raw, image_layout)
hal::pso::Descriptor::Image(raw, image_layout)
}
resource::TextureViewInner::SwapChain { .. } => {
panic!("Unable to create a bind group with a swap chain image")
}
resource::TextureViewInner::SwapChain { .. } =>
panic!("Unable to create a bind group with a swap chain image"),
}
}
};
@@ -1371,17 +1406,17 @@ pub fn device_create_bind_group<B: GfxBackend>(
id_out
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_bind_group(
device_id: DeviceId,
desc: &binding_model::BindGroupDescriptor,
) -> BindGroupId {
gfx_select!(device_id => device_create_bind_group(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_bind_group(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn bind_group_destroy<B: GfxBackend>(bind_group_id: BindGroupId) {
let hub = B::hub();
pub fn bind_group_destroy<B: GfxBackend>(global: &Global, bind_group_id: BindGroupId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let (bind_group_guard, _) = hub.bind_groups.read(&mut token);
@@ -1395,17 +1430,19 @@ pub fn bind_group_destroy<B: GfxBackend>(bind_group_id: BindGroupId) {
);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_bind_group_destroy(bind_group_id: BindGroupId) {
gfx_select!(bind_group_id => bind_group_destroy(bind_group_id))
gfx_select!(bind_group_id => bind_group_destroy(&*GLOBAL, bind_group_id))
}
pub fn device_create_shader_module<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &pipeline::ShaderModuleDescriptor,
id_in: Input<ShaderModuleId>,
) -> Output<ShaderModuleId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let spv = unsafe { slice::from_raw_parts(desc.code.bytes, desc.code.length) };
@@ -1424,21 +1461,22 @@ pub fn device_create_shader_module<B: GfxBackend>(
.register_identity(id_in, shader, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_shader_module(
device_id: DeviceId,
desc: &pipeline::ShaderModuleDescriptor,
) -> ShaderModuleId {
gfx_select!(device_id => device_create_shader_module(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_shader_module(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_command_encoder<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
_desc: &command::CommandEncoderDescriptor,
id_in: Input<CommandEncoderId>,
) -> Output<CommandEncoderId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -1448,7 +1486,9 @@ pub fn device_create_command_encoder<B: GfxBackend>(
value: device_id,
ref_count: device.life_guard.ref_count.clone(),
};
let mut comb = device.com_allocator.allocate(dev_stored, &device.raw, device.features);
let mut comb = device
.com_allocator
.allocate(dev_stored, &device.raw, device.features);
unsafe {
comb.raw.last_mut().unwrap().begin(
hal::command::CommandBufferFlags::ONE_TIME_SUBMIT,
@@ -1460,23 +1500,28 @@ pub fn device_create_command_encoder<B: GfxBackend>(
.register_identity(id_in, comb, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_command_encoder(
device_id: DeviceId,
desc: Option<&command::CommandEncoderDescriptor>,
) -> CommandEncoderId {
let desc = &desc.cloned().unwrap_or_default();
gfx_select!(device_id => device_create_command_encoder(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_command_encoder(&*GLOBAL, device_id, desc, PhantomData))
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_get_queue(device_id: DeviceId) -> QueueId {
device_id
}
pub fn queue_submit<B: GfxBackend>(queue_id: QueueId, command_buffer_ids: &[CommandBufferId]) {
let hub = B::hub();
pub fn queue_submit<B: GfxBackend>(
global: &Global,
queue_id: QueueId,
command_buffer_ids: &[CommandBufferId],
) {
let hub = B::hub(global);
let (submit_index, fence) = {
let mut token = Token::root();
@@ -1510,9 +1555,15 @@ pub fn queue_submit<B: GfxBackend>(queue_id: QueueId, command_buffer_ids: &[Comm
if let Some((view_id, fbo)) = comb.used_swap_chain.take() {
let sem = match texture_view_guard[view_id.value].inner {
resource::TextureViewInner::Native { .. } => unreachable!(),
resource::TextureViewInner::SwapChain { ref source_id, ref mut framebuffer, .. } => {
assert!(framebuffer.is_none(),
"Using a swap chain in multiple framebuffers is not supported yet");
resource::TextureViewInner::SwapChain {
ref source_id,
ref mut framebuffer,
..
} => {
assert!(
framebuffer.is_none(),
"Using a swap chain in multiple framebuffers is not supported yet"
);
*framebuffer = Some(fbo);
&swap_chain_guard[source_id.value].semaphore
}
@@ -1594,8 +1645,7 @@ pub fn queue_submit<B: GfxBackend>(queue_id: QueueId, command_buffer_ids: &[Comm
};
unsafe {
device.queue_group.queues[0]
.submit(submission, Some(&fence));
device.queue_group.queues[0].submit(submission, Some(&fence));
}
(submit_index, fence)
@@ -1607,7 +1657,7 @@ pub fn queue_submit<B: GfxBackend>(queue_id: QueueId, command_buffer_ids: &[Comm
let (device_guard, mut token) = hub.devices.read(&mut token);
let device = &device_guard[queue_id];
let callbacks = device.maintain(false, &mut token);
let callbacks = device.maintain(global, false, &mut token);
device.pending.lock().active.alloc().init(ActiveSubmission {
index: submit_index,
fence,
@@ -1627,6 +1677,7 @@ pub fn queue_submit<B: GfxBackend>(queue_id: QueueId, command_buffer_ids: &[Comm
Device::<B>::fire_map_callbacks(callbacks);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_queue_submit(
queue_id: QueueId,
@@ -1635,15 +1686,16 @@ pub extern "C" fn wgpu_queue_submit(
) {
let command_buffer_ids =
unsafe { slice::from_raw_parts(command_buffers, command_buffers_length) };
gfx_select!(queue_id => queue_submit(queue_id, command_buffer_ids))
gfx_select!(queue_id => queue_submit(&*GLOBAL, queue_id, command_buffer_ids))
}
pub fn device_create_render_pipeline<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &pipeline::RenderPipelineDescriptor,
id_in: Input<RenderPipelineId>,
) -> Output<RenderPipelineId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let sc = desc.sample_count;
@@ -1898,21 +1950,22 @@ pub fn device_create_render_pipeline<B: GfxBackend>(
.register_identity(id_in, pipeline, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_render_pipeline(
device_id: DeviceId,
desc: &pipeline::RenderPipelineDescriptor,
) -> RenderPipelineId {
gfx_select!(device_id => device_create_render_pipeline(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_render_pipeline(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_compute_pipeline<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
desc: &pipeline::ComputePipelineDescriptor,
id_in: Input<ComputePipelineId>,
) -> Output<ComputePipelineId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let raw_pipeline = {
@@ -1959,25 +2012,26 @@ pub fn device_create_compute_pipeline<B: GfxBackend>(
.register_identity(id_in, pipeline, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_compute_pipeline(
device_id: DeviceId,
desc: &pipeline::ComputePipelineDescriptor,
) -> ComputePipelineId {
gfx_select!(device_id => device_create_compute_pipeline(device_id, desc, PhantomData))
gfx_select!(device_id => device_create_compute_pipeline(&*GLOBAL, device_id, desc, PhantomData))
}
pub fn device_create_swap_chain<B: GfxBackend>(
global: &Global,
device_id: DeviceId,
surface_id: SurfaceId,
desc: &swap_chain::SwapChainDescriptor,
) -> SwapChainId {
log::info!("creating swap chain {:?}", desc);
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut surface_guard, mut token) = GLOBAL.surfaces.write(&mut token);
let (mut surface_guard, mut token) = global.surfaces.write(&mut token);
let (adapter_guard, mut token) = hub.adapters.read(&mut token);
let (device_guard, mut token) = hub.devices.read(&mut token);
let (mut swap_chain_guard, _) = hub.swap_chains.write(&mut token);
@@ -2003,13 +2057,17 @@ pub fn device_create_swap_chain<B: GfxBackend>(
formats
);
}
if desc.width < caps.extents.start().width ||
desc.width > caps.extents.end().width ||
desc.height < caps.extents.start().height ||
desc.height > caps.extents.end().height
if desc.width < caps.extents.start().width
|| desc.width > caps.extents.end().width
|| desc.height < caps.extents.start().height
|| desc.height > caps.extents.end().height
{
log::warn!("Requested size {}x{} is outside of the supported range: {:?}",
desc.width, desc.height, caps.extents);
log::warn!(
"Requested size {}x{} is outside of the supported range: {:?}",
desc.width,
desc.height,
caps.extents
);
}
unsafe {
@@ -2039,40 +2097,42 @@ pub fn device_create_swap_chain<B: GfxBackend>(
sc_id
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_create_swap_chain(
device_id: DeviceId,
surface_id: SurfaceId,
desc: &swap_chain::SwapChainDescriptor,
) -> SwapChainId {
gfx_select!(device_id => device_create_swap_chain(device_id, surface_id, desc))
gfx_select!(device_id => device_create_swap_chain(&*GLOBAL, device_id, surface_id, desc))
}
pub fn device_poll<B: GfxBackend>(device_id: DeviceId, force_wait: bool) {
let hub = B::hub();
pub fn device_poll<B: GfxBackend>(global: &Global, device_id: DeviceId, force_wait: bool) {
let hub = B::hub(global);
let callbacks = {
let (device_guard, mut token) = hub.devices.read(&mut Token::root());
device_guard[device_id].maintain(force_wait, &mut token)
device_guard[device_id].maintain(global, force_wait, &mut token)
};
Device::<B>::fire_map_callbacks(callbacks);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_poll(device_id: DeviceId, force_wait: bool) {
gfx_select!(device_id => device_poll(device_id, force_wait))
gfx_select!(device_id => device_poll(&*GLOBAL, device_id, force_wait))
}
pub fn device_destroy<B: GfxBackend>(device_id: DeviceId) {
let hub = B::hub();
pub fn device_destroy<B: GfxBackend>(global: &Global, device_id: DeviceId) {
let hub = B::hub(global);
let (device, mut token) = hub.devices.unregister(device_id, &mut Token::root());
device.maintain(true, &mut token);
device.maintain(global, true, &mut token);
device.com_allocator.destroy(&device.raw);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_device_destroy(device_id: DeviceId) {
gfx_select!(device_id => device_destroy(device_id))
gfx_select!(device_id => device_destroy(&*GLOBAL, device_id))
}
pub type BufferMapReadCallback =
@@ -2081,11 +2141,12 @@ pub type BufferMapWriteCallback =
extern "C" fn(status: BufferMapAsyncStatus, data: *mut u8, userdata: *mut u8);
pub fn buffer_map_async<B: GfxBackend>(
global: &Global,
buffer_id: BufferId,
usage: resource::BufferUsage,
operation: BufferMapOperation,
) {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -2121,6 +2182,7 @@ pub fn buffer_map_async<B: GfxBackend>(
device.pending.lock().map(buffer_id, ref_count);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_buffer_map_read_async(
buffer_id: BufferId,
@@ -2130,9 +2192,10 @@ pub extern "C" fn wgpu_buffer_map_read_async(
userdata: *mut u8,
) {
let operation = BufferMapOperation::Read(start .. start + size, callback, userdata);
gfx_select!(buffer_id => buffer_map_async(buffer_id, resource::BufferUsage::MAP_READ, operation))
gfx_select!(buffer_id => buffer_map_async(&*GLOBAL, buffer_id, resource::BufferUsage::MAP_READ, operation))
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_buffer_map_write_async(
buffer_id: BufferId,
@@ -2142,11 +2205,11 @@ pub extern "C" fn wgpu_buffer_map_write_async(
userdata: *mut u8,
) {
let operation = BufferMapOperation::Write(start .. start + size, callback, userdata);
gfx_select!(buffer_id => buffer_map_async(buffer_id, resource::BufferUsage::MAP_WRITE, operation))
gfx_select!(buffer_id => buffer_map_async(&*GLOBAL, buffer_id, resource::BufferUsage::MAP_WRITE, operation))
}
pub fn buffer_unmap<B: GfxBackend>(buffer_id: BufferId) {
let hub = B::hub();
pub fn buffer_unmap<B: GfxBackend>(global: &Global, buffer_id: BufferId) {
let hub = B::hub(global);
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
@@ -2172,7 +2235,8 @@ pub fn buffer_unmap<B: GfxBackend>(buffer_id: BufferId) {
buffer.memory.unmap(device_raw);
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_buffer_unmap(buffer_id: BufferId) {
gfx_select!(buffer_id => buffer_unmap(buffer_id))
gfx_select!(buffer_id => buffer_unmap(&*GLOBAL, buffer_id))
}
+31 -22
View File
@@ -46,15 +46,16 @@ use crate::{
TypedId,
};
use lazy_static::lazy_static;
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
use parking_lot::Mutex;
use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
use vec_map::VecMap;
#[allow(unused)]
#[cfg(debug_assertions)]
use std::cell::Cell;
use std::{marker::PhantomData, ops, sync::Arc};
#[cfg(feature = "local")]
use std::sync::Arc;
use std::{marker::PhantomData, ops};
/// A simple structure to manage identities of objects.
@@ -147,7 +148,8 @@ impl<T, I: TypedId> Storage<T, I> {
pub fn remove(&mut self, id: I) -> Option<T> {
let (index, epoch, _) = id.unzip();
self.map.remove(index as usize)
self.map
.remove(index as usize)
.map(|(value, storage_epoch)| {
assert_eq!(epoch, storage_epoch);
value
@@ -271,7 +273,7 @@ impl<'a, T> Drop for Token<'a, T> {
#[derive(Debug)]
pub struct Registry<T, I: TypedId> {
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub identity: Mutex<IdentityManager<I>>,
data: RwLock<Storage<T, I>>,
backend: Backend,
@@ -280,7 +282,7 @@ pub struct Registry<T, I: TypedId> {
impl<T, I: TypedId> Registry<T, I> {
fn new(backend: Backend) -> Self {
Registry {
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
identity: Mutex::new(IdentityManager::new(backend)),
data: RwLock::new(Storage {
map: VecMap::new(),
@@ -298,13 +300,13 @@ impl<T, I: TypedId + Copy> Registry<T, I> {
assert!(old.is_none());
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub fn new_identity(&self, _id_in: Input<I>) -> (I, Output<I>) {
let id = self.identity.lock().alloc();
(id, id)
}
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
pub fn new_identity(&self, id_in: Input<I>) -> (I, Output<I>) {
//TODO: debug_assert_eq!(self.backend, id_in.backend());
(id_in, PhantomData)
@@ -324,7 +326,7 @@ impl<T, I: TypedId + Copy> Registry<T, I> {
pub fn unregister<A: Access<T>>(&self, id: I, _token: &mut Token<A>) -> (T, Token<T>) {
let value = self.data.write().remove(id).unwrap();
//Note: careful about the order here!
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
self.identity.lock().free(id);
(value, Token::new())
}
@@ -389,7 +391,10 @@ impl<B: GfxBackend> Default for Hub<B> {
#[derive(Debug, Default)]
pub struct Hubs {
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
vulkan: Hub<backend::Vulkan>,
#[cfg(any(target_os = "ios", target_os = "macos"))]
metal: Hub<backend::Metal>,
@@ -406,7 +411,8 @@ pub struct Global {
hubs: Hubs,
}
lazy_static! {
#[cfg(feature = "local")]
lazy_static::lazy_static! {
pub static ref GLOBAL: Arc<Global> = Arc::new(Global {
instance: Instance::new("wgpu", 1),
surfaces: Registry::new(Backend::Empty),
@@ -416,15 +422,18 @@ lazy_static! {
pub trait GfxBackend: hal::Backend {
const VARIANT: Backend;
fn hub() -> &'static Hub<Self>;
fn hub(global: &Global) -> &Hub<Self>;
fn get_surface_mut(surface: &mut Surface) -> &mut Self::Surface;
}
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
impl GfxBackend for backend::Vulkan {
const VARIANT: Backend = Backend::Vulkan;
fn hub() -> &'static Hub<Self> {
&GLOBAL.hubs.vulkan
fn hub(global: &Global) -> &Hub<Self> {
&global.hubs.vulkan
}
fn get_surface_mut(surface: &mut Surface) -> &mut Self::Surface {
surface.vulkan.as_mut().unwrap()
@@ -434,8 +443,8 @@ impl GfxBackend for backend::Vulkan {
#[cfg(any(target_os = "ios", target_os = "macos"))]
impl GfxBackend for backend::Metal {
const VARIANT: Backend = Backend::Metal;
fn hub() -> &'static Hub<Self> {
&GLOBAL.hubs.metal
fn hub(global: &Global) -> &Hub<Self> {
&global.hubs.metal
}
fn get_surface_mut(surface: &mut Surface) -> &mut Self::Surface {
&mut surface.metal
@@ -445,8 +454,8 @@ impl GfxBackend for backend::Metal {
#[cfg(windows)]
impl GfxBackend for backend::Dx12 {
const VARIANT: Backend = Backend::Dx12;
fn hub() -> &'static Hub<Self> {
&GLOBAL.hubs.dx12
fn hub(global: &Global) -> &Hub<Self> {
&global.hubs.dx12
}
fn get_surface_mut(surface: &mut Surface) -> &mut Self::Surface {
surface.dx12.as_mut().unwrap()
@@ -456,8 +465,8 @@ impl GfxBackend for backend::Dx12 {
#[cfg(windows)]
impl GfxBackend for backend::Dx11 {
const VARIANT: Backend = Backend::Dx11;
fn hub() -> &'static Hub<Self> {
&GLOBAL.hubs.dx11
fn hub(global: &Global) -> &Hub<Self> {
&global.hubs.dx11
}
fn get_surface_mut(surface: &mut Surface) -> &mut Self::Surface {
&mut surface.dx11
+4 -4
View File
@@ -76,13 +76,13 @@ impl<T> TypedId for Id<T> {
}
}
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
pub type Input<T> = T;
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub type Input<T> = PhantomData<T>;
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub type Output<T> = T;
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
pub type Output<T> = PhantomData<T>;
+75 -62
View File
@@ -6,7 +6,7 @@ use crate::{
backend,
binding_model::MAX_BIND_GROUPS,
device::BIND_BUFFER_ALIGNMENT,
hub::{GfxBackend, Token, GLOBAL},
hub::{GfxBackend, Global, Token},
id::{Input, Output},
AdapterId,
AdapterInfo,
@@ -14,28 +14,25 @@ use crate::{
Device,
DeviceId,
};
#[cfg(not(feature = "remote"))]
use crate::{gfx_select, SurfaceId};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL, SurfaceId};
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
use bitflags::bitflags;
use log::{info, warn};
#[cfg(feature = "remote")]
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use hal::{
self,
Instance as _,
adapter::PhysicalDevice as _,
queue::QueueFamily as _,
};
#[cfg(not(feature = "remote"))]
use hal::{self, adapter::PhysicalDevice as _, queue::QueueFamily as _, Instance as _};
#[cfg(feature = "local")]
use std::marker::PhantomData;
#[derive(Debug)]
pub struct Instance {
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
vulkan: Option<gfx_backend_vulkan::Instance>,
#[cfg(any(target_os = "ios", target_os = "macos"))]
metal: gfx_backend_metal::Instance,
@@ -46,9 +43,12 @@ pub struct Instance {
}
impl Instance {
pub(crate) fn new(name: &str, version: u32) -> Self {
pub fn new(name: &str, version: u32) -> Self {
Instance {
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
vulkan: gfx_backend_vulkan::Instance::create(name, version).ok(),
#[cfg(any(target_os = "ios", target_os = "macos"))]
metal: gfx_backend_metal::Instance::create(name, version).unwrap(),
@@ -64,7 +64,10 @@ type GfxSurface<B> = <B as hal::Backend>::Surface;
#[derive(Debug)]
pub struct Surface {
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
pub(crate) vulkan: Option<GfxSurface<backend::Vulkan>>,
#[cfg(any(target_os = "ios", target_os = "macos"))]
pub(crate) metal: GfxSurface<backend::Metal>,
@@ -81,14 +84,14 @@ pub struct Adapter<B: hal::Backend> {
#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum PowerPreference {
Default = 0,
LowPower = 1,
HighPerformance = 2,
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
bitflags! {
#[repr(transparent)]
pub struct BackendBit: u32 {
@@ -104,7 +107,7 @@ bitflags! {
}
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
impl From<Backend> for BackendBit {
fn from(backend: Backend) -> Self {
BackendBit::from_bits(1 << backend as u32).unwrap()
@@ -113,10 +116,10 @@ impl From<Backend> for BackendBit {
#[repr(C)]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct RequestAdapterOptions {
pub power_preference: PowerPreference,
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub backends: BackendBit,
}
@@ -124,7 +127,7 @@ impl Default for RequestAdapterOptions {
fn default() -> Self {
RequestAdapterOptions {
power_preference: PowerPreference::Default,
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
backends: BackendBit::PRIMARY,
}
}
@@ -132,14 +135,14 @@ impl Default for RequestAdapterOptions {
#[repr(C)]
#[derive(Clone, Debug, Default)]
#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Extensions {
pub anisotropic_filtering: bool,
}
#[repr(C)]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Limits {
pub max_bind_groups: u32,
}
@@ -154,13 +157,13 @@ impl Default for Limits {
#[repr(C)]
#[derive(Clone, Debug, Default)]
#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DeviceDescriptor {
pub extensions: Extensions,
pub limits: Limits,
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
pub fn wgpu_create_surface(raw_handle: raw_window_handle::RawWindowHandle) -> SurfaceId {
use raw_window_handle::RawWindowHandle as Rwh;
@@ -220,7 +223,12 @@ pub fn wgpu_create_surface(raw_handle: raw_window_handle::RawWindowHandle) -> Su
.register_identity(PhantomData, surface, &mut token)
}
#[cfg(all(not(feature = "remote"), unix, not(target_os = "ios"), not(target_os = "macos")))]
#[cfg(all(
feature = "local",
unix,
not(target_os = "ios"),
not(target_os = "macos")
))]
#[no_mangle]
pub extern "C" fn wgpu_create_surface_from_xlib(
display: *mut *const std::ffi::c_void,
@@ -234,7 +242,7 @@ pub extern "C" fn wgpu_create_surface_from_xlib(
}))
}
#[cfg(all(not(feature = "remote"), any(target_os = "ios", target_os = "macos")))]
#[cfg(all(feature = "local", any(target_os = "ios", target_os = "macos")))]
#[no_mangle]
pub extern "C" fn wgpu_create_surface_from_metal_layer(layer: *mut std::ffi::c_void) -> SurfaceId {
let surface = Surface {
@@ -251,7 +259,7 @@ pub extern "C" fn wgpu_create_surface_from_metal_layer(layer: *mut std::ffi::c_v
.register_identity(PhantomData, surface, &mut Token::root())
}
#[cfg(all(not(feature = "remote"), windows))]
#[cfg(all(feature = "local", windows))]
#[no_mangle]
pub extern "C" fn wgpu_create_surface_from_windows_hwnd(
_hinstance: *mut std::ffi::c_void,
@@ -267,15 +275,16 @@ pub extern "C" fn wgpu_create_surface_from_windows_hwnd(
}
pub fn request_adapter(
global: &Global,
desc: &RequestAdapterOptions,
input_ids: &[Input<AdapterId>],
) -> Option<AdapterId> {
let instance = &GLOBAL.instance;
let instance = &global.instance;
let mut device_types = Vec::new();
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
let find_input = |b: Backend| input_ids.iter().find(|id| id.backend() == b).cloned();
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
let find_input = |b: Backend| {
let _ = input_ids;
if desc.backends.contains(b.into()) {
@@ -284,9 +293,9 @@ pub fn request_adapter(
None
}
};
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
let pick = |_output, input_maybe| input_maybe;
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
let pick = |output, _input_maybe| Some(output);
let id_vulkan = find_input(Backend::Vulkan);
@@ -294,7 +303,10 @@ pub fn request_adapter(
let id_dx12 = find_input(Backend::Dx12);
let id_dx11 = find_input(Backend::Dx11);
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
let mut adapters_vk = match instance.vulkan {
Some(ref inst) if id_vulkan.is_some() => {
let adapters = inst.enumerate_adapters();
@@ -360,14 +372,17 @@ pub fn request_adapter(
let mut token = Token::root();
let mut selected = preferred_gpu.unwrap_or(0);
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
{
if selected < adapters_vk.len() {
let adapter = Adapter {
raw: adapters_vk.swap_remove(selected),
};
info!("Adapter Vulkan {:?}", adapter.raw.info);
let id_out = backend::Vulkan::hub().adapters.register_identity(
log::info!("Adapter Vulkan {:?}", adapter.raw.info);
let id_out = backend::Vulkan::hub(global).adapters.register_identity(
id_vulkan.unwrap(),
adapter,
&mut token,
@@ -382,8 +397,8 @@ pub fn request_adapter(
let adapter = Adapter {
raw: adapters_mtl.swap_remove(selected),
};
info!("Adapter Metal {:?}", adapter.raw.info);
let id_out = backend::Metal::hub().adapters.register_identity(
log::info!("Adapter Metal {:?}", adapter.raw.info);
let id_out = backend::Metal::hub(global).adapters.register_identity(
id_metal.unwrap(),
adapter,
&mut token,
@@ -398,8 +413,8 @@ pub fn request_adapter(
let adapter = Adapter {
raw: adapters_dx12.swap_remove(selected),
};
info!("Adapter Dx12 {:?}", adapter.raw.info);
let id_out = backend::Dx12::hub().adapters.register_identity(
log::info!("Adapter Dx12 {:?}", adapter.raw.info);
let id_out = backend::Dx12::hub(global).adapters.register_identity(
id_dx12.unwrap(),
adapter,
&mut token,
@@ -411,8 +426,8 @@ pub fn request_adapter(
let adapter = Adapter {
raw: adapters_dx11.swap_remove(selected),
};
info!("Adapter Dx11 {:?}", adapter.raw.info);
let id_out = backend::Dx11::hub().adapters.register_identity(
log::info!("Adapter Dx11 {:?}", adapter.raw.info);
let id_out = backend::Dx11::hub(global).adapters.register_identity(
id_dx11.unwrap(),
adapter,
&mut token,
@@ -425,18 +440,19 @@ pub fn request_adapter(
None
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_request_adapter(desc: Option<&RequestAdapterOptions>) -> AdapterId {
request_adapter(&desc.cloned().unwrap_or_default(), &[]).unwrap()
request_adapter(&*GLOBAL, &desc.cloned().unwrap_or_default(), &[]).unwrap()
}
pub fn adapter_request_device<B: GfxBackend>(
global: &Global,
adapter_id: AdapterId,
desc: &DeviceDescriptor,
id_in: Input<DeviceId>,
) -> Output<DeviceId> {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let device = {
let (adapter_guard, _) = hub.adapters.read(&mut token);
@@ -445,12 +461,11 @@ pub fn adapter_request_device<B: GfxBackend>(
let family = adapter
.queue_families
.iter()
.find(|family| {
family.queue_type().supports_graphics()
})
.find(|family| family.queue_type().supports_graphics())
.unwrap();
let mut gpu = unsafe {
adapter.physical_device
adapter
.physical_device
.open(&[(family, &[1.0])], hal::Features::empty())
.unwrap()
};
@@ -467,7 +482,7 @@ pub fn adapter_request_device<B: GfxBackend>(
"Adapter uniform buffer offset alignment not compatible with WGPU"
);
if desc.limits.max_bind_groups == 0 {
warn!("max_bind_groups limit is missing");
log::warn!("max_bind_groups limit is missing");
} else {
assert!(
u32::from(limits.max_bound_descriptor_sets) >= desc.limits.max_bind_groups,
@@ -496,27 +511,25 @@ pub fn adapter_request_device<B: GfxBackend>(
hub.devices.register_identity(id_in, device, &mut token)
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_adapter_request_device(
adapter_id: AdapterId,
desc: Option<&DeviceDescriptor>,
) -> DeviceId {
let desc = &desc.cloned().unwrap_or_default();
gfx_select!(adapter_id => adapter_request_device(adapter_id, desc, PhantomData))
gfx_select!(adapter_id => adapter_request_device(&*GLOBAL, adapter_id, desc, PhantomData))
}
pub fn adapter_get_info<B: GfxBackend>(adapter_id: AdapterId) -> AdapterInfo {
let hub = B::hub();
pub fn adapter_get_info<B: GfxBackend>(global: &Global, adapter_id: AdapterId) -> AdapterInfo {
let hub = B::hub(global);
let mut token = Token::root();
let (adapter_guard, _) = hub.adapters.read(&mut token);
let adapter = &adapter_guard[adapter_id];
adapter.raw.info.clone()
}
#[cfg(not(feature = "remote"))]
pub fn wgpu_adapter_get_info(
adapter_id: AdapterId
) -> AdapterInfo {
gfx_select!(adapter_id => adapter_get_info(adapter_id))
#[cfg(feature = "local")]
pub fn wgpu_adapter_get_info(adapter_id: AdapterId) -> AdapterInfo {
gfx_select!(adapter_id => adapter_get_info(&*GLOBAL, adapter_id))
}
+6 -3
View File
@@ -10,7 +10,10 @@ pub mod backend {
pub use gfx_backend_empty::Backend as Empty;
#[cfg(any(target_os = "ios", target_os = "macos"))]
pub use gfx_backend_metal::Backend as Metal;
#[cfg(any(not(any(target_os = "ios", target_os = "macos")), feature = "gfx-backend-vulkan"))]
#[cfg(any(
not(any(target_os = "ios", target_os = "macos")),
feature = "gfx-backend-vulkan"
))]
pub use gfx_backend_vulkan::Backend as Vulkan;
}
@@ -29,15 +32,15 @@ mod track;
pub use self::binding_model::*;
pub use self::command::*;
pub use self::device::*;
#[cfg(feature = "remote")]
#[cfg(not(feature = "local"))]
pub use self::hub::{Access, IdentityManager, Registry, Token};
pub use self::id::*;
pub use self::instance::*;
pub use self::pipeline::*;
pub use self::resource::*;
pub use self::swap_chain::*;
pub use hal::pso::read_spirv;
pub use hal::adapter::AdapterInfo;
pub use hal::pso::read_spirv;
use std::{
os::raw::c_char,
-1
View File
@@ -288,7 +288,6 @@ pub struct TextureView<B: hal::Backend> {
pub(crate) extent: hal::image::Extent,
pub(crate) samples: hal::image::NumSamples,
pub(crate) range: hal::image::SubresourceRange,
#[cfg_attr(feature = "remote", allow(dead_code))]
pub(crate) life_guard: LifeGuard,
}
+33 -35
View File
@@ -34,8 +34,7 @@
use crate::{
conv,
gfx_select,
hub::{GLOBAL, GfxBackend, Token},
hub::{GfxBackend, Global, Token},
resource,
DeviceId,
Extent3d,
@@ -46,15 +45,12 @@ use crate::{
SwapChainId,
TextureViewId,
};
#[cfg(feature = "local")]
use crate::{gfx_select, hub::GLOBAL};
use hal::{
self,
device::Device as _,
queue::CommandQueue as _,
window::PresentationSurface as _,
};
use hal::{self, device::Device as _, queue::CommandQueue as _, window::PresentationSurface as _};
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
use std::marker::PhantomData;
const FRAME_TIMEOUT_MS: u64 = 1000;
@@ -88,7 +84,11 @@ pub struct SwapChainDescriptor {
}
impl SwapChainDescriptor {
pub(crate) fn to_hal(&self, num_frames: u32, features: &Features) -> hal::window::SwapchainConfig {
pub(crate) fn to_hal(
&self,
num_frames: u32,
features: &Features,
) -> hal::window::SwapchainConfig {
let mut config = hal::window::SwapchainConfig::new(
self.width,
self.height,
@@ -129,13 +129,14 @@ pub struct SwapChainOutput {
}
pub fn swap_chain_get_next_texture<B: GfxBackend>(
global: &Global,
swap_chain_id: SwapChainId,
view_id_in: Input<TextureViewId>,
) -> SwapChainOutput {
let hub = B::hub();
let hub = B::hub(global);
let mut token = Token::root();
let (mut surface_guard, mut token) = GLOBAL.surfaces.write(&mut token);
let (mut surface_guard, mut token) = global.surfaces.write(&mut token);
let surface = &mut surface_guard[swap_chain_id.to_surface_id()];
let (device_guard, mut token) = hub.devices.read(&mut token);
let (mut swap_chain_guard, mut token) = hub.swap_chains.write(&mut token);
@@ -153,12 +154,8 @@ pub fn swap_chain_get_next_texture<B: GfxBackend>(
log::warn!("acquire_image() failed ({:?}), reconfiguring swapchain", e);
let desc = sc.desc.to_hal(sc.num_frames, &device.features);
unsafe {
suf
.configure_swapchain(&device.raw, desc)
.unwrap();
suf
.acquire_image(FRAME_TIMEOUT_MS * 1_000_000)
.unwrap()
suf.configure_swapchain(&device.raw, desc).unwrap();
suf.acquire_image(FRAME_TIMEOUT_MS * 1_000_000).unwrap()
}
}
}
@@ -191,50 +188,50 @@ pub fn swap_chain_get_next_texture<B: GfxBackend>(
let (view_id, _) = hub.texture_views.new_identity(view_id_in);
hub.texture_views.register(view_id, view, &mut token);
assert!(sc.acquired_view_id.is_none(), "Swap chain image is already acquired");
assert!(
sc.acquired_view_id.is_none(),
"Swap chain image is already acquired"
);
sc.acquired_view_id = Some(Stored {
value: view_id,
ref_count,
});
SwapChainOutput {
view_id,
}
SwapChainOutput { view_id }
}
#[cfg(not(feature = "remote"))]
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_swap_chain_get_next_texture(swap_chain_id: SwapChainId) -> SwapChainOutput {
gfx_select!(swap_chain_id => swap_chain_get_next_texture(swap_chain_id, PhantomData))
gfx_select!(swap_chain_id => swap_chain_get_next_texture(&*GLOBAL, swap_chain_id, PhantomData))
}
pub fn swap_chain_present<B: GfxBackend>(swap_chain_id: SwapChainId) {
let hub = B::hub();
pub fn swap_chain_present<B: GfxBackend>(global: &Global, swap_chain_id: SwapChainId) {
let hub = B::hub(global);
let mut token = Token::root();
let (mut surface_guard, mut token) = GLOBAL.surfaces.write(&mut token);
let (mut surface_guard, mut token) = global.surfaces.write(&mut token);
let surface = &mut surface_guard[swap_chain_id.to_surface_id()];
let (mut device_guard, mut token) = hub.devices.write(&mut token);
let (mut swap_chain_guard, mut token) = hub.swap_chains.write(&mut token);
let sc = &mut swap_chain_guard[swap_chain_id];
let device = &mut device_guard[sc.device_id.value];
let view_id = sc.acquired_view_id
let view_id = sc
.acquired_view_id
.take()
.expect("Swap chain image is not acquired");
let (view, _) = hub.texture_views.unregister(view_id.value, &mut token);
let (image, framebuffer) = match view.inner {
resource::TextureViewInner::Native { .. } => unreachable!(),
resource::TextureViewInner::SwapChain { image, framebuffer, .. } => (image, framebuffer),
resource::TextureViewInner::SwapChain {
image, framebuffer, ..
} => (image, framebuffer),
};
let err = unsafe {
let queue = &mut device.queue_group.queues[0];
queue.present_surface(
B::get_surface_mut(surface),
image,
Some(&sc.semaphore),
)
queue.present_surface(B::get_surface_mut(surface), image, Some(&sc.semaphore))
};
if let Err(e) = err {
log::warn!("present failed: {:?}", e);
@@ -247,7 +244,8 @@ pub fn swap_chain_present<B: GfxBackend>(swap_chain_id: SwapChainId) {
}
}
#[cfg(feature = "local")]
#[no_mangle]
pub extern "C" fn wgpu_swap_chain_present(swap_chain_id: SwapChainId) {
gfx_select!(swap_chain_id => swap_chain_present(swap_chain_id))
gfx_select!(swap_chain_id => swap_chain_present(&*GLOBAL, swap_chain_id))
}
+1 -1
View File
@@ -14,7 +14,7 @@ crate-type = ["lib", "cdylib", "staticlib"]
default = []
[dependencies]
wgpu-native = { path = "../wgpu-native", version = "0.3", features = ["remote"] }
wgpu-native = { path = "../wgpu-native", version = "0.3", features = ["serde"] }
ipc-channel = "0.12"
log = "0.4"
parking_lot = { version = "0.9" }
+1 -2
View File
@@ -9,7 +9,6 @@ use wgn::{AdapterId, Backend, DeviceId, IdentityManager, SurfaceId};
use crate::server::Server;
use ipc_channel::ipc;
use log::error;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
@@ -124,7 +123,7 @@ pub extern "C" fn wgpu_initialize() -> Infrastructure {
}
}
Err(e) => {
error!("WGPU initialize failed: {:?}", e);
log::error!("WGPU initialize failed: {:?}", e);
Infrastructure {
client: ptr::null_mut(),
server: ptr::null_mut(),
+3 -2
View File
@@ -23,7 +23,8 @@ enum ControlFlow {
Terminate,
}
fn process(message: GlobalMessage) -> ControlFlow {
fn process(_message: GlobalMessage) -> ControlFlow {
/*
match message {
GlobalMessage::RequestAdapter(ref desc, ref ids) => {
wgn::request_adapter(desc, ids);
@@ -33,7 +34,7 @@ fn process(message: GlobalMessage) -> ControlFlow {
wgn::gfx_select!(adapter_id => fun(adapter_id, desc, id));
}
GlobalMessage::Terminate => return ControlFlow::Terminate,
}
}*/
ControlFlow::Continue
}