Start aligning Dx and OpenGl approaches.

This commit is contained in:
jmsgrogan 2023-01-05 08:46:01 +00:00
parent d1ec8b4f68
commit d99a36f24f
22 changed files with 899 additions and 366 deletions

View file

@ -44,9 +44,20 @@ if(UNIX)
endif()
else()
list(APPEND graphics_LIB_INCLUDES
directx/DirectXPainter.cpp)
directx/DirectXPainter.cpp
directx/DirectXTextPainter.cpp
directx/DirectXMeshPainter.cpp
directx/DirectXShaderProgram.cpp
)
list(APPEND graphics_HEADERS
directx/DirectXPainter.h)
directx/DirectXPainter.h
directx/DirectXTextPainter.h
directx/DirectXMeshPainter.h
directx/DirectXShaderProgram.h
)
find_package(DirectX-Headers REQUIRED)
list(APPEND platform_LIBS D3D12.lib D3DCompiler.lib Dwrite.lib D2d1.lib Microsoft::DirectX-Headers)
endif()
add_library(${MODULE_NAME} SHARED
@ -57,6 +68,7 @@ target_include_directories(${MODULE_NAME} PUBLIC
${platform_INCLUDE_DIRS}
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/opengl
${CMAKE_CURRENT_SOURCE_DIR}/directx
)
target_compile_definitions(${MODULE_NAME} PRIVATE ${DEFINES})

View file

@ -41,3 +41,8 @@ void DrawingContext::paint()
mPainter->paint(this);
}
AbstractPainter* DrawingContext::getPainter() const
{
return mPainter.get();
}

View file

@ -26,6 +26,8 @@ public:
void paint();
AbstractPainter* getPainter() const;
private:
DrawingMode mDrawingMode;
FontsManager* mFontsManager{nullptr};

View file

