SequenceCommands.cpp

Go to the documentation of this file.

#include "SequenceCommands.hpp"
 
#include <limits>
#include <type_traits>
#include <utility>
 
namespace monopoly::sequence
{
    MoveSequenceCommand makeMoveTheWorks(data::DataId dataId,
        std::uint16_t priority, SequenceTransform transform, bool wholeTree) noexcept
    { return {dataId, priority, std::move(transform), wholeTree}; }
 
    MoveSequenceCommand makeMoveXY(data::DataId dataId,
        std::uint16_t priority, std::int32_t x, std::int32_t y) noexcept
    { return makeMoveTheWorks(dataId, priority, moveXYTransform(x, y)); }
 
    MoveSequenceCommand makeMoveRySTxz(data::DataId dataId,
        std::uint16_t priority, float yaw, float scale,
        float x, float z) noexcept
    {
        return makeMoveTheWorks(dataId, priority,
            SequenceTransform(moveRySTxzTransform(yaw, scale, x, z)));
    }
 
    SequenceCommandQueue::SequenceCommandQueue(SequenceRuntime& runtime) noexcept
        : runtime_(runtime)
    {
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueueValidated(
        SequenceCommand command)
    {
        if (pending_.size() >= Capacity)
            return std::unexpected(CommandQueueError::QueueFull);
        pending_.push_back(std::move(command));
        return {};
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        StartSequenceCommand command)
    {
        if (!command.program || command.program->descriptions().empty())
            return std::unexpected(CommandQueueError::InvalidProgram);
        return enqueueValidated(std::move(command));
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        StopSequenceCommand command)
    {
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        MoveSequenceCommand command)
    {
        return enqueueValidated(std::move(command));
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetSequenceEndingActionCommand command)
    {
        if (command.action == 0 || command.action > 3)
            return std::unexpected(CommandQueueError::InvalidEndingAction);
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetSequenceVolumeCommand command)
    {
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetSequencePitchCommand command)
    {
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetSequencePanningCommand command)
    {
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        ForceRedrawSequenceCommand command)
    {
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetViewportCommand command)
    {
        if (command.renderSlot >= MonopolyRenderSlotCount)
            return std::unexpected(CommandQueueError::InvalidRenderSlot);
        return enqueueValidated(command);
    }
 
    std::expected<void, CommandQueueError> SequenceCommandQueue::enqueue(
        SetCameraCommand command)
    {
        // Monopoly's C_ArtLib.h sets CE_ARTLIB_RendMaxRenderSlots to five.
        // Preserve raw camera values here; the historical queue did not
        // validate vectors/FOV/planes before dispatching to the render slot.
        if (command.renderSlot >= MonopolyRenderSlotCount)
            return std::unexpected(CommandQueueError::InvalidRenderSlot);
        return enqueueValidated(command);
    }
 
    const SetViewportCommand* SequenceCommandQueue::viewportState(
        std::uint8_t renderSlot) const noexcept
    {
        if (renderSlot >= viewportStates_.size() || !viewportStates_[renderSlot])
            return nullptr;
        return &*viewportStates_[renderSlot];
    }
 
    const SetCameraCommand* SequenceCommandQueue::cameraState(
        std::uint8_t renderSlot) const noexcept
    {
        if (renderSlot >= cameraStates_.size() || !cameraStates_[renderSlot]) return nullptr;
        return &*cameraStates_[renderSlot];
    }
 
    std::expected<int, CommandQueueError> SequenceCommandQueue::collect()
    {
        if (nestingLevel_ == std::numeric_limits<int>::max())
            return std::unexpected(CommandQueueError::NestingOverflow);
        return ++nestingLevel_;
    }
 
    std::expected<int, CommandQueueError> SequenceCommandQueue::execute()
    {
        cycleEvents_.clear();
        cycleError_.reset();
        if (nestingLevel_ == std::numeric_limits<int>::min())
            return std::unexpected(CommandQueueError::NestingOverflow);
        --nestingLevel_;
        if (nestingLevel_ == 0 && !pending_.empty())
        {
            // LE_SEQNCR_ProcessUserCommands maps to DoUpdateCycle(0) in the
            // single-tasking Monopoly build. Preserve the current parent time.
            drain();
            const auto updated = runtime_.update(parentClock_);
            const auto events = runtime_.events();
            cycleEvents_.assign(events.begin(), events.end());
            cycleError_ = updated ? std::nullopt : std::optional<RuntimeError>(updated.error());
        }
        return nestingLevel_;
    }
 
    std::expected<void, RuntimeError>
    SequenceCommandQueue::processUserCommands()
    {
        // Monopoly is built with CE_ARTLIB_EnableMultitasking == 0, where
        // LE_SEQNCR_ProcessUserCommands() is LE_SEQNCR_DoUpdateCycle(0).
        // Preserve the modern absolute parent clock while forcing the queued
        // command cycle immediately.
        return updateCycle(parentClock_);
    }
 
    void SequenceCommandQueue::drain()
    {
        outcomes_.clear();
        while (nestingLevel_ <= 0 && !pending_.empty())
        {
            auto command = std::move(pending_.front());
            pending_.pop_front();
            std::visit([this](auto&& value)
            {
                using Command = std::remove_cvref_t<decltype(value)>;
                if constexpr (std::is_same_v<Command, StartSequenceCommand>)
                {
                    const auto result = runtime_.start(
                        std::move(value.program), value.priority, value.options,
                        std::move(value.initialTransform), value.labelOverride);
                    outcomes_.push_back(SequenceCommandOutcome{SequenceCommandKind::Start,
                        result ? std::optional<SequenceNodeId>(*result) : std::nullopt,
                        result ? 1U : 0U, result ? std::nullopt : std::optional<RuntimeError>(result.error())});
                }
                else if constexpr (std::is_same_v<Command, StopSequenceCommand>)
                {
                    const auto count = runtime_.stopMatching(
                        value.dataId, value.priority, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::Stop, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, MoveSequenceCommand>)
                {
                    const auto count = runtime_.moveMatching(
                        value.dataId, value.priority, value.transform, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::Move, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, SetSequenceEndingActionCommand>)
                {
                    const auto result = runtime_.setEndingActionMatching(
                        value.dataId, value.priority, value.action, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{SequenceCommandKind::SetEndingAction,
                        {}, result ? *result : 0U,
                        result ? std::nullopt : std::optional<RuntimeError>(result.error())});
                }
                else if constexpr (std::is_same_v<Command, SetSequenceVolumeCommand>)
                {
                    const auto count = runtime_.setVolumeMatching(
                        value.dataId, value.priority, value.volume, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::SetVolume, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, SetSequencePitchCommand>)
                {
                    const auto count = runtime_.setPitchMatching(
                        value.dataId, value.priority, value.pitch, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::SetPitch, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, SetSequencePanningCommand>)
                {
                    const auto count = runtime_.setPanningMatching(
                        value.dataId, value.priority, value.panning, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::SetPanning, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, ForceRedrawSequenceCommand>)
                {
                    const auto count = runtime_.forceRedrawMatching(
                        value.dataId, value.priority, value.wholeTree);
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::ForceRedraw, {}, count, {}});
                }
                else if constexpr (std::is_same_v<Command, SetViewportCommand>)
                {
                    viewportStates_[value.renderSlot] = value;
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::SetViewport, {}, 1U, {}});
                }
                else
                {
                    cameraStates_[value.renderSlot] = value;
                    outcomes_.push_back(SequenceCommandOutcome{
                        SequenceCommandKind::SetCamera, {}, 1U, {}});
                }
            }, std::move(command));
 
            if (!outcomes_.empty() &&
                outcomes_.back().kind != SequenceCommandKind::SetViewport &&
                outcomes_.back().kind != SequenceCommandKind::SetCamera &&
                !outcomes_.back().error)
            {
                const auto events = runtime_.events();
                outcomes_.back().events.assign(events.begin(), events.end());
            }
        }
    }
 
    std::expected<void, RuntimeError> SequenceCommandQueue::updateCycle(std::int32_t parentClock)
    {
        outcomes_.clear();
        cycleEvents_.clear();
        cycleError_.reset();
        parentClock_ = parentClock;
        if (nestingLevel_ <= 0) drain();
        auto updated = runtime_.update(parentClock);
        const auto events = runtime_.events();
        cycleEvents_.assign(events.begin(), events.end());
        if (!updated) cycleError_ = updated.error();
        return updated;
    }
 
    int SequenceCommandQueue::percentageFull() const noexcept
    {
        return static_cast<int>((100U * pending_.size()) / Capacity);
    }
}