protected virtual void Start()
    {
        bloom = volume.profile.GetSetting <Bloom>();
        chromaticAberration = volume.profile.GetSetting <ChromaticAberration>();
        colorGrading        = volume.profile.GetSetting <ColorGrading>();
        vignette            = volume.profile.GetSetting <Vignette>();

        //Set Min values
        if (bloom)
        {
            minBloomIntensity = bloom.intensity.value;
        }
        if (vignette)
        {
            minVignetteIntensity = vignette.intensity.value;
        }
        if (chromaticAberration)
        {
            minChromaticIntensity = chromaticAberration.intensity.value;
        }
        if (colorGrading)
        {
            minPostExposure  = colorGrading.postExposure.value;
            minSaturation    = colorGrading.saturation.value;
            minContrast      = colorGrading.contrast.value;
            startColorFilter = colorGrading.colorFilter.value;
        }
    }
    void Start()
    {
        m_Vignette = ScriptableObject.CreateInstance <Vignette>();
        m_Vignette.enabled.Override(true);
        m_Vignette.intensity.Override(0f);

        m_colour = ScriptableObject.CreateInstance <ColorGrading>();
        m_colour.enabled.Override(true);

        m_colour.mixerBlueOutBlueIn.Override(150f);
        m_colour.mixerRedOutBlueIn.Override(0f);
        m_colour.mixerGreenOutBlueIn.Override(0f);

        m_colour.mixerBlueOutRedIn.Override(0f);
        m_colour.mixerRedOutRedIn.Override(150f);
        m_colour.mixerGreenOutRedIn.Override(0f);

        m_colour.mixerBlueOutGreenIn.Override(0f);
        m_colour.mixerRedOutGreenIn.Override(0f);
        m_colour.mixerGreenOutGreenIn.Override(150f);

        m_colour.saturation.Override(100f);

        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, m_Vignette);
        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, m_colour);


        //
        recordBtn.SetActive(false);
        gifPreview.SetActive(false);
        uploadBtn.SetActive(false);
    }
예제 #3
0
 private void Awake()
 {
     ppVol             = GetComponent <PostProcessVolume>();
     colorGradingDrunk = ppVol.profile.settings[2] as ColorGrading;
     hueShift          = new FloatParameter();
     audioSrc          = GetComponent <AudioSource>();
 }
예제 #4
0
    //[Header("Player Damage Effect Properties")]
    //public float _playerDamageVignetteAmount;
    //public float _playerDamageContrastAmount;


    // Use this for initialization
    void Start()
    {
        //_postVignette = _postVolume.
        //_exposureFadeSpeed = .025f;

        _postVignette = ScriptableObject.CreateInstance <Vignette>();
        _postVignette.enabled.Override(true);
        //_postVignette.intensity.Override(_vignetteStartValue);
        _postVignette.opacity.Override(_vignetteOpactityStartValue);

        //_postSettings

        _postColorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        _postColorGrading.enabled.Override(true);
        _postColorGrading.contrast.Override(_contrastStartValue);
        _postColorGrading.postExposure.Override(_exposureStartValue);
        //_postColorGrading.mixerGreenOutRedIn.Override(_redStartValue);

        //_postDOF = ScriptableObject.CreateInstance<DepthOfField>();
        //_postDOF.enabled.Override(true);
        //_postDOF.focalLength.Override(_focalLengthStartValue);
        //_postDOF.focusDistance.Override(_focusDisatnceStartValue);

        _postVolume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, _postVignette, _postColorGrading);//, _postDOF);
    }
    void OnEnable()
    {
        Debug.Log("Psychedelic phase START");
        depthOfField = ScriptableObject.CreateInstance <DepthOfField>();
        colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        bloom        = ScriptableObject.CreateInstance <Bloom>();

        depthOfField.enabled.Override(true);
        colorGrading.enabled.Override(true);
        bloom.enabled.Override(true);

        colorGrading.tint.Override(ColorGradingTint);
        colorGrading.hueShift.Override(ColorGradingHueShift);
        colorGrading.saturation.Override(ColorGradingSaturation);
        colorGrading.postExposure.Override(ColorGradingPostExposure);

        bloom.intensity.Override(BloomIntensity);
        bloom.softKnee.Override(BloomSoftKnee);
        bloom.dirtTexture.Override(BloomTexture);

        bloom.dirtIntensity.Override(BloomDirtIntensity);
        bloom.clamp.Override(BloomClamp);
        bloom.diffusion.Override(BloomDiffusion);
        bloom.anamorphicRatio.Override(BloomAnamorphicRatio);

        depthOfField.focusDistance.Override(DoFFocusDistance);
        depthOfField.kernelSize.Override(DoFKernelSize);
        depthOfField.aperture.Override(DoFAperture);
        depthOfField.focalLength.Override(DoFFocalLength);

        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, depthOfField, bloom, colorGrading);
    }