@ -8,6 +8,13 @@
#include "OpenGlFontTexture.h"
#endif
#ifdef _WIN32
#include "DirectXPainter.h"
//#include "DirectXMeshPainter.h"
//#include "DirectXTextPainter.h"
//#include "DirectXShaderProgram.h"
#endif
#include "Grid.h"
#include "RasterPainter.h"
@ -16,6 +23,16 @@
std::unique_ptr<AbstractPainter> PainterFactory::Create(DrawingMode drawMode)
{
#ifdef _WIN32
if (drawMode == DrawingMode::GRAPH)
{
return std::make_unique<DirectXPainter>();
}
else
{
return std::make_unique<RasterPainter>();
}
#else
#ifdef HAS_OPENGL
if (drawMode == DrawingMode::GRAPH)
{
@ -28,6 +45,7 @@ std::unique_ptr<AbstractPainter> PainterFactory::Create(DrawingMode drawMode)
#else
return std::make_unique<RasterPainter>();
#endif
#endif
}

View file

@ -0,0 +1,242 @@
#include "DirectXMeshPainter.h"
#include "DrawingContext.h"
#include "DrawingSurface.h"
#include "SceneModel.h"
#include "TriMesh.h"
#include "LineMesh.h"
#include "DirectXShaderProgram.h"
#include <windows.h>
#include <iostream>
#include <filesystem>
#include <directx/d3dx12.h>
DirectXMeshPainter::DirectXMeshPainter()
{
const float aspectRatio = 1.0;
mVertexBuffer =
{
{ { 0.0f, 0.25f * aspectRatio, 0.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
{ { 0.25f, -0.25f * aspectRatio, 0.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
{ { -0.25f, -0.25f * aspectRatio, 0.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
};
auto shader_path = std::filesystem::path(__FILE__).parent_path() / "shaders.hlsl";
mShaderProgram = std::make_unique<DirectXShaderProgram>(shader_path, shader_path);
}
void DirectXMeshPainter::initializeShader()
{
}
DirectXShaderProgram* DirectXMeshPainter::getShaderProgram() const
{
return mShaderProgram.get();
}
unsigned int DirectXMeshPainter::getVertexBufferSize() const
{
return mVertexBuffer.size()*sizeof(Vertex);
}
unsigned int DirectXMeshPainter::getVertexSize() const
{
return sizeof(Vertex);
}
ID3D12PipelineState* DirectXMeshPainter::getPipelineState() const
{
return mPipelineState.Get();
}
ID3D12RootSignature* DirectXMeshPainter::getRootSignature() const
{
return mRootSignature.Get();
}
void DirectXMeshPainter::updateVertexBuffer(unsigned char* pBuffer) const
{
memcpy(pBuffer, mVertexBuffer.data(), getVertexBufferSize());
}
void DirectXMeshPainter::updateCommandList(const CD3DX12_CPU_DESCRIPTOR_HANDLE& rtvHandle, ID3D12GraphicsCommandList* commandList)
{
const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
commandList->IASetVertexBuffers(0, 1, &mVertexBufferView);
commandList->DrawInstanced(3, 1, 0, 0);
}
void DirectXMeshPainter::initializeBuffers()
{
/*
glGenBuffers(1, &mVertexBuffer);
glGenBuffers(1, &mElementBuffer);
glGenVertexArrays(1, &mVertexArray);
*/
}
void DirectXMeshPainter::paint(const std::vector<float>& verts, const std::vector<unsigned>& elements, const std::vector<float>& color, bool lines)
{
/*
glBindVertexArray(mVertexArray);
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
glBufferData(GL_ARRAY_BUFFER, verts.size() * sizeof(float), verts.data(), GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mElementBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, elements.size() * sizeof(unsigned), elements.data(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
//glm::mat4 projection = glm::ortho(0.0f, width, 0.0f, height);
//glUniformMatrix4fv(glGetUniformLocation(mShaderProgram->getHandle(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glUseProgram(mShaderProgram->getHandle());
glBindVertexArray(mVertexArray);
int vertexColorLocation = glGetUniformLocation(mShaderProgram->getHandle(), "ourColor");
glUniform4f(vertexColorLocation, float(color[0]), float(color[1]), float(color[2]), float(color[3]));
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
if (lines)
{
glDrawElements(GL_LINES, elements.size(), GL_UNSIGNED_INT, 0);
}
else
{
glDrawElements(GL_TRIANGLES, elements.size(), GL_UNSIGNED_INT, 0);
}
glBindVertexArray(0);
*/
}
void DirectXMeshPainter::paint(SceneModel* model, DrawingContext* context)
{
return;
/*
if (!mShaderProgram)
{
initializeShader();
}
if (mVertexArray == 0)
{
initializeBuffers();
}
auto surface = context->getSurface();
const auto width = float(surface->getWidth());
const auto height = float(surface->getHeight());
auto transform = model->getTransform();
auto vertices = model->getMesh()->getVerticesFlat<float>();
for (std::size_t idx = 0; idx < vertices.size(); idx++)
{
if (idx % 3 == 0)
{
auto x = vertices[idx] * transform.getScaleX() + transform.getLocation().getX();
vertices[idx] = 2 * x / width - 1.0;
}
else if (idx % 3 == 1)
{
auto y = vertices[idx] * transform.getScaleY() + transform.getLocation().getY();
vertices[idx] = 1.0 - 2 * y / height;
}
}
std::vector<unsigned> indices;
const bool line_mesh = model->getMesh()->getType() == AbstractMesh::MeshType::LINE;
if (line_mesh)
{
indices = dynamic_cast<LineMesh*>(model->getMesh())->getEdgeNodeIds();
}
else
{
indices = dynamic_cast<TriMesh*>(model->getMesh())->getFaceNodeIds();
}
auto model_color = model->getColor().getAsVectorDouble();
std::vector<float> color = { float(model_color[0]), float(model_color[1]), float(model_color[2]), float(model_color[3]) };
paint(vertices, indices, color, line_mesh);
if (model->getShowOutline())
{
auto edge_indices = dynamic_cast<TriMesh*>(model->getMesh())->getEdgeNodeIds();
paint(vertices, edge_indices, { 0, 0, 0, 1 }, true);
}
*/
}
void DirectXMeshPainter::createVertexBuffer(ID3D12Device* device)
{
// Note: using upload heaps to transfer static data like vert buffers is not
// recommended. Every time the GPU needs it, the upload heap will be marshalled
// over. Please read up on Default Heap usage. An upload heap is used here for
// code simplicity and because there are very few verts to actually transfer.
CD3DX12_HEAP_PROPERTIES heapProps(D3D12_HEAP_TYPE_UPLOAD);
auto desc = CD3DX12_RESOURCE_DESC::Buffer(getVertexBufferSize());
device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&mD3dVertexBuffer));
// Copy the mesh data to the vertex buffer.
UINT8* pVertexDataBegin;
CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU.
mD3dVertexBuffer->Map(0, &readRange, reinterpret_cast<void**>(&pVertexDataBegin));
updateVertexBuffer(pVertexDataBegin);
mD3dVertexBuffer->Unmap(0, nullptr);
// Initialize the vertex buffer view.
mVertexBufferView.BufferLocation = mD3dVertexBuffer->GetGPUVirtualAddress();
mVertexBufferView.StrideInBytes = getVertexSize();
mVertexBufferView.SizeInBytes = getVertexBufferSize();
}
void DirectXMeshPainter::createRootSignature(ID3D12Device* device)
{
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
Microsoft::WRL::ComPtr<ID3DBlob> signature;
Microsoft::WRL::ComPtr<ID3DBlob> error;
D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error);
device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&mRootSignature));
}
void DirectXMeshPainter::createPipelineStateObject(ID3D12Device* device)
{
auto vert_shader = mShaderProgram->getVertexShader();
auto pixel_shader = mShaderProgram->getPixelShader();
D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
};
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = { inputElementDescs, _countof(inputElementDescs) };
psoDesc.pRootSignature = mRootSignature.Get();
psoDesc.VS = CD3DX12_SHADER_BYTECODE(vert_shader);
psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixel_shader);
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
psoDesc.DepthStencilState.DepthEnable = FALSE;
psoDesc.DepthStencilState.StencilEnable = FALSE;
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
psoDesc.SampleDesc.Count = 1;
device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&mPipelineState));
}

View file

@ -0,0 +1,60 @@
#pragma once
#include <wrl.h>
#include <directxmath.h>
#include <d3d12.h>
#include <memory>
#include <vector>
class DrawingContext;
class DirectXShaderProgram;
class SceneModel;
struct CD3DX12_CPU_DESCRIPTOR_HANDLE;
class DirectXMeshPainter
{
public:
DirectXMeshPainter();
void paint(SceneModel* model, DrawingContext* context);
DirectXShaderProgram* getShaderProgram() const;
void createVertexBuffer(ID3D12Device* device);
void createRootSignature(ID3D12Device* device);
void createPipelineStateObject(ID3D12Device* device);
ID3D12PipelineState* getPipelineState() const;
ID3D12RootSignature* getRootSignature() const;
void updateCommandList(const CD3DX12_CPU_DESCRIPTOR_HANDLE& rtvHandle, ID3D12GraphicsCommandList* commandList);
private:
struct Vertex
{
DirectX::XMFLOAT3 position;
DirectX::XMFLOAT4 color;
};
void initializeShader();
void initializeBuffers();
unsigned int getVertexBufferSize() const;
unsigned int getVertexSize() const;
void updateVertexBuffer(unsigned char* pBuffer) const;
void paint(const std::vector<float>& verts, const std::vector<unsigned>& elements, const std::vector<float>& color, bool lines = false);
unsigned int mVertexBufferSize{ 0 };
std::vector<Vertex> mVertexBuffer;
Microsoft::WRL::ComPtr<ID3D12Resource> mD3dVertexBuffer;
D3D12_VERTEX_BUFFER_VIEW mVertexBufferView{};
Microsoft::WRL::ComPtr<ID3D12RootSignature> mRootSignature;
Microsoft::WRL::ComPtr<ID3D12PipelineState> mPipelineState;
std::unique_ptr<DirectXShaderProgram> mShaderProgram;
};

