/// <summary> /// Adds an affector to this particle system. /// </summary> /// <remarks> /// Particles are modified over time in a particle system by affectors - see the ParticleAffector /// class for more details. /// </remarks> /// <param name="emitterType"> /// string identifying the affector type to create. Affector types are defined /// by registering new factories with the manager - see ParticleAffectorFactory for more details. /// Affector types can be extended by plugin authors. /// </param> /// <returns></returns> public ParticleAffector AddAffector(string affectorType) { ParticleAffector affector = ParticleSystemManager.Instance.CreateAffector(affectorType); affectorList.Add(affector); return(affector); }
public void RemoveAffector(int index) { Debug.Assert(index < affectorList.Count, "Affector index out of bounds!"); ParticleAffector affector = affectorList[index]; // ParticleSystemManager.Instance.DestroyAffector(affector); affectorList.RemoveAt(index); }
/// <summary> /// /// </summary> /// <param name="line"></param> /// <param name="affector"></param> private void ParseAffectorAttrib(string line, ParticleAffector affector) { string[] values = line.Split(new char[] { ' ' }, 2); if (!(affector.SetParam(values[0], values[1]))) { ParseHelper.LogParserError(values[0], affector.Type, "Command not found."); } }
/// <see cref="Translator.Translate"/> public override void Translate( ScriptCompiler compiler, AbstractNode node ) { ObjectAbstractNode obj = (ObjectAbstractNode)node; // Must have a type as the first value if ( obj.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, obj.File, obj.Line ); return; } string type = string.Empty; if ( !getString( obj.Values[ 0 ], out type ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, obj.File, obj.Line ); return; } ParticleSystem system = (ParticleSystem)obj.Parent.Context; _Affector = system.AddAffector( type ); foreach ( AbstractNode i in obj.Children ) { if ( i is PropertyAbstractNode ) { PropertyAbstractNode prop = (PropertyAbstractNode)i; string value = string.Empty; // Glob the values together foreach ( AbstractNode it in prop.Values ) { if ( it is AtomAbstractNode ) { if ( string.IsNullOrEmpty( value ) ) value = ( (AtomAbstractNode)it ).Value; else value = value + " " + ( (AtomAbstractNode)it ).Value; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); break; } } if ( !_Affector.SetParam( prop.Name, value ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } else { _processNode( compiler, i ); } } }
public virtual void CopyTo(ParticleAffector affector) { // loop through all registered commands and copy from this instance to the target instance foreach (var key in this.commandTable.Keys) { // get the value of the param from this instance var val = ((IPropertyCommand)this.commandTable[key]).Get(this); // set the param on the target instance affector.SetParam(key, val); } }
/// <summary> /// /// </summary> /// <param name="emitter"></param> public virtual void CopyTo(ParticleAffector affector) { // loop through all registered commands and copy from this instance to the target instance foreach (DictionaryEntry entry in commandTable) { string name = (string)entry.Key; // get the value of the param from this instance string val = ((ICommand)entry.Value).Get(this); // set the param on the target instance affector.SetParam(name, val); } }
/// <summary> /// Cloning will deep copy all particle emitters and effectors, but not particles. The /// system's name is also not copied. /// </summary> /// <returns></returns> public void CopyTo(ParticleSystem system) { // remove the target's emitters and affectors system.RemoveAllEmitters(); system.RemoveAllAffectors(); // loop through emitter and affector lists and copy them over foreach (ParticleEmitter emitter in emitterList) { ParticleEmitter newEmitter = system.AddEmitter(emitter.Type); emitter.CopyTo(newEmitter); } foreach (ParticleAffector affector in affectorList) { ParticleAffector newAffector = system.AddAffector(affector.Type); affector.CopyTo(newAffector); } system.ParticleQuota = this.ParticleQuota; system.MaterialName = this.MaterialName; system.SetDefaultDimensions(this.defaultWidth, this.defaultHeight); system.cullIndividual = this.cullIndividual; system.sorted = this.sorted; system.localSpace = this.localSpace; system.iterationInterval = this.iterationInterval; system.iterationIntervalSet = this.iterationIntervalSet; system.nonvisibleTimeout = this.nonvisibleTimeout; system.nonvisibleTimeoutSet = this.nonvisibleTimeoutSet; if (this.color != null) { system.color = new ColorEx(this.color); } // last frame visible and time since last visible should be left default system.RendererName = this.RendererName; // FIXME if (system.renderer != null && renderer != null) { renderer.CopyParametersTo(system.renderer); } }
/// <summary> /// /// </summary> /// <param name="line"></param> /// <param name="system"></param> private void ParseAffector(string type, TextReader script, ParticleSystem system) { ParticleAffector affector = system.AddAffector(type); string line = ""; while (line != null) { line = ParseHelper.ReadLine(script); if (!(line.Length == 0 || line.StartsWith("//"))) { if (line == "}") { // finished with this affector break; } else { ParseAffectorAttrib(line.ToLower(), affector); } } // if } // while }
/// <summary> /// /// </summary> /// <param name="affector"></param> public virtual void CopyTo( ParticleAffector affector ) { // loop through all registered commands and copy from this instance to the target instance foreach ( string key in commandTable.Keys ) { // get the value of the param from this instance string val = ( (IPropertyCommand)commandTable[ key ] ).Get( this ); // set the param on the target instance affector.SetParam( key, val ); } }
/// <summary> /// Destroys the affector referenced by the parameter. /// </summary> /// <param name="e">The Affector to destroy.</param> public virtual void Destroy(ParticleAffector e) { // remove the affector from the list affectorList.Remove(e); }
/// <summary> /// /// </summary> /// <param name="line"></param> /// <param name="affector"></param> private void ParseAffectorAttrib(string line, ParticleAffector affector) { string[] values = line.Split(new char[] {' '}, 2); if(!(affector.SetParam(values[0], values[1]))) { ParseHelper.LogParserError(values[0], affector.Type, "Command not found."); } }
public ParticleAffectorTranslator() : base() { _Affector = null; }
/// <summary> /// /// </summary> /// <param name="emitter"></param> public virtual void CopyTo(ParticleAffector affector) { // loop through all registered commands and copy from this instance to the target instance foreach(DictionaryEntry entry in commandTable) { string name = (string)entry.Key; // get the value of the param from this instance string val = ((ICommand)entry.Value).Get(this); // set the param on the target instance affector.SetParam(name, val); } }
/// <summary> /// Destroys the affector referenced by the parameter. /// </summary> /// <param name="e">The Affector to destroy.</param> public virtual void Destroy( ParticleAffector e ) { // remove the affector from the list affectorList.Remove( e ); }