コード例 #1
0
        public static void GenerateLightmapUVButton(CSGModel[] models)
        {
            GUIStyleUtility.InitStyles();

            bool needLightmapUVUpdate = false;

            for (int m = 0; m < models.Length && !needLightmapUVUpdate; m++)
            {
                if (!models[m])
                {
                    continue;
                }

                needLightmapUVUpdate = MeshInstanceManager.NeedToGenerateLightmapUVsForModel(models[m]) || needLightmapUVUpdate;
            }

            if (needLightmapUVUpdate)
            {
                if (GUILayout.Button(UpdateLightmapUVContent, GUIStyleUtility.redButton))
                {
                    CSGModelManager.BuildLightmapUvs();
                }
                GUILayout.Space(10);
            }
        }
コード例 #2
0
 public static void UpdateLightmapUVButton()
 {
     CSG_GUIStyleUtility.InitStyles();
     if (IndentableButton(UpdateLightmapUVContent, CSG_GUIStyleUtility.redButton))
     {
         CSGModelManager.BuildLightmapUvs();
     }
 }
コード例 #3
0
        public static HideFlagsState BeginPicking(GameObject[] ignoreGameObjects)
        {
            var state = new HideFlagsState()
            {
                generatedComponents = new Dictionary <UnityEngine.GameObject, CSGModel>(),
                hideFlags           = new Dictionary <UnityEngine.GameObject, HideFlags>()
            };

            foreach (var model in CSGModelManager.GetAllModels())
            {
                if (!model.generatedMeshes)
                {
                    continue;
                }

                var renderers = model.generatedMeshes.GetComponentsInChildren <Renderer>();
                if (renderers != null)
                {
                    foreach (var renderer in renderers)
                    {
                        state.generatedComponents[renderer.gameObject] = model;
                    }
                }

                var colliders = model.generatedMeshes.GetComponentsInChildren <Collider>();
                if (colliders != null)
                {
                    foreach (var collider in colliders)
                    {
                        state.generatedComponents[collider.gameObject] = model;
                    }
                }
            }
            if (state.generatedComponents != null)
            {
                foreach (var pair in state.generatedComponents)
                {
                    var gameObject = pair.Key;
                    var model      = pair.Value;

                    state.hideFlags[gameObject] = gameObject.hideFlags;

                    if (ignoreGameObjects != null &&
                        ArrayUtility.Contains(ignoreGameObjects, model.gameObject))
                    {
                        gameObject.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
                    }
                    else
                    {
                        gameObject.hideFlags = HideFlags.None;
                    }
                }
            }
            return(state);
        }
コード例 #4
0
        public static void UpdateButtons(CSGModel[] models)
        {
            CSG_GUIStyleUtility.InitStyles();

            bool needLightmapUVUpdate = false;
            bool needColliderUpdate   = false;

            for (int m = 0; m < models.Length; m++)
            {
                if (!models[m])
                {
                    continue;
                }

                needLightmapUVUpdate = needLightmapUVUpdate || MeshInstanceManager.NeedToGenerateLightmapUVsForModel(models[m]);
                needColliderUpdate   = needColliderUpdate || MeshInstanceManager.NeedToGenerateCollidersForModel(models[m]);
            }

            if (needLightmapUVUpdate)
            {
                if (GUILayout.Button(UpdateLightmapUVContent, CSG_GUIStyleUtility.redButton))
                {
                    CSGModelManager.BuildLightmapUvs();
                }
                GUILayout.Space(10);
            }

            if (needColliderUpdate)
            {
                if (GUILayout.Button(UpdateCollidersContent))
                {
                    CSGModelManager.BuildColliders();
                }
                GUILayout.Space(10);
            }
        }
コード例 #5
0
        public static bool FindUnityWorldIntersection(Vector2 screenPos, out GameObject foundObject)
        {
            var sceneView = SceneView.currentDrawingSceneView;            // ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
            var camera    = sceneView ? sceneView.camera : Camera.current;

            foundObject = null;
            if (!camera)
            {
                return(false);
            }

            var wireframeShown = CSGSettings.IsWireframeShown(sceneView);
            var worldRay       = HandleUtility.GUIPointToWorldRay(screenPos);
            var worldRayStart  = worldRay.origin;
            var worldRayVector = (worldRay.direction * (camera.farClipPlane - camera.nearClipPlane));
            var worldRayEnd    = worldRayStart + worldRayVector;

            CSGModel intersectionModel = null;

            LegacyBrushIntersection[] intersections;
            if (FindMultiWorldIntersection(worldRayStart, worldRayEnd, out intersections, ignoreInvisibleSurfaces: !wireframeShown))
            {
                var visibleLayers = Tools.visibleLayers;
                for (int i = 0; i < intersections.Length; i++)
                {
                    if (((1 << intersections[i].gameObject.layer) & visibleLayers) == 0)
                    {
                        continue;
                    }
                    intersectionModel = intersections[i].model;
                    break;
                }
            }

            GameObject[] modelMeshes = null;
            HideFlags[]  hideFlags   = null;
            if (intersectionModel != null)
            {
                modelMeshes = CSGModelManager.GetModelMeshes(intersectionModel);
                if (modelMeshes != null)
                {
                    hideFlags = new HideFlags[modelMeshes.Length];
                    for (var i = 0; i < modelMeshes.Length; i++)
                    {
                        hideFlags[i]             = modelMeshes[i].hideFlags;
                        modelMeshes[i].hideFlags = HideFlags.None;
                    }
                }
            }

            var gameObject = HandleUtility.PickGameObject(screenPos, false);

            if (modelMeshes != null)
            {
                for (var i = 0; i < modelMeshes.Length; i++)
                {
                    var modelMesh = modelMeshes[i];
                    if (!modelMesh)
                    {
                        continue;
                    }

                    if (gameObject == modelMesh)
                    {
                        gameObject = null;
                    }

                    modelMesh.hideFlags = hideFlags[i];
                }
            }

            if (!gameObject ||
                gameObject.GetComponent <Canvas>() ||
                gameObject.GetComponent <CSGModel>() ||
                gameObject.GetComponent <CSGBrush>() ||
                gameObject.GetComponent <CSGOperation>() ||
                gameObject.GetComponent <GeneratedMeshInstance>() ||
                gameObject.GetComponent <GeneratedMeshes>())
            {
                return(false);
            }

            foundObject = gameObject;
            return(true);
        }
