297 lines
14 KiB
C++
297 lines
14 KiB
C++
#include "Gameplay.hpp"
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <chrono>
|
|
#include <faset/core/io.hpp>
|
|
#include <faset/player/SceneView.hpp>
|
|
#include <faset/runtime/Runtime.hpp>
|
|
#include <filesystem>
|
|
#include <iostream>
|
|
#include <set>
|
|
#include <stdexcept>
|
|
#if defined(_WIN32)
|
|
#define NOMINMAX
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
namespace {
|
|
std::filesystem::path executableDirectory(const char* argument) {
|
|
#if defined(_WIN32)
|
|
std::wstring path(32768, L'\0');
|
|
const auto length = GetModuleFileNameW(nullptr, path.data(), static_cast<DWORD>(path.size()));
|
|
if (length == 0 || length >= path.size())
|
|
throw std::runtime_error("Cannot locate Player executable");
|
|
path.resize(length);
|
|
return std::filesystem::path(path).parent_path();
|
|
#else
|
|
std::error_code error;
|
|
auto executable = std::filesystem::read_symlink("/proc/self/exe", error);
|
|
return error ? std::filesystem::absolute(argument).parent_path() : executable.parent_path();
|
|
#endif
|
|
}
|
|
std::uint64_t count(const std::string& value) {
|
|
if (value.empty() || value.find_first_not_of("0123456789") != std::string::npos)
|
|
throw std::invalid_argument("Frame count must be a positive integer");
|
|
auto result = std::stoull(value);
|
|
if (result == 0 || result > 10000000)
|
|
throw std::invalid_argument("Frame count out of range");
|
|
return result;
|
|
}
|
|
faset::runtime::RuntimeConfig simulationConfig(const nlohmann::json& scene) {
|
|
faset::runtime::RuntimeConfig config;
|
|
if (!scene.contains("simulation"))
|
|
return config;
|
|
const auto& settings = scene.at("simulation");
|
|
if (!settings.is_object())
|
|
throw std::invalid_argument("simulation must be an object");
|
|
config.fixedDelta = settings.value("fixed_delta", config.fixedDelta);
|
|
auto boundedInteger = [&](const char* key, int fallback, int maximum) {
|
|
if (!settings.contains(key))
|
|
return fallback;
|
|
const auto& value = settings.at(key);
|
|
if (!value.is_number_integer())
|
|
throw std::invalid_argument(std::string(key) + " must be an integer");
|
|
// Check before narrowing, so very large unsigned values cannot wrap into
|
|
// a valid configuration on a platform with a narrower unsigned type.
|
|
const auto numeric = value.get<double>();
|
|
if (numeric < 1 || numeric > maximum)
|
|
throw std::invalid_argument(std::string(key) + " is out of range");
|
|
return value.get<int>();
|
|
};
|
|
config.maxCatchUpTicks = static_cast<unsigned>(
|
|
boundedInteger("max_catch_up_ticks", static_cast<int>(config.maxCatchUpTicks), 1024));
|
|
config.physicsSubsteps = boundedInteger("physics_substeps", config.physicsSubsteps, 128);
|
|
if (settings.contains("gravity")) {
|
|
const auto& gravity = settings.at("gravity");
|
|
if (!gravity.is_array() || gravity.size() != 3)
|
|
throw std::invalid_argument("gravity must contain three numbers");
|
|
config.gravity = gravity.get<faset::runtime::Vec3>();
|
|
}
|
|
return config;
|
|
}
|
|
void validatePackagedShaders(const std::filesystem::path& directory) {
|
|
for (const auto* name : {"vertexMain.spv", "fragmentMain.spv", "shadowMain.spv"}) {
|
|
const auto path = directory / "shaders" / name;
|
|
if (!std::filesystem::is_regular_file(path))
|
|
throw std::runtime_error("Packaged shader is missing: " + path.string());
|
|
const auto bytes = faset::read_text(path);
|
|
if (bytes.size() < 20 || bytes.size() % 4 != 0 ||
|
|
static_cast<unsigned char>(bytes[0]) != 0x03 ||
|
|
static_cast<unsigned char>(bytes[1]) != 0x02 ||
|
|
static_cast<unsigned char>(bytes[2]) != 0x23 ||
|
|
static_cast<unsigned char>(bytes[3]) != 0x07)
|
|
throw std::runtime_error("Packaged shader is not a SPIR-V module: " + path.string());
|
|
}
|
|
}
|
|
} // namespace
|
|
int main(int argc, char** argv) {
|
|
try {
|
|
std::filesystem::path scenePath, assetsPath, capturePath, controlPath;
|
|
bool headless = false, validateOnly = false;
|
|
std::uint64_t maximumFrames = 0;
|
|
std::set<std::string> options;
|
|
for (int i = 1; i < argc; ++i) {
|
|
const std::string arg = argv[i];
|
|
if (arg == "--help") {
|
|
std::cout << "faset_player [--scene PATH] [--assets CACHE] [--frames N] "
|
|
"[--headless] [--capture PATH.ppm] [--validate] [--control PATH]\n"
|
|
"No --scene: open scene.fscene beside the executable. CACHE contains "
|
|
"assets/<id>/.\n"
|
|
"Headless uses offscreen Vulkan; --frames uses the configured fixed "
|
|
"simulation delta.\n"
|
|
"--validate checks scene/resources on CPU without gameplay callbacks "
|
|
"or Vulkan initialization.\n"
|
|
"--control is an optional editor mailbox for pause/resume/step/stop, "
|
|
"without world queries.\n"
|
|
"Keys: A/D horizontal, W/S vertical, Space jump, E interact, P pause, "
|
|
"N single-step, Escape quit.\n";
|
|
return 0;
|
|
}
|
|
if (!options.insert(arg).second)
|
|
throw std::invalid_argument("Repeated option: " + arg);
|
|
auto value = [&]() -> std::string {
|
|
if (i + 1 >= argc)
|
|
throw std::invalid_argument("Missing value for " + arg);
|
|
return argv[++i];
|
|
};
|
|
if (arg == "--scene")
|
|
scenePath = value();
|
|
else if (arg == "--assets")
|
|
assetsPath = value();
|
|
else if (arg == "--capture")
|
|
capturePath = value();
|
|
else if (arg == "--control")
|
|
controlPath = value();
|
|
else if (arg == "--frames")
|
|
maximumFrames = count(value());
|
|
else if (arg == "--headless")
|
|
headless = true;
|
|
else if (arg == "--validate")
|
|
validateOnly = true;
|
|
else
|
|
throw std::invalid_argument("Unknown option: " + arg);
|
|
}
|
|
if (scenePath.empty())
|
|
scenePath = executableDirectory(argv[0]) / "scene.fscene";
|
|
scenePath = std::filesystem::absolute(scenePath).lexically_normal();
|
|
if (assetsPath.empty())
|
|
assetsPath = scenePath.parent_path();
|
|
if (!std::filesystem::is_directory(assetsPath))
|
|
throw std::invalid_argument("Asset cache directory does not exist: " +
|
|
assetsPath.string());
|
|
if (headless && maximumFrames == 0)
|
|
maximumFrames = 1;
|
|
const auto document = faset::player::readScene(scenePath);
|
|
const auto config = simulationConfig(document);
|
|
const auto executableRoot = executableDirectory(argv[0]);
|
|
if (scenePath.extension() == ".fscene" &&
|
|
std::filesystem::equivalent(scenePath.parent_path(), executableRoot))
|
|
validatePackagedShaders(executableRoot);
|
|
if (validateOnly) {
|
|
if (!capturePath.empty() || !controlPath.empty())
|
|
throw std::invalid_argument("--validate cannot capture or control a running game");
|
|
faset::runtime::Runtime validator(config);
|
|
validator.load(document);
|
|
faset::player::SceneView view(assetsPath);
|
|
view.build(document, 16.0f / 9.0f);
|
|
for (const auto& diagnostic : view.diagnostics()) {
|
|
if (diagnostic.starts_with("error:"))
|
|
throw std::runtime_error(diagnostic);
|
|
std::cerr << diagnostic << '\n';
|
|
}
|
|
std::cout << nlohmann::json{{"validated", true},
|
|
{"dimension", document.value("dimension", 3)}}
|
|
.dump()
|
|
<< '\n';
|
|
return 0;
|
|
}
|
|
faset::runtime::Runtime world(config);
|
|
faset::gameplay::registerGameplay(world);
|
|
world.load(document);
|
|
faset::player::SceneView view(assetsPath);
|
|
faset::render::Renderer renderer(
|
|
{1280, 720, document.value("name", std::string("Faset Player")), headless, true});
|
|
std::set<std::string> held;
|
|
bool stop = false;
|
|
std::uint64_t frames = 0;
|
|
std::size_t logCursor = 0;
|
|
std::set<std::string> reported;
|
|
std::uint64_t controlSequence = 0;
|
|
std::string previousControl;
|
|
auto previous = std::chrono::steady_clock::now();
|
|
while (!stop && !renderer.should_close() &&
|
|
(maximumFrames == 0 || frames < maximumFrames)) {
|
|
faset::runtime::InputState input;
|
|
bool singleStep = false;
|
|
if (!controlPath.empty() && std::filesystem::is_regular_file(controlPath)) {
|
|
try {
|
|
if (std::filesystem::file_size(controlPath) > 65536)
|
|
throw std::runtime_error("control message exceeds 64 KiB");
|
|
auto content = faset::read_text(controlPath);
|
|
if (content != previousControl) {
|
|
previousControl = content;
|
|
const auto message = nlohmann::json::parse(content);
|
|
const auto& sequence = message.at("sequence");
|
|
if (!(sequence.is_number_unsigned() ||
|
|
(sequence.is_number_integer() && sequence.get<std::int64_t>() >= 0)))
|
|
throw std::invalid_argument(
|
|
"control sequence must be a nonnegative integer");
|
|
const auto value = sequence.get<std::uint64_t>();
|
|
if (value > controlSequence) {
|
|
const auto command = message.at("command").get<std::string>();
|
|
if (command == "pause")
|
|
world.setPaused(true);
|
|
else if (command == "resume")
|
|
world.setPaused(false);
|
|
else if (command == "step") {
|
|
world.setPaused(true);
|
|
singleStep = true;
|
|
} else if (command == "stop")
|
|
stop = true;
|
|
else
|
|
throw std::invalid_argument("unsupported control command");
|
|
controlSequence = value;
|
|
}
|
|
}
|
|
} catch (const std::exception& error) {
|
|
const std::string message =
|
|
std::string("Player control ignored: ") + error.what();
|
|
if (reported.insert(message).second)
|
|
std::cerr << message << '\n';
|
|
}
|
|
}
|
|
for (const auto& event : renderer.poll_events()) {
|
|
using Type = faset::render::Event::Type;
|
|
if (event.type == Type::Quit)
|
|
stop = true;
|
|
if (event.type == Type::FocusLost)
|
|
held.clear();
|
|
std::string key = event.key;
|
|
std::transform(key.begin(), key.end(), key.begin(),
|
|
[](unsigned char c) { return static_cast<char>(std::toupper(c)); });
|
|
if (event.type == Type::KeyUp)
|
|
held.erase(key);
|
|
if (event.type == Type::KeyDown) {
|
|
held.insert(key);
|
|
if (key == "ESCAPE")
|
|
stop = true;
|
|
if (!event.repeat) {
|
|
if (key == "SPACE")
|
|
input.jumpPressed = true;
|
|
if (key == "E")
|
|
input.interactPressed = true;
|
|
if (key == "P")
|
|
world.setPaused(!world.paused());
|
|
if (key == "N")
|
|
singleStep = true;
|
|
}
|
|
}
|
|
}
|
|
if (stop)
|
|
break;
|
|
input.horizontal = float(held.contains("D") || held.contains("RIGHT")) -
|
|
float(held.contains("A") || held.contains("LEFT"));
|
|
input.vertical = float(held.contains("W") || held.contains("UP")) -
|
|
float(held.contains("S") || held.contains("DOWN"));
|
|
const auto now = std::chrono::steady_clock::now();
|
|
const double elapsed = maximumFrames
|
|
? config.fixedDelta
|
|
: std::chrono::duration<double>(now - previous).count();
|
|
previous = now;
|
|
if (singleStep && world.paused())
|
|
world.singleStep(input);
|
|
else
|
|
world.advance(elapsed, input);
|
|
auto snapshot = view.build(world.snapshotJson(), static_cast<float>(renderer.width()) /
|
|
std::max(1u, renderer.height()));
|
|
for (const auto& diagnostic : view.diagnostics()) {
|
|
if (diagnostic.starts_with("error:"))
|
|
throw std::runtime_error(diagnostic);
|
|
if (reported.insert(diagnostic).second)
|
|
std::cerr << diagnostic << '\n';
|
|
}
|
|
while (logCursor < world.diagnostics().size())
|
|
std::cerr << world.diagnostics()[logCursor++] << '\n';
|
|
renderer.render(snapshot);
|
|
++frames;
|
|
}
|
|
if (!capturePath.empty()) {
|
|
if (frames == 0)
|
|
throw std::runtime_error("No frame was rendered for capture");
|
|
renderer.capture(capturePath);
|
|
}
|
|
const auto stats = renderer.stats();
|
|
std::cout << nlohmann::json{{"frames", frames},
|
|
{"ticks", world.snapshot().tick},
|
|
{"dimension", document.value("dimension", 3)},
|
|
{"device", stats.device},
|
|
{"validation_errors", stats.validation_errors}}
|
|
.dump()
|
|
<< '\n';
|
|
return stats.validation_errors == 0 ? 0 : 2;
|
|
} catch (const std::exception& error) {
|
|
std::cerr << "Player failed: " << error.what() << '\n';
|
|
return 1;
|
|
}
|
|
}
|