public MinMaxGradientData(Color c1)
{
_mode = ParticleSystemGradientMode.Color;
_color1 = c1;
_color2 = Color.clear;
_gradient1 = _gradient2 = null;
_startColor = MakeMinMaxGradient(_mode, _color1, _color2, _gradient1, _gradient2);
}
public void Apply(ParticleSystem.MinMaxGradient gradient)
{
MinMaxState = gradient.mode;
MaxGradient.Apply(gradient.gradientMax);
MinGradient.Apply(gradient.gradientMin);
MaxColor.ColorHelper = gradient.colorMax;
MinColor.ColorHelper = gradient.colorMin;
}
public ParticleSystem.MinMaxGradient GetMinMaxGradient()
{
ParticleSystem.MinMaxGradient minMaxGradient = new ParticleSystem.MinMaxGradient();
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.Color)
{
if (minMaxGradient.color == null)
{
minMaxGradient.color = new Color();
}
minMaxGradient.color = color.GetColor();
}
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.TwoColors)
{
if (minMaxGradient.colorMax == null)
{
minMaxGradient.colorMax = new Color();
}
minMaxGradient.colorMax = colorMax.GetColor();
if (minMaxGradient.colorMin == null)
{
minMaxGradient.colorMin = new Color();
}
minMaxGradient.colorMin = colorMin.GetColor();
}
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.Gradient)
{
if (minMaxGradient.gradient == null)
{
minMaxGradient.gradient = new Gradient();
}
minMaxGradient.gradient.alphaKeys = gradientAlphaKeys.GetAlphaKeys();
minMaxGradient.gradient.colorKeys = gradientColorKeys.GetColorKeys();
}
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.TwoGradients)
{
if (minMaxGradient.gradientMax == null)
{
minMaxGradient.gradientMax = new Gradient();
}
minMaxGradient.gradientMax.alphaKeys = gradientMaxAlphaKeys.GetAlphaKeys();
minMaxGradient.gradientMax.colorKeys = gradientMaxColorKeys.GetColorKeys();
if (minMaxGradient.gradientMin == null)
{
minMaxGradient.gradientMin = new Gradient();
}
minMaxGradient.gradientMin.alphaKeys = gradientMinAlphaKeys.GetAlphaKeys();
minMaxGradient.gradientMin.colorKeys = gradientMinColorKeys.GetColorKeys();
}
minMaxGradient.mode = gradientMode.GetGradientMode();
return(minMaxGradient);
}
protected override void LerpParameters(float lerp)
{
Color val = LerpColor(lerp, initialColor);
switch (type)
{
case objectType.Material:
if (forceSetMaterial)
{
mat.SetColor(propID, val);
}
else
{
if (image != null)
{
var iMat = image.material;
iMat.SetColor(propID, val);
image.SetMaterialDirty();
break;
}
renderer.sharedMaterial.SetColor(propID, val);
}
break;
case objectType.Graphic:
image.color = val;
break;
case objectType.Sprite:
sprite.color = val;
break;
case objectType.Particle:
#if UNITY_5_5_OR_NEWER
ParticleSystem.MinMaxGradient pMain = psys.main.startColor;
pMain.color = val;
#else
psys.startColor = val;
#endif
break;
case objectType.CanvasGroup:
canvasGroup.alpha = val.a;
break;
case objectType.TextMesh:
textMesh.color = val;
break;
case objectType.Light:
light.color = val;
break;
case objectType.Camera:
camera.backgroundColor = val;
break;
}
}
private void ChangeColor(float value, ParticleSystem.MainModule main)
{
if (changeColor)
{
ParticleSystem.MinMaxGradient startColor = particle.main.startColor;
startColor.color = colorCurve.Evaluate(value);
main.startColor = startColor;
}
}
public void Tick()
{
// Update all visible elements based on throttle value:
ParticleSystem.MainModule mainModule = rearThrusterParticle.main;
ParticleSystem.MinMaxGradient col = mainModule.startColor;
col.color = new Color(col.color.r, col.color.g, col.color.b, Mathf.Clamp01(throttle));
mainModule.startColor = col;
rearThrusterMat.SetColor("_EmissionColor", new Color(0.66f, 0.93f, 1f) * 12f * Mathf.Clamp01(throttle));
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 水しぶきの動き
/// </summary>
void Start()
{
m_splasheScaleZ = Body.transform.localScale.z;
tag = SplasheInfo.TRANS_TAG;
m_isParticleModuleMoving = true;
SplashParticleMainModule = SplashParticle.main;
SplashParticleMinMaxGradient = SplashParticle.main.startColor;
m_loopStopTime = SplashParticleMainModule.duration + m_addNum;
}
// Start is called before the first frame update
void Start()
{
_particleSystem = GetComponent <ParticleSystem>();
_particleEmission = _particleSystem.emission;
_particleColor = _particleSystem.colorOverLifetime;
SyncPowerManager.OnSyncPowerUpdate += SyncUpdate;
PlayerAttackState.OnAttack += HitFeedback;
_defaultColor = _particleColor.color;
}
void Awake()
{
var collider = GetComponent <CircleCollider2D> ();
collider.isTrigger = true;
radius = collider.radius;
startColour = particle.colorOverLifetime.color;
playerRigidbody = transform.parent.GetComponent <Rigidbody2D> ();
}
// Start is called before the first frame update
void Start()
{
particleLight = GetComponentInChildren <Light>();
mainParticle = GetComponent <ParticleSystem>();
particleColor = mainParticle.main.startColor;
particleDust = transform.GetChild(0).GetComponent <ParticleSystem>();
ParticleSystem.MainModule ma = particleDust.main;
SetPartLight();
}
public YoooMinMaxGradient(ParticleSystem.MinMaxGradient gradient)
{
Data = gradient;
colorMax = Data.colorMax;
colorMin = Data.colorMin;
gradientMax = Data.gradientMax;
gradientMin = Data.gradientMin;
mode = Data.mode;
}
public virtual void bounce(Missile proj)
{
ParticleSystem newBounce = Instantiate(proj.bounceEffect, proj.transform.position, Quaternion.identity);
ParticleSystem.MainModule main = newBounce.main;
ParticleSystem.MinMaxGradient startCol = main.startColor;
startCol.color = baseColor;
Destroy(newBounce.gameObject, 1f);
}
private void LoadDefaults()
{
if (defaultsLoaded)
{
return;
}
defaultGrad = particles.main.startColor;
defaultsLoaded = true;
}
// Start is called before the first frame update
void Start()
{
rbody = GetComponent <Rigidbody2D>();
rayLine = GetComponentInChildren <LineRenderer>();
mainPS = vfx.main;
swapColorPS = new ParticleSystem.MinMaxGradient(swapColor);
cantSwapColorPS = new ParticleSystem.MinMaxGradient(cantSwapColor);
}
/// <param name="gradient"></param>
/// <param name="samples">Must be 2 or higher</param>
public SampledMinMaxGradient(ParticleSystem.MinMaxGradient gradient, int samples)
{
sampledColor = new NativeArray <Color32>(samples, Allocator.Persistent);
float timeStep = 1f / (samples - 1);
for (int i = 0; i < samples; i++)
{
sampledColor[i] = gradient.Evaluate(i * timeStep);
}
}
private JSONObject ParseRandomColor(ParticleSystem.MinMaxGradient colorData)
{
JSONObject res = new JSONObject(JSONObject.Type.OBJECT);
JSONObject data = new JSONObject(JSONObject.Type.OBJECT);
res.AddField("type", "RandomColor");
res.AddField("data", data);
data.AddField("gColor", GetGradientColor(colorData.gradient));
return(res);
}
public void Playparticle(Color particleColor, float playTime)
{
ParticleSystem.MinMaxGradient color = new ParticleSystem.MinMaxGradient {
mode = ParticleSystemGradientMode.Color, color = particleColor
};
ParticleSystem.MainModule main = myParticle.main;
main.startColor = color;
myParticle.Play();
Invoke(nameof(StopParticle), playTime);
}
void Start()
{
engineTrail = GameObject.Find("newEngineTrail").GetComponent <ParticleSystem>();
smokeTrail = smokeEngineParticle.GetComponent <ParticleSystem>();
playerFuelScript = GameObject.Find("Player").GetComponent <PlayerFuel>();
colorModule = engineTrail.colorOverLifetime;
startColor_Engine = engineTrail.colorOverLifetime.color;
playerPhaseShiftScript = GameObject.Find("Phase_Gadget").GetComponent <PlayerPhaseShift>();
}
public void SetValue(ParticleSystem.MinMaxGradient minMaxGradient)
{
// TODO: Fix this and make it work with GetValue, above.
//if (minMaxGradient.mode == ParticleSystemGradientMode.Color)
// Value = $"Color({ColorUtility.ToHtmlStringRGB(minMaxGradient.color)})";
//else if (minMaxGradient.mode == ParticleSystemGradientMode.TwoColors)
// Value = $"TwoColors({ColorUtility.ToHtmlStringRGB(minMaxGradient.colorMin)} -> {ColorUtility.ToHtmlStringRGB(minMaxGradient.colorMax)})";
//else if (minMaxGradient.mode == ParticleSystemGradientMode.RandomColor)
// Value = $"RandomColor({ColorUtility.ToHtmlStringRGB(minMaxGradient.colorMin)} -> {ColorUtility.ToHtmlStringRGB(minMaxGradient.colorMax)})";
}
public void SetColor()
{
if (((IList <ParticleSystem>) this.particleColor1).IsNullOrEmpty <ParticleSystem>())
{
return;
}
ParticleSystem.MainModule main = this.particleColor1[0].get_main();
ParticleSystem.MinMaxGradient startColor = ((ParticleSystem.MainModule) ref main).get_startColor();
this.defColor01 = ((ParticleSystem.MinMaxGradient) ref startColor).get_color();
}
// Token: 0x0600196B RID: 6507 RVA: 0x0007996C File Offset: 0x00077B6C
private void LateUpdate()
{
ParticleSystem.MainModule main = this.particleSystem.main;
ParticleSystem.MinMaxGradient startColor = main.startColor;
Color color = startColor.color;
color.a = Util.Remap(this.light.intensity, this.lowerLightIntensity, this.upperLightIntensity, this.lowerParticleAlpha, this.upperParticleAlpha);
startColor.color = color;
main.startColor = startColor;
}
void Start()
{
spRender = GetComponent <SpriteRenderer>();
anim = GetComponent <Animator>();
body = GetComponent <Rigidbody2D>();
initialRunSpeed = runSpeed;
smokeColor = Smoke.colorOverLifetime;
oldGradient = smokeColor.color;
}
public ParticleSystem.MinMaxGradient GetData()
{
var mmg = new ParticleSystem.MinMaxGradient();
mmg.colorMax = colorMax;
mmg.colorMin = colorMin;
mmg.gradientMax = gradientMax;
mmg.gradientMin = gradientMin;
mmg.mode = mode;
return(mmg);
}
// Use this for initialization
void Start()
{
ParticleSystem.MinMaxGradient color = new ParticleSystem.MinMaxGradient();
color.mode = ParticleSystemGradientMode.Color;
color.color = new Color(Random.value, Random.value, Random.value, 1.0f);
foreach (var particle in particleSystem)
{
ParticleSystem.MainModule main = particle.main;
main.startColor = color;
}
}
public void ChangeColor(Color color)
{
var darkColor = StaticUtilities.ChangeColorBrightness(color, COLOR_CORRECTION_FACTOR);
var minMaxGradient = new ParticleSystem.MinMaxGradient(darkColor, color);
foreach (var mainModule in _mainModules)
{
var module = mainModule;
module.startColor = minMaxGradient;
}
}
public void Play(Color teamColor)
{
var gradient = new ParticleSystem.MinMaxGradient(SetColorGradient(teamColor))
{
mode = ParticleSystemGradientMode.RandomColor
};
var main = ConfettiSystem.main;
main.startColor = gradient;
ConfettiSystem.Play();
}
private JSONObject ParseTwoGradients(ParticleSystem.MinMaxGradient colorData)
{
JSONObject res = new JSONObject(JSONObject.Type.OBJECT);
JSONObject data = new JSONObject(JSONObject.Type.OBJECT);
res.AddField("type", "TwoGradients");
res.AddField("data", data);
data.AddField("max", GetGradientColor(colorData.gradientMax));
data.AddField("min", GetGradientColor(colorData.gradientMin));
return(res);
}
// Update is called once per frame
void Update()
{
if (Particules == null)
{
Setup();
}
if (startSize != oldStartSize)
{
ModuleMain.startSize = startSize;
oldStartSize = startSize;
}
if (RateOverTIme != oldRateOverTime)
{
ModuleEmission.rateOverTime = RateOverTIme;
oldRateOverTime = RateOverTIme;
}
if (Couleur1 != oldColor1 || Couleur2 != oldColor2)
{
ParticleSystem.MinMaxGradient minMaxGradient = new ParticleSystem.MinMaxGradient(Couleur1, Couleur2);
ModuleMain.startColor = minMaxGradient;
oldColor1 = Couleur1;
oldColor2 = Couleur2;
}
if (MeshShapeType != OldMeshShapeType)
{
OldMeshShapeType = MeshShapeType;
ModuleShape.meshShapeType = MeshShapeType;
}
if (oldWindZoneMultiplier != WindZoneMultiplier)
{
ModuleExternalForce.multiplier = WindZoneMultiplier;
oldWindZoneMultiplier = WindZoneMultiplier;
}
if (oldLimiteMax != LimitMax)
{
oldLimiteMax = LimitMax;
ModuleMain.maxParticles = LimitMax;
//Setup();
}
if (oldstartLifetime != startLifetime)
{
ParticleSystem.MinMaxCurve minMax = new ParticleSystem.MinMaxCurve(startLifetime.x, startLifetime.y);
ModuleMain.startLifetime = minMax;
oldstartLifetime = startLifetime;
}
}
// Start is called before the first frame update
void Start()
{
origGrad = psArray[0].colorOverLifetime.color;
colArray = new ParticleSystem.ColorOverLifetimeModule[psArray.Length];
for (int i = 0; i < colArray.Length; i++)
{
colArray[i] = psArray[i].colorOverLifetime;
colArray[i].enabled = true;
}
grad.SetKeys(new GradientColorKey[] { new GradientColorKey(color1, 0.0f), new GradientColorKey(color2, 1.0f) },
new GradientAlphaKey[] { new GradientAlphaKey(1.0f, 0.0f), new GradientAlphaKey(0.0f, 1.0f) });
}
public override void Update()
{
ParticleSystem.MainModule mainModule = DonoDaAcao.GetComponentInChildren <ParticleSystem> ().main;
ParticleSystem.MinMaxGradient gradient = new ParticleSystem.MinMaxGradient();
DonoDaAcao.GetComponentInChildren <Light>().color = cor;
DonoDaAcao.GetComponentInChildren <MeshRenderer>().material.color = cor;
gradient.color = cor;
mainModule.startColor = gradient;
Finalizado = true;
}
