tileshadow/canvasstack.cpp at master · DanielSabo/tileshadow · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include "canvasstack.h"
#include "canvaslayer.h"
#include "canvastile.h"

CanvasStack::CanvasStack()
{
    std::unique_ptr<CanvasTile> newBackground(new CanvasTile());
    newBackground->fill(1.0f, 1.0f, 1.0f, 1.0f);

    setBackground(std::move(newBackground));
}

CanvasStack::~CanvasStack()
{
    clearLayers();
}

void CanvasStack::clearLayers()
{
    for (CanvasLayer *layer: layers)
        delete layer;
    layers.clear();
}

namespace {
/* If filterErase is true convert erasing modes to BlendMode::Normal, otherwise return mode. */
BlendMode::Mode filterEraseModes(BlendMode::Mode mode, bool filterErase)
{
    if (filterErase)
    {
        if (mode == BlendMode::DestinationIn)
            return BlendMode::Over;
        if (mode == BlendMode::DestinationOut)
            return BlendMode::Over;
        if (mode == BlendMode::SourceAtop)
            return BlendMode::Over;
        if (mode == BlendMode::DestinationAtop)
            return BlendMode::Over;
    }
    return mode;
}

std::unique_ptr<CanvasTile> renderList(QList<CanvasLayer *> const &children, int x, int y, CanvasTile *background)
{
    std::unique_ptr<CanvasTile> result(nullptr);

    for (CanvasLayer *layer: children)
    {
        std::unique_ptr<CanvasTile> childRender = nullptr;
        CanvasTile *auxTile = nullptr;

        if (layer->visible && layer->opacity > 0.0f)
        {
            if (layer->type == LayerType::Layer ||
                (layer->type == LayerType::Group && !layer->tiles->empty()))
            {
                auxTile = layer->getTileMaybe(x, y);
            }
            else if (layer->type == LayerType::Group)
            {
                childRender = renderList(layer->children, x, y, nullptr);
                auxTile = childRender.get();
            }
        }

        if (auxTile)
        {
            if (!result)
            {
                if (background)
                {
                    result = background->copy();
                }
                else
                {
                    result.reset(new CanvasTile());
                    result->fill(0, 0, 0, 0);
                }
            }
            BlendMode::Mode mode = filterEraseModes(layer->mode, background);
            auxTile->blendOnto(result.get(), mode, layer->opacity);
        }
        else
        {
            // !background here is standing in for filterEraseModes
            if (!background &&
                layer->visible &&
                BlendMode::isMasking(layer->mode))
                result.reset();
        }
    }

    return result;
}
}

std::unique_ptr<CanvasTile> renderList(QList<CanvasLayer *> const &children, int x, int y)
{
    return renderList(children, x, y, nullptr);
}

std::unique_ptr<CanvasTile> CanvasStack::getTileMaybe(int x, int y) const
{
    return renderList(layers, x, y, backgroundTileCL.get());
}

TileSet CanvasStack::getTileSet() const
{
    TileSet result;

    for (CanvasLayer *layer: layers)
    {
        TileSet layerSet = layer->getTileSet();
        result.insert(layerSet.begin(), layerSet.end());
    }

    return result;
}

void CanvasStack::setBackground(std::unique_ptr<CanvasTile> newBackground)
{
    backgroundTileCL = newBackground->copy();
    backgroundTileCL->unmapHost();
    backgroundTile = std::move(newBackground);
}