Exemple #1
0
 protected override void OnCanvasGroupChanged()
 {
     base.OnCanvasGroupChanged();
     if (!Application.isPlaying)
     {
         return;
     }
     if (_useRaycast)
     {
         var block = GetComponentInParent <CanvasGroup>().blocksRaycasts;
         raycastTarget = block;
         if (!block)
         {
             _unregistered = true;
             GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
         }
         else
         {
             if (_unregistered)
             {
                 GraphicRegistry.RegisterGraphicForCanvas(canvas, this);
             }
         }
     }
 }
Exemple #2
0
    private void PreformGraphics(PvrBasePoint pointer, List <Graphic> results)
    {
        Vector2 screenPos = eventCamera.WorldToScreenPoint(pointer.ray.GetPoint(pointer.maxPointDistance));
        var     graphics  = GraphicRegistry.GetGraphicsForCanvas(canvas);

        for (int i = 0; i < graphics.Count; i++)
        {
            Graphic g = graphics[i];
            Debug.Log(g.gameObject.name);
            if (g.depth == -1 || !g.raycastTarget)
            {
                continue;
            }

            if (!RectTransformUtility.RectangleContainsScreenPoint(g.rectTransform, screenPos, eventCamera))
            {
                continue;
            }
            if (g.Raycast(screenPos, eventCamera))
            {
                sortedGraphics.Add(g);
                // Debug.Log(g.gameObject.name);
            }
            sortedGraphics.Sort((g1, g2) => g1.depth.CompareTo(g.depth));
            foreach (var s in sortedGraphics)
            {
                results.Add(s);
            }
            sortedGraphics.Clear();
        }
    }
        private void GraphicRaycast(Canvas canvas, Ray ray, List <Graphic> results)
        {
            var foundGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            s_SortedGraphics.Clear();

            for (int i = 0; i < foundGraphics.Count; ++i)
            {
                Graphic graphic = foundGraphics[i];

                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                Vector3 worldPos;
                if (RayIntersectsRectTransform(graphic.rectTransform, ray, out worldPos))
                {
                    var screenPos = eventCamera.WorldToScreenPoint(worldPos);

                    // mask/image intersection - See Unity docs on eventAlphaThreshold for when this does anything
                    if (graphic.Raycast(screenPos, eventCamera))
                    {
                        s_SortedGraphics.Add(graphic);
                    }
                }
            }

            s_SortedGraphics.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));
            results.AddRange(s_SortedGraphics);
        }
Exemple #4
0
        ////////////////////////////////////////////////////////////////////////
        // Private Methods
        ////////////////////////////////////////////////////////////////////////

        private void Raycast(
            Ray ray,
            List <RaycastResult> resultAppendList,
            float maxDistance,
            int layerMask)
        {
            // Potentially reduce the maximum hit distance based on whether
            // any 2D or 3D blocking objects have been intersected.
            float distance =
                this.eventCamera.farClipPlane - this.eventCamera.nearClipPlane;

            if (this.blockingObjects == BlockingObjects.ThreeD ||
                this.blockingObjects == BlockingObjects.All)
            {
                RaycastHit hit;
                if (Physics.Raycast(ray, out hit, distance, this.m_BlockingMask))
                {
                    maxDistance = Mathf.Min(hit.distance, maxDistance);
                }
            }

            if (this.blockingObjects == BlockingObjects.TwoD ||
                this.blockingObjects == BlockingObjects.All)
            {
                RaycastHit2D hit = Physics2D.GetRayIntersection(
                    ray, distance, this.m_BlockingMask);

                if (hit.collider != null)
                {
                    maxDistance = Mathf.Min(
                        hit.fraction * distance, maxDistance);
                }
            }

            // Retrieve the list of graphics associated with the canvas.
            IList <Graphic> graphics =
                GraphicRegistry.GetGraphicsForCanvas(this.Canvas);

            // Iterate through each of graphics and perform hit tests.
            for (int i = 0; i < graphics.Count; ++i)
            {
                Graphic graphic = graphics[i];

                // Skip the graphic if it's not in the layer mask.
                if (((1 << graphic.gameObject.layer) & layerMask) == 0)
                {
                    continue;
                }

                // Perform a raycast against the graphic.
                RaycastResult result;
                if (this.Raycast(ray, graphic, out result, maxDistance))
                {
                    resultAppendList.Add(result);
                }
            }

            // Sort the results by depth.
            resultAppendList.Sort((x, y) => y.depth.CompareTo(x.depth));
        }
        private void SortedRaycastGraphics(Canvas canvas, Ray ray, List <RaycastHitData> results)
        {
            var graphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            _sortedGraphics.Clear();
            for (int i = 0; i < graphics.Count; ++i)
            {
                Graphic graphic = graphics[i];

                if (graphic.depth == -1)
                {
                    continue;
                }

                Vector3 worldPos;
                Vector3 worldNormal;
                float   distance;
                if (RayIntersectsRectTransform(graphic.rectTransform, ray, out worldPos, out worldNormal, out distance))
                {
                    _sortedGraphics.Add(new RaycastHitData(graphic, worldPos, worldNormal, distance));
                }
            }

            _sortedGraphics.Sort((g1, g2) => g2.Graphic.depth.CompareTo(g1.Graphic.depth));

            results.AddRange(_sortedGraphics);
        }
