mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-21 15:00:57 +01:00
Enable unsafe_ops_in_unsafe_fn lint in all workspaces (#3044)
This commit is contained in:
1 parent
d536613705
commit
18f3f5f6f0
43 files changed
+3038
-2406
No files matched your search
@@ -229,6 +229,7 @@ both `raw_window_handle::HasRawWindowHandle` and `raw_window_handle::HasRawDispl
|
||||
- Don't use `PhantomData` for `IdentityManager`'s `Input` type. By @jimblandy in [#2972](https://github.com/gfx-rs/wgpu/pull/2972)
|
||||
- Changed Naga variant in ShaderSource to `Cow<'static, Module>`, to allow loading global variables by @daxpedda in [#2903](https://github.com/gfx-rs/wgpu/pull/2903)
|
||||
- Updated the maximum binding index to match the WebGPU specification by @nical in [#2957](https://github.com/gfx-rs/wgpu/pull/2957)
|
||||
- Add `unsafe_op_in_unsafe_fn` to Clippy lints in the entire workspace. By @ErichDonGubler in [#3044](https://github.com/gfx-rs/wgpu/pull/3044).
|
||||
|
||||
#### Metal
|
||||
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
|
||||
|
||||
#![warn(unsafe_op_in_unsafe_fn)]
|
||||
|
||||
use deno_core::error::AnyError;
|
||||
use deno_core::include_js_files;
|
||||
use deno_core::op;
|
||||
|
||||
@@ -6,6 +6,8 @@
|
||||
* so that we don't accidentally try to use the same ID.
|
||||
!*/
|
||||
|
||||
#![warn(unsafe_op_in_unsafe_fn)]
|
||||
|
||||
use wgc::device::trace;
|
||||
|
||||
use std::{borrow::Cow, fmt::Debug, fs, marker::PhantomData, path::Path};
|
||||
|
||||
@@ -763,7 +763,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
let mut offsets = self.base.dynamic_offsets.as_slice();
|
||||
let mut pipeline_layout_id = None::<id::Valid<id::PipelineLayoutId>>;
|
||||
if let Some(ref label) = self.base.label {
|
||||
raw.begin_debug_marker(label);
|
||||
unsafe { raw.begin_debug_marker(label) };
|
||||
}
|
||||
|
||||
for command in self.base.commands.iter() {
|
||||
@@ -774,17 +774,19 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
bind_group_id,
|
||||
} => {
|
||||
let bind_group = bind_group_guard.get(bind_group_id).unwrap();
|
||||
raw.set_bind_group(
|
||||
&pipeline_layout_guard[pipeline_layout_id.unwrap()].raw,
|
||||
index as u32,
|
||||
&bind_group.raw,
|
||||
&offsets[..num_dynamic_offsets as usize],
|
||||
);
|
||||
unsafe {
|
||||
raw.set_bind_group(
|
||||
&pipeline_layout_guard[pipeline_layout_id.unwrap()].raw,
|
||||
index as u32,
|
||||
&bind_group.raw,
|
||||
&offsets[..num_dynamic_offsets as usize],
|
||||
)
|
||||
};
|
||||
offsets = &offsets[num_dynamic_offsets as usize..];
|
||||
}
|
||||
RenderCommand::SetPipeline(pipeline_id) => {
|
||||
let pipeline = pipeline_guard.get(pipeline_id).unwrap();
|
||||
raw.set_render_pipeline(&pipeline.raw);
|
||||
unsafe { raw.set_render_pipeline(&pipeline.raw) };
|
||||
|
||||
pipeline_layout_id = Some(pipeline.layout_id.value);
|
||||
}
|
||||
@@ -805,7 +807,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
offset,
|
||||
size,
|
||||
};
|
||||
raw.set_index_buffer(bb, index_format);
|
||||
unsafe { raw.set_index_buffer(bb, index_format) };
|
||||
}
|
||||
RenderCommand::SetVertexBuffer {
|
||||
slot,
|
||||
@@ -824,7 +826,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
offset,
|
||||
size,
|
||||
};
|
||||
raw.set_vertex_buffer(slot, bb);
|
||||
unsafe { raw.set_vertex_buffer(slot, bb) };
|
||||
}
|
||||
RenderCommand::SetPushConstant {
|
||||
stages,
|
||||
@@ -841,18 +843,22 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
let data_slice = &self.base.push_constant_data
|
||||
[(values_offset as usize)..values_end_offset];
|
||||
|
||||
raw.set_push_constants(&pipeline_layout.raw, stages, offset, data_slice)
|
||||
unsafe {
|
||||
raw.set_push_constants(&pipeline_layout.raw, stages, offset, data_slice)
|
||||
}
|
||||
} else {
|
||||
super::push_constant_clear(
|
||||
offset,
|
||||
size_bytes,
|
||||
|clear_offset, clear_data| {
|
||||
raw.set_push_constants(
|
||||
&pipeline_layout.raw,
|
||||
stages,
|
||||
clear_offset,
|
||||
clear_data,
|
||||
);
|
||||
unsafe {
|
||||
raw.set_push_constants(
|
||||
&pipeline_layout.raw,
|
||||
stages,
|
||||
clear_offset,
|
||||
clear_data,
|
||||
)
|
||||
};
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -863,7 +869,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
first_vertex,
|
||||
first_instance,
|
||||
} => {
|
||||
raw.draw(first_vertex, vertex_count, first_instance, instance_count);
|
||||
unsafe { raw.draw(first_vertex, vertex_count, first_instance, instance_count) };
|
||||
}
|
||||
RenderCommand::DrawIndexed {
|
||||
index_count,
|
||||
@@ -872,13 +878,15 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
base_vertex,
|
||||
first_instance,
|
||||
} => {
|
||||
raw.draw_indexed(
|
||||
first_index,
|
||||
index_count,
|
||||
base_vertex,
|
||||
first_instance,
|
||||
instance_count,
|
||||
);
|
||||
unsafe {
|
||||
raw.draw_indexed(
|
||||
first_index,
|
||||
index_count,
|
||||
base_vertex,
|
||||
first_instance,
|
||||
instance_count,
|
||||
)
|
||||
};
|
||||
}
|
||||
RenderCommand::MultiDrawIndirect {
|
||||
buffer_id,
|
||||
@@ -892,7 +900,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(ExecutionError::DestroyedBuffer(buffer_id))?;
|
||||
raw.draw_indirect(buffer, offset, 1);
|
||||
unsafe { raw.draw_indirect(buffer, offset, 1) };
|
||||
}
|
||||
RenderCommand::MultiDrawIndirect {
|
||||
buffer_id,
|
||||
@@ -906,7 +914,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(ExecutionError::DestroyedBuffer(buffer_id))?;
|
||||
raw.draw_indexed_indirect(buffer, offset, 1);
|
||||
unsafe { raw.draw_indexed_indirect(buffer, offset, 1) };
|
||||
}
|
||||
RenderCommand::MultiDrawIndirect { .. }
|
||||
| RenderCommand::MultiDrawIndirectCount { .. } => {
|
||||
@@ -931,7 +939,7 @@ impl<A: HalApi> RenderBundle<A> {
|
||||
}
|
||||
|
||||
if let Some(_) = self.base.label {
|
||||
raw.end_debug_marker();
|
||||
unsafe { raw.end_debug_marker() };
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -1439,13 +1447,15 @@ pub mod bundle_ffi {
|
||||
offsets: *const DynamicOffset,
|
||||
offset_length: usize,
|
||||
) {
|
||||
let redundant = bundle.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut bundle.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
);
|
||||
let redundant = unsafe {
|
||||
bundle.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut bundle.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
)
|
||||
};
|
||||
|
||||
if redundant {
|
||||
return;
|
||||
@@ -1522,7 +1532,7 @@ pub mod bundle_ffi {
|
||||
0,
|
||||
"Push constant size must be aligned to 4 bytes."
|
||||
);
|
||||
let data_slice = slice::from_raw_parts(data, size_bytes as usize);
|
||||
let data_slice = unsafe { slice::from_raw_parts(data, size_bytes as usize) };
|
||||
let value_offset = pass.base.push_constant_data.len().try_into().expect(
|
||||
"Ran out of push constant space. Don't set 4gb of push constants per RenderBundle.",
|
||||
);
|
||||
|
||||
@@ -800,13 +800,15 @@ pub mod compute_ffi {
|
||||
offsets: *const DynamicOffset,
|
||||
offset_length: usize,
|
||||
) {
|
||||
let redundant = pass.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut pass.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
);
|
||||
let redundant = unsafe {
|
||||
pass.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut pass.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
)
|
||||
};
|
||||
|
||||
if redundant {
|
||||
return;
|
||||
@@ -854,7 +856,7 @@ pub mod compute_ffi {
|
||||
0,
|
||||
"Push constant size must be aligned to 4 bytes."
|
||||
);
|
||||
let data_slice = slice::from_raw_parts(data, size_bytes as usize);
|
||||
let data_slice = unsafe { slice::from_raw_parts(data, size_bytes as usize) };
|
||||
let value_offset = pass.base.push_constant_data.len().try_into().expect(
|
||||
"Ran out of push constant space. Don't set 4gb of push constants per ComputePass.",
|
||||
);
|
||||
@@ -905,7 +907,7 @@ pub mod compute_ffi {
|
||||
label: RawString,
|
||||
color: u32,
|
||||
) {
|
||||
let bytes = ffi::CStr::from_ptr(label).to_bytes();
|
||||
let bytes = unsafe { ffi::CStr::from_ptr(label) }.to_bytes();
|
||||
pass.base.string_data.extend_from_slice(bytes);
|
||||
|
||||
pass.base.commands.push(ComputeCommand::PushDebugGroup {
|
||||
@@ -929,7 +931,7 @@ pub mod compute_ffi {
|
||||
label: RawString,
|
||||
color: u32,
|
||||
) {
|
||||
let bytes = ffi::CStr::from_ptr(label).to_bytes();
|
||||
let bytes = unsafe { ffi::CStr::from_ptr(label) }.to_bytes();
|
||||
pass.base.string_data.extend_from_slice(bytes);
|
||||
|
||||
pass.base.commands.push(ComputeCommand::InsertDebugMarker {
|
||||
|
||||
@@ -526,7 +526,8 @@ impl BindGroupStateChange {
|
||||
if let Some(current_bind_group) = self.last_states.get_mut(index as usize) {
|
||||
current_bind_group.reset();
|
||||
}
|
||||
dynamic_offsets.extend_from_slice(slice::from_raw_parts(offsets, offset_length));
|
||||
dynamic_offsets
|
||||
.extend_from_slice(unsafe { slice::from_raw_parts(offsets, offset_length) });
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
@@ -2113,13 +2113,15 @@ pub mod render_ffi {
|
||||
offsets: *const DynamicOffset,
|
||||
offset_length: usize,
|
||||
) {
|
||||
let redundant = pass.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut pass.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
);
|
||||
let redundant = unsafe {
|
||||
pass.current_bind_groups.set_and_check_redundant(
|
||||
bind_group_id,
|
||||
index,
|
||||
&mut pass.base.dynamic_offsets,
|
||||
offsets,
|
||||
offset_length,
|
||||
)
|
||||
};
|
||||
|
||||
if redundant {
|
||||
return;
|
||||
@@ -2239,7 +2241,7 @@ pub mod render_ffi {
|
||||
0,
|
||||
"Push constant size must be aligned to 4 bytes."
|
||||
);
|
||||
let data_slice = slice::from_raw_parts(data, size_bytes as usize);
|
||||
let data_slice = unsafe { slice::from_raw_parts(data, size_bytes as usize) };
|
||||
let value_offset = pass.base.push_constant_data.len().try_into().expect(
|
||||
"Ran out of push constant space. Don't set 4gb of push constants per RenderPass.",
|
||||
);
|
||||
@@ -2402,7 +2404,7 @@ pub mod render_ffi {
|
||||
label: RawString,
|
||||
color: u32,
|
||||
) {
|
||||
let bytes = ffi::CStr::from_ptr(label).to_bytes();
|
||||
let bytes = unsafe { ffi::CStr::from_ptr(label) }.to_bytes();
|
||||
pass.base.string_data.extend_from_slice(bytes);
|
||||
|
||||
pass.base.commands.push(RenderCommand::PushDebugGroup {
|
||||
@@ -2426,7 +2428,7 @@ pub mod render_ffi {
|
||||
label: RawString,
|
||||
color: u32,
|
||||
) {
|
||||
let bytes = ffi::CStr::from_ptr(label).to_bytes();
|
||||
let bytes = unsafe { ffi::CStr::from_ptr(label) }.to_bytes();
|
||||
pass.base.string_data.extend_from_slice(bytes);
|
||||
|
||||
pass.base.commands.push(RenderCommand::InsertDebugMarker {
|
||||
@@ -2478,7 +2480,9 @@ pub mod render_ffi {
|
||||
render_bundle_ids: *const id::RenderBundleId,
|
||||
render_bundle_ids_length: usize,
|
||||
) {
|
||||
for &bundle_id in slice::from_raw_parts(render_bundle_ids, render_bundle_ids_length) {
|
||||
for &bundle_id in
|
||||
unsafe { slice::from_raw_parts(render_bundle_ids, render_bundle_ids_length) }
|
||||
{
|
||||
pass.base
|
||||
.commands
|
||||
.push(RenderCommand::ExecuteBundle(bundle_id));
|
||||
|
||||
@@ -132,61 +132,61 @@ impl<A: hal::Api> NonReferencedResources<A> {
|
||||
if !self.buffers.is_empty() {
|
||||
profiling::scope!("destroy_buffers");
|
||||
for raw in self.buffers.drain(..) {
|
||||
device.destroy_buffer(raw);
|
||||
unsafe { device.destroy_buffer(raw) };
|
||||
}
|
||||
}
|
||||
if !self.textures.is_empty() {
|
||||
profiling::scope!("destroy_textures");
|
||||
for raw in self.textures.drain(..) {
|
||||
device.destroy_texture(raw);
|
||||
unsafe { device.destroy_texture(raw) };
|
||||
}
|
||||
}
|
||||
if !self.texture_views.is_empty() {
|
||||
profiling::scope!("destroy_texture_views");
|
||||
for raw in self.texture_views.drain(..) {
|
||||
device.destroy_texture_view(raw);
|
||||
unsafe { device.destroy_texture_view(raw) };
|
||||
}
|
||||
}
|
||||
if !self.samplers.is_empty() {
|
||||
profiling::scope!("destroy_samplers");
|
||||
for raw in self.samplers.drain(..) {
|
||||
device.destroy_sampler(raw);
|
||||
unsafe { device.destroy_sampler(raw) };
|
||||
}
|
||||
}
|
||||
if !self.bind_groups.is_empty() {
|
||||
profiling::scope!("destroy_bind_groups");
|
||||
for raw in self.bind_groups.drain(..) {
|
||||
device.destroy_bind_group(raw);
|
||||
unsafe { device.destroy_bind_group(raw) };
|
||||
}
|
||||
}
|
||||
if !self.compute_pipes.is_empty() {
|
||||
profiling::scope!("destroy_compute_pipelines");
|
||||
for raw in self.compute_pipes.drain(..) {
|
||||
device.destroy_compute_pipeline(raw);
|
||||
unsafe { device.destroy_compute_pipeline(raw) };
|
||||
}
|
||||
}
|
||||
if !self.render_pipes.is_empty() {
|
||||
profiling::scope!("destroy_render_pipelines");
|
||||
for raw in self.render_pipes.drain(..) {
|
||||
device.destroy_render_pipeline(raw);
|
||||
unsafe { device.destroy_render_pipeline(raw) };
|
||||
}
|
||||
}
|
||||
if !self.bind_group_layouts.is_empty() {
|
||||
profiling::scope!("destroy_bind_group_layouts");
|
||||
for raw in self.bind_group_layouts.drain(..) {
|
||||
device.destroy_bind_group_layout(raw);
|
||||
unsafe { device.destroy_bind_group_layout(raw) };
|
||||
}
|
||||
}
|
||||
if !self.pipeline_layouts.is_empty() {
|
||||
profiling::scope!("destroy_pipeline_layouts");
|
||||
for raw in self.pipeline_layouts.drain(..) {
|
||||
device.destroy_pipeline_layout(raw);
|
||||
unsafe { device.destroy_pipeline_layout(raw) };
|
||||
}
|
||||
}
|
||||
if !self.query_sets.is_empty() {
|
||||
profiling::scope!("destroy_query_sets");
|
||||
for raw in self.query_sets.drain(..) {
|
||||
device.destroy_query_set(raw);
|
||||
unsafe { device.destroy_query_set(raw) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4519,10 +4519,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
});
|
||||
};
|
||||
|
||||
let shader = match device.create_shader_module_spirv(device_id, desc, &source) {
|
||||
Ok(shader) => shader,
|
||||
Err(e) => break e,
|
||||
};
|
||||
let shader =
|
||||
match unsafe { device.create_shader_module_spirv(device_id, desc, &source) } {
|
||||
Ok(shader) => shader,
|
||||
Err(e) => break e,
|
||||
};
|
||||
let id = fid.assign(shader, &mut token);
|
||||
return (id.0, None);
|
||||
};
|
||||
|
||||
@@ -116,7 +116,7 @@ pub(super) struct EncoderInFlight<A: hal::Api> {
|
||||
|
||||
impl<A: hal::Api> EncoderInFlight<A> {
|
||||
pub(super) unsafe fn land(mut self) -> A::CommandEncoder {
|
||||
self.raw.reset_all(self.cmd_buffers.into_iter());
|
||||
unsafe { self.raw.reset_all(self.cmd_buffers.into_iter()) };
|
||||
self.raw
|
||||
}
|
||||
}
|
||||
@@ -276,9 +276,9 @@ fn prepare_staging_buffer<A: HalApi>(
|
||||
impl<A: hal::Api> StagingBuffer<A> {
|
||||
unsafe fn flush(&self, device: &A::Device) -> Result<(), DeviceError> {
|
||||
if !self.is_coherent {
|
||||
device.flush_mapped_ranges(&self.raw, iter::once(0..self.size));
|
||||
unsafe { device.flush_mapped_ranges(&self.raw, iter::once(0..self.size)) };
|
||||
}
|
||||
device.unmap_buffer(&self.raw)?;
|
||||
unsafe { device.unmap_buffer(&self.raw)? };
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -586,7 +586,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
#[cfg(vulkan)]
|
||||
vulkan: None,
|
||||
dx12: self.instance.dx12.as_ref().map(|inst| HalSurface {
|
||||
raw: { inst.create_surface_from_visual(visual as _) },
|
||||
raw: unsafe { inst.create_surface_from_visual(visual as _) },
|
||||
}),
|
||||
dx11: None,
|
||||
#[cfg(gl)]
|
||||
|
||||
@@ -28,6 +28,7 @@
|
||||
#![warn(
|
||||
trivial_casts,
|
||||
trivial_numeric_casts,
|
||||
unsafe_op_in_unsafe_fn,
|
||||
unused_extern_crates,
|
||||
unused_qualifications,
|
||||
// We don't match on a reference, unless required.
|
||||
|
||||
+107
-87
@@ -147,19 +147,21 @@ impl<A: hub::HalApi> BufferUsageScope<A> {
|
||||
let (index32, epoch, _) = id.0.unzip();
|
||||
let index = index32 as usize;
|
||||
|
||||
insert_or_merge(
|
||||
None,
|
||||
None,
|
||||
&mut self.state,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
BufferStateProvider::Direct { state },
|
||||
ResourceMetadataProvider::Direct {
|
||||
epoch,
|
||||
ref_count: Cow::Borrowed(ref_count),
|
||||
},
|
||||
)?;
|
||||
unsafe {
|
||||
insert_or_merge(
|
||||
None,
|
||||
None,
|
||||
&mut self.state,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
BufferStateProvider::Direct { state },
|
||||
ResourceMetadataProvider::Direct {
|
||||
epoch,
|
||||
ref_count: Cow::Borrowed(ref_count),
|
||||
},
|
||||
)?
|
||||
};
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -490,27 +492,29 @@ impl<A: hub::HalApi> BufferTracker<A> {
|
||||
|
||||
scope.tracker_assert_in_bounds(index);
|
||||
|
||||
if !scope.metadata.owned.get(index).unwrap_unchecked() {
|
||||
if unsafe { !scope.metadata.owned.get(index).unwrap_unchecked() } {
|
||||
continue;
|
||||
}
|
||||
insert_or_barrier_update(
|
||||
None,
|
||||
Some(&mut self.start),
|
||||
&mut self.end,
|
||||
&mut self.metadata,
|
||||
index as u32,
|
||||
index,
|
||||
BufferStateProvider::Indirect {
|
||||
state: &scope.state,
|
||||
},
|
||||
None,
|
||||
ResourceMetadataProvider::Indirect {
|
||||
metadata: &scope.metadata,
|
||||
},
|
||||
&mut self.temp,
|
||||
);
|
||||
unsafe {
|
||||
insert_or_barrier_update(
|
||||
None,
|
||||
Some(&mut self.start),
|
||||
&mut self.end,
|
||||
&mut self.metadata,
|
||||
index as u32,
|
||||
index,
|
||||
BufferStateProvider::Indirect {
|
||||
state: &scope.state,
|
||||
},
|
||||
None,
|
||||
ResourceMetadataProvider::Indirect {
|
||||
metadata: &scope.metadata,
|
||||
},
|
||||
&mut self.temp,
|
||||
)
|
||||
};
|
||||
|
||||
scope.metadata.reset(index);
|
||||
unsafe { scope.metadata.reset(index) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -570,7 +574,7 @@ impl BufferStateProvider<'_> {
|
||||
BufferStateProvider::Direct { state } => state,
|
||||
BufferStateProvider::Indirect { state } => {
|
||||
strict_assert!(index < state.len());
|
||||
*state.get_unchecked(index)
|
||||
*unsafe { state.get_unchecked(index) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -596,29 +600,33 @@ unsafe fn insert_or_merge<A: hub::HalApi>(
|
||||
state_provider: BufferStateProvider<'_>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
let currently_owned = resource_metadata.owned.get(index).unwrap_unchecked();
|
||||
let currently_owned = unsafe { resource_metadata.owned.get(index).unwrap_unchecked() };
|
||||
|
||||
if !currently_owned {
|
||||
insert(
|
||||
life_guard,
|
||||
start_states,
|
||||
current_states,
|
||||
resource_metadata,
|
||||
index,
|
||||
state_provider,
|
||||
None,
|
||||
metadata_provider,
|
||||
);
|
||||
unsafe {
|
||||
insert(
|
||||
life_guard,
|
||||
start_states,
|
||||
current_states,
|
||||
resource_metadata,
|
||||
index,
|
||||
state_provider,
|
||||
None,
|
||||
metadata_provider,
|
||||
)
|
||||
};
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
merge(
|
||||
current_states,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
unsafe {
|
||||
merge(
|
||||
current_states,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// If the resource isn't tracked
|
||||
@@ -651,32 +659,36 @@ unsafe fn insert_or_barrier_update<A: hub::HalApi>(
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
barriers: &mut Vec<PendingTransition<BufferUses>>,
|
||||
) {
|
||||
let currently_owned = resource_metadata.owned.get(index).unwrap_unchecked();
|
||||
let currently_owned = unsafe { resource_metadata.owned.get(index).unwrap_unchecked() };
|
||||
|
||||
if !currently_owned {
|
||||
insert(
|
||||
life_guard,
|
||||
start_states,
|
||||
current_states,
|
||||
resource_metadata,
|
||||
index,
|
||||
start_state_provider,
|
||||
end_state_provider,
|
||||
metadata_provider,
|
||||
);
|
||||
unsafe {
|
||||
insert(
|
||||
life_guard,
|
||||
start_states,
|
||||
current_states,
|
||||
resource_metadata,
|
||||
index,
|
||||
start_state_provider,
|
||||
end_state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
};
|
||||
return;
|
||||
}
|
||||
|
||||
let update_state_provider = end_state_provider.unwrap_or_else(|| start_state_provider.clone());
|
||||
barrier(
|
||||
current_states,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
barriers,
|
||||
);
|
||||
unsafe {
|
||||
barrier(
|
||||
current_states,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
barriers,
|
||||
)
|
||||
};
|
||||
|
||||
update(current_states, index, update_state_provider);
|
||||
unsafe { update(current_states, index, update_state_provider) };
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
@@ -690,8 +702,9 @@ unsafe fn insert<A: hub::HalApi>(
|
||||
end_state_provider: Option<BufferStateProvider<'_>>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) {
|
||||
let new_start_state = start_state_provider.get_state(index);
|
||||
let new_end_state = end_state_provider.map_or(new_start_state, |p| p.get_state(index));
|
||||
let new_start_state = unsafe { start_state_provider.get_state(index) };
|
||||
let new_end_state =
|
||||
end_state_provider.map_or(new_start_state, |p| unsafe { p.get_state(index) });
|
||||
|
||||
// This should only ever happen with a wgpu bug, but let's just double
|
||||
// check that resource states don't have any conflicts.
|
||||
@@ -700,16 +713,19 @@ unsafe fn insert<A: hub::HalApi>(
|
||||
|
||||
log::trace!("\tbuf {index}: insert {new_start_state:?}..{new_end_state:?}");
|
||||
|
||||
if let Some(&mut ref mut start_state) = start_states {
|
||||
*start_state.get_unchecked_mut(index) = new_start_state;
|
||||
unsafe {
|
||||
if let Some(&mut ref mut start_state) = start_states {
|
||||
*start_state.get_unchecked_mut(index) = new_start_state;
|
||||
}
|
||||
*current_states.get_unchecked_mut(index) = new_end_state;
|
||||
|
||||
let (epoch, ref_count) = metadata_provider.get_own(life_guard, index);
|
||||
|
||||
resource_metadata.owned.set(index, true);
|
||||
|
||||
*resource_metadata.epochs.get_unchecked_mut(index) = epoch;
|
||||
*resource_metadata.ref_counts.get_unchecked_mut(index) = Some(ref_count);
|
||||
}
|
||||
*current_states.get_unchecked_mut(index) = new_end_state;
|
||||
|
||||
let (epoch, ref_count) = metadata_provider.get_own(life_guard, index);
|
||||
|
||||
resource_metadata.owned.set(index, true);
|
||||
*resource_metadata.epochs.get_unchecked_mut(index) = epoch;
|
||||
*resource_metadata.ref_counts.get_unchecked_mut(index) = Some(ref_count);
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
@@ -720,14 +736,18 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
state_provider: BufferStateProvider<'_>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
let current_state = current_states.get_unchecked_mut(index);
|
||||
let new_state = state_provider.get_state(index);
|
||||
let current_state = unsafe { current_states.get_unchecked_mut(index) };
|
||||
let new_state = unsafe { state_provider.get_state(index) };
|
||||
|
||||
let merged_state = *current_state | new_state;
|
||||
|
||||
if invalid_resource_state(merged_state) {
|
||||
return Err(UsageConflict::from_buffer(
|
||||
BufferId::zip(index32, metadata_provider.get_epoch(index), A::VARIANT),
|
||||
BufferId::zip(
|
||||
index32,
|
||||
unsafe { metadata_provider.get_epoch(index) },
|
||||
A::VARIANT,
|
||||
),
|
||||
*current_state,
|
||||
new_state,
|
||||
));
|
||||
@@ -748,8 +768,8 @@ unsafe fn barrier(
|
||||
state_provider: BufferStateProvider<'_>,
|
||||
barriers: &mut Vec<PendingTransition<BufferUses>>,
|
||||
) {
|
||||
let current_state = *current_states.get_unchecked(index);
|
||||
let new_state = state_provider.get_state(index);
|
||||
let current_state = unsafe { *current_states.get_unchecked(index) };
|
||||
let new_state = unsafe { state_provider.get_state(index) };
|
||||
|
||||
if skip_barrier(current_state, new_state) {
|
||||
return;
|
||||
@@ -770,8 +790,8 @@ unsafe fn update(
|
||||
index: usize,
|
||||
state_provider: BufferStateProvider<'_>,
|
||||
) {
|
||||
let current_state = current_states.get_unchecked_mut(index);
|
||||
let new_state = state_provider.get_state(index);
|
||||
let current_state = unsafe { current_states.get_unchecked_mut(index) };
|
||||
let new_state = unsafe { state_provider.get_state(index) };
|
||||
|
||||
*current_state = new_state;
|
||||
}
|
||||
+31
-25
@@ -409,8 +409,8 @@ impl<A: hub::HalApi> ResourceMetadata<A> {
|
||||
|
||||
/// Resets the metadata for a given index to sane "invalid" values.
|
||||
unsafe fn reset(&mut self, index: usize) {
|
||||
*self.ref_counts.get_unchecked_mut(index) = None;
|
||||
*self.epochs.get_unchecked_mut(index) = u32::MAX;
|
||||
unsafe { *self.ref_counts.get_unchecked_mut(index) = None };
|
||||
unsafe { *self.epochs.get_unchecked_mut(index) = u32::MAX };
|
||||
self.owned.set(index, false);
|
||||
}
|
||||
}
|
||||
@@ -445,18 +445,14 @@ impl<A: hub::HalApi> ResourceMetadataProvider<'_, A> {
|
||||
}
|
||||
ResourceMetadataProvider::Indirect { metadata } => {
|
||||
metadata.tracker_assert_in_bounds(index);
|
||||
(
|
||||
*metadata.epochs.get_unchecked(index),
|
||||
metadata
|
||||
.ref_counts
|
||||
.get_unchecked(index)
|
||||
.clone()
|
||||
.unwrap_unchecked(),
|
||||
)
|
||||
(unsafe { *metadata.epochs.get_unchecked(index) }, {
|
||||
let ref_count = unsafe { metadata.ref_counts.get_unchecked(index) };
|
||||
unsafe { ref_count.clone().unwrap_unchecked() }
|
||||
})
|
||||
}
|
||||
ResourceMetadataProvider::Resource { epoch } => {
|
||||
strict_assert!(life_guard.is_some());
|
||||
(epoch, life_guard.unwrap_unchecked().add_ref())
|
||||
(epoch, unsafe { life_guard.unwrap_unchecked() }.add_ref())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -472,7 +468,7 @@ impl<A: hub::HalApi> ResourceMetadataProvider<'_, A> {
|
||||
| ResourceMetadataProvider::Resource { epoch, .. } => epoch,
|
||||
ResourceMetadataProvider::Indirect { metadata } => {
|
||||
metadata.tracker_assert_in_bounds(index);
|
||||
*metadata.epochs.get_unchecked(index)
|
||||
unsafe { *metadata.epochs.get_unchecked(index) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -564,9 +560,11 @@ impl<A: hub::HalApi> RenderBundleScope<A> {
|
||||
textures: &hub::Storage<resource::Texture<A>, id::TextureId>,
|
||||
bind_group: &BindGroupStates<A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
self.buffers.merge_bind_group(&bind_group.buffers)?;
|
||||
self.textures
|
||||
.merge_bind_group(textures, &bind_group.textures)?;
|
||||
unsafe { self.buffers.merge_bind_group(&bind_group.buffers)? };
|
||||
unsafe {
|
||||
self.textures
|
||||
.merge_bind_group(textures, &bind_group.textures)?
|
||||
};
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -611,9 +609,11 @@ impl<A: hub::HalApi> UsageScope<A> {
|
||||
textures: &hub::Storage<resource::Texture<A>, id::TextureId>,
|
||||
bind_group: &BindGroupStates<A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
self.buffers.merge_bind_group(&bind_group.buffers)?;
|
||||
self.textures
|
||||
.merge_bind_group(textures, &bind_group.textures)?;
|
||||
unsafe {
|
||||
self.buffers.merge_bind_group(&bind_group.buffers)?;
|
||||
self.textures
|
||||
.merge_bind_group(textures, &bind_group.textures)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -740,13 +740,19 @@ impl<A: hub::HalApi> Tracker<A> {
|
||||
scope: &mut UsageScope<A>,
|
||||
bind_group: &BindGroupStates<A>,
|
||||
) {
|
||||
self.buffers
|
||||
.set_and_remove_from_usage_scope_sparse(&mut scope.buffers, bind_group.buffers.used());
|
||||
self.textures.set_and_remove_from_usage_scope_sparse(
|
||||
textures,
|
||||
&mut scope.textures,
|
||||
&bind_group.textures,
|
||||
);
|
||||
unsafe {
|
||||
self.buffers.set_and_remove_from_usage_scope_sparse(
|
||||
&mut scope.buffers,
|
||||
bind_group.buffers.used(),
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
self.textures.set_and_remove_from_usage_scope_sparse(
|
||||
textures,
|
||||
&mut scope.textures,
|
||||
&bind_group.textures,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
/// Tracks the stateless resources from the given renderbundle. It is expected
|
||||
|
||||
+177
-138
@@ -114,7 +114,7 @@ impl ComplexTextureState {
|
||||
strict_assert_eq!(invalid_resource_state(desired_state), false);
|
||||
|
||||
let mips = selector.mips.start as usize..selector.mips.end as usize;
|
||||
for mip in complex.mips.get_unchecked_mut(mips) {
|
||||
for mip in unsafe { complex.mips.get_unchecked_mut(mips) } {
|
||||
for &mut (_, ref mut state) in mip.isolate(&selector.layers, TextureUses::UNKNOWN) {
|
||||
*state = desired_state;
|
||||
}
|
||||
@@ -291,9 +291,10 @@ impl<A: hub::HalApi> TextureUsageScope<A> {
|
||||
self.tracker_assert_in_bounds(index);
|
||||
scope.tracker_assert_in_bounds(index);
|
||||
|
||||
let texture_data = unsafe { texture_data_from_texture(storage, index32) };
|
||||
unsafe {
|
||||
insert_or_merge(
|
||||
texture_data_from_texture(storage, index32),
|
||||
texture_data,
|
||||
&mut self.set,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
@@ -327,7 +328,7 @@ impl<A: hub::HalApi> TextureUsageScope<A> {
|
||||
bind_group: &TextureBindGroupState<A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
for &(id, ref selector, ref ref_count, state) in &bind_group.textures {
|
||||
self.merge_single(storage, id, selector.clone(), ref_count, state)?;
|
||||
unsafe { self.merge_single(storage, id, selector.clone(), ref_count, state)? };
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -359,18 +360,21 @@ impl<A: hub::HalApi> TextureUsageScope<A> {
|
||||
|
||||
self.tracker_assert_in_bounds(index);
|
||||
|
||||
insert_or_merge(
|
||||
texture_data_from_texture(storage, index32),
|
||||
&mut self.set,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
TextureStateProvider::from_option(selector, new_state),
|
||||
ResourceMetadataProvider::Direct {
|
||||
epoch,
|
||||
ref_count: Cow::Borrowed(ref_count),
|
||||
},
|
||||
)?;
|
||||
let texture_data = unsafe { texture_data_from_texture(storage, index32) };
|
||||
unsafe {
|
||||
insert_or_merge(
|
||||
texture_data,
|
||||
&mut self.set,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
TextureStateProvider::from_option(selector, new_state),
|
||||
ResourceMetadataProvider::Direct {
|
||||
epoch,
|
||||
ref_count: Cow::Borrowed(ref_count),
|
||||
},
|
||||
)?
|
||||
};
|
||||
|
||||
Ok(())
|
||||
}
|
||||
@@ -465,11 +469,8 @@ impl<A: hub::HalApi> TextureTracker<A> {
|
||||
|
||||
self.tracker_assert_in_bounds(index);
|
||||
|
||||
self.metadata
|
||||
.ref_counts
|
||||
.get_unchecked(index)
|
||||
.as_ref()
|
||||
.unwrap_unchecked()
|
||||
let ref_count = unsafe { self.metadata.ref_counts.get_unchecked(index) };
|
||||
unsafe { ref_count.as_ref().unwrap_unchecked() }
|
||||
}
|
||||
|
||||
/// Inserts a single texture and a state into the resource tracker.
|
||||
@@ -676,25 +677,28 @@ impl<A: hub::HalApi> TextureTracker<A> {
|
||||
let index = index32 as usize;
|
||||
scope.tracker_assert_in_bounds(index);
|
||||
|
||||
if !scope.metadata.owned.get(index).unwrap_unchecked() {
|
||||
if unsafe { !scope.metadata.owned.get(index).unwrap_unchecked() } {
|
||||
continue;
|
||||
}
|
||||
insert_or_barrier_update(
|
||||
texture_data_from_texture(storage, index32),
|
||||
Some(&mut self.start_set),
|
||||
&mut self.end_set,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
TextureStateProvider::TextureSet { set: &scope.set },
|
||||
None,
|
||||
ResourceMetadataProvider::Indirect {
|
||||
metadata: &scope.metadata,
|
||||
},
|
||||
&mut self.temp,
|
||||
);
|
||||
let texture_data = unsafe { texture_data_from_texture(storage, index32) };
|
||||
unsafe {
|
||||
insert_or_barrier_update(
|
||||
texture_data,
|
||||
Some(&mut self.start_set),
|
||||
&mut self.end_set,
|
||||
&mut self.metadata,
|
||||
index32,
|
||||
index,
|
||||
TextureStateProvider::TextureSet { set: &scope.set },
|
||||
None,
|
||||
ResourceMetadataProvider::Indirect {
|
||||
metadata: &scope.metadata,
|
||||
},
|
||||
&mut self.temp,
|
||||
)
|
||||
};
|
||||
|
||||
scope.metadata.reset(index);
|
||||
unsafe { scope.metadata.reset(index) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -856,10 +860,10 @@ impl<'a> TextureStateProvider<'a> {
|
||||
}
|
||||
}
|
||||
TextureStateProvider::TextureSet { set } => {
|
||||
let new_state = *set.simple.get_unchecked(index);
|
||||
let new_state = *unsafe { set.simple.get_unchecked(index) };
|
||||
|
||||
if new_state == TextureUses::COMPLEX {
|
||||
let new_complex = set.complex.get(&index32).unwrap_unchecked();
|
||||
let new_complex = unsafe { set.complex.get(&index32).unwrap_unchecked() };
|
||||
|
||||
SingleOrManyStates::Many(EitherIter::Right(
|
||||
new_complex.to_selector_state_iter(),
|
||||
@@ -879,7 +883,7 @@ unsafe fn texture_data_from_texture<A: hub::HalApi>(
|
||||
storage: &hub::Storage<Texture<A>, TextureId>,
|
||||
index32: u32,
|
||||
) -> (&LifeGuard, &TextureSelector) {
|
||||
let texture = storage.get_unchecked(index32);
|
||||
let texture = unsafe { storage.get_unchecked(index32) };
|
||||
(&texture.life_guard, &texture.full_range)
|
||||
}
|
||||
|
||||
@@ -902,31 +906,35 @@ unsafe fn insert_or_merge<A: hub::HalApi>(
|
||||
state_provider: TextureStateProvider<'_>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
let currently_owned = resource_metadata.owned.get(index).unwrap_unchecked();
|
||||
let currently_owned = unsafe { resource_metadata.owned.get(index).unwrap_unchecked() };
|
||||
|
||||
if !currently_owned {
|
||||
insert(
|
||||
Some(texture_data),
|
||||
None,
|
||||
current_state_set,
|
||||
resource_metadata,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
None,
|
||||
metadata_provider,
|
||||
);
|
||||
unsafe {
|
||||
insert(
|
||||
Some(texture_data),
|
||||
None,
|
||||
current_state_set,
|
||||
resource_metadata,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
None,
|
||||
metadata_provider,
|
||||
)
|
||||
};
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
merge(
|
||||
texture_data,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
unsafe {
|
||||
merge(
|
||||
texture_data,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// If the resource isn't tracked
|
||||
@@ -959,42 +967,48 @@ unsafe fn insert_or_barrier_update<A: hub::HalApi>(
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
barriers: &mut Vec<PendingTransition<TextureUses>>,
|
||||
) {
|
||||
let currently_owned = resource_metadata.owned.get(index).unwrap_unchecked();
|
||||
let currently_owned = unsafe { resource_metadata.owned.get(index).unwrap_unchecked() };
|
||||
|
||||
if !currently_owned {
|
||||
insert(
|
||||
Some(texture_data),
|
||||
start_state,
|
||||
current_state_set,
|
||||
resource_metadata,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
end_state_provider,
|
||||
metadata_provider,
|
||||
);
|
||||
unsafe {
|
||||
insert(
|
||||
Some(texture_data),
|
||||
start_state,
|
||||
current_state_set,
|
||||
resource_metadata,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
end_state_provider,
|
||||
metadata_provider,
|
||||
)
|
||||
};
|
||||
return;
|
||||
}
|
||||
|
||||
let update_state_provider = end_state_provider.unwrap_or_else(|| start_state_provider.clone());
|
||||
barrier(
|
||||
texture_data,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
barriers,
|
||||
);
|
||||
unsafe {
|
||||
barrier(
|
||||
texture_data,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
start_state_provider,
|
||||
barriers,
|
||||
)
|
||||
};
|
||||
|
||||
let start_state_set = start_state.unwrap();
|
||||
update(
|
||||
texture_data,
|
||||
start_state_set,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
update_state_provider,
|
||||
);
|
||||
unsafe {
|
||||
update(
|
||||
texture_data,
|
||||
start_state_set,
|
||||
current_state_set,
|
||||
index32,
|
||||
index,
|
||||
update_state_provider,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
@@ -1009,7 +1023,7 @@ unsafe fn insert<A: hub::HalApi>(
|
||||
end_state_provider: Option<TextureStateProvider<'_>>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) {
|
||||
let start_layers = start_state_provider.get_state(texture_data, index32, index);
|
||||
let start_layers = unsafe { start_state_provider.get_state(texture_data, index32, index) };
|
||||
match start_layers {
|
||||
SingleOrManyStates::Single(state) => {
|
||||
// This should only ever happen with a wgpu bug, but let's just double
|
||||
@@ -1019,36 +1033,37 @@ unsafe fn insert<A: hub::HalApi>(
|
||||
log::trace!("\ttex {index32}: insert start {state:?}");
|
||||
|
||||
if let Some(start_state) = start_state {
|
||||
*start_state.simple.get_unchecked_mut(index) = state;
|
||||
unsafe { *start_state.simple.get_unchecked_mut(index) = state };
|
||||
}
|
||||
|
||||
// We only need to insert ourselves the end state if there is no end state provider.
|
||||
if end_state_provider.is_none() {
|
||||
*end_state.simple.get_unchecked_mut(index) = state;
|
||||
unsafe { *end_state.simple.get_unchecked_mut(index) = state };
|
||||
}
|
||||
}
|
||||
SingleOrManyStates::Many(state_iter) => {
|
||||
let full_range = texture_data.unwrap().1.clone();
|
||||
|
||||
let complex = ComplexTextureState::from_selector_state_iter(full_range, state_iter);
|
||||
let complex =
|
||||
unsafe { ComplexTextureState::from_selector_state_iter(full_range, state_iter) };
|
||||
|
||||
log::trace!("\ttex {index32}: insert start {complex:?}");
|
||||
|
||||
if let Some(start_state) = start_state {
|
||||
*start_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX;
|
||||
unsafe { *start_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX };
|
||||
start_state.complex.insert(index32, complex.clone());
|
||||
}
|
||||
|
||||
// We only need to insert ourselves the end state if there is no end state provider.
|
||||
if end_state_provider.is_none() {
|
||||
*end_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX;
|
||||
unsafe { *end_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX };
|
||||
end_state.complex.insert(index32, complex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(end_state_provider) = end_state_provider {
|
||||
match end_state_provider.get_state(texture_data, index32, index) {
|
||||
match unsafe { end_state_provider.get_state(texture_data, index32, index) } {
|
||||
SingleOrManyStates::Single(state) => {
|
||||
// This should only ever happen with a wgpu bug, but let's just double
|
||||
// check that resource states don't have any conflicts.
|
||||
@@ -1058,29 +1073,31 @@ unsafe fn insert<A: hub::HalApi>(
|
||||
|
||||
// We only need to insert into the end, as there is guarenteed to be
|
||||
// a start state provider.
|
||||
*end_state.simple.get_unchecked_mut(index) = state;
|
||||
unsafe { *end_state.simple.get_unchecked_mut(index) = state };
|
||||
}
|
||||
SingleOrManyStates::Many(state_iter) => {
|
||||
let full_range = texture_data.unwrap().1.clone();
|
||||
|
||||
let complex = ComplexTextureState::from_selector_state_iter(full_range, state_iter);
|
||||
let complex = unsafe {
|
||||
ComplexTextureState::from_selector_state_iter(full_range, state_iter)
|
||||
};
|
||||
|
||||
log::trace!("\ttex {index32}: insert end {complex:?}");
|
||||
|
||||
// We only need to insert into the end, as there is guarenteed to be
|
||||
// a start state provider.
|
||||
*end_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX;
|
||||
unsafe { *end_state.simple.get_unchecked_mut(index) = TextureUses::COMPLEX };
|
||||
end_state.complex.insert(index32, complex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let (epoch, ref_count) =
|
||||
metadata_provider.get_own(texture_data.map(|(life_guard, _)| life_guard), index);
|
||||
unsafe { metadata_provider.get_own(texture_data.map(|(life_guard, _)| life_guard), index) };
|
||||
|
||||
resource_metadata.owned.set(index, true);
|
||||
*resource_metadata.epochs.get_unchecked_mut(index) = epoch;
|
||||
*resource_metadata.ref_counts.get_unchecked_mut(index) = Some(ref_count);
|
||||
unsafe { *resource_metadata.epochs.get_unchecked_mut(index) = epoch };
|
||||
unsafe { *resource_metadata.ref_counts.get_unchecked_mut(index) = Some(ref_count) };
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
@@ -1092,19 +1109,19 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
state_provider: TextureStateProvider<'_>,
|
||||
metadata_provider: ResourceMetadataProvider<'_, A>,
|
||||
) -> Result<(), UsageConflict> {
|
||||
let current_simple = current_state_set.simple.get_unchecked_mut(index);
|
||||
let current_simple = unsafe { current_state_set.simple.get_unchecked_mut(index) };
|
||||
let current_state = if *current_simple == TextureUses::COMPLEX {
|
||||
SingleOrManyStates::Many(
|
||||
SingleOrManyStates::Many(unsafe {
|
||||
current_state_set
|
||||
.complex
|
||||
.get_mut(&index32)
|
||||
.unwrap_unchecked(),
|
||||
)
|
||||
.unwrap_unchecked()
|
||||
})
|
||||
} else {
|
||||
SingleOrManyStates::Single(current_simple)
|
||||
};
|
||||
|
||||
let new_state = state_provider.get_state(Some(texture_data), index32, index);
|
||||
let new_state = unsafe { state_provider.get_state(Some(texture_data), index32, index) };
|
||||
|
||||
match (current_state, new_state) {
|
||||
(SingleOrManyStates::Single(current_simple), SingleOrManyStates::Single(new_simple)) => {
|
||||
@@ -1114,7 +1131,11 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
|
||||
if invalid_resource_state(merged_state) {
|
||||
return Err(UsageConflict::from_texture(
|
||||
TextureId::zip(index32, metadata_provider.get_epoch(index), A::VARIANT),
|
||||
TextureId::zip(
|
||||
index32,
|
||||
unsafe { metadata_provider.get_epoch(index) },
|
||||
A::VARIANT,
|
||||
),
|
||||
texture_data.1.clone(),
|
||||
*current_simple,
|
||||
new_simple,
|
||||
@@ -1127,10 +1148,12 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
// Because we are now demoting this simple state to a complex state,
|
||||
// we actually need to make a whole new complex state for us to use
|
||||
// as there wasn't one before.
|
||||
let mut new_complex = ComplexTextureState::from_selector_state_iter(
|
||||
texture_data.1.clone(),
|
||||
iter::once((texture_data.1.clone(), *current_simple)),
|
||||
);
|
||||
let mut new_complex = unsafe {
|
||||
ComplexTextureState::from_selector_state_iter(
|
||||
texture_data.1.clone(),
|
||||
iter::once((texture_data.1.clone(), *current_simple)),
|
||||
)
|
||||
};
|
||||
|
||||
for (selector, new_state) in new_many {
|
||||
let merged_state = *current_simple | new_state;
|
||||
@@ -1141,7 +1164,11 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
|
||||
if invalid_resource_state(merged_state) {
|
||||
return Err(UsageConflict::from_texture(
|
||||
TextureId::zip(index32, metadata_provider.get_epoch(index), A::VARIANT),
|
||||
TextureId::zip(
|
||||
index32,
|
||||
unsafe { metadata_provider.get_epoch(index) },
|
||||
A::VARIANT,
|
||||
),
|
||||
selector,
|
||||
*current_simple,
|
||||
new_state,
|
||||
@@ -1182,7 +1209,11 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
|
||||
if invalid_resource_state(merged_state) {
|
||||
return Err(UsageConflict::from_texture(
|
||||
TextureId::zip(index32, metadata_provider.get_epoch(index), A::VARIANT),
|
||||
TextureId::zip(
|
||||
index32,
|
||||
unsafe { metadata_provider.get_epoch(index) },
|
||||
A::VARIANT,
|
||||
),
|
||||
TextureSelector {
|
||||
mips: mip_id..mip_id + 1,
|
||||
layers: layers.clone(),
|
||||
@@ -1203,7 +1234,7 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
for mip_id in selector.mips {
|
||||
strict_assert!((mip_id as usize) < current_complex.mips.len());
|
||||
|
||||
let mip = current_complex.mips.get_unchecked_mut(mip_id as usize);
|
||||
let mip = unsafe { current_complex.mips.get_unchecked_mut(mip_id as usize) };
|
||||
|
||||
for &mut (ref layers, ref mut current_layer_state) in
|
||||
mip.isolate(&selector.layers, TextureUses::UNKNOWN)
|
||||
@@ -1225,7 +1256,7 @@ unsafe fn merge<A: hub::HalApi>(
|
||||
return Err(UsageConflict::from_texture(
|
||||
TextureId::zip(
|
||||
index32,
|
||||
metadata_provider.get_epoch(index),
|
||||
unsafe { metadata_provider.get_epoch(index) },
|
||||
A::VARIANT,
|
||||
),
|
||||
TextureSelector {
|
||||
@@ -1256,14 +1287,16 @@ unsafe fn barrier(
|
||||
state_provider: TextureStateProvider<'_>,
|
||||
barriers: &mut Vec<PendingTransition<TextureUses>>,
|
||||
) {
|
||||
let current_simple = *current_state_set.simple.get_unchecked(index);
|
||||
let current_simple = unsafe { *current_state_set.simple.get_unchecked(index) };
|
||||
let current_state = if current_simple == TextureUses::COMPLEX {
|
||||
SingleOrManyStates::Many(current_state_set.complex.get(&index32).unwrap_unchecked())
|
||||
SingleOrManyStates::Many(unsafe {
|
||||
current_state_set.complex.get(&index32).unwrap_unchecked()
|
||||
})
|
||||
} else {
|
||||
SingleOrManyStates::Single(current_simple)
|
||||
};
|
||||
|
||||
let new_state = state_provider.get_state(Some(texture_data), index32, index);
|
||||
let new_state = unsafe { state_provider.get_state(Some(texture_data), index32, index) };
|
||||
|
||||
match (current_state, new_state) {
|
||||
(SingleOrManyStates::Single(current_simple), SingleOrManyStates::Single(new_simple)) => {
|
||||
@@ -1334,7 +1367,7 @@ unsafe fn barrier(
|
||||
for mip_id in selector.mips {
|
||||
strict_assert!((mip_id as usize) < current_complex.mips.len());
|
||||
|
||||
let mip = current_complex.mips.get_unchecked(mip_id as usize);
|
||||
let mip = unsafe { current_complex.mips.get_unchecked(mip_id as usize) };
|
||||
|
||||
for (layers, current_layer_state) in mip.iter_filter(&selector.layers) {
|
||||
if *current_layer_state == TextureUses::UNKNOWN
|
||||
@@ -1377,29 +1410,30 @@ unsafe fn update(
|
||||
index: usize,
|
||||
state_provider: TextureStateProvider<'_>,
|
||||
) {
|
||||
let start_simple = *start_state_set.simple.get_unchecked(index);
|
||||
let start_simple = unsafe { *start_state_set.simple.get_unchecked(index) };
|
||||
|
||||
// We only ever need to update the start state here if the state is complex.
|
||||
//
|
||||
// If the state is simple, the first insert to the tracker would cover it.
|
||||
let mut start_complex = None;
|
||||
if start_simple == TextureUses::COMPLEX {
|
||||
start_complex = Some(start_state_set.complex.get_mut(&index32).unwrap_unchecked());
|
||||
start_complex =
|
||||
Some(unsafe { start_state_set.complex.get_mut(&index32).unwrap_unchecked() });
|
||||
}
|
||||
|
||||
let current_simple = current_state_set.simple.get_unchecked_mut(index);
|
||||
let current_simple = unsafe { current_state_set.simple.get_unchecked_mut(index) };
|
||||
let current_state = if *current_simple == TextureUses::COMPLEX {
|
||||
SingleOrManyStates::Many(
|
||||
SingleOrManyStates::Many(unsafe {
|
||||
current_state_set
|
||||
.complex
|
||||
.get_mut(&index32)
|
||||
.unwrap_unchecked(),
|
||||
)
|
||||
.unwrap_unchecked()
|
||||
})
|
||||
} else {
|
||||
SingleOrManyStates::Single(current_simple)
|
||||
};
|
||||
|
||||
let new_state = state_provider.get_state(Some(texture_data), index32, index);
|
||||
let new_state = unsafe { state_provider.get_state(Some(texture_data), index32, index) };
|
||||
|
||||
match (current_state, new_state) {
|
||||
(SingleOrManyStates::Single(current_simple), SingleOrManyStates::Single(new_simple)) => {
|
||||
@@ -1409,10 +1443,12 @@ unsafe fn update(
|
||||
// Because we are now demoting this simple state to a complex state,
|
||||
// we actually need to make a whole new complex state for us to use
|
||||
// as there wasn't one before.
|
||||
let mut new_complex = ComplexTextureState::from_selector_state_iter(
|
||||
texture_data.1.clone(),
|
||||
iter::once((texture_data.1.clone(), *current_simple)),
|
||||
);
|
||||
let mut new_complex = unsafe {
|
||||
ComplexTextureState::from_selector_state_iter(
|
||||
texture_data.1.clone(),
|
||||
iter::once((texture_data.1.clone(), *current_simple)),
|
||||
)
|
||||
};
|
||||
|
||||
for (selector, mut new_state) in new_many {
|
||||
if new_state == TextureUses::UNKNOWN {
|
||||
@@ -1442,7 +1478,7 @@ unsafe fn update(
|
||||
if let Some(&mut ref mut start_complex) = start_complex {
|
||||
strict_assert!(mip_id < start_complex.mips.len());
|
||||
|
||||
let start_mip = start_complex.mips.get_unchecked_mut(mip_id);
|
||||
let start_mip = unsafe { start_complex.mips.get_unchecked_mut(mip_id) };
|
||||
|
||||
for &mut (_, ref mut current_start_state) in
|
||||
start_mip.isolate(layers, TextureUses::UNKNOWN)
|
||||
@@ -1457,11 +1493,13 @@ unsafe fn update(
|
||||
}
|
||||
}
|
||||
|
||||
*current_state_set.simple.get_unchecked_mut(index) = new_single;
|
||||
current_state_set
|
||||
.complex
|
||||
.remove(&index32)
|
||||
.unwrap_unchecked();
|
||||
unsafe { *current_state_set.simple.get_unchecked_mut(index) = new_single };
|
||||
unsafe {
|
||||
current_state_set
|
||||
.complex
|
||||
.remove(&index32)
|
||||
.unwrap_unchecked()
|
||||
};
|
||||
}
|
||||
(SingleOrManyStates::Many(current_complex), SingleOrManyStates::Many(new_many)) => {
|
||||
for (selector, new_state) in new_many {
|
||||
@@ -1474,7 +1512,7 @@ unsafe fn update(
|
||||
let mip_id = mip_id as usize;
|
||||
strict_assert!(mip_id < current_complex.mips.len());
|
||||
|
||||
let mip = current_complex.mips.get_unchecked_mut(mip_id);
|
||||
let mip = unsafe { current_complex.mips.get_unchecked_mut(mip_id) };
|
||||
|
||||
for &mut (ref layers, ref mut current_layer_state) in
|
||||
mip.isolate(&selector.layers, TextureUses::UNKNOWN)
|
||||
@@ -1490,11 +1528,12 @@ unsafe fn update(
|
||||
// otherwise we would know about this state.
|
||||
strict_assert!(start_complex.is_some());
|
||||
|
||||
let start_complex = start_complex.as_deref_mut().unwrap_unchecked();
|
||||
let start_complex =
|
||||
unsafe { start_complex.as_deref_mut().unwrap_unchecked() };
|
||||
|
||||
strict_assert!(mip_id < start_complex.mips.len());
|
||||
|
||||
let start_mip = start_complex.mips.get_unchecked_mut(mip_id);
|
||||
let start_mip = unsafe { start_complex.mips.get_unchecked_mut(mip_id) };
|
||||
|
||||
for &mut (_, ref mut current_start_state) in
|
||||
start_mip.isolate(layers, TextureUses::UNKNOWN)
|
||||
|
||||
+1
-1
@@ -22,7 +22,7 @@ rustdoc-args = ["--cfg", "docsrs"]
|
||||
[lib]
|
||||
|
||||
[features]
|
||||
default = []
|
||||
default = ["gles"]
|
||||
metal = ["naga/msl-out", "block", "foreign-types"]
|
||||
vulkan = ["naga/spv-out", "ash", "gpu-alloc", "gpu-descriptor", "libloading", "smallvec"]
|
||||
gles = ["naga/glsl-out", "glow", "egl", "libloading"]
|
||||
|
||||
@@ -46,21 +46,23 @@ unsafe extern "system" fn output_debug_string_handler(
|
||||
exception_info: *mut winnt::EXCEPTION_POINTERS,
|
||||
) -> i32 {
|
||||
// See https://stackoverflow.com/a/41480827
|
||||
let record = &*(*exception_info).ExceptionRecord;
|
||||
let record = unsafe { &*(*exception_info).ExceptionRecord };
|
||||
if record.NumberParameters != 2 {
|
||||
return excpt::EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
let message = match record.ExceptionCode {
|
||||
winnt::DBG_PRINTEXCEPTION_C => String::from_utf8_lossy(slice::from_raw_parts(
|
||||
record.ExceptionInformation[1] as *const u8,
|
||||
record.ExceptionInformation[0],
|
||||
)),
|
||||
winnt::DBG_PRINTEXCEPTION_WIDE_C => {
|
||||
Cow::Owned(String::from_utf16_lossy(slice::from_raw_parts(
|
||||
winnt::DBG_PRINTEXCEPTION_C => String::from_utf8_lossy(unsafe {
|
||||
slice::from_raw_parts(
|
||||
record.ExceptionInformation[1] as *const u8,
|
||||
record.ExceptionInformation[0],
|
||||
)
|
||||
}),
|
||||
winnt::DBG_PRINTEXCEPTION_WIDE_C => Cow::Owned(String::from_utf16_lossy(unsafe {
|
||||
slice::from_raw_parts(
|
||||
record.ExceptionInformation[1] as *const u16,
|
||||
record.ExceptionInformation[0],
|
||||
)))
|
||||
}
|
||||
)
|
||||
})),
|
||||
_ => return excpt::EXCEPTION_CONTINUE_SEARCH,
|
||||
};
|
||||
|
||||
|
||||
@@ -44,12 +44,13 @@ impl RenderDoc {
|
||||
let renderdoc_filename = "libVkLayer_GLES_RenderDoc.so";
|
||||
|
||||
#[cfg(unix)]
|
||||
let renderdoc_result: Result<libloading::Library, libloading::Error> =
|
||||
let renderdoc_result: Result<libloading::Library, libloading::Error> = unsafe {
|
||||
libloading::os::unix::Library::open(
|
||||
Some(renderdoc_filename),
|
||||
libloading::os::unix::RTLD_NOW | RTLD_NOLOAD,
|
||||
)
|
||||
.map(|lib| lib.into());
|
||||
}
|
||||
.map(|lib| lib.into());
|
||||
|
||||
#[cfg(windows)]
|
||||
let renderdoc_result: Result<libloading::Library, libloading::Error> =
|
||||
@@ -68,22 +69,23 @@ impl RenderDoc {
|
||||
}
|
||||
};
|
||||
|
||||
let get_api: libloading::Symbol<GetApiFn> = match renderdoc_lib.get(b"RENDERDOC_GetAPI\0") {
|
||||
Ok(api) => api,
|
||||
Err(e) => {
|
||||
return RenderDoc::NotAvailable {
|
||||
reason: format!(
|
||||
"Unable to get RENDERDOC_GetAPI from renderdoc library '{}': {:?}",
|
||||
renderdoc_filename, e
|
||||
),
|
||||
let get_api: libloading::Symbol<GetApiFn> =
|
||||
match unsafe { renderdoc_lib.get(b"RENDERDOC_GetAPI\0") } {
|
||||
Ok(api) => api,
|
||||
Err(e) => {
|
||||
return RenderDoc::NotAvailable {
|
||||
reason: format!(
|
||||
"Unable to get RENDERDOC_GetAPI from renderdoc library '{}': {:?}",
|
||||
renderdoc_filename, e
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
let mut obj = ptr::null_mut();
|
||||
match get_api(10401, &mut obj) {
|
||||
match unsafe { get_api(10401, &mut obj) } {
|
||||
1 => RenderDoc::Available {
|
||||
api: RenderDocApi {
|
||||
api: *(obj as *mut renderdoc_sys::RENDERDOC_API_1_4_1),
|
||||
api: unsafe { *(obj as *mut renderdoc_sys::RENDERDOC_API_1_4_1) },
|
||||
lib: renderdoc_lib,
|
||||
},
|
||||
},
|
||||
@@ -115,7 +117,7 @@ impl RenderDoc {
|
||||
pub unsafe fn start_frame_capture(&self, device_handle: Handle, window_handle: Handle) -> bool {
|
||||
match *self {
|
||||
Self::Available { api: ref entry } => {
|
||||
entry.api.StartFrameCapture.unwrap()(device_handle, window_handle);
|
||||
unsafe { entry.api.StartFrameCapture.unwrap()(device_handle, window_handle) };
|
||||
true
|
||||
}
|
||||
Self::NotAvailable { ref reason } => {
|
||||
@@ -129,7 +131,7 @@ impl RenderDoc {
|
||||
pub unsafe fn end_frame_capture(&self, device_handle: Handle, window_handle: Handle) {
|
||||
match *self {
|
||||
Self::Available { api: ref entry } => {
|
||||
entry.api.EndFrameCapture.unwrap()(device_handle, window_handle);
|
||||
unsafe { entry.api.EndFrameCapture.unwrap()(device_handle, window_handle) };
|
||||
}
|
||||
Self::NotAvailable { ref reason } => {
|
||||
log::warn!("Could not end RenderDoc frame capture: {}", reason)
|
||||
|
||||
@@ -227,14 +227,16 @@ impl crate::Queue<super::Api> for super::Queue {
|
||||
impl super::D3D11Device {
|
||||
#[allow(trivial_casts)] // come on
|
||||
pub unsafe fn check_feature_support<T>(&self, feature: d3d11::D3D11_FEATURE) -> T {
|
||||
let mut value = mem::zeroed::<T>();
|
||||
let ret = self.CheckFeatureSupport(
|
||||
feature,
|
||||
&mut value as *mut T as *mut c_void,
|
||||
mem::size_of::<T>() as u32,
|
||||
);
|
||||
assert_eq!(ret.into_result(), Ok(()));
|
||||
unsafe {
|
||||
let mut value = mem::zeroed::<T>();
|
||||
let ret = self.CheckFeatureSupport(
|
||||
feature,
|
||||
&mut value as *mut T as *mut c_void,
|
||||
mem::size_of::<T>() as u32,
|
||||
);
|
||||
assert_eq!(ret.into_result(), Ok(()));
|
||||
|
||||
value
|
||||
value
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -29,15 +29,17 @@ impl Drop for super::Adapter {
|
||||
|
||||
impl super::Adapter {
|
||||
pub unsafe fn report_live_objects(&self) {
|
||||
if let Ok(debug_device) = self
|
||||
.raw
|
||||
.cast::<d3d12sdklayers::ID3D12DebugDevice>()
|
||||
.into_result()
|
||||
{
|
||||
debug_device.ReportLiveDeviceObjects(
|
||||
d3d12sdklayers::D3D12_RLDO_SUMMARY | d3d12sdklayers::D3D12_RLDO_IGNORE_INTERNAL,
|
||||
);
|
||||
debug_device.destroy();
|
||||
if let Ok(debug_device) = unsafe {
|
||||
self.raw
|
||||
.cast::<d3d12sdklayers::ID3D12DebugDevice>()
|
||||
.into_result()
|
||||
} {
|
||||
unsafe {
|
||||
debug_device.ReportLiveDeviceObjects(
|
||||
d3d12sdklayers::D3D12_RLDO_SUMMARY | d3d12sdklayers::D3D12_RLDO_IGNORE_INTERNAL,
|
||||
)
|
||||
};
|
||||
unsafe { debug_device.destroy() };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -365,35 +367,33 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
|
||||
let mut data = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
|
||||
Format: raw_format,
|
||||
Support1: mem::zeroed(),
|
||||
Support2: mem::zeroed(),
|
||||
Support1: unsafe { mem::zeroed() },
|
||||
Support2: unsafe { mem::zeroed() },
|
||||
};
|
||||
assert_eq!(
|
||||
winerror::S_OK,
|
||||
assert_eq!(winerror::S_OK, unsafe {
|
||||
self.device.CheckFeatureSupport(
|
||||
d3d12::D3D12_FEATURE_FORMAT_SUPPORT,
|
||||
&mut data as *mut _ as *mut _,
|
||||
mem::size_of::<d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT>() as _,
|
||||
)
|
||||
);
|
||||
});
|
||||
|
||||
// Because we use a different format for SRV and UAV views of depth textures, we need to check
|
||||
// the features that use SRV/UAVs using the no-depth format.
|
||||
let mut data_no_depth = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
|
||||
Format: no_depth_format,
|
||||
Support1: mem::zeroed(),
|
||||
Support2: mem::zeroed(),
|
||||
Support1: unsafe { mem::zeroed() },
|
||||
Support2: unsafe { mem::zeroed() },
|
||||
};
|
||||
if raw_format != no_depth_format {
|
||||
// Only-recheck if we're using a different format
|
||||
assert_eq!(
|
||||
winerror::S_OK,
|
||||
assert_eq!(winerror::S_OK, unsafe {
|
||||
self.device.CheckFeatureSupport(
|
||||
d3d12::D3D12_FEATURE_FORMAT_SUPPORT,
|
||||
&mut data_no_depth as *mut _ as *mut _,
|
||||
mem::size_of::<d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT>() as _,
|
||||
)
|
||||
);
|
||||
});
|
||||
} else {
|
||||
// Same format, just copy over.
|
||||
data_no_depth = data;
|
||||
@@ -462,11 +462,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
let mut set_sample_count = |sc: u32, tfc: Tfc| {
|
||||
ms_levels.SampleCount = sc;
|
||||
|
||||
if self.device.CheckFeatureSupport(
|
||||
d3d12::D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
|
||||
<*mut _>::cast(&mut ms_levels),
|
||||
mem::size_of::<d3d12::D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS>() as _,
|
||||
) == winerror::S_OK
|
||||
if unsafe {
|
||||
self.device.CheckFeatureSupport(
|
||||
d3d12::D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
|
||||
<*mut _>::cast(&mut ms_levels),
|
||||
mem::size_of::<d3d12::D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS>() as _,
|
||||
)
|
||||
} == winerror::S_OK
|
||||
&& ms_levels.NumQualityLevels != 0
|
||||
{
|
||||
caps.set(tfc, !no_msaa_load && !no_msaa_target);
|
||||
@@ -487,8 +489,8 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
let current_extent = {
|
||||
match surface.target {
|
||||
SurfaceTarget::WndHandle(wnd_handle) => {
|
||||
let mut rect: windef::RECT = mem::zeroed();
|
||||
if winuser::GetClientRect(wnd_handle, &mut rect) != 0 {
|
||||
let mut rect: windef::RECT = unsafe { mem::zeroed() };
|
||||
if unsafe { winuser::GetClientRect(wnd_handle, &mut rect) } != 0 {
|
||||
Some(wgt::Extent3d {
|
||||
width: (rect.right - rect.left) as u32,
|
||||
height: (rect.bottom - rect.top) as u32,
|
||||
|
||||
+268
-190
@@ -64,7 +64,7 @@ impl super::CommandEncoder {
|
||||
self.pass.kind = kind;
|
||||
if let Some(label) = label {
|
||||
let (wide_label, size) = self.temp.prepare_marker(label);
|
||||
list.BeginEvent(0, wide_label.as_ptr() as *const _, size);
|
||||
unsafe { list.BeginEvent(0, wide_label.as_ptr() as *const _, size) };
|
||||
self.pass.has_label = true;
|
||||
}
|
||||
self.pass.dirty_root_elements = 0;
|
||||
@@ -76,7 +76,7 @@ impl super::CommandEncoder {
|
||||
let list = self.list.unwrap();
|
||||
list.set_descriptor_heaps(&[]);
|
||||
if self.pass.has_label {
|
||||
list.EndEvent();
|
||||
unsafe { list.EndEvent() };
|
||||
}
|
||||
self.pass.clear();
|
||||
}
|
||||
@@ -86,11 +86,13 @@ impl super::CommandEncoder {
|
||||
let list = self.list.unwrap();
|
||||
let index = self.pass.dirty_vertex_buffers.trailing_zeros();
|
||||
self.pass.dirty_vertex_buffers ^= 1 << index;
|
||||
list.IASetVertexBuffers(
|
||||
index,
|
||||
1,
|
||||
self.pass.vertex_buffers.as_ptr().offset(index as isize),
|
||||
);
|
||||
unsafe {
|
||||
list.IASetVertexBuffers(
|
||||
index,
|
||||
1,
|
||||
self.pass.vertex_buffers.as_ptr().offset(index as isize),
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some(root_index) = self.pass.layout.special_constants_root_index {
|
||||
let needs_update = match self.pass.root_elements[root_index as usize] {
|
||||
@@ -244,7 +246,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
|
||||
if let Some(label) = label {
|
||||
let cwstr = conv::map_label(label);
|
||||
list.SetName(cwstr.as_ptr());
|
||||
unsafe { list.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
self.list = Some(list);
|
||||
@@ -290,32 +292,38 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut raw = d3d12::D3D12_RESOURCE_BARRIER {
|
||||
Type: d3d12::D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
|
||||
Flags: d3d12::D3D12_RESOURCE_BARRIER_FLAG_NONE,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: barrier.buffer.resource.as_mut_ptr(),
|
||||
Subresource: d3d12::D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
|
||||
StateBefore: s0,
|
||||
StateAfter: s1,
|
||||
unsafe {
|
||||
*raw.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: barrier.buffer.resource.as_mut_ptr(),
|
||||
Subresource: d3d12::D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
|
||||
StateBefore: s0,
|
||||
StateAfter: s1,
|
||||
}
|
||||
};
|
||||
self.temp.barriers.push(raw);
|
||||
} else if barrier.usage.start == crate::BufferUses::STORAGE_READ_WRITE {
|
||||
let mut raw = d3d12::D3D12_RESOURCE_BARRIER {
|
||||
Type: d3d12::D3D12_RESOURCE_BARRIER_TYPE_UAV,
|
||||
Flags: d3d12::D3D12_RESOURCE_BARRIER_FLAG_NONE,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw.u.UAV_mut() = d3d12::D3D12_RESOURCE_UAV_BARRIER {
|
||||
pResource: barrier.buffer.resource.as_mut_ptr(),
|
||||
unsafe {
|
||||
*raw.u.UAV_mut() = d3d12::D3D12_RESOURCE_UAV_BARRIER {
|
||||
pResource: barrier.buffer.resource.as_mut_ptr(),
|
||||
}
|
||||
};
|
||||
self.temp.barriers.push(raw);
|
||||
}
|
||||
}
|
||||
|
||||
if !self.temp.barriers.is_empty() {
|
||||
self.list
|
||||
.unwrap()
|
||||
.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr());
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr())
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -340,13 +348,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut raw = d3d12::D3D12_RESOURCE_BARRIER {
|
||||
Type: d3d12::D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
|
||||
Flags: d3d12::D3D12_RESOURCE_BARRIER_FLAG_NONE,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: barrier.texture.resource.as_mut_ptr(),
|
||||
Subresource: d3d12::D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
|
||||
StateBefore: s0,
|
||||
StateAfter: s1,
|
||||
unsafe {
|
||||
*raw.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: barrier.texture.resource.as_mut_ptr(),
|
||||
Subresource: d3d12::D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
|
||||
StateBefore: s0,
|
||||
StateAfter: s1,
|
||||
}
|
||||
};
|
||||
|
||||
let mip_level_count = match barrier.range.mip_level_count {
|
||||
@@ -383,12 +393,14 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
for rel_mip_level in 0..mip_level_count {
|
||||
for rel_array_layer in 0..array_layer_count {
|
||||
for plane in planes.clone() {
|
||||
raw.u.Transition_mut().Subresource =
|
||||
barrier.texture.calc_subresource(
|
||||
barrier.range.base_mip_level + rel_mip_level,
|
||||
barrier.range.base_array_layer + rel_array_layer,
|
||||
plane,
|
||||
);
|
||||
unsafe {
|
||||
raw.u.Transition_mut().Subresource =
|
||||
barrier.texture.calc_subresource(
|
||||
barrier.range.base_mip_level + rel_mip_level,
|
||||
barrier.range.base_array_layer + rel_array_layer,
|
||||
plane,
|
||||
);
|
||||
};
|
||||
self.temp.barriers.push(raw);
|
||||
}
|
||||
}
|
||||
@@ -398,19 +410,23 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut raw = d3d12::D3D12_RESOURCE_BARRIER {
|
||||
Type: d3d12::D3D12_RESOURCE_BARRIER_TYPE_UAV,
|
||||
Flags: d3d12::D3D12_RESOURCE_BARRIER_FLAG_NONE,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw.u.UAV_mut() = d3d12::D3D12_RESOURCE_UAV_BARRIER {
|
||||
pResource: barrier.texture.resource.as_mut_ptr(),
|
||||
unsafe {
|
||||
*raw.u.UAV_mut() = d3d12::D3D12_RESOURCE_UAV_BARRIER {
|
||||
pResource: barrier.texture.resource.as_mut_ptr(),
|
||||
}
|
||||
};
|
||||
self.temp.barriers.push(raw);
|
||||
}
|
||||
}
|
||||
|
||||
if !self.temp.barriers.is_empty() {
|
||||
self.list
|
||||
.unwrap()
|
||||
.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr());
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr())
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -419,13 +435,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut offset = range.start;
|
||||
while offset < range.end {
|
||||
let size = super::ZERO_BUFFER_SIZE.min(range.end - offset);
|
||||
list.CopyBufferRegion(
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
self.shared.zero_buffer.as_mut_ptr(),
|
||||
0,
|
||||
size,
|
||||
);
|
||||
unsafe {
|
||||
list.CopyBufferRegion(
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
self.shared.zero_buffer.as_mut_ptr(),
|
||||
0,
|
||||
size,
|
||||
)
|
||||
};
|
||||
offset += size;
|
||||
}
|
||||
}
|
||||
@@ -440,13 +458,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
{
|
||||
let list = self.list.unwrap();
|
||||
for r in regions {
|
||||
list.CopyBufferRegion(
|
||||
dst.resource.as_mut_ptr(),
|
||||
r.dst_offset,
|
||||
src.resource.as_mut_ptr(),
|
||||
r.src_offset,
|
||||
r.size.get(),
|
||||
);
|
||||
unsafe {
|
||||
list.CopyBufferRegion(
|
||||
dst.resource.as_mut_ptr(),
|
||||
r.dst_offset,
|
||||
src.resource.as_mut_ptr(),
|
||||
r.src_offset,
|
||||
r.size.get(),
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -463,27 +483,33 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut src_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: src.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
let mut dst_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: dst.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
|
||||
for r in regions {
|
||||
let src_box = make_box(&r.src_base.origin, &r.size);
|
||||
*src_location.u.SubresourceIndex_mut() = src.calc_subresource_for_copy(&r.src_base);
|
||||
*dst_location.u.SubresourceIndex_mut() = dst.calc_subresource_for_copy(&r.dst_base);
|
||||
unsafe {
|
||||
*src_location.u.SubresourceIndex_mut() = src.calc_subresource_for_copy(&r.src_base)
|
||||
};
|
||||
unsafe {
|
||||
*dst_location.u.SubresourceIndex_mut() = dst.calc_subresource_for_copy(&r.dst_base)
|
||||
};
|
||||
|
||||
list.CopyTextureRegion(
|
||||
&dst_location,
|
||||
r.dst_base.origin.x,
|
||||
r.dst_base.origin.y,
|
||||
r.dst_base.origin.z,
|
||||
&src_location,
|
||||
&src_box,
|
||||
);
|
||||
unsafe {
|
||||
list.CopyTextureRegion(
|
||||
&dst_location,
|
||||
r.dst_base.origin.x,
|
||||
r.dst_base.origin.y,
|
||||
r.dst_base.origin.z,
|
||||
&src_location,
|
||||
&src_box,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -499,25 +525,32 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut src_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: src.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
let mut dst_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: dst.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
for r in regions {
|
||||
let src_box = make_box(&wgt::Origin3d::ZERO, &r.size);
|
||||
*src_location.u.PlacedFootprint_mut() = r.to_subresource_footprint(dst.format);
|
||||
*dst_location.u.SubresourceIndex_mut() = dst.calc_subresource_for_copy(&r.texture_base);
|
||||
list.CopyTextureRegion(
|
||||
&dst_location,
|
||||
r.texture_base.origin.x,
|
||||
r.texture_base.origin.y,
|
||||
r.texture_base.origin.z,
|
||||
&src_location,
|
||||
&src_box,
|
||||
);
|
||||
unsafe {
|
||||
*src_location.u.PlacedFootprint_mut() = r.to_subresource_footprint(dst.format)
|
||||
};
|
||||
unsafe {
|
||||
*dst_location.u.SubresourceIndex_mut() =
|
||||
dst.calc_subresource_for_copy(&r.texture_base)
|
||||
};
|
||||
unsafe {
|
||||
list.CopyTextureRegion(
|
||||
&dst_location,
|
||||
r.texture_base.origin.x,
|
||||
r.texture_base.origin.y,
|
||||
r.texture_base.origin.z,
|
||||
&src_location,
|
||||
&src_box,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -534,37 +567,48 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut src_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: src.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
let mut dst_location = d3d12::D3D12_TEXTURE_COPY_LOCATION {
|
||||
pResource: dst.resource.as_mut_ptr(),
|
||||
Type: d3d12::D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
for r in regions {
|
||||
let src_box = make_box(&r.texture_base.origin, &r.size);
|
||||
*src_location.u.SubresourceIndex_mut() = src.calc_subresource_for_copy(&r.texture_base);
|
||||
*dst_location.u.PlacedFootprint_mut() = r.to_subresource_footprint(src.format);
|
||||
list.CopyTextureRegion(&dst_location, 0, 0, 0, &src_location, &src_box);
|
||||
unsafe {
|
||||
*src_location.u.SubresourceIndex_mut() =
|
||||
src.calc_subresource_for_copy(&r.texture_base)
|
||||
};
|
||||
unsafe {
|
||||
*dst_location.u.PlacedFootprint_mut() = r.to_subresource_footprint(src.format)
|
||||
};
|
||||
unsafe { list.CopyTextureRegion(&dst_location, 0, 0, 0, &src_location, &src_box) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn begin_query(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.list
|
||||
.unwrap()
|
||||
.BeginQuery(set.raw.as_mut_ptr(), set.raw_ty, index);
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.BeginQuery(set.raw.as_mut_ptr(), set.raw_ty, index)
|
||||
};
|
||||
}
|
||||
unsafe fn end_query(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.list
|
||||
.unwrap()
|
||||
.EndQuery(set.raw.as_mut_ptr(), set.raw_ty, index);
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.EndQuery(set.raw.as_mut_ptr(), set.raw_ty, index)
|
||||
};
|
||||
}
|
||||
unsafe fn write_timestamp(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.list.unwrap().EndQuery(
|
||||
set.raw.as_mut_ptr(),
|
||||
d3d12::D3D12_QUERY_TYPE_TIMESTAMP,
|
||||
index,
|
||||
);
|
||||
unsafe {
|
||||
self.list.unwrap().EndQuery(
|
||||
set.raw.as_mut_ptr(),
|
||||
d3d12::D3D12_QUERY_TYPE_TIMESTAMP,
|
||||
index,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn reset_queries(&mut self, _set: &super::QuerySet, _range: Range<u32>) {
|
||||
// nothing to do here
|
||||
@@ -577,20 +621,22 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
_stride: wgt::BufferSize,
|
||||
) {
|
||||
self.list.unwrap().ResolveQueryData(
|
||||
set.raw.as_mut_ptr(),
|
||||
set.raw_ty,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
);
|
||||
unsafe {
|
||||
self.list.unwrap().ResolveQueryData(
|
||||
set.raw.as_mut_ptr(),
|
||||
set.raw_ty,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
// render
|
||||
|
||||
unsafe fn begin_render_pass(&mut self, desc: &crate::RenderPassDescriptor<super::Api>) {
|
||||
self.begin_pass(super::PassKind::Render, desc.label);
|
||||
unsafe { self.begin_pass(super::PassKind::Render, desc.label) };
|
||||
let mut color_views = [native::CpuDescriptor { ptr: 0 }; crate::MAX_COLOR_ATTACHMENTS];
|
||||
for (rtv, cat) in color_views.iter_mut().zip(desc.color_attachments.iter()) {
|
||||
if let Some(cat) = cat.as_ref() {
|
||||
@@ -612,12 +658,14 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
};
|
||||
|
||||
let list = self.list.unwrap();
|
||||
list.OMSetRenderTargets(
|
||||
desc.color_attachments.len() as u32,
|
||||
color_views.as_ptr(),
|
||||
0,
|
||||
ds_view,
|
||||
);
|
||||
unsafe {
|
||||
list.OMSetRenderTargets(
|
||||
desc.color_attachments.len() as u32,
|
||||
color_views.as_ptr(),
|
||||
0,
|
||||
ds_view,
|
||||
)
|
||||
};
|
||||
|
||||
self.pass.resolves.clear();
|
||||
for (rtv, cat) in color_views.iter().zip(desc.color_attachments.iter()) {
|
||||
@@ -657,7 +705,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
|
||||
if !ds_view.is_null() && !flags.is_empty() {
|
||||
list.clear_depth_stencil_view(
|
||||
*ds_view,
|
||||
unsafe { *ds_view },
|
||||
flags,
|
||||
ds.clear_value.0,
|
||||
ds.clear_value.1 as u8,
|
||||
@@ -680,8 +728,8 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
right: desc.extent.width as i32,
|
||||
bottom: desc.extent.height as i32,
|
||||
};
|
||||
list.RSSetViewports(1, &raw_vp);
|
||||
list.RSSetScissorRects(1, &raw_rect);
|
||||
unsafe { list.RSSetViewports(1, &raw_vp) };
|
||||
unsafe { list.RSSetScissorRects(1, &raw_rect) };
|
||||
}
|
||||
|
||||
unsafe fn end_render_pass(&mut self) {
|
||||
@@ -695,54 +743,70 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let mut barrier = d3d12::D3D12_RESOURCE_BARRIER {
|
||||
Type: d3d12::D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
|
||||
Flags: d3d12::D3D12_RESOURCE_BARRIER_FLAG_NONE,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
//Note: this assumes `D3D12_RESOURCE_STATE_RENDER_TARGET`.
|
||||
// If it's not the case, we can include the `TextureUses` in `PassResove`.
|
||||
*barrier.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: resolve.src.0.as_mut_ptr(),
|
||||
Subresource: resolve.src.1,
|
||||
StateBefore: d3d12::D3D12_RESOURCE_STATE_RENDER_TARGET,
|
||||
StateAfter: d3d12::D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
|
||||
unsafe {
|
||||
*barrier.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: resolve.src.0.as_mut_ptr(),
|
||||
Subresource: resolve.src.1,
|
||||
StateBefore: d3d12::D3D12_RESOURCE_STATE_RENDER_TARGET,
|
||||
StateAfter: d3d12::D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
|
||||
}
|
||||
};
|
||||
self.temp.barriers.push(barrier);
|
||||
*barrier.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: resolve.dst.0.as_mut_ptr(),
|
||||
Subresource: resolve.dst.1,
|
||||
StateBefore: d3d12::D3D12_RESOURCE_STATE_RENDER_TARGET,
|
||||
StateAfter: d3d12::D3D12_RESOURCE_STATE_RESOLVE_DEST,
|
||||
unsafe {
|
||||
*barrier.u.Transition_mut() = d3d12::D3D12_RESOURCE_TRANSITION_BARRIER {
|
||||
pResource: resolve.dst.0.as_mut_ptr(),
|
||||
Subresource: resolve.dst.1,
|
||||
StateBefore: d3d12::D3D12_RESOURCE_STATE_RENDER_TARGET,
|
||||
StateAfter: d3d12::D3D12_RESOURCE_STATE_RESOLVE_DEST,
|
||||
}
|
||||
};
|
||||
self.temp.barriers.push(barrier);
|
||||
}
|
||||
|
||||
if !self.temp.barriers.is_empty() {
|
||||
profiling::scope!("ID3D12GraphicsCommandList::ResourceBarrier");
|
||||
list.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr());
|
||||
unsafe {
|
||||
list.ResourceBarrier(
|
||||
self.temp.barriers.len() as u32,
|
||||
self.temp.barriers.as_ptr(),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
for resolve in self.pass.resolves.iter() {
|
||||
profiling::scope!("ID3D12GraphicsCommandList::ResolveSubresource");
|
||||
list.ResolveSubresource(
|
||||
resolve.dst.0.as_mut_ptr(),
|
||||
resolve.dst.1,
|
||||
resolve.src.0.as_mut_ptr(),
|
||||
resolve.src.1,
|
||||
resolve.format,
|
||||
);
|
||||
unsafe {
|
||||
list.ResolveSubresource(
|
||||
resolve.dst.0.as_mut_ptr(),
|
||||
resolve.dst.1,
|
||||
resolve.src.0.as_mut_ptr(),
|
||||
resolve.src.1,
|
||||
resolve.format,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
// Flip all the barriers to reverse, back into `COLOR_TARGET`.
|
||||
for barrier in self.temp.barriers.iter_mut() {
|
||||
let transition = barrier.u.Transition_mut();
|
||||
let transition = unsafe { barrier.u.Transition_mut() };
|
||||
mem::swap(&mut transition.StateBefore, &mut transition.StateAfter);
|
||||
}
|
||||
if !self.temp.barriers.is_empty() {
|
||||
profiling::scope!("ID3D12GraphicsCommandList::ResourceBarrier");
|
||||
list.ResourceBarrier(self.temp.barriers.len() as u32, self.temp.barriers.as_ptr());
|
||||
unsafe {
|
||||
list.ResourceBarrier(
|
||||
self.temp.barriers.len() as u32,
|
||||
self.temp.barriers.as_ptr(),
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
self.end_pass();
|
||||
unsafe { self.end_pass() };
|
||||
}
|
||||
|
||||
unsafe fn set_bind_group(
|
||||
@@ -818,18 +882,22 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
|
||||
unsafe fn insert_debug_marker(&mut self, label: &str) {
|
||||
let (wide_label, size) = self.temp.prepare_marker(label);
|
||||
self.list
|
||||
.unwrap()
|
||||
.SetMarker(0, wide_label.as_ptr() as *const _, size);
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.SetMarker(0, wide_label.as_ptr() as *const _, size)
|
||||
};
|
||||
}
|
||||
unsafe fn begin_debug_marker(&mut self, group_label: &str) {
|
||||
let (wide_label, size) = self.temp.prepare_marker(group_label);
|
||||
self.list
|
||||
.unwrap()
|
||||
.BeginEvent(0, wide_label.as_ptr() as *const _, size);
|
||||
unsafe {
|
||||
self.list
|
||||
.unwrap()
|
||||
.BeginEvent(0, wide_label.as_ptr() as *const _, size)
|
||||
};
|
||||
}
|
||||
unsafe fn end_debug_marker(&mut self) {
|
||||
self.list.unwrap().EndEvent()
|
||||
unsafe { self.list.unwrap().EndEvent() }
|
||||
}
|
||||
|
||||
unsafe fn set_render_pipeline(&mut self, pipeline: &super::RenderPipeline) {
|
||||
@@ -842,7 +910,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
};
|
||||
|
||||
list.set_pipeline_state(pipeline.raw);
|
||||
list.IASetPrimitiveTopology(pipeline.topology);
|
||||
unsafe { list.IASetPrimitiveTopology(pipeline.topology) };
|
||||
|
||||
for (index, (vb, &stride)) in self
|
||||
.pass
|
||||
@@ -891,7 +959,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
MinDepth: depth_range.start,
|
||||
MaxDepth: depth_range.end,
|
||||
};
|
||||
self.list.unwrap().RSSetViewports(1, &raw_vp);
|
||||
unsafe { self.list.unwrap().RSSetViewports(1, &raw_vp) };
|
||||
}
|
||||
unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {
|
||||
let raw_rect = d3d12::D3D12_RECT {
|
||||
@@ -900,7 +968,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
right: (rect.x + rect.w) as i32,
|
||||
bottom: (rect.y + rect.h) as i32,
|
||||
};
|
||||
self.list.unwrap().RSSetScissorRects(1, &raw_rect);
|
||||
unsafe { self.list.unwrap().RSSetScissorRects(1, &raw_rect) };
|
||||
}
|
||||
unsafe fn set_stencil_reference(&mut self, value: u32) {
|
||||
self.list.unwrap().set_stencil_reference(value);
|
||||
@@ -916,7 +984,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
start_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
self.prepare_draw(start_vertex as i32, start_instance);
|
||||
unsafe { self.prepare_draw(start_vertex as i32, start_instance) };
|
||||
self.list
|
||||
.unwrap()
|
||||
.draw(vertex_count, instance_count, start_vertex, start_instance);
|
||||
@@ -929,7 +997,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
start_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
self.prepare_draw(base_vertex, start_instance);
|
||||
unsafe { self.prepare_draw(base_vertex, start_instance) };
|
||||
self.list.unwrap().draw_indexed(
|
||||
index_count,
|
||||
instance_count,
|
||||
@@ -944,15 +1012,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
self.prepare_draw(0, 0);
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw.as_mut_ptr(),
|
||||
draw_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
);
|
||||
unsafe { self.prepare_draw(0, 0) };
|
||||
unsafe {
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw.as_mut_ptr(),
|
||||
draw_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indexed_indirect(
|
||||
&mut self,
|
||||
@@ -960,15 +1030,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
self.prepare_draw(0, 0);
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw_indexed.as_mut_ptr(),
|
||||
draw_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
);
|
||||
unsafe { self.prepare_draw(0, 0) };
|
||||
unsafe {
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw_indexed.as_mut_ptr(),
|
||||
draw_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indirect_count(
|
||||
&mut self,
|
||||
@@ -978,15 +1050,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
self.prepare_draw(0, 0);
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw.as_mut_ptr(),
|
||||
max_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
count_buffer.resource.as_mut_ptr(),
|
||||
count_offset,
|
||||
);
|
||||
unsafe { self.prepare_draw(0, 0) };
|
||||
unsafe {
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw.as_mut_ptr(),
|
||||
max_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
count_buffer.resource.as_mut_ptr(),
|
||||
count_offset,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indexed_indirect_count(
|
||||
&mut self,
|
||||
@@ -996,24 +1070,26 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
self.prepare_draw(0, 0);
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw_indexed.as_mut_ptr(),
|
||||
max_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
count_buffer.resource.as_mut_ptr(),
|
||||
count_offset,
|
||||
);
|
||||
unsafe { self.prepare_draw(0, 0) };
|
||||
unsafe {
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.draw_indexed.as_mut_ptr(),
|
||||
max_count,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
count_buffer.resource.as_mut_ptr(),
|
||||
count_offset,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
// compute
|
||||
|
||||
unsafe fn begin_compute_pass(&mut self, desc: &crate::ComputePassDescriptor) {
|
||||
self.begin_pass(super::PassKind::Compute, desc.label);
|
||||
unsafe { self.begin_pass(super::PassKind::Compute, desc.label) };
|
||||
}
|
||||
unsafe fn end_compute_pass(&mut self) {
|
||||
self.end_pass();
|
||||
unsafe { self.end_pass() };
|
||||
}
|
||||
|
||||
unsafe fn set_compute_pipeline(&mut self, pipeline: &super::ComputePipeline) {
|
||||
@@ -1035,13 +1111,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
unsafe fn dispatch_indirect(&mut self, buffer: &super::Buffer, offset: wgt::BufferAddress) {
|
||||
self.prepare_dispatch([0; 3]);
|
||||
//TODO: update special constants indirectly
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.dispatch.as_mut_ptr(),
|
||||
1,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
);
|
||||
unsafe {
|
||||
self.list.unwrap().ExecuteIndirect(
|
||||
self.shared.cmd_signatures.dispatch.as_mut_ptr(),
|
||||
1,
|
||||
buffer.resource.as_mut_ptr(),
|
||||
offset,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -157,7 +157,7 @@ impl FixedSizeHeap {
|
||||
}
|
||||
|
||||
unsafe fn destroy(&self) {
|
||||
self.raw.destroy();
|
||||
unsafe { self.raw.destroy() };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -225,7 +225,7 @@ impl CpuPool {
|
||||
|
||||
pub(super) unsafe fn destroy(&self) {
|
||||
for heap in &self.heaps {
|
||||
heap.destroy();
|
||||
unsafe { heap.destroy() };
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -274,7 +274,7 @@ impl CpuHeap {
|
||||
}
|
||||
|
||||
pub(super) unsafe fn destroy(self) {
|
||||
self.inner.into_inner().raw.destroy();
|
||||
unsafe { self.inner.into_inner().raw.destroy() };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -296,14 +296,16 @@ pub(super) unsafe fn upload(
|
||||
) -> Result<DualHandle, crate::DeviceError> {
|
||||
let count = src.stage.len() as u32;
|
||||
let index = dst.allocate_slice(count as u64)?;
|
||||
device.CopyDescriptors(
|
||||
1,
|
||||
&dst.cpu_descriptor_at(index),
|
||||
&count,
|
||||
count,
|
||||
src.stage.as_ptr(),
|
||||
dummy_copy_counts.as_ptr(),
|
||||
dst.ty as u32,
|
||||
);
|
||||
unsafe {
|
||||
device.CopyDescriptors(
|
||||
1,
|
||||
&dst.cpu_descriptor_at(index),
|
||||
&count,
|
||||
count,
|
||||
src.stage.as_ptr(),
|
||||
dummy_copy_counts.as_ptr(),
|
||||
dst.ty as u32,
|
||||
)
|
||||
};
|
||||
Ok(dst.at(index, count as u64))
|
||||
}
|
||||
+183
-149
@@ -182,7 +182,7 @@ impl super::Device {
|
||||
.fence
|
||||
.set_event_on_completion(self.idler.event, value);
|
||||
hr.into_device_result("Set event")?;
|
||||
synchapi::WaitForSingleObject(self.idler.event.0, winbase::INFINITE);
|
||||
unsafe { synchapi::WaitForSingleObject(self.idler.event.0, winbase::INFINITE) };
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -319,13 +319,13 @@ impl super::Device {
|
||||
impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn exit(self, queue: super::Queue) {
|
||||
self.rtv_pool.lock().free_handle(self.null_rtv_handle);
|
||||
self.rtv_pool.into_inner().destroy();
|
||||
self.dsv_pool.into_inner().destroy();
|
||||
self.srv_uav_pool.into_inner().destroy();
|
||||
self.sampler_pool.into_inner().destroy();
|
||||
self.shared.destroy();
|
||||
self.idler.destroy();
|
||||
queue.raw.destroy();
|
||||
unsafe { self.rtv_pool.into_inner().destroy() };
|
||||
unsafe { self.dsv_pool.into_inner().destroy() };
|
||||
unsafe { self.srv_uav_pool.into_inner().destroy() };
|
||||
unsafe { self.sampler_pool.into_inner().destroy() };
|
||||
unsafe { self.shared.destroy() };
|
||||
unsafe { self.idler.destroy() };
|
||||
unsafe { queue.raw.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_buffer(
|
||||
@@ -377,30 +377,32 @@ impl crate::Device<super::Api> for super::Device {
|
||||
VisibleNodeMask: 0,
|
||||
};
|
||||
|
||||
let hr = self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.private_caps.heap_create_not_zeroed {
|
||||
D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
d3d12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
d3d12::D3D12_RESOURCE_STATE_COMMON,
|
||||
ptr::null(),
|
||||
&d3d12::ID3D12Resource::uuidof(),
|
||||
resource.mut_void(),
|
||||
);
|
||||
let hr = unsafe {
|
||||
self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.private_caps.heap_create_not_zeroed {
|
||||
D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
d3d12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
d3d12::D3D12_RESOURCE_STATE_COMMON,
|
||||
ptr::null(),
|
||||
&d3d12::ID3D12Resource::uuidof(),
|
||||
resource.mut_void(),
|
||||
)
|
||||
};
|
||||
|
||||
hr.into_device_result("Buffer creation")?;
|
||||
if let Some(label) = desc.label {
|
||||
let cwstr = conv::map_label(label);
|
||||
resource.SetName(cwstr.as_ptr());
|
||||
unsafe { resource.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::Buffer { resource, size })
|
||||
}
|
||||
unsafe fn destroy_buffer(&self, buffer: super::Buffer) {
|
||||
buffer.resource.destroy();
|
||||
unsafe { buffer.resource.destroy() };
|
||||
}
|
||||
unsafe fn map_buffer(
|
||||
&self,
|
||||
@@ -408,17 +410,17 @@ impl crate::Device<super::Api> for super::Device {
|
||||
range: crate::MemoryRange,
|
||||
) -> Result<crate::BufferMapping, crate::DeviceError> {
|
||||
let mut ptr = ptr::null_mut();
|
||||
let hr = (*buffer.resource).Map(0, ptr::null(), &mut ptr);
|
||||
let hr = unsafe { (*buffer.resource).Map(0, ptr::null(), &mut ptr) };
|
||||
hr.into_device_result("Map buffer")?;
|
||||
Ok(crate::BufferMapping {
|
||||
ptr: ptr::NonNull::new(ptr.offset(range.start as isize) as *mut _).unwrap(),
|
||||
ptr: ptr::NonNull::new(unsafe { ptr.offset(range.start as isize) } as *mut _).unwrap(),
|
||||
//TODO: double-check this. Documentation is a bit misleading -
|
||||
// it implies that Map/Unmap is needed to invalidate/flush memory.
|
||||
is_coherent: true,
|
||||
})
|
||||
}
|
||||
unsafe fn unmap_buffer(&self, buffer: &super::Buffer) -> Result<(), crate::DeviceError> {
|
||||
(*buffer.resource).Unmap(0, ptr::null());
|
||||
unsafe { (*buffer.resource).Unmap(0, ptr::null()) };
|
||||
Ok(())
|
||||
}
|
||||
unsafe fn flush_mapped_ranges<I>(&self, _buffer: &super::Buffer, _ranges: I) {}
|
||||
@@ -470,24 +472,26 @@ impl crate::Device<super::Api> for super::Device {
|
||||
VisibleNodeMask: 0,
|
||||
};
|
||||
|
||||
let hr = self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.private_caps.heap_create_not_zeroed {
|
||||
D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
d3d12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
d3d12::D3D12_RESOURCE_STATE_COMMON,
|
||||
ptr::null(), // clear value
|
||||
&d3d12::ID3D12Resource::uuidof(),
|
||||
resource.mut_void(),
|
||||
);
|
||||
let hr = unsafe {
|
||||
self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.private_caps.heap_create_not_zeroed {
|
||||
D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
d3d12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
d3d12::D3D12_RESOURCE_STATE_COMMON,
|
||||
ptr::null(), // clear value
|
||||
&d3d12::ID3D12Resource::uuidof(),
|
||||
resource.mut_void(),
|
||||
)
|
||||
};
|
||||
|
||||
hr.into_device_result("Texture creation")?;
|
||||
if let Some(label) = desc.label {
|
||||
let cwstr = conv::map_label(label);
|
||||
resource.SetName(cwstr.as_ptr());
|
||||
unsafe { resource.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::Texture {
|
||||
@@ -500,7 +504,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_texture(&self, texture: super::Texture) {
|
||||
texture.resource.destroy();
|
||||
unsafe { texture.resource.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_texture_view(
|
||||
@@ -518,13 +522,15 @@ impl crate::Device<super::Api> for super::Device {
|
||||
texture.calc_subresource(desc.range.base_mip_level, desc.range.base_array_layer, 0),
|
||||
),
|
||||
handle_srv: if desc.usage.intersects(crate::TextureUses::RESOURCE) {
|
||||
let raw_desc = view_desc.to_srv();
|
||||
let raw_desc = unsafe { view_desc.to_srv() };
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
self.raw.CreateShaderResourceView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.raw.CreateShaderResourceView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
} else {
|
||||
None
|
||||
@@ -532,26 +538,30 @@ impl crate::Device<super::Api> for super::Device {
|
||||
handle_uav: if desc.usage.intersects(
|
||||
crate::TextureUses::STORAGE_READ | crate::TextureUses::STORAGE_READ_WRITE,
|
||||
) {
|
||||
let raw_desc = view_desc.to_uav();
|
||||
let raw_desc = unsafe { view_desc.to_uav() };
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
} else {
|
||||
None
|
||||
},
|
||||
handle_rtv: if desc.usage.intersects(crate::TextureUses::COLOR_TARGET) {
|
||||
let raw_desc = view_desc.to_rtv();
|
||||
let raw_desc = unsafe { view_desc.to_rtv() };
|
||||
let handle = self.rtv_pool.lock().alloc_handle();
|
||||
self.raw.CreateRenderTargetView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.raw.CreateRenderTargetView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
} else {
|
||||
None
|
||||
@@ -560,13 +570,15 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.usage
|
||||
.intersects(crate::TextureUses::DEPTH_STENCIL_READ)
|
||||
{
|
||||
let raw_desc = view_desc.to_dsv(desc.format.into());
|
||||
let raw_desc = unsafe { view_desc.to_dsv(desc.format.into()) };
|
||||
let handle = self.dsv_pool.lock().alloc_handle();
|
||||
self.raw.CreateDepthStencilView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.raw.CreateDepthStencilView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
} else {
|
||||
None
|
||||
@@ -575,13 +587,15 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.usage
|
||||
.intersects(crate::TextureUses::DEPTH_STENCIL_WRITE)
|
||||
{
|
||||
let raw_desc = view_desc.to_dsv(FormatAspects::empty());
|
||||
let raw_desc = unsafe { view_desc.to_dsv(FormatAspects::empty()) };
|
||||
let handle = self.dsv_pool.lock().alloc_handle();
|
||||
self.raw.CreateDepthStencilView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.raw.CreateDepthStencilView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
} else {
|
||||
None
|
||||
@@ -664,7 +678,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
let cwstr = conv::map_label(label);
|
||||
allocator.SetName(cwstr.as_ptr());
|
||||
unsafe { allocator.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::CommandEncoder {
|
||||
@@ -681,12 +695,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_command_encoder(&self, encoder: super::CommandEncoder) {
|
||||
if let Some(list) = encoder.list {
|
||||
list.close();
|
||||
list.destroy();
|
||||
unsafe { list.destroy() };
|
||||
}
|
||||
for list in encoder.free_lists {
|
||||
list.destroy();
|
||||
unsafe { list.destroy() };
|
||||
}
|
||||
encoder.allocator.destroy();
|
||||
unsafe { encoder.allocator.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group_layout(
|
||||
@@ -737,10 +751,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
}
|
||||
unsafe fn destroy_bind_group_layout(&self, bg_layout: super::BindGroupLayout) {
|
||||
if let Some(cpu_heap) = bg_layout.cpu_heap_views {
|
||||
cpu_heap.destroy();
|
||||
unsafe { cpu_heap.destroy() };
|
||||
}
|
||||
if let Some(cpu_heap) = bg_layout.cpu_heap_samplers {
|
||||
cpu_heap.destroy();
|
||||
unsafe { cpu_heap.destroy() };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1064,9 +1078,9 @@ impl crate::Device<super::Api> for super::Device {
|
||||
if !error.is_null() {
|
||||
log::error!(
|
||||
"Root signature serialization error: {:?}",
|
||||
error.as_c_str().to_str().unwrap()
|
||||
unsafe { error.as_c_str() }.to_str().unwrap()
|
||||
);
|
||||
error.destroy();
|
||||
unsafe { error.destroy() };
|
||||
return Err(crate::DeviceError::Lost);
|
||||
}
|
||||
|
||||
@@ -1074,13 +1088,13 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.raw
|
||||
.create_root_signature(blob, 0)
|
||||
.into_device_result("Root signature creation")?;
|
||||
blob.destroy();
|
||||
unsafe { blob.destroy() };
|
||||
|
||||
log::debug!("\traw = {:?}", raw);
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
let cwstr = conv::map_label(label);
|
||||
raw.SetName(cwstr.as_ptr());
|
||||
unsafe { raw.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::PipelineLayout {
|
||||
@@ -1101,7 +1115,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: super::PipelineLayout) {
|
||||
pipeline_layout.shared.signature.destroy();
|
||||
unsafe { pipeline_layout.shared.signature.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group(
|
||||
@@ -1155,7 +1169,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
BufferLocation: gpu_address,
|
||||
SizeInBytes: ((size - 1) | size_mask) + 1,
|
||||
};
|
||||
self.raw.CreateConstantBufferView(&raw_desc, handle);
|
||||
unsafe { self.raw.CreateConstantBufferView(&raw_desc, handle) };
|
||||
}
|
||||
wgt::BufferBindingType::Storage { read_only: true } => {
|
||||
let mut raw_desc = d3d12::D3D12_SHADER_RESOURCE_VIEW_DESC {
|
||||
@@ -1163,39 +1177,47 @@ impl crate::Device<super::Api> for super::Device {
|
||||
Shader4ComponentMapping:
|
||||
view::D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING,
|
||||
ViewDimension: d3d12::D3D12_SRV_DIMENSION_BUFFER,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw_desc.u.Buffer_mut() = d3d12::D3D12_BUFFER_SRV {
|
||||
FirstElement: data.offset / 4,
|
||||
NumElements: size / 4,
|
||||
StructureByteStride: 0,
|
||||
Flags: d3d12::D3D12_BUFFER_SRV_FLAG_RAW,
|
||||
unsafe {
|
||||
*raw_desc.u.Buffer_mut() = d3d12::D3D12_BUFFER_SRV {
|
||||
FirstElement: data.offset / 4,
|
||||
NumElements: size / 4,
|
||||
StructureByteStride: 0,
|
||||
Flags: d3d12::D3D12_BUFFER_SRV_FLAG_RAW,
|
||||
}
|
||||
};
|
||||
unsafe {
|
||||
self.raw.CreateShaderResourceView(
|
||||
data.buffer.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle,
|
||||
)
|
||||
};
|
||||
self.raw.CreateShaderResourceView(
|
||||
data.buffer.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle,
|
||||
);
|
||||
}
|
||||
wgt::BufferBindingType::Storage { read_only: false } => {
|
||||
let mut raw_desc = d3d12::D3D12_UNORDERED_ACCESS_VIEW_DESC {
|
||||
Format: dxgiformat::DXGI_FORMAT_R32_TYPELESS,
|
||||
ViewDimension: d3d12::D3D12_UAV_DIMENSION_BUFFER,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
*raw_desc.u.Buffer_mut() = d3d12::D3D12_BUFFER_UAV {
|
||||
FirstElement: data.offset / 4,
|
||||
NumElements: size / 4,
|
||||
StructureByteStride: 0,
|
||||
CounterOffsetInBytes: 0,
|
||||
Flags: d3d12::D3D12_BUFFER_UAV_FLAG_RAW,
|
||||
unsafe {
|
||||
*raw_desc.u.Buffer_mut() = d3d12::D3D12_BUFFER_UAV {
|
||||
FirstElement: data.offset / 4,
|
||||
NumElements: size / 4,
|
||||
StructureByteStride: 0,
|
||||
CounterOffsetInBytes: 0,
|
||||
Flags: d3d12::D3D12_BUFFER_UAV_FLAG_RAW,
|
||||
}
|
||||
};
|
||||
unsafe {
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
data.buffer.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle,
|
||||
)
|
||||
};
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
data.buffer.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle,
|
||||
);
|
||||
}
|
||||
}
|
||||
inner.stage.push(handle);
|
||||
@@ -1229,24 +1251,28 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let handle_views = match cpu_views {
|
||||
Some(inner) => {
|
||||
let dual = descriptor::upload(
|
||||
self.raw,
|
||||
&inner,
|
||||
&self.shared.heap_views,
|
||||
&desc.layout.copy_counts,
|
||||
)?;
|
||||
let dual = unsafe {
|
||||
descriptor::upload(
|
||||
self.raw,
|
||||
&inner,
|
||||
&self.shared.heap_views,
|
||||
&desc.layout.copy_counts,
|
||||
)
|
||||
}?;
|
||||
Some(dual)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let handle_samplers = match cpu_samplers {
|
||||
Some(inner) => {
|
||||
let dual = descriptor::upload(
|
||||
self.raw,
|
||||
&inner,
|
||||
&self.shared.heap_samplers,
|
||||
&desc.layout.copy_counts,
|
||||
)?;
|
||||
let dual = unsafe {
|
||||
descriptor::upload(
|
||||
self.raw,
|
||||
&inner,
|
||||
&self.shared.heap_samplers,
|
||||
&desc.layout.copy_counts,
|
||||
)
|
||||
}?;
|
||||
Some(dual)
|
||||
}
|
||||
None => None,
|
||||
@@ -1396,7 +1422,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
RasterizerState: raw_rasterizer,
|
||||
DepthStencilState: match desc.depth_stencil {
|
||||
Some(ref ds) => conv::map_depth_stencil(ds),
|
||||
None => mem::zeroed(),
|
||||
None => unsafe { mem::zeroed() },
|
||||
},
|
||||
InputLayout: d3d12::D3D12_INPUT_LAYOUT_DESC {
|
||||
pInputElementDescs: if input_element_descs.is_empty() {
|
||||
@@ -1437,16 +1463,18 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let mut raw = native::PipelineState::null();
|
||||
let hr = {
|
||||
profiling::scope!("ID3D12Device::CreateGraphicsPipelineState");
|
||||
self.raw.CreateGraphicsPipelineState(
|
||||
&raw_desc,
|
||||
&d3d12::ID3D12PipelineState::uuidof(),
|
||||
raw.mut_void(),
|
||||
)
|
||||
unsafe {
|
||||
self.raw.CreateGraphicsPipelineState(
|
||||
&raw_desc,
|
||||
&d3d12::ID3D12PipelineState::uuidof(),
|
||||
raw.mut_void(),
|
||||
)
|
||||
}
|
||||
};
|
||||
|
||||
blob_vs.destroy();
|
||||
unsafe { blob_vs.destroy() };
|
||||
if !blob_fs.is_null() {
|
||||
blob_fs.destroy();
|
||||
unsafe { blob_fs.destroy() };
|
||||
}
|
||||
|
||||
hr.into_result()
|
||||
@@ -1454,7 +1482,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
if let Some(name) = desc.label {
|
||||
let cwstr = conv::map_label(name);
|
||||
raw.SetName(cwstr.as_ptr());
|
||||
unsafe { raw.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::RenderPipeline {
|
||||
@@ -1465,7 +1493,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: super::RenderPipeline) {
|
||||
pipeline.raw.destroy();
|
||||
unsafe { pipeline.raw.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_compute_pipeline(
|
||||
@@ -1485,7 +1513,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
)
|
||||
};
|
||||
|
||||
blob_cs.destroy();
|
||||
unsafe { blob_cs.destroy() };
|
||||
|
||||
let raw = pair.into_result().map_err(|err| {
|
||||
crate::PipelineError::Linkage(wgt::ShaderStages::COMPUTE, err.into_owned())
|
||||
@@ -1493,7 +1521,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
if let Some(name) = desc.label {
|
||||
let cwstr = conv::map_label(name);
|
||||
raw.SetName(cwstr.as_ptr());
|
||||
unsafe { raw.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::ComputePipeline {
|
||||
@@ -1502,7 +1530,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: super::ComputePipeline) {
|
||||
pipeline.raw.destroy();
|
||||
unsafe { pipeline.raw.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_query_set(
|
||||
@@ -1531,34 +1559,36 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
let cwstr = conv::map_label(label);
|
||||
raw.SetName(cwstr.as_ptr());
|
||||
unsafe { raw.SetName(cwstr.as_ptr()) };
|
||||
}
|
||||
|
||||
Ok(super::QuerySet { raw, raw_ty })
|
||||
}
|
||||
unsafe fn destroy_query_set(&self, set: super::QuerySet) {
|
||||
set.raw.destroy();
|
||||
unsafe { set.raw.destroy() };
|
||||
}
|
||||
|
||||
unsafe fn create_fence(&self) -> Result<super::Fence, crate::DeviceError> {
|
||||
let mut raw = native::Fence::null();
|
||||
let hr = self.raw.CreateFence(
|
||||
0,
|
||||
d3d12::D3D12_FENCE_FLAG_NONE,
|
||||
&d3d12::ID3D12Fence::uuidof(),
|
||||
raw.mut_void(),
|
||||
);
|
||||
let hr = unsafe {
|
||||
self.raw.CreateFence(
|
||||
0,
|
||||
d3d12::D3D12_FENCE_FLAG_NONE,
|
||||
&d3d12::ID3D12Fence::uuidof(),
|
||||
raw.mut_void(),
|
||||
)
|
||||
};
|
||||
hr.into_device_result("Fence creation")?;
|
||||
Ok(super::Fence { raw })
|
||||
}
|
||||
unsafe fn destroy_fence(&self, fence: super::Fence) {
|
||||
fence.raw.destroy();
|
||||
unsafe { fence.raw.destroy() };
|
||||
}
|
||||
unsafe fn get_fence_value(
|
||||
&self,
|
||||
fence: &super::Fence,
|
||||
) -> Result<crate::FenceValue, crate::DeviceError> {
|
||||
Ok(fence.raw.GetCompletedValue())
|
||||
Ok(unsafe { fence.raw.GetCompletedValue() })
|
||||
}
|
||||
unsafe fn wait(
|
||||
&self,
|
||||
@@ -1566,13 +1596,13 @@ impl crate::Device<super::Api> for super::Device {
|
||||
value: crate::FenceValue,
|
||||
timeout_ms: u32,
|
||||
) -> Result<bool, crate::DeviceError> {
|
||||
if fence.raw.GetCompletedValue() >= value {
|
||||
if unsafe { fence.raw.GetCompletedValue() } >= value {
|
||||
return Ok(true);
|
||||
}
|
||||
let hr = fence.raw.set_event_on_completion(self.idler.event, value);
|
||||
hr.into_device_result("Set event")?;
|
||||
|
||||
match synchapi::WaitForSingleObject(self.idler.event.0, timeout_ms) {
|
||||
match unsafe { synchapi::WaitForSingleObject(self.idler.event.0, timeout_ms) } {
|
||||
winbase::WAIT_ABANDONED | winbase::WAIT_FAILED => Err(crate::DeviceError::Lost),
|
||||
winbase::WAIT_OBJECT_0 => Ok(true),
|
||||
winerror::WAIT_TIMEOUT => Ok(false),
|
||||
@@ -1586,8 +1616,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn start_capture(&self) -> bool {
|
||||
#[cfg(feature = "renderdoc")]
|
||||
{
|
||||
self.render_doc
|
||||
.start_frame_capture(self.raw.as_mut_ptr() as *mut _, ptr::null_mut())
|
||||
unsafe {
|
||||
self.render_doc
|
||||
.start_frame_capture(self.raw.as_mut_ptr() as *mut _, ptr::null_mut())
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "renderdoc"))]
|
||||
false
|
||||
@@ -1595,7 +1627,9 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
unsafe fn stop_capture(&self) {
|
||||
#[cfg(feature = "renderdoc")]
|
||||
self.render_doc
|
||||
.end_frame_capture(self.raw.as_mut_ptr() as *mut _, ptr::null_mut())
|
||||
unsafe {
|
||||
self.render_doc
|
||||
.end_frame_capture(self.raw.as_mut_ptr() as *mut _, ptr::null_mut())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
Ok(pair) => match pair.into_result() {
|
||||
Ok(debug_controller) => {
|
||||
debug_controller.enable_layer();
|
||||
debug_controller.Release();
|
||||
unsafe { debug_controller.Release() };
|
||||
}
|
||||
Err(err) => {
|
||||
log::warn!("Unable to enable D3D12 debug interface: {}", err);
|
||||
@@ -43,11 +43,13 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
#[allow(trivial_casts)]
|
||||
if let Some(factory5) = factory.as_factory5() {
|
||||
let mut allow_tearing: minwindef::BOOL = minwindef::FALSE;
|
||||
let hr = factory5.CheckFeatureSupport(
|
||||
dxgi1_5::DXGI_FEATURE_PRESENT_ALLOW_TEARING,
|
||||
&mut allow_tearing as *mut _ as *mut _,
|
||||
mem::size_of::<minwindef::BOOL>() as _,
|
||||
);
|
||||
let hr = unsafe {
|
||||
factory5.CheckFeatureSupport(
|
||||
dxgi1_5::DXGI_FEATURE_PRESENT_ALLOW_TEARING,
|
||||
&mut allow_tearing as *mut _ as *mut _,
|
||||
mem::size_of::<minwindef::BOOL>() as _,
|
||||
)
|
||||
};
|
||||
|
||||
match hr.into_result() {
|
||||
Err(err) => log::warn!("Unable to check for tearing support: {}", err),
|
||||
|
||||
+53
-40
@@ -100,7 +100,7 @@ impl Instance {
|
||||
) -> Surface {
|
||||
Surface {
|
||||
factory: self.factory,
|
||||
target: SurfaceTarget::Visual(native::WeakPtr::from_raw(visual)),
|
||||
target: SurfaceTarget::Visual(unsafe { native::WeakPtr::from_raw(visual) }),
|
||||
supports_allow_tearing: self.supports_allow_tearing,
|
||||
swap_chain: None,
|
||||
}
|
||||
@@ -183,7 +183,7 @@ struct Idler {
|
||||
|
||||
impl Idler {
|
||||
unsafe fn destroy(self) {
|
||||
self.fence.destroy();
|
||||
unsafe { self.fence.destroy() };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -195,9 +195,11 @@ struct CommandSignatures {
|
||||
|
||||
impl CommandSignatures {
|
||||
unsafe fn destroy(&self) {
|
||||
self.draw.destroy();
|
||||
self.draw_indexed.destroy();
|
||||
self.dispatch.destroy();
|
||||
unsafe {
|
||||
self.draw.destroy();
|
||||
self.draw_indexed.destroy();
|
||||
self.dispatch.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -210,10 +212,12 @@ struct DeviceShared {
|
||||
|
||||
impl DeviceShared {
|
||||
unsafe fn destroy(&self) {
|
||||
self.zero_buffer.destroy();
|
||||
self.cmd_signatures.destroy();
|
||||
self.heap_views.raw.destroy();
|
||||
self.heap_samplers.raw.destroy();
|
||||
unsafe {
|
||||
self.zero_buffer.destroy();
|
||||
self.cmd_signatures.destroy();
|
||||
self.heap_views.raw.destroy();
|
||||
self.heap_samplers.raw.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -548,7 +552,7 @@ unsafe impl Sync for ComputePipeline {}
|
||||
impl SwapChain {
|
||||
unsafe fn release_resources(self) -> native::WeakPtr<dxgi1_4::IDXGISwapChain3> {
|
||||
for resource in self.resources {
|
||||
resource.destroy();
|
||||
unsafe { resource.destroy() };
|
||||
}
|
||||
self.raw
|
||||
}
|
||||
@@ -561,7 +565,7 @@ impl SwapChain {
|
||||
Some(duration) => duration.as_millis() as u32,
|
||||
None => winbase::INFINITE,
|
||||
};
|
||||
match synchapi::WaitForSingleObject(self.waitable, timeout_ms) {
|
||||
match unsafe { synchapi::WaitForSingleObject(self.waitable, timeout_ms) } {
|
||||
winbase::WAIT_ABANDONED | winbase::WAIT_FAILED => Err(crate::SurfaceError::Lost),
|
||||
winbase::WAIT_OBJECT_0 => Ok(true),
|
||||
winerror::WAIT_TIMEOUT => Ok(false),
|
||||
@@ -593,16 +597,18 @@ impl crate::Surface<Api> for Surface {
|
||||
//Note: this path doesn't properly re-initialize all of the things
|
||||
Some(sc) => {
|
||||
// can't have image resources in flight used by GPU
|
||||
let _ = device.wait_idle();
|
||||
let _ = unsafe { device.wait_idle() };
|
||||
|
||||
let raw = sc.release_resources();
|
||||
let result = raw.ResizeBuffers(
|
||||
config.swap_chain_size,
|
||||
config.extent.width,
|
||||
config.extent.height,
|
||||
non_srgb_format,
|
||||
flags,
|
||||
);
|
||||
let raw = unsafe { sc.release_resources() };
|
||||
let result = unsafe {
|
||||
raw.ResizeBuffers(
|
||||
config.swap_chain_size,
|
||||
config.extent.width,
|
||||
config.extent.height,
|
||||
non_srgb_format,
|
||||
flags,
|
||||
)
|
||||
};
|
||||
if let Err(err) = result.into_result() {
|
||||
log::error!("ResizeBuffers failed: {}", err);
|
||||
return Err(crate::SurfaceError::Other("window is in use"));
|
||||
@@ -664,7 +670,8 @@ impl crate::Surface<Api> for Surface {
|
||||
match self.target {
|
||||
SurfaceTarget::WndHandle(_) => {}
|
||||
SurfaceTarget::Visual(visual) => {
|
||||
if let Err(err) = visual.SetContent(swap_chain1.as_unknown()).into_result()
|
||||
if let Err(err) =
|
||||
unsafe { visual.SetContent(swap_chain1.as_unknown()) }.into_result()
|
||||
{
|
||||
log::error!("Unable to SetContent: {}", err);
|
||||
return Err(crate::SurfaceError::Other(
|
||||
@@ -674,9 +681,9 @@ impl crate::Surface<Api> for Surface {
|
||||
}
|
||||
}
|
||||
|
||||
match swap_chain1.cast::<dxgi1_4::IDXGISwapChain3>().into_result() {
|
||||
match unsafe { swap_chain1.cast::<dxgi1_4::IDXGISwapChain3>() }.into_result() {
|
||||
Ok(swap_chain3) => {
|
||||
swap_chain1.destroy();
|
||||
unsafe { swap_chain1.destroy() };
|
||||
swap_chain3
|
||||
}
|
||||
Err(err) => {
|
||||
@@ -692,20 +699,24 @@ impl crate::Surface<Api> for Surface {
|
||||
// Disable automatic Alt+Enter handling by DXGI.
|
||||
const DXGI_MWA_NO_WINDOW_CHANGES: u32 = 1;
|
||||
const DXGI_MWA_NO_ALT_ENTER: u32 = 2;
|
||||
self.factory.MakeWindowAssociation(
|
||||
wnd_handle,
|
||||
DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER,
|
||||
);
|
||||
unsafe {
|
||||
self.factory.MakeWindowAssociation(
|
||||
wnd_handle,
|
||||
DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER,
|
||||
)
|
||||
};
|
||||
}
|
||||
SurfaceTarget::Visual(_) => {}
|
||||
}
|
||||
|
||||
swap_chain.SetMaximumFrameLatency(config.swap_chain_size);
|
||||
let waitable = swap_chain.GetFrameLatencyWaitableObject();
|
||||
unsafe { swap_chain.SetMaximumFrameLatency(config.swap_chain_size) };
|
||||
let waitable = unsafe { swap_chain.GetFrameLatencyWaitableObject() };
|
||||
|
||||
let mut resources = vec![native::Resource::null(); config.swap_chain_size as usize];
|
||||
for (i, res) in resources.iter_mut().enumerate() {
|
||||
swap_chain.GetBuffer(i as _, &d3d12::ID3D12Resource::uuidof(), res.mut_void());
|
||||
unsafe {
|
||||
swap_chain.GetBuffer(i as _, &d3d12::ID3D12Resource::uuidof(), res.mut_void())
|
||||
};
|
||||
}
|
||||
|
||||
self.swap_chain = Some(SwapChain {
|
||||
@@ -723,12 +734,14 @@ impl crate::Surface<Api> for Surface {
|
||||
|
||||
unsafe fn unconfigure(&mut self, device: &Device) {
|
||||
if let Some(mut sc) = self.swap_chain.take() {
|
||||
let _ = sc.wait(None);
|
||||
//TODO: this shouldn't be needed,
|
||||
// but it complains that the queue is still used otherwise
|
||||
let _ = device.wait_idle();
|
||||
let raw = sc.release_resources();
|
||||
raw.destroy();
|
||||
unsafe {
|
||||
let _ = sc.wait(None);
|
||||
//TODO: this shouldn't be needed,
|
||||
// but it complains that the queue is still used otherwise
|
||||
let _ = device.wait_idle();
|
||||
let raw = sc.release_resources();
|
||||
raw.destroy();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -738,9 +751,9 @@ impl crate::Surface<Api> for Surface {
|
||||
) -> Result<Option<crate::AcquiredSurfaceTexture<Api>>, crate::SurfaceError> {
|
||||
let sc = self.swap_chain.as_mut().unwrap();
|
||||
|
||||
sc.wait(timeout)?;
|
||||
unsafe { sc.wait(timeout) }?;
|
||||
|
||||
let base_index = sc.raw.GetCurrentBackBufferIndex() as usize;
|
||||
let base_index = unsafe { sc.raw.GetCurrentBackBufferIndex() } as usize;
|
||||
let index = (base_index + sc.acquired_count) % sc.resources.len();
|
||||
sc.acquired_count += 1;
|
||||
|
||||
@@ -803,14 +816,14 @@ impl crate::Queue<Api> for Queue {
|
||||
};
|
||||
|
||||
profiling::scope!("IDXGISwapchain3::Present");
|
||||
sc.raw.Present(interval, flags);
|
||||
unsafe { sc.raw.Present(interval, flags) };
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn get_timestamp_period(&self) -> f32 {
|
||||
let mut frequency = 0u64;
|
||||
self.raw.GetTimestampFrequency(&mut frequency);
|
||||
unsafe { self.raw.GetTimestampFrequency(&mut frequency) };
|
||||
(1_000_000_000.0 / frequency as f64) as f32
|
||||
}
|
||||
}
|
||||
+135
-89
@@ -42,16 +42,18 @@ impl ViewDescriptor {
|
||||
Format: self.format_nodepth,
|
||||
ViewDimension: 0,
|
||||
Shader4ComponentMapping: D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE1D;
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
@@ -67,67 +69,81 @@ impl ViewDescriptor {
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE2DMS;
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_SRV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_SRV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE2D;
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
PlaneSlice: 0,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
PlaneSlice: 0,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_SRV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_SRV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3 => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURE3D;
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURECUBE;
|
||||
*desc.u.TextureCube_mut() = d3d12::D3D12_TEXCUBE_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.TextureCube_mut() = d3d12::D3D12_TEXCUBE_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube | wgt::TextureViewDimension::CubeArray => {
|
||||
desc.ViewDimension = d3d12::D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
|
||||
*desc.u.TextureCubeArray_mut() = d3d12::D3D12_TEXCUBE_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
First2DArrayFace: self.array_layer_base,
|
||||
NumCubes: if self.array_layer_count == !0 {
|
||||
!0
|
||||
} else {
|
||||
self.array_layer_count / 6
|
||||
},
|
||||
ResourceMinLODClamp: 0.0,
|
||||
unsafe {
|
||||
*desc.u.TextureCubeArray_mut() = d3d12::D3D12_TEXCUBE_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
First2DArrayFace: self.array_layer_base,
|
||||
NumCubes: if self.array_layer_count == !0 {
|
||||
!0
|
||||
} else {
|
||||
self.array_layer_count / 6
|
||||
},
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -139,14 +155,16 @@ impl ViewDescriptor {
|
||||
let mut desc = d3d12::D3D12_UNORDERED_ACCESS_VIEW_DESC {
|
||||
Format: self.format_nodepth,
|
||||
ViewDimension: 0,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = d3d12::D3D12_UAV_DIMENSION_TEXTURE1D;
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
unsafe {
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
@@ -160,26 +178,32 @@ impl ViewDescriptor {
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_UAV_DIMENSION_TEXTURE2D;
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = d3d12::D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3 => {
|
||||
desc.ViewDimension = d3d12::D3D12_UAV_DIMENSION_TEXTURE3D;
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstWSlice: self.array_layer_base,
|
||||
WSize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstWSlice: self.array_layer_base,
|
||||
WSize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube | wgt::TextureViewDimension::CubeArray => {
|
||||
@@ -194,14 +218,16 @@ impl ViewDescriptor {
|
||||
let mut desc = d3d12::D3D12_RENDER_TARGET_VIEW_DESC {
|
||||
Format: self.format,
|
||||
ViewDimension: 0,
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE1D;
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
unsafe {
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
@@ -215,41 +241,51 @@ impl ViewDescriptor {
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE2DMS;
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_RTV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_RTV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE2D;
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_RTV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_RTV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3 => {
|
||||
desc.ViewDimension = d3d12::D3D12_RTV_DIMENSION_TEXTURE3D;
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstWSlice: self.array_layer_base,
|
||||
WSize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture3D_mut() = d3d12::D3D12_TEX3D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstWSlice: self.array_layer_base,
|
||||
WSize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube | wgt::TextureViewDimension::CubeArray => {
|
||||
@@ -277,14 +313,16 @@ impl ViewDescriptor {
|
||||
}
|
||||
flags
|
||||
},
|
||||
u: mem::zeroed(),
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = d3d12::D3D12_DSV_DIMENSION_TEXTURE1D;
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
unsafe {
|
||||
*desc.u.Texture1D_mut() = d3d12::D3D12_TEX1D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
@@ -298,31 +336,39 @@ impl ViewDescriptor {
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_DSV_DIMENSION_TEXTURE2DMS;
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_DSV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMS_mut() = d3d12::D3D12_TEX2DMS_DSV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = d3d12::D3D12_DSV_DIMENSION_TEXTURE2D;
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
unsafe {
|
||||
*desc.u.Texture2D_mut() = d3d12::D3D12_TEX2D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = d3d12::D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_DSV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture2DMSArray_mut() = d3d12::D3D12_TEX2DMS_ARRAY_DSV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = d3d12::D3D12_DSV_DIMENSION_TEXTURE2DARRAY;
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
unsafe {
|
||||
*desc.u.Texture2DArray_mut() = d3d12::D3D12_TEX2D_ARRAY_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3
|
||||
|
||||
@@ -191,12 +191,12 @@ impl super::Adapter {
|
||||
(glow::VENDOR, glow::RENDERER)
|
||||
};
|
||||
let (vendor, renderer) = {
|
||||
let vendor = gl.get_parameter_string(vendor_const);
|
||||
let renderer = gl.get_parameter_string(renderer_const);
|
||||
let vendor = unsafe { gl.get_parameter_string(vendor_const) };
|
||||
let renderer = unsafe { gl.get_parameter_string(renderer_const) };
|
||||
|
||||
(vendor, renderer)
|
||||
};
|
||||
let version = gl.get_parameter_string(glow::VERSION);
|
||||
let version = unsafe { gl.get_parameter_string(glow::VERSION) };
|
||||
log::info!("Vendor: {}", vendor);
|
||||
log::info!("Renderer: {}", renderer);
|
||||
log::info!("Version: {}", version);
|
||||
@@ -217,7 +217,7 @@ impl super::Adapter {
|
||||
let supports_work_group_params = ver >= (3, 1);
|
||||
|
||||
let shading_language_version = {
|
||||
let sl_version = gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION);
|
||||
let sl_version = unsafe { gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION) };
|
||||
log::info!("SL version: {}", &sl_version);
|
||||
let (sl_major, sl_minor) = Self::parse_version(&sl_version).ok()?;
|
||||
let value = sl_major as u16 * 100 + sl_minor as u16 * 10;
|
||||
@@ -231,27 +231,27 @@ impl super::Adapter {
|
||||
let is_angle = renderer.contains("ANGLE");
|
||||
|
||||
let vertex_shader_storage_blocks = if supports_storage {
|
||||
gl.get_parameter_i32(glow::MAX_VERTEX_SHADER_STORAGE_BLOCKS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_SHADER_STORAGE_BLOCKS) } as u32)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let fragment_shader_storage_blocks = if supports_storage {
|
||||
gl.get_parameter_i32(glow::MAX_FRAGMENT_SHADER_STORAGE_BLOCKS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_FRAGMENT_SHADER_STORAGE_BLOCKS) } as u32)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let vertex_shader_storage_textures = if supports_storage {
|
||||
gl.get_parameter_i32(glow::MAX_VERTEX_IMAGE_UNIFORMS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_IMAGE_UNIFORMS) } as u32)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let fragment_shader_storage_textures = if supports_storage {
|
||||
gl.get_parameter_i32(glow::MAX_FRAGMENT_IMAGE_UNIFORMS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_FRAGMENT_IMAGE_UNIFORMS) } as u32)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let max_storage_block_size = if supports_storage {
|
||||
gl.get_parameter_i32(glow::MAX_SHADER_STORAGE_BLOCK_SIZE) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_SHADER_STORAGE_BLOCK_SIZE) } as u32)
|
||||
} else {
|
||||
0
|
||||
};
|
||||
@@ -422,24 +422,25 @@ impl super::Adapter {
|
||||
color_buffer_float,
|
||||
);
|
||||
|
||||
let max_texture_size = gl.get_parameter_i32(glow::MAX_TEXTURE_SIZE) as u32;
|
||||
let max_texture_3d_size = gl.get_parameter_i32(glow::MAX_3D_TEXTURE_SIZE) as u32;
|
||||
let max_texture_size = unsafe { gl.get_parameter_i32(glow::MAX_TEXTURE_SIZE) } as u32;
|
||||
let max_texture_3d_size = unsafe { gl.get_parameter_i32(glow::MAX_3D_TEXTURE_SIZE) } as u32;
|
||||
|
||||
let min_uniform_buffer_offset_alignment =
|
||||
gl.get_parameter_i32(glow::UNIFORM_BUFFER_OFFSET_ALIGNMENT) as u32;
|
||||
(unsafe { gl.get_parameter_i32(glow::UNIFORM_BUFFER_OFFSET_ALIGNMENT) } as u32);
|
||||
let min_storage_buffer_offset_alignment = if ver >= (3, 1) {
|
||||
gl.get_parameter_i32(glow::SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT) } as u32)
|
||||
} else {
|
||||
256
|
||||
};
|
||||
let max_uniform_buffers_per_shader_stage =
|
||||
gl.get_parameter_i32(glow::MAX_VERTEX_UNIFORM_BLOCKS)
|
||||
.min(gl.get_parameter_i32(glow::MAX_FRAGMENT_UNIFORM_BLOCKS)) as u32;
|
||||
unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_UNIFORM_BLOCKS) }
|
||||
.min(unsafe { gl.get_parameter_i32(glow::MAX_FRAGMENT_UNIFORM_BLOCKS) })
|
||||
as u32;
|
||||
|
||||
let max_compute_workgroups_per_dimension = if supports_work_group_params {
|
||||
gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 0)
|
||||
.min(gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 1))
|
||||
.min(gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 2))
|
||||
unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 0) }
|
||||
.min(unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 1) })
|
||||
.min(unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_COUNT, 2) })
|
||||
as u32
|
||||
} else {
|
||||
0
|
||||
@@ -449,7 +450,9 @@ impl super::Adapter {
|
||||
max_texture_dimension_1d: max_texture_size,
|
||||
max_texture_dimension_2d: max_texture_size,
|
||||
max_texture_dimension_3d: max_texture_3d_size,
|
||||
max_texture_array_layers: gl.get_parameter_i32(glow::MAX_ARRAY_TEXTURE_LAYERS) as u32,
|
||||
max_texture_array_layers: unsafe {
|
||||
gl.get_parameter_i32(glow::MAX_ARRAY_TEXTURE_LAYERS)
|
||||
} as u32,
|
||||
max_bind_groups: crate::MAX_BIND_GROUPS as u32,
|
||||
max_bindings_per_bind_group: 65535,
|
||||
max_dynamic_uniform_buffers_per_pipeline_layout: max_uniform_buffers_per_shader_stage,
|
||||
@@ -459,56 +462,62 @@ impl super::Adapter {
|
||||
max_storage_buffers_per_shader_stage,
|
||||
max_storage_textures_per_shader_stage,
|
||||
max_uniform_buffers_per_shader_stage,
|
||||
max_uniform_buffer_binding_size: gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE)
|
||||
as u32,
|
||||
max_uniform_buffer_binding_size: unsafe {
|
||||
gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE)
|
||||
} as u32,
|
||||
max_storage_buffer_binding_size: if ver >= (3, 1) {
|
||||
gl.get_parameter_i32(glow::MAX_SHADER_STORAGE_BLOCK_SIZE)
|
||||
unsafe { gl.get_parameter_i32(glow::MAX_SHADER_STORAGE_BLOCK_SIZE) }
|
||||
} else {
|
||||
0
|
||||
} as u32,
|
||||
max_vertex_buffers: if private_caps
|
||||
.contains(super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT)
|
||||
{
|
||||
gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIB_BINDINGS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIB_BINDINGS) } as u32)
|
||||
} else {
|
||||
16 // should this be different?
|
||||
},
|
||||
max_vertex_attributes: (gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIBS) as u32)
|
||||
max_vertex_attributes: (unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIBS) }
|
||||
as u32)
|
||||
.min(super::MAX_VERTEX_ATTRIBUTES as u32),
|
||||
max_vertex_buffer_array_stride: if private_caps
|
||||
.contains(super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT)
|
||||
{
|
||||
gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIB_STRIDE) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_VERTEX_ATTRIB_STRIDE) } as u32)
|
||||
} else {
|
||||
!0
|
||||
},
|
||||
max_push_constant_size: super::MAX_PUSH_CONSTANTS as u32 * 4,
|
||||
min_uniform_buffer_offset_alignment,
|
||||
min_storage_buffer_offset_alignment,
|
||||
max_inter_stage_shader_components: gl.get_parameter_i32(glow::MAX_VARYING_COMPONENTS)
|
||||
as u32,
|
||||
max_inter_stage_shader_components: unsafe {
|
||||
gl.get_parameter_i32(glow::MAX_VARYING_COMPONENTS)
|
||||
} as u32,
|
||||
max_compute_workgroup_storage_size: if supports_work_group_params {
|
||||
gl.get_parameter_i32(glow::MAX_COMPUTE_SHARED_MEMORY_SIZE) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_COMPUTE_SHARED_MEMORY_SIZE) } as u32)
|
||||
} else {
|
||||
0
|
||||
},
|
||||
max_compute_invocations_per_workgroup: if supports_work_group_params {
|
||||
gl.get_parameter_i32(glow::MAX_COMPUTE_WORK_GROUP_INVOCATIONS) as u32
|
||||
(unsafe { gl.get_parameter_i32(glow::MAX_COMPUTE_WORK_GROUP_INVOCATIONS) } as u32)
|
||||
} else {
|
||||
0
|
||||
},
|
||||
max_compute_workgroup_size_x: if supports_work_group_params {
|
||||
gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 0) as u32
|
||||
(unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 0) }
|
||||
as u32)
|
||||
} else {
|
||||
0
|
||||
},
|
||||
max_compute_workgroup_size_y: if supports_work_group_params {
|
||||
gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 1) as u32
|
||||
(unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 1) }
|
||||
as u32)
|
||||
} else {
|
||||
0
|
||||
},
|
||||
max_compute_workgroup_size_z: if supports_work_group_params {
|
||||
gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 2) as u32
|
||||
(unsafe { gl.get_parameter_indexed_i32(glow::MAX_COMPUTE_WORK_GROUP_SIZE, 2) }
|
||||
as u32)
|
||||
} else {
|
||||
0
|
||||
},
|
||||
@@ -578,27 +587,22 @@ impl super::Adapter {
|
||||
unsafe fn create_shader_clear_program(
|
||||
gl: &glow::Context,
|
||||
) -> (glow::Program, glow::UniformLocation) {
|
||||
let program = gl
|
||||
.create_program()
|
||||
.expect("Could not create shader program");
|
||||
let vertex = gl
|
||||
.create_shader(glow::VERTEX_SHADER)
|
||||
.expect("Could not create shader");
|
||||
gl.shader_source(vertex, include_str!("./shaders/clear.vert"));
|
||||
gl.compile_shader(vertex);
|
||||
let fragment = gl
|
||||
.create_shader(glow::FRAGMENT_SHADER)
|
||||
.expect("Could not create shader");
|
||||
gl.shader_source(fragment, include_str!("./shaders/clear.frag"));
|
||||
gl.compile_shader(fragment);
|
||||
gl.attach_shader(program, vertex);
|
||||
gl.attach_shader(program, fragment);
|
||||
gl.link_program(program);
|
||||
let color_uniform_location = gl
|
||||
.get_uniform_location(program, "color")
|
||||
let program = unsafe { gl.create_program() }.expect("Could not create shader program");
|
||||
let vertex =
|
||||
unsafe { gl.create_shader(glow::VERTEX_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(vertex, include_str!("./shaders/clear.vert")) };
|
||||
unsafe { gl.compile_shader(vertex) };
|
||||
let fragment =
|
||||
unsafe { gl.create_shader(glow::FRAGMENT_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(fragment, include_str!("./shaders/clear.frag")) };
|
||||
unsafe { gl.compile_shader(fragment) };
|
||||
unsafe { gl.attach_shader(program, vertex) };
|
||||
unsafe { gl.attach_shader(program, fragment) };
|
||||
unsafe { gl.link_program(program) };
|
||||
let color_uniform_location = unsafe { gl.get_uniform_location(program, "color") }
|
||||
.expect("Could not find color uniform in shader clear shader");
|
||||
gl.delete_shader(vertex);
|
||||
gl.delete_shader(fragment);
|
||||
unsafe { gl.delete_shader(vertex) };
|
||||
unsafe { gl.delete_shader(fragment) };
|
||||
|
||||
(program, color_uniform_location)
|
||||
}
|
||||
@@ -611,24 +615,22 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
_limits: &wgt::Limits,
|
||||
) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1);
|
||||
gl.pixel_store_i32(glow::PACK_ALIGNMENT, 1);
|
||||
let main_vao = gl
|
||||
.create_vertex_array()
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
gl.bind_vertex_array(Some(main_vao));
|
||||
unsafe { gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1) };
|
||||
unsafe { gl.pixel_store_i32(glow::PACK_ALIGNMENT, 1) };
|
||||
let main_vao =
|
||||
unsafe { gl.create_vertex_array() }.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
unsafe { gl.bind_vertex_array(Some(main_vao)) };
|
||||
|
||||
let zero_buffer = gl
|
||||
.create_buffer()
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
gl.bind_buffer(glow::COPY_READ_BUFFER, Some(zero_buffer));
|
||||
let zero_buffer =
|
||||
unsafe { gl.create_buffer() }.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
unsafe { gl.bind_buffer(glow::COPY_READ_BUFFER, Some(zero_buffer)) };
|
||||
let zeroes = vec![0u8; super::ZERO_BUFFER_SIZE];
|
||||
gl.buffer_data_u8_slice(glow::COPY_READ_BUFFER, &zeroes, glow::STATIC_DRAW);
|
||||
unsafe { gl.buffer_data_u8_slice(glow::COPY_READ_BUFFER, &zeroes, glow::STATIC_DRAW) };
|
||||
|
||||
// Compile the shader program we use for doing manual clears to work around Mesa fastclear
|
||||
// bug.
|
||||
let (shader_clear_program, shader_clear_program_color_uniform_location) =
|
||||
Self::create_shader_clear_program(gl);
|
||||
unsafe { Self::create_shader_clear_program(gl) };
|
||||
|
||||
Ok(crate::OpenDevice {
|
||||
device: super::Device {
|
||||
@@ -640,11 +642,9 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
queue: super::Queue {
|
||||
shared: Arc::clone(&self.shared),
|
||||
features,
|
||||
draw_fbo: gl
|
||||
.create_framebuffer()
|
||||
draw_fbo: unsafe { gl.create_framebuffer() }
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?,
|
||||
copy_fbo: gl
|
||||
.create_framebuffer()
|
||||
copy_fbo: unsafe { gl.create_framebuffer() }
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?,
|
||||
shader_clear_program,
|
||||
shader_clear_program_color_uniform_location,
|
||||
@@ -664,11 +664,12 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
use wgt::TextureFormat as Tf;
|
||||
|
||||
let sample_count = {
|
||||
let max_samples = self
|
||||
.shared
|
||||
.context
|
||||
.lock()
|
||||
.get_parameter_i32(glow::MAX_SAMPLES);
|
||||
let max_samples = unsafe {
|
||||
self.shared
|
||||
.context
|
||||
.lock()
|
||||
.get_parameter_i32(glow::MAX_SAMPLES)
|
||||
};
|
||||
if max_samples >= 8 {
|
||||
Tfc::MULTISAMPLE_X2 | Tfc::MULTISAMPLE_X4 | Tfc::MULTISAMPLE_X8
|
||||
} else if max_samples >= 4 {
|
||||
@@ -865,16 +866,16 @@ impl super::AdapterShared {
|
||||
.private_caps
|
||||
.contains(super::PrivateCapabilities::GET_BUFFER_SUB_DATA)
|
||||
{
|
||||
gl.get_buffer_sub_data(target, offset, dst_data);
|
||||
unsafe { gl.get_buffer_sub_data(target, offset, dst_data) };
|
||||
} else {
|
||||
log::error!("Fake map");
|
||||
let length = dst_data.len();
|
||||
let buffer_mapping =
|
||||
gl.map_buffer_range(target, offset, length as _, glow::MAP_READ_BIT);
|
||||
unsafe { gl.map_buffer_range(target, offset, length as _, glow::MAP_READ_BIT) };
|
||||
|
||||
std::ptr::copy_nonoverlapping(buffer_mapping, dst_data.as_mut_ptr(), length);
|
||||
unsafe { std::ptr::copy_nonoverlapping(buffer_mapping, dst_data.as_mut_ptr(), length) };
|
||||
|
||||
gl.unmap_buffer(target);
|
||||
unsafe { gl.unmap_buffer(target) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+200
-157
@@ -168,21 +168,22 @@ impl super::Device {
|
||||
naga::ShaderStage::Compute => glow::COMPUTE_SHADER,
|
||||
};
|
||||
|
||||
let raw = gl.create_shader(target).unwrap();
|
||||
let raw = unsafe { gl.create_shader(target) }.unwrap();
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if gl.supports_debug() {
|
||||
//TODO: remove all transmutes from `object_label`
|
||||
// https://github.com/grovesNL/glow/issues/186
|
||||
gl.object_label(glow::SHADER, mem::transmute(raw), label);
|
||||
let name = unsafe { mem::transmute(raw) };
|
||||
unsafe { gl.object_label(glow::SHADER, name, label) };
|
||||
}
|
||||
|
||||
gl.shader_source(raw, shader);
|
||||
gl.compile_shader(raw);
|
||||
unsafe { gl.shader_source(raw, shader) };
|
||||
unsafe { gl.compile_shader(raw) };
|
||||
|
||||
log::info!("\tCompiled shader {:?}", raw);
|
||||
|
||||
let compiled_ok = gl.get_shader_compile_status(raw);
|
||||
let msg = gl.get_shader_info_log(raw);
|
||||
let compiled_ok = unsafe { gl.get_shader_compile_status(raw) };
|
||||
let msg = unsafe { gl.get_shader_info_log(raw) };
|
||||
if compiled_ok {
|
||||
if !msg.is_empty() {
|
||||
log::warn!("\tCompile: {}", msg);
|
||||
@@ -272,11 +273,12 @@ impl super::Device {
|
||||
#[cfg_attr(target_arch = "wasm32", allow(unused))] label: Option<&str>,
|
||||
multiview: Option<std::num::NonZeroU32>,
|
||||
) -> Result<super::PipelineInner, crate::PipelineError> {
|
||||
let program = gl.create_program().unwrap();
|
||||
let program = unsafe { gl.create_program() }.unwrap();
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(label) = label {
|
||||
if gl.supports_debug() {
|
||||
gl.object_label(glow::PROGRAM, mem::transmute(program), Some(label));
|
||||
let name = unsafe { mem::transmute(program) };
|
||||
unsafe { gl.object_label(glow::PROGRAM, name, Some(label)) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -306,28 +308,30 @@ impl super::Device {
|
||||
};
|
||||
let shader_src = format!("#version {} es \n void main(void) {{}}", version,);
|
||||
log::info!("Only vertex shader is present. Creating an empty fragment shader",);
|
||||
let shader = Self::compile_shader(
|
||||
gl,
|
||||
&shader_src,
|
||||
naga::ShaderStage::Fragment,
|
||||
Some("(wgpu internal) dummy fragment shader"),
|
||||
)?;
|
||||
let shader = unsafe {
|
||||
Self::compile_shader(
|
||||
gl,
|
||||
&shader_src,
|
||||
naga::ShaderStage::Fragment,
|
||||
Some("(wgpu internal) dummy fragment shader"),
|
||||
)
|
||||
}?;
|
||||
shaders_to_delete.push(shader);
|
||||
}
|
||||
|
||||
for &shader in shaders_to_delete.iter() {
|
||||
gl.attach_shader(program, shader);
|
||||
unsafe { gl.attach_shader(program, shader) };
|
||||
}
|
||||
gl.link_program(program);
|
||||
unsafe { gl.link_program(program) };
|
||||
|
||||
for shader in shaders_to_delete {
|
||||
gl.delete_shader(shader);
|
||||
unsafe { gl.delete_shader(shader) };
|
||||
}
|
||||
|
||||
log::info!("\tLinked program {:?}", program);
|
||||
|
||||
let linked_ok = gl.get_program_link_status(program);
|
||||
let msg = gl.get_program_info_log(program);
|
||||
let linked_ok = unsafe { gl.get_program_link_status(program) };
|
||||
let msg = unsafe { gl.get_program_info_log(program) };
|
||||
if !linked_ok {
|
||||
return Err(crate::PipelineError::Linkage(has_stages, msg));
|
||||
}
|
||||
@@ -342,16 +346,17 @@ impl super::Device {
|
||||
{
|
||||
// This remapping is only needed if we aren't able to put the binding layout
|
||||
// in the shader. We can't remap storage buffers this way.
|
||||
gl.use_program(Some(program));
|
||||
unsafe { gl.use_program(Some(program)) };
|
||||
for (ref name, (register, slot)) in name_binding_map {
|
||||
log::trace!("Get binding {:?} from program {:?}", name, program);
|
||||
match register {
|
||||
super::BindingRegister::UniformBuffers => {
|
||||
let index = gl.get_uniform_block_index(program, name).unwrap();
|
||||
gl.uniform_block_binding(program, index, slot as _);
|
||||
let index = unsafe { gl.get_uniform_block_index(program, name) }.unwrap();
|
||||
unsafe { gl.uniform_block_binding(program, index, slot as _) };
|
||||
}
|
||||
super::BindingRegister::StorageBuffers => {
|
||||
let index = gl.get_shader_storage_block_index(program, name).unwrap();
|
||||
let index =
|
||||
unsafe { gl.get_shader_storage_block_index(program, name) }.unwrap();
|
||||
log::error!(
|
||||
"Unable to re-map shader storage block {} to {}",
|
||||
name,
|
||||
@@ -360,28 +365,26 @@ impl super::Device {
|
||||
return Err(crate::DeviceError::Lost.into());
|
||||
}
|
||||
super::BindingRegister::Textures | super::BindingRegister::Images => {
|
||||
gl.uniform_1_i32(
|
||||
gl.get_uniform_location(program, name).as_ref(),
|
||||
slot as _,
|
||||
);
|
||||
let location = unsafe { gl.get_uniform_location(program, name) };
|
||||
unsafe { gl.uniform_1_i32(location.as_ref(), slot as _) };
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut uniforms: [super::UniformDesc; super::MAX_PUSH_CONSTANTS] = Default::default();
|
||||
let count = gl.get_active_uniforms(program);
|
||||
let count = unsafe { gl.get_active_uniforms(program) };
|
||||
let mut offset = 0;
|
||||
|
||||
for uniform in 0..count {
|
||||
let glow::ActiveUniform { utype, name, .. } =
|
||||
gl.get_active_uniform(program, uniform).unwrap();
|
||||
unsafe { gl.get_active_uniform(program, uniform) }.unwrap();
|
||||
|
||||
if conv::is_sampler(utype) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(location) = gl.get_uniform_location(program, &name) {
|
||||
if let Some(location) = unsafe { gl.get_uniform_location(program, &name) } {
|
||||
if uniforms[offset / 4].location.is_some() {
|
||||
panic!("Offset already occupied")
|
||||
}
|
||||
@@ -410,10 +413,10 @@ impl super::Device {
|
||||
impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn exit(self, queue: super::Queue) {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.delete_vertex_array(self.main_vao);
|
||||
gl.delete_framebuffer(queue.draw_fbo);
|
||||
gl.delete_framebuffer(queue.copy_fbo);
|
||||
gl.delete_buffer(queue.zero_buffer);
|
||||
unsafe { gl.delete_vertex_array(self.main_vao) };
|
||||
unsafe { gl.delete_framebuffer(queue.draw_fbo) };
|
||||
unsafe { gl.delete_framebuffer(queue.copy_fbo) };
|
||||
unsafe { gl.delete_buffer(queue.zero_buffer) };
|
||||
}
|
||||
|
||||
unsafe fn create_buffer(
|
||||
@@ -468,8 +471,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
map_flags |= glow::MAP_WRITE_BIT;
|
||||
}
|
||||
|
||||
let raw = Some(gl.create_buffer().unwrap());
|
||||
gl.bind_buffer(target, raw);
|
||||
let raw = Some(unsafe { gl.create_buffer() }.unwrap());
|
||||
unsafe { gl.bind_buffer(target, raw) };
|
||||
let raw_size = desc
|
||||
.size
|
||||
.try_into()
|
||||
@@ -486,7 +489,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
map_flags |= glow::MAP_COHERENT_BIT;
|
||||
}
|
||||
}
|
||||
gl.buffer_storage(target, raw_size, None, map_flags);
|
||||
unsafe { gl.buffer_storage(target, raw_size, None, map_flags) };
|
||||
} else {
|
||||
assert!(!is_coherent);
|
||||
let usage = if is_host_visible {
|
||||
@@ -498,10 +501,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
} else {
|
||||
glow::STATIC_DRAW
|
||||
};
|
||||
gl.buffer_data_size(target, raw_size, usage);
|
||||
unsafe { gl.buffer_data_size(target, raw_size, usage) };
|
||||
}
|
||||
|
||||
gl.bind_buffer(target, None);
|
||||
unsafe { gl.bind_buffer(target, None) };
|
||||
|
||||
if !is_coherent && desc.usage.contains(crate::BufferUses::MAP_WRITE) {
|
||||
map_flags |= glow::MAP_FLUSH_EXPLICIT_BIT;
|
||||
@@ -511,7 +514,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(label) = desc.label {
|
||||
if gl.supports_debug() {
|
||||
gl.object_label(glow::BUFFER, mem::transmute(raw), Some(label));
|
||||
let name = unsafe { mem::transmute(raw) };
|
||||
unsafe { gl.object_label(glow::BUFFER, name, Some(label)) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -532,7 +536,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_buffer(&self, buffer: super::Buffer) {
|
||||
if let Some(raw) = buffer.raw {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.delete_buffer(raw);
|
||||
unsafe { gl.delete_buffer(raw) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -550,21 +554,23 @@ impl crate::Device<super::Api> for super::Device {
|
||||
}
|
||||
Some(raw) => {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.bind_buffer(buffer.target, Some(raw));
|
||||
unsafe { gl.bind_buffer(buffer.target, Some(raw)) };
|
||||
let ptr = if let Some(ref map_read_allocation) = buffer.data {
|
||||
let mut guard = map_read_allocation.lock().unwrap();
|
||||
let slice = guard.as_mut_slice();
|
||||
self.shared.get_buffer_sub_data(gl, buffer.target, 0, slice);
|
||||
unsafe { self.shared.get_buffer_sub_data(gl, buffer.target, 0, slice) };
|
||||
slice.as_mut_ptr()
|
||||
} else {
|
||||
gl.map_buffer_range(
|
||||
buffer.target,
|
||||
range.start as i32,
|
||||
(range.end - range.start) as i32,
|
||||
buffer.map_flags,
|
||||
)
|
||||
unsafe {
|
||||
gl.map_buffer_range(
|
||||
buffer.target,
|
||||
range.start as i32,
|
||||
(range.end - range.start) as i32,
|
||||
buffer.map_flags,
|
||||
)
|
||||
}
|
||||
};
|
||||
gl.bind_buffer(buffer.target, None);
|
||||
unsafe { gl.bind_buffer(buffer.target, None) };
|
||||
ptr
|
||||
}
|
||||
};
|
||||
@@ -577,9 +583,9 @@ impl crate::Device<super::Api> for super::Device {
|
||||
if let Some(raw) = buffer.raw {
|
||||
if buffer.data.is_none() {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.bind_buffer(buffer.target, Some(raw));
|
||||
gl.unmap_buffer(buffer.target);
|
||||
gl.bind_buffer(buffer.target, None);
|
||||
unsafe { gl.bind_buffer(buffer.target, Some(raw)) };
|
||||
unsafe { gl.unmap_buffer(buffer.target) };
|
||||
unsafe { gl.bind_buffer(buffer.target, None) };
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
@@ -590,13 +596,15 @@ impl crate::Device<super::Api> for super::Device {
|
||||
{
|
||||
if let Some(raw) = buffer.raw {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.bind_buffer(buffer.target, Some(raw));
|
||||
unsafe { gl.bind_buffer(buffer.target, Some(raw)) };
|
||||
for range in ranges {
|
||||
gl.flush_mapped_buffer_range(
|
||||
buffer.target,
|
||||
range.start as i32,
|
||||
(range.end - range.start) as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.flush_mapped_buffer_range(
|
||||
buffer.target,
|
||||
range.start as i32,
|
||||
(range.end - range.start) as i32,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -625,89 +633,105 @@ impl crate::Device<super::Api> for super::Device {
|
||||
&& desc.dimension == wgt::TextureDimension::D2
|
||||
&& desc.size.depth_or_array_layers == 1
|
||||
{
|
||||
let raw = gl.create_renderbuffer().unwrap();
|
||||
gl.bind_renderbuffer(glow::RENDERBUFFER, Some(raw));
|
||||
let raw = unsafe { gl.create_renderbuffer().unwrap() };
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, Some(raw)) };
|
||||
if desc.sample_count > 1 {
|
||||
gl.renderbuffer_storage_multisample(
|
||||
glow::RENDERBUFFER,
|
||||
desc.sample_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.renderbuffer_storage_multisample(
|
||||
glow::RENDERBUFFER,
|
||||
desc.sample_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
)
|
||||
};
|
||||
} else {
|
||||
gl.renderbuffer_storage(
|
||||
glow::RENDERBUFFER,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.renderbuffer_storage(
|
||||
glow::RENDERBUFFER,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(label) = desc.label {
|
||||
if gl.supports_debug() {
|
||||
gl.object_label(glow::RENDERBUFFER, mem::transmute(raw), Some(label));
|
||||
let name = unsafe { mem::transmute(raw) };
|
||||
unsafe { gl.object_label(glow::RENDERBUFFER, name, Some(label)) };
|
||||
}
|
||||
}
|
||||
|
||||
gl.bind_renderbuffer(glow::RENDERBUFFER, None);
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, None) };
|
||||
(super::TextureInner::Renderbuffer { raw }, false)
|
||||
} else {
|
||||
let raw = gl.create_texture().unwrap();
|
||||
let raw = unsafe { gl.create_texture().unwrap() };
|
||||
let (target, is_3d, is_cubemap) =
|
||||
super::Texture::get_info_from_desc(&mut copy_size, desc);
|
||||
|
||||
gl.bind_texture(target, Some(raw));
|
||||
unsafe { gl.bind_texture(target, Some(raw)) };
|
||||
//Note: this has to be done before defining the storage!
|
||||
match desc.format.describe().sample_type {
|
||||
wgt::TextureSampleType::Float { filterable: false }
|
||||
| wgt::TextureSampleType::Uint
|
||||
| wgt::TextureSampleType::Sint => {
|
||||
// reset default filtering mode
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32);
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32);
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32)
|
||||
};
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32)
|
||||
};
|
||||
}
|
||||
wgt::TextureSampleType::Float { filterable: true }
|
||||
| wgt::TextureSampleType::Depth => {}
|
||||
}
|
||||
|
||||
if is_3d {
|
||||
gl.tex_storage_3d(
|
||||
target,
|
||||
desc.mip_level_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
desc.size.depth_or_array_layers as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.tex_storage_3d(
|
||||
target,
|
||||
desc.mip_level_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
desc.size.depth_or_array_layers as i32,
|
||||
)
|
||||
};
|
||||
} else if desc.sample_count > 1 {
|
||||
gl.tex_storage_2d_multisample(
|
||||
target,
|
||||
desc.sample_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
true,
|
||||
);
|
||||
unsafe {
|
||||
gl.tex_storage_2d_multisample(
|
||||
target,
|
||||
desc.sample_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
true,
|
||||
)
|
||||
};
|
||||
} else {
|
||||
gl.tex_storage_2d(
|
||||
target,
|
||||
desc.mip_level_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.tex_storage_2d(
|
||||
target,
|
||||
desc.mip_level_count as i32,
|
||||
format_desc.internal,
|
||||
desc.size.width as i32,
|
||||
desc.size.height as i32,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(label) = desc.label {
|
||||
if gl.supports_debug() {
|
||||
gl.object_label(glow::TEXTURE, mem::transmute(raw), Some(label));
|
||||
let name = unsafe { mem::transmute(raw) };
|
||||
unsafe { gl.object_label(glow::TEXTURE, name, Some(label)) };
|
||||
}
|
||||
}
|
||||
|
||||
gl.bind_texture(target, None);
|
||||
unsafe { gl.bind_texture(target, None) };
|
||||
(super::TextureInner::Texture { raw, target }, is_cubemap)
|
||||
};
|
||||
|
||||
@@ -731,11 +755,11 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let gl = &self.shared.context.lock();
|
||||
match texture.inner {
|
||||
super::TextureInner::Renderbuffer { raw, .. } => {
|
||||
gl.delete_renderbuffer(raw);
|
||||
unsafe { gl.delete_renderbuffer(raw) };
|
||||
}
|
||||
super::TextureInner::DefaultRenderbuffer => {}
|
||||
super::TextureInner::Texture { raw, .. } => {
|
||||
gl.delete_texture(raw);
|
||||
unsafe { gl.delete_texture(raw) };
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -777,29 +801,35 @@ impl crate::Device<super::Api> for super::Device {
|
||||
) -> Result<super::Sampler, crate::DeviceError> {
|
||||
let gl = &self.shared.context.lock();
|
||||
|
||||
let raw = gl.create_sampler().unwrap();
|
||||
let raw = unsafe { gl.create_sampler().unwrap() };
|
||||
|
||||
let (min, mag) =
|
||||
conv::map_filter_modes(desc.min_filter, desc.mag_filter, desc.mipmap_filter);
|
||||
|
||||
gl.sampler_parameter_i32(raw, glow::TEXTURE_MIN_FILTER, min as i32);
|
||||
gl.sampler_parameter_i32(raw, glow::TEXTURE_MAG_FILTER, mag as i32);
|
||||
unsafe { gl.sampler_parameter_i32(raw, glow::TEXTURE_MIN_FILTER, min as i32) };
|
||||
unsafe { gl.sampler_parameter_i32(raw, glow::TEXTURE_MAG_FILTER, mag as i32) };
|
||||
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_S,
|
||||
conv::map_address_mode(desc.address_modes[0]) as i32,
|
||||
);
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_T,
|
||||
conv::map_address_mode(desc.address_modes[1]) as i32,
|
||||
);
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_R,
|
||||
conv::map_address_mode(desc.address_modes[2]) as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_S,
|
||||
conv::map_address_mode(desc.address_modes[0]) as i32,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_T,
|
||||
conv::map_address_mode(desc.address_modes[1]) as i32,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_WRAP_R,
|
||||
conv::map_address_mode(desc.address_modes[2]) as i32,
|
||||
)
|
||||
};
|
||||
|
||||
if let Some(border_color) = desc.border_color {
|
||||
let border = match border_color {
|
||||
@@ -809,37 +839,44 @@ impl crate::Device<super::Api> for super::Device {
|
||||
wgt::SamplerBorderColor::OpaqueBlack => [0.0, 0.0, 0.0, 1.0],
|
||||
wgt::SamplerBorderColor::OpaqueWhite => [1.0; 4],
|
||||
};
|
||||
gl.sampler_parameter_f32_slice(raw, glow::TEXTURE_BORDER_COLOR, &border);
|
||||
unsafe { gl.sampler_parameter_f32_slice(raw, glow::TEXTURE_BORDER_COLOR, &border) };
|
||||
}
|
||||
|
||||
if let Some(ref range) = desc.lod_clamp {
|
||||
gl.sampler_parameter_f32(raw, glow::TEXTURE_MIN_LOD, range.start);
|
||||
gl.sampler_parameter_f32(raw, glow::TEXTURE_MAX_LOD, range.end);
|
||||
unsafe { gl.sampler_parameter_f32(raw, glow::TEXTURE_MIN_LOD, range.start) };
|
||||
unsafe { gl.sampler_parameter_f32(raw, glow::TEXTURE_MAX_LOD, range.end) };
|
||||
}
|
||||
|
||||
if let Some(anisotropy) = desc.anisotropy_clamp {
|
||||
gl.sampler_parameter_i32(raw, glow::TEXTURE_MAX_ANISOTROPY, anisotropy.get() as i32);
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(raw, glow::TEXTURE_MAX_ANISOTROPY, anisotropy.get() as i32)
|
||||
};
|
||||
}
|
||||
|
||||
//set_param_float(glow::TEXTURE_LOD_BIAS, info.lod_bias.0);
|
||||
|
||||
if let Some(compare) = desc.compare {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_COMPARE_MODE,
|
||||
glow::COMPARE_REF_TO_TEXTURE as i32,
|
||||
);
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_COMPARE_FUNC,
|
||||
conv::map_compare_func(compare) as i32,
|
||||
);
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_COMPARE_MODE,
|
||||
glow::COMPARE_REF_TO_TEXTURE as i32,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.sampler_parameter_i32(
|
||||
raw,
|
||||
glow::TEXTURE_COMPARE_FUNC,
|
||||
conv::map_compare_func(compare) as i32,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if let Some(label) = desc.label {
|
||||
if gl.supports_debug() {
|
||||
gl.object_label(glow::SAMPLER, mem::transmute(raw), Some(label));
|
||||
let name = unsafe { mem::transmute(raw) };
|
||||
unsafe { gl.object_label(glow::SAMPLER, name, Some(label)) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -847,7 +884,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
}
|
||||
unsafe fn destroy_sampler(&self, sampler: super::Sampler) {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.delete_sampler(sampler.raw);
|
||||
unsafe { gl.delete_sampler(sampler.raw) };
|
||||
}
|
||||
|
||||
unsafe fn create_command_encoder(
|
||||
@@ -1035,7 +1072,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.as_ref()
|
||||
.map(|fs| (naga::ShaderStage::Fragment, fs)),
|
||||
);
|
||||
let inner = self.create_pipeline(gl, shaders, desc.layout, desc.label, desc.multiview)?;
|
||||
let inner =
|
||||
unsafe { self.create_pipeline(gl, shaders, desc.layout, desc.label, desc.multiview) }?;
|
||||
|
||||
let (vertex_buffers, vertex_attributes) = {
|
||||
let mut buffers = Vec::new();
|
||||
@@ -1095,7 +1133,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
}
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: super::RenderPipeline) {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.delete_program(pipeline.inner.program);
|
||||
unsafe { gl.delete_program(pipeline.inner.program) };
|
||||
}
|
||||
|
||||
unsafe fn create_compute_pipeline(
|
||||
@@ -1104,13 +1142,13 @@ impl crate::Device<super::Api> for super::Device {
|
||||
) -> Result<super::ComputePipeline, crate::PipelineError> {
|
||||
let gl = &self.shared.context.lock();
|
||||
let shaders = iter::once((naga::ShaderStage::Compute, &desc.stage));
|
||||
let inner = self.create_pipeline(gl, shaders, desc.layout, desc.label, None)?;
|
||||
let inner = unsafe { self.create_pipeline(gl, shaders, desc.layout, desc.label, None) }?;
|
||||
|
||||
Ok(super::ComputePipeline { inner })
|
||||
}
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: super::ComputePipeline) {
|
||||
let gl = &self.shared.context.lock();
|
||||
gl.delete_program(pipeline.inner.program);
|
||||
unsafe { gl.delete_program(pipeline.inner.program) };
|
||||
}
|
||||
|
||||
#[cfg_attr(target_arch = "wasm32", allow(unused))]
|
||||
@@ -1123,9 +1161,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let mut queries = Vec::with_capacity(desc.count as usize);
|
||||
for i in 0..desc.count {
|
||||
let query = gl
|
||||
.create_query()
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
let query =
|
||||
unsafe { gl.create_query() }.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
if gl.supports_debug() {
|
||||
use std::fmt::Write;
|
||||
@@ -1133,7 +1170,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
if let Some(label) = desc.label {
|
||||
temp_string.clear();
|
||||
let _ = write!(temp_string, "{}[{}]", label, i);
|
||||
gl.object_label(glow::QUERY, mem::transmute(query), Some(&temp_string));
|
||||
let name = unsafe { mem::transmute(query) };
|
||||
unsafe { gl.object_label(glow::QUERY, name, Some(&temp_string)) };
|
||||
}
|
||||
}
|
||||
queries.push(query);
|
||||
@@ -1150,7 +1188,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_query_set(&self, set: super::QuerySet) {
|
||||
let gl = &self.shared.context.lock();
|
||||
for &query in set.queries.iter() {
|
||||
gl.delete_query(query);
|
||||
unsafe { gl.delete_query(query) };
|
||||
}
|
||||
}
|
||||
unsafe fn create_fence(&self) -> Result<super::Fence, crate::DeviceError> {
|
||||
@@ -1162,7 +1200,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_fence(&self, fence: super::Fence) {
|
||||
let gl = &self.shared.context.lock();
|
||||
for (_, sync) in fence.pending {
|
||||
gl.delete_sync(sync);
|
||||
unsafe { gl.delete_sync(sync) };
|
||||
}
|
||||
}
|
||||
unsafe fn get_fence_value(
|
||||
@@ -1190,7 +1228,9 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.iter()
|
||||
.find(|&&(value, _)| value >= wait_value)
|
||||
.unwrap();
|
||||
match gl.client_wait_sync(sync, glow::SYNC_FLUSH_COMMANDS_BIT, timeout_ns as i32) {
|
||||
match unsafe {
|
||||
gl.client_wait_sync(sync, glow::SYNC_FLUSH_COMMANDS_BIT, timeout_ns as i32)
|
||||
} {
|
||||
// for some reason firefox returns WAIT_FAILED, to investigate
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
glow::WAIT_FAILED => {
|
||||
@@ -1208,16 +1248,19 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
unsafe fn start_capture(&self) -> bool {
|
||||
#[cfg(feature = "renderdoc")]
|
||||
return self
|
||||
.render_doc
|
||||
.start_frame_capture(self.shared.context.raw_context(), ptr::null_mut());
|
||||
return unsafe {
|
||||
self.render_doc
|
||||
.start_frame_capture(self.shared.context.raw_context(), ptr::null_mut())
|
||||
};
|
||||
#[allow(unreachable_code)]
|
||||
false
|
||||
}
|
||||
unsafe fn stop_capture(&self) {
|
||||
#[cfg(feature = "renderdoc")]
|
||||
self.render_doc
|
||||
.end_frame_capture(ptr::null_mut(), ptr::null_mut())
|
||||
unsafe {
|
||||
self.render_doc
|
||||
.end_frame_capture(ptr::null_mut(), ptr::null_mut())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+114
-94
@@ -94,11 +94,11 @@ unsafe extern "system" fn egl_debug_proc(
|
||||
EGL_DEBUG_MSG_INFO_KHR => log::Level::Info,
|
||||
_ => log::Level::Debug,
|
||||
};
|
||||
let command = ffi::CStr::from_ptr(command_raw).to_string_lossy();
|
||||
let command = unsafe { ffi::CStr::from_ptr(command_raw) }.to_string_lossy();
|
||||
let message = if message_raw.is_null() {
|
||||
"".into()
|
||||
} else {
|
||||
ffi::CStr::from_ptr(message_raw).to_string_lossy()
|
||||
unsafe { ffi::CStr::from_ptr(message_raw) }.to_string_lossy()
|
||||
};
|
||||
|
||||
log::log!(
|
||||
@@ -122,7 +122,7 @@ fn open_x_display() -> Option<(ptr::NonNull<raw::c_void>, libloading::Library)>
|
||||
|
||||
unsafe fn find_library(paths: &[&str]) -> Option<libloading::Library> {
|
||||
for path in paths {
|
||||
match libloading::Library::new(path) {
|
||||
match unsafe { libloading::Library::new(path) } {
|
||||
Ok(lib) => return Some(lib),
|
||||
_ => continue,
|
||||
};
|
||||
@@ -629,11 +629,15 @@ impl crate::Instance<super::Api> for Instance {
|
||||
|
||||
#[cfg(not(feature = "emscripten"))]
|
||||
let egl_result = if cfg!(windows) {
|
||||
egl::DynamicInstance::<egl::EGL1_4>::load_required_from_filename("libEGL.dll")
|
||||
unsafe {
|
||||
egl::DynamicInstance::<egl::EGL1_4>::load_required_from_filename("libEGL.dll")
|
||||
}
|
||||
} else if cfg!(any(target_os = "macos", target_os = "ios")) {
|
||||
egl::DynamicInstance::<egl::EGL1_4>::load_required_from_filename("libEGL.dylib")
|
||||
unsafe {
|
||||
egl::DynamicInstance::<egl::EGL1_4>::load_required_from_filename("libEGL.dylib")
|
||||
}
|
||||
} else {
|
||||
egl::DynamicInstance::<egl::EGL1_4>::load_required()
|
||||
unsafe { egl::DynamicInstance::<egl::EGL1_4>::load_required() }
|
||||
};
|
||||
let egl = match egl_result {
|
||||
Ok(egl) => Arc::new(egl),
|
||||
@@ -734,8 +738,10 @@ impl crate::Instance<super::Api> for Instance {
|
||||
&& client_ext_str.contains("EGL_KHR_debug")
|
||||
{
|
||||
log::info!("Enabling EGL debug output");
|
||||
let function: EglDebugMessageControlFun =
|
||||
std::mem::transmute(egl.get_proc_address("eglDebugMessageControlKHR").unwrap());
|
||||
let function: EglDebugMessageControlFun = {
|
||||
let addr = egl.get_proc_address("eglDebugMessageControlKHR").unwrap();
|
||||
unsafe { std::mem::transmute(addr) }
|
||||
};
|
||||
let attributes = [
|
||||
EGL_DEBUG_MSG_CRITICAL_KHR as egl::Attrib,
|
||||
1,
|
||||
@@ -747,7 +753,7 @@ impl crate::Instance<super::Api> for Instance {
|
||||
1,
|
||||
egl::ATTRIB_NONE,
|
||||
];
|
||||
(function)(Some(egl_debug_proc), attributes.as_ptr());
|
||||
unsafe { (function)(Some(egl_debug_proc), attributes.as_ptr()) };
|
||||
}
|
||||
|
||||
let inner = Inner::create(desc.flags, egl, display)?;
|
||||
@@ -786,7 +792,9 @@ impl crate::Instance<super::Api> for Instance {
|
||||
.get_config_attrib(inner.egl.display, inner.config, egl::NATIVE_VISUAL_ID)
|
||||
.unwrap();
|
||||
|
||||
let ret = ANativeWindow_setBuffersGeometry(handle.a_native_window, 0, 0, format);
|
||||
let ret = unsafe {
|
||||
ANativeWindow_setBuffersGeometry(handle.a_native_window, 0, 0, format)
|
||||
};
|
||||
|
||||
if ret != 0 {
|
||||
log::error!("Error returned from ANativeWindow_setBuffersGeometry");
|
||||
@@ -858,33 +866,36 @@ impl crate::Instance<super::Api> for Instance {
|
||||
let inner = self.inner.lock();
|
||||
inner.egl.make_current();
|
||||
|
||||
let gl = glow::Context::from_loader_function(|name| {
|
||||
inner
|
||||
.egl
|
||||
.instance
|
||||
.get_proc_address(name)
|
||||
.map_or(ptr::null(), |p| p as *const _)
|
||||
});
|
||||
let gl = unsafe {
|
||||
glow::Context::from_loader_function(|name| {
|
||||
inner
|
||||
.egl
|
||||
.instance
|
||||
.get_proc_address(name)
|
||||
.map_or(ptr::null(), |p| p as *const _)
|
||||
})
|
||||
};
|
||||
|
||||
if self.flags.contains(crate::InstanceFlags::DEBUG) && gl.supports_debug() {
|
||||
log::info!(
|
||||
"Max label length: {}",
|
||||
log::info!("Max label length: {}", unsafe {
|
||||
gl.get_parameter_i32(glow::MAX_LABEL_LENGTH)
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if self.flags.contains(crate::InstanceFlags::VALIDATION) && gl.supports_debug() {
|
||||
log::info!("Enabling GLES debug output");
|
||||
gl.enable(glow::DEBUG_OUTPUT);
|
||||
gl.debug_message_callback(gl_debug_message_callback);
|
||||
unsafe { gl.enable(glow::DEBUG_OUTPUT) };
|
||||
unsafe { gl.debug_message_callback(gl_debug_message_callback) };
|
||||
}
|
||||
|
||||
inner.egl.unmake_current();
|
||||
|
||||
super::Adapter::expose(AdapterContext {
|
||||
glow: Mutex::new(gl),
|
||||
egl: Some(inner.egl.clone()),
|
||||
})
|
||||
unsafe {
|
||||
super::Adapter::expose(AdapterContext {
|
||||
glow: Mutex::new(gl),
|
||||
egl: Some(inner.egl.clone()),
|
||||
})
|
||||
}
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
@@ -901,10 +912,13 @@ impl super::Adapter {
|
||||
pub unsafe fn new_external(
|
||||
fun: impl FnMut(&str) -> *const ffi::c_void,
|
||||
) -> Option<crate::ExposedAdapter<super::Api>> {
|
||||
Self::expose(AdapterContext {
|
||||
glow: Mutex::new(glow::Context::from_loader_function(fun)),
|
||||
egl: None,
|
||||
})
|
||||
let context = unsafe { glow::Context::from_loader_function(fun) };
|
||||
unsafe {
|
||||
Self::expose(AdapterContext {
|
||||
glow: Mutex::new(context),
|
||||
egl: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub fn adapter_context(&self) -> &AdapterContext {
|
||||
@@ -968,27 +982,29 @@ impl Surface {
|
||||
crate::SurfaceError::Lost
|
||||
})?;
|
||||
|
||||
gl.disable(glow::SCISSOR_TEST);
|
||||
gl.color_mask(true, true, true, true);
|
||||
unsafe { gl.disable(glow::SCISSOR_TEST) };
|
||||
unsafe { gl.color_mask(true, true, true, true) };
|
||||
|
||||
gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None);
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(sc.framebuffer));
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(sc.framebuffer)) };
|
||||
// Note the Y-flipping here. GL's presentation is not flipped,
|
||||
// but main rendering is. Therefore, we Y-flip the output positions
|
||||
// in the shader, and also this blit.
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
sc.extent.height as i32,
|
||||
sc.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
sc.extent.width as i32,
|
||||
sc.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
);
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None);
|
||||
unsafe {
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
sc.extent.height as i32,
|
||||
sc.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
sc.extent.width as i32,
|
||||
sc.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None) };
|
||||
|
||||
self.egl
|
||||
.instance
|
||||
@@ -1015,8 +1031,8 @@ impl Surface {
|
||||
let gl = &device.shared.context.lock();
|
||||
match self.swapchain.take() {
|
||||
Some(sc) => {
|
||||
gl.delete_renderbuffer(sc.renderbuffer);
|
||||
gl.delete_framebuffer(sc.framebuffer);
|
||||
unsafe { gl.delete_renderbuffer(sc.renderbuffer) };
|
||||
unsafe { gl.delete_framebuffer(sc.framebuffer) };
|
||||
Some((sc.surface, sc.wl_window))
|
||||
}
|
||||
None => None,
|
||||
@@ -1039,7 +1055,7 @@ impl crate::Surface<super::Api> for Surface {
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
use raw_window_handle::RawWindowHandle as Rwh;
|
||||
|
||||
let (surface, wl_window) = match self.unconfigure_impl(device) {
|
||||
let (surface, wl_window) = match unsafe { self.unconfigure_impl(device) } {
|
||||
Some(pair) => pair,
|
||||
None => {
|
||||
let mut wl_window = None;
|
||||
@@ -1064,9 +1080,9 @@ impl crate::Surface<super::Api> for Surface {
|
||||
(WindowKind::Wayland, Rwh::Wayland(handle)) => {
|
||||
let library = self.wsi.library.as_ref().unwrap();
|
||||
let wl_egl_window_create: libloading::Symbol<WlEglWindowCreateFun> =
|
||||
library.get(b"wl_egl_window_create").unwrap();
|
||||
let window = wl_egl_window_create(handle.surface, 640, 480) as *mut _
|
||||
as *mut std::ffi::c_void;
|
||||
unsafe { library.get(b"wl_egl_window_create") }.unwrap();
|
||||
let window = unsafe { wl_egl_window_create(handle.surface, 640, 480) }
|
||||
as *mut _ as *mut std::ffi::c_void;
|
||||
wl_window = Some(window);
|
||||
window
|
||||
}
|
||||
@@ -1143,12 +1159,14 @@ impl crate::Surface<super::Api> for Surface {
|
||||
&attributes_usize,
|
||||
)
|
||||
}
|
||||
_ => self.egl.instance.create_window_surface(
|
||||
self.egl.display,
|
||||
self.config,
|
||||
native_window_ptr,
|
||||
Some(&attributes),
|
||||
),
|
||||
_ => unsafe {
|
||||
self.egl.instance.create_window_surface(
|
||||
self.egl.display,
|
||||
self.config,
|
||||
native_window_ptr,
|
||||
Some(&attributes),
|
||||
)
|
||||
},
|
||||
};
|
||||
|
||||
match raw_result {
|
||||
@@ -1164,36 +1182,42 @@ impl crate::Surface<super::Api> for Surface {
|
||||
if let Some(window) = wl_window {
|
||||
let library = self.wsi.library.as_ref().unwrap();
|
||||
let wl_egl_window_resize: libloading::Symbol<WlEglWindowResizeFun> =
|
||||
library.get(b"wl_egl_window_resize").unwrap();
|
||||
wl_egl_window_resize(
|
||||
window,
|
||||
config.extent.width as i32,
|
||||
config.extent.height as i32,
|
||||
0,
|
||||
0,
|
||||
);
|
||||
unsafe { library.get(b"wl_egl_window_resize") }.unwrap();
|
||||
unsafe {
|
||||
wl_egl_window_resize(
|
||||
window,
|
||||
config.extent.width as i32,
|
||||
config.extent.height as i32,
|
||||
0,
|
||||
0,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
let format_desc = device.shared.describe_texture_format(config.format);
|
||||
let gl = &device.shared.context.lock();
|
||||
let renderbuffer = gl.create_renderbuffer().unwrap();
|
||||
gl.bind_renderbuffer(glow::RENDERBUFFER, Some(renderbuffer));
|
||||
gl.renderbuffer_storage(
|
||||
glow::RENDERBUFFER,
|
||||
format_desc.internal,
|
||||
config.extent.width as _,
|
||||
config.extent.height as _,
|
||||
);
|
||||
let framebuffer = gl.create_framebuffer().unwrap();
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer));
|
||||
gl.framebuffer_renderbuffer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::RENDERBUFFER,
|
||||
Some(renderbuffer),
|
||||
);
|
||||
gl.bind_renderbuffer(glow::RENDERBUFFER, None);
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None);
|
||||
let renderbuffer = unsafe { gl.create_renderbuffer() }.unwrap();
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, Some(renderbuffer)) };
|
||||
unsafe {
|
||||
gl.renderbuffer_storage(
|
||||
glow::RENDERBUFFER,
|
||||
format_desc.internal,
|
||||
config.extent.width as _,
|
||||
config.extent.height as _,
|
||||
)
|
||||
};
|
||||
let framebuffer = unsafe { gl.create_framebuffer() }.unwrap();
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer)) };
|
||||
unsafe {
|
||||
gl.framebuffer_renderbuffer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::RENDERBUFFER,
|
||||
Some(renderbuffer),
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, None) };
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None) };
|
||||
|
||||
self.swapchain = Some(Swapchain {
|
||||
surface,
|
||||
@@ -1210,20 +1234,16 @@ impl crate::Surface<super::Api> for Surface {
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&mut self, device: &super::Device) {
|
||||
if let Some((surface, wl_window)) = self.unconfigure_impl(device) {
|
||||
if let Some((surface, wl_window)) = unsafe { self.unconfigure_impl(device) } {
|
||||
self.egl
|
||||
.instance
|
||||
.destroy_surface(self.egl.display, surface)
|
||||
.unwrap();
|
||||
if let Some(window) = wl_window {
|
||||
let wl_egl_window_destroy: libloading::Symbol<WlEglWindowDestroyFun> = self
|
||||
.wsi
|
||||
.library
|
||||
.as_ref()
|
||||
.expect("unsupported window")
|
||||
.get(b"wl_egl_window_destroy")
|
||||
.unwrap();
|
||||
wl_egl_window_destroy(window);
|
||||
let library = self.wsi.library.as_ref().expect("unsupported window");
|
||||
let wl_egl_window_destroy: libloading::Symbol<WlEglWindowDestroyFun> =
|
||||
unsafe { library.get(b"wl_egl_window_destroy") }.unwrap();
|
||||
unsafe { wl_egl_window_destroy(window) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+646
-520
File diff suppressed because it is too large.
Load diff
+94
-86
@@ -101,7 +101,7 @@ impl crate::Instance<super::Api> for Instance {
|
||||
None => return Vec::new(),
|
||||
};
|
||||
|
||||
super::Adapter::expose(AdapterContext { glow_context: gl })
|
||||
unsafe { super::Adapter::expose(AdapterContext { glow_context: gl }) }
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
@@ -172,67 +172,67 @@ impl Surface {
|
||||
|
||||
if swapchain.format.describe().srgb {
|
||||
// Important to set the viewport since we don't know in what state the user left it.
|
||||
gl.viewport(
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as _,
|
||||
swapchain.extent.height as _,
|
||||
);
|
||||
gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None);
|
||||
gl.bind_sampler(0, None);
|
||||
gl.active_texture(glow::TEXTURE0);
|
||||
gl.bind_texture(glow::TEXTURE_2D, self.texture);
|
||||
gl.use_program(self.srgb_present_program);
|
||||
gl.disable(glow::DEPTH_TEST);
|
||||
gl.disable(glow::STENCIL_TEST);
|
||||
gl.disable(glow::SCISSOR_TEST);
|
||||
gl.disable(glow::BLEND);
|
||||
gl.disable(glow::CULL_FACE);
|
||||
gl.draw_buffers(&[glow::BACK]);
|
||||
gl.draw_arrays(glow::TRIANGLES, 0, 3);
|
||||
unsafe {
|
||||
gl.viewport(
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as _,
|
||||
swapchain.extent.height as _,
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
unsafe { gl.bind_sampler(0, None) };
|
||||
unsafe { gl.active_texture(glow::TEXTURE0) };
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, self.texture) };
|
||||
unsafe { gl.use_program(self.srgb_present_program) };
|
||||
unsafe { gl.disable(glow::DEPTH_TEST) };
|
||||
unsafe { gl.disable(glow::STENCIL_TEST) };
|
||||
unsafe { gl.disable(glow::SCISSOR_TEST) };
|
||||
unsafe { gl.disable(glow::BLEND) };
|
||||
unsafe { gl.disable(glow::CULL_FACE) };
|
||||
unsafe { gl.draw_buffers(&[glow::BACK]) };
|
||||
unsafe { gl.draw_arrays(glow::TRIANGLES, 0, 3) };
|
||||
} else {
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(swapchain.framebuffer));
|
||||
gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None);
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(swapchain.framebuffer)) };
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
// Note the Y-flipping here. GL's presentation is not flipped,
|
||||
// but main rendering is. Therefore, we Y-flip the output positions
|
||||
// in the shader, and also this blit.
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
swapchain.extent.height as i32,
|
||||
swapchain.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as i32,
|
||||
swapchain.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
);
|
||||
unsafe {
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
swapchain.extent.height as i32,
|
||||
swapchain.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as i32,
|
||||
swapchain.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn create_srgb_present_program(gl: &glow::Context) -> glow::Program {
|
||||
let program = gl
|
||||
.create_program()
|
||||
.expect("Could not create shader program");
|
||||
let vertex = gl
|
||||
.create_shader(glow::VERTEX_SHADER)
|
||||
.expect("Could not create shader");
|
||||
gl.shader_source(vertex, include_str!("./shaders/srgb_present.vert"));
|
||||
gl.compile_shader(vertex);
|
||||
let fragment = gl
|
||||
.create_shader(glow::FRAGMENT_SHADER)
|
||||
.expect("Could not create shader");
|
||||
gl.shader_source(fragment, include_str!("./shaders/srgb_present.frag"));
|
||||
gl.compile_shader(fragment);
|
||||
gl.attach_shader(program, vertex);
|
||||
gl.attach_shader(program, fragment);
|
||||
gl.link_program(program);
|
||||
gl.delete_shader(vertex);
|
||||
gl.delete_shader(fragment);
|
||||
gl.bind_texture(glow::TEXTURE_2D, None);
|
||||
let program = unsafe { gl.create_program() }.expect("Could not create shader program");
|
||||
let vertex =
|
||||
unsafe { gl.create_shader(glow::VERTEX_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(vertex, include_str!("./shaders/srgb_present.vert")) };
|
||||
unsafe { gl.compile_shader(vertex) };
|
||||
let fragment =
|
||||
unsafe { gl.create_shader(glow::FRAGMENT_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(fragment, include_str!("./shaders/srgb_present.frag")) };
|
||||
unsafe { gl.compile_shader(fragment) };
|
||||
unsafe { gl.attach_shader(program, vertex) };
|
||||
unsafe { gl.attach_shader(program, fragment) };
|
||||
unsafe { gl.link_program(program) };
|
||||
unsafe { gl.delete_shader(vertex) };
|
||||
unsafe { gl.delete_shader(fragment) };
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, None) };
|
||||
|
||||
program
|
||||
}
|
||||
@@ -253,49 +253,57 @@ impl crate::Surface<super::Api> for Surface {
|
||||
|
||||
if let Some(swapchain) = self.swapchain.take() {
|
||||
// delete all frame buffers already allocated
|
||||
gl.delete_framebuffer(swapchain.framebuffer);
|
||||
unsafe { gl.delete_framebuffer(swapchain.framebuffer) };
|
||||
}
|
||||
|
||||
if self.srgb_present_program.is_none() && config.format.describe().srgb {
|
||||
self.srgb_present_program = Some(Self::create_srgb_present_program(gl));
|
||||
self.srgb_present_program = Some(unsafe { Self::create_srgb_present_program(gl) });
|
||||
}
|
||||
|
||||
if let Some(texture) = self.texture.take() {
|
||||
gl.delete_texture(texture);
|
||||
unsafe { gl.delete_texture(texture) };
|
||||
}
|
||||
|
||||
self.texture = Some(gl.create_texture().unwrap());
|
||||
self.texture = Some(unsafe { gl.create_texture() }.unwrap());
|
||||
|
||||
let desc = device.shared.describe_texture_format(config.format);
|
||||
gl.bind_texture(glow::TEXTURE_2D, self.texture);
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MIN_FILTER,
|
||||
glow::NEAREST as _,
|
||||
);
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MAG_FILTER,
|
||||
glow::NEAREST as _,
|
||||
);
|
||||
gl.tex_storage_2d(
|
||||
glow::TEXTURE_2D,
|
||||
1,
|
||||
desc.internal,
|
||||
config.extent.width as i32,
|
||||
config.extent.height as i32,
|
||||
);
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, self.texture) };
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MIN_FILTER,
|
||||
glow::NEAREST as _,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MAG_FILTER,
|
||||
glow::NEAREST as _,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.tex_storage_2d(
|
||||
glow::TEXTURE_2D,
|
||||
1,
|
||||
desc.internal,
|
||||
config.extent.width as i32,
|
||||
config.extent.height as i32,
|
||||
)
|
||||
};
|
||||
|
||||
let framebuffer = gl.create_framebuffer().unwrap();
|
||||
gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer));
|
||||
gl.framebuffer_texture_2d(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::TEXTURE_2D,
|
||||
self.texture,
|
||||
0,
|
||||
);
|
||||
gl.bind_texture(glow::TEXTURE_2D, None);
|
||||
let framebuffer = unsafe { gl.create_framebuffer() }.unwrap();
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer)) };
|
||||
unsafe {
|
||||
gl.framebuffer_texture_2d(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::TEXTURE_2D,
|
||||
self.texture,
|
||||
0,
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, None) };
|
||||
|
||||
self.swapchain = Some(Swapchain {
|
||||
extent: config.extent,
|
||||
@@ -310,10 +318,10 @@ impl crate::Surface<super::Api> for Surface {
|
||||
unsafe fn unconfigure(&mut self, device: &super::Device) {
|
||||
let gl = device.shared.context.lock();
|
||||
if let Some(swapchain) = self.swapchain.take() {
|
||||
gl.delete_framebuffer(swapchain.framebuffer);
|
||||
unsafe { gl.delete_framebuffer(swapchain.framebuffer) };
|
||||
}
|
||||
if let Some(renderbuffer) = self.texture.take() {
|
||||
gl.delete_texture(renderbuffer);
|
||||
unsafe { gl.delete_texture(renderbuffer) };
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -42,6 +42,7 @@
|
||||
#![warn(
|
||||
trivial_casts,
|
||||
trivial_numeric_casts,
|
||||
unsafe_op_in_unsafe_fn,
|
||||
unused_extern_crates,
|
||||
unused_qualifications,
|
||||
// We don't match on a reference, unless required.
|
||||
|
||||
@@ -266,7 +266,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let ptr = buffer.raw.contents() as *mut u8;
|
||||
assert!(!ptr.is_null());
|
||||
Ok(crate::BufferMapping {
|
||||
ptr: ptr::NonNull::new(ptr.offset(range.start as isize)).unwrap(),
|
||||
ptr: ptr::NonNull::new(unsafe { ptr.offset(range.start as isize) }).unwrap(),
|
||||
is_coherent: true,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -88,19 +88,18 @@ impl crate::Instance<Api> for Instance {
|
||||
#[cfg(target_os = "ios")]
|
||||
raw_window_handle::RawWindowHandle::UiKit(handle) => {
|
||||
let _ = &self.managed_metal_layer_delegate;
|
||||
Ok(Surface::from_view(handle.ui_view, None))
|
||||
Ok(unsafe { Surface::from_view(handle.ui_view, None) })
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
raw_window_handle::RawWindowHandle::AppKit(handle) => Ok(Surface::from_view(
|
||||
handle.ns_view,
|
||||
Some(&self.managed_metal_layer_delegate),
|
||||
)),
|
||||
raw_window_handle::RawWindowHandle::AppKit(handle) => Ok(unsafe {
|
||||
Surface::from_view(handle.ns_view, Some(&self.managed_metal_layer_delegate))
|
||||
}),
|
||||
_ => Err(crate::InstanceError),
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn destroy_surface(&self, surface: Surface) {
|
||||
surface.dispose();
|
||||
unsafe { surface.dispose() };
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(&self) -> Vec<crate::ExposedAdapter<Api>> {
|
||||
|
||||
@@ -83,9 +83,11 @@ impl super::Surface {
|
||||
delegate: Option<&HalManagedMetalLayerDelegate>,
|
||||
) -> Self {
|
||||
let view = view as *mut Object;
|
||||
let render_layer =
|
||||
mem::transmute::<_, &mtl::MetalLayerRef>(Self::get_metal_layer(view, delegate))
|
||||
.to_owned();
|
||||
let render_layer = {
|
||||
let layer = unsafe { Self::get_metal_layer(view, delegate) };
|
||||
unsafe { mem::transmute::<_, &mtl::MetalLayerRef>(layer) }
|
||||
}
|
||||
.to_owned();
|
||||
let _: *mut c_void = msg_send![view, retain];
|
||||
Self::new(NonNull::new(view), render_layer)
|
||||
}
|
||||
@@ -136,7 +138,7 @@ impl super::Surface {
|
||||
{
|
||||
let () = msg_send![view, setLayer: new_layer];
|
||||
let () = msg_send![view, setWantsLayer: YES];
|
||||
let () = msg_send![new_layer, setContentsGravity: kCAGravityTopLeft];
|
||||
let () = msg_send![new_layer, setContentsGravity: unsafe { kCAGravityTopLeft }];
|
||||
let window: *mut Object = msg_send![view, window];
|
||||
if !window.is_null() {
|
||||
let scale_factor: CGFloat = msg_send![window, backingScaleFactor];
|
||||
|
||||
@@ -1110,9 +1110,11 @@ impl super::Adapter {
|
||||
) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
|
||||
let mem_properties = {
|
||||
profiling::scope!("vkGetPhysicalDeviceMemoryProperties");
|
||||
self.instance
|
||||
.raw
|
||||
.get_physical_device_memory_properties(self.raw)
|
||||
unsafe {
|
||||
self.instance
|
||||
.raw
|
||||
.get_physical_device_memory_properties(self.raw)
|
||||
}
|
||||
};
|
||||
let memory_types =
|
||||
&mem_properties.memory_types[..mem_properties.memory_type_count as usize];
|
||||
@@ -1219,7 +1221,7 @@ impl super::Adapter {
|
||||
|
||||
let raw_queue = {
|
||||
profiling::scope!("vkGetDeviceQueue");
|
||||
raw_device.get_device_queue(family_index, queue_index)
|
||||
unsafe { raw_device.get_device_queue(family_index, queue_index) }
|
||||
};
|
||||
|
||||
let shared = Arc::new(super::DeviceShared {
|
||||
@@ -1246,9 +1248,11 @@ impl super::Adapter {
|
||||
});
|
||||
let mut relay_semaphores = [vk::Semaphore::null(); 2];
|
||||
for sem in relay_semaphores.iter_mut() {
|
||||
*sem = shared
|
||||
.raw
|
||||
.create_semaphore(&vk::SemaphoreCreateInfo::builder(), None)?;
|
||||
unsafe {
|
||||
*sem = shared
|
||||
.raw
|
||||
.create_semaphore(&vk::SemaphoreCreateInfo::builder(), None)?
|
||||
};
|
||||
}
|
||||
let queue = super::Queue {
|
||||
raw: raw_queue,
|
||||
@@ -1344,18 +1348,20 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
.build();
|
||||
let raw_device = {
|
||||
profiling::scope!("vkCreateDevice");
|
||||
self.instance.raw.create_device(self.raw, &info, None)?
|
||||
unsafe { self.instance.raw.create_device(self.raw, &info, None)? }
|
||||
};
|
||||
|
||||
self.device_from_raw(
|
||||
raw_device,
|
||||
true,
|
||||
&enabled_extensions,
|
||||
features,
|
||||
uab_types,
|
||||
family_info.queue_family_index,
|
||||
0,
|
||||
)
|
||||
unsafe {
|
||||
self.device_from_raw(
|
||||
raw_device,
|
||||
true,
|
||||
&enabled_extensions,
|
||||
features,
|
||||
uab_types,
|
||||
family_info.queue_family_index,
|
||||
0,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn texture_format_capabilities(
|
||||
@@ -1365,10 +1371,11 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
use crate::TextureFormatCapabilities as Tfc;
|
||||
|
||||
let vk_format = self.private_caps.map_texture_format(format);
|
||||
let properties = self
|
||||
.instance
|
||||
.raw
|
||||
.get_physical_device_format_properties(self.raw, vk_format);
|
||||
let properties = unsafe {
|
||||
self.instance
|
||||
.raw
|
||||
.get_physical_device_format_properties(self.raw, vk_format)
|
||||
};
|
||||
let features = properties.optimal_tiling_features;
|
||||
|
||||
let mut flags = Tfc::empty();
|
||||
@@ -1466,11 +1473,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
let queue_family_index = 0; //TODO
|
||||
{
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceSupportKHR");
|
||||
match surface.functor.get_physical_device_surface_support(
|
||||
self.raw,
|
||||
queue_family_index,
|
||||
surface.raw,
|
||||
) {
|
||||
match unsafe {
|
||||
surface.functor.get_physical_device_surface_support(
|
||||
self.raw,
|
||||
queue_family_index,
|
||||
surface.raw,
|
||||
)
|
||||
} {
|
||||
Ok(true) => (),
|
||||
Ok(false) => return None,
|
||||
Err(e) => {
|
||||
@@ -1482,10 +1491,11 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
|
||||
let caps = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
|
||||
match surface
|
||||
.functor
|
||||
.get_physical_device_surface_capabilities(self.raw, surface.raw)
|
||||
{
|
||||
match unsafe {
|
||||
surface
|
||||
.functor
|
||||
.get_physical_device_surface_capabilities(self.raw, surface.raw)
|
||||
} {
|
||||
Ok(caps) => caps,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_capabilities: {}", e);
|
||||
@@ -1527,10 +1537,11 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
|
||||
let raw_present_modes = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfacePresentModesKHR");
|
||||
match surface
|
||||
.functor
|
||||
.get_physical_device_surface_present_modes(self.raw, surface.raw)
|
||||
{
|
||||
match unsafe {
|
||||
surface
|
||||
.functor
|
||||
.get_physical_device_surface_present_modes(self.raw, surface.raw)
|
||||
} {
|
||||
Ok(present_modes) => present_modes,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_present_modes: {}", e);
|
||||
@@ -1541,10 +1552,11 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
|
||||
let raw_surface_formats = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceFormatsKHR");
|
||||
match surface
|
||||
.functor
|
||||
.get_physical_device_surface_formats(self.raw, surface.raw)
|
||||
{
|
||||
match unsafe {
|
||||
surface
|
||||
.functor
|
||||
.get_physical_device_surface_formats(self.raw, surface.raw)
|
||||
} {
|
||||
Ok(formats) => formats,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_formats: {}", e);
|
||||
|
||||
+279
-214
@@ -50,18 +50,20 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
.command_pool(self.raw)
|
||||
.command_buffer_count(ALLOCATION_GRANULARITY)
|
||||
.build();
|
||||
let cmd_buf_vec = self.device.raw.allocate_command_buffers(&vk_info)?;
|
||||
let cmd_buf_vec = unsafe { self.device.raw.allocate_command_buffers(&vk_info)? };
|
||||
self.free.extend(cmd_buf_vec);
|
||||
}
|
||||
let raw = self.free.pop().unwrap();
|
||||
|
||||
// Set the name unconditionally, since there might be a
|
||||
// previous name assigned to this.
|
||||
self.device.set_object_name(
|
||||
vk::ObjectType::COMMAND_BUFFER,
|
||||
raw,
|
||||
label.unwrap_or_default(),
|
||||
);
|
||||
unsafe {
|
||||
self.device.set_object_name(
|
||||
vk::ObjectType::COMMAND_BUFFER,
|
||||
raw,
|
||||
label.unwrap_or_default(),
|
||||
)
|
||||
};
|
||||
|
||||
// Reset this in case the last renderpass was never ended.
|
||||
self.rpass_debug_marker_active = false;
|
||||
@@ -69,7 +71,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let vk_info = vk::CommandBufferBeginInfo::builder()
|
||||
.flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT)
|
||||
.build();
|
||||
self.device.raw.begin_command_buffer(raw, &vk_info)?;
|
||||
unsafe { self.device.raw.begin_command_buffer(raw, &vk_info) }?;
|
||||
self.active = raw;
|
||||
|
||||
Ok(())
|
||||
@@ -78,7 +80,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
unsafe fn end_encoding(&mut self) -> Result<super::CommandBuffer, crate::DeviceError> {
|
||||
let raw = self.active;
|
||||
self.active = vk::CommandBuffer::null();
|
||||
self.device.raw.end_command_buffer(raw)?;
|
||||
unsafe { self.device.raw.end_command_buffer(raw) }?;
|
||||
Ok(super::CommandBuffer { raw })
|
||||
}
|
||||
|
||||
@@ -95,10 +97,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
self.free
|
||||
.extend(cmd_bufs.into_iter().map(|cmd_buf| cmd_buf.raw));
|
||||
self.free.append(&mut self.discarded);
|
||||
let _ = self
|
||||
.device
|
||||
.raw
|
||||
.reset_command_pool(self.raw, vk::CommandPoolResetFlags::default());
|
||||
let _ = unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.reset_command_pool(self.raw, vk::CommandPoolResetFlags::default())
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn transition_buffers<'a, T>(&mut self, barriers: T)
|
||||
@@ -128,15 +131,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
}
|
||||
|
||||
if !vk_barriers.is_empty() {
|
||||
self.device.raw.cmd_pipeline_barrier(
|
||||
self.active,
|
||||
src_stages,
|
||||
dst_stages,
|
||||
vk::DependencyFlags::empty(),
|
||||
&[],
|
||||
vk_barriers,
|
||||
&[],
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_pipeline_barrier(
|
||||
self.active,
|
||||
src_stages,
|
||||
dst_stages,
|
||||
vk::DependencyFlags::empty(),
|
||||
&[],
|
||||
vk_barriers,
|
||||
&[],
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,26 +176,30 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
}
|
||||
|
||||
if !vk_barriers.is_empty() {
|
||||
self.device.raw.cmd_pipeline_barrier(
|
||||
self.active,
|
||||
src_stages,
|
||||
dst_stages,
|
||||
vk::DependencyFlags::empty(),
|
||||
&[],
|
||||
&[],
|
||||
vk_barriers,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_pipeline_barrier(
|
||||
self.active,
|
||||
src_stages,
|
||||
dst_stages,
|
||||
vk::DependencyFlags::empty(),
|
||||
&[],
|
||||
&[],
|
||||
vk_barriers,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn clear_buffer(&mut self, buffer: &super::Buffer, range: crate::MemoryRange) {
|
||||
self.device.raw.cmd_fill_buffer(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
0,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_fill_buffer(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
0,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_buffer<T>(
|
||||
@@ -207,12 +216,14 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
size: r.size.get(),
|
||||
});
|
||||
|
||||
self.device.raw.cmd_copy_buffer(
|
||||
self.active,
|
||||
src.raw,
|
||||
dst.raw,
|
||||
&smallvec::SmallVec::<[vk::BufferCopy; 32]>::from_iter(vk_regions_iter),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_copy_buffer(
|
||||
self.active,
|
||||
src.raw,
|
||||
dst.raw,
|
||||
&smallvec::SmallVec::<[vk::BufferCopy; 32]>::from_iter(vk_regions_iter),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_texture<T>(
|
||||
@@ -244,14 +255,16 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
}
|
||||
});
|
||||
|
||||
self.device.raw.cmd_copy_image(
|
||||
self.active,
|
||||
src.raw,
|
||||
src_layout,
|
||||
dst.raw,
|
||||
DST_IMAGE_LAYOUT,
|
||||
&smallvec::SmallVec::<[vk::ImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_copy_image(
|
||||
self.active,
|
||||
src.raw,
|
||||
src_layout,
|
||||
dst.raw,
|
||||
DST_IMAGE_LAYOUT,
|
||||
&smallvec::SmallVec::<[vk::ImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_texture<T>(
|
||||
@@ -264,13 +277,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
{
|
||||
let vk_regions_iter = dst.map_buffer_copies(regions);
|
||||
|
||||
self.device.raw.cmd_copy_buffer_to_image(
|
||||
self.active,
|
||||
src.raw,
|
||||
dst.raw,
|
||||
DST_IMAGE_LAYOUT,
|
||||
&smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_copy_buffer_to_image(
|
||||
self.active,
|
||||
src.raw,
|
||||
dst.raw,
|
||||
DST_IMAGE_LAYOUT,
|
||||
&smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_buffer<T>(
|
||||
@@ -285,41 +300,49 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let src_layout = conv::derive_image_layout(src_usage, src.aspects);
|
||||
let vk_regions_iter = src.map_buffer_copies(regions);
|
||||
|
||||
self.device.raw.cmd_copy_image_to_buffer(
|
||||
self.active,
|
||||
src.raw,
|
||||
src_layout,
|
||||
dst.raw,
|
||||
&smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_copy_image_to_buffer(
|
||||
self.active,
|
||||
src.raw,
|
||||
src_layout,
|
||||
dst.raw,
|
||||
&smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn begin_query(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.device.raw.cmd_begin_query(
|
||||
self.active,
|
||||
set.raw,
|
||||
index,
|
||||
vk::QueryControlFlags::empty(),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_begin_query(
|
||||
self.active,
|
||||
set.raw,
|
||||
index,
|
||||
vk::QueryControlFlags::empty(),
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn end_query(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.device.raw.cmd_end_query(self.active, set.raw, index);
|
||||
unsafe { self.device.raw.cmd_end_query(self.active, set.raw, index) };
|
||||
}
|
||||
unsafe fn write_timestamp(&mut self, set: &super::QuerySet, index: u32) {
|
||||
self.device.raw.cmd_write_timestamp(
|
||||
self.active,
|
||||
vk::PipelineStageFlags::BOTTOM_OF_PIPE,
|
||||
set.raw,
|
||||
index,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_write_timestamp(
|
||||
self.active,
|
||||
vk::PipelineStageFlags::BOTTOM_OF_PIPE,
|
||||
set.raw,
|
||||
index,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn reset_queries(&mut self, set: &super::QuerySet, range: Range<u32>) {
|
||||
self.device.raw.cmd_reset_query_pool(
|
||||
self.active,
|
||||
set.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_reset_query_pool(
|
||||
self.active,
|
||||
set.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn copy_query_results(
|
||||
&mut self,
|
||||
@@ -329,16 +352,18 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
stride: wgt::BufferSize,
|
||||
) {
|
||||
self.device.raw.cmd_copy_query_pool_results(
|
||||
self.active,
|
||||
set.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
buffer.raw,
|
||||
offset,
|
||||
stride.get(),
|
||||
vk::QueryResultFlags::TYPE_64 | vk::QueryResultFlags::WAIT,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_copy_query_pool_results(
|
||||
self.active,
|
||||
set.raw,
|
||||
range.start,
|
||||
range.end - range.start,
|
||||
buffer.raw,
|
||||
offset,
|
||||
stride.get(),
|
||||
vk::QueryResultFlags::TYPE_64 | vk::QueryResultFlags::WAIT,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
// render
|
||||
@@ -358,7 +383,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
for cat in desc.color_attachments {
|
||||
if let Some(cat) = cat.as_ref() {
|
||||
vk_clear_values.push(vk::ClearValue {
|
||||
color: cat.make_vk_clear_color(),
|
||||
color: unsafe { cat.make_vk_clear_color() },
|
||||
});
|
||||
vk_image_views.push(cat.target.view.raw);
|
||||
let color = super::ColorAttachmentKey {
|
||||
@@ -371,7 +396,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
rp_key.colors.push(Some(color));
|
||||
fb_key.attachments.push(cat.target.view.attachment.clone());
|
||||
if let Some(ref at) = cat.resolve_target {
|
||||
vk_clear_values.push(mem::zeroed());
|
||||
vk_clear_values.push(unsafe { mem::zeroed() });
|
||||
vk_image_views.push(at.view.raw);
|
||||
fb_key.attachments.push(at.view.attachment.clone());
|
||||
}
|
||||
@@ -456,27 +481,33 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
}
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.begin_debug_marker(label);
|
||||
unsafe { self.begin_debug_marker(label) };
|
||||
self.rpass_debug_marker_active = true;
|
||||
}
|
||||
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_viewport(self.active, 0, &vk_viewports);
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_scissor(self.active, 0, &[render_area]);
|
||||
self.device
|
||||
.raw
|
||||
.cmd_begin_render_pass(self.active, &vk_info, vk::SubpassContents::INLINE);
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_viewport(self.active, 0, &vk_viewports);
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_scissor(self.active, 0, &[render_area]);
|
||||
self.device.raw.cmd_begin_render_pass(
|
||||
self.active,
|
||||
&vk_info,
|
||||
vk::SubpassContents::INLINE,
|
||||
);
|
||||
};
|
||||
|
||||
self.bind_point = vk::PipelineBindPoint::GRAPHICS;
|
||||
}
|
||||
unsafe fn end_render_pass(&mut self) {
|
||||
self.device.raw.cmd_end_render_pass(self.active);
|
||||
if self.rpass_debug_marker_active {
|
||||
self.end_debug_marker();
|
||||
self.rpass_debug_marker_active = false;
|
||||
unsafe {
|
||||
self.device.raw.cmd_end_render_pass(self.active);
|
||||
if self.rpass_debug_marker_active {
|
||||
self.end_debug_marker();
|
||||
self.rpass_debug_marker_active = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -488,14 +519,16 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
dynamic_offsets: &[wgt::DynamicOffset],
|
||||
) {
|
||||
let sets = [*group.set.raw()];
|
||||
self.device.raw.cmd_bind_descriptor_sets(
|
||||
self.active,
|
||||
self.bind_point,
|
||||
layout.raw,
|
||||
index,
|
||||
&sets,
|
||||
dynamic_offsets,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_bind_descriptor_sets(
|
||||
self.active,
|
||||
self.bind_point,
|
||||
layout.raw,
|
||||
index,
|
||||
&sets,
|
||||
dynamic_offsets,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn set_push_constants(
|
||||
&mut self,
|
||||
@@ -504,41 +537,45 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: u32,
|
||||
data: &[u32],
|
||||
) {
|
||||
self.device.raw.cmd_push_constants(
|
||||
self.active,
|
||||
layout.raw,
|
||||
conv::map_shader_stage(stages),
|
||||
offset,
|
||||
slice::from_raw_parts(data.as_ptr() as _, data.len() * 4),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_push_constants(
|
||||
self.active,
|
||||
layout.raw,
|
||||
conv::map_shader_stage(stages),
|
||||
offset,
|
||||
slice::from_raw_parts(data.as_ptr() as _, data.len() * 4),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn insert_debug_marker(&mut self, label: &str) {
|
||||
if let Some(ext) = self.device.debug_messenger() {
|
||||
let cstr = self.temp.make_c_str(label);
|
||||
let vk_label = vk::DebugUtilsLabelEXT::builder().label_name(cstr).build();
|
||||
ext.cmd_insert_debug_utils_label(self.active, &vk_label);
|
||||
unsafe { ext.cmd_insert_debug_utils_label(self.active, &vk_label) };
|
||||
}
|
||||
}
|
||||
unsafe fn begin_debug_marker(&mut self, group_label: &str) {
|
||||
if let Some(ext) = self.device.debug_messenger() {
|
||||
let cstr = self.temp.make_c_str(group_label);
|
||||
let vk_label = vk::DebugUtilsLabelEXT::builder().label_name(cstr).build();
|
||||
ext.cmd_begin_debug_utils_label(self.active, &vk_label);
|
||||
unsafe { ext.cmd_begin_debug_utils_label(self.active, &vk_label) };
|
||||
}
|
||||
}
|
||||
unsafe fn end_debug_marker(&mut self) {
|
||||
if let Some(ext) = self.device.debug_messenger() {
|
||||
ext.cmd_end_debug_utils_label(self.active);
|
||||
unsafe { ext.cmd_end_debug_utils_label(self.active) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_render_pipeline(&mut self, pipeline: &super::RenderPipeline) {
|
||||
self.device.raw.cmd_bind_pipeline(
|
||||
self.active,
|
||||
vk::PipelineBindPoint::GRAPHICS,
|
||||
pipeline.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_bind_pipeline(
|
||||
self.active,
|
||||
vk::PipelineBindPoint::GRAPHICS,
|
||||
pipeline.raw,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn set_index_buffer<'a>(
|
||||
@@ -546,12 +583,14 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
binding: crate::BufferBinding<'a, super::Api>,
|
||||
format: wgt::IndexFormat,
|
||||
) {
|
||||
self.device.raw.cmd_bind_index_buffer(
|
||||
self.active,
|
||||
binding.buffer.raw,
|
||||
binding.offset,
|
||||
conv::map_index_format(format),
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_bind_index_buffer(
|
||||
self.active,
|
||||
binding.buffer.raw,
|
||||
binding.offset,
|
||||
conv::map_index_format(format),
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn set_vertex_buffer<'a>(
|
||||
&mut self,
|
||||
@@ -560,9 +599,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
) {
|
||||
let vk_buffers = [binding.buffer.raw];
|
||||
let vk_offsets = [binding.offset];
|
||||
self.device
|
||||
.raw
|
||||
.cmd_bind_vertex_buffers(self.active, index, &vk_buffers, &vk_offsets);
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_bind_vertex_buffers(self.active, index, &vk_buffers, &vk_offsets)
|
||||
};
|
||||
}
|
||||
unsafe fn set_viewport(&mut self, rect: &crate::Rect<f32>, depth_range: Range<f32>) {
|
||||
let vk_viewports = [vk::Viewport {
|
||||
@@ -577,9 +618,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
min_depth: depth_range.start,
|
||||
max_depth: depth_range.end,
|
||||
}];
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_viewport(self.active, 0, &vk_viewports);
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_viewport(self.active, 0, &vk_viewports)
|
||||
};
|
||||
}
|
||||
unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {
|
||||
let vk_scissors = [vk::Rect2D {
|
||||
@@ -592,19 +635,23 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
height: rect.h,
|
||||
},
|
||||
}];
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_scissor(self.active, 0, &vk_scissors);
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_set_scissor(self.active, 0, &vk_scissors)
|
||||
};
|
||||
}
|
||||
unsafe fn set_stencil_reference(&mut self, value: u32) {
|
||||
self.device.raw.cmd_set_stencil_reference(
|
||||
self.active,
|
||||
vk::StencilFaceFlags::FRONT_AND_BACK,
|
||||
value,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_set_stencil_reference(
|
||||
self.active,
|
||||
vk::StencilFaceFlags::FRONT_AND_BACK,
|
||||
value,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) {
|
||||
self.device.raw.cmd_set_blend_constants(self.active, color);
|
||||
unsafe { self.device.raw.cmd_set_blend_constants(self.active, color) };
|
||||
}
|
||||
|
||||
unsafe fn draw(
|
||||
@@ -614,13 +661,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
start_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
self.device.raw.cmd_draw(
|
||||
self.active,
|
||||
vertex_count,
|
||||
instance_count,
|
||||
start_vertex,
|
||||
start_instance,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_draw(
|
||||
self.active,
|
||||
vertex_count,
|
||||
instance_count,
|
||||
start_vertex,
|
||||
start_instance,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indexed(
|
||||
&mut self,
|
||||
@@ -630,14 +679,16 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
start_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
self.device.raw.cmd_draw_indexed(
|
||||
self.active,
|
||||
index_count,
|
||||
instance_count,
|
||||
start_index,
|
||||
base_vertex,
|
||||
start_instance,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_draw_indexed(
|
||||
self.active,
|
||||
index_count,
|
||||
instance_count,
|
||||
start_index,
|
||||
base_vertex,
|
||||
start_instance,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indirect(
|
||||
&mut self,
|
||||
@@ -645,13 +696,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
self.device.raw.cmd_draw_indirect(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
draw_count,
|
||||
mem::size_of::<wgt::DrawIndirectArgs>() as u32,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_draw_indirect(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
draw_count,
|
||||
mem::size_of::<wgt::DrawIndirectArgs>() as u32,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indexed_indirect(
|
||||
&mut self,
|
||||
@@ -659,13 +712,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
self.device.raw.cmd_draw_indexed_indirect(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
draw_count,
|
||||
mem::size_of::<wgt::DrawIndexedIndirectArgs>() as u32,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_draw_indexed_indirect(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
draw_count,
|
||||
mem::size_of::<wgt::DrawIndexedIndirectArgs>() as u32,
|
||||
)
|
||||
};
|
||||
}
|
||||
unsafe fn draw_indirect_count(
|
||||
&mut self,
|
||||
@@ -678,15 +733,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let stride = mem::size_of::<wgt::DrawIndirectArgs>() as u32;
|
||||
match self.device.extension_fns.draw_indirect_count {
|
||||
Some(ref t) => {
|
||||
t.cmd_draw_indirect_count(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
count_buffer.raw,
|
||||
count_offset,
|
||||
max_count,
|
||||
stride,
|
||||
);
|
||||
unsafe {
|
||||
t.cmd_draw_indirect_count(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
count_buffer.raw,
|
||||
count_offset,
|
||||
max_count,
|
||||
stride,
|
||||
)
|
||||
};
|
||||
}
|
||||
None => panic!("Feature `DRAW_INDIRECT_COUNT` not enabled"),
|
||||
}
|
||||
@@ -702,15 +759,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let stride = mem::size_of::<wgt::DrawIndexedIndirectArgs>() as u32;
|
||||
match self.device.extension_fns.draw_indirect_count {
|
||||
Some(ref t) => {
|
||||
t.cmd_draw_indexed_indirect_count(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
count_buffer.raw,
|
||||
count_offset,
|
||||
max_count,
|
||||
stride,
|
||||
);
|
||||
unsafe {
|
||||
t.cmd_draw_indexed_indirect_count(
|
||||
self.active,
|
||||
buffer.raw,
|
||||
offset,
|
||||
count_buffer.raw,
|
||||
count_offset,
|
||||
max_count,
|
||||
stride,
|
||||
)
|
||||
};
|
||||
}
|
||||
None => panic!("Feature `DRAW_INDIRECT_COUNT` not enabled"),
|
||||
}
|
||||
@@ -721,34 +780,40 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
unsafe fn begin_compute_pass(&mut self, desc: &crate::ComputePassDescriptor) {
|
||||
self.bind_point = vk::PipelineBindPoint::COMPUTE;
|
||||
if let Some(label) = desc.label {
|
||||
self.begin_debug_marker(label);
|
||||
unsafe { self.begin_debug_marker(label) };
|
||||
self.rpass_debug_marker_active = true;
|
||||
}
|
||||
}
|
||||
unsafe fn end_compute_pass(&mut self) {
|
||||
if self.rpass_debug_marker_active {
|
||||
self.end_debug_marker();
|
||||
unsafe { self.end_debug_marker() };
|
||||
self.rpass_debug_marker_active = false
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_compute_pipeline(&mut self, pipeline: &super::ComputePipeline) {
|
||||
self.device.raw.cmd_bind_pipeline(
|
||||
self.active,
|
||||
vk::PipelineBindPoint::COMPUTE,
|
||||
pipeline.raw,
|
||||
);
|
||||
unsafe {
|
||||
self.device.raw.cmd_bind_pipeline(
|
||||
self.active,
|
||||
vk::PipelineBindPoint::COMPUTE,
|
||||
pipeline.raw,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn dispatch(&mut self, count: [u32; 3]) {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_dispatch(self.active, count[0], count[1], count[2]);
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_dispatch(self.active, count[0], count[1], count[2])
|
||||
};
|
||||
}
|
||||
unsafe fn dispatch_indirect(&mut self, buffer: &super::Buffer, offset: wgt::BufferAddress) {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_dispatch_indirect(self.active, buffer.raw, offset)
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.cmd_dispatch_indirect(self.active, buffer.raw, offset)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+250
-189
@@ -49,13 +49,17 @@ impl super::DeviceShared {
|
||||
&buffer_vec
|
||||
};
|
||||
|
||||
let _result = extension.debug_utils_set_object_name(
|
||||
self.raw.handle(),
|
||||
&vk::DebugUtilsObjectNameInfoEXT::builder()
|
||||
.object_type(object_type)
|
||||
.object_handle(object.as_raw())
|
||||
.object_name(CStr::from_bytes_with_nul_unchecked(name_bytes)),
|
||||
);
|
||||
let name = unsafe { CStr::from_bytes_with_nul_unchecked(name_bytes) };
|
||||
|
||||
let _result = unsafe {
|
||||
extension.debug_utils_set_object_name(
|
||||
self.raw.handle(),
|
||||
&vk::DebugUtilsObjectNameInfoEXT::builder()
|
||||
.object_type(object_type)
|
||||
.object_handle(object.as_raw())
|
||||
.object_name(name),
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
pub fn make_render_pass(
|
||||
@@ -278,13 +282,13 @@ impl super::DeviceShared {
|
||||
|
||||
unsafe fn free_resources(&self) {
|
||||
for &raw in self.render_passes.lock().values() {
|
||||
self.raw.destroy_render_pass(raw, None);
|
||||
unsafe { self.raw.destroy_render_pass(raw, None) };
|
||||
}
|
||||
for &raw in self.framebuffers.lock().values() {
|
||||
self.raw.destroy_framebuffer(raw, None);
|
||||
unsafe { self.raw.destroy_framebuffer(raw, None) };
|
||||
}
|
||||
if self.handle_is_owned {
|
||||
self.raw.destroy_device(None);
|
||||
unsafe { self.raw.destroy_device(None) };
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -308,7 +312,7 @@ impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
|
||||
info = info.push_next(&mut info_flags);
|
||||
}
|
||||
|
||||
match self.raw.allocate_memory(&info, None) {
|
||||
match unsafe { self.raw.allocate_memory(&info, None) } {
|
||||
Ok(memory) => Ok(memory),
|
||||
Err(vk::Result::ERROR_OUT_OF_DEVICE_MEMORY) => {
|
||||
Err(gpu_alloc::OutOfMemory::OutOfDeviceMemory)
|
||||
@@ -322,7 +326,7 @@ impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
|
||||
}
|
||||
|
||||
unsafe fn deallocate_memory(&self, memory: vk::DeviceMemory) {
|
||||
self.raw.free_memory(memory, None);
|
||||
unsafe { self.raw.free_memory(memory, None) };
|
||||
}
|
||||
|
||||
unsafe fn map_memory(
|
||||
@@ -331,10 +335,10 @@ impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
|
||||
offset: u64,
|
||||
size: u64,
|
||||
) -> Result<ptr::NonNull<u8>, gpu_alloc::DeviceMapError> {
|
||||
match self
|
||||
.raw
|
||||
.map_memory(*memory, offset, size, vk::MemoryMapFlags::empty())
|
||||
{
|
||||
match unsafe {
|
||||
self.raw
|
||||
.map_memory(*memory, offset, size, vk::MemoryMapFlags::empty())
|
||||
} {
|
||||
Ok(ptr) => Ok(ptr::NonNull::new(ptr as *mut u8)
|
||||
.expect("Pointer to memory mapping must not be null")),
|
||||
Err(vk::Result::ERROR_OUT_OF_DEVICE_MEMORY) => {
|
||||
@@ -349,7 +353,7 @@ impl gpu_alloc::MemoryDevice<vk::DeviceMemory> for super::DeviceShared {
|
||||
}
|
||||
|
||||
unsafe fn unmap_memory(&self, memory: &mut vk::DeviceMemory) {
|
||||
self.raw.unmap_memory(*memory);
|
||||
unsafe { self.raw.unmap_memory(*memory) };
|
||||
}
|
||||
|
||||
unsafe fn invalidate_memory_ranges(
|
||||
@@ -433,7 +437,7 @@ impl
|
||||
.pool_sizes(&filtered_counts)
|
||||
.build();
|
||||
|
||||
match self.raw.create_descriptor_pool(&vk_info, None) {
|
||||
match unsafe { self.raw.create_descriptor_pool(&vk_info, None) } {
|
||||
Ok(pool) => Ok(pool),
|
||||
Err(vk::Result::ERROR_OUT_OF_HOST_MEMORY) => {
|
||||
Err(gpu_descriptor::CreatePoolError::OutOfHostMemory)
|
||||
@@ -452,7 +456,7 @@ impl
|
||||
}
|
||||
|
||||
unsafe fn destroy_descriptor_pool(&self, pool: vk::DescriptorPool) {
|
||||
self.raw.destroy_descriptor_pool(pool, None)
|
||||
unsafe { self.raw.destroy_descriptor_pool(pool, None) }
|
||||
}
|
||||
|
||||
unsafe fn alloc_descriptor_sets<'a>(
|
||||
@@ -461,16 +465,18 @@ impl
|
||||
layouts: impl ExactSizeIterator<Item = &'a vk::DescriptorSetLayout>,
|
||||
sets: &mut impl Extend<vk::DescriptorSet>,
|
||||
) -> Result<(), gpu_descriptor::DeviceAllocationError> {
|
||||
let result = self.raw.allocate_descriptor_sets(
|
||||
&vk::DescriptorSetAllocateInfo::builder()
|
||||
.descriptor_pool(*pool)
|
||||
.set_layouts(
|
||||
&smallvec::SmallVec::<[vk::DescriptorSetLayout; 32]>::from_iter(
|
||||
layouts.cloned(),
|
||||
),
|
||||
)
|
||||
.build(),
|
||||
);
|
||||
let result = unsafe {
|
||||
self.raw.allocate_descriptor_sets(
|
||||
&vk::DescriptorSetAllocateInfo::builder()
|
||||
.descriptor_pool(*pool)
|
||||
.set_layouts(
|
||||
&smallvec::SmallVec::<[vk::DescriptorSetLayout; 32]>::from_iter(
|
||||
layouts.cloned(),
|
||||
),
|
||||
)
|
||||
.build(),
|
||||
)
|
||||
};
|
||||
|
||||
match result {
|
||||
Ok(vk_sets) => {
|
||||
@@ -499,10 +505,12 @@ impl
|
||||
pool: &mut vk::DescriptorPool,
|
||||
sets: impl Iterator<Item = vk::DescriptorSet>,
|
||||
) {
|
||||
let result = self.raw.free_descriptor_sets(
|
||||
*pool,
|
||||
&smallvec::SmallVec::<[vk::DescriptorSet; 32]>::from_iter(sets),
|
||||
);
|
||||
let result = unsafe {
|
||||
self.raw.free_descriptor_sets(
|
||||
*pool,
|
||||
&smallvec::SmallVec::<[vk::DescriptorSet; 32]>::from_iter(sets),
|
||||
)
|
||||
};
|
||||
match result {
|
||||
Ok(()) => {}
|
||||
Err(err) => log::error!("free_descriptor_sets: {:?}", err),
|
||||
@@ -559,12 +567,12 @@ impl super::Device {
|
||||
|
||||
let result = {
|
||||
profiling::scope!("vkCreateSwapchainKHR");
|
||||
functor.create_swapchain(&info, None)
|
||||
unsafe { functor.create_swapchain(&info, None) }
|
||||
};
|
||||
|
||||
// doing this before bailing out with error
|
||||
if old_swapchain != vk::SwapchainKHR::null() {
|
||||
functor.destroy_swapchain(old_swapchain, None)
|
||||
unsafe { functor.destroy_swapchain(old_swapchain, None) }
|
||||
}
|
||||
|
||||
let raw = match result {
|
||||
@@ -580,15 +588,11 @@ impl super::Device {
|
||||
}
|
||||
};
|
||||
|
||||
let images = functor
|
||||
.get_swapchain_images(raw)
|
||||
.map_err(crate::DeviceError::from)?;
|
||||
let images =
|
||||
unsafe { functor.get_swapchain_images(raw) }.map_err(crate::DeviceError::from)?;
|
||||
|
||||
let vk_info = vk::FenceCreateInfo::builder().build();
|
||||
let fence = self
|
||||
.shared
|
||||
.raw
|
||||
.create_fence(&vk_info, None)
|
||||
let fence = unsafe { self.shared.raw.create_fence(&vk_info, None) }
|
||||
.map_err(crate::DeviceError::from)?;
|
||||
|
||||
Ok(super::Swapchain {
|
||||
@@ -741,12 +745,12 @@ impl super::Device {
|
||||
|
||||
impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn exit(self, queue: super::Queue) {
|
||||
self.mem_allocator.into_inner().cleanup(&*self.shared);
|
||||
self.desc_allocator.into_inner().cleanup(&*self.shared);
|
||||
unsafe { self.mem_allocator.into_inner().cleanup(&*self.shared) };
|
||||
unsafe { self.desc_allocator.into_inner().cleanup(&*self.shared) };
|
||||
for &sem in queue.relay_semaphores.iter() {
|
||||
self.shared.raw.destroy_semaphore(sem, None);
|
||||
unsafe { self.shared.raw.destroy_semaphore(sem, None) };
|
||||
}
|
||||
self.shared.free_resources();
|
||||
unsafe { self.shared.free_resources() };
|
||||
}
|
||||
|
||||
unsafe fn create_buffer(
|
||||
@@ -758,8 +762,8 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.usage(conv::map_buffer_usage(desc.usage))
|
||||
.sharing_mode(vk::SharingMode::EXCLUSIVE);
|
||||
|
||||
let raw = self.shared.raw.create_buffer(&vk_info, None)?;
|
||||
let req = self.shared.raw.get_buffer_memory_requirements(raw);
|
||||
let raw = unsafe { self.shared.raw.create_buffer(&vk_info, None)? };
|
||||
let req = unsafe { self.shared.raw.get_buffer_memory_requirements(raw) };
|
||||
|
||||
let mut alloc_usage = if desc
|
||||
.usage
|
||||
@@ -784,23 +788,29 @@ impl crate::Device<super::Api> for super::Device {
|
||||
desc.memory_flags.contains(crate::MemoryFlags::TRANSIENT),
|
||||
);
|
||||
|
||||
let block = self.mem_allocator.lock().alloc(
|
||||
&*self.shared,
|
||||
gpu_alloc::Request {
|
||||
size: req.size,
|
||||
align_mask: req.alignment - 1,
|
||||
usage: alloc_usage,
|
||||
memory_types: req.memory_type_bits & self.valid_ash_memory_types,
|
||||
},
|
||||
)?;
|
||||
let block = unsafe {
|
||||
self.mem_allocator.lock().alloc(
|
||||
&*self.shared,
|
||||
gpu_alloc::Request {
|
||||
size: req.size,
|
||||
align_mask: req.alignment - 1,
|
||||
usage: alloc_usage,
|
||||
memory_types: req.memory_type_bits & self.valid_ash_memory_types,
|
||||
},
|
||||
)?
|
||||
};
|
||||
|
||||
self.shared
|
||||
.raw
|
||||
.bind_buffer_memory(raw, *block.memory(), block.offset())?;
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.bind_buffer_memory(raw, *block.memory(), block.offset())?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::BUFFER, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::BUFFER, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::Buffer {
|
||||
@@ -809,10 +819,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_buffer(&self, buffer: super::Buffer) {
|
||||
self.shared.raw.destroy_buffer(buffer.raw, None);
|
||||
self.mem_allocator
|
||||
.lock()
|
||||
.dealloc(&*self.shared, buffer.block.into_inner());
|
||||
unsafe { self.shared.raw.destroy_buffer(buffer.raw, None) };
|
||||
unsafe {
|
||||
self.mem_allocator
|
||||
.lock()
|
||||
.dealloc(&*self.shared, buffer.block.into_inner())
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn map_buffer(
|
||||
@@ -822,14 +834,14 @@ impl crate::Device<super::Api> for super::Device {
|
||||
) -> Result<crate::BufferMapping, crate::DeviceError> {
|
||||
let size = range.end - range.start;
|
||||
let mut block = buffer.block.lock();
|
||||
let ptr = block.map(&*self.shared, range.start, size as usize)?;
|
||||
let ptr = unsafe { block.map(&*self.shared, range.start, size as usize)? };
|
||||
let is_coherent = block
|
||||
.props()
|
||||
.contains(gpu_alloc::MemoryPropertyFlags::HOST_COHERENT);
|
||||
Ok(crate::BufferMapping { ptr, is_coherent })
|
||||
}
|
||||
unsafe fn unmap_buffer(&self, buffer: &super::Buffer) -> Result<(), crate::DeviceError> {
|
||||
buffer.block.lock().unmap(&*self.shared);
|
||||
unsafe { buffer.block.lock().unmap(&*self.shared) };
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -839,12 +851,14 @@ impl crate::Device<super::Api> for super::Device {
|
||||
{
|
||||
let vk_ranges = self.shared.make_memory_ranges(buffer, ranges);
|
||||
|
||||
self.shared
|
||||
.raw
|
||||
.flush_mapped_memory_ranges(
|
||||
&smallvec::SmallVec::<[vk::MappedMemoryRange; 32]>::from_iter(vk_ranges),
|
||||
)
|
||||
.unwrap();
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.flush_mapped_memory_ranges(
|
||||
&smallvec::SmallVec::<[vk::MappedMemoryRange; 32]>::from_iter(vk_ranges),
|
||||
)
|
||||
}
|
||||
.unwrap();
|
||||
}
|
||||
unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &super::Buffer, ranges: I)
|
||||
where
|
||||
@@ -852,12 +866,14 @@ impl crate::Device<super::Api> for super::Device {
|
||||
{
|
||||
let vk_ranges = self.shared.make_memory_ranges(buffer, ranges);
|
||||
|
||||
self.shared
|
||||
.raw
|
||||
.invalidate_mapped_memory_ranges(
|
||||
&smallvec::SmallVec::<[vk::MappedMemoryRange; 32]>::from_iter(vk_ranges),
|
||||
)
|
||||
.unwrap();
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.invalidate_mapped_memory_ranges(
|
||||
&smallvec::SmallVec::<[vk::MappedMemoryRange; 32]>::from_iter(vk_ranges),
|
||||
)
|
||||
}
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
unsafe fn create_texture(
|
||||
@@ -896,26 +912,32 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.sharing_mode(vk::SharingMode::EXCLUSIVE)
|
||||
.initial_layout(vk::ImageLayout::UNDEFINED);
|
||||
|
||||
let raw = self.shared.raw.create_image(&vk_info, None)?;
|
||||
let req = self.shared.raw.get_image_memory_requirements(raw);
|
||||
let raw = unsafe { self.shared.raw.create_image(&vk_info, None)? };
|
||||
let req = unsafe { self.shared.raw.get_image_memory_requirements(raw) };
|
||||
|
||||
let block = self.mem_allocator.lock().alloc(
|
||||
&*self.shared,
|
||||
gpu_alloc::Request {
|
||||
size: req.size,
|
||||
align_mask: req.alignment - 1,
|
||||
usage: gpu_alloc::UsageFlags::FAST_DEVICE_ACCESS,
|
||||
memory_types: req.memory_type_bits & self.valid_ash_memory_types,
|
||||
},
|
||||
)?;
|
||||
let block = unsafe {
|
||||
self.mem_allocator.lock().alloc(
|
||||
&*self.shared,
|
||||
gpu_alloc::Request {
|
||||
size: req.size,
|
||||
align_mask: req.alignment - 1,
|
||||
usage: gpu_alloc::UsageFlags::FAST_DEVICE_ACCESS,
|
||||
memory_types: req.memory_type_bits & self.valid_ash_memory_types,
|
||||
},
|
||||
)?
|
||||
};
|
||||
|
||||
self.shared
|
||||
.raw
|
||||
.bind_image_memory(raw, *block.memory(), block.offset())?;
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.bind_image_memory(raw, *block.memory(), block.offset())?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::IMAGE, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::IMAGE, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::Texture {
|
||||
@@ -931,10 +953,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
}
|
||||
unsafe fn destroy_texture(&self, texture: super::Texture) {
|
||||
if texture.drop_guard.is_none() {
|
||||
self.shared.raw.destroy_image(texture.raw, None);
|
||||
unsafe { self.shared.raw.destroy_image(texture.raw, None) };
|
||||
}
|
||||
if let Some(block) = texture.block {
|
||||
self.mem_allocator.lock().dealloc(&*self.shared, block);
|
||||
unsafe { self.mem_allocator.lock().dealloc(&*self.shared, block) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -964,11 +986,13 @@ impl crate::Device<super::Api> for super::Device {
|
||||
texture.usage
|
||||
};
|
||||
|
||||
let raw = self.shared.raw.create_image_view(&vk_info, None)?;
|
||||
let raw = unsafe { self.shared.raw.create_image_view(&vk_info, None) }?;
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::IMAGE_VIEW, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::IMAGE_VIEW, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
let attachment = super::FramebufferAttachment {
|
||||
@@ -993,12 +1017,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let mut fbuf_lock = self.shared.framebuffers.lock();
|
||||
for (key, &raw_fbuf) in fbuf_lock.iter() {
|
||||
if key.attachments.iter().any(|at| at.raw == view.raw) {
|
||||
self.shared.raw.destroy_framebuffer(raw_fbuf, None);
|
||||
unsafe { self.shared.raw.destroy_framebuffer(raw_fbuf, None) };
|
||||
}
|
||||
}
|
||||
fbuf_lock.retain(|key, _| !key.attachments.iter().any(|at| at.raw == view.raw));
|
||||
}
|
||||
self.shared.raw.destroy_image_view(view.raw, None);
|
||||
unsafe { self.shared.raw.destroy_image_view(view.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn create_sampler(
|
||||
@@ -1040,17 +1064,19 @@ impl crate::Device<super::Api> for super::Device {
|
||||
vk_info = vk_info.border_color(conv::map_border_color(color));
|
||||
}
|
||||
|
||||
let raw = self.shared.raw.create_sampler(&vk_info, None)?;
|
||||
let raw = unsafe { self.shared.raw.create_sampler(&vk_info, None)? };
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::SAMPLER, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::SAMPLER, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::Sampler { raw })
|
||||
}
|
||||
unsafe fn destroy_sampler(&self, sampler: super::Sampler) {
|
||||
self.shared.raw.destroy_sampler(sampler.raw, None);
|
||||
unsafe { self.shared.raw.destroy_sampler(sampler.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn create_command_encoder(
|
||||
@@ -1061,7 +1087,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.queue_family_index(desc.queue.family_index)
|
||||
.flags(vk::CommandPoolCreateFlags::TRANSIENT)
|
||||
.build();
|
||||
let raw = self.shared.raw.create_command_pool(&vk_info, None)?;
|
||||
let raw = unsafe { self.shared.raw.create_command_pool(&vk_info, None)? };
|
||||
|
||||
Ok(super::CommandEncoder {
|
||||
raw,
|
||||
@@ -1075,17 +1101,19 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_command_encoder(&self, cmd_encoder: super::CommandEncoder) {
|
||||
if !cmd_encoder.free.is_empty() {
|
||||
self.shared
|
||||
.raw
|
||||
.free_command_buffers(cmd_encoder.raw, &cmd_encoder.free);
|
||||
unsafe {
|
||||
if !cmd_encoder.free.is_empty() {
|
||||
self.shared
|
||||
.raw
|
||||
.free_command_buffers(cmd_encoder.raw, &cmd_encoder.free)
|
||||
}
|
||||
if !cmd_encoder.discarded.is_empty() {
|
||||
self.shared
|
||||
.raw
|
||||
.free_command_buffers(cmd_encoder.raw, &cmd_encoder.discarded)
|
||||
}
|
||||
self.shared.raw.destroy_command_pool(cmd_encoder.raw, None);
|
||||
}
|
||||
if !cmd_encoder.discarded.is_empty() {
|
||||
self.shared
|
||||
.raw
|
||||
.free_command_buffers(cmd_encoder.raw, &cmd_encoder.discarded);
|
||||
}
|
||||
self.shared.raw.destroy_command_pool(cmd_encoder.raw, None);
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group_layout(
|
||||
@@ -1224,14 +1252,17 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let vk_info = vk_info.flags(dsl_create_flags);
|
||||
|
||||
let raw = self
|
||||
.shared
|
||||
.raw
|
||||
.create_descriptor_set_layout(&vk_info, None)?;
|
||||
let raw = unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.create_descriptor_set_layout(&vk_info, None)?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::DESCRIPTOR_SET_LAYOUT, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::DESCRIPTOR_SET_LAYOUT, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::BindGroupLayout {
|
||||
@@ -1243,9 +1274,11 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_bind_group_layout(&self, bg_layout: super::BindGroupLayout) {
|
||||
self.shared
|
||||
.raw
|
||||
.destroy_descriptor_set_layout(bg_layout.raw, None);
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.destroy_descriptor_set_layout(bg_layout.raw, None)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn create_pipeline_layout(
|
||||
@@ -1275,12 +1308,14 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let raw = {
|
||||
profiling::scope!("vkCreatePipelineLayout");
|
||||
self.shared.raw.create_pipeline_layout(&vk_info, None)?
|
||||
unsafe { self.shared.raw.create_pipeline_layout(&vk_info, None)? }
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE_LAYOUT, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE_LAYOUT, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
let mut binding_arrays = BTreeMap::new();
|
||||
@@ -1304,31 +1339,37 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: super::PipelineLayout) {
|
||||
self.shared
|
||||
.raw
|
||||
.destroy_pipeline_layout(pipeline_layout.raw, None);
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.destroy_pipeline_layout(pipeline_layout.raw, None)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group(
|
||||
&self,
|
||||
desc: &crate::BindGroupDescriptor<super::Api>,
|
||||
) -> Result<super::BindGroup, crate::DeviceError> {
|
||||
let mut vk_sets = self.desc_allocator.lock().allocate(
|
||||
&*self.shared,
|
||||
&desc.layout.raw,
|
||||
if desc.layout.requires_update_after_bind {
|
||||
gpu_descriptor::DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND
|
||||
} else {
|
||||
gpu_descriptor::DescriptorSetLayoutCreateFlags::empty()
|
||||
},
|
||||
&desc.layout.desc_count,
|
||||
1,
|
||||
)?;
|
||||
let mut vk_sets = unsafe {
|
||||
self.desc_allocator.lock().allocate(
|
||||
&*self.shared,
|
||||
&desc.layout.raw,
|
||||
if desc.layout.requires_update_after_bind {
|
||||
gpu_descriptor::DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND
|
||||
} else {
|
||||
gpu_descriptor::DescriptorSetLayoutCreateFlags::empty()
|
||||
},
|
||||
&desc.layout.desc_count,
|
||||
1,
|
||||
)?
|
||||
};
|
||||
|
||||
let set = vk_sets.pop().unwrap();
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::DESCRIPTOR_SET, *set.raw(), label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::DESCRIPTOR_SET, *set.raw(), label)
|
||||
};
|
||||
}
|
||||
|
||||
let mut writes = Vec::with_capacity(desc.entries.len());
|
||||
@@ -1397,13 +1438,15 @@ impl crate::Device<super::Api> for super::Device {
|
||||
writes.push(write.build());
|
||||
}
|
||||
|
||||
self.shared.raw.update_descriptor_sets(&writes, &[]);
|
||||
unsafe { self.shared.raw.update_descriptor_sets(&writes, &[]) };
|
||||
Ok(super::BindGroup { set })
|
||||
}
|
||||
unsafe fn destroy_bind_group(&self, group: super::BindGroup) {
|
||||
self.desc_allocator
|
||||
.lock()
|
||||
.free(&*self.shared, Some(group.set));
|
||||
unsafe {
|
||||
self.desc_allocator
|
||||
.lock()
|
||||
.free(&*self.shared, Some(group.set))
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn create_shader_module(
|
||||
@@ -1448,8 +1491,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let raw = self.create_shader_module_impl(&spv)?;
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::SHADER_MODULE, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::SHADER_MODULE, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::ShaderModule::Raw(raw))
|
||||
@@ -1457,7 +1502,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_shader_module(&self, module: super::ShaderModule) {
|
||||
match module {
|
||||
super::ShaderModule::Raw(raw) => {
|
||||
self.shared.raw.destroy_shader_module(raw, None);
|
||||
unsafe { self.shared.raw.destroy_shader_module(raw, None) };
|
||||
}
|
||||
super::ShaderModule::Intermediate { .. } => {}
|
||||
}
|
||||
@@ -1674,33 +1719,37 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let mut raw_vec = {
|
||||
profiling::scope!("vkCreateGraphicsPipelines");
|
||||
self.shared
|
||||
.raw
|
||||
.create_graphics_pipelines(vk::PipelineCache::null(), &vk_infos, None)
|
||||
.map_err(|(_, e)| crate::DeviceError::from(e))?
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.create_graphics_pipelines(vk::PipelineCache::null(), &vk_infos, None)
|
||||
.map_err(|(_, e)| crate::DeviceError::from(e))
|
||||
}?
|
||||
};
|
||||
|
||||
let raw = raw_vec.pop().unwrap();
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
if let Some(raw_module) = compiled_vs.temp_raw_module {
|
||||
self.shared.raw.destroy_shader_module(raw_module, None);
|
||||
unsafe { self.shared.raw.destroy_shader_module(raw_module, None) };
|
||||
}
|
||||
if let Some(CompiledStage {
|
||||
temp_raw_module: Some(raw_module),
|
||||
..
|
||||
}) = compiled_fs
|
||||
{
|
||||
self.shared.raw.destroy_shader_module(raw_module, None);
|
||||
unsafe { self.shared.raw.destroy_shader_module(raw_module, None) };
|
||||
}
|
||||
|
||||
Ok(super::RenderPipeline { raw })
|
||||
}
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: super::RenderPipeline) {
|
||||
self.shared.raw.destroy_pipeline(pipeline.raw, None);
|
||||
unsafe { self.shared.raw.destroy_pipeline(pipeline.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn create_compute_pipeline(
|
||||
@@ -1722,26 +1771,30 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
let mut raw_vec = {
|
||||
profiling::scope!("vkCreateComputePipelines");
|
||||
self.shared
|
||||
.raw
|
||||
.create_compute_pipelines(vk::PipelineCache::null(), &vk_infos, None)
|
||||
.map_err(|(_, e)| crate::DeviceError::from(e))?
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.create_compute_pipelines(vk::PipelineCache::null(), &vk_infos, None)
|
||||
.map_err(|(_, e)| crate::DeviceError::from(e))
|
||||
}?
|
||||
};
|
||||
|
||||
let raw = raw_vec.pop().unwrap();
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::PIPELINE, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
if let Some(raw_module) = compiled.temp_raw_module {
|
||||
self.shared.raw.destroy_shader_module(raw_module, None);
|
||||
unsafe { self.shared.raw.destroy_shader_module(raw_module, None) };
|
||||
}
|
||||
|
||||
Ok(super::ComputePipeline { raw })
|
||||
}
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: super::ComputePipeline) {
|
||||
self.shared.raw.destroy_pipeline(pipeline.raw, None);
|
||||
unsafe { self.shared.raw.destroy_pipeline(pipeline.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn create_query_set(
|
||||
@@ -1769,16 +1822,18 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.pipeline_statistics(pipeline_statistics)
|
||||
.build();
|
||||
|
||||
let raw = self.shared.raw.create_query_pool(&vk_info, None)?;
|
||||
let raw = unsafe { self.shared.raw.create_query_pool(&vk_info, None) }?;
|
||||
if let Some(label) = desc.label {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::QUERY_POOL, raw, label);
|
||||
unsafe {
|
||||
self.shared
|
||||
.set_object_name(vk::ObjectType::QUERY_POOL, raw, label)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(super::QuerySet { raw })
|
||||
}
|
||||
unsafe fn destroy_query_set(&self, set: super::QuerySet) {
|
||||
self.shared.raw.destroy_query_pool(set.raw, None);
|
||||
unsafe { self.shared.raw.destroy_query_pool(set.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn create_fence(&self) -> Result<super::Fence, crate::DeviceError> {
|
||||
@@ -1786,7 +1841,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let mut sem_type_info =
|
||||
vk::SemaphoreTypeCreateInfo::builder().semaphore_type(vk::SemaphoreType::TIMELINE);
|
||||
let vk_info = vk::SemaphoreCreateInfo::builder().push_next(&mut sem_type_info);
|
||||
let raw = self.shared.raw.create_semaphore(&vk_info, None)?;
|
||||
let raw = unsafe { self.shared.raw.create_semaphore(&vk_info, None) }?;
|
||||
super::Fence::TimelineSemaphore(raw)
|
||||
} else {
|
||||
super::Fence::FencePool {
|
||||
@@ -1799,7 +1854,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
unsafe fn destroy_fence(&self, fence: super::Fence) {
|
||||
match fence {
|
||||
super::Fence::TimelineSemaphore(raw) => {
|
||||
self.shared.raw.destroy_semaphore(raw, None);
|
||||
unsafe { self.shared.raw.destroy_semaphore(raw, None) };
|
||||
}
|
||||
super::Fence::FencePool {
|
||||
active,
|
||||
@@ -1807,10 +1862,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
last_completed: _,
|
||||
} => {
|
||||
for (_, raw) in active {
|
||||
self.shared.raw.destroy_fence(raw, None);
|
||||
unsafe { self.shared.raw.destroy_fence(raw, None) };
|
||||
}
|
||||
for raw in free {
|
||||
self.shared.raw.destroy_fence(raw, None);
|
||||
unsafe { self.shared.raw.destroy_fence(raw, None) };
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1839,12 +1894,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.semaphores(&semaphores)
|
||||
.values(&values);
|
||||
let result = match self.shared.extension_fns.timeline_semaphore {
|
||||
Some(super::ExtensionFn::Extension(ref ext)) => {
|
||||
Some(super::ExtensionFn::Extension(ref ext)) => unsafe {
|
||||
ext.wait_semaphores(&vk_info, timeout_ns)
|
||||
}
|
||||
Some(super::ExtensionFn::Promoted) => {
|
||||
},
|
||||
Some(super::ExtensionFn::Promoted) => unsafe {
|
||||
self.shared.raw.wait_semaphores(&vk_info, timeout_ns)
|
||||
}
|
||||
},
|
||||
None => unreachable!(),
|
||||
};
|
||||
match result {
|
||||
@@ -1863,7 +1918,9 @@ impl crate::Device<super::Api> for super::Device {
|
||||
} else {
|
||||
match active.iter().find(|&&(value, _)| value >= wait_value) {
|
||||
Some(&(_, raw)) => {
|
||||
match self.shared.raw.wait_for_fences(&[raw], true, timeout_ns) {
|
||||
match unsafe {
|
||||
self.shared.raw.wait_for_fences(&[raw], true, timeout_ns)
|
||||
} {
|
||||
Ok(()) => Ok(true),
|
||||
Err(vk::Result::TIMEOUT) => Ok(false),
|
||||
Err(other) => Err(other.into()),
|
||||
@@ -1885,9 +1942,11 @@ impl crate::Device<super::Api> for super::Device {
|
||||
// Renderdoc requires us to give us the pointer that vkInstance _points to_.
|
||||
let raw_vk_instance =
|
||||
ash::vk::Handle::as_raw(self.shared.instance.raw.handle()) as *mut *mut _;
|
||||
let raw_vk_instance_dispatch_table = *raw_vk_instance;
|
||||
self.render_doc
|
||||
.start_frame_capture(raw_vk_instance_dispatch_table, ptr::null_mut())
|
||||
let raw_vk_instance_dispatch_table = unsafe { *raw_vk_instance };
|
||||
unsafe {
|
||||
self.render_doc
|
||||
.start_frame_capture(raw_vk_instance_dispatch_table, ptr::null_mut())
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "renderdoc"))]
|
||||
false
|
||||
@@ -1898,10 +1957,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
// Renderdoc requires us to give us the pointer that vkInstance _points to_.
|
||||
let raw_vk_instance =
|
||||
ash::vk::Handle::as_raw(self.shared.instance.raw.handle()) as *mut *mut _;
|
||||
let raw_vk_instance_dispatch_table = *raw_vk_instance;
|
||||
let raw_vk_instance_dispatch_table = unsafe { *raw_vk_instance };
|
||||
|
||||
self.render_doc
|
||||
.end_frame_capture(raw_vk_instance_dispatch_table, ptr::null_mut())
|
||||
unsafe {
|
||||
self.render_doc
|
||||
.end_frame_capture(raw_vk_instance_dispatch_table, ptr::null_mut())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -31,17 +31,17 @@ unsafe extern "system" fn debug_utils_messenger_callback(
|
||||
_ => log::Level::Warn,
|
||||
};
|
||||
|
||||
let cd = &*callback_data_ptr;
|
||||
let cd = unsafe { &*callback_data_ptr };
|
||||
|
||||
let message_id_name = if cd.p_message_id_name.is_null() {
|
||||
Cow::from("")
|
||||
} else {
|
||||
CStr::from_ptr(cd.p_message_id_name).to_string_lossy()
|
||||
unsafe { CStr::from_ptr(cd.p_message_id_name) }.to_string_lossy()
|
||||
};
|
||||
let message = if cd.p_message.is_null() {
|
||||
Cow::from("")
|
||||
} else {
|
||||
CStr::from_ptr(cd.p_message).to_string_lossy()
|
||||
unsafe { CStr::from_ptr(cd.p_message) }.to_string_lossy()
|
||||
};
|
||||
|
||||
let _ = std::panic::catch_unwind(|| {
|
||||
@@ -56,14 +56,13 @@ unsafe extern "system" fn debug_utils_messenger_callback(
|
||||
});
|
||||
|
||||
if cd.queue_label_count != 0 {
|
||||
let labels = slice::from_raw_parts(cd.p_queue_labels, cd.queue_label_count as usize);
|
||||
let labels =
|
||||
unsafe { slice::from_raw_parts(cd.p_queue_labels, cd.queue_label_count as usize) };
|
||||
let names = labels
|
||||
.iter()
|
||||
.flat_map(|dul_obj| {
|
||||
dul_obj
|
||||
.p_label_name
|
||||
.as_ref()
|
||||
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
|
||||
unsafe { dul_obj.p_label_name.as_ref() }
|
||||
.map(|lbl| unsafe { CStr::from_ptr(lbl) }.to_string_lossy())
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
@@ -73,14 +72,13 @@ unsafe extern "system" fn debug_utils_messenger_callback(
|
||||
}
|
||||
|
||||
if cd.cmd_buf_label_count != 0 {
|
||||
let labels = slice::from_raw_parts(cd.p_cmd_buf_labels, cd.cmd_buf_label_count as usize);
|
||||
let labels =
|
||||
unsafe { slice::from_raw_parts(cd.p_cmd_buf_labels, cd.cmd_buf_label_count as usize) };
|
||||
let names = labels
|
||||
.iter()
|
||||
.flat_map(|dul_obj| {
|
||||
dul_obj
|
||||
.p_label_name
|
||||
.as_ref()
|
||||
.map(|lbl| CStr::from_ptr(lbl).to_string_lossy())
|
||||
unsafe { dul_obj.p_label_name.as_ref() }
|
||||
.map(|lbl| unsafe { CStr::from_ptr(lbl) }.to_string_lossy())
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
@@ -90,15 +88,13 @@ unsafe extern "system" fn debug_utils_messenger_callback(
|
||||
}
|
||||
|
||||
if cd.object_count != 0 {
|
||||
let labels = slice::from_raw_parts(cd.p_objects, cd.object_count as usize);
|
||||
let labels = unsafe { slice::from_raw_parts(cd.p_objects, cd.object_count as usize) };
|
||||
//TODO: use color fields of `vk::DebugUtilsLabelExt`?
|
||||
let names = labels
|
||||
.iter()
|
||||
.map(|obj_info| {
|
||||
let name = obj_info
|
||||
.p_object_name
|
||||
.as_ref()
|
||||
.map(|name| CStr::from_ptr(name).to_string_lossy())
|
||||
let name = unsafe { obj_info.p_object_name.as_ref() }
|
||||
.map(|name| unsafe { CStr::from_ptr(name) }.to_string_lossy())
|
||||
.unwrap_or(Cow::Borrowed("?"));
|
||||
|
||||
format!(
|
||||
@@ -125,9 +121,9 @@ impl super::Swapchain {
|
||||
profiling::scope!("Swapchain::release_resources");
|
||||
{
|
||||
profiling::scope!("vkDeviceWaitIdle");
|
||||
let _ = device.device_wait_idle();
|
||||
let _ = unsafe { device.device_wait_idle() };
|
||||
};
|
||||
device.destroy_fence(self.fence, None);
|
||||
unsafe { device.destroy_fence(self.fence, None) };
|
||||
self
|
||||
}
|
||||
}
|
||||
@@ -256,9 +252,8 @@ impl super::Instance {
|
||||
| vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
|
||||
)
|
||||
.pfn_user_callback(Some(debug_utils_messenger_callback));
|
||||
let messenger = extension
|
||||
.create_debug_utils_messenger(&vk_info, None)
|
||||
.unwrap();
|
||||
let messenger =
|
||||
unsafe { extension.create_debug_utils_messenger(&vk_info, None) }.unwrap();
|
||||
Some(super::DebugUtils {
|
||||
extension,
|
||||
messenger,
|
||||
@@ -484,7 +479,7 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor) -> Result<Self, crate::InstanceError> {
|
||||
use crate::auxil::cstr_from_bytes_until_nul;
|
||||
|
||||
let entry = match ash::Entry::load() {
|
||||
let entry = match unsafe { ash::Entry::load() } {
|
||||
Ok(entry) => entry,
|
||||
Err(err) => {
|
||||
log::info!("Missing Vulkan entry points: {:?}", err);
|
||||
@@ -595,22 +590,24 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
.enabled_layer_names(&str_pointers[..layers.len()])
|
||||
.enabled_extension_names(&str_pointers[layers.len()..]);
|
||||
|
||||
entry.create_instance(&create_info, None).map_err(|e| {
|
||||
unsafe { entry.create_instance(&create_info, None) }.map_err(|e| {
|
||||
log::warn!("create_instance: {:?}", e);
|
||||
crate::InstanceError
|
||||
})?
|
||||
};
|
||||
|
||||
Self::from_raw(
|
||||
entry,
|
||||
vk_instance,
|
||||
driver_api_version,
|
||||
android_sdk_version,
|
||||
extensions,
|
||||
desc.flags,
|
||||
has_nv_optimus,
|
||||
Some(Box::new(())), // `Some` signals that wgpu-hal is in charge of destroying vk_instance
|
||||
)
|
||||
unsafe {
|
||||
Self::from_raw(
|
||||
entry,
|
||||
vk_instance,
|
||||
driver_api_version,
|
||||
android_sdk_version,
|
||||
extensions,
|
||||
desc.flags,
|
||||
has_nv_optimus,
|
||||
Some(Box::new(())), // `Some` signals that wgpu-hal is in charge of destroying vk_instance
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn create_surface(
|
||||
@@ -635,7 +632,7 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
(Rwh::Win32(handle), _) => {
|
||||
use winapi::um::libloaderapi::GetModuleHandleW;
|
||||
|
||||
let hinstance = GetModuleHandleW(std::ptr::null());
|
||||
let hinstance = unsafe { GetModuleHandleW(std::ptr::null()) };
|
||||
self.create_surface_from_hwnd(hinstance as *mut _, handle.hwnd)
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
@@ -655,13 +652,13 @@ impl crate::Instance<super::Api> for super::Instance {
|
||||
}
|
||||
|
||||
unsafe fn destroy_surface(&self, surface: super::Surface) {
|
||||
surface.functor.destroy_surface(surface.raw, None);
|
||||
unsafe { surface.functor.destroy_surface(surface.raw, None) };
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(&self) -> Vec<crate::ExposedAdapter<super::Api>> {
|
||||
use crate::auxil::db;
|
||||
|
||||
let raw_devices = match self.shared.raw.enumerate_physical_devices() {
|
||||
let raw_devices = match unsafe { self.shared.raw.enumerate_physical_devices() } {
|
||||
Ok(devices) => devices,
|
||||
Err(err) => {
|
||||
log::error!("enumerate_adapters: {}", err);
|
||||
@@ -708,9 +705,9 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
let old = self
|
||||
.swapchain
|
||||
.take()
|
||||
.map(|sc| sc.release_resources(&device.shared.raw));
|
||||
.map(|sc| unsafe { sc.release_resources(&device.shared.raw) });
|
||||
|
||||
let swapchain = device.create_swapchain(self, config, old)?;
|
||||
let swapchain = unsafe { device.create_swapchain(self, config, old)? };
|
||||
self.swapchain = Some(swapchain);
|
||||
|
||||
Ok(())
|
||||
@@ -718,8 +715,8 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
|
||||
unsafe fn unconfigure(&mut self, device: &super::Device) {
|
||||
if let Some(sc) = self.swapchain.take() {
|
||||
let swapchain = sc.release_resources(&device.shared.raw);
|
||||
swapchain.functor.destroy_swapchain(swapchain.raw, None);
|
||||
let swapchain = unsafe { sc.release_resources(&device.shared.raw) };
|
||||
unsafe { swapchain.functor.destroy_swapchain(swapchain.raw, None) };
|
||||
}
|
||||
}
|
||||
|
||||
@@ -748,23 +745,22 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
}
|
||||
|
||||
// will block if no image is available
|
||||
let (index, suboptimal) =
|
||||
match sc
|
||||
.functor
|
||||
let (index, suboptimal) = match unsafe {
|
||||
sc.functor
|
||||
.acquire_next_image(sc.raw, timeout_ns, vk::Semaphore::null(), sc.fence)
|
||||
{
|
||||
Ok(pair) => pair,
|
||||
Err(error) => {
|
||||
return match error {
|
||||
vk::Result::TIMEOUT => Ok(None),
|
||||
vk::Result::NOT_READY | vk::Result::ERROR_OUT_OF_DATE_KHR => {
|
||||
Err(crate::SurfaceError::Outdated)
|
||||
}
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR => Err(crate::SurfaceError::Lost),
|
||||
other => Err(crate::DeviceError::from(other).into()),
|
||||
} {
|
||||
Ok(pair) => pair,
|
||||
Err(error) => {
|
||||
return match error {
|
||||
vk::Result::TIMEOUT => Ok(None),
|
||||
vk::Result::NOT_READY | vk::Result::ERROR_OUT_OF_DATE_KHR => {
|
||||
Err(crate::SurfaceError::Outdated)
|
||||
}
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR => Err(crate::SurfaceError::Lost),
|
||||
other => Err(crate::DeviceError::from(other).into()),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
// special case for Intel Vulkan returning bizzare values (ugh)
|
||||
if sc.device.vendor_id == crate::auxil::db::intel::VENDOR && index > 0x100 {
|
||||
@@ -773,14 +769,9 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
|
||||
let fences = &[sc.fence];
|
||||
|
||||
sc.device
|
||||
.raw
|
||||
.wait_for_fences(fences, true, !0)
|
||||
.map_err(crate::DeviceError::from)?;
|
||||
sc.device
|
||||
.raw
|
||||
.reset_fences(fences)
|
||||
unsafe { sc.device.raw.wait_for_fences(fences, true, !0) }
|
||||
.map_err(crate::DeviceError::from)?;
|
||||
unsafe { sc.device.raw.reset_fences(fences) }.map_err(crate::DeviceError::from)?;
|
||||
|
||||
let texture = super::SurfaceTexture {
|
||||
index,
|
||||
|
||||
+14
-11
@@ -589,10 +589,11 @@ impl crate::Queue<Api> for Queue {
|
||||
} => {
|
||||
fence_raw = match free.pop() {
|
||||
Some(raw) => raw,
|
||||
None => self
|
||||
.device
|
||||
.raw
|
||||
.create_fence(&vk::FenceCreateInfo::builder(), None)?,
|
||||
None => unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.create_fence(&vk::FenceCreateInfo::builder(), None)?
|
||||
},
|
||||
};
|
||||
active.push((value, fence_raw));
|
||||
}
|
||||
@@ -620,9 +621,11 @@ impl crate::Queue<Api> for Queue {
|
||||
vk_info = vk_info.signal_semaphores(&signal_semaphores[..signal_count]);
|
||||
|
||||
profiling::scope!("vkQueueSubmit");
|
||||
self.device
|
||||
.raw
|
||||
.queue_submit(self.raw, &[vk_info.build()], fence_raw)?;
|
||||
unsafe {
|
||||
self.device
|
||||
.raw
|
||||
.queue_submit(self.raw, &[vk_info.build()], fence_raw)?
|
||||
};
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -645,13 +648,13 @@ impl crate::Queue<Api> for Queue {
|
||||
|
||||
let suboptimal = {
|
||||
profiling::scope!("vkQueuePresentKHR");
|
||||
self.swapchain_fn
|
||||
.queue_present(self.raw, &vk_info)
|
||||
.map_err(|error| match error {
|
||||
unsafe { self.swapchain_fn.queue_present(self.raw, &vk_info) }.map_err(|error| {
|
||||
match error {
|
||||
vk::Result::ERROR_OUT_OF_DATE_KHR => crate::SurfaceError::Outdated,
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR => crate::SurfaceError::Lost,
|
||||
_ => crate::DeviceError::from(error).into(),
|
||||
})?
|
||||
}
|
||||
})?
|
||||
};
|
||||
if suboptimal {
|
||||
log::warn!("Suboptimal present of frame {}", texture.index);
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
// We don't use syntax sugar where it's not necessary.
|
||||
clippy::match_like_matches_macro,
|
||||
)]
|
||||
#![warn(missing_docs)]
|
||||
#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
+47
-34
@@ -40,25 +40,26 @@ impl fmt::Debug for Context {
|
||||
impl Context {
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
pub unsafe fn from_hal_instance<A: wgc::hub::HalApi>(hal_instance: A::Instance) -> Self {
|
||||
Self(wgc::hub::Global::from_hal_instance::<A>(
|
||||
"wgpu",
|
||||
wgc::hub::IdentityManagerFactory,
|
||||
hal_instance,
|
||||
))
|
||||
Self(unsafe {
|
||||
wgc::hub::Global::from_hal_instance::<A>(
|
||||
"wgpu",
|
||||
wgc::hub::IdentityManagerFactory,
|
||||
hal_instance,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// # Safety
|
||||
///
|
||||
/// - The raw instance handle returned must not be manually destroyed.
|
||||
pub unsafe fn instance_as_hal<A: wgc::hub::HalApi>(&self) -> Option<&A::Instance> {
|
||||
self.0.instance_as_hal::<A>()
|
||||
unsafe { self.0.instance_as_hal::<A>() }
|
||||
}
|
||||
|
||||
pub unsafe fn from_core_instance(core_instance: wgc::instance::Instance) -> Self {
|
||||
Self(wgc::hub::Global::from_instance(
|
||||
wgc::hub::IdentityManagerFactory,
|
||||
core_instance,
|
||||
))
|
||||
Self(unsafe {
|
||||
wgc::hub::Global::from_instance(wgc::hub::IdentityManagerFactory, core_instance)
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn global(&self) -> &wgc::hub::Global<wgc::hub::IdentityManagerFactory> {
|
||||
@@ -76,7 +77,7 @@ impl Context {
|
||||
&self,
|
||||
hal_adapter: hal::ExposedAdapter<A>,
|
||||
) -> wgc::id::AdapterId {
|
||||
self.0.create_adapter_from_hal(hal_adapter, ())
|
||||
unsafe { self.0.create_adapter_from_hal(hal_adapter, ()) }
|
||||
}
|
||||
|
||||
pub unsafe fn adapter_as_hal<A: wgc::hub::HalApi, F: FnOnce(Option<&A::Adapter>) -> R, R>(
|
||||
@@ -84,8 +85,10 @@ impl Context {
|
||||
adapter: wgc::id::AdapterId,
|
||||
hal_adapter_callback: F,
|
||||
) -> R {
|
||||
self.0
|
||||
.adapter_as_hal::<A, F, R>(adapter, hal_adapter_callback)
|
||||
unsafe {
|
||||
self.0
|
||||
.adapter_as_hal::<A, F, R>(adapter, hal_adapter_callback)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
@@ -97,13 +100,15 @@ impl Context {
|
||||
trace_dir: Option<&std::path::Path>,
|
||||
) -> Result<(Device, Queue), crate::RequestDeviceError> {
|
||||
let global = &self.0;
|
||||
let (device_id, error) = global.create_device_from_hal(
|
||||
*adapter,
|
||||
hal_device,
|
||||
&desc.map_label(|l| l.map(Borrowed)),
|
||||
trace_dir,
|
||||
(),
|
||||
);
|
||||
let (device_id, error) = unsafe {
|
||||
global.create_device_from_hal(
|
||||
*adapter,
|
||||
hal_device,
|
||||
&desc.map_label(|l| l.map(Borrowed)),
|
||||
trace_dir,
|
||||
(),
|
||||
)
|
||||
};
|
||||
if let Some(err) = error {
|
||||
self.handle_error_fatal(err, "Adapter::create_device_from_hal");
|
||||
}
|
||||
@@ -128,12 +133,14 @@ impl Context {
|
||||
desc: &TextureDescriptor,
|
||||
) -> Texture {
|
||||
let global = &self.0;
|
||||
let (id, error) = global.create_texture_from_hal::<A>(
|
||||
hal_texture,
|
||||
device.id,
|
||||
&desc.map_label(|l| l.map(Borrowed)),
|
||||
(),
|
||||
);
|
||||
let (id, error) = unsafe {
|
||||
global.create_texture_from_hal::<A>(
|
||||
hal_texture,
|
||||
device.id,
|
||||
&desc.map_label(|l| l.map(Borrowed)),
|
||||
(),
|
||||
)
|
||||
};
|
||||
if let Some(cause) = error {
|
||||
self.handle_error(
|
||||
&device.error_sink,
|
||||
@@ -155,8 +162,10 @@ impl Context {
|
||||
device: &Device,
|
||||
hal_device_callback: F,
|
||||
) -> R {
|
||||
self.0
|
||||
.device_as_hal::<A, F, R>(device.id, hal_device_callback)
|
||||
unsafe {
|
||||
self.0
|
||||
.device_as_hal::<A, F, R>(device.id, hal_device_callback)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
@@ -169,8 +178,10 @@ impl Context {
|
||||
surface: &Surface,
|
||||
hal_surface_callback: F,
|
||||
) -> R {
|
||||
self.0
|
||||
.surface_as_hal_mut::<A, F, R>(surface.id, hal_surface_callback)
|
||||
unsafe {
|
||||
self.0
|
||||
.surface_as_hal_mut::<A, F, R>(surface.id, hal_surface_callback)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
@@ -179,8 +190,10 @@ impl Context {
|
||||
texture: &Texture,
|
||||
hal_texture_callback: F,
|
||||
) {
|
||||
self.0
|
||||
.texture_as_hal::<A, F>(texture.id, hal_texture_callback)
|
||||
unsafe {
|
||||
self.0
|
||||
.texture_as_hal::<A, F>(texture.id, hal_texture_callback)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
@@ -232,7 +245,7 @@ impl Context {
|
||||
self: &Arc<Self>,
|
||||
visual: *mut std::ffi::c_void,
|
||||
) -> crate::Surface {
|
||||
let id = self.0.instance_create_surface_from_visual(visual, ());
|
||||
let id = unsafe { self.0.instance_create_surface_from_visual(visual, ()) };
|
||||
crate::Surface {
|
||||
context: Arc::clone(self),
|
||||
id: Surface {
|
||||
@@ -1265,7 +1278,7 @@ impl crate::Context for Context {
|
||||
label: desc.label.map(Borrowed),
|
||||
// Doesn't matter the value since spirv shaders aren't mutated to include
|
||||
// runtime checks
|
||||
shader_bound_checks: wgt::ShaderBoundChecks::unchecked(),
|
||||
shader_bound_checks: unsafe { wgt::ShaderBoundChecks::unchecked() },
|
||||
};
|
||||
let (id, error) = wgc::gfx_select!(
|
||||
device.id => global.device_create_shader_module_spirv(device.id, &descriptor, Borrowed(&desc.source), ())
|
||||
|
||||
+54
-39
@@ -4,7 +4,7 @@
|
||||
|
||||
#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
|
||||
#![doc(html_logo_url = "https://raw.githubusercontent.com/gfx-rs/wgpu/master/logo.png")]
|
||||
#![warn(missing_docs)]
|
||||
#![warn(missing_docs, unsafe_op_in_unsafe_fn)]
|
||||
|
||||
mod backend;
|
||||
pub mod util;
|
||||
@@ -1738,7 +1738,7 @@ impl Instance {
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
|
||||
pub unsafe fn from_hal<A: wgc::hub::HalApi>(hal_instance: A::Instance) -> Self {
|
||||
Self {
|
||||
context: Arc::new(C::from_hal_instance::<A>(hal_instance)),
|
||||
context: Arc::new(unsafe { C::from_hal_instance::<A>(hal_instance) }),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1754,7 +1754,7 @@ impl Instance {
|
||||
/// [`Instance`]: hal::Api::Instance
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "webgl"))]
|
||||
pub unsafe fn as_hal<A: wgc::hub::HalApi>(&self) -> Option<&A::Instance> {
|
||||
self.context.instance_as_hal::<A>()
|
||||
unsafe { self.context.instance_as_hal::<A>() }
|
||||
}
|
||||
|
||||
/// Create an new instance of wgpu from a wgpu-core instance.
|
||||
@@ -1769,7 +1769,7 @@ impl Instance {
|
||||
#[cfg(any(not(target_arch = "wasm32"), feature = "webgl"))]
|
||||
pub unsafe fn from_core(core_instance: wgc::instance::Instance) -> Self {
|
||||
Self {
|
||||
context: Arc::new(C::from_core_instance(core_instance)),
|
||||
context: Arc::new(unsafe { C::from_core_instance(core_instance) }),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1815,7 +1815,7 @@ impl Instance {
|
||||
hal_adapter: hal::ExposedAdapter<A>,
|
||||
) -> Adapter {
|
||||
let context = Arc::clone(&self.context);
|
||||
let id = context.create_adapter_from_hal(hal_adapter);
|
||||
let id = unsafe { context.create_adapter_from_hal(hal_adapter) };
|
||||
Adapter { context, id }
|
||||
}
|
||||
|
||||
@@ -1855,7 +1855,7 @@ impl Instance {
|
||||
&self,
|
||||
layer: *mut std::ffi::c_void,
|
||||
) -> Surface {
|
||||
self.context.create_surface_from_core_animation_layer(layer)
|
||||
unsafe { self.context.create_surface_from_core_animation_layer(layer) }
|
||||
}
|
||||
|
||||
/// Creates a surface from `IDCompositionVisual`.
|
||||
@@ -1865,7 +1865,7 @@ impl Instance {
|
||||
/// - visual must be a valid IDCompositionVisual to create a surface upon.
|
||||
#[cfg(target_os = "windows")]
|
||||
pub unsafe fn create_surface_from_visual(&self, visual: *mut std::ffi::c_void) -> Surface {
|
||||
self.context.create_surface_from_visual(visual)
|
||||
unsafe { self.context.create_surface_from_visual(visual) }
|
||||
}
|
||||
|
||||
/// Creates a surface from a `web_sys::HtmlCanvasElement`.
|
||||
@@ -1978,20 +1978,22 @@ impl Adapter {
|
||||
trace_path: Option<&std::path::Path>,
|
||||
) -> Result<(Device, Queue), RequestDeviceError> {
|
||||
let context = Arc::clone(&self.context);
|
||||
self.context
|
||||
.create_device_from_hal(&self.id, hal_device, desc, trace_path)
|
||||
.map(|(device_id, queue_id)| {
|
||||
(
|
||||
Device {
|
||||
context: Arc::clone(&context),
|
||||
id: device_id,
|
||||
},
|
||||
Queue {
|
||||
context,
|
||||
id: queue_id,
|
||||
},
|
||||
)
|
||||
})
|
||||
unsafe {
|
||||
self.context
|
||||
.create_device_from_hal(&self.id, hal_device, desc, trace_path)
|
||||
}
|
||||
.map(|(device_id, queue_id)| {
|
||||
(
|
||||
Device {
|
||||
context: Arc::clone(&context),
|
||||
id: device_id,
|
||||
},
|
||||
Queue {
|
||||
context,
|
||||
id: queue_id,
|
||||
},
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Apply a callback to this `Adapter`'s underlying backend adapter.
|
||||
@@ -2018,8 +2020,10 @@ impl Adapter {
|
||||
&self,
|
||||
hal_adapter_callback: F,
|
||||
) -> R {
|
||||
self.context
|
||||
.adapter_as_hal::<A, F, R>(self.id, hal_adapter_callback)
|
||||
unsafe {
|
||||
self.context
|
||||
.adapter_as_hal::<A, F, R>(self.id, hal_adapter_callback)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether this adapter may present to the passed surface.
|
||||
@@ -2119,12 +2123,14 @@ impl Device {
|
||||
) -> ShaderModule {
|
||||
ShaderModule {
|
||||
context: Arc::clone(&self.context),
|
||||
id: Context::device_create_shader_module(
|
||||
&*self.context,
|
||||
&self.id,
|
||||
desc,
|
||||
wgt::ShaderBoundChecks::unchecked(),
|
||||
),
|
||||
id: unsafe {
|
||||
Context::device_create_shader_module(
|
||||
&*self.context,
|
||||
&self.id,
|
||||
desc,
|
||||
wgt::ShaderBoundChecks::unchecked(),
|
||||
)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2142,7 +2148,9 @@ impl Device {
|
||||
) -> ShaderModule {
|
||||
ShaderModule {
|
||||
context: Arc::clone(&self.context),
|
||||
id: Context::device_create_shader_module_spirv(&*self.context, &self.id, desc),
|
||||
id: unsafe {
|
||||
Context::device_create_shader_module_spirv(&*self.context, &self.id, desc)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2252,9 +2260,10 @@ impl Device {
|
||||
) -> Texture {
|
||||
Texture {
|
||||
context: Arc::clone(&self.context),
|
||||
id: self
|
||||
.context
|
||||
.create_texture_from_hal::<A>(hal_texture, &self.id, desc),
|
||||
id: unsafe {
|
||||
self.context
|
||||
.create_texture_from_hal::<A>(hal_texture, &self.id, desc)
|
||||
},
|
||||
owned: true,
|
||||
}
|
||||
}
|
||||
@@ -2326,8 +2335,10 @@ impl Device {
|
||||
&self,
|
||||
hal_device_callback: F,
|
||||
) -> R {
|
||||
self.context
|
||||
.device_as_hal::<A, F, R>(&self.id, hal_device_callback)
|
||||
unsafe {
|
||||
self.context
|
||||
.device_as_hal::<A, F, R>(&self.id, hal_device_callback)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2637,8 +2648,10 @@ impl Texture {
|
||||
&self,
|
||||
hal_texture_callback: F,
|
||||
) {
|
||||
self.context
|
||||
.texture_as_hal::<A, F>(&self.id, hal_texture_callback)
|
||||
unsafe {
|
||||
self.context
|
||||
.texture_as_hal::<A, F>(&self.id, hal_texture_callback)
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a view of this texture.
|
||||
@@ -3795,8 +3808,10 @@ impl Surface {
|
||||
&mut self,
|
||||
hal_surface_callback: F,
|
||||
) -> R {
|
||||
self.context
|
||||
.surface_as_hal_mut::<A, F, R>(&self.id, hal_surface_callback)
|
||||
unsafe {
|
||||
self.context
|
||||
.surface_as_hal_mut::<A, F, R>(&self.id, hal_surface_callback)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user