omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Thin recording bridge and canvas draw seams

Browse Source
This commit is contained in:
omigamedev
2026-06-16 08:41:03 +02:00
parent 52f0d32612
commit d5b137c9ff
7 changed files with 122 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/app.cpp
View File

@@ -211,6 +211,11 @@ void App::initLog()
LOG("load preferences failed");
}
namespace pp::panopainter
{
bool process_legacy_recording_worker_iteration(App& app);
}
bool App::check_license()
{
return true; // TODO: for distribuiton only
@@ -641,78 +646,13 @@ void App::rec_export(std::string path)
LOG("Recording export action failed: %s", status.message);
}
namespace
{
template <typename CanvasDocument>
struct RecordingWorkerIterationContext
{
Canvas* legacy_canvas = nullptr;
CanvasDocument* canvas_document = nullptr;
CanvasEncoder* encoder = nullptr;
pp::app::RecordingWorkerIterationPlan plan{};
};
template <typename CanvasDocument>
RecordingWorkerIterationContext<CanvasDocument> make_recording_worker_iteration_context(App& app)
{
RecordingWorkerIterationContext<CanvasDocument> context;
context.legacy_canvas = Canvas::I;
context.canvas_document = app.canvas ? app.canvas->m_canvas.get() : nullptr;
context.encoder = context.legacy_canvas ? context.legacy_canvas->m_encoder.get() : nullptr;
context.plan = pp::app::plan_recording_worker_iteration(
app.rec_running,
context.encoder != nullptr,
context.legacy_canvas != nullptr && context.canvas_document != nullptr);
return context;
}
template <typename CanvasDocument>
void encode_recording_frame(
App& app,
pp::app::RecordingWorkerIterationPlan const& plan,
Canvas* legacy_canvas,
CanvasDocument* canvas_document,
CanvasEncoder* encoder)
{
if (plan.clear_dirty_stroke)
canvas_document->m_dirty_stroke = false;
PBO equirect = legacy_canvas->m_layers_merge.gen_equirect_pbo(encoder->frame_size());
std::this_thread::yield();
ImageRef img;
img.create(equirect.width, equirect.height, equirect.map());
encoder->encode(img);
equirect.unmap();
LOG("rec frame encoded");
if (plan.update_frame_label)
app.update_rec_frames();
}
template <typename CanvasDocument>
bool process_recording_worker_iteration(App& app)
{
std::unique_lock<std::mutex> lock(app.rec_mutex);
app.rec_cv.wait(lock);
const auto iteration = make_recording_worker_iteration_context<CanvasDocument>(app);
if (!iteration.plan.continue_running)
return false;
if (iteration.plan.encode_frame && iteration.legacy_canvas && iteration.canvas_document && iteration.encoder)
encode_recording_frame(app, iteration.plan, iteration.legacy_canvas, iteration.canvas_document, iteration.encoder);
return true;
}
}
void App::rec_loop()
{
BT_SetTerminate();
rec_running = true;
while (rec_running)
{
if (!process_recording_worker_iteration<CanvasDocument>(*this))
if (!pp::panopainter::process_legacy_recording_worker_iteration(*this))
break;
}
}

22
src/legacy_canvas_draw_merge_services.h
View File

