Example #1
0
        public override void OnVFXOutputEvent(VFXEventAttribute eventAttribute)
        {
            if (rigidBodies == null || rigidBodies.Length == 0)
            {
                return;
            }

            var position = eventAttribute.GetVector3(k_Position);
            var size     = eventAttribute.GetFloat(k_Size);
            var velocity = eventAttribute.GetVector3(k_Velocity);

            if (attributeSpace == Space.Local)
            {
                position = transform.localToWorldMatrix.MultiplyPoint(position);
                velocity = transform.localToWorldMatrix.MultiplyVector(velocity);
                // We assume that the size is bound to the X component of the transform scale
                // and that the transform is uniform.
                size = transform.localToWorldMatrix.MultiplyVector(Vector3.right * size).magnitude;
            }

            foreach (var rigidBody in rigidBodies)
            {
                if (rigidBody == null)
                {
                    continue;
                }
                switch (eventType)
                {
                case RigidBodyEventType.Impulse:
                    rigidBody.AddForce(velocity, ForceMode.Impulse);
                    break;

                case RigidBodyEventType.Explosion:
                    rigidBody.AddExplosionForce(velocity.magnitude, position, size, UpwardsModifier);
                    break;

                case RigidBodyEventType.VelocityChange:
                    rigidBody.AddForce(velocity, ForceMode.VelocityChange);
                    break;

                default:
                    break;
                }
            }
        }
Example #2
0
        public override void OnVFXOutputEvent(VFXEventAttribute eventAttribute)
        {
            CheckAndRebuildInstances();

            int freeIdx = -1;

            for (int i = 0; i < m_Instances.Length; i++)
            {
                if (!m_Instances[i].activeSelf)
                {
                    freeIdx = i;
                    break;
                }
            }

            if (freeIdx != -1)
            {
                var availableInstance = m_Instances[freeIdx];
                availableInstance.SetActive(true);
                if (usePosition && eventAttribute.HasVector3(k_PositionID))
                {
                    if (m_ParentInstances)
                    {
                        availableInstance.transform.localPosition = eventAttribute.GetVector3(k_PositionID);
                    }
                    else
                    {
                        availableInstance.transform.position = eventAttribute.GetVector3(k_PositionID);
                    }
                }

                if (useAngle && eventAttribute.HasVector3(k_AngleID))
                {
                    if (parentInstances)
                    {
                        availableInstance.transform.localEulerAngles = eventAttribute.GetVector3(k_AngleID);
                    }
                    else
                    {
                        availableInstance.transform.eulerAngles = eventAttribute.GetVector3(k_AngleID);
                    }
                }

                if (useScale && eventAttribute.HasVector3(k_ScaleID))
                {
                    availableInstance.transform.localScale = eventAttribute.GetVector3(k_ScaleID);
                }

                if (useLifetime && eventAttribute.HasFloat(k_LifetimeID))
                {
                    m_TimesToLive[freeIdx] = eventAttribute.GetFloat(k_LifetimeID);
                }
                else
                {
                    m_TimesToLive[freeIdx] = float.NegativeInfinity;
                }

                var handlers = availableInstance.GetComponentsInChildren <VFXOutputEventPrefabAttributeAbstractHandler>();
                foreach (var handler in handlers)
                {
                    handler.OnVFXEventAttribute(eventAttribute, m_VisualEffect);
                }
            } //Else, can't find an instance available, ignoring.
        }