Exemple #1
0
 void SetDirty(DirtyFlags flags)
 {
     if (m_IsUsedInstance)
     {
         if (flags.HasFlag(DirtyFlags.Target))
         {
             EditorUtility.SetDirty(target);
         }
         if (flags.HasFlag(DirtyFlags.Shader))
         {
             m_NeedToRefreshShader = true;
         }
         if (flags.HasFlag(DirtyFlags.Noise))
         {
             m_NeedToReloadNoise = true;
         }
         if (flags.HasFlag(DirtyFlags.GlobalMesh))
         {
             GlobalMesh.Destroy();
         }
         if (flags.HasFlag(DirtyFlags.AllBeamGeom))
         {
             VolumetricLightBeam._EditorSetAllBeamGeomDirty();
         }
         if (flags.HasFlag(DirtyFlags.AllMeshes))
         {
             VolumetricLightBeam._EditorSetAllMeshesDirty();
         }
     }
 }
Exemple #2
0
        public void Reset()
        {
            geometryOverrideLayer = Consts.ConfigGeometryOverrideLayerDefault;
            geometryLayerID       = Consts.ConfigGeometryLayerIDDefault;
            geometryTag           = Consts.ConfigGeometryTagDefault;
            geometryRenderQueue   = (int)Consts.ConfigGeometryRenderQueueDefault;

            beamShader1Pass = Shader.Find("Hidden/VolumetricLightBeam1Pass");
            beamShader2Pass = Shader.Find("Hidden/VolumetricLightBeam2Pass");

            sharedMeshSides    = Consts.ConfigSharedMeshSides;
            sharedMeshSegments = Consts.ConfigSharedMeshSegments;

            globalNoiseScale    = Consts.NoiseScaleDefault;
            globalNoiseVelocity = Consts.NoiseVelocityDefault;

            noise3DData = Resources.Load("Noise3D_64x64x64") as TextAsset;
            noise3DSize = Consts.ConfigNoise3DSizeDefault;

            dustParticlesPrefab = Resources.Load("DustParticles", typeof(ParticleSystem)) as ParticleSystem;

            renderPipeline = Consts.ConfigGeometryRenderPipelineDefault;
            renderingMode  = Consts.ConfigGeometryRenderingModeDefault;

#if UNITY_EDITOR
            GlobalMesh.Destroy();
            VolumetricLightBeam._EditorSetAllMeshesDirty();
            OnRenderPipelineChanged(renderPipeline);
#endif
        }
Exemple #3
0
        public void Reset()
        {
            geometryOverrideLayer = Consts.ConfigGeometryOverrideLayerDefault;
            geometryLayerID       = Consts.ConfigGeometryLayerIDDefault;
            geometryTag           = Consts.ConfigGeometryTagDefault;
            geometryRenderQueue   = (int)Consts.ConfigGeometryRenderQueueDefault;

            sharedMeshSides    = Consts.ConfigSharedMeshSides;
            sharedMeshSegments = Consts.ConfigSharedMeshSegments;

            globalNoiseScale    = Consts.NoiseScaleDefault;
            globalNoiseVelocity = Consts.NoiseVelocityDefault;

            renderPipeline  = Consts.ConfigGeometryRenderPipelineDefault;
            renderingMode   = Consts.ConfigGeometryRenderingModeDefault;
            ditheringFactor = Consts.ConfigDitheringFactor;

            fadeOutCameraTag = Consts.ConfigFadeOutCameraTagDefault;

            featureEnabledColorGradient      = Consts.ConfigFeatureEnabledColorGradientDefault;
            featureEnabledDepthBlend         = Consts.ConfigFeatureEnabledDefault;
            featureEnabledNoise3D            = Consts.ConfigFeatureEnabledDefault;
            featureEnabledDynamicOcclusion   = Consts.ConfigFeatureEnabledDefault;
            featureEnabledMeshSkewing        = Consts.ConfigFeatureEnabledDefault;
            featureEnabledShaderAccuracyHigh = Consts.ConfigFeatureEnabledDefault;

            ResetInternalData();

#if UNITY_EDITOR
            GlobalMesh.Destroy();
            VolumetricLightBeam._EditorSetAllMeshesDirty();
#endif
        }
