static int _m_GetBurst(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked; translator.Get(L, 1, out gen_to_be_invoked);
{
int _index = LuaAPI.xlua_tointeger(L, 2);
UnityEngine.ParticleSystem.Burst gen_ret = gen_to_be_invoked.GetBurst(_index);
translator.Push(L, gen_ret);
translator.Update(L, 1, gen_to_be_invoked);
return(1);
}
} catch (System.Exception gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
}
}
public override void ReadFrom(object obj)
{
base.ReadFrom(obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.EmissionModule o = (UnityEngine.ParticleSystem.EmissionModule)obj;
enabled = o.enabled;
#if !RT_PE_MAINTANANCE
rateOverTime = Read(rateOverTime, o.rateOverTime);
rateOverDistance = Read(rateOverDistance, o.rateOverDistance);
UnityEngine.ParticleSystem.Burst[] psBursts = new UnityEngine.ParticleSystem.Burst[o.burstCount];
bursts = new PersistentBurst[o.burstCount];
o.GetBursts(psBursts);
for (int i = 0; i < bursts.Length; ++i)
{
PersistentBurst burst = new PersistentBurst();
burst.ReadFrom(bursts[i]);
bursts[i] = burst;
}
#endif
rateOverTimeMultiplier = o.rateOverTimeMultiplier;
rateOverDistanceMultiplier = o.rateOverDistanceMultiplier;
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var ps = value as ParticleSystem;
#if UNITY_5_5_OR_NEWER
ps.useAutoRandomSeed = data.useAutoRandomSeed;
if (ps.useAutoRandomSeed == false)
{
ps.randomSeed = data.randomSeed;
}
#endif
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.main, ps.main);
{
UABUtils.CopyToParticleSystemModule(data.emission.data, ps.emission);
var bursts = new UnityEngine.ParticleSystem.Burst[data.emission.bursts.Length];
for (int i = 0; i < data.emission.bursts.Length; ++i)
{
bursts[i] = UABUtils.CopyToParticleSystemModule(data.emission.bursts[i], bursts[i]);
}
ps.emission.SetBursts(bursts, data.emission.bursts.Length);
}
#endif
UABUtils.CopyToParticleSystemModule(data.shape, ps.shape);
UABUtils.CopyToParticleSystemModule(data.velocityOverLifetime, ps.velocityOverLifetime);
UABUtils.CopyToParticleSystemModule(data.limitVelocityOverLifetime, ps.limitVelocityOverLifetime);
UABUtils.CopyToParticleSystemModule(data.inheritVelocity, ps.inheritVelocity);
UABUtils.CopyToParticleSystemModule(data.forceOverLifetime, ps.forceOverLifetime);
UABUtils.CopyToParticleSystemModule(data.colorOverLifetime, ps.colorOverLifetime);
UABUtils.CopyToParticleSystemModule(data.sizeOverLifetime, ps.sizeOverLifetime);
UABUtils.CopyToParticleSystemModule(data.sizeBySpeed, ps.sizeBySpeed);
UABUtils.CopyToParticleSystemModule(data.rotationOverLifetime, ps.rotationOverLifetime);
UABUtils.CopyToParticleSystemModule(data.rotationBySpeed, ps.rotationBySpeed);
UABUtils.CopyToParticleSystemModule(data.externalForces, ps.externalForces);
UABUtils.CopyToParticleSystemModule(data.rotationBySpeed, ps.rotationBySpeed);
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.noise, ps.noise);
#endif
UABUtils.CopyToParticleSystemModule(data.collision, ps.collision);
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.trigger, ps.trigger);
{
UABUtils.CopyToParticleSystemModule(data.subEmitters.data, ps.subEmitters);
for (int i = 0; i < data.subEmitters.subEmitters.Length; ++i)
{
ps.subEmitters.AddSubEmitter(data.subEmitters.subEmitters[i], data.subEmitters.types[i], data.subEmitters.properties[i]);
}
}
//UABUtils.CopyToParticleSystemModule(data.textureSheetAnimation, ps.textureSheetAnimation);
UABUtils.CopyToParticleSystemModule(data.lights, ps.lights);
UABUtils.CopyToParticleSystemModule(data.trails, ps.trails);
#endif
}
static int __CreateInstance(RealStatePtr L)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
try {
if (LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3))
{
float _time = (float)LuaAPI.lua_tonumber(L, 2);
short _count = (short)LuaAPI.xlua_tointeger(L, 3);
UnityEngine.ParticleSystem.Burst __cl_gen_ret = new UnityEngine.ParticleSystem.Burst(_time, _count);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4))
{
float _time = (float)LuaAPI.lua_tonumber(L, 2);
short _minCount = (short)LuaAPI.xlua_tointeger(L, 3);
short _maxCount = (short)LuaAPI.xlua_tointeger(L, 4);
UnityEngine.ParticleSystem.Burst __cl_gen_ret = new UnityEngine.ParticleSystem.Burst(_time, _minCount, _maxCount);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6))
{
float _time = (float)LuaAPI.lua_tonumber(L, 2);
short _minCount = (short)LuaAPI.xlua_tointeger(L, 3);
short _maxCount = (short)LuaAPI.xlua_tointeger(L, 4);
int _cycleCount = LuaAPI.xlua_tointeger(L, 5);
float _repeatInterval = (float)LuaAPI.lua_tonumber(L, 6);
UnityEngine.ParticleSystem.Burst __cl_gen_ret = new UnityEngine.ParticleSystem.Burst(_time, _minCount, _maxCount, _cycleCount, _repeatInterval);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 1)
{
translator.Push(L, default(UnityEngine.ParticleSystem.Burst));
return(1);
}
}
catch (System.Exception __gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
}
return(LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Burst constructor!"));
}
private void WriteBurst(UnityEngine.ParticleSystem.Burst data)
{
CommaNL();
Indent(); jsonWriter.Write("{\n");
IndentIn();
CommaNL();
Indent(); jsonWriter.Write("\"minCount\":" + data.minCount);
CommaNL();
Indent(); jsonWriter.Write("\"maxCount\":" + data.maxCount);
CommaNL();
Indent(); jsonWriter.Write("\"time\":" + data.time);
IndentOut();
Indent(); jsonWriter.Write("}\n");
}
public override void ReadFrom(object obj)
{
base.ReadFrom(obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.Burst o = (UnityEngine.ParticleSystem.Burst)obj;
time = o.time;
minCount = o.minCount;
maxCount = o.maxCount;
cycleCount = o.cycleCount;
repeatInterval = o.repeatInterval;
}
public override object WriteTo(object obj, System.Collections.Generic.Dictionary <long, UnityEngine.Object> objects)
{
obj = base.WriteTo(obj, objects);
if (obj == null)
{
return(null);
}
UnityEngine.ParticleSystem.Burst o = (UnityEngine.ParticleSystem.Burst)obj;
o.time = time;
o.minCount = minCount;
o.maxCount = maxCount;
o.cycleCount = cycleCount;
o.repeatInterval = repeatInterval;
return(o);
}
private void WriteEmission()
{
var dataE = particleSys.emission;
if (!dataE.enabled)
{
return;
}
CommaNL();
Indent(); jsonWriter.Write("\"emission\":{\n");
IndentIn();
var bursts = new UnityEngine.ParticleSystem.Burst[dataE.burstCount];
dataE.GetBursts(bursts);
CommaNL();
Indent(); jsonWriter.Write("\"rateOverDistanceMultiplier\":" + dataE.rateOverDistanceMultiplier);
CommaNL();
Indent(); jsonWriter.Write("\"rateOverTimeMultiplier\":" + dataE.rateOverTimeMultiplier);
WriteMinMaxCurve(dataE.rateOverDistance, "rateOverDistance");
WriteMinMaxCurve(dataE.rateOverTime, "rateOverTime");
CommaNL();
Indent(); jsonWriter.Write("\"bursts\":[\n");
IndentIn();
if (bursts != null)
{
foreach (var v in bursts)
{
WriteBurst(v);
}
}
IndentOut();
Indent(); jsonWriter.Write("]\n");
/// bursts: [{time: 0.1, min: 3, max: 3}];
//scope.WriteKeyValue("burstCount", data.burstCount);
IndentOut();
Indent(); jsonWriter.Write("}");
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.ParticleSystem uParticleSystem) =>
{
var eParticleSystem = GetPrimaryEntity(uParticleSystem);
AddTransforms(ref uParticleSystem, eParticleSystem);
// General settings
ParticleEmitter particleEmitter = new ParticleEmitter
{
Duration = uParticleSystem.main.duration,
MaxParticles = (uint)uParticleSystem.main.maxParticles,
Lifetime = ConvertMinMaxCurve(uParticleSystem.main.startLifetime),
AttachToEmitter = uParticleSystem.main.simulationSpace == ParticleSystemSimulationSpace.Local,
};
DstEntityManager.AddComponentData(eParticleSystem, new EmitterInitialSpeed {
Speed = ConvertMinMaxCurve(uParticleSystem.main.startSpeed)
});
if (uParticleSystem.main.loop)
{
DstEntityManager.AddComponentData(eParticleSystem, new Looping());
}
DstEntityManager.AddComponentData(eParticleSystem, new StartDelay {
Delay = ConvertMinMaxCurve(uParticleSystem.main.startDelay)
});
DstEntityManager.AddComponentData(eParticleSystem, ConvertMinMaxGradient(uParticleSystem.main.startColor));
if (!uParticleSystem.useAutoRandomSeed)
{
DstEntityManager.AddComponentData(eParticleSystem, new RandomSeed {
Value = uParticleSystem.randomSeed
});
}
// Emission settings
if (uParticleSystem.emission.enabled)
{
particleEmitter.EmitRate = ConvertMinMaxCurve(uParticleSystem.emission.rateOverTime);
if (uParticleSystem.emission.burstCount > 0)
{
UnityEngine.ParticleSystem.Burst[] bursts = new UnityEngine.ParticleSystem.Burst[uParticleSystem.emission.burstCount];
uParticleSystem.emission.GetBursts(bursts);
// TODO support multiple bursts with IBufferElementData or by creating a new entity for each burst emitter
//foreach (var burst in bursts)
var burst = bursts[0];
{
DstEntityManager.AddComponentData <BurstEmission>(eParticleSystem, new BurstEmission
{
Count = ConvertMinMaxCurve(burst.count),
Interval = burst.repeatInterval,
Cycles = burst.cycleCount
// TODO probability
// TODO time
});
}
}
}
DstEntityManager.AddComponentData <ParticleEmitter>(eParticleSystem, particleEmitter);
// Shape settings
AddEmitterSource(ref uParticleSystem, eParticleSystem);
DstEntityManager.AddComponentData(eParticleSystem, new RandomizeDirection {
Value = uParticleSystem.shape.randomDirectionAmount
});
DstEntityManager.AddComponentData(eParticleSystem, new RandomizePosition {
Value = uParticleSystem.shape.randomPositionAmount
});
// Renderer settings
ParticleSystemRenderer uParticleSystemRenderer = uParticleSystem.gameObject.GetComponent <ParticleSystemRenderer>();
DstEntityManager.AddComponentData(eParticleSystem, new ParticleMaterial {
Material = GetPrimaryEntity(uParticleSystemRenderer.sharedMaterial)
});
if (uParticleSystemRenderer.renderMode == ParticleSystemRenderMode.Mesh)
{
DstEntityManager.AddComponentData(eParticleSystem, new ParticleMesh {
Mesh = GetPrimaryEntity(uParticleSystemRenderer.mesh)
});
}
});
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var ps = value as ParticleSystem;
var data = new Data();
#if UNITY_5_5_OR_NEWER
data.useAutoRandomSeed = ps.useAutoRandomSeed;
if (data.useAutoRandomSeed == false)
{
data.randomSeed = ps.randomSeed;
}
else
{
data.randomSeed = 0;
}
#endif
#if UNITY_5_5_OR_NEWER
data.main = UABUtils.CopyFromParticleSystemModule(ps.main, data.main);
{
data.emission.data = UABUtils.CopyFromParticleSystemModule(ps.emission, data.emission.data);
var bursts = new UnityEngine.ParticleSystem.Burst[ps.emission.burstCount];
ps.emission.GetBursts(bursts);
data.emission.bursts = new Data.EmissionModule.Burst[bursts.Length];
for (int i = 0; i < bursts.Length; ++i)
{
data.emission.bursts[i] = new Data.EmissionModule.Burst();
UABUtils.CopyFromParticleSystemModule(bursts[i], data.emission.bursts[i]);
}
}
#endif
data.shape = UABUtils.CopyFromParticleSystemModule(ps.shape, data.shape);
data.velocityOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.velocityOverLifetime, data.velocityOverLifetime);
data.limitVelocityOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.limitVelocityOverLifetime, data.limitVelocityOverLifetime);
data.inheritVelocity = UABUtils.CopyFromParticleSystemModule(ps.inheritVelocity, data.inheritVelocity);
data.forceOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.forceOverLifetime, data.forceOverLifetime);
data.colorOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.colorOverLifetime, data.colorOverLifetime);
data.colorOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.colorOverLifetime, data.colorOverLifetime);
data.sizeOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.sizeOverLifetime, data.sizeOverLifetime);
data.sizeBySpeed = UABUtils.CopyFromParticleSystemModule(ps.sizeBySpeed, data.sizeBySpeed);
data.rotationOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.rotationOverLifetime, data.rotationOverLifetime);
data.rotationBySpeed = UABUtils.CopyFromParticleSystemModule(ps.rotationBySpeed, data.rotationBySpeed);
data.externalForces = UABUtils.CopyFromParticleSystemModule(ps.externalForces, data.externalForces);
data.rotationBySpeed = UABUtils.CopyFromParticleSystemModule(ps.rotationBySpeed, data.rotationBySpeed);
#if UNITY_5_5_OR_NEWER
data.noise = UABUtils.CopyFromParticleSystemModule(ps.noise, data.noise);
#endif
data.collision = UABUtils.CopyFromParticleSystemModule(ps.collision, data.collision);
#if UNITY_5_5_OR_NEWER
data.trigger = UABUtils.CopyFromParticleSystemModule(ps.trigger, data.trigger);
{
data.subEmitters.data = UABUtils.CopyFromParticleSystemModule(ps.subEmitters, data.subEmitters.data);
data.subEmitters.subEmitters = new ParticleSystem[ps.subEmitters.subEmittersCount];
data.subEmitters.properties = new ParticleSystemSubEmitterProperties[ps.subEmitters.subEmittersCount];
data.subEmitters.types = new ParticleSystemSubEmitterType[ps.subEmitters.subEmittersCount];
for (int i = 0; i < ps.subEmitters.subEmittersCount; ++i)
{
data.subEmitters.subEmitters[i] = ps.subEmitters.GetSubEmitterSystem(i);
data.subEmitters.properties[i] = ps.subEmitters.GetSubEmitterProperties(i);
data.subEmitters.types[i] = ps.subEmitters.GetSubEmitterType(i);
}
}
#endif
data.textureSheetAnimation = UABUtils.CopyFromParticleSystemModule(ps.textureSheetAnimation, data.textureSheetAnimation);
#if UNITY_5_5_OR_NEWER
data.lights = UABUtils.CopyFromParticleSystemModule(ps.lights, data.lights);
data.trails = UABUtils.CopyFromParticleSystemModule(ps.trails, data.trails);
#endif
field.fields = packer.Serialize(data, serializers);
}
