< Summary

Class:DCL.PointerEventsController
Assembly:DCL.Components.Events
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/DCLPlugins/UUIDEventComponentsPlugin/UUIDComponent/PointerEventsController/PointerEventsController.cs
Covered lines:201
Uncovered lines:65
Coverable lines:266
Total lines:665
Line coverage:75.5% (201 of 266)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
PointerEventsController(...)0%330100%
Update()0%34.5328079.73%
GetPointerEventList(...)0%330100%
GetPointerEvent(...)0%110100%
GetPointerInputEvents(...)0%110100%
EventObjectCanBeHovered(...)0%440100%
ResolveGenericRaycastHandlers(...)0%1101000%
UnhoverLastHoveredObject()0%660100%
Dispose()0%330100%
RetrieveCamera()0%220100%
GetRayFromCamera()0%110100%
OnButtonEvent(...)0%26.1211050%
ProcessButtonUp(...)0%10.279075%
ProcessButtonDown(...)0%17.0615079.07%
ReportGlobalPointerUpEvent(...)0%4.254075%
ReportGlobalPointerDownEvent(...)0%440100%
AreSameEntity(...)0%330100%
IsBlockingOnClick(...)0%440100%
EntityHasPointerEvent(...)0%440100%
AreCollidersFromSameEntity(...)0%5.025090.91%
HandleCursorLockChanges(...)0%6200%
HideOrShowCursor(...)0%110100%
SetHoverCursor()0%110100%
SetNormalCursor()0%110100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/DCLPlugins/UUIDEventComponentsPlugin/UUIDComponent/PointerEventsController/PointerEventsController.cs

