/// <summary>
/// Decrements reference count of an <see cref="AssetReference"/>.
/// </summary>
/// <param name="assetReference"></param>
/// <param name="publicReference"></param>
internal void DecrementReference(AssetReference assetReference, bool publicReference)
{
int referenceCount;
if (publicReference)
{
if (assetReference.PublicReferenceCount <= 0)
throw new InvalidOperationException("Cannot release an object that doesn't have active public references. Load/Unload pairs must match.");
referenceCount = --assetReference.PublicReferenceCount + assetReference.PrivateReferenceCount;
}
else
{
if (assetReference.PrivateReferenceCount <= 0)
throw new InvalidOperationException("Cannot release an object that doesn't have active private references. This is either due to non-matching Load/Unload pairs or an engine internal error.");
referenceCount = --assetReference.PrivateReferenceCount + assetReference.PublicReferenceCount;
}
if (referenceCount == 0)
{
// Free the object itself
ReleaseAsset(assetReference);
// Free all its referenced objects
foreach (var reference in assetReference.References)
{
DecrementReference(reference, false);
}
}
else if (publicReference && assetReference.PublicReferenceCount == 0)
{
// If there is no more public reference but object is still alive, let's kick a cycle GC
CollectUnreferencedCycles();
}
}
public IEnumerable<AssetReference> LoadAssets(AssetContainer<Func<Texture2D>> textureContainer,
AssetContainer<SpriteFont> fontContainer)
{
var assetTileReference = new AssetReference(typeof(ITile), Color.White, "blank");
var snakeHeadReference = new AssetReference(typeof(SnakePiece), Color.White, "snakeHead");
var snakeBodyReference = new AssetReference(typeof(SnakePiece), Color.Blue, "snakeBody");
try
{
textureContainer.Add(assetTileReference.Reference,
content => new StaticTexture(content.Load<Texture2D>(@"Map/tile")).GetTexture);
textureContainer.Add(snakeHeadReference.Reference,
content => new StaticTexture(content.Load<Texture2D>(@"Mobs/snakeHead")).GetTexture);
textureContainer.Add(snakeBodyReference.Reference,
content => new StaticTexture(content.Load<Texture2D>(@"Mobs/snakeBody")).GetTexture);
fontContainer.Add("scoreFont", content => content.Load<SpriteFont>(@"Fonts/scoreFont"));
}
catch (Exception ex)
{
Debug.Write("Error while loading content " + ex.Message);
throw;
}
return new List<AssetReference>
{
assetTileReference,
snakeHeadReference,
snakeBodyReference
};
}
/// <summary>
/// Releases an asset.
/// </summary>
/// <param name="assetReference">The asset reference.</param>
private void ReleaseAsset(AssetReference assetReference)
{
var referencable = assetReference.Object as IReferencable;
if (referencable != null)
{
referencable.Release();
}
else
{
var disposable = assetReference.Object as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
// Remove AssetReference from loaded assets.
var oldPrev = assetReference.Prev;
var oldNext = assetReference.Next;
if (oldPrev != null)
oldPrev.Next = oldNext;
if (oldNext != null)
oldNext.Prev = oldPrev;
if (oldPrev == null)
{
if (oldNext == null)
LoadedAssetUrls.Remove(assetReference.Url);
else
LoadedAssetUrls[assetReference.Url] = oldNext;
}
LoadedAssetReferences.Remove(assetReference.Object);
assetReference.Object = null;
}
/// <summary>
/// Increments reference count of an <see cref="AssetReference"/>.
/// </summary>
/// <param name="assetReference"></param>
/// <param name="publicReference"></param>
internal void IncrementReference(AssetReference assetReference, bool publicReference)
{
if (publicReference)
{
assetReference.PublicReferenceCount++;
}
else
{
assetReference.PrivateReferenceCount++;
}
}
public AssetManifestBuilder_Tests()
{
var asset = new Mock<IAsset>();
asset.SetupGet(a => a.SourceFile.FullPath).Returns("~/asset");
bundleReference = new AssetReference("~/bundle", asset.Object, 1, AssetReferenceType.DifferentBundle);
urlReference = new AssetReference("http://example.com/", asset.Object, 2, AssetReferenceType.Url);
rawFileReference = new AssetReference("~/file", asset.Object, 3, AssetReferenceType.RawFilename);
var sameBundleReference = new AssetReference("~/same", asset.Object, 4, AssetReferenceType.SameBundle);
asset.SetupGet(a => a.References)
.Returns(new[] { bundleReference, urlReference, rawFileReference, sameBundleReference });
var builder = new AssetManifestBuilder();
manifest = builder.BuildManifest(asset.Object);
}
/// <summary>
/// Generate a precompiled sprite font from the current sprite font asset.
/// </summary>
/// <param name="asset">The sprite font asset</param>
/// <param name="sourceAsset">The source sprite font asset item</param>
/// <param name="texturePath">The path of the source texture</param>
/// <param name="srgb">Indicate if the generated texture should be srgb</param>
/// <returns>The precompiled sprite font asset</returns>
public static PrecompiledSpriteFontAsset GeneratePrecompiledSDFSpriteFont(this SpriteFontAsset asset, AssetItem sourceAsset, string texturePath)
{
// TODO create PrecompiledSDFSpriteFontAsset
var scalableFont = (SignedDistanceFieldSpriteFont)SignedDistanceFieldFontCompiler.Compile(FontDataFactory, asset);
var referenceToSourceFont = new AssetReference<SpriteFontAsset>(sourceAsset.Id, sourceAsset.Location);
var glyphs = new List<Glyph>(scalableFont.CharacterToGlyph.Values);
var textures = scalableFont.Textures;
var imageType = ImageFileType.Png;
var textureFileName = new UFile(texturePath).GetFullPathWithoutExtension() + imageType.ToFileExtension();
if (textures != null && textures.Count > 0)
{
// save the texture TODO support for multi-texture
using (var stream = File.OpenWrite(textureFileName))
scalableFont.Textures[0].GetSerializationData().Save(stream, imageType);
}
var precompiledAsset = new PrecompiledSpriteFontAsset
{
Glyphs = glyphs,
Size = asset.FontType.Size,
Style = asset.FontSource.Style,
OriginalFont = referenceToSourceFont,
FontDataFile = textureFileName,
BaseOffset = scalableFont.BaseOffsetY,
DefaultLineSpacing = scalableFont.DefaultLineSpacing,
ExtraSpacing = scalableFont.ExtraSpacing,
ExtraLineSpacing = scalableFont.ExtraLineSpacing,
DefaultCharacter = asset.DefaultCharacter,
FontName = asset.FontSource.GetFontName(),
IsPremultiplied = asset.FontType.IsPremultiplied,
IsSrgb = false,
};
return precompiledAsset;
}
/// <summary>
/// Generate a precompiled sprite font from the current sprite font asset.
/// </summary>
/// <param name="asset">The sprite font asset</param>
/// <param name="sourceAsset">The source sprite font asset item</param>
/// <param name="texturePath">The path of the source texture</param>
/// <param name="srgb">Indicate if the generated texture should be srgb</param>
/// <returns>The precompiled sprite font asset</returns>
public static PrecompiledSpriteFontAsset GeneratePrecompiledSpriteFont(this SpriteFontAsset asset, AssetItem sourceAsset, string texturePath, bool srgb)
{
var staticFont = (StaticSpriteFont)StaticFontCompiler.Compile(FontDataFactory, asset, srgb);
var referenceToSourceFont = new AssetReference<SpriteFontAsset>(sourceAsset.Id, sourceAsset.Location);
var glyphs = new List<Glyph>(staticFont.CharacterToGlyph.Values);
var textures = staticFont.Textures;
var imageType = ImageFileType.Png;
var textureFileName = new UFile(texturePath).GetFullPathWithoutExtension() + imageType.ToFileExtension();
if (textures != null && textures.Count > 0)
{
// save the texture TODO support for multi-texture
using (var stream = File.OpenWrite(textureFileName))
staticFont.Textures[0].GetSerializationData().Save(stream, imageType);
}
var precompiledAsset = new PrecompiledSpriteFontAsset
{
Glyphs = glyphs,
Size = asset.Size,
Style = asset.Style,
Source = referenceToSourceFont,
FontDataFile = textureFileName,
BaseOffset = staticFont.BaseOffsetY,
DefaultLineSpacing = staticFont.DefaultLineSpacing,
ExtraSpacing = staticFont.ExtraSpacing,
ExtraLineSpacing = staticFont.ExtraLineSpacing,
DefaultCharacter = asset.DefaultCharacter,
FontName = !string.IsNullOrEmpty(asset.Source) ? (asset.Source.GetFileName() ?? "") : asset.FontName,
IsPremultiplied = asset.IsPremultiplied,
IsSrgb = srgb
};
return precompiledAsset;
}
/// <summary>
/// Checks if a default scene exists for this game package.
/// </summary>
/// <param name="log">The log to output the result of the validation.</param>
public override void Run(ILogger log)
{
if (log == null) throw new ArgumentNullException("log");
foreach (var package in Session.Packages)
{
// Make sure package has its assets loaded
if (package.State < PackageState.AssetsReady)
continue;
var hasGameExecutable = package.Profiles.SelectMany(profile => profile.ProjectReferences).Any(projectRef => projectRef.Type == ProjectType.Executable);
if (!hasGameExecutable)
{
continue;
}
var sharedProfile = package.Profiles.FindSharedProfile();
if (sharedProfile == null) continue;
var defaultScene = sharedProfile.Properties.Get(GameSettingsAsset.DefaultScene);
// If the pdxpkg does not reference any scene
if (defaultScene == null)
{
log.Error(package, null, AssetMessageCode.DefaultSceneNotFound, null);
// Creates a new default scene
// Checks we don't overwrite an existing asset
const string defaultSceneLocation = GameSettingsAsset.DefaultSceneLocation;
var existingDefault = package.Assets.Find(defaultSceneLocation);
if (existingDefault != null && existingDefault.Asset is SceneAsset)
{
// A scene at the default location already exists among the assets, let's reference it as the default scene
var sceneAsset = new AssetReference<SceneAsset>(existingDefault.Id, existingDefault.Location);
GameSettingsAsset.SetDefaultScene(package, sceneAsset);
}
else if (existingDefault != null)
{
// Very rare case: the default scene location is occupied by another asset which is not a scene
// Compute a new default name to not overwrite the existing asset
var newName = NamingHelper.ComputeNewName(defaultSceneLocation, package.Assets, a => a.Location);
GameSettingsAsset.CreateAndSetDefaultScene(package, newName);
}
else
{
// Creates a new default scene asset
GameSettingsAsset.CreateAndSetDefaultScene(package, defaultSceneLocation);
}
continue;
}
// The pdxpkg references an asset
var defaultAsset = package.Assets.Find(defaultScene.Location);
if (defaultAsset != null) continue; // Default scene exists and is referenced
// The asset referenced does not exist, create it
log.Error(package, defaultScene, AssetMessageCode.AssetNotFound, defaultScene);
GameSettingsAsset.CreateAndSetDefaultScene(package);
}
}
private void SerializeObject(Queue <SerializeOperation> serializeOperations, string url, object obj, bool publicReference)
{
// Don't create context in case we don't want to serialize referenced objects
//if (!SerializeReferencedObjects && obj != RootObject)
// return null;
// Already saved?
// TODO: Ref counting? Should we change it on save? Probably depends if we cache or not.
if (LoadedAssetReferences.ContainsKey(obj))
{
return;
}
var serializer = Serializer.GetSerializer(null, obj.GetType());
if (serializer == null)
{
throw new InvalidOperationException(string.Format("Content serializer for {0} could not be found.", obj.GetType()));
}
var contentSerializerContext = new ContentSerializerContext(url, ArchiveMode.Serialize, this);
using (var stream = FileProvider.OpenStream(url, VirtualFileMode.Create, VirtualFileAccess.Write))
{
var streamWriter = new BinarySerializationWriter(stream);
PrepareSerializerContext(contentSerializerContext, streamWriter.Context);
ChunkHeader header = null;
// Allocate space in the stream, and also include header version in the hash computation, which is better
// If serialization type is null, it means there should be no header.
var serializationType = serializer.SerializationType;
if (serializationType != null)
{
header = new ChunkHeader();
header.Type = serializer.SerializationType.AssemblyQualifiedName;
header.Write(streamWriter);
header.OffsetToObject = (int)streamWriter.NativeStream.Position;
}
contentSerializerContext.SerializeContent(streamWriter, serializer, obj);
// Write references and updated header
if (header != null)
{
header.OffsetToReferences = (int)streamWriter.NativeStream.Position;
contentSerializerContext.SerializeReferences(streamWriter);
// Move back to the pre-allocated header position in the steam
stream.Seek(0, SeekOrigin.Begin);
// Write actual header.
header.Write(new BinarySerializationWriter(stream));
}
}
var assetReference = new AssetReference(url, publicReference);
contentSerializerContext.AssetReference = assetReference;
SetAssetObject(assetReference, obj);
// Process content references
// TODO: Should we work at ChunkReference level?
foreach (var contentReference in contentSerializerContext.ContentReferences)
{
if (contentReference.ObjectValue != null)
{
var attachedReference = AttachedReferenceManager.GetAttachedReference(contentReference.ObjectValue);
if (attachedReference == null || attachedReference.IsProxy)
{
continue;
}
serializeOperations.Enqueue(new SerializeOperation(contentReference.Location, contentReference.ObjectValue, false));
}
}
}
public static T SetConditionStartParticleReference <T>(this T entity, AssetReference value)
where T : EffectParticleParameters
{
entity.SetField("conditionStartParticleReference", value);
return(entity);
}
public static T SetEmissiveBorderSurfaceParticleReference <T>(this T entity, AssetReference value)
where T : EffectParticleParameters
{
entity.SetField("emissiveBorderSurfaceParticleReference", value);
return(entity);
}
private void LoadAsset(AssetMigrationContext context, PackageLoadingAssetFile assetFile, LoggerResult loggerResult)
{
var fileUPath = assetFile.FilePath;
var sourceFolder = assetFile.SourceFolder;
// Check if asset has been deleted by an upgrader
if (assetFile.Deleted)
{
IsDirty = true;
lock (filesToDelete)
{
filesToDelete.Add(assetFile.FilePath);
}
// Don't create temporary assets for files deleted during package upgrading
return;
}
// An exception can occur here, so we make sure that loading a single asset is not going to break
// the loop
try
{
AssetMigration.MigrateAssetIfNeeded(context, assetFile, PackageStore.Instance.DefaultPackageName);
// Try to load only if asset is not already in the package or assetRef.Asset is null
var assetPath = assetFile.AssetPath;
var assetFullPath = fileUPath.FullPath;
var assetContent = assetFile.AssetContent;
var projectInclude = assetFile.ProjectFile != null ? fileUPath.MakeRelative(assetFile.ProjectFile.GetFullDirectory()) : null;
bool aliasOccurred;
var asset = LoadAsset(context.Log, assetFullPath, assetPath, assetFile.ProjectFile, projectInclude, assetContent, out aliasOccurred);
// Create asset item
var assetItem = new AssetItem(assetPath, asset, this)
{
IsDirty = assetContent != null || aliasOccurred,
SourceFolder = sourceFolder.MakeRelative(RootDirectory),
SourceProject = asset is SourceCodeAsset && assetFile.ProjectFile != null ? assetFile.ProjectFile : null
};
// Set the modified time to the time loaded from disk
if (!assetItem.IsDirty)
assetItem.ModifiedTime = File.GetLastWriteTime(assetFullPath);
// TODO: Let's review that when we rework import process
// Not fixing asset import anymore, as it was only meant for upgrade
// However, it started to make asset dirty, for ex. when we create a new texture, choose a file and reload the scene later
// since there was no importer id and base.
//FixAssetImport(assetItem);
// Add to temporary assets
lock (TemporaryAssets)
{
TemporaryAssets.Add(assetItem);
}
}
catch (Exception ex)
{
int row = 1;
int column = 1;
var yamlException = ex as YamlException;
if (yamlException != null)
{
row = yamlException.Start.Line + 1;
column = yamlException.Start.Column;
}
var module = context.Log.Module;
var assetReference = new AssetReference<Asset>(Guid.Empty, fileUPath.FullPath);
// TODO: Change this instead of patching LoggerResult.Module, use a proper log message
if (loggerResult != null)
{
loggerResult.Module = "{0}({1},{2})".ToFormat(Path.GetFullPath(fileUPath.FullPath), row, column);
}
context.Log.Error(this, assetReference, AssetMessageCode.AssetLoadingFailed, ex, fileUPath, ex.Message);
if (loggerResult != null)
{
loggerResult.Module = module;
}
}
}
// Sets the default scene within a package properties
public static void SetDefaultScene(Package package, AssetReference<SceneAsset> defaultScene)
{
package.Profiles.FindSharedProfile().Properties.Set(DefaultScene, defaultScene);
MarkPackageDirty(package);
}
private IEnumerator LoadAssets()
{
// 加载UI面板
GameLogger.Log("Load UIRoot.");
AssetReference rootRef = new AssetReference("UIPanel/UIRoot");
var rootHandle = rootRef.LoadAssetAsync <GameObject>();
yield return(rootHandle);
GameObject uiRoot = rootHandle.InstantiateObject; // 实例化对象
// 加载窗口
GameObject window;
{
AssetReference windowRef = new AssetReference("UIPanel/LoginWindow");
var handle = windowRef.LoadAssetAsync <GameObject>();
yield return(handle);
window = handle.InstantiateObject; // 实例化对象
window.transform.SetParent(uiRoot.transform, false);
var versionTxt = window.transform.BFSearch("Version").GetComponent <Text>();
if (MotionEngine.Contains(typeof(PatchManager)))
{
versionTxt.text = PatchManager.Instance.GetGameVersion();
}
else
{
versionTxt.text = "NO Server";
}
}
// 加载资源包
{
GameLogger.Log("Load texture package");
AssetReference packRef = new AssetReference("UITexture/Foods");
var handle1 = packRef.LoadAssetAsync <Texture>("eggs");
yield return(handle1);
Texture tex1 = handle1.AssetObject as Texture;
var handle2 = packRef.LoadAssetAsync <Texture>("apple");
yield return(handle2);
Texture tex2 = handle2.AssetObject as Texture;
// 设置纹理1
RawImage img1 = window.transform.BFSearch("FoodImg1").GetComponent <RawImage>();
img1.texture = tex1;
img1.SetNativeSize();
// 设置纹理2
RawImage img2 = window.transform.BFSearch("FoodImg2").GetComponent <RawImage>();
img2.texture = tex2;
img2.SetNativeSize();
}
// 加载模型
{
AssetReference entityRef = new AssetReference("Entity/Monster/Boss");
var handle = entityRef.LoadAssetAsync <GameObject>();
yield return(handle);
var sphere = handle.InstantiateObject; // 实例化对象
sphere.transform.position = new Vector3(5f, 0, 0);
sphere.transform.localScale = sphere.transform.localScale * 2f;
}
}
public void GivenAssetWithReferenceToUrl_WhenSaveContainer_ThenXmlHasReferenceElementWithUrlAsPath()
{
using (var cacheDir = new TempDirectory())
{
var settings = new CassetteSettings
{
SourceDirectory = Mock.Of<IDirectory>(),
CacheDirectory = new FileSystemDirectory(cacheDir)
};
var cache = new BundleCache("VERSION", settings);
var bundle = new TestableBundle("~/bundle-1");
var asset = StubAsset();
var reference = new AssetReference("http://test.com", asset.Object, -1, AssetReferenceType.Url);
asset.SetupGet(a => a.References)
.Returns(new[] { reference });
bundle.Assets.Add(asset.Object);
cache.SaveBundleContainer(new BundleContainer(new Bundle[] { bundle, new ExternalScriptBundle("http://test.com"), }));
var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml"));
xml.ShouldContain("<Reference Path=\"http://test.com\" />");
}
}
public static ShaderPair Load(GraphicsDevice device, AssetReference <ShaderAsset> frag, AssetReference <ShaderAsset> vert, ShaderType type)
{
var fragShader = loadShader(frag, device.device, VkShaderStageFlags.Fragment);
var vertShader = loadShader(vert, device.device, VkShaderStageFlags.Vertex);
return(new ShaderPair(device, type, fragShader, vertShader));
}
public static T SetPrefabReference <T>(this T entity, AssetReference value)
where T : MonsterPresentationDefinition
{
entity.SetField("prefabReference", value);
return(entity);
}
public OwnerRegisterDataSourceCommand(UniTask <IContext> contextTask, AssetReference resource) : base(contextTask, resource)
{
}
// Multi selection handling. Returns new list of selected instanceIDs
internal static List <int> GetNewSelection(ref AssetReference clickedEntry, List <int> allEntryInstanceIDs, List <string> allEntryGuids, List <int> selectedInstanceIDs, int lastClickedInstanceID, bool keepMultiSelection, bool useShiftAsActionKey, bool allowMultiSelection, bool shiftKeyIsDown, bool actionKeyIsDown)
{
bool useShift = shiftKeyIsDown || (actionKeyIsDown && useShiftAsActionKey);
bool useActionKey = actionKeyIsDown && !useShiftAsActionKey;
if (!allowMultiSelection)
{
useShift = useActionKey = false;
}
// Toggle selected node from selection
if (useActionKey)
{
var newSelection = new List <int>(selectedInstanceIDs);
if (newSelection.Contains(clickedEntry.instanceID))
{
newSelection.Remove(clickedEntry.instanceID);
}
else
{
if (TrySetInstanceId(ref clickedEntry))
{
newSelection.Add(clickedEntry.instanceID);
}
}
return(newSelection);
}
// Select everything between the first selected object and the selected
else if (useShift)
{
if (clickedEntry.instanceID == lastClickedInstanceID)
{
return(new List <int>(selectedInstanceIDs));
}
int firstIndex;
int lastIndex;
if (!GetFirstAndLastSelected(allEntryInstanceIDs, selectedInstanceIDs, out firstIndex, out lastIndex))
{
// We had no selection
var newSelection = new List <int>(1);
if (TrySetInstanceId(ref clickedEntry))
{
newSelection.Add(clickedEntry.instanceID);
}
return(newSelection);
}
int newIndex = -1;
int prevIndex = -1;
// Only valid in case the selection concerns assets
if (!TrySetInstanceId(ref clickedEntry))
{
return(new List <int>(selectedInstanceIDs));
}
int clickedInstanceID = clickedEntry.instanceID;
if (lastClickedInstanceID != 0)
{
for (int i = 0; i < allEntryInstanceIDs.Count; ++i)
{
if (allEntryInstanceIDs[i] == clickedInstanceID)
{
newIndex = i;
}
if (allEntryInstanceIDs[i] == lastClickedInstanceID)
{
prevIndex = i;
}
}
}
else
{
for (int i = 0; i < allEntryInstanceIDs.Count; ++i)
{
if (allEntryInstanceIDs[i] == clickedInstanceID)
{
newIndex = i;
}
}
}
System.Diagnostics.Debug.Assert(newIndex != -1); // new item should be part of visible folder set
int dir = 0;
if (prevIndex != -1)
{
dir = (newIndex > prevIndex) ? 1 : -1;
}
int from, to;
if (newIndex > lastIndex)
{
from = firstIndex;
to = newIndex;
}
else if (newIndex >= firstIndex && newIndex < lastIndex)
{
if (dir > 0)
{
from = newIndex;
to = lastIndex;
}
else
{
from = firstIndex;
to = newIndex;
}
}
else
{
from = newIndex;
to = lastIndex;
}
// Outcomment to debug
//Debug.Log (clickedEntry + ", firstIndex " + firstIndex + ", lastIndex " + lastIndex + ", newIndex " + newIndex + " " + ", lastClickedIndex " + prevIndex + ", from " + from + ", to " + to);
if (allEntryGuids == null)
{
return(allEntryInstanceIDs.GetRange(from, to - from + 1));
}
var foundInstanceIDs = TryGetInstanceIds(allEntryInstanceIDs, allEntryGuids, from, to);
if (foundInstanceIDs != null)
{
return(foundInstanceIDs);
}
return(new List <int>(selectedInstanceIDs));
}
// Just set the selection to the clicked object
else
{
if (keepMultiSelection)
{
// Don't change selection on mouse down when clicking on selected item.
// This is for dragging in case with multiple items selected or right click (mouse down should not unselect the rest).
if (selectedInstanceIDs.Contains(clickedEntry.instanceID))
{
return(new List <int>(selectedInstanceIDs));
}
}
if (TrySetInstanceId(ref clickedEntry))
{
var newSelection = new List <int>(1);
newSelection.Add(clickedEntry.instanceID);
return(newSelection);
}
else
{
return(new List <int>(selectedInstanceIDs));
}
}
}
internal static List <int> GetNewSelection(ref AssetReference clickedEntry, List <int> allEntryInstanceIDs, List <string> allEntryGuids, List <int> selectedInstanceIDs, int lastClickedInstanceID, bool keepMultiSelection, bool useShiftAsActionKey, bool allowMultiSelection)
{
return(GetNewSelection(ref clickedEntry, allEntryInstanceIDs, allEntryGuids, selectedInstanceIDs, lastClickedInstanceID, keepMultiSelection, useShiftAsActionKey, allowMultiSelection, Event.current.shift, EditorGUI.actionKey));
}
public static object GetAsset(AssetReference id)
{
if(id.index == -1)
return null;
try
{
return assetStore[id.type][id.name][id.index];
}
catch
{
return null;
}
}
public static T SetPrefabReference <T>(this T entity, AssetReference value)
where T : PrefabByEnvironmentDescription
{
entity.SetField("prefabReference", value);
return(entity);
}
public void GivenAssetWithReferenceToAnotherBundle_WhenSaveContainer_ThenXmlHasReferenceElementWithReferencedBundlePath()
{
using (var cacheDir = new TempDirectory())
{
var settings = new CassetteSettings
{
SourceDirectory = Mock.Of<IDirectory>(),
CacheDirectory = new FileSystemDirectory(cacheDir)
};
var cache = new BundleCache("VERSION", settings);
var bundle1 = new TestableBundle("~/bundle-1");
var bundle2 = new TestableBundle("~/bundle-2");
var asset1 = StubAsset();
var reference = new AssetReference("~/bundle-2", asset1.Object, -1, AssetReferenceType.DifferentBundle);
asset1.SetupGet(a => a.References)
.Returns(new[] { reference });
bundle1.Assets.Add(asset1.Object);
cache.SaveBundleContainer(new BundleContainer(new[] { bundle1, bundle2 }));
var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml"));
xml.ShouldContain("<Reference Path=\"~/bundle-2\" />");
}
}
// Token: 0x060011CE RID: 4558 RVA: 0x00073AC1 File Offset: 0x00071EC1
protected virtual void handleAssetReferenceDocked(AssetReference <T> assetReference)
{
base.inspectable.value = assetReference;
}
private static void UpdateRootAssets(RootAssetCollection rootAssetCollection, IReadOnlyDictionary<AssetId, Tuple<AssetId, UFile>> idRemap)
{
foreach (var rootAsset in rootAssetCollection.ToArray())
{
var id = rootAsset.Id;
Tuple<AssetId, UFile> remap;
if (idRemap.TryGetValue(id, out remap) && IsNewReference(remap, rootAsset))
{
var newRootAsset = new AssetReference(remap.Item1, remap.Item2);
rootAssetCollection.Remove(rootAsset.Id);
rootAssetCollection.Add(newRootAsset);
}
}
}
public Dictionary <Material, int> GetMaterialsData(MeshRenderer[] allRenderers)
{
float3 ColorToVector(Color c)
{
return(float3(c.r, c.b, c.g));
}
float2 GetVector2(float4 vec)
{
return(float2(vec.x, vec.y));
}
var dict = new Dictionary <Material, int>(allRenderers.Length);
allProperties = new List <MaterialProperties>(allRenderers.Length);
var albedoTexs = new List <Texture>(allRenderers.Length);
var normalTexs = new List <Texture>(allRenderers.Length);
var smoTexs = new List <Texture>(allRenderers.Length);
var emissionTex = new List <Texture>(allRenderers.Length);
var heightTex = new List <Texture>(allRenderers.Length);
var secondAlbedoTex = new List <Texture>(allRenderers.Length);
var secondBumpTex = new List <Texture>(allRenderers.Length);
var secondSpecTex = new List <Texture>(allRenderers.Length);
var albedoDict = new Dictionary <Texture, int>(allRenderers.Length);
var normalDict = new Dictionary <Texture, int>(allRenderers.Length);
var smoDict = new Dictionary <Texture, int>(allRenderers.Length);
var emissionDict = new Dictionary <Texture, int>(allRenderers.Length);
var heightDict = new Dictionary <Texture, int>(allRenderers.Length);
var secondAlbedoDict = new Dictionary <Texture, int>(allRenderers.Length);
var secondBumpDict = new Dictionary <Texture, int>(allRenderers.Length);
var secondSpecDict = new Dictionary <Texture, int>(allRenderers.Length);
int len = 0;
int GetTextureIndex(List <Texture> lst, Dictionary <Texture, int> texDict, Texture tex)
{
int ind = -1;
if (tex)
{
if (!texDict.TryGetValue(tex, out ind))
{
ind = lst.Count;
lst.Add(tex);
texDict.Add(tex, ind);
}
}
return(ind);
}
foreach (var r in allRenderers)
{
var ms = r.sharedMaterials;
foreach (var m in ms)
{
if (!m)
{
throw new System.Exception(r.name + " Has Null Mat");
}
if (!dict.ContainsKey(m))
{
dict.Add(m, len);
Texture albedo = m.GetTexture("_MainTex");
Texture normal = m.GetTexture("_BumpMap");
Texture smo = m.GetTexture("_SpecularMap");
Texture emission = m.GetTexture("_EmissionMap");
Texture height = m.GetTexture("_HeightMap");
Texture secondBump = m.GetTexture("_SecondaryBumpMap");
Texture secondAlbedo = m.GetTexture("_SecondaryMainTex");
Texture secondSpec = m.GetTexture("_SecondarySpecularMap");
int albedoIndex = GetTextureIndex(albedoTexs, albedoDict, albedo);
int normalIndex = GetTextureIndex(normalTexs, normalDict, normal);
int smoIndex = GetTextureIndex(smoTexs, smoDict, smo);
int emissionIndex = GetTextureIndex(emissionTex, emissionDict, emission);
int heightIndex = GetTextureIndex(heightTex, heightDict, height);
int secondBumpIndex = GetTextureIndex(secondBumpTex, secondBumpDict, secondBump);
int secondAlbedoIndex = GetTextureIndex(secondAlbedoTex, secondAlbedoDict, secondAlbedo);
int secondSpecIndex = GetTextureIndex(secondSpecTex, secondSpecDict, secondSpec);
allProperties.Add(new MaterialProperties
{
_Color = ColorToVector(m.GetColor("_Color")),
_Glossiness = m.GetFloat("_Glossiness"),
_DecalLayer = (uint)m.GetInt("_DecalLayer"),
_EmissionColor = ColorToVector(m.GetColor("_EmissionColor") * m.GetFloat("_EmissionMultiplier")),
_MetallicIntensity = m.GetFloat("_MetallicIntensity"),
_SpecularIntensity = m.GetFloat("_SpecularIntensity"),
_Occlusion = m.GetFloat("_Occlusion"),
_NormalIntensity = GetVector2(m.GetVector("_NormalIntensity")),
_TileOffset = m.GetVector("_TileOffset"),
_BumpMap = normalIndex,
_EmissionMap = emissionIndex,
_MainTex = albedoIndex,
_SpecularMap = smoIndex,
_HeightMap = heightIndex,
_HeightMapIntensity = m.GetFloat("_HeightmapIntensity"),
_SecondaryBumpMap = secondBumpIndex,
_SecondaryMainTex = secondAlbedoIndex,
_SecondarySpecularMap = secondSpecIndex,
_SecondaryTileOffset = m.GetVector("_SecondaryTileOffset")
});
len++;
}
}
}
ComputeShader readRTDataShader = Resources.Load <ComputeShader>("ReadRTData");
void GetGUIDs(out AssetReference[] strs, List <Texture> texs, int typeIndex)
{
strs = new AssetReference[texs.Count];
for (int i = 0; i < texs.Count; ++i)
{
string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(texs[i]));
SetObjectAddressable(texs[i], guid);
strs[i] = new AssetReference(guid);
}
}
GetGUIDs(out albedoGUIDs, albedoTexs, 0);
GetGUIDs(out secondAlbedoGUIDs, secondAlbedoTex, 0);
GetGUIDs(out normalGUIDs, normalTexs, 1);
GetGUIDs(out secondNormalGUIDs, secondBumpTex, 1);
GetGUIDs(out smoGUIDs, smoTexs, 0);
GetGUIDs(out secondSpecGUIDs, secondSpecTex, 0);
GetGUIDs(out emissionGUIDs, emissionTex, 2);
GetGUIDs(out heightGUIDs, heightTex, 3);
EditorUtility.SetDirty(AddressableAssetSettingsDefaultObject.Settings);
return(dict);
}
public object GetAsset(AssetReference id)
{
if(id.index == -1)
return null;
try
{
var type = UnitySerializer.GetTypeEx(id.type);
Index<string, List<UnityEngine.Object>> nameLookup;
if(!assetReferences.TryGetValue(type, out nameLookup))
{
assetReferences[type] = nameLookup = new Index<string, List<UnityEngine.Object>>();
var objectsOfType = Resources.FindObjectsOfTypeAll(type).Except(UnityEngine.Object.FindObjectsOfType(type));
foreach(var reference in objectsOfType)
{
nameLookup[reference.name].Add(reference);
}
}
List<UnityEngine.Object> references;
if(!nameLookup.TryGetValue(id.name, out references))
{
return null;
}
if(id.index >= references.Count)
return null;
return references[id.index];
}
catch
{
return null;
}
}
public AsyncOperationHandle <GameObject> InstantiateReplicaAsync(AssetReference reference) => InstantiateReplicaAsync(reference.RuntimeKey, Vector3.zero, Quaternion.identity);
internal void RegisterDeserializedObject <T>(string url, T obj)
{
var assetReference = new AssetReference(url, false);
SetAssetObject(assetReference, obj);
}
public AsyncOperationHandle <GameObject> InstantiateReplicaAsync(AssetReference reference, Vector3 position, Quaternion rotation) => InstantiateReplicaAsync(reference.RuntimeKey, position, rotation);
public static T SetActiveEffectSurfaceStartParticleReference <T>(this T entity, AssetReference value)
where T : EffectParticleParameters
{
entity.SetField("activeEffectSurfaceStartParticleReference", value);
return(entity);
}
public void TestLoadAssetSync()
{
AssetReference result = m_AssetManager.LoadAssetSync("ArtResources/Prefabs/MyPrefab.prefab");
Assert.AreNotEqual(result, null);
}
void ManifestReferenceEqualsAssetReference(AssetReferenceManifest referenceManifest, AssetReference reference)
{
referenceManifest.Path.ShouldEqual(reference.Path);
referenceManifest.Type.ShouldEqual(reference.Type);
referenceManifest.SourceLineNumber.ShouldEqual(reference.SourceLineNumber);
}
bool IsUrlReferenceNotYetSeen(AssetReference reference)
{
var isUrl = reference.Type == AssetReferenceType.Url;
var alreadySeenUrl = existingUrls.Contains(reference.ToPath);
return isUrl && !alreadySeenUrl;
}
private static void UpdateRootAssets(RootAssetCollection rootAssetCollection, Dictionary<Guid, Tuple<Guid, UFile>> idRemap, Dictionary<UFile, UFile> locationRemap)
{
foreach (var rootAsset in rootAssetCollection.ToArray())
{
var location = (UFile)rootAsset.Location;
var id = rootAsset.Id;
Tuple<Guid, UFile> newId;
UFile newLocation;
bool changed = false;
if (idRemap.TryGetValue(id, out newId))
{
id = newId.Item1;
location = newId.Item2;
changed = true;
}
if (!changed && locationRemap.TryGetValue(location, out newLocation))
{
location = newLocation;
changed = true;
}
if (changed)
{
var newRootAsset = new AssetReference<Asset>(id, location);
rootAssetCollection.Remove(rootAsset.Id);
rootAssetCollection.Add(newRootAsset);
}
}
}
/// <summary>
/// Generate an array of PricingStructurePoint from a set of input arrays
/// The array can then be added to the Matrix
/// </summary>
/// <param name="expiry">Expiry values to use</param>
/// <param name="strike">Strike values to use</param>
/// <param name="volatility">An array of volatility values</param>
/// <param name="strikeQuoteUnits">The strike quote units.</param>
/// <param name="underlyingAssetReference">The underlying asset.</param>
/// <returns></returns>
private PricingStructurePoint[] ProcessRawSurface(String[] expiry, Double[] strike, double[,] volatility, PriceQuoteUnits strikeQuoteUnits, AssetReference underlyingAssetReference)
{
var expiryLength = expiry.Length;
var strikeLength = strike.Length;
var pointIndex = 0;
var points = new PricingStructurePoint[expiryLength * strikeLength];
for (var expiryIndex = 0; expiryIndex < expiryLength; expiryIndex++)
{
// extract the current expiry
var expiryKeyPart = expiry[expiryIndex];
for (var strikeIndex = 0; strikeIndex < strikeLength; strikeIndex++)
{
// Extract the strike to use in the helper key
var strikeKeyPart = strike[strikeIndex];
// Extract the row,column indexed volatility
var vol = (decimal)volatility[expiryIndex, strikeIndex];
var key = new ExpiryTenorStrikeKey(expiryKeyPart, strikeKeyPart);
_matrixIndexHelper.Add(key, pointIndex);
// Add the value to the points array (dataPoints entry in the matrix)
var coordinates = new PricingDataPointCoordinate[1];
coordinates[0] = PricingDataPointCoordinateFactory.Create(expiry[expiryIndex], null, (Decimal)strike[strikeIndex]);
var pt = new PricingStructurePoint {
value = vol,
valueSpecified = true,
coordinate = coordinates,
underlyingAssetReference = underlyingAssetReference,
quoteUnits = strikeQuoteUnits
};
points[pointIndex++] = pt;
}
}
return(points);
}
/// <summary>
/// Refreshes this package from the disk by loading or reloading all assets.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="assetFiles">The asset files (loaded from <see cref="ListAssetFiles"/> if null).</param>
/// <param name="cancelToken">The cancel token.</param>
/// <returns>A logger that contains error messages while refreshing.</returns>
/// <exception cref="System.InvalidOperationException">Package RootDirectory is null
/// or
/// Package RootDirectory [{0}] does not exist.ToFormat(RootDirectory)</exception>
public void LoadTemporaryAssets(ILogger log, IList<PackageLoadingAssetFile> assetFiles = null, CancellationToken? cancelToken = null)
{
if (log == null) throw new ArgumentNullException("log");
// If FullPath is null, then we can't load assets from disk, just return
if (FullPath == null)
{
log.Warning("Fullpath not set on this package");
return;
}
// Clears the assets already loaded and reload them
TemporaryAssets.Clear();
// List all package files on disk
if (assetFiles == null)
assetFiles = ListAssetFiles(log, this, cancelToken);
var progressMessage = String.Format("Loading Assets from Package [{0}]", FullPath.GetFileNameWithExtension());
// Display this message at least once if the logger does not log progress (And it shouldn't in this case)
var loggerResult = log as LoggerResult;
if (loggerResult == null || !loggerResult.IsLoggingProgressAsInfo)
{
log.Info(progressMessage);
}
// Update step counter for log progress
for (int i = 0; i < assetFiles.Count; i++)
{
var fileUPath = assetFiles[i].FilePath;
var sourceFolder = assetFiles[i].SourceFolder;
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
log.Warning("Skipping loading assets. PackageSession.Load cancelled");
break;
}
// Update the loading progress
if (loggerResult != null)
{
loggerResult.Progress(progressMessage, i, assetFiles.Count);
}
// Check if asset has been deleted by an upgrader
if (assetFiles[i].Deleted)
{
IsDirty = true;
filesToDelete.Add(assetFiles[i].FilePath);
continue;
}
// An exception can occur here, so we make sure that loading a single asset is not going to break
// the loop
try
{
AssetMigration.MigrateAssetIfNeeded(log, assetFiles[i]);
// Try to load only if asset is not already in the package or assetRef.Asset is null
var assetPath = fileUPath.MakeRelative(sourceFolder).GetDirectoryAndFileName();
var assetFullPath = fileUPath.FullPath;
var assetContent = assetFiles[i].AssetContent;
var asset = LoadAsset(log, assetFullPath, assetPath, fileUPath, assetContent);
// Create asset item
var assetItem = new AssetItem(assetPath, asset)
{
IsDirty = assetContent != null,
Package = this,
SourceFolder = sourceFolder.MakeRelative(RootDirectory)
};
// Set the modified time to the time loaded from disk
if (!assetItem.IsDirty)
assetItem.ModifiedTime = File.GetLastWriteTime(assetFullPath);
// TODO: Let's review that when we rework import process
// Not fixing asset import anymore, as it was only meant for upgrade
// However, it started to make asset dirty, for ex. when we create a new texture, choose a file and reload the scene later
// since there was no importer id and base.
//FixAssetImport(assetItem);
// Add to temporary assets
TemporaryAssets.Add(assetItem);
}
catch (Exception ex)
{
int row = 1;
int column = 1;
var yamlException = ex as YamlException;
if (yamlException != null)
{
row = yamlException.Start.Line + 1;
column = yamlException.Start.Column;
}
var module = log.Module;
var assetReference = new AssetReference<Asset>(Guid.Empty, fileUPath.FullPath);
// TODO: Change this instead of patching LoggerResult.Module, use a proper log message
if (loggerResult != null)
{
loggerResult.Module = "{0}({1},{2})".ToFormat(Path.GetFullPath(fileUPath.FullPath), row, column);
}
log.Error(this, assetReference, AssetMessageCode.AssetLoadingFailed, ex, fileUPath, ex.Message);
if (loggerResult != null)
{
loggerResult.Module = module;
}
}
}
}
/// <summary>
/// Constructor that provides an AddressableAudioSource by an AssetReference Primary Key (AssetGuid)
/// </summary>
/// <param name="assetReferenceGuid">The primary key (AssetGuid) of the AssetReference</param>
public AddressableAudioSource(AssetReference assetReference)
{
AssetReference = assetReference;
}
public void GivenAssetWithRawFilenameReference_WhenSaveContainer_ThenXmlHasFileElement()
{
using (var cacheDir = new TempDirectory())
{
var settings = new CassetteSettings
{
SourceDirectory = Mock.Of<IDirectory>(),
CacheDirectory = new FileSystemDirectory(cacheDir)
};
var cache = new BundleCache("VERSION", settings);
var bundle = new TestableBundle("~/bundle-1");
var asset = StubAsset();
var reference = new AssetReference("~/images/test.png", asset.Object, -1, AssetReferenceType.RawFilename);
asset.SetupGet(a => a.References)
.Returns(new[] { reference });
bundle.Assets.Add(asset.Object);
cache.SaveBundleContainer(new BundleContainer(new[] { bundle }));
var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml"));
xml.ShouldContain("<File Path=\"~/images/test.png\" />");
}
}
public static async Task CreateAssetAddToList <T>(AssetReference reference, List <T> completedObjs)
where T : Object
{
completedObjs.Add(await reference.InstantiateAsync().Task as T);
}
public void GivenAssetWithReferenceToAssetInSameBundle_WhenSaveContainer_ThenXmlHasNoReferenceElements()
{
using (var cacheDir = new TempDirectory())
{
var settings = new CassetteSettings
{
SourceDirectory = Mock.Of<IDirectory>(),
CacheDirectory = new FileSystemDirectory(cacheDir)
};
var cache = new BundleCache("VERSION", settings);
var bundle = new TestableBundle("~/bundle-1");
var asset1 = StubAsset("~/bundle-1/asset1.js");
var asset2 = StubAsset("~/bundle-1/asset2.js");
var reference = new AssetReference("~/bundle-1/asset2.js", asset1.Object, -1, AssetReferenceType.SameBundle);
asset1.SetupGet(a => a.References)
.Returns(new[] { reference });
bundle.Assets.Add(new ConcatenatedAsset(new[]
{
asset1.Object,
asset2.Object
}));
cache.SaveBundleContainer(new BundleContainer(new[] { bundle }));
var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml"));
xml.ShouldNotContain("<Reference ");
}
}
public IEnumerator LoadContent <T>(AssetReference assetRef, Action <T> setter, Action <float> percentageSetter = null)
{
return(Utils.LoadContent(assetRef, setter, percentageSetter));
}
public void GivenAssetWithTwoReferencesToAssetsInAnotherBundle_WhenSaveContainer_ThenXmlHasOneReferenceElementWithReferencedBundlePath()
{
using (var cacheDir = new TempDirectory())
{
var settings = new CassetteSettings
{
SourceDirectory = Mock.Of<IDirectory>(),
CacheDirectory = new FileSystemDirectory(cacheDir)
};
var cache = new BundleCache("VERSION", settings);
var bundle1 = new TestableBundle("~/bundle-1");
var bundle2 = new TestableBundle("~/bundle-2");
var asset1 = StubAsset();
var reference1 = new AssetReference("~/bundle-2/asset2.js", asset1.Object, -1, AssetReferenceType.DifferentBundle);
var reference2 = new AssetReference("~/bundle-2/asset3.js", asset1.Object, -1, AssetReferenceType.DifferentBundle);
asset1.SetupGet(a => a.References)
.Returns(new[] { reference1, reference2 });
bundle1.Assets.Add(asset1.Object);
bundle2.Assets.Add(
new ConcatenatedAsset(new[]
{
StubAsset("~/bundle-2/asset2.js").Object,
StubAsset("~/bundle-2/asset3.js").Object
})
);
cache.SaveBundleContainer(new BundleContainer(new[] { bundle1, bundle2 }));
var xml = File.ReadAllText(Path.Combine(cacheDir, "container.xml"));
Regex.Matches(xml, Regex.Escape("<Reference Path=\"~/bundle-2\" />")).Count.ShouldEqual(1);
}
}
public void LoadAsset <T>(AssetReference assetRef, Action <T> setter)
{
Utils.LoadAsset(assetRef, setter);
}
/// <summary>
/// Cleans the specified input items.
/// </summary>
/// <param name="package">The package to process (optional).</param>
/// <param name="inputItems">The input items.</param>
/// <param name="outputItems">The output items.</param>
/// <param name="assetResolver">The asset resolver.</param>
/// <param name="cloneInput">if set to <c>true</c> [clone input].</param>
/// <param name="removeUnloadableObjects">If set to <c>true</c>, assets will be cloned with <see cref="AssetClonerFlags.RemoveUnloadableObjects"/>.</param>
/// <exception cref="System.ArgumentNullException">
/// inputItems
/// or
/// outputItems
/// or
/// assetResolver
/// </exception>
/// <exception cref="System.ArgumentException">List cannot contain null items;inputItems</exception>
public static void Clean(Package package, ICollection<AssetItem> inputItems, ICollection<AssetItem> outputItems, AssetResolver assetResolver, bool cloneInput, bool removeUnloadableObjects)
{
if (inputItems == null) throw new ArgumentNullException(nameof(inputItems));
if (outputItems == null) throw new ArgumentNullException(nameof(outputItems));
if (assetResolver == null) throw new ArgumentNullException(nameof(assetResolver));
// Check that all items are non-null
if (inputItems.Any(item => item == null))
{
throw new ArgumentException("List cannot contain null items", nameof(inputItems));
}
var items = inputItems;
if (cloneInput)
{
items = inputItems.Select(item => item.Clone(flags: removeUnloadableObjects ? AssetClonerFlags.RemoveUnloadableObjects : AssetClonerFlags.None)).ToList();
}
// idRemap should contain only assets that have either 1) their id remapped or 2) their location remapped
var idRemap = new Dictionary<AssetId, Tuple<AssetId, UFile>>();
var itemRemap = new Dictionary<AssetItem, Tuple<AssetId, UFile>>();
foreach (var item in items)
{
if (outputItems.Contains(item))
{
continue;
}
outputItems.Add(item);
bool changed = false;
AssetId newId;
if (assetResolver.RegisterId(item.Id, out newId))
{
changed = true;
}
UFile newLocation;
if (assetResolver.RegisterLocation(item.Location, out newLocation))
{
changed = true;
}
var tuple = new Tuple<AssetId, UFile>(newId != AssetId.Empty ? newId : item.Id, newLocation ?? item.Location);
if (changed)
{
if (!itemRemap.ContainsKey(item))
{
itemRemap.Add(item, tuple);
}
}
if (!idRemap.ContainsKey(item.Id))
{
idRemap.Add(item.Id, tuple);
}
}
// Process assets
foreach (var item in outputItems)
{
Tuple<AssetId, UFile> remap;
if (itemRemap.TryGetValue(item, out remap) && (remap.Item1 != item.Asset.Id || remap.Item2 != item.Location))
{
item.Asset.Id = remap.Item1;
item.Location = remap.Item2;
item.IsDirty = true;
}
// The loop is a one or two-step.
// - If there is no link to update, and the asset has not been cloned, we can exist immediately
// - If there is links to update, and the asset has not been cloned, we need to clone it and re-enter the loop
// to perform the update of the clone asset
var links = AssetReferenceAnalysis.Visit(item.Asset).Where(link => link.Reference is IReference).ToList();
foreach (var assetLink in links)
{
var assetReference = (IReference)assetLink.Reference;
var newId = assetReference.Id;
if (idRemap.TryGetValue(newId, out remap) && IsNewReference(remap, assetReference))
{
assetLink.UpdateReference(remap.Item1, remap.Item2);
item.IsDirty = true;
}
}
// Fix base parts if there are any remap for them as well
var assetComposite = item.Asset as IAssetComposite;
if (assetComposite != null)
{
foreach (var basePart in assetComposite.CollectParts())
{
if (basePart.Base != null && idRemap.TryGetValue(basePart.Base.BasePartAsset.Id, out remap) && IsNewReference(remap, basePart.Base.BasePartAsset))
{
var newAssetReference = new AssetReference(remap.Item1, remap.Item2);
basePart.UpdateBase(new BasePart(newAssetReference, basePart.Base.BasePartId, basePart.Base.InstanceId));
item.IsDirty = true;
}
}
}
}
// Process roots (until references in package are handled in general)
if (package != null)
{
UpdateRootAssets(package.RootAssets, idRemap);
// We check dependencies to be consistent with other places, but nothing should be changed in there
// (except if we were to instantiate multiple packages referencing each other at once?)
foreach (var dependency in package.LocalDependencies)
{
if (dependency.RootAssets != null)
UpdateRootAssets(dependency.RootAssets, idRemap);
}
foreach (var dependency in package.Meta.Dependencies)
{
if (dependency.RootAssets != null)
UpdateRootAssets(dependency.RootAssets, idRemap);
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Parts;
foreach (dynamic entityDesign in entities)
{
var entity = entityDesign.Entity;
foreach (var component in entity.Components)
{
try
{
var componentTag = component.Value.Node.Tag;
if (componentTag == "!ModelComponent")
{
var materials = component.Value.Materials;
var node = ((DynamicYamlMapping)materials).Node;
var i = -1;
foreach (var material in node.Children.ToList())
{
++i;
node.Children.Remove(material.Key);
if (((YamlScalarNode)material.Value).Value == "null")
continue;
node.Children.Add(new YamlScalarNode(((YamlScalarNode)material.Key).Value + '~' + i), material.Value);
}
}
}
catch (Exception)
{
try
{
// Component list serialized with the old version (as a sequence with ~Id in each item)
var componentTag = component.Node.Tag;
if (componentTag == "!ModelComponent")
{
var materials = component.Materials;
var node = ((DynamicYamlArray)materials).Node;
var i = -1;
dynamic newMaterial = new DynamicYamlMapping(new YamlMappingNode());
foreach (var material in node.Children.ToList())
{
++i;
var reference = (YamlScalarNode)material;
if (reference.Value == "null") // Skip null
continue;
UFile location;
Guid referenceId;
AssetId assetReference;
if (AssetReference.TryParse(reference.Value, out assetReference, out location, out referenceId) && referenceId != Guid.Empty)
{
var itemId = new ItemId(referenceId.ToByteArray());
newMaterial[itemId + "~" + i] = new AssetReference(assetReference, location);
}
}
component["Materials"] = newMaterial;
}
}
catch (Exception e)
{
e.Ignore();
}
}
}
}
}
/// <summary>
/// Refreshes this package from the disk by loading or reloading all assets.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="cancelToken">The cancel token.</param>
/// <returns>A logger that contains error messages while refreshing.</returns>
/// <exception cref="System.InvalidOperationException">Package RootDirectory is null
/// or
/// Package RootDirectory [{0}] does not exist.ToFormat(RootDirectory)</exception>
public void LoadTemporaryAssets(ILogger log, CancellationToken? cancelToken = null)
{
if (log == null) throw new ArgumentNullException("log");
// If FullPath is null, then we can't load assets from disk, just return
if (FullPath == null)
{
log.Warning("Fullpath not set on this package");
return;
}
// Clears the assets already loaded and reload them
TemporaryAssets.Clear();
// List all package files on disk
var listFiles = ListAssetFiles(log, this, cancelToken);
var progressMessage = String.Format("Loading Assets from Package [{0}]", FullPath.GetFileNameWithExtension());
// Display this message at least once if the logger does not log progress (And it shouldn't in this case)
var loggerResult = log as LoggerResult;
if (loggerResult == null || !loggerResult.IsLoggingProgressAsInfo)
{
log.Info(progressMessage);
}
// Update step counter for log progress
for (int i = 0; i < listFiles.Count; i++)
{
var fileUPath = listFiles[i].Item1;
var sourceFolder = listFiles[i].Item2;
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
log.Warning("Skipping loading assets. PackageSession.Load cancelled");
break;
}
// Update the loading progress
if (loggerResult != null)
{
loggerResult.Progress(progressMessage, i, listFiles.Count);
}
// Try to load only if asset is not already in the package or assetRef.Asset is null
var assetPath = fileUPath.MakeRelative(sourceFolder).GetDirectoryAndFileName();
try
{
// An exception can occur here, so we make sure that loading a single asset is not going to break
// the loop
var assetFullPath = fileUPath.FullPath;
var asset = LoadAsset(log, assetFullPath, assetPath, fileUPath);
// Create asset item
var assetItem = new AssetItem(assetPath, asset)
{
IsDirty = false,
Package = this,
SourceFolder = sourceFolder.MakeRelative(RootDirectory)
};
// Set the modified time to the time loaded from disk
assetItem.ModifiedTime = File.GetLastWriteTime(assetFullPath);
FixAssetImport(assetItem);
// Add to temporary assets
TemporaryAssets.Add(assetItem);
}
catch (Exception ex)
{
int row = 1;
int column = 1;
var yamlException = ex as YamlException;
if (yamlException != null)
{
row = yamlException.Start.Line + 1;
column = yamlException.Start.Column;
}
var module = log.Module;
var assetReference = new AssetReference<Asset>(Guid.Empty, fileUPath.FullPath);
// TODO: Change this instead of patching LoggerResult.Module, use a proper log message
if (loggerResult != null)
{
loggerResult.Module = "{0}({1},{2})".ToFormat(Path.GetFullPath(fileUPath.FullPath), row, column);
}
log.Error(this, assetReference, AssetMessageCode.AssetLoadingFailed, ex, fileUPath, ex.Message);
if (loggerResult != null)
{
loggerResult.Module = module;
}
}
}
}
protected abstract Task <GameObject> InstantiateSceneObject(AssetReference reference);
public static void CreateAndSetDefaultScene(Package package, String location = "MainScene")
{
var defaultSceneAsset = SceneAsset.Create();
var sceneAssetItem = new AssetItem(location, defaultSceneAsset);
package.Assets.Add(sceneAssetItem);
sceneAssetItem.IsDirty = true;
var sceneAsset = new AssetReference<SceneAsset>(sceneAssetItem.Id, sceneAssetItem.Location);
// Sets the scene created as default in the shared profile
SetDefaultScene(package, sceneAsset);
}
public Type GetAssetType(AssetReference asset)
{
return(typeof(AnimationClip));
}
private object DeserializeObject(Queue <DeserializeOperation> serializeOperations, AssetReference parentAssetReference, string url, Type objType, object obj, AssetManagerLoaderSettings settings)
{
// Try to find already loaded object
AssetReference assetReference = FindDeserializedObject(url, objType);
if (assetReference != null && assetReference.Deserialized)
{
// Add reference
bool isRoot = parentAssetReference == null;
if (isRoot || parentAssetReference.References.Add(assetReference))
{
IncrementReference(assetReference, isRoot);
}
return(assetReference.Object);
}
if (!FileProvider.FileExists(url))
{
HandleAssetNotFound(url);
return(null);
}
ContentSerializerContext contentSerializerContext;
object result;
// Open asset binary stream
try
{
using (var stream = FileProvider.OpenStream(url, VirtualFileMode.Open, VirtualFileAccess.Read))
{
// File does not exist
// TODO/Benlitz: Add a log entry for that, it's not expected to happen
if (stream == null)
{
return(null);
}
Type headerObjType = null;
// Read header
var streamReader = new BinarySerializationReader(stream);
var chunkHeader = ChunkHeader.Read(streamReader);
if (chunkHeader != null)
{
headerObjType = AssemblyRegistry.GetType(chunkHeader.Type);
}
// Find serializer
var serializer = Serializer.GetSerializer(headerObjType, objType);
if (serializer == null)
{
throw new InvalidOperationException(string.Format("Content serializer for {0}/{1} could not be found.", headerObjType, objType));
}
contentSerializerContext = new ContentSerializerContext(url, ArchiveMode.Deserialize, this)
{
LoadContentReferences = settings.LoadContentReferences
};
// Read chunk references
if (chunkHeader != null && chunkHeader.OffsetToReferences != -1)
{
// Seek to where references are stored and deserialize them
streamReader.NativeStream.Seek(chunkHeader.OffsetToReferences, SeekOrigin.Begin);
contentSerializerContext.SerializeReferences(streamReader);
streamReader.NativeStream.Seek(chunkHeader.OffsetToObject, SeekOrigin.Begin);
}
if (assetReference == null)
{
// Create AssetReference
assetReference = new AssetReference(url, parentAssetReference == null);
contentSerializerContext.AssetReference = assetReference;
result = obj ?? serializer.Construct(contentSerializerContext);
SetAssetObject(assetReference, result);
}
else
{
result = assetReference.Object;
contentSerializerContext.AssetReference = assetReference;
}
assetReference.Deserialized = true;
PrepareSerializerContext(contentSerializerContext, streamReader.Context);
contentSerializerContext.SerializeContent(streamReader, serializer, result);
// Add reference
if (parentAssetReference != null)
{
parentAssetReference.References.Add(assetReference);
}
}
}
catch (Exception exception)
{
throw new AssetManagerException(string.Format("Unexpected exception while loading asset [{0}]. Reason: {1}. Check inner-exception for details.", url, exception.Message), exception);
}
if (settings.LoadContentReferences)
{
// Process content references
// TODO: Should we work at ChunkReference level?
foreach (var contentReference in contentSerializerContext.ContentReferences)
{
bool shouldBeLoaded = true;
//AssetReference childReference;
if (settings.ContentFilter != null)
{
settings.ContentFilter(contentReference, ref shouldBeLoaded);
}
if (shouldBeLoaded)
{
serializeOperations.Enqueue(new DeserializeOperation(assetReference, contentReference.Location, contentReference.Type, contentReference.ObjectValue));
}
}
}
return(result);
}
public static bool IsNullOrEmpty(this AssetReference aref)
{
return(aref == null || aref.RuntimeKey == Hash128.Parse(""));
}
/// <summary>
/// Cleans the specified input items.
/// </summary>
/// <param name="package">The package to process (optional).</param>
/// <param name="inputItems">The input items.</param>
/// <param name="outputItems">The output items.</param>
/// <param name="assetResolver">The asset resolver.</param>
/// <param name="cloneInput">if set to <c>true</c> [clone input].</param>
/// <param name="removeUnloadableObjects">If set to <c>true</c>, assets will be cloned with <see cref="AssetClonerFlags.RemoveUnloadableObjects"/>.</param>
/// <exception cref="System.ArgumentNullException">
/// inputItems
/// or
/// outputItems
/// or
/// assetResolver
/// </exception>
/// <exception cref="System.ArgumentException">List cannot contain null items;inputItems</exception>
public static void Clean(Package package, ICollection <AssetItem> inputItems, ICollection <AssetItem> outputItems, AssetResolver assetResolver, bool cloneInput, bool removeUnloadableObjects)
{
if (inputItems == null)
{
throw new ArgumentNullException(nameof(inputItems));
}
if (outputItems == null)
{
throw new ArgumentNullException(nameof(outputItems));
}
if (assetResolver == null)
{
throw new ArgumentNullException(nameof(assetResolver));
}
// Check that all items are non-null
if (inputItems.Any(item => item == null))
{
throw new ArgumentException("List cannot contain null items", nameof(inputItems));
}
var items = inputItems;
if (cloneInput)
{
items = inputItems.Select(item => item.Clone(flags: removeUnloadableObjects ? AssetClonerFlags.RemoveUnloadableObjects : AssetClonerFlags.None)).ToList();
}
// idRemap should contain only assets that have either 1) their id remapped or 2) their location remapped
var idRemap = new Dictionary <AssetId, Tuple <AssetId, UFile> >();
var itemRemap = new Dictionary <AssetItem, Tuple <AssetId, UFile> >();
foreach (var item in items)
{
if (outputItems.Contains(item))
{
continue;
}
outputItems.Add(item);
bool changed = false;
AssetId newId;
if (assetResolver.RegisterId(item.Id, out newId))
{
changed = true;
}
UFile newLocation;
if (assetResolver.RegisterLocation(item.Location, out newLocation))
{
changed = true;
}
var tuple = new Tuple <AssetId, UFile>(newId != AssetId.Empty ? newId : item.Id, newLocation ?? item.Location);
if (changed)
{
if (!itemRemap.ContainsKey(item))
{
itemRemap.Add(item, tuple);
}
}
if (!idRemap.ContainsKey(item.Id))
{
idRemap.Add(item.Id, tuple);
}
}
// Process assets
foreach (var item in outputItems)
{
Tuple <AssetId, UFile> remap;
if (itemRemap.TryGetValue(item, out remap) && (remap.Item1 != item.Asset.Id || remap.Item2 != item.Location))
{
item.Asset.Id = remap.Item1;
item.Location = remap.Item2;
item.IsDirty = true;
}
// Fix base parts if there are any remap for them as well
// This has to be done before the default resolver below because this fix requires to rewrite the base part completely, since the base part asset is immutable
var assetComposite = item.Asset as IAssetComposite;
if (assetComposite != null)
{
foreach (var basePart in assetComposite.CollectParts())
{
if (basePart.Base != null && idRemap.TryGetValue(basePart.Base.BasePartAsset.Id, out remap) && IsNewReference(remap, basePart.Base.BasePartAsset))
{
var newAssetReference = new AssetReference(remap.Item1, remap.Item2);
basePart.UpdateBase(new BasePart(newAssetReference, basePart.Base.BasePartId, basePart.Base.InstanceId));
item.IsDirty = true;
}
}
}
// The loop is a one or two-step.
// - If there is no link to update, and the asset has not been cloned, we can exist immediately
// - If there is links to update, and the asset has not been cloned, we need to clone it and re-enter the loop
// to perform the update of the clone asset
var links = AssetReferenceAnalysis.Visit(item.Asset).Where(link => link.Reference is IReference).ToList();
foreach (var assetLink in links)
{
var assetReference = (IReference)assetLink.Reference;
var newId = assetReference.Id;
if (idRemap.TryGetValue(newId, out remap) && IsNewReference(remap, assetReference))
{
assetLink.UpdateReference(remap.Item1, remap.Item2);
item.IsDirty = true;
}
}
}
// Process roots (until references in package are handled in general)
if (package != null)
{
UpdateRootAssets(package.RootAssets, idRemap);
// We check dependencies to be consistent with other places, but nothing should be changed in there
// (except if we were to instantiate multiple packages referencing each other at once?)
foreach (var dependency in package.LocalDependencies)
{
if (dependency.RootAssets != null)
{
UpdateRootAssets(dependency.RootAssets, idRemap);
}
}
foreach (var dependency in package.Meta.Dependencies)
{
if (dependency.RootAssets != null)
{
UpdateRootAssets(dependency.RootAssets, idRemap);
}
}
}
}
public static T SetCasterQuickSpellParticleReference <T>(this T entity, AssetReference value)
where T : EffectParticleParameters
{
entity.SetField("casterQuickSpellParticleReference", value);
return(entity);
}
public string GetAssetExtension(AssetReference asset)
{
return(".dae");
}
internal static void DrawHint(Rect hintTriggerRect, Vector2 mousePosition, AssetReference assetReference)
{
if (!hintTriggerRect.Contains(mousePosition) || !GUIClip.visibleRect.Contains(mousePosition))
{
return;
}
string assetPath = AssetDatabase.GUIDToAssetPath(assetReference.guid);
var assetType = AssetDatabase.GetMainAssetTypeAtPath(assetPath);
if (assetType == null) //this means the object or its base script has been deleted and is "Missing"
{
return;
}
var hintGenerators = TypeCache.GetMethodsWithAttribute <DynamicHintGeneratorAttribute>();
if (assetType.IsSubclassOf(typeof(ScriptableObject)))
{
DynamicHintContent hint = GetDynamicHintContentOf(hintGenerators, assetType, assetPath);
if (hint != null)
{
DrawMouseTooltip(hint, hintTriggerRect);
}
return;
}
if (assetType == typeof(GameObject))
{
/* GameObjects can have multiple components with custom tooltips
* so for now we'll just display the first one.
* If needed, we could:
* 1) Implement a "priority system" (like OrderedCallbacks)
* 2) Display one big tooltip made up with all elements from custom tooltip
*/
GameObject assetGameObject = (GetLoadedObjectFromInstanceID(assetReference.instanceID) as GameObject);
if (!assetGameObject)
{
/* this seems to happen non-deterministically at project startup depending of what the user is hovering when the editor opens,
* or while the user is scrolling a list of objects and hovers one of them casually, even if the object hovered is actually a
* GameObject.
* */
return;
}
foreach (var component in assetGameObject.GetComponents <Component>())
{
if (component == null)
{
continue;
} //this means its script has been deleted and is "Missing"
DynamicHintContent hint = GetDynamicHintContentOf(hintGenerators, component.GetType(), string.Empty, component);
if (hint == null)
{
continue;
}
DrawMouseTooltip(hint, hintTriggerRect);
return;
}
}
}
