src/shapes/shape.cpp

#include "rive/hittest_command_path.hpp"
#include "rive/shapes/path.hpp"
#include "rive/shapes/shape.hpp"
#include "rive/shapes/clipping_shape.hpp"
#include "rive/shapes/paint/blend_mode.hpp"
#include "rive/shapes/paint/shape_paint.hpp"
#include "rive/shapes/path_composer.hpp"
#include <algorithm>

using namespace rive;

Shape::Shape() : m_PathComposer(this) {}

void Shape::addPath(Path* path) {
    // Make sure the path is not already in the shape.
    assert(std::find(m_Paths.begin(), m_Paths.end(), path) == m_Paths.end());
    m_Paths.push_back(path);
}

void Shape::update(ComponentDirt value) {
    Super::update(value);

    if (hasDirt(value, ComponentDirt::RenderOpacity)) {
        for (auto shapePaint : m_ShapePaints) {
            shapePaint->renderOpacity(renderOpacity());
        }
    }
}

void Shape::pathChanged() {
    m_PathComposer.addDirt(ComponentDirt::Path, true);
    invalidateStrokeEffects();
}

void Shape::draw(Renderer* renderer) {
    if (renderOpacity() == 0.0f) {
        return;
    }
    auto shouldRestore = clip(renderer);

    for (auto shapePaint : m_ShapePaints) {
        if (!shapePaint->isVisible()) {
            continue;
        }
        renderer->save();
        bool paintsInLocal = (shapePaint->pathSpace() & PathSpace::Local) == PathSpace::Local;
        if (paintsInLocal) {
            renderer->transform(worldTransform());
        }
        shapePaint->draw(renderer,
                         paintsInLocal ? m_PathComposer.localPath() : m_PathComposer.worldPath());
        renderer->restore();
    }

    if (shouldRestore) {
        renderer->restore();
    }
}

bool Shape::hitTest(const IAABB& area) const {
    HitTestCommandPath tester(area);

    for (auto path : m_Paths) {
        tester.setXform(path->pathTransform());
        path->buildPath(tester);
    }
    return tester.wasHit();
}

Core* Shape::hitTest(HitInfo* hinfo, const Mat2D& xform) {
    if (renderOpacity() == 0.0f) {
        return nullptr;
    }

    // TODO: clip:

    const bool shapeIsLocal = (pathSpace() & PathSpace::Local) == PathSpace::Local;

    for (auto rit = m_ShapePaints.rbegin(); rit != m_ShapePaints.rend(); ++rit) {
        auto shapePaint = *rit;
        if (shapePaint->isTranslucent()) {
            continue;
        }
        if (!shapePaint->isVisible()) {
            continue;
        }

        auto paintIsLocal = (shapePaint->pathSpace() & PathSpace::Local) == PathSpace::Local;

        auto mx = xform;
        if (paintIsLocal) {
            mx *= worldTransform();
        }

        HitTestCommandPath tester(hinfo->area);

        for (auto path : m_Paths) {
            if (shapeIsLocal) {
                tester.setXform(xform * path->pathTransform());
            } else {
                tester.setXform(mx * path->pathTransform());
            }
            path->buildPath(tester);
        }
        if (tester.wasHit()) {
            return this;
        }
    }
    return nullptr;
}

void Shape::buildDependencies() {
    // Make sure to propagate the call to PathComposer as it's no longer part of
    // Core and owned only by the Shape.
    m_PathComposer.buildDependencies();

    Super::buildDependencies();

    // Set the blend mode on all the shape paints. If we ever animate this
    // property, we'll need to update it in the update cycle/mark dirty when the
    // blend mode changes.
    for (auto paint : m_ShapePaints) {
        paint->blendMode(blendMode());
    }
}

void Shape::addDefaultPathSpace(PathSpace space) { m_DefaultPathSpace |= space; }

StatusCode Shape::onAddedDirty(CoreContext* context) {
    auto code = Super::onAddedDirty(context);
    if (code != StatusCode::Ok) {
        return code;
    }
    // This ensures context propagates to path composer too.
    return m_PathComposer.onAddedDirty(context);
}