public void Initialize(VolumetricLightBeam master, Shader shader) { HideFlags objectsHideFlags = Consts.ProceduralObjectsHideFlags; this.m_Master = master; ((Component)this).get_transform().SetParent(((Component)master).get_transform(), false); this.material = new Material(shader); ((Object)this.material).set_hideFlags(objectsHideFlags); this.meshRenderer = ((Component)this).get_gameObject().GetOrAddComponent <MeshRenderer>(); ((Object)this.meshRenderer).set_hideFlags(objectsHideFlags); ((Renderer)this.meshRenderer).set_material(this.material); ((Renderer)this.meshRenderer).set_shadowCastingMode((ShadowCastingMode)0); ((Renderer)this.meshRenderer).set_receiveShadows(false); ((Renderer)this.meshRenderer).set_lightProbeUsage((LightProbeUsage)0); if (SortingLayer.IsValid(this.m_Master.sortingLayerID)) { this.sortingLayerID = this.m_Master.sortingLayerID; } else { Debug.LogError((object)string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", (object)Utils.GetPath(((Component)this.m_Master).get_transform()), (object)this.m_Master.sortingLayerID)); } this.sortingOrder = this.m_Master.sortingOrder; this.meshFilter = ((Component)this).get_gameObject().GetOrAddComponent <MeshFilter>(); ((Object)this.meshFilter).set_hideFlags(objectsHideFlags); ((Object)((Component)this).get_gameObject()).set_hideFlags(objectsHideFlags); }
public void IntensityChangeCheck() { lightIntensityInput.text = lightIntensity.value.ToString(); lightFixture.spotlight.intensity = Globals.AdjustLight(lightIntensity.value); colorPreview.color = new Color(lightColorR.value / 255.0f, lightColorG.value / 255.0f, lightColorB.value / 255.0f); lightFixture.spotlight.color = colorPreview.color; lightFixture.SetEmissionColor(lightFixture.spotlight.intensity, colorPreview.color); lightFixture.GetComponentInChildren <VLB.BeamGeometry>().gameObject.GetComponent <Renderer>().material.SetColor("_Color", colorPreview.color); foreach (int id in gameManager.captureImport.channels[lightFixture.captureData.channel].lightIds) { LightFixture channelFixture = gameManager.lightManager.lightIds[id].GetComponent <LightFixture>(); channelFixture.spotlight.intensity = Globals.AdjustLight(lightIntensity.value); channelFixture.SetEmissionColor(Globals.AdjustLight(lightIntensity.value), gameManager.lightManager.lightIds[id].GetComponent <LightFixture>().spotlight.color); if (lightFixture.spotlight.intensity > 0.05f) { if (Globals.ShowingHaze) { VLB.VolumetricLightBeam beamComponent = gameManager.lightManager.lightIds[id].GetComponentInChildren <VLB.VolumetricLightBeam>(); beamComponent.enabled = true; Material beamRenderer = channelFixture.GetComponentInChildren <VLB.BeamGeometry>().gameObject.GetComponent <Renderer>().material; beamRenderer.SetFloat("_AlphaInside", Globals.AdjustBeamValue(Globals.LightBeamInside, lightIntensity.value)); beamRenderer.SetFloat("_AlphaOutside", Globals.AdjustBeamValue(Globals.LightBeamOutside, lightIntensity.value)); } } else { gameManager.lightManager.lightIds[id].GetComponentInChildren <VLB.VolumetricLightBeam>().enabled = false; } } }
protected virtual void Awake() { m_Master = GetComponent <VolumetricLightBeam>(); Debug.Assert(m_Master); m_Master._INTERNAL_DynamicOcclusionMode = GetDynamicOcclusionMode(); }
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 }
void OnEnable() { m_Beam = GetComponent <VolumetricLightBeam>(); Debug.Assert(m_Beam != null); m_DynamicOcclusionRaycasting = GetComponent <DynamicOcclusionRaycasting>(); switch (updateRate) { case TriggerZoneUpdateRate.OnEnable: { ComputeZone(); enabled = false; break; } case TriggerZoneUpdateRate.OnOcclusionChange: { if (m_DynamicOcclusionRaycasting) { m_DynamicOcclusionRaycasting.onOcclusionProcessed += OnOcclusionProcessed; } break; } } }
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 }
public void Initialize(VolumetricLightBeam master) { var hideFlags = Consts.ProceduralObjectsHideFlags; m_Master = master; this.Lod = m_Master.lod; bool noise = (m_Master.noiseEnabled && m_Master.noiseIntensity > 0f && Noise3D.isSupported); bool depth = (m_Master.depthBlendDistance > 0f); transform.SetParent(master.transform, false); meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>(); ChangeMat(noise, depth, false); meshRenderer.hideFlags = hideFlags; meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.receiveShadows = false; meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off; meshFilter = gameObject.GetOrAddComponent <MeshFilter>(); meshRenderer.material = material; material.hideFlags = hideFlags; gameObject.hideFlags = hideFlags; gameObject.layer = Config.Instance.geometryLayerID; coneMesh = MeshGenerator.GetSharedConeZ_Mesh(m_Master.geomSides); meshFilter.mesh = coneMesh; UpdateMaterialAndBounds(); }
public void Initialize(VolumetricLightBeam master, Shader shader) { HideFlags proceduralObjectsHideFlags = Consts.ProceduralObjectsHideFlags; this.m_Master = master; base.transform.SetParent(master.transform, false); this.material = new Material(shader) { hideFlags = proceduralObjectsHideFlags }; this.meshRenderer = base.gameObject.GetOrAddComponent <MeshRenderer>(); this.meshRenderer.hideFlags = proceduralObjectsHideFlags; this.meshRenderer.material = this.material; this.meshRenderer.shadowCastingMode = ShadowCastingMode.Off; this.meshRenderer.receiveShadows = false; this.meshRenderer.lightProbeUsage = LightProbeUsage.Off; if (!SortingLayer.IsValid(this.m_Master.sortingLayerID)) { Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(this.m_Master.transform), this.m_Master.sortingLayerID)); } else { this.sortingLayerID = this.m_Master.sortingLayerID; } this.sortingOrder = this.m_Master.sortingOrder; this.meshFilter = base.gameObject.GetOrAddComponent <MeshFilter>(); this.meshFilter.hideFlags = proceduralObjectsHideFlags; base.gameObject.hideFlags = proceduralObjectsHideFlags; }
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(); } } }
public void Initialize(VolumetricLightBeam master, Shader shader) { var hideFlags = Consts.ProceduralObjectsHideFlags; m_Master = master; transform.SetParent(master.transform, false); material = new Material(shader); material.hideFlags = hideFlags; meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>(); meshRenderer.hideFlags = hideFlags; meshRenderer.material = material; meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.receiveShadows = false; #if UNITY_5_4_OR_NEWER meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off; #else meshRenderer.useLightProbes = false; #endif sortingLayerID = m_Master.sortingLayerID; sortingOrder = m_Master.sortingOrder; meshFilter = gameObject.GetOrAddComponent <MeshFilter>(); meshFilter.hideFlags = hideFlags; gameObject.hideFlags = hideFlags; }
void Start() { isCulled = false; m_Master = GetComponent<VolumetricLightBeam>(); Debug.Assert(m_Master); InstantiateParticleSystem(); SetActiveAndPlay(); }
private void Start() { this.isCulled = false; this.m_Master = (VolumetricLightBeam)((Component)this).GetComponent <VolumetricLightBeam>(); Debug.Assert(Object.op_Implicit((Object)this.m_Master)); this.InstantiateParticleSystem(); this.SetActiveAndPlay(); }
private void Start() { this.isCulled = false; this.m_Master = base.GetComponent <VolumetricLightBeam>(); Debug.Assert(this.m_Master); this.InstantiateParticleSystem(); this.SetActiveAndPlay(); }
public override void OnInspectorGUI() { base.OnInspectorGUI(); EditorGUILayout.LabelField(string.Format("Current Plugin Version: {0}", Version.Current), EditorStyles.miniBoldLabel); Header("Beam Geometry"); EditorGUI.BeginChangeCheck(); geometryLayerID.intValue = EditorGUILayout.LayerField(new GUIContent("Layer", "The layer the GameObjects holding the procedural cone meshes are created on"), geometryLayerID.intValue); geometryTag.stringValue = EditorGUILayout.TagField(new GUIContent("Tag", "The tag applied on the procedural geometry GameObjects"), geometryTag.stringValue); if (EditorGUI.EndChangeCheck()) { VolumetricLightBeam._EditorSetAllMeshesDirty(); } EditorGUILayout.PropertyField(beamShader, new GUIContent("Shader", "Main shader applied to the cone beam geometry")); Header("Global 3D Noise"); EditorGUILayout.PropertyField(globalNoiseScale, new GUIContent("Scale", "Global 3D Noise texture scaling: higher scale make the noise more visible, but potentially less realistic")); EditorGUILayout.PropertyField(globalNoiseVelocity, new GUIContent("Velocity", "Global World Space direction and speed of the noise scrolling, simulating the fog/smoke movement")); Header("3D Noise Texture Data"); bool reloadNoise = false; EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(noise3DData, new GUIContent("Binary file", "Binary file holding the 3D Noise texture data (a 3D array). Must be exactly Size * Size * Size bytes long.")); int newSizeValue = EditorGUILayout.IntField(new GUIContent("Data dimension", "Size (of one dimension) of the 3D Noise data. Must be power of 2. So if the binary file holds a 32x32x32 texture, this value must be 32.") , noise3DSize.intValue); noise3DSize.intValue = Mathf.Max(2, Mathf.NextPowerOfTwo(newSizeValue)); if (EditorGUI.EndChangeCheck()) { reloadNoise = true; } if (Noise3D.isSupported && !Noise3D.isProperlyLoaded) { EditorGUILayout.HelpBox("Fail to load 3D noise texture", MessageType.Error); } Header("Volumetric Dust Particles"); EditorGUILayout.PropertyField(dustParticlesPrefab, new GUIContent("Prefab", "ParticleSystem prefab instantiated for the Volumetric Dust Particles feature (Unity 5.5 or above)")); EditorGUILayout.Space(); if (GUILayout.Button(new GUIContent("Default values", "Reset properties to their default values."), 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 } }
void OnEnable() { m_Master = GetComponent <VolumetricLightBeam>(); Debug.Assert(m_Master); #if UNITY_EDITOR EditorLoadPrefs(); editorDebugData.currentOccluder = null; editorDebugData.lastFrameUpdate = 0; #endif }
private IEnumerator CoPlaytimeUpdate() { VolumetricLightBeam volumetricLightBeam = this; while (volumetricLightBeam.trackChangesDuringPlaytime && ((Behaviour)volumetricLightBeam).get_enabled()) { volumetricLightBeam.UpdateAfterManualPropertyChange(); yield return((object)null); } volumetricLightBeam.m_CoPlaytimeUpdate = (Coroutine)null; }
private IEnumerator CoPlaytimeUpdate() { VolumetricLightBeam volumetricLightBeam = null; while (volumetricLightBeam.trackChangesDuringPlaytime && volumetricLightBeam.enabled) { volumetricLightBeam.UpdateAfterManualPropertyChange(); yield return(null); } volumetricLightBeam.m_CoPlaytimeUpdate = null; }
// handle zoom logic private void updateZoom(float zoomAngle) { // set color of the material to a gradient between the colors as listed above Light[] lights = GetComponentsInChildren <Light>(); foreach (var light in lights) { VLB.VolumetricLightBeam beam = light.GetComponentInChildren <VLB.VolumetricLightBeam>(); light.spotAngle = zoomAngle; beam.UpdateAfterManualPropertyChange(); } }
void Start() { isCulled = false; m_Master = GetComponent <VolumetricLightBeam>(); Debug.Assert(m_Master); HandleBackwardCompatibility(m_Master._INTERNAL_pluginVersion, Version.Current); InstantiateParticleSystem(); SetActiveAndPlay(); }
public void Reset() { geometryLayerID = 1; beamShader = Shader.Find("VolumetricLightBeam/Beam"); globalNoiseScale = Consts.NoiseScaleDefault; globalNoiseVelocity = Consts.NoiseVelocityDefault; noise3DData = Resources.Load("Noise3D_64x64x64") as TextAsset; noise3DSize = 64; dustParticlesPrefab = Resources.Load("DustParticles", typeof(ParticleSystem)) as ParticleSystem; #if UNITY_EDITOR VolumetricLightBeam._EditorSetAllMeshesDirty(); #endif }
public static bool CanBeBatched(VolumetricLightBeam beamA, VolumetricLightBeam beamB, ref string reasons) { bool ret = true; if (!CanBeBatched(beamA, ref reasons)) { ret = false; } if (!CanBeBatched(beamB, ref reasons)) { ret = false; } if ((beamA.GetComponent <DynamicOcclusionAbstractBase>() == null) != (beamB.GetComponent <DynamicOcclusionAbstractBase>() == null)) { AppendErrorMessage(ref reasons, string.Format("{0}/{1}: dynamically occluded and non occluded beams cannot be batched together", beamA.name, beamB.name)); ret = false; } if (beamA.colorMode != beamB.colorMode) { AppendErrorMessage(ref reasons, "Color Mode mismatch"); ret = false; } if (beamA.blendingMode != beamB.blendingMode) { AppendErrorMessage(ref reasons, "Blending Mode mismatch"); ret = false; } if (beamA.isNoiseEnabled != beamB.isNoiseEnabled) { AppendErrorMessage(ref reasons, "3D Noise enabled mismatch"); ret = false; } if (!forceEnableDepthBlend) { #pragma warning disable 0162 if ((beamA.depthBlendDistance > 0) != (beamB.depthBlendDistance > 0)) { AppendErrorMessage(ref reasons, "Opaque Geometry Blending mismatch"); ret = false; } #pragma warning restore 0162 } return(ret); }
public void Initialize(VolumetricLightBeam master) { Debug.Assert(master != null); var customHideFlags = Consts.ProceduralObjectsHideFlags; m_Master = master; transform.SetParent(master.transform, false); meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>(); meshRenderer.hideFlags = customHideFlags; meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.receiveShadows = false; meshRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off; // different reflection probes could break batching with GPU Instancing #if UNITY_5_4_OR_NEWER meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off; #else meshRenderer.useLightProbes = false; #endif if (!shouldUseGPUInstancedMaterial) { m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false); ApplyMaterial(); } if (SortingLayer.IsValid(m_Master.sortingLayerID)) { sortingLayerID = m_Master.sortingLayerID; } else { Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID)); } sortingOrder = m_Master.sortingOrder; meshFilter = gameObject.GetOrAddComponent <MeshFilter>(); meshFilter.hideFlags = customHideFlags; gameObject.hideFlags = customHideFlags; #if UNITY_EDITOR UnityEditor.GameObjectUtility.SetStaticEditorFlags(gameObject, master.GetStaticEditorFlagsForSubObjects()); gameObject.SetSameSceneVisibilityStatesThan(master.gameObject); #endif RestartFadeOutCoroutine(); }
public void Initialize(VolumetricLightBeam master) { var hideFlags = Consts.ProceduralObjectsHideFlags; m_Master = master; transform.SetParent(master.transform, false); meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>(); meshRenderer.hideFlags = hideFlags; meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.receiveShadows = false; #if UNITY_5_4_OR_NEWER meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off; #else meshRenderer.useLightProbes = false; #endif if (Config.Instance.actualRenderingMode != RenderingMode.GPUInstancing) { m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false); ApplyMaterial(); } if (SortingLayer.IsValid(m_Master.sortingLayerID)) { sortingLayerID = m_Master.sortingLayerID; } else { Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID)); } sortingOrder = m_Master.sortingOrder; meshFilter = gameObject.GetOrAddComponent <MeshFilter>(); meshFilter.hideFlags = hideFlags; gameObject.hideFlags = hideFlags; #if UNITY_EDITOR // Apply the same static flags to the BeamGeometry than the VLB GAO var flags = UnityEditor.GameObjectUtility.GetStaticEditorFlags(master.gameObject); flags &= ~(UnityEditor.StaticEditorFlags.ContributeGI); // remove the Lightmap static flag since it will generate error messages when selecting the BeamGeometry GAO in the editor UnityEditor.GameObjectUtility.SetStaticEditorFlags(gameObject, flags); #endif RestartFadeOutCoroutine(); }
public static void AddComponentFromEditor <TComp>(VolumetricLightBeam self) where TComp : Component { if (self) { if (self.GetComponent <TComp>() == null) { var comp = Undo.AddComponent <TComp>(self.gameObject); if (comp is DynamicOcclusionRaycasting) { (comp as DynamicOcclusionRaycasting).dimensions = self.dimensions; } } } }
// handle color changes // @REACH: true color wheel implementation private void UpdateColor(int c) { // set color of the material to a gradient between the colors as listed above Light[] lights = GetComponentsInChildren <Light>(); foreach (var light in lights) { VLB.VolumetricLightBeam beam = light.GetComponentInChildren <VLB.VolumetricLightBeam>(); // single color if (c < 128) { // set the color of the beam Color set = sharpyColor[c]; light.color = new Color(set.r, set.g, set.b, lightAlpha); beam.UpdateAfterManualPropertyChange(); // COMMENTED OUT: code for blending, but that's not what we really want //int colorIndex = c / 9; // which color a we're mixing; //int step = c % 9; // step between color a and b //float mix = step / 9f; // the mix between color a and b //// get the colors //Color a = sharpyColor[colorIndex]; //Color b; //// wrap around for color b //if (colorIndex < 14) // b = sharpyColor[colorIndex + 1]; //else // b = sharpyColor[0]; //// set the material's color //Color mixed = Color.Lerp(a, b, mix); //rend.material.color = new Color (mixed.r, mixed.g, mixed.b, 0.5f); //// may use this mixing instead if not satisfied with Lerp color mixing above //// Color mixed = LerpHSV(a, b, mix); //// rend.material.color = new Color (mixed.r, mixed.g, mixed.b, 0.5f); } // rotating color wheel else { // rotate colors } } }
public static bool CanBeBatched(VolumetricLightBeam beam, ref string reasons) { bool ret = true; if (beam.geomMeshType != MeshType.Shared) { AppendErrorMessage(ref reasons, string.Format("{0} is not using shared mesh", beam.name)); ret = false; } if (beam.GetComponent <DynamicOcclusionDepthBuffer>()) { AppendErrorMessage(ref reasons, string.Format("{0} is using the DynamicOcclusion DepthBuffer feature", beam.name)); ret = false; } return(ret); }
public static bool CanBeBatched(VolumetricLightBeam beam, ref string reason) { bool ret = true; if (beam.geomMeshType != MeshType.Shared) { AppendErrorMessage(ref reason, string.Format("{0} is not using shared mesh", beam.name)); ret = false; } if (beam.GetComponent <DynamicOcclusion>()) { AppendErrorMessage(ref reason, string.Format("{0}: dynamically occluded and non occluded beams cannot be batched together", beam.name)); ret = false; } return(ret); }
public static bool CanBeBatched(VolumetricLightBeam beamA, VolumetricLightBeam beamB, ref string reasons) { bool ret = true; if (!CanBeBatched(beamA, ref reasons)) { ret = false; } if (!CanBeBatched(beamB, ref reasons)) { ret = false; } if (beamA.colorMode != beamB.colorMode) { AppendErrorMessage(ref reasons, "Color Mode mismatch"); ret = false; } if (beamA.blendingMode != beamB.blendingMode) { AppendErrorMessage(ref reasons, "Blending Mode mismatch"); ret = false; } if (beamA.noiseEnabled != beamB.noiseEnabled) { AppendErrorMessage(ref reasons, "3D Noise enabled mismatch"); ret = false; } if (!forceEnableDepthBlend) { #pragma warning disable 0162 if ((beamA.depthBlendDistance > 0) != (beamB.depthBlendDistance > 0)) { AppendErrorMessage(ref reasons, "Opaque Geometry Blending mismatch"); ret = false; } #pragma warning restore 0162 } return(ret); }
public void Initialize(VolumetricLightBeam master) { var hideFlags = Consts.ProceduralObjectsHideFlags; m_Master = master; transform.SetParent(master.transform, false); meshRenderer = gameObject.GetOrAddComponent <MeshRenderer>(); meshRenderer.hideFlags = hideFlags; meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; meshRenderer.receiveShadows = false; #if UNITY_5_4_OR_NEWER meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off; #else meshRenderer.useLightProbes = false; #endif if (Config.Instance.actualRenderingMode != RenderingMode.GPUInstancing) { m_CustomMaterial = MaterialManager.NewMaterial(gpuInstanced: false); ApplyMaterial(); } if (SortingLayer.IsValid(m_Master.sortingLayerID)) { sortingLayerID = m_Master.sortingLayerID; } else { Debug.LogError(string.Format("Beam '{0}' has an invalid sortingLayerID ({1}). Please fix it by setting a valid layer.", Utils.GetPath(m_Master.transform), m_Master.sortingLayerID)); } sortingOrder = m_Master.sortingOrder; meshFilter = gameObject.GetOrAddComponent <MeshFilter>(); meshFilter.hideFlags = hideFlags; gameObject.hideFlags = hideFlags; RestartFadeOutCoroutine(); }
public static bool CanBeBatched(VolumetricLightBeam beam, ref string reasons) { bool ret = true; if (Config.Instance.actualRenderingMode == RenderingMode.GPUInstancing) { if (beam.geomMeshType != MeshType.Shared) { AppendErrorMessage(ref reasons, string.Format("{0} is not using shared mesh", beam.name)); ret = false; } } if (Config.Instance.featureEnabledDynamicOcclusion && beam.GetComponent <DynamicOcclusionDepthBuffer>() != null) { AppendErrorMessage(ref reasons, string.Format("{0} is using the DynamicOcclusion DepthBuffer feature", beam.name)); ret = false; } return(ret); }