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 const DawnProcTable& GetProcsAutogen(); 26 GetProcs()27 const 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 48 Adapter::Adapter(const Adapter& other) = default; 49 Adapter& Adapter::operator=(const Adapter& other) = default; 50 GetProperties(wgpu::AdapterProperties * properties) const51 void Adapter::GetProperties(wgpu::AdapterProperties* properties) const { 52 properties->backendType = mImpl->GetBackendType(); 53 properties->adapterType = mImpl->GetAdapterType(); 54 properties->driverDescription = mImpl->GetDriverDescription().c_str(); 55 properties->deviceID = mImpl->GetPCIInfo().deviceId; 56 properties->vendorID = mImpl->GetPCIInfo().vendorId; 57 properties->name = mImpl->GetPCIInfo().name.c_str(); 58 } 59 GetBackendType() const60 BackendType Adapter::GetBackendType() const { 61 switch (mImpl->GetBackendType()) { 62 case wgpu::BackendType::D3D12: 63 return BackendType::D3D12; 64 case wgpu::BackendType::Metal: 65 return BackendType::Metal; 66 case wgpu::BackendType::Null: 67 return BackendType::Null; 68 case wgpu::BackendType::OpenGL: 69 return BackendType::OpenGL; 70 case wgpu::BackendType::Vulkan: 71 return BackendType::Vulkan; 72 73 case wgpu::BackendType::D3D11: 74 case wgpu::BackendType::OpenGLES: 75 UNREACHABLE(); 76 } 77 } 78 GetDeviceType() const79 DeviceType Adapter::GetDeviceType() const { 80 switch (mImpl->GetAdapterType()) { 81 case wgpu::AdapterType::DiscreteGPU: 82 return DeviceType::DiscreteGPU; 83 case wgpu::AdapterType::IntegratedGPU: 84 return DeviceType::IntegratedGPU; 85 case wgpu::AdapterType::CPU: 86 return DeviceType::CPU; 87 case wgpu::AdapterType::Unknown: 88 return DeviceType::Unknown; 89 } 90 } 91 GetPCIInfo() const92 const PCIInfo& Adapter::GetPCIInfo() const { 93 return mImpl->GetPCIInfo(); 94 } 95 GetSupportedExtensions() const96 std::vector<const char*> Adapter::GetSupportedExtensions() const { 97 ExtensionsSet supportedExtensionsSet = mImpl->GetSupportedExtensions(); 98 return supportedExtensionsSet.GetEnabledExtensionNames(); 99 } 100 GetAdapterProperties() const101 WGPUDeviceProperties Adapter::GetAdapterProperties() const { 102 return mImpl->GetAdapterProperties(); 103 } 104 operator bool() const105 Adapter::operator bool() const { 106 return mImpl != nullptr; 107 } 108 CreateDevice(const DeviceDescriptor * deviceDescriptor)109 WGPUDevice Adapter::CreateDevice(const DeviceDescriptor* deviceDescriptor) { 110 return reinterpret_cast<WGPUDevice>(mImpl->CreateDevice(deviceDescriptor)); 111 } 112 113 // AdapterDiscoverOptionsBase 114 AdapterDiscoveryOptionsBase(WGPUBackendType type)115 AdapterDiscoveryOptionsBase::AdapterDiscoveryOptionsBase(WGPUBackendType type) 116 : backendType(type) { 117 } 118 119 // Instance 120 Instance()121 Instance::Instance() : mImpl(InstanceBase::Create()) { 122 } 123 ~Instance()124 Instance::~Instance() { 125 if (mImpl != nullptr) { 126 mImpl->Release(); 127 mImpl = nullptr; 128 } 129 } 130 DiscoverDefaultAdapters()131 void Instance::DiscoverDefaultAdapters() { 132 mImpl->DiscoverDefaultAdapters(); 133 } 134 DiscoverAdapters(const AdapterDiscoveryOptionsBase * options)135 bool Instance::DiscoverAdapters(const AdapterDiscoveryOptionsBase* options) { 136 return mImpl->DiscoverAdapters(options); 137 } 138 GetAdapters() const139 std::vector<Adapter> Instance::GetAdapters() const { 140 // Adapters are owned by mImpl so it is safe to return non RAII pointers to them 141 std::vector<Adapter> adapters; 142 for (const std::unique_ptr<AdapterBase>& adapter : mImpl->GetAdapters()) { 143 adapters.push_back({adapter.get()}); 144 } 145 return adapters; 146 } 147 GetToggleInfo(const char * toggleName)148 const ToggleInfo* Instance::GetToggleInfo(const char* toggleName) { 149 return mImpl->GetToggleInfo(toggleName); 150 } 151 EnableBackendValidation(bool enableBackendValidation)152 void Instance::EnableBackendValidation(bool enableBackendValidation) { 153 mImpl->EnableBackendValidation(enableBackendValidation); 154 } 155 EnableGPUBasedBackendValidation(bool enableGPUBasedBackendValidation)156 void Instance::EnableGPUBasedBackendValidation(bool enableGPUBasedBackendValidation) { 157 mImpl->EnableGPUBasedBackendValidation(enableGPUBasedBackendValidation); 158 } 159 EnableBeginCaptureOnStartup(bool beginCaptureOnStartup)160 void Instance::EnableBeginCaptureOnStartup(bool beginCaptureOnStartup) { 161 mImpl->EnableBeginCaptureOnStartup(beginCaptureOnStartup); 162 } 163 SetPlatform(dawn_platform::Platform * platform)164 void Instance::SetPlatform(dawn_platform::Platform* platform) { 165 mImpl->SetPlatform(platform); 166 } 167 Get() const168 WGPUInstance Instance::Get() const { 169 return reinterpret_cast<WGPUInstance>(mImpl); 170 } 171 GetLazyClearCountForTesting(WGPUDevice device)172 size_t GetLazyClearCountForTesting(WGPUDevice device) { 173 dawn_native::DeviceBase* deviceBase = reinterpret_cast<dawn_native::DeviceBase*>(device); 174 return deviceBase->GetLazyClearCountForTesting(); 175 } 176 GetDeprecationWarningCountForTesting(WGPUDevice device)177 size_t GetDeprecationWarningCountForTesting(WGPUDevice device) { 178 dawn_native::DeviceBase* deviceBase = reinterpret_cast<dawn_native::DeviceBase*>(device); 179 return deviceBase->GetDeprecationWarningCountForTesting(); 180 } 181 IsTextureSubresourceInitialized(WGPUTexture texture,uint32_t baseMipLevel,uint32_t levelCount,uint32_t baseArrayLayer,uint32_t layerCount,WGPUTextureAspect aspect)182 bool IsTextureSubresourceInitialized(WGPUTexture texture, 183 uint32_t baseMipLevel, 184 uint32_t levelCount, 185 uint32_t baseArrayLayer, 186 uint32_t layerCount, 187 WGPUTextureAspect aspect) { 188 dawn_native::TextureBase* textureBase = 189 reinterpret_cast<dawn_native::TextureBase*>(texture); 190 SubresourceRange range = { 191 baseMipLevel, levelCount, baseArrayLayer, layerCount, 192 ConvertAspect(textureBase->GetFormat(), static_cast<wgpu::TextureAspect>(aspect))}; 193 return textureBase->IsSubresourceContentInitialized(range); 194 } 195 196 std::vector<const char*> GetProcMapNamesForTestingInternal(); 197 GetProcMapNamesForTesting()198 std::vector<const char*> GetProcMapNamesForTesting() { 199 return GetProcMapNamesForTestingInternal(); 200 } 201 DeviceTick(WGPUDevice device)202 DAWN_NATIVE_EXPORT bool DeviceTick(WGPUDevice device) { 203 dawn_native::DeviceBase* deviceBase = reinterpret_cast<dawn_native::DeviceBase*>(device); 204 return deviceBase->Tick(); 205 } 206 207 // ExternalImageDescriptor 208 ExternalImageDescriptor(ExternalImageType type)209 ExternalImageDescriptor::ExternalImageDescriptor(ExternalImageType type) : type(type) { 210 } 211 212 // ExternalImageExportInfo 213 ExternalImageExportInfo(ExternalImageType type)214 ExternalImageExportInfo::ExternalImageExportInfo(ExternalImageType type) : type(type) { 215 } 216 217 } // namespace dawn_native 218