Exemple #6
0
    private RaycastResult RaycastAll(Vector2 ptInScreen)
    {
        Matrix4x4 matWorldClip = uiCamera.projectionMatrix * uiCamera.worldToCameraMatrix;

        if (previousResult != null && previousResult.raycastTarget && graphicContainsPoint(ptInScreen, previousResult, uiCamera, matWorldClip, screenScale, supportCanvasGroupsAndDragging))
        {
            return(createRaycastResult(ptInScreen, previousResult));
        }
        previousResult  = null;
        fallbackElement = null;
        IList <Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(canvas);
        int             count             = graphicsForCanvas.Count;

        for (int i = 0; i < count; i++)
        {
            Graphic graphic = graphicsForCanvas[i];
            if (graphic.raycastTarget && graphicContainsPoint(ptInScreen, graphic, uiCamera, matWorldClip, screenScale, supportCanvasGroupsAndDragging))
            {
                EmptyGraphic emptyGraphic = graphic as EmptyGraphic;
                if (!(emptyGraphic != null) || !emptyGraphic.lowPriorityTarget)
                {
                    previousResult = graphic;
                    return(createRaycastResult(ptInScreen, graphic));
                }
                fallbackElement = emptyGraphic;
            }
        }
        if (fallbackElement != null)
        {
            return(createRaycastResult(ptInScreen, fallbackElement));
        }
        return(default(RaycastResult));
    }
 public static void UnregisterGraphic(params Graphic[] toUnregister)
 {
     for (int i = 0; i < toUnregister.Length; i++)
     {
         GraphicRegistry.UnregisterGraphicForCanvas(toUnregister[i].canvas, toUnregister[i]);
     }
 }
        private void SortedRaycastGraphics(Canvas canvas, Ray ray, List <RaycastHitData> results)
        {
            var graphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            s_SortedGraphics.Clear();
            for (int i = 0; i < graphics.Count; ++i)
            {
                Graphic graphic = graphics[i];

                if (graphic.depth == -1)
                {
                    continue;
                }

                Vector3 worldPos;
                float   distance;
                if (RayIntersectsRectTransform(graphic.rectTransform, ray, out worldPos, out distance))
                {
                    Vector2 screenPos = eventCamera.WorldToScreenPoint(worldPos);
                    // mask/image intersection - See Unity docs on eventAlphaThreshold for when this does anything
                    if (graphic.Raycast(screenPos, eventCamera))
                    {
                        s_SortedGraphics.Add(new RaycastHitData(graphic, worldPos, screenPos, distance));
                    }
                }
            }

            s_SortedGraphics.Sort(CompareRaycastHits);

            results.AddRange(s_SortedGraphics);
        }
