669 lines
23 KiB
C++
669 lines
23 KiB
C++
#pragma once
|
|
|
|
#include "shader.h"
|
|
|
|
#include <array>
|
|
#include <functional>
|
|
|
|
namespace pp::panopainter {
|
|
|
|
struct LegacyCanvasDrawMergeCheckerboardUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
bool colorize = false;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTextureUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeAtlasUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
glm::vec2 offset {};
|
|
glm::vec2 size { 1.0f };
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeEquirectUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTextureMaskUniforms {
|
|
int texture_slot = 0;
|
|
glm::vec2 pattern_offset {};
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTextureAlphaUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
float alpha = 1.0f;
|
|
int highlight = 0;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTextureBlendUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
int destination_texture_slot = 2;
|
|
bool use_destination_texture = false;
|
|
int blend_mode = 0;
|
|
float alpha = 1.0f;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTextureColorizeUniforms {
|
|
glm::mat4 mvp { 1.0f };
|
|
int texture_slot = 0;
|
|
glm::vec4 color { 1.0f };
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeShaderExecution {
|
|
std::function<void(kShader)> use_shader;
|
|
std::function<void(kShaderUniform, int)> set_int;
|
|
std::function<void(kShaderUniform, float)> set_float;
|
|
std::function<void(kShaderUniform, const glm::vec2&)> set_vec2;
|
|
std::function<void(kShaderUniform, const glm::vec4&)> set_vec4;
|
|
std::function<void(kShaderUniform, const glm::mat4&)> set_mat4;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeLayerBlendUniforms {
|
|
LegacyCanvasDrawMergeTextureBlendUniforms shader;
|
|
bool copy_destination = false;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeLayerBlendExecution {
|
|
std::function<void()> unbind_merge_framebuffer;
|
|
std::function<void()> bind_samplers;
|
|
std::function<void()> bind_merge_texture;
|
|
std::function<void()> bind_destination_texture;
|
|
std::function<void()> copy_destination_framebuffer;
|
|
std::function<void()> draw;
|
|
std::function<void()> unbind_destination_texture;
|
|
std::function<void()> unbind_merge_texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeLayerTextureExecution {
|
|
std::function<void()> bind_sampler;
|
|
std::function<void()> bind_layer_texture;
|
|
std::function<void()> draw;
|
|
std::function<void()> unbind_layer_texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeLayerCompositeExecution {
|
|
std::function<void()> execute_temporary_erase;
|
|
std::function<void()> execute_temporary_paint;
|
|
std::function<void()> execute_layer_texture;
|
|
std::function<void()> execute_layer_blend;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeLayerPlaneExecution {
|
|
std::function<void()> bind_blender_framebuffer;
|
|
std::function<void()> clear_blender_framebuffer;
|
|
std::function<void()> unbind_blender_framebuffer;
|
|
std::function<void()> prepare_temporary_erase;
|
|
std::function<void(int, float)> draw_temporary_erase_frame;
|
|
std::function<void()> cleanup_temporary_erase;
|
|
std::function<void()> prepare_temporary_paint;
|
|
std::function<void(int, float)> draw_temporary_paint_frame;
|
|
std::function<void()> cleanup_temporary_paint;
|
|
std::function<void()> prepare_layer_texture;
|
|
std::function<void(int, float)> draw_layer_texture_frame;
|
|
std::function<void()> cleanup_layer_texture;
|
|
std::function<void()> draw_blend;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeTemporaryCompositeExecution {
|
|
std::function<void()> setup;
|
|
std::function<void()> bind_samplers;
|
|
std::function<void()> bind_textures;
|
|
std::function<void()> draw;
|
|
std::function<void()> unbind_textures;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeBackgroundSetupUniforms {
|
|
bool draw_merged = false;
|
|
bool use_blend = false;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeBackgroundSetupExecution {
|
|
std::function<void()> disable_blend;
|
|
std::function<void(int)> draw_checkerboard_plane;
|
|
};
|
|
|
|
template <
|
|
typename Setup,
|
|
typename BindSamplers,
|
|
typename BindTextures,
|
|
typename Draw,
|
|
typename UnbindTextures>
|
|
[[nodiscard]] inline LegacyCanvasDrawMergeTemporaryCompositeExecution make_legacy_canvas_draw_merge_temporary_erase_composite(
|
|
Setup&& setup,
|
|
BindSamplers&& bind_samplers,
|
|
BindTextures&& bind_textures,
|
|
Draw&& draw,
|
|
UnbindTextures&& unbind_textures)
|
|
{
|
|
return LegacyCanvasDrawMergeTemporaryCompositeExecution {
|
|
.setup = std::forward<Setup>(setup),
|
|
.bind_samplers = std::forward<BindSamplers>(bind_samplers),
|
|
.bind_textures = std::forward<BindTextures>(bind_textures),
|
|
.draw = std::forward<Draw>(draw),
|
|
.unbind_textures = std::forward<UnbindTextures>(unbind_textures),
|
|
};
|
|
}
|
|
|
|
template <
|
|
typename Setup,
|
|
typename BindSamplers,
|
|
typename BindTextures,
|
|
typename Draw,
|
|
typename UnbindTextures>
|
|
[[nodiscard]] inline LegacyCanvasDrawMergeTemporaryCompositeExecution make_legacy_canvas_draw_merge_temporary_paint_composite(
|
|
Setup&& setup,
|
|
BindSamplers&& bind_samplers,
|
|
BindTextures&& bind_textures,
|
|
Draw&& draw,
|
|
UnbindTextures&& unbind_textures)
|
|
{
|
|
return LegacyCanvasDrawMergeTemporaryCompositeExecution {
|
|
.setup = std::forward<Setup>(setup),
|
|
.bind_samplers = std::forward<BindSamplers>(bind_samplers),
|
|
.bind_textures = std::forward<BindTextures>(bind_textures),
|
|
.draw = std::forward<Draw>(draw),
|
|
.unbind_textures = std::forward<UnbindTextures>(unbind_textures),
|
|
};
|
|
}
|
|
|
|
struct LegacyCanvasDrawMergePlaneSetupUniforms {
|
|
LegacyCanvasDrawMergeCheckerboardUniforms checkerboard;
|
|
bool use_blend = false;
|
|
bool draw_checkerboard = false;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergePlaneSetupExecution {
|
|
std::function<void()> clear_plane;
|
|
std::function<void()> disable_blend;
|
|
std::function<void()> enable_blend;
|
|
std::function<void()> draw;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeFinalPlaneCompositeUniforms {
|
|
LegacyCanvasDrawMergeCheckerboardUniforms checkerboard;
|
|
LegacyCanvasDrawMergeTextureUniforms texture;
|
|
bool draw_checkerboard = false;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeFinalPlaneCompositeExecution {
|
|
std::function<void()> bind_merged_texture_copy_target;
|
|
std::function<void()> copy_merged_framebuffer;
|
|
std::function<void()> enable_blend;
|
|
std::function<void()> draw;
|
|
std::function<void()> bind_sampler;
|
|
std::function<void()> bind_merged_texture;
|
|
std::function<void()> unbind_merged_texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeCacheToScreenCompositeUniforms {
|
|
LegacyCanvasDrawMergeCheckerboardUniforms checkerboard;
|
|
LegacyCanvasDrawMergeTextureUniforms texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeCacheToScreenCompositeExecution {
|
|
std::function<void()> enable_blend;
|
|
std::function<void(const LegacyCanvasDrawMergeCheckerboardUniforms&, int)> draw_checkerboard_plane;
|
|
std::function<void()> bind_sampler;
|
|
std::function<void()> bind_cache_texture;
|
|
std::function<void()> draw_cache_texture;
|
|
std::function<void()> unbind_cache_texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeDisplayResolveUniforms {
|
|
LegacyCanvasDrawMergeTextureUniforms texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeDisplayResolveExecution {
|
|
std::function<void()> unbind_resolve_framebuffer;
|
|
std::function<void()> clear_color_buffer;
|
|
std::function<void()> apply_viewport;
|
|
std::function<void()> bind_sampler;
|
|
std::function<void()> bind_resolve_texture;
|
|
std::function<void()> draw;
|
|
std::function<void()> unbind_resolve_texture;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergePostDrawExecution {
|
|
std::function<void()> draw_mask_free;
|
|
std::function<void()> draw_mask_line;
|
|
std::function<void()> draw_smask_faces;
|
|
std::function<void()> draw_grid_modes;
|
|
std::function<void()> draw_heightmap;
|
|
std::function<void()> draw_current_modes;
|
|
};
|
|
|
|
struct LegacyCanvasDrawMergeSmaskFacesExecution {
|
|
std::function<void()> set_active_texture_unit;
|
|
std::function<void()> enable_blend;
|
|
std::function<void(int plane_index)> bind_face_texture;
|
|
std::function<void()> draw_face;
|
|
std::function<void(int plane_index)> unbind_face_texture;
|
|
};
|
|
|
|
[[nodiscard]] inline LegacyCanvasDrawMergeShaderExecution legacy_shader_manager_draw_merge_execution() noexcept
|
|
{
|
|
return {
|
|
.use_shader = [](kShader shader) { ShaderManager::use(shader); },
|
|
.set_int = [](kShaderUniform uniform, int value) { ShaderManager::u_int(uniform, value); },
|
|
.set_float = [](kShaderUniform uniform, float value) { ShaderManager::u_float(uniform, value); },
|
|
.set_vec2 = [](kShaderUniform uniform, const glm::vec2& value) { ShaderManager::u_vec2(uniform, value); },
|
|
.set_vec4 = [](kShaderUniform uniform, const glm::vec4& value) { ShaderManager::u_vec4(uniform, value); },
|
|
.set_mat4 = [](kShaderUniform uniform, const glm::mat4& value) { ShaderManager::u_mat4(uniform, value); },
|
|
};
|
|
}
|
|
|
|
inline void apply_legacy_canvas_draw_merge_mvp(
|
|
const glm::mat4& mvp,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.set_mat4(kShaderUniform::MVP, mvp);
|
|
}
|
|
|
|
inline void apply_legacy_canvas_draw_merge_mvp(const glm::mat4& mvp)
|
|
{
|
|
apply_legacy_canvas_draw_merge_mvp(mvp, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_checkerboard_shader(
|
|
const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::Checkerboard);
|
|
execution.set_int(kShaderUniform::Colorize, uniforms.colorize);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_checkerboard_shader(
|
|
const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_checkerboard_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_shader(
|
|
const LegacyCanvasDrawMergeTextureUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::Texture);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_shader(
|
|
const LegacyCanvasDrawMergeTextureUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_atlas_shader(
|
|
const LegacyCanvasDrawMergeAtlasUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::Atlas);
|
|
execution.set_vec2(kShaderUniform::Tof, uniforms.offset);
|
|
execution.set_vec2(kShaderUniform::Tsz, uniforms.size);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_atlas_shader(
|
|
const LegacyCanvasDrawMergeAtlasUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_atlas_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_equirect_shader(
|
|
const LegacyCanvasDrawMergeEquirectUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::Equirect);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_equirect_shader(
|
|
const LegacyCanvasDrawMergeEquirectUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_equirect_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
|
|
const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::TextureMask);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
execution.set_vec2(kShaderUniform::PatternOffset, uniforms.pattern_offset);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
|
|
const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_mask_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_alpha_shader(
|
|
const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::TextureAlpha);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
execution.set_float(kShaderUniform::Alpha, uniforms.alpha);
|
|
execution.set_int(kShaderUniform::Highlight, uniforms.highlight);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_alpha_shader(
|
|
const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_alpha_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_blend_shader(
|
|
const LegacyCanvasDrawMergeTextureBlendUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::TextureBlend);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
if (uniforms.use_destination_texture) {
|
|
execution.set_int(kShaderUniform::TexBG, uniforms.destination_texture_slot);
|
|
}
|
|
execution.set_int(kShaderUniform::BlendMode, uniforms.blend_mode);
|
|
execution.set_float(kShaderUniform::Alpha, uniforms.alpha);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_blend_shader(
|
|
const LegacyCanvasDrawMergeTextureBlendUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_blend_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
|
|
const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
|
|
{
|
|
execution.use_shader(kShader::TextureColorize);
|
|
execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
|
|
execution.set_vec4(kShaderUniform::Col, uniforms.color);
|
|
execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
|
|
}
|
|
|
|
inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
|
|
const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_colorize_shader(uniforms, legacy_shader_manager_draw_merge_execution());
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_layer_blend(
|
|
const LegacyCanvasDrawMergeLayerBlendUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeLayerBlendExecution& execution)
|
|
{
|
|
execution.unbind_merge_framebuffer();
|
|
execution.bind_samplers();
|
|
setup_legacy_canvas_draw_merge_texture_blend_shader(uniforms.shader);
|
|
execution.bind_merge_texture();
|
|
|
|
if (uniforms.copy_destination) {
|
|
execution.bind_destination_texture();
|
|
execution.copy_destination_framebuffer();
|
|
}
|
|
|
|
execution.draw();
|
|
|
|
if (uniforms.copy_destination) {
|
|
execution.unbind_destination_texture();
|
|
}
|
|
|
|
execution.unbind_merge_texture();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_layer_texture(
|
|
const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeLayerTextureExecution& execution)
|
|
{
|
|
execution.bind_sampler();
|
|
setup_legacy_canvas_draw_merge_texture_alpha_shader(uniforms);
|
|
execution.bind_layer_texture();
|
|
execution.draw();
|
|
execution.unbind_layer_texture();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_layer_composite(
|
|
bool is_temporary_erase,
|
|
bool is_temporary_paint,
|
|
bool use_blend,
|
|
const LegacyCanvasDrawMergeLayerCompositeExecution& execution)
|
|
{
|
|
if (is_temporary_erase) {
|
|
execution.execute_temporary_erase();
|
|
} else if (is_temporary_paint) {
|
|
execution.execute_temporary_paint();
|
|
} else {
|
|
execution.execute_layer_texture();
|
|
}
|
|
|
|
if (use_blend) {
|
|
execution.execute_layer_blend();
|
|
}
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_layer_plane(
|
|
bool is_temporary_erase,
|
|
bool is_temporary_paint,
|
|
bool use_blend,
|
|
int first_frame,
|
|
int last_frame,
|
|
const std::function<float(int)>& frame_alpha,
|
|
const LegacyCanvasDrawMergeLayerPlaneExecution& execution)
|
|
{
|
|
if (use_blend) {
|
|
execution.bind_blender_framebuffer();
|
|
execution.clear_blender_framebuffer();
|
|
}
|
|
|
|
if (is_temporary_erase) {
|
|
execution.prepare_temporary_erase();
|
|
for (int frame = first_frame; frame <= last_frame; frame++) {
|
|
execution.draw_temporary_erase_frame(frame, frame_alpha(frame));
|
|
}
|
|
execution.cleanup_temporary_erase();
|
|
} else if (is_temporary_paint) {
|
|
execution.prepare_temporary_paint();
|
|
for (int frame = first_frame; frame <= last_frame; frame++) {
|
|
execution.draw_temporary_paint_frame(frame, frame_alpha(frame));
|
|
}
|
|
execution.cleanup_temporary_paint();
|
|
} else {
|
|
execution.prepare_layer_texture();
|
|
for (int frame = first_frame; frame <= last_frame; frame++) {
|
|
execution.draw_layer_texture_frame(frame, frame_alpha(frame));
|
|
}
|
|
execution.cleanup_layer_texture();
|
|
}
|
|
|
|
if (use_blend) {
|
|
execution.unbind_blender_framebuffer();
|
|
execution.draw_blend();
|
|
}
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_temporary_composite(
|
|
const LegacyCanvasDrawMergeTemporaryCompositeExecution& execution)
|
|
{
|
|
execution.setup();
|
|
execution.bind_samplers();
|
|
execution.bind_textures();
|
|
execution.draw();
|
|
execution.unbind_textures();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_background_setup(
|
|
const LegacyCanvasDrawMergeBackgroundSetupUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeBackgroundSetupExecution& execution)
|
|
{
|
|
if (uniforms.draw_merged) {
|
|
execution.disable_blend();
|
|
}
|
|
|
|
if (uniforms.draw_merged || !uniforms.use_blend) {
|
|
for (int plane_index = 0; plane_index < 6; ++plane_index) {
|
|
execution.draw_checkerboard_plane(plane_index);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_plane_setup(
|
|
const LegacyCanvasDrawMergePlaneSetupUniforms& uniforms,
|
|
const LegacyCanvasDrawMergePlaneSetupExecution& execution)
|
|
{
|
|
execution.clear_plane();
|
|
|
|
if (uniforms.use_blend) {
|
|
execution.disable_blend();
|
|
execution.clear_plane();
|
|
return;
|
|
}
|
|
|
|
if (uniforms.draw_checkerboard) {
|
|
setup_legacy_canvas_draw_merge_checkerboard_shader(uniforms.checkerboard);
|
|
execution.draw();
|
|
}
|
|
|
|
execution.enable_blend();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_final_plane_composite(
|
|
const LegacyCanvasDrawMergeFinalPlaneCompositeUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeFinalPlaneCompositeExecution& execution)
|
|
{
|
|
execution.bind_merged_texture_copy_target();
|
|
execution.copy_merged_framebuffer();
|
|
|
|
execution.enable_blend();
|
|
|
|
if (uniforms.draw_checkerboard) {
|
|
setup_legacy_canvas_draw_merge_checkerboard_shader(uniforms.checkerboard);
|
|
execution.draw();
|
|
}
|
|
|
|
execution.bind_sampler();
|
|
execution.bind_merged_texture();
|
|
setup_legacy_canvas_draw_merge_texture_shader(uniforms.texture);
|
|
execution.draw();
|
|
execution.unbind_merged_texture();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_cache_to_screen_composite(
|
|
const LegacyCanvasDrawMergeCacheToScreenCompositeUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeCacheToScreenCompositeExecution& execution)
|
|
{
|
|
execution.enable_blend();
|
|
|
|
for (int plane_index = 0; plane_index < 6; ++plane_index) {
|
|
execution.draw_checkerboard_plane(uniforms.checkerboard, plane_index);
|
|
}
|
|
|
|
execution.bind_sampler();
|
|
execution.bind_cache_texture();
|
|
setup_legacy_canvas_draw_merge_texture_shader(uniforms.texture);
|
|
execution.draw_cache_texture();
|
|
execution.unbind_cache_texture();
|
|
}
|
|
|
|
template <typename PlaneTransform, typename DrawPlane>
|
|
[[nodiscard]] inline auto make_legacy_canvas_draw_merge_cache_to_screen_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](
|
|
const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms,
|
|
int plane_index) {
|
|
auto checkerboard_uniforms = uniforms;
|
|
checkerboard_uniforms.mvp = proj * camera *
|
|
glm::scale(glm::vec3(layer_scale)) *
|
|
plane_transform[plane_index] *
|
|
glm::translate(glm::vec3(0, 0, -1.f));
|
|
|
|
setup_legacy_canvas_draw_merge_checkerboard_shader(checkerboard_uniforms);
|
|
draw_plane();
|
|
};
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_display_resolve(
|
|
const LegacyCanvasDrawMergeDisplayResolveUniforms& uniforms,
|
|
const LegacyCanvasDrawMergeDisplayResolveExecution& execution)
|
|
{
|
|
execution.unbind_resolve_framebuffer();
|
|
execution.clear_color_buffer();
|
|
execution.apply_viewport();
|
|
execution.bind_sampler();
|
|
execution.bind_resolve_texture();
|
|
setup_legacy_canvas_draw_merge_texture_shader(uniforms.texture);
|
|
execution.draw();
|
|
execution.unbind_resolve_texture();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_post_draw(
|
|
bool smask_active,
|
|
bool draw_mask_overlay,
|
|
int smask_mode,
|
|
bool draw_grid_modes,
|
|
const LegacyCanvasDrawMergePostDrawExecution& execution)
|
|
{
|
|
if (smask_active || draw_mask_overlay) {
|
|
if (smask_mode == 1) {
|
|
execution.draw_mask_free();
|
|
} else if (smask_mode == 2) {
|
|
execution.draw_mask_line();
|
|
}
|
|
}
|
|
|
|
if (smask_active) {
|
|
execution.draw_smask_faces();
|
|
}
|
|
|
|
if (draw_grid_modes) {
|
|
execution.draw_grid_modes();
|
|
}
|
|
|
|
execution.draw_heightmap();
|
|
execution.draw_current_modes();
|
|
}
|
|
|
|
inline void execute_legacy_canvas_draw_merge_smask_faces(
|
|
const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms,
|
|
const glm::mat4& proj,
|
|
const glm::mat4& camera,
|
|
float layer_scale,
|
|
const std::array<glm::mat4, 6>& plane_transform,
|
|
const LegacyCanvasDrawMergeSmaskFacesExecution& execution)
|
|
{
|
|
setup_legacy_canvas_draw_merge_texture_mask_shader(uniforms);
|
|
execution.set_active_texture_unit();
|
|
execution.enable_blend();
|
|
|
|
for (int plane_index = 0; plane_index < 6; ++plane_index) {
|
|
auto plane_mvp = proj * camera *
|
|
glm::scale(glm::vec3(layer_scale)) *
|
|
plane_transform[plane_index] *
|
|
glm::translate(glm::vec3(0, 0, -1.f));
|
|
|
|
apply_legacy_canvas_draw_merge_mvp(plane_mvp);
|
|
execution.bind_face_texture(plane_index);
|
|
execution.draw_face();
|
|
execution.unbind_face_texture(plane_index);
|
|
}
|
|
}
|
|
|
|
} // namespace pp::panopainter
|