Exemple #4
0
        /// <summary>
        /// Generate the cone mesh and calls UpdateMaterialAndBounds.
        /// Since this process involves recreating a new mesh, make sure to not call it at every frame during playtime.
        /// </summary>
        public void RegenerateMesh()
        {
            Debug.Assert(m_Master);

            if (Config.Instance.geometryOverrideLayer)
            {
                gameObject.layer = Config.Instance.geometryLayerID;
            }
            else
            {
                gameObject.layer = m_Master.gameObject.layer;
            }

            gameObject.tag = Config.Instance.geometryTag;

            if (coneMesh && m_CurrentMeshType == MeshType.Custom)
            {
                DestroyImmediate(coneMesh);
            }

            m_CurrentMeshType = m_Master.geomMeshType;

            switch (m_Master.geomMeshType)
            {
            case MeshType.Custom:
            {
                coneMesh           = MeshGenerator.GenerateConeZ_Radius(1f, 1f, 1f, m_Master.geomCustomSides, m_Master.geomCustomSegments, m_Master.geomCap, Config.Instance.useSinglePassShader);
                coneMesh.hideFlags = Consts.ProceduralObjectsHideFlags;
                meshFilter.mesh    = coneMesh;
                break;
            }

            case MeshType.Shared:
            {
                coneMesh = GlobalMesh.Get();
                meshFilter.sharedMesh = coneMesh;
                break;
            }

            default:
            {
                Debug.LogError("Unsupported MeshType");
                break;
            }
            }

            UpdateMaterialAndBounds();
        }
Exemple #5
0
        public void Reset()
        {
            ResetInternalData();

            geometryOverrideLayer = Consts.ConfigGeometryOverrideLayerDefault;
            geometryLayerID       = Consts.ConfigGeometryLayerIDDefault;
            geometryTag           = Consts.ConfigGeometryTagDefault;
            geometryRenderQueue   = (int)Consts.ConfigGeometryRenderQueueDefault;

            sharedMeshSides    = Consts.ConfigSharedMeshSides;
            sharedMeshSegments = Consts.ConfigSharedMeshSegments;

            globalNoiseScale    = Consts.NoiseScaleDefault;
            globalNoiseVelocity = Consts.NoiseVelocityDefault;

            renderPipeline = Consts.ConfigGeometryRenderPipelineDefault;
            renderingMode  = Consts.ConfigGeometryRenderingModeDefault;

#if UNITY_EDITOR
            GlobalMesh.Destroy();
            VolumetricLightBeam._EditorSetAllMeshesDirty();
            OnRenderPipelineChanged(renderPipeline);
#endif
        }
