static void _CopyParticleSystem(ParticleSystem original, GameObject copyTo)
{
ParticleSystem ps = null;
if ((ps = copyTo.GetComponent <ParticleSystem>()) == null)
{
ps = copyTo.AddComponent <ParticleSystem>();
}
SerializedObject newPsSerial = new SerializedObject(ps);
SerializedObject srcPsSerial = new SerializedObject(original);
SerializedProperty srcProperty = srcPsSerial.FindProperty("InitialModule.startLifetime");
LegacyToShurikenConverter.SetShurikenMinMaxCurve(newPsSerial, "InitialModule.startLifetime", 0.3f, 0.4f, true);
newPsSerial.Update();
}
void ConvertLegacyParticles()
{
systemParent = LegacyToShurikenConverter.Convert(systemParent);
UpdateParent(systemParent);
}
void BakeAtlas()
{
UpdateParent(systemParent);
if (!parentIsOk)
{
return;
}
if (viewDirection == Vector3.zero)
{
return;
}
finalTime = (overrideSystemDuration) ? customDuration : systemDuration;
GameObject cam = new GameObject("__Camera", typeof(Camera));
cam.transform.rotation = Quaternion.LookRotation(viewDirection);
renderCamera = cam.camera;
renderCamera.orthographic = true;
renderCamera.backgroundColor = bgColor == BackgroundColor.Black ? new Color(0, 0, 0, 0) : new Color(0.5f, 0.5f, 0.5f, 0);
renderCamera.cullingMask = 1 << useLayer;
GameObject lighte = new GameObject("__Light", typeof(Light));
lighte.transform.rotation = Quaternion.LookRotation(lightDirection);
lighte.light.renderMode = LightRenderMode.ForcePixel;
lighte.light.type = LightType.Directional;
lighte.light.color = dirLightColor;
RenderTexture rt = new RenderTexture(cellSizeX, cellSizeY, 16);
rt.isPowerOfTwo = true;
renderCamera.targetTexture = rt;
bool oldfog = RenderSettings.fog;
Color oldAmbient = RenderSettings.ambientLight;
RenderSettings.fog = false;
RenderSettings.ambientLight = ambientLightColor;
bool hasAlpha = false;
bool hasSolid = false;
bool hasAdditive = false;
OriginalRendererState[] oldStates = new OriginalRendererState[renderers.Length];
for (int i1 = 0; i1 < renderers.Length; i1++)
{
OriginalRendererState s = new OriginalRendererState();
s.layer = renderers[i1].gameObject.layer;
s.materials = renderers[i1].sharedMaterials;
List <Material> newMaterials = new List <Material>();
foreach (Material m in renderers[i1].sharedMaterials)
{
if (!hasAlpha)
{
hasAlpha = m.shader.name.Contains("Alpha Blended");
}
if (!hasSolid)
{
hasSolid = !m.shader.name.Contains("Particle") && !m.shader.name.Contains("Transparent");
}
if (!hasAdditive)
{
hasAdditive = m.shader.name.Contains("Additive");
}
}
foreach (Material m in renderers[i1].sharedMaterials)
{
bool bg = m.shader.name.Contains("Particle") && m.shader.name.Contains("Additive") && !hasAlpha;
if (bg)
{
Material newMat = new Material(m);
if (newMat.HasProperty("_Color"))
{
newMat.color = Color.Lerp(newMat.color, Color.clear, 0.3f);
}
if (newMat.HasProperty("_TintColor"))
{
newMat.SetColor("_TintColor", Color.Lerp(newMat.GetColor("_TintColor"), Color.clear, 0.3f));
}
newMat.shader = Shader.Find("Particles/Alpha Blended");
newMaterials.Add(newMat);
}
Material newMat1 = new Material(m);
if (newMat1.shader.name == "Particles/Additive")
{
newMat1.shader = addPlusOne;
}
if (newMat1.shader.name == "Particles/Additive (Soft)")
{
newMat1.shader = addSoftPlusOne;
}
if (bg)
{
if (newMat1.HasProperty("_Color"))
{
newMat1.color = Color.Lerp(newMat1.color, Color.clear, 0.3f);
}
if (newMat1.HasProperty("_TintColor"))
{
newMat1.SetColor("_TintColor", Color.Lerp(newMat1.GetColor("_TintColor"), Color.clear, 0.3f));
}
}
newMaterials.Add(newMat1);
}
renderers[i1].sharedMaterials = newMaterials.ToArray();
oldStates[i1] = s;
renderers[i1].gameObject.layer = useLayer;
}
// sets systemBounds & usedBoundsCenter
GetBounds();
cam.transform.position = usedBoundsCenter - viewDirection.normalized * systemBounds.size.z * 1.4f * cameraPad;
renderCamera.aspect = (float)cellSizeX / cellSizeY;
renderCamera.orthographicSize = Mathf.Max(systemBounds.extents.x / renderCamera.aspect, systemBounds.extents.y) * cameraPad;
renderCamera.nearClipPlane = systemBounds.size.z * 0.25f * cameraPad;
renderCamera.farClipPlane = systemBounds.size.z * 3 * cameraPad;
Texture2D copyTex = new Texture2D(cellSizeX, cellSizeY, TextureFormat.RGB24, false);
//Texture2D copyTex2 = new Texture2D( cellSizeX*0.5f, cellSizeY*0.5f, TextureFormat.RGB24, false );
Texture2D tex = new Texture2D(atlasSizeX, atlasSizeY, TextureFormat.ARGB32, false);
Texture2D texA = new Texture2D(atlasSizeX, atlasSizeY, TextureFormat.ARGB32, false);
RenderSheet(copyTex, renderCamera, tex);
renderCamera.backgroundColor = Color.black;
for (int i1 = 0; i1 < renderers.Length; i1++)
{
List <Material> newMaterials = new List <Material>();
foreach (Material m in oldStates[i1].materials)
{
Material newMat = new Material(m);
if (m.shader.name.Contains("Particle"))
{
newMat.shader = m.shader.name.Contains("Additive") ? addAlpha : blendAlpha;
}
else
{
newMat.shader = solidAlpha;
}
newMaterials.Add(newMat);
}
renderers[i1].sharedMaterials = newMaterials.ToArray();
}
RenderSheet(copyTex, renderCamera, texA);
for (var i1 = 0; i1 < renderers.Length; i1++)
{
renderers[i1].gameObject.layer = oldStates[i1].layer;
renderers[i1].sharedMaterials = oldStates[i1].materials;
}
int x = 0;
int y = 0;
float avgHueTilt = 0f;
float avgHueDist = 0f;
while (x < tex.width)
{
y = 0;
while (y < tex.height)
{
Color c = tex.GetPixel(x, y);
HSBColor hsb = HSBColor.FromColor(c);
Color cA = texA.GetPixel(x, y);
float a = (cA.r + cA.g + cA.b) * 0.33f;
Vector4 cv = new Vector4(c.r, c.g, c.b, 1);
if (bgColor == BackgroundColor.Gray)
{
Vector4 delta = new Vector4(c.r - 0.5f, c.g - 0.5f, c.b - 0.5f, 1);
if (a != 0)
{
cv += delta / a;
}
}
else
{
cv /= a;
}
Color nc = new Color(cv.x, cv.y, cv.z, a * a);
HSBColor nhsb = HSBColor.FromColor(nc);
nhsb.h = hsb.h;
float tilt = nhsb.h - (float)((int)nhsb.h % 60);
avgHueTilt += tilt;
avgHueDist += Mathf.Abs(tilt);
tex.SetPixel(x, y, HSBColor.ToColor(nhsb));
y++;
}
x++;
}
if (autoHueAdjust > 1f)
{
avgHueDist /= (tex.width * tex.height);
for (x = 0; x < tex.width; x++)
{
for (y = 0; y < tex.height; y++)
{
Color c = tex.GetPixel(x, y);
HSBColor hsb = HSBColor.FromColor(c);
hsb.h += avgHueDist * (autoHueAdjust * 0.01f) * (avgHueTilt > 0 ? -1 : 1);
tex.SetPixel(x, y, HSBColor.ToColor(hsb));
}
}
}
tex.Apply();
path = EditorUtility.SaveFilePanelInProject("Save texture as PNG", path, "png", "Please enter a file name to save the texture to");
if (path.Length != 0)
{
byte[] bytes = tex.EncodeToPNG();
if (bytes != null)
{
File.WriteAllBytes(path, bytes);
AssetDatabase.Refresh();
}
}
RenderTexture.active = null;
DestroyImmediate(copyTex);
DestroyImmediate(tex);
DestroyImmediate(texA);
DestroyImmediate(rt);
DestroyImmediate(lighte);
RenderSettings.fog = oldfog;
RenderSettings.ambientLight = oldAmbient;
float origSize = renderCamera.orthographicSize * 2;
Vector3 pos = systemParent.position + Vector3.right * origSize;
Quaternion rot = systemParent.rotation;
Vector3 localScale = Vector3.one;
Transform p = null;
if (systemTarget)
{
pos = systemTarget.position;
rot = systemTarget.rotation;
localScale = systemTarget.localScale;
p = systemTarget.parent;
DestroyImmediate(systemTarget.gameObject);
}
systemTarget = Instantiate(systemParent, pos, rot) as Transform;
systemTarget.gameObject.name = systemParent.gameObject.name + " packed";
systemTarget.parent = p;
systemTarget.localScale = localScale;
List <Renderer> theRenderers = new List <Renderer>();
List <Animation> theAnimations = new List <Animation>();
List <SpritePackerAnimation> theProviders = new List <SpritePackerAnimation>();
List <ParticleSystem> theParticleSystems = new List <ParticleSystem>();
//List<ParticleEmitter> theParticleEmitters = new List<ParticleEmitter>();
//FindAllInterestingComponents(theRenderers, theAnimations, theProviders, theParticleSystems, theParticleEmitters, systemTarget);
FindAllInterestingComponents(theRenderers, theAnimations, theProviders, theParticleSystems, systemTarget);
foreach (Renderer r in theRenderers)
{
DestroyImmediate(r);
}
foreach (Animation r in theAnimations)
{
DestroyImmediate(r);
}
//foreach(SpritePackerAnimation r in theProviders) Destroy(r);
foreach (ParticleSystem r in theParticleSystems)
{
DestroyImmediate(r);
}
//foreach(ParticleEmitter r in theParticleEmitters) DestroyImmediate(r);
List <GameObject> objects = new List <GameObject>();
FindAllGameObjects(objects, systemTarget);
foreach (GameObject g in objects)
{
g.transform.parent = systemTarget;
}
foreach (GameObject g in objects)
{
Component[] cs = g.GetComponents <Component>();
if (cs.Length == 1)
{
DestroyImmediate(g);
}
}
GameObject go = new GameObject(systemParent.name + " sprite");
go.transform.parent = systemTarget;
go.transform.localPosition = systemParent.InverseTransformPoint(usedBoundsCenter);
ParticleSystem ps = go.AddComponent <ParticleSystem>();
ParticleSystemRenderer psr = go.GetComponent <ParticleSystemRenderer>();
SerializedObject psSerial = new SerializedObject(ps);
SerializedObject psrSerial = new SerializedObject(psr);
psSerial.Update();
psrSerial.Update();
psSerial.FindProperty("UVModule.enabled").boolValue = true;
psSerial.FindProperty("UVModule.tilesX").intValue = numberOfColumns;
psSerial.FindProperty("UVModule.tilesY").intValue = numberOfRows;
psSerial.FindProperty("EmissionModule.m_BurstCount").intValue = 1;
psSerial.FindProperty("EmissionModule.time0").floatValue = 0;
psSerial.FindProperty("EmissionModule.cnt0").intValue = 1;
LegacyToShurikenConverter.SetShurikenMinMaxCurve(psSerial, "EmissionModule.rate", 0, 0, true);
psSerial.FindProperty("lengthInSec").floatValue = finalTime;
LegacyToShurikenConverter.SetShurikenMinMaxCurve(psSerial, "InitialModule.startLifetime", finalTime - 0.01f, finalTime - 0.01f, true);
LegacyToShurikenConverter.SetShurikenMinMaxCurve(psSerial, "InitialModule.startSize", origSize, origSize, true);
psSerial.FindProperty("ShapeModule.radius").floatValue = 0;
psSerial.FindProperty("ShapeModule.type").intValue = (int)ShapeTypes.Sphere;
LegacyToShurikenConverter.SetShurikenMinMaxCurve(psSerial, "InitialModule.startSpeed", 0, 0, true);
psSerial.ApplyModifiedProperties();
psrSerial.ApplyModifiedProperties();
string name1 = hasAlpha || hasSolid || !hasAdditive ? "SpritePacker/PackedBlend" : "SpritePacker/PackedAdditive";
if (hasSolid && !hasAlpha && !hasAdditive)
{
name1 = "SpritePacker/PackedCutout";
}
Material mat = new Material(Shader.Find(name1));
mat.mainTexture = AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D)) as Texture2D;
psr.sharedMaterial = mat;
DestroyImmediate(cam);
Debug.Log("Create Particle Animation done, saved to: " + path);
if (path.LastIndexOf("/") != -1)
{
path = path.Substring(path.LastIndexOf("/") + 1);
}
}
