}

const std::shared_ptr<Train> train = world.create<Train>(l3, 800000);

for (int N = 0; N < 6; N++) {

train->create<RailVehicle>(b47);

}

train->orders.create<FreeRoam>(&train->orders);

train->currentActivity = train->orders.current()->createActivity();

std::uniform_int_distribution<int> treeVariantDistribution {1, 4};

for (auto x = 311000000; x < 311830000; x += 5000) {

for (auto y = 491100000; y < 491130000; y += 5000) {

Location {terrain->positionAt({{x + positionOffsetDistribution(randomdev),

y + positionOffsetDistribution(randomdev)}}),

{0, rotationDistribution(randomdev), 0}});

mainLoop();

return 0;

}

};

#include "factoryMesh.h"

#include "persistence.h"

#include <stdTypeDefs.h>

class TextureAtlas;

class Asset : public Persistence::Persistable, public StdTypeDefs<Asset> {

public:

using TexturePtr = std::shared_ptr<TextureAtlas>;

std::string id;

#include "filesystem.h"

#include "gfx/image.h"

#include "gfx/models/texture.h"

#include "object.h"

#include "plane.h"

#include "saxParse-persistence.h"

AssetFactory::persist(Persistence::PersistenceStore & store)

{

using MapObjects = Persistence::MapByMember<Shapes, std::shared_ptr<Object>>;

using MapTextureFragments = Persistence::MapByMember<TextureFragments>;

using MapAssImp = Persistence::MapByMember<AssImps, std::shared_ptr<AssImp>, &AssImp::path>;

return STORE_TYPE && STORE_NAME_HELPER("object", shapes, MapObjects)

class AssetFactory : public Persistence::Persistable {

public:

using Shapes = std::map<std::string, Shape::Ptr, std::less<>>;

using AssImps = std::map<std::string, AssImp::Ptr, std::less<>>;

using TextureFragments = std::map<std::string, TextureFragment::Ptr, std::less<>>;

using Colour = RGB;

class WorldObject;

class Terrain;

class Environment;

class GameState {

public:

NO_MOVE(GameState);

NO_COPY(GameState);

std::shared_ptr<Terrain> terrain;

std::shared_ptr<Environment> environment;

AssetFactory::Assets assets;

protected:

using Network::Network;

void joinLinks(const Link::Ptr &) const;

protected:

void

NetworkOf<T, Links...>::joinLinks(const Link::Ptr & l) const

{

Network::joinLinks(l, ol);

}

}

NetworkOf<T, Links...>::intersectRayLinks(const Ray<GlobalPosition3D> & ray) const

{

// Click link

[&ray](const std::shared_ptr<T> & link) {

return link->intersectRay(ray);

});

return *link;

}

return {};

float

NetworkOf<T, Links...>::findNodeDirection(Node::AnyCPtr n) const

{

for (const auto & e : l->ends) {

// cppcheck-suppress useStlAlgorithm

if (e.node.get() == n.get()) {

void

RailLinks::render(const SceneShader & shader, const Frustum &) const

{

texture->bind();

glEnable(GL_POLYGON_OFFSET_FILL);

glPolygonOffset(-1, 0);

const Surface *

RailLinks::getBaseSurface() const

{

}

RelativeDistance

class Objective;

public:

[[nodiscard]] Objective * current() const;

Objective * next();

class ShadowMapper;

template<typename> class Ray;

public:

explicit Train(const Link::CPtr & link, float linkDist = 0) : Vehicle {link, linkDist} { }

void generateMeshes();

std::shared_ptr<GeoData> geoData;

Texture::Ptr water;

};

shadowStenciller.setLightDirection(dir);

for (const auto & [id, asset] : gameState->assets) {

r->updateStencil(shadowStenciller);

}

}

#include <algorithm>

#include <functional>

#include <memory>

#include <type_traits>

#include <vector>

public:

virtual ~Collection() = default;

using Objects = std::vector<Ptr>;

template<typename T = Object, typename... Params>

auto

create(Params &&... params)

requires std::is_base_of_v<Object, T>

{

auto obj = std::make_shared<T>(std::forward<Params>(params)...);

objects.emplace_back(obj);

return obj;

}

else {

}

}

T *

find()

{

}

return nullptr;

}

auto

apply(const auto & m, Params &&... params) const

{

}

template<typename T = Object, typename... Params>

auto

rapply(const auto & m, Params &&... params) const

{

}

template<typename T = Object, typename... Params>

auto

applyOne(const auto & m, Params &&... params) const

{

}

template<typename T = Object, typename... Params>

auto

rapplyOne(const auto & m, Params &&... params) const

{

}

auto

removeAll()

{

}

end() const

{

return objects.end();

}

rend() const

{

return objects.rend();

}

protected:

template<typename T = Object, typename... Params>

auto

apply_internal(const auto begin, const auto end, const auto & m, Params &&... params) const

{

}

template<typename T = Object, typename... Params>

auto

applyOne_internal(const auto begin, const auto end, const auto & m, Params &&... params) const

{

}

};

<*>. {

LexerError("Unexpected input");

}

#pragma once

#include <charconv>

#include <format>

#include <functional>

}

