示例#1
0
        public void EnablePostProcessing(Camera camera, bool value)
        {
            HDAdditionalCameraData cameraData = camera.GetComponent <HDAdditionalCameraData>();

            if (cameraData == null)
            {
                cameraData = camera.gameObject.AddComponent <HDAdditionalCameraData>();
            }

            cameraData.customRenderingSettings = true;
            FrameSettingsOverrideMask settingsOverride = cameraData.renderingPathCustomFrameSettingsOverrideMask;
            FrameSettings             settings         = cameraData.renderingPathCustomFrameSettings;

            settings.SetEnabled(FrameSettingsField.Postprocess, value);
            settings.SetEnabled(FrameSettingsField.AfterPostprocess, value);
            settings.SetEnabled(FrameSettingsField.TransparentPostpass, value);
            settings.SetEnabled(FrameSettingsField.TransparentPostpass, value);
            settings.SetEnabled(FrameSettingsField.LowResTransparent, value);
            settings.SetEnabled(FrameSettingsField.ShadowMaps, value);
            settings.SetEnabled(FrameSettingsField.ContactShadows, value);
            settings.SetEnabled(FrameSettingsField.ScreenSpaceShadows, value);
            settings.SetEnabled(FrameSettingsField.Transmission, value);
            settings.SetEnabled(FrameSettingsField.ExposureControl, value);
            settings.SetEnabled(FrameSettingsField.ReflectionProbe, value);
            settings.SetEnabled(FrameSettingsField.PlanarProbe, value);
            settings.SetEnabled(FrameSettingsField.ReplaceDiffuseForIndirect, value);
            settings.SetEnabled(FrameSettingsField.SkyReflection, value);
            settings.SetEnabled(FrameSettingsField.DirectSpecularLighting, value);
            settings.SetEnabled(FrameSettingsField.Volumetrics, value);
            settings.SetEnabled(FrameSettingsField.ReprojectionForVolumetrics, value);
            settings.SetEnabled(FrameSettingsField.CustomPostProcess, value);

            settingsOverride.mask[(uint)FrameSettingsField.Postprocess]                = true;
            settingsOverride.mask[(uint)FrameSettingsField.AfterPostprocess]           = true;
            settingsOverride.mask[(uint)FrameSettingsField.TransparentPostpass]        = true;
            settingsOverride.mask[(uint)FrameSettingsField.TransparentPostpass]        = true;
            settingsOverride.mask[(uint)FrameSettingsField.LowResTransparent]          = true;
            settingsOverride.mask[(uint)FrameSettingsField.ShadowMaps]                 = true;
            settingsOverride.mask[(uint)FrameSettingsField.ContactShadows]             = true;
            settingsOverride.mask[(uint)FrameSettingsField.ScreenSpaceShadows]         = true;
            settingsOverride.mask[(uint)FrameSettingsField.SubsurfaceScattering]       = true;
            settingsOverride.mask[(uint)FrameSettingsField.Transmission]               = true;
            settingsOverride.mask[(uint)FrameSettingsField.ExposureControl]            = true;
            settingsOverride.mask[(uint)FrameSettingsField.ReflectionProbe]            = true;
            settingsOverride.mask[(uint)FrameSettingsField.PlanarProbe]                = true;
            settingsOverride.mask[(uint)FrameSettingsField.ReplaceDiffuseForIndirect]  = true;
            settingsOverride.mask[(uint)FrameSettingsField.SkyReflection]              = true;
            settingsOverride.mask[(uint)FrameSettingsField.DirectSpecularLighting]     = true;
            settingsOverride.mask[(uint)FrameSettingsField.Volumetrics]                = true;
            settingsOverride.mask[(uint)FrameSettingsField.ReprojectionForVolumetrics] = true;
            settingsOverride.mask[(uint)FrameSettingsField.CustomPostProcess]          = true;

            cameraData.renderingPathCustomFrameSettingsOverrideMask = settingsOverride;
            cameraData.renderingPathCustomFrameSettings             = settings;

            if (PostProcessingEnabled != null)
            {
                PostProcessingEnabled(camera, value);
            }
        }
示例#2
0
        public void NoDoubleBitIndex()
        {
            var values       = Enum.GetValues(typeof(FrameSettingsField));
            var singleValues = (values as IEnumerable <int>).Distinct();

#pragma warning disable 0612 // Type or member is obsolete
            var excluded = new List <FrameSettingsField> {
                FrameSettingsField.RoughRefraction
            };
#pragma warning restore 0612 // Type or member is obsolete

            //gathering helpful debug info
            var messageDuplicates = new StringBuilder();
            if (values.Length != singleValues.Count())
            {
                var names = Enum.GetNames(typeof(FrameSettingsField));
                for (int i = 0; i < values.Length - 1; ++i)
                {
                    var a = (int)values.GetValue(i);
                    var b = (int)values.GetValue(i + 1);
                    if (a == b && !excluded.Contains((FrameSettingsField)a))
                    {
                        messageDuplicates.AppendFormat("{{ {0}: {1}, {2}", (int)values.GetValue(i), names[i], names[i + 1]);
                        ++i;
                        while (values.GetValue(i) == values.GetValue(i + 1))
                        {
                            if (values.GetValue(i) == values.GetValue(i + 1))
                            {
                                messageDuplicates.AppendFormat(", {0}", names[i + 1]);
                                ++i;
                            }
                        }
                        messageDuplicates.Append(" }, ");
                    }
                }
            }

            FrameSettingsOverrideMask fsm        = default;
            StringBuilder             availables = new StringBuilder();
            for (int i = 0; i < fsm.mask.capacity; ++i)
            {
                if (!singleValues.Contains(i))
                {
                    availables.AppendFormat("{0} ", i);
                }
            }
            Debug.Log($"Available bit in FrameSettings: {availables}");
            // Weirdly if we pass directly the String.Format statement, the assert.Equal function generates an exception so we create it here.
            var errorMessage = String.Format("Double bit index found: {0}\nNumber of bit index against number of distinct bit index:", messageDuplicates.ToString());
            Assert.AreEqual(values.Length - excluded.Count, singleValues.Count(), errorMessage);
        }