Exemple #9
0
    private static void GraphicsRaycast(Canvas canvas, Ray ray, float hitDistance, Camera camera, List <Graphic> results)
    {
        IList <Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(canvas);

        for (int i = 0; i < graphicsForCanvas.Count; i++)
        {
            Graphic graphic = graphicsForCanvas[i];

            if (graphic.depth != -1 && !graphic.raycastTarget)
            {
                continue;
            }

            Vector3 screenPoint = camera.WorldToScreenPoint(ray.GetPoint(hitDistance));
            if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, screenPoint, camera))
            {
                continue;
            }

            if (graphic.Raycast(screenPoint, camera))
            {
                sortedGraphics.Add(graphic);
            }
        }

        sortedGraphics.Sort((Graphic g1, Graphic g2) => g2.depth.CompareTo(g1.depth));
        for (int i = 0; i < sortedGraphics.Count; i++)
        {
            results.Add(sortedGraphics[i]);
        }
        sortedGraphics.Clear();
    }
Exemple #10
0
        private static void Raycast(Canvas canvas, Ray ray, float hitDistance, Camera eventCamera, List <TGraphicRaycastResult> results)
        {
            // Debug.Log("ttt" + pointerPoision + ":::" + camera);
            // Necessary for the event system
            IList <Graphic> foundGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < foundGraphics.Count; ++i)
            {
                Graphic graphic = foundGraphics[i];
                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                Transform trans        = graphic.transform.transform;
                Vector3   transForward = trans.forward;
                // http://geomalgorithms.com/a06-_intersect-2.html
                float distance = (Vector3.Dot(transForward, trans.position - ray.origin) / Vector3.Dot(transForward, ray.direction));

                // Check to see if the go is behind the camera.
                if (distance < 0)
                {
                    continue;
                }

                // is behind some blocking 2D or 3D
                if (distance >= hitDistance)
                {
                    continue;
                }

                Vector3 position        = ray.GetPoint(distance);
                Vector2 pointerPosition = eventCamera.WorldToScreenPoint(position);

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
                {
                    continue;
                }

                if (graphic.Raycast(pointerPosition, eventCamera))
                {
                    s_SortedGraphics.Add(new TGraphicRaycastResult()
                    {
                        graphic         = graphic,
                        distance        = distance,
                        pointerPosition = pointerPosition,
                        position        = position
                    });
                }
            }

            s_SortedGraphics.Sort((g1, g2) => g2.graphic.depth.CompareTo(g1.graphic.depth));
            for (int i = 0; i < s_SortedGraphics.Count; ++i)
            {
                results.Add(s_SortedGraphics[i]);
            }

            s_SortedGraphics.Clear();
        }
Exemple #11
0
        private bool CheckGraphicAddedToRaycastGraphicRegistry()
        {
            var graphicList     = GraphicRegistry.GetRaycastableGraphicsForCanvas(m_canvas);
            var graphicListSize = graphicList.Count;

            return(ContainsGraphic(graphicList, graphicListSize, m_graphic));
        }
