void FillData(ref MyGPUEmitter emitter)
        {
            MatrixD mat = CalculateWorldMatrix();

            emitter.Data.RotationMatrix = mat;
            emitter.WorldPosition       = mat.Translation;
            emitter.Data.Scale          = m_effect.GetEmitterScale();
            emitter.Data.Gravity        = m_effect.Gravity * Gravity;


            emitter.ParticlesPerSecond = GetParticlesPerSecond();


            Velocity.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.Velocity);
            VelocityVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.VelocityVar);
            float cone;

            DirectionCone.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionCone = MathHelper.ToRadians(cone);
            DirectionConeVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionConeVar = MathHelper.ToRadians(cone);

            EmitterSize.GetInterpolatedValue <Vector3>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSize);
            EmitterSizeMin.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSizeMin);
        }
        public void InitDefault()
        {
            ArraySize.SetValue(Vector3.One);
            ArrayModulo.SetValue(1);

            var colorAnim = new MyAnimatedPropertyVector4();

            colorAnim.AddKey(0, Vector4.One);
            colorAnim.AddKey(0.33f, Vector4.One);
            colorAnim.AddKey(0.66f, Vector4.One);
            colorAnim.AddKey(1, Vector4.One);
            Color.AddKey(0, colorAnim);

            var colorIntensityAnim = new MyAnimatedPropertyFloat();

            colorIntensityAnim.AddKey(0, 1.0f);
            colorIntensityAnim.AddKey(0.33f, 1.0f);
            colorIntensityAnim.AddKey(0.66f, 1.0f);
            colorIntensityAnim.AddKey(1, 1.0f);
            ColorIntensity.AddKey(0, colorIntensityAnim);

            Offset.SetValue(new Vector3(0, 0, 0));
            Direction.SetValue(new Vector3(0, 0, -1));

            var radiusAnim = new MyAnimatedPropertyFloat();

            radiusAnim.AddKey(0, 0.1f);
            radiusAnim.AddKey(0.33f, 0.1f);
            radiusAnim.AddKey(0.66f, 0.1f);
            radiusAnim.AddKey(1, 0.1f);
            Radius.AddKey(0, radiusAnim);

            Life.SetValue(1);

            StreakMultiplier.SetValue(4);
            AnimationFrameTime.SetValue(1);

            Enabled.SetValue(true);

            EmitterSize.AddKey(0, new Vector3(0.0f, 0.0f, 0.0f));
            EmitterSizeMin.AddKey(0, 0.0f);
            DirectionCone.AddKey(0, 0.0f);
            DirectionConeVar.AddKey(0, 0.0f);

            Velocity.AddKey(0, 1.0f);
            VelocityVar.AddKey(0, 0.0f);

            ParticlesPerSecond.AddKey(0, 1000.0f);
            Material.SetValue(MyTransparentMaterials.GetMaterial("WhiteBlock"));

            SoftParticleDistanceScale.SetValue(1);
            Bounciness.SetValue(0.5f);
            ColorVar.SetValue(0);
            HueVar.SetValue(0);

            OITWeightFactor.SetValue(1f);

            TargetCoverage.SetValue(1f);
        }
Beispiel #3
0
        private void FillData(ref MyGPUEmitter emitter)
        {
            MatrixD mat = CalculateWorldMatrix();

            emitter.Data.RotationMatrix = mat;
            emitter.WorldPosition       = mat.Translation;
            emitter.Data.Scale          = m_effect.GetEmitterScale();
            emitter.Data.Gravity        = m_effect.Gravity * Gravity;
            Vector3 angle    = Angle;
            Vector3 angleVar = AngleVar;

            if (angleVar.LengthSquared() > 0)
            {
                angle = new Vector3(
                    MyUtils.GetRandomFloat(angle.X - angleVar.X, angle.X + angleVar.X),
                    MyUtils.GetRandomFloat(angle.Y - angleVar.Y, angle.Y + angleVar.Y),
                    MyUtils.GetRandomFloat(angle.Z - angleVar.Z, angle.Z + angleVar.Z));
            }
            Matrix rot;

            if (angle.LengthSquared() > 0)
            {
                rot = Matrix.CreateFromAxisAngle(mat.Right, MathHelper.ToRadians(angle.X)) *
                      Matrix.CreateFromAxisAngle(mat.Up, MathHelper.ToRadians(angle.Y)) *
                      Matrix.CreateFromAxisAngle(mat.Forward, MathHelper.ToRadians(angle.Z));
            }
            else
            {
                rot = mat;
            }
            emitter.Data.ParticleRotationRow0 = rot.Right;
            emitter.Data.ParticleRotationRow1 = rot.Up;
            emitter.Data.ParticleRotationRow2 = rot.Backward;

            emitter.ParticlesPerSecond = m_currentParticlesPerSecond = GetParticlesPerSecond();


            Velocity.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.Velocity);
            VelocityVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.VelocityVar);
            float cone;

            DirectionInnerCone.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionInnerCone = cone;// MathHelper.ToRadians(cone);
            DirectionConeVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionConeVar = MathHelper.ToRadians(cone);

            EmitterSize.GetInterpolatedValue <Vector3>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSize);
            EmitterSizeMin.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSizeMin);
        }