View file

@ -0,0 +1,73 @@
#include "DirectXPainter.h"
#include "DrawingContext.h"
#include "DrawingSurface.h"
#include "Scene.h"
#include "SceneItem.h"
#include "SceneModel.h"
#include "SceneText.h"
#include "TriMesh.h"
#include "FontsManager.h"
#include "FontGlyph.h"
#include "TextData.h"
#include "DirectXShaderProgram.h"
#include "DirectXMeshPainter.h"
#include "DirectXTextPainter.h"
#include "File.h"
#include <windows.h>
#include <iostream>
DirectXPainter::DirectXPainter()
: mMeshPainter(std::make_unique<DirectXMeshPainter>()),
mTextPainter(std::make_unique<DirectXTextPainter>())
{
}
DirectXMeshPainter* DirectXPainter::getMeshPainter() const
{
return mMeshPainter.get();
}
DirectXTextPainter* DirectXPainter::getTextPainter() const
{
return mTextPainter.get();
}
void DirectXPainter::paint(DrawingContext* context)
{
auto surface = context->getSurface();
const auto width = double(surface->getWidth());
const auto height = double(surface->getHeight());
/*
glViewport(0, 0, width, height);
glOrtho(0, width, 0, height, -1.0, 1.0);
glClearColor(0.5, 0.5, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
*/
auto scene = context->getSurface()->getScene();
for (const auto item : scene->getItems())
{
if (item->getType() == SceneItem::Type::MODEL)
{
mMeshPainter->paint(dynamic_cast<SceneModel*>(item), context);
}
else if (item->getType() == SceneItem::Type::TEXT)
{
mTextPainter->paint(dynamic_cast<SceneText*>(item), context);
}
}
/*
glFlush();
*/
}

View file

@ -0,0 +1,22 @@
#pragma once
#include "AbstractPainter.h"
#include <memory>
class DrawingContext;
class DirectXMeshPainter;
class DirectXTextPainter;
class DirectXPainter : public AbstractPainter
{
public:
DirectXPainter();
void paint(DrawingContext* context) override;
DirectXMeshPainter* getMeshPainter() const;
DirectXTextPainter* getTextPainter() const;
private:
std::unique_ptr<DirectXMeshPainter> mMeshPainter;
std::unique_ptr<DirectXTextPainter> mTextPainter;
};

View file

@ -0,0 +1,31 @@
#include "DirectXShaderProgram.h"
#include "File.h"
#include "FileLogger.h"
#include <d3d12.h>
#include <d3dcompiler.h>
DirectXShaderProgram::DirectXShaderProgram(const Path& vertShaderPath, const Path& fragShaderPath)
{
#if defined(_DEBUG)
// Enable better shader debugging with the graphics debugging tools.
// UINT compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
UINT compileFlags = 0;
#else
UINT compileFlags = 0;
#endif
D3DCompileFromFile(vertShaderPath.c_str(), nullptr, nullptr, "VSMain", "vs_5_0", compileFlags, 0, &mVertexShader, nullptr);
D3DCompileFromFile(fragShaderPath.c_str(), nullptr, nullptr, "PSMain", "ps_5_0", compileFlags, 0, &mPixelShader, nullptr);
}
ID3DBlob* DirectXShaderProgram::getVertexShader() const
{
return mVertexShader.Get();
}
ID3DBlob* DirectXShaderProgram::getPixelShader() const
{
return mPixelShader.Get();
}

View file

@ -0,0 +1,20 @@
#pragma once
#include <wrl.h>
#include <D3Dcommon.h>
#include <filesystem>
using Path = std::filesystem::path;
class DirectXShaderProgram
{
public:
DirectXShaderProgram(const Path& vertShaderPath, const Path& pixelShaderPath);
ID3DBlob* getVertexShader() const;
ID3DBlob* getPixelShader() const;
private:
Microsoft::WRL::ComPtr<ID3DBlob> mVertexShader;
Microsoft::WRL::ComPtr<ID3DBlob> mPixelShader;
};

View file

@ -0,0 +1,64 @@
#include "DirectXTextPainter.h"
#include "DrawingContext.h"
#include "DrawingSurface.h"
#include "FontsManager.h"
#include "FontGlyph.h"
#include "DirectXShaderProgram.h"
#include "TextData.h"
#include "SceneText.h"
#include "File.h"
#include <windows.h>
#include <d2d1_3.h>
#include <d2d1_1.h>
#include <dwrite.h>
DirectXTextPainter::DirectXTextPainter()
{
}
void DirectXTextPainter::paint(SceneText* text, DrawingContext* context)
{
}
void DirectXTextPainter::paint(ID2D1DeviceContext2* d2dContext, float width, float height)
{
D2D1_RECT_F textRect = D2D1::RectF(0, 0, width, height);
static const WCHAR text[] = L"11On12";
d2dContext->BeginDraw();
d2dContext->SetTransform(D2D1::Matrix3x2F::Identity());
d2dContext->DrawText(text, _countof(text) - 1, mTextFormat.Get(), &textRect, mTextBrush.Get());
d2dContext->EndDraw();
}
void DirectXTextPainter::initializeBrush(ID2D1DeviceContext2* d2dContext)
{
d2dContext->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &mTextBrush);
}
void DirectXTextPainter::initializeTextFormat(IDWriteFactory* directWriteFactory)
{
directWriteFactory->CreateTextFormat(
L"Verdana",
NULL,
DWRITE_FONT_WEIGHT_NORMAL,
DWRITE_FONT_STYLE_NORMAL,
DWRITE_FONT_STRETCH_NORMAL,
50,
L"en-us",
&mTextFormat
);
mTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
mTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
}

View file

