Ejemplo n.º 1
0
        public MyParticleEffect CreateInstance()
        {
            MyParticleEffect effect = MyParticlesManager.EffectsPool.Allocate();

            effect.Start(m_particleID);

            effect.Name    = Name;
            effect.Enabled = Enabled;
            effect.SetLength(GetLength());
            effect.SetPreload(GetPreload());
            effect.LowRes = LowRes;

            foreach (MyParticleGeneration generation in m_generations)
            {
                MyParticleGeneration gen = generation.CreateInstance(effect);
                if (gen != null)
                {
                    effect.AddGeneration(gen);
                }
            }

            if (m_instances == null)
            {
                m_instances = new List <MyParticleEffect>();
            }

            m_instances.Add(effect);

            return(effect);
        }
        //  For sorting generations if needed
        public int CompareTo(object compareToObject)
        {
            MyParticleGeneration compareToGeneration = (MyParticleGeneration)compareToObject;

            if (UseLayerSorting && compareToGeneration.UseLayerSorting)
            {
                return(SortLayer.GetValue <int>().CompareTo(compareToGeneration.SortLayer.GetValue <int>()));
            }

            return(0);
        }
Ejemplo n.º 3
0
        public void AddGeneration(MyParticleGeneration generation)
        {
            m_generations.Add(generation);

            if (m_instances != null)
            {
                foreach (MyParticleEffect effect in m_instances)
                {
                    effect.AddGeneration(generation.CreateInstance(effect));
                }
            }
        }
        public MyParticleGeneration Duplicate(MyParticleEffect effect)
        {
            MyParticleGeneration generation = MyParticlesManager.GenerationsPool.Allocate();

            generation.Start(effect);

            generation.Name = Name;

            for (int i = 0; i < m_properties.Length; i++)
            {
                generation.m_properties[i] = m_properties[i].Duplicate();
            }

            m_emitter.Duplicate(generation.m_emitter);

            return(generation);
        }
Ejemplo n.º 5
0
        public void Start(MyParticleGeneration generation)
        {
            System.Diagnostics.Debug.Assert(Life > 0);

            m_elapsedTime        = 0;
            m_normalizedTime     = 0.0f;
            m_elapsedTimeDivider = MyConstants.PHYSICS_STEP_SIZE_IN_SECONDS / Life;
            m_generation         = generation;

            MyUtils.AssertIsValid(StartPosition);
            MyUtils.AssertIsValid(Angle);
            MyUtils.AssertIsValid(Velocity);
            MyUtils.AssertIsValid(RotationSpeed);

            m_actualPosition = StartPosition;
            m_actualAngle    = Angle;
        }
Ejemplo n.º 6
0
        public void RemoveGeneration(int index)
        {
            MyParticleGeneration generation = m_generations[index];

            m_generations.Remove(generation);

            generation.Close();
            MyParticlesManager.GenerationsPool.Deallocate(generation);

            if (m_instances != null)
            {
                foreach (MyParticleEffect effect in m_instances)
                {
                    effect.RemoveGeneration(index);
                }
            }
        }
Ejemplo n.º 7
0
        public MyParticleEffect Duplicate()
        {
            MyParticleEffect effect = MyParticlesManager.EffectsPool.Allocate();

            effect.Start(0);

            effect.Name      = Name;
            effect.m_preload = m_preload;
            effect.m_length  = m_length;

            foreach (MyParticleGeneration generation in m_generations)
            {
                MyParticleGeneration duplicatedGeneration = generation.Duplicate(effect);
                effect.AddGeneration(duplicatedGeneration);
            }

            return(effect);
        }
        public MyParticleGeneration CreateInstance(MyParticleEffect effect)
        {
            MyParticleGeneration generation = MyParticlesManager.GenerationsPool.Allocate(true);

            if (generation == null)
            {
                return(null);
            }

            generation.Start(effect);

            generation.Name = Name;

            for (int i = 0; i < m_properties.Length; i++)
            {
                generation.m_properties[i] = m_properties[i];
            }

            generation.m_emitter.CreateInstance(m_emitter);

            return(generation);
        }
