Exemplo n.º 1
0
        /// <summary>
        /// Inspector - Finds the collision points between an arc extrapolated to be distance long (the PlanetariaRaycastHit structs have no particular order)
        /// </summary>
        /// <param name="arc">A fragment that defines the arc in space (might not be fully used or return collisions after the end of the arc).</param>
        /// <param name="distance">The distance to raycast (may be greater than or less than the length of the arc - or negative).</param>
        /// <param name="layer_mask">The collision mask that defines which objects will be ignored.</param>
        /// <returns>All of the collision points of the Raycast (listed exactly once).</returns>
        private static PlanetariaRaycastHit[] unordered_raycast_all(Arc arc, float distance, int layer_mask, bool collide_with_fields)
        {
            //float angle = arc.angle(); // this would determine the intersections for the un-modified arc (ignoring distance)

            // desired_angle = desired_length * (partial_angle/partial_length) i.e. length * length_to_angle ratio
            float desired_angle = distance * (arc.angle() / arc.length()); // TODO: verify negative distances go backwards

            desired_angle = Mathf.Clamp(desired_angle, -2 * Mathf.PI, 2 * Mathf.PI);

            // primative arc points
            Vector3 arc_left   = arc.position(-arc.angle() / 2);
            Vector3 arc_center = arc.position(-arc.angle() / 2 + desired_angle / 2);
            Vector3 arc_right  = arc.position(-arc.angle() / 2 + desired_angle);

            SerializedArc ray_arc = ArcFactory.curve(arc_left, arc_center, arc_right);

            PlanetariaShape ray_shape = PlanetariaShape.Create(new List <SerializedArc> {
                ray_arc
            }, false);

            // composites
            Vector3 arc_boundary_midpoint = (arc_left + arc_right) / 2;                      // if the arc is like a wooden bow, this is the midpoint of the string
            Vector3 arc_forward           = (arc_center - arc_boundary_midpoint).normalized; // the direction a hypothetical arrow would travel
            Vector3 arc_up = arc.floor().normal;                                             // orthogonal/perpendicular to the imaginary "bow"

            // UnityEngine.Physics.OverlapBox() requirements
            // FIXME: OPTIMIZE: half_extents currently provides unnecessary false positives because the "width" of plane (the depth into the distance and zero height are fine)
            Vector3    half_extents = new Vector3(1, 0, 1);                    // The largest collision "box" for a unit sphere is a radius of 1 in the x-z plane; height along y is 0.
            Vector3    center       = arc_boundary_midpoint + arc_forward * 1; // The center of the "box" must be offset 1 (the radius) along the forward axis from the two arc boundaries.
            Quaternion rotation     = Quaternion.LookRotation(arc_forward, arc_up);

            // SphereColliders (only) that represent potential collisions (not guaranteed).
            Collider[] colliders = Physics.OverlapBox(center, half_extents, rotation, layer_mask, QueryTriggerInteraction.Collide); // TODO: verify this casts properly
            List <PlanetariaRaycastHit> raycast_hits = new List <PlanetariaRaycastHit>();

            Debug.Log(colliders.Length);
            foreach (SphereCollider sphere_collider in colliders)
            {
                PlanetariaCollider planetaria_collider = PlanetariaCache.collider_fetch(sphere_collider);
                if (planetaria_collider.is_field && !collide_with_fields)
                {
                    Debug.LogError("Why?");
                    continue;
                }
                Quaternion geometry_rotation = planetaria_collider.gameObject.internal_game_object.transform.rotation;
                Debug.Log("Found a collider with " + planetaria_collider.shape.Length + " arcs.");
                foreach (Arc geometry_arc in ray_shape.block_collision(planetaria_collider.shape, geometry_rotation))
                {
                    Vector3[] intersections = PlanetariaIntersection.raycast_intersection(arc, geometry_arc, distance, geometry_rotation); // TODO: verify distance is indeed the angle in this scenario
                    Debug.Log("Found an arc with " + intersections.Length + " intersections.");
                    foreach (Vector3 intersection in intersections)
                    {
                        PlanetariaRaycastHit single_collision = PlanetariaRaycastHit.hit(arc, planetaria_collider, geometry_arc, intersection, distance);
                        raycast_hits.Add(single_collision);
                    }
                }
            }
            return(raycast_hits.ToArray());
        }
Exemplo n.º 2
0
        private void OnTriggerStay(Collider collider)
        {
            optional <SphereCollider> sphere_collider = collider as SphereCollider;

            if (!sphere_collider.exists)
            {
                Debug.LogError("This should never happen");
                return;
            }
            optional <PlanetariaCollider> other_collider = PlanetariaCache.collider_fetch(sphere_collider.data);

            if (!other_collider.exists)
            {
                Debug.LogError("This should never happen");
                return;
            }

            Quaternion shift_from_self_to_other = other_collider.data.internal_transform.rotation;

            if (this.internal_transform.rotation != Quaternion.identity) // Only shift orientation when necessary
            {
                // TODO: verify the order of operations is correct (and logic itself)
                shift_from_self_to_other = Quaternion.Inverse(this.internal_transform.rotation) * shift_from_self_to_other;
            }

            if (other_collider.data.is_field) // field collision
            {
                if (this.shape.field_collision(other_collider.data.shape, shift_from_self_to_other))
                {
                    observer.potential_field_collision(other_collider.data); // TODO: augment field (like Unity triggers) works on both the sender and receiver.
                }
            }
            else // block collision
            {
                foreach (Arc intersection in this.shape.block_collision(other_collider.data.shape, shift_from_self_to_other))
                {
                    Vector3 position = planetaria_transform.position;
                    if (other_collider.data.gameObject.internal_game_object.transform.rotation != Quaternion.identity) // Only shift orientation when necessary
                    {
                        position = Quaternion.Inverse(other_collider.data.gameObject.internal_game_object.transform.rotation) * position;
                    }
                    if (intersection.contains(position, planetaria_transform.scale / 2))
                    {
                        observer.potential_block_collision(intersection, other_collider.data); // block collisions are handled in OnCollisionStay(): notification stage
                    }
                }
            }
        }
Exemplo n.º 3
0
        private void cache(PlanetariaShape shape)
        {
            PlanetariaCache.uncache(this);
            shape_variable = shape;
            if (shape != null)
            {
                PlanetariaCache.cache(this);
                PlanetariaSphereCollider sphere = shape.bounding_sphere;

                internal_collider.center = sphere.center;
                internal_collider.radius = sphere.radius;
            }
            else
            {
                internal_collider.radius = float.NegativeInfinity; // FIXME: HACK: ensure there are no collisions
            }
            internal_collider.isTrigger = true;                    // Rigidbody must be added for collisions to be detected.
        }
Exemplo n.º 4
0
 protected override void OnDestroy()
 {
     PlanetariaCache.uncache(this);
     GameObject.Destroy(internal_collider);
 }