#LineLine coverage
 1using System;
 2using DCL.Components;
 3using DCL.Configuration;
 4using DCL.Helpers;
 5using DCL.Interface;
 6using UnityEngine;
 7using UnityEngine.UI;
 8using UnityEngine.EventSystems;
 9using System.Collections.Generic;
 10using System.Linq;
 11using DCL.Controllers;
 12using DCL.Models;
 13using DCLPlugins.UUIDEventComponentsPlugin.UUIDComponent.Interfaces;
 14using Ray = UnityEngine.Ray;
 15
 16namespace DCL
 17{
 18    public class PointerEventsController
 19    {
 020        private static bool renderingEnabled => CommonScriptableObjects.rendererState.Get();
 21        public System.Action OnPointerHoverStarts;
 22        public System.Action OnPointerHoverEnds;
 23
 24        RaycastHitInfo lastPointerDownEventHitInfo;
 25        IPointerInputEvent pointerInputUpEvent;
 8426        IRaycastHandler raycastHandler = new RaycastHandler();
 27
 28        Camera charCamera;
 29
 30        GameObject lastHoveredObject = null;
 31        GameObject newHoveredGO = null;
 32
 33        IPointerEvent newHoveredInputEvent = null;
 34        IList<IPointerEvent> lastHoveredEventList = null;
 35
 36        RaycastHit hitInfo;
 8437        PointerEventData uiGraphicRaycastPointerEventData = new PointerEventData(null);
 8438        List<RaycastResult> uiGraphicRaycastResults = new List<RaycastResult>();
 39        GraphicRaycaster uiGraphicRaycaster;
 40
 41        private IRaycastPointerClickHandler clickHandler;
 42        private InputController_Legacy inputControllerLegacy;
 43        private InteractionHoverCanvasController hoverCanvas;
 44
 8445        private DataStore_ECS7 dataStoreEcs7 = DataStore.i.ecs7;
 46
 8447        public PointerEventsController(InputController_Legacy inputControllerLegacy,
 48            InteractionHoverCanvasController hoverCanvas)
 49        {
 8450            this.inputControllerLegacy = inputControllerLegacy;
 8451            this.hoverCanvas = hoverCanvas;
 52
 252053            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 54            {
 117655                var buttonId = (WebInterface.ACTION_BUTTON) i;
 56
 117657                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 58                    continue;
 59
 109260                inputControllerLegacy.AddListener(buttonId, OnButtonEvent);
 61            }
 62
 8463            OnPointerHoverStarts += SetHoverCursor;
 8464            OnPointerHoverEnds += SetNormalCursor;
 65
 8466            RetrieveCamera();
 67
 8468            Environment.i.platform.updateEventHandler.AddListener(IUpdateEventHandler.EventType.Update, Update);
 8469            Utils.OnCursorLockChanged += HandleCursorLockChanges;
 70
 8471            HideOrShowCursor(Utils.IsCursorLocked);
 8472        }
 73
 74        public void Update()
 75        {
 1615276            if (charCamera == null)
 577                RetrieveCamera();
 78
 1615279            if (!CommonScriptableObjects.rendererState.Get() || charCamera == null)
 080                return;
 81
 1615282            if (!Utils.IsCursorLocked)
 89183                return;
 84
 1526185            IWorldState worldState = Environment.i.world.state;
 86
 87            // We use Physics.Raycast() instead of our raycastHandler.Raycast() as that one is slower, sometimes 2x, bec
 1526188            Ray ray = GetRayFromCamera();
 1526189            bool didHit = Physics.Raycast(ray, out hitInfo, Mathf.Infinity,
 90                PhysicsLayers.physicsCastLayerMaskWithoutCharacter);
 91
 1526192            bool uiIsBlocking = false;
 1526193            int currentSceneNumber = worldState.GetCurrentSceneNumber();
 94
 1526195            bool validCurrentScene = currentSceneNumber > 0 && worldState.ContainsScene(currentSceneNumber);
 96
 97            // NOTE: in case of a single scene loaded (preview or builder) sceneId is set to null when stepping outside
 1526198            if (didHit && validCurrentScene)
 99            {
 14756100                DataStore_World worldData = DataStore.i.Get<DataStore_World>();
 14756101                GraphicRaycaster raycaster = worldData.currentRaycaster.Get();
 102
 14756103                if (raycaster)
 104                {
 6105                    uiGraphicRaycastPointerEventData.position = new Vector2(Screen.width / 2, Screen.height / 2);
 6106                    uiGraphicRaycastResults.Clear();
 6107                    raycaster.Raycast(uiGraphicRaycastPointerEventData, uiGraphicRaycastResults);
 6108                    uiIsBlocking = uiGraphicRaycastResults.Count > 0;
 109                }
 110            }
 111
 15261112            if (dataStoreEcs7.isEcs7Enabled)
 113            {
 0114                dataStoreEcs7.lastPointerRayHit.hit.collider = hitInfo.collider;
 0115                dataStoreEcs7.lastPointerRayHit.hit.point = hitInfo.point;
 0116                dataStoreEcs7.lastPointerRayHit.hit.normal = hitInfo.normal;
 0117                dataStoreEcs7.lastPointerRayHit.hit.distance = hitInfo.distance;
 0118                dataStoreEcs7.lastPointerRayHit.didHit = didHit;
 0119                dataStoreEcs7.lastPointerRayHit.ray = ray;
 0120                dataStoreEcs7.lastPointerRayHit.hasValue = true;
 121            }
 122
 15261123            if (!didHit || uiIsBlocking)
 124            {
 507125                clickHandler = null;
 507126                UnhoverLastHoveredObject();
 127
 507128                return;
 129            }
 130
 14754131            var raycastHandlerTarget = hitInfo.collider.GetComponent<IRaycastPointerHandler>();
 132
 14754133            if (raycastHandlerTarget != null)
 134            {
 0135                ResolveGenericRaycastHandlers(raycastHandlerTarget);
 0136                UnhoverLastHoveredObject();
 137
 0138                return;
 139            }
 140
 14754141            if (CollidersManager.i.GetColliderInfo(hitInfo.collider, out ColliderInfo info))
 14754142                newHoveredInputEvent = GetPointerEvent(info.entity);
 143            else
 0144                newHoveredInputEvent = hitInfo.collider.GetComponentInChildren<IPointerEvent>();
 145
 14754146            clickHandler = null;
 147
 14754148            if (!EventObjectCanBeHovered(info, hitInfo.distance))
 149            {
 15150                UnhoverLastHoveredObject();
 151
 15152                return;
 153            }
 154
 14739155            newHoveredGO = newHoveredInputEvent.GetTransform().gameObject;
 156
 14739157            if (newHoveredGO != lastHoveredObject)
 158            {
 18159                UnhoverLastHoveredObject();
 160
 18161                lastHoveredObject = newHoveredGO;
 162
 18163                lastHoveredEventList = GetPointerEventList(newHoveredInputEvent.entity);
 164
 165                // NOTE: this case is for the Avatar, since it hierarchy differs from other ECS components
 18166                if (lastHoveredEventList?.Count == 0)
 167                {
 0168                    lastHoveredEventList = newHoveredGO.GetComponents<IPointerEvent>();
 169                }
 170
 18171                OnPointerHoverStarts?.Invoke();
 172            }
 173
 174            // OnPointerDown/OnClick and OnPointerUp should display their hover feedback at different moments
 14739175            if (lastHoveredEventList != null && lastHoveredEventList.Count > 0)
 176            {
 14739177                bool isEntityShowingHoverFeedback = false;
 178
 58958179                for (int i = 0; i < lastHoveredEventList.Count; i++)
 180                {
 14740181                    if (lastHoveredEventList[i] is IPointerInputEvent e)
 182                    {
 14732183                        bool eventButtonIsPressed = inputControllerLegacy.IsPressed(e.GetActionButton());
 184
 14732185                        bool isClick = e.GetEventType() == PointerInputEventType.CLICK;
 14732186                        bool isDown = e.GetEventType() == PointerInputEventType.DOWN;
 14732187                        bool isUp = e.GetEventType() == PointerInputEventType.UP;
 188
 14732189                        if (isUp && eventButtonIsPressed)
 190                        {
 0191                            e.SetHoverState(true);
 0192                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 193                        }
 14732194                        else if ((isDown || isClick) && !eventButtonIsPressed)
 195                        {
 14730196                            e.SetHoverState(true);
 14730197                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 198                        }
 2199                        else if (!isEntityShowingHoverFeedback)
 200                        {
 2201                            e.SetHoverState(false);
 202                        }
 203                    }
 204                    else
 205                    {
 8206                        lastHoveredEventList[i].SetHoverState(true);
 207                    }
 208                }
 209            }
 210
 14739211            newHoveredGO = null;
 14739212            newHoveredInputEvent = null;
 14739213        }
 214
 215        private IList<IPointerEvent> GetPointerEventList(IDCLEntity entity)
 216        {
 18217            return entity.gameObject.transform.Cast<Transform>()
 37218                                    .Select(child => child.GetComponent<IPointerEvent>())
 37219                                    .Where(pointerComponent => pointerComponent != null)
 220                                    .ToArray();
 221        }
 222
 223        private IPointerEvent GetPointerEvent(IDCLEntity entity)
 224        {
 14754225            return entity.gameObject.GetComponentInChildren<IPointerEvent>();
 226        }
 227
 228        private IList<IPointerInputEvent> GetPointerInputEvents(GameObject hitGameObject)
 229        {
 10230            return hitGameObject.GetComponentsInChildren<IPointerInputEvent>();
 231        }
 232
 233        private bool EventObjectCanBeHovered(ColliderInfo colliderInfo, float distance)
 234        {
 14754235            return newHoveredInputEvent != null &&
 236                   newHoveredInputEvent.IsAtHoverDistance(distance) &&
 237                   newHoveredInputEvent.IsVisible() &&
 238                   AreSameEntity(newHoveredInputEvent, colliderInfo);
 239        }
 240
 241        private void ResolveGenericRaycastHandlers(IRaycastPointerHandler raycastHandlerTarget)
 242        {
 0243            if (Utils.LockedThisFrame())
 0244                return;
 245
 0246            var mouseIsDown = Input.GetMouseButtonDown(0);
 0247            var mouseIsUp = Input.GetMouseButtonUp(0);
 248
 0249            if (raycastHandlerTarget is IRaycastPointerDownHandler down)
 250            {
 0251                if (mouseIsDown)
 0252                    down.OnPointerDown();
 253            }
 254
 0255            if (raycastHandlerTarget is IRaycastPointerUpHandler up)
 256            {
 0257                if (mouseIsUp)
 0258                    up.OnPointerUp();
 259            }
 260
 0261            if (raycastHandlerTarget is IRaycastPointerClickHandler click)
 262            {
 0263                if (mouseIsDown)
 0264                    clickHandler = click;
 265
 0266                if (mouseIsUp)
 267                {
 0268                    if (clickHandler == click)
 0269                        click.OnPointerClick();
 270
 0271                    clickHandler = null;
 272                }
 273            }
 0274        }
 275
 276        void UnhoverLastHoveredObject()
 277        {
 540278            if (lastHoveredObject == null)
 279            {
 535280                if (hoverCanvas != null)
 535281                    hoverCanvas.SetHoverState(false);
 282
 535283                return;
 284            }
 285
 5286            OnPointerHoverEnds?.Invoke();
 287
 22288            for (int i = 0; i < lastHoveredEventList.Count; i++)
 289            {
 6290                if (lastHoveredEventList[i] == null)
 291                    continue;
 292
 6293                lastHoveredEventList[i].SetHoverState(false);
 294            }
 295
 5296            lastHoveredEventList = null;
 5297            lastHoveredObject = null;
 5298        }
 299
 300        public void Dispose()
 301        {
 2520302            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 303            {
 1176304                var buttonId = (WebInterface.ACTION_BUTTON) i;
 305
 1176306                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 307                    continue;
 308
 1092309                inputControllerLegacy.RemoveListener(buttonId, OnButtonEvent);
 310            }
 311
 84312            lastHoveredObject = null;
 84313            newHoveredGO = null;
 84314            newHoveredInputEvent = null;
 84315            lastHoveredEventList = null;
 316
 84317            OnPointerHoverStarts -= SetHoverCursor;
 84318            OnPointerHoverEnds -= SetNormalCursor;
 319
 84320            Environment.i.platform.updateEventHandler.RemoveListener(IUpdateEventHandler.EventType.Update, Update);
 84321            Utils.OnCursorLockChanged -= HandleCursorLockChanges;
 84322        }
 323
 324        void RetrieveCamera()
 325        {
 89326            if (charCamera == null)
 327            {
 89328                charCamera = Camera.main;
 329            }
 89330        }
 331
 15275332        public Ray GetRayFromCamera() { return charCamera.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height /
 333
 334        void OnButtonEvent(WebInterface.ACTION_BUTTON buttonId, InputController_Legacy.EVENT evt, bool useRaycast,
 335            bool enablePointerEvent)
 336        {
 337            //TODO(Brian): We should remove this when we get a proper initialization layer
 14338            if (!EnvironmentSettings.RUNNING_TESTS)
 339            {
 0340                if (Utils.LockedThisFrame())
 0341                    return;
 342
 0343                if (!Utils.IsCursorLocked || !renderingEnabled)
 0344                    return;
 345            }
 346
 14347            if (charCamera == null)
 348            {
 0349                RetrieveCamera();
 350
 0351                if (charCamera == null)
 0352                    return;
 353            }
 354
 14355            var pointerEventLayer =
 356                PhysicsLayers.physicsCastLayerMaskWithoutCharacter; //Ensure characterController is being filtered
 357
 14358            var globalLayer = pointerEventLayer & ~PhysicsLayers.physicsCastLayerMask;
 359
 14360            if (evt == InputController_Legacy.EVENT.BUTTON_DOWN)
 361            {
 11362                ProcessButtonDown(buttonId, useRaycast, enablePointerEvent, pointerEventLayer, globalLayer);
 363            }
 3364            else if (evt == InputController_Legacy.EVENT.BUTTON_UP)
 365            {
 3366                ProcessButtonUp(buttonId, useRaycast, enablePointerEvent, pointerEventLayer, globalLayer);
 367            }
 368
 14369            if (dataStoreEcs7.isEcs7Enabled)
 370            {
 0371                dataStoreEcs7.lastPointerInputEvent.buttonId = (int)buttonId;
 0372                dataStoreEcs7.lastPointerInputEvent.isButtonDown = evt == InputController_Legacy.EVENT.BUTTON_DOWN;
 0373                dataStoreEcs7.lastPointerInputEvent.hasValue = evt == InputController_Legacy.EVENT.BUTTON_DOWN || evt ==
 374            }
 14375        }
 376
 377        private void ProcessButtonUp(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 378            LayerMask pointerEventLayer, int globalLayer)
 379        {
 3380            IWorldState worldState = Environment.i.world.state;
 381
 3382            int currentSceneNumber = worldState.GetCurrentSceneNumber();
 3383            if (currentSceneNumber <= 0)
 0384                return;
 385
 386            RaycastHitInfo raycastGlobalLayerHitInfo;
 3387            Ray ray = GetRayFromCamera();
 388
 389            // Raycast for global pointer events
 3390            worldState.TryGetScene(currentSceneNumber, out var loadedScene);
 391
 3392            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 393                loadedScene);
 394
 3395            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 396
 3397            RaycastResultInfo raycastInfoPointerEventLayer = null;
 3398            if (pointerInputUpEvent != null || dataStoreEcs7.isEcs7Enabled)
 399            {
 400                // Raycast for pointer event components
 3401                raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane,
 402                    pointerEventLayer, loadedScene);
 403            }
 404
 3405            if (pointerInputUpEvent != null && raycastInfoPointerEventLayer != null)
 406            {
 3407                bool isOnClickComponentBlocked =
 408                    IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 409
 3410                bool isSameEntityThatWasPressed = AreCollidersFromSameEntity(raycastInfoPointerEventLayer.hitInfo,
 411                    lastPointerDownEventHitInfo);
 412
 3413                if (!isOnClickComponentBlocked && isSameEntityThatWasPressed && enablePointerEvent)
 414                {
 3415                    pointerInputUpEvent.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 416                }
 417
 3418                pointerInputUpEvent = null;
 419            }
 420
 3421            ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer, currentS
 422
 423            // Raycast for global pointer events (for each PE scene)
 3424            List<string> currentPortableExperienceIds = DataStore.i.Get<DataStore_World>().portableExperienceIds.Get().T
 6425            for (int i = 0; i < currentPortableExperienceIds.Count; i++)
 426            {
 0427                IParcelScene pexSene = worldState.GetPortableExperienceScene(currentPortableExperienceIds[i]);
 0428                if (pexSene != null)
 429                {
 0430                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer, pexSene);
 0431                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 432
 0433                    ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 434                        pexSene.sceneData.sceneNumber);
 435                }
 436            }
 3437        }
 438
 439        private void ProcessButtonDown(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 440            LayerMask pointerEventLayer, int globalLayer)
 441        {
 11442            IWorldState worldState = Environment.i.world.state;
 443
 11444            int currentSceneNumber = worldState.GetCurrentSceneNumber();
 11445            if (currentSceneNumber <= 0)
 0446                return;
 447
 448            RaycastHitInfo raycastGlobalLayerHitInfo;
 11449            Ray ray = GetRayFromCamera();
 11450            worldState.TryGetScene(currentSceneNumber, out var loadedScene);
 451
 452            // Raycast for pointer event components
 11453            RaycastResultInfo raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, pointe
 454
 455            // Raycast for global pointer events
 11456            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 457
 11458            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 459
 11460            bool isOnClickComponentBlocked =
 461                IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 462
 11463            if (!isOnClickComponentBlocked && raycastInfoPointerEventLayer.hitInfo.hit.collider)
 464            {
 10465                Collider collider = raycastInfoPointerEventLayer.hitInfo.hit.collider;
 466
 467                GameObject hitGameObject;
 468
 10469                if (CollidersManager.i.GetColliderInfo(collider, out ColliderInfo info))
 10470                    hitGameObject = info.entity.gameObject;
 471                else
 0472                    hitGameObject = collider.gameObject;
 473
 10474                IList<IPointerInputEvent> events = GetPointerInputEvents(hitGameObject);
 475
 36476                for (var i = 0; i < events.Count; i++)
 477                {
 8478                    IPointerInputEvent e = events[i];
 8479                    bool areSameEntity = AreSameEntity(e, info);
 480
 8481                    switch (e.GetEventType())
 482                    {
 483                        case PointerInputEventType.CLICK:
 1484                            if (areSameEntity && enablePointerEvent)
 1485                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 486
 1487                            break;
 488                        case PointerInputEventType.DOWN:
 4489                            if (areSameEntity && enablePointerEvent)
 4490                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 491
 4492                            break;
 493                        case PointerInputEventType.UP:
 3494                            if (areSameEntity && enablePointerEvent)
 3495                                pointerInputUpEvent = e;
 496                            else
 0497                                pointerInputUpEvent = null;
 498
 499                            break;
 500                    }
 501                }
 502
 10503                lastPointerDownEventHitInfo = raycastInfoPointerEventLayer.hitInfo;
 504            }
 505
 11506            ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer, curren
 507
 508            // Raycast for global pointer events (for each PE scene)
 11509            IEnumerable<string> currentPortableExperienceSceneIds = DataStore.i.world.portableExperienceIds.Get();
 22510            foreach (var pexSceneId in currentPortableExperienceSceneIds)
 511            {
 0512                IParcelScene pexSene = worldState.GetPortableExperienceScene(pexSceneId);
 0513                if (pexSene != null)
 514                {
 0515                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer, pexSene);
 516
 0517                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 518
 0519                    ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer
 520                }
 521            }
 11522        }
 523
 524        private void ReportGlobalPointerUpEvent(
 525            WebInterface.ACTION_BUTTON buttonId,
 526            bool useRaycast,
 527            RaycastHitInfo raycastGlobalLayerHitInfo,
 528            RaycastResultInfo raycastInfoGlobalLayer,
 529            int sceneNumber)
 530        {
 3531            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 532            {
 3533                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 534                    out ColliderInfo colliderInfo);
 535
 3536                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 537
 3538                if (colliderInfo.entity != null)
 3539                    entityId =
 540                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 541
 3542                WebInterface.ReportGlobalPointerUpEvent(
 543                    buttonId,
 544                    raycastInfoGlobalLayer.ray,
 545                    raycastGlobalLayerHitInfo.hit.point,
 546                    raycastGlobalLayerHitInfo.hit.normal,
 547                    raycastGlobalLayerHitInfo.hit.distance,
 548                    sceneNumber,
 549                    entityId,
 550                    colliderInfo.meshName,
 551                    isHitInfoValid: true);
 552            }
 553            else
 554            {
 0555                WebInterface.ReportGlobalPointerUpEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 556                    Vector3.zero, 0, sceneNumber);
 557            }
 0558        }
 559
 560        private void ReportGlobalPointerDownEvent(
 561            WebInterface.ACTION_BUTTON buttonId,
 562            bool useRaycast,
 563            RaycastHitInfo raycastGlobalLayerHitInfo,
 564            RaycastResultInfo raycastInfoGlobalLayer,
 565            int sceneNumber)
 566        {
 11567            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 568            {
 10569                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 570                    out ColliderInfo colliderInfo);
 571
 10572                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 573
 10574                if (colliderInfo.entity != null)
 10575                    entityId =
 576                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 577
 10578                WebInterface.ReportGlobalPointerDownEvent(
 579                    buttonId,
 580                    raycastInfoGlobalLayer.ray,
 581                    raycastGlobalLayerHitInfo.hit.point,
 582                    raycastGlobalLayerHitInfo.hit.normal,
 583                    raycastGlobalLayerHitInfo.hit.distance,
 584                    sceneNumber,
 585                    entityId,
 586                    colliderInfo.meshName,
 587                    isHitInfoValid: true);
 588            }
 589            else
 590            {
 1591                WebInterface.ReportGlobalPointerDownEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 592                    Vector3.zero, 0, sceneNumber);
 593            }
 1594        }
 595
 596        bool AreSameEntity(IPointerEvent pointerInputEvent, ColliderInfo colliderInfo)
 597        {
 14748598            return pointerInputEvent != null && colliderInfo.entity != null &&
 599                   pointerInputEvent.entity == colliderInfo.entity;
 600        }
 601
 602        bool IsBlockingOnClick(RaycastHitInfo targetOnClickHit, RaycastHitInfo potentialBlockerHit)
 603        {
 14604            return
 605                potentialBlockerHit.hit.collider != null // Does a potential blocker hit exist?
 606                && targetOnClickHit.hit.collider != null // Was a target entity with a pointer event component hit?
 607                && potentialBlockerHit.hit.distance <=
 608                targetOnClickHit.hit.distance // Is potential blocker nearer than target entity?
 609                && !AreCollidersFromSameEntity(potentialBlockerHit,
 610                    targetOnClickHit); // Does potential blocker belong to other entity rather than target entity?
 611        }
 612
 613        bool EntityHasPointerEvent(IDCLEntity entity)
 614        {
 32615            var componentsManager = entity.scene.componentsManagerLegacy;
 616
 32617            return componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_CALLBACK) ||
 618                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_UP) ||
 619                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_DOWN) ||
 620                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_CLICK);
 621        }
 622
 623        bool AreCollidersFromSameEntity(RaycastHitInfo hitInfoA, RaycastHitInfo hitInfoB)
 624        {
 16625            CollidersManager.i.GetColliderInfo(hitInfoA.hit.collider, out ColliderInfo colliderInfoA);
 16626            CollidersManager.i.GetColliderInfo(hitInfoB.hit.collider, out ColliderInfo colliderInfoB);
 627
 16628            var entityA = colliderInfoA.entity;
 16629            var entityB = colliderInfoB.entity;
 630
 16631            bool entityAHasEvent = entityA != null && EntityHasPointerEvent(entityA);
 16632            bool entityBHasEvent = entityB != null && EntityHasPointerEvent(entityB);
 633
 634            // If both entities has OnClick/PointerEvent component
 16635            if (entityAHasEvent && entityBHasEvent)
 636            {
 14637                return entityA == entityB;
 638            }
 639            // If only one of them has OnClick/PointerEvent component
 2640            else if (entityAHasEvent ^ entityBHasEvent)
 641            {
 0642                return false;
 643            }
 644            // None of them has OnClick/PointerEvent component
 645            else
 646            {
 2647                return colliderInfoA.entity == colliderInfoB.entity;
 648            }
 649        }
 650
 651        private void HandleCursorLockChanges(bool isLocked)
 652        {
 0653            HideOrShowCursor(isLocked);
 654
 0655            if (!isLocked)
 0656                UnhoverLastHoveredObject();
 0657        }
 658
 168659        private void HideOrShowCursor(bool isCursorLocked) { DataStore.i.Get<DataStore_Cursor>().cursorVisible.Set(isCur
 660
 36661        private void SetHoverCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.H
 662
 10663        private void SetNormalCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.
 664    }
 665}