Beispiel #4
0
        private void FillData(ref MyGPUEmitter emitter)
        {
            MatrixD mat = CalculateWorldMatrix();

            emitter.Data.RotationMatrix = mat;
            emitter.WorldPosition       = mat.Translation;
            emitter.Data.Scale          = m_effect.GetEmitterScale();
            emitter.Data.Gravity        = m_effect.Gravity * Gravity;
            var rotMat = CalculateParticleRotation(mat);

            emitter.Data.ParticleRotationRow0 = rotMat.Right;
            emitter.Data.ParticleRotationRow1 = rotMat.Up;
            emitter.Data.ParticleRotationRow2 = rotMat.Backward;

            emitter.ParticlesPerSecond = m_currentParticlesPerSecond = GetParticlesPerSecond();


            if (ParticlesPerFrame.GetKeysCount() > 0)
            {
                float keyTime, diff;
                ParticlesPerFrame.GetNextValue(m_effect.GetElapsedTime() - VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS, out emitter.ParticlesPerFrame,
                                               out keyTime, out diff);
                if (keyTime < (m_effect.GetElapsedTime() - VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS) ||
                    keyTime >= m_effect.GetElapsedTime())
                {
                    emitter.ParticlesPerFrame = 0;
                }
                else
                {
                    emitter.ParticlesPerFrame *= m_effect.UserBirthMultiplier;
                }
            }


            Velocity.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.Velocity);
            VelocityVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.VelocityVar);
            float cone;

            DirectionInnerCone.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionInnerCone = cone;// MathHelper.ToRadians(cone);
            DirectionConeVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionConeVar = MathHelper.ToRadians(cone);

            EmitterSize.GetInterpolatedValue <Vector3>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSize);
            EmitterSizeMin.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSizeMin);
        }