예제 #6
0
        private void DrawColorGradingConvertButton()
        {
            GUILayout.Space(5);
            if (GUILayout.Button("Convert") == false)
            {
                return;
            }

            if (inputLUT == null)
            {
                messageType    = MessageType.Error;
                helpBoxMessage = "Please supply an input lookup texture";
                return;
            }

            TextureImporter importer  = (TextureImporter)TextureImporter.GetAtPath(inputPath);
            Texture2D       converted = ColorGrading.Convert(inputLUT, compatibilityMode, importer.linearTexture);

            //Remove file extension and add "_Scion.png"
            string newPath = inputPath.Substring(0, inputPath.LastIndexOf(".")) + "_Scion.png";

            SaveLookupTexture(newPath, converted);

            helpBoxMessage = "Saved converted lookup texture: " + newPath;
            messageType    = MessageType.Info;
            Debug.Log(helpBoxMessage);
        }
예제 #7
0
 private void Start()
 {
     //assign the specific post process variables to the post process profile settings
     postProcessColor    = gamePostProcess.GetSetting <ColorGrading>();
     postProcessGrain    = gamePostProcess.GetSetting <Grain>();
     postProcessVignette = gamePostProcess.GetSetting <Vignette>();
 }
        private IEnumerator TrippingCoroutine()
        {
            ColorGrading colorGrading = PostProcessing.CurrentFilter.GetSetting <ColorGrading>();

            colorGrading.enabled.Override(true);

            while (true)
            {
                for (int i = 0; i < 101; i++)
                {
                    if (PostProcessing.CurrentFilter != null)
                    {
                        FloatParameter newValue = new FloatParameter();
                        newValue.value = i;
                        colorGrading.temperature.Override(newValue);
                    }
                    yield return(null);
                }
                for (int i = -100; i < 1; i++)
                {
                    if (PostProcessing.CurrentFilter != null)
                    {
                        FloatParameter newValue = new FloatParameter();
                        newValue.value = i;
                        colorGrading.temperature.Override(newValue);
                    }
                    yield return(null);
                }
            }
        }
예제 #9
0
    void Awake()
    {
        healthManager = Player.GetComponent <HealthManager>();
        scriptManager = Player.gameObject.GetComponentInChildren <ScriptManager>();

        if (scriptManager.ArmsCamera.GetComponent <PostProcessVolume>())
        {
            postProcessing = scriptManager.ArmsCamera.GetComponent <PostProcessVolume>();

            if (postProcessing.profile.HasSettings <ColorGrading>())
            {
                colorGrading = postProcessing.profile.GetSetting <ColorGrading>();
            }
            else if (useGreyscale)
            {
                Debug.LogError($"[PostProcessing] Please add ColorGrading Effect to a {postProcessing.profile.name} profile in order to use Greyscale.");
            }
        }
        else
        {
            Debug.LogError($"[PostProcessing] There is no PostProcessVolume script added to a {ScriptManager.Instance.ArmsCamera.gameObject.name}!");
        }

        lightSlider     = LightPercentagle.GetComponentInChildren <Slider>();
        lightBackground = lightSlider.transform.GetChild(0).GetComponent <Image>();
        defaultIcon     = LightPercentagle.transform.GetChild(0).GetComponent <Image>().sprite;

        configHandler   = GetComponent <ConfigHandler>();
        saveHandler     = GetComponent <SaveGameHandler>();
        inputManager    = GetComponent <InputController>();
        inventoryScript = GetComponent <Inventory>();

        uiInteractive = true;
    }