コード例 #6
0
        public static bool FindClickWorldIntersection(Vector2 screenPos, out GameObject foundObject)
        {
            var sceneView = SceneView.currentDrawingSceneView;// ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
            var camera    = sceneView ? sceneView.camera : Camera.current;

            foundObject = null;
            if (!camera)
            {
                return(false);
            }

            var worldRay       = HandleUtility.GUIPointToWorldRay(screenPos);
            var worldRayStart  = worldRay.origin;
            var worldRayVector = (worldRay.direction * (camera.farClipPlane - camera.nearClipPlane));
            var worldRayEnd    = worldRayStart + worldRayVector;

            CSGModel intersectionModel = null;

            if (_prevSceenPos == screenPos && _prevSceneView == sceneView && _deepClickIntersections != null)
            {
                var prevIntersection = (_deepIndex > 0 && _deepIndex < _deepClickIntersections.Length) ? _deepClickIntersections[_deepIndex] : null;
                if (_deepClickIntersections.Length > 1)
                {
                    var visibleLayers = Tools.visibleLayers;
                    for (var i = _deepClickIntersections.Length - 1; i >= 0; i--)
                    {
                        if (((1 << _deepClickIntersections[i].gameObject.layer) & visibleLayers) == 0)
                        {
                            continue;
                        }

                        if (_deepClickIntersections[i].brush)
                        {
                            continue;
                        }
                        ArrayUtility.RemoveAt(ref _deepClickIntersections, i);
                        if (i <= _deepIndex)
                        {
                            _deepIndex--;
                        }
                    }
                }

                if (_deepClickIntersections.Length <= 1)
                {
                    ResetDeepClick();
                }
                else
                {
                    _deepIndex = (_deepIndex + 1) % _deepClickIntersections.Length;
                    var currentIntersection = (_deepIndex > 0 && _deepIndex < _deepClickIntersections.Length) ? _deepClickIntersections[_deepIndex] : null;
                    if (currentIntersection != prevIntersection &&
                        currentIntersection != null)
                    {
                        foundObject       = currentIntersection.gameObject;
                        _prevSceenPos     = screenPos;
                        _prevSceneView    = sceneView;
                        intersectionModel = currentIntersection.model;
                    }
                    else
                    {
                        ResetDeepClick();
                    }
                }
            }

            if (_prevSceenPos != screenPos)
            {
                var wireframeShown = CSGSettings.IsWireframeShown(sceneView);
                if (FindMultiWorldIntersection(worldRayStart, worldRayEnd, out _deepClickIntersections, ignoreInvisibleSurfaces: !wireframeShown, ignoreUnrenderables: !wireframeShown))
                {
                    var visibleLayers = Tools.visibleLayers;
                    for (int i = 0; i < _deepClickIntersections.Length; i++)
                    {
                        if (((1 << _deepClickIntersections[i].gameObject.layer) & visibleLayers) == 0)
                        {
                            continue;
                        }

                        _deepIndex = 0;
                        var intersection = _deepClickIntersections[i];
                        foundObject       = intersection.gameObject;
                        _prevSceenPos     = screenPos;
                        _prevSceneView    = sceneView;
                        intersectionModel = intersection.model;
                        break;
                    }
                }
                else
                {
                    ResetDeepClick();
                }
            }

            GameObject[] modelMeshes = null;
            if (intersectionModel != null)
            {
                modelMeshes = CSGModelManager.GetModelMeshes(intersectionModel);
            }

            HideFlags[] hideFlags = null;
            if (modelMeshes != null)
            {
                hideFlags = new HideFlags[modelMeshes.Length];
                for (var i = 0; i < modelMeshes.Length; i++)
                {
                    hideFlags[i] = modelMeshes[i].hideFlags;
                    if (modelMeshes[i].hideFlags != HideFlags.None)
                    {
                        modelMeshes[i].hideFlags = HideFlags.None;
                    }
                }
            }

            var gameObject = HandleUtility.PickGameObject(screenPos, true);

            if (modelMeshes != null)
            {
                for (var i = 0; i < modelMeshes.Length; i++)
                {
                    var modelMesh = modelMeshes[i];
                    if (!modelMesh)
                    {
                        continue;
                    }

                    if (gameObject == modelMesh)
                    {
                        gameObject = null;
                    }

                    if (modelMesh.hideFlags != hideFlags[i])
                    {
                        modelMesh.hideFlags = hideFlags[i];
                    }
                }
            }

            if (!gameObject ||
                gameObject.GetComponent <CSGModel>() ||
                gameObject.GetComponent <CSGBrush>() ||
                gameObject.GetComponent <CSGOperation>() ||
                gameObject.GetComponent <GeneratedMeshInstance>() ||
                gameObject.GetComponent <GeneratedMeshes>())
            {
                return(foundObject != null);
            }

            foundObject = gameObject;
            return(true);
        }