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);
        }
Ejemplo n.º 2
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);
        }
Ejemplo n.º 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;
            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);
        }
        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;
        }