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