2019-07-18 15:43:45 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2019 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2019-12-04 14:57:48 +00:00
|
|
|
#include "dawn/webgpu_cpp.h"
|
2019-07-25 14:00:52 +00:00
|
|
|
#include "tools/gpu/dawn/DawnTestContext.h"
|
2019-07-18 15:43:45 +00:00
|
|
|
|
|
|
|
#ifdef SK_BUILD_FOR_UNIX
|
|
|
|
#include "GL/glx.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef SK_BUILD_FOR_WIN
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define USE_OPENGL_BACKEND 0
|
|
|
|
|
|
|
|
#ifdef SK_DAWN
|
2019-12-04 14:57:48 +00:00
|
|
|
#include "dawn/webgpu.h"
|
2019-10-16 13:48:53 +00:00
|
|
|
#include "dawn/dawn_proc.h"
|
2019-07-18 15:43:45 +00:00
|
|
|
#include "include/gpu/GrContext.h"
|
|
|
|
#include "tools/AutoreleasePool.h"
|
|
|
|
#if USE_OPENGL_BACKEND
|
|
|
|
#include "dawn_native/OpenGLBackend.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(SK_BUILD_FOR_MAC) && USE_OPENGL_BACKEND
|
|
|
|
#include <dlfcn.h>
|
|
|
|
static void* getProcAddressMacOS(const char* procName) {
|
|
|
|
return dlsym(RTLD_DEFAULT, procName);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
#ifdef SK_BUILD_FOR_WIN
|
|
|
|
class ProcGetter {
|
|
|
|
public:
|
|
|
|
typedef void(*Proc)();
|
|
|
|
|
|
|
|
ProcGetter()
|
|
|
|
: fModule(LoadLibraryA("opengl32.dll")) {
|
|
|
|
SkASSERT(!fInstance);
|
|
|
|
fInstance = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
~ProcGetter() {
|
|
|
|
if (fModule) {
|
|
|
|
FreeLibrary(fModule);
|
|
|
|
}
|
|
|
|
fInstance = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void* getProcAddress(const char* name) {
|
|
|
|
return fInstance->getProc(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Proc getProc(const char* name) {
|
|
|
|
PROC proc;
|
2019-10-17 14:44:37 +00:00
|
|
|
if ((proc = GetProcAddress(fModule, name))) {
|
2019-07-18 15:43:45 +00:00
|
|
|
return (Proc) proc;
|
|
|
|
}
|
2019-10-17 14:44:37 +00:00
|
|
|
if ((proc = wglGetProcAddress(name))) {
|
2019-07-18 15:43:45 +00:00
|
|
|
return (Proc) proc;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
HMODULE fModule;
|
|
|
|
static ProcGetter* fInstance;
|
|
|
|
};
|
|
|
|
|
|
|
|
ProcGetter* ProcGetter::fInstance;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
class DawnTestContextImpl : public sk_gpu_test::DawnTestContext {
|
|
|
|
public:
|
2019-10-30 13:56:23 +00:00
|
|
|
static wgpu::Device createDevice(const dawn_native::Instance& instance,
|
2019-07-18 15:43:45 +00:00
|
|
|
dawn_native::BackendType type) {
|
|
|
|
DawnProcTable backendProcs = dawn_native::GetProcs();
|
2019-10-16 13:48:53 +00:00
|
|
|
dawnProcSetProcs(&backendProcs);
|
2019-07-18 15:43:45 +00:00
|
|
|
|
|
|
|
std::vector<dawn_native::Adapter> adapters = instance.GetAdapters();
|
|
|
|
for (dawn_native::Adapter adapter : adapters) {
|
|
|
|
if (adapter.GetBackendType() == type) {
|
2020-05-29 17:58:39 +00:00
|
|
|
return wgpu::Device::Acquire(adapter.CreateDevice());
|
2019-07-18 15:43:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DawnTestContext* Create(DawnTestContext* sharedContext) {
|
|
|
|
std::unique_ptr<dawn_native::Instance> instance = std::make_unique<dawn_native::Instance>();
|
2019-10-30 13:56:23 +00:00
|
|
|
wgpu::Device device;
|
2019-07-18 15:43:45 +00:00
|
|
|
if (sharedContext) {
|
|
|
|
device = sharedContext->getDevice();
|
|
|
|
} else {
|
|
|
|
dawn_native::BackendType type;
|
|
|
|
#if USE_OPENGL_BACKEND
|
|
|
|
dawn_native::opengl::AdapterDiscoveryOptions adapterOptions;
|
|
|
|
adapterOptions.getProc = reinterpret_cast<void*(*)(const char*)>(
|
|
|
|
#if defined(SK_BUILD_FOR_UNIX)
|
|
|
|
glXGetProcAddress
|
|
|
|
#elif defined(SK_BUILD_FOR_MAC)
|
|
|
|
getProcAddressMacOS
|
|
|
|
#elif defined(SK_BUILD_FOR_WIN)
|
|
|
|
ProcGetter::getProcAddress
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
instance->DiscoverAdapters(&adapterOptions);
|
|
|
|
type = dawn_native::BackendType::OpenGL;
|
|
|
|
#else
|
|
|
|
instance->DiscoverDefaultAdapters();
|
|
|
|
#if defined(SK_BUILD_FOR_MAC)
|
|
|
|
type = dawn_native::BackendType::Metal;
|
|
|
|
#elif defined(SK_BUILD_FOR_WIN)
|
|
|
|
type = dawn_native::BackendType::D3D12;
|
|
|
|
#elif defined(SK_BUILD_FOR_UNIX)
|
|
|
|
type = dawn_native::BackendType::Vulkan;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
device = createDevice(*instance, type);
|
|
|
|
}
|
|
|
|
if (!device) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return new DawnTestContextImpl(std::move(instance), device);
|
|
|
|
}
|
|
|
|
|
|
|
|
~DawnTestContextImpl() override { this->teardown(); }
|
|
|
|
|
|
|
|
void testAbandon() override {}
|
|
|
|
|
|
|
|
void finish() override {}
|
|
|
|
|
|
|
|
sk_sp<GrContext> makeGrContext(const GrContextOptions& options) override {
|
|
|
|
return GrContext::MakeDawn(fDevice, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void teardown() override {
|
|
|
|
INHERITED::teardown();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
DawnTestContextImpl(std::unique_ptr<dawn_native::Instance> instance,
|
2019-10-30 13:56:23 +00:00
|
|
|
const wgpu::Device& device)
|
2020-06-03 18:05:48 +00:00
|
|
|
: DawnTestContext(std::move(instance), device) {
|
2020-02-21 20:46:27 +00:00
|
|
|
fFenceSupport = true;
|
2019-07-18 15:43:45 +00:00
|
|
|
}
|
|
|
|
|
2020-02-13 17:59:19 +00:00
|
|
|
void onPlatformMakeNotCurrent() const override {}
|
2019-07-18 15:43:45 +00:00
|
|
|
void onPlatformMakeCurrent() const override {}
|
|
|
|
std::function<void()> onPlatformGetAutoContextRestore() const override { return nullptr; }
|
|
|
|
|
|
|
|
typedef sk_gpu_test::DawnTestContext INHERITED;
|
|
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
namespace sk_gpu_test {
|
|
|
|
DawnTestContext* CreatePlatformDawnTestContext(DawnTestContext* sharedContext) {
|
|
|
|
return DawnTestContextImpl::Create(sharedContext);
|
|
|
|
}
|
|
|
|
} // namespace sk_gpu_test
|
|
|
|
|
|
|
|
#endif
|