Track individual dependencies in SystemScheduler

Arranging the systems in groups does not provide enough flexibility for
parallelizing the execution.

Add texture coordinates to generated meshes

Make temporary copies of component/child vectors when synthesizing events

An event listener might add components or child entities, which can
invalidate iterators to the vectors.

Add an example application for physics

Minor improvements

Support loading stage contents from files

Basic integration of physics

Add an early_tick function to System

Add utilities for keeping track of entities with specific components

Add generation number to BufferedComponent

Make the data members of BufferedComponent private

Derived classes should only access them through the provided functions.

Set camera to non-VR view

This accidentally got broken in 503a9c6 while working on the VR stuff.

Adjust order of members in Renderer::RenderedEntity

Since destroying the DynamicMeshSource triggers the destruction of the
MeshRenderer, it's important that the former is destroyed first or there
will be an invalid access to an already destroyed Owned handle.

Drop the shape wrapper statement from ShapeSetup loader

Instead use an auxiliary loader to allow the shape to be specified
inline with the rest of the setup.

Make the shape component available for generated setups

Ensure that a Shape's setup actually has a shape

Support declaring external types for generated setups

Always check pool relationships when a new pool is created

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.