Exemple #12
0
    private void GraphicRaycast(Canvas canvas, Ray ray, List <OVRRaycaster.RaycastHit> results)
    {
        IList <Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(canvas);

        OVRRaycaster.s_SortedGraphics.Clear();
        for (int i = 0; i < graphicsForCanvas.Count; i++)
        {
            Graphic graphic = graphicsForCanvas[i];
            if (graphic.depth != -1 && !(this.pointer == graphic.gameObject))
            {
                Vector3 vector;
                if (OVRRaycaster.RayIntersectsRectTransform(graphic.rectTransform, ray, out vector))
                {
                    Vector2 sp = this.eventCamera.WorldToScreenPoint(vector);
                    if (graphic.Raycast(sp, this.eventCamera))
                    {
                        OVRRaycaster.RaycastHit item;
                        item.graphic   = graphic;
                        item.worldPos  = vector;
                        item.fromMouse = false;
                        OVRRaycaster.s_SortedGraphics.Add(item);
                    }
                }
            }
        }
        OVRRaycaster.s_SortedGraphics.Sort((OVRRaycaster.RaycastHit g1, OVRRaycaster.RaycastHit g2) => g2.graphic.depth.CompareTo(g1.graphic.depth));
        for (int j = 0; j < OVRRaycaster.s_SortedGraphics.Count; j++)
        {
            results.Add(OVRRaycaster.s_SortedGraphics[j]);
        }
    }
        public static void Raycast(Canvas canvas, bool ignoreReversedGraphics, BaseRaycaster module, Vector2 position, Camera eventCamera, List <RaycastResult> raycastResults)
        {
            if (canvas == null)
            {
                return;
            }

            var ray      = eventCamera.ScreenPointToRay(position);
            var distance = eventCamera.farClipPlane - eventCamera.nearClipPlane;

            var graphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < graphics.Count; ++i)
            {
                var graphic = graphics[i];

                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, position, eventCamera))
                {
                    continue;
                }

                if (ignoreReversedGraphics && Vector3.Dot(eventCamera.transform.forward, graphic.transform.forward) <= 0f)
                {
                    continue;
                }

                if (!graphic.Raycast(position, eventCamera))
                {
                    continue;
                }

                float dist;
                new Plane(graphic.transform.forward, graphic.transform.position).Raycast(ray, out dist);
                if (dist > distance)
                {
                    continue;
                }

                raycastResults.Add(new RaycastResult
                {
                    gameObject     = graphic.gameObject,
                    module         = module,
                    distance       = dist,
                    worldPosition  = ray.GetPoint(dist),
                    worldNormal    = graphic.transform.forward,
                    screenPosition = position,
                    index          = raycastResults.Count,
                    depth          = graphic.depth,
                    sortingLayer   = canvas.sortingLayerID,
                    sortingOrder   = canvas.sortingOrder
                });
            }
        }
Exemple #14
0
 protected override void OnTransformParentChanged()
 {
     base.OnTransformParentChanged();
     if (!raycastTarget)
     {
         GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
     }
 }
Exemple #15
0
 protected override void OnCanvasHierarchyChanged()
 {
     base.OnCanvasHierarchyChanged();
     if (!raycastTarget)
     {
         GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
     }
 }
Exemple #16
0
 protected override void OnEnable()
 {
     base.OnEnable();
     if (!raycastTarget)
     {
         GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
     }
 }
        public virtual void GraphicRaycast(Canvas canvas, bool ignoreReversedGraphics, Ray ray, float distance, TXRPointerRaycaster raycaster, List <RaycastResult> raycastResults)
        {
            if (canvas == null)
            {
                return;
            }

            var eventCamera       = raycaster.eventCamera;
            var screenCenterPoint = TXRInputModule.ScreenCenterPoint;
            var graphics          = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < graphics.Count; ++i)
            {
                var graphic = graphics[i];

                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, screenCenterPoint, eventCamera))
                {
                    continue;
                }

                if (ignoreReversedGraphics && Vector3.Dot(ray.direction, graphic.transform.forward) <= 0f)
                {
                    continue;
                }

                if (!graphic.Raycast(screenCenterPoint, eventCamera))
                {
                    continue;
                }

                float dist;
                new Plane(graphic.transform.forward, graphic.transform.position).Raycast(ray, out dist);
                if (dist > distance)
                {
                    continue;
                }

                raycastResults.Add(new RaycastResult
                {
                    gameObject     = graphic.gameObject,
                    module         = raycaster,
                    distance       = dist,
                    worldPosition  = ray.GetPoint(dist),
                    worldNormal    = -graphic.transform.forward,
                    screenPosition = screenCenterPoint,
                    index          = raycastResults.Count,
                    depth          = graphic.depth,
                    sortingLayer   = canvas.sortingLayerID,
                    sortingOrder   = canvas.sortingOrder
                });
            }
        }
