protected virtual void OnParticleCollision(GameObject hitGameObject)
        {
            // Get the collision events array
            var count = cachedParticleSystem.GetSafeCollisionEventSize();

            // Expand collisionEvents list to fit all particles
            for (var i = particleCollisionEvents.Count; i < count; i++)
            {
                particleCollisionEvents.Add(new ParticleCollisionEvent());
            }

            count = cachedParticleSystem.GetCollisionEvents(hitGameObject, particleCollisionEvents);

            // Calculate up vector ahead of time
            var finalUp = orientation == OrientationType.CameraUp ? P3dHelper.GetCameraUp(_camera) : Vector3.up;

            // Paint all locations
            for (var i = 0; i < count; i++)
            {
                var collisionEvent = particleCollisionEvents[i];
                var finalPosition  = collisionEvent.intersection + collisionEvent.normal * offset;
                var finalNormal    = normal == NormalType.CollisionNormal ? collisionEvent.normal : -collisionEvent.velocity;
                var finalRotation  = finalNormal != Vector3.zero ? Quaternion.LookRotation(finalNormal, finalUp) : Quaternion.identity;

                hitCache.InvokePoints(gameObject, null, null, false, collisionEvent.colliderComponent as Collider, finalPosition, finalRotation, 1.0f);
            }
        }
示例#2
0
        protected void DispatchHits(bool preview, Collider collider, Vector3 worldPosition, Quaternion worldRotation, float pressure, object owner)
        {
            if (connectHits == true && owner != null)
            {
                var link = default(Link);

                if (TryGetLink(owner, ref link) == true)
                {
                    if (link.Preview == preview)
                    {
                        hitCache.InvokeLines(gameObject, null, null, preview, link.WorldPosition, worldPosition, link.Pressure, pressure);
                    }
                    else
                    {
                        hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
                    }
                }
                else
                {
                    link = linkPool.Count > 0 ? linkPool.Pop() : new Link();

                    link.Owner = owner;

                    links.Add(link);

                    hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
                }

                link.WorldPosition = worldPosition;
                link.Pressure      = pressure;
                link.Preview       = preview;
            }
            else
            {
                hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
            }
        }
        protected virtual void OnParticleCollision(GameObject hitGameObject)
        {
            // Get the collision events array
            var count = cachedParticleSystem.GetSafeCollisionEventSize();

            // Expand collisionEvents list to fit all particles
            for (var i = particleCollisionEvents.Count; i < count; i++)
            {
                particleCollisionEvents.Add(new ParticleCollisionEvent());
            }

            count = cachedParticleSystem.GetCollisionEvents(hitGameObject, particleCollisionEvents);

            // Calculate up vector ahead of time
            var finalUp = orientation == OrientationType.CameraUp ? P3dHelper.GetCameraUp(_camera) : Vector3.up;

            // Paint all locations
            for (var i = 0; i < count; i++)
            {
                if (skip > 0)
                {
                    if (skipCounter++ > skip)
                    {
                        skipCounter = 0;
                    }
                    else
                    {
                        continue;
                    }
                }

                var collisionEvent = particleCollisionEvents[i];
                var finalPosition  = collisionEvent.intersection + collisionEvent.normal * offset;
                var finalNormal    = normal == NormalType.CollisionNormal ? -collisionEvent.normal : collisionEvent.velocity;
                var finalRotation  = finalNormal != Vector3.zero ? Quaternion.LookRotation(finalNormal, finalUp) : Quaternion.identity;
                var finalPressure  = pressure;

                if (pressureMinDistance != pressureMaxDistance)
                {
                    var distance = Vector3.Distance(transform.position, collisionEvent.intersection);

                    finalPressure *= Mathf.InverseLerp(pressureMinDistance, pressureMaxDistance, distance);
                }

                hitCache.InvokePoints(gameObject, preview, priority, collisionEvent.colliderComponent as Collider, finalPosition, finalRotation, finalPressure);
            }
        }
