StylizeRuntime.cpp

浏览该文件的文档.

#include "stylize/editing/StylizeTarget.h"
 
#include "common/Exception.h"
#include "graphics/Canvas.h"
#include "graphics/Graphics.h"
#include "stylize/StyleInstance.h"
#include "stylize/StylePass.h"
#include "stylize/StyleRecipe.h"
 
#include <utility>
 
namespace eve::stylize_editing {
namespace {}  // namespace
 
StylizeRecipeRuntime::StylizeRecipeRuntime()  = default;
StylizeRecipeRuntime::~StylizeRecipeRuntime() = default;
 
Result<void> StylizeRecipeRuntime::publish(const StylizeRecipeTarget& document, graphics::Graphics* graphics) {
    if (!graphics)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.graphics"),
                                          "Stylize publication requires Graphics");
    const auto diagnostics = document.validate();
    for (const auto& d : diagnostics)
        if (d.severity() == DiagnosticSeverity::Error)
            return Result<void>::failure(eve::Status(EditorStatus::Rejected, diagnostics));
    std::vector<std::unique_ptr<stylize::StyleInstance>> instances;
    auto                                                 recipe = std::make_unique<stylize::StyleRecipe>();
    try {
        for (const auto& pass : document.passes()) {
            if (!pass.enabled) continue;
            auto instance = std::make_unique<stylize::StyleInstance>(pass.style);
            instance->setPriority(pass.priority);
            for (const auto& [name, value] : pass.overrides) instance->setFloat(name, static_cast<float>(value));
            recipe->add(instance.get());
            instances.push_back(std::move(instance));
        }
        if (!instances.empty()) recipe->compile(graphics);
    } catch (const std::exception& exception) {
        return eve::editing::failed<void>(EditorStatus::Failed, RuleId("editor.stylize.compile"), exception.what());
    }
    instances_                         = std::move(instances);
    recipe_                            = std::move(recipe);
    graphics_                          = graphics;
    revision_                          = document.revision();
    return eve::editing::applied<void>(diagnostics);
}
Result<void> StylizeRecipeRuntime::apply(graphics::Graphics* graphics, graphics::Texture* source,
                                               graphics::Canvas* destination, Revision expectedRevision) const {
    if (expectedRevision != revision_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.stylize.stale"),
                                          "Stylize runtime generation is stale");
    if (!graphics || !source || !destination || graphics != graphics_ || revision_ == 0)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.runtime"),
                                          "Stylize runtime requires its compiled Graphics, source and destination");
    try {
        if (instances_.empty()) {
            auto* previous = graphics->getCanvas();
            graphics->setCanvas(destination);
            graphics->drawTexturedRect(source, 0, 0, static_cast<float>(destination->getWidth()),
                                       static_cast<float>(destination->getHeight()), graphics::Color(1, 1, 1, 1));
            graphics->setCanvas(previous);
        } else
            recipe_->apply(graphics, source, destination);
    } catch (const std::exception& exception) {
        return eve::editing::failed<void>(EditorStatus::Failed, RuleId("editor.stylize.apply"), exception.what());
    }
    return eve::editing::applied<void>();
}
 
}  // namespace eve::stylize_editing