< Summary

Class:Builder.DCLBuilderEntity
Assembly:Builder
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Builder/Scripts/DCLBuilderEntity.cs
Covered lines:80
Uncovered lines:75
Coverable lines:155
Total lines:366
Line coverage:51.6% (80 of 155)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetEntity(...)0%33095.24%
IsInsideSceneBoundaries()0%3.333066.67%
SetSelectLayer()0%30500%
SetDefaultLayer()0%30500%
HasShape()0%2100%
HasRenderer()0%6200%
SetOnShapeLoaded(...)0%12300%
OnEntityRemoved(...)0%110100%
OnShapeUpdated(...)0%8.126061.11%
OnTransformUpdated(...)0%9.218073.33%
OnAvatarShapeUpdated(...)0%6200%
OnPreviewModeChanged(...)0%12300%
ProcessEntityShape(...)0%330100%
CreateColliders(...)0%330100%
ScaleAnimationRoutine()0%30500%
DestroyColliders()0%440100%
SetCollidersActive(...)0%440100%
DefaultAnimationStop()0%12300%
DefaultAnimationSample(...)0%5.264057.14%
DefaultAnimationPlay()0%12300%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Builder/Scripts/DCLBuilderEntity.cs

#LineLine coverage
 1using DCL.Components;
 2using DCL.Helpers;
 3using DCL.Models;
 4using System;
 5using System.Collections;
 6using DCL;
 7using UnityEngine;
 8using Environment = DCL.Environment;
 9
 10namespace Builder
 11{
 12    public class DCLBuilderEntity : EditableEntity
 13    {
 14        public static Action<DCLBuilderEntity> OnEntityShapeUpdated;
 15        public static Action<DCLBuilderEntity> OnEntityTransformUpdated;
 16        public static Action<DCLBuilderEntity> OnEntityAddedWithTransform;
 17
 18        public bool hasGizmoComponent
 19        {
 20            get
 21            {
 222                if (rootEntity != null)
 23                {
 224                    return rootEntity.components.ContainsKey(CLASS_ID_COMPONENT.GIZMOS);
 25                }
 26                else
 27                {
 028                    return false;
 29                }
 30            }
 31        }
 32
 33        public bool hasSmartItemComponent
 34        {
 35            get
 36            {
 237                if (rootEntity != null)
 38                {
 239                    return rootEntity.components.ContainsKey(CLASS_ID_COMPONENT.SMART_ITEM);
 40                }
 41                else
 42                {
 043                    return false;
 44                }
 45            }
 46        }
 47
 48        private DCLBuilderSelectionCollider[] meshColliders;
 49        private Animation[] meshAnimations;
 50        private Action OnShapeLoaded;
 51
 52        private bool isTransformComponentSet;
 53        private bool isShapeComponentSet;
 54
 55        private Vector3 scaleTarget;
 56        private bool isScalingAnimation = false;
 57
 58        public void SetEntity(IDCLEntity entity)
 59        {
 160            rootEntity = entity;
 61
 162            entity.OnShapeUpdated -= OnShapeUpdated;
 163            entity.OnShapeUpdated += OnShapeUpdated;
 64
 165            entity.OnTransformChange -= OnTransformUpdated;
 166            entity.OnTransformChange += OnTransformUpdated;
 67
 168            entity.OnRemoved -= OnEntityRemoved;
 169            entity.OnRemoved += OnEntityRemoved;
 70
 171            AvatarShape.OnAvatarShapeUpdated -= OnAvatarShapeUpdated;
 172            AvatarShape.OnAvatarShapeUpdated += OnAvatarShapeUpdated;
 73
 174            DCLBuilderBridge.OnPreviewModeChanged -= OnPreviewModeChanged;
 175            DCLBuilderBridge.OnPreviewModeChanged += OnPreviewModeChanged;
 76
 77            //builder evaluate boundaries by itself
 178            if (Environment.i.world.sceneBoundsChecker.enabled)
 179                entity.OnShapeUpdated -= Environment.i.world.sceneBoundsChecker.EvaluateEntityPosition;
 80
 181            gameObject.transform.localScale = Vector3.zero;
 82
 183            isTransformComponentSet = false;
 184            isShapeComponentSet = false;
 85
 186            scaleTarget = Vector3.one;
 87
 188            DestroyColliders();
 89
 190            if (HasShape())
 91            {
 092                OnShapeUpdated(entity);
 93            }
 194        }
 95
 96        public bool IsInsideSceneBoundaries()
 97        {
 198            if (rootEntity != null && rootEntity.meshesInfo.renderers != null)
 99            {
 1100                return rootEntity.scene.IsInsideSceneBoundaries(MeshesInfoUtils.BuildMergedBounds(rootEntity.meshesInfo.
 101            }
 102
 0103            return true;
 104        }
 105
 106        public override void SetSelectLayer()
 107        {
 0108            if (rootEntity.meshesInfo == null || rootEntity.meshesInfo.renderers == null)
 109            {
 0110                return;
 111            }
 112
 0113            int selectionLayer = LayerMask.NameToLayer(DCLBuilderRaycast.LAYER_SELECTION);
 114            Renderer renderer;
 0115            for (int i = 0; i < rootEntity.meshesInfo.renderers.Length; i++)
 116            {
 0117                renderer = rootEntity.meshesInfo.renderers[i];
 0118                if (renderer)
 0119                    renderer.gameObject.layer = selectionLayer;
 120            }
 0121        }
 122
 123        public override void SetDefaultLayer()
 124        {
 0125            if (rootEntity.meshesInfo == null || rootEntity.meshesInfo.renderers == null)
 126            {
 0127                return;
 128            }
 129
 0130            int selectionLayer = 0;
 131            Renderer renderer;
 0132            for (int i = 0; i < rootEntity.meshesInfo.renderers.Length; i++)
 133            {
 0134                renderer = rootEntity.meshesInfo.renderers[i];
 0135                if (renderer)
 0136                    renderer.gameObject.layer = selectionLayer;
 137            }
 0138        }
 139
 0140        public bool HasShape() { return isShapeComponentSet; }
 141
 0142        public bool HasRenderer() { return rootEntity.meshesInfo != null && rootEntity.meshesInfo.renderers != null; }
 143
 144        public void SetOnShapeLoaded(Action onShapeLoad)
 145        {
 0146            if (HasShape())
 147            {
 0148                if (onShapeLoad != null)
 0149                    onShapeLoad();
 0150            }
 151            else
 152            {
 0153                OnShapeLoaded = onShapeLoad;
 154            }
 0155        }
 156
 157        private void OnEntityRemoved(IDCLEntity entity)
 158        {
 1159            rootEntity.OnRemoved -= OnEntityRemoved;
 1160            rootEntity.OnShapeUpdated -= OnShapeUpdated;
 1161            rootEntity.OnTransformChange -= OnTransformUpdated;
 1162            DCLBuilderBridge.OnPreviewModeChanged -= OnPreviewModeChanged;
 1163            AvatarShape.OnAvatarShapeUpdated -= OnAvatarShapeUpdated;
 1164            DestroyColliders();
 1165        }
 166
 167        private void OnShapeUpdated(IDCLEntity entity)
 168        {
 2169            isShapeComponentSet = true;
 2170            OnEntityShapeUpdated?.Invoke(this);
 171
 172            // We don't want animation to be running on editor
 2173            meshAnimations = GetComponentsInChildren<Animation>();
 2174            if (hasSmartItemComponent)
 175            {
 0176                DefaultAnimationStop();
 0177            }
 178            else
 179            {
 2180                DefaultAnimationSample(0);
 181            }
 182
 2183            if (hasGizmoComponent)
 184            {
 0185                gameObject.transform.localScale = Vector3.zero;
 0186                StartCoroutine(ScaleAnimationRoutine(0.3f));
 0187            }
 2188            else if (isTransformComponentSet)
 189            {
 2190                gameObject.transform.localScale = scaleTarget;
 2191                ProcessEntityShape(entity);
 192            }
 193
 2194            if (OnShapeLoaded != null)
 195            {
 0196                OnShapeLoaded();
 0197                OnShapeLoaded = null;
 198            }
 2199        }
 200
 201        private void OnTransformUpdated(object model)
 202        {
 1203            DCLTransform.Model transformModel = (DCLTransform.Model)model;
 204            //NOTE: there is no parenting entities in editor mode so we can set properties in world space
 1205            gameObject.transform.position = transformModel.position;
 1206            gameObject.transform.rotation = transformModel.rotation;
 207
 1208            if (isScalingAnimation || !isShapeComponentSet)
 209            {
 1210                scaleTarget = transformModel.scale;
 1211            }
 0212            else if (isShapeComponentSet)
 213            {
 0214                scaleTarget = transformModel.scale;
 0215                gameObject.transform.localScale = transformModel.scale;
 216            }
 217
 1218            if (!isTransformComponentSet)
 219            {
 1220                isTransformComponentSet = true;
 1221                OnEntityAddedWithTransform?.Invoke(this);
 222            }
 223
 1224            if (isShapeComponentSet)
 225            {
 0226                OnEntityTransformUpdated?.Invoke(this);
 227            }
 1228        }
 229
 230        private void OnAvatarShapeUpdated(IDCLEntity entity, AvatarShape avatarShape)
 231        {
 0232            if (rootEntity != entity)
 233            {
 0234                return;
 235            }
 236
 0237            OnShapeUpdated(rootEntity);
 0238        }
 239
 240        private void OnPreviewModeChanged(bool isPreview)
 241        {
 0242            if (!hasSmartItemComponent)
 243            {
 0244                if (isPreview)
 245                {
 0246                    DefaultAnimationPlay();
 0247                }
 248                else
 249                {
 0250                    DefaultAnimationSample(0);
 251                }
 252            }
 253
 0254            SetCollidersActive(!isPreview);
 0255        }
 256
 257        private void ProcessEntityShape(IDCLEntity entity)
 258        {
 2259            if (entity.meshRootGameObject && entity.meshesInfo.renderers.Length > 0)
 260            {
 1261                CreateColliders(entity.meshesInfo);
 1262                SetCollidersActive(true);
 263            }
 2264        }
 265
 266        private void CreateColliders(MeshesInfo meshInfo)
 267        {
 1268            meshColliders = new DCLBuilderSelectionCollider[meshInfo.renderers.Length];
 8269            for (int i = 0; i < meshInfo.renderers.Length; i++)
 270            {
 3271                if (meshInfo.renderers[i] == null)
 272                    continue;
 3273                meshColliders[i] = new GameObject("BuilderSelectionCollider").AddComponent<DCLBuilderSelectionCollider>(
 3274                meshColliders[i].Initialize(this, meshInfo.renderers[i]);
 3275                meshColliders[i].gameObject.SetActive(false);
 276            }
 1277        }
 278
 279        private IEnumerator ScaleAnimationRoutine(float seconds)
 280        {
 0281            float startingTime = Time.time;
 0282            float normalizedTime = 0;
 0283            Vector3 scale = Vector3.zero;
 284
 0285            gameObject.transform.localScale = scale;
 0286            isScalingAnimation = true;
 287
 0288            while (Time.time - startingTime <= seconds)
 289            {
 0290                normalizedTime = (Time.time - startingTime) / seconds;
 0291                scale = Vector3.Lerp(scale, scaleTarget, normalizedTime);
 0292                gameObject.transform.localScale = scale;
 0293                yield return null;
 294            }
 295
 0296            gameObject.transform.localScale = scaleTarget;
 0297            isScalingAnimation = false;
 0298            ProcessEntityShape(rootEntity);
 0299            OnEntityTransformUpdated?.Invoke(this);
 0300        }
 301
 302        private void DestroyColliders()
 303        {
 2304            if (meshColliders != null)
 305            {
 8306                for (int i = 0; i < meshColliders.Length; i++)
 307                {
 3308                    if (meshColliders[i] != null)
 309                    {
 3310                        Destroy(meshColliders[i].gameObject);
 311                    }
 312                }
 313
 1314                meshColliders = null;
 315            }
 2316        }
 317
 318        private void SetCollidersActive(bool active)
 319        {
 1320            if (meshColliders != null)
 321            {
 8322                for (int i = 0; i < meshColliders.Length; i++)
 323                {
 3324                    if (meshColliders[i] != null)
 325                    {
 3326                        meshColliders[i].gameObject.SetActive(active);
 327                    }
 328                }
 329            }
 1330        }
 331
 332        private void DefaultAnimationStop()
 333        {
 0334            if (meshAnimations != null)
 335            {
 0336                for (int i = 0; i < meshAnimations.Length; i++)
 337                {
 0338                    meshAnimations[i].Stop();
 339                }
 340            }
 0341        }
 342
 343        private void DefaultAnimationSample(float time)
 344        {
 2345            if (meshAnimations != null)
 346            {
 4347                for (int i = 0; i < meshAnimations.Length; i++)
 348                {
 0349                    meshAnimations[i].Stop();
 0350                    meshAnimations[i].clip?.SampleAnimation(meshAnimations[i].gameObject, time);
 351                }
 352            }
 2353        }
 354
 355        private void DefaultAnimationPlay()
 356        {
 0357            if (meshAnimations != null)
 358            {
 0359                for (int i = 0; i < meshAnimations.Length; i++)
 360                {
 0361                    meshAnimations[i].Play();
 362                }
 363            }
 0364        }
 365    }
 366}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:13
GitHub | www.palmmedia.de

Methods/Properties

hasGizmoComponent()
hasSmartItemComponent()
SetEntity(DCL.Models.IDCLEntity)
IsInsideSceneBoundaries()
SetSelectLayer()
SetDefaultLayer()
HasShape()
HasRenderer()
SetOnShapeLoaded(System.Action)
OnEntityRemoved(DCL.Models.IDCLEntity)
OnShapeUpdated(DCL.Models.IDCLEntity)
OnTransformUpdated(System.Object)
OnAvatarShapeUpdated(DCL.Models.IDCLEntity, DCL.AvatarShape)
OnPreviewModeChanged(System.Boolean)
ProcessEntityShape(DCL.Models.IDCLEntity)
CreateColliders(DCL.Models.MeshesInfo)
ScaleAnimationRoutine()
DestroyColliders()
SetCollidersActive(System.Boolean)
DefaultAnimationStop()
DefaultAnimationSample(System.Single)
DefaultAnimationPlay()