119 lines
3.2 KiB
C#
119 lines
3.2 KiB
C#
using System;
|
|
using UnityEngine;
|
|
using System.IO;
|
|
using GLTF.Schema;
|
|
|
|
namespace UnityGLTF.Cache
|
|
{
|
|
/// <summary>
|
|
/// Caches data in order to construct a unity object
|
|
/// </summary>
|
|
public class AssetCache : IDisposable
|
|
{
|
|
/// <summary>
|
|
/// Streams to the images to be loaded
|
|
/// </summary>
|
|
public Stream[] ImageStreamCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Loaded raw texture data
|
|
/// </summary>
|
|
public Texture2D[] ImageCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Invalid/missing textures. These are cached since we can still remap them after import, but don't
|
|
/// want to apply them to materials.
|
|
/// </summary>
|
|
public Texture2D[] InvalidImageCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Textures to be used for assets. Textures from image cache with samplers applied
|
|
/// </summary>
|
|
public TextureCacheData[] TextureCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Cache for materials to be applied to the meshes
|
|
/// </summary>
|
|
public MaterialCacheData[] MaterialCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Byte buffers that represent the binary contents that get parsed
|
|
/// </summary>
|
|
public BufferCacheData[] BufferCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Cache of loaded meshes
|
|
/// </summary>
|
|
public MeshCacheData[] MeshCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Cache of loaded unity meshes data
|
|
/// </summary>
|
|
public UnityMeshData[] UnityMeshDataCache { get; private set; }
|
|
#if UNITY_ANIMATION || !UNITY_2019_1_OR_NEWER
|
|
/// <summary>
|
|
/// Cache of loaded animations
|
|
/// </summary>
|
|
public AnimationCacheData[] AnimationCache { get; private set; }
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Cache of loaded node objects
|
|
/// </summary>
|
|
public GameObject[] NodeCache { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Creates an asset cache which caches objects used in scene
|
|
/// </summary>
|
|
/// <param name="root">A glTF root whose assets will eventually be cached here</param>
|
|
public AssetCache(GLTFRoot root)
|
|
{
|
|
ImageCache = new Texture2D[root.Images?.Count ?? 0];
|
|
InvalidImageCache = new Texture2D[ImageCache.Length];
|
|
ImageStreamCache = new Stream[ImageCache.Length];
|
|
TextureCache = new TextureCacheData[root.Textures?.Count ?? 0];
|
|
MaterialCache = new MaterialCacheData[root.Materials?.Count ?? 0];
|
|
BufferCache = new BufferCacheData[root.Buffers?.Count ?? 0];
|
|
MeshCache = new MeshCacheData[root.Meshes?.Count ?? 0];
|
|
UnityMeshDataCache = new UnityMeshData[root.Meshes?.Count ?? 0];
|
|
NodeCache = new GameObject[root.Nodes?.Count ?? 0];
|
|
#if UNITY_ANIMATION || !UNITY_2019_1_OR_NEWER
|
|
AnimationCache = new AnimationCacheData[root.Animations?.Count ?? 0];
|
|
#endif
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (ImageStreamCache != null)
|
|
{
|
|
foreach (var stream in ImageStreamCache)
|
|
{
|
|
stream?.Dispose();
|
|
}
|
|
|
|
ImageStreamCache = null;
|
|
}
|
|
|
|
ImageCache = null;
|
|
TextureCache = null;
|
|
MaterialCache = null;
|
|
if (BufferCache != null)
|
|
{
|
|
foreach (BufferCacheData bufferCacheData in BufferCache)
|
|
{
|
|
if (bufferCacheData != null)
|
|
{
|
|
bufferCacheData.Dispose();
|
|
}
|
|
}
|
|
BufferCache = null;
|
|
}
|
|
|
|
MeshCache = null;
|
|
#if UNITY_ANIMATION || !UNITY_2019_1_OR_NEWER
|
|
AnimationCache = null;
|
|
#endif
|
|
}
|
|
}
|
|
}
|