mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-18 11:29:20 +02:00
100 lines
2.6 KiB
C++
100 lines
2.6 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "vehicle/graph/graph_block.h"
|
|
#include "vehicle/graph/graph_body.h"
|
|
#include "vehicle/graph/graph_lua.h"
|
|
#include "vehicle/graph/graph_template.h"
|
|
|
|
#include <memory>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
namespace vgraph
|
|
{
|
|
|
|
// simulation state of the graph of a single vehicle
|
|
class graph_instance
|
|
{
|
|
public:
|
|
explicit graph_instance(std::shared_ptr<graph_template const> Template);
|
|
~graph_instance();
|
|
|
|
// advances the graph by the specified time. the order of evaluation is fixed, and there's no other source
|
|
// of time or randomness, so the same inputs always produce the same results
|
|
void update(double Deltatime);
|
|
|
|
graph_template const &definition() const
|
|
{
|
|
return *m_template;
|
|
}
|
|
double time() const
|
|
{
|
|
return m_time;
|
|
}
|
|
// state of the vehicle body shared with the blocks; filled by the owner of the graph before every step
|
|
body_state &body()
|
|
{
|
|
return m_body;
|
|
}
|
|
body_state const &body() const
|
|
{
|
|
return m_body;
|
|
}
|
|
|
|
// block of the node with the specified index (see graph_template::nodes())
|
|
block &node_block(std::size_t Index)
|
|
{
|
|
return *m_blocks[Index];
|
|
}
|
|
block const &node_block(std::size_t Index) const
|
|
{
|
|
return *m_blocks[Index];
|
|
}
|
|
// block of the node with the specified id, or null
|
|
block *find_block(std::string_view Id);
|
|
|
|
double signal(int Slot) const
|
|
{
|
|
return m_signals[Slot];
|
|
}
|
|
link_state const &link(int Index) const
|
|
{
|
|
return m_links[Index];
|
|
}
|
|
// keeps the slot at the specified value regardless of what its block writes, until released
|
|
void force(int Slot, double Value);
|
|
void release(int Slot);
|
|
bool is_forced(int Slot) const
|
|
{
|
|
return m_forced[Slot] != 0;
|
|
}
|
|
|
|
private:
|
|
frame make_frame(double Deltatime);
|
|
|
|
std::shared_ptr<graph_template const> m_template;
|
|
// lua state of the vehicle, created when the graph has lua blocks. declared before the blocks, so it outlives them
|
|
std::unique_ptr<lua_host> m_lua;
|
|
std::vector<std::unique_ptr<block>> m_blocks; // in the order of the template's nodes
|
|
std::vector<block *> m_order; // blocks in the order of evaluation
|
|
std::vector<block *> m_late; // blocks updated again after all the others
|
|
std::vector<block *> m_deferred; // blocks publishing their outputs after the step
|
|
std::vector<double> m_signals;
|
|
std::vector<std::uint8_t> m_forced;
|
|
std::vector<link_state> m_links;
|
|
body_state m_body;
|
|
double m_time{0.0};
|
|
std::uint64_t m_step{0};
|
|
};
|
|
|
|
} // namespace vgraph
|