// Copyright (c) 2015, NVIDIA CORPORATION.  All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto.  Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.

// Modified 2024 Bigscreen, Inc
// Changed from single, central triangle to 4 colored squares per eye

#pragma once

#include <d3d12.h>
#include <d3d11on12.h>
#include <dxgi1_4.h>
#include <wrl.h>

#include <vector>
#include <string>
#include <iostream>

using namespace Microsoft::WRL;

#pragma comment(lib, "d3d12.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3d11.lib")
#include "DirectXTex.h"
inline void ThrowIfFailedImg(HRESULT hr, const char* function, int line)
{
    if (FAILED(hr))
    {
        std::cerr << "Failure result "<< hr << " in function " << function << " at line " << line << std::endl;
        throw;
    }
}

class D3D12RenderImage
{
public:
    D3D12RenderImage(IDXGIAdapter* pAdapter, const wchar_t* image_filename);

    void                    Init(UINT numSharedHandles, HANDLE* pSharedHandles, DXGI_FORMAT dxgiFormat);
    void                    SetClearColor(float red, float green, float blue);
    void                    Render();
    void                    ResetCommandList();
    bool                    WriteRenderTargetToBMP(const char* path);
    std::vector<UINT8>      GenerateTextureData();
    void                    ShowNewTexture(const wchar_t* image_filename);

    ComPtr<IUnknown>        GetDevice() const { return m_device; }
    UINT                    GetRenderedFrameIndex() const { return m_renderedFrameIndex; }

    ComPtr<ID3D12GraphicsCommandList>   GetCommandList() const { return m_commandList; }
    ComPtr<ID3D12CommandQueue>          GetCommandQueue() const { return m_commandQueue; }

private:
    void OpenRenderTargets(UINT numSharedHandles, HANDLE* pSharedHandles, DXGI_FORMAT dxgiFormat);
    void LoadPipeline();
    void UpdateImageTexture(ComPtr<ID3D12Resource>& textureUploadHeap);

    void WaitForPreviousFrame();
private:
    struct XMFLOAT3 { float x; float y; float z; };
    struct XMFLOAT2 { float u; float v; };
    struct Vertex
    {
        XMFLOAT3 position;
        XMFLOAT2 texture_coord;
    };

    static const UINT MAX_RENDER_TARGETS = 4;

private:
    static const UINT TextureWidth = 256;
    static const UINT TextureHeight = 256;
    static const UINT TexturePixelSize = 4;    // The number of bytes used to represent a pixel in the texture.

    std::wstring m_filename; // save the path of the image file to load

    bool use_static_color = false;
    FLOAT m_clearcolor[4];

    UINT m_frameIndex = 1;
    UINT m_renderedFrameIndex = 0;

    ComPtr<ID3D12Device> m_device;

    UINT m_numRenderTargets = 0;

    DXGI_FORMAT m_renderTargetFormat = DXGI_FORMAT_UNKNOWN;
    ComPtr<ID3D12DescriptorHeap> m_rtvDescriptorHeap;
    ComPtr<ID3D12DescriptorHeap> m_srvHeap;
    ComPtr<ID3D12Resource> m_renderTargets[MAX_RENDER_TARGETS];

    D3D12_VIEWPORT m_viewport;
    D3D12_RECT m_scissorRect;
    ComPtr<ID3D12RootSignature> m_rootSignature;
    ComPtr<ID3D12PipelineState> m_pipelineState;
    ComPtr<ID3D12Resource> m_vertexBuffer;
    D3D12_VERTEX_BUFFER_VIEW m_vertexBufferView;
    ComPtr<ID3D12Resource> m_texture;

    ComPtr<ID3D12CommandAllocator> m_commandAllocator;
    ComPtr<ID3D12CommandQueue> m_commandQueue;
    ComPtr<ID3D12GraphicsCommandList> m_commandList;
    ComPtr<ID3D12Fence> m_fence;
    UINT64 m_fenceValue = 0;
    HANDLE m_fenceEvent = nullptr;
    std::atomic_bool update_texture;
};