control_standalone_host.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/format/standalone_control_host.hpp>
#include <pulp/inspect/control_host_development_executor.hpp>
#include <pulp/inspect/control_sample_region_target.hpp>
#include <pulp/inspect/control_timeline_document_session_executor.hpp>
#include <pulp/state/sequencer_state_channel.hpp>
 
#include <cstdint>
#include <filesystem>
#include <functional>
#include <memory>
#include <string_view>
 
namespace pulp::host {
class SignalGraphControlAuthority;
}
 
namespace pulp::inspect {
 
class RuntimeEvaluator;
enum class ControlTelemetrySensitivity : std::uint8_t;
 
} // namespace pulp::inspect
 
namespace pulp::view::motion {
struct RenderCostSnapshot;
}
 
namespace pulp::format {
class ViewBridge;
}
 
namespace pulp::playback {
class MasterTransport;
}
 
namespace pulp::inspect {

std::unique_ptr<format::StandaloneControlHost> make_control_standalone_host();
 
namespace detail {
 
struct StandaloneControlAuthorHooks {
    std::function<ControlTelemetrySensitivity(std::string_view)> telemetry_classifier;
    std::function<view::motion::RenderCostSnapshot()> motion_cost_probe;
    std::filesystem::path motion_fixture_path;
    std::function<std::vector<ControlDiagnosticItem>()> diagnostics;
    std::function<ControlAuthoringApplyResult(const ControlAuthoringChanges&)> apply_authoring;
    std::function<playback::MasterTransport*()> sequencer_transport;
};
 
using StandaloneControlAuthorHooksFactory = StandaloneControlAuthorHooks (*)(format::Processor&);

bool install_standalone_control_author_hooks_factory(
    StandaloneControlAuthorHooksFactory factory) noexcept;
StandaloneControlAuthorHooks create_standalone_control_author_hooks(format::Processor& processor);
 
using StandaloneRuntimeEvaluatorFactory =
    std::shared_ptr<RuntimeEvaluator> (*)(format::Processor&, format::ViewBridge&);
 
using StandaloneSequencerStateChannelFactory =
    std::shared_ptr<state::SequencerStateChannel> (*)(format::Processor&);

bool install_standalone_sequencer_state_channel_factory(
    StandaloneSequencerStateChannelFactory factory) noexcept;
std::shared_ptr<state::SequencerStateChannel>
create_standalone_sequencer_state_channel(format::Processor& processor);

bool install_standalone_runtime_evaluator_factory(
    StandaloneRuntimeEvaluatorFactory factory) noexcept;
std::shared_ptr<RuntimeEvaluator> create_standalone_runtime_evaluator(format::Processor& processor,
                                                                      format::ViewBridge& bridge);
 
using StandaloneTimelineDocumentSessionFactory =
    std::optional<ControlTimelineDocumentSessionSource> (*)(const ControlAdmissionPlan&);

bool install_standalone_timeline_document_session_factory(
    StandaloneTimelineDocumentSessionFactory factory) noexcept;
std::optional<ControlTimelineDocumentSessionSource>
create_standalone_timeline_document_session_source(const ControlAdmissionPlan& plan);

using StandaloneSignalGraphAuthorityFactory =
    pulp::host::SignalGraphControlAuthority* (*)(format::Processor&);
bool install_standalone_signal_graph_authority_factory(
    StandaloneSignalGraphAuthorityFactory factory) noexcept;
pulp::host::SignalGraphControlAuthority*
create_standalone_signal_graph_authority(format::Processor& processor);

using StandaloneSampleRegionTargetFactory = std::shared_ptr<ControlSampleRegionTarget> (*)(
    format::Processor&, state::StateStore&, ControlSampleRegionGeneration&);
bool install_standalone_sample_region_target_factory(
    StandaloneSampleRegionTargetFactory factory) noexcept;
std::shared_ptr<ControlSampleRegionTarget>
create_standalone_sample_region_target(format::Processor& processor, state::StateStore& store,
                                       ControlSampleRegionGeneration& generation);
 
} // namespace detail
 
} // namespace pulp::inspect