void SetRenderMode(string value)
{
ParticleSystemRenderMode render = ParticleSystemRenderMode.None;
if (value == ParticleSystemRenderMode.HorizontalBillboard.ToString())
{
render = ParticleSystemRenderMode.HorizontalBillboard;
}
else if (value == ParticleSystemRenderMode.VerticalBillboard.ToString())
{
render = ParticleSystemRenderMode.VerticalBillboard;
}
else if (value == ParticleSystemRenderMode.Stretch.ToString())
{
render = ParticleSystemRenderMode.Stretch;
}
else if (value == ParticleSystemRenderMode.Mesh.ToString())
{
render = ParticleSystemRenderMode.Mesh;
}
else if (value == ParticleSystemRenderMode.Billboard.ToString())
{
render = ParticleSystemRenderMode.Billboard;
}
GlowParticleSystem.GetComponent <ParticleSystemRenderer>().renderMode = render;
}
public static void ParticleRendererSettings(this ParticleSystem PS,
bool enabled = true,
string Resources_MeshObject = null,
string Resources_Material = null,
string Resources_TrailMaterial = null,
ParticleSystemRenderMode RenderMode = ParticleSystemRenderMode.Stretch,
ParticleSystemSortMode SortMode = ParticleSystemSortMode.Distance
)
{
// Call Last
ParticleSystemRenderer PR = PS.GetComponent <ParticleSystemRenderer>();
// Renderer Settings
PR.enabled = enabled;
// Mesh Options / Material Options
if (Resources_MeshObject != null)
{
GameObject ResourceMesh = (GameObject)LoadResource(Resources_MeshObject);
PR.mesh = ResourceMesh.GetComponent <MeshFilter>().sharedMesh;
}
if (Resources_Material != null)
{
PR.material = (Material)LoadResource(Resources_Material);
}
if (Resources_TrailMaterial != null)
{
PR.trailMaterial = (Material)LoadResource(Resources_TrailMaterial);
}
// Mode Settings
PR.renderMode = RenderMode;
PR.sortMode = SortMode;
}
internal static bool CanRegister(GameObject gameObj, bool autoReg)
{
// Ignore static objects
if (gameObj.isStatic)
{
return(false);
}
// Ignore invalid materials; Ignore static batches
Renderer renderer = gameObj.GetComponent <Renderer>();
if (renderer == null || renderer.sharedMaterials == null || renderer.isPartOfStaticBatch)
{
return(false);
}
// Ignore disabled renderer
if (!renderer.enabled)
{
return(false);
}
// Ignore if visible only for shadows
if (renderer.shadowCastingMode == UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly)
{
return(false);
}
if (renderer.GetType() == typeof(SpriteRenderer))
{
return(false);
}
else
{
// Ignore unsupported RenderType
if (!FindValidTag(renderer.sharedMaterials))
{
return(false);
}
// Only valid and supported renderers
Type type = renderer.GetType();
if (type == typeof(MeshRenderer) || type == typeof(SkinnedMeshRenderer))
{
return(true);
}
#if !UNITY_PRE_5_3
if (type == typeof(ParticleSystemRenderer) && !autoReg)
{
// Only supported ParticleSystem modes
ParticleSystemRenderMode mode = (renderer as ParticleSystemRenderer).renderMode;
return(mode == ParticleSystemRenderMode.Mesh || mode == ParticleSystemRenderMode.Billboard);
}
#endif
}
return(false);
}
static int IntToEnum(IntPtr L)
{
int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
ParticleSystemRenderMode o = (ParticleSystemRenderMode)arg0;
LuaScriptMgr.PushEnum(L, o);
return(1);
}
protected void SetRenderMethod(ParticleSystemRenderMode mode, Mesh mesh = null)
{
cloud_renderer.renderMode = mode;
if (mode == ParticleSystemRenderMode.Mesh)
{
SetFollowCamera(false);
cloud_renderer.mesh = mesh;
cloud_renderer.enableGPUInstancing = true;
}
else
{
SetFollowCamera(true);
}
}
private static int get_renderMode(IntPtr L)
{
object obj = null;
int result;
try
{
obj = ToLua.ToObject(L, 1);
ParticleSystemRenderer particleSystemRenderer = (ParticleSystemRenderer)obj;
ParticleSystemRenderMode renderMode = particleSystemRenderer.renderMode;
ToLua.Push(L, renderMode);
result = 1;
}
catch (Exception ex)
{
result = LuaDLL.toluaL_exception(L, ex, (obj != null) ? ex.Message : "attempt to index renderMode on a nil value");
}
return(result);
}
private static int set_renderMode(IntPtr L)
{
object obj = null;
int result;
try
{
obj = ToLua.ToObject(L, 1);
ParticleSystemRenderer particleSystemRenderer = (ParticleSystemRenderer)obj;
ParticleSystemRenderMode renderMode = (ParticleSystemRenderMode)((int)ToLua.CheckObject(L, 2, typeof(ParticleSystemRenderMode)));
particleSystemRenderer.renderMode = renderMode;
result = 0;
}
catch (Exception ex)
{
result = LuaDLL.toluaL_exception(L, ex, (obj != null) ? ex.Message : "attempt to index renderMode on a nil value");
}
return(result);
}
// Token: 0x06000963 RID: 2403 RVA: 0x00049D0C File Offset: 0x00047F0C
internal static bool CanRegister(GameObject gameObj, bool autoReg)
{
if (gameObj.isStatic)
{
return(false);
}
Renderer component = gameObj.GetComponent <Renderer>();
if (component == null || component.sharedMaterials == null || component.isPartOfStaticBatch)
{
return(false);
}
if (!component.enabled)
{
return(false);
}
if (component.shadowCastingMode == ShadowCastingMode.ShadowsOnly)
{
return(false);
}
if (component.GetType() == typeof(SpriteRenderer))
{
return(false);
}
if (!AmplifyMotionEffectBase.FindValidTag(component.sharedMaterials))
{
return(false);
}
Type type = component.GetType();
if (type == typeof(MeshRenderer) || type == typeof(SkinnedMeshRenderer))
{
return(true);
}
if (type == typeof(ParticleSystemRenderer) && !autoReg)
{
ParticleSystemRenderMode renderMode = (component as ParticleSystemRenderer).renderMode;
return(renderMode == ParticleSystemRenderMode.Mesh || renderMode == ParticleSystemRenderMode.Billboard);
}
return(false);
}
private void OnGUI()
{
renderMode = (ParticleSystemRenderMode)GUI.SelectionGrid(new Rect(25, 25, 900, 30), (int)renderMode, new GUIContent[] {
new GUIContent("Billboard"),
new GUIContent("Stretch"),
new GUIContent("HorizontalBillboard"),
new GUIContent("VerticalBillboard"),
new GUIContent("Mesh"),
new GUIContent("None")
}, 6);
//Debug.Log(renderMode);
if (renderMode == ParticleSystemRenderMode.Stretch)
{
GUI.Label(new Rect(25, 80, 100, 30), "Camera Scale");
GUI.Label(new Rect(25, 120, 100, 30), "Length Scale");
GUI.Label(new Rect(25, 160, 100, 30), "Velocity Scale");
cameraScale = GUI.HorizontalSlider(new Rect(125, 85, 100, 30), cameraScale, 0.0f, 10.0f);
lengthScale = GUI.HorizontalSlider(new Rect(125, 125, 100, 30), lengthScale, 0.0f, 10.0f);
velocityScale = GUI.HorizontalSlider(new Rect(125, 165, 100, 30), velocityScale, 0.0f, 10.0f);
}
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystemRenderer uo = (ParticleSystemRenderer)obj;
mesh = ToID(uo.mesh);
alignment = uo.alignment;
renderMode = uo.renderMode;
sortMode = uo.sortMode;
lengthScale = uo.lengthScale;
velocityScale = uo.velocityScale;
cameraVelocityScale = uo.cameraVelocityScale;
normalDirection = uo.normalDirection;
sortingFudge = uo.sortingFudge;
minParticleSize = uo.minParticleSize;
maxParticleSize = uo.maxParticleSize;
pivot = uo.pivot;
maskInteraction = uo.maskInteraction;
trailMaterial = ToID(uo.trailMaterial);
enableGPUInstancing = uo.enableGPUInstancing;
shadowBias = uo.shadowBias;
flip = uo.flip;
allowRoll = uo.allowRoll;
}
internal static bool CanRegister(GameObject gameObj, bool autoReg)
{
// Ignore static objects
if (gameObj.isStatic)
{
return(false);
}
// Ignore invalid materials; Ignore static batches
Renderer renderer = gameObj.GetComponent <Renderer>();
if (renderer == null || renderer.sharedMaterials == null || renderer.isPartOfStaticBatch)
{
return(false);
}
// Ignore disabled renderer
if (!renderer.enabled)
{
return(false);
}
// Ignore if visible only for shadows
#if !UNITY_4
if (renderer.shadowCastingMode == UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly)
{
return(false);
}
#endif
if (renderer.GetType() == typeof(SpriteRenderer))
{
return(false);
}
else
{
// Ignore unsupported RenderType
if (!FindValidTag(renderer.sharedMaterials))
{
return(false);
}
#if UNITY_4
if (renderer.GetType() == typeof(ClothRenderer))
{
if (gameObj.GetComponent <InteractiveCloth>().tearFactor != 0.0f)
{
Debug.LogWarning("[AmplifyMotion] Tearable cloth objects are not supported at this time. Ignoring cloth object \"" + renderer.name + "\"");
}
else
{
return(true);
}
}
#endif
// Only valid and supported renderers
Type type = renderer.GetType();
if (type == typeof(MeshRenderer) || type == typeof(SkinnedMeshRenderer))
{
return(true);
}
#if !UNITY_PRE_5_3
if (type == typeof(ParticleSystemRenderer) && !autoReg)
{
// Only supported ParticleSystem modes
ParticleSystemRenderMode mode = (renderer as ParticleSystemRenderer).renderMode;
return(mode == ParticleSystemRenderMode.Mesh || mode == ParticleSystemRenderMode.Billboard);
}
#endif
}
return(false);
}
protected override JSONObject ToJSON(WXHierarchyContext context)
{
ParticleSystemRenderer particleSystemRenderer = particleSys.GetComponent <ParticleSystemRenderer>();
JSONObject json = new JSONObject(JSONObject.Type.OBJECT);
JSONObject data = new JSONObject(JSONObject.Type.OBJECT);
json.AddField("type", getTypeName());
json.AddField("data", data);
JSONObject materials = new JSONObject(JSONObject.Type.ARRAY);
data.AddField("materials", materials);
Material[] mats = particleSystemRenderer.sharedMaterials;
foreach (Material material in mats)
{
if (material != null)
{
WXMaterial materialConverter = new WXMaterial(material, particleSystemRenderer);
string materialPath = materialConverter.Export(context.preset);
materials.Add(materialPath);
context.AddResource(materialPath);
}
}
JSONObject modCommon = new JSONObject(JSONObject.Type.OBJECT);
JSONObject modCommonData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("common", modCommonData);
modCommonData.AddField("startSize3D", particleSys.main.startSize3D);
if (particleSys.main.startSize3D)
{
modCommonData.AddField("startSizeX", ParseMinMaxCurve(particleSys.main.startSizeX));
modCommonData.AddField("startSizeY", ParseMinMaxCurve(particleSys.main.startSizeY));
modCommonData.AddField("startSizeZ", ParseMinMaxCurve(particleSys.main.startSizeZ));
}
else
{
modCommonData.AddField("startSize", ParseMinMaxCurve(particleSys.main.startSize));
}
modCommonData.AddField("startColor", ParseMinMaxGradient(particleSys.main.startColor));
modCommonData.AddField("startLifetime", ParseMinMaxCurve(particleSys.main.startLifetime));
modCommonData.AddField("startRotation3D", particleSys.main.startRotation3D);
if (particleSys.main.startRotation3D)
{
modCommonData.AddField("startRotationX", ParseMinMaxCurve(particleSys.main.startRotationX, (float)(180 / Math.PI)));
modCommonData.AddField("startRotationY", ParseMinMaxCurve(particleSys.main.startRotationY, (float)(180 / Math.PI)));
modCommonData.AddField("startRotationZ", ParseMinMaxCurve(particleSys.main.startRotationZ, (float)(180 / Math.PI)));
}
else
{
modCommonData.AddField("startRotationZ", ParseMinMaxCurve(particleSys.main.startRotation, (float)(180 / Math.PI)));
}
modCommonData.AddField("startSpeed", ParseMinMaxCurve(particleSys.main.startSpeed));
modCommonData.AddField("gravityModifier", ParseMinMaxCurve(particleSys.main.gravityModifier));
#if UNITY_2018_1_OR_NEWER
modCommonData.AddField("randomizeRotation", particleSys.main.flipRotation);
#endif
modCommonData.AddField("randomSeed", particleSys.randomSeed);
modCommonData.AddField("autoRandomSeed", particleSys.useAutoRandomSeed);
ParticleSystemScalingMode pScalingMode = particleSys.main.scalingMode;
int pScalingModeNum = 0;
switch (pScalingMode)
{
case ParticleSystemScalingMode.Hierarchy:
pScalingModeNum = 0;
break;
case ParticleSystemScalingMode.Local:
pScalingModeNum = 1;
break;
case ParticleSystemScalingMode.Shape:
pScalingModeNum = 2;
break;
}
modCommonData.AddField("scalingMode", pScalingModeNum);
ParticleSystemSimulationSpace simulationSpace = particleSys.main.simulationSpace;
int simulationSpaceNum = 0;
switch (simulationSpace)
{
case ParticleSystemSimulationSpace.Local:
simulationSpaceNum = 0;
break;
case ParticleSystemSimulationSpace.World:
simulationSpaceNum = 1;
break;
case ParticleSystemSimulationSpace.Custom:
simulationSpaceNum = 2;
break;
}
modCommonData.AddField("simulationSpace", simulationSpaceNum);
JSONObject emitter = new JSONObject(JSONObject.Type.OBJECT);
JSONObject emitterData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("emitter", emitterData);
emitterData.AddField("playOnAwake", particleSys.main.playOnAwake);
emitterData.AddField("looping", particleSys.main.loop);
emitterData.AddField("duration", particleSys.main.duration);
emitterData.AddField("startDelay", ParseMinMaxCurve(particleSys.main.startDelay));
if (particleSys.emission.enabled)
{
JSONObject burst = new JSONObject(JSONObject.Type.ARRAY);
emitterData.AddField("bursts", burst);
int count = particleSys.emission.burstCount;
ParticleSystem.Burst[] bursts = new ParticleSystem.Burst[count];
particleSys.emission.GetBursts(bursts);
for (int i = 0; i < count; i++)
{
//burst.Add(ParseBurst(particleSys.emission.GetBurst(i)));
burst.Add(ParseBurst(bursts[i]));
}
emitterData.AddField("rateOverTime", ParseMinMaxCurve(particleSys.emission.rateOverTime));
}
emitterData.AddField("maxParticles", particleSys.main.maxParticles);
if (particleSystemRenderer.enabled)
{
JSONObject renderer = new JSONObject(JSONObject.Type.OBJECT);
JSONObject rendererData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("renderer", rendererData);
ParticleSystemRenderMode pRenderMode = particleSystemRenderer.renderMode;
int pRenderModeNum = 0;
switch (pRenderMode)
{
case ParticleSystemRenderMode.Billboard:
pRenderModeNum = 1;
break;
case ParticleSystemRenderMode.Stretch:
pRenderModeNum = 2;
rendererData.AddField("cameraScale", particleSystemRenderer.cameraVelocityScale);
rendererData.AddField("speedScale", particleSystemRenderer.velocityScale);
rendererData.AddField("lengthScale", particleSystemRenderer.lengthScale);
break;
case ParticleSystemRenderMode.HorizontalBillboard:
pRenderModeNum = 3;
break;
case ParticleSystemRenderMode.VerticalBillboard:
pRenderModeNum = 4;
break;
case ParticleSystemRenderMode.Mesh:
Mesh mesh = particleSystemRenderer.mesh;
if (mesh != null)
{
WXMesh meshConverter = new WXMesh(mesh);
string meshPath = meshConverter.Export(context.preset);
rendererData.AddField("mesh", meshPath);
rendererData.AddField("meshCount", particleSystemRenderer.meshCount);
context.AddResource(meshPath);
}
else
{
Debug.LogError(string.Format("{0} mesh is null", particleSys.name));
}
pRenderModeNum = 5;
break;
case ParticleSystemRenderMode.None:
pRenderModeNum = 0;
break;
default:
pRenderModeNum = 1;
break;
}
rendererData.AddField("renderMode", pRenderModeNum);
int mode = 1;
switch (particleSystemRenderer.alignment)
{
case ParticleSystemRenderSpace.View:
mode = 1;
break;
case ParticleSystemRenderSpace.World:
mode = 2;
break;
case ParticleSystemRenderSpace.Local:
mode = 3;
break;
case ParticleSystemRenderSpace.Facing:
mode = 4;
break;
#if UNITY_2017_1_OR_NEWER
case ParticleSystemRenderSpace.Velocity:
mode = 5;
break;
#endif
default:
break;
}
rendererData.AddField("renderAlignment", mode);
mode = 0;
switch (particleSystemRenderer.sortMode)
{
case ParticleSystemSortMode.None:
mode = 0;
break;
case ParticleSystemSortMode.Distance:
mode = 1;
break;
case ParticleSystemSortMode.OldestInFront:
mode = 2;
break;
case ParticleSystemSortMode.YoungestInFront:
mode = 3;
break;
default:
break;
}
rendererData.AddField("sortMode", mode);
rendererData.AddField("sortingFudge", particleSystemRenderer.sortingFudge);
rendererData.AddField("normalDirection", particleSystemRenderer.normalDirection);
rendererData.AddField("minParticleSize", particleSystemRenderer.minParticleSize);
rendererData.AddField("maxParticleSize", particleSystemRenderer.maxParticleSize);
var flipValue = TryGetContainProperty(particleSystemRenderer, "flip");
if (flipValue != null)
{
rendererData.AddField("flip", GetVect3((Vector3)flipValue));
}
else
{
renderer.AddField("flip", GetVect3(new Vector3(0, 0, 0)));
}
//rendererData.AddField("flip", GetVect3(particleSystemRenderer.flip));
rendererData.AddField("pivot", GetVect3(particleSystemRenderer.pivot));
var allowRollData = TryGetContainProperty(particleSystemRenderer, "allowRoll");
if (allowRollData != null)
{
rendererData.AddField("allowRoll", (bool)allowRollData);
}
else
{
rendererData.AddField("allowRoll", false);
}
}
else
{
String info = "entity: " + particleSys.gameObject.name + " 的粒子组件没有renderer模块，不可导出;请加上renderer模块，或删除该粒子组件";
ErrorUtil.ExportErrorReporter.create()
.setGameObject(particleSys.gameObject)
.setHierarchyContext(context)
.error(0, "粒子组件没有renderer模块，不可导出;请加上renderer模块，或删除该粒子组件");
}
if (particleSys.rotationOverLifetime.enabled)
{
JSONObject rotationByLife = new JSONObject(JSONObject.Type.OBJECT);
JSONObject rotationByLifeData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("rotationByLife", rotationByLifeData);
rotationByLifeData.AddField("separateAxes", particleSys.rotationOverLifetime.separateAxes);
if (particleSys.rotationOverLifetime.separateAxes)
{
rotationByLifeData.AddField("x", ParseMinMaxCurve(particleSys.rotationOverLifetime.x, (float)(180 / Math.PI)));
rotationByLifeData.AddField("y", ParseMinMaxCurve(particleSys.rotationOverLifetime.y, (float)(180 / Math.PI)));
rotationByLifeData.AddField("z", ParseMinMaxCurve(particleSys.rotationOverLifetime.z, (float)(180 / Math.PI)));
}
else
{
rotationByLifeData.AddField("z", ParseMinMaxCurve(particleSys.rotationOverLifetime.z, (float)(180 / Math.PI)));
}
}
if (particleSys.sizeOverLifetime.enabled)
{
JSONObject sizeOverLifetime = new JSONObject(JSONObject.Type.OBJECT);
JSONObject sizeOverLifetimeData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("sizeByLife", sizeOverLifetimeData);
sizeOverLifetimeData.AddField("separateAxes", particleSys.sizeOverLifetime.separateAxes);
if (particleSys.sizeOverLifetime.separateAxes)
{
sizeOverLifetimeData.AddField("x", ParseMinMaxCurve(particleSys.sizeOverLifetime.x));
sizeOverLifetimeData.AddField("y", ParseMinMaxCurve(particleSys.sizeOverLifetime.y));
sizeOverLifetimeData.AddField("z", ParseMinMaxCurve(particleSys.sizeOverLifetime.z));
}
else
{
sizeOverLifetimeData.AddField("x", ParseMinMaxCurve(particleSys.sizeOverLifetime.size));
}
}
if (particleSys.velocityOverLifetime.enabled)
{
JSONObject speedByLifeData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("speedByLife", speedByLifeData);
switch (particleSys.velocityOverLifetime.space)
{
case ParticleSystemSimulationSpace.Local:
speedByLifeData.AddField("space", 1);
break;
case ParticleSystemSimulationSpace.World:
speedByLifeData.AddField("space", 2);
break;
case ParticleSystemSimulationSpace.Custom:
break;
default:
break;
}
speedByLifeData.AddField("x", ParseMinMaxCurve(particleSys.velocityOverLifetime.x));
speedByLifeData.AddField("y", ParseMinMaxCurve(particleSys.velocityOverLifetime.y));
speedByLifeData.AddField("z", ParseMinMaxCurve(particleSys.velocityOverLifetime.z));
#if UNITY_2018_1_OR_NEWER
speedByLifeData.AddField("orbitalX", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalX));
speedByLifeData.AddField("orbitalY", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalY));
speedByLifeData.AddField("orbitalZ", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalZ));
speedByLifeData.AddField("orbitalOffsetX", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalOffsetX));
speedByLifeData.AddField("orbitalOffsetY", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalOffsetY));
speedByLifeData.AddField("orbitalOffsetZ", ParseMinMaxCurve(particleSys.velocityOverLifetime.orbitalOffsetZ));
speedByLifeData.AddField("radial", ParseMinMaxCurve(particleSys.velocityOverLifetime.radial));
#endif
#if UNITY_2017_1_OR_NEWER
speedByLifeData.AddField("speedScale", ParseMinMaxCurve(particleSys.velocityOverLifetime.speedModifier));
#endif
}
if (particleSys.limitVelocityOverLifetime.enabled)
{
JSONObject speedLimitByLifeData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("speedLimitByLife", speedLimitByLifeData);
speedLimitByLifeData.AddField("separateAxes", particleSys.limitVelocityOverLifetime.separateAxes);
if (particleSys.limitVelocityOverLifetime.separateAxes)
{
speedLimitByLifeData.AddField("x", ParseMinMaxCurve(particleSys.limitVelocityOverLifetime.limitX, particleSys.limitVelocityOverLifetime.limitXMultiplier));
speedLimitByLifeData.AddField("y", ParseMinMaxCurve(particleSys.limitVelocityOverLifetime.limitY, particleSys.limitVelocityOverLifetime.limitYMultiplier));
speedLimitByLifeData.AddField("z", ParseMinMaxCurve(particleSys.limitVelocityOverLifetime.limitZ, particleSys.limitVelocityOverLifetime.limitZMultiplier));
}
else
{
speedLimitByLifeData.AddField("x", ParseMinMaxCurve(particleSys.limitVelocityOverLifetime.limit, particleSys.limitVelocityOverLifetime.limitMultiplier));
}
speedLimitByLifeData.AddField("dampen", particleSys.limitVelocityOverLifetime.dampen);
switch (particleSys.limitVelocityOverLifetime.space)
{
case ParticleSystemSimulationSpace.Local:
speedLimitByLifeData.AddField("space", 1);
break;
case ParticleSystemSimulationSpace.World:
speedLimitByLifeData.AddField("space", 2);
break;
case ParticleSystemSimulationSpace.Custom:
break;
default:
break;
}
#if UNITY_2017_1_OR_NEWER
speedLimitByLifeData.AddField("drag", ParseMinMaxCurve(particleSys.limitVelocityOverLifetime.drag));
speedLimitByLifeData.AddField("dragMultiplyBySize", particleSys.limitVelocityOverLifetime.multiplyDragByParticleSize);
speedLimitByLifeData.AddField("dragMultiplyBySpeed", particleSys.limitVelocityOverLifetime.multiplyDragByParticleVelocity);
#endif
}
if (particleSys.colorOverLifetime.enabled)
{
JSONObject colorOverLifetime = new JSONObject(JSONObject.Type.OBJECT);
JSONObject colorOverLifetimeData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("colorByLife", colorOverLifetimeData);
colorOverLifetimeData.AddField("gColor", ParseMinMaxGradient(particleSys.colorOverLifetime.color));
}
if (particleSys.shape.enabled)
{
JSONObject shapeData = new JSONObject(JSONObject.Type.OBJECT);
var haveShape = true;
if (particleSys.shape.shapeType == ParticleSystemShapeType.Cone || particleSys.shape.shapeType == ParticleSystemShapeType.ConeVolume || particleSys.shape.shapeType == ParticleSystemShapeType.ConeVolumeShell || particleSys.shape.shapeType == ParticleSystemShapeType.ConeShell)
{
shapeData.AddField("shape", ParseConeShape(particleSys.shape));
}
else if (particleSys.shape.shapeType == ParticleSystemShapeType.Sphere || particleSys.shape.shapeType == ParticleSystemShapeType.SphereShell)
{
shapeData.AddField("shape", ParseSphereShape(particleSys.shape));
}
else if (particleSys.shape.shapeType == ParticleSystemShapeType.Circle || particleSys.shape.shapeType == ParticleSystemShapeType.CircleEdge)
{
shapeData.AddField("shape", ParseCircleShape(particleSys.shape));
}
else if (particleSys.shape.shapeType == ParticleSystemShapeType.Box || particleSys.shape.shapeType == ParticleSystemShapeType.BoxEdge || particleSys.shape.shapeType == ParticleSystemShapeType.BoxShell)
{
shapeData.AddField("shape", ParseBox(particleSys.shape));
}
else if (particleSys.shape.shapeType == ParticleSystemShapeType.Hemisphere || particleSys.shape.shapeType == ParticleSystemShapeType.HemisphereShell)
{
shapeData.AddField("shape", ParseHemisphere(particleSys.shape));
}
// else if (particleSys.shape.shapeType == ParticleSystemShapeType.SingleSidedEdge) {
// shapeData.AddField("shape", ParseSingleSidedEdge(particleSys.shape));
// }
else
{
var parentChain = go.name;
var parent = go.transform.parent;
while (parent)
{
parentChain += " -> " + parent.gameObject.name;
parent = parent.parent;
}
Debug.LogError("unSupport shape (" + particleSys.shape.shapeType.ToString() + ") at: " + parentChain);
haveShape = false;
}
if (haveShape)
{
data.AddField("emitterShape", shapeData);
}
}
if (particleSys.textureSheetAnimation.enabled)
{
JSONObject textureSheetAnimationData = new JSONObject(JSONObject.Type.OBJECT);
data.AddField("textureSheetAnimation", textureSheetAnimationData);
int mode = 1;
#if UNITY_2017_1_OR_NEWER
mode = 1;
switch (particleSys.textureSheetAnimation.mode)
{
case ParticleSystemAnimationMode.Grid:
mode = 1;
break;
case ParticleSystemAnimationMode.Sprites:
mode = 2;
break;
default:
break;
}
textureSheetAnimationData.AddField("mode", mode);
#endif
JSONObject vec2 = new JSONObject(JSONObject.Type.ARRAY);
vec2.Add(particleSys.textureSheetAnimation.numTilesX);
vec2.Add(particleSys.textureSheetAnimation.numTilesY);
textureSheetAnimationData.AddField("tiles", vec2);
mode = 1;
switch (particleSys.textureSheetAnimation.animation)
{
case ParticleSystemAnimationType.WholeSheet:
mode = 1;
break;
case ParticleSystemAnimationType.SingleRow:
mode = 2;
break;
default:
break;
}
textureSheetAnimationData.AddField("animationType", mode);
textureSheetAnimationData.AddField("randomRow", particleSys.textureSheetAnimation.useRandomRow);
textureSheetAnimationData.AddField("row", particleSys.textureSheetAnimation.rowIndex);
//mode = 1;
//switch (particleSys.textureSheetAnimation.timeMode)
//{
// case ParticleSystemAnimationTimeMode.Lifetime:
// mode = 1;
// break;
// case ParticleSystemAnimationTimeMode.Speed:
// mode = 2;
// break;
// case ParticleSystemAnimationTimeMode.FPS:
// mode = 3;
// break;
// default:
// break;
//}
textureSheetAnimationData.AddField("timeMode", 1);
if (mode == 1)
{
textureSheetAnimationData.AddField("frameOverTime", ParseMinMaxCurve(particleSys.textureSheetAnimation.frameOverTime, particleSys.textureSheetAnimation.numTilesX * particleSys.textureSheetAnimation.numTilesY));
}
else
{
textureSheetAnimationData.AddField("frameOverTime", ParseMinMaxCurve(particleSys.textureSheetAnimation.frameOverTime, particleSys.textureSheetAnimation.numTilesX));
}
textureSheetAnimationData.AddField("startFrame", ParseMinMaxCurve(particleSys.textureSheetAnimation.startFrame));
textureSheetAnimationData.AddField("cycles", particleSys.textureSheetAnimation.cycleCount);
mode = 0;
var a = particleSys.textureSheetAnimation.uvChannelMask;
var b = a & UVChannelFlags.UV0;
if ((a & UVChannelFlags.UV0) != 0)
{
mode += 1;
}
if ((a & UVChannelFlags.UV1) != 0)
{
mode += 2;
}
if ((a & UVChannelFlags.UV2) != 0)
{
mode += 3;
}
if ((a & UVChannelFlags.UV3) != 0)
{
mode += 4;
}
textureSheetAnimationData.AddField("affectedUVChannels", mode);
}
if (particleSys.subEmitters.enabled)
{
JSONObject subEmittersData = new JSONObject(JSONObject.Type.ARRAY);
data.AddField("subEmitters", subEmittersData);
int count = particleSys.subEmitters.subEmittersCount;
for (int i = 0; i < count; i++)
{
ParticleSystemSubEmitterProperties properties = particleSys.subEmitters.GetSubEmitterProperties(i);
ParticleSystemSubEmitterType type = particleSys.subEmitters.GetSubEmitterType(i);
JSONObject res = new JSONObject(JSONObject.Type.OBJECT);
int typeNum = 0;
switch (type)
{
case ParticleSystemSubEmitterType.Birth:
typeNum = 0;
break;
case ParticleSystemSubEmitterType.Collision:
typeNum = 1;
break;
case ParticleSystemSubEmitterType.Death:
typeNum = 2;
break;
default:
break;
}
res.AddField("type", typeNum);
int propertiesNum = 0;
switch (properties)
{
case ParticleSystemSubEmitterProperties.InheritNothing:
propertiesNum = 0;
break;
case ParticleSystemSubEmitterProperties.InheritEverything:
propertiesNum = 1;
break;
case ParticleSystemSubEmitterProperties.InheritColor:
propertiesNum = 2;
break;
case ParticleSystemSubEmitterProperties.InheritSize:
propertiesNum = 3;
break;
case ParticleSystemSubEmitterProperties.InheritRotation:
propertiesNum = 4;
break;
default:
break;
}
res.AddField("properties", propertiesNum);
subEmittersData.Add(res);
}
}
return(json);
}
//PARTICLE SYSTEM SETUP: Sets up the first/beta particle system.\\
public void setupParticleSystem(Vector3 SystemRotation, ParticleSystem.ColorOverLifetimeModule ColorModule, ParticleSystem.MinMaxGradient ParticleColor, ParticleSystemRenderMode RenderMode, float StretchVelocity)
{
storedParticleSystem = new GameObject("Particle System");
system = storedParticleSystem.AddComponent<ParticleSystem>();
// Create a textured stretched Particle System.
storedParticleSystem.transform.Rotate(SystemRotation); // Rotate so the system emits upwards.
ParticleSystem.ColorOverLifetimeModule colorModule = ColorModule;
colorModule.color = ParticleColor;
storedParticleSystem.GetComponent<ParticleSystemRenderer>().renderMode = RenderMode;
storedParticleSystem.GetComponent<ParticleSystemRenderer>().velocityScale = StretchVelocity;
}
/// <summary>
/// Extension method to set the rendering type of the particle emitter (billboard/etc).
/// </summary>
/// <param name="ps"></param>
/// <param name="mode"></param>
public static void ext_setRenderMode(this ParticleSystem ps, ParticleSystemRenderMode mode)
{
var bs = ps.gameObject.GetComponent <ParticleSystemRenderer>();
bs.renderMode = mode;
}
