Added parsing of progressive data to ColladaSystem and stored it in Meshdata
Added DirectChunkRequest that allows downloading a chunk by hash without doing a name lookup
Merge branch 'master', remote-tracking branch 'origin' into progressive_loading
Changed ResourceDownloadTask to be more abstract and repaired the horror that ensued
Refactored all the things and got loading of base mesh + 128x128 texture working
Make slauncher support subdirectories for data.
Support relative URLs in slauncher file listing.
Use a single stream for manual object host prox queries.

Instead of allocating a substream for each message to the manual
proximity service on the server, allocate a single prox substream and
use it for all messages to the server. This requires some additional
queueing while allocating the stream. This has less overhead and is
simpler since the server doesn't have to worry about unordered
messages. This should result in this implementation having a fixed
stream construction procedure (client's initial request comes in on a
new stream, the space server wouldn't have had to message it before
that), only uses a single stream, and makes messages in each direction
completely ordered.
Add refine/coarsen requests to manual query processor.

Add encoding and sending of refine and coarsen requests to the manual
object query processor. Add some test code which forces refinement on
any additions which are known to be aggregates. This is only a
temporary solution but will allow testing of code on the server and
client without a more complicated approach.
Parse refine/coarsen requests and forward them to queries.

Parse refine and coarsen requests. Forward them to queries, which in
turn pass them to the query handler for processing. This finally
allows clients to control their cuts.  Also update libprox for a fix
to refinement handling where leaf nodes were not refined due to a
logic error: leaves can be refined (to get at individual objects) so
long as they are still in the result set.
Handle Collada save errors.

Catch StreamWriterExceptions in the collada save code so errors, such
as permissions failures, are caught and returned as a failure to
perform the conversion.
Log and ignore conversion/save failures in AggregateManager.

Instead of ignoring the return value of ModelsSystem::convertVisual,
use it to log an error and force the AggregateManager to move on to
the next aggregate since there's nothing to be done when we can't
actually save the model.
Allow ObjectQueryProcessor to intercept queries on connection.

When the ObjectHost requests a connection, have it pass the query to
the ObjectQueryProcessor. This makes the ObjectQueryProcessor aware of
the value when the connection is requested and also allows it to
change the value, e.g. if the individual object query should not be
registered, using an aggregate object host query instead. This
approach is implemented in ManualObjectQueryProcessor, whereas the
simple one simply lets the value pass through.
Add enough pass-through of queries to get ManualObjectQueryProcessor to display objects.

Add pass-through (with some minor translation) of query results in
ManualObjectQueryProcessor to display objects. This isn't even close
to how we should be handling those queries, but sufficient to make the
system end-to-end testable.

This required improving tracking of HostedObjectPtrs to perform
callbacks and translation/construction of proximity results from
SequencePresenceProperties objecs, both of which will be useful for
the real querying implementation in the future.
Add and use LocationServiceCache for OH queries.

Add a LocationServiceCache for OH queries which uses
SequencedPresenceProperties for its underlying storage. This version
is thread-safe but guarantees Prox LocationUpdateListener events are
triggered in a strand. Replace the old storage in
ManualObjectQueryProcessor with this one.

This change also required a number of other semi-related changes. The
interface for libprox LocationServiceCache needed to be updated to
remove consts to allow locks and return-by-reference to allow
returning values derived from other values. Also reorganized the
ProxSimulationTraits from a monolithic version in libspace to
situation-specific versions -- they share some overlap, but are small
and this gets rid of awkward sharing in a library which didn't need
those types. Also add a few ObjectReference nested types for
generating random and null ObjectReferences.
Add libsirikata-sdl for shared SDL state/operations.

Add libsirikata-sdl to handle shared state/operations within a single
app, where the clients of SDL may not be coordinated, e.g. graphics
and audio that are implemented separately. Currently this just covers
initialization and destruction, ensuring basic SDL initialization only
occurs once, subsystems are only initialized once and refcounted so
they aren't destroyed until everyone is done with them. Convert Ogre
plugin to use this new interface.
Remove requirement that TimeSteppedSimulation be a ConnectionEventListener.

Remove ConnectionEventListener from TimeSteppedSimulation's base
classes. Instead, require ConnectionEventProvider* as parameter to
SimulationFactory and move subscription under control of the
Simulation rather than of the HostedObject. This change makes sense
because many simulations won't care about connectivity.
Add Simulation base class and make SimulationFactory produce them instead of TimeSteppedSimulation.

Add Simulation base class which only requires that the subclass implement
Service and Invokable rather than acting as a Poller as TimeSteppedSimulation
required. Change SimulationFactory to produce Simulations rather than
TimeSteppedSimulations.

This also required changing how Pollers and PollingServices worked. Pollers are
no longer Services, although they do implement start() and stop()
methods. PollerService is a new intermediate class which is both a Poller and
implements the Service interface. Finally, PollingService is the standard
verison which also does profiling and delegates polling to a standard poll()
method, making it easier to implement. The naming isn't great, but these should
serve all the needs without getting into hairy virtual inheritance issues due to
a bunch of different interfaces implementing the Service interface.
Add skeleton SDLAudio plugin.

Add skeleton SDLAudio plugin for running "audio"
simulations. Currently it's just stubbed out with the basic interface,
initialization and cleanup code, and generates quiet noise as a simple
test that it's working.
Add FFmpeg build support.

Add FFmpeg library search and make the SDLAudio library depend on it
since we're not going to be able to do much without a way to decode
audio. Test it by performing basic initialization in the
SDL::AudioSimulation class. Update Linux dependencies to get the basic
required dependency. Linux is the only platform currently supported.