< Summary

Class:DCL.Camera.FreeCameraMovement
Assembly:BuilderInWorld
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/BuilderMode/States/EditorMode/FreeCameraController/FreeCameraMovement.cs
Covered lines:260
Uncovered lines:39
Coverable lines:299
Total lines:646
Line coverage:86.9% (260 of 299)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
FreeCameraMovement()0%110100%
Awake()0%10100100%
StartDectectingMovement()0%2100%
HasBeenMovement()0%2100%
StopDetectingMovement()0%2100%
OnInputMouseUp(...)0%2.062075%
OnInputMouseDown(...)0%2.032080%
OnDestroy()0%14140100%
Update()0%110100%
HandleCameraMovement()0%3.213071.43%
HandleCameraLook()0%2.062075%
HandleCameraPan()0%3.073080%
HandleCameraMovementInput()0%14140100%
GetTotalVelocity(...)0%3.583060%
SetCameraCanMove(...)0%2100%
MouseWheel(...)0%3.13077.78%
MouseDragRaw(...)0%330100%
MouseDrag(...)0%440100%
CameraDrag(...)0%2.022083.33%
CameraLook(...)0%3.043083.33%
OnGetRotation()0%110100%
FocusOnEntities(...)0%9.738070%
SetPosition(...)0%110100%
LookAt(...)0%110100%
SmoothLookAt(...)0%2100%
SmoothLookAt(...)0%2.062075%
FindMidPoint(...)0%660100%
SmoothScroll()0%4.024088.89%
SmoothFocusOnTarget()0%5.055087.5%
SmoothLookAtCorutine()0%440100%
SetResetConfiguration(...)0%110100%
ResetCameraPosition()0%110100%
TakeSceneScreenshot(...)0%110100%
TakeSceneScreenshotCoroutine()0%550100%
TakeSceneScreenshotFromResetPosition(...)0%2100%
TakeSceneScreenshotFromResetPositionCoroutine()0%20400%
ScreenshotFromCamera(...)0%110100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/BuilderMode/States/EditorMode/FreeCameraController/FreeCameraMovement.cs

