1 // Copyright 2018 The Dawn Authors 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "dawn_native/DawnNative.h" 16 #include "dawn_native/Device.h" 17 #include "dawn_native/Instance.h" 18 #include "dawn_native/Texture.h" 19 #include "dawn_platform/DawnPlatform.h" 20 21 // Contains the entry-points into dawn_native 22 23 namespace dawn_native { 24 25 DawnProcTable GetProcsAutogen(); 26 GetProcs()27 DawnProcTable GetProcs() { 28 return GetProcsAutogen(); 29 } 30 GetTogglesUsed(WGPUDevice device)31 std::vector<const char*> GetTogglesUsed(WGPUDevice device) { 32 const dawn_native::DeviceBase* deviceBase = 33 reinterpret_cast<const dawn_native::DeviceBase*>(device); 34 return deviceBase->GetTogglesUsed(); 35 } 36 37 // Adapter 38 39 Adapter::Adapter() = default; 40 Adapter(AdapterBase * impl)41 Adapter::Adapter(AdapterBase* impl) : mImpl(impl) { 42 } 43 ~Adapter()44 Adapter::~Adapter() { 45 mImpl = nullptr; 46 } 47 GetProperties(wgpu::AdapterProperties * properties) const48 void Adapter::GetProperties(wgpu::AdapterProperties* properties) const { 49 properties->backendType = mImpl->GetBackendType(); 50 properties->adapterType = mImpl->GetAdapterType(); 51 properties->deviceID = mImpl->GetPCIInfo().deviceId; 52 properties->vendorID = mImpl->GetPCIInfo().vendorId; 53 properties->name = mImpl->GetPCIInfo().name.c_str(); 54 } 55 GetBackendType() const56 BackendType Adapter::GetBackendType() const { 57 switch (mImpl->GetBackendType()) { 58 case wgpu::BackendType::D3D12: 59 return BackendType::D3D12; 60 case wgpu::BackendType::Metal: 61 return BackendType::Metal; 62 case wgpu::BackendType::Null: 63 return BackendType::Null; 64 case wgpu::BackendType::OpenGL: 65 return BackendType::OpenGL; 66 case wgpu::BackendType::Vulkan: 67 return BackendType::Vulkan; 68 default: 69 UNREACHABLE(); 70 } 71 } 72 GetDeviceType() const73 DeviceType Adapter::GetDeviceType() const { 74 switch (mImpl->GetAdapterType()) { 75 case wgpu::AdapterType::DiscreteGPU: 76 return DeviceType::DiscreteGPU; 77 case wgpu::AdapterType::IntegratedGPU: 78 return DeviceType::IntegratedGPU; 79 case wgpu::AdapterType::CPU: 80 return DeviceType::CPU; 81 case wgpu::AdapterType::Unknown: 82 return DeviceType::Unknown; 83 default: 84 UNREACHABLE(); 85 } 86 } 87 GetPCIInfo() const88 const PCIInfo& Adapter::GetPCIInfo() const { 89 return mImpl->GetPCIInfo(); 90 } 91 GetSupportedExtensions() const92 std::vector<const char*> Adapter::GetSupportedExtensions() const { 93 ExtensionsSet supportedExtensionsSet = mImpl->GetSupportedExtensions(); 94 return supportedExtensionsSet.GetEnabledExtensionNames(); 95 } 96 GetAdapterProperties() const97 WGPUDeviceProperties Adapter::GetAdapterProperties() const { 98 return mImpl->GetAdapterProperties(); 99 } 100 operator bool() const101 Adapter::operator bool() const { 102 return mImpl != nullptr; 103 } 104 CreateDevice(const DeviceDescriptor * deviceDescriptor)105 WGPUDevice Adapter::CreateDevice(const DeviceDescriptor* deviceDescriptor) { 106 return reinterpret_cast<WGPUDevice>(mImpl->CreateDevice(deviceDescriptor)); 107 } 108 109 // AdapterDiscoverOptionsBase 110 AdapterDiscoveryOptionsBase(WGPUBackendType type)111 AdapterDiscoveryOptionsBase::AdapterDiscoveryOptionsBase(WGPUBackendType type) 112 : backendType(type) { 113 } 114 115 // Instance 116 Instance()117 Instance::Instance() : mImpl(InstanceBase::Create()) { 118 } 119 ~Instance()120 Instance::~Instance() { 121 if (mImpl != nullptr) { 122 mImpl->Release(); 123 mImpl = nullptr; 124 } 125 } 126 DiscoverDefaultAdapters()127 void Instance::DiscoverDefaultAdapters() { 128 mImpl->DiscoverDefaultAdapters(); 129 } 130 DiscoverAdapters(const AdapterDiscoveryOptionsBase * options)131 bool Instance::DiscoverAdapters(const AdapterDiscoveryOptionsBase* options) { 132 return mImpl->DiscoverAdapters(options); 133 } 134 GetAdapters() const135 std::vector<Adapter> Instance::GetAdapters() const { 136 // Adapters are owned by mImpl so it is safe to return non RAII pointers to them 137 std::vector<Adapter> adapters; 138 for (const std::unique_ptr<AdapterBase>& adapter : mImpl->GetAdapters()) { 139 adapters.push_back({adapter.get()}); 140 } 141 return adapters; 142 } 143 GetToggleInfo(const char * toggleName)144 const ToggleInfo* Instance::GetToggleInfo(const char* toggleName) { 145 return mImpl->GetToggleInfo(toggleName); 146 } 147 EnableBackendValidation(bool enableBackendValidation)148 void Instance::EnableBackendValidation(bool enableBackendValidation) { 149 mImpl->EnableBackendValidation(enableBackendValidation); 150 } 151 EnableBeginCaptureOnStartup(bool beginCaptureOnStartup)152 void Instance::EnableBeginCaptureOnStartup(bool beginCaptureOnStartup) { 153 mImpl->EnableBeginCaptureOnStartup(beginCaptureOnStartup); 154 } 155 SetPlatform(dawn_platform::Platform * platform)156 void Instance::SetPlatform(dawn_platform::Platform* platform) { 157 mImpl->SetPlatform(platform); 158 } 159 Get() const160 WGPUInstance Instance::Get() const { 161 return reinterpret_cast<WGPUInstance>(mImpl); 162 } 163 GetLazyClearCountForTesting(WGPUDevice device)164 size_t GetLazyClearCountForTesting(WGPUDevice device) { 165 dawn_native::DeviceBase* deviceBase = reinterpret_cast<dawn_native::DeviceBase*>(device); 166 return deviceBase->GetLazyClearCountForTesting(); 167 } 168 IsTextureSubresourceInitialized(WGPUTexture texture,uint32_t baseMipLevel,uint32_t levelCount,uint32_t baseArrayLayer,uint32_t layerCount)169 bool IsTextureSubresourceInitialized(WGPUTexture texture, 170 uint32_t baseMipLevel, 171 uint32_t levelCount, 172 uint32_t baseArrayLayer, 173 uint32_t layerCount) { 174 dawn_native::TextureBase* textureBase = 175 reinterpret_cast<dawn_native::TextureBase*>(texture); 176 return textureBase->IsSubresourceContentInitialized(baseMipLevel, levelCount, 177 baseArrayLayer, layerCount); 178 } 179 180 std::vector<const char*> GetProcMapNamesForTestingInternal(); 181 GetProcMapNamesForTesting()182 std::vector<const char*> GetProcMapNamesForTesting() { 183 return GetProcMapNamesForTestingInternal(); 184 } 185 ExternalImageDescriptor(ExternalImageDescriptorType type)186 ExternalImageDescriptor::ExternalImageDescriptor(ExternalImageDescriptorType type) 187 : type(type) { 188 } 189 190 } // namespace dawn_native 191