edgevoid/armorpaint
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
5c19a166404891d610d1bc8a8596b897465aacbc
armorpaint/paint/sources/slot_layer.c
T
luboslenco 5c19a16640 paint: merge sculpt
2026-06-11 20:01:25 +02:00

899 lines
31 KiB
C
Raw Blame History

#include "global.h"
slot_layer_t *slot_layer_create(char *ext, layer_slot_type_t type, slot_layer_t *parent) {
slot_layer_t *raw = GC_ALLOC_INIT(slot_layer_t, {0});
raw->id = 0;
raw->ext = "";
raw->visible = true;
raw->mask_opacity = 1.0; // Opacity mask
raw->show_panel = true;
raw->blending = BLEND_TYPE_MIX;
raw->object_mask = 0;
raw->scale = 1.0;
raw->angle = 0.0;
raw->uv_type = UV_TYPE_UVMAP;
raw->paint_base = true;
raw->paint_opac = true;
raw->paint_occ = true;
raw->paint_rough = true;
raw->paint_met = true;
raw->paint_nor = true;
raw->paint_nor_blend = true;
raw->paint_height = true;
raw->paint_height_blend = true;
raw->paint_emis = true;
raw->paint_subs = true;
raw->decal_mat = mat4_identity(); // Decal layer
if (string_equals(ext, "")) {
raw->id = 0;
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->id >= raw->id) {
raw->id = l->id + 1;
}
}
ext = string("%d", raw->id);
}
raw->ext = string_copy(ext);
raw->parent = parent;
if (type == LAYER_SLOT_TYPE_GROUP) {
i32 id = (raw->id + 1);
raw->name = string("Group %d", id);
}
else if (type == LAYER_SLOT_TYPE_LAYER) {
i32 id = (raw->id + 1);
raw->name = string("Layer %d", id);
char *format = base_bits_handle->i == TEXTURE_BITS_BITS8 ? "RGBA32" : base_bits_handle->i == TEXTURE_BITS_BITS16 ? "RGBA64" : "RGBA128";
{
render_target_t *t = render_target_create();
t->name = string("texpaint%s", ext);
t->width = config_get_texture_res_x();
t->height = config_get_texture_res_y();
t->format = string_copy(format);
raw->texpaint = render_path_create_render_target(t)->_image;
}
{
render_target_t *t = render_target_create();
t->name = string("texpaint_nor%s", ext);
t->width = config_get_texture_res_x();
t->height = config_get_texture_res_y();
t->format = string_copy(format);
raw->texpaint_nor = render_path_create_render_target(t)->_image;
}
{
render_target_t *t = render_target_create();
t->name = string("texpaint_pack%s", ext);
t->width = config_get_texture_res_x();
t->height = config_get_texture_res_y();
t->format = string_copy(format);
raw->texpaint_pack = render_path_create_render_target(t)->_image;
}
raw->texpaint_preview = gpu_create_render_target(util_render_layer_preview_size, util_render_layer_preview_size, GPU_TEXTURE_FORMAT_RGBA32);
if (slot_layer_is_filter(raw)) {
raw->name = string("Filter %d", id);
}
}
else { // Mask
i32 id = (raw->id + 1);
raw->name = string("Mask %d", id);
char *format = "RGBA32"; // Full bits for undo support, R8 is used
raw->blending = BLEND_TYPE_MIX;
{
render_target_t *t = render_target_create();
t->name = string("texpaint%s", ext);
t->width = config_get_texture_res_x();
t->height = config_get_texture_res_y();
t->format = string_copy(format);
raw->texpaint = render_path_create_render_target(t)->_image;
}
raw->texpaint_preview = gpu_create_render_target(util_render_layer_preview_size, util_render_layer_preview_size, GPU_TEXTURE_FORMAT_RGBA32);
}
return raw;
}
void slot_layer_delete(slot_layer_t *raw) {
slot_layer_unload(raw);
if (slot_layer_is_layer(raw)) {
slot_layer_t_array_t *masks = slot_layer_get_masks(raw, false); // Prevents deleting group masks
if (masks != NULL) {
for (i32 i = 0; i < masks->length; ++i) {
slot_layer_t *m = masks->buffer[i];
slot_layer_delete(m);
}
}
}
else if (slot_layer_is_group(raw)) {
slot_layer_t_array_t *children = slot_layer_get_children(raw);
if (children != NULL) {
for (i32 i = 0; i < children->length; ++i) {
slot_layer_t *c = children->buffer[i];
slot_layer_delete(c);
}
}
slot_layer_t_array_t *masks = slot_layer_get_masks(raw, true);
if (masks != NULL) {
for (i32 i = 0; i < masks->length; ++i) {
slot_layer_t *m = masks->buffer[i];
slot_layer_delete(m);
}
}
}
i32 lpos = array_index_of(g_project->_->layers, raw);
array_remove(g_project->_->layers, raw);
// Undo can remove base layer and then restore it from undo layers
if (g_project->_->layers->length > 0) {
context_set_layer(g_project->_->layers->buffer[lpos > 0 ? lpos - 1 : 0]);
}
// Do not remove empty groups if the last layer is deleted as this prevents redo from working properly
}
void slot_layer_unload(slot_layer_t *raw) {
if (slot_layer_is_group(raw)) {
return;
}
gpu_texture_t *_texpaint = raw->texpaint;
gpu_texture_t *_texpaint_nor = raw->texpaint_nor;
gpu_texture_t *_texpaint_pack = raw->texpaint_pack;
gpu_texture_t *_texpaint_preview = raw->texpaint_preview;
gpu_delete_texture(_texpaint);
if (_texpaint_nor != NULL) {
gpu_delete_texture(_texpaint_nor);
}
if (_texpaint_pack != NULL) {
gpu_delete_texture(_texpaint_pack);
}
if (_texpaint_preview != NULL) {
gpu_delete_texture(_texpaint_preview);
}
map_delete(render_path_render_targets, string("texpaint%s", raw->ext));
if (slot_layer_is_layer(raw)) {
map_delete(render_path_render_targets, string("texpaint_nor%s", raw->ext));
map_delete(render_path_render_targets, string("texpaint_pack%s", raw->ext));
}
}
void slot_layer_swap(slot_layer_t *raw, slot_layer_t *other) {
if ((slot_layer_is_layer(raw) || slot_layer_is_mask(raw)) && (slot_layer_is_layer(other) || slot_layer_is_mask(other))) {
render_target_t *rt0 = any_map_get(render_path_render_targets, string("texpaint%s", raw->ext));
render_target_t *rt1 = any_map_get(render_path_render_targets, string("texpaint%s", other->ext));
rt0->_image = other->texpaint;
rt1->_image = raw->texpaint;
gpu_texture_t *_texpaint = raw->texpaint;
raw->texpaint = other->texpaint;
other->texpaint = _texpaint;
gpu_texture_t *_texpaint_preview = raw->texpaint_preview;
raw->texpaint_preview = other->texpaint_preview;
other->texpaint_preview = _texpaint_preview;
}
if (raw->texpaint_sculpt != NULL && other->texpaint_sculpt != NULL) {
render_target_t *srt0 = any_map_get(render_path_render_targets, string("texpaint_sculpt%s", raw->ext));
render_target_t *srt1 = any_map_get(render_path_render_targets, string("texpaint_sculpt%s", other->ext));
srt0->_image = other->texpaint_sculpt;
srt1->_image = raw->texpaint_sculpt;
gpu_texture_t *_texpaint_sculpt = raw->texpaint_sculpt;
raw->texpaint_sculpt = other->texpaint_sculpt;
other->texpaint_sculpt = _texpaint_sculpt;
}
if (slot_layer_is_layer(raw) && slot_layer_is_layer(other)) {
render_target_t *nor0 = any_map_get(render_path_render_targets, string("texpaint_nor%s", raw->ext));
nor0->_image = other->texpaint_nor;
render_target_t *pack0 = any_map_get(render_path_render_targets, string("texpaint_pack%s", raw->ext));
pack0->_image = other->texpaint_pack;
render_target_t *nor1 = any_map_get(render_path_render_targets, string("texpaint_nor%s", other->ext));
nor1->_image = raw->texpaint_nor;
render_target_t *pack1 = any_map_get(render_path_render_targets, string("texpaint_pack%s", other->ext));
pack1->_image = raw->texpaint_pack;
gpu_texture_t *_texpaint_nor = raw->texpaint_nor;
gpu_texture_t *_texpaint_pack = raw->texpaint_pack;
raw->texpaint_nor = other->texpaint_nor;
raw->texpaint_pack = other->texpaint_pack;
other->texpaint_nor = _texpaint_nor;
other->texpaint_pack = _texpaint_pack;
}
}
void slot_layer_clear(slot_layer_t *raw, i32 base_color, gpu_texture_t *base_image, f32 occlusion, f32 roughness, f32 metallic) {
// Base
_gpu_begin(raw->texpaint, NULL, NULL, GPU_CLEAR_COLOR, base_color, 0.0);
gpu_end();
if (base_image != NULL) {
draw_begin(raw->texpaint, false, 0);
draw_scaled_image(base_image, 0, 0, raw->texpaint->width, raw->texpaint->height);
draw_end();
}
if (slot_layer_is_layer(raw)) {
// Nor
_gpu_begin(raw->texpaint_nor, NULL, NULL, GPU_CLEAR_COLOR, color_from_floats(0.5, 0.5, 1.0, 0.0), 0.0);
gpu_end();
// Occ, rough, met
_gpu_begin(raw->texpaint_pack, NULL, NULL, GPU_CLEAR_COLOR, color_from_floats(occlusion, roughness, metallic, 0.0), 0.0);
gpu_end();
}
g_context->layer_preview_dirty = true;
g_context->ddirty = 3;
}
void slot_layer_invert_mask(slot_layer_t *raw) {
gpu_texture_t *inverted = gpu_create_render_target(raw->texpaint->width, raw->texpaint->height, GPU_TEXTURE_FORMAT_RGBA32);
draw_begin(inverted, false, 0);
draw_set_pipeline(pipes_invert_mask);
draw_image(raw->texpaint, 0, 0);
draw_set_pipeline(NULL);
draw_end();
gpu_texture_t *_texpaint = raw->texpaint;
gpu_delete_texture(_texpaint);
render_target_t *rt = any_map_get(render_path_render_targets, string("texpaint%d", raw->id));
raw->texpaint = rt->_image = inverted;
g_context->layer_preview_dirty = true;
g_context->ddirty = 3;
}
void layers_apply_mask(slot_layer_t *l, slot_layer_t *m) {
if (!slot_layer_is_layer(l) || !slot_layer_is_mask(m)) {
return;
}
layers_make_temp_img();
// Copy layer to temp
draw_begin(layers_temp_image, false, 0);
draw_set_pipeline(pipes_copy);
draw_image(l->texpaint, 0, 0);
draw_set_pipeline(NULL);
draw_end();
// Apply mask
_gpu_begin(l->texpaint, NULL, NULL, GPU_CLEAR_NONE, 0, 0.0);
gpu_set_pipeline(pipes_apply_mask);
gpu_set_texture(pipes_tex0_mask, layers_temp_image);
gpu_set_texture(pipes_texa_mask, m->texpaint);
gpu_set_float(pipes_opac_apply_mask, m->mask_opacity);
gpu_set_vertex_buffer(const_data_screen_aligned_vb);
gpu_set_index_buffer(const_data_screen_aligned_ib);
gpu_draw();
gpu_end();
}
void slot_layer_apply_mask(slot_layer_t *raw) {
if (raw->parent->fill_material != NULL) {
slot_layer_to_paint_layer(raw->parent);
}
if (slot_layer_is_group(raw->parent)) {
for (i32 i = 0; i < slot_layer_get_children(raw->parent)->length; ++i) {
slot_layer_t *c = slot_layer_get_children(raw->parent)->buffer[i];
layers_apply_mask(c, raw);
}
}
else {
layers_apply_mask(raw->parent, raw);
}
slot_layer_delete(raw);
}
slot_layer_t *slot_layer_duplicate(slot_layer_t *raw) {
slot_layer_t_array_t *layers = g_project->_->layers;
i32 i = array_index_of(layers, raw) + 1;
slot_layer_t *l = slot_layer_create("",
slot_layer_is_layer(raw) ? LAYER_SLOT_TYPE_LAYER
: slot_layer_is_mask(raw) ? LAYER_SLOT_TYPE_MASK
: LAYER_SLOT_TYPE_GROUP,
raw->parent);
array_insert(layers, i, l);
if (slot_layer_is_layer(raw)) {
draw_begin(l->texpaint, false, 0);
draw_set_pipeline(pipes_copy);
draw_image(raw->texpaint, 0, 0);
draw_set_pipeline(NULL);
draw_end();
if (l->texpaint_nor != NULL) {
draw_begin(l->texpaint_nor, false, 0);
draw_set_pipeline(pipes_copy);
draw_image(raw->texpaint_nor, 0, 0);
draw_set_pipeline(NULL);
draw_end();
}
if (l->texpaint_pack != NULL) {
draw_begin(l->texpaint_pack, false, 0);
draw_set_pipeline(pipes_copy);
draw_image(raw->texpaint_pack, 0, 0);
draw_set_pipeline(NULL);
draw_end();
}
}
else if (slot_layer_is_mask(raw)) {
draw_begin(l->texpaint, false, 0);
draw_set_pipeline(pipes_copy8);
draw_image(raw->texpaint, 0, 0);
draw_set_pipeline(NULL);
draw_end();
}
if (l->texpaint_preview != NULL) {
draw_begin(l->texpaint_preview, true, 0x00000000);
draw_set_pipeline(pipes_copy);
draw_scaled_image(raw->texpaint_preview, 0, 0, raw->texpaint_preview->width, raw->texpaint_preview->height);
draw_set_pipeline(NULL);
draw_end();
}
l->visible = raw->visible;
l->mask_opacity = raw->mask_opacity;
l->fill_material = raw->fill_material;
l->object_mask = raw->object_mask;
l->blending = raw->blending;
l->uv_type = raw->uv_type;
l->decal_mat = raw->decal_mat;
l->scale = raw->scale;
l->angle = raw->angle;
l->paint_base = raw->paint_base;
l->paint_opac = raw->paint_opac;
l->paint_occ = raw->paint_occ;
l->paint_rough = raw->paint_rough;
l->paint_met = raw->paint_met;
l->paint_nor = raw->paint_nor;
l->paint_nor_blend = raw->paint_nor_blend;
l->paint_height = raw->paint_height;
l->paint_height_blend = raw->paint_height_blend;
l->paint_emis = raw->paint_emis;
l->paint_subs = raw->paint_subs;
if (raw->path_points != NULL) {
l->path_points = f32_array_create_from_raw(raw->path_points->buffer, raw->path_points->length);
l->path_points_world = f32_array_create_from_raw(raw->path_points_world->buffer, raw->path_points_world->length);
l->path_points_camera = f32_array_create_from_raw(raw->path_points_camera->buffer, raw->path_points_camera->length);
l->path_points_parent = i32_array_create_from_raw(raw->path_points_parent->buffer, raw->path_points_parent->length);
l->path_tool = raw->path_tool;
l->path_curved = raw->path_curved;
l->path_material = raw->path_material;
}
return l;
}
void slot_layer_resize_and_set_bits(slot_layer_t *raw) {
i32 res_x = config_get_texture_res_x();
i32 res_y = config_get_texture_res_y();
any_map_t *rts = render_path_render_targets;
if (slot_layer_is_layer(raw)) {
gpu_texture_format_t format = base_bits_handle->i == TEXTURE_BITS_BITS8 ? GPU_TEXTURE_FORMAT_RGBA32
: base_bits_handle->i == TEXTURE_BITS_BITS16 ? GPU_TEXTURE_FORMAT_RGBA64
: GPU_TEXTURE_FORMAT_RGBA128;
gpu_pipeline_t *pipe = format == GPU_TEXTURE_FORMAT_RGBA32 ? pipes_copy : format == GPU_TEXTURE_FORMAT_RGBA64 ? pipes_copy64 : pipes_copy128;
gpu_texture_t *_texpaint = raw->texpaint;
raw->texpaint = gpu_create_render_target(res_x, res_y, format);
draw_begin(raw->texpaint, false, 0);
draw_set_pipeline(pipe);
draw_scaled_image(_texpaint, 0, 0, res_x, res_y);
draw_set_pipeline(NULL);
draw_end();
gpu_texture_t *_texpaint_nor = raw->texpaint_nor;
if (raw->texpaint_nor != NULL) {
raw->texpaint_nor = gpu_create_render_target(res_x, res_y, format);
draw_begin(raw->texpaint_nor, false, 0);
draw_set_pipeline(pipe);
draw_scaled_image(_texpaint_nor, 0, 0, res_x, res_y);
draw_set_pipeline(NULL);
draw_end();
}
gpu_texture_t *_texpaint_pack = raw->texpaint_pack;
if (raw->texpaint_pack != NULL) {
raw->texpaint_pack = gpu_create_render_target(res_x, res_y, format);
draw_begin(raw->texpaint_pack, false, 0);
draw_set_pipeline(pipe);
draw_scaled_image(_texpaint_pack, 0, 0, res_x, res_y);
draw_set_pipeline(NULL);
draw_end();
}
gpu_delete_texture(_texpaint);
if (_texpaint_nor != NULL) {
gpu_delete_texture(_texpaint_nor);
}
if (_texpaint_pack != NULL) {
gpu_delete_texture(_texpaint_pack);
}
render_target_t *rt = any_map_get(rts, string("texpaint%s", raw->ext));
rt->_image = raw->texpaint;
if (raw->texpaint_nor != NULL) {
render_target_t *rt_nor = any_map_get(rts, string("texpaint_nor%s", raw->ext));
rt_nor->_image = raw->texpaint_nor;
}
if (raw->texpaint_pack != NULL) {
render_target_t *rt_pack = any_map_get(rts, string("texpaint_pack%s", raw->ext));
rt_pack->_image = raw->texpaint_pack;
}
}
else if (slot_layer_is_mask(raw)) {
gpu_texture_t *_texpaint = raw->texpaint;
raw->texpaint = gpu_create_render_target(res_x, res_y, GPU_TEXTURE_FORMAT_RGBA32);
draw_begin(raw->texpaint, false, 0);
draw_set_pipeline(pipes_copy8);
draw_scaled_image(_texpaint, 0, 0, res_x, res_y);
draw_set_pipeline(NULL);
draw_end();
gpu_delete_texture(_texpaint);
render_target_t *rt = any_map_get(rts, string("texpaint%s", raw->ext));
rt->_image = raw->texpaint;
}
// Clear and repack the base mesh
if (raw->texpaint_sculpt != NULL) {
gpu_texture_t *_texpaint_sculpt = raw->texpaint_sculpt;
raw->texpaint_sculpt = gpu_create_render_target(res_x, res_y, GPU_TEXTURE_FORMAT_RGBA128);
sculpt_import_mesh_pack_to_texture(raw->texpaint_sculpt);
gpu_delete_texture(_texpaint_sculpt);
render_target_t *srt = any_map_get(rts, string("texpaint_sculpt%s", raw->ext));
srt->width = res_x;
srt->height = res_y;
srt->_image = raw->texpaint_sculpt;
}
}
void slot_layer_to_fill_layer_on_next_frame(void *_) {
make_material_parse_paint_material(true);
g_context->layer_preview_dirty = true;
ui_base_hwnds->buffer[TAB_AREA_SIDEBAR0]->redraws = 2;
}
void slot_layer_to_fill_layer(slot_layer_t *raw) {
context_set_layer(raw);
raw->fill_material = g_context->material;
layers_update_fill_layer(true);
sys_notify_on_next_frame(&slot_layer_to_fill_layer_on_next_frame, NULL);
}
void slot_layer_to_paint_layer(slot_layer_t *raw) {
context_set_layer(raw);
raw->fill_material = NULL;
if (raw->path_material != NULL) {
raw->path_material = NULL;
raw->path_points = NULL;
util_layer_update_path();
}
make_material_parse_paint_material(true);
g_context->layer_preview_dirty = true;
ui_base_hwnds->buffer[TAB_AREA_SIDEBAR0]->redraws = 2;
}
bool slot_layer_is_visible(slot_layer_t *raw) {
return raw->visible && (raw->parent == NULL || raw->parent->visible);
}
slot_layer_t_array_t *slot_layer_get_children(slot_layer_t *raw) {
slot_layer_t_array_t *children = NULL; // Child layers of a group
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw && slot_layer_is_layer(l)) {
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
return children;
}
slot_layer_t_array_t *slot_layer_get_recursive_children(slot_layer_t *raw) {
slot_layer_t_array_t *children = NULL;
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw) { // Child layers and group masks
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
if (l->parent != NULL && l->parent->parent == raw) { // Layer masks
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
return children;
}
slot_layer_t_array_t *slot_layer_get_masks(slot_layer_t *raw, bool include_group_masks) {
if (slot_layer_is_mask(raw)) {
return NULL;
}
slot_layer_t_array_t *children = NULL;
// Child masks of a layer
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw && slot_layer_is_mask(l)) {
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
// Child masks of a parent group
if (include_group_masks) {
if (raw->parent != NULL && slot_layer_is_group(raw->parent)) {
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw->parent && slot_layer_is_mask(l)) {
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
}
}
return children;
}
bool slot_layer_has_masks(slot_layer_t *raw, bool include_group_masks) {
// Layer mask
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw && slot_layer_is_mask(l)) {
return true;
}
}
// Group mask
if (include_group_masks && raw->parent != NULL && slot_layer_is_group(raw->parent)) {
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw->parent && slot_layer_is_mask(l)) {
return true;
}
}
}
return false;
}
slot_layer_t_array_t *slot_layer_get_filters(slot_layer_t *raw, bool include_group_filters) {
if (slot_layer_is_filter(raw)) {
return NULL;
}
slot_layer_t_array_t *children = NULL;
// Child filters of a layer
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw && slot_layer_is_filter(l)) {
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
// Child filters of a parent group
if (include_group_filters) {
if (raw->parent != NULL && slot_layer_is_group(raw->parent)) {
for (i32 i = 0; i < g_project->_->layers->length; ++i) {
slot_layer_t *l = g_project->_->layers->buffer[i];
if (l->parent == raw->parent && slot_layer_is_filter(l)) {
if (children == NULL) {
children = any_array_create_from_raw((void *[]){}, 0);
}
any_array_push(children, l);
}
}
}
}
return children;
}
f32 slot_layer_get_opacity(slot_layer_t *raw) {
f32 f = raw->mask_opacity;
if (slot_layer_is_layer(raw) && raw->parent != NULL) {
f *= raw->parent->mask_opacity;
}
return f;
}
i32 slot_layer_get_object_mask(slot_layer_t *raw) {
return (slot_layer_is_mask(raw) || slot_layer_is_filter(raw)) ? raw->parent->object_mask : raw->object_mask;
}
i32 slot_layer_get_blending(slot_layer_t *raw) {
return slot_layer_is_filter(raw) ? raw->parent->blending : raw->blending;
}
bool slot_layer_is_layer(slot_layer_t *raw) {
return raw->texpaint != NULL && raw->texpaint_nor != NULL;
}
bool slot_layer_is_path(slot_layer_t *raw) {
return raw->path_points != NULL;
}
bool slot_layer_is_group(slot_layer_t *raw) {
return raw->texpaint == NULL;
}
slot_layer_t *slot_layer_get_containing_group(slot_layer_t *raw) {
if (raw->parent != NULL && slot_layer_is_group(raw->parent)) {
return raw->parent;
}
else if (raw->parent != NULL && raw->parent->parent != NULL && slot_layer_is_group(raw->parent->parent)) {
return raw->parent->parent;
}
else {
return NULL;
}
}
bool slot_layer_is_filter(slot_layer_t *raw) {
return raw->texpaint != NULL && raw->texpaint_nor != NULL && raw->parent != NULL && slot_layer_is_layer(raw->parent);
}
bool slot_layer_is_mask(slot_layer_t *raw) {
return raw->texpaint != NULL && raw->texpaint_nor == NULL;
}
bool slot_layer_is_group_mask(slot_layer_t *raw) {
return slot_layer_is_mask(raw) && slot_layer_is_group(raw->parent);
}
bool slot_layer_is_layer_mask(slot_layer_t *raw) {
return slot_layer_is_mask(raw) && slot_layer_is_layer(raw->parent);
}
bool slot_layer_is_in_group(slot_layer_t *raw) {
return raw->parent != NULL && (slot_layer_is_group(raw->parent) || (raw->parent->parent != NULL && slot_layer_is_group(raw->parent->parent)));
}
bool slot_layer_can_move(slot_layer_t *raw, i32 to) {
i32 old_index = array_index_of(g_project->_->layers, raw);
i32 delta = to - old_index; // If delta > 0 the layer is moved up, otherwise down
if (to < 0 || to > g_project->_->layers->length - 1 || delta == 0) {
return false;
}
// If the layer is moved up, all layers between the old position and the new one move one down
// The layers above the new position stay where they are
// If the new position is on top or on bottom no upper resp. lower layer exists
slot_layer_t *new_upper_layer =
delta > 0 ? (to < g_project->_->layers->length - 1 ? g_project->_->layers->buffer[to + 1] : NULL) : g_project->_->layers->buffer[to];
// Group or layer is collapsed so we check below and update the upper layer
if (new_upper_layer != NULL && !new_upper_layer->show_panel) {
slot_layer_t_array_t *children = slot_layer_get_recursive_children(new_upper_layer);
to -= children != NULL ? children->length : 0;
delta = to - old_index;
new_upper_layer = delta > 0 ? (to < g_project->_->layers->length - 1 ? g_project->_->layers->buffer[to + 1] : NULL) : g_project->_->layers->buffer[to];
}
slot_layer_t *new_lower_layer = delta > 0 ? g_project->_->layers->buffer[to] : (to > 0 ? g_project->_->layers->buffer[to - 1] : NULL);
if (slot_layer_is_mask(raw)) {
// Masks can not be on top
if (new_upper_layer == NULL) {
return false;
}
// Masks should not be placed below a collapsed group - this condition can be savely removed
if (slot_layer_is_in_group(new_upper_layer) && !slot_layer_get_containing_group(new_upper_layer)->show_panel) {
return false;
}
// Masks should not be placed below a collapsed layer - this condition can be savely removed
if (slot_layer_is_mask(new_upper_layer) && !new_upper_layer->parent->show_panel) {
return false;
}
}
if (slot_layer_is_filter(raw)) {
// Filters can not be on top
if (new_upper_layer == NULL) {
return false;
}
// Filters should not be placed below a collapsed group
if (slot_layer_is_in_group(new_upper_layer) && !slot_layer_get_containing_group(new_upper_layer)->show_panel) {
return false;
}
// Filters should not be placed below a collapsed layer
if ((slot_layer_is_filter(new_upper_layer) || slot_layer_is_mask(new_upper_layer)) && !new_upper_layer->parent->show_panel) {
return false;
}
}
if (slot_layer_is_layer(raw) && !slot_layer_is_filter(raw)) {
// Layers can not be moved directly below its own mask(s)
if (new_upper_layer != NULL && slot_layer_is_mask(new_upper_layer) && new_upper_layer->parent == raw) {
return false;
}
// Layers can not be moved directly below its own filter(s)
if (new_upper_layer != NULL && slot_layer_is_filter(new_upper_layer) && new_upper_layer->parent == raw) {
return false;
}
// Layers can not be placed above a mask as the mask would be reparented
if (new_lower_layer != NULL && slot_layer_is_mask(new_lower_layer)) {
return false;
}
// Layers can not be placed above a filter as the filter would be reparented
if (new_lower_layer != NULL && slot_layer_is_filter(new_lower_layer)) {
return false;
}
}
// Currently groups can not be nested - thus valid positions for groups are:
if (slot_layer_is_group(raw)) {
// At the top
if (new_upper_layer == NULL) {
return true;
}
// NOT below its own children
if (slot_layer_get_containing_group(new_upper_layer) == raw) {
return false;
}
// At the bottom
if (new_lower_layer == NULL) {
return true;
}
// Above a group
if (slot_layer_is_group(new_lower_layer)) {
return true;
}
// Above a non-grouped layer
if (slot_layer_is_layer(new_lower_layer) && !slot_layer_is_in_group(new_lower_layer)) {
return true;
}
else {
return false;
}
}
return true;
}
void slot_layer_move(slot_layer_t *raw, i32 to) {
if (!slot_layer_can_move(raw, to)) {
return;
}
i32_map_t *pointers = tab_layers_init_layer_map();
i32 old_index = array_index_of(g_project->_->layers, raw);
i32 delta = to - old_index;
slot_layer_t *new_upper_layer =
delta > 0 ? (to < g_project->_->layers->length - 1 ? g_project->_->layers->buffer[to + 1] : NULL) : g_project->_->layers->buffer[to];
// Group or layer is collapsed so we check below and update the upper layer
if (new_upper_layer != NULL && !new_upper_layer->show_panel) {
slot_layer_t_array_t *children = slot_layer_get_recursive_children(new_upper_layer);
to -= children != NULL ? children->length : 0;
delta = to - old_index;
new_upper_layer = delta > 0 ? (to < g_project->_->layers->length - 1 ? g_project->_->layers->buffer[to + 1] : NULL) : g_project->_->layers->buffer[to];
}
context_set_layer(raw);
history_order_layers(to);
ui_base_hwnds->buffer[TAB_AREA_SIDEBAR0]->redraws = 2;
array_remove(g_project->_->layers, raw);
array_insert(g_project->_->layers, to, raw);
if (slot_layer_is_filter(raw)) {
// Precondition new_upper_layer != NULL, ensured in can_move
if (slot_layer_is_filter(new_upper_layer) || slot_layer_is_mask(new_upper_layer)) {
raw->parent = new_upper_layer->parent;
}
else if (slot_layer_is_layer(new_upper_layer) || slot_layer_is_group(new_upper_layer)) {
raw->parent = new_upper_layer;
}
}
else if (slot_layer_is_layer(raw)) {
slot_layer_t *old_parent = raw->parent;
if (new_upper_layer == NULL) {
raw->parent = NULL; // Placed on top
}
else if (slot_layer_is_in_group(new_upper_layer) && !slot_layer_get_containing_group(new_upper_layer)->show_panel) {
raw->parent = NULL; // Placed below a collapsed group
}
else if (slot_layer_is_filter(new_upper_layer)) {
raw->parent = new_upper_layer->parent->parent; // Placed below a filter, use the same level as the filter's parent
}
else if (slot_layer_is_layer(new_upper_layer)) {
raw->parent = new_upper_layer->parent; // Placed below a layer, use the same parent
}
else if (slot_layer_is_group(new_upper_layer)) {
raw->parent = new_upper_layer; // Placed as top layer in a group
}
else if (slot_layer_is_group_mask(new_upper_layer)) {
raw->parent = new_upper_layer->parent; // Placed in a group below the lowest group mask
}
else if (slot_layer_is_layer_mask(new_upper_layer)) {
raw->parent = slot_layer_get_containing_group(new_upper_layer); // Either the group the mask belongs to or NULL
}
// Layers can have masks as children
// These have to be moved, too
slot_layer_t_array_t *layer_masks = slot_layer_get_masks(raw, false);
if (layer_masks != NULL) {
for (i32 idx = 0; idx < layer_masks->length; ++idx) {
slot_layer_t *mask = layer_masks->buffer[idx];
array_remove(g_project->_->layers, mask);
// If the masks are moved down each step increases the index below the layer by one.
array_insert(g_project->_->layers, delta > 0 ? old_index + delta - 1 : old_index + delta + idx, mask);
}
}
// Layers can have filters as children
// These have to be moved, too
slot_layer_t_array_t *layer_filters = slot_layer_get_filters(raw, false);
if (layer_filters != NULL) {
i32 masks_count = layer_masks != NULL ? layer_masks->length : 0;
for (i32 idx = 0; idx < layer_filters->length; ++idx) {
slot_layer_t *filter = layer_filters->buffer[idx];
array_remove(g_project->_->layers, filter);
array_insert(g_project->_->layers, delta > 0 ? old_index + delta - 1 : old_index + delta + masks_count + idx, filter);
}
}
// The layer is the last layer in the group, remove it
// Notice that this might remove group masks
if (old_parent != NULL && slot_layer_get_children(old_parent) == NULL) {
slot_layer_delete(old_parent);
}
}
else if (slot_layer_is_mask(raw)) {
// Precondition new_upper_layer != NULL, ensured in can_move
if (slot_layer_is_filter(new_upper_layer) || slot_layer_is_mask(new_upper_layer)) {
raw->parent = new_upper_layer->parent;
}
else if (slot_layer_is_layer(new_upper_layer) || slot_layer_is_group(new_upper_layer)) {
raw->parent = new_upper_layer;
}
}
else if (slot_layer_is_group(raw)) {
slot_layer_t_array_t *children = slot_layer_get_recursive_children(raw);
if (children != NULL) {
for (i32 idx = 0; idx < children->length; ++idx) {
slot_layer_t *child = children->buffer[idx];
array_remove(g_project->_->layers, child);
// If the children are moved down each step increases the index below the layer by one
array_insert(g_project->_->layers, delta > 0 ? old_index + delta - 1 : old_index + delta + idx, child);
}
}
}
for (i32 i = 0; i < g_project->_->materials->length; ++i) {
slot_material_t *m = g_project->_->materials->buffer[i];
tab_layers_remap_layer_pointers(m->canvas->nodes, tab_layers_fill_layer_map(pointers));
}
}
Reference in New Issue View Git Blame Copy Permalink