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