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

Member rename: src/{common/utils/wire}

Browse Source
This commit is contained in:
Corentin Wallez
2017-11-23 10:49:58 -08:00
committed by Corentin Wallez
parent 8d75e5b4ae
commit ad6470466c
11 changed files with 214 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/utils/BackendBinding.cpp
View File

@@ -35,7 +35,7 @@ namespace utils {
#endif
void BackendBinding::SetWindow(GLFWwindow* window) {
this->window = window;
mWindow = window;
}
BackendBinding* CreateBinding(BackendType type) {

2
src/utils/BackendBinding.h
View File

@@ -43,7 +43,7 @@ namespace utils {
void SetWindow(GLFWwindow* window);
protected:
GLFWwindow* window = nullptr;
GLFWwindow* mWindow = nullptr;
};
BackendBinding* CreateBinding(BackendType type);

106
src/utils/D3D12Binding.cpp
View File

@@ -123,26 +123,26 @@ namespace utils {
}
private:
nxtDevice backendDevice = nullptr;
nxtProcTable procs = {};
nxtDevice mBackendDevice = nullptr;
nxtProcTable mProcs = {};
static constexpr unsigned int kFrameCount = 2;
HWND window = 0;
ComPtr<IDXGIFactory4> factory = {};
ComPtr<ID3D12CommandQueue> commandQueue = {};
ComPtr<IDXGISwapChain3> swapChain = {};
ComPtr<ID3D12Resource> renderTargetResources[kFrameCount] = {};
HWND mWindow = 0;
ComPtr<IDXGIFactory4> mFactory = {};
ComPtr<ID3D12CommandQueue> mCommandQueue = {};
ComPtr<IDXGISwapChain3> mSwapChain = {};
ComPtr<ID3D12Resource> mRenderTargetResources[kFrameCount] = {};
// Frame synchronization. Updated every frame
uint32_t renderTargetIndex = 0;
uint32_t previousRenderTargetIndex = 0;
uint64_t lastSerialRenderTargetWasUsed[kFrameCount] = {};
uint32_t mRenderTargetIndex = 0;
uint32_t mPreviousRenderTargetIndex = 0;
uint64_t mLastSerialRenderTargetWasUsed[kFrameCount] = {};
D3D12_RESOURCE_STATES renderTargetResourceState;
D3D12_RESOURCE_STATES mRenderTargetResourceState;
SwapChainImplD3D12(HWND window, nxtProcTable procs)
: window(window), procs(procs), factory(CreateFactory()) {
: mWindow(window), mProcs(procs), mFactory(CreateFactory()) {
}
~SwapChainImplD3D12() {
@@ -152,8 +152,8 @@ namespace utils {
friend class SwapChainImpl;
void Init(nxtWSIContextD3D12* ctx) {
backendDevice = ctx->device;
commandQueue = backend::d3d12::GetCommandQueue(backendDevice);
mBackendDevice = ctx->device;
mCommandQueue = backend::d3d12::GetCommandQueue(mBackendDevice);
}
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit allowedUsage,
@@ -175,73 +175,73 @@ namespace utils {
swapChainDesc.SampleDesc.Quality = 0;
ComPtr<IDXGISwapChain1> swapChain1;
ASSERT_SUCCESS(factory->CreateSwapChainForHwnd(
commandQueue.Get(),
window,
ASSERT_SUCCESS(mFactory->CreateSwapChainForHwnd(
mCommandQueue.Get(),
mWindow,
&swapChainDesc,
nullptr,
nullptr,
&swapChain1
));
ASSERT_SUCCESS(swapChain1.As(&swapChain));
ASSERT_SUCCESS(swapChain1.As(&mSwapChain));
for (uint32_t n = 0; n < kFrameCount; ++n) {
ASSERT_SUCCESS(swapChain->GetBuffer(n, IID_PPV_ARGS(&renderTargetResources[n])));
ASSERT_SUCCESS(mSwapChain->GetBuffer(n, IID_PPV_ARGS(&mRenderTargetResources[n])));
}
// Get the initial render target and arbitrarily choose a "previous" render target that's different
previousRenderTargetIndex = renderTargetIndex = swapChain->GetCurrentBackBufferIndex();
previousRenderTargetIndex = renderTargetIndex == 0 ? 1 : 0;
mPreviousRenderTargetIndex = mRenderTargetIndex = mSwapChain->GetCurrentBackBufferIndex();
mPreviousRenderTargetIndex = mRenderTargetIndex == 0 ? 1 : 0;
// Initial the serial for all render targets
const uint64_t initialSerial = backend::d3d12::GetSerial(backendDevice);
const uint64_t initialSerial = backend::d3d12::GetSerial(mBackendDevice);
for (uint32_t n = 0; n < kFrameCount; ++n) {
lastSerialRenderTargetWasUsed[n] = initialSerial;
mLastSerialRenderTargetWasUsed[n] = initialSerial;
}
return NXT_SWAP_CHAIN_NO_ERROR;
}
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
nextTexture->texture = renderTargetResources[renderTargetIndex].Get();
nextTexture->texture = mRenderTargetResources[mRenderTargetIndex].Get();
return NXT_SWAP_CHAIN_NO_ERROR;
}
nxtSwapChainError Present() {
// Current frame already transitioned to Present by the application, but
// we need to flush the D3D12 backend's pending transitions.
procs.deviceTick(backendDevice);
mProcs.deviceTick(mBackendDevice);
ASSERT_SUCCESS(swapChain->Present(1, 0));
ASSERT_SUCCESS(mSwapChain->Present(1, 0));
// Transition last frame's render target back to being a render target
if (renderTargetResourceState != D3D12_RESOURCE_STATE_PRESENT) {
if (mRenderTargetResourceState != D3D12_RESOURCE_STATE_PRESENT) {
ComPtr<ID3D12GraphicsCommandList> commandList = {};
backend::d3d12::OpenCommandList(backendDevice, &commandList);
backend::d3d12::OpenCommandList(mBackendDevice, &commandList);
D3D12_RESOURCE_BARRIER resourceBarrier;
resourceBarrier.Transition.pResource = renderTargetResources[previousRenderTargetIndex].Get();
resourceBarrier.Transition.pResource = mRenderTargetResources[mPreviousRenderTargetIndex].Get();
resourceBarrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
resourceBarrier.Transition.StateAfter = renderTargetResourceState;
resourceBarrier.Transition.StateAfter = mRenderTargetResourceState;
resourceBarrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
resourceBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
resourceBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
commandList->ResourceBarrier(1, &resourceBarrier);
ASSERT_SUCCESS(commandList->Close());
backend::d3d12::ExecuteCommandLists(backendDevice, { commandList.Get() });
backend::d3d12::ExecuteCommandLists(mBackendDevice, { commandList.Get() });
}
backend::d3d12::NextSerial(backendDevice);
backend::d3d12::NextSerial(mBackendDevice);
previousRenderTargetIndex = renderTargetIndex;
renderTargetIndex = swapChain->GetCurrentBackBufferIndex();
mPreviousRenderTargetIndex = mRenderTargetIndex;
mRenderTargetIndex = mSwapChain->GetCurrentBackBufferIndex();
// If the next render target is not ready to be rendered yet, wait until it is ready.
// If the last completed serial is less than the last requested serial for this render target,
// then the commands previously executed on this render target have not yet completed
backend::d3d12::WaitForSerial(backendDevice, lastSerialRenderTargetWasUsed[renderTargetIndex]);
backend::d3d12::WaitForSerial(mBackendDevice, mLastSerialRenderTargetWasUsed[mRenderTargetIndex]);
lastSerialRenderTargetWasUsed[renderTargetIndex] = backend::d3d12::GetSerial(backendDevice);
mLastSerialRenderTargetWasUsed[mRenderTargetIndex] = backend::d3d12::GetSerial(mBackendDevice);
return NXT_SWAP_CHAIN_NO_ERROR;
}
@@ -254,25 +254,25 @@ namespace utils {
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
factory = CreateFactory();
ASSERT(GetHardwareAdapter(factory.Get(), &hardwareAdapter));
mFactory = CreateFactory();
ASSERT(GetHardwareAdapter(mFactory.Get(), &mHardwareAdapter));
ASSERT_SUCCESS(D3D12CreateDevice(
hardwareAdapter.Get(),
mHardwareAdapter.Get(),
D3D_FEATURE_LEVEL_11_0,
IID_PPV_ARGS(&d3d12Device)
IID_PPV_ARGS(&mD3d12Device)
));
backend::d3d12::Init(d3d12Device, procs, device);
backendDevice = *device;
procTable = *procs;
backend::d3d12::Init(mD3d12Device, procs, device);
mBackendDevice = *device;
mProcTable = *procs;
}
uint64_t GetSwapChainImplementation() override {
if (swapchainImpl.userData == nullptr) {
HWND win32Window = glfwGetWin32Window(window);
swapchainImpl = SwapChainImplD3D12::Create(win32Window, procTable);
if (mSwapchainImpl.userData == nullptr) {
HWND win32Window = glfwGetWin32Window(mWindow);
mSwapchainImpl = SwapChainImplD3D12::Create(win32Window, mProcTable);
}
return reinterpret_cast<uint64_t>(&swapchainImpl);
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
@@ -280,14 +280,14 @@ namespace utils {
}
private:
nxtDevice backendDevice = nullptr;
nxtSwapChainImplementation swapchainImpl = {};
nxtProcTable procTable = {};
nxtDevice mBackendDevice = nullptr;
nxtSwapChainImplementation mSwapchainImpl = {};
nxtProcTable mProcTable = {};
// Initialization
ComPtr<IDXGIFactory4> factory;
ComPtr<IDXGIAdapter1> hardwareAdapter;
ComPtr<ID3D12Device> d3d12Device;
ComPtr<IDXGIFactory4> mFactory;
ComPtr<IDXGIAdapter1> mHardwareAdapter;
ComPtr<ID3D12Device> mD3d12Device;
static bool GetHardwareAdapter(IDXGIFactory4* factory, IDXGIAdapter1** hardwareAdapter) {
*hardwareAdapter = nullptr;

72
src/utils/MetalBinding.mm
View File

@@ -43,29 +43,29 @@ namespace utils {
}
private:
id nsWindow = nil;
id<MTLDevice> mtlDevice = nil;
id<MTLCommandQueue> commandQueue = nil;
id mNsWindow = nil;
id<MTLDevice> mMtlDevice = nil;
id<MTLCommandQueue> mCommandQueue = nil;
CAMetalLayer* layer = nullptr;
id<CAMetalDrawable> currentDrawable = nil;
id<MTLTexture> currentTexture = nil;
CAMetalLayer* mLayer = nullptr;
id<CAMetalDrawable> mCurrentDrawable = nil;
id<MTLTexture> mCurrentTexture = nil;
SwapChainImplMTL(id nsWindow)
: nsWindow(nsWindow) {
: mNsWindow(nsWindow) {
}
~SwapChainImplMTL() {
[currentTexture release];
[currentDrawable release];
[mCurrentTexture release];
[mCurrentDrawable release];
}
// For GenerateSwapChainImplementation
friend class SwapChainImpl;
void Init(nxtWSIContextMetal* ctx) {
mtlDevice = ctx->device;
commandQueue = [mtlDevice newCommandQueue];
mMtlDevice = ctx->device;
mCommandQueue = [mMtlDevice newCommandQueue];
}
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit,
@@ -76,41 +76,41 @@ namespace utils {
ASSERT(width > 0);
ASSERT(height > 0);
NSView* contentView = [nsWindow contentView];
NSView* contentView = [mNsWindow contentView];
[contentView setWantsLayer: YES];
CGSize size = {};
size.width = width;
size.height = height;
layer = [CAMetalLayer layer];
[layer setDevice: mtlDevice];
[layer setPixelFormat: MTLPixelFormatBGRA8Unorm];
[layer setFramebufferOnly: YES];
[layer setDrawableSize: size];
mLayer = [CAMetalLayer layer];
[mLayer setDevice: mMtlDevice];
[mLayer setPixelFormat: MTLPixelFormatBGRA8Unorm];
[mLayer setFramebufferOnly: YES];
[mLayer setDrawableSize: size];
[contentView setLayer: layer];
[contentView setLayer: mLayer];
return NXT_SWAP_CHAIN_NO_ERROR;
}
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
[currentDrawable release];
currentDrawable = [layer nextDrawable];
[currentDrawable retain];
[mCurrentDrawable release];
mCurrentDrawable = [mLayer nextDrawable];
[mCurrentDrawable retain];
[currentTexture release];
currentTexture = currentDrawable.texture;
[currentTexture retain];
[mCurrentTexture release];
mCurrentTexture = mCurrentDrawable.texture;
[mCurrentTexture retain];
nextTexture->texture = reinterpret_cast<void*>(currentTexture);
nextTexture->texture = reinterpret_cast<void*>(mCurrentTexture);
return NXT_SWAP_CHAIN_NO_ERROR;
}
nxtSwapChainError Present() {
id<MTLCommandBuffer> commandBuffer = [commandQueue commandBuffer];
[commandBuffer presentDrawable: currentDrawable];
id<MTLCommandBuffer> commandBuffer = [mCommandQueue commandBuffer];
[commandBuffer presentDrawable: mCurrentDrawable];
[commandBuffer commit];
return NXT_SWAP_CHAIN_NO_ERROR;
@@ -123,17 +123,17 @@ namespace utils {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
metalDevice = MTLCreateSystemDefaultDevice();
mMetalDevice = MTLCreateSystemDefaultDevice();
backend::metal::Init(metalDevice, procs, device);
backendDevice = *device;
backend::metal::Init(mMetalDevice, procs, device);
mBackendDevice = *device;
}
uint64_t GetSwapChainImplementation() override {
if (swapchainImpl.userData == nullptr) {
swapchainImpl = SwapChainImplMTL::Create(glfwGetCocoaWindow(window));
if (mSwapchainImpl.userData == nullptr) {
mSwapchainImpl = SwapChainImplMTL::Create(glfwGetCocoaWindow(mWindow));
}
return reinterpret_cast<uint64_t>(&swapchainImpl);
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
@@ -141,9 +141,9 @@ namespace utils {
}
private:
id<MTLDevice> metalDevice = nil;
nxtDevice backendDevice = nullptr;
nxtSwapChainImplementation swapchainImpl = {};
id<MTLDevice> mMetalDevice = nil;
nxtDevice mBackendDevice = nullptr;
nxtSwapChainImplementation mSwapchainImpl = {};
};
BackendBinding* CreateMetalBinding() {

54
src/utils/OpenGLBinding.cpp
View File

@@ -39,34 +39,34 @@ namespace utils {
}
private:
GLFWwindow* window = nullptr;
uint32_t cfgWidth = 0;
uint32_t cfgHeight = 0;
GLuint backFBO = 0;
GLuint backTexture = 0;
GLFWwindow* mWindow = nullptr;
uint32_t mWidth = 0;
uint32_t mHeight = 0;
GLuint mBackFBO = 0;
GLuint mBackTexture = 0;
SwapChainImplGL(GLFWwindow* window)
: window(window) {
: mWindow(window) {
}
~SwapChainImplGL() {
glDeleteTextures(1, &backTexture);
glDeleteFramebuffers(1, &backFBO);
glDeleteTextures(1, &mBackTexture);
glDeleteFramebuffers(1, &mBackFBO);
}
// For GenerateSwapChainImplementation
friend class SwapChainImpl;
void Init(nxtWSIContextGL*) {
glGenTextures(1, &backTexture);
glBindTexture(GL_TEXTURE_2D, backTexture);
glGenTextures(1, &mBackTexture);
glBindTexture(GL_TEXTURE_2D, mBackTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 0,
GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glGenFramebuffers(1, &backFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, backFBO);
glGenFramebuffers(1, &mBackFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, backTexture, 0);
GL_TEXTURE_2D, mBackTexture, 0);
}
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit,
@@ -76,10 +76,10 @@ namespace utils {
}
ASSERT(width > 0);
ASSERT(height > 0);
cfgWidth = width;
cfgHeight = height;
mWidth = width;
mHeight = height;
glBindTexture(GL_TEXTURE_2D, backTexture);
glBindTexture(GL_TEXTURE_2D, mBackTexture);
// Reallocate the texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
@@ -88,16 +88,16 @@ namespace utils {
}
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
nextTexture->texture = reinterpret_cast<void*>(static_cast<size_t>(backTexture));
nextTexture->texture = reinterpret_cast<void*>(static_cast<size_t>(mBackTexture));
return NXT_SWAP_CHAIN_NO_ERROR;
}
nxtSwapChainError Present() {
glBindFramebuffer(GL_READ_FRAMEBUFFER, backFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBlitFramebuffer(0, 0, cfgWidth, cfgHeight, 0, 0, cfgWidth, cfgHeight,
glBlitFramebuffer(0, 0, mWidth, mHeight, 0, 0, mWidth, mHeight,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glfwSwapBuffers(window);
glfwSwapBuffers(mWindow);
return NXT_SWAP_CHAIN_NO_ERROR;
}
@@ -119,17 +119,17 @@ namespace utils {
#endif
}
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
glfwMakeContextCurrent(window);
glfwMakeContextCurrent(mWindow);
backend::opengl::Init(reinterpret_cast<void*(*)(const char*)>(glfwGetProcAddress), procs, device);
backendDevice = *device;
mBackendDevice = *device;
}
uint64_t GetSwapChainImplementation() override {
if (swapchainImpl.userData == nullptr) {
swapchainImpl = SwapChainImplGL::Create(window);
if (mSwapchainImpl.userData == nullptr) {
mSwapchainImpl = SwapChainImplGL::Create(mWindow);
}
return reinterpret_cast<uint64_t>(&swapchainImpl);
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
@@ -137,8 +137,8 @@ namespace utils {
}
private:
nxtDevice backendDevice = nullptr;
nxtSwapChainImplementation swapchainImpl = {};
nxtDevice mBackendDevice = nullptr;
nxtSwapChainImplementation mSwapchainImpl = {};
};
BackendBinding* CreateOpenGLBinding() {

8
src/utils/VulkanBinding.cpp
View File

@@ -70,17 +70,17 @@ namespace utils {
backend::vulkan::Init(procs, device);
}
uint64_t GetSwapChainImplementation() override {
if (swapchainImpl.userData == nullptr) {
swapchainImpl = SwapChainImplVulkan::Create(window);
if (mSwapchainImpl.userData == nullptr) {
mSwapchainImpl = SwapChainImplVulkan::Create(mWindow);
}
return reinterpret_cast<uint64_t>(&swapchainImpl);
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
}
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
}
private:
nxtSwapChainImplementation swapchainImpl = {};
nxtSwapChainImplementation mSwapchainImpl = {};
};