Ejemplo n.º 9
0
        public void Deserialize(XmlReader reader)
        {
            m_name = reader.GetAttribute("name");
            int version = Convert.ToInt32(reader.GetAttribute("version"));

            reader.ReadStartElement(); //ParticleEffect

            m_particleID = reader.ReadElementContentAsInt();

            m_length = reader.ReadElementContentAsFloat();

            m_preload = reader.ReadElementContentAsFloat();

            if (reader.Name == "LowRes")
            {
                LowRes = reader.ReadElementContentAsBoolean();
            }

            bool isEmpty = reader.IsEmptyElement;

            reader.ReadStartElement(); //Generations

            while (reader.NodeType != XmlNodeType.EndElement)
            {
                MyParticleGeneration generation = MyParticlesManager.GenerationsPool.Allocate();
                generation.Start(this);
                generation.Init();

                generation.Deserialize(reader);

                AddGeneration(generation);
            }

            if (!isEmpty)
            {
                reader.ReadEndElement(); //Generations
            }
            reader.ReadEndElement();     //ParticleEffect
        }
Ejemplo n.º 10
0
        private void UpdateParticlesCreation()
        {
            if (!Enabled.GetValue <bool>())
            {
                return;
            }

            //particles to create in this update
            if (!m_effect.IsStopped)
            {
                float lodBirth = 1.0f;
                if (GetEffect().EnableLods)
                {
                    LODBirth.GetInterpolatedValue <float>(GetEffect().Distance, out lodBirth);
                }

                Birth.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out m_birthRate);
                m_birthRate *=
                    MyConstants.PHYSICS_STEP_SIZE_IN_SECONDS
                    * (EnableCustomBirth ? m_effect.UserBirthMultiplier : 1.0f)
                    * MyParticlesManager.BirthMultiplierOverall
                    * lodBirth;

                m_particlesToCreate += m_birthRate;
            }

            //If speed of effect is too high, there would be created bunches
            //of particles each frame. By interpolating position, we create
            //seamless particle creation.
            Vector3 positionDelta = Vector3.Zero;

            if (!m_lastEffectPosition.HasValue)
            {
                m_lastEffectPosition = EffectMatrix.Translation;
            }

            //Position delta interpolates particle position at fast flying objects, dont do that while motion inheritance
            if (m_particlesToCreate > 1.0f && !m_effect.CalculateDeltaMatrix)
            {
                positionDelta = (EffectMatrix.Translation - m_lastEffectPosition.Value) / (int)m_particlesToCreate;
            }

            //MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("CreateParticle");


            using (ParticlesLock.AcquireExclusiveUsing())
            {
                int maxParticles = 40;
                while (m_particlesToCreate >= 1.0f && maxParticles-- > 0)
                {
                    if (m_effect.CalculateDeltaMatrix)
                    {
                        CreateParticle(EffectMatrix.Translation);
                    }
                    else
                    {
                        CreateParticle(m_lastEffectPosition.Value + positionDelta * (int)m_particlesToCreate);
                    }

                    m_particlesToCreate -= 1.0f;
                }
            }

            //   MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartNextBlock("OnLife");

            if (OnLife.GetValue <int>() != -1)
            {
                MyParticleGeneration inheritedGeneration = GetInheritedGeneration(OnLife.GetValue <int>());

                if (inheritedGeneration == null)
                {
                    OnLife.SetValue(-1);
                }
                else
                {
                    inheritedGeneration.IsInherited = true;

                    float particlesToCreate = inheritedGeneration.m_particlesToCreate;

                    using (ParticlesLock.AcquireSharedUsing())
                    {
                        foreach (MyAnimatedParticle particle in m_particles)
                        {
                            inheritedGeneration.m_particlesToCreate = particlesToCreate;
                            inheritedGeneration.EffectMatrix        = Matrix.CreateWorld(particle.ActualPosition, particle.Velocity, Vector3.Cross(Vector3.Left, particle.Velocity));
                            inheritedGeneration.UpdateParticlesCreation();
                        }
                    }
                }
            }

            //  MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();

            m_lastEffectPosition = EffectMatrix.Translation;
        }
