How to change individual spritesheet in TextureImporter object without regenerating all spriteIDs

Hello @chilon
Sorry that we missed this question. This territory is unfortunately not very well documented. I'll bring this back to the team to see what we can do in future versions. While we wait for that, I took the time to write you a sample that can help you along towards your goal.

[Written and tested in Unity 2020.3]

Code (CSharp):

1. using UnityEditor;
2. using UnityEditor.U2D.Sprites;
3. using UnityEngine;
4.  
5. public static class PivotUpdater
6. {
7.     [MenuItem("Custom/Update Sprite Pivots")]
8.     static void UpdatePivot()
9.     {
10.         foreach (var obj in Selection.objects)
11.         {
12.             if (obj is Texture2D)
13.             {
14.                 var factory = new SpriteDataProviderFactories();
15.                 factory.Init();
16.                 var dataProvider = factory.GetSpriteEditorDataProviderFromObject(obj);
17.                 dataProvider.InitSpriteEditorDataProvider();
18.  
19.                 SetPivot(dataProvider, new Vector2(3, 4));
20.                 SetPhysicsShape(dataProvider);
21.              
22.                 dataProvider.Apply();
23.              
24.                 // Optional: If you want to auto save your changes
25.                 AutoSaveChanges(dataProvider);
26.             }
27.         }
28.     }
29.  
30.     static void SetPivot(ISpriteEditorDataProvider dataProvider, Vector2 pivot)
31.     {
32.         var spriteRects = dataProvider.GetSpriteRects();
33.         foreach (var rect in spriteRects)
34.         {
35.             rect.pivot = pivot;
36.             rect.alignment = SpriteAlignment.Custom;
37.         }
38.         dataProvider.SetSpriteRects(spriteRects);
39.     }
40.  
41.     static void SetPhysicsShape(ISpriteEditorDataProvider dataProvider)
42.     {
43.         var physicsOutlineDataProvider = dataProvider.GetDataProvider<ISpritePhysicsOutlineDataProvider>();
44.         var rects = dataProvider.GetSpriteRects();
45.         foreach (var rect in rects)
46.         {
47.             var outlines = physicsOutlineDataProvider.GetOutlines(rect.spriteID);
48.             // Do changes
49.             physicsOutlineDataProvider.SetOutlines(rect.spriteID, outlines);
50.         }
51.     }
52.  
53.     static void AutoSaveChanges(ISpriteEditorDataProvider dataProvider)
54.     {
55.         var assetImporter = dataProvider.targetObject as AssetImporter;
56.         assetImporter.SaveAndReimport();
57.     }
58. }

So the main gist is that you need to work through the different data providers. These data providers will help you update the Sprite Rect data in a valid way so that it can be stored back into the .meta file with the same format.

For physics, you need to use the

ISpritePhysicsOutlineDataProvider

, you can find a bit more info about it here. In this script reference link, you can also see more data providers that exist, to be used to modify other pieces of Sprite Rect data.

Let me know how it goes!

 

Thank you for the feedback @Lo-renzo
The UI and UI interactions in the Sprite Editor Window is a different system which makes use of these data providers from my example. Which part more exactly would benefit from increased extensibility? Do you have any examples of what you would like to do, which you cannot do today?

 

I see, thanks for the clarification. Yeah, so the SpriteEditorWindow is fully internal and currently does not allow any external functionality to be built on-top of it. The way you would be able to accomplish this task is to create your own editor tool with the data providers.
It is good to know that you would like to see us adding ways to extend/build on top of the existing editor window. I will bring this feedback, and your previous feedback, to the team and we'll use it as a base for discussions on future improvements of the editor window.

Let us know if you have any other ideas on what could be improved/what is missing.

 

@ZenTeapot I put together a small sample script to demonstrate how you would go about changing a Sprites name using the data providers. Note the additional step you need to perform in Unity 2021.2 and newer.

Let me know if it answers your question.

[Tested with Unity 2022.2]

Code (CSharp):