Methods/Properties

renderingEnabled()
PointerEventsController(DCL.InputController_Legacy, InteractionHoverCanvasController)
Update()
GetPointerEventList(DCL.Models.IDCLEntity)
GetPointerEvent(DCL.Models.IDCLEntity)
GetPointerInputEvents(UnityEngine.GameObject)
EventObjectCanBeHovered(DCL.Components.ColliderInfo, System.Single)
ResolveGenericRaycastHandlers(IRaycastPointerHandler)
UnhoverLastHoveredObject()
Dispose()
RetrieveCamera()
GetRayFromCamera()
OnButtonEvent(DCL.Interface.WebInterface/ACTION_BUTTON, DCL.InputController_Legacy/EVENT, System.Boolean, System.Boolean)
ProcessButtonUp(DCL.Interface.WebInterface/ACTION_BUTTON, System.Boolean, System.Boolean, UnityEngine.LayerMask, System.Int32)
ProcessButtonDown(DCL.Interface.WebInterface/ACTION_BUTTON, System.Boolean, System.Boolean, UnityEngine.LayerMask, System.Int32)
ReportGlobalPointerUpEvent(DCL.Interface.WebInterface/ACTION_BUTTON, System.Boolean, DCL.Helpers.RaycastHitInfo, DCL.Helpers.RaycastResultInfo, System.Int32)
ReportGlobalPointerDownEvent(DCL.Interface.WebInterface/ACTION_BUTTON, System.Boolean, DCL.Helpers.RaycastHitInfo, DCL.Helpers.RaycastResultInfo, System.Int32)
AreSameEntity(DCLPlugins.UUIDEventComponentsPlugin.UUIDComponent.Interfaces.IPointerEvent, DCL.Components.ColliderInfo)
IsBlockingOnClick(DCL.Helpers.RaycastHitInfo, DCL.Helpers.RaycastHitInfo)
EntityHasPointerEvent(DCL.Models.IDCLEntity)
AreCollidersFromSameEntity(DCL.Helpers.RaycastHitInfo, DCL.Helpers.RaycastHitInfo)
HandleCursorLockChanges(System.Boolean)
HideOrShowCursor(System.Boolean)
SetHoverCursor()
SetNormalCursor()