[dx12] update d3d12 to 0.3 and use explicit linking

Author: kvark

src/backend/dx12/Cargo.toml

@@ -23,7 +23,7 @@ auxil = { path = "../../auxil/auxil", version = "0.2", package = "gfx-auxil", fe
 hal = { path = "../../hal", version = "0.4", package = "gfx-hal" }
 range-alloc = { path = "../../auxil/range-alloc", version = "0.1" }
 bitflags = "1"
-native = { version = "0.2.2", package = "d3d12" }
+native = { package = "d3d12", version = "0.3", features = ["libloading"] }
 log = { version = "0.4" }
 smallvec = "0.6"
 spirv_cross = { version = "0.16", features = ["hlsl"] }

src/backend/dx12/src/command.rs

@@ -32,8 +32,6 @@ use winapi::{
     Interface,
 };
 
-use device::{ViewInfo, IDENTITY_MAPPING};
-use native::descriptor;
 use smallvec::SmallVec;
 
 use crate::{
@@ -676,12 +674,12 @@ impl CommandBuffer {
         stencil: Option<u32>,
         rects: &[d3d12::D3D12_RECT],
     ) {
-        let mut flags = native::command_list::ClearFlags::empty();
+        let mut flags = native::ClearFlags::empty();
         if depth.is_some() {
-            flags |= native::command_list::ClearFlags::DEPTH;
+            flags |= native::ClearFlags::DEPTH;
         }
         if stencil.is_some() {
-            flags |= native::command_list::ClearFlags::STENCIL;
+            flags |= native::ClearFlags::STENCIL;
         }
 
         self.raw.clear_depth_stencil_view(
@@ -1482,7 +1480,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
 
                     let mut rtv_pool = descriptors_cpu::HeapLinear::new(
                         device,
-                        descriptor::HeapType::Rtv,
+                        native::DescriptorHeapType::Rtv,
                         clear_rects.len(),
                     );
 
@@ -1496,7 +1494,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
                             caps: image::ViewCapabilities::empty(),
                             view_kind: image::ViewKind::D2Array,
                             format: attachment.dxgi_format,
-                            component_mapping: IDENTITY_MAPPING,
+                            component_mapping: device::IDENTITY_MAPPING,
                             range: image::SubresourceRange {
                                 aspects: Aspects::COLOR,
                                 levels: attachment.mip_levels.0 .. attachment.mip_levels.1,
@@ -1519,7 +1517,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
 
                     let mut dsv_pool = descriptors_cpu::HeapLinear::new(
                         device,
-                        descriptor::HeapType::Dsv,
+                        native::DescriptorHeapType::Dsv,
                         clear_rects.len(),
                     );
 
@@ -1533,7 +1531,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
                             caps: image::ViewCapabilities::empty(),
                             view_kind: image::ViewKind::D2Array,
                             format: attachment.dxgi_format,
-                            component_mapping: IDENTITY_MAPPING,
+                            component_mapping: device::IDENTITY_MAPPING,
                             range: image::SubresourceRange {
                                 aspects: if depth.is_some() {
                                     Aspects::DEPTH
@@ -1650,17 +1648,17 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
         // Descriptor heap for the current blit, only storing the src image
         let (srv_heap, _) = device.create_descriptor_heap(
             1,
-            descriptor::HeapType::CbvSrvUav,
-            descriptor::HeapFlags::SHADER_VISIBLE,
+            native::DescriptorHeapType::CbvSrvUav,
+            native::DescriptorHeapFlags::SHADER_VISIBLE,
             0,
         );
-        let srv_desc = Device::build_image_as_shader_resource_desc(&ViewInfo {
+        let srv_desc = Device::build_image_as_shader_resource_desc(&device::ViewInfo {
             resource: src.resource,
             kind: src.kind,
             caps: src.view_caps,
             view_kind: image::ViewKind::D2Array, // TODO
             format: src.default_view_format.unwrap(),
-            component_mapping: IDENTITY_MAPPING,
+            component_mapping: device::IDENTITY_MAPPING,
             range: image::SubresourceRange {
                 aspects: format::Aspects::COLOR, // TODO
                 levels: 0 .. src.descriptor.MipLevels as _,
@@ -1698,7 +1696,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
             // WORKAROUND: renderdoc crashes if we destroy the pool too early
             let rtv_pool = Device::create_descriptor_heap_impl(
                 device,
-                descriptor::HeapType::Rtv,
+                native::DescriptorHeapType::Rtv,
                 false,
                 num_layers as _,
             );
@@ -2526,7 +2524,7 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
 
     unsafe fn begin_query(&mut self, query: query::Query<Backend>, flags: query::ControlFlags) {
         let query_ty = match query.pool.ty {
-            native::query::HeapType::Occlusion => {
+            native::QueryHeapType::Occlusion => {
                 if flags.contains(query::ControlFlags::PRECISE) {
                     self.occlusion_query = Some(OcclusionQuery::Precise(query.id));
                     d3d12::D3D12_QUERY_TYPE_OCCLUSION
@@ -2537,8 +2535,8 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
                     d3d12::D3D12_QUERY_TYPE_BINARY_OCCLUSION
                 }
             }
-            native::query::HeapType::Timestamp => panic!("Timestap queries are issued via "),
-            native::query::HeapType::PipelineStatistics => {
+            native::QueryHeapType::Timestamp => panic!("Timestap queries are issued via "),
+            native::QueryHeapType::PipelineStatistics => {
                 self.pipeline_stats_query = Some(query.id);
                 d3d12::D3D12_QUERY_TYPE_PIPELINE_STATISTICS
             }
@@ -2552,19 +2550,19 @@ impl com::CommandBuffer<Backend> for CommandBuffer {
     unsafe fn end_query(&mut self, query: query::Query<Backend>) {
         let id = query.id;
         let query_ty = match query.pool.ty {
-            native::query::HeapType::Occlusion
+            native::QueryHeapType::Occlusion
                 if self.occlusion_query == Some(OcclusionQuery::Precise(id)) =>
             {
                 self.occlusion_query = None;
                 d3d12::D3D12_QUERY_TYPE_OCCLUSION
             }
-            native::query::HeapType::Occlusion
+            native::QueryHeapType::Occlusion
                 if self.occlusion_query == Some(OcclusionQuery::Binary(id)) =>
             {
                 self.occlusion_query = None;
                 d3d12::D3D12_QUERY_TYPE_BINARY_OCCLUSION
             }
-            native::query::HeapType::PipelineStatistics
+            native::QueryHeapType::PipelineStatistics
                 if self.pipeline_stats_query == Some(id) =>
             {
                 self.pipeline_stats_query = None;

src/backend/dx12/src/conv.rs

@@ -19,7 +19,7 @@ use hal::{
     pso,
 };
 
-use native::descriptor::ShaderVisibility;
+use native::ShaderVisibility;
 
 pub fn map_format(format: Format) -> Option<DXGI_FORMAT> {
     use hal::format::Format::*;

src/backend/dx12/src/descriptors_cpu.rs

@@ -1,4 +1,4 @@
-use native::descriptor::{CpuDescriptor, HeapFlags, HeapType};
+use native::{CpuDescriptor, DescriptorHeapFlags, DescriptorHeapType};
 use std::{collections::HashSet, fmt};
 
 // Linear stack allocator for CPU descriptor heaps.
@@ -17,8 +17,8 @@ impl fmt::Debug for HeapLinear {
 }
 
 impl HeapLinear {
-    pub fn new(device: native::Device, ty: HeapType, size: usize) -> Self {
-        let (heap, _hr) = device.create_descriptor_heap(size as _, ty, HeapFlags::empty(), 0);
+    pub fn new(device: native::Device, ty: DescriptorHeapType, size: usize) -> Self {
+        let (heap, _hr) = device.create_descriptor_heap(size as _, ty, DescriptorHeapFlags::empty(), 0);
 
         HeapLinear {
             handle_size: device.get_descriptor_increment_size(ty) as _,
@@ -74,9 +74,9 @@ impl fmt::Debug for Heap {
 }
 
 impl Heap {
-    pub fn new(device: native::Device, ty: HeapType) -> Self {
+    pub fn new(device: native::Device, ty: DescriptorHeapType) -> Self {
         let (heap, _hr) =
-            device.create_descriptor_heap(HEAP_SIZE_FIXED as _, ty, HeapFlags::empty(), 0);
+            device.create_descriptor_heap(HEAP_SIZE_FIXED as _, ty, DescriptorHeapFlags::empty(), 0);
 
         Heap {
             handle_size: device.get_descriptor_increment_size(ty) as _,
@@ -109,7 +109,7 @@ impl Heap {
 
 pub struct DescriptorCpuPool {
     device: native::Device,
-    ty: HeapType,
+    ty: DescriptorHeapType,
     heaps: Vec<Heap>,
     free_list: HashSet<usize>,
 }
@@ -121,7 +121,7 @@ impl fmt::Debug for DescriptorCpuPool {
 }
 
 impl DescriptorCpuPool {
-    pub fn new(device: native::Device, ty: HeapType) -> Self {
+    pub fn new(device: native::Device, ty: DescriptorHeapType) -> Self {
         DescriptorCpuPool {
             device,
             ty,

src/backend/dx12/src/device.rs

@@ -50,7 +50,6 @@ use hal::{
 use crate::{
     command as cmd,
     conv,
-    descriptor,
     descriptors_cpu,
     pool::{CommandPool, CommandPoolAllocator},
     resource as r,
@@ -65,8 +64,11 @@ use crate::{
     QUEUE_FAMILIES,
 };
 use native::{
-    command_list::IndirectArgument,
-    pso::{CachedPSO, PipelineStateFlags, PipelineStateSubobject, Subobject},
+    CachedPSO,
+    IndirectArgument,
+    PipelineStateFlags,
+    PipelineStateSubobject,
+    Subobject,
 };
 
 // Register space used for root constants.
@@ -506,7 +508,7 @@ impl Device {
 
     pub(crate) fn create_descriptor_heap_impl(
         device: native::Device,
-        heap_type: descriptor::HeapType,
+        heap_type: native::DescriptorHeapType,
         shader_visible: bool,
         capacity: usize,
     ) -> r::DescriptorHeap {
@@ -516,9 +518,9 @@ impl Device {
             capacity as _,
             heap_type,
             if shader_visible {
-                descriptor::HeapFlags::SHADER_VISIBLE
+                native::DescriptorHeapFlags::SHADER_VISIBLE
             } else {
-                descriptor::HeapFlags::empty()
+                native::DescriptorHeapFlags::empty()
             },
             0,
         );
@@ -1050,7 +1052,7 @@ impl Device {
         };
         let rtv_heap = Device::create_descriptor_heap_impl(
             self.raw,
-            descriptor::HeapType::Rtv,
+            native::DescriptorHeapType::Rtv,
             false,
             config.image_count as _,
         );
@@ -1531,9 +1533,9 @@ impl d::Device<B> for Device {
                 "\tRoot constant set={} range {:?}",
                 ROOT_CONSTANT_SPACE, root_constant.range
             );
-            parameters.push(descriptor::RootParameter::constants(
+            parameters.push(native::RootParameter::constants(
                 conv::map_shader_visibility(root_constant.stages),
-                descriptor::Binding {
+                native::Binding {
                     register: root_constant.range.start as _,
                     space: ROOT_CONSTANT_SPACE,
                 },
@@ -1587,10 +1589,10 @@ impl d::Device<B> for Device {
                 }
 
                 let describe = |bind: &pso::DescriptorSetLayoutBinding, ty| {
-                    descriptor::DescriptorRange::new(
+                    native::DescriptorRange::new(
                         ty,
                         bind.count as _,
-                        descriptor::Binding {
+                        native::Binding {
                             register: bind.binding as _,
                             space,
                         },
@@ -1605,7 +1607,7 @@ impl d::Device<B> for Device {
 
                     if content.is_dynamic() {
                         // Root Descriptor
-                        let binding = descriptor::Binding {
+                        let binding = native::Binding {
                             register: bind.binding as _,
                             space,
                         };
@@ -1614,7 +1616,7 @@ impl d::Device<B> for Device {
                             descriptors.push(r::RootDescriptor {
                                 offset: root_offset,
                             });
-                            parameters.push(descriptor::RootParameter::cbv_descriptor(
+                            parameters.push(native::RootParameter::cbv_descriptor(
                                 visibility, binding,
                             ));
                             root_offset += 2;
@@ -1625,18 +1627,18 @@ impl d::Device<B> for Device {
                     } else {
                         // Descriptor table ranges
                         if content.contains(r::DescriptorContent::CBV) {
-                            ranges.push(describe(bind, descriptor::DescriptorRangeType::CBV));
+                            ranges.push(describe(bind, native::DescriptorRangeType::CBV));
                         }
                         if content.contains(r::DescriptorContent::SRV) {
-                            ranges.push(describe(bind, descriptor::DescriptorRangeType::SRV));
+                            ranges.push(describe(bind, native::DescriptorRangeType::SRV));
                         }
                         if content.contains(r::DescriptorContent::UAV) {
-                            ranges.push(describe(bind, descriptor::DescriptorRangeType::UAV));
+                            ranges.push(describe(bind, native::DescriptorRangeType::UAV));
                         }
                     }
                 }
                 if ranges.len() > range_base {
-                    parameters.push(descriptor::RootParameter::descriptor_table(
+                    parameters.push(native::RootParameter::descriptor_table(
                         visibility,
                         &ranges[range_base ..],
                     ));
@@ -1648,11 +1650,11 @@ impl d::Device<B> for Device {
                 for bind in set.bindings.iter() {
                     let content = r::DescriptorContent::from(bind.ty);
                     if content.contains(r::DescriptorContent::SAMPLER) {
-                        ranges.push(describe(bind, descriptor::DescriptorRangeType::Sampler));
+                        ranges.push(describe(bind, native::DescriptorRangeType::Sampler));
                     }
                 }
                 if ranges.len() > range_base {
-                    parameters.push(descriptor::RootParameter::descriptor_table(
+                    parameters.push(native::RootParameter::descriptor_table(
                         visibility,
                         &ranges[range_base ..],
                     ));
@@ -1674,12 +1676,16 @@ impl d::Device<B> for Device {
         debug_assert_eq!(ranges.len(), total);
 
         // TODO: error handling
-        let ((signature_raw, error), _hr) = native::RootSignature::serialize(
-            descriptor::RootSignatureVersion::V1_0,
+        let (signature_raw, error) = match self.library.serialize_root_signature(
+            native::RootSignatureVersion::V1_0,
             &parameters,
             &[],
-            descriptor::RootSignatureFlags::ALLOW_IA_INPUT_LAYOUT,
-        );
+            native::RootSignatureFlags::ALLOW_IA_INPUT_LAYOUT,
+        ) {
+            Ok((pair, hr)) if winerror::SUCCEEDED(hr) => pair,
+            Ok((_, hr)) => panic!("Can't serialize root signature: {:?}", hr),
+            Err(e) => panic!("Can't find serialization function: {:?}", e),
+        };
 
         if !error.is_null() {
             error!(
@@ -1691,7 +1697,6 @@ impl d::Device<B> for Device {
 
         // TODO: error handling
         let (signature, _hr) = self.raw.create_root_signature(signature_raw, 0);
-        signature_raw.destroy();
 
         Ok(r::PipelineLayout {
             raw: signature,
@@ -2835,7 +2840,7 @@ impl d::Device<B> for Device {
                                 let max_size = 1u64 << 12; //arbitrary
                                 descriptor_update_pools.push(descriptors_cpu::HeapLinear::new(
                                     self.raw,
-                                    descriptor::HeapType::CbvSrvUav,
+                                    native::DescriptorHeapType::CbvSrvUav,
                                     max_size as _,
                                 ));
                             }
@@ -2901,7 +2906,7 @@ impl d::Device<B> for Device {
                                     let max_size = 1u64 << 12; //arbitrary
                                     descriptor_update_pools.push(descriptors_cpu::HeapLinear::new(
                                         self.raw,
-                                        descriptor::HeapType::CbvSrvUav,
+                                        native::DescriptorHeapType::CbvSrvUav,
                                         max_size as _,
                                     ));
                                     heap = descriptor_update_pools.last_mut().unwrap();
@@ -3309,9 +3314,9 @@ impl d::Device<B> for Device {
         count: query::Id,
     ) -> Result<r::QueryPool, query::CreationError> {
         let heap_ty = match query_ty {
-            query::Type::Occlusion => native::query::HeapType::Occlusion,
-            query::Type::PipelineStatistics(_) => native::query::HeapType::PipelineStatistics,
-            query::Type::Timestamp => native::query::HeapType::Timestamp,
+            query::Type::Occlusion => native::QueryHeapType::Occlusion,
+            query::Type::PipelineStatistics(_) => native::QueryHeapType::PipelineStatistics,
+            query::Type::Timestamp => native::QueryHeapType::Timestamp,
         };
 
         let (query_heap, hr) = self.raw.create_query_heap(heap_ty, count, 0);