예제 #10
0
    public int GrayscaleRange = 0;   //Targeted reset for Grayscaling (-100 Gray, 0 Normal, 100 Super Saturated)

    void Start()
    {
        #region Vignette Init
        Vig = ScriptableObject.CreateInstance <Vignette>();
        Vig.enabled.Override(true);
        Vig.intensity.Override(.45f);
        #endregion

        #region ColorGrading Init
        ColorG = ScriptableObject.CreateInstance <ColorGrading>();
        ColorG.enabled.Override(true);
        if (GrayScale)
        {
            ColorG.saturation.Override(-100f);
        }
        ColorG.postExposure.overrideState = true;
        #endregion

        #region DepthOfField Init
        DOF = ScriptableObject.CreateInstance <DepthOfField>();
        DOF.enabled.Override(true);
        DOF.focusDistance.Override(5f);
        #endregion

        #region MotionBlur Init
        Blur = ScriptableObject.CreateInstance <MotionBlur>();
        Blur.enabled.Override(true);
        #endregion

        #region Volume Init
        Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, Vig, ColorG, DOF, Blur);
        #endregion
    }
예제 #11
0
    // Token: 0x06000C11 RID: 3089 RVA: 0x0004BCD8 File Offset: 0x00049ED8
    private void ApplyBrightnessSetting()
    {
        ColorGrading colorGrading = null;

        this.postProcessingVolume.profile.TryGetSettings <ColorGrading>(out colorGrading);
        colorGrading.postExposure.value = PlayerPrefs.GetFloat("brightnessValue");
    }
예제 #12
0
    private void Start()
    {
        //Finds PostProcessing layer to apply effect.
        //Must have PostProcessing layer added in order for effect to work properly.
        layerIndex = LayerMask.NameToLayer("PostProcessing");
        camera.GetComponent <PostProcessLayer>().volumeLayer = LayerMask.GetMask("PostProcessing");

        //Creates vignette effect and sets default settings.
        vignette = ScriptableObject.CreateInstance <Vignette>();
        vignette.enabled.Override(false);
        vignette.intensity.Override(0f);

        //Creates color grading effect and sets default settings.
        colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        colorGrading.enabled.Override(false);

        //Gets settings to use from effect profile provided.
        vColor      = postProfile.GetSetting <Vignette>().color;
        vCenter     = postProfile.GetSetting <Vignette>().center;
        vSmoothness = postProfile.GetSetting <Vignette>().smoothness;
        vRoundness  = postProfile.GetSetting <Vignette>().roundness;
        vRounded    = postProfile.GetSetting <Vignette>().rounded;

        //Sets settings to approprate values.
        vignette.color.Override(vColor);
        vignette.center.Override(vCenter);
        vignette.smoothness.Override(vSmoothness);
        vignette.roundness.Override(vRoundness);
        vignette.rounded.Override(vRounded);

        //Creates volume for effect to be applied.
        volume          = PostProcessManager.instance.QuickVolume(layerIndex, 0, vignette, colorGrading);
        volume.isGlobal = true;
    }
예제 #13
0
        public void AfterTest()
        {
            _fader = null;

            _otherVolumeColorGrading = null;
            _volumeColorGrading = null;
        }
    void Start()
    {
        #region BlurVision
        BlurOfVision = ScriptableObject.CreateInstance <DepthOfField>();
        BlurOfVision.enabled.Override(true);
        BlurOfVision.focusDistance.overrideState = true;
        #endregion

        #region LensD
        LensD = ScriptableObject.CreateInstance <LensDistortion>();
        LensD.enabled.Override(true);
        LensD.intensity.overrideState = true;
        #endregion

        #region ColorG
        ColorG = ScriptableObject.CreateInstance <ColorGrading>();
        ColorG.enabled.Override(true);
        ColorG.saturation.overrideState = true;
        #endregion

        #region TVig
        TVig = ScriptableObject.CreateInstance <Vignette>();
        TVig.enabled.Override(true);
        TVig.intensity.overrideState = true;
        #endregion

        Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, BlurOfVision, LensD, ColorG, TVig);
    }
