Esempio n. 1
0
        void Start()
        {
            cachedWorldTransform = new WorldTransformData(transform);
            EnsureWellFormed();

            Invalidate(false);

            if (brushCache == null || brushCache.Polygons == null || brushCache.Polygons.Length == 0)
            {
                RecachePolygons(true);
            }

#if UNITY_EDITOR
            UnityEditor.EditorUtility.SetSelectedWireframeHidden(GetComponent <Renderer>(), true);
#endif

            objectVersionUnserialized = objectVersionSerialized;
        }
Esempio n. 2
0
        void Start()
        {
            cachedWorldTransform = new WorldTransformData(transform);
            EnsureWellFormed();

            Invalidate(false);

            if (brushCache == null || brushCache.Polygons == null || brushCache.Polygons.Length == 0)
            {
                RecachePolygons(true);
            }

#if UNITY_EDITOR
#if UNITY_5_5_OR_NEWER
            // Unity 5.5 introduces a second possible selection highlight state, so the hiding API has changed
            UnityEditor.EditorUtility.SetSelectedRenderState(GetComponent <Renderer>(), UnityEditor.EditorSelectedRenderState.Hidden);
#else
            // Pre Unity 5.5 the only selection highlight was a wireframe
            UnityEditor.EditorUtility.SetSelectedWireframeHidden(GetComponent <Renderer>(), true);
#endif
#endif

            objectVersionUnserialized = objectVersionSerialized;
        }
Esempio n. 3
0
        /// <summary>
        /// Tells the brush it has changed
        /// </summary>
        /// <param name="polygonsChanged">If set to <c>true</c> polygons will be recached.</param>
        public override void Invalidate(bool polygonsChanged)
        {
            base.Invalidate(polygonsChanged);
            if (!gameObject.activeInHierarchy)
            {
                return;
            }

            // previous versions of sabrecsg used to use mesh colliders for ray collision, but that's no longer the case so we clean them up.
            MeshCollider[] meshColliders = GetComponents <MeshCollider>();
            if (meshColliders.Length > 0)
            {
                for (int i = 0; i < meshColliders.Length; i++)
                {
                    DestroyImmediate(meshColliders[i]);
                }
            }


            // Make sure there is a mesh filter on this object
            MeshFilter   meshFilter   = gameObject.AddOrGetComponent <MeshFilter>();
            MeshRenderer meshRenderer = gameObject.AddOrGetComponent <MeshRenderer>();

            bool requireRegen = false;

            // If the cached ID hasn't been set or we mismatch
            if (cachedInstanceID == 0 ||
                gameObject.GetInstanceID() != cachedInstanceID)
            {
                requireRegen     = true;
                cachedInstanceID = gameObject.GetInstanceID();
            }

            Mesh renderMesh = meshFilter.sharedMesh;

            if (requireRegen)
            {
                renderMesh = new Mesh();
            }

            if (polygons != null)
            {
                List <int> polygonIndices;
                BrushFactory.GenerateMeshFromPolygons(polygons, ref renderMesh, out polygonIndices);
            }

            if (mode == CSGMode.Subtract)
            {
                MeshHelper.Invert(ref renderMesh);
            }
            // Displace the triangles for display along the normals very slightly (this is so we can overlay built
            // geometry with semi-transparent geometry and avoid depth fighting)
            MeshHelper.Displace(ref renderMesh, 0.001f);

            meshFilter.sharedMesh = renderMesh;

            meshRenderer.receiveShadows    = false;
            meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;

            meshFilter.hideFlags   = HideFlags.NotEditable; // | HideFlags.HideInInspector;
            meshRenderer.hideFlags = HideFlags.NotEditable; // | HideFlags.HideInInspector;

#if UNITY_EDITOR
            Material material;
            if (IsNoCSG)
            {
                material = SabreCSGResources.GetNoCSGMaterial();
            }
            else
            {
                if (this.mode == CSGMode.Add)
                {
                    material = SabreCSGResources.GetAddMaterial();
                }
                else
                {
                    material = SabreCSGResources.GetSubtractMaterial();
                }
            }
            if (meshRenderer.sharedMaterial != material)
            {
                meshRenderer.sharedMaterial = material;
            }
#endif
//			isBrushConvex = GeometryHelper.IsBrushConvex(polygons);

            if (polygonsChanged)
            {
                RecalculateBrushCache();
            }

            UpdateVisibility();

            objectVersionSerialized++;
            objectVersionUnserialized = objectVersionSerialized;

            if (cachedWorldTransform == null)
            {
                cachedWorldTransform = new WorldTransformData(transform);
            }
            cachedWorldTransform.SetFromTransform(transform);
        }