@ -0,0 +1,37 @@
#pragma once
#include <wrl.h>
#include <dwrite.h>
#include <d2d1_3.h>
#include <d2d1_1.h>
#include <unordered_map>
#include <memory>
class DrawingContext;
class DirectXShaderProgram;
class TextData;
class SceneText;
struct ID2D1DeviceContext2;
struct ID2D1SolidColorBrush;
struct IDWriteFactory;
class DirectXTextPainter
{
public:
DirectXTextPainter();
void paint(SceneText* text, DrawingContext* context);
void paint(ID2D1DeviceContext2* d2dContext, float width, float height);
void initializeBrush(ID2D1DeviceContext2* d2dContext);
void initializeTextFormat(IDWriteFactory* directWriteFactory);
private:
Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> mTextBrush;
Microsoft::WRL::ComPtr<IDWriteTextFormat> mTextFormat;
};

View file

@ -116,6 +116,11 @@ void Window::show()
}
}
DrawingContext* Window::getDrawingContent() const
{
return mDrawingContext.get();
}
void Window::doPaint(mt::Screen* screen)
{
if (mPlatformWindow)

View file

@ -98,6 +98,8 @@ public:
return mParent;
}
DrawingContext* getDrawingContent() const;
private:
WidgetPtr mWidget {nullptr};
std::string mTitle;

View file

@ -97,6 +97,11 @@ unsigned TextNode::getNumSceneItems() const
void TextNode::updateLines(FontsManager* fontsManager)
{
if (!fontsManager)
{
return;
}
auto original_count = mTextData.mLines.size();
std::vector<std::string> lines = StringUtils::toLines(mTextData.mContent);
std::vector<std::string> output_lines;

View file

@ -31,7 +31,6 @@ void Win32DxInterface::getHardwareAdapter(IDXGIAdapter1** ppAdapter)
IDXGIAdapter1* pAdapter = nullptr;
if (DXGI_ERROR_NOT_FOUND == mFactory->EnumAdapters1(adapterIndex, &pAdapter))
{
// No more adapters to enumerate.
break;
}
@ -92,50 +91,71 @@ ID3D11DeviceContext* Win32DxInterface::getD3d11DeviceContext() const
void Win32DxInterface::initialize()
{
if (!DirectX::XMVerifyCPUSupport())
{
MLOG_ERROR("Directx math not supported");
return;
}
MLOG_INFO("Initialize DX");
UINT dxgiFactoryFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
// Enable the D3D12 debug layer.
{
ID3D12Debug* debugController;
D3D12GetDebugInterface(IID_PPV_ARGS(&debugController));
Microsoft::WRL::ComPtr<ID3D12Debug> debugController;
if (SUCCEEDED(::D3D12GetDebugInterface(IID_PPV_ARGS(&debugController))))
{
debugController->EnableDebugLayer();
dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
}
}
#endif
HRESULT hr = CreateDXGIFactory(__uuidof(IDXGIFactory7), (void**)(&mFactory));
HRESULT hr = ::CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&mFactory));
IDXGIAdapter1* pAdapter{ nullptr };
Microsoft::WRL::ComPtr<IDXGIAdapter1> pAdapter;
getHardwareAdapter(&pAdapter);
if (pAdapter)
{
MLOG_INFO("Found adapter");
if (SUCCEEDED(D3D12CreateDevice(pAdapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&mDevice))))
if (!SUCCEEDED(D3D12CreateDevice(pAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&mDevice))))
{
MLOG_INFO("Got device");
MLOG_ERROR("Failed to create D3D12 device.");
return;
}
}
else
{
MLOG_INFO("No adapter found");
MLOG_ERROR("Failed to get DX hardware adapter.");
return;
}
D3D12_COMMAND_QUEUE_DESC queueDesc = {};
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
if (!SUCCEEDED(mDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue))))
{
MLOG_ERROR("Failed to create command queue.");
return;
}
mDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue));
mIsValid = initializeD2d();
const auto init_2d_ok = initializeD2d();
mIsValid = init_2d_ok;
}
bool Win32DxInterface::initializeD2d()
{
if (!initializeD11on12())
{
return false;
}
D2D1_FACTORY_OPTIONS d2dFactoryOptions = {};
D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory3), &d2dFactoryOptions, &mD2dFactory);
Microsoft::WRL::ComPtr<IDXGIDevice> dxgiDevice;
mD3d11On12Device.As(&dxgiDevice);
mD2dFactory->CreateDevice(dxgiDevice.Get(), &mD2dDevice);
D2D1_DEVICE_CONTEXT_OPTIONS deviceOptions = D2D1_DEVICE_CONTEXT_OPTIONS_NONE;
mD2dDevice->CreateDeviceContext(deviceOptions, &mD2dDeviceContext);
return initializeDirectWrite();
}
bool Win32DxInterface::initializeD11on12()
{
Microsoft::WRL::ComPtr<ID3D11Device> d3d11Device;
UINT d3d11DeviceFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
@ -151,24 +171,12 @@ bool Win32DxInterface::initializeD2d()
&mD3d11DeviceContext,
nullptr
);
d3d11Device.As(&mD3d11On12Device);
// Create D2D/DWrite components.
{
D2D1_DEVICE_CONTEXT_OPTIONS deviceOptions = D2D1_DEVICE_CONTEXT_OPTIONS_NONE;
D2D1_FACTORY_OPTIONS d2dFactoryOptions = {};
D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory3), &d2dFactoryOptions, &mD2dFactory);
Microsoft::WRL::ComPtr<IDXGIDevice> dxgiDevice;
mD3d11On12Device.As(&dxgiDevice);
mD2dFactory->CreateDevice(dxgiDevice.Get(), &mD2dDevice);
mD2dDevice->CreateDeviceContext(deviceOptions, &mD2dDeviceContext);
DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &mDWriteFactory);
}
return true;
}
bool Win32DxInterface::initializeDirectWrite()
{
DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &mDWriteFactory);
return true;
}

View file

@ -42,6 +42,8 @@ private:
void getHardwareAdapter(IDXGIAdapter1** ppAdapter);
bool initializeD2d();
bool initializeD11on12();
bool initializeDirectWrite();
bool mIsValid{ false };