Exemple #18
0
        // based on code provided by unity
        protected virtual void Raycast(Canvas canvas, Camera eventCamera, PointerEventData eventData, Ray ray, ref List <RaycastResult> results)
        {
            float           hitDistance    = GetHitDistance(ray, float.MaxValue);
            IList <Graphic> canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < canvasGraphics.Count; ++i)
            {
                Graphic graphic = canvasGraphics[i];

                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                Transform graphicTransform = graphic.transform;
                Vector3   graphicForward   = graphicTransform.forward;
                float     distance         = Vector3.Dot(graphicForward, graphicTransform.position - ray.origin) / Vector3.Dot(graphicForward, ray.direction);

                if (distance < 0)
                {
                    continue;
                }

                //Prevents "flickering hover" on items near canvas center.
                if ((distance - UI_CONTROL_OFFSET) > hitDistance)
                {
                    continue;
                }

                Vector3 position        = ray.GetPoint(distance);
                Vector2 pointerPosition = eventCamera.WorldToScreenPoint(position);

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
                {
                    continue;
                }

                if (graphic.Raycast(pointerPosition, eventCamera))
                {
                    RaycastResult result = new RaycastResult()
                    {
                        gameObject     = graphic.gameObject,
                        module         = this,
                        distance       = distance,
                        screenPosition = pointerPosition,
                        worldPosition  = position,
                        depth          = graphic.depth,
                        sortingLayer   = canvas.sortingLayerID,
                        sortingOrder   = canvas.sortingOrder,
                    };

                    results.Add(result);
                }
            }

            results.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));
        }
Exemple #19
0
        private bool CheckGraphicAddedToGraphicRaycaster()
        {
            // check that Graphic is removed from m_CanvasGraphics
            var raycaster       = m_canvas.GetComponent <GraphicRaycaster>();
            var graphicList     = GraphicRegistry.GetGraphicsForCanvas(m_canvas);
            var graphicListSize = graphicList.Count;

            return(ContainsGraphic(graphicList, graphicListSize, m_graphic));
        }
        private void Raycast(Canvas canvas, Camera eventCamera, Ray ray, List <VIVE_Graphic> results)
        {
            var hitDistance    = GetHitDistance(ray);
            var canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < canvasGraphics.Count; ++i)
            {
                var graphic = canvasGraphics[i];

                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                var     graphicTransform = graphic.transform;
                Vector3 graphicFormward  = graphicTransform.forward;
                float   distance         = (Vector3.Dot(graphicFormward, graphicTransform.position - ray.origin) / Vector3.Dot(graphicFormward, ray.direction));

                if (distance < 0)
                {
                    continue;
                }

                if ((distance - UI_CONTROL_OFFSET) > hitDistance)
                {
                    continue;
                }

                Vector3 position        = ray.GetPoint(distance);
                Vector2 pointerPosition = eventCamera.WorldToScreenPoint(position);

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
                {
                    continue;
                }

                if (graphic.Raycast(pointerPosition, eventCamera))
                {
                    var vrGraphic = new VIVE_Graphic();
                    vrGraphic.graphic         = graphic;
                    vrGraphic.position        = position;
                    vrGraphic.distance        = distance;
                    vrGraphic.pointerPosition = pointerPosition;
                    sortedGraphics.Add(vrGraphic);
                }
            }

            sortedGraphics.Sort((g1, g2) => g2.graphic.depth.CompareTo(g1.graphic.depth));
            for (int i = 0; i < sortedGraphics.Count; ++i)
            {
                results.Add(sortedGraphics[i]);
            }

            sortedGraphics.Clear();
        }
        /// <summary>
        /// 手指检测最近的平面
        /// </summary>
        private bool FingerRaycast(XRPointEventData eventData, out Vector3 raycasterDirection)
        {
            raycasterDirection = Vector3.forward;

            if (UICanvas == null)
            {
                return(false);
            }
            if (UICanvas.renderMode == RenderMode.ScreenSpaceOverlay)
            {
                return(false);
            }
            var canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(UICanvas);

            if (canvasGraphics == null || canvasGraphics.Count == 0)
            {
                return(false);
            }

            float maxSqrDistance   = eventData.hitDistance * eventData.hitDistance;
            int   lengthOfGraphics = canvasGraphics.Count;
            float minSqrDistance   = maxSqrDistance + 1f;

            for (int i = 0; i < lengthOfGraphics; i++)
            {
                Graphic graphic = canvasGraphics[i];

                if (graphic.depth == -1 || !graphic.raycastTarget || graphic.canvasRenderer.cull)
                {
                    continue;
                }

                RectTransform rectTransform = graphic.rectTransform;
                if (ignoreReversedGraphics)
                {
                    var rayDir = eventData.origin - rectTransform.position;
                    if (Vector3.Dot(rayDir, rectTransform.forward) > 0)
                    {
                        continue;
                    }
                }

                float sqrDistance = maxSqrDistance + 1;
                if (rectTransform.InRectangle(eventData.origin, out sqrDistance))
                {
                    if (sqrDistance < minSqrDistance && sqrDistance <= maxSqrDistance)
                    {
                        minSqrDistance     = sqrDistance;
                        raycasterDirection = rectTransform.forward;
                    }
                }
            }
            return(minSqrDistance <= maxSqrDistance);
        }
