public void AtualizaPerfil()
{
float intensidadeGrain = 0.18f;
float intensidadeVignette = 0.4f;
float temperatura = -5f;
float difSaturacao = 0.64f;
float difContraste = 0.3f;
GrainModel.Settings grainSettings = perfil.grain.settings;
grainSettings.intensity = intensidadeGrain * intensidade;
perfil.grain.settings = grainSettings;
VignetteModel.Settings vignetteSettings = perfil.vignette.settings;
vignetteSettings.intensity = intensidadeVignette * intensidade;
perfil.vignette.settings = vignetteSettings;
ColorGradingModel.Settings colorGradingSettings = perfil.colorGrading.settings;
colorGradingSettings.basic.temperature = temperatura * intensidade;
colorGradingSettings.basic.saturation = 1 - difSaturacao * intensidade;
colorGradingSettings.basic.contrast = 1 - difContraste * intensidade;
colorGradingSettings.colorWheels.log.slope = new Color(1 - 0.183f * intensidade, 1 - 0.152f * intensidade, 1f, 0f);
colorGradingSettings.colorWheels.log.power = new Color(1 - 0.35f * intensidade, 1 - 0.284f * intensidade, 1f, 0f);
perfil.colorGrading.settings = colorGradingSettings;
}
public void SetInitialPostProcess(PostProcessType pType, float value)
{
switch (pType)
{
case PostProcessType.vignette:
VignetteModel.Settings confv = profile.vignette.settings;
confv.intensity = value;
profile.vignette.settings = confv;
break;
case PostProcessType.blackout:
ColorGradingModel.Settings confg = profile.colorGrading.settings;
confg.tonemapping.neutralBlackOut = value;
profile.colorGrading.settings = confg;
break;
case PostProcessType.chromatic:
ChromaticAberrationModel.Settings confc = profile.chromaticAberration.settings;
confc.intensity = value;
profile.chromaticAberration.settings = confc;
break;
case PostProcessType.grain:
GrainModel.Settings confgr = profile.grain.settings;
confgr.intensity = value;
profile.grain.settings = confgr;
break;
}
}
IEnumerator InterpolateGrain(float target, float speed, float limit, InterpolationType iType)
{
float velocity = 0;
GrainModel.Settings conf = profile.grain.settings;
while (Mathf.Abs(conf.intensity - target) > limit)
{
switch (iType)
{
case InterpolationType.damp:
conf.intensity = Mathf.SmoothDamp(conf.intensity, target, ref velocity, speed);
break;
case InterpolationType.lerp:
conf.intensity = Mathf.Lerp(conf.intensity, target, speed);
break;
}
profile.grain.settings = conf;
yield return(new WaitForEndOfFrame());
}
conf.intensity = target;
profile.grain.settings = conf;
isFading = false;
}
private IEnumerator LerpCR()
{
GetComponent <CameraFollow>().FocusOnPlayer();
float currentTime = 0f;
while (currentTime < duration)
{
VignetteModel vignet = ppp.vignette;
VignetteModel.Settings newVignette = vignet.settings;
newVignette.intensity = Mathf.Lerp(1f, 0f, currentTime / duration);
newVignette.smoothness = Mathf.Lerp(1f, 0f, currentTime / duration);
vignet.settings = newVignette;
GrainModel grain = ppp.grain;
GrainModel.Settings newGrain = grain.settings;
newGrain.intensity = Mathf.Lerp(1f, 0f, currentTime / duration);
newGrain.size = Mathf.Lerp(3f, 1f, currentTime / duration);
newGrain.luminanceContribution = Mathf.Lerp(0f, 1f, currentTime / duration);
grain.settings = newGrain;
currentTime += Time.deltaTime;
yield return(null);
}
}
private IEnumerator CameraEffectsHit(PostProcessingBehaviour pp)
{
pp.profile.chromaticAberration.enabled = true;
pp.profile.grain.enabled = true;
ChromaticAberrationModel.Settings CASettings = new ChromaticAberrationModel.Settings();
GrainModel.Settings GrainSettings = new GrainModel.Settings();
CASettings.intensity = 0;
GrainSettings.intensity = 0;
GrainSettings.size = 0;
var time = .4f;
while (time > .2f)
{
time -= Time.deltaTime;
CASettings.intensity += .1f;
GrainSettings.intensity += .025f;
GrainSettings.size += .1f;
pp.profile.chromaticAberration.settings = CASettings;
pp.profile.grain.settings = GrainSettings;
yield return(null);
}
while (time > 0f && time <= .2f)
{
time -= Time.deltaTime;
CASettings.intensity -= .15f;
GrainSettings.intensity -= .025f;
GrainSettings.size -= .1f;
pp.profile.chromaticAberration.settings = CASettings;
pp.profile.grain.settings = GrainSettings;
yield return(null);
}
pp.profile.chromaticAberration.enabled = false;
pp.profile.grain.enabled = false;
}
// Start is called before the first frame update
void Start()
{
goforward.onClick.AddListener(FirstGoForward);
floorSpawningScript = GetComponent <FloorSpawningScript>();
GrainModel.Settings settings = profile.grain.settings;
settings.intensity = 0.7f;
profile.grain.settings = settings;
}
// Use this for initialization
void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
stage = 0;
GrainModel.Settings Grain = normal.grain.settings;
Grain.intensity = 0;
normal.grain.settings = Grain;
i = 0;
}
private void PPPUpdateHelper(bool motionBlur, bool chromaticAberration, float grainIntensity, float grainSize)
{
ppb.profile.motionBlur.enabled = motionBlur;
ppb.profile.chromaticAberration.enabled = chromaticAberration;
GrainModel.Settings grainSettings = ppb.profile.grain.settings;
grainSettings.intensity = grainIntensity;
grainSettings.size = grainSize;
ppb.profile.grain.settings = grainSettings;
}
private static void WriteG(List <string> lines, GrainModel.Settings settings)
{
lines.Append("Grain", 1);
lines.Append("{", 1);
lines.Append("Colored = " + settings.colored.Convert(), 2);
lines.Append("Intensity = " + settings.intensity, 2);
lines.Append("Luminance_Contribution = " + settings.luminanceContribution, 2);
lines.Append("Size = " + settings.size, 2);
lines.Append("}", 1);
}
void Start()
{
profile = Camera.main.GetComponent <PostProcessingBehaviour>().profile;
bloomSettings = profile.bloom.settings;
vignetteSettings = profile.vignette.settings;
grainSettings = profile.grain.settings;
ResetGrain();
ResetVignette();
}
void Start()
{
//Recticle Activate
Reticle.gameObject.SetActive(true);
//Grey Reset
transitionImage.gameObject.SetActive(false);
//Grain Reset
GrainModel.Settings grainSettings = postProProfile.grain.settings;
grainSettings.intensity = grainLevel;
postProProfile.grain.settings = grainSettings;
}
public void MagneticIntensityUp()
{
intentsityEffect += Time.deltaTime;
if (intentsityEffect > 1.0f)
{
intentsityEffect = 1.0f;
}
GrainModel.Settings grainSettings = profiles[1].grain.settings;
grainSettings.intensity = intentsityEffect;
profiles[1].grain.settings = grainSettings;
}
// Update is called once per frame
void Update()
{
if (flag4)
{
grainsetting = behaviour.profile.grain.settings;
grainsetting.intensity = 0.5f;
behaviour.profile.grain.settings = grainsetting;
Invoke("mati", 0.5f);
flag4 = false;
}
}
// Update is called once per frame
void Update()
{
float ratio = m_motivation.Total / 100.0f;
ColorGradingModel.Settings colorSettings = m_profile.colorGrading.settings;
colorSettings.basic.saturation = ratio * 2.0f;
m_profile.colorGrading.settings = colorSettings;
GrainModel.Settings grainSettings = m_profile.grain.settings;
grainSettings.intensity = (1 - ratio) / 2.0f;
m_profile.grain.settings = grainSettings;
}
public void GrainEffect(float level, float instanceId = -1)
{
GrainModel.Settings settings = postProcessingProfile.grain.settings;
settings.intensity = level / 5;
postProcessingProfile.grain.settings = settings;
if (instanceId != -1)
{
ids.Add(instanceId);
}
}
// Use this for initialization
void Start()
{
profile = Behaviour.profile;
grain = profile.grain.settings;
vignette = profile.vignette.settings;
saturation = profile.colorGrading.settings;
Space.Connect <DefaultEvent>(Events.StatChange, OnStatChange);
StartCoroutine(TextParser.FrameDelay(Events.StatChange));
}
// Update is called once per frame
void Update()
{
if (stage == 0)
{
if (player.GetComponent <damageController>().getHealth() <= 0)
{
OnPlayerDeath();
}
}
else if (stage == 1)
{
GrainModel.Settings Grain = normal.grain.settings;
//float time = Time.unscaledDeltaTime;
//Debug.Log(Grain.intensity + " | " + time);
Grain.intensity += Time.unscaledDeltaTime;
if (Grain.intensity >= 1)
{
stage = 2;
Grain.intensity = 1;
}
normal.grain.settings = Grain;
}
else if (stage == 2)
{
stage = 3;
videoPlayer.GetComponent <VideoPlayer>().Play();
var clone1 = Instantiate(DeathSound2, transform.position, Quaternion.identity);
HUD.SetActive(false);
}
else if (stage == 3)
{
GrainModel.Settings Grain = normal.grain.settings;
Grain.intensity -= Time.unscaledDeltaTime * 5;
if (Grain.intensity <= 0)
{
Grain.intensity = 0;
}
stage = 4;
normal.grain.settings = Grain;
}
else if (stage == 4)
{
i += Time.unscaledDeltaTime;
if (i >= 1)
{
stage = 5;
}
}
else if (stage == 5)
{
DeathMenu.SetActive(true);
}
}
private static void ConvertGrainSettings(PostProcessProfile ppp, GrainModel.Settings grain)
{
var grain2 = ppp.AddSettings <Grain>();
grain2.colored.overrideState = true;
grain2.colored.value = grain.colored;
grain2.intensity.overrideState = true;
grain2.intensity.value = grain.intensity;
grain2.lumContrib.overrideState = true;
grain2.lumContrib.value = grain.luminanceContribution;
grain2.size.overrideState = true;
grain2.size.value = grain.size;
}
protected override void SetupEffects()
{
//Model Settings
motionBlurModel = profile.motionBlur.settings;
grainModel = profile.grain.settings;
vignetteModel = profile.vignette.settings;
InitialEffectsSettings();
//Parameters Compensation
motionBlurFrameBlending -= initialMotionBlurFrameBlending;
grainIntensity -= initialGrainIntensity;
vignetteIntensity -= initialVignetteIntensity;
}
// Use this for initialization
void Start()
{
if (bGrainOn)
{
GrainModel.Settings temp = mPostProcessing.grain.settings;
mGrainTime += Time.deltaTime;
float mMin = 0.2f;
temp.intensity = mMin + Mathf.PingPong(mGrainTime, 0.1f);
if (mGrainTime >= 1)
{
mGrainTime = 0;
}
}
}
// Use this for initialization
void Start()
{
//Always assign the default settings so other
//things you don't want to change aren't reset
bloomS = mainProfile.bloom.settings;
bloomS.bloom.intensity = 0;
chromeS = mainProfile.chromaticAberration.settings;
chromeS.intensity = 0;
vigS = mainProfile.vignette.settings;
vigS.intensity = 0.5f;
StartCoroutine(heartbeatChange());
grainS = mainProfile.grain.settings;
grainS.intensity = 0;
mainProfile.grain.settings = grainS;
}
public static void EnableNightVisionEffect(AbstractActor source)
{
// Skip if the green effect is disabled
if (!Mod.Config.Toggles.ShowNightVision)
{
return;
}
ModState.IsNightVisionMode = true;
MoodController mc = ModState.GetMoodController();
Traverse uppT = Traverse.Create(mc).Field("unityPostProcess");
PostProcessingBehaviour ppb = uppT.GetValue <PostProcessingBehaviour>();
// Enable grain and set the intensity
Traverse grainT = Traverse.Create(ppb).Field("m_Grain");
GrainComponent gc = grainT.GetValue <GrainComponent>();
GrainModel.Settings gms = gc.model.settings;
gms.intensity = 0.8f;
gms.size = 1.0f;
gc.model.settings = gms;
Traverse sunlightBTT = Traverse.Create(mc).Field("sunlightBT");
BTSunlight sunlightBT = sunlightBTT.GetValue <BTSunlight>();
// Disable shadows from sunlight
//BTSunlight.SunlightSettings sunlightS = sunlightBT.sunSettings;
//sunlightS.castShadows = false;
//sunlightBT.sunSettings = sunlightS;
Traverse sunlightT = Traverse.Create(sunlightBT).Field("sunLight");
Light sunlight = sunlightT.GetValue <Light>();
sunlight.shadows = LightShadows.None;
// Set the sunlight color
Color lightVision = Color.green;
lightVision.a = 0.8f;
Shader.SetGlobalColor(Shader.PropertyToID("_BT_SunlightColor"), lightVision);
// Disable opacity from the clouds
Shader.SetGlobalFloat(Shader.PropertyToID("_BT_CloudOpacity"), 0f);
// Make the sunlight point straight down
Shader.SetGlobalVector(Shader.PropertyToID("_BT_SunlightDirection"), sunlightBT.transform.up);
}
void Transition()
{
float rndm = Random.Range(0.75f, 1.0f);
//Grain Activate
GrainModel.Settings grainSettings = postProProfile.grain.settings;
grainSettings.intensity = 1;
postProProfile.grain.settings = grainSettings;
//Grey Activate
transitionImage.gameObject.SetActive(true);
//Reticle Reset
Reticle.gameObject.SetActive(false);
//Transition Sound
audioSource.pitch = rndm;
audioSource.PlayOneShot(transitionSound, 0.75f);
}
IEnumerator ProcessMushroomEffect()
{
while (true)
{
ChromaticAberrationModel.Settings caSettings = profile.chromaticAberration.settings;
GrainModel.Settings gSettings = profile.grain.settings;
caSettings.intensity = player.GetComponent <MushroomEffect>().intoxication / 30f;
gSettings.intensity = player.GetComponent <MushroomEffect>().intoxication / 60f;
profile.chromaticAberration.settings = caSettings;
profile.grain.settings = gSettings;
yield return(new WaitForSeconds(0.25f));
}
}
protected void LerpGrain(float rate)
{
float GRAIN_ACTIVATION_LIMIT = 0.05f;
transitionProfile.grain.enabled = EnableOrDisableEffect(oldProfile.grain.enabled, futureProfile.grain.enabled, rate, GRAIN_ACTIVATION_LIMIT);
GrainModel.Settings currentSettings = oldProfile.grain.settings;
GrainModel.Settings futureSettings = futureProfile.grain.settings;
currentSettings.intensity = Mathf.Lerp(currentSettings.intensity, futureSettings.intensity, rate);
currentSettings.luminanceContribution = Mathf.Lerp(currentSettings.luminanceContribution, futureSettings.luminanceContribution, rate);
currentSettings.size = Mathf.Lerp(currentSettings.size, futureSettings.size, rate);
// currentSettings.colored = ;
transitionProfile.grain.settings = currentSettings;
}
IEnumerator ResetGrain(float waitTime)
{
//Wait
yield return(new WaitForSeconds(waitTime));
//Recticle Activate
Reticle.gameObject.SetActive(true);
//Grey Reset
transitionImage.gameObject.SetActive(false);
//Grain Reset
GrainModel.Settings grainSettings = postProProfile.grain.settings;
grainSettings.intensity = grainLevel;
postProProfile.grain.settings = grainSettings;
//Transition Sound Stop
audioSource.Stop();
}
public void Fire()
{
behaviour.profile.grain.enabled = true;
var grainIntensity = kvps.ContainsKey(intensity) ? float.Parse(kvps[intensity]) : 0;
var grainSize = kvps.ContainsKey(size) ? float.Parse(kvps[size]) : 0.3f;
var grainContribution = kvps.ContainsKey(contribution) ? float.Parse(kvps[contribution]) : 0;
var isColor = kvps.ContainsKey(coloerd) ? bool.Parse(kvps[coloerd]) : true;
var setting = new GrainModel.Settings();
setting.intensity = grainIntensity;
setting.size = grainSize;
setting.luminanceContribution = grainContribution;
setting.colored = isColor;
behaviour.profile.grain.settings = setting;
}
void Start()
{
// Replace the profile with its clone.
var postfx = GetComponent <PostProcessingBehaviour>();
_profile = Instantiate <PostProcessingProfile>(postfx.profile);
postfx.profile = _profile;
// Initialize the public structs with the current profile.
enableAntialiasing = _profile.antialiasing.enabled;
antialiasing = _profile.antialiasing.settings;
enableAmbientOcclusion = _profile.ambientOcclusion.enabled;
ambientOcclusion = _profile.ambientOcclusion.settings;
enableScreenSpaceReflection = _profile.screenSpaceReflection.enabled;
screenSpaceReflection = _profile.screenSpaceReflection.settings;
enableDepthOfField = _profile.depthOfField.enabled;
depthOfField = _profile.depthOfField.settings;
enableMotionBlur = _profile.motionBlur.enabled;
motionBlur = _profile.motionBlur.settings;
enableEyeAdaptation = _profile.eyeAdaptation.enabled;
eyeAdaptation = _profile.eyeAdaptation.settings;
enableBloom = _profile.bloom.enabled;
bloom = _profile.bloom.settings;
enableColorGrading = _profile.colorGrading.enabled;
colorGrading = _profile.colorGrading.settings;
enableUserLut = _profile.userLut.enabled;
userLut = _profile.userLut.settings;
enableChromaticAberration = _profile.chromaticAberration.enabled;
chromaticAberration = _profile.chromaticAberration.settings;
enableGrain = _profile.grain.enabled;
grain = _profile.grain.settings;
enableVignette = _profile.vignette.enabled;
vignette = _profile.vignette.settings;
}
// Use this for initialization
void Start()
{
playerMove = GameObject.Find("Player").GetComponent <PlayerMovement>();
playerCombatScript = GameObject.Find("Player").GetComponent <PlayerCombat>();
darkness = false;
enhancedRadius = false;
enhancedRadiusTime = 0;
vignetteSettings = profile.vignette.settings;
chromaticAberSettings = profile.chromaticAberration.settings;
grainSettings = profile.grain.settings;
gameCam = GameObject.Find("Main Camera").GetComponent <Camera>();
// set starting intensities for easier code management
vignetteStartingIntensity = .8f;
chromaticAbStartingIntensity = chromaticAberSettings.intensity;
grainStartingIntensity = grainSettings.intensity;
expansionRate = .005f;
}
void RestartGraphicProfile()
{
vignette_sett = camera_effects.vignette.settings;
vignette_sett.intensity = 0.0f;
camera_effects.vignette.settings = vignette_sett;
grain_sett = camera_effects.grain.settings;
grain_sett.intensity = 0.0f;
camera_effects.grain.settings = grain_sett;
aberration_sett = camera_effects.chromaticAberration.settings;
aberration_sett.intensity = 0.0f;
camera_effects.chromaticAberration.settings = aberration_sett;
bloom_set = camera_effects.bloom.settings;
bloom_set.bloom.intensity = 0.0f;
camera_effects.bloom.settings = bloom_set;
}