#include "ScriptableRenderer.h"

#include "RenderTexture.h"

#include "BufferFactory.h"

#include "ComputeShader.h"

#include "RenderPass/CopyPass.h"

#include "Core/ThreadPool.h"

#include "Core/ThreadSyncManager.h"

#include "Core/Logger.h"

#include <algorithm>

namespace sh::render

{

std::vector<ResourceUsage> ScriptableRenderer::swapChainStates{};

ScriptableRenderer::ScriptableRenderer(IRenderContext& ctx) :

ctx(ctx)

{

cpyPass = std::make_unique<CopyPass>();

}

ScriptableRenderer::~ScriptableRenderer() = default;

SH_RENDER_API auto ScriptableRenderer::AddRenderPass(const core::Name& passName, RenderQueue renderQueue) -> ScriptableRenderPass&

{

allPasses.push_back(std::make_unique<ScriptableRenderPass>(passName, renderQueue));

return *allPasses.back();

}

SH_RENDER_API auto ScriptableRenderer::ReadRenderTextureAsync(RenderTexture& rt, int x, int y) -> std::future<std::unique_ptr<IBuffer>>

{

SyncDirty();

SyncData data{};

data.src = &rt;

data.x = x;

data.y = y;

return syncDatas.emplace_back(std::move(data)).promise.get_future();

}

SH_RENDER_API void ScriptableRenderer::Dispatch(const ComputeShader& computeShader, uint32_t x, uint32_t y, uint32_t z)

{

CommandBuffer* const cmdPtr = ctx.AllocateCommandBuffer(true);

if (cmdPtr == nullptr)

{

SH_ERROR("Failed to allocate command buffer!");

return;

}

cmdPtr->Begin(true);

cmdPtr->Dispatch(computeShader, x, y, z);

cmdPtr->End();

ctx.SubmitCommand(*cmdPtr);

ctx.DeallocateCommandBuffer(*cmdPtr);

}

SH_RENDER_API auto ScriptableRenderer::HasPass(const core::Name& passName) const -> bool

{

for (const std::unique_ptr<ScriptableRenderPass>& pass : allPasses)

{

if (pass->passName == passName)

return true;

}

return false;

}

SH_RENDER_API void ScriptableRenderer::SyncDirty()

{

if (bSyncDirty)

return;

core::ThreadSyncManager::PushSyncable(*this);

bSyncDirty = true;

}

SH_RENDER_API void ScriptableRenderer::Sync()

{

for (auto& data : syncDatas)

{

BufferFactory::CreateInfo ci{};

ci.size = sizeof(uint8_t) * 4;

std::unique_ptr<IBuffer> buffer = BufferFactory::Create(ctx, ci);

IRenderThrMethod<CopyPass>::EnqueCopyImagePixelToBuffer(*cpyPass, *data.src, data.x, data.y, *buffer.get());

pendingReadbacks.push_back(PendingReadback{ std::move(buffer), std::move(data.promise) });

}

syncDatas.clear();

bSyncDirty = false;

}

SH_RENDER_API void ScriptableRenderer::Setup(const RenderData& data)

{

for (const std::unique_ptr<ScriptableRenderPass>& pass : allPasses)

activePasses.push_back(pass.get());

}

SH_RENDER_API void ScriptableRenderer::Execute(const RenderData& data)

{

renderCallCount = 0;

std::stable_sort(activePasses.begin(), activePasses.end(),

[&](const ScriptableRenderPass* left, const ScriptableRenderPass* right)

{

return left->renderQueue < right->renderQueue;

}

);

for (ScriptableRenderPass* pass : activePasses)

{

IRenderThrMethod<ScriptableRenderPass>::Configure(*pass, data);

renderCallCount += IRenderThrMethod<ScriptableRenderPass>::GetRenderCallCount(*pass);

}

// 각 패스에서 사용되는 렌더 텍스쳐를 추적하여 커맨드를 기록하기전에 배리어를 걸어줘야 함.

std::vector<std::vector<BarrierInfo>> barriers(activePasses.size());

for (int i = 0; i < activePasses.size(); ++i)

{

barriers[i] = BuildBarrierInfo(*activePasses[i], data.GetFrameIdx());

}

std::vector<std::future<std::pair<ScriptableRenderPass*, CommandBuffer*>>> futurePasses;

futurePasses.reserve(activePasses.size());

int idx = 0;

for (ScriptableRenderPass* pass : activePasses)

{

futurePasses.push_back(core::ThreadPool::GetInstance()->AddTask(

[idx, pass, &ctx = ctx, &data, &barriers]() -> std::pair<ScriptableRenderPass*, CommandBuffer*>

{

CommandBuffer* cmd = ctx.AllocateCommandBuffer(false);

cmd->Begin(true);

cmd->EmitBarrier(barriers[idx]);

IRenderThrMethod<ScriptableRenderPass>::Record(*pass, *cmd, ctx, data);

cmd->End();

return { pass, cmd };

}

));

++idx;

}

// 모든 패스가 기록이 될 때 까지 대기

for (auto& futurePass : futurePasses)

{

auto [pass, cmd] = futurePass.get();

recordedCmds.push_back({ *pass, *cmd });

}

activePasses.clear();

}

SH_RENDER_API void ScriptableRenderer::ExecuteTransfer(uint32_t imgIdx)

{

RenderData data{};

IRenderThrMethod<RenderData>::SetFrameIndex(data, imgIdx);

IRenderThrMethod<RenderData>::SetDrawablesPtr(data, nullptr);

IRenderThrMethod<ScriptableRenderPass>::Configure(*cpyPass, data);

std::vector<BarrierInfo> preBarriers = BuildBarrierInfo(*cpyPass, imgIdx);

std::vector<BarrierInfo> postBarriers;

if (swapChainStates.size() > imgIdx)

{

postBarriers = { BarrierInfo{imgIdx, swapChainStates[imgIdx], ResourceUsage::Present} };

swapChainStates[imgIdx] = ResourceUsage::Present;

}

else

{

swapChainStates.resize(imgIdx + 1, ResourceUsage::Undefined);

postBarriers = { BarrierInfo{imgIdx, ResourceUsage::Undefined, ResourceUsage::Present} };

swapChainStates[imgIdx] = ResourceUsage::Present;

}

CommandBuffer* cmd = ctx.AllocateCommandBuffer(false);

cmd->Begin(true);

cmd->EmitBarrier(preBarriers);

IRenderThrMethod<ScriptableRenderPass>::Record(*cpyPass, *cmd, ctx, data);

cmd->EmitBarrier(postBarriers);

cmd->End();

recordedCmds.push_back({ *cpyPass, *cmd});

}

SH_RENDER_API void ScriptableRenderer::CallReadbacks()

{

for (auto& p : pendingReadbacks)

p.promise.set_value(std::move(p.buffer));

pendingReadbacks.clear();

}

SH_RENDER_API void ScriptableRenderer::EnqueRenderPass(ScriptableRenderPass& pass)

{

activePasses.push_back(&pass);

}

SH_RENDER_API void ScriptableRenderer::ResetSubmittedCommands(IRenderContext& ctx)

{

for (RecordedCommand& recordedCmd : recordedCmds)

ctx.DeallocateCommandBuffer(recordedCmd.cmd);

recordedCmds.clear();

}

SH_RENDER_API void ScriptableRenderer::ResetSwapChainStates()

{

for (auto& state : swapChainStates)

state = ResourceUsage::Undefined;

}

auto ScriptableRenderer::BuildBarrierInfo(ScriptableRenderPass& pass, uint32_t imgIdx) -> std::vector<BarrierInfo>

{

std::vector<BarrierInfo> barriers{};

barriers.reserve(pass.GetRenderTextures().size());

for (auto& [rt, usage] : pass.GetRenderTextures())

{

BarrierInfo& barrierInfo = barriers.emplace_back();

if (rt == nullptr) // 스왑체인인 경우

{

barrierInfo.target = imgIdx;

if (swapChainStates.size() <= imgIdx)

swapChainStates.resize(imgIdx + 1, ResourceUsage::Undefined);

barrierInfo.lastUsage = swapChainStates[imgIdx];

swapChainStates[imgIdx] = usage;

}

else

{

barrierInfo.target = rt;

barrierInfo.lastUsage = rt->GetUsage();

IRenderThrMethod<RenderTexture>::ChangeUsage(const_cast<RenderTexture&>(*rt), usage);

}

barrierInfo.curUsage = usage;

}

return barriers;

}

}//namespace