1. using UnityEditor;
2. using UnityEditor.U2D.Sprites;
3. using UnityEngine;
4.  
5. public class SpriteName : MonoBehaviour
6. {
7.     [MenuItem("Custom/Update Sprite Name")]
8.     static void UpdateName()
9.     {
10.         foreach (var obj in Selection.objects)
11.         {
12.             if (obj is Texture2D)
13.             {
14.                 var factory = new SpriteDataProviderFactories();
15.                 factory.Init();
16.                 var dataProvider = factory.GetSpriteEditorDataProviderFromObject(obj);
17.                 dataProvider.InitSpriteEditorDataProvider();
18.  
19.                 SetSpriteName(dataProvider);
20.  
21.                 dataProvider.Apply();
22.                
23.                 var assetImporter = dataProvider.targetObject as AssetImporter;
24.                 assetImporter.SaveAndReimport();
25.             }
26.         }
27.     }
28.  
29.     static void SetSpriteName(ISpriteEditorDataProvider dataProvider)
30.     {
31.         var spriteRects = dataProvider.GetSpriteRects();
32.         for (var i = 0; i < spriteRects.Length; ++i)
33.             spriteRects[i].name = GetRandomName();
34.         dataProvider.SetSpriteRects(spriteRects);
35.        
36.         // Additional step for Unity 2021.2 and newer
37.         var nameFileIdDataProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
38.         var pairs = nameFileIdDataProvider.GetNameFileIdPairs();
39.         foreach (var pair in pairs)
40.         {
41.             var spriteRect = System.Array.Find(spriteRects, x => x.spriteID == pair.GetFileGUID());
42.             pair.name = spriteRect.name;
43.         }
44.        
45.         nameFileIdDataProvider.SetNameFileIdPairs(pairs);
46.         // End
47.     }
48.  
49.     static string GetRandomName()
50.     {
51.         return GUID.Generate().ToString();
52.     }
53. }
54.  

 

Agreed! We have just created a few samples on how to work with the APIs, which will be available in the 2D Sprite package's documentation once it lands.

 

Sure! It all comes down to retaining the reference to a Sprite in different consumers of Sprites (such as SpriteRenderer). When you are working in the Sprite Editor Window, you can do many different operations on a Sprite, and the reference to that Sprite tends to remain. Only tracking a Sprite by its name is not enough to keep the reference intact, we also need an ID to the Sprite as a backup, in case we cannot resolve the Sprite only by its name.

In Unity 2021.2, we updated the way we track these Name + IDs, and introduced the

ISpriteNameFileIdDataProvider

interface. We did this to introduce more flexibility in how a Sprite reference could be resolved.

The reason why I am adding this extra step in my examples is because without it, you run the chance of losing the reference to a Sprite when combining your custom Sprite edit tool with the Sprite Editor Window. If you are not relying on the Sprite Editor Window when authoring new Sprites, this step can be dropped, as you would be responsible for keeping track of the Sprites IDs between iterations.

 

Update: We have added a section to the 2D Sprite package's documentation, where we show samples on how to use

ISpriteEditorDataProvider

and its friends. Have a look, and let me know if you have any feedback!

https://docs.unity3d.com/Packages/com.unity.2d.sprite@1.0/manual/DataProvider.html

 

Thanks for the feedback! Let me see if we can add a renaming sample as well.

 

Thank you for your kind words, @ZenTeapot. I'm happy we could help out, and be sure that we are trying our best to help our users, but sometimes it takes a bit of time before we are able to roll out the changes.

Happy developing!

 

In the TextureImporter's SetSpriteRects implementation, we do not write the data back to the Name/FileId map, so the data stored in the Sprite Rects vs. the data stored in the Name/FileId map will diverge if you skip the SetFileIdPairs-call. This means that if there is a contention for either the name or an ID, whatever is stored in the Name/FileId map will win over what's stored in a Sprite Rect, which in turn will most likely lead to a broken reference.

 

Sounds like a neat tool!

The FileIds in the Name/FileId map are local to the texture and are not being used to compare across multiple textures, so copying this data over shouldn't cause any issues.

Regarding the suggested implementation, I would go for a new ID for any copied data. The reason is that in the rare occasion that you need to debug this data, you have a smaller chance to have the same ID used for two Sprites in different textures, which makes for clearer debugging.

 

Nice one, thanks for sharing your solution with the community!

 

It is up to each importer how they would like to generate and store the ids of the individual objects. PsdImporter does not make use of ISpriteNameFileIdDataProvider, since its primary use is to import layers from Photoshop. These layers have a GUID (in most cases, depending on the DCC tool creating the .psd/.psb file) which is being used to identify a layer and keep its id intact even though the name may change outside of Unity.