/// <summary>
/// Loads a waves.bin file
/// </summary>
public override object Load( ISource source, LoadParameters parameters )
{
using ( Stream stream = ( ( IStreamSource )source ).Open( ) )
{
return WaveAnimation.Load( stream );
}
}
/// <summary>
/// Loads code from a source
/// </summary>
public override object Load( ISource source, LoadParameters parameters )
{
string typeToInstance = DynamicProperties.GetProperty< string >( parameters.Properties, InstanceTypeName, null );
IEnumerable< string > assemblies = DynamicProperties.GetProperty< IEnumerable< string > >( parameters.Properties, ReferencesName, new string[] { } );
using ( Stream stream = OpenStream( source ) )
{
StreamReader reader = new StreamReader( stream );
string allLines = reader.ReadToEnd( );
CodeDomProvider provider = new CSharpCodeProvider( );
CompilerParameters compilerParams = new CompilerParameters( );
compilerParams.GenerateInMemory = true;
#if DEBUG
compilerParams.IncludeDebugInformation = true;
#endif
// Add referenced assemblies to compiler parameters
foreach ( string assembly in assemblies )
{
compilerParams.ReferencedAssemblies.Add( assembly );
}
CompilerResults results = provider.CompileAssemblyFromSource( compilerParams, allLines );
if ( results.Errors.Count > 0 )
{
// Failed to compile assembly - dump
foreach ( CompilerError error in results.Errors )
{
Entry entry = new Entry( AssetsLog.GetSource( error.IsWarning ? Severity.Warning : Severity.Error ), error.ErrorText );
entry.Locate( error.FileName, error.Line, error.Column, "" );
Source.HandleEntry( entry );
}
return null;
}
// If the caller requested the instance of a specific type, then find that type in the
// compiled assembly, and create an instance of it
if ( typeToInstance != null )
{
Type instanceType = results.CompiledAssembly.GetType( typeToInstance );
return Activator.CreateInstance( instanceType );
}
// Find a type that implements IBuilder, instance it, then use the IBuilder.CreateInstance()
// to create our required type
foreach ( Type type in results.CompiledAssembly.GetTypes( ) )
{
if ( typeof( IBuilder ).IsAssignableFrom( type ) )
{
IBuilder builder = ( IBuilder )Activator.CreateInstance( type );
return builder.CreateInstance( type );
}
}
}
return null;
}
/// <summary>
/// Loads a resource from a stream
/// </summary>
public override object Load( ISource source, LoadParameters parameters )
{
if ( m_Context == IntPtr.Zero )
{
CreateContext( );
}
parameters.CanCache = true;
return new CgEffect( m_Context, ( IStreamSource )source );
}
/// <summary>
/// Loads an asset supported by this loader
/// </summary>
/// <param name="source">Asset source</param>
/// <param name="parameters">Asset load parameters</param>
/// <returns>
/// If the parameters specify "returnTextureDataOnly" as true (<see cref="TextureLoadParameters.ReturnTextureDataOnly"/>),
/// the method returns an array of <see cref="Texture2dData"/> or <see cref="Texture3dData"/>. If the "returnTextureDataOnly"
/// is false, or does not exist, this method returns an <see cref="ITexture"/> object.
/// </returns>
public unsafe override object Load( ISource source, LoadParameters parameters )
{
bool generateMipMaps = DynamicProperties.GetProperty( parameters.Properties, TextureLoadParameters.GenerateMipMapsPropertyName, false );
bool returnTextureData = DynamicProperties.GetProperty( parameters.Properties, TextureLoadParameters.ReturnTextureDataOnlyName, false );
using ( Stream stream = ( ( IStreamSource )source ).Open( ) )
{
return TextureReader.ReadTextureFromStream( source.ToString( ), stream, returnTextureData, generateMipMaps );
}
}
/// <summary>
/// Creates default loading parameters
/// </summary>
/// <param name="addAllProperties">If true, then the parameters object gets all relevant dynamic properties with their default values added</param>
/// <returns>Returns default loading parameters</returns>
public override LoadParameters CreateDefaultParameters( bool addAllProperties )
{
LoadParameters parameters = new LoadParameters( );
if ( addAllProperties )
{
parameters.Properties.Add( InstanceTypeName, "" );
parameters.Properties.Add( ReferencesName, new string[] { } );
}
return parameters;
}
/// <summary>
/// Loads an asset
/// </summary>
/// <param name="source">Source of the asset</param>
/// <param name="parameters">Load parameters</param>
/// <returns>Loaded asset</returns>
/// <remarks>
/// If parameters contains the bool typed parameter "generateMipMaps" set to true, the loaded texture
/// has mipmaps generated.
/// </remarks>
public override object Load( ISource source, LoadParameters parameters )
{
parameters.CanCache = true;
using ( Stream stream = ( ( IStreamSource )source ).Open( ) )
{
bool generateMipMaps = DynamicProperties.GetProperty( parameters.Properties, TextureLoadParameters.GenerateMipMapsPropertyName, false );
return Texture2dUtils.LoadTextureFromImageStream( stream, generateMipMaps );
}
}
/// <summary>
/// If the current host's ID is equal to hostId, then the specified local controller is added
/// </summary>
/// <param name="hostId">ID of the local controller's host</param>
/// <param name="controllerPath">Path to the resource that describes the controller</param>
/// <param name="parameters">Parameters to pass to the controller resource loader</param>
public void SetupController( Guid hostId, string controllerPath, LoadParameters parameters )
{
IHost host = m_Scene.GetService< IHost >( );
if ( ( host == null ) || ( host.HostType == HostType.Local ) )
{
// Local hosts can't receive commands from remote controllers, so the controller
// must be created locally
parameters = ( LoadParameters )parameters.Clone( );
parameters.Target = this;
AddChild( AssetManager.Instance.Load( controllerPath, parameters ) );
}
else if ( host.Id == hostId )
{
// The ChildUpdateProvider does stuff...
ChildUpdateProvider provider = new ChildUpdateProvider( );
provider.UpdateMessageType = typeof( CommandMessage );
provider.Source = this;
provider.Target = m_Scene.GetService< UpdateSource >( );
provider.RemoveBufferedMessages = false;
provider.UpdateMessageType = typeof( CommandMessage );
// The scene host is the local controller host - create away
parameters = ( LoadParameters )parameters.Clone( );
parameters.Target = this;
AddChild( AssetManager.Instance.Load( controllerPath, parameters ) );
}
else
{
// The ChildUpdateHandler listens out for update mesages sent to the scene UpdateTarget, passing them on to this entity
ChildUpdateHandler handler = new ChildUpdateHandler( );
handler.Target = this;
handler.Source = m_Scene.GetService< UpdateTarget >( );
AddChild( handler );
// The ChildUpdateProvider does stuff...
//ChildUpdateProvider provider = new ChildUpdateProvider( );
//provider.UpdateMessageType = typeof( CommandMessage );
//provider.Source = this;
//provider.Target = m_Scene.GetService< UpdateSource >( );
//provider.IgnoreUpdateHandlerMessages = false;
//provider.RemoveBufferedMessages = false;
//provider.UpdateMessageType = typeof( CommandMessage );
}
}
/// <summary>
/// Loads materials from an asset
/// </summary>
/// <param name="source">Asset source</param>
/// <param name="createFallbackOnError">Generates a fallback default material set if an error occurs</param>
public static MaterialSet Load( ISource source, bool createFallbackOnError )
{
LoadParameters parameters = new LoadParameters( );
return ( MaterialSet )AssetManager.Instance.Load( source, parameters );
}
/// <summary>
/// Clones this object
/// </summary>
/// <returns>Deep copy clone</returns>
public virtual object Clone( )
{
LoadParameters clone = new LoadParameters( );
DeepCopy( clone );
return clone;
}
/// <summary>
/// Loads an asset
/// </summary>
/// <param name="source">Data source</param>
/// <param name="parameters">Loading parameters</param>
/// <returns>Returns loaded object</returns>
public override object Load( ISource source, LoadParameters parameters )
{
using ( Stream stream = OpenStream( source ) )
{
return Load( stream, source, parameters );
}
}
/// <summary>
/// Loads component XML from a stream
/// </summary>
public object Load( Stream stream, ISource source, LoadParameters parameters )
{
if ( !( parameters is ComponentLoadParameters ) )
{
ComponentLoadParameters newParameters = new ComponentLoadParameters( parameters.Target );
foreach ( IDynamicProperty property in parameters.Properties )
{
newParameters.Properties.Add( property );
}
parameters = newParameters;
}
parameters.CanCache = false;
ErrorCollection errors = new ErrorCollection( string.Copy( source.Path ) );
XmlTextReader reader = new XmlTextReader( stream );
reader.WhitespaceHandling = WhitespaceHandling.Significant;
try
{
if ( reader.MoveToContent( ) == XmlNodeType.None )
{
AssetsLog.Warning( "XML component asset \"{0}\" was empty - returning null", source.Name );
return null;
}
}
catch ( XmlException ex )
{
AssetsLog.Error( "Moving to XML component asset \"{0}\" content threw an exception", source.Name );
Entry entry = new Entry( AssetsLog.GetSource( Severity.Error ), ex.Message );
Source.HandleEntry( entry.Locate( source.Path, ex.LineNumber, ex.LinePosition, "" ) );
throw new ApplicationException( string.Format( "Failed to load component XML asset \"{0}\" (see log for details)", source.Name ) );
}
string cacheable = reader.GetAttribute( "cacheable" );
parameters.CanCache = ( cacheable != null ) && ( ( cacheable == "yes" ) || ( cacheable == "true" ) );
RootBuilder builder = ( RootBuilder )BaseBuilder.CreateBuilderFromReader( null, ( ComponentLoadParameters )parameters, errors, reader );
if ( errors.Count == 0 )
{
BaseBuilder.SafePostCreate( builder );
if ( errors.Count == 0 )
{
BaseBuilder.SafeResolve( builder, true );
}
}
if ( ( builder.BuildObject == null ) && ( errors.Count == 0 ) )
{
errors.Add( builder, "Empty components file" );
}
if ( errors.Count > 0 )
{
foreach ( Entry error in errors )
{
Source.HandleEntry( error );
}
throw new ApplicationException( string.Format( "Failed to load component XML asset \"{0}\" (see log for details)", source.Name ) );
}
// TODO: AP: bit dubious... if there's more than one object, return a list
if ( builder.Children.Count == 0 )
{
throw new ApplicationException( string.Format( "Failed to load component XML asset \"{0}\" - did not contain any components", source.Name ) );
}
if ( builder.Children.Count == 1 )
{
return builder.Children[ 0 ];
}
return builder.Children;
}
private void ui_SelectionChanged( object sender, EventArgs e )
{
// The selection has changed - if the user has selected a loadable asset, then present the load parameters
// in a property grid
ISource[] sources = m_AssetBrowserUi.Sources;
if ( sources.Length == 0 )
{
loadParametersGrid.SelectedObject = null;
return;
}
IAssetLoader loader = AssetManager.Instance.FindLoaderForAsset( sources[ 0 ] );
if ( loader == null )
{
return;
}
m_CurrentLoadParameters = loader.CreateDefaultParameters( true );
// Create a property bag from the dynamic properties
PropertyBag bag = new PropertyBag( );
string category = string.Format( Properties.Resources.LoaderProperties, loader.Name );
foreach ( IDynamicProperty dynProperty in m_CurrentLoadParameters.Properties )
{
bag.Properties.Add( new DynPropertySpec( category, dynProperty ) );
}
if ( bag.Properties.Count == 0 )
{
return;
}
bag.SetValue += DynPropertySpec.SetValue;
bag.GetValue += DynPropertySpec.GetValue;
// Add the property bag to the load parameters property grid
loadParametersGrid.SelectedObject = bag;
}
/// <summary>
/// Setup constructor
/// </summary>
/// <param name="loader">Asset loader</param>
/// <param name="source">Asset source</param>
/// <param name="parameters">Loading parameters</param>
public LoadState( IAssetLoader loader, ISource source, LoadParameters parameters )
{
m_Loader = loader;
m_Source = source;
m_Parameters = parameters ?? loader.CreateDefaultParameters( false );
}
private void GameClientForm_Shown( object sender, EventArgs e )
{
if ( DesignMode )
{
return;
}
gameDisplay.OnBeginPaint += delegate { GameProfiles.Game.Rendering.Begin( ); };
gameDisplay.OnEndPaint += delegate
{
GameProfiles.Game.Rendering.End( );
GameProfiles.Game.Rendering.Reset( );
};
UniPoint3 initialViewPos = new UniPoint3( );
try
{
m_SolarSystem = CreateSolarSystem( initialViewPos );
}
catch ( Exception ex )
{
AppLog.Exception( ex, "Error occurred creating the solar system" );
ErrorMessageBox.Show( this, Resources.ErrorCreatingSolarSystem, ex );
Close( );
return;
}
// Load the game viewer
try
{
LoadParameters loadParams = new LoadParameters( );
loadParams.Properties[ "user" ] = m_User;
Viewer viewer = ( Viewer )AssetManager.Instance.Load( "Viewers/TestGameViewer.components.xml", loadParams );
viewer.Renderable = m_SolarSystem;
( ( IUniCamera )viewer.Camera ).Position.Z = initialViewPos.Z;
gameDisplay.AddViewer( viewer );
}
catch ( Exception ex )
{
AppLog.Exception( ex, "Error occurred creating game viewer" );
ErrorMessageBox.Show( this, Resources.ErrorCreatingGameViewer, ex );
Close( );
return;
}
// Load the game controls
try
{
CommandInputTemplateMap[] gameControlMaps = new CommandInputTemplateMap[]
{
( CommandInputTemplateMap )AssetManager.Instance.Load( "Input/TestTrackingCameraInputs.components.xml" ),
( CommandInputTemplateMap )AssetManager.Instance.Load( "Input/HeadCameraInputs.components.xml" )
};
foreach ( Viewer viewer in gameDisplay.Viewers )
{
foreach ( CommandInputTemplateMap gameControlMap in gameControlMaps )
{
gameControlMap.BindToInput( new InputContext( viewer ), m_User );
}
}
}
catch ( Exception ex )
{
AppLog.Exception( ex, "Error occurred creating game controls" );
ErrorMessageBox.Show( this, Resources.ErrorCreatingGameControls, ex );
}
}
/// <summary>
/// Loads... stuff
/// </summary>
public override object Load( ISource source, LoadParameters parameters )
{
parameters.CanCache = true;
Vector3 scale = new Vector3
(
DynamicProperties.GetProperty( parameters.Properties, "scaleX", 1.0f ),
DynamicProperties.GetProperty( parameters.Properties, "scaleY", 1.0f ),
DynamicProperties.GetProperty( parameters.Properties, "scaleZ", 1.0f )
);
Matrix44 transform = new Matrix44( );
transform.Scale( scale.X, scale.Y, scale.Z );
// create the model
Model model = new Model( );
// oh dear another md3 hack - directories mean articulated models, with skins and animations. Files
// mean single objects
if ( source is IFolder )
{
// Load animations
model.Animations = LoadAnimations( AnimationFile( source ) );
LoadNestedModel( model, source, transform );
}
else
{
LoadObjectModel( model, source, transform );
}
return model;
}
/// <summary>
/// Copies members from this LoadParameters to parameters
/// </summary>
protected void DeepCopy( LoadParameters parameters )
{
parameters.m_Target = m_Target;
parameters.m_Properties = m_Properties;
}
private void GameViewForm_Load( object sender, EventArgs e )
{
// Add a performance display
Scene.Objects.Add( new PerformanceDisplay( ) );
DebugInfo.ShowFps = true;
DebugInfo.ShowMemoryWorkingSet = true;
DebugInfo.ShowMemoryPeakWorkingSet = true;
// Load in the game viewer
LoadParameters loadArgs = new LoadParameters( );
loadArgs.Properties.Add( "Users", m_Users );
m_Viewer = ( Viewer )AssetManager.Instance.Load( m_Setup.ViewerSource, loadArgs );
gameDisplay.AddViewer( m_Viewer );
// Get start points
IEnumerable< PlayerStart > startPoints = Scene.Objects.GetAllOfType<PlayerStart>( );
// Setup players
InputContext inputContext = new InputContext( m_Viewer );
m_Users = new CommandUser[ m_Setup.NumberOfPlayers ];
for ( int playerIndex = 0; playerIndex < m_Setup.NumberOfPlayers; ++playerIndex )
{
PlayerSetup player = m_Setup.Players[ playerIndex ];
// Find the start position for this player
PlayerStart playerStart = null;
foreach ( PlayerStart startPoint in startPoints )
{
if ( startPoint.PlayerIndex == playerIndex )
{
playerStart = startPoint;
break;
}
}
if ( playerStart == null )
{
throw new InvalidOperationException( "No player start available for player " + playerIndex );
}
// Load game inputs
m_Users[ playerIndex ] = new CommandUser( );
CommandInputTemplateMap gameInputs = ( CommandInputTemplateMap )AssetManager.Instance.Load( player.CommandSource );
gameInputs.BindToInput( inputContext, m_Users[ playerIndex ] );
// Load the player's character
object character = AssetManager.Instance.Load( player.CharacterSource );
Scene.Objects.Add( ( IUnique )character );
// Place the character at the start position
IPlaceable placeable = Rb.Core.Components.Parent.GetType<IPlaceable>( character );
if ( placeable != null )
{
placeable.Position = playerStart.Position;
}
// Hack... if the viewer camera is a follow camera, force it to look at the player
if ( ( m_Setup.NumberOfPlayers == 1 ) && ( m_Viewer.Camera is FollowCamera ) )
{
FollowCamera camera = ( FollowCamera )m_Viewer.Camera;
// Follow the player
camera.Target = ( IPlaceable )character;
// Add a camera controller
FollowCameraControl cameraControl = new FollowCameraControl( camera, m_Users[ 0 ] );
m_Viewer.Camera.AddChild( cameraControl );
}
IParent characterParent = ( IParent )character;
characterParent.AddChild( new UserController( m_Users[ playerIndex ], ( IMessageHandler )character ) );
}
// Start rendering the scene
m_Viewer.Renderable = Scene;
// Kick off the update service... (TODO: AP: Not a very good hack)
IUpdateService updater = Scene.GetService< IUpdateService >( );
if ( updater != null )
{
updater.Start( );
}
playButton.Enabled = false;
}
/// <summary>
/// Loads an asset at a given location path, with specified parameters
/// </summary>
/// <param name="path">Location path</param>
/// <param name="parameters">Loading parameters</param>
/// <returns>Returns the loaded asset</returns>
public object Load( string path, LoadParameters parameters )
{
ISource loc = Locations.NewLocation( path );
return Load( loc, parameters );
}
/// <summary>
/// Loads an asset at a given location, with specified parameters
/// </summary>
/// <param name="source">Asset source</param>
/// <param name="parameters">Loading parameters</param>
/// <returns>Returns the loaded asset</returns>
public object Load( ISource source, LoadParameters parameters )
{
if ( source == null )
{
throw new ArgumentNullException( "source", "Asset source was null - check that location exists" );
}
foreach ( IAssetLoader loader in m_Loaders )
{
if ( loader.CanLoad( source ) )
{
LoadState loadState = new LoadState( loader, source, parameters );
return loadState.Load( );
}
}
throw new ArgumentException( string.Format( "No loader could load asset \"{0}\"", source ) );
}
/// <summary>
/// Creates a load state that can load an asset from a given source
/// </summary>
/// <param name="source">Asset source</param>
/// <param name="parameters">Asset loading parameters</param>
/// <returns>Returns a new LoadState that can load the asset at source</returns>
public LoadState CreateLoadState( ISource source, LoadParameters parameters )
{
IAssetLoader loader = FindLoaderForAsset( source );
if ( loader == null )
{
throw new ArgumentException( string.Format( "No loader could load asset {0}", source ) );
}
return new LoadState( loader, source, parameters );
}
