// Use this for initialization
void Start()
{
cgm = postProcessingBehaviour.profile.colorGrading;
cgms = cgm.settings;
dofm = postProcessingBehaviour.profile.depthOfField;
dofms = dofm.settings;
if (QualitySettings.GetQualityLevel() <= 2)
{
postProcessingBehaviour.enabled = false;
}
/*TerrainData tData = terrain.terrainData;
* float[,,] alphaData = tData.GetAlphamaps(0, 0, tData.alphamapWidth, tData.alphamapHeight);
*
* float percentage = 0.2f;
* for(int y=0; y<tData.alphamapHeight; y++){
* for(int x = 0; x < tData.alphamapWidth; x++){
* float swap = alphaData[x, y, 1];
* alphaData[x, y, 1] = alphaData[x, y, 2];
* alphaData[x, y, 2] = swap;
* }
* }
*
* tData.SetAlphamaps(0, 0, alphaData);*/
}
public void ChangeSaturation(float level)
{
ColorGradingModel.Settings settings = postProcessingProfile.colorGrading.settings;
settings.basic.saturation = level;
postProcessingProfile.colorGrading.settings = settings;
}
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;
}
}
void Start()
{
TabButtonPanel.SetActive(false);
saveNotification.SetActive(false);
HideSprites(spriteType.Interact);
HideSprites(spriteType.Grab);
HideSprites(spriteType.Examine);
Unpause();
if (m_ShowCursor)
{
Cursor.visible = (true);
Cursor.lockState = CursorLockMode.None;
}
else
{
Cursor.visible = (false);
Cursor.lockState = CursorLockMode.Locked;
}
processingBehaviour = Camera.main.gameObject.GetComponent <PostProcessingBehaviour>();
processingProfile = processingBehaviour.profile;
colorGrading = processingProfile.colorGrading.settings;
if (useGreyscale)
{
processingProfile.colorGrading.enabled = true;
}
}
void Start()
{
//pp stuff
colorGrader = myPost.colorGrading.settings;
colorGrader.basic.hueShift = 0;
myPost.colorGrading.settings = colorGrader;
//set our movement points
movementPoints = new Transform[movementPointHolder.childCount];
for (int i = 0; i < movementPointHolder.childCount; i++)
{
movementPoints[i] = movementPointHolder.transform.GetChild(i);
}
finishDest = movementPoints.Length - 1;
playerNavMove = GetComponent <NavMeshAgent>();
planeSource = airship.GetComponent <AudioSource>();
planeSource.Play();
SetDestination();
smokeSpawnTimer = smokeSpawnTotal;
clock = GameObject.FindGameObjectWithTag("SimpleClock").GetComponent <SimpleClock>();
myCam = Camera.main;
}
void Start()
{
m_AnimationBehaviours = new Dictionary <PostEffectsTypes, AnimationBehaviour>();
m_ActiveAnimationBehaviours = new List <AnimationBehaviour>();
//Создать новый профиль и начать его использовать
m_Profile = ScriptableObject.CreateInstance <PostProcessingProfile>();
Behaviour.profile = m_Profile;
///Color grading
m_Profile.colorGrading = new ColorGradingModel();
//Изменить тип Tonemapper на Tonemapper.None
ColorGradingModel.Settings colorGradingModelSettings = m_Profile.colorGrading.settings;
colorGradingModelSettings.tonemapping.tonemapper = ColorGradingModel.Tonemapper.None;
m_Profile.colorGrading.settings = colorGradingModelSettings;
//Saturation
AnimationBehaviour behaviour = new SaturationAnimationBehaviour(m_Profile, m_SATURATION_FADE_TIME);
behaviour.OnAnimationFinished += AnimationFinishedHandler;
m_AnimationBehaviours.Add(PostEffectsTypes.Saturation, behaviour);
//Expose
behaviour = new ExposeAnimationBehaviour(m_Profile, m_POSTEXPOSURE_FADE_TIME);
behaviour.OnAnimationFinished += AnimationFinishedHandler;
m_AnimationBehaviours.Add(PostEffectsTypes.PostExposure, behaviour);
///Vignette
behaviour = new VignetteAnimationBehaviour(null, m_VIGNETTE_FADE_TIME, Vignette, Vignette.VignetteInnerValue, Vignette.VignetteOuterValue);
behaviour.OnAnimationFinished += AnimationFinishedHandler;
m_AnimationBehaviours.Add(PostEffectsTypes.Vignette, behaviour);
InputManager.Instance.OnInputStateChange += VignetteOnInputState;
}
// Update is called once per frame
void Update()
{
// Linearly update all post processing values which aren't at their target values.
lerp += Time.deltaTime / duration;
VignetteModel.Settings vignette = profile.vignette.settings;
if (vignette.intensity != targetVignette)
{
vignette.intensity = Mathf.Lerp(fromVignette, targetVignette, lerp);
}
DepthOfFieldModel.Settings dof = profile.depthOfField.settings;
if (dof.aperture != targetDof)
{
dof.aperture = Mathf.Lerp(fromDof, targetDof, lerp);
}
ColorGradingModel.Settings cgm = profile.colorGrading.settings;
if (cgm.basic.saturation != targetSaturation)
{
cgm.basic.saturation = Mathf.Lerp(fromSaturation, targetSaturation, lerp);
}
if (cgm.basic.temperature != targetTemp)
{
cgm.basic.temperature = Mathf.Lerp(fromTemp, targetTemp, lerp);
}
profile.vignette.settings = vignette;
profile.depthOfField.settings = dof;
profile.colorGrading.settings = cgm;
}
public void setColorWheelSettings()
{
ColorGradingModel.Settings currSettings = currProfile.colorGrading.settings;
ColorGradingModel.Settings daySettings = dayProfile.colorGrading.settings;
ColorGradingModel.Settings nightSettings = nightProfile.colorGrading.settings;
Color currLift = DayBasedLerp(dayColor[0], nightColor[0]);
Color currGamma = DayBasedLerp(dayColor[1], nightColor[1]);
Color currGain = DayBasedLerp(dayColor[2], nightColor[2]);
currSettings.colorWheels.linear.lift = currLift;
currSettings.colorWheels.linear.gamma = currGamma;
currSettings.colorWheels.linear.gain = currGain;
float currTempature = DayBasedLerp(daySettings.basic.temperature, nightSettings.basic.temperature);
float currTint = DayBasedLerp(daySettings.basic.tint, nightSettings.basic.tint);
float currHueShift = DayBasedLerp(daySettings.basic.hueShift, nightSettings.basic.hueShift);
float currSaturation = DayBasedLerp(daySettings.basic.saturation, nightSettings.basic.saturation);
currSettings.basic.temperature = currTempature;
currSettings.basic.saturation = currSaturation;
currSettings.basic.tint = currTint;
currSettings.basic.hueShift = currHueShift;
currProfile.colorGrading.settings = currSettings;
}
public void SetSaturation(float number)
{
ColorGradingModel.Settings cgSettings = postprocessingProfile.colorGrading.settings;
cgSettings.basic.saturation = number;
DOTween.To(() => cgSettings.basic.saturation, x => cgSettings.basic.saturation = x, number, 1f);
postprocessingProfile.colorGrading.settings = cgSettings;
}
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;
}
void Update()
{
ColorGradingModel.Settings cgs = profile.colorGrading.settings;
cgs.basic.saturation = Mathf.Abs(Mathf.Sin(Time.time));
profile.colorGrading.settings = cgs;
}
private void Update()
{
if (startWalk)
{
counter += 1 * Time.deltaTime;
if (counter >= 1f)
{
myBasicSettings = levelProfile.colorGrading.settings;
myBasicSettings.basic.postExposure += 1f * Time.deltaTime;
if (myBasicSettings.basic.postExposure >= 9f)
{
levelChanger.GetComponent <LevelChanger>().FadeToLevel(8);
}
for (int i = 0; i < players.Length; i++)
{
Rigidbody2D playersrb2d = players[i].GetComponent <Rigidbody2D>();
players[i].GetComponent <P_controls>().StopGameControl = true;
playersrb2d.velocity = new Vector2(13f, playersrb2d.velocity.y);
players[i].GetComponent <Animator>().SetBool("Idle", false);
players[i].GetComponent <Animator>().SetBool("Walking", true);
players[i].transform.localScale = new Vector3(1, 1, 1);
}
levelProfile.colorGrading.settings = myBasicSettings;
}
}
}
/// <summary>
/// Fade brightness to zero and then load the scene
/// </summary>
private IEnumerator LoadScene()
{
var nextScene = SceneManagerExtension.GetBuildIndexByName(m_loadSceneName);
if (nextScene < 0)
{
Debug.LogError("Invalid Scene Name!");
yield break;
}
PostProcessingProfile effect = Instantiate <PostProcessingProfile> (
m_brightnessEffect.profile);
ColorGradingModel.Settings effectSetting = effect.colorGrading.settings;
m_brightnessEffect.profile = effect;
// Fade brightness
float timer = 0;
while (timer < 2)
{
JITimer.Instance.TimeScale = 0;
timer += JITimer.Instance.RealDeltTime;
effectSetting.basic.postExposure = -5 * timer;
effect.colorGrading.settings = effectSetting;
yield return(null);
}
EventManager.Instance.Raise(new BeforeChangeToNextStageEvent(
SceneManager.GetActiveScene().buildIndex, nextScene));
SceneManager.LoadSceneAsync(m_loadSceneName, LoadSceneMode.Single);
}
private void OnEnable()
{
PostProcessingBehaviour component = base.GetComponent <PostProcessingBehaviour>();
if (component.profile == null)
{
base.enabled = false;
}
else
{
this.profile = Instantiate <PostProcessingProfile>(component.profile);
component.profile = this.profile;
this.DisableAllEffects(this.profile);
int qualityLevel = QualitySettings.GetQualityLevel();
this.Fog.enabled = ((qualityLevel >= 2) && (GraphicsSettings.INSTANCE != null)) && (GraphicsSettings.INSTANCE.CurrentShadowQuality != 0);
this.profile.userLut.enabled = qualityLevel >= 2;
this.profile.colorGrading.enabled = qualityLevel >= 2;
if (this.profile.colorGrading.enabled)
{
ColorGradingModel.Settings settings = this.profile.colorGrading.settings;
settings.basic.saturation = (GraphicsSettings.INSTANCE != null) ? GraphicsSettings.INSTANCE.CurrentSaturationLevel : 1f;
this.profile.colorGrading.settings = settings;
}
if ((GraphicsSettings.INSTANCE != null) && GraphicsSettings.INSTANCE.customSettings)
{
this.SetCustomSettings();
}
else
{
this.SetDefaultSettings();
}
}
}
void LightSet()
{
switch (m_Light)
{
case Light.Dark:
colorGrad = ppProfile.colorGrading.settings;
colorGrad.basic.postExposure = Mathf.Lerp(colorGrad.basic.postExposure, lightIntensity.x, 2 * Time.deltaTime);
ppProfile.colorGrading.settings = colorGrad;
vignetteSet = ppProfile.vignette.settings;
vignetteSet.intensity = Mathf.Lerp(vignetteSet.intensity, vignetteIntensity.x, 2 * Time.deltaTime);
ppProfile.vignette.settings = vignetteSet;
break;
case Light.Lantern:
colorGrad = ppProfile.colorGrading.settings;
colorGrad.basic.postExposure = Mathf.Lerp(colorGrad.basic.postExposure, lightIntensity.y, 2 * Time.deltaTime);
ppProfile.colorGrading.settings = colorGrad;
vignetteSet = ppProfile.vignette.settings;
vignetteSet.intensity = Mathf.Lerp(vignetteSet.intensity, vignetteIntensity.y, 2 * Time.deltaTime);
ppProfile.vignette.settings = vignetteSet;
break;
case Light.Lamp:
colorGrad = ppProfile.colorGrading.settings;
colorGrad.basic.postExposure = Mathf.Lerp(colorGrad.basic.postExposure, lightIntensity.z, 2 * Time.deltaTime);
ppProfile.colorGrading.settings = colorGrad;
vignetteSet = ppProfile.vignette.settings;
vignetteSet.intensity = Mathf.Lerp(vignetteSet.intensity, vignetteIntensity.z, 2 * Time.deltaTime);
ppProfile.vignette.settings = vignetteSet;
break;
}
}
private void TurnNeutral()
{
ColorGradingModel.Settings settings = this.Profile.colorGrading.settings;
settings.channelMixer.red = Vector3.MoveTowards(settings.channelMixer.red, new Vector3(1f, 0f, 0f), Time.deltaTime * 0.66666f);
settings.channelMixer.green = Vector3.MoveTowards(settings.channelMixer.green, new Vector3(0f, 1f, 0f), Time.deltaTime * 0.66666f);
settings.channelMixer.blue = Vector3.MoveTowards(settings.channelMixer.blue, new Vector3(0f, 0f, 1f), Time.deltaTime * 0.66666f);
this.Profile.colorGrading.settings = settings;
}
public float blueSpeed, bloomSpeed; //control how intense effects are
// Use this for initialization
void Start()
{
//assigns everything and starts them at default values since script permantely edits file
colorS = mainProfile.colorGrading.settings;
colorS.channelMixer.blue = new Vector3(0f, 0f, 1f);
bloomS = mainProfile.bloom.settings;
bloomS.bloom.intensity = 0;
}
// Use this for initialization
void Start()
{
PostProcessingProfile postProcessingProfile = Camera.main.GetComponent <PostProcessingBehaviour>().profile;
ColorGradingModel.Settings set = postProcessingProfile.colorGrading.settings;
set.basic.saturation = 1;
postProcessingProfile.colorGrading.settings = set;
}
private static void UpdateGreenChannel(Vector3 value)
{
ColorGradingModel.Settings cgms = ig_GameManager.instance.postProcessProfile.colorGrading.settings;
cgms.channelMixer.green = value;
ig_GameManager.instance.postProcessProfile.colorGrading.settings = cgms;
}
private static void UpdateBlueChannel(Vector3 value)
{
ColorGradingModel.Settings cgms = instance.postProcessProfile.colorGrading.settings;
cgms.channelMixer.blue = value;
instance.postProcessProfile.colorGrading.settings = cgms;
}
// make sure it is colored when the game starts
private void InitPostProcessingColor()
{
PostProcessingProfile postProcessingProfile = Camera.main.GetComponent <PostProcessingBehaviour>().profile;
ColorGradingModel.Settings s = postProcessingProfile.colorGrading.settings;
s.basic.saturation = 1;
postProcessingProfile.colorGrading.settings = s;
}
public void ChangeSaturation()
{
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <PostProcessingBehaviour>();
auxSettings = cam.profile.colorGrading.settings;
auxSettings.basic.saturation = saturation + 1;
cam.profile.colorGrading.settings = auxSettings;
}
private void UpdateBlueChannel(Vector3 value)
{
ColorGradingModel.Settings cgms = standardColorModel;
cgms.channelMixer.blue = value;
ig_GameManager.instance.postProcessProfile.colorGrading.settings = cgms;
}
// Use this for initialization
void Start()
{
currentLife = startingLife;
txtLifeLeft.text = currentLife.ToString() + " / " + startingLife.ToString();
ColorGradingModel.Settings s = profile.colorGrading.settings;
s.basic.saturation = 1f;
profile.colorGrading.settings = s;
}
void ResetPostProcessingProfiles()
{
foreach (PostProcessingProfile profile in postProcessingProfiles)
{
ColorGradingModel.Settings gradingSettings = profile.colorGrading.settings;
gradingSettings.basic.postExposure = 0;
profile.colorGrading.settings = gradingSettings;
}
}
public void SetValue(float f)
{
this.warningText.enabled = (f > 0.5f);
PlayerPrefs.SetFloat("gamma", f);
ColorGradingModel.Settings settings = default(ColorGradingModel.Settings);
settings = this.profile.colorGrading.settings;
settings.basic.postExposure = f;
this.profile.colorGrading.settings = settings;
}
//void OnTriggerStay(Collider other)
//{
// if (isGrayScale)
// return;
// ColorGradingModel.Settings cgs = profile.colorGrading.settings;
// cgs.basic.saturation = 1;
// profile.colorGrading.settings = cgs;
//}
void OnTriggerExit(Collider other)
{
//Debug.Log("exiting region");
ColorGradingModel.Settings cgs = profile.colorGrading.settings;
cgs.basic.saturation = 0;
profile.colorGrading.settings = cgs;
Debug.Log(cgs.basic.saturation);
//Debug.Log("region exited");
}
// Update is called once per frame
void Update()
{
ColorGradingModel.Settings colorGrading = Profile.colorGrading.settings;
if (Input.GetKeyDown(KeyCode.Alpha6))
{
colorGrading.basic.hueShift = HueShiftAngle;
}
Profile.colorGrading.settings = colorGrading;
}
void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
cammy = GetComponent <Camera>();
colorGrader = pp.colorGrading.settings;
ResetColor();
}
private void TurnRed()
{
ColorGradingModel.Settings settings = this.Profile.colorGrading.settings;
settings.basic.saturation = Mathf.MoveTowards(settings.basic.saturation, 1f, Time.deltaTime * 0.1f);
settings.channelMixer.red = Vector3.MoveTowards(settings.channelMixer.red, new Vector3(1f, 0f, 0f), Time.deltaTime * 0.1f);
settings.channelMixer.green = Vector3.MoveTowards(settings.channelMixer.green, new Vector3(0f, 0.5f, 0f), Time.deltaTime * 0.1f);
settings.channelMixer.blue = Vector3.MoveTowards(settings.channelMixer.blue, new Vector3(0f, 0f, 0.5f), Time.deltaTime * 0.1f);
this.Profile.colorGrading.settings = settings;
}