[[nodiscard]] virtual NameActionSelection setName(const std::string_view key, SelectionFactory &&) = 0;

virtual void setType(const std::string_view, const Persistable *) = 0;

SelectionPtr sel {};

<toolset>tidy:<librarydef>boost

;

lib test : [ glob *.cpp : test-*.cpp perf-*.cpp ] ;

run test-collection.cpp ;

run test-maths.cpp ;

run test-render.cpp : -- : test-assetFactory : <library>test ;

run test-glContextBhvr.cpp ;

run test-assetFactory.cpp : -- : [ sequence.insertion-sort [ glob-tree $(res) : *.* ] fixtures/rgb.txt test-instancing ] : <library>test ;

run test-worker.cpp ;

run test-instancing.cpp : -- : test-glContainer : <library>test ;

run test-glContainer.cpp : : : <library>test ;

run test-pack.cpp : : : <library>test ;

run test-environment.cpp : : : <library>test ;

compile test-static-enumDetails.cpp ;

compile test-static-stream_support.cpp ;

alias perf : perf-assetFactory perf-persistence perf-geoData perf-instancing perf-terrain ;

explicit perf ;

sceneRenderer.render(*this);

}

private:

SceneRenderer sceneRenderer;

BOOST_CHECK_EQUAL(4, mf->assets.size());

auto gravelAsset = mf->assets.at("terrain.surface.gravel");

BOOST_REQUIRE(gravelAsset);

BOOST_REQUIRE(gravel);

BOOST_REQUIRE_EQUAL(gravel->name, "Gravel");

BOOST_REQUIRE_EQUAL(gravel->colorBias, RGB {.9F});

BOOST_CHECK_EQUAL(1, mf->assets.size());

auto brush47 = mf->assets.at("brush-47");

BOOST_REQUIRE(brush47);

BOOST_REQUIRE(brush47rvc);

BOOST_REQUIRE(brush47rvc->bodyMesh);

BOOST_REQUIRE(brush47rvc->bogies.front());

BOOST_REQUIRE(brush47rvc->bogies.back());

auto railVehicle = std::make_shared<RailVehicle>(brush47rvc);

render(10000);

}

gameState.assets = mf->assets;

auto tree_01_1 = mf->assets.at("Tree-01-1");

BOOST_REQUIRE(tree_01_1);

BOOST_REQUIRE(tree_01_1_f);

auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}});

auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}});

auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}});

auto plant4 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, 2000, 0}, {0, 3, 0}});

render(6000);

}

BOOST_REQUIRE(rlight);

auto oldlamp = mf->assets.at("old-lamp");

BOOST_REQUIRE(oldlamp);

BOOST_REQUIRE(rlight_f);

BOOST_REQUIRE(oldlamp_f);

auto light1 = std::make_shared<Light>(oldlamp_f, Location {{0, 0, 0}, {0, 0, 0}});

auto light2 = std::make_shared<Light>(rlight_f, Location {{-4000, 0, 0}, {0, 2, 0}});

auto light3 = std::make_shared<Light>(rlight_f, Location {{-4000, -4000, 0}, {0, 1, 0}});

auto light4 = std::make_shared<Light>(oldlamp_f, Location {{3000, 4600, 0}, {0, 2, 0}});

// yes I'm hacking some floor to light up as though its a bush

auto floor = std::make_shared<Plant>(floorf, Location {});

render(6000);

}

return false;

}

unsigned int total {0};

};

}

};

BOOST_FIXTURE_TEST_SUITE(tc, TestCollection)

BOOST_AUTO_TEST_CASE(empty)

{

BOOST_REQUIRE(!apply(&Base::add));

const auto i = applyOne(&Base::add);

BOOST_CHECK_EQUAL(i, end());

}

BOOST_AUTO_TEST_CASE(a_base)

{

auto b = create<Base>();

BOOST_REQUIRE(apply(&Base::add));

BOOST_CHECK_EQUAL(b->total, 1);

const auto i = applyOne(&Base::add);

BOOST_CHECK_EQUAL(i, end());

}

BOOST_AUTO_TEST_CASE(a_rbase)

BOOST_AUTO_TEST_CASE(a_sub)