Exemple #6
0
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();
            bool reloadNoise = false;

            if ((Object)Config.Instance != this.target)
            {
                EditorGUILayout.HelpBox(EditorStrings.ConfigMultipleAssets, MessageType.Error);
                EditorGUILayout.Separator();
                ButtonOpenConfig();
            }
            else
            {
                EditorGUI.BeginChangeCheck();
                {
                    if (HeaderFoldable("Beam Geometry"))
                    {
                        using (new EditorGUILayout.HorizontalScope())
                        {
                            geometryOverrideLayer.boolValue = EditorGUILayout.Toggle(EditorStrings.ConfigGeometryOverrideLayer, geometryOverrideLayer.boolValue);
                            using (new EditorGUI.DisabledGroupScope(!geometryOverrideLayer.boolValue))
                            {
                                geometryLayerID.intValue = EditorGUILayout.LayerField(geometryLayerID.intValue);
                            }
                        }

                        geometryTag.stringValue = EditorGUILayout.TagField(EditorStrings.ConfigGeometryTag, geometryTag.stringValue);
                    }
                    DrawLineSeparator();

                    if (HeaderFoldable("Rendering"))
                    {
                        RenderQueueGUIDraw();

                        if (BeamGeometry.isCustomRenderPipelineSupported)
                        {
                            EditorGUI.BeginChangeCheck();
                            {
                                renderPipeline.CustomEnum <RenderPipeline>(EditorStrings.ConfigGeometryRenderPipeline, EditorStrings.ConfigGeometryRenderPipelineEnumDescriptions);
                            }
                            if (EditorGUI.EndChangeCheck())
                            {
                                Config.OnRenderPipelineChanged((RenderPipeline)renderPipeline.enumValueIndex);
                                VolumetricLightBeam._EditorSetAllBeamGeomDirty(); // need to fully reset the BeamGeom to update the shader
                                ReimportShaders();
                            }
                        }

                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUILayout.PropertyField(renderingMode, EditorStrings.ConfigGeometryRenderingMode);

                            if (renderPipeline.enumValueIndex == (int)RenderPipeline.SRP_4_0_0_or_higher && renderingMode.enumValueIndex == (int)RenderingMode.MultiPass)
                            {
                                EditorGUILayout.HelpBox(EditorStrings.ConfigSrpAndMultiPassNoCompatible, MessageType.Error);
                            }

#pragma warning disable 0162 // warning CS0162: Unreachable code detected
                            if (renderingMode.enumValueIndex == (int)RenderingMode.GPUInstancing && !GpuInstancing.isSupported)
                            {
                                EditorGUILayout.HelpBox(EditorStrings.ConfigGeometryGpuInstancingNotSupported, MessageType.Warning);
                            }
#pragma warning restore 0162
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            VolumetricLightBeam._EditorSetAllBeamGeomDirty(); // need to fully reset the BeamGeom to update the shader
                            GlobalMesh.Destroy();
                            ReimportShaders();
                        }
                    }
                }
                if (EditorGUI.EndChangeCheck())
                {
                    VolumetricLightBeam._EditorSetAllMeshesDirty();
                }
                DrawLineSeparator();

                if (HeaderFoldable("Shared Mesh"))
                {
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(sharedMeshSides, EditorStrings.ConfigSharedMeshSides);
                    EditorGUILayout.PropertyField(sharedMeshSegments, EditorStrings.ConfigSharedMeshSegments);
                    if (EditorGUI.EndChangeCheck())
                    {
                        GlobalMesh.Destroy();
                        VolumetricLightBeam._EditorSetAllMeshesDirty();
                    }

                    var meshInfo = "These properties will change the mesh tessellation of each Volumetric Light Beam with 'Shared' MeshType.\nAdjust them carefully since they could impact performance.";
                    meshInfo += string.Format("\nShared Mesh stats: {0} vertices, {1} triangles", MeshGenerator.GetSharedMeshVertexCount(), MeshGenerator.GetSharedMeshIndicesCount() / 3);
                    EditorGUILayout.HelpBox(meshInfo, MessageType.Info);
                }
                DrawLineSeparator();

                if (HeaderFoldable("Global 3D Noise"))
                {
                    EditorGUILayout.PropertyField(globalNoiseScale, EditorStrings.ConfigGlobalNoiseScale);
                    EditorGUILayout.PropertyField(globalNoiseVelocity, EditorStrings.ConfigGlobalNoiseVelocity);
                }
                DrawLineSeparator();

                if (HeaderFoldable("Internal Data (do not change)"))
                {
                    EditorGUILayout.PropertyField(beamShader1Pass, EditorStrings.ConfigBeamShader1Pass);
                    EditorGUILayout.PropertyField(beamShader2Pass, EditorStrings.ConfigBeamShader2Pass);
                    EditorGUILayout.PropertyField(dustParticlesPrefab, EditorStrings.ConfigDustParticlesPrefab);

                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(noise3DData, EditorStrings.ConfigNoise3DData);
                    EditorGUILayout.PropertyField(noise3DSize, EditorStrings.ConfigNoise3DSize);
                    if (EditorGUI.EndChangeCheck())
                    {
                        reloadNoise = true;
                    }

                    if (Noise3D.isSupported && !Noise3D.isProperlyLoaded)
                    {
                        EditorGUILayout.HelpBox(EditorStrings.HelpNoiseLoadingFailed, MessageType.Error);
                    }
                }
                DrawLineSeparator();

                using (new EditorGUILayout.HorizontalScope())
                {
                    if (GUILayout.Button(EditorStrings.ConfigOpenDocumentation, EditorStyles.miniButton))
                    {
                        UnityEditor.Help.BrowseURL(Consts.HelpUrlConfig);
                    }

                    if (GUILayout.Button(EditorStrings.ConfigResetToDefaultButton, EditorStyles.miniButton))
                    {
                        UnityEditor.Undo.RecordObject(target, "Reset Config Properties");
                        (target as Config).Reset();
                    }
                }
            }

            serializedObject.ApplyModifiedProperties();

            if (reloadNoise)
            {
                Noise3D._EditorForceReloadData(); // Should be called AFTER ApplyModifiedProperties so the Config instance has the proper values when reloading data
            }
        }
 public void OnActiveBuildTargetChanged(BuildTarget previousTarget, BuildTarget newTarget)
 {
     Config.Instance.RefreshShader(Config.RefreshShaderFlags.All);
     GlobalMesh.Destroy();
     VolumetricLightBeam._EditorSetAllMeshesDirty();
 }
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();

            Header("Beam Geometry");
            EditorGUI.BeginChangeCheck();
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    geometryOverrideLayer.boolValue = EditorGUILayout.Toggle(EditorStrings.ConfigGeometryOverrideLayer, geometryOverrideLayer.boolValue);
                    using (new EditorGUI.DisabledGroupScope(!geometryOverrideLayer.boolValue))
                    {
                        geometryLayerID.intValue = EditorGUILayout.LayerField(geometryLayerID.intValue);
                    }
                }

                geometryTag.stringValue = EditorGUILayout.TagField(EditorStrings.ConfigGeometryTag, geometryTag.stringValue);
            }

            Header("Rendering");
            {
                RenderQueueGUIDraw();

                EditorGUI.BeginChangeCheck();
                {
                    forceSinglePass.boolValue = EditorGUILayout.Toggle(EditorStrings.ConfigGeometryForceSinglePass, forceSinglePass.boolValue);
                }
                if (EditorGUI.EndChangeCheck())
                {
                    VolumetricLightBeam._EditorSetAllBeamGeomDirty(); // need to fully reset the BeamGeom to update the shader
                    GlobalMesh.Destroy();
                }
            }
            if (EditorGUI.EndChangeCheck())
            {
                VolumetricLightBeam._EditorSetAllMeshesDirty();
            }

            EditorGUILayout.PropertyField(beamShader1Pass, EditorStrings.ConfigBeamShader1Pass);
            EditorGUILayout.PropertyField(beamShader2Pass, EditorStrings.ConfigBeamShader2Pass);

            Header("Shared Mesh");
            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(sharedMeshSides, EditorStrings.ConfigSharedMeshSides);
            EditorGUILayout.PropertyField(sharedMeshSegments, EditorStrings.ConfigSharedMeshSegments);
            if (EditorGUI.EndChangeCheck())
            {
                GlobalMesh.Destroy();
                VolumetricLightBeam._EditorSetAllMeshesDirty();
            }

            var meshInfo = "These properties will change the mesh tessellation of each Volumetric Light Beam with 'Shared' MeshType.\nAdjust them carefully since they could impact performance.";

            meshInfo += string.Format("\nShared Mesh stats: {0} vertices, {1} triangles", MeshGenerator.GetSharedMeshVertexCount(), MeshGenerator.GetSharedMeshIndicesCount() / 3);
            EditorGUILayout.HelpBox(meshInfo, MessageType.Info);

            Header("Global 3D Noise");
            EditorGUILayout.PropertyField(globalNoiseScale, EditorStrings.ConfigGlobalNoiseScale);
            EditorGUILayout.PropertyField(globalNoiseVelocity, EditorStrings.ConfigGlobalNoiseVelocity);

            Header("3D Noise Texture Data");
            bool reloadNoise = false;

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(noise3DData, EditorStrings.ConfigNoise3DData);
            EditorGUILayout.PropertyField(noise3DSize, EditorStrings.ConfigNoise3DSize);
            if (EditorGUI.EndChangeCheck())
            {
                reloadNoise = true;
            }

            if (Noise3D.isSupported && !Noise3D.isProperlyLoaded)
            {
                EditorGUILayout.HelpBox(EditorStrings.HelpNoiseLoadingFailed, MessageType.Error);
            }

            Header("Volumetric Dust Particles");
            EditorGUILayout.PropertyField(dustParticlesPrefab, EditorStrings.ConfigDustParticlesPrefab);

            EditorGUILayout.Separator();
            EditorExtensions.HorizontalLineSeparator();
            EditorGUILayout.Separator();

            if (GUILayout.Button(EditorStrings.ConfigResetToDefaultButton, EditorStyles.miniButton))
            {
                UnityEditor.Undo.RecordObject(target, "Reset Config Properties");
                (target as Config).Reset();
            }

            serializedObject.ApplyModifiedProperties();

            if (reloadNoise)
            {
                Noise3D._EditorForceReloadData(); // Should be called AFTER ApplyModifiedProperties so the Config instance has the proper values when reloading data
            }
        }