Question Ordering of imports using AssetImportContext.DependsOnArtifact() is wrong?

Hi @Harryh_h !

References to other assets in a ScriptedImport may fail during the import (because the reference may not exist yet and the c# code cannot deal with it...)
The correct way to write your DependentImporter is to use a LazyLoadReference instead of a direct reference.

Code (CSharp):

1. using UnityEditor;
2. using UnityEditor.AssetImporters;
3. using UnityEngine;
4. [ScriptedImporter(1, ".dependent")]
5. public class DependentImporter : ScriptedImporter
6. {
7.     [SerializeField] LazyLoadReference<Dependency> dependency;
8.     public override void OnImportAsset(AssetImportContext ctx)
9.     {
10.         if (dependency.isSet && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(dependency, out var guid, out long _))
11.             ctx.DependsOnArtifact(guid);
12.         Debug.Log("Dependent Object depending on " + dependency.asset);
13.     }
14.     [MenuItem("Assets/Create/Dependent Object", false, 0)]
15.     private static void CreateNewAsset()
16.     {
17.         ProjectWindowUtil.CreateAssetWithContent("Dependent Object.dependent", string.Empty);
18.     }
19. }

Edit: You may see multiple import of the DependentImporter, because the assetdatabase resolves dependencies on the fly and may try to import the DependentImporter once before importing the Dependency, then re-import it after once the dependency is ready.
To avoid that, you can specify a priority order in the ScriptedImporter attribute so that DependentImporters are always imported after DependencyImporters.

 

Are you moving your imported file along with its .meta file?
The .meta file contains a unique GUID that is used by other assets and scenes to reference your assets and subasset (in this case the sprites), if the guid changes, then any references to it will be lost in your project.
Looking specifically at the Palette, it keeps a link to the Tile asset GUID itself, and also to the Sprite used by the Tile, so if you're using a ScriptedImporter that generate both Sprites and Tiles, your Palette prefab should contains that guid twice (or more if you have multiple Tiles/Sprites linked to the same palette).
It should look like that in the .prefab file (fileID and guid being specific to my local tests):

Code (CSharp):

1.   m_TileAssetArray:
2.   - m_RefCount: 1
3.     m_Data: {fileID: -4990108416319592044, guid: 4d3a91d68d1e2f246a597041ba24f4d7, type: 3}
4.   m_TileSpriteArray:
5.   - m_RefCount: 1
6.     m_Data: {fileID: 8442006906113355076, guid: 4d3a91d68d1e2f246a597041ba24f4d7, type: 3}

 

Can you report a bug with your project and send me the bug number here? I'll be able to have a look early next week and figure out what's going on.
From what I can tell, the Palette should only use the tiles and sprites as a reference and the import order should not impact that, but maybe there is an issue with the Prefab system or the Palette itself.

 

Just wanted to clarify - I think there's an issue with this code, in that it uses TryGetGUIDAndLocalFileIdentifier to get a string-form GUID, which it then passes to DependsOnArtifact directly.

The problem being that when you pass a string to DependsOnArtifact, it expects it to be a path.

So instead, the code should be:

Code (CSharp):

1.         if (dependency.isSet && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(dependency, out var guid, out long _))
2.             ctx.DependsOnArtifact(new GUID(guid));

 

I'd refer you to our documentation:
https://docs.unity3d.com/2022.3/Doc...ers.AssetImportContext.DependsOnArtifact.html
Each piece of code displayed on the documentation is run in a test suite to make sure it compiles. While it doesn't make sure the code is doing what it says it does, we have internal unit tests making sure each method is working as expected and our documentation examples are usually very similar to the tests, cleaned from some specifics of our test system that makes the code harder to understand.

Regarding this specific error, this is probably because you are declaring a dependency on an asset that you are not loading.
I know this is a bit cumbersome, but it is required to call AssetDatabase.LoadAssetAtPath before or after declaring the dependency to tell the AssetDatabase that you are actually trying to use this asset (even if you already have a direct reference to it, that reference may not be up to date and loading the asset is preferred).

 

Circling back on this code snippet per Bastien's response.

In order for the artifact dependency to "hang around", you must attempt to load the asset after setting up the dependency, so it'd be more like this, if you encounter that warning message:

Code (CSharp):

1.         if (dependency.isSet && AssetDatabase.TryGetGUIDAndLocalFileIdentifier(dependency, out var guid, out long _))
2.         {
3.             var actualGuid = new GUID(guid);
4.             ctx.DependsOnArtifact(actualGuid);
5.             AssetDatabase.LoadAssetAtPath<TheTypeOfTheArtifactYouWantToLoad>(AssetDatabase.GUIDToAssetPath(actualGuid));
6.         }

 

You still have to call LoadAssetAtPath to tell the AssetDatabse that this has been loaded explicitly.

By the way, the Import Activity Window is a very good way to make sure dependencies are properly added to your imported assets and check reasons for re-import whenever it happens and you didn't expect it:
https://docs.unity3d.com/Manual/ImportActivityWindow.html