@@ -276,6 +276,28 @@ template <typename ModesT>
};
}
template <typename PlaneTransform, typename DrawPlane>
[[nodiscard]] inline auto make_legacy_canvas_draw_merge_background_checkerboard_plane(
glm::mat4 proj,
glm::mat4 camera,
float layer_scale,
PlaneTransform plane_transform,
DrawPlane draw_plane)
{
return [proj, camera, layer_scale, plane_transform, draw_plane](int plane_index) {
auto checkerboard_uniforms = LegacyCanvasDrawMergeCheckerboardUniforms {
.mvp = proj * camera *
glm::scale(glm::vec3(layer_scale)) *
plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1.f)),
.colorize = false,
};
setup_legacy_canvas_draw_merge_checkerboard_shader(checkerboard_uniforms);
draw_plane();
};
}
struct LegacyCanvasDrawMergeSmaskFacesExecution {
std::function<void()> set_active_texture_unit;
std::function<void()> enable_blend;

51
src/legacy_recording_services.cpp
View File

@@ -11,6 +11,40 @@
namespace pp::panopainter {
namespace {
pp::app::RecordingWorkerIterationPlan make_recording_worker_iteration_plan(App& app)
{
auto* legacy_canvas = Canvas::I;
auto* canvas_document = app.canvas ? app.canvas->m_canvas.get() : nullptr;
auto* encoder = legacy_canvas ? legacy_canvas->m_encoder.get() : nullptr;
return pp::app::plan_recording_worker_iteration(
app.rec_running,
encoder != nullptr,
legacy_canvas != nullptr && canvas_document != nullptr);
}
void encode_recording_frame(
App& app,
const pp::app::RecordingWorkerIterationPlan& plan,
Canvas* legacy_canvas,
Canvas* canvas_document,
CanvasEncoder* encoder)
{
if (plan.clear_dirty_stroke)
canvas_document->m_dirty_stroke = false;
PBO equirect = legacy_canvas->m_layers_merge.gen_equirect_pbo(encoder->frame_size());
std::this_thread::yield();
ImageRef img;
img.create(equirect.width, equirect.height, equirect.map());
encoder->encode(img);
equirect.unmap();
LOG("rec frame encoded");
if (plan.update_frame_label)
app.update_rec_frames();
}
class LegacyRecordingServices final : public pp::app::RecordingServices {
public:
explicit LegacyRecordingServices(App& app) noexcept
@@ -77,6 +111,23 @@ private:
} // namespace
bool process_legacy_recording_worker_iteration(App& app)
{
std::unique_lock<std::mutex> lock(app.rec_mutex);
app.rec_cv.wait(lock);
const auto plan = make_recording_worker_iteration_plan(app);
if (!plan.continue_running)
return false;
auto* legacy_canvas = Canvas::I;
auto* canvas_document = app.canvas ? app.canvas->m_canvas.get() : nullptr;
auto* encoder = legacy_canvas ? legacy_canvas->m_encoder.get() : nullptr;
if (plan.encode_frame && legacy_canvas && canvas_document && encoder)
encode_recording_frame(app, plan, legacy_canvas, canvas_document, encoder);
return true;
}
pp::foundation::Status execute_legacy_recording_start_action(
App& app,
pp::app::RecordingStartAction action)

32
src/node_canvas.cpp
View File

@@ -365,20 +365,6 @@ void NodeCanvas::draw()
bool draw_merged = !(m_canvas->m_current_mode == kCanvasMode::Camera);
draw_merged = false;
const auto draw_background_plane = [&](int plane_index) {
auto plane_mvp = proj * camera *
glm::scale(glm::vec3(m_canvas->m_layers.size() + 500)) *
m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1));
pp::panopainter::setup_legacy_canvas_draw_merge_checkerboard_shader(
pp::panopainter::LegacyCanvasDrawMergeCheckerboardUniforms {
.mvp = plane_mvp,
.colorize = false,
});
m_face_plane.draw_fill();
};
if (draw_merged)
{
pp::panopainter::execute_legacy_canvas_draw_merge_background_setup(
@@ -389,7 +375,14 @@ void NodeCanvas::draw()
.disable_blend = [&] {
apply_node_canvas_capability(pp::renderer::gl::blend_state(), false);
},
.draw_checkerboard_plane = draw_background_plane,
.draw_checkerboard_plane = pp::panopainter::make_legacy_canvas_draw_merge_background_checkerboard_plane(
proj,
camera,
m_canvas->m_layers.size() + 500.f,
m_canvas->m_plane_transform,
[&] {
m_face_plane.draw_fill();
}),
});
const auto draw_merged_texture_plane = [&](int plane_index) {
@@ -449,7 +442,14 @@ void NodeCanvas::draw()
.disable_blend = [&] {
apply_node_canvas_capability(pp::renderer::gl::blend_state(), false);
},
.draw_checkerboard_plane = draw_background_plane,
.draw_checkerboard_plane = pp::panopainter::make_legacy_canvas_draw_merge_background_checkerboard_plane(
proj,
camera,
m_canvas->m_layers.size() + 500.f,
m_canvas->m_plane_transform,
[&] {
m_face_plane.draw_fill();
}),
});
// if not using shader blend, use gl rasterizer blend