Exemple #22
0
    protected override void OnEnable()
    {
        base.OnEnable();
        if (!Application.isPlaying)
        {
            return;
        }

        if (!_useRaycast)
        {
            GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
        }
    }
Exemple #23
0
    protected override void OnTransformParentChanged()
    {
        base.OnTransformParentChanged();
        if (!Application.isPlaying)
        {
            return;
        }

        if (!_useRaycast)
        {
            GraphicRegistry.UnregisterGraphicForCanvas(canvas, this);
        }
    }
    private void GraphicRaycast(Canvas canvas, Ray ray, List <RaycastHit> results)
    {
        //This function is based closely on :
        // void GraphicRaycaster.Raycast(Canvas canvas, Camera eventCamera, Vector2 pointerPosition, List<Graphic> results)
        // But modified to take a Ray instead of a canvas pointer, and also to explicitly ignore
        // the graphic associated with the pointer

        // Necessary for the event system
        var foundGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

        s_SortedGraphics.Clear();
        for (int i = 0; i < foundGraphics.Count; ++i)
        {
            Graphic graphic = foundGraphics[i];

            //WriteToLog("graphic = " + graphic);
            // WriteToLog("graphic.depth = " + graphic.depth);
            // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
            if (graphic.depth == -1 || (pointer == graphic.gameObject))
            {
                continue;
            }
            Vector3 worldPos;
            // WriteToLog("Before if of RayIntersectsRectTransform");

            if (RayIntersectsRectTransform(graphic.rectTransform, ray, out worldPos))
            {
                //WriteToLog("inside if of RayIntersectsRectTransform");

                //Work out where this is on the screen for compatibility with existing Unity UI code
                Vector2 screenPos = eventCamera.WorldToScreenPoint(worldPos);
                // mask/image intersection - See Unity docs on eventAlphaThreshold for when this does anything
                if (graphic.Raycast(screenPos, eventCamera))
                {
                    RaycastHit hit;
                    hit.graphic   = graphic;
                    hit.worldPos  = worldPos;
                    hit.fromMouse = false;
                    s_SortedGraphics.Add(hit);
                }
            }
        }

        s_SortedGraphics.Sort((g1, g2) => g2.graphic.depth.CompareTo(g1.graphic.depth));

        for (int i = 0; i < s_SortedGraphics.Count; ++i)
        {
            results.Add(s_SortedGraphics[i]);
        }
    }
Exemple #25
0
    // Start is called before the first frame update
    void Start()
    {
        var     canvas = GetComponent <Canvas>();
        Vector2 p      = new Vector2(Screen.width / 2.0f, Screen.height / 2.0f);

        p = new Vector2(-1000, -10000);
        var allGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

        for (int i = 0; i < allGraphics.Count; i++)
        {
            var  g   = allGraphics[i];
            bool con = RectTransformUtility.RectangleContainsScreenPoint(g.rectTransform, p, Camera.main);
            Debug.LogError(g.Raycast(p, Camera.main) + "  " + g.name + " " + con);
        }
    }