{

auto s = create<Sub>();

BOOST_REQUIRE(apply(&Base::add));

BOOST_CHECK_EQUAL(s->total, 2);

const auto i = applyOne(&Base::add);

BOOST_CHECK_EQUAL(*i, s);

}

BOOST_AUTO_TEST_SUITE_END()

BOOST_AUTO_TEST_CASE(wrapped_ptr_file_cons)

BOOST_AUTO_TEST_CASE(network_joins)

{

// Ends

// Join 0 <-> 1

// Join 1 <-> 2

}

BOOST_DATA_TEST_CASE(routeTo_nodeNotInNetwork, INVALID_NODES, dest)

{

BOOST_CHECK_THROW((void)routeFromTo(start, dest), std::out_of_range);

}

BOOST_AUTO_TEST_CASE(routeTo_noSteps)

{

auto r = this->routeFromTo(start, p100);

BOOST_CHECK(r.empty());

}

BOOST_AUTO_TEST_CASE(routeTo_upStream_to2)

{

auto r = this->routeFromTo(start, p200);

BOOST_REQUIRE_EQUAL(r.size(), 1);

}

BOOST_AUTO_TEST_CASE(routeTo_upStream_to3)

{

auto r = this->routeFromTo(start, p300);

BOOST_REQUIRE_EQUAL(r.size(), 2);

}

BOOST_AUTO_TEST_CASE(routeTo_downStream_to0)

{

auto r = this->routeFromTo(start, p000);

BOOST_REQUIRE_EQUAL(r.size(), 2);

}

BOOST_AUTO_TEST_CASE(routeTo_upStream_3to300)

{

auto r = this->routeFromTo(start, p300);

BOOST_REQUIRE_EQUAL(r.size(), 2);

}

BOOST_AUTO_TEST_CASE(routeTo_downStream_3to300)

{

auto r = this->routeFromTo(start, p300);

BOOST_REQUIRE_EQUAL(r.size(), 3);

}

BOOST_AUTO_TEST_SUITE_END()

terrain->point(GeoData::VertexHandle {517}).z = 100'000;

terrain->generateMeshes();

gameState->assets = AssetFactory::loadAll(RESDIR);

std::random_device randomdev {};

std::uniform_real_distribution<Angle> rotationDistribution {0, two_pi};

std::uniform_int_distribution<GlobalDistance> positionOffsetDistribution {-1500, +1500};

train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position());

for (auto x = 40000; x < 100000; x += 5000) {

for (auto y = 65000; y < 125000; y += 5000) {

Location {{x + positionOffsetDistribution(randomdev), y + positionOffsetDistribution(randomdev),

1},

{0, rotationDistribution(randomdev), 0}});

water.render(shader, frustum);

rail.render(shader, frustum);

std::ranges::for_each(gameState->assets, [&shader, &frustum](const auto & asset) {

renderable->render(shader, frustum);

}

});

{

terrain->shadows(shadowMapper, frustum);

std::ranges::for_each(gameState->assets, [&shadowMapper, &frustum](const auto & asset) {

renderable->shadows(shadowMapper, frustum);

}

});

{

if (p1) {

if (const auto p = network->intersectRayNodes(ray)) {

}

else if (const auto p = geoData->intersectRay(ray)) {

}

else {

}

}

else {

}

}

{

if (p1) {

if (const auto p = network->intersectRayNodes(ray)) {

}

else {

}

}

}

if (p1) {

create(network, geoData, p1, p);

p1.reset();

}

else {

p1 = p;

{

if (p1) {

if (const auto p = geoData->intersectRay(ray)) {

}

else {

}

}

}

if (const auto p = geoData->intersectRay(ray)) {

if (p1) {

create(network, geoData, *p1, p->first);

p1.reset();

}

else {

return;

case SDL_BUTTON_MIDDLE:

p1.reset();

return;

}

}

using Ptr = std::unique_ptr<Builder>;

protected:

};

private:

{

uiComponents.create<ManualCameraController>(glm::vec2 {310'727'624, 494'018'810});

auto gms = uiComponents.create<GameMainSelector>(&camera, ScreenAbsCoord {w, h});

}

GameMainWindow::~GameMainWindow() { }

void

GameMainWindow::content(const SceneShader & shader, const Frustum & frustum) const

{

}

}

uiComponents.apply<WorldOverlay>(&WorldOverlay::render, shader, frustum);

}

void

GameMainWindow::lights(const SceneShader & shader) const

{

}

void

GameMainWindow::shadows(const ShadowMapper & shadowMapper, const Frustum & frustum) const

{

}

}

}

class MainApplication : public ApplicationBase {

public:

void mainLoop();

protected:

bool handleInput(const SDL_Event & e, const Position & parentPos) override;

};

virtual bool handleInput(const SDL_Event & e);

protected:

UIShader uiShader;

};