Extract app runtime shell, canvas render shell, and node tree services
This commit is contained in:
727
src/legacy_canvas_render_shell_services.cpp
Normal file
727
src/legacy_canvas_render_shell_services.cpp
Normal file
@@ -0,0 +1,727 @@
|
||||
#include "pch.h"
|
||||
|
||||
#include "legacy_canvas_render_shell_services.h"
|
||||
|
||||
#include "app.h"
|
||||
#include "legacy_canvas_draw_merge_services.h"
|
||||
#include "legacy_canvas_stroke_commit_services.h"
|
||||
#include "legacy_canvas_stroke_composite_services.h"
|
||||
#include "legacy_canvas_stroke_erase_services.h"
|
||||
#include "legacy_canvas_stroke_execution_services.h"
|
||||
#include "legacy_canvas_stroke_runtime_services.h"
|
||||
#include "legacy_canvas_stroke_shader_services.h"
|
||||
#include "legacy_canvas_projection_services.h"
|
||||
#include "legacy_ui_gl_dispatch.h"
|
||||
#include "renderer_gl/opengl_capabilities.h"
|
||||
#include "util.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
|
||||
namespace {
|
||||
|
||||
using namespace pp::panopainter;
|
||||
|
||||
GLint current_canvas_stroke_internal_format()
|
||||
{
|
||||
const auto renderer_features = ShaderManager::render_device_features();
|
||||
if (renderer_features.float32_linear_filtering)
|
||||
return static_cast<GLint>(pp::renderer::gl::rgba32f_internal_format());
|
||||
if (renderer_features.float16_render_targets)
|
||||
return static_cast<GLint>(pp::renderer::gl::rgba16f_internal_format());
|
||||
return static_cast<GLint>(pp::renderer::gl::rgba8_internal_format());
|
||||
}
|
||||
|
||||
GLint rgba8_internal_format()
|
||||
{
|
||||
return static_cast<GLint>(pp::renderer::gl::rgba8_internal_format());
|
||||
}
|
||||
|
||||
GLenum depth_test_state()
|
||||
{
|
||||
return static_cast<GLenum>(pp::renderer::gl::depth_test_state());
|
||||
}
|
||||
|
||||
GLenum blend_state()
|
||||
{
|
||||
return static_cast<GLenum>(pp::renderer::gl::blend_state());
|
||||
}
|
||||
|
||||
void set_active_texture_unit(std::uint32_t unit_index)
|
||||
{
|
||||
pp::legacy::ui_gl::activate_texture_unit(unit_index, "Canvas");
|
||||
}
|
||||
|
||||
void unbind_texture_2d()
|
||||
{
|
||||
pp::legacy::ui_gl::unbind_texture_2d("Canvas");
|
||||
}
|
||||
|
||||
void apply_canvas_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
|
||||
{
|
||||
pp::legacy::ui_gl::apply_viewport(x, y, width, height, "Canvas");
|
||||
}
|
||||
|
||||
void apply_canvas_capability(std::uint32_t state, bool enabled)
|
||||
{
|
||||
pp::legacy::ui_gl::set_capability(state, enabled, "Canvas");
|
||||
}
|
||||
|
||||
pp::paint_renderer::CanvasBlendGatePlan draw_merge_blend_gate_plan(
|
||||
int width,
|
||||
int height,
|
||||
const std::vector<std::shared_ptr<Layer>>& layers,
|
||||
const Brush* brush) noexcept
|
||||
{
|
||||
std::vector<int> layer_blend_modes;
|
||||
layer_blend_modes.reserve(layers.size());
|
||||
for (const auto& layer : layers) {
|
||||
if (!layer) {
|
||||
continue;
|
||||
}
|
||||
layer_blend_modes.push_back(layer->m_blend_mode);
|
||||
}
|
||||
|
||||
const auto plan = pp::paint_renderer::plan_canvas_blend_gate(
|
||||
ShaderManager::render_device_features(),
|
||||
pp::paint_renderer::CanvasBlendGateRequest {
|
||||
.extent = pp::renderer::Extent2D {
|
||||
.width = static_cast<std::uint32_t>(std::max(width, 0)),
|
||||
.height = static_cast<std::uint32_t>(std::max(height, 0)),
|
||||
},
|
||||
.layer_blend_modes = layer_blend_modes,
|
||||
.has_stroke_blend_mode = brush != nullptr,
|
||||
.stroke_blend_mode = brush ? brush->m_blend_mode : 0,
|
||||
});
|
||||
if (plan) {
|
||||
return plan.value();
|
||||
}
|
||||
|
||||
pp::paint_renderer::CanvasBlendGatePlan fallback;
|
||||
fallback.shader_blend = true;
|
||||
fallback.complex_blend = true;
|
||||
fallback.compatibility_fallback = true;
|
||||
return fallback;
|
||||
}
|
||||
|
||||
pp::panopainter::LegacyCanvasDrawMergeFinalPlaneCompositeExecution
|
||||
make_canvas_draw_merge_final_plane_composite_execution(Canvas& canvas)
|
||||
{
|
||||
return {
|
||||
.bind_merged_texture_copy_target = [&] {
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_merge_tex.bind();
|
||||
},
|
||||
.copy_merged_framebuffer = [&] {
|
||||
copy_framebuffer_to_texture_2d(0, 0, 0, 0, canvas.m_width, canvas.m_height);
|
||||
},
|
||||
.enable_blend = [&] {
|
||||
apply_canvas_capability(blend_state(), true);
|
||||
},
|
||||
.draw = [&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
.bind_sampler = [&] {
|
||||
canvas.m_sampler.bind(0);
|
||||
},
|
||||
.bind_merged_texture = [&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_merge_tex.bind();
|
||||
},
|
||||
.unbind_merged_texture = [&] {
|
||||
canvas.m_merge_tex.unbind();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
static void execute_canvas_draw_merge_temporary_erase_dispatch(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const glm::mat4& ortho);
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeTemporaryCompositeExecution
|
||||
make_canvas_draw_merge_temporary_paint_request(
|
||||
Canvas& canvas,
|
||||
int layer_index,
|
||||
int plane_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho);
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeLayerTextureExecution
|
||||
make_canvas_draw_merge_layer_texture_dispatch(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index);
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeLayerBlendExecution
|
||||
make_canvas_draw_merge_layer_blend_dispatch(Canvas& canvas);
|
||||
|
||||
static void execute_canvas_draw_merge_branch_body(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho,
|
||||
bool use_blend,
|
||||
bool copy_blend_destination)
|
||||
{
|
||||
if (use_blend)
|
||||
{
|
||||
canvas.m_merge_rtt.bindFramebuffer();
|
||||
canvas.m_merge_rtt.clear();
|
||||
}
|
||||
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_layer_composite(
|
||||
canvas.m_current_stroke && canvas.m_current_mode == kCanvasMode::Erase && canvas.m_show_tmp && canvas.m_current_layer_idx == layer_index,
|
||||
canvas.m_current_stroke && canvas.m_show_tmp && canvas.m_current_layer_idx == layer_index,
|
||||
use_blend,
|
||||
pp::panopainter::LegacyCanvasDrawMergeLayerCompositeExecution {
|
||||
.execute_temporary_erase = [&] {
|
||||
execute_canvas_draw_merge_temporary_erase_dispatch(
|
||||
canvas,
|
||||
plane_index,
|
||||
layer_index,
|
||||
layer,
|
||||
ortho);
|
||||
},
|
||||
.execute_temporary_paint = [&] {
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_temporary_composite(
|
||||
make_canvas_draw_merge_temporary_paint_request(
|
||||
canvas,
|
||||
layer_index,
|
||||
plane_index,
|
||||
layer,
|
||||
brush,
|
||||
ortho));
|
||||
},
|
||||
.execute_layer_texture = [&] {
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_layer_texture(
|
||||
pp::panopainter::LegacyCanvasDrawMergeTextureAlphaUniforms {
|
||||
.mvp = ortho,
|
||||
.texture_slot = 0,
|
||||
.alpha = layer->m_opacity,
|
||||
.highlight = layer->m_hightlight,
|
||||
},
|
||||
make_canvas_draw_merge_layer_texture_dispatch(
|
||||
canvas,
|
||||
plane_index,
|
||||
layer_index));
|
||||
},
|
||||
.execute_layer_blend = [&] {
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_layer_blend(
|
||||
pp::panopainter::LegacyCanvasDrawMergeLayerBlendUniforms {
|
||||
.shader = {
|
||||
.mvp = ortho,
|
||||
.texture_slot = 0,
|
||||
.destination_texture_slot = 2,
|
||||
.use_destination_texture = copy_blend_destination,
|
||||
.blend_mode = layer->m_blend_mode,
|
||||
.alpha = 1.f,
|
||||
},
|
||||
.copy_destination = copy_blend_destination,
|
||||
},
|
||||
make_canvas_draw_merge_layer_blend_dispatch(
|
||||
canvas));
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
static void execute_canvas_draw_merge_plane_final_composite(
|
||||
Canvas& canvas,
|
||||
const glm::mat4& ortho,
|
||||
bool draw_checkerboard,
|
||||
bool use_blend)
|
||||
{
|
||||
if (use_blend)
|
||||
{
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_final_plane_composite(
|
||||
pp::panopainter::LegacyCanvasDrawMergeFinalPlaneCompositeUniforms {
|
||||
.checkerboard = {
|
||||
.mvp = ortho,
|
||||
.colorize = false,
|
||||
},
|
||||
.texture = {
|
||||
.mvp = ortho,
|
||||
.texture_slot = 0,
|
||||
},
|
||||
.draw_checkerboard = draw_checkerboard,
|
||||
},
|
||||
make_canvas_draw_merge_final_plane_composite_execution(canvas));
|
||||
}
|
||||
}
|
||||
|
||||
static void execute_canvas_draw_merge_plane_dispatch(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
const std::vector<std::shared_ptr<Layer>>& layers,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho,
|
||||
bool use_blend,
|
||||
bool copy_blend_destination,
|
||||
bool draw_checkerboard)
|
||||
{
|
||||
canvas.m_layers_merge.rtt(plane_index).bindFramebuffer();
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_plane_setup(
|
||||
pp::panopainter::LegacyCanvasDrawMergePlaneSetupUniforms {
|
||||
.checkerboard = {
|
||||
.mvp = ortho,
|
||||
.colorize = false,
|
||||
},
|
||||
.use_blend = use_blend,
|
||||
.draw_checkerboard = draw_checkerboard,
|
||||
},
|
||||
pp::panopainter::LegacyCanvasDrawMergePlaneSetupExecution {
|
||||
.clear_plane = [&] {
|
||||
canvas.m_layers_merge.rtt(plane_index).clear({ 1, 1, 1, 0 });
|
||||
},
|
||||
.disable_blend = [&] {
|
||||
apply_canvas_capability(blend_state(), false);
|
||||
},
|
||||
.enable_blend = [&] {
|
||||
apply_canvas_capability(blend_state(), true);
|
||||
},
|
||||
.draw = [&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
});
|
||||
|
||||
for (int layer_index = 0; layer_index < layers.size(); layer_index++)
|
||||
{
|
||||
execute_canvas_draw_merge_branch_body(
|
||||
canvas,
|
||||
plane_index,
|
||||
layer_index,
|
||||
layers[layer_index],
|
||||
brush,
|
||||
ortho,
|
||||
use_blend,
|
||||
copy_blend_destination);
|
||||
}
|
||||
|
||||
execute_canvas_draw_merge_plane_final_composite(canvas, ortho, draw_checkerboard, use_blend);
|
||||
canvas.m_layers_merge.rtt(plane_index).unbindFramebuffer();
|
||||
}
|
||||
|
||||
static void execute_canvas_draw_merge_plane_iteration(
|
||||
Canvas& canvas,
|
||||
const std::array<bool, 6>& faces,
|
||||
const std::vector<std::shared_ptr<Layer>>& layers,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho,
|
||||
bool use_blend,
|
||||
bool copy_blend_destination,
|
||||
bool draw_checkerboard)
|
||||
{
|
||||
for (int plane_index = 0; plane_index < 6; plane_index++)
|
||||
{
|
||||
if (!faces[plane_index])
|
||||
continue;
|
||||
|
||||
execute_canvas_draw_merge_plane_dispatch(
|
||||
canvas,
|
||||
plane_index,
|
||||
layers,
|
||||
brush,
|
||||
ortho,
|
||||
use_blend,
|
||||
copy_blend_destination,
|
||||
draw_checkerboard);
|
||||
}
|
||||
}
|
||||
|
||||
static void execute_canvas_draw_merge_temporary_erase_dispatch(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const glm::mat4& ortho)
|
||||
{
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_temporary_composite(
|
||||
pp::panopainter::make_legacy_canvas_draw_merge_temporary_erase_composite(
|
||||
[&] {
|
||||
pp::panopainter::setup_legacy_stroke_erase_shader(
|
||||
pp::panopainter::LegacyStrokeEraseUniforms {
|
||||
.mvp = ortho,
|
||||
.texture_slot = 0,
|
||||
.stroke_texture_slot = 1,
|
||||
.mask_texture_slot = 2,
|
||||
.alpha = layer->m_opacity,
|
||||
.mask_enabled = canvas.m_smask_active,
|
||||
});
|
||||
},
|
||||
[&] {
|
||||
canvas.m_sampler.bind(0);
|
||||
canvas.m_sampler.bind(1);
|
||||
canvas.m_sampler.bind(2);
|
||||
},
|
||||
[&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).bindTexture();
|
||||
set_active_texture_unit(1);
|
||||
canvas.m_tmp[plane_index].bindTexture();
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_smask.rtt(plane_index).bindTexture();
|
||||
},
|
||||
[&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
[&] {
|
||||
canvas.m_smask.rtt(plane_index).unbindTexture();
|
||||
set_active_texture_unit(1);
|
||||
canvas.m_tmp[plane_index].unbindTexture();
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).unbindTexture();
|
||||
}));
|
||||
}
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeTemporaryCompositeExecution
|
||||
make_canvas_draw_merge_temporary_paint_request(
|
||||
Canvas& canvas,
|
||||
int layer_index,
|
||||
int plane_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho)
|
||||
{
|
||||
const auto stroke_material = pp::panopainter::plan_legacy_canvas_stroke_material(
|
||||
pp::paint_renderer::CanvasStrokeMaterialRequest {
|
||||
.destination_feedback_needed = false,
|
||||
.pattern_enabled = brush.m_pattern_enabled,
|
||||
.pattern_eachsample = brush.m_pattern_eachsample,
|
||||
.wet_blend = brush.m_tip_wet > 0.F,
|
||||
.mix_blend = brush.m_tip_mix > 0.F,
|
||||
.noise_enabled = brush.m_tip_noise > 0.F,
|
||||
.dual_brush_enabled = brush.m_dual_enabled,
|
||||
.dual_blend_mode = brush.m_dual_blend_mode,
|
||||
.pattern_blend_mode = brush.m_pattern_blend_mode,
|
||||
.dual_alpha = brush.m_dual_opacity,
|
||||
});
|
||||
glm::vec2 patt_scale = glm::vec2(brush.m_pattern_scale);
|
||||
if (brush.m_pattern_flipx) patt_scale.x *= -1.f;
|
||||
if (brush.m_pattern_flipy) patt_scale.y *= -1.f;
|
||||
|
||||
return pp::panopainter::make_legacy_canvas_draw_merge_temporary_paint_composite(
|
||||
[&] {
|
||||
pp::panopainter::setup_legacy_stroke_composite_shader(
|
||||
pp::panopainter::LegacyStrokeCompositeUniforms {
|
||||
.resolution = Canvas::I->m_size,
|
||||
.pattern = {
|
||||
.scale = patt_scale,
|
||||
.invert = static_cast<float>(brush.m_pattern_invert),
|
||||
.brightness = brush.m_pattern_brightness,
|
||||
.contrast = brush.m_pattern_contrast,
|
||||
.depth = brush.m_pattern_depth,
|
||||
.blend_mode = brush.m_pattern_blend_mode,
|
||||
.offset = Canvas::I->m_pattern_offset,
|
||||
},
|
||||
.mvp = ortho,
|
||||
.layer_alpha = layer->m_opacity,
|
||||
.alpha_lock = layer->m_alpha_locked,
|
||||
.mask_enabled = canvas.m_smask_active,
|
||||
.use_fragcoord = false,
|
||||
.blend_mode = brush.m_blend_mode,
|
||||
.use_dual = stroke_material.composite_pass.use_dual,
|
||||
.dual_blend_mode = stroke_material.composite_pass.dual_blend_mode,
|
||||
.dual_alpha = stroke_material.composite_pass.dual_alpha,
|
||||
.use_pattern = stroke_material.composite_pass.use_pattern,
|
||||
});
|
||||
},
|
||||
[&] {
|
||||
canvas.m_sampler.bind(0);
|
||||
canvas.m_sampler.bind(1);
|
||||
canvas.m_sampler.bind(2);
|
||||
canvas.m_sampler.bind(3);
|
||||
canvas.m_sampler_stencil.bind(4);
|
||||
},
|
||||
[&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).bindTexture();
|
||||
set_active_texture_unit(1);
|
||||
canvas.m_tmp[plane_index].bindTexture();
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_smask.rtt(plane_index).bindTexture();
|
||||
set_active_texture_unit(3);
|
||||
if (stroke_material.composite_pass.use_dual)
|
||||
canvas.m_tmp_dual[plane_index].bindTexture();
|
||||
set_active_texture_unit(4);
|
||||
brush.m_pattern_texture ? brush.m_pattern_texture->bind() : unbind_texture_2d();
|
||||
},
|
||||
[&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
[&] {
|
||||
set_active_texture_unit(3);
|
||||
if (stroke_material.composite_pass.use_dual)
|
||||
canvas.m_tmp_dual[plane_index].unbindTexture();
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_smask.rtt(plane_index).unbindTexture();
|
||||
set_active_texture_unit(1);
|
||||
canvas.m_tmp[plane_index].unbindTexture();
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).unbindTexture();
|
||||
});
|
||||
}
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeLayerTextureExecution
|
||||
make_canvas_draw_merge_layer_texture_dispatch(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index)
|
||||
{
|
||||
return {
|
||||
.bind_sampler = [&] {
|
||||
canvas.m_cam_fov < 20.f ? canvas.m_sampler_nearest.bind(0) : canvas.m_sampler.bind(0);
|
||||
},
|
||||
.bind_layer_texture = [&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).bindTexture();
|
||||
},
|
||||
.draw = [&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
.unbind_layer_texture = [&] {
|
||||
canvas.m_layers[layer_index]->rtt(plane_index).unbindTexture();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
static pp::panopainter::LegacyCanvasDrawMergeLayerBlendExecution
|
||||
make_canvas_draw_merge_layer_blend_dispatch(Canvas& canvas)
|
||||
{
|
||||
return {
|
||||
.unbind_merge_framebuffer = [&] {
|
||||
canvas.m_merge_rtt.unbindFramebuffer();
|
||||
},
|
||||
.bind_samplers = [&] {
|
||||
canvas.m_sampler.bind(0);
|
||||
canvas.m_sampler.bind(2);
|
||||
},
|
||||
.bind_merge_texture = [&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_merge_rtt.bindTexture();
|
||||
},
|
||||
.bind_destination_texture = [&] {
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_merge_tex.bind();
|
||||
},
|
||||
.copy_destination_framebuffer = [&] {
|
||||
copy_framebuffer_to_texture_2d(0, 0, 0, 0, canvas.m_width, canvas.m_height);
|
||||
},
|
||||
.draw = [&] {
|
||||
canvas.m_plane.draw_fill();
|
||||
},
|
||||
.unbind_destination_texture = [&] {
|
||||
set_active_texture_unit(2);
|
||||
canvas.m_merge_tex.unbind();
|
||||
},
|
||||
.unbind_merge_texture = [&] {
|
||||
set_active_texture_unit(0);
|
||||
canvas.m_merge_rtt.unbindTexture();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace pp::panopainter {
|
||||
|
||||
void legacy_canvas_draw_merge_temporary_paint_branch(
|
||||
Canvas& canvas,
|
||||
int layer_index,
|
||||
int plane_index,
|
||||
std::shared_ptr<Layer> layer,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho)
|
||||
{
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_temporary_composite(
|
||||
make_canvas_draw_merge_temporary_paint_request(
|
||||
canvas,
|
||||
layer_index,
|
||||
plane_index,
|
||||
layer,
|
||||
brush,
|
||||
ortho));
|
||||
}
|
||||
|
||||
void legacy_canvas_draw_merge_branch_orchestration(
|
||||
Canvas& canvas,
|
||||
int plane_index,
|
||||
int layer_index,
|
||||
const std::shared_ptr<Layer>& layer,
|
||||
const Brush& brush,
|
||||
const glm::mat4& ortho,
|
||||
bool use_blend,
|
||||
bool copy_blend_destination)
|
||||
{
|
||||
if (!(canvas.m_show_tmp && canvas.m_current_layer_idx == layer_index) &&
|
||||
(!layer->m_visible ||
|
||||
layer->m_opacity == .0f ||
|
||||
!layer->face(plane_index)))
|
||||
return;
|
||||
execute_canvas_draw_merge_branch_body(
|
||||
canvas,
|
||||
plane_index,
|
||||
layer_index,
|
||||
layer,
|
||||
brush,
|
||||
ortho,
|
||||
use_blend,
|
||||
copy_blend_destination);
|
||||
}
|
||||
|
||||
void legacy_canvas_draw_merge_final_plane_composite(
|
||||
Canvas& canvas,
|
||||
const glm::mat4& ortho,
|
||||
bool draw_checkerboard)
|
||||
{
|
||||
pp::panopainter::execute_legacy_canvas_draw_merge_final_plane_composite(
|
||||
pp::panopainter::LegacyCanvasDrawMergeFinalPlaneCompositeUniforms {
|
||||
.checkerboard = {
|
||||
.mvp = ortho,
|
||||
.colorize = false,
|
||||
},
|
||||
.texture = {
|
||||
.mvp = ortho,
|
||||
.texture_slot = 0,
|
||||
},
|
||||
.draw_checkerboard = draw_checkerboard,
|
||||
},
|
||||
make_canvas_draw_merge_final_plane_composite_execution(canvas));
|
||||
}
|
||||
|
||||
void legacy_canvas_stroke_commit_timelapse(Canvas& canvas)
|
||||
{
|
||||
if (canvas.m_encoder && App::I->rec_running)
|
||||
{
|
||||
auto t_now = std::chrono::high_resolution_clock::now();
|
||||
float dt = std::chrono::duration<float>(t_now - canvas.m_disrty_stroke_time).count();
|
||||
if (dt > 2.f && canvas.m_dirty_stroke && App::I->rec_mutex.try_lock())
|
||||
{
|
||||
legacy_canvas_draw_merge(canvas, true);
|
||||
App::I->rec_mutex.unlock();
|
||||
App::I->rec_cv.notify_one();
|
||||
LOG("rec frame generated");
|
||||
canvas.m_dirty_stroke = false;
|
||||
canvas.m_disrty_stroke_time = std::chrono::steady_clock::now();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void legacy_canvas_draw_merge(Canvas& canvas, bool draw_checkerboard, std::array<bool, 6> faces)
|
||||
{
|
||||
assert(App::I->is_render_thread());
|
||||
|
||||
apply_canvas_viewport(0, 0, canvas.m_width, canvas.m_height);
|
||||
auto ortho = glm::ortho<float>(-0.5f, 0.5f, -0.5f, 0.5f, -1.f, 1.f);
|
||||
const auto& b = canvas.m_current_stroke->m_brush;
|
||||
|
||||
const auto blend_gate = draw_merge_blend_gate_plan(
|
||||
canvas.m_width,
|
||||
canvas.m_height,
|
||||
canvas.m_layers,
|
||||
canvas.m_current_stroke ? canvas.m_current_stroke->m_brush.get() : nullptr);
|
||||
const bool use_blend = blend_gate.shader_blend;
|
||||
const bool copy_blend_destination = use_blend && !blend_gate.reads_destination_color;
|
||||
|
||||
apply_canvas_capability(depth_test_state(), false);
|
||||
|
||||
execute_canvas_draw_merge_plane_iteration(
|
||||
canvas,
|
||||
faces,
|
||||
canvas.m_layers,
|
||||
*b,
|
||||
ortho,
|
||||
use_blend,
|
||||
copy_blend_destination,
|
||||
draw_checkerboard);
|
||||
}
|
||||
|
||||
void legacy_canvas_destroy(Canvas& canvas)
|
||||
{
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
canvas.m_tmp[i].destroy();
|
||||
canvas.m_tmp_dual[i].destroy();
|
||||
canvas.m_tex[i].destroy();
|
||||
canvas.m_tex2[i].destroy();
|
||||
}
|
||||
for (auto& l : canvas.m_layers)
|
||||
l->destroy();
|
||||
canvas.m_smask.destroy();
|
||||
canvas.m_mixer.destroy();
|
||||
canvas.m_layers_merge.destroy();
|
||||
canvas.m_merge_rtt.destroy();
|
||||
canvas.m_merge_tex.destroy();
|
||||
}
|
||||
|
||||
bool legacy_canvas_create(Canvas& canvas, int width, int height)
|
||||
{
|
||||
canvas.m_width = width;
|
||||
canvas.m_height = height;
|
||||
canvas.m_size = { width, height };
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
const auto stroke_format = current_canvas_stroke_internal_format();
|
||||
canvas.m_tmp[i].create(width, height, -1, stroke_format);
|
||||
canvas.m_tmp_dual[i].create(width, height, -1, stroke_format);
|
||||
canvas.m_tex[i].create(width, height, rgba8_internal_format());
|
||||
canvas.m_tex2[i].create(width, height, rgba8_internal_format());
|
||||
}
|
||||
#if defined(__GLES__)
|
||||
canvas.m_sampler_brush.create();
|
||||
#else
|
||||
canvas.m_sampler_brush.create(pp::renderer::gl::linear_texture_filter(), pp::renderer::gl::clamp_to_border_texture_wrap());
|
||||
#endif
|
||||
canvas.m_sampler.create(pp::renderer::gl::linear_texture_filter());
|
||||
canvas.m_sampler_nearest.create(pp::renderer::gl::nearest_texture_filter());
|
||||
canvas.m_sampler_brush.set_filter(pp::renderer::gl::linear_mipmap_linear_texture_filter(), pp::renderer::gl::linear_texture_filter());
|
||||
canvas.m_sampler_brush.set_border({ 1, 1, 1, 1 });
|
||||
canvas.m_sampler_stencil.create(pp::renderer::gl::linear_texture_filter(), pp::renderer::gl::repeat_texture_wrap());
|
||||
canvas.m_sampler_mix.create(pp::renderer::gl::nearest_texture_filter(), pp::renderer::gl::repeat_texture_wrap());
|
||||
canvas.m_sampler_linear.create();
|
||||
canvas.m_plane.create<1>(1, 1);
|
||||
canvas.m_plane_brush.create<1>(1, 1);
|
||||
canvas.m_brush_shape.create();
|
||||
for (auto& l : canvas.m_layers)
|
||||
l->create(width, height, "");
|
||||
canvas.m_smask.create(width, height, "mask");
|
||||
canvas.m_layers_merge.create(width, height, "merge");
|
||||
canvas.m_merge_rtt.create(width, height);
|
||||
canvas.m_merge_tex.create(width, height);
|
||||
canvas.m_unsaved = true;
|
||||
|
||||
canvas.timelapse_reset_encoder();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void legacy_canvas_clear_context(Canvas& canvas)
|
||||
{
|
||||
LOG("Canvas CLEAR CONTEXT");
|
||||
for (auto& layer : canvas.m_layers)
|
||||
layer->destroy();
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
canvas.m_tmp[i].destroy();
|
||||
canvas.m_tex[i].destroy();
|
||||
canvas.m_tex2[i].destroy();
|
||||
}
|
||||
}
|
||||
|
||||
CameraData legacy_canvas_render_shell_get_camera(const Canvas& canvas)
|
||||
{
|
||||
return legacy_canvas_get_camera(canvas);
|
||||
}
|
||||
|
||||
void legacy_canvas_render_shell_set_camera(Canvas& canvas, const CameraData& camera)
|
||||
{
|
||||
legacy_canvas_set_camera(canvas, camera);
|
||||
}
|
||||
|
||||
} // namespace pp::panopainter
|
||||
Reference in New Issue
Block a user