mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-05-13 10:51:35 +00:00
5397f9f9d0
Adds upstream instance/adapter APIs. In dawn_native, the basic APIs to get limits and properties are implemented, but requestAdapter and requestDevice are not. In dawn_wire, nothing is implemented, but the stub definitions are put in place, as well the mechanism to inject WGPUInstance into the wire. There is a lifetime concern with WGPUInstance and WGPUAdapter on the wire in that we need to ensure that the client cannot free the instance or adapter while they are in use. In the near term, this is not a problem because Chromium will always hold ownership of the instance and adapters outside of the wire - i.e. it won't inject and then release ownership. Bug: dawn:160, dawn:689 Change-Id: Id904272983f23babc9177bc163d78c4fa1044da0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/71520 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Loko Kung <lokokung@google.com> Commit-Queue: Austin Eng <enga@chromium.org>
319 lines
11 KiB
C++
319 lines
11 KiB
C++
// Copyright 2018 The Dawn Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "dawn_native/Instance.h"
|
|
|
|
#include "common/Assert.h"
|
|
#include "common/Log.h"
|
|
#include "dawn_native/ErrorData.h"
|
|
#include "dawn_native/Surface.h"
|
|
#include "dawn_native/ValidationUtils_autogen.h"
|
|
#include "dawn_platform/DawnPlatform.h"
|
|
|
|
#if defined(DAWN_USE_X11)
|
|
# include "dawn_native/XlibXcbFunctions.h"
|
|
#endif // defined(DAWN_USE_X11)
|
|
|
|
namespace dawn_native {
|
|
|
|
// Forward definitions of each backend's "Connect" function that creates new BackendConnection.
|
|
// Conditionally compiled declarations are used to avoid using static constructors instead.
|
|
#if defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
namespace d3d12 {
|
|
BackendConnection* Connect(InstanceBase* instance);
|
|
}
|
|
#endif // defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
#if defined(DAWN_ENABLE_BACKEND_METAL)
|
|
namespace metal {
|
|
BackendConnection* Connect(InstanceBase* instance);
|
|
}
|
|
#endif // defined(DAWN_ENABLE_BACKEND_METAL)
|
|
#if defined(DAWN_ENABLE_BACKEND_NULL)
|
|
namespace null {
|
|
BackendConnection* Connect(InstanceBase* instance);
|
|
}
|
|
#endif // defined(DAWN_ENABLE_BACKEND_NULL)
|
|
#if defined(DAWN_ENABLE_BACKEND_OPENGL)
|
|
namespace opengl {
|
|
BackendConnection* Connect(InstanceBase* instance, wgpu::BackendType backendType);
|
|
}
|
|
#endif // defined(DAWN_ENABLE_BACKEND_OPENGL)
|
|
#if defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
namespace vulkan {
|
|
BackendConnection* Connect(InstanceBase* instance);
|
|
}
|
|
#endif // defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
|
|
namespace {
|
|
|
|
BackendsBitset GetEnabledBackends() {
|
|
BackendsBitset enabledBackends;
|
|
#if defined(DAWN_ENABLE_BACKEND_NULL)
|
|
enabledBackends.set(wgpu::BackendType::Null);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_NULL)
|
|
#if defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
enabledBackends.set(wgpu::BackendType::D3D12);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
#if defined(DAWN_ENABLE_BACKEND_METAL)
|
|
enabledBackends.set(wgpu::BackendType::Metal);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_METAL)
|
|
#if defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
enabledBackends.set(wgpu::BackendType::Vulkan);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
|
|
enabledBackends.set(wgpu::BackendType::OpenGL);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
|
|
#if defined(DAWN_ENABLE_BACKEND_OPENGLES)
|
|
enabledBackends.set(wgpu::BackendType::OpenGLES);
|
|
#endif // defined(DAWN_ENABLE_BACKEND_OPENGLES)
|
|
|
|
return enabledBackends;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
// InstanceBase
|
|
|
|
// static
|
|
InstanceBase* InstanceBase::Create(const InstanceDescriptor* descriptor) {
|
|
Ref<InstanceBase> instance = AcquireRef(new InstanceBase);
|
|
if (!instance->Initialize(descriptor)) {
|
|
return nullptr;
|
|
}
|
|
return instance.Detach();
|
|
}
|
|
|
|
// TODO(crbug.com/dawn/832): make the platform an initialization parameter of the instance.
|
|
bool InstanceBase::Initialize(const InstanceDescriptor*) {
|
|
return true;
|
|
}
|
|
|
|
void InstanceBase::APIRequestAdapter(const RequestAdapterOptions* options,
|
|
WGPURequestAdapterCallback callback,
|
|
void* userdata) {
|
|
callback(WGPURequestAdapterStatus_Error, nullptr, "Not implemented", userdata);
|
|
}
|
|
|
|
void InstanceBase::DiscoverDefaultAdapters() {
|
|
for (wgpu::BackendType b : IterateBitSet(GetEnabledBackends())) {
|
|
EnsureBackendConnection(b);
|
|
}
|
|
|
|
if (mDiscoveredDefaultAdapters) {
|
|
return;
|
|
}
|
|
|
|
// Query and merge all default adapters for all backends
|
|
for (std::unique_ptr<BackendConnection>& backend : mBackends) {
|
|
std::vector<std::unique_ptr<AdapterBase>> backendAdapters =
|
|
backend->DiscoverDefaultAdapters();
|
|
|
|
for (std::unique_ptr<AdapterBase>& adapter : backendAdapters) {
|
|
ASSERT(adapter->GetBackendType() == backend->GetType());
|
|
ASSERT(adapter->GetInstance() == this);
|
|
mAdapters.push_back(std::move(adapter));
|
|
}
|
|
}
|
|
|
|
mDiscoveredDefaultAdapters = true;
|
|
}
|
|
|
|
// This is just a wrapper around the real logic that uses Error.h error handling.
|
|
bool InstanceBase::DiscoverAdapters(const AdapterDiscoveryOptionsBase* options) {
|
|
return !ConsumedError(DiscoverAdaptersInternal(options));
|
|
}
|
|
|
|
const ToggleInfo* InstanceBase::GetToggleInfo(const char* toggleName) {
|
|
return mTogglesInfo.GetToggleInfo(toggleName);
|
|
}
|
|
|
|
Toggle InstanceBase::ToggleNameToEnum(const char* toggleName) {
|
|
return mTogglesInfo.ToggleNameToEnum(toggleName);
|
|
}
|
|
|
|
const FeatureInfo* InstanceBase::GetFeatureInfo(const char* featureName) {
|
|
return mFeaturesInfo.GetFeatureInfo(featureName);
|
|
}
|
|
|
|
Feature InstanceBase::FeatureNameToEnum(const char* featureName) {
|
|
return mFeaturesInfo.FeatureNameToEnum(featureName);
|
|
}
|
|
|
|
FeaturesSet InstanceBase::FeatureNamesToFeaturesSet(
|
|
const std::vector<const char*>& requiredFeatures) {
|
|
return mFeaturesInfo.FeatureNamesToFeaturesSet(requiredFeatures);
|
|
}
|
|
|
|
const std::vector<std::unique_ptr<AdapterBase>>& InstanceBase::GetAdapters() const {
|
|
return mAdapters;
|
|
}
|
|
|
|
void InstanceBase::EnsureBackendConnection(wgpu::BackendType backendType) {
|
|
if (mBackendsConnected[backendType]) {
|
|
return;
|
|
}
|
|
|
|
auto Register = [this](BackendConnection* connection, wgpu::BackendType expectedType) {
|
|
if (connection != nullptr) {
|
|
ASSERT(connection->GetType() == expectedType);
|
|
ASSERT(connection->GetInstance() == this);
|
|
mBackends.push_back(std::unique_ptr<BackendConnection>(connection));
|
|
}
|
|
};
|
|
|
|
switch (backendType) {
|
|
#if defined(DAWN_ENABLE_BACKEND_NULL)
|
|
case wgpu::BackendType::Null:
|
|
Register(null::Connect(this), wgpu::BackendType::Null);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_NULL)
|
|
|
|
#if defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
case wgpu::BackendType::D3D12:
|
|
Register(d3d12::Connect(this), wgpu::BackendType::D3D12);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_D3D12)
|
|
|
|
#if defined(DAWN_ENABLE_BACKEND_METAL)
|
|
case wgpu::BackendType::Metal:
|
|
Register(metal::Connect(this), wgpu::BackendType::Metal);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_METAL)
|
|
|
|
#if defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
case wgpu::BackendType::Vulkan:
|
|
Register(vulkan::Connect(this), wgpu::BackendType::Vulkan);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_VULKAN)
|
|
|
|
#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
|
|
case wgpu::BackendType::OpenGL:
|
|
Register(opengl::Connect(this, wgpu::BackendType::OpenGL),
|
|
wgpu::BackendType::OpenGL);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL)
|
|
|
|
#if defined(DAWN_ENABLE_BACKEND_OPENGLES)
|
|
case wgpu::BackendType::OpenGLES:
|
|
Register(opengl::Connect(this, wgpu::BackendType::OpenGLES),
|
|
wgpu::BackendType::OpenGLES);
|
|
break;
|
|
#endif // defined(DAWN_ENABLE_BACKEND_OPENGLES)
|
|
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
|
|
mBackendsConnected.set(backendType);
|
|
}
|
|
|
|
MaybeError InstanceBase::DiscoverAdaptersInternal(const AdapterDiscoveryOptionsBase* options) {
|
|
wgpu::BackendType backendType = static_cast<wgpu::BackendType>(options->backendType);
|
|
DAWN_TRY(ValidateBackendType(backendType));
|
|
|
|
if (!GetEnabledBackends()[backendType]) {
|
|
return DAWN_FORMAT_VALIDATION_ERROR("%s not supported.", backendType);
|
|
}
|
|
|
|
EnsureBackendConnection(backendType);
|
|
|
|
bool foundBackend = false;
|
|
for (std::unique_ptr<BackendConnection>& backend : mBackends) {
|
|
if (backend->GetType() != backendType) {
|
|
continue;
|
|
}
|
|
foundBackend = true;
|
|
|
|
std::vector<std::unique_ptr<AdapterBase>> newAdapters;
|
|
DAWN_TRY_ASSIGN(newAdapters, backend->DiscoverAdapters(options));
|
|
|
|
for (std::unique_ptr<AdapterBase>& adapter : newAdapters) {
|
|
ASSERT(adapter->GetBackendType() == backend->GetType());
|
|
ASSERT(adapter->GetInstance() == this);
|
|
mAdapters.push_back(std::move(adapter));
|
|
}
|
|
}
|
|
|
|
DAWN_INVALID_IF(!foundBackend, "%s not available.", backendType);
|
|
return {};
|
|
}
|
|
|
|
bool InstanceBase::ConsumedError(MaybeError maybeError) {
|
|
if (maybeError.IsError()) {
|
|
std::unique_ptr<ErrorData> error = maybeError.AcquireError();
|
|
|
|
ASSERT(error != nullptr);
|
|
dawn::InfoLog() << error->GetFormattedMessage();
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool InstanceBase::IsBackendValidationEnabled() const {
|
|
return mBackendValidationLevel != BackendValidationLevel::Disabled;
|
|
}
|
|
|
|
void InstanceBase::SetBackendValidationLevel(BackendValidationLevel level) {
|
|
mBackendValidationLevel = level;
|
|
}
|
|
|
|
BackendValidationLevel InstanceBase::GetBackendValidationLevel() const {
|
|
return mBackendValidationLevel;
|
|
}
|
|
|
|
void InstanceBase::EnableBeginCaptureOnStartup(bool beginCaptureOnStartup) {
|
|
mBeginCaptureOnStartup = beginCaptureOnStartup;
|
|
}
|
|
|
|
bool InstanceBase::IsBeginCaptureOnStartupEnabled() const {
|
|
return mBeginCaptureOnStartup;
|
|
}
|
|
|
|
void InstanceBase::SetPlatform(dawn_platform::Platform* platform) {
|
|
mPlatform = platform;
|
|
}
|
|
|
|
dawn_platform::Platform* InstanceBase::GetPlatform() {
|
|
if (mPlatform != nullptr) {
|
|
return mPlatform;
|
|
}
|
|
|
|
if (mDefaultPlatform == nullptr) {
|
|
mDefaultPlatform = std::make_unique<dawn_platform::Platform>();
|
|
}
|
|
return mDefaultPlatform.get();
|
|
}
|
|
|
|
const XlibXcbFunctions* InstanceBase::GetOrCreateXlibXcbFunctions() {
|
|
#if defined(DAWN_USE_X11)
|
|
if (mXlibXcbFunctions == nullptr) {
|
|
mXlibXcbFunctions = std::make_unique<XlibXcbFunctions>();
|
|
}
|
|
return mXlibXcbFunctions.get();
|
|
#else
|
|
UNREACHABLE();
|
|
#endif // defined(DAWN_USE_X11)
|
|
}
|
|
|
|
Surface* InstanceBase::APICreateSurface(const SurfaceDescriptor* descriptor) {
|
|
if (ConsumedError(ValidateSurfaceDescriptor(this, descriptor))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return new Surface(this, descriptor);
|
|
}
|
|
|
|
} // namespace dawn_native
|