Miscellaneous minor cleanups

Implement a VR mode for the playground example

Currently grabbing toys only works with left hand because Input::Bindings
does not support multiple devices of the same type.

Adjust destruction order of Application members

The VR system needs to be destroyed before the GL device because it
holds some Vulkan images created using the latter.

Refactor layer and collision mask logic in PhysicsSystem

Collisions between moving and incorporeal were not two-way, and the
chained ternary was a bit hard to read.

Add missing event observation to PhysicsSystem

Clarify names of some functions

Trigger reflected base class discovery from the pool allocator

This makes it run when a previously unseen intermediate base class is
requested, even if it does not own any components.

Redesign reflected base class discovery

It now uses subobject layout to find out which classes can be bases of
which other ones.  This allows the discovery to work even when an object
of the exact type is not available, such as intermediate base classes.

Update body generation when setting motion type

Initialize expected generations to nonzero

If a component is only modified during initialization its generation
values remain as zero.

Don't autogenerate mesh if the shape has no technique name

Use fresh parent state when propagating transforms

Add components for defining joints between rigid bodies

Allow overriding the base class of BufferedComponent

It still has to ultimately derive from Component, but this allows
inserting an intermediate base class.

Add a setup flag to make rigid bodies incorporeal

It can be used to create triggers which report collisions but don't
affect the physics simulation.

Use world space transforms to interface with physics simulation

The physics library require everything to be in the same space.

Support setting transform values in world space

Skip propagating transforms that were not changed

It saves some work and is necessary for change tracking in systems to
function.

Clear the dirty flag when updating transform order

Only update transform component if the physics body is dynamic

The simulation does not affect static bodies at all and kinematic bodies
are expected to end up in the externally specified position.

Add an event for collisions between rigid bodies

RigidBody now takes a setup with a flag to enable collision reporting.

Support emitting preconstructed events without copying

Only add colliders to the lookup if necessary

Refactor handling of pending physics bodies

This avoids the need to keep the list of pending bodies sorted.

Take advantage of the new algorithms in mspcore

Don't allow setting a zero field of view at runtime

Add a function to set the stepsize

Ignore catch-up ticks in Renderer

If falling behind was caused by rendering (via vsync or just complex
frames) trying to render on every tick would just make the situation
worse.

Also render on partial ticks in case the desired output framerate is
higher than the reciprocal stepsize.

Pass more information about tick timing to systems

They now get the remaining amount of backlog, which allows detecting if
catch up is happening or processing partial ticks.

Implement moving toys with the mouse in the playground example

Add support for kinematic motion of rigid bodies

Use a different way of determining the default transactor of a component

Declaring the type alias in BufferedComponent results in a transactor
for BufferedComponent<T>, which does not match the actual type used in
system dependencies.

Avoid committing systems at the wrong time

Checks were missing to only commit a system after it has finished
running and not committing it a second time.

Add a missing include

Add raycast functionality

Includes a helper function in the Camera component to create rays.

Set physics bodies on different layers based on whether they move

This should improve performance when there's a lot of static bodies
compared to moving ones.

Use AffineTransform instead of Matrix in the Transform component

Implement commit barriers in SystemScheduler

In a multithreaded environment systems which write to a component must
wait until potential concurrent reads have finished before committing
the changes.

Re-separate transaction unblock/block from prepare/commit

Multithreaded ticks may require waiting or even running other systems in
between a system's tick finishing and the changes being committed.

Customized transactors must explicitly unblock and re-block access if
they wish to modify the component during commit.

Move System tick bracketing to SystemScheduler

Refactor dependency iteration in SystemScheduler to be more reusable

Make BufferedComponent's commit/prepare functions non-virtual

Customizing these should be handled through transactors.

Convert TransformPropagator to a Transactor

The propagation is now done automatically after any system modifies
transforms.

Rewrite System tick bracketing with a Transactor class

This allows components to better customize their transactions.

Rename Stage::get_system to find_system

It can return null so this is more appropriate.

Prevent concurrent write access to unbuffered components

Allow read-only accesses to a component to occur in parallel

Add test cases for SystemScheduler

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