示例#4
0
        private void CheckCollision(Collision collision)
        {
            if (cooldown > 0.0f)
            {
                return;
            }

            var speed = collision.relativeVelocity.magnitude;

            // Only handle the collision if the impact was strong enough
            if (speed >= speedMin)
            {
                cooldown = delay;

                // Calculate up vector ahead of time
                var finalUp  = orientation == OrientationType.CameraUp ? P3dHelper.GetCameraUp(_camera) : Vector3.up;
                var contacts = collision.contacts;
                var pressure = Mathf.InverseLerp(speedMin, speedPressure, speed);

                for (var i = contacts.Length - 1; i >= 0; i--)
                {
                    var contact       = contacts[i];
                    var finalPosition = contact.point + contact.normal * offset;
                    var finalRotation = Quaternion.LookRotation(-contact.normal, finalUp);

                    hitCache.InvokePoints(gameObject, null, null, false, contact.otherCollider, finalPosition, finalRotation, 1.0f);

                    if (raycastDistance > 0.0f)
                    {
                        var ray = new Ray(contact.point + contact.normal * raycastDistance, -contact.normal);
                        var hit = default(RaycastHit);

                        if (contact.otherCollider.Raycast(ray, out hit, raycastDistance * 2.0f) == true)
                        {
                            hitCache.InvokeRaycast(gameObject, null, null, false, hit, pressure);
                        }
                    }

                    if (onlyUseFirstContact == true)
                    {
                        break;
                    }
                }
            }
        }
        private IEnumerator DelayedOnHit(Vector3 pointA, Vector3 pointB)
        {
            var vector      = pointB - pointA;
            var maxDistance = vector.magnitude;
            var ray         = new Ray(pointA, vector);
            var hit         = default(RaycastHit);

            if (Physics.Raycast(ray, out hit, maxDistance, layers) == true)
            {
                var distance01 = Mathf.InverseLerp(0.0f, radius, hit.distance);

                // Wait based on hit distance
                yield return(new WaitForSeconds(distance01 * delayMax));

                var finalUp       = orientation == OrientationType.CameraUp ? P3dHelper.GetCameraUp(_camera) : Vector3.up;
                var finalPosition = hit.point + hit.normal * offset;
                var finalNormal   = normal == NormalType.HitNormal ? -hit.normal : ray.direction;
                var finalRotation = Quaternion.LookRotation(finalNormal, finalUp);

                hitCache.InvokePoints(gameObject, preview, priority, hit.collider, finalPosition, finalRotation, 1.0f - distance01);
            }
        }
示例#6
0
        protected void DispatchHits(bool preview, Collider collider, Vector3 worldPosition, Quaternion worldRotation, float pressure, object owner)
        {
            if (connectHits == true && owner != null)
            {
                var link             = default(Link);
                var newWorldPosition = worldPosition;

                if (TryGetLink(owner, ref link) == true)
                {
                    if (link.Preview == preview)
                    {
                        if (hitSpacing > 0.0f)
                        {
                            newWorldPosition = link.WorldPosition;

                            var distance = Vector3.Distance(link.WorldPosition, worldPosition);
                            var steps    = Mathf.FloorToInt(distance / hitSpacing);

                            if (steps > hitLimit)
                            {
                                steps = hitLimit;
                            }

                            for (var i = 0; i < steps; i++)
                            {
                                newWorldPosition = Vector3.MoveTowards(newWorldPosition, worldPosition, hitSpacing);

                                hitCache.InvokeLines(gameObject, null, null, preview, link.WorldPosition, newWorldPosition, link.Pressure, pressure);

                                link.WorldPosition = newWorldPosition;
                            }
                        }
                        else
                        {
                            hitCache.InvokeLines(gameObject, null, null, preview, link.WorldPosition, worldPosition, link.Pressure, pressure);
                        }
                    }
                    else
                    {
                        hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
                    }
                }
                else
                {
                    link = linkPool.Count > 0 ? linkPool.Pop() : new Link();

                    link.Owner = owner;

                    links.Add(link);

                    hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
                }

                link.WorldPosition = newWorldPosition;
                link.Pressure      = pressure;
                link.Preview       = preview;
            }
            else
            {
                hitCache.InvokePoints(gameObject, null, null, preview, collider, worldPosition, worldRotation, pressure);
            }
        }