#LineLine coverage
 1using System.Collections;
 2using System.Collections.Generic;
 3using UnityEngine;
 4
 5namespace DCL.Camera
 6{
 7    public interface IFreeCameraMovement
 8    {
 9        GameObject gameObject { get; }
 10        delegate void OnSnapshotsReady(Texture2D sceneSnapshot);
 11        void FocusOnEntities(List<BIWEntity> entitiesToFocus);
 12        void SmoothLookAt(Vector3 position);
 13        void StartDectectingMovement();
 14        void StopDetectingMovement();
 15        bool HasBeenMovement();
 16        void SetCameraCanMove(bool canMove);
 17        void SetPosition(Vector3 position);
 18        void LookAt(Transform transformToLookAt);
 19        void SetResetConfiguration(Vector3 position, Transform lookAt);
 20        void ResetCameraPosition();
 21        void TakeSceneScreenshot(OnSnapshotsReady onSuccess);
 22        void TakeSceneScreenshotFromResetPosition(OnSnapshotsReady onSuccess);
 23    }
 24
 25    public class FreeCameraMovement : CameraStateBase, IFreeCameraMovement
 26    {
 27        private const float CAMERA_ANGLE_THRESHOLD = 0.01f;
 28        private const float CAMERA_PAN_THRESHOLD = 0.001f;
 29        private const float CAMERA_MOVEMENT_THRESHOLD = 0.001f;
 30
 31        private const float CAMERA_MOVEMENT_DEACTIVATE_INPUT_MAGNITUD = 0.001f;
 32
 33        private const int SCENE_SNAPSHOT_WIDTH_RES = 854;
 34        private const int SCENE_SNAPSHOT_HEIGHT_RES = 480;
 35
 34236        public float focusDistance = 5f;
 37
 38        [Header("Camera Movement")]
 34239        public float xPlaneSpeedPercentCompensantion = 0.85f;
 40
 34241        public float movementSpeed = 5f;
 34242        public float lerpTime = 0.3F;
 43
 34244        public float lerpDeccelerationTime = 0.3F;
 34245        public float initalAcceleration = 2f;
 34246        public float speedClamp = 1f;
 47
 48        [Header("Camera Look")]
 34249        public float smoothLookAtSpeed = 5f;
 50
 34251        public float smoothCameraLookSpeed = 5f;
 34252        public float lookSpeedH = 2f;
 34253        public float lookSpeedV = 2f;
 54
 55        [Header("Camera Pan")]
 34256        public float smoothCameraPanAceleration = 5f;
 57
 34258        public float dragSpeed = 3f;
 59
 60        [Header("Camera Zoom")]
 34261        public float zoomSpeed = 2f;
 62
 63        [Header("InputActions")]
 64        [SerializeField] internal InputAction_Hold advanceFowardInputAction;
 65
 66        [SerializeField] internal InputAction_Hold advanceBackInputAction;
 67        [SerializeField] internal InputAction_Hold advanceLeftInputAction;
 68        [SerializeField] internal InputAction_Hold advanceRightInputAction;
 69        [SerializeField] internal InputAction_Hold advanceUpInputAction;
 70        [SerializeField] internal InputAction_Hold advanceDownInputAction;
 71        [SerializeField] internal InputAction_Hold cameraPanInputAction;
 72        [SerializeField] internal InputAction_Trigger zoomInFromKeyboardInputAction;
 73        [SerializeField] internal InputAction_Trigger zoomOutFromKeyboardInputAction;
 74
 34275        internal Vector3 direction = Vector3.zero;
 76
 77        internal float yaw = 0f;
 78        internal float pitch = 0f;
 79
 80        internal float panAxisX = 0f;
 81        internal float panAxisY = 0f;
 82
 34283        internal bool isCameraAbleToMove = true;
 84
 85        internal bool isAdvancingForward = false;
 86        internal bool isAdvancingBackward = false;
 87        internal bool isAdvancingLeft = false;
 88        internal bool isAdvancingRight = false;
 89        internal bool isAdvancingUp = false;
 90        internal bool isAdvancingDown = false;
 91
 92        internal bool isDetectingMovement = false;
 93        internal bool hasBeenMovement = false;
 94
 95        internal bool isPanCameraActive = false;
 96        internal bool isMouseRightClickDown = false;
 97
 98        internal Coroutine smoothLookAtCoroutine;
 99        internal Coroutine smoothFocusOnTargetCoroutine;
 100        internal Coroutine smoothScrollCoroutine;
 101        internal Coroutine takeScreenshotCoroutine;
 102
 103        private InputAction_Hold.Started advanceForwardStartDelegate;
 104        private InputAction_Hold.Finished advanceForwardFinishedDelegate;
 105
 106        private InputAction_Hold.Started advanceBackStartDelegate;
 107        private InputAction_Hold.Finished advanceBackFinishedDelegate;
 108
 109        private InputAction_Hold.Started advanceLeftStartDelegate;
 110        private InputAction_Hold.Finished advanceLeftFinishedDelegate;
 111
 112        private InputAction_Hold.Started advanceRightStartDelegate;
 113        private InputAction_Hold.Finished advanceRightFinishedDelegate;
 114
 115        private InputAction_Hold.Started advanceDownStartDelegate;
 116        private InputAction_Hold.Finished advanceDownFinishedDelegate;
 117
 118        private InputAction_Hold.Started advanceUpStartDelegate;
 119        private InputAction_Hold.Finished advanceUpFinishedDelegate;
 120
 121        private InputAction_Hold.Started cameraPanStartDelegate;
 122        private InputAction_Hold.Finished cameraPanFinishedDelegate;
 123
 124        private InputAction_Trigger.Triggered zoomInFromKeyboardDelegate;
 125        private InputAction_Trigger.Triggered zoomOutFromKeyboardDelegate;
 126
 127        private Vector3 nextTranslation;
 128        internal Vector3 originalCameraPosition;
 129        internal Transform originalCameraLookAt;
 342130        private Vector3 cameraVelocity = Vector3.zero;
 131
 132        private float lastMouseWheelTime;
 133        private float cameraPanAdvance;
 134        private float cameraLookAdvance;
 135        internal UnityEngine.Camera screenshotCamera;
 136
 137        private void Awake()
 138        {
 26139            BIWInputWrapper.OnMouseDrag += MouseDrag;
 26140            BIWInputWrapper.OnMouseDragRaw += MouseDragRaw;
 26141            BIWInputWrapper.OnMouseWheel += MouseWheel;
 142
 26143            BIWInputWrapper.OnMouseDown += OnInputMouseDown;
 26144            BIWInputWrapper.OnMouseUp += OnInputMouseUp;
 145
 26146            advanceForwardStartDelegate = (action) => isAdvancingForward = true;
 26147            advanceForwardFinishedDelegate = (action) => isAdvancingForward = false;
 148
 26149            if (advanceFowardInputAction != null)
 150            {
 12151                advanceFowardInputAction.OnStarted += advanceForwardStartDelegate;
 12152                advanceFowardInputAction.OnFinished += advanceForwardFinishedDelegate;
 153            }
 154
 26155            advanceBackStartDelegate = (action) => isAdvancingBackward = true;
 26156            advanceBackFinishedDelegate = (action) => isAdvancingBackward = false;
 157
 26158            if (advanceBackInputAction != null)
 159            {
 12160                advanceBackInputAction.OnStarted += advanceBackStartDelegate;
 12161                advanceBackInputAction.OnFinished += advanceBackFinishedDelegate;
 162            }
 163
 26164            advanceLeftStartDelegate = (action) => isAdvancingLeft = true;
 26165            advanceLeftFinishedDelegate = (action) => isAdvancingLeft = false;
 166
 26167            if (advanceLeftInputAction != null)
 168            {
 12169                advanceLeftInputAction.OnStarted += advanceLeftStartDelegate;
 12170                advanceLeftInputAction.OnFinished += advanceLeftFinishedDelegate;
 171            }
 172
 26173            advanceRightStartDelegate = (action) => isAdvancingRight = true;
 26174            advanceRightFinishedDelegate = (action) => isAdvancingRight = false;
 175
 26176            if (advanceRightInputAction != null)
 177            {
 12178                advanceRightInputAction.OnStarted += advanceRightStartDelegate;
 12179                advanceRightInputAction.OnFinished += advanceRightFinishedDelegate;
 180            }
 181
 26182            advanceUpStartDelegate = (action) => isAdvancingUp = true;
 26183            advanceUpFinishedDelegate = (action) => isAdvancingUp = false;
 184
 26185            if (advanceUpInputAction != null)
 186            {
 12187                advanceUpInputAction.OnStarted += advanceUpStartDelegate;
 12188                advanceUpInputAction.OnFinished += advanceUpFinishedDelegate;
 189            }
 190
 26191            advanceDownStartDelegate = (action) => isAdvancingDown = true;
 26192            advanceDownFinishedDelegate = (action) => isAdvancingDown = false;
 193
 26194            if (advanceDownInputAction != null)
 195            {
 12196                advanceDownInputAction.OnStarted += advanceDownStartDelegate;
 12197                advanceDownInputAction.OnFinished += advanceDownFinishedDelegate;
 198            }
 199
 26200            cameraPanStartDelegate = (action) => isPanCameraActive = true;
 26201            cameraPanFinishedDelegate = (action) => isPanCameraActive = false;
 202
 26203            if (cameraPanInputAction != null)
 204            {
 12205                cameraPanInputAction.OnStarted += cameraPanStartDelegate;
 12206                cameraPanInputAction.OnFinished += cameraPanFinishedDelegate;
 207            }
 208
 26209            zoomInFromKeyboardDelegate = (action) => MouseWheel(1f);
 210
 26211            if (zoomInFromKeyboardInputAction != null)
 12212                zoomInFromKeyboardInputAction.OnTriggered += zoomInFromKeyboardDelegate;
 213
 26214            zoomOutFromKeyboardDelegate = (action) => MouseWheel(-1f);
 215
 26216            if (zoomOutFromKeyboardInputAction != null)
 12217                zoomOutFromKeyboardInputAction.OnTriggered += zoomOutFromKeyboardDelegate;
 26218        }
 219
 220        public void StartDectectingMovement()
 221        {
 0222            isDetectingMovement = true;
 0223            hasBeenMovement = false;
 0224        }
 225
 0226        public bool HasBeenMovement() { return hasBeenMovement; }
 227
 0228        public void StopDetectingMovement() { isDetectingMovement = false; }
 229
 230        internal void OnInputMouseUp(int buttonId, Vector3 mousePosition)
 231        {
 1232            if (buttonId != 1)
 0233                return;
 234
 1235            isMouseRightClickDown = false;
 1236        }
 237
 238        internal void OnInputMouseDown(int buttonId, Vector3 mousePosition)
 239        {
 1240            if (buttonId != 1)
 0241                return;
 242
 1243            isMouseRightClickDown = true;
 1244            direction = Vector3.zero;
 1245        }
 246
 247        private void OnDestroy()
 248        {
 26249            BIWInputWrapper.OnMouseDrag -= MouseDrag;
 26250            BIWInputWrapper.OnMouseDragRaw -= MouseDragRaw;
 26251            BIWInputWrapper.OnMouseWheel -= MouseWheel;
 252
 26253            BIWInputWrapper.OnMouseDown -= OnInputMouseDown;
 26254            BIWInputWrapper.OnMouseUp -= OnInputMouseUp;
 255
 26256            if (advanceFowardInputAction != null)
 257            {
 12258                advanceFowardInputAction.OnStarted -= advanceForwardStartDelegate;
 12259                advanceFowardInputAction.OnFinished -= advanceForwardFinishedDelegate;
 260            }
 261
 26262            if (advanceBackInputAction != null)
 263            {
 12264                advanceBackInputAction.OnStarted -= advanceBackStartDelegate;
 12265                advanceBackInputAction.OnFinished -= advanceBackFinishedDelegate;
 266            }
 267
 26268            if (advanceLeftInputAction != null)
 269            {
 12270                advanceLeftInputAction.OnStarted -= advanceLeftStartDelegate;
 12271                advanceLeftInputAction.OnFinished -= advanceLeftFinishedDelegate;
 272            }
 273
 26274            if (advanceRightInputAction != null)
 275            {
 12276                advanceRightInputAction.OnStarted -= advanceRightStartDelegate;
 12277                advanceRightInputAction.OnFinished -= advanceRightFinishedDelegate;
 278            }
 279
 26280            if (advanceDownInputAction != null)
 281            {
 12282                advanceDownInputAction.OnStarted -= advanceDownStartDelegate;
 12283                advanceDownInputAction.OnFinished -= advanceDownFinishedDelegate;
 284            }
 285
 26286            if (advanceUpInputAction != null)
 287            {
 12288                advanceUpInputAction.OnStarted -= advanceUpStartDelegate;
 12289                advanceUpInputAction.OnFinished -= advanceUpFinishedDelegate;
 290            }
 291
 26292            if (cameraPanInputAction != null)
 293            {
 12294                cameraPanInputAction.OnStarted -= cameraPanStartDelegate;
 12295                cameraPanInputAction.OnFinished -= cameraPanFinishedDelegate;
 296            }
 297
 26298            if (zoomInFromKeyboardInputAction != null)
 12299                zoomInFromKeyboardInputAction.OnTriggered -= zoomInFromKeyboardDelegate;
 300
 26301            if (zoomOutFromKeyboardInputAction != null)
 12302                zoomOutFromKeyboardInputAction.OnTriggered -= zoomOutFromKeyboardDelegate;
 303
 26304            if (smoothScrollCoroutine != null)
 1305                CoroutineStarter.Stop(smoothScrollCoroutine);
 306
 26307            if (smoothLookAtCoroutine != null)
 1308                CoroutineStarter.Stop(smoothLookAtCoroutine);
 309
 26310            if (smoothFocusOnTargetCoroutine != null)
 1311                CoroutineStarter.Stop(smoothFocusOnTargetCoroutine);
 312
 26313            if (takeScreenshotCoroutine != null)
 2314                CoroutineStarter.Stop(takeScreenshotCoroutine);
 26315        }
 316
 317        private void Update()
 318        {
 1204319            HandleCameraLook();
 1204320            HandleCameraPan();
 1204321            HandleCameraMovement();
 1204322        }
 323
 324        #region CameraTransformChanges
 325
 326        private void HandleCameraMovement()
 327        {
 1204328            HandleCameraMovementInput();
 1204329            if (direction.magnitude >= CAMERA_MOVEMENT_DEACTIVATE_INPUT_MAGNITUD)
 0330                nextTranslation = direction;
 1204331            nextTranslation = Vector3.Lerp(nextTranslation, Vector3.zero, lerpTime * Time.deltaTime);
 332
 1204333            if (nextTranslation.magnitude >= CAMERA_MOVEMENT_THRESHOLD)
 0334                transform.Translate(nextTranslation * (movementSpeed * Time.deltaTime), Space.Self);
 1204335        }
 336
 337        private void HandleCameraLook()
 338        {
 1204339            Quaternion nextIteration =  Quaternion.Lerp(transform.rotation, Quaternion.Euler(new Vector3(pitch, yaw, 0f)
 340
 1204341            if (Mathf.Abs(nextIteration.eulerAngles.magnitude - transform.rotation.eulerAngles.magnitude) >= CAMERA_ANGL
 0342                transform.rotation = nextIteration;
 1204343        }
 344
 345        private void HandleCameraPan()
 346        {
 1204347            panAxisX = Mathf.Lerp(panAxisX, 0, cameraPanAdvance * Time.deltaTime);
 1204348            panAxisY = Mathf.Lerp(panAxisY, 0, cameraPanAdvance * Time.deltaTime);
 349
 1204350            if (Mathf.Abs(panAxisX) >= CAMERA_PAN_THRESHOLD || Mathf.Abs(panAxisY) >= CAMERA_PAN_THRESHOLD)
 0351                transform.Translate(panAxisX, panAxisY, 0);
 1204352        }
 353
 354        #endregion
 355
 356        internal void HandleCameraMovementInput()
 357        {
 1206358            int velocityChangedCount = 0;
 1206359            if (isAdvancingForward)
 360            {
 1361                cameraVelocity += GetTotalVelocity(Vector3.forward);
 1362                velocityChangedCount++;
 363            }
 364
 1206365            if (isAdvancingBackward)
 366            {
 1367                cameraVelocity += GetTotalVelocity(Vector3.back);
 1368                velocityChangedCount++;
 369            }
 370
 1206371            if (!isAdvancingBackward && !isAdvancingForward)
 1204372                cameraVelocity.z = Mathf.Lerp(cameraVelocity.z, 0, lerpDeccelerationTime);
 373
 1206374            if (isAdvancingRight)
 375            {
 1376                cameraVelocity += GetTotalVelocity(Vector3.right) * xPlaneSpeedPercentCompensantion;
 1377                velocityChangedCount++;
 378            }
 379
 1206380            if (isAdvancingLeft)
 381            {
 1382                cameraVelocity += GetTotalVelocity(Vector3.left) * xPlaneSpeedPercentCompensantion;
 1383                velocityChangedCount++;
 384            }
 385
 1206386            if (!isAdvancingRight && !isAdvancingLeft)
 1204387                cameraVelocity.x = Mathf.Lerp(cameraVelocity.x, 0, lerpDeccelerationTime);
 388
 1206389            if (isAdvancingUp)
 390            {
 1391                cameraVelocity += GetTotalVelocity(Vector3.up);
 1392                velocityChangedCount++;
 393            }
 394
 1206395            if (isAdvancingDown)
 396            {
 1397                cameraVelocity += GetTotalVelocity(Vector3.down);
 1398                velocityChangedCount++;
 399            }
 400
 1206401            if (!isAdvancingUp && !isAdvancingDown)
 1204402                cameraVelocity.y = Mathf.Lerp(cameraVelocity.y, 0, lerpDeccelerationTime);
 403
 1206404            if (velocityChangedCount != 0)
 2405                cameraVelocity = Vector3.ClampMagnitude(cameraVelocity, speedClamp);
 406
 1206407            direction = cameraVelocity;
 1206408        }
 409
 410        private Vector3 GetTotalVelocity(Vector3 velocityToAdd)
 411        {
 6412            if (!isMouseRightClickDown)
 0413                return  Vector3.zero;
 414
 6415            if (isDetectingMovement)
 0416                hasBeenMovement = true;
 6417            return velocityToAdd * (initalAcceleration * Time.deltaTime);
 418        }
 419
 0420        public void SetCameraCanMove(bool canMove) { isCameraAbleToMove = canMove; }
 421
 422        internal void MouseWheel(float axis)
 423        {
 1424            if (!isCameraAbleToMove)
 0425                return;
 426
 1427            if (smoothScrollCoroutine != null)
 0428                CoroutineStarter.Stop(smoothScrollCoroutine);
 429
 1430            float delta = Time.time - lastMouseWheelTime;
 1431            float scrollValue = axis * Mathf.Clamp01(delta);
 1432            lastMouseWheelTime = Time.time;
 433
 1434            smoothScrollCoroutine = CoroutineStarter.Start(SmoothScroll(scrollValue));
 1435        }
 436
 437        internal void MouseDragRaw(int buttonId, Vector3 mousePosition, float axisX, float axisY)
 438        {
 1439            if (buttonId == 1 && !isPanCameraActive)
 1440                CameraLook(axisX, axisY);
 1441        }
 442
 443        internal void MouseDrag(int buttonId, Vector3 mousePosition, float axisX, float axisY)
 444        {
 1445            if (buttonId == 2 || buttonId == 1 && isPanCameraActive)
 1446                CameraDrag(axisX, axisY);
 1447        }
 448
 449        private void CameraDrag(float axisX, float axisY)
 450        {
 1451            if (!isCameraAbleToMove)
 0452                return;
 453
 1454            panAxisX += -axisX * Time.deltaTime * dragSpeed;
 1455            panAxisY += -axisY * Time.deltaTime * dragSpeed;
 1456            cameraPanAdvance = smoothCameraPanAceleration;
 1457        }
 458
 459        private void CameraLook(float axisX, float axisY)
 460        {
 1461            if (!isCameraAbleToMove || !isMouseRightClickDown)
 0462                return;
 463
 1464            yaw += lookSpeedH * axisX;
 1465            pitch -= lookSpeedV * axisY;
 1466            cameraLookAdvance = smoothCameraLookSpeed * Time.deltaTime;
 1467        }
 468
 1469        public override Vector3 OnGetRotation() { return transform.eulerAngles; }
 470
 471        public void FocusOnEntities(List<BIWEntity> entitiesToFocus)
 472        {
 1473            if (entitiesToFocus.Count <= 0)
 0474                return;
 475
 1476            Vector3 middlePoint = FindMidPoint(entitiesToFocus);
 1477            if (Vector3.positiveInfinity == middlePoint ||
 478                Vector3.negativeInfinity == middlePoint ||
 479                float.IsNaN(middlePoint.x) ||
 480                float.IsNaN(middlePoint.y) ||
 481                float.IsNaN(middlePoint.z))
 0482                return;
 483
 1484            if (smoothFocusOnTargetCoroutine != null)
 0485                CoroutineStarter.Stop(smoothFocusOnTargetCoroutine);
 1486            smoothFocusOnTargetCoroutine = CoroutineStarter.Start(SmoothFocusOnTarget(middlePoint));
 1487            SmoothLookAt(middlePoint);
 1488        }
 489
 100490        public void SetPosition(Vector3 position) { transform.position = position; }
 491
 492        public void LookAt(Transform transformToLookAt)
 493        {
 50494            transform.LookAt(transformToLookAt);
 50495            yaw = transform.eulerAngles.y;
 50496            pitch = transform.eulerAngles.x;
 50497        }
 498
 0499        public void SmoothLookAt(Transform transformToLookAt) { SmoothLookAt(transformToLookAt.position); }
 500
 501        public void SmoothLookAt(Vector3 position)
 502        {
 1503            if (smoothLookAtCoroutine != null)
 0504                CoroutineStarter.Stop(smoothLookAtCoroutine);
 1505            smoothLookAtCoroutine = CoroutineStarter.Start(SmoothLookAtCorutine(position));
 1506        }
 507
 508        Vector3 FindMidPoint(List<BIWEntity> entitiesToLook)
 509        {
 1510            Vector3 finalPosition = Vector3.zero;
 1511            int totalPoints = 0;
 4512            foreach (BIWEntity entity in entitiesToLook)
 513            {
 1514                if (entity.rootEntity.meshRootGameObject && entity.rootEntity.meshesInfo.renderers.Length > 0)
 515                {
 1516                    Vector3 midPointFromEntity = Vector3.zero;
 4517                    foreach (Renderer render in entity.rootEntity.renderers)
 518                    {
 1519                        if (render == null)
 520                            continue;
 1521                        midPointFromEntity += render.bounds.center;
 522                    }
 523
 1524                    midPointFromEntity /= entity.rootEntity.renderers.Length;
 1525                    finalPosition += midPointFromEntity;
 1526                    totalPoints++;
 527                }
 528            }
 529
 1530            finalPosition /= totalPoints;
 1531            return finalPosition;
 532        }
 533
 534        IEnumerator SmoothScroll(float axis)
 535        {
 1536            float scrollMovementDestination = axis * zoomSpeed;
 537
 1538            Vector3 targetPosition = transform.position + transform.TransformDirection(Vector3.forward * scrollMovementD
 539
 1540            float advance = 0;
 1541            while (advance <= 1)
 542            {
 1543                advance += smoothLookAtSpeed * Time.deltaTime;
 1544                Vector3 result = Vector3.Lerp(transform.position, targetPosition, advance);
 1545                transform.position = result;
 1546                yield return null;
 547            }
 0548        }
 549
 550        IEnumerator SmoothFocusOnTarget(Vector3 targetPosition)
 551        {
 1552            float advance = 0;
 17553            while (advance <= 1)
 554            {
 17555                advance += smoothLookAtSpeed * Time.deltaTime;
 17556                transform.position = Vector3.Lerp(transform.position, targetPosition, advance);
 17557                if (Vector3.Distance(transform.position, targetPosition) <= focusDistance)
 1558                    yield break;
 16559                yield return null;
 560            }
 0561        }
 562
 563        IEnumerator SmoothLookAtCorutine(Vector3 targetPosition)
 564        {
 1565            Quaternion targetRotation = Quaternion.LookRotation(targetPosition - transform.position);
 1566            float advance = 0;
 37567            while (advance <= 1)
 568            {
 36569                advance += smoothLookAtSpeed * Time.deltaTime;
 36570                transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, advance);
 36571                yield return null;
 572            }
 573
 1574            yaw = transform.eulerAngles.y;
 1575            pitch = transform.eulerAngles.x;
 1576        }
 577
 578        public void SetResetConfiguration(Vector3 position, Transform lookAt)
 579        {
 49580            originalCameraPosition = position;
 49581            originalCameraLookAt = lookAt;
 49582        }
 583
 584        public void ResetCameraPosition()
 585        {
 1586            SetPosition(originalCameraPosition);
 1587            LookAt(originalCameraLookAt);
 1588            direction = Vector3.zero;
 1589        }
 590
 4591        public void TakeSceneScreenshot(IFreeCameraMovement.OnSnapshotsReady onSuccess) { takeScreenshotCoroutine = Star
 592
 593        private IEnumerator TakeSceneScreenshotCoroutine(IFreeCameraMovement.OnSnapshotsReady callback)
 594        {
 2595            UnityEngine.Camera camera = UnityEngine.Camera.main;
 2596            if (screenshotCamera != null)
 2597                camera = screenshotCamera;
 598
 2599            var current = camera.targetTexture;
 2600            camera.targetTexture = null;
 601
 2602            yield return null;
 603
 2604            Texture2D sceneScreenshot = ScreenshotFromCamera(camera, SCENE_SNAPSHOT_WIDTH_RES, SCENE_SNAPSHOT_HEIGHT_RES
 2605            camera.targetTexture = current;
 2606            callback?.Invoke(sceneScreenshot);
 2607        }
 608
 0609        public void TakeSceneScreenshotFromResetPosition(IFreeCameraMovement.OnSnapshotsReady onSuccess) { StartCoroutin
 610
 611        private IEnumerator TakeSceneScreenshotFromResetPositionCoroutine(IFreeCameraMovement.OnSnapshotsReady callback)
 612        {
 613            // Store current camera position/direction
 0614            Vector3 currentPos = transform.position;
 0615            Vector3 currentLookAt = transform.forward;
 0616            SetPosition(originalCameraPosition);
 0617            transform.LookAt(originalCameraLookAt);
 618
 0619            var current = camera.targetTexture;
 0620            camera.targetTexture = null;
 621
 0622            yield return null;
 623
 0624            Texture2D sceneScreenshot = ScreenshotFromCamera(camera, SCENE_SNAPSHOT_WIDTH_RES, SCENE_SNAPSHOT_HEIGHT_RES
 0625            camera.targetTexture = current;
 0626            callback?.Invoke(sceneScreenshot);
 627
 628            // Restore camera position/direction after the screenshot
 0629            SetPosition(currentPos);
 0630            transform.forward = currentLookAt;
 0631        }
 632
 633        private Texture2D ScreenshotFromCamera(UnityEngine.Camera cameraToScreenshot, int width, int height)
 634        {
 2635            RenderTexture rt = new RenderTexture(width, height, 32);
 2636            cameraToScreenshot.targetTexture = rt;
 2637            Texture2D screenShot = new Texture2D(rt.width, rt.height, TextureFormat.RGBA32, false);
 2638            cameraToScreenshot.Render();
 2639            RenderTexture.active = rt;
 2640            screenShot.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
 2641            screenShot.Apply();
 642
 2643            return screenShot;
 644        }
 645    }
 646}
Generated by: ReportGenerator 4.8.9.0
10/18/2021 - 20:28:17
GitHub | www.palmmedia.de

Methods/Properties

FreeCameraMovement()
Awake()
StartDectectingMovement()
HasBeenMovement()
StopDetectingMovement()
OnInputMouseUp(System.Int32, UnityEngine.Vector3)
OnInputMouseDown(System.Int32, UnityEngine.Vector3)
OnDestroy()
Update()
HandleCameraMovement()
HandleCameraLook()
HandleCameraPan()
HandleCameraMovementInput()
GetTotalVelocity(UnityEngine.Vector3)
SetCameraCanMove(System.Boolean)
MouseWheel(System.Single)
MouseDragRaw(System.Int32, UnityEngine.Vector3, System.Single, System.Single)
MouseDrag(System.Int32, UnityEngine.Vector3, System.Single, System.Single)
CameraDrag(System.Single, System.Single)
CameraLook(System.Single, System.Single)
OnGetRotation()
FocusOnEntities(System.Collections.Generic.List[BIWEntity])
SetPosition(UnityEngine.Vector3)
LookAt(UnityEngine.Transform)
SmoothLookAt(UnityEngine.Transform)
SmoothLookAt(UnityEngine.Vector3)
FindMidPoint(System.Collections.Generic.List[BIWEntity])
SmoothScroll()
SmoothFocusOnTarget()
SmoothLookAtCorutine()
SetResetConfiguration(UnityEngine.Vector3, UnityEngine.Transform)
ResetCameraPosition()
TakeSceneScreenshot(DCL.Camera.IFreeCameraMovement/OnSnapshotsReady)
TakeSceneScreenshotCoroutine()
TakeSceneScreenshotFromResetPosition(DCL.Camera.IFreeCameraMovement/OnSnapshotsReady)
TakeSceneScreenshotFromResetPositionCoroutine()
ScreenshotFromCamera(UnityEngine.Camera, System.Int32, System.Int32)