< 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:204
Uncovered lines:55
Coverable lines:259
Total lines:652
Line coverage:78.7% (204 of 259)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
PointerEventsController(...)0%330100%
Update()0%28.6227086.96%
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%5.295077.27%
ProcessButtonDown(...)0%15.1314082.05%
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;
 6025        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;
 6036        PointerEventData uiGraphicRaycastPointerEventData = new PointerEventData(null);
 6037        List<RaycastResult> uiGraphicRaycastResults = new List<RaycastResult>();
 38        GraphicRaycaster uiGraphicRaycaster;
 39
 40        private IRaycastPointerClickHandler clickHandler;
 41        private InputController_Legacy inputControllerLegacy;
 42        private InteractionHoverCanvasController hoverCanvas;
 43
 6044        public PointerEventsController(InputController_Legacy inputControllerLegacy,
 45            InteractionHoverCanvasController hoverCanvas)
 46        {
 6047            this.inputControllerLegacy = inputControllerLegacy;
 6048            this.hoverCanvas = hoverCanvas;
 49
 180050            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 51            {
 84052                var buttonId = (WebInterface.ACTION_BUTTON) i;
 53
 84054                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 55                    continue;
 56
 78057                inputControllerLegacy.AddListener(buttonId, OnButtonEvent);
 58            }
 59
 6060            OnPointerHoverStarts += SetHoverCursor;
 6061            OnPointerHoverEnds += SetNormalCursor;
 62
 6063            RetrieveCamera();
 64
 6065            Environment.i.platform.updateEventHandler.AddListener(IUpdateEventHandler.EventType.Update, Update);
 6066            Utils.OnCursorLockChanged += HandleCursorLockChanges;
 67
 6068            HideOrShowCursor(Utils.IsCursorLocked);
 6069        }
 70
 71        public void Update()
 72        {
 163573            if (charCamera == null)
 574                RetrieveCamera();
 75
 163576            if (!CommonScriptableObjects.rendererState.Get() || charCamera == null)
 077                return;
 78
 163579            if (!Utils.IsCursorLocked)
 22480                return;
 81
 141182            IWorldState worldState = Environment.i.world.state;
 83
 84            // We use Physics.Raycast() instead of our raycastHandler.Raycast() as that one is slower, sometimes 2x, bec
 141185            bool didHit = Physics.Raycast(GetRayFromCamera(), out hitInfo, Mathf.Infinity,
 86                PhysicsLayers.physicsCastLayerMaskWithoutCharacter);
 87
 141188            bool uiIsBlocking = false;
 141189            string currentSceneId = worldState.currentSceneId;
 90
 141191            bool validCurrentSceneId = !string.IsNullOrEmpty(currentSceneId);
 141192            bool validCurrentScene = validCurrentSceneId && worldState.loadedScenes.ContainsKey(currentSceneId);
 93
 94            // NOTE: in case of a single scene loaded (preview or builder) sceneId is set to null when stepping outside
 141195            if (didHit && validCurrentSceneId && validCurrentScene)
 96            {
 117297                DataStore_World worldData = DataStore.i.Get<DataStore_World>();
 117298                GraphicRaycaster raycaster = worldData.currentRaycaster.Get();
 99
 1172100                if (raycaster)
 101                {
 6102                    uiGraphicRaycastPointerEventData.position = new Vector2(Screen.width / 2, Screen.height / 2);
 6103                    uiGraphicRaycastResults.Clear();
 6104                    raycaster.Raycast(uiGraphicRaycastPointerEventData, uiGraphicRaycastResults);
 6105                    uiIsBlocking = uiGraphicRaycastResults.Count > 0;
 106                }
 107            }
 108
 1411109            if (!didHit || uiIsBlocking)
 110            {
 241111                clickHandler = null;
 241112                UnhoverLastHoveredObject();
 241113                return;
 114            }
 115
 1170116            var raycastHandlerTarget = hitInfo.collider.GetComponent<IRaycastPointerHandler>();
 1170117            if (raycastHandlerTarget != null)
 118            {
 0119                ResolveGenericRaycastHandlers(raycastHandlerTarget);
 0120                UnhoverLastHoveredObject();
 0121                return;
 122            }
 123
 1170124            if (CollidersManager.i.GetColliderInfo(hitInfo.collider, out ColliderInfo info))
 1170125                newHoveredInputEvent = GetPointerEvent(info.entity);
 126            else
 0127                newHoveredInputEvent = hitInfo.collider.GetComponentInChildren<IPointerEvent>();
 128
 1170129            clickHandler = null;
 130
 1170131            if (!EventObjectCanBeHovered(info, hitInfo.distance))
 132            {
 17133                UnhoverLastHoveredObject();
 17134                return;
 135            }
 136
 1153137            newHoveredGO = newHoveredInputEvent.GetTransform().gameObject;
 138
 1153139            if (newHoveredGO != lastHoveredObject)
 140            {
 18141                UnhoverLastHoveredObject();
 142
 18143                lastHoveredObject = newHoveredGO;
 144
 18145                lastHoveredEventList = GetPointerEventList(newHoveredInputEvent.entity);
 146
 147                // NOTE: this case is for the Avatar, since it hierarchy differs from other ECS components
 18148                if (lastHoveredEventList?.Count == 0)
 149                {
 0150                    lastHoveredEventList = newHoveredGO.GetComponents<IPointerEvent>();
 151                }
 152
 18153                OnPointerHoverStarts?.Invoke();
 154            }
 155
 156            // OnPointerDown/OnClick and OnPointerUp should display their hover feedback at different moments
 1153157            if (lastHoveredEventList != null && lastHoveredEventList.Count > 0)
 158            {
 1153159                bool isEntityShowingHoverFeedback = false;
 160
 4614161                for (int i = 0; i < lastHoveredEventList.Count; i++)
 162                {
 1154163                    if (lastHoveredEventList[i] is IPointerInputEvent e)
 164                    {
 1146165                        bool eventButtonIsPressed = inputControllerLegacy.IsPressed(e.GetActionButton());
 166
 1146167                        bool isClick = e.GetEventType() == PointerInputEventType.CLICK;
 1146168                        bool isDown = e.GetEventType() == PointerInputEventType.DOWN;
 1146169                        bool isUp = e.GetEventType() == PointerInputEventType.UP;
 170
 1146171                        if (isUp && eventButtonIsPressed)
 172                        {
 0173                            e.SetHoverState(true);
 0174                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 0175                        }
 1146176                        else if ((isDown || isClick) && !eventButtonIsPressed)
 177                        {
 1144178                            e.SetHoverState(true);
 1144179                            isEntityShowingHoverFeedback = isEntityShowingHoverFeedback || e.ShouldShowHoverFeedback();
 1144180                        }
 2181                        else if (!isEntityShowingHoverFeedback)
 182                        {
 2183                            e.SetHoverState(false);
 184                        }
 2185                    }
 186                    else
 187                    {
 8188                        lastHoveredEventList[i].SetHoverState(true);
 189                    }
 190                }
 191            }
 192
 1153193            newHoveredGO = null;
 1153194            newHoveredInputEvent = null;
 1153195        }
 196
 197        private IList<IPointerEvent> GetPointerEventList(IDCLEntity entity)
 198        {
 199            // If an event exist in the new ECS, we got that value, if not it is ECS 6, so we continue as before
 18200            if (DataStore.i.ecs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent> pointerInputEven
 201            {
 0202                return pointerInputEvent.Cast<IPointerEvent>().ToList();
 203            }
 204            else
 205            {
 18206                var lastHoveredEventList = newHoveredInputEvent.entity.gameObject.transform.Cast<Transform>()
 37207                                                               .Select(child => child.GetComponent<IPointerEvent>())
 37208                                                               .Where(pointerComponent => pointerComponent != null)
 209                                                               .ToArray();
 210
 18211                return lastHoveredEventList;
 212            }
 213        }
 214
 215        private IPointerEvent GetPointerEvent(IDCLEntity entity)
 216        {
 217            // If an event exist in the new ECS, we got that value, if not it is ECS 6, so we continue as before
 1170218            if (DataStore.i.ecs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent> pointerInputEven
 0219                return pointerInputEvent.First();
 220            else
 1170221                return entity.gameObject.GetComponentInChildren<IPointerEvent>();
 222        }
 223
 224        private IList<IPointerInputEvent> GetPointerInputEvents(IDCLEntity entity, GameObject hitGameObject)
 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
 10227            if (entity != null && DataStore.i.ecs7.entityEvents.TryGetValue(entity.entityId, out List<IPointerInputEvent
 0228                return pointerInputEvent;
 229            else
 10230                return hitGameObject.GetComponentsInChildren<IPointerInputEvent>();
 231        }
 232
 233        private bool EventObjectCanBeHovered(ColliderInfo colliderInfo, float distance)
 234        {
 1170235            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();
 0270                    clickHandler = null;
 271                }
 272            }
 0273        }
 274
 275        void UnhoverLastHoveredObject()
 276        {
 276277            if (lastHoveredObject == null)
 278            {
 271279                if (hoverCanvas != null)
 271280                    hoverCanvas.SetHoverState(false);
 281
 271282                return;
 283            }
 284
 5285            OnPointerHoverEnds?.Invoke();
 286
 22287            for (int i = 0; i < lastHoveredEventList.Count; i++)
 288            {
 6289                if (lastHoveredEventList[i] == null)
 290                    continue;
 6291                lastHoveredEventList[i].SetHoverState(false);
 292            }
 293
 5294            lastHoveredEventList = null;
 5295            lastHoveredObject = null;
 5296        }
 297
 298        public void Dispose()
 299        {
 1800300            for (int i = 0; i < Enum.GetValues(typeof(WebInterface.ACTION_BUTTON)).Length; i++)
 301            {
 840302                var buttonId = (WebInterface.ACTION_BUTTON) i;
 303
 840304                if (buttonId == WebInterface.ACTION_BUTTON.ANY)
 305                    continue;
 306
 780307                inputControllerLegacy.RemoveListener(buttonId, OnButtonEvent);
 308            }
 309
 60310            lastHoveredObject = null;
 60311            newHoveredGO = null;
 60312            newHoveredInputEvent = null;
 60313            lastHoveredEventList = null;
 314
 60315            OnPointerHoverStarts -= SetHoverCursor;
 60316            OnPointerHoverEnds -= SetNormalCursor;
 317
 60318            Environment.i.platform.updateEventHandler.RemoveListener(IUpdateEventHandler.EventType.Update, Update);
 60319            Utils.OnCursorLockChanged -= HandleCursorLockChanges;
 60320        }
 321
 322        void RetrieveCamera()
 323        {
 65324            if (charCamera == null)
 325            {
 65326                charCamera = Camera.main;
 327            }
 65328        }
 329
 330        public Ray GetRayFromCamera()
 331        {
 1425332            return charCamera.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2, 0));
 333        }
 334
 335        void OnButtonEvent(WebInterface.ACTION_BUTTON buttonId, InputController_Legacy.EVENT evt, bool useRaycast,
 336            bool enablePointerEvent)
 337        {
 338            //TODO(Brian): We should remove this when we get a proper initialization layer
 14339            if (!EnvironmentSettings.RUNNING_TESTS)
 340            {
 0341                if (Utils.LockedThisFrame())
 0342                    return;
 343
 0344                if (!Utils.IsCursorLocked || !renderingEnabled)
 0345                    return;
 346            }
 347
 14348            if (charCamera == null)
 349            {
 0350                RetrieveCamera();
 351
 0352                if (charCamera == null)
 0353                    return;
 354            }
 355
 14356            var pointerEventLayer =
 357                PhysicsLayers.physicsCastLayerMaskWithoutCharacter; //Ensure characterController is being filtered
 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            }
 3368        }
 369
 370        private void ProcessButtonUp(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 371            LayerMask pointerEventLayer, int globalLayer)
 372        {
 3373            IWorldState worldState = Environment.i.world.state;
 374
 3375            if (string.IsNullOrEmpty(worldState.currentSceneId))
 0376                return;
 377
 378            RaycastHitInfo raycastGlobalLayerHitInfo;
 3379            Ray ray = GetRayFromCamera();
 380
 381            // Raycast for global pointer events
 3382            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 383                worldState.loadedScenes[worldState.currentSceneId]);
 3384            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 385
 3386            if (pointerInputUpEvent != null)
 387            {
 388                // Raycast for pointer event components
 3389                RaycastResultInfo raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane,
 390                    pointerEventLayer, worldState.loadedScenes[worldState.currentSceneId]);
 391
 3392                bool isOnClickComponentBlocked =
 393                    IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 3394                bool isSameEntityThatWasPressed = AreCollidersFromSameEntity(raycastInfoPointerEventLayer.hitInfo,
 395                    lastPointerDownEventHitInfo);
 396
 3397                if (!isOnClickComponentBlocked && isSameEntityThatWasPressed && enablePointerEvent)
 398                {
 3399                    pointerInputUpEvent.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 400                }
 401
 3402                pointerInputUpEvent = null;
 403            }
 404
 3405            ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 406                worldState.currentSceneId);
 407
 408            // Raycast for global pointer events (for each PE scene)
 3409            List<string> currentPortableExperienceIds =
 410                DataStore.i.Get<DataStore_World>().portableExperienceIds.Get().ToList();
 411
 6412            for (int i = 0; i < currentPortableExperienceIds.Count; i++)
 413            {
 0414                raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 415                    worldState.loadedScenes[currentPortableExperienceIds[i]]);
 0416                raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 417
 0418                ReportGlobalPointerUpEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 419                    currentPortableExperienceIds[i]);
 420            }
 3421        }
 422
 423        private void ProcessButtonDown(WebInterface.ACTION_BUTTON buttonId, bool useRaycast, bool enablePointerEvent,
 424            LayerMask pointerEventLayer, int globalLayer)
 425        {
 11426            IWorldState worldState = Environment.i.world.state;
 427
 11428            if (string.IsNullOrEmpty(worldState.currentSceneId))
 0429                return;
 430
 431            RaycastHitInfo raycastGlobalLayerHitInfo;
 11432            Ray ray = GetRayFromCamera();
 433
 434            // Raycast for pointer event components
 11435            RaycastResultInfo raycastInfoPointerEventLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane,
 436                pointerEventLayer, worldState.loadedScenes[worldState.currentSceneId]);
 437
 438            // Raycast for global pointer events
 11439            RaycastResultInfo raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 440                worldState.loadedScenes[worldState.currentSceneId]);
 11441            raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 442
 11443            bool isOnClickComponentBlocked =
 444                IsBlockingOnClick(raycastInfoPointerEventLayer.hitInfo, raycastGlobalLayerHitInfo);
 445
 11446            if (!isOnClickComponentBlocked && raycastInfoPointerEventLayer.hitInfo.hit.collider)
 447            {
 10448                Collider collider = raycastInfoPointerEventLayer.hitInfo.hit.collider;
 449
 450                GameObject hitGameObject;
 451
 10452                if (CollidersManager.i.GetColliderInfo(collider, out ColliderInfo info))
 10453                    hitGameObject = info.entity.gameObject;
 454                else
 0455                    hitGameObject = collider.gameObject;
 456
 10457                IList<IPointerInputEvent> events = GetPointerInputEvents(info.entity, hitGameObject);
 458
 36459                for (var i = 0; i < events.Count; i++)
 460                {
 8461                    IPointerInputEvent e = events[i];
 8462                    bool areSameEntity = AreSameEntity(e, info);
 463
 8464                    switch (e.GetEventType())
 465                    {
 466                        case PointerInputEventType.CLICK:
 1467                            if (areSameEntity && enablePointerEvent)
 1468                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 1469                            break;
 470                        case PointerInputEventType.DOWN:
 4471                            if (areSameEntity && enablePointerEvent)
 4472                                e.Report(buttonId, ray, raycastInfoPointerEventLayer.hitInfo.hit);
 4473                            break;
 474                        case PointerInputEventType.UP:
 3475                            if (areSameEntity && enablePointerEvent)
 3476                                pointerInputUpEvent = e;
 477                            else
 0478                                pointerInputUpEvent = null;
 479                            break;
 480                    }
 481                }
 482
 10483                lastPointerDownEventHitInfo = raycastInfoPointerEventLayer.hitInfo;
 484            }
 485
 11486            ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 487                worldState.currentSceneId);
 488
 489            // Raycast for global pointer events (for each PE scene)
 11490            IEnumerable<string> currentPortableExperienceIds = DataStore.i.world.portableExperienceIds.Get();
 491
 22492            foreach (var pexId in currentPortableExperienceIds)
 493            {
 0494                raycastInfoGlobalLayer = raycastHandler.Raycast(ray, charCamera.farClipPlane, globalLayer,
 495                    worldState.loadedScenes[pexId]);
 0496                raycastGlobalLayerHitInfo = raycastInfoGlobalLayer.hitInfo;
 497
 0498                ReportGlobalPointerDownEvent(buttonId, useRaycast, raycastGlobalLayerHitInfo, raycastInfoGlobalLayer,
 499                    pexId);
 500            }
 11501        }
 502
 503        private void ReportGlobalPointerUpEvent(
 504            WebInterface.ACTION_BUTTON buttonId,
 505            bool useRaycast,
 506            RaycastHitInfo raycastGlobalLayerHitInfo,
 507            RaycastResultInfo raycastInfoGlobalLayer,
 508            string sceneId)
 509        {
 3510            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 511            {
 3512                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 513                    out ColliderInfo colliderInfo);
 514
 3515                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 516
 3517                if (colliderInfo.entity != null)
 3518                    entityId =
 519                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 520
 3521                WebInterface.ReportGlobalPointerUpEvent(
 522                    buttonId,
 523                    raycastInfoGlobalLayer.ray,
 524                    raycastGlobalLayerHitInfo.hit.point,
 525                    raycastGlobalLayerHitInfo.hit.normal,
 526                    raycastGlobalLayerHitInfo.hit.distance,
 527                    sceneId,
 528                    entityId,
 529                    colliderInfo.meshName,
 530                    isHitInfoValid: true);
 3531            }
 532            else
 533            {
 0534                WebInterface.ReportGlobalPointerUpEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 535                    Vector3.zero, 0, sceneId);
 536            }
 0537        }
 538
 539        private void ReportGlobalPointerDownEvent(
 540            WebInterface.ACTION_BUTTON buttonId,
 541            bool useRaycast,
 542            RaycastHitInfo raycastGlobalLayerHitInfo,
 543            RaycastResultInfo raycastInfoGlobalLayer,
 544            string sceneId)
 545        {
 11546            if (useRaycast && raycastGlobalLayerHitInfo.isValid)
 547            {
 10548                CollidersManager.i.GetColliderInfo(raycastGlobalLayerHitInfo.hit.collider,
 549                    out ColliderInfo colliderInfo);
 550
 10551                string entityId = SpecialEntityIdLegacyLiteral.SCENE_ROOT_ENTITY;
 552
 10553                if (colliderInfo.entity != null)
 10554                    entityId =
 555                        Environment.i.world.sceneController.entityIdHelper.GetOriginalId(colliderInfo.entity.entityId);
 556
 10557                WebInterface.ReportGlobalPointerDownEvent(
 558                    buttonId,
 559                    raycastInfoGlobalLayer.ray,
 560                    raycastGlobalLayerHitInfo.hit.point,
 561                    raycastGlobalLayerHitInfo.hit.normal,
 562                    raycastGlobalLayerHitInfo.hit.distance,
 563                    sceneId,
 564                    entityId,
 565                    colliderInfo.meshName,
 566                    isHitInfoValid: true);
 10567            }
 568            else
 569            {
 1570                WebInterface.ReportGlobalPointerDownEvent(buttonId, raycastInfoGlobalLayer.ray, Vector3.zero,
 571                    Vector3.zero, 0, sceneId);
 572            }
 1573        }
 574
 575        bool AreSameEntity(IPointerEvent pointerInputEvent, ColliderInfo colliderInfo)
 576        {
 1162577            return pointerInputEvent != null && colliderInfo.entity != null &&
 578                   pointerInputEvent.entity == colliderInfo.entity;
 579        }
 580
 581        bool IsBlockingOnClick(RaycastHitInfo targetOnClickHit, RaycastHitInfo potentialBlockerHit)
 582        {
 14583            return
 584                potentialBlockerHit.hit.collider != null // Does a potential blocker hit exist?
 585                && targetOnClickHit.hit.collider != null // Was a target entity with a pointer event component hit?
 586                && potentialBlockerHit.hit.distance <=
 587                targetOnClickHit.hit.distance // Is potential blocker nearer than target entity?
 588                && !AreCollidersFromSameEntity(potentialBlockerHit,
 589                    targetOnClickHit); // Does potential blocker belong to other entity rather than target entity?
 590        }
 591
 592        bool EntityHasPointerEvent(IDCLEntity entity)
 593        {
 32594            var componentsManager = entity.scene.componentsManagerLegacy;
 32595            return componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_CALLBACK) ||
 596                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_UP) ||
 597                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_DOWN) ||
 598                   componentsManager.HasComponent(entity, Models.CLASS_ID_COMPONENT.UUID_ON_CLICK);
 599        }
 600
 601        bool AreCollidersFromSameEntity(RaycastHitInfo hitInfoA, RaycastHitInfo hitInfoB)
 602        {
 16603            CollidersManager.i.GetColliderInfo(hitInfoA.hit.collider, out ColliderInfo colliderInfoA);
 16604            CollidersManager.i.GetColliderInfo(hitInfoB.hit.collider, out ColliderInfo colliderInfoB);
 605
 16606            var entityA = colliderInfoA.entity;
 16607            var entityB = colliderInfoB.entity;
 608
 16609            bool entityAHasEvent = entityA != null && EntityHasPointerEvent(entityA);
 16610            bool entityBHasEvent = entityB != null && EntityHasPointerEvent(entityB);
 611
 612            // If both entities has OnClick/PointerEvent component
 16613            if (entityAHasEvent && entityBHasEvent)
 614            {
 14615                return entityA == entityB;
 616            }
 617            // If only one of them has OnClick/PointerEvent component
 2618            else if (entityAHasEvent ^ entityBHasEvent)
 619            {
 0620                return false;
 621            }
 622            // None of them has OnClick/PointerEvent component
 623            else
 624            {
 2625                return colliderInfoA.entity == colliderInfoB.entity;
 626            }
 627        }
 628
 629        private void HandleCursorLockChanges(bool isLocked)
 630        {
 0631            HideOrShowCursor(isLocked);
 632
 0633            if (!isLocked)
 0634                UnhoverLastHoveredObject();
 0635        }
 636
 637        private void HideOrShowCursor(bool isCursorLocked)
 638        {
 60639            DataStore.i.Get<DataStore_Cursor>().cursorVisible.Set(isCursorLocked);
 60640        }
 641
 642        private void SetHoverCursor()
 643        {
 18644            DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.HOVER);
 18645        }
 646
 647        private void SetNormalCursor()
 648        {
 5649            DataStore.i.Get<DataStore_Cursor>().cursorType.Set(DataStore_Cursor.CursorType.NORMAL);
 5650        }
 651    }
 652}
Generated by: ReportGenerator 4.8.9.0
08/26/2022 - 09:02:04
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()