< 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:211
Uncovered lines:60
Coverable lines:271
Total lines:678
Line coverage:77.8% (211 of 271)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
PointerEventsController(...)0%330100%
Update()0%30.1928085.92%
GetPointerEventList(...)0%4.254075%
GetPointerEvent(...)0%2.152066.67%
GetPointerInputEvents(...)0%3.333066.67%
EventObjectCanBeHovered(...)0%440100%
ResolveGenericRaycastHandlers(...)0%1101000%
UnhoverLastHoveredObject()0%660100%
Dispose()0%330100%
RetrieveCamera()0%220100%
GetRayFromCamera()0%110100%
OnButtonEvent(...)0%14.669058.82%
ProcessButtonUp(...)0%11.4110075.86%
ProcessButtonDown(...)0%18.1916079.55%
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        {
 176675            if (charCamera == null)
 576                RetrieveCamera();
 77
 176678            if (!CommonScriptableObjects.rendererState.Get() || charCamera == null)
 079                return;
 80
 176681            if (!Utils.IsCursorLocked)
 40082                return;
 83
 136684            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
 136687            bool didHit = Physics.Raycast(GetRayFromCamera(), out hitInfo, Mathf.Infinity,
 88                PhysicsLayers.physicsCastLayerMaskWithoutCharacter);
 89
 136690            bool uiIsBlocking = false;
 136691            string currentSceneId = worldState.GetCurrentSceneId();
 92
 136693            bool validCurrentSceneId = !string.IsNullOrEmpty(currentSceneId);
 136694            bool validCurrentScene = validCurrentSceneId && worldState.ContainsScene(currentSceneId);
 95
 96            // NOTE: in case of a single scene loaded (preview or builder) sceneId is set to null when stepping outside
 136697            if (didHit && validCurrentSceneId && validCurrentScene)
 98            {
 112799                DataStore_World worldData = DataStore.i.Get<DataStore_World>();
 1127100                GraphicRaycaster raycaster = worldData.currentRaycaster.Get();
 101
 1127102                if (raycaster)
 103                {
 6104                    uiGraphicRaycastPointerEventData.position = new Vector2(Screen.width / 2, Screen.height / 2);
 6105                    uiGraphicRaycastResults.Clear();
 6106                    raycaster.Raycast(uiGraphicRaycastPointerEventData, uiGraphicRaycastResults);
 6107                    uiIsBlocking = uiGraphicRaycastResults.Count > 0;
 108                }
 109            }
 110
 1366111            if (!didHit || uiIsBlocking)
 112            {
 241113                clickHandler = null;
 241114                UnhoverLastHoveredObject();
 115
 241116                return;
 117            }
 118
 1125119            if (dataStoreEcs7.isEcs7Enabled)
 0120                dataStoreEcs7.lastPointerRayHit = hitInfo;
 121
 1125122            var raycastHandlerTarget = hitInfo.collider.GetComponent<IRaycastPointerHandler>();
 123
 1125124            if (raycastHandlerTarget != null)
 125            {
 0126                ResolveGenericRaycastHandlers(raycastHandlerTarget);
 0127                UnhoverLastHoveredObject();
 128
 0129                return;
 130            }
 131
 1125132            if (CollidersManager.i.GetColliderInfo(hitInfo.collider, out ColliderInfo info))
 1125133                newHoveredInputEvent = GetPointerEvent(info.entity);
 134            else
 0135                newHoveredInputEvent = hitInfo.collider.GetComponentInChildren<IPointerEvent>();
 136
 1125137            clickHandler = null;
 138
 1125139            if (!EventObjectCanBeHovered(info, hitInfo.distance))
 140            {
 20141                UnhoverLastHoveredObject();
 142
 20143                return;
 144            }
 145
 1105146            newHoveredGO = newHoveredInputEvent.GetTransform().gameObject;
 147
 1105148            if (newHoveredGO != lastHoveredObject)
 149            {
 18150                UnhoverLastHoveredObject();
 151
 18152                lastHoveredObject = newHoveredGO;
 153
 18154                lastHoveredEventList = GetPointerEventList(newHoveredInputEvent.entity);
 155
 156                // NOTE: this case is for the Avatar, since it hierarchy differs from other ECS components
 18157                if (lastHoveredEventList?.Count == 0)
 158                {
 0159                    lastHoveredEventList = newHoveredGO.GetComponents<IPointerEvent>();
 160                }
 161
 18162                OnPointerHoverStarts?.Invoke();
 163            }
 164
 165            // OnPointerDown/OnClick and OnPointerUp should display their hover feedback at different moments
 1105166            if (lastHoveredEventList != null && lastHoveredEventList.Count > 0)
 167            {
 1105168                bool isEntityShowingHoverFeedback = false;
 169
 4422170                for (int i = 0; i < lastHoveredEventList.Count; i++)
 171                {
 1106172                    if (lastHoveredEventList[i] is IPointerInputEvent e)
 173                    {
 1098174                        bool eventButtonIsPressed = inputControllerLegacy.IsPressed(e.GetActionButton());
 175
 1098176                        bool isClick = e.GetEventType() == PointerInputEventType.CLICK;
 1098177                        bool isDown = e.GetEventType() == PointerInputEventType.DOWN;
 1098178                        bool isUp = e.GetEventType() == PointerInputEventType.UP;
 179
 1098180                        if (isUp && eventButtonIsPressed)
 181                        {
 0182                            e.SetHoverState(true);
 0183                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 0184                        }
 1098185                        else if ((isDown || isClick) && !eventButtonIsPressed)
 186                        {
 1096187                            e.SetHoverState(true);
 1096188                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 1096189                        }
 2190                        else if (!isEntityShowingHoverFeedback)
 191                        {
 2192                            e.SetHoverState(false);
 193                        }
 2194                    }
 195                    else
 196                    {
 8197                        lastHoveredEventList[i].SetHoverState(true);
 198                    }
 199                }
 200            }
 201
 1105202            newHoveredGO = null;
 1105203            newHoveredInputEvent = null;
 1105204        }
 205
 206        private IList<IPointerEvent> GetPointerEventList(IDCLEntity entity)
 207        {
 208            // If an event exist in the new ECS, we got that value, if not it is ECS 6, so we continue as before
 18209            if (dataStoreEcs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent> pointerInputEvent))
 210            {
 0211                return pointerInputEvent.Cast<IPointerEvent>().ToList();
 212            }
 213            else
 214            {
 18215                var lastHoveredEventList = newHoveredInputEvent.entity.gameObject.transform.Cast<Transform>()
 37216                                                               .Select(child => child.GetComponent<IPointerEvent>())
 37217                                                               .Where(pointerComponent => pointerComponent != null)
 218                                                               .ToArray();
 219
 18220                return lastHoveredEventList;
 221            }
 222        }
 223
 224        private IPointerEvent GetPointerEvent(IDCLEntity entity)
 225        {
 226            // If an event exist in the new ECS, we got that value, if not it is ECS 6, so we continue as before
 1125227            if (dataStoreEcs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent> pointerInputEvent))
 0228                return pointerInputEvent.First();
 229            else
 1125230                return entity.gameObject.GetComponentInChildren<IPointerEvent>();
 231        }
 232
 233        private IList<IPointerInputEvent> GetPointerInputEvents(IDCLEntity entity, GameObject hitGameObject)
 234        {
 235            // If an event exist in the new ECS, we got that value, if not it is ECS 6, so we continue as before
 10236            if (entity != null && dataStoreEcs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent> p
 0237                return pointerInputEvent;
 238            else
 10239                return hitGameObject.GetComponentsInChildren<IPointerInputEvent>();
 240        }
 241
 242        private bool EventObjectCanBeHovered(ColliderInfo colliderInfo, float distance)
 243        {
 1125244            return newHoveredInputEvent != null &&
 245                   newHoveredInputEvent.IsAtHoverDistance(distance) &&
 246                   newHoveredInputEvent.IsVisible() &&
 247                   AreSameEntity(newHoveredInputEvent, colliderInfo);
 248        }
 249
 250        private void ResolveGenericRaycastHandlers(IRaycastPointerHandler raycastHandlerTarget)
 251        {
 0252            if (Utils.LockedThisFrame())
 0253                return;
 254
 0255            var mouseIsDown = Input.GetMouseButtonDown(0);
 0256            var mouseIsUp = Input.GetMouseButtonUp(0);
 257
 0258            if (raycastHandlerTarget is IRaycastPointerDownHandler down)
 259            {
 0260                if (mouseIsDown)
 0261                    down.OnPointerDown();
 262            }
 263
 0264            if (raycastHandlerTarget is IRaycastPointerUpHandler up)
 265            {
 0266                if (mouseIsUp)
 0267                    up.OnPointerUp();
 268            }
 269
 0270            if (raycastHandlerTarget is IRaycastPointerClickHandler click)
 271            {
 0272                if (mouseIsDown)
 0273                    clickHandler = click;
 274
 0275                if (mouseIsUp)
 276                {
 0277                    if (clickHandler == click)
 0278                        click.OnPointerClick();
 279
 0280                    clickHandler = null;
 281                }
 282            }
 0283        }
 284
 285        void UnhoverLastHoveredObject()
 286        {
 279287            if (lastHoveredObject == null)
 288            {
 274289                if (hoverCanvas != null)
 274290                    hoverCanvas.SetHoverState(false);
 291
 274292                return;
 293            }
 294
 5295            OnPointerHoverEnds?.Invoke();
 296
 22297            for (int i = 0; i < lastHoveredEventList.Count; i++)
 298            {
 6299                if (lastHoveredEventList[i] == null)
 300                    continue;
 301
 6302                lastHoveredEventList[i].SetHoverState(false);
 303            }
 304
 5305            lastHoveredEventList = null;
 5306            lastHoveredObject = null;
 5307        }
 308
 309        public void Dispose()
 310        {
 2490311            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 312            {
 1162313                var buttonId = (WebInterface.ACTION_BUTTON) i;
 314
 1162315                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 316                    continue;
 317
 1079318                inputControllerLegacy.RemoveListener(buttonId, OnButtonEvent);
 319            }
 320
 83321            lastHoveredObject = null;
 83322            newHoveredGO = null;
 83323            newHoveredInputEvent = null;
 83324            lastHoveredEventList = null;
 325
 83326            OnPointerHoverStarts -= SetHoverCursor;
 83327            OnPointerHoverEnds -= SetNormalCursor;
 328
 83329            Environment.i.platform.updateEventHandler.RemoveListener(IUpdateEventHandler.EventType.Update, Update);
 83330            Utils.OnCursorLockChanged -= HandleCursorLockChanges;
 83331        }
 332
 333        void RetrieveCamera()
 334        {
 88335            if (charCamera == null)
 336            {
 88337                charCamera = Camera.main;
 338            }
 88339        }
 340
 1380341        public Ray GetRayFromCamera() { return charCamera.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height /
 342
 343        void OnButtonEvent(WebInterface.ACTION_BUTTON buttonId, InputController_Legacy.EVENT evt, bool useRaycast,
 344            bool enablePointerEvent)
 345        {
 346            //TODO(Brian): We should remove this when we get a proper initialization layer
 14347            if (!EnvironmentSettings.RUNNING_TESTS)
 348            {
 0349                if (Utils.LockedThisFrame())
 0350                    return;
 351
 0352                if (!Utils.IsCursorLocked || !renderingEnabled)
 0353                    return;
 354            }
 355
 14356            if (charCamera == null)
 357            {
 0358                RetrieveCamera();
 359
 0360                if (charCamera == null)
 0361                    return;
 362            }
 363
 14364            var pointerEventLayer =
 365                PhysicsLayers.physicsCastLayerMaskWithoutCharacter; //Ensure characterController is being filtered
 366
 14367            var globalLayer = pointerEventLayer & ~PhysicsLayers.physicsCastLayerMask;
 368
 14369            if (evt == InputController_Legacy.EVENT.BUTTON_DOWN)
 370            {
 11371                ProcessButtonDown(buttonId, useRaycast, enablePointerEvent, pointerEventLayer, globalLayer);
 11372            }
 3373            else if (evt == InputController_Legacy.EVENT.BUTTON_UP)
 374            {
 3375                ProcessButtonUp(buttonId, useRaycast, enablePointerEvent, pointerEventLayer, globalLayer);
 376            }
 3377        }
 378
 379        private void ProcessButtonUp(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 380            LayerMask pointerEventLayer, int globalLayer)
 381        {
 3382            IWorldState worldState = Environment.i.world.state;
 383
 3384            string currentSceneId = worldState.GetCurrentSceneId();
 3385            if (string.IsNullOrEmpty(currentSceneId))
 0386                return;
 387
 388            RaycastHitInfo raycastGlobalLayerHitInfo;
 3389            Ray ray = GetRayFromCamera();
 390
 391            // Raycast for global pointer events
 3392            worldState.TryGetScene(currentSceneId, out var loadedScene);
 393
 3394            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 395                loadedScene);
 396
 3397            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 398
 3399            RaycastResultInfo raycastInfoPointerEventLayer = null;
 3400            if (pointerInputUpEvent != null || dataStoreEcs7.isEcs7Enabled)
 401            {
 402                // Raycast for pointer event components
 3403                raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane,
 404                    pointerEventLayer, loadedScene);
 405            }
 406
 3407            if (pointerInputUpEvent != null && raycastInfoPointerEventLayer != null)
 408            {
 3409                bool isOnClickComponentBlocked =
 410                    IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 411
 3412                bool isSameEntityThatWasPressed = AreCollidersFromSameEntity(raycastInfoPointerEventLayer.hitInfo,
 413                    lastPointerDownEventHitInfo);
 414
 3415                if (!isOnClickComponentBlocked && isSameEntityThatWasPressed && enablePointerEvent)
 416                {
 3417                    pointerInputUpEvent.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 418                }
 419
 3420                pointerInputUpEvent = null;
 421            }
 422
 3423            ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 424                currentSceneId);
 425
 426            // Raycast for global pointer events (for each PE scene)
 3427            List<string> currentPortableExperienceIds = DataStore.i.Get<DataStore_World>().portableExperienceIds.Get().T
 428
 6429            for (int i = 0; i < currentPortableExperienceIds.Count; i++)
 430            {
 0431                if (worldState.TryGetScene(currentPortableExperienceIds[i], out var portableScene))
 432                {
 0433                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 434                        portableScene);
 435
 0436                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 437
 0438                    ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 439                        currentPortableExperienceIds[i]);
 440                }
 441            }
 442
 3443            if (dataStoreEcs7.isEcs7Enabled)
 0444                dataStoreEcs7.lastPointerInputEvent = new DataStore_ECS7.PointerEvent((int)buttonId, false, raycastInfoP
 3445        }
 446
 447        private void ProcessButtonDown(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 448            LayerMask pointerEventLayer, int globalLayer)
 449        {
 11450            IWorldState worldState = Environment.i.world.state;
 451
 11452            string currentSceneId = worldState.GetCurrentSceneId();
 11453            if (string.IsNullOrEmpty(currentSceneId))
 0454                return;
 455
 456            RaycastHitInfo raycastGlobalLayerHitInfo;
 11457            Ray ray = GetRayFromCamera();
 11458            worldState.TryGetScene(currentSceneId, out var loadedScene);
 459
 460            // Raycast for pointer event components
 11461            RaycastResultInfo raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, pointe
 462
 463            // Raycast for global pointer events
 11464            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 465
 11466            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 467
 11468            bool isOnClickComponentBlocked =
 469                IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 470
 11471            if (!isOnClickComponentBlocked && raycastInfoPointerEventLayer.hitInfo.hit.collider)
 472            {
 10473                Collider collider = raycastInfoPointerEventLayer.hitInfo.hit.collider;
 474
 475                GameObject hitGameObject;
 476
 10477                if (CollidersManager.i.GetColliderInfo(collider, out ColliderInfo info))
 10478                    hitGameObject = info.entity.gameObject;
 479                else
 0480                    hitGameObject = collider.gameObject;
 481
 10482                IList<IPointerInputEvent> events = GetPointerInputEvents(info.entity, hitGameObject);
 483
 36484                for (var i = 0; i < events.Count; i++)
 485                {
 8486                    IPointerInputEvent e = events[i];
 8487                    bool areSameEntity = AreSameEntity(e, info);
 488
 8489                    switch (e.GetEventType())
 490                    {
 491                        case PointerInputEventType.CLICK:
 1492                            if (areSameEntity && enablePointerEvent)
 1493                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 494
 1495                            break;
 496                        case PointerInputEventType.DOWN:
 4497                            if (areSameEntity && enablePointerEvent)
 4498                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 499
 4500                            break;
 501                        case PointerInputEventType.UP:
 3502                            if (areSameEntity && enablePointerEvent)
 3503                                pointerInputUpEvent = e;
 504                            else
 0505                                pointerInputUpEvent = null;
 506
 507                            break;
 508                    }
 509                }
 510
 10511                lastPointerDownEventHitInfo = raycastInfoPointerEventLayer.hitInfo;
 512            }
 513
 11514            ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer, curren
 515
 516            // Raycast for global pointer events (for each PE scene)
 11517            IEnumerable<string> currentPortableExperienceIds = DataStore.i.world.portableExperienceIds.Get();
 518
 22519            foreach (var pexId in currentPortableExperienceIds)
 520            {
 0521                if (worldState.TryGetScene(pexId, out var portableScene))
 522                {
 0523                    raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer, portableS
 524
 0525                    raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 526
 0527                    ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer
 528                        pexId);
 529                }
 530
 531            }
 532
 11533            if (dataStoreEcs7.isEcs7Enabled)
 0534                dataStoreEcs7.lastPointerInputEvent = new DataStore_ECS7.PointerEvent((int)buttonId, true, raycastInfoPo
 11535        }
 536
 537        private void ReportGlobalPointerUpEvent(
 538            WebInterface.ACTION_BUTTON buttonId,
 539            bool useRaycast,
 540            RaycastHitInfo raycastGlobalLayerHitInfo,
 541            RaycastResultInfo raycastInfoGlobalLayer,
 542            string sceneId)
 543        {
 3544            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 545            {
 3546                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 547                    out ColliderInfo colliderInfo);
 548
 3549                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 550
 3551                if (colliderInfo.entity != null)
 3552                    entityId =
 553                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 554
 3555                WebInterface.ReportGlobalPointerUpEvent(
 556                    buttonId,
 557                    raycastInfoGlobalLayer.ray,
 558                    raycastGlobalLayerHitInfo.hit.point,
 559                    raycastGlobalLayerHitInfo.hit.normal,
 560                    raycastGlobalLayerHitInfo.hit.distance,
 561                    sceneId,
 562                    entityId,
 563                    colliderInfo.meshName,
 564                    isHitInfoValid: true);
 3565            }
 566            else
 567            {
 0568                WebInterface.ReportGlobalPointerUpEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 569                    Vector3.zero, 0, sceneId);
 570            }
 0571        }
 572
 573        private void ReportGlobalPointerDownEvent(
 574            WebInterface.ACTION_BUTTON buttonId,
 575            bool useRaycast,
 576            RaycastHitInfo raycastGlobalLayerHitInfo,
 577            RaycastResultInfo raycastInfoGlobalLayer,
 578            string sceneId)
 579        {
 11580            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 581            {
 10582                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 583                    out ColliderInfo colliderInfo);
 584
 10585                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 586
 10587                if (colliderInfo.entity != null)
 10588                    entityId =
 589                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 590
 10591                WebInterface.ReportGlobalPointerDownEvent(
 592                    buttonId,
 593                    raycastInfoGlobalLayer.ray,
 594                    raycastGlobalLayerHitInfo.hit.point,
 595                    raycastGlobalLayerHitInfo.hit.normal,
 596                    raycastGlobalLayerHitInfo.hit.distance,
 597                    sceneId,
 598                    entityId,
 599                    colliderInfo.meshName,
 600                    isHitInfoValid: true);
 10601            }
 602            else
 603            {
 1604                WebInterface.ReportGlobalPointerDownEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 605                    Vector3.zero, 0, sceneId);
 606            }
 1607        }
 608
 609        bool AreSameEntity(IPointerEvent pointerInputEvent, ColliderInfo colliderInfo)
 610        {
 1114611            return pointerInputEvent != null && colliderInfo.entity != null &&
 612                   pointerInputEvent.entity == colliderInfo.entity;
 613        }
 614
 615        bool IsBlockingOnClick(RaycastHitInfo targetOnClickHit, RaycastHitInfo potentialBlockerHit)
 616        {
 14617            return
 618                potentialBlockerHit.hit.collider != null // Does a potential blocker hit exist?
 619                && targetOnClickHit.hit.collider != null // Was a target entity with a pointer event component hit?
 620                && potentialBlockerHit.hit.distance <=
 621                targetOnClickHit.hit.distance // Is potential blocker nearer than target entity?
 622                && !AreCollidersFromSameEntity(potentialBlockerHit,
 623                    targetOnClickHit); // Does potential blocker belong to other entity rather than target entity?
 624        }
 625
 626        bool EntityHasPointerEvent(IDCLEntity entity)
 627        {
 32628            var componentsManager = entity.scene.componentsManagerLegacy;
 629
 32630            return componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_CALLBACK) ||
 631                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_UP) ||
 632                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_DOWN) ||
 633                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_CLICK);
 634        }
 635
 636        bool AreCollidersFromSameEntity(RaycastHitInfo hitInfoA, RaycastHitInfo hitInfoB)
 637        {
 16638            CollidersManager.i.GetColliderInfo(hitInfoA.hit.collider, out ColliderInfo colliderInfoA);
 16639            CollidersManager.i.GetColliderInfo(hitInfoB.hit.collider, out ColliderInfo colliderInfoB);
 640
 16641            var entityA = colliderInfoA.entity;
 16642            var entityB = colliderInfoB.entity;
 643
 16644            bool entityAHasEvent = entityA != null && EntityHasPointerEvent(entityA);
 16645            bool entityBHasEvent = entityB != null && EntityHasPointerEvent(entityB);
 646
 647            // If both entities has OnClick/PointerEvent component
 16648            if (entityAHasEvent && entityBHasEvent)
 649            {
 14650                return entityA == entityB;
 651            }
 652            // If only one of them has OnClick/PointerEvent component
 2653            else if (entityAHasEvent ^ entityBHasEvent)
 654            {
 0655                return false;
 656            }
 657            // None of them has OnClick/PointerEvent component
 658            else
 659            {
 2660                return colliderInfoA.entity == colliderInfoB.entity;
 661            }
 662        }
 663
 664        private void HandleCursorLockChanges(bool isLocked)
 665        {
 0666            HideOrShowCursor(isLocked);
 667
 0668            if (!isLocked)
 0669                UnhoverLastHoveredObject();
 0670        }
 671
 166672        private void HideOrShowCursor(bool isCursorLocked) { DataStore.i.Get<DataStore_Cursor>().cursorVisible.Set(isCur
 673
 36674        private void SetHoverCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.H
 675
 10676        private void SetNormalCursor() { DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.
 677    }
 678}
Generated by: ReportGenerator 4.8.9.0
09/09/2022 - 13:27:11
GitHub | www.palmmedia.de

Methods/Properties

renderingEnabled()
PointerEventsController(DCL.InputController_Legacy, InteractionHoverCanvasController)
Update()
GetPointerEventList(DCL.Models.IDCLEntity)
GetPointerEvent(DCL.Models.IDCLEntity)
GetPointerInputEvents(DCL.Models.IDCLEntity, 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()