Use the auto type to hold the result of dynamic_handle_cast

It's clear enough what the type will be so no need to repeat it.

Put simple constructor definitions in headers

Rework virtual reality initialization

VR mode must now be requested when creating the Application object,
because it may need to interact with graphics initialization.

Fix .gitignore

Use the aligned form of operator delete

By the language spec the form of new and delete must match

Clean up MeshRenderer when DynamicMeshSource is destroyed

Add some missing VR calls

Rewrite the VR code to match changes in mspvr

There now needs to be an entity tagged with a TrackingAnchor component
to designate the location of the tracking area within the game world.
A player character entity or something closely related should generally
be suitable.

Adjust to different way of accessing VR::MotionController type constant

Export TransformValues in the API

Add missing includes

Use different allocation functions for pools

It appears using alignas with new is a gcc extension.

Explicitly declare special members of certain classes

MSVC tries to generate them for DLL export and that fails because of
vectors of unique pointers.

Adjust for changes in mspnet

Hide thread-local data behind accessor functions

MSVC doesn't like them as static members of classes with DLL interface.

Add a component for creating meshes via geometry definitions

Add a missing include and forward declaration

Add virtual reality support

Rework the relationship between renderers and the view

A renderer can't just associate itself with the view in its constructor
since stages may get activated multiple times during the application's
lifetime and the renderer for each stage is only created the first time.

Include the input device in the LocalPlayerArrived event

Add factory function from a matrix to TransformValues

Remove more unnecessary uses of std::ref

These didn't get caught the last time since they lacked the namespace
prefix.

Add polymorphism discovery for systems

Check bases of intermediate base classes

Without this iterating objects of such an intermediate base type does
not work.

Allow reflection to detect polymorphic bases from a type alias

Implement queueing for remote calls

This allows received calls to be dispatched in a controlled order during
a frame.

Consolidate the remote call classes

Global and entity calls are now declared using the same class.  If the
entity type is void (the default), the call is global.

Adjust network code for changes in the mspnet library

Use iterate_objects in Renderer::tick

Cosmetic changes

Check that clients only do calls on entities they possess

Move an include to where it's actually needed

Add some network state checks

Don't filter by target players when sending from a client

Require entity packets to have an entity_id field of correct type

Allow a custom protocol to be set for Replicator

It needs to derive from StageProtocol, which is now exported from the
library.

Fix an incorrect argument to key_error

Add more kinds of remote calls

Avoid sending a packet to the same connection more than once

To keep things efficient, player IDs are now stored as 32-bit quantities,
with the high 16 bits containing an ID for the client connection.  Only
the lower 16 bits are transmitted on the network to avoid leaking
information on which players share the same connection.

Streamline the send functions in Replicator a bit

Calling the targeted send function with a target of zero will now forward
to the broadcast function, avoiding the need to branch at call sites.

Track the sender of the current packet

Add facilities to designate entities as player-controlled

Fix errors revealed by gcc 13

Rework Landscape to support replication

Add a dynamic cast function for Owned

Add a callback when an entity is spawned over the network

It can be used by the owner of the spawner to send additional packets
to initialize the entity.

Add a mechanism for replicating function calls to clients

Support custom lookup functions for retrieving setups in Spawner

Give IDs to entities replicated over the network

Only send spawns to the target players of the replicator

Send spawns of newly-created entities in deferred_tick

Spawn info won't have been set in the component_create event for the
zygote.

Add a mechanism for spawning entities over the network

Add interfaces for using Networking from the outside

Emit events when the other side of a network connection changes stages

Rename Networking::next_id to next_player_id

Use Networking::set_state in start_server and connect_to_server

This gets the event appropriately emitted.

Add string interning to the network protocol

This allows transmitting commonly used strings using short IDs.

Identify stages with a name

Remove unnecessary std::ref invocations

I got confused by the std::thread constructor, which stores its arguments
in a tuple and creates copies without std::ref.  It's not needed in these
cases since the arguments are just forwarded directly.

Place Networking after event things in Director

It uses the event bus, so correct order of destruction must be ensured.

Rename some events for clarity and consistency

Support adding prop entities to Landscape

Add support for shadows

Track destruction of individual components in Renderer

Allow clearing an Owned by assigning nullptr

Make Owned friendly to other template specializations

Make iterate_objects const

Chain certain pool operations to pools of derived objects

Keep track of object pools for derived types

Make the destructor of PoolBase virtual

Make pools non-movable

I'm not actually using move semantics for them and they're of dubious
value due to polymorphism anyway.

Add a generation number to Reflector

Include generated headers from the installed location

Add game setup imports as transitive dependencies

Update location of generated source files

Add components and systems for creating terrains

Make Presenter store pointers to systems, not just renderers

Add a component for using dynamic meshes in entities

Adjust Bassteroids for the lighting changes

Create the rendering sequence dynamically

Sequence templates are a bit too rigid for games where it's desirable to
tune many different graphics quality settings independently.

Add components for creating lights

Further refactor Renderer and MeshRenderer

The ObjectInstance is now hidden inside MeshRenderer and RAII is used to
remove it from the scene.  This limits the instance to being in only a
single scene, but I don't think that will be an issue.

Add a transform propagator to stages by default

This is possible now that system dependencies have been implemented.

Refactor Renderer to pick up components instead of entities

This makes more sense since there isn't an entity class which always
contains a MeshSource.

Have MeshRenderer's constructor take a GL::Object

Undefine the API macro at the end of a setup header

Otherwise it may interfere with other setup headers.

Add basic networking infrastructure

Currently it only allows running a server, connecting to it and creating
players, but no synchronization yet.

Derive GameSetupDefinitions from TemplateFile instead of SourceFile

Builder's InstallMap checks for that class to figure out the install
locations for generated headers.

Update .gitignore files

This includes pre-emptive changes for Windows build products.

Load the various setups through resources

Add dependency to mspmath in Bassteroids

Use the setup generator to create setup structs

Support API decorations for setups

Prefix C++ types with namespaces in the setup generator

Add import functionality for setup modules

Also install setup definition files so definitions from libraries can be
used.

Refactor the setup generator to store types in modules

Create a builder plugin for the setup generator tool

Remove a temporary hack

The bug it was for is now fixed.

Add an include which is now necessary

Changes in the Variant class require classes retrieved from a collection
to be fully defined.

Decorate things which constitute the public API of the library