Exemple #26
0
        /// <summary>
        /// Returns all the canvas objects that are intersected by given ray
        /// </summary>
        /// <returns>The objects hit by ray.</returns>
        /// <param name="ray">Ray.</param>
        public List <GameObject> GetObjectsHitByRay(Ray ray)
        {
            List <GameObject> results = new List <GameObject>();

            Vector2 pointerPosition;

            //ray outside the canvas, return null
            if (!GetScreenSpacePointByRay(ray, out pointerPosition))
            {
                return(results);
            }

            //lets find the graphics under ray!
            List <Graphic> s_SortedGraphics = new List <Graphic>();
            var            foundGraphics    = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < foundGraphics.Count; ++i)
            {
                Graphic graphic = foundGraphics[i];

                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1 || !graphic.raycastTarget)
                {
                    continue;
                }

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
                {
                    continue;
                }

                if (graphic.Raycast(pointerPosition, eventCamera))
                {
                    s_SortedGraphics.Add(graphic);
                }
            }

            s_SortedGraphics.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));
            for (int i = 0; i < s_SortedGraphics.Count; ++i)
            {
                results.Add(s_SortedGraphics[i].gameObject);
            }

            s_SortedGraphics.Clear();

            return(results);
        }
Exemple #27
0
        /// <summary>
        /// 优化 GraphicRaycaster.Raycast 避免CPU周期浪费
        /// </summary>
        public void OptimizeFrameGraphic()
        {
            for (int i = 0; i < this.m_frameCanvases.Length; ++i)
            {
                Canvas canvasInFrame = this.m_frameCanvases[i];

                IList <Graphic> canvasGraphics = GraphicRegistry.GetGraphicsForCanvas(canvasInFrame);

                for (int j = 0; j < canvasGraphics.Count; ++j)
                {
                    Graphic graphic = canvasGraphics[j];
                    if (!graphic.raycastTarget)
                    {
                        GraphicRegistry.UnregisterGraphicForCanvas(canvasInFrame, graphic);
                    }
                }
            }
        }
        /// Perform a raycast into the screen and collect all graphics underneath it.
        private static void Raycast(Canvas canvas, Ray ray, Camera cam, float maxPointerDistance,
                                    List <Graphic> results, out Ray finalRay)
        {
            Vector3 screenPoint = cam.WorldToScreenPoint(ray.GetPoint(maxPointerDistance));

            finalRay = cam.ScreenPointToRay(screenPoint);

            // Necessary for the event system
            IList <Graphic> foundGraphics = GraphicRegistry.GetGraphicsForCanvas(canvas);

            for (int i = 0; i < foundGraphics.Count; ++i)
            {
                Graphic graphic = foundGraphics[i];

                // -1 means it hasn't been processed by the canvas, which means it isn't actually drawn
                if (graphic.depth == -1
                                        #if UNITY_5_3_OR_NEWER || UNITY_5_3 || UNITY_5_2
                    || !graphic.raycastTarget
                                        #endif
                    )
                {
                    continue;
                }

                if (!RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, screenPoint, cam))
                {
                    continue;
                }

                if (graphic.Raycast(screenPoint, cam))
                {
                    sortedGraphics.Add(graphic);
                }
            }

            sortedGraphics.Sort((g1, g2) => g2.depth.CompareTo(g1.depth));

            for (int i = 0; i < sortedGraphics.Count; ++i)
            {
                results.Add(sortedGraphics[i]);
            }

            sortedGraphics.Clear();
        }
Exemple #29
0
    public static int GetGraphicsForCanvas_s(IntPtr l)
    {
        int result;

        try
        {
            Canvas canvas;
            LuaObject.checkType <Canvas>(l, 1, out canvas);
            IList <Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(canvas);
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, graphicsForCanvas);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
        public List <GameObject> GetObjectsHitByRay(Ray ray)
        {
            Vector2           vector;
            List <GameObject> list = new List <GameObject>();

            if (this.GetScreenSpacePointByRay(ray, out vector))
            {
                List <Graphic>  list2             = new List <Graphic>();
                IList <Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(this.myCanvas);
                for (int i = 0; i < graphicsForCanvas.Count; i++)
                {
                    Graphic item = graphicsForCanvas[i];
                    if ((item.depth != -1) && (item.raycastTarget && (RectTransformUtility.RectangleContainsScreenPoint(item.rectTransform, vector, this.eventCamera) && item.Raycast(vector, this.eventCamera))))
                    {
                        list2.Add(item);
                    }
                }
                if (< > f__am$cache1 == null)
                {