예제 #15
0
    void Start()
    {
        m_colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        m_colorGrading.enabled.Override(true);
        m_colorGrading.brightness.Override(0f);

        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 1, m_colorGrading);
    }
예제 #16
0
    private void Start()
    {
        cg = ScriptableObject.CreateInstance <ColorGrading>();
        cg.enabled.Override(true);
        //cg.saturation.Override(-100f);

        volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, cg);
    }
예제 #17
0
    void Awake()
    {
        m_color_grading = ScriptableObject.CreateInstance <ColorGrading>();
        m_vignette      = ScriptableObject.CreateInstance <Vignette>();

        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, m_color_grading);
        m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, m_vignette);
    }
예제 #18
0
 void Start()
 {
     colorGrading = GameManager.Instance.GetComponent <PostProcessVolume>().profile.GetSetting <ColorGrading>();
     colorGrading.brightness.value = -100;
     //GameManager.Player.GetComponent<PlayerController>().hasControl = false;
     GameManager.GameTimer.StartTimer();
     StartCoroutine(Intro());
 }
예제 #19
0
 private void ReloadCamera()
 {
     _camera                    = Camera.main;
     _volume                    = _camera.GetComponent <PostProcessVolume>();
     _shaderColorGrading        = _volume.profile.GetSetting <ColorGrading>();
     _shaderDepthOfField        = _volume.profile.GetSetting <DepthOfField>();
     _shaderChromaticAberration = _volume.profile.GetSetting <ChromaticAberration>();
 }
        void Start()
        {
            Oclussion = Volume.profile.GetSetting <AmbientOcclusion>();
            Grading   = Volume.profile.GetSetting <ColorGrading>();

            PlayerManager.NormalOclussion += (sender, args) => NormalOclussion();
            PlayerManager.OrangeOclussion += (sender, args) => OrangeOclussion();
        }
예제 #21
0
            public ColorGradeEntry(ColorGrading inColorGrading, float inDefaultPostExposure)
            {
                CurrentStartPostExposure = inColorGrading.postExposure.value;
                CurrentFinalPostExposure = 0.0f;

                ColorGrade          = inColorGrading;
                DefaultPostExposure = inDefaultPostExposure;
            }
예제 #22
0
 private void Awake()
 {
     matchTimer    = GameObject.FindGameObjectWithTag("MatchTimer").GetComponent <MatchTimer>();
     emissionBar   = GameObject.FindGameObjectWithTag("EmissionsBar").GetComponent <ProgressBar>();
     populationBar = GameObject.FindGameObjectWithTag("PopulationBar").GetComponent <ProgressBar>();
     ppv           = GameObject.FindGameObjectWithTag("PostProcessGlobal").GetComponent <PostProcessVolume>();
     colorGrade    = ppv.profile.GetSetting <ColorGrading>();
     saveGame      = GetComponent <SaveGame>();
 }
예제 #23
0
    void Awake()
    {
        gameController = GameController.Instance;
        colorGrading   = (ColorGrading)postProcess.profile.settings.Find(x => x.GetType() == typeof(ColorGrading));
        vignette       = (Vignette)postProcess.profile.settings.Find(x => x.GetType() == typeof(Vignette));
        grain          = (Grain)postProcess.profile.settings.Find(x => x.GetType() == typeof(Grain));

        gameController.player.Stats.StatChanged += OnPlayerStatChanged;
    }
 void Start()
 {
     p_colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
     p_colorGrading.enabled.Override(true);
     p_colorGrading.hueShift.Override(hueShiftValue);
     p_colorGrading.saturation.Override(saturationValue);
     p_Volume             = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, p_colorGrading);
     questPerson          = GameObject.Find("QuestPerson");
     happynesCompareValue = PlayerInfo.PlayerMood;
 }
