// Use this for initialization
void Start ()
{
//Cache vars
myParticleSystem = GetComponent<ParticleSystem>();
particleArray = new ParticleSystem.Particle[GetComponent<ParticleSystem>().maxParticles];
particlesInitialPositions = new Vector3[GetComponent<ParticleSystem>().maxParticles];
}
public void shoot(bool _fire, ParticleSystem _projectile)
{
rotate(gattlingGunData.warmupDelay);
if (_fire)
{
if (gattlingGunData.warmupDelay < gattlingGunData.warmState)
{
gattlingGunData.warmupDelay++;
return;
}
gattlingGunData.currentShotDelay--;
if (gattlingGunData.currentShotDelay <= 0)
{
_projectile.Emit(1);
gattlingGunData.currentShotDelay = gattlingGunData.shotDelayMax;
}
}
else
{
if (gattlingGunData.warmupDelay > gattlingGunData.coldState)
{
gattlingGunData.warmupDelay--;
}
}
}
public Arc(ParticleSystem particleSystem, Vector3 position)
{
particleSystem.name = "Particle: " + ++ID + " clones";
GameObject parent = new GameObject("Arc clone (" + ID + ") ");
particleSystem = (ParticleSystem)Object.Instantiate(particleSystem, position, new Quaternion());
particleSystem.transform.parent = parent.transform;
arc = new ParticleSystem.Particle[resolution * resolution * resolution];
float increment = 1f / (resolution - 1);
int i = 0;
for (int x = 0; x < resolution; x++)
{
for (int z = 0; z < resolution; z++)
{
for (int y = 0; y < resolution; y++)
{
Vector3 p = new Vector3(x, y, z) * increment;
arc[i].position = p;
arc[i].color = new Color(p.x, p.y, p.z);
arc[i++].size = 0.1f;
}
}
}
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (s_Texts == null)
{
s_Texts = new Texts();
}
ModuleUI.GUIFloat(s_Texts.ratio, this.m_Ratio, new GUILayoutOption[0]);
ModuleUI.GUIMinMaxCurve(s_Texts.lifetime, this.m_Lifetime, new GUILayoutOption[0]);
ModuleUI.GUIFloat(s_Texts.minVertexDistance, this.m_MinVertexDistance, new GUILayoutOption[0]);
ModuleUI.GUIPopup(s_Texts.textureMode, this.m_TextureMode, s_Texts.textureModeOptions, new GUILayoutOption[0]);
ModuleUI.GUIToggle(s_Texts.worldSpace, this.m_WorldSpace, new GUILayoutOption[0]);
ModuleUI.GUIToggle(s_Texts.dieWithParticles, this.m_DieWithParticles, new GUILayoutOption[0]);
ModuleUI.GUIToggle(s_Texts.sizeAffectsWidth, this.m_SizeAffectsWidth, new GUILayoutOption[0]);
ModuleUI.GUIToggle(s_Texts.sizeAffectsLifetime, this.m_SizeAffectsLifetime, new GUILayoutOption[0]);
ModuleUI.GUIToggle(s_Texts.inheritParticleColor, this.m_InheritParticleColor, new GUILayoutOption[0]);
base.GUIMinMaxGradient(s_Texts.colorOverLifetime, this.m_ColorOverLifetime, new GUILayoutOption[0]);
ModuleUI.GUIMinMaxCurve(s_Texts.widthOverTrail, this.m_WidthOverTrail, new GUILayoutOption[0]);
base.GUIMinMaxGradient(s_Texts.colorOverTrail, this.m_ColorOverTrail, new GUILayoutOption[0]);
if (base.m_ParticleSystemUI.m_ParticleSystem.trails.enabled)
{
ParticleSystemRenderer component = base.m_ParticleSystemUI.m_ParticleSystem.GetComponent<ParticleSystemRenderer>();
if ((component != null) && (component.trailMaterial == null))
{
EditorGUILayout.HelpBox("Assign a Trail Material in the Renderer Module", MessageType.Warning, true);
}
}
}
void MoveParticle(ref ParticleSystem.Particle p)
{
var n = GetDFNoise(p.position + Vector3.up * _animationSpeed * Time.time);
p.velocity =
p.velocity * (1.0f - _damping) +
n * Time.fixedDeltaTime * _advection;
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (RotationByVelocityModuleUI.s_Texts == null)
RotationByVelocityModuleUI.s_Texts = new RotationByVelocityModuleUI.Texts();
EditorGUI.BeginChangeCheck();
bool flag = ModuleUI.GUIToggle(RotationByVelocityModuleUI.s_Texts.separateAxes, this.m_SeparateAxes);
if (EditorGUI.EndChangeCheck())
{
if (flag)
{
this.m_Z.RemoveCurveFromEditor();
}
else
{
this.m_X.RemoveCurveFromEditor();
this.m_Y.RemoveCurveFromEditor();
this.m_Z.RemoveCurveFromEditor();
}
}
if (flag)
{
this.m_Z.m_DisplayName = RotationByVelocityModuleUI.s_Texts.z;
this.GUITripleMinMaxCurve(GUIContent.none, RotationByVelocityModuleUI.s_Texts.x, this.m_X, RotationByVelocityModuleUI.s_Texts.y, this.m_Y, RotationByVelocityModuleUI.s_Texts.z, this.m_Z, (SerializedProperty) null);
}
else
{
this.m_Z.m_DisplayName = RotationByVelocityModuleUI.s_Texts.rotation;
ModuleUI.GUIMinMaxCurve(RotationByVelocityModuleUI.s_Texts.rotation, this.m_Z);
}
ModuleUI.GUIMinMaxRange(RotationByVelocityModuleUI.s_Texts.velocityRange, this.m_Range);
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (s_Texts == null)
{
s_Texts = new Texts();
}
EditorGUI.BeginChangeCheck();
bool flag = ModuleUI.GUIToggle(s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
if (flag)
{
this.m_X.RemoveCurveFromEditor();
}
else
{
this.m_X.RemoveCurveFromEditor();
this.m_Y.RemoveCurveFromEditor();
this.m_Z.RemoveCurveFromEditor();
}
}
MinMaxCurveState state = this.m_X.state;
this.m_Y.state = state;
this.m_Z.state = state;
if (flag)
{
this.m_X.m_DisplayName = s_Texts.x;
base.GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, this.m_X, s_Texts.y, this.m_Y, s_Texts.z, this.m_Z, null, new GUILayoutOption[0]);
}
else
{
this.m_X.m_DisplayName = s_Texts.size;
ModuleUI.GUIMinMaxCurve(s_Texts.size, this.m_X, new GUILayoutOption[0]);
}
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (InitialModuleUI.s_Texts == null)
InitialModuleUI.s_Texts = new InitialModuleUI.Texts();
double num1 = (double) ModuleUI.GUIFloat(InitialModuleUI.s_Texts.duration, this.m_LengthInSec, "f2");
this.m_LengthInSec.floatValue = Mathf.Min(100000f, Mathf.Max(0.0f, this.m_LengthInSec.floatValue));
bool boolValue1 = this.m_Looping.boolValue;
ModuleUI.GUIToggle(InitialModuleUI.s_Texts.looping, this.m_Looping);
if (this.m_Looping.boolValue && !boolValue1 && (double) s.time >= (double) this.m_LengthInSec.floatValue)
s.time = 0.0f;
EditorGUI.BeginDisabledGroup(!this.m_Looping.boolValue);
ModuleUI.GUIToggle(InitialModuleUI.s_Texts.prewarm, this.m_Prewarm);
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(this.m_Prewarm.boolValue && this.m_Looping.boolValue);
ModuleUI.GUIMinMaxCurve(InitialModuleUI.s_Texts.startDelay, this.m_StartDelay);
EditorGUI.EndDisabledGroup();
ModuleUI.GUIMinMaxCurve(InitialModuleUI.s_Texts.lifetime, this.m_LifeTime);
ModuleUI.GUIMinMaxCurve(InitialModuleUI.s_Texts.speed, this.m_Speed);
ModuleUI.GUIMinMaxCurve(InitialModuleUI.s_Texts.size, this.m_Size);
EditorGUI.BeginChangeCheck();
bool flag = ModuleUI.GUIToggle(InitialModuleUI.s_Texts.rotation3D, this.m_Rotation3D);
if (EditorGUI.EndChangeCheck())
{
if (flag)
{
this.m_RotationZ.RemoveCurveFromEditor();
}
else
{
this.m_RotationX.RemoveCurveFromEditor();
this.m_RotationY.RemoveCurveFromEditor();
this.m_RotationZ.RemoveCurveFromEditor();
}
}
if (flag)
{
this.m_RotationZ.m_DisplayName = InitialModuleUI.s_Texts.z;
this.GUITripleMinMaxCurve(GUIContent.none, InitialModuleUI.s_Texts.x, this.m_RotationX, InitialModuleUI.s_Texts.y, this.m_RotationY, InitialModuleUI.s_Texts.z, this.m_RotationZ, (SerializedProperty) null);
}
else
{
this.m_RotationZ.m_DisplayName = InitialModuleUI.s_Texts.rotation;
ModuleUI.GUIMinMaxCurve(InitialModuleUI.s_Texts.rotation, this.m_RotationZ);
}
double num2 = (double) ModuleUI.GUIFloat(InitialModuleUI.s_Texts.randomizeRotationDirection, this.m_RandomizeRotationDirection);
this.GUIMinMaxGradient(InitialModuleUI.s_Texts.color, this.m_Color);
double num3 = (double) ModuleUI.GUIFloat(InitialModuleUI.s_Texts.gravity, this.m_GravityModifier);
ModuleUI.GUIBoolAsPopup(InitialModuleUI.s_Texts.simulationSpace, this.m_SimulationSpace, InitialModuleUI.s_Texts.simulationSpaces);
ModuleUI.GUIPopup(InitialModuleUI.s_Texts.scalingMode, this.m_ScalingMode, new string[3]
{
"Hierarchy",
"Local",
"Shape"
});
bool boolValue2 = this.m_PlayOnAwake.boolValue;
bool newPlayOnAwake = ModuleUI.GUIToggle(InitialModuleUI.s_Texts.autoplay, this.m_PlayOnAwake);
if (boolValue2 != newPlayOnAwake)
this.m_ParticleSystemUI.m_ParticleEffectUI.PlayOnAwakeChanged(newPlayOnAwake);
ModuleUI.GUIInt(InitialModuleUI.s_Texts.maxParticles, this.m_MaxNumParticles);
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (s_Texts == null)
{
s_Texts = new Texts();
}
ModuleUI.GUIIntDraggableX2(s_Texts.tiles, s_Texts.tilesX, this.m_TilesX, s_Texts.tilesY, this.m_TilesY);
int num = ModuleUI.GUIPopup(s_Texts.animation, this.m_AnimationType, s_Texts.types);
if (num == 1)
{
ModuleUI.GUIToggle(s_Texts.randomRow, this.m_RandomRow);
if (!this.m_RandomRow.boolValue)
{
ModuleUI.GUIInt(s_Texts.row, this.m_RowIndex);
}
}
if (num == 1)
{
this.m_FrameOverTime.m_RemapValue = this.m_TilesX.intValue;
}
if (num == 0)
{
this.m_FrameOverTime.m_RemapValue = this.m_TilesX.intValue * this.m_TilesY.intValue;
}
ModuleUI.GUIMinMaxCurve(s_Texts.frameOverTime, this.m_FrameOverTime);
ModuleUI.GUIFloat(s_Texts.cycles, this.m_Cycles);
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (ColorByVelocityModuleUI.s_Texts == null)
ColorByVelocityModuleUI.s_Texts = new ColorByVelocityModuleUI.Texts();
this.GUIMinMaxGradient(ColorByVelocityModuleUI.s_Texts.color, this.m_Gradient);
ModuleUI.GUIMinMaxRange(ColorByVelocityModuleUI.s_Texts.velocityRange, this.m_Range);
}
public override void Awake()
{
base.Awake();
beamtf = tf.FindChild("Beam").transform;
ps = tf.FindChild("Particle System").GetComponent<ParticleSystem>();
capsule = gameObject.GetComponent<CapsuleCollider>();
}
private void Awake()
{
ParticleSystem = GetComponent<ParticleSystem>();
lastTime = Time.realtimeSinceStartup;
if(!ParticleSystem.playOnAwake)
ParticleSystem.time = ParticleSystem.duration;
}
public void Setup() {
this.particleSystem = this.GetComponent<ParticleSystem>();
if (this.particleSystem != null) {
//var alpha = this.lastAlpha;
//this.SetStartAlpha(1f);
var obj = new UnityEditor.SerializedObject(this.particleSystem);
var module = obj.FindProperty("InitialModule").FindPropertyRelative("startColor");
var minColor = module.FindPropertyRelative("minColor");
var maxColor = module.FindPropertyRelative("maxColor");
var minGradient = module.FindPropertyRelative("minGradient");
var maxGradient = module.FindPropertyRelative("maxGradient");
var minMaxState = module.FindPropertyRelative("minMaxState");
this.startColor.minColor = minColor.colorValue;
this.startColor.maxColor = maxColor.colorValue;
this.startColor.minGradient = minGradient.GetGradient();
this.startColor.maxGradient = maxGradient.GetGradient();
this.startColor.minMaxState = (MinMaxState)minMaxState.intValue;
//if (alpha >= 0f) this.SetStartAlpha(alpha);
}
}
public ParticleEffectInstanceManager(EffectManager effect_manager, Mesh character_mesh, bool letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
{
m_particle_emitter = particle_emitter;
m_particle_system = particle_system;
m_letter_mesh = character_mesh;
m_letter_flipped = letter_flipped;
m_follow_mesh = effect_setup.m_follow_mesh;
m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
m_position_offset = effect_setup.m_position_offset.GetValue(progression_vars, animate_per);
m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(progression_vars, animate_per));
m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
m_effect_manager_handle = effect_manager;
m_active = false;
if(m_particle_emitter != null)
{
m_transform = m_particle_emitter.transform;
m_particle_emitter.emit = true;
m_particle_emitter.enabled = false;
}
else if(m_particle_system != null)
{
m_transform = m_particle_system.transform;
m_particle_system.playOnAwake = false;
m_particle_system.Play();
#if !UNITY_3_5 && UNITY_EDITOR
p_system_timer = 0;
#endif
}
}
/*
[Serializable]
internal class ExplosionDesc
{
public ChuzzleColor color;
public Color[] possibleColors;
}
*/
void Awake()
{
if (!ps)
{
ps = GetComponent<ParticleSystem>();
}
}
internal static ParticleSystem[] GetParticleSystems(ParticleSystem root)
{
List<ParticleSystem> particleSystems = new List<ParticleSystem>();
particleSystems.Add(root);
ParticleEffectUI.GetDirectParticleSystemChildrenRecursive(root.transform, particleSystems);
return particleSystems.ToArray();
}
public override void OnInspectorGUI(ParticleSystem s)
{
if (VelocityModuleUI.s_Texts == null)
VelocityModuleUI.s_Texts = new VelocityModuleUI.Texts();
this.GUITripleMinMaxCurve(GUIContent.none, VelocityModuleUI.s_Texts.x, this.m_X, VelocityModuleUI.s_Texts.y, this.m_Y, VelocityModuleUI.s_Texts.z, this.m_Z, (SerializedProperty) null);
ModuleUI.GUIBoolAsPopup(VelocityModuleUI.s_Texts.space, this.m_InWorldSpace, VelocityModuleUI.s_Texts.spaces);
}
public KiPunch(ParticleSystem particleSystem)
{
if (particleSystem == null)
throw new ArgumentNullException("Particle system cannot be null");
this.particleSystem = particleSystem;
}
/// <summary>Plays the particle effect, but replaces the material on the particle with the one specified (mat).</summary>
public void PlayEffect(ParticleSystem effect, Vector3 pos, Quaternion rot, int parentId, Material mat)
{
if (effect == null) return;
// Check if we're at the maximum active particle limit. If so, ignore the request to play the particle effect.
if (IsMaxActiveParticles) return;
// Check if we've reached the max particle limit per destructible object for this object already.
int parentParticleCount = ActiveParticles.Count(x => x.ParentId == parentId);
if (parentParticleCount > maxPerDestructible) return;
// Instantiate and add to the ActiveParticles counter
GameObject spawn = ObjectPool.Instance.Spawn(effect.gameObject, pos, rot);
if (spawn == null || spawn.GetComponent<ParticleSystem>() == null) return;
ActiveParticle aParticle = new ActiveParticle() { GameObject = spawn, InstantiatedTime = Time.time, ParentId = parentId };
Array.Resize(ref activeParticles, activeParticles.Length + 1);
ActiveParticles[activeParticles.Length - 1] = aParticle;
// Replace the materials on the particle effect with the one passed in.
if (mat != null && spawn.GetComponent<ParticleSystem>() != null)
{
foreach (ParticleSystemRenderer ps in spawn.GetComponentsInChildren<ParticleSystemRenderer>())
{
if (ps.renderMode == ParticleSystemRenderMode.Mesh)
ps.sharedMaterial = mat;
}
}
}
private void Start()
{
car = transform.parent.GetComponent<CarController>();
wheelCollider = GetComponent<Collider>() as WheelCollider;
if (wheelModel != null)
{
originalWheelModelPosition = wheelModel.localPosition;
transform.position = wheelModel.position; // - wheelCollider.suspensionDistance*0.5f*transform.up;
}
// store initial starting values of wheelCollider
sidewaysFriction = wheelCollider.sidewaysFriction;
forwardFriction = wheelCollider.forwardFriction;
sidewaysStiffness = wheelCollider.sidewaysFriction.stiffness;
forwardStiffness = wheelCollider.forwardFriction.stiffness;
// nominal max rpm at Car's top speed (can be more if Car is rolling downhill!)
MaxRpm = (car.MaxSpeed/(Mathf.PI*wheelCollider.radius*2))*60;
// get a reference to the particle system for the tire smoke
skidSmokeSystem = car.GetComponentInChildren<ParticleSystem>();
rb = wheelCollider.attachedRigidbody;
if (skidTrailsDetachedParent == null)
{
skidTrailsDetachedParent = new GameObject("Skid Trails - Detached").transform;
}
}
protected override void OnResetPlugin()
{
fluidB = null;
fluidC = null;
fluidD = null;
distanceMultiplier = 0.5f;
}
public override void Init()
{
ParticleSystem = gameObject.GetComponent<ParticleSystem>();
arc = ParticleSystem.shape.arc;
Reloaded = false;
ReloadStarted = false;
}
public override void OnInspectorGUI(ParticleSystem s)
{
EditorGUI.BeginChangeCheck();
bool flag = ModuleUI.GUIToggle(ClampVelocityModuleUI.s_Texts.separateAxis, this.m_SeparateAxis);
if (EditorGUI.EndChangeCheck())
{
if (flag)
{
this.m_Magnitude.RemoveCurveFromEditor();
}
else
{
this.m_X.RemoveCurveFromEditor();
this.m_Y.RemoveCurveFromEditor();
this.m_Z.RemoveCurveFromEditor();
}
}
if (flag)
{
base.GUITripleMinMaxCurve(GUIContent.none, ClampVelocityModuleUI.s_Texts.x, this.m_X, ClampVelocityModuleUI.s_Texts.y, this.m_Y, ClampVelocityModuleUI.s_Texts.z, this.m_Z, null);
ModuleUI.GUIBoolAsPopup(ClampVelocityModuleUI.s_Texts.space, this.m_InWorldSpace, ClampVelocityModuleUI.s_Texts.spaces);
}
else
{
ModuleUI.GUIMinMaxCurve(ClampVelocityModuleUI.s_Texts.magnitude, this.m_Magnitude);
}
ModuleUI.GUIFloat(ClampVelocityModuleUI.s_Texts.dampen, this.m_Dampen);
}
public override void OnEnter()
{
ps = Fsm.GetOwnerDefaultTarget(gameObject).GetComponent<ParticleSystem>();
if (delay.Value <= 0)
{
if (clear.Value) {
stopWithClear.Value = false;
ps.Clear();
}
else {
ps.Stop();
ps.Clear();
}
if(finishEvent != null) Fsm.Event(finishEvent);{
Finish();
return;
}
}
startTime = Time.realtimeSinceStartup;
timer = 0f;
}
void On_CosmosReady()
{
isReady = true;
cacheTransform = Cosmos.instance.SpaceCamera.transform;
// Create particle system
gameObject.AddComponent<ParticleSystem>();
cacheCosmosParticle = GetComponent<ParticleSystem>();
cacheCosmosParticle.playOnAwake = false;
cacheCosmosParticle.enableEmission = false;
cacheCosmosParticle.simulationSpace = ParticleSystemSimulationSpace.Local;
cacheCosmosParticle.emissionRate = 0;
cacheCosmosParticle.startSpeed = 0;
cacheCosmosParticle.startLifetime = Mathf.Infinity;
cacheCosmosParticle.startRotation = Random.Range(-Mathf.PI,Mathf.PI);
cacheCosmosParticle.GetComponent<Renderer>().material = mat;
cacheCosmosParticle.GetComponent<Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
cacheCosmosParticle.GetComponent<Renderer>().receiveShadows = false;
// Pre Spawn
for (int i=0; i < maxParticle; i ++) {
Vector3 drift = Vector3.zero;
if (enableDrift){
drift =new Vector3( Random.Range(-1f,1f),Random.Range(-1f,1f),0) * driftSpeed;
}
cacheCosmosParticle.Emit( cacheTransform.position + (UnityEngine.Random.insideUnitSphere * 200), drift, Random.Range(minSize, maxSize ) , Mathf.Infinity, color.Evaluate( Random.Range(0f,1f)));
}
}
private void Awake()
{
_explosionParticles = Instantiate(ExplosionPrefab).GetComponent<ParticleSystem>();
_explosionAudio = _explosionParticles.GetComponent<AudioSource>();
_explosionParticles.gameObject.SetActive(false);
}
public static int GetParticlesInLargetArray(this ParticleSystem shuriken, ref ParticleSystem.Particle[] particles)
{
if (particles == null || particles.Length < shuriken.particleCount) {
particles = new ParticleSystem.Particle[shuriken.particleCount * 2];
}
return shuriken.GetParticles(particles);
}
public void Setup() {
this.particleSystems = this.GetComponentsInChildren<ParticleSystem>(true);
this.mainParticleSystem = (this.particleSystems.Length > 0) ? this.particleSystems[0] : null;
this.count = this.particleSystems.Length;
this.ValidateCanvasGroup();
this.particleSystemItems = new ParticleSystemCachedItem[this.particleSystems.Length];
for (int i = 0; i < this.particleSystems.Length; ++i) {
var ps = this.particleSystems[i];
var item = ps.gameObject.GetComponent<ParticleSystemCachedItem>();
if (item == null) item = ps.gameObject.AddComponent<ParticleSystemCachedItem>();
item.Setup();
this.particleSystemItems[i] = item;
}
var index = System.Array.IndexOf(this.particleSystems, this.mainParticleSystem);
if (index >= 0) this.mainParticleSystemItem = this.particleSystemItems[index];
}
// Use this for initialization
void Start () {
particles = GetComponent<ParticleSystem>();
circleColider = GetComponent <CircleCollider2D>();
animator = GetComponent<Animator>();
timeToRespawn = timeToRespawn + Random.Range ( timeToRespawn * 0.96f , timeToRespawn * 1.04f);
}
protected override void Awake()
{
base.Awake();
waterSpray = transform.FindChild("WaterSpray").gameObject;
particles = waterSpray.GetComponent<ParticleSystem>();
particles.Stop();
}
static public int GetSafeTriggerParticlesSize(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystemTriggerEventType a2;
checkEnum(l, 2, out a2);
var ret = self.GetSafeTriggerParticlesSize(a2);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int SetCustomParticleData(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Collections.Generic.List <UnityEngine.Vector4> a1;
checkType(l, 2, out a1);
UnityEngine.ParticleSystemCustomData a2;
checkEnum(l, 3, out a2);
self.SetCustomParticleData(a1, a2);
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static void ParticleSystem_randomSeed(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.randomSeed;
JSApi.setUInt32((int)JSApi.SetType.Rval, (System.UInt32)(result));
}
else
{
System.UInt32 arg0 = (System.UInt32)JSApi.getUInt32((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.randomSeed = arg0;
}
}
static void ParticleSystem_playOnAwake(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.playOnAwake;
JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(result));
}
else
{
System.Boolean arg0 = (System.Boolean)JSApi.getBooleanS((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.playOnAwake = arg0;
}
}
static public int SetParticles(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystem.Particle[] a1;
checkType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
self.SetParticles(a1, a2);
return(0);
}
catch (Exception e) {
return(error(l, e));
}
}
static void ParticleSystem_simulationSpace(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.simulationSpace;
JSApi.setEnum((int)JSApi.SetType.Rval, (int)result);
}
else
{
UnityEngine.ParticleSystemSimulationSpace arg0 = (UnityEngine.ParticleSystemSimulationSpace)JSApi.getEnum((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.simulationSpace = arg0;
}
}
static public int GetParticles(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystem.Particle[] a1;
checkArray(l, 2, out a1);
var ret = self.GetParticles(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int GetParticles(IntPtr l)
{
try{
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystem.Particle[] a1;
checkType(l, 2, out a1);
System.Int32 ret = self.GetParticles(a1);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
static void ParticleSystem_gravityModifier(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.gravityModifier;
JSApi.setSingle((int)JSApi.SetType.Rval, (System.Single)(result));
}
else
{
System.Single arg0 = (System.Single)JSApi.getSingle((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.gravityModifier = arg0;
}
}
static void ParticleSystem_startRotation3D(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.startRotation3D;
JSApi.setVector3S((int)JSApi.SetType.Rval, result);
}
else
{
UnityEngine.Vector3 arg0 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.startRotation3D = arg0;
}
}
static public int IsAlive__Boolean(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Boolean a1;
checkType(l, 2, out a1);
var ret = self.IsAlive(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static void ParticleSystem_playbackSpeed(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.playbackSpeed;
JSApi.setSingle((int)JSApi.SetType.Rval, (System.Single)(result));
}
else
{
System.Single arg0 = (System.Single)JSApi.getSingle((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.playbackSpeed = arg0;
}
}
static void ParticleSystem_startColor(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
var result = _this.startColor;
JSMgr.datax.setObject((int)JSApi.SetType.Rval, result);
}
else
{
UnityEngine.Color arg0 = (UnityEngine.Color)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem _this = (UnityEngine.ParticleSystem)vc.csObj;
_this.startColor = arg0;
}
}
static public int TriggerSubEmitter__Int32__List_1_Particle(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
System.Collections.Generic.List <UnityEngine.ParticleSystem.Particle> a2;
checkType(l, 3, out a2);
self.TriggerSubEmitter(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int SetTriggerParticles__ParticleSystem__ParticleSystemTriggerEventType__List_1_Particle(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystemTriggerEventType a2;
checkEnum(l, 2, out a2);
System.Collections.Generic.List <UnityEngine.ParticleSystem.Particle> a3;
checkType(l, 3, out a3);
self.SetTriggerParticles(a2, a3);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public static void ClusterSimulate(this UnityEngine.ParticleSystem ps, float t)
{
var observer = validateCheck(ps);
if (observer == null)
{
return;
}
ps.Simulate(t);
FduParticleSystemOP op = new FduParticleSystemOP();
op.operation = FduParticleSystemOP.Operation.simulate;
op.paras = new object[1];
op.paras[0] = t;
observer.addOperation(op);
}
public static void ClusterSetRandomSeed(this UnityEngine.ParticleSystem ps, uint randomSeed)
{
var observer = validateCheck(ps);
if (observer == null)
{
return;
}
ps.randomSeed = randomSeed;
FduParticleSystemOP op = new FduParticleSystemOP();
op.operation = FduParticleSystemOP.Operation.setRandomSeed;
op.paras = new object[1];
op.paras[0] = (int)randomSeed;
observer.addOperation(op);
}
public static void ClusterEmit(this UnityEngine.ParticleSystem ps, int count)
{
var observer = validateCheck(ps);
if (observer == null)
{
return;
}
ps.Emit(count);
FduParticleSystemOP op = new FduParticleSystemOP();
op.operation = FduParticleSystemOP.Operation.emit;
op.paras = new object[1];
op.paras[0] = count;
observer.addOperation(op);
}
public static void ClusterClear(this UnityEngine.ParticleSystem ps, bool withChildren)
{
var observer = validateCheck(ps);
if (observer == null)
{
return;
}
ps.Clear(withChildren);
FduParticleSystemOP op = new FduParticleSystemOP();
op.operation = FduParticleSystemOP.Operation.clear;
op.paras = new object[1];
op.paras[0] = withChildren;
observer.addOperation(op);
}
static void SubEmittersModule_collision1(JSVCall vc)
{
if (vc.bGet)
{
UnityEngine.ParticleSystem.SubEmittersModule _this = (UnityEngine.ParticleSystem.SubEmittersModule)vc.csObj;
var result = _this.collision1;
JSMgr.datax.setObject((int)JSApi.SetType.Rval, result);
}
else
{
UnityEngine.ParticleSystem arg0 = (UnityEngine.ParticleSystem)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
UnityEngine.ParticleSystem.SubEmittersModule _this = (UnityEngine.ParticleSystem.SubEmittersModule)vc.csObj;
_this.collision1 = arg0;
JSMgr.changeJSObj(vc.jsObjID, _this);
}
}
static public int Emit__EmitParams__Int32(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystem.EmitParams a1;
checkValueType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
self.Emit(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int Stop__Boolean__ParticleSystemStopBehavior(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Boolean a1;
checkType(l, 2, out a1);
UnityEngine.ParticleSystemStopBehavior a2;
checkEnum(l, 3, out a2);
self.Stop(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int Simulate__Single__Boolean(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Single a1;
checkType(l, 2, out a1);
System.Boolean a2;
checkType(l, 3, out a2);
self.Simulate(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
private void AddEmitterSource(ref UnityEngine.ParticleSystem uParticleSystem, Entity eParticleSystem)
{
if (!uParticleSystem.shape.enabled)
{
return;
}
switch (uParticleSystem.shape.shapeType)
{
case ParticleSystemShapeType.Cone:
DstEntityManager.AddComponentData(eParticleSystem, new EmitterConeSource
{
Radius = uParticleSystem.shape.radius,
Angle = uParticleSystem.shape.angle
});
break;
case ParticleSystemShapeType.Circle:
DstEntityManager.AddComponentData(eParticleSystem, new EmitterCircleSource
{
Radius = uParticleSystem.shape.radius
});
break;
case ParticleSystemShapeType.Rectangle:
DstEntityManager.AddComponentData(eParticleSystem, new EmitterRectangleSource());
break;
case ParticleSystemShapeType.Sphere:
DstEntityManager.AddComponentData(eParticleSystem, new EmitterSphereSource
{
Radius = uParticleSystem.shape.radius
});
break;
case ParticleSystemShapeType.Hemisphere:
DstEntityManager.AddComponentData(eParticleSystem, new EmitterHemisphereSource
{
Radius = uParticleSystem.shape.radius
});
break;
default:
UnityEngine.Debug.LogWarning("ParticleSystemShapeType " + nameof(uParticleSystem.shape.shapeType) + " not supported.");
break;
}
}
static public int Emit(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (matchType(l, argc, 2, typeof(UnityEngine.ParticleSystem.Particle)))
{
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.ParticleSystem.Particle a1;
checkValueType(l, 2, out a1);
self.Emit(a1);
pushValue(l, true);
return(1);
}
else if (matchType(l, argc, 2, typeof(int)))
{
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
self.Emit(a1);
pushValue(l, true);
return(1);
}
else if (argc == 6)
{
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.Vector3 a1;
checkType(l, 2, out a1);
UnityEngine.Vector3 a2;
checkType(l, 3, out a2);
System.Single a3;
checkType(l, 4, out a3);
System.Single a4;
checkType(l, 5, out a4);
UnityEngine.Color32 a5;
checkValueType(l, 6, out a5);
self.Emit(a1, a2, a3, a4, a5);
pushValue(l, true);
return(1);
}
pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function to call");
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int GetCollisionEvents(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
UnityEngine.GameObject a1;
checkType(l, 2, out a1);
UnityEngine.ParticleSystem.CollisionEvent[] a2;
checkType(l, 3, out a2);
var ret = self.GetCollisionEvents(a1, a2);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
static public int TriggerSubEmitter__Int32__R_Particle(IntPtr l)
{
try {
UnityEngine.ParticleSystem self = (UnityEngine.ParticleSystem)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.ParticleSystem.Particle a2;
checkValueType(l, 3, out a2);
self.TriggerSubEmitter(a1, ref a2);
pushValue(l, true);
pushValue(l, a2);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
private static void FillEffector(UnityEngine.ParticleSystem ups, ParticleSystem ps)
{
foreach (var effect in ps.Effectors)
{
try
{
effect.ApplyToUnityParticleSystem(ups, ps);
}
catch (NotImplementedException ex)
{
UnityEngine.Debug.LogErrorFormat("{0},{1}", ex.Message, effect.GetType().ToString());
}
finally
{
}
}
}
public static void ClusterStop(this UnityEngine.ParticleSystem ps, bool withChildren, ParticleSystemStopBehavior stopBehavior)
{
var observer = validateCheck(ps);
if (observer == null)
{
return;
}
ps.Stop(withChildren, stopBehavior);
FduParticleSystemOP op = new FduParticleSystemOP();
op.operation = FduParticleSystemOP.Operation.stop;
op.paras = new object[2];
op.paras[0] = withChildren;
op.paras[1] = (byte)stopBehavior;
observer.addOperation(op);
}
static int _m_Stop(RealStatePtr L)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
UnityEngine.ParticleSystem __cl_gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1);
int __gen_param_count = LuaAPI.lua_gettop(L);
try {
if (__gen_param_count == 1)
{
__cl_gen_to_be_invoked.Stop( );
return(0);
}
if (__gen_param_count == 2 && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2))
{
bool withChildren = LuaAPI.lua_toboolean(L, 2);
__cl_gen_to_be_invoked.Stop(withChildren);
return(0);
}
if (__gen_param_count == 3 && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2) && translator.Assignable <UnityEngine.ParticleSystemStopBehavior>(L, 3))
{
bool withChildren = LuaAPI.lua_toboolean(L, 2);
UnityEngine.ParticleSystemStopBehavior stopBehavior; translator.Get(L, 3, out stopBehavior);
__cl_gen_to_be_invoked.Stop(withChildren, stopBehavior);
return(0);
}
} catch (System.Exception __gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
}
return(LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Stop!"));
}