Beispiel #5
0
        public override void Save()
        {
            XmlDocument doc  = new XmlDocument();
            XmlElement  root = doc.CreateElement("particleemitter");

            doc.AppendChild(root);

            root.AppendChild(doc.CreateElement("material").SimpleTag("name", Material));
            root.AppendChild(doc.CreateElement("numparticles").SimpleTag("value", NumParticles.ToString()));
            root.AppendChild(doc.CreateElement("updateinvisible").SimpleTag("enable", UpdateInvisible ? "true" : "false"));
            root.AppendChild(doc.CreateElement("relative").SimpleTag("enable", Relative ? "true" : "false"));
            root.AppendChild(doc.CreateElement("scaled").SimpleTag("enable", Scaled ? "true" : "false"));
            root.AppendChild(doc.CreateElement("sorted").SimpleTag("enable", Sorted ? "true" : "false"));
            root.AppendChild(doc.CreateElement("animlodbias").SimpleTag("value", AnimLodBias.ToString()));
            root.AppendChild(doc.CreateElement("emittertype").ValueTag(Type.ToString().ToLower()));
            if (EmitterSize != null)
            {
                root.AppendChild(doc.CreateElement("emittersize").ValueTag(EmitterSize.ToString()));
            }
            root.AppendChild(doc.CreateElement("emitterradius").ValueTag(EmitterRadius.ToString()));

            XmlElement dir = doc.CreateElement("direction");

            dir.SetAttribute("min", DirectionMin.ToString());
            dir.SetAttribute("max", DirectionMax.ToString());
            root.AppendChild(dir);

            root.AppendChild(doc.CreateElement("constantforce").ValueTag(ConstantForce.ToString()));
            root.AppendChild(doc.CreateElement("dampingforce").ValueTag(DampingForce.ToString()));
            root.AppendChild(doc.CreateElement("activetime").ValueTag(ActiveTime.ToString()));
            root.AppendChild(doc.CreateElement("inactivetime").ValueTag(InActiveTime.ToString()));
            root.AppendChild(Interval.ToElement(doc.CreateElement("interval")));
            root.AppendChild(EmissionRate.ToElement(doc.CreateElement("emissionrate")));

            XmlElement psize = doc.CreateElement("particlesize");

            psize.SetAttribute("min", MinSize.ToString());
            psize.SetAttribute("max", MaxSize.ToString());
            root.AppendChild(psize);

            root.AppendChild(TimeToLive.ToElement(doc.CreateElement("timetolive")));
            root.AppendChild(Velocity.ToElement(doc.CreateElement("velocity")));
            root.AppendChild(Rotation.ToElement(doc.CreateElement("rotation")));
            root.AppendChild(RotationSpeed.ToElement(doc.CreateElement("rotationspeed")));
            //SIZE DELTA
            XmlElement sized = doc.CreateElement("sizedelta");

            sized.SetAttribute("add", SizeDelta.X.ToString());
            sized.SetAttribute("mul", SizeDelta.Y.ToString());
            root.AppendChild(sized);

            foreach (ParticleColorFade f in ColorFade)
            {
                XmlElement e = doc.CreateElement("colorfade");
                e.SetAttribute("color", f.Color.ToString());
                e.SetAttribute("time", f.Time.ToString());
                root.AppendChild(e);
            }
            foreach (ParticleTexAnim a in TextureAnim)
            {
                XmlElement e = doc.CreateElement("texanim");
                e.SetAttribute("uv", a.Animation.ToString());
                e.SetAttribute("time", a.Time.ToString());
                root.AppendChild(e);
            }

            XmlWriterSettings xws = new XmlWriterSettings {
                OmitXmlDeclaration = true, Indent = true
            };

            using (XmlWriter xw = XmlWriter.Create(System.IO.Path.ChangeExtension(Name, "xml"), xws))
                doc.Save(xw);
        }
        void FillDataComplete(ref MyGPUEmitter emitter)
        {
            float time;

            m_animatedTimeValues = Velocity.GetKeysCount() > 1 ||
                                   VelocityVar.GetKeysCount() > 1 ||
                                   DirectionCone.GetKeysCount() > 1 ||
                                   DirectionConeVar.GetKeysCount() > 1 ||
                                   EmitterSize.GetKeysCount() > 1 ||
                                   EmitterSizeMin.GetKeysCount() > 1;

            MyAnimatedPropertyVector4 color;

            Color.GetKey(0, out time, out color);
            color.GetKey(0, out time, out emitter.Data.Color0);
            color.GetKey(1, out emitter.Data.ColorKey1, out emitter.Data.Color1);
            color.GetKey(2, out emitter.Data.ColorKey2, out emitter.Data.Color2);
            color.GetKey(3, out time, out emitter.Data.Color3);

            m_currentParticlesPerSecond = GetParticlesPerSecond();
            emitter.ParticlesPerSecond  = m_show ? m_currentParticlesPerSecond : 0;

            // unmultiply colors and factor by intensity
            MyAnimatedPropertyFloat colorIntensity;
            float intensity;

            ColorIntensity.GetKey(0, out time, out colorIntensity);
            colorIntensity.GetInterpolatedValue <float>(0, out intensity);
            emitter.Data.Color0.X *= intensity;
            emitter.Data.Color0.Y *= intensity;
            emitter.Data.Color0.Z *= intensity;
            colorIntensity.GetInterpolatedValue <float>(emitter.Data.ColorKey1, out intensity);
            emitter.Data.Color1.X *= intensity;
            emitter.Data.Color1.Y *= intensity;
            emitter.Data.Color1.Z *= intensity;
            colorIntensity.GetInterpolatedValue <float>(emitter.Data.ColorKey2, out intensity);
            emitter.Data.Color2.X *= intensity;
            emitter.Data.Color2.Y *= intensity;
            emitter.Data.Color2.Z *= intensity;
            colorIntensity.GetInterpolatedValue <float>(1.0f, out intensity);
            emitter.Data.Color3.X *= intensity;
            emitter.Data.Color3.Y *= intensity;
            emitter.Data.Color3.Z *= intensity;

            emitter.Data.Color0 *= m_effect.UserColorMultiplier;
            emitter.Data.Color1 *= m_effect.UserColorMultiplier;
            emitter.Data.Color2 *= m_effect.UserColorMultiplier;
            emitter.Data.Color3 *= m_effect.UserColorMultiplier;

            MyAnimatedPropertyFloat radius;

            Radius.GetKey(0, out time, out radius);
            radius.GetKey(0, out time, out emitter.Data.ParticleSize0);
            radius.GetKey(1, out emitter.Data.ParticleSizeKeys1, out emitter.Data.ParticleSize1);
            radius.GetKey(2, out emitter.Data.ParticleSizeKeys2, out emitter.Data.ParticleSize2);
            radius.GetKey(3, out time, out emitter.Data.ParticleSize3);
            emitter.Data.ParticleSize0 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize1 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize2 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize3 *= m_effect.UserRadiusMultiplier;

            emitter.Data.ColorVar = ColorVar;
            if (emitter.Data.ColorVar > 1.0f)
            {
                emitter.Data.ColorVar = 1.0f;
            }
            else if (emitter.Data.ColorVar < 0)
            {
                emitter.Data.ColorVar = 0;
            }
            emitter.Data.HueVar = HueVar;
            if (emitter.Data.HueVar > 1.0f)
            {
                emitter.Data.HueVar = 1.0f;
            }
            else if (emitter.Data.HueVar < 0)
            {
                emitter.Data.HueVar = 0;
            }

            emitter.Data.Bounciness = Bounciness;

            emitter.Data.ParticleLifeSpan = Life;

            emitter.Data.Direction = Direction;

            emitter.Data.RotationVelocity    = RotationVelocity;
            emitter.Data.RotationVelocityVar = RotationVelocityVar;

            emitter.Data.Acceleration     = Acceleration;
            emitter.Data.StreakMultiplier = StreakMultiplier;

            emitter.Data.SoftParticleDistanceScale = SoftParticleDistanceScale;
            emitter.Data.AnimationFrameTime        = AnimationFrameTime;
            emitter.Data.OITWeightFactor           = OITWeightFactor;

            emitter.AtlasTexture     = (Material.GetValue <MyTransparentMaterial>()).Texture;
            emitter.AtlasDimension   = new Vector2I((int)ArraySize.GetValue <Vector3>().X, (int)ArraySize.GetValue <Vector3>().Y);
            emitter.AtlasFrameOffset = ArrayOffset;
            emitter.AtlasFrameModulo = ArrayModulo;

            GPUEmitterFlags flags = 0;

            flags |= Streaks ? GPUEmitterFlags.Streaks : 0;
            flags |= Collide ? GPUEmitterFlags.Collide : 0;
            flags |= SleepState ? GPUEmitterFlags.SleepState : 0;
            flags |= Light ? GPUEmitterFlags.Light : 0;
            flags |= VolumetricLight ? GPUEmitterFlags.VolumetricLight : 0;
            flags |= m_effect.IsSimulationPaused || MyParticlesManager.Paused ? GPUEmitterFlags.FreezeSimulate : 0;
            flags |= MyParticlesManager.Paused ? GPUEmitterFlags.FreezeEmit : 0;

            emitter.Data.Flags = flags;

            emitter.GID = m_renderId;

            FillData(ref emitter);
        }
        void FillData(ref MyGPUEmitter emitter)
        {
            float time;
            MyAnimatedPropertyVector4 color;
            MyAnimatedPropertyFloat   radius;
            MyAnimatedPropertyFloat   colorIntensity;

            Color.GetKey(0, out time, out color);
            Radius.GetKey(0, out time, out radius);
            ColorIntensity.GetKey(0, out time, out colorIntensity);

            emitter.GID = m_renderId;
            if (Enabled.GetValue <bool>() && !m_effect.IsEmittingStopped)
            {
                ParticlesPerSecond.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.ParticlesPerSecond);
                emitter.ParticlesPerSecond *= m_effect.UserBirthMultiplier;
            }
            else
            {
                emitter.ParticlesPerSecond = 0;
            }

            float intensity;

            color.GetKey(0, out time, out emitter.Data.Color0);
            color.GetKey(1, out emitter.Data.ColorKey1, out emitter.Data.Color1);
            color.GetKey(2, out emitter.Data.ColorKey2, out emitter.Data.Color2);
            color.GetKey(3, out time, out emitter.Data.Color3);

            // unmultiply colors and factor by intensity
            colorIntensity.GetInterpolatedValue <float>(0, out intensity);
            emitter.Data.Color0.X *= intensity;
            emitter.Data.Color0.Y *= intensity;
            emitter.Data.Color0.Z *= intensity;
            emitter.Data.Color0   *= m_effect.UserColorMultiplier;
            colorIntensity.GetInterpolatedValue <float>(emitter.Data.ColorKey1, out intensity);
            emitter.Data.Color1.X *= intensity;
            emitter.Data.Color1.Y *= intensity;
            emitter.Data.Color1.Z *= intensity;
            emitter.Data.Color1   *= m_effect.UserColorMultiplier;
            colorIntensity.GetInterpolatedValue <float>(emitter.Data.ColorKey2, out intensity);
            emitter.Data.Color2.X *= intensity;
            emitter.Data.Color2.Y *= intensity;
            emitter.Data.Color2.Z *= intensity;
            emitter.Data.Color2   *= m_effect.UserColorMultiplier;
            colorIntensity.GetInterpolatedValue <float>(1.0f, out intensity);
            emitter.Data.Color3.X *= intensity;
            emitter.Data.Color3.Y *= intensity;
            emitter.Data.Color3.Z *= intensity;
            emitter.Data.Color3   *= m_effect.UserColorMultiplier;

            emitter.Data.ColorVar = ColorVar;
            if (emitter.Data.ColorVar > 1.0f)
            {
                emitter.Data.ColorVar = 1.0f;
            }
            else if (emitter.Data.ColorVar < 0)
            {
                emitter.Data.ColorVar = 0;
            }
            emitter.Data.HueVar = HueVar;
            if (emitter.Data.HueVar > 1.0f)
            {
                emitter.Data.HueVar = 1.0f;
            }
            else if (emitter.Data.HueVar < 0)
            {
                emitter.Data.HueVar = 0;
            }

            emitter.Data.Bounciness = Bounciness;

            MatrixD mat = CalculateWorldMatrix();

            emitter.Data.RotationMatrix = mat;
            emitter.Data.Direction      = Direction;
            Velocity.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.Velocity);
            VelocityVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.VelocityVar);
            float cone;

            DirectionCone.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionCone = MathHelper.ToRadians(cone);
            DirectionConeVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out cone);
            emitter.Data.DirectionConeVar = MathHelper.ToRadians(cone);

            emitter.Data.NumParticlesToEmitThisFrame = 0;

            emitter.Data.ParticleLifeSpan = Life;

            radius.GetKey(0, out time, out emitter.Data.ParticleSize0);
            radius.GetKey(1, out emitter.Data.ParticleSizeKeys1, out emitter.Data.ParticleSize1);
            radius.GetKey(2, out emitter.Data.ParticleSizeKeys2, out emitter.Data.ParticleSize2);
            radius.GetKey(3, out time, out emitter.Data.ParticleSize3);
            emitter.Data.ParticleSize0 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize1 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize2 *= m_effect.UserRadiusMultiplier;
            emitter.Data.ParticleSize3 *= m_effect.UserRadiusMultiplier;

            EmitterSize.GetInterpolatedValue <Vector3>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSize);
            EmitterSizeMin.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out emitter.Data.EmitterSizeMin);
            emitter.Data.RotationVelocity    = RotationVelocity;
            emitter.Data.RotationVelocityVar = RotationVelocityVar;

            emitter.Data.Acceleration     = Acceleration;
            emitter.Data.Gravity          = m_effect.Gravity * Gravity;
            emitter.Data.StreakMultiplier = StreakMultiplier;

            GPUEmitterFlags flags = 0;

            flags |= Streaks ? GPUEmitterFlags.Streaks : 0;
            flags |= Collide ? GPUEmitterFlags.Collide : 0;
            flags |= SleepState ? GPUEmitterFlags.SleepState : 0;
            flags |= Light ? GPUEmitterFlags.Light : 0;
            flags |= VolumetricLight ? GPUEmitterFlags.VolumetricLight : 0;
            flags |= m_effect.IsSimulationPaused ? GPUEmitterFlags.FreezeSimulate : 0;

            emitter.Data.Flags = flags;

            emitter.Data.SoftParticleDistanceScale = SoftParticleDistanceScale;
            emitter.Data.AnimationFrameTime        = AnimationFrameTime;
            emitter.Data.OITWeightFactor           = OITWeightFactor;

            emitter.Data.Scale = m_effect.GetEmitterScale();

            emitter.AtlasTexture     = (Material.GetValue <MyTransparentMaterial>()).Texture;
            emitter.AtlasDimension   = new Vector2I((int)ArraySize.GetValue <Vector3>().X, (int)ArraySize.GetValue <Vector3>().Y);
            emitter.AtlasFrameOffset = ArrayOffset;
            emitter.AtlasFrameModulo = ArrayModulo;
            emitter.WorldPosition    = mat.Translation;
        }