maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement RenderTicker::removeSwapChain

Browse Source
This commit is contained in:
Nick Fisher
2025-07-01 10:42:21 +08:00
parent 70c67b59f7
commit e50a1b6002
1 changed files with 74 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
thermion_dart/native/src/RenderTicker.cpp
View File

@@ -18,6 +18,7 @@
#include <filament/Camera.h> #include <filament/Camera.h>
#include <filament/ColorGrading.h> #include <filament/ColorGrading.h>
#include <filament/Engine.h> #include <filament/Engine.h>
#include <filament/Fence.h>
#include <filament/IndexBuffer.h> #include <filament/IndexBuffer.h>
#include <filament/IndirectLight.h> #include <filament/IndirectLight.h>
#include <filament/LightManager.h> #include <filament/LightManager.h>
@@ -29,7 +30,8 @@
#include <filament/TransformManager.h> #include <filament/TransformManager.h>
#include <filament/VertexBuffer.h> #include <filament/VertexBuffer.h>
#include <chrono> #include <chrono>
#include <map>
#include "Log.hpp" #include "Log.hpp"
#include "RenderTicker.hpp" #include "RenderTicker.hpp"
@@ -43,20 +45,37 @@ namespace thermion
using std::string; using std::string;
void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews) { void RenderTicker::removeSwapChain(SwapChain *swapChain)
{
std::lock_guard lock(mMutex);
auto erased = std::remove_if(mRenderable.begin(),
mRenderable.end(),
[=](ViewAttachment attachment)
{ return attachment.first == swapChain; });
mRenderable.erase(erased,
mRenderable.end());
}
void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews)
{
std::lock_guard lock(mMutex); std::lock_guard lock(mMutex);
auto it = std::find_if(mRenderable.begin(), mRenderable.end(), auto it = std::find_if(mRenderable.begin(), mRenderable.end(),
[swapChain](const auto& pair) { return pair.first == swapChain; }); [swapChain](const auto &pair)
{ return pair.first == swapChain; });
std::vector<View*> swapChainViews; std::vector<View *> swapChainViews;
for(int i = 0; i < numViews; i++) { for (int i = 0; i < numViews; i++)
{
swapChainViews.push_back(views[i]); swapChainViews.push_back(views[i]);
} }
if (it != mRenderable.end()) { if (it != mRenderable.end())
{
it->second = swapChainViews; it->second = swapChainViews;
} else { }
else
{
mRenderable.emplace_back(swapChain, swapChainViews); mRenderable.emplace_back(swapChain, swapChainViews);
} }
TRACE("Set %d views as renderable", numViews); TRACE("Set %d views as renderable", numViews);
@@ -65,74 +84,80 @@ namespace thermion
bool RenderTicker::render(uint64_t frameTimeInNanos) bool RenderTicker::render(uint64_t frameTimeInNanos)
{ {
auto startTime = std::chrono::high_resolution_clock::now(); auto startTime = std::chrono::high_resolution_clock::now();
std::lock_guard lock(mMutex); std::lock_guard lock(mMutex);
for (auto animationManager : mAnimationManagers) { for (auto animationManager : mAnimationManagers)
{
animationManager->update(frameTimeInNanos); animationManager->update(frameTimeInNanos);
} }
auto durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f; auto durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
TRACE("Updated animations in %.3f ms", durationNs); TRACE("Updated animations in %.3f ms", durationNs);
int numRendered = 0;
#ifdef ENABLE_TRACING
TRACE("%d swapchains", mRenderable.size());
#endif
for (const auto& [swapChain, views] : mRenderable)
{
if (!views.empty())
{
TRACE("Rendering %d views", views.size());
bool beginFrame = mRenderer->beginFrame(swapChain, frameTimeInNanos); int swapChainIndex = 0;
if (beginFrame) bool rendered = false;
for (const auto &[swapChain, views] : mRenderable)
{
int numRendered = 0;
bool beginFrame = mRenderer->beginFrame(swapChain, frameTimeInNanos);
if (beginFrame)
{
numRendered++;
durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
TRACE("Beginning frame (%.3f ms since last endFrame())", durationNs);
for (auto view : views)
{ {
numRendered++; mRenderer->render(view);
durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
TRACE("Beginning frame (%.3f ms since last endFrame())", durationNs);
for (auto view : views)
{
mRenderer->render(view);
}
mLastRender = std::chrono::high_resolution_clock::now();
mRenderer->endFrame();
} else {
durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
TRACE("Skipping frame (%.3f ms since last endFrame())", durationNs);
} }
#ifdef ENABLE_TRACING if (mOverlayComponentManager)
} else { {
TRACE("No views for swapchain"); mOverlayComponentManager->update();
}
mLastRender = std::chrono::high_resolution_clock::now();
mRenderer->endFrame();
}
else
{
durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
TRACE("Skipping frame (%.3f ms since last endFrame())", durationNs);
}
TRACE("%d views rendered for swapchain %d", numRendered, swapChainIndex);
swapChainIndex++;
if (numRendered > 0)
{
rendered = true;
} }
TRACE("%d swapchains rendered", numRendered);
#else
} }
#endif #ifdef __EMSCRIPTEN__
}
#ifdef __EMSCRIPTEN__
mEngine->execute(); mEngine->execute();
#endif #endif
auto endTime = std::chrono::high_resolution_clock::now(); auto endTime = std::chrono::high_resolution_clock::now();
durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count(); durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
float durationMs = durationNs / 1e6f; float durationMs = durationNs / 1e6f;
TRACE("Total render() time: %.3f ms", durationMs); TRACE("Total render() time: %.3f ms", durationMs);
return numRendered > 0; return rendered;
} }
void RenderTicker::addAnimationManager(AnimationManager* animationManager) { void RenderTicker::addAnimationManager(AnimationManager *animationManager)
{
std::lock_guard<std::mutex> lock(mMutex); std::lock_guard<std::mutex> lock(mMutex);
mAnimationManagers.push_back(animationManager); mAnimationManagers.push_back(animationManager);
} }
void RenderTicker::removeAnimationManager(AnimationManager* animationManager) { void RenderTicker::removeAnimationManager(AnimationManager *animationManager)
{
std::lock_guard<std::mutex> lock(mMutex); std::lock_guard<std::mutex> lock(mMutex);
auto it = std::find(mAnimationManagers.begin(), mAnimationManagers.end(), animationManager); auto it = std::find(mAnimationManagers.begin(), mAnimationManagers.end(), animationManager);
if (it != mAnimationManagers.end()) { if (it != mAnimationManagers.end())
{
mAnimationManagers.erase(it); mAnimationManagers.erase(it);
} }
} }