示例#3
0
        public void NoDoubleBitIndex()
        {
            var values       = Enum.GetValues(typeof(FrameSettingsField));
            var singleValues = (values as IEnumerable <int>).Distinct();

            //gathering helpful debug info
            var messageDuplicates = new StringBuilder();

            if (values.Length != singleValues.Count())
            {
                var names = Enum.GetNames(typeof(FrameSettingsField));
                for (int i = 0; i < values.Length - 1; ++i)
                {
                    var a = values.GetValue(i);
                    var b = values.GetValue(i + 1);
                    if ((int)values.GetValue(i) == (int)values.GetValue(i + 1))
                    {
                        messageDuplicates.AppendFormat("{{ {0}: {1}, {2}", (int)values.GetValue(i), names[i], names[i + 1]);
                        ++i;
                        while (values.GetValue(i) == values.GetValue(i + 1))
                        {
                            if (values.GetValue(i) == values.GetValue(i + 1))
                            {
                                messageDuplicates.AppendFormat(", {0}", names[i + 1]);
                                ++i;
                            }
                        }
                        messageDuplicates.Append(" }, ");
                    }
                }
            }

            FrameSettingsOverrideMask fsm        = default;
            StringBuilder             availables = new StringBuilder();

            for (int i = 0; i < fsm.mask.capacity; ++i)
            {
                if (!singleValues.Contains(i))
                {
                    availables.AppendFormat("{0} ", i);
                }
            }
            Debug.Log($"Available bit in FrameSettings: {availables}");

            Assert.AreEqual(values.Length, singleValues.Count(), String.Format("Double bit index found: {0}\nNumber of bit index against number of distinct bit index:", messageDuplicates.ToString()));
        }
示例#4
0
        // deactivate this test for template package making issue
        //[Test]
        public void FrameSettingsAggregation()
        {
            for (int i = 0; i < 10; ++i)
            {
                //init
                FrameSettings             fs            = default;
                FrameSettingsOverrideMask fso           = default;
                FrameSettingsRenderType   defaultFSType = RandomUtilities.RandomEnumValue <FrameSettingsRenderType>(i);
                FrameSettings             defaultFS;
                FrameSettings             result            = FrameSettings.NewDefaultCamera();
                FrameSettings             tester            = default;
                RenderPipelineSettings    supportedFeatures = new RenderPipelineSettings();
                switch (defaultFSType)
                {
                case FrameSettingsRenderType.Camera:
                    defaultFS = FrameSettings.NewDefaultCamera();
                    break;

                case FrameSettingsRenderType.CustomOrBakedReflection:
                    defaultFS = FrameSettings.NewDefaultCustomOrBakeReflectionProbe();
                    break;

                case FrameSettingsRenderType.RealtimeReflection:
                    defaultFS = FrameSettings.NewDefaultRealtimeReflectionProbe();
                    break;

                default:
                    throw new ArgumentException("Unknown FrameSettingsRenderType");
                }

                //change randomly override values
                for (int j = 0; j < 10; ++j)
                {
                    FrameSettingsField field = RandomUtilities.RandomEnumValue <FrameSettingsField>((i + 0.5f) * (j + 0.3f));
                    fs.SetEnabled(field, RandomUtilities.RandomBool((i + 1) * j));
                    fso.mask[(uint)field] = true;
                }

                //create and init gameobjects
                var go = new GameObject("TestObject");
                m_ToClean = go;
                var cam = go.AddComponent <Camera>();

                var add = cam.GetComponent <HDAdditionalCameraData>() ?? cam.gameObject.AddComponent <HDAdditionalCameraData>();
                Assert.True(add != null && !add.Equals(null));

                add.renderingPathCustomFrameSettings             = fs;
                add.renderingPathCustomFrameSettingsOverrideMask = fso;
                add.defaultFrameSettings    = defaultFSType;
                add.customRenderingSettings = true;

                //gather data two different ways
                FrameSettings.AggregateFrameSettings(ref result, cam, add, ref defaultFS, supportedFeatures);

                foreach (FrameSettingsField field in Enum.GetValues(typeof(FrameSettingsField)))
                {
                    tester.SetEnabled(field, fso.mask[(uint)field] ? fs.IsEnabled(field) : defaultFS.IsEnabled(field));
                }
                tester.lodBias             = result.lodBias;
                tester.lodBiasMode         = result.lodBiasMode;
                tester.maximumLODLevel     = result.maximumLODLevel;
                tester.maximumLODLevelMode = result.maximumLODLevelMode;
                FrameSettings.Sanitize(ref tester, cam, supportedFeatures);

                //test
                Assert.AreEqual(result, tester);

                Object.DestroyImmediate(go);
            }
        }