private void SortingOrdersCompact(SVGAssetInput svgAsset)
{
List <SpriteRenderer> spriteRenderers = new List <SpriteRenderer>();
// get the list of instantiated sprites relative to this atlas generator
List <GameObject> spritesInstances = new List <GameObject>();
this.GetSpritesInstances(spritesInstances);
foreach (GameObject gameObj in spritesInstances)
{
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
SVGSpriteRef spriteRef = spriteLoader.SpriteReference;
// if the sprite belongs to the specified SVG asset input, keep track of it
if (spriteRef.TxtAsset == svgAsset.TxtAsset)
{
SpriteRenderer renderer = (SpriteRenderer)gameObj.GetComponent <SpriteRenderer>();
if (renderer != null)
{
spriteRenderers.Add(renderer);
}
}
}
if (spriteRenderers.Count > 0)
{
// order the list by current sorting order
spriteRenderers.Sort(delegate(SpriteRenderer renderer1, SpriteRenderer renderer2) {
if (renderer1.sortingOrder < renderer2.sortingOrder)
{
return(-1);
}
if (renderer1.sortingOrder > renderer2.sortingOrder)
{
return(1);
}
return(0);
});
int j = spriteRenderers.Count;
for (int i = 0; i < j; ++i)
{
SpriteRenderer renderer = spriteRenderers[i];
int currentOrder = renderer.sortingOrder;
// isolate high part
int svgIndex = currentOrder & SPRITES_SORTING_DOCUMENTS_MASK;
// assign the new order
renderer.sortingOrder = SVGAtlas.SortingOrderCalc(svgIndex, i);
}
svgAsset.InstanceBaseIdx = j;
}
else
{
// there are no sprite instances relative to the specified SVG, so we can start from 0
svgAsset.InstanceBaseIdx = 0;
}
}
public override void OnInspectorGUI()
{
// get the target object
this.m_EditedLoader = target as SVGSpriteLoaderBehaviour;
if (this.m_EditedLoader != null)
{
GUI.enabled = (Application.isPlaying) ? false : true;
this.DrawInspector();
}
}
private void ResizeOrcCharacter(int backgroundWidth, int backgroundHeight)
{
// get the orc (body) sprite loader
SVGSpriteLoaderBehaviour spriteLoader = gameObject.GetComponent <SVGSpriteLoaderBehaviour>();
// update/regenerate all orc sprites; NB: we want to size the orc according to
// the background sprite (actually the background height)
if (spriteLoader != null)
{
spriteLoader.UpdateSprite(true, backgroundWidth, backgroundHeight);
}
}
private static void ProcessScene()
{
GameObject[] allObjects = GameObject.FindObjectsOfType <GameObject>();
List <SVGBasicAtlas> unexportedAtlases = new List <SVGBasicAtlas>();
// scan all game objects in the current scene, and keep track of used atlas generators
foreach (GameObject gameObj in allObjects)
{
if (gameObj.activeInHierarchy)
{
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
if (loader != null)
{
// if this atlas has not been already flagged, lets keep track of it
if (!loader.Atlas.Exporting)
{
unexportedAtlases.Add(loader.Atlas);
loader.Atlas.Exporting = true;
}
}
SVGUISpriteLoaderBehaviour uiLoader = gameObj.GetComponent <SVGUISpriteLoaderBehaviour>();
if (uiLoader != null)
{
// if this atlas has not been already flagged, lets keep track of it
if (!uiLoader.UIAtlas.Exporting)
{
unexportedAtlases.Add(uiLoader.UIAtlas);
uiLoader.UIAtlas.Exporting = true;
}
}
SVGCanvasBehaviour uiCanvas = gameObj.GetComponent <SVGCanvasBehaviour>();
if (uiCanvas != null)
{
// if this atlas has not been already flagged, lets keep track of it
if (!uiCanvas.UIAtlas.Exporting)
{
unexportedAtlases.Add(uiCanvas.UIAtlas);
uiCanvas.UIAtlas.Exporting = true;
}
}
}
}
foreach (SVGBasicAtlas baseAtlas in unexportedAtlases)
{
SVGBuildProcessor.ProcessAtlas(baseAtlas);
// keep track of this atlas in the global list
SVGBuildProcessor.m_Atlases.Add(baseAtlas);
}
}
private GameObject Instantiate(SVGSpriteAssetFile spriteAsset, int sortingOrder)
{
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
GameObject gameObj = new GameObject();
SpriteRenderer renderer = (SpriteRenderer)gameObj.AddComponent <SpriteRenderer>();
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.AddComponent <SVGSpriteLoaderBehaviour>();
renderer.sprite = spriteData.Sprite;
renderer.sortingOrder = sortingOrder;
spriteLoader.Atlas = this;
spriteLoader.SpriteReference = spriteRef;
spriteLoader.ResizeOnStart = true;
gameObj.name = spriteData.Sprite.name;
spriteData.InCurrentInstancesGroup = true;
return(gameObj);
}
private void GetSpritesInstances(List <GameObject> spritesInstances)
{
GameObject[] allObjects = GameObject.FindObjectsOfType <GameObject>();
foreach (GameObject gameObj in allObjects)
{
// check if the game object is an "SVG sprite" instance of this atlas generator
if (gameObj.activeInHierarchy)
{
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
// we must be sure that the loader component must refer to this atlas
if (loader != null && loader.Atlas == this)
{
// add this instance to the output lists
spritesInstances.Add(gameObj);
}
}
}
}
public void UpdateSprite(bool updateChildren, int currentScreenWidth, int currentScreenHeight)
{
// regenerate (if needed) the sprite
this.UpdateSprite(currentScreenWidth, currentScreenHeight);
if (updateChildren)
{
int childCount = this.transform.childCount;
// update children
for (int i = 0; i < childCount; ++i)
{
GameObject gameObj = this.transform.GetChild(i).gameObject;
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
if (loader != null)
{
loader.UpdateSprite(updateChildren, currentScreenWidth, currentScreenHeight);
}
}
}
}
private static void UpdatePivotHierarchy(GameObject gameObj, Vector2 delta, uint depthLevel)
{
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
if (loader != null)
{
Vector2 realDelta = (depthLevel > 0) ? (new Vector2(-delta.x, -delta.y)) : (new Vector2(delta.x * gameObj.transform.localScale.x, delta.y * gameObj.transform.localScale.y));
Vector2 newPos = new Vector2(gameObj.transform.localPosition.x + realDelta.x, gameObj.transform.localPosition.y + realDelta.y);
// modify the current node
gameObj.transform.localPosition = newPos;
}
// traverse children
int j = gameObj.transform.childCount;
for (int i = 0; i < j; ++i)
{
GameObject child = gameObj.transform.GetChild(i).gameObject;
SVGAtlas.UpdatePivotHierarchy(child, delta, depthLevel + 1);
}
}
public Sprite UpdateCardSprite(GameCardBehaviour card)
{
if (this.Atlas != null)
{
GameCardType cardType = card.BackSide ? GameCardType.BackSide : card.AnimalType;
SVGRuntimeSprite data = this.Atlas.GetSpriteByName(GameCardBehaviour.AnimalSpriteName(cardType));
// get the sprite, given its name
if (data != null)
{
card.gameObject.GetComponent <SpriteRenderer>().sprite = data.Sprite;
// keep updated the SVGSpriteLoaderBehaviour component too
SVGSpriteLoaderBehaviour loader = card.gameObject.GetComponent <SVGSpriteLoaderBehaviour>();
if (loader != null)
{
loader.SpriteReference = data.SpriteReference;
}
return(data.Sprite);
}
}
return(null);
}
// recalculate sorting orders of instantiated sprites: changing is due only to SVG index, so the lower part (group + zNatural) is left unchanged
private void SortingOrdersUpdateSvgIndex()
{
// get the list of instantiated sprites relative to this atlas generator
List <GameObject> spritesInstances = new List <GameObject>();
this.GetSpritesInstances(spritesInstances);
foreach (GameObject gameObj in spritesInstances)
{
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
SpriteRenderer renderer = (SpriteRenderer)gameObj.GetComponent <SpriteRenderer>();
if (renderer != null)
{
SVGSpriteRef spriteRef = spriteLoader.SpriteReference;
int svgIndex = this.SvgAssetIndexGet(spriteRef.TxtAsset);
if (svgIndex >= 0)
{
int instance = renderer.sortingOrder & SPRITES_SORTING_INSTANCES_MASK;
renderer.sortingOrder = SVGAtlas.SortingOrderCalc(svgIndex, instance);
}
}
}
}
public void UpdatePivot(SVGSpriteAssetFile spriteAsset, Vector2 newPivot)
{
SVGSpriteRef spriteRef = spriteAsset.SpriteRef;
SVGSpriteData spriteData = spriteAsset.SpriteData;
Sprite oldSprite = spriteData.Sprite;
// keep track of pivot movement
Vector2 deltaPivot = newPivot - spriteData.Pivot;
Vector2 deltaMovement = (new Vector2(deltaPivot.x * oldSprite.rect.width, deltaPivot.y * oldSprite.rect.height)) / SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT;
// create a new sprite (same texture, same rectangle, different pivot)
Sprite newSprite = Sprite.Create(oldSprite.texture, oldSprite.rect, newPivot, SVGBasicAtlas.SPRITE_PIXELS_PER_UNIT, 0, SpriteMeshType.FullRect, spriteData.Border);
GameObject[] allObjects = GameObject.FindObjectsOfType <GameObject>();
foreach (GameObject gameObj in allObjects)
{
if (gameObj.activeInHierarchy)
{
SVGSpriteLoaderBehaviour loader = gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
// we must be sure that the loader component must refer to this atlas
if (loader != null && loader.Atlas == this)
{
// check if the instance uses the specified sprite
if (loader.SpriteReference.TxtAsset == spriteRef.TxtAsset && loader.SpriteReference.ElemIdx == spriteRef.ElemIdx)
{
SVGAtlas.UpdatePivotHierarchy(gameObj, deltaMovement, 0);
}
}
}
}
spriteData.Pivot = newPivot;
newSprite.name = oldSprite.name;
EditorUtility.CopySerialized(newSprite, oldSprite);
SVGUtils.MarkObjectDirty(oldSprite);
// destroy the temporary sprite
GameObject.DestroyImmediate(newSprite);
}
private void UpdateEditorSprites(float newScale)
{
// get the list of instantiated SVG sprites
List <GameObject> spritesInstances = new List <GameObject>();
this.GetSpritesInstances(spritesInstances);
// regenerate the list of sprite locations
this.m_GeneratedSpritesLists = new SVGSpritesListDictionary();
if (this.m_SvgList.Count <= 0)
{
AssetDatabase.StartAssetEditing();
// delete previously generated textures (i.e. get all this.GeneratedTextures entries and delete the relative files)
this.DeleteTextures();
// delete previously generated sprites (i.e. get all this.GeneratedSprites entries and delete the relative files)
this.DeleteSprites();
if (spritesInstances.Count > 0)
{
bool remove = EditorUtility.DisplayDialog("Missing sprite!",
string.Format("{0} gameobjects reference sprites that do not exist anymore. Would you like to remove them from the scene?", spritesInstances.Count),
"Remove", "Keep");
if (remove)
{
this.DeleteGameObjects(spritesInstances);
}
}
AssetDatabase.StopAssetEditing();
// input SVG list is empty, simply reset both hash
this.m_SvgListHashOld = this.m_SvgListHashCurrent = "";
return;
}
// generate textures and sprites
List <Texture2D> textures = new List <Texture2D>();
List <KeyValuePair <SVGSpriteRef, SVGSpriteData> > sprites = new List <KeyValuePair <SVGSpriteRef, SVGSpriteData> >();
if (SVGRuntimeGenerator.GenerateSprites(// input
this.m_SvgList, this.m_MaxTexturesDimension, this.m_SpritesBorder, this.m_Pow2Textures, newScale, this.m_ClearColor, this.m_FastUpload, this.m_GeneratedSpritesFiles,
// output
textures, sprites, this.m_GeneratedSpritesLists))
{
int i, j;
if ((this.m_EditorGenerationScale > 0) && (newScale != this.m_EditorGenerationScale))
{
// calculate how much we have to scale (relative) positions
float deltaScale = newScale / this.m_EditorGenerationScale;
// fix objects positions and animations
foreach (GameObject gameObj in spritesInstances)
{
this.FixPositions(gameObj, deltaScale, deltaScale);
}
}
// keep track of the new generation scale
this.m_EditorGenerationScale = newScale;
AssetDatabase.StartAssetEditing();
// delete previously generated textures (i.e. get all this.GeneratedTextures entries and delete the relative files)
this.DeleteTextures();
// delete previously generated sprites (i.e. get all this.GeneratedSprites entries and delete the relative files)
this.DeleteSprites();
// ensure the presence of needed subdirectories
string atlasesPath = this.CreateOutputFolders();
string texturesDir = atlasesPath + "/Textures/";
string spritesDir = atlasesPath + "/Sprites/";
// save new texture assets
i = 0;
foreach (Texture2D texture in textures)
{
string textureFileName = texturesDir + "texture" + i + ".asset";
// save texture
AssetDatabase.CreateAsset(texture, textureFileName);
// DEBUG STUFF
//byte[] pngData = texture.EncodeToPNG();
//if (pngData != null)
// System.IO.File.WriteAllBytes(texturesDir + "texture" + i + ".png", pngData);
// keep track of the saved texture
this.m_GeneratedTexturesFiles.Add(new AssetFile(textureFileName, texture));
i++;
}
// save sprite assets
j = sprites.Count;
for (i = 0; i < j; ++i)
{
// get sprite reference and its pivot
SVGSpriteRef spriteRef = sprites[i].Key;
SVGSpriteData spriteData = sprites[i].Value;
// build sprite file name
string spriteFileName = spritesDir + spriteData.Sprite.name + ".asset";
// save sprite asset
AssetDatabase.CreateAsset(spriteData.Sprite, spriteFileName);
// keep track of the saved sprite and its pivot
this.m_GeneratedSpritesFiles.Add(spriteRef, new SVGSpriteAssetFile(spriteFileName, spriteRef, spriteData));
}
AssetDatabase.StopAssetEditing();
// for already instantiated (SVG) game object, set the new sprites
// in the same loop we keep track of those game objects that reference missing sprites (i.e. sprites that do not exist anymore)
List <GameObject> missingSpriteObjs = new List <GameObject>();
foreach (GameObject gameObj in spritesInstances)
{
SVGSpriteAssetFile spriteAsset;
SVGSpriteLoaderBehaviour spriteLoader = (SVGSpriteLoaderBehaviour)gameObj.GetComponent <SVGSpriteLoaderBehaviour>();
if (spriteLoader.SpriteReference.TxtAsset != null)
{
if (this.m_GeneratedSpritesFiles.TryGetValue(spriteLoader.SpriteReference, out spriteAsset))
{
// link the new sprite to the renderer
SpriteRenderer renderer = (SpriteRenderer)gameObj.GetComponent <SpriteRenderer>();
if (renderer != null)
{
SVGSpriteData spriteData = spriteAsset.SpriteData;
// assign the new sprite
renderer.sprite = spriteData.Sprite;
// NB: existing instances do not change sorting order!
}
}
else
{
missingSpriteObjs.Add(gameObj);
}
}
}
if (missingSpriteObjs.Count > 0)
{
bool remove = EditorUtility.DisplayDialog("Missing sprite!",
string.Format("{0} gameobjects reference sprites that do not exist anymore. Would you like to remove them from the scene?", missingSpriteObjs.Count),
"Remove", "Keep");
if (remove)
{
this.DeleteGameObjects(missingSpriteObjs);
}
}
// now SVG documents are instantiable
foreach (SVGAssetInput svgAsset in this.m_SvgList)
{
svgAsset.Instantiable = true;
}
// keep track of the new hash
this.m_SvgListHashOld = this.m_SvgListHashCurrent;
}
}
