Start aligning Dx and OpenGl approaches.

src/graphics/CMakeLists.txt

@@ -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})

src/graphics/DrawingContext.cpp

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

src/graphics/DrawingContext.h

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

src/graphics/PainterFactory.cpp

@@ -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
 }
 
 

src/graphics/directx/DirectXMeshPainter.cpp

@@ -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));
+}

src/graphics/directx/DirectXMeshPainter.h

@@ -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;
+};

src/graphics/directx/DirectXPainter.cpp

@@ -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();
+    */
+}

src/graphics/directx/DirectXPainter.h

@@ -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;
+};

src/graphics/directx/DirectXShaderProgram.cpp

@@ -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();
+}

src/graphics/directx/DirectXShaderProgram.h

@@ -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;
+};

src/graphics/directx/DirectXTextPainter.cpp

@@ -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);
+}
+

src/graphics/directx/DirectXTextPainter.h

@@ -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;
+};

src/ui_elements/desktop_elements/Window.cpp

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

src/ui_elements/desktop_elements/Window.h

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

src/visual_elements/TextNode.cpp

@@ -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;

src/windows/ui_interfaces/win32/Win32DxInterface.cpp

@@ -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_INFO("Initialize DX");
-	{
+	UINT dxgiFactoryFlags = 0;
-		MLOG_ERROR("Directx math not supported");
-		return;
-	}
-
 #if defined(DEBUG) || defined(_DEBUG)
-	// Enable the D3D12 debug layer.
 	{
-		ID3D12Debug* debugController;
+		Microsoft::WRL::ComPtr<ID3D12Debug> debugController;
-		D3D12GetDebugInterface(IID_PPV_ARGS(&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.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&mDevice))))
-		if (SUCCEEDED(D3D12CreateDevice(pAdapter, 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));
+	const auto init_2d_ok = initializeD2d();
-
+	mIsValid = init_2d_ok;
-	mIsValid = initializeD2d();
 }
 
 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);
-
+	return true;
-	// Create D2D/DWrite components.
+}
-	{
+
-		D2D1_DEVICE_CONTEXT_OPTIONS deviceOptions = D2D1_DEVICE_CONTEXT_OPTIONS_NONE;
+bool Win32DxInterface::initializeDirectWrite()
-		D2D1_FACTORY_OPTIONS d2dFactoryOptions = {};
+{
-
+	DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &mDWriteFactory);
-		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;
 }

src/windows/ui_interfaces/win32/Win32DxInterface.h

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

src/windows/ui_interfaces/win32/Win32DxWindowInterface.cpp

@@ -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)
+Win32DxWindowInterface::Win32DxWindowInterface(mt::Window* window, Win32DxInterface* dxInterface)
-	: mDxInterface(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.
+    painter->getMeshPainter()->updateCommandList(rtvHandle, mCommandList.Get());
-    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);
 
     // 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 width = mWindow->getWidth();
-    const auto height = window->getHeight();
+    const auto height = mWindow->getHeight();
-    mViewport = CD3DX12_VIEWPORT(0.0f, 0.0f, width, height);
+    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(
+    const auto hr = mDxInterface->getFactory()->CreateSwapChainForHwnd(command_queue, hwnd, &swapChainDesc, nullptr, nullptr, &swapChain);
-        mDxInterface->getCommandQueue(),
+    if (!SUCCEEDED(hr))
-        hwnd,
+    {
-        &swapChainDesc,
+        MLOG_ERROR("Failed to create swap chain for hwnd: " << hwnd);
-        nullptr,
+        return false;
-        nullptr,
+    }
-        &swapChain
-    );
-    mDxInterface->getFactory()->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
     swapChain.As(&mSwapChain);
-    auto mFrameIndex = mSwapChain->GetCurrentBackBufferIndex();
 
-    // Query the desktop's dpi settings, which will be used to create
+    // Prevent fullscreen toggle
-    // D2D's render targets.
+    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]));
+        setupFrameResource(n, rtvHandle, bitmapProperties);
-            mDxInterface->getDevice()->CreateRenderTargetView(mRenderTargets[n].Get(), nullptr, rtvHandle);
+    }
+}
 
+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(
+    mDxInterface->get11On12Device()->CreateWrappedResource(mRenderTargets[idx].Get(),&d3d11Flags,
-                mRenderTargets[n].Get(),
+        D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT, IID_PPV_ARGS(&mWrappedBackBuffers[idx]));
-                &d3d11Flags,
-                D3D12_RESOURCE_STATE_RENDER_TARGET,
-                D3D12_RESOURCE_STATE_PRESENT,
-                IID_PPV_ARGS(&mWrappedBackBuffers[n])
-            );
 
-            // Create a render target for D2D to draw directly to this back buffer.
     Microsoft::WRL::ComPtr<IDXGISurface> surface;
-            mWrappedBackBuffers[n].As(&surface);
+    mWrappedBackBuffers[idx].As(&surface);
-            mDxInterface->getD2dContext()->CreateBitmapFromDxgiSurface(
+    mDxInterface->getD2dContext()->CreateBitmapFromDxgiSurface(surface.Get(), &bitmapProps, &mD2dRenderTargets[idx]);
-                surface.Get(),
-                &bitmapProperties,
-                &mD2dRenderTargets[n]
-            );
-            
-            rtvHandle.Offset(1, mRtvDescriptorSize);
-        }
 }
 
-    mDxInterface->getDevice()->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&mCommandAllocator));
+bool Win32DxWindowInterface::loadAssets()
-}
-
-void Win32DxWindowInterface::loadAssets()
 {
-    // Create an empty root signature.
+    auto painter = dynamic_cast<DirectXPainter*>(mWindow->getDrawingContent()->getPainter());
-    {
-        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;
+    painter->getMeshPainter()->createRootSignature(mDxInterface->getDevice());
-        Microsoft::WRL::ComPtr<ID3DBlob> error;
+    painter->getMeshPainter()->createPipelineStateObject(mDxInterface->getDevice());
-        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));
-    }
 
     // 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.
-    {
+    painter->getTextPainter()->initializeBrush(mDxInterface->getD2dContext());
-        mDxInterface->getD2dContext()->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &mTextBrush);
+    painter->getTextPainter()->initializeTextFormat(mDxInterface->getDirectWriteFactory());
-        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);
-    }
-
 
     // 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.
+    painter->getMeshPainter()->createVertexBuffer(mDxInterface->getDevice());
-    {
-        // 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 } }
-        };
 
-        const UINT vertexBufferSize = sizeof(triangleVertices);
+    createSyncObjects();
 
-        // Note: using upload heaps to transfer static data like vert buffers is not 
+    return true;
-        // 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;
 }
 
-    // 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()
 {

src/windows/ui_interfaces/win32/Win32DxWindowInterface.h

@@ -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 D2D1_BITMAP_PROPERTIES1;
-struct IDWriteTextFormat;
+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);
+    bool loadPipeline();
-    void loadAssets();
+    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
+    mt::Window* mWindow{ nullptr };
-    {
-        DirectX::XMFLOAT3 position;
-        DirectX::XMFLOAT4 color;
-    };
-
     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] = {};

src/windows/ui_interfaces/win32/Win32Window.cpp

@@ -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)
+            onPaintMessage();
-            {
-                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);
-            }
         }
     }
     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);
     }
 }

src/windows/ui_interfaces/win32/Win32Window.h

@@ -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 };