/// <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 ); }