private static void OnSpritePrefabPostprocess( )
{
EditorApplication.delayCall -= OnSpritePrefabPostprocess;
try
{
Uni2DAssetPostprocessor.LockTo(false);
foreach (string rGameObjectPrefabGUID in ms_oGameObjectGUIDsToPostProcess)
{
GameObject rGameObjectPrefab = Uni2DEditorUtils.GetAssetFromUnityGUID <GameObject>(rGameObjectPrefabGUID);
if (rGameObjectPrefab != null)
{
//Debug.Log ( "Post processing game object prefab " + rGameObjectPrefabGUID );
Uni2DEditorSpriteBuilderUtils.OnPrefabPostProcess(rGameObjectPrefab);
rGameObjectPrefab = null;
EditorUtility.UnloadUnusedAssets( );
}
}
}
finally
{
ms_oGameObjectGUIDsToPostProcess.Clear( );
Uni2DAssetPostprocessor.Unlock( );
Uni2DAssetPostprocessor.Enabled = true;
}
}
public void RegenerateInteractiveData( )
{
if (EditorUtility.IsPersistent(this))
{
Uni2DEditorSpriteBuilderUtils.UpdateSpriteInResource(this);
}
else
{
Uni2DEditorSpriteBuilderUtils.RegenerateInteractiveDataFromSettings(this);
}
EditorUtility.SetDirty(this.gameObject);
}
// Rebuild mesh in a batch
// Useful when some sprites share the same texture (only one texture import)
public void RebuildInABatch(bool a_bForce = false)
{
// RebuildInABatch purpose is only to reduce the time of
// the awful-texture-imports-juggling currently performed to read the true texture dimensions.
if (EditorUtility.IsPersistent(this))
{
Uni2DEditorSpriteBuilderUtils.UpdateSpriteInResourceInABatch(this);
}
else
{
Uni2DEditorSpriteBuilderUtils.GenerateSpriteFromSettings(m_rSpriteSettings, this, a_bForce, true);
}
EditorUtility.SetDirty(this.gameObject);
}
// Rebuild
public void Regenerate(bool a_bForce = false)
{
if (EditorUtility.IsPersistent(this))
{
Uni2DEditorSpriteBuilderUtils.UpdateSpriteInResource(this, a_bForce);
}
else
{
// Force update/rebuild
Uni2DEditorSpriteBuilderUtils.GenerateSpriteFromSettings(m_rSpriteSettings, this, a_bForce);
}
EditorUtility.SetDirty(this.gameObject);
}
// Update for a texture change
public void UpdateAccordinglyToTextureChange(string a_oNewTextureImportGUID)
{
//Debug.Log( "UpdateAccordinglyTo... current GUID: " + m_oTextureImportGUID + " / new:" + a_oNewTextureImportGUID, this.gameObject );
if (m_oTextureImportGUID == a_oNewTextureImportGUID)
{
return;
}
// Regenerate sprite mesh
Uni2DEditorSpriteBuilderUtils.GenerateSpriteMeshFromSettings(m_rSpriteSettings, this);
// Texture change end
m_oTextureImportGUID = a_oNewTextureImportGUID;
if (m_rSpriteSettings.physicsMode != PhysicsMode.NoPhysics)
{
isPhysicsDirty = true;
}
EditorUtility.SetDirty(this.gameObject);
}
// Update all frames infos about given textures
private void GenerateTextureFramesInfos(ICollection <Uni2DAnimationFrame> a_rFramesToGenerate)
{
Uni2DAssetPostprocessor.Enabled = false;
EditorUtility.DisplayProgressBar(mc_oProgressBarTitle, "Reading texture settings...", 0.0f);
int iFrameCount = a_rFramesToGenerate.Count;
int iFrameIndex = 0;
Texture2D[] oFrameTextures = new Texture2D[iFrameCount];
foreach (Uni2DAnimationFrame rFrame in a_rFramesToGenerate)
{
oFrameTextures[iFrameIndex++] = rFrame.textureContainer.Texture;
}
// Prepare textures
List <Uni2DTextureImporterSettingsPair> oImporterSettingsPair = Uni2DEditorSpriteBuilderUtils.TexturesProcessingBegin(oFrameTextures);
try
{
iFrameIndex = 1;
float fInvCount = 1.0f / (float)iFrameCount;
foreach (Uni2DAnimationFrame rFrame in a_rFramesToGenerate)
{
EditorUtility.DisplayProgressBar(mc_oProgressBarTitle,
"Generating frame #" + iFrameIndex + " out of " + iFrameCount,
iFrameIndex * fInvCount);
rFrame.GenerateInfos( );
++iFrameIndex;
}
// Restore Texture import settings
EditorUtility.DisplayProgressBar(mc_oProgressBarTitle, "Restoring texture settings...", 1.0f);
}
finally
{
Uni2DEditorSpriteBuilderUtils.TexturesProcessingEnd(oImporterSettingsPair);
EditorUtility.ClearProgressBar( );
Uni2DAssetPostprocessor.Enabled = true;
}
}
// Before prefab post process
private bool IsResourcesInTheCorrectFolder()
{
string oResourceDirectory = Uni2DEditorSpriteBuilderUtils.GetPrefabResourcesDirectoryPathLocal(this.gameObject);
if (AssetDatabase.GetAssetPath(m_rSpriteData.renderMesh).Contains(oResourceDirectory) == false)
{
return(false);
}
//if(AssetDatabase.GetAssetPath(m_rSpriteData.renderMeshMaterial).Contains(oResourceDirectory) == false)
//{
// return false;
//}
foreach (Mesh rMeshCollider in m_rSpriteData.meshCollidersList)
{
if (AssetDatabase.GetAssetPath(rMeshCollider).Contains(oResourceDirectory) == false)
{
return(false);
}
}
return(true);
}
// On a texture change
private void OnTextureChange(string a_oNewTextureImportGUID)
{
//Debug.Log("On texture change: " + this.gameObject.name );
Texture2D rSpriteTexture = m_rSpriteSettings.textureContainer;
// Update sprite size
if (rSpriteTexture != null)
{
string oTexturePath = AssetDatabase.GetAssetPath(rSpriteTexture.GetInstanceID( ));
TextureImporter rTextureImporter = TextureImporter.GetAtPath(oTexturePath) as TextureImporter;
if (rTextureImporter != null)
{
TextureImporterSettings oTextureImporterSettings = Uni2DEditorSpriteBuilderUtils.TextureProcessingBegin(rTextureImporter);
this.UpdateAccordinglyToTextureChange(a_oNewTextureImportGUID);
//Uni2DEditorUtilsSpriteBuilder.DoUpdateAllSceneSpritesAccordinglyToTextureChange( rSpriteTexture, a_oNewTextureImportGUID);
Uni2DEditorSpriteBuilderUtils.TextureProcessingEnd(rTextureImporter, oTextureImporterSettings);
EditorUtility.UnloadUnusedAssets( );
}
}
}
// Sets the sprite settings according to the new material (assuming it's new)
private void OnMaterialChange( )
{
Material rNewMaterial = renderer.sharedMaterial;
if (rNewMaterial != null)
{
Texture rNewTexture = rNewMaterial.mainTexture;
if (EditorUtility.IsPersistent(rNewMaterial))
{
m_rSpriteSettings.sharedMaterial = rNewMaterial;
}
m_rSpriteData.renderMeshMaterial = rNewMaterial;
if (rNewTexture == null)
{
rNewTexture = m_rSpriteSettings.textureContainer;
rNewMaterial.mainTexture = rNewTexture;
}
if (rNewTexture != null)
{
m_rSpriteSettings.atlas = null;
// Material & texture not null =>
// Take in account this material, its texture and regen the sprite mesh
m_rSpriteSettings.textureContainer = new Texture2DContainer((Texture2D)rNewTexture, false);
this.Regenerate(true);
return;
}
}
// No material and/or no texture => regenerate/reset it with the current texture
Uni2DEditorSpriteBuilderUtils.GenerateSpriteMatFromSettings(m_rSpriteSettings, this);
}
// Apply settings
public bool ApplySettings(bool a_bUpdateSprites = true)
{
bool bSuccess;
Uni2DAssetPostprocessor.Enabled = false;
{
int iContainerCount = textures.Length;
Texture2D[] oTexturesToPack = new Texture2D[iContainerCount];
for (int iContainerIndex = 0; iContainerIndex < iContainerCount; ++iContainerIndex)
{
oTexturesToPack[iContainerIndex] = textures[iContainerIndex].Texture;
}
List <Uni2DTextureImporterSettingsPair> rTextureImporterSettings = Uni2DEditorSpriteBuilderUtils.TexturesProcessingBegin(oTexturesToPack);
oTexturesToPack = null;
// Look if the atlas is set properly regarding to texture sizes
int iOversizedTextures = this.LookForOversizedTextures(textures, padding, maximumAtlasSize);
if (iOversizedTextures == 0)
{
textures = this.SanitizeInputTextures(textures);
iContainerCount = textures.Length;
string rAtlasGUID = Uni2DEditorUtils.GetUnityAssetGUID(this);
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
for (int iTextureIndex = 0, iTextureCount = m_rTextureContainers.Length; iTextureIndex < iTextureCount; ++iTextureIndex)
{
rAssetTable.RemoveAtlasUsingTexture(rAtlasGUID, m_rTextureContainers[iTextureIndex].GUID);
}
m_rTextureContainers = new Texture2DContainer[iContainerCount];
// Deep copy
for (int iContainerIndex = 0; iContainerIndex < iContainerCount; ++iContainerIndex)
{
Texture2DContainer oTextureContainer = new Texture2DContainer(textures[iContainerIndex]);
m_rTextureContainers[iContainerIndex] = oTextureContainer;
rAssetTable.AddAtlasUsingTexture(rAtlasGUID, oTextureContainer.GUID);
}
rAssetTable.Save( );
m_iPadding = padding;
m_eMaximumAtlasSize = maximumAtlasSize;
bSuccess = Generate( );
if (a_bUpdateSprites)
{
Uni2DEditorSpriteBuilderUtils.UpdateSpriteInCurrentSceneAndResourcesAccordinglyToAtlasChange(this);
}
}
else // Some textures can't fit
{
bSuccess = false;
Debug.LogWarning("Uni2D could not regenerate atlas '" + (this.gameObject.name) + "' properly: "
+ iOversizedTextures + " texture" + (iOversizedTextures > 1 ? "s are" : " is")
+ " too large to fit in the atlas.", this.gameObject);
}
Uni2DEditorSpriteBuilderUtils.TexturesProcessingEnd(rTextureImporterSettings);
}
Uni2DAssetPostprocessor.Enabled = true;
EditorUtility.UnloadUnusedAssets( );
return(bSuccess);
}
private static void OnPostprocessAllAssets(string[] a_rImportedAssets, string[] a_rDeletedAssets, string[] a_rMovedAssets, string[] a_rMovedFromPath)
{
if (ms_bEnabled)
{
bool bUpdateAssets = false;
bool bPostprocessPrefabs = false;
bool bSaveTable = false;
Uni2DEditorAssetTable rAssetTable = Uni2DEditorAssetTable.Instance;
foreach (string rImportedAssetPath in a_rImportedAssets)
{
// Check if the asset isn't re-processed due to a call to GenerateTextureImportGUID
if (ms_oImportedTexturesWithUpdatedUni2DGUIDs.Contains(rImportedAssetPath) == false)
{
Texture2D rImportedTexture = (Texture2D)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Texture2D));
if (rImportedTexture != null)
{
//Debug.Log ( "Imported " + rImportedAssetPath );
string rImportedTextureGUID = AssetDatabase.AssetPathToGUID(rImportedAssetPath);
ms_oImportedTextureGUIDs.Add(rImportedTextureGUID);
if (Uni2DEditorUtils.ItIsTheFirstTimeWeUseTheTexture(rImportedTexture))
{
Uni2DEditorSpriteBuilderUtils.SetDefaultTextureImporterSettings(rImportedTexture, false);
}
// This call will produce an unvoidable import of the texture (didn't find out how to prevent it)
Uni2DEditorUtils.GenerateTextureImportGUID(rImportedTexture);
// ... so, save the path reference to avoid to re-process it again
ms_oImportedTexturesWithUpdatedUni2DGUIDs.Add(rImportedAssetPath);
bUpdateAssets = true;
rImportedTexture = null;
EditorUtility.UnloadUnusedAssets( );
continue;
}
Uni2DTextureAtlas rImportedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DTextureAtlas));
if (rImportedAtlas != null)
{
//Debug.Log ( "Imported atlas " + rImportedAssetPath );
bSaveTable = true;
rAssetTable.AddAtlasPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath));
rImportedAtlas = null;
EditorUtility.UnloadUnusedAssets( );
continue;
}
Uni2DAnimationClip rImportedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(Uni2DAnimationClip));
if (rImportedClip != null)
{
//Debug.Log ( "Imported clip " + rImportedClip );
bSaveTable = true;
rAssetTable.AddClipPath(rImportedAssetPath, AssetDatabase.AssetPathToGUID(rImportedAssetPath));
rImportedClip = null;
EditorUtility.UnloadUnusedAssets( );
continue;
}
GameObject rImportedGameObject = (GameObject)AssetDatabase.LoadAssetAtPath(rImportedAssetPath, typeof(GameObject));
if (rImportedGameObject != null)
{
//Debug.Log ( "Imported game object " + rImportedAssetPath );
ms_oGameObjectGUIDsToPostProcess.Add(AssetDatabase.AssetPathToGUID(rImportedAssetPath));
bPostprocessPrefabs = true;
rImportedGameObject = null;
EditorUtility.UnloadUnusedAssets( );
}
}
else
{
// ... remove the asset path from our list if it was already processed
ms_oImportedTexturesWithUpdatedUni2DGUIDs.Remove(rImportedAssetPath);
}
}
// Moved assets
for (int iIndex = 0, iCount = a_rMovedAssets.Length; iIndex < iCount; ++iIndex)
{
//Debug.Log ( "Importing moved asset" );
Uni2DTextureAtlas rMovedAtlas = (Uni2DTextureAtlas)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DTextureAtlas));
if (rMovedAtlas != null)
{
rAssetTable.RemoveAtlasFromPath(a_rMovedFromPath[iIndex], false);
rAssetTable.AddAtlasPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex]));
bSaveTable = true;
rMovedAtlas = null;
EditorUtility.UnloadUnusedAssets( );
continue;
}
Uni2DAnimationClip rMovedClip = (Uni2DAnimationClip)AssetDatabase.LoadAssetAtPath(a_rMovedAssets[iIndex], typeof(Uni2DAnimationClip));
if (rMovedClip != null)
{
rAssetTable.RemoveClipFromPath(a_rMovedFromPath[iIndex], false);
rAssetTable.AddClipPath(a_rMovedAssets[iIndex], AssetDatabase.AssetPathToGUID(a_rMovedAssets[iIndex]));
bSaveTable = true;
rMovedClip = null;
EditorUtility.UnloadUnusedAssets( );
}
}
// Deleted assets
foreach (string rDeletedAsset in a_rDeletedAssets)
{
string[] rSpritePrefabGUIDs = rAssetTable.GetSpritePrefabGUIDsUsingThisAtlasPath(rDeletedAsset);
if (rSpritePrefabGUIDs.Length > 0)
{
bUpdateAssets = true;
ms_oSpritePrefabGUIDsToUpdate.UnionWith(rSpritePrefabGUIDs);
}
/*
* // TODO: mettre des paths au lieu d'IDs
* string[ ] rClipGUIDs = rAssetTable.GetClipGUIDsUsingThisTexturePath( rDeletedAsset );
* if( rClipGUIDs.Length > 0 )
* {
* bUpdateAssets = true;
* ms_oAnimationClipGUIDsToUpdate.UnionWith( rClipGUIDs );
* }
*/
bSaveTable = rAssetTable.RemoveAtlasFromPath(rDeletedAsset, true) || bSaveTable;
bSaveTable = rAssetTable.RemoveClipFromPath(rDeletedAsset, true) || bSaveTable;
}
if (bSaveTable)
{
rAssetTable.Save( );
}
if (bUpdateAssets)
{
ms_oAtlasGUIDsToUpdate.UnionWith(rAssetTable.GetAtlasGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs));
ms_oAnimationClipGUIDsToUpdate.UnionWith(rAssetTable.GetClipGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs));
ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseTextures(ms_oImportedTextureGUIDs));
ms_oSpritePrefabGUIDsToUpdate.UnionWith(rAssetTable.GetSpritePrefabGUIDsUsingTheseAtlases(ms_oAtlasGUIDsToUpdate));
EditorApplication.delayCall += UpdateUni2DAssets;
}
if (bPostprocessPrefabs)
{
EditorApplication.delayCall += OnSpritePrefabPostprocess;
}
}
}
// NEW
private GameObject CreateSprite(Texture2D a_rTexture, bool a_bPhysic)
{
// Get default Uni2DSprite settings, according to a_bPhysic argument
return(Uni2DEditorSpriteBuilderUtils.GenerateSpriteFromSettings(new Uni2DEditorSpriteSettings(a_rTexture, a_bPhysic)));
}
