< 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:207
Uncovered lines:64
Coverable lines:271
Total lines:670
Line coverage:76.3% (207 of 271)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
PointerEventsController(...)0%330100%
Update()0%34.7628079.49%
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%24.0711052.38%
ProcessButtonUp(...)0%9.899077.78%
ProcessButtonDown(...)0%16.5615080.95%
ReportGlobalPointerUpEvent(...)0%4.184077.78%
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.Models;
 12using DCLPlugins.UUIDEventComponentsPlugin.UUIDComponent.Interfaces;
 13using Ray = UnityEngine.Ray;
 14
 15namespace DCL
 16{
 17    public class PointerEventsController
 18    {
 019        private static bool renderingEnabled => CommonScriptableObjects.rendererState.Get();
 20        public System.Action OnPointerHoverStarts;
 21        public System.Action OnPointerHoverEnds;
 22
 23        RaycastHitInfo lastPointerDownEventHitInfo;
 24        IPointerInputEvent pointerInputUpEvent;
 8325        IRaycastHandler raycastHandler = new RaycastHandler();
 26
 27        Camera charCamera;
 28
 29        GameObject lastHoveredObject = null;
 30        GameObject newHoveredGO = null;
 31
 32        IPointerEvent newHoveredInputEvent = null;
 33        IList<IPointerEvent> lastHoveredEventList = null;
 34
 35        RaycastHit hitInfo;
 8336        PointerEventData uiGraphicRaycastPointerEventData = new PointerEventData(null);
 8337        List<RaycastResult> uiGraphicRaycastResults = new List<RaycastResult>();
 38        GraphicRaycaster uiGraphicRaycaster;
 39
 40        private IRaycastPointerClickHandler clickHandler;
 41        private InputController_Legacy inputControllerLegacy;
 42        private InteractionHoverCanvasController hoverCanvas;
 43
 8344        private DataStore_ECS7 dataStoreEcs7 = DataStore.i.ecs7;
 45
 8346        public PointerEventsController(InputController_Legacy inputControllerLegacy,
 47            InteractionHoverCanvasController hoverCanvas)
 48        {
 8349            this.inputControllerLegacy = inputControllerLegacy;
 8350            this.hoverCanvas = hoverCanvas;
 51
 249052            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 53            {
 116254                var buttonId = (WebInterface.ACTION_BUTTON) i;
 55
 116256                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 57                    continue;
 58
 107959                inputControllerLegacy.AddListener(buttonId, OnButtonEvent);
 60            }
 61
 8362            OnPointerHoverStarts += SetHoverCursor;
 8363            OnPointerHoverEnds += SetNormalCursor;
 64
 8365            RetrieveCamera();
 66
 8367            Environment.i.platform.updateEventHandler.AddListener(IUpdateEventHandler.EventType.Update, Update);
 8368            Utils.OnCursorLockChanged += HandleCursorLockChanges;
 69
 8370            HideOrShowCursor(Utils.IsCursorLocked);
 8371        }
 72
 73        public void Update()
 74        {
 177475            if (charCamera == null)
 576                RetrieveCamera();
 77
 177478            if (!CommonScriptableObjects.rendererState.Get() || charCamera == null)
 079                return;
 80
 177481            if (!Utils.IsCursorLocked)
 39382                return;
 83
 138184            IWorldState worldState = Environment.i.world.state;
 85
 86            // We use Physics.Raycast() instead of our raycastHandler.Raycast() as that one is slower, sometimes 2x, bec
 138187            Ray ray = GetRayFromCamera();
 138188            bool didHit = Physics.Raycast(ray, out hitInfo, Mathf.Infinity,
 89                PhysicsLayers.physicsCastLayerMaskWithoutCharacter);
 90
 138191            bool uiIsBlocking = false;
 138192            string currentSceneId = worldState.GetCurrentSceneId();
 93
 138194            bool validCurrentSceneId = !string.IsNullOrEmpty(currentSceneId);
 138195            bool validCurrentScene = validCurrentSceneId && worldState.ContainsScene(currentSceneId);
 96
 97            // NOTE: in case of a single scene loaded (preview or builder) sceneId is set to null when stepping outside
 138198            if (didHit && validCurrentSceneId && validCurrentScene)
 99            {
 1142100                DataStore_World worldData = DataStore.i.Get<DataStore_World>();
 1142101                GraphicRaycaster raycaster = worldData.currentRaycaster.Get();
 102
 1142103                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
 1381112            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
 1381123            if (!didHit || uiIsBlocking)
 124            {
 241125                clickHandler = null;
 241126                UnhoverLastHoveredObject();
 127
 241128                return;
 129            }
 130
 1140131            var raycastHandlerTarget = hitInfo.collider.GetComponent<IRaycastPointerHandler>();
 132
 1140133            if (raycastHandlerTarget != null)
 134            {
 0135                ResolveGenericRaycastHandlers(raycastHandlerTarget);
 0136                UnhoverLastHoveredObject();
 137
 0138                return;
 139            }
 140
 1140141            if (CollidersManager.i.GetColliderInfo(hitInfo.collider, out ColliderInfo info))
 1140142                newHoveredInputEvent = GetPointerEvent(info.entity);
 143            else
 0144                newHoveredInputEvent = hitInfo.collider.GetComponentInChildren<IPointerEvent>();
 145
 1140146            clickHandler = null;
 147
 1140148            if (!EventObjectCanBeHovered(info, hitInfo.distance))
 149            {
 15150                UnhoverLastHoveredObject();
 151
 15152                return;
 153            }
 154
 1125155            newHoveredGO = newHoveredInputEvent.GetTransform().gameObject;
 156
 1125157            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
 1125175            if (lastHoveredEventList != null && lastHoveredEventList.Count > 0)
 176            {
 1125177                bool isEntityShowingHoverFeedback = false;
 178
 4502179                for (int i = 0; i < lastHoveredEventList.Count; i++)
 180                {
 1126181                    if (lastHoveredEventList[i] is IPointerInputEvent e)
 182                    {
 1118183                        bool eventButtonIsPressed = inputControllerLegacy.IsPressed(e.GetActionButton());
 184
 1118185                        bool isClick = e.GetEventType() == PointerInputEventType.CLICK;
 1118186                        bool isDown = e.GetEventType() == PointerInputEventType.DOWN;
 1118187                        bool isUp = e.GetEventType() == PointerInputEventType.UP;
 188
 1118189                        if (isUp && eventButtonIsPressed)
 190                        {
 0191                            e.SetHoverState(true);
 0192                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 0193                        }
 1118194                        else if ((isDown || isClick) && !eventButtonIsPressed)
 195                        {
 1116196                            e.SetHoverState(true);
 1116197                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 1116198                        }
 2199                        else if (!isEntityShowingHoverFeedback)
 200                        {
 2201                            e.SetHoverState(false);
 202                        }
 2203                    }
 204                    else
 205                    {
 8206                        lastHoveredEventList[i].SetHoverState(true);
 207                    }
 208                }
 209            }
 210
 1125211            newHoveredGO = null;
 1125212            newHoveredInputEvent = null;
 1125213        }
 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        {
 1140225            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        {
 1140235            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        {
 274278            if (lastHoveredObject == null)
 279            {
 269280                if (hoverCanvas != null)
 269281                    hoverCanvas.SetHoverState(false);
 282
 269283                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        {
 2490302            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 303            {
 1162304                var buttonId = (WebInterface.ACTION_BUTTON) i;
 305
 1162306                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 307                    continue;
 308
 1079309                inputControllerLegacy.RemoveListener(buttonId, OnButtonEvent);
 310            }
 311
 83312            lastHoveredObject = null;
 83313            newHoveredGO = null;
 83314            newHoveredInputEvent = null;
 83315            lastHoveredEventList = null;
 316
 83317            OnPointerHoverStarts -= SetHoverCursor;
 83318            OnPointerHoverEnds -= SetNormalCursor;
 319
 83320            Environment.i.platform.updateEventHandler.RemoveListener(IUpdateEventHandler.EventType.Update, Update);
 83321            Utils.OnCursorLockChanged -= HandleCursorLockChanges;
 83322        }
 323
 324        void RetrieveCamera()
 325        {
 88326            if (charCamera == null)
 327            {
 88328                charCamera = Camera.main;
 329            }
 88330        }
 331
 1395332        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);
 11363            }
 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            string currentSceneId = worldState.GetCurrentSceneId();
 3383            if (string.IsNullOrEmpty(currentSceneId))
 0384                return;
 385
 386            RaycastHitInfo raycastGlobalLayerHitInfo;
 3387            Ray ray = GetRayFromCamera();
 388
 389            // Raycast for global pointer events
 3390            worldState.TryGetScene(currentSceneId, 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,
 422                currentSceneId);
 423
 424            // Raycast for global pointer events (for each PE scene)
 3425            List<string> currentPortableExperienceIds = DataStore.i.Get<DataStore_World>().portableExperienceIds.Get().T
 426
 6427            for (int i = 0; i < currentPortableExperienceIds.Count; i++)
 428            {
 0429                if (worldState.TryGetScene(currentPortableExperienceIds[i], out var portableScene))
 430                {
 0431                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 432                        portableScene);
 433
 0434                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 435
 0436                    ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 437                        currentPortableExperienceIds[i]);
 438                }
 439            }
 3440        }
 441
 442        private void ProcessButtonDown(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 443            LayerMask pointerEventLayer, int globalLayer)
 444        {
 11445            IWorldState worldState = Environment.i.world.state;
 446
 11447            string currentSceneId = worldState.GetCurrentSceneId();
 11448            if (string.IsNullOrEmpty(currentSceneId))
 0449                return;
 450
 451            RaycastHitInfo raycastGlobalLayerHitInfo;
 11452            Ray ray = GetRayFromCamera();
 11453            worldState.TryGetScene(currentSceneId, out var loadedScene);
 454
 455            // Raycast for pointer event components
 11456            RaycastResultInfo raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, pointe
 457
 458            // Raycast for global pointer events
 11459            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 460
 11461            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 462
 11463            bool isOnClickComponentBlocked =
 464                IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 465
 11466            if (!isOnClickComponentBlocked && raycastInfoPointerEventLayer.hitInfo.hit.collider)
 467            {
 10468                Collider collider = raycastInfoPointerEventLayer.hitInfo.hit.collider;
 469
 470                GameObject hitGameObject;
 471
 10472                if (CollidersManager.i.GetColliderInfo(collider, out ColliderInfo info))
 10473                    hitGameObject = info.entity.gameObject;
 474                else
 0475                    hitGameObject = collider.gameObject;
 476
 10477                IList<IPointerInputEvent> events = GetPointerInputEvents(hitGameObject);
 478
 36479                for (var i = 0; i < events.Count; i++)
 480                {
 8481                    IPointerInputEvent e = events[i];
 8482                    bool areSameEntity = AreSameEntity(e, info);
 483
 8484                    switch (e.GetEventType())
 485                    {
 486                        case PointerInputEventType.CLICK:
 1487                            if (areSameEntity && enablePointerEvent)
 1488                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 489
 1490                            break;
 491                        case PointerInputEventType.DOWN:
 4492                            if (areSameEntity && enablePointerEvent)
 4493                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 494
 4495                            break;
 496                        case PointerInputEventType.UP:
 3497                            if (areSameEntity && enablePointerEvent)
 3498                                pointerInputUpEvent = e;
 499                            else
 0500                                pointerInputUpEvent = null;
 501
 502                            break;
 503                    }
 504                }
 505
 10506                lastPointerDownEventHitInfo = raycastInfoPointerEventLayer.hitInfo;
 507            }
 508
 11509            ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer, curren
 510
 511            // Raycast for global pointer events (for each PE scene)
 11512            IEnumerable<string> currentPortableExperienceIds = DataStore.i.world.portableExperienceIds.Get();
 513
 22514            foreach (var pexId in currentPortableExperienceIds)
 515            {
 0516                if (worldState.TryGetScene(pexId, out var portableScene))
 517                {
 0518                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer, portableS
 519
 0520                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 521
 0522                    ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer
 523                        pexId);
 524                }
 525
 526            }
 11527        }
 528
 529        private void ReportGlobalPointerUpEvent(
 530            WebInterface.ACTION_BUTTON buttonId,
 531            bool useRaycast,
 532            RaycastHitInfo raycastGlobalLayerHitInfo,
 533            RaycastResultInfo raycastInfoGlobalLayer,
 534            string sceneId)
 535        {
 3536            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 537            {
 3538                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 539                    out ColliderInfo colliderInfo);
 540
 3541                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 542
 3543                if (colliderInfo.entity != null)
 3544                    entityId =
 545                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 546
 3547                WebInterface.ReportGlobalPointerUpEvent(
 548                    buttonId,
 549                    raycastInfoGlobalLayer.ray,
 550                    raycastGlobalLayerHitInfo.hit.point,
 551                    raycastGlobalLayerHitInfo.hit.normal,
 552                    raycastGlobalLayerHitInfo.hit.distance,
 553                    sceneId,
 554                    entityId,
 555                    colliderInfo.meshName,
 556                    isHitInfoValid: true);
 3557            }
 558            else
 559            {
 0560                WebInterface.ReportGlobalPointerUpEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 561                    Vector3.zero, 0, sceneId);
 562            }
 0563        }
 564
 565        private void ReportGlobalPointerDownEvent(
 566            WebInterface.ACTION_BUTTON buttonId,
 567            bool useRaycast,
 568            RaycastHitInfo raycastGlobalLayerHitInfo,
 569            RaycastResultInfo raycastInfoGlobalLayer,
 570            string sceneId)
 571        {
 11572            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 573            {
 10574                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 575                    out ColliderInfo colliderInfo);
 576
 10577                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 578
 10579                if (colliderInfo.entity != null)
 10580                    entityId =
 581                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 582
 10583                WebInterface.ReportGlobalPointerDownEvent(
 584                    buttonId,
 585                    raycastInfoGlobalLayer.ray,
 586                    raycastGlobalLayerHitInfo.hit.point,
 587                    raycastGlobalLayerHitInfo.hit.normal,
 588                    raycastGlobalLayerHitInfo.hit.distance,
 589                    sceneId,
 590                    entityId,
 591                    colliderInfo.meshName,
 592                    isHitInfoValid: true);
 10593            }
 594            else
 595            {
 1596                WebInterface.ReportGlobalPointerDownEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 597                    Vector3.zero, 0, sceneId);
 598            }
 1599        }
 600
 601        bool AreSameEntity(IPointerEvent pointerInputEvent, ColliderInfo colliderInfo)
 602        {
 1134603            return pointerInputEvent != null && colliderInfo.entity != null &&
 604                   pointerInputEvent.entity == colliderInfo.entity;
 605        }
 606
 607        bool IsBlockingOnClick(RaycastHitInfo targetOnClickHit, RaycastHitInfo potentialBlockerHit)
 608        {
 14609            return
 610                potentialBlockerHit.hit.collider != null // Does a potential blocker hit exist?
 611                && targetOnClickHit.hit.collider != null // Was a target entity with a pointer event component hit?
 612                && potentialBlockerHit.hit.distance <=
 613                targetOnClickHit.hit.distance // Is potential blocker nearer than target entity?
 614                && !AreCollidersFromSameEntity(potentialBlockerHit,
 615                    targetOnClickHit); // Does potential blocker belong to other entity rather than target entity?
 616        }
 617
 618        bool EntityHasPointerEvent(IDCLEntity entity)
 619        {
 32620            var componentsManager = entity.scene.componentsManagerLegacy;
 621
 32622            return componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_CALLBACK) ||
 623                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_UP) ||
 624                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_DOWN) ||
 625                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_CLICK);
 626        }
 627
 628        bool AreCollidersFromSameEntity(RaycastHitInfo hitInfoA, RaycastHitInfo hitInfoB)
 629        {
 16630            CollidersManager.i.GetColliderInfo(hitInfoA.hit.collider, out ColliderInfo colliderInfoA);
 16631            CollidersManager.i.GetColliderInfo(hitInfoB.hit.collider, out ColliderInfo colliderInfoB);
 632
 16633            var entityA = colliderInfoA.entity;
 16634            var entityB = colliderInfoB.entity;
 635
 16636            bool entityAHasEvent = entityA != null && EntityHasPointerEvent(entityA);
 16637            bool entityBHasEvent = entityB != null && EntityHasPointerEvent(entityB);
 638
 639            // If both entities has OnClick/PointerEvent component
 16640            if (entityAHasEvent && entityBHasEvent)
 641            {
 14642                return entityA == entityB;
 643            }
 644            // If only one of them has OnClick/PointerEvent component
 2645            else if (entityAHasEvent ^ entityBHasEvent)
 646            {
 0647                return false;
 648            }
 649            // None of them has OnClick/PointerEvent component
 650            else
 651            {
 2652                return colliderInfoA.entity == colliderInfoB.entity;
 653            }
 654        }
 655
 656        private void HandleCursorLockChanges(bool isLocked)
 657        {
 0658            HideOrShowCursor(isLocked);
 659
 0660            if (!isLocked)
 0661                UnhoverLastHoveredObject();
 0662        }
 663
 166664        private void HideOrShowCursor(bool isCursorLocked) { DataStore.i.Get<DataStore_Cursor>().cursorVisible.Set(isCur
 665
 36666        private void SetHoverCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.H
 667
 10668        private void SetNormalCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.
 669    }
 670}
Generated by: ReportGenerator 4.8.9.0
10/10/2022 - 13:25:23
GitHub | www.palmmedia.de

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.String)
ReportGlobalPointerDownEvent(DCL.Interface.WebInterface/ACTION_BUTTON, System.Boolean, DCL.Helpers.RaycastHitInfo, DCL.Helpers.RaycastResultInfo, System.String)
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()