예제 #25
0
    // Start is called before the first frame update
    void Start()
    {
        player_cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();

        default_fov = player_cam.fieldOfView;

        ca = profile.GetSetting <ChromaticAberration>();
        ld = profile.GetSetting <LensDistortion>();
        cg = profile.GetSetting <ColorGrading>();
    }
예제 #26
0
    void PP()
    {
        ColorGrading colorGradingLayer = null;

        // somewhere during initializing
        PostProcessVolume volume = gameObject.GetComponent <PostProcessVolume>();

        volume.profile.TryGetSettings(out colorGradingLayer);
        colorGradingLayer.colorFilter.value = Color.Lerp(Color.black, Color.white, Mathf.Clamp(Time.time * 0.2f, 0.0f, 1.0f));
    }
예제 #27
0
    void Start()
    {
        volume = GetComponent <PostProcessVolume>();

        colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        colorGrading.enabled.Override(true);
        colorGrading.saturation.Override(0f);
        volume     = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, colorGrading);
        saturation = 0f;
    }
    // Start is called before the first frame update
    void Start()
    {
        _LD  = PPV.profile.GetSetting <LensDistortion>();
        _VIG = PPV.profile.GetSetting <Vignette>();
        _CG  = PPV.profile.GetSetting <ColorGrading>();

        SetDistortionLevel(0);

        Instance = this;
    }
        internal void InitializeProfiles()
        {
            if (!SettingValues.profile.TryGetSettings(out chromaticAberrationLayer))
            {
                chromaticAberrationLayer = SettingValues.profile.AddSettings <ChromaticAberration>();
            }

            if (!SettingValues.profile.TryGetSettings(out grainLayer))
            {
                grainLayer = SettingValues.profile.AddSettings <Grain>();
            }

            if (!SettingValues.profile.TryGetSettings(out ambientOcclusionLayer))
            {
                ambientOcclusionLayer = SettingValues.profile.AddSettings <AmbientOcclusion>();
            }

            if (!SettingValues.profile.TryGetSettings(out autoExposureLayer))
            {
                autoExposureLayer = SettingValues.profile.AddSettings <AutoExposure>();
            }

            if (!SettingValues.profile.TryGetSettings(out bloomLayer))
            {
                bloomLayer = SettingValues.profile.AddSettings <Bloom>();
            }

            if (!SettingValues.profile.TryGetSettings(out colorGradingLayer))
            {
                colorGradingLayer = SettingValues.profile.AddSettings <ColorGrading>();
            }

            if (!SettingValues.profile.TryGetSettings(out depthOfFieldLayer))
            {
                depthOfFieldLayer = SettingValues.profile.AddSettings <DepthOfField>();
            }

            if (!SettingValues.profile.TryGetSettings(out screenSpaceReflectionsLayer))
            {
                screenSpaceReflectionsLayer = SettingValues.profile.AddSettings <ScreenSpaceReflections>();
            }

            if (!SettingValues.profile.TryGetSettings(out vignetteLayer))
            {
                vignetteLayer = SettingValues.profile.AddSettings <Vignette>();
            }

            if (!SettingValues.profile.TryGetSettings(out motionBlurLayer))
            {
                motionBlurLayer = SettingValues.profile.AddSettings <MotionBlur>();
                motionBlurLayer.enabled.value = false;
            }

            depthOfFieldLayer.enabled.value = false; // Make people use Depth of Field Manually
        }
예제 #30
0
    IEnumerator Desaturate()
    {
        ColorGrading colorGradingLayer = null;

        volume.profile.TryGetSettings(out colorGradingLayer);
        while (true)
        {
            colorGradingLayer.saturation.value = Mathf.Lerp(colorGradingLayer.saturation.value, -100.0f, 10.0f * Time.unscaledDeltaTime);
            yield return(new WaitForEndOfFrame());
        }
    }