encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-14 23:56:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change the API prefix in generators from nxt to dawn

Browse Source
This commit is contained in:
Corentin Wallez
2018-07-18 15:12:52 +02:00
committed by Corentin Wallez
parent ae79c03d45
commit b1669e3fa4
43 changed files with 541 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/backend/Buffer.cpp
View File

@@ -30,8 +30,8 @@ namespace backend {
BufferBase::~BufferBase() {
if (mIsMapped) {
CallMapReadCallback(mMapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapWriteCallback(mMapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapReadCallback(mMapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapWriteCallback(mMapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
}
}
@@ -52,26 +52,26 @@ namespace backend {
}
void BufferBase::CallMapReadCallback(uint32_t serial,
nxtBufferMapAsyncStatus status,
dawnBufferMapAsyncStatus status,
const void* pointer) {
if (mMapReadCallback != nullptr && serial == mMapSerial) {
ASSERT(mMapWriteCallback == nullptr);
// Tag the callback as fired before firing it, otherwise it could fire a second time if
// for example buffer.Unmap() is called inside the application-provided callback.
nxtBufferMapReadCallback callback = mMapReadCallback;
dawnBufferMapReadCallback callback = mMapReadCallback;
mMapReadCallback = nullptr;
callback(status, pointer, mMapUserdata);
}
}
void BufferBase::CallMapWriteCallback(uint32_t serial,
nxtBufferMapAsyncStatus status,
dawnBufferMapAsyncStatus status,
void* pointer) {
if (mMapWriteCallback != nullptr && serial == mMapSerial) {
ASSERT(mMapReadCallback == nullptr);
// Tag the callback as fired before firing it, otherwise it could fire a second time if
// for example buffer.Unmap() is called inside the application-provided callback.
nxtBufferMapWriteCallback callback = mMapWriteCallback;
dawnBufferMapWriteCallback callback = mMapWriteCallback;
mMapWriteCallback = nullptr;
callback(status, pointer, mMapUserdata);
}
@@ -93,10 +93,10 @@ namespace backend {
void BufferBase::MapReadAsync(uint32_t start,
uint32_t size,
nxtBufferMapReadCallback callback,
nxtCallbackUserdata userdata) {
dawnBufferMapReadCallback callback,
dawnCallbackUserdata userdata) {
if (!ValidateMapBase(start, size, dawn::BufferUsageBit::MapRead)) {
callback(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata);
callback(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata);
return;
}
@@ -113,10 +113,10 @@ namespace backend {
void BufferBase::MapWriteAsync(uint32_t start,
uint32_t size,
nxtBufferMapWriteCallback callback,
nxtCallbackUserdata userdata) {
dawnBufferMapWriteCallback callback,
dawnCallbackUserdata userdata) {
if (!ValidateMapBase(start, size, dawn::BufferUsageBit::MapWrite)) {
callback(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata);
callback(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata);
return;
}
@@ -139,8 +139,8 @@ namespace backend {
// A map request can only be called once, so this will fire only if the request wasn't
// completed before the Unmap
CallMapReadCallback(mMapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapWriteCallback(mMapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapReadCallback(mMapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
CallMapWriteCallback(mMapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr);
UnmapImpl();
mIsMapped = false;
mMapReadCallback = nullptr;

18
src/backend/Buffer.h
View File

@@ -46,19 +46,19 @@ namespace backend {
void SetSubData(uint32_t start, uint32_t count, const uint8_t* data);
void MapReadAsync(uint32_t start,
uint32_t size,
nxtBufferMapReadCallback callback,
nxtCallbackUserdata userdata);
dawnBufferMapReadCallback callback,
dawnCallbackUserdata userdata);
void MapWriteAsync(uint32_t start,
uint32_t size,
nxtBufferMapWriteCallback callback,
nxtCallbackUserdata userdata);
dawnBufferMapWriteCallback callback,
dawnCallbackUserdata userdata);
void Unmap();
protected:
void CallMapReadCallback(uint32_t serial,
nxtBufferMapAsyncStatus status,
dawnBufferMapAsyncStatus status,
const void* pointer);
void CallMapWriteCallback(uint32_t serial, nxtBufferMapAsyncStatus status, void* pointer);
void CallMapWriteCallback(uint32_t serial, dawnBufferMapAsyncStatus status, void* pointer);
private:
virtual void SetSubDataImpl(uint32_t start, uint32_t count, const uint8_t* data) = 0;
@@ -72,9 +72,9 @@ namespace backend {
uint32_t mSize;
dawn::BufferUsageBit mAllowedUsage = dawn::BufferUsageBit::None;
nxtBufferMapReadCallback mMapReadCallback = nullptr;
nxtBufferMapWriteCallback mMapWriteCallback = nullptr;
nxtCallbackUserdata mMapUserdata = 0;
dawnBufferMapReadCallback mMapReadCallback = nullptr;
dawnBufferMapWriteCallback mMapWriteCallback = nullptr;
dawnCallbackUserdata mMapUserdata = 0;
uint32_t mMapSerial = 0;
bool mIsMapped = false;

4
src/backend/Builder.cpp
View File

@@ -44,7 +44,7 @@ namespace backend {
BuilderBase::~BuilderBase() {
if (!mIsConsumed && mCallback != nullptr) {
mCallback(NXT_BUILDER_ERROR_STATUS_UNKNOWN, "Builder destroyed before GetResult",
mCallback(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, "Builder destroyed before GetResult",
mUserdata1, mUserdata2);
}
}
@@ -87,7 +87,7 @@ namespace backend {
}
if (mCallback != nullptr) {
mCallback(static_cast<nxtBuilderErrorStatus>(mStoredStatus), mStoredMessage.c_str(),
mCallback(static_cast<dawnBuilderErrorStatus>(mStoredStatus), mStoredMessage.c_str(),
mUserdata1, mUserdata2);
}

4
src/backend/SwapChain.cpp
View File

@@ -48,8 +48,8 @@ namespace backend {
mAllowedUsage = allowedUsage;
mWidth = width;
mHeight = height;
mImplementation.Configure(mImplementation.userData, static_cast<nxtTextureFormat>(format),
static_cast<nxtTextureUsageBit>(allowedUsage), width, height);
mImplementation.Configure(mImplementation.userData, static_cast<dawnTextureFormat>(format),
static_cast<dawnTextureUsageBit>(allowedUsage), width, height);
}
TextureBase* SwapChainBase::GetNextTexture() {

4
src/backend/d3d12/BufferD3D12.cpp
View File

@@ -155,9 +155,9 @@ namespace backend { namespace d3d12 {
void Buffer::OnMapCommandSerialFinished(uint32_t mapSerial, void* data, bool isWrite) {
if (isWrite) {
CallMapWriteCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapWriteCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
} else {
CallMapReadCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapReadCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
}
}

12
src/backend/d3d12/DeviceD3D12.cpp
View File

@@ -43,26 +43,26 @@ namespace backend { namespace d3d12 {
nxtProcTable GetNonValidatingProcs();
nxtProcTable GetValidatingProcs();
void Init(nxtProcTable* procs, nxtDevice* device) {
void Init(nxtProcTable* procs, dawnDevice* device) {
*device = nullptr;
*procs = GetValidatingProcs();
*device = reinterpret_cast<nxtDevice>(new Device());
*device = reinterpret_cast<dawnDevice>(new Device());
}
dawnSwapChainImplementation CreateNativeSwapChainImpl(nxtDevice device, HWND window) {
dawnSwapChainImplementation CreateNativeSwapChainImpl(dawnDevice device, HWND window) {
Device* backendDevice = reinterpret_cast<Device*>(device);
dawnSwapChainImplementation impl;
impl = CreateSwapChainImplementation(new NativeSwapChainImpl(backendDevice, window));
impl.textureUsage = NXT_TEXTURE_USAGE_BIT_PRESENT;
impl.textureUsage = DAWN_TEXTURE_USAGE_BIT_PRESENT;
return impl;
}
nxtTextureFormat GetNativeSwapChainPreferredFormat(
dawnTextureFormat GetNativeSwapChainPreferredFormat(
const dawnSwapChainImplementation* swapChain) {
NativeSwapChainImpl* impl = reinterpret_cast<NativeSwapChainImpl*>(swapChain->userData);
return static_cast<nxtTextureFormat>(impl->GetPreferredFormat());
return static_cast<dawnTextureFormat>(impl->GetPreferredFormat());
}
void ASSERT_SUCCESS(HRESULT hr) {

14
src/backend/d3d12/NativeSwapChainImplD3D12.cpp
View File

@@ -21,15 +21,15 @@
namespace backend { namespace d3d12 {
namespace {
DXGI_USAGE D3D12SwapChainBufferUsage(nxtTextureUsageBit allowedUsages) {
DXGI_USAGE D3D12SwapChainBufferUsage(dawnTextureUsageBit allowedUsages) {
DXGI_USAGE usage = DXGI_CPU_ACCESS_NONE;
if (allowedUsages & NXT_TEXTURE_USAGE_BIT_SAMPLED) {
if (allowedUsages & DAWN_TEXTURE_USAGE_BIT_SAMPLED) {
usage |= DXGI_USAGE_SHADER_INPUT;
}
if (allowedUsages & NXT_TEXTURE_USAGE_BIT_STORAGE) {
if (allowedUsages & DAWN_TEXTURE_USAGE_BIT_STORAGE) {
usage |= DXGI_USAGE_UNORDERED_ACCESS;
}
if (allowedUsages & NXT_TEXTURE_USAGE_BIT_OUTPUT_ATTACHMENT) {
if (allowedUsages & DAWN_TEXTURE_USAGE_BIT_OUTPUT_ATTACHMENT) {
usage |= DXGI_USAGE_RENDER_TARGET_OUTPUT;
}
return usage;
@@ -48,13 +48,13 @@ namespace backend { namespace d3d12 {
void NativeSwapChainImpl::Init(dawnWSIContextD3D12* /*context*/) {
}
dawnSwapChainError NativeSwapChainImpl::Configure(nxtTextureFormat format,
nxtTextureUsageBit usage,
dawnSwapChainError NativeSwapChainImpl::Configure(dawnTextureFormat format,
dawnTextureUsageBit usage,
uint32_t width,
uint32_t height) {
ASSERT(width > 0);
ASSERT(height > 0);
ASSERT(format == static_cast<nxtTextureFormat>(GetPreferredFormat()));
ASSERT(format == static_cast<dawnTextureFormat>(GetPreferredFormat()));
ComPtr<IDXGIFactory4> factory = mDevice->GetFactory();
ComPtr<ID3D12CommandQueue> queue = mDevice->GetCommandQueue();

4
src/backend/d3d12/NativeSwapChainImplD3D12.h
View File

@@ -34,8 +34,8 @@ namespace backend { namespace d3d12 {
~NativeSwapChainImpl();
void Init(dawnWSIContextD3D12* context);
dawnSwapChainError Configure(nxtTextureFormat format,
nxtTextureUsageBit,
dawnSwapChainError Configure(dawnTextureFormat format,
dawnTextureUsageBit,
uint32_t width,
uint32_t height);
dawnSwapChainError GetNextTexture(dawnSwapChainNextTexture* nextTexture);

4
src/backend/d3d12/SwapChainD3D12.cpp
View File

@@ -24,10 +24,10 @@ namespace backend { namespace d3d12 {
SwapChain::SwapChain(SwapChainBuilder* builder) : SwapChainBase(builder) {
const auto& im = GetImplementation();
dawnWSIContextD3D12 wsiContext = {};
wsiContext.device = reinterpret_cast<nxtDevice>(GetDevice());
wsiContext.device = reinterpret_cast<dawnDevice>(GetDevice());
im.Init(im.userData, &wsiContext);
ASSERT(im.textureUsage != NXT_TEXTURE_USAGE_BIT_NONE);
ASSERT(im.textureUsage != DAWN_TEXTURE_USAGE_BIT_NONE);
mTextureUsage = static_cast<dawn::TextureUsageBit>(im.textureUsage);
}

4
src/backend/metal/BufferMTL.mm
View File

@@ -43,9 +43,9 @@ namespace backend { namespace metal {
void Buffer::OnMapCommandSerialFinished(uint32_t mapSerial, uint32_t offset, bool isWrite) {
char* data = reinterpret_cast<char*>([mMtlBuffer contents]);
if (isWrite) {
CallMapWriteCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data + offset);
CallMapWriteCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data + offset);
} else {
CallMapReadCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data + offset);
CallMapReadCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data + offset);
}
}

4
src/backend/metal/DeviceMTL.mm
View File

@@ -38,11 +38,11 @@ namespace backend { namespace metal {
nxtProcTable GetNonValidatingProcs();
nxtProcTable GetValidatingProcs();
void Init(id<MTLDevice> metalDevice, nxtProcTable* procs, nxtDevice* device) {
void Init(id<MTLDevice> metalDevice, nxtProcTable* procs, dawnDevice* device) {
*device = nullptr;
*procs = GetValidatingProcs();
*device = reinterpret_cast<nxtDevice>(new Device(metalDevice));
*device = reinterpret_cast<dawnDevice>(new Device(metalDevice));
}
// Device

8
src/backend/null/NullBackend.cpp
View File

@@ -23,9 +23,9 @@ namespace backend { namespace null {
nxtProcTable GetNonValidatingProcs();
nxtProcTable GetValidatingProcs();
void Init(nxtProcTable* procs, nxtDevice* device) {
void Init(nxtProcTable* procs, dawnDevice* device) {
*procs = GetValidatingProcs();
*device = reinterpret_cast<nxtDevice>(new Device);
*device = reinterpret_cast<dawnDevice>(new Device);
}
// Device
@@ -135,9 +135,9 @@ namespace backend { namespace null {
void Buffer::MapReadOperationCompleted(uint32_t serial, void* ptr, bool isWrite) {
if (isWrite) {
CallMapWriteCallback(serial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, ptr);
CallMapWriteCallback(serial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, ptr);
} else {
CallMapReadCallback(serial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, ptr);
CallMapReadCallback(serial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, ptr);
}
}

4
src/backend/opengl/BufferGL.cpp
View File

@@ -38,7 +38,7 @@ namespace backend { namespace opengl {
// version of OpenGL that would let us map the buffer unsynchronized.
glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
void* data = glMapBufferRange(GL_ARRAY_BUFFER, start, count, GL_MAP_READ_BIT);
CallMapReadCallback(serial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapReadCallback(serial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
}
void Buffer::MapWriteAsyncImpl(uint32_t serial, uint32_t start, uint32_t count) {
@@ -46,7 +46,7 @@ namespace backend { namespace opengl {
// version of OpenGL that would let us map the buffer unsynchronized.
glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
void* data = glMapBufferRange(GL_ARRAY_BUFFER, start, count, GL_MAP_WRITE_BIT);
CallMapWriteCallback(serial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapWriteCallback(serial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
}
void Buffer::UnmapImpl() {

4
src/backend/opengl/DeviceGL.cpp
View File

@@ -35,13 +35,13 @@ namespace backend { namespace opengl {
nxtProcTable GetNonValidatingProcs();
nxtProcTable GetValidatingProcs();
void Init(void* (*getProc)(const char*), nxtProcTable* procs, nxtDevice* device) {
void Init(void* (*getProc)(const char*), nxtProcTable* procs, dawnDevice* device) {
*device = nullptr;
gladLoadGLLoader(reinterpret_cast<GLADloadproc>(getProc));
*procs = GetValidatingProcs();
*device = reinterpret_cast<nxtDevice>(new Device);
*device = reinterpret_cast<dawnDevice>(new Device);
glEnable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);

4
src/backend/vulkan/BufferVk.cpp
View File

@@ -150,11 +150,11 @@ namespace backend { namespace vulkan {
}
void Buffer::OnMapReadCommandSerialFinished(uint32_t mapSerial, const void* data) {
CallMapReadCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapReadCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
}
void Buffer::OnMapWriteCommandSerialFinished(uint32_t mapSerial, void* data) {
CallMapWriteCallback(mapSerial, NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
CallMapWriteCallback(mapSerial, DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, data);
}
VkBuffer Buffer::GetHandle() const {

14
src/backend/vulkan/DeviceVk.cpp
View File

@@ -56,31 +56,31 @@ namespace backend { namespace vulkan {
nxtProcTable GetValidatingProcs();
void Init(nxtProcTable* procs,
nxtDevice* device,
dawnDevice* device,
const std::vector<const char*>& requiredInstanceExtensions) {
*procs = GetValidatingProcs();
*device = reinterpret_cast<nxtDevice>(new Device(requiredInstanceExtensions));
*device = reinterpret_cast<dawnDevice>(new Device(requiredInstanceExtensions));
}
VkInstance GetInstance(nxtDevice device) {
VkInstance GetInstance(dawnDevice device) {
Device* backendDevice = reinterpret_cast<Device*>(device);
return backendDevice->GetInstance();
}
dawnSwapChainImplementation CreateNativeSwapChainImpl(nxtDevice device, VkSurfaceKHR surface) {
dawnSwapChainImplementation CreateNativeSwapChainImpl(dawnDevice device, VkSurfaceKHR surface) {
Device* backendDevice = reinterpret_cast<Device*>(device);
dawnSwapChainImplementation impl;
impl = CreateSwapChainImplementation(new NativeSwapChainImpl(backendDevice, surface));
impl.textureUsage = NXT_TEXTURE_USAGE_BIT_PRESENT;
impl.textureUsage = DAWN_TEXTURE_USAGE_BIT_PRESENT;
return impl;
}
nxtTextureFormat GetNativeSwapChainPreferredFormat(
dawnTextureFormat GetNativeSwapChainPreferredFormat(
const dawnSwapChainImplementation* swapChain) {
NativeSwapChainImpl* impl = reinterpret_cast<NativeSwapChainImpl*>(swapChain->userData);
return static_cast<nxtTextureFormat>(impl->GetPreferredFormat());
return static_cast<dawnTextureFormat>(impl->GetPreferredFormat());
}
// Device

6
src/backend/vulkan/NativeSwapChainImplVk.cpp
View File

@@ -67,8 +67,8 @@ namespace backend { namespace vulkan {
}
}
dawnSwapChainError NativeSwapChainImpl::Configure(nxtTextureFormat format,
nxtTextureUsageBit usage,
dawnSwapChainError NativeSwapChainImpl::Configure(dawnTextureFormat format,
dawnTextureUsageBit usage,
uint32_t width,
uint32_t height) {
ASSERT(mInfo.capabilities.minImageExtent.width <= width);
@@ -76,7 +76,7 @@ namespace backend { namespace vulkan {
ASSERT(mInfo.capabilities.minImageExtent.height <= height);
ASSERT(mInfo.capabilities.maxImageExtent.height >= height);
ASSERT(format == static_cast<nxtTextureFormat>(GetPreferredFormat()));
ASSERT(format == static_cast<dawnTextureFormat>(GetPreferredFormat()));
// TODO(cwallez@chromium.org): need to check usage works too
// Create the swapchain with the configuration we chose

4
src/backend/vulkan/NativeSwapChainImplVk.h
View File

@@ -32,8 +32,8 @@ namespace backend { namespace vulkan {
~NativeSwapChainImpl();
void Init(dawnWSIContextVulkan* context);
dawnSwapChainError Configure(nxtTextureFormat format,
nxtTextureUsageBit,
dawnSwapChainError Configure(dawnTextureFormat format,
dawnTextureUsageBit,
uint32_t width,
uint32_t height);
dawnSwapChainError GetNextTexture(dawnSwapChainNextTexture* nextTexture);

2
src/backend/vulkan/SwapChainVk.cpp
View File

@@ -24,7 +24,7 @@ namespace backend { namespace vulkan {
dawnWSIContextVulkan wsiContext = {};
im.Init(im.userData, &wsiContext);
ASSERT(im.textureUsage != NXT_TEXTURE_USAGE_BIT_NONE);
ASSERT(im.textureUsage != DAWN_TEXTURE_USAGE_BIT_NONE);
mTextureUsage = static_cast<dawn::TextureUsageBit>(im.textureUsage);
}

2
src/common/SwapChainUtils.h
View File

@@ -24,7 +24,7 @@ dawnSwapChainImplementation CreateSwapChainImplementation(T* swapChain) {
reinterpret_cast<T*>(userData)->Init(ctx);
};
impl.Destroy = [](void* userData) { delete reinterpret_cast<T*>(userData); };
impl.Configure = [](void* userData, nxtTextureFormat format, nxtTextureUsageBit allowedUsage,
impl.Configure = [](void* userData, dawnTextureFormat format, dawnTextureUsageBit allowedUsage,
uint32_t width, uint32_t height) {
return reinterpret_cast<T*>(userData)->Configure(format, allowedUsage, width, height);
};

8
src/include/dawn/dawn_wsi.h
View File

@@ -40,8 +40,8 @@ typedef struct {
/// Configure/reconfigure the swap chain.
dawnSwapChainError (*Configure)(void* userData,
nxtTextureFormat format,
nxtTextureUsageBit allowedUsage,
dawnTextureFormat format,
dawnTextureUsageBit allowedUsage,
uint32_t width,
uint32_t height);
@@ -55,12 +55,12 @@ typedef struct {
void* userData;
/// For use by the D3D12 and Vulkan backends: how the swapchain will use the texture.
nxtTextureUsageBit textureUsage;
dawnTextureUsageBit textureUsage;
} dawnSwapChainImplementation;
#if defined(DAWN_ENABLE_BACKEND_D3D12) && defined(__cplusplus)
typedef struct {
nxtDevice device = nullptr;
dawnDevice device = nullptr;
} dawnWSIContextD3D12;
#endif

14
src/tests/NXTTest.cpp
View File

@@ -86,7 +86,7 @@ namespace {
// End2end tests should test valid commands produce the expected result so no error
// should happen. Failure cases should be tested in the validation tests.
void DeviceErrorCauseTestFailure(const char* message, nxtCallbackUserdata) {
void DeviceErrorCauseTestFailure(const char* message, dawnCallbackUserdata) {
FAIL() << "Device level failure: " << message;
}
@@ -136,12 +136,12 @@ void NXTTest::SetUp() {
mBinding->SetWindow(testWindow);
nxtDevice backendDevice;
dawnDevice backendDevice;
nxtProcTable backendProcs;
mBinding->GetProcAndDevice(&backendProcs, &backendDevice);
// Choose whether to use the backend procs and devices directly, or set up the wire.
nxtDevice cDevice = nullptr;
dawnDevice cDevice = nullptr;
nxtProcTable procs;
if (gTestUsesWire) {
@@ -151,7 +151,7 @@ void NXTTest::SetUp() {
mWireServer = dawn::wire::NewServerCommandHandler(backendDevice, backendProcs, mS2cBuf);
mC2sBuf->SetHandler(mWireServer);
nxtDevice clientDevice;
dawnDevice clientDevice;
nxtProcTable clientProcs;
mWireClient = dawn::wire::NewClientDevice(&clientProcs, &clientDevice, mC2sBuf);
mS2cBuf->SetHandler(mWireClient);
@@ -320,10 +320,10 @@ void NXTTest::MapSlotsSynchronously() {
}
// static
void NXTTest::SlotMapReadCallback(nxtBufferMapAsyncStatus status,
void NXTTest::SlotMapReadCallback(dawnBufferMapAsyncStatus status,
const void* data,
nxtCallbackUserdata userdata_) {
DAWN_ASSERT(status == NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS);
dawnCallbackUserdata userdata_) {
DAWN_ASSERT(status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS);
auto userdata = reinterpret_cast<MapReadUserdata*>(static_cast<uintptr_t>(userdata_));
userdata->test->mReadbackSlots[userdata->slot].mappedData = data;

4
src/tests/NXTTest.h
View File

@@ -128,9 +128,9 @@ class NXTTest : public ::testing::TestWithParam<BackendType> {
// Maps all the buffers and fill ReadbackSlot::mappedData
void MapSlotsSynchronously();
static void SlotMapReadCallback(nxtBufferMapAsyncStatus status,
static void SlotMapReadCallback(dawnBufferMapAsyncStatus status,
const void* data,
nxtCallbackUserdata userdata);
dawnCallbackUserdata userdata);
size_t mNumPendingMapOperations = 0;
// Reserve space where the data for an expectation can be copied

8
src/tests/end2end/BufferTests.cpp
View File

@@ -19,8 +19,8 @@
class BufferMapReadTests : public NXTTest {
protected:
static void MapReadCallback(nxtBufferMapAsyncStatus status, const void* data, nxtCallbackUserdata userdata) {
ASSERT_EQ(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
static void MapReadCallback(dawnBufferMapAsyncStatus status, const void* data, dawnCallbackUserdata userdata) {
ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
ASSERT_NE(nullptr, data);
auto test = reinterpret_cast<BufferMapReadTests*>(static_cast<uintptr_t>(userdata));
@@ -115,8 +115,8 @@ NXT_INSTANTIATE_TEST(BufferMapReadTests, D3D12Backend, MetalBackend, OpenGLBacke
class BufferMapWriteTests : public NXTTest {
protected:
static void MapWriteCallback(nxtBufferMapAsyncStatus status, void* data, nxtCallbackUserdata userdata) {
ASSERT_EQ(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
static void MapWriteCallback(dawnBufferMapAsyncStatus status, void* data, dawnCallbackUserdata userdata) {
ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
ASSERT_NE(nullptr, data);
auto test = reinterpret_cast<BufferMapWriteTests*>(static_cast<uintptr_t>(userdata));

462
src/tests/unittests/WireTests.cpp
View File

File diff suppressed because it is too large Load Diff

52
src/tests/unittests/validation/BufferValidationTests.cpp
View File

@@ -20,22 +20,22 @@ using namespace testing;
class MockBufferMapReadCallback {
public:
MOCK_METHOD3(Call, void(nxtBufferMapAsyncStatus status, const uint32_t* ptr, nxtCallbackUserdata userdata));
MOCK_METHOD3(Call, void(dawnBufferMapAsyncStatus status, const uint32_t* ptr, dawnCallbackUserdata userdata));
};
static MockBufferMapReadCallback* mockBufferMapReadCallback = nullptr;
static void ToMockBufferMapReadCallback(nxtBufferMapAsyncStatus status, const void* ptr, nxtCallbackUserdata userdata) {
static void ToMockBufferMapReadCallback(dawnBufferMapAsyncStatus status, const void* ptr, dawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockBufferMapReadCallback->Call(status, reinterpret_cast<const uint32_t*>(ptr), userdata);
}
class MockBufferMapWriteCallback {
public:
MOCK_METHOD3(Call, void(nxtBufferMapAsyncStatus status, uint32_t* ptr, nxtCallbackUserdata userdata));
MOCK_METHOD3(Call, void(dawnBufferMapAsyncStatus status, uint32_t* ptr, dawnCallbackUserdata userdata));
};
static MockBufferMapWriteCallback* mockBufferMapWriteCallback = nullptr;
static void ToMockBufferMapWriteCallback(nxtBufferMapAsyncStatus status, void* ptr, nxtCallbackUserdata userdata) {
static void ToMockBufferMapWriteCallback(dawnBufferMapAsyncStatus status, void* ptr, dawnCallbackUserdata userdata) {
// Assume the data is uint32_t to make writing matchers easier
mockBufferMapWriteCallback->Call(status, reinterpret_cast<uint32_t*>(ptr), userdata);
}
@@ -171,7 +171,7 @@ TEST_F(BufferValidationTest, MapReadSuccess) {
dawn::CallbackUserdata userdata = 40598;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.Times(1);
queue.Submit(0, nullptr);
@@ -185,7 +185,7 @@ TEST_F(BufferValidationTest, MapWriteSuccess) {
dawn::CallbackUserdata userdata = 40598;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.Times(1);
queue.Submit(0, nullptr);
@@ -197,7 +197,7 @@ TEST_F(BufferValidationTest, MapReadOutOfRange) {
dawn::Buffer buf = CreateMapReadBuffer(4);
dawn::CallbackUserdata userdata = 40599;
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(0, 5, ToMockBufferMapReadCallback, userdata));
@@ -208,7 +208,7 @@ TEST_F(BufferValidationTest, MapWriteOutOfRange) {
dawn::Buffer buf = CreateMapWriteBuffer(4);
dawn::CallbackUserdata userdata = 40599;
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(0, 5, ToMockBufferMapWriteCallback, userdata));
@@ -222,7 +222,7 @@ TEST_F(BufferValidationTest, MapReadWrongUsage) {
.GetResult();
dawn::CallbackUserdata userdata = 40600;
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata));
@@ -236,7 +236,7 @@ TEST_F(BufferValidationTest, MapWriteWrongUsage) {
.GetResult();
dawn::CallbackUserdata userdata = 40600;
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata));
@@ -248,11 +248,11 @@ TEST_F(BufferValidationTest, MapReadAlreadyMapped) {
dawn::CallbackUserdata userdata1 = 40601;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata1);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata1))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata1))
.Times(1);
dawn::CallbackUserdata userdata2 = 40602;
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata2))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata2))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata2));
@@ -265,11 +265,11 @@ TEST_F(BufferValidationTest, MapWriteAlreadyMapped) {
dawn::CallbackUserdata userdata1 = 40601;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata1);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata1))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata1))
.Times(1);
dawn::CallbackUserdata userdata2 = 40602;
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata2))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_ERROR, nullptr, userdata2))
.Times(1);
ASSERT_DEVICE_ERROR(buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata2));
@@ -284,7 +284,7 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResult) {
dawn::CallbackUserdata userdata = 40603;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
buf.Unmap();
@@ -300,7 +300,7 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResult) {
dawn::CallbackUserdata userdata = 40603;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
buf.Unmap();
@@ -319,7 +319,7 @@ TEST_F(BufferValidationTest, DISABLED_MapReadDestroyBeforeResult) {
dawn::CallbackUserdata userdata = 40604;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
}
@@ -338,7 +338,7 @@ TEST_F(BufferValidationTest, DISABLED_MapWriteDestroyBeforeResult) {
dawn::CallbackUserdata userdata = 40604;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
}
@@ -355,7 +355,7 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResultThenMapAgain) {
dawn::CallbackUserdata userdata = 40605;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
buf.Unmap();
@@ -363,7 +363,7 @@ TEST_F(BufferValidationTest, MapReadUnmapBeforeResultThenMapAgain) {
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.Times(1);
queue.Submit(0, nullptr);
}
@@ -377,7 +377,7 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResultThenMapAgain) {
dawn::CallbackUserdata userdata = 40605;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN, nullptr, userdata))
.Times(1);
buf.Unmap();
@@ -385,7 +385,7 @@ TEST_F(BufferValidationTest, MapWriteUnmapBeforeResultThenMapAgain) {
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.Times(1);
queue.Submit(0, nullptr);
}
@@ -397,7 +397,7 @@ TEST_F(BufferValidationTest, UnmapInsideMapReadCallback) {
dawn::CallbackUserdata userdata = 40678;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.WillOnce(InvokeWithoutArgs([&]() {
buf.Unmap();
}));
@@ -412,7 +412,7 @@ TEST_F(BufferValidationTest, UnmapInsideMapWriteCallback) {
dawn::CallbackUserdata userdata = 40678;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.WillOnce(InvokeWithoutArgs([&]() {
buf.Unmap();
}));
@@ -427,7 +427,7 @@ TEST_F(BufferValidationTest, DestroyInsideMapReadCallback) {
dawn::CallbackUserdata userdata = 40679;
buf.MapReadAsync(0, 4, ToMockBufferMapReadCallback, userdata);
EXPECT_CALL(*mockBufferMapReadCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapReadCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.WillOnce(InvokeWithoutArgs([&]() {
buf = dawn::Buffer();
}));
@@ -442,7 +442,7 @@ TEST_F(BufferValidationTest, DestroyInsideMapWriteCallback) {
dawn::CallbackUserdata userdata = 40679;
buf.MapWriteAsync(0, 4, ToMockBufferMapWriteCallback, userdata);
EXPECT_CALL(*mockBufferMapWriteCallback, Call(NXT_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
EXPECT_CALL(*mockBufferMapWriteCallback, Call(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, Ne(nullptr), userdata))
.WillOnce(InvokeWithoutArgs([&]() {
buf = dawn::Buffer();
}));

14
src/tests/unittests/validation/ValidationTest.cpp
View File

@@ -18,19 +18,19 @@
namespace backend {
namespace null {
void Init(nxtProcTable* procs, nxtDevice* device);
void Init(nxtProcTable* procs, dawnDevice* device);
}
}
ValidationTest::ValidationTest() {
nxtProcTable procs;
nxtDevice cDevice;
dawnDevice cDevice;
backend::null::Init(&procs, &cDevice);
nxtSetProcs(&procs);
device = dawn::Device::Acquire(cDevice);
device.SetErrorCallback(ValidationTest::OnDeviceError, static_cast<nxtCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
device.SetErrorCallback(ValidationTest::OnDeviceError, static_cast<dawnCallbackUserdata>(reinterpret_cast<uintptr_t>(this)));
}
ValidationTest::~ValidationTest() {
@@ -51,9 +51,9 @@ void ValidationTest::TearDown() {
ASSERT_TRUE(expectation.gotStatus) << "Didn't get a status for " << name;
ASSERT_NE(NXT_BUILDER_ERROR_STATUS_UNKNOWN, expectation.status) << "Got unknown status for " << name;
ASSERT_NE(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, expectation.status) << "Got unknown status for " << name;
bool wasSuccess = expectation.status == NXT_BUILDER_ERROR_STATUS_SUCCESS;
bool wasSuccess = expectation.status == DAWN_BUILDER_ERROR_STATUS_SUCCESS;
ASSERT_EQ(expectation.expectSuccess, wasSuccess)
<< "Got wrong status value for " << name
<< ", status was " << expectation.status << " with \"" << expectation.statusMessage << "\"";
@@ -85,7 +85,7 @@ dawn::RenderPassDescriptor ValidationTest::CreateSimpleRenderPass() {
.GetResult();
}
void ValidationTest::OnDeviceError(const char* message, nxtCallbackUserdata userdata) {
void ValidationTest::OnDeviceError(const char* message, dawnCallbackUserdata userdata) {
// Skip this one specific error that is raised when a builder is used after it got an error
// this is important because we don't want to wrap all creation tests in ASSERT_DEVICE_ERROR.
// Yes the error message is misleading.
@@ -99,7 +99,7 @@ void ValidationTest::OnDeviceError(const char* message, nxtCallbackUserdata user
self->mError = true;
}
void ValidationTest::OnBuilderErrorStatus(nxtBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2) {
void ValidationTest::OnBuilderErrorStatus(dawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2) {
auto* self = reinterpret_cast<ValidationTest*>(static_cast<uintptr_t>(userdata1));
size_t index = static_cast<size_t>(userdata2);

6
src/tests/unittests/validation/ValidationTest.h
View File

@@ -65,7 +65,7 @@ class ValidationTest : public testing::Test {
dawn::Device device;
private:
static void OnDeviceError(const char* message, nxtCallbackUserdata userdata);
static void OnDeviceError(const char* message, dawnCallbackUserdata userdata);
bool mExpectError = false;
bool mError = false;
@@ -75,14 +75,14 @@ class ValidationTest : public testing::Test {
bool gotStatus = false;
std::string statusMessage;
nxtBuilderErrorStatus status;
dawnBuilderErrorStatus status;
};
std::vector<BuilderStatusExpectations> mExpectations;
template<typename Builder>
Builder AddExpectation(Builder& builder, std::string debugName, bool expectSuccess);
static void OnBuilderErrorStatus(nxtBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2);
static void OnBuilderErrorStatus(dawnBuilderErrorStatus status, const char* message, dawn::CallbackUserdata userdata1, dawn::CallbackUserdata userdata2);
};
// Template implementation details

6
src/utils/BackendBinding.h
View File

@@ -19,7 +19,7 @@
struct GLFWwindow;
typedef struct nxtProcTable_s nxtProcTable;
typedef struct nxtDeviceImpl* nxtDevice;
typedef struct dawnDeviceImpl* dawnDevice;
namespace utils {
@@ -36,9 +36,9 @@ namespace utils {
virtual ~BackendBinding() = default;
virtual void SetupGLFWWindowHints() = 0;
virtual void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) = 0;
virtual void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) = 0;
virtual uint64_t GetSwapChainImplementation() = 0;
virtual nxtTextureFormat GetPreferredSwapChainTextureFormat() = 0;
virtual dawnTextureFormat GetPreferredSwapChainTextureFormat() = 0;
void SetWindow(GLFWwindow* window);

12
src/utils/D3D12Binding.cpp
View File

@@ -22,10 +22,10 @@
#include "GLFW/glfw3native.h"
namespace backend { namespace d3d12 {
void Init(nxtProcTable* procs, nxtDevice* device);
void Init(nxtProcTable* procs, dawnDevice* device);
dawnSwapChainImplementation CreateNativeSwapChainImpl(nxtDevice device, HWND window);
nxtTextureFormat GetNativeSwapChainPreferredFormat(
dawnSwapChainImplementation CreateNativeSwapChainImpl(dawnDevice device, HWND window);
dawnTextureFormat GetNativeSwapChainPreferredFormat(
const dawnSwapChainImplementation* swapChain);
}} // namespace backend::d3d12
@@ -37,7 +37,7 @@ namespace utils {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) override {
backend::d3d12::Init(procs, device);
mBackendDevice = *device;
}
@@ -51,13 +51,13 @@ namespace utils {
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
dawnTextureFormat GetPreferredSwapChainTextureFormat() override {
ASSERT(mSwapchainImpl.userData != nullptr);
return backend::d3d12::GetNativeSwapChainPreferredFormat(&mSwapchainImpl);
}
private:
nxtDevice mBackendDevice = nullptr;
dawnDevice mBackendDevice = nullptr;
dawnSwapChainImplementation mSwapchainImpl = {};
};

20
src/utils/MetalBinding.mm
View File

@@ -26,9 +26,9 @@
#import <QuartzCore/CAMetalLayer.h>
namespace backend { namespace metal {
void Init(id<MTLDevice> metalDevice, nxtProcTable* procs, nxtDevice* device);
void SetNextDrawable(nxtDevice device, id<CAMetalDrawable> drawable);
void Present(nxtDevice device);
void Init(id<MTLDevice> metalDevice, nxtProcTable* procs, dawnDevice* device);
void SetNextDrawable(dawnDevice device, id<CAMetalDrawable> drawable);
void Present(dawnDevice device);
}}
namespace utils {
@@ -49,11 +49,11 @@ namespace utils {
mCommandQueue = [mMtlDevice newCommandQueue];
}
dawnSwapChainError Configure(nxtTextureFormat format,
nxtTextureUsageBit,
dawnSwapChainError Configure(dawnTextureFormat format,
dawnTextureUsageBit,
uint32_t width,
uint32_t height) {
if (format != NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM) {
if (format != DAWN_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM) {
return "unsupported format";
}
ASSERT(width > 0);
@@ -114,7 +114,7 @@ namespace utils {
void SetupGLFWWindowHints() override {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) override {
mMetalDevice = MTLCreateSystemDefaultDevice();
backend::metal::Init(mMetalDevice, procs, device);
@@ -129,13 +129,13 @@ namespace utils {
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
return NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM;
dawnTextureFormat GetPreferredSwapChainTextureFormat() override {
return DAWN_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM;
}
private:
id<MTLDevice> mMetalDevice = nil;
nxtDevice mBackendDevice = nullptr;
dawnDevice mBackendDevice = nullptr;
dawnSwapChainImplementation mSwapchainImpl = {};
};

8
src/utils/NullBinding.cpp
View File

@@ -15,7 +15,7 @@
#include "utils/BackendBinding.h"
namespace backend { namespace null {
void Init(nxtProcTable* procs, nxtDevice* device);
void Init(nxtProcTable* procs, dawnDevice* device);
}} // namespace backend::null
namespace utils {
@@ -24,14 +24,14 @@ namespace utils {
public:
void SetupGLFWWindowHints() override {
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) override {
backend::null::Init(procs, device);
}
uint64_t GetSwapChainImplementation() override {
return 0;
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
dawnTextureFormat GetPreferredSwapChainTextureFormat() override {
return DAWN_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
}
};

16
src/utils/OpenGLBinding.cpp
View File

@@ -26,7 +26,7 @@
#include "GLFW/glfw3.h"
namespace backend { namespace opengl {
void Init(void* (*getProc)(const char*), nxtProcTable* procs, nxtDevice* device);
void Init(void* (*getProc)(const char*), nxtProcTable* procs, dawnDevice* device);
}} // namespace backend::opengl
namespace utils {
@@ -53,11 +53,11 @@ namespace utils {
mBackTexture, 0);
}
dawnSwapChainError Configure(nxtTextureFormat format,
nxtTextureUsageBit,
dawnSwapChainError Configure(dawnTextureFormat format,
dawnTextureUsageBit,
uint32_t width,
uint32_t height) {
if (format != NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
if (format != DAWN_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
return "unsupported format";
}
ASSERT(width > 0);
@@ -111,7 +111,7 @@ namespace utils {
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) override {
glfwMakeContextCurrent(mWindow);
backend::opengl::Init(reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress),
procs, device);
@@ -126,12 +126,12 @@ namespace utils {
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
dawnTextureFormat GetPreferredSwapChainTextureFormat() override {
return DAWN_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
}
private:
nxtDevice mBackendDevice = nullptr;
dawnDevice mBackendDevice = nullptr;
dawnSwapChainImplementation mSwapchainImpl = {};
};

16
src/utils/VulkanBinding.cpp
View File

@@ -24,13 +24,13 @@
namespace backend { namespace vulkan {
void Init(nxtProcTable* procs,
nxtDevice* device,
dawnDevice* device,
const std::vector<const char*>& requiredInstanceExtensions);
VkInstance GetInstance(nxtDevice device);
VkInstance GetInstance(dawnDevice device);
dawnSwapChainImplementation CreateNativeSwapChainImpl(nxtDevice device, VkSurfaceKHR surface);
nxtTextureFormat GetNativeSwapChainPreferredFormat(
dawnSwapChainImplementation CreateNativeSwapChainImpl(dawnDevice device, VkSurfaceKHR surface);
dawnTextureFormat GetNativeSwapChainPreferredFormat(
const dawnSwapChainImplementation* swapChain);
}} // namespace backend::vulkan
@@ -49,7 +49,7 @@ namespace utils {
void Init(dawnWSIContextVulkan*) {
}
dawnSwapChainError Configure(nxtTextureFormat, nxtTextureUsageBit, uint32_t, uint32_t) {
dawnSwapChainError Configure(dawnTextureFormat, dawnTextureUsageBit, uint32_t, uint32_t) {
return DAWN_SWAP_CHAIN_NO_ERROR;
}
@@ -67,7 +67,7 @@ namespace utils {
void SetupGLFWWindowHints() override {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
void GetProcAndDevice(nxtProcTable* procs, dawnDevice* device) override {
uint32_t extensionCount = 0;
const char** glfwInstanceExtensions =
glfwGetRequiredInstanceExtensions(&extensionCount);
@@ -89,13 +89,13 @@ namespace utils {
}
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
dawnTextureFormat GetPreferredSwapChainTextureFormat() override {
ASSERT(mSwapchainImpl.userData != nullptr);
return backend::vulkan::GetNativeSwapChainPreferredFormat(&mSwapchainImpl);
}
private:
nxtDevice mDevice;
dawnDevice mDevice;
dawnSwapChainImplementation mSwapchainImpl = {};
};

4
src/wire/Wire.h
View File

@@ -35,9 +35,9 @@ namespace dawn { namespace wire {
};
CommandHandler* NewClientDevice(nxtProcTable* procs,
nxtDevice* device,
dawnDevice* device,
CommandSerializer* serializer);
CommandHandler* NewServerCommandHandler(nxtDevice device,
CommandHandler* NewServerCommandHandler(dawnDevice device,
const nxtProcTable& procs,
CommandSerializer* serializer);