129 lines
4.2 KiB
C++
129 lines
4.2 KiB
C++
#include "RenderThread.h"
|
|
|
|
#include "../frames/InputFrameMailbox.h"
|
|
#include "../frames/SystemFrameExchange.h"
|
|
#include "../frames/SystemFrameTypes.h"
|
|
#include "../logging/Logger.h"
|
|
#include "../platform/HiddenGlWindow.h"
|
|
#include "InputFrameTexture.h"
|
|
#include "readback/OutputReadbackPipeline.h"
|
|
#include "GLExtensions.h"
|
|
#include "RuntimeRenderScene.h"
|
|
#include "SimpleMotionRenderer.h"
|
|
|
|
#include <memory>
|
|
#include <thread>
|
|
|
|
void RenderThread::ThreadMain()
|
|
{
|
|
RenderCadenceCompositor::TryLog(RenderCadenceCompositor::LogLevel::Log, "render-thread", "Render thread starting.");
|
|
HiddenGlWindow window;
|
|
std::string error;
|
|
if (!window.Create(mConfig.width, mConfig.height, error))
|
|
{
|
|
SignalStartupFailure(error.empty() ? "OpenGL context creation failed." : error);
|
|
return;
|
|
}
|
|
std::unique_ptr<HiddenGlWindow> prepareWindow = std::make_unique<HiddenGlWindow>();
|
|
if (!prepareWindow->CreateShared(mConfig.width, mConfig.height, window.DeviceContext(), window.Context(), error))
|
|
{
|
|
SignalStartupFailure(error.empty() ? "Runtime shader prepare shared context creation failed." : error);
|
|
return;
|
|
}
|
|
if (!window.MakeCurrent())
|
|
{
|
|
SignalStartupFailure("OpenGL context creation failed.");
|
|
return;
|
|
}
|
|
if (!ResolveGLExtensions())
|
|
{
|
|
SignalStartupFailure("OpenGL extension resolution failed.");
|
|
return;
|
|
}
|
|
|
|
SimpleMotionRenderer renderer;
|
|
RuntimeRenderScene runtimeRenderScene;
|
|
OutputReadbackPipeline readback;
|
|
InputFrameTexture inputTexture;
|
|
if (!runtimeRenderScene.StartPrepareWorker(std::move(prepareWindow), error))
|
|
{
|
|
SignalStartupFailure(error.empty() ? "Runtime shader prepare worker initialization failed." : error);
|
|
return;
|
|
}
|
|
if (!renderer.InitializeGl(mConfig.width, mConfig.height) ||
|
|
!readback.Initialize(mConfig.width, mConfig.height, mConfig.outputPixelFormat, mConfig.pboDepth))
|
|
{
|
|
SignalStartupFailure("Render pipeline initialization failed.");
|
|
return;
|
|
}
|
|
|
|
RenderCadenceClock clock(mConfig.frameDurationMilliseconds);
|
|
uint64_t frameIndex = 0;
|
|
mRunning.store(true, std::memory_order_release);
|
|
SignalStarted();
|
|
|
|
while (!mStopping.load(std::memory_order_acquire))
|
|
{
|
|
readback.ConsumeCompleted(
|
|
[this](SystemFrame& frame) { return mFrameExchange.AcquireForRender(frame); },
|
|
[this](const SystemFrame& frame) { return mFrameExchange.PublishCompleted(frame); },
|
|
[this]() {
|
|
CountAcquireMiss();
|
|
},
|
|
[this]() { CountCompleted(); });
|
|
PublishReadbackMetrics(readback);
|
|
|
|
const auto now = RenderCadenceClock::Clock::now();
|
|
const RenderCadenceClock::Tick tick = clock.Poll(now);
|
|
if (!tick.due)
|
|
{
|
|
if (tick.sleepFor > RenderCadenceClock::Duration::zero())
|
|
std::this_thread::sleep_for(tick.sleepFor);
|
|
continue;
|
|
}
|
|
|
|
TryCommitReadyRuntimeShader(runtimeRenderScene);
|
|
const GLuint videoInputTexture = inputTexture.PollAndUpload(mInputMailbox);
|
|
PublishInputMetrics(inputTexture);
|
|
if (!readback.RenderAndQueue(frameIndex, [this, &renderer, &runtimeRenderScene, videoInputTexture](uint64_t index) {
|
|
if (runtimeRenderScene.HasLayers())
|
|
runtimeRenderScene.RenderFrame(index, mConfig.width, mConfig.height, videoInputTexture);
|
|
else if (videoInputTexture != 0)
|
|
renderer.RenderTexture(videoInputTexture);
|
|
else
|
|
renderer.RenderFrame(index);
|
|
}))
|
|
{
|
|
mPboQueueMisses.fetch_add(1, std::memory_order_relaxed);
|
|
}
|
|
PublishReadbackMetrics(readback);
|
|
|
|
CountRendered();
|
|
++frameIndex;
|
|
clock.MarkRendered(RenderCadenceClock::Clock::now());
|
|
|
|
mClockOverruns.store(clock.OverrunCount(), std::memory_order_relaxed);
|
|
mSkippedFrames.store(clock.SkippedFrameCount(), std::memory_order_relaxed);
|
|
}
|
|
|
|
for (std::size_t i = 0; i < mConfig.pboDepth * 2; ++i)
|
|
{
|
|
readback.ConsumeCompleted(
|
|
[this](SystemFrame& frame) { return mFrameExchange.AcquireForRender(frame); },
|
|
[this](const SystemFrame& frame) { return mFrameExchange.PublishCompleted(frame); },
|
|
[this]() {
|
|
CountAcquireMiss();
|
|
},
|
|
[this]() { CountCompleted(); });
|
|
PublishReadbackMetrics(readback);
|
|
}
|
|
|
|
readback.Shutdown();
|
|
inputTexture.ShutdownGl();
|
|
runtimeRenderScene.ShutdownGl();
|
|
renderer.ShutdownGl();
|
|
window.ClearCurrent();
|
|
mRunning.store(false, std::memory_order_release);
|
|
RenderCadenceCompositor::TryLog(RenderCadenceCompositor::LogLevel::Log, "render-thread", "Render thread stopped.");
|
|
}
|