View file

@ -4,6 +4,13 @@
#include "Win32Window.h"
#include "Window.h"
#include "Widget.h"
#include "FileLogger.h"
#include "DrawingContext.h"
#include "DirectXPainter.h"
#include "DirectXMeshPainter.h"
#include "DirectXTextPainter.h"
#include "DirectXShaderProgram.h"
#include <dxgi.h>
#include <dxgi1_6.h>
@ -14,11 +21,13 @@
#include <d3d11on12.h>
#include <d2d1_3.h>
#include <d2d1_1.h>
#include <D3Dcommon.h>
#include <dwrite.h>
Win32DxWindowInterface::Win32DxWindowInterface(Win32DxInterface* dxInterface)
: mDxInterface(dxInterface)
Win32DxWindowInterface::Win32DxWindowInterface(mt::Window* window, Win32DxInterface* dxInterface)
: mWindow(window),
mDxInterface(dxInterface)
{
}
@ -37,6 +46,11 @@ void Win32DxWindowInterface::destroyWindow()
void Win32DxWindowInterface::onRender()
{
if (!mIsValid)
{
return;
}
// Record all the commands we need to render the scene into the command list.
populateCommandList();
@ -54,6 +68,8 @@ void Win32DxWindowInterface::onRender()
void Win32DxWindowInterface::populateCommandList()
{
auto painter = dynamic_cast<DirectXPainter*>(mWindow->getDrawingContent()->getPainter());
// Command list allocators can only be reset when the associated
// command lists have finished execution on the GPU; apps should use
// fences to determine GPU execution progress.
@ -62,10 +78,10 @@ void Win32DxWindowInterface::populateCommandList()
// However, when ExecuteCommandList() is called on a particular command
// list, that command list can then be reset at any time and must be before
// re-recording.
mCommandList->Reset(mCommandAllocator.Get(), mPipelineState.Get());
mCommandList->Reset(mCommandAllocator.Get(), painter->getMeshPainter()->getPipelineState());
// Set necessary state.
mCommandList->SetGraphicsRootSignature(mRootSignature.Get());
mCommandList->SetGraphicsRootSignature(painter->getMeshPainter()->getRootSignature());
mCommandList->RSSetViewports(1, &mViewport);
mCommandList->RSSetScissorRects(1, &mScissorRect);
@ -76,12 +92,7 @@ void Win32DxWindowInterface::populateCommandList()
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(mRtvHeap->GetCPUDescriptorHandleForHeapStart(), static_cast<INT>(mFrameIndex), mRtvDescriptorSize);
mCommandList->OMSetRenderTargets(1, &rtvHandle, FALSE, nullptr);
// Record commands.
const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
mCommandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
mCommandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
mCommandList->IASetVertexBuffers(0, 1, &mVertexBufferView);
mCommandList->DrawInstanced(3, 1, 0, 0);
painter->getMeshPainter()->updateCommandList(rtvHandle, mCommandList.Get());
// Indicate that the back buffer will now be used to present.
//barrier = CD3DX12_RESOURCE_BARRIER::Transition(mRenderTargets[mFrameIndex].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
@ -90,61 +101,120 @@ void Win32DxWindowInterface::populateCommandList()
mCommandList->Close();
}
bool Win32DxWindowInterface::initialize(mt::Window* window)
void Win32DxWindowInterface::renderD2d()
{
// Acquire our wrapped render target resource for the current back buffer.
mDxInterface->get11On12Device()->AcquireWrappedResources(mWrappedBackBuffers[mFrameIndex].GetAddressOf(), 1);
// Render text directly to the back buffer.
mDxInterface->getD2dContext()->SetTarget(mD2dRenderTargets[mFrameIndex].Get());
auto painter = dynamic_cast<DirectXPainter*>(mWindow->getDrawingContent()->getPainter());
D2D1_SIZE_F rtSize = mD2dRenderTargets[mFrameIndex]->GetSize();
painter->getTextPainter()->paint(mDxInterface->getD2dContext(), rtSize.width, rtSize.height);
// Release our wrapped render target resource. Releasing
// transitions the back buffer resource to the state specified
// as the OutState when the wrapped resource was created.
mDxInterface->get11On12Device()->ReleaseWrappedResources(mWrappedBackBuffers[mFrameIndex].GetAddressOf(), 1);
// Flush to submit the 11 command list to the shared command queue.
mDxInterface->getD3d11DeviceContext()->Flush();
}
bool Win32DxWindowInterface::initialize()
{
if (mInitialized)
{
return true;
}
mInitialized = true;
const auto width = window->getWidth();
const auto height = window->getHeight();
mViewport = CD3DX12_VIEWPORT(0.0f, 0.0f, width, height);
const auto width = mWindow->getWidth();
const auto height = mWindow->getHeight();
mViewport = CD3DX12_VIEWPORT(0.0f, 0.0f, static_cast<float>(width), static_cast<float>(height));
mScissorRect = CD3DX12_RECT(0, 0, width, height);
loadPipeline(window);
if (!loadPipeline())
{
return false;
}
loadAssets();
if (!loadAssets())
{
return false;
}
mIsValid = true;
return true;
}
bool Win32DxWindowInterface::loadPipeline()
{
if (!setupSwapChain())
{
return false;
}
setupDescriptorHeaps();
setupFrameResources();
mDxInterface->getDevice()->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&mCommandAllocator));
return true;
}
void Win32DxWindowInterface::loadPipeline(mt::Window* window)
bool Win32DxWindowInterface::setupSwapChain()
{
const auto width = mWindow->getWidth();
const auto height = mWindow->getHeight();
const auto hwnd = dynamic_cast<Win32Window*>(mWindow->getPlatformWindow())->getHandle();
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
swapChainDesc.BufferCount = FrameCount;
const auto width = window->getWidth();
const auto height = window->getHeight();
swapChainDesc.Width = width;
swapChainDesc.Height = height;
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.SampleDesc.Count = 1;
const auto hwnd = dynamic_cast<Win32Window*>(window->getPlatformWindow())->getHandle();
auto command_queue = mDxInterface->getCommandQueue();
Microsoft::WRL::ComPtr<IDXGISwapChain1> swapChain;
mDxInterface->getFactory()->CreateSwapChainForHwnd(
mDxInterface->getCommandQueue(),
hwnd,
&swapChainDesc,
nullptr,
nullptr,
&swapChain
);
mDxInterface->getFactory()->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
const auto hr = mDxInterface->getFactory()->CreateSwapChainForHwnd(command_queue, hwnd, &swapChainDesc, nullptr, nullptr, &swapChain);
if (!SUCCEEDED(hr))
{
MLOG_ERROR("Failed to create swap chain for hwnd: " << hwnd);
return false;
}
swapChain.As(&mSwapChain);
auto mFrameIndex = mSwapChain->GetCurrentBackBufferIndex();
// Query the desktop's dpi settings, which will be used to create
// D2D's render targets.
// Prevent fullscreen toggle
mDxInterface->getFactory()->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
// Update index for backbuffer
mFrameIndex = mSwapChain->GetCurrentBackBufferIndex();
return true;
}
void Win32DxWindowInterface::setupDescriptorHeaps()
{
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
mDxInterface->getDevice()->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&mRtvHeap));
mRtvDescriptorSize = mDxInterface->getDevice()->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
}
void Win32DxWindowInterface::setupFrameResources()
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(mRtvHeap->GetCPUDescriptorHandleForHeapStart());
float dpiX{ 0.0 };
float dpiY{ 0.0 };
mDxInterface->getD2dFactory()->GetDesktopDpi(&dpiX, &dpiY);
D2D1_BITMAP_PROPERTIES1 bitmapProperties = D2D1::BitmapProperties1(
D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
@ -152,175 +222,60 @@ void Win32DxWindowInterface::loadPipeline(mt::Window* window)
dpiY
);
// Create descriptor heaps.
{
// Describe and create a render target view (RTV) descriptor heap.
D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
rtvHeapDesc.NumDescriptors = FrameCount;
rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
mDxInterface->getDevice()->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&mRtvHeap));
mRtvDescriptorSize = mDxInterface->getDevice()->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
}
// Create frame resources.
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(mRtvHeap->GetCPUDescriptorHandleForHeapStart());
// Create a RTV for each frame.
for (UINT n = 0; n < FrameCount; n++)
{
mSwapChain->GetBuffer(n, IID_PPV_ARGS(&mRenderTargets[n]));
mDxInterface->getDevice()->CreateRenderTargetView(mRenderTargets[n].Get(), nullptr, rtvHandle);
setupFrameResource(n, rtvHandle, bitmapProperties);
}
}
void Win32DxWindowInterface::setupFrameResource(UINT idx, CD3DX12_CPU_DESCRIPTOR_HANDLE& descriptorHandle, const D2D1_BITMAP_PROPERTIES1& bitmapProps)
{
mSwapChain->GetBuffer(idx, IID_PPV_ARGS(&mRenderTargets[idx]));
mDxInterface->getDevice()->CreateRenderTargetView(mRenderTargets[idx].Get(), nullptr, descriptorHandle);
setupFrameD2DResource(idx, bitmapProps);
descriptorHandle.Offset(1, mRtvDescriptorSize);
}
void Win32DxWindowInterface::setupFrameD2DResource(UINT idx, const D2D1_BITMAP_PROPERTIES1& bitmapProps)
{
D3D11_RESOURCE_FLAGS d3d11Flags = { D3D11_BIND_RENDER_TARGET };
mDxInterface->get11On12Device()->CreateWrappedResource(
mRenderTargets[n].Get(),
&d3d11Flags,
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PRESENT,
IID_PPV_ARGS(&mWrappedBackBuffers[n])
);
mDxInterface->get11On12Device()->CreateWrappedResource(mRenderTargets[idx].Get(),&d3d11Flags,
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT, IID_PPV_ARGS(&mWrappedBackBuffers[idx]));
// Create a render target for D2D to draw directly to this back buffer.
Microsoft::WRL::ComPtr<IDXGISurface> surface;
mWrappedBackBuffers[n].As(&surface);
mDxInterface->getD2dContext()->CreateBitmapFromDxgiSurface(
surface.Get(),
&bitmapProperties,
&mD2dRenderTargets[n]
);
rtvHandle.Offset(1, mRtvDescriptorSize);
}
mWrappedBackBuffers[idx].As(&surface);
mDxInterface->getD2dContext()->CreateBitmapFromDxgiSurface(surface.Get(), &bitmapProps, &mD2dRenderTargets[idx]);
}
mDxInterface->getDevice()->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&mCommandAllocator));
}
void Win32DxWindowInterface::loadAssets()
bool Win32DxWindowInterface::loadAssets()
{
// Create an empty root signature.
{
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(0, nullptr, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
auto painter = dynamic_cast<DirectXPainter*>(mWindow->getDrawingContent()->getPainter());
Microsoft::WRL::ComPtr<ID3DBlob> signature;
Microsoft::WRL::ComPtr<ID3DBlob> error;
D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error);
mDxInterface->getDevice()->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&mRootSignature));
}
// Create the pipeline state, which includes compiling and loading shaders.
{
Microsoft::WRL::ComPtr<ID3DBlob> vertexShader;
Microsoft::WRL::ComPtr<ID3DBlob> pixelShader;
#if defined(_DEBUG)
// Enable better shader debugging with the graphics debugging tools.
// UINT compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
UINT compileFlags = 0;
#else
UINT compileFlags = 0;
#endif
auto shader_path = std::filesystem::path(__FILE__).parent_path() / "shaders.hlsl";
D3DCompileFromFile(shader_path.c_str(), nullptr, nullptr, "VSMain", "vs_5_0", compileFlags, 0, &vertexShader, nullptr);
D3DCompileFromFile(shader_path.c_str(), nullptr, nullptr, "PSMain", "ps_5_0", compileFlags, 0, &pixelShader, nullptr);
// Define the vertex input layout.
D3D12_INPUT_ELEMENT_DESC inputElementDescs[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
};
// Describe and create the graphics pipeline state object (PSO).
D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.InputLayout = { inputElementDescs, _countof(inputElementDescs) };
psoDesc.pRootSignature = mRootSignature.Get();
psoDesc.VS = CD3DX12_SHADER_BYTECODE(vertexShader.Get());
psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixelShader.Get());
psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
psoDesc.DepthStencilState.DepthEnable = FALSE;
psoDesc.DepthStencilState.StencilEnable = FALSE;
psoDesc.SampleMask = UINT_MAX;
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.NumRenderTargets = 1;
psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
psoDesc.SampleDesc.Count = 1;
mDxInterface->getDevice()->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&mPipelineState));
}
painter->getMeshPainter()->createRootSignature(mDxInterface->getDevice());
painter->getMeshPainter()->createPipelineStateObject(mDxInterface->getDevice());
// Create the command list.
mDxInterface->getDevice()->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, mCommandAllocator.Get(), mPipelineState.Get(), IID_PPV_ARGS(&mCommandList));
mDxInterface->getDevice()->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, mCommandAllocator.Get(),
painter->getMeshPainter()->getPipelineState(), IID_PPV_ARGS(&mCommandList));
// Create D2D/DWrite objects for rendering text.
{
mDxInterface->getD2dContext()->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &mTextBrush);
mDxInterface->getDirectWriteFactory()->CreateTextFormat(
L"Verdana",
NULL,
DWRITE_FONT_WEIGHT_NORMAL,
DWRITE_FONT_STYLE_NORMAL,
DWRITE_FONT_STRETCH_NORMAL,
50,
L"en-us",
&mTextFormat
);
mTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
mTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
}
painter->getTextPainter()->initializeBrush(mDxInterface->getD2dContext());
painter->getTextPainter()->initializeTextFormat(mDxInterface->getDirectWriteFactory());
// Command lists are created in the recording state, but there is nothing
// to record yet. The main loop expects it to be closed, so close it now.
mCommandList->Close();
// Create the vertex buffer.
{
// Define the geometry for a triangle.
const float aspectRatio = 1.0;
Vertex triangleVertices[] =
{
{ { 0.0f, 0.25f * aspectRatio, 0.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
{ { 0.25f, -0.25f * aspectRatio, 0.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
{ { -0.25f, -0.25f * aspectRatio, 0.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
};
painter->getMeshPainter()->createVertexBuffer(mDxInterface->getDevice());
const UINT vertexBufferSize = sizeof(triangleVertices);
createSyncObjects();
// Note: using upload heaps to transfer static data like vert buffers is not
// recommended. Every time the GPU needs it, the upload heap will be marshalled
// over. Please read up on Default Heap usage. An upload heap is used here for
// code simplicity and because there are very few verts to actually transfer.
CD3DX12_HEAP_PROPERTIES heapProps(D3D12_HEAP_TYPE_UPLOAD);
auto desc = CD3DX12_RESOURCE_DESC::Buffer(vertexBufferSize);
mDxInterface->getDevice()->CreateCommittedResource(
&heapProps,
D3D12_HEAP_FLAG_NONE,
&desc,
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&mVertexBuffer));
// Copy the triangle data to the vertex buffer.
UINT8* pVertexDataBegin;
CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU.
mVertexBuffer->Map(0, &readRange, reinterpret_cast<void**>(&pVertexDataBegin));
memcpy(pVertexDataBegin, triangleVertices, sizeof(triangleVertices));
mVertexBuffer->Unmap(0, nullptr);
// Initialize the vertex buffer view.
mVertexBufferView.BufferLocation = mVertexBuffer->GetGPUVirtualAddress();
mVertexBufferView.StrideInBytes = sizeof(Vertex);
mVertexBufferView.SizeInBytes = vertexBufferSize;
return true;
}
// Create synchronization objects and wait until assets have been uploaded to the GPU.
void Win32DxWindowInterface::createSyncObjects()
{
mDxInterface->getDevice()->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&mFence));
mFenceValue = 1;
@ -337,38 +292,6 @@ void Win32DxWindowInterface::loadAssets()
// complete before continuing.
waitForPreviousFrame();
}
}
void Win32DxWindowInterface::renderD2d()
{
D2D1_SIZE_F rtSize = mD2dRenderTargets[mFrameIndex]->GetSize();
D2D1_RECT_F textRect = D2D1::RectF(0, 0, rtSize.width, rtSize.height);
static const WCHAR text[] = L"11On12";
// Acquire our wrapped render target resource for the current back buffer.
mDxInterface->get11On12Device()->AcquireWrappedResources(mWrappedBackBuffers[mFrameIndex].GetAddressOf(), 1);
// Render text directly to the back buffer.
mDxInterface->getD2dContext()->SetTarget(mD2dRenderTargets[mFrameIndex].Get());
mDxInterface->getD2dContext()->BeginDraw();
mDxInterface->getD2dContext()->SetTransform(D2D1::Matrix3x2F::Identity());
mDxInterface->getD2dContext()->DrawText(
text,
_countof(text) - 1,
mTextFormat.Get(),
&textRect,
mTextBrush.Get()
);
mDxInterface->getD2dContext()->EndDraw();
// Release our wrapped render target resource. Releasing
// transitions the back buffer resource to the state specified
// as the OutState when the wrapped resource was created.
mDxInterface->get11On12Device()->ReleaseWrappedResources(mWrappedBackBuffers[mFrameIndex].GetAddressOf(), 1);
// Flush to submit the 11 command list to the shared command queue.
mDxInterface->getD3d11DeviceContext()->Flush();
}
void Win32DxWindowInterface::waitForPreviousFrame()
{

View file

@ -4,7 +4,6 @@
#include <wrl.h>
#include <d3d12.h>
#include <directxmath.h>
#include <directx/d3dx12.h>
class Win32DxInterface;
@ -25,27 +24,23 @@ struct ID3D12PipelineState;
struct ID3D11Resource;
struct ID2D1Bitmap1;
struct ID2D1SolidColorBrush;
struct IDWriteTextFormat;
struct D2D1_BITMAP_PROPERTIES1;
struct CD3DX12_CPU_DESCRIPTOR_HANDLE;
class Win32DxWindowInterface
{
public:
Win32DxWindowInterface(Win32DxInterface* dxInterface);
Win32DxWindowInterface(mt::Window* window, Win32DxInterface* dxInterface);
~Win32DxWindowInterface();
bool initialize(mt::Window* window);
bool initialize();
void onRender();
//void afterPaint();
//void resizeViewPort(unsigned width, unsigned height);
private:
void loadPipeline(mt::Window* window);
void loadAssets();
bool loadPipeline();
bool loadAssets();
void populateCommandList();
void waitForPreviousFrame();
@ -53,16 +48,21 @@ private:
void renderD2d();
bool setupSwapChain();
void setupDescriptorHeaps();
void setupFrameResources();
void setupFrameResource(UINT idx, CD3DX12_CPU_DESCRIPTOR_HANDLE& descriptorHandle, const D2D1_BITMAP_PROPERTIES1& bitmapProps);
void setupFrameD2DResource(UINT idx, const D2D1_BITMAP_PROPERTIES1& bitmapProps);
void createSyncObjects();
static const UINT FrameCount = 2;
Win32DxInterface* mDxInterface{ nullptr };
bool mInitialized{ false };
bool mIsValid{ false };
struct Vertex
{
DirectX::XMFLOAT3 position;
DirectX::XMFLOAT4 color;
};
mt::Window* mWindow{ nullptr };
CD3DX12_VIEWPORT mViewport;
CD3DX12_RECT mScissorRect;
@ -71,9 +71,6 @@ private:
Microsoft::WRL::ComPtr<IDXGISwapChain4> mSwapChain;
Microsoft::WRL::ComPtr<ID3D12RootSignature> mRootSignature;
Microsoft::WRL::ComPtr<ID3D12PipelineState> mPipelineState;
Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> mRtvHeap;
UINT mRtvDescriptorSize{ 0 };
@ -81,12 +78,6 @@ private:
Microsoft::WRL::ComPtr<ID3D11Resource> mWrappedBackBuffers[FrameCount];
Microsoft::WRL::ComPtr<ID2D1Bitmap1> mD2dRenderTargets[FrameCount];
Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> mTextBrush;
Microsoft::WRL::ComPtr<IDWriteTextFormat> mTextFormat;
Microsoft::WRL::ComPtr<ID3D12Resource> mVertexBuffer;
D3D12_VERTEX_BUFFER_VIEW mVertexBufferView{};
Microsoft::WRL::ComPtr<ID3D12Fence> mFence;
uint64_t mFenceValue = 0;
uint64_t mFrameFenceValues[FrameCount] = {};

View file

@ -20,7 +20,7 @@ Win32Window::Win32Window(mt::Window* window, Win32DxInterface* dxInterface)
{
if (dxInterface)
{
mDxInterface = std::make_unique<Win32DxWindowInterface>(dxInterface);
mDxInterface = std::make_unique<Win32DxWindowInterface>(window, dxInterface);
}
}
@ -80,6 +80,13 @@ void Win32Window::createNative(Win32ApplicationContext* context, DesktopManager*
MLOG_INFO("Request window create got handle: " << "0x" << mHandle);
}
void Win32Window::onPaintMessage()
{
mDesktopManager->onUiEvent(PaintEvent::Create());
mWindow->doPaint(nullptr);
}
LRESULT CALLBACK Win32Window::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
@ -89,7 +96,6 @@ LRESULT CALLBACK Win32Window::WindowProc(UINT message, WPARAM wParam, LPARAM lPa
PostQuitMessage(0);
return 0;
}
case WM_CHAR:
{
auto key_event = std::make_unique<KeyboardEvent>();
@ -99,25 +105,9 @@ LRESULT CALLBACK Win32Window::WindowProc(UINT message, WPARAM wParam, LPARAM lPa
key_event->setKeyString(StringUtils::convert(std::wstring(1, keyChar)));
mDesktopManager->onUiEvent(std::move(key_event));
}
case WM_PAINT:
{
if (mDxInterface)
{
mDxInterface->onRender();
}
else
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(mHandle, &ps);
FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
auto text = L"Hello World";
auto val = DrawText(hdc, (LPCSTR)(&text[0]), -1, &ps.rcPaint, 0);
EndPaint(mHandle, &ps);
}
onPaintMessage();
}
}
return DefWindowProc(mHandle, message, wParam, lParam);
@ -136,9 +126,11 @@ static LRESULT CALLBACK FreeWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPAR
if (::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)window) == 0)
{
if (GetLastError() != 0)
{
return FALSE;
}
}
}
else
{
window = (Win32Window*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
@ -157,6 +149,26 @@ void Win32Window::beforePaint(mt::Screen* screen)
{
if (mDxInterface)
{
mDxInterface->initialize(mWindow);
mDxInterface->initialize();
}
}
void Win32Window::afterPaint(mt::Screen* screen)
{
if (mDxInterface)
{
mDxInterface->onRender();
}
else
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(mHandle, &ps);
FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
auto text = L"Hello World";
auto val = DrawText(hdc, (LPCSTR)(&text[0]), -1, &ps.rcPaint, 0);
EndPaint(mHandle, &ps);
}
}

View file

@ -47,12 +47,11 @@ public:
void beforePaint(mt::Screen* screen);
void afterPaint(mt::Screen* screen)
{
}
void afterPaint(mt::Screen* screen);
private:
void onPaintMessage();
HWND mHandle{ 0 };
int mCmdShow{ 0 };
DesktopManager* mDesktopManager{ nullptr };