Ejemplo n.º 11
0
        private void UpdateParticlesLife()
        {
            int counter = 0;

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("ParticleGeneration-UpdateParticlesLife");

            MyParticleGeneration inheritedGeneration = null;
            Vector3 previousParticlePosition         = m_effect.WorldMatrix.Translation;
            float   particlesToCreate = 0;

            m_AABB = m_AABB.CreateInvalid();
            m_AABB = m_AABB.Include(ref previousParticlePosition);

            if (OnDie.GetValue <int>() != -1)
            {
                inheritedGeneration = GetInheritedGeneration(OnDie.GetValue <int>());

                if (inheritedGeneration == null)
                {
                    OnDie.SetValue(-1);
                }
                else
                {
                    inheritedGeneration.IsInherited = true;
                    particlesToCreate = inheritedGeneration.m_particlesToCreate;
                }
            }

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().StartProfilingBlock("ParticleGeneration-Update01");

            Vector3 previousTrail0 = previousParticlePosition;
            Vector3 previousTrail1 = previousParticlePosition;

            using (ParticlesLock.AcquireExclusiveUsing())
            {
                while (counter < m_particles.Count)
                {
                    float motionInheritance;
                    MotionInheritance.GetInterpolatedValue(m_effect.GetElapsedTime(), out motionInheritance);

                    MyAnimatedParticle particle = m_particles[counter];

                    if (motionInheritance > 0)
                    {
                        m_effect.CalculateDeltaMatrix = true;
                    }

                    if (particle.Update())
                    {
                        if (motionInheritance > 0)
                        {
                            particle.AddMotionInheritance(ref motionInheritance, ref m_effect.DeltaMatrix);
                        }

                        if (counter == 0)
                        {
                            previousParticlePosition = particle.ActualPosition;
                            previousTrail0           = particle.Quad.Point1;
                            previousTrail1           = particle.Quad.Point2;
                            particle.Quad.Point0     = particle.ActualPosition;
                            particle.Quad.Point2     = particle.ActualPosition;
                        }

                        counter++;


                        if (particle.Type == MyParticleTypeEnum.Trail)
                        {
                            if (particle.ActualPosition == previousParticlePosition)
                            {
                                particle.Quad.Point0 = particle.ActualPosition;
                                particle.Quad.Point1 = particle.ActualPosition;
                                particle.Quad.Point2 = particle.ActualPosition;
                                particle.Quad.Point3 = particle.ActualPosition;
                            }
                            else
                            {
                                MyPolyLine polyLine = new MyPolyLine();
                                polyLine.Thickness = particle.Thickness;
                                polyLine.Point0    = particle.ActualPosition;
                                polyLine.Point1    = previousParticlePosition;

                                Vector3 direction           = polyLine.Point1 - polyLine.Point0;
                                Vector3 normalizedDirection = MyMwcUtils.Normalize(polyLine.Point1 - polyLine.Point0);


                                polyLine.Point1 = polyLine.Point0 + (polyLine.Point1 - polyLine.Point0);

                                polyLine.LineDirectionNormalized = normalizedDirection;
                                MyUtils.GetPolyLineQuad(out particle.Quad, ref polyLine);

                                particle.Quad.Point0 = previousTrail0 + direction * 0.15f;
                                particle.Quad.Point3 = previousTrail1 + direction * 0.15f;
                                previousTrail0       = particle.Quad.Point1;
                                previousTrail1       = particle.Quad.Point2;
                            }
                        }

                        previousParticlePosition = particle.ActualPosition;

                        m_AABB         = m_AABB.Include(ref previousParticlePosition);
                        particle.Flags = GetEffect().IsInFrustum ? particle.Flags | MyAnimatedParticle.ParticleFlags.IsInFrustum : particle.Flags & ~MyAnimatedParticle.ParticleFlags.IsInFrustum;
                        continue;
                    }

                    if (inheritedGeneration != null)
                    {
                        inheritedGeneration.m_particlesToCreate = particlesToCreate;
                        inheritedGeneration.EffectMatrix        = Matrix.CreateWorld(particle.ActualPosition, Vector3.Normalize(particle.Velocity), Vector3.Cross(Vector3.Left, particle.Velocity));
                        inheritedGeneration.UpdateParticlesCreation();
                    }

                    m_particles.Remove(particle);
                    MyTransparentGeometry.DeallocateAnimatedParticle(particle);
                }
            }

            MinerWars.AppCode.Game.Render.MyRender.GetRenderProfiler().EndProfilingBlock();
        }
Ejemplo n.º 12
0
        public void RemoveGeneration(MyParticleGeneration generation)
        {
            int index = m_generations.IndexOf(generation);

            RemoveGeneration(index);
        }