public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
if (Application.isPlaying)
{
var path = ctx.assetPath.Substring(21, ctx.assetPath.Length - 21 - 4);
var moduleName = path.Replace('/', '.');
lock ( modifiedModules ) {
modifiedModules.Add(moduleName);
}
}
ExecLuaCheck(ctx.assetPath);
var text = File.ReadAllText(ctx.assetPath);
var asset = new TextAsset(text);
using (var reader = new StringReader(asset.text)) {
var line = reader.ReadLine();
while (line != null)
{
if (line.StartsWith("---@class"))
{
var statements = line.Split(' ');
var className = statements[1];
LuaClassEditorFactory.ReloadDescriptor(className);
break;
}
line = reader.ReadLine();
}
}
ctx.AddObjectToAsset("main obj", asset);
ctx.SetMainObject(asset);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext context)
{
TextAsset subAsset = new TextAsset(File.ReadAllText(context.assetPath));
context.AddObjectToAsset("text", subAsset);
context.SetMainObject(subAsset);
}
private void GenerateAseAnimations(UnityEditor.AssetImporters.AssetImportContext ctx, AseFile aseFile, Sprite[] sprites)
{
if (animationSettings == null)
{
animationSettings = new AseFileAnimationSettings[0];
}
var animSettings = new List <AseFileAnimationSettings>(animationSettings);
var animations = aseFile.GetAnimations();
if (animations.Length <= 0)
{
return;
}
if (animationSettings != null)
{
RemoveUnusedAnimationSettings(animSettings, animations);
}
foreach (var animation in animations)
{
// AseAnim
AseAnimation aseAnim = new AseAnimation();
aseAnim.name = aseAnim.Name = animation.TagName;
AseFileAnimationSettings importSettings = GetAnimationSettingFor(animSettings, animation);
importSettings.about = GetAnimationAbout(animation);
int length = animation.FrameTo - animation.FrameFrom + 1;
aseAnim.Points = new AseAnimation.KeyPoint[length];
aseAnim.LoopType = (AseAnimation.LoopAnimation)animation.Animation;
aseAnim.Loop = length > 1;
float time = 0;
int from = (animation.Animation != LoopAnimation.Reverse) ? animation.FrameFrom : animation.FrameTo;
int step = (animation.Animation != LoopAnimation.Reverse) ? 1 : -1;
int keyIndex = from;
for (int i = 0; i < length; i++)
{
if (i >= length)
{
keyIndex = from;
}
aseAnim.Points[i] = new AseAnimation.KeyPoint(sprites[keyIndex], aseFile.Frames[keyIndex].FrameDuration / 1000f);
time += aseFile.Frames[keyIndex].FrameDuration / 1000f;
keyIndex += step;
}
ctx.AddObjectToAsset(aseAnim.Name, aseAnim);
}
animationSettings = animSettings.ToArray();
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
IUriLoader loader = new BufferedStreamLoader(
ctx.assetPath, Path.GetDirectoryName(ctx.assetPath));
ImportGltf.GltfImportResult result = ImportGltf.Import(
ctx.assetPath, loader, null, kOptions);
// The "identifier" param passed here is supposed to be:
// - Unique to this asset
// - Deterministic (if possible)
foreach (var obj in result.textures)
{
if (!AssetDatabase.Contains(obj))
{
ctx.AddObjectToAsset("Texture/" + obj.name, obj);
}
}
foreach (var obj in result.materials)
{
ctx.AddObjectToAsset("Material/" + obj.name, obj);
}
foreach (var obj in result.meshes)
{
ctx.AddObjectToAsset("Mesh/" + obj.name, obj);
}
string objectName = Path.GetFileNameWithoutExtension(ctx.assetPath);
result.root.name = objectName;
ctx.AddObjectToAsset("ROOT", result.root);
ctx.SetMainObject(result.root);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
TextAsset lua = new TextAsset(File.ReadAllText(ctx.assetPath));
ctx.AddObjectToAsset("main", lua);
ctx.SetMainObject(lua);
}
private void ImportTileset(UnityEditor.AssetImporters.AssetImportContext ctx, Texture2D atlas)
{
int cols = atlas.width / textureSettings.tileSize.x;
int rows = atlas.height / textureSettings.tileSize.y;
int width = textureSettings.tileSize.x;
int height = textureSettings.tileSize.y;
int index = 0;
for (int y = rows - 1; y >= 0; y--)
{
for (int x = 0; x < cols; x++)
{
Rect tileRect = new Rect(x * width, y * height, width, height);
Sprite sprite = Sprite.Create(atlas, tileRect, textureSettings.spritePivot,
textureSettings.pixelsPerUnit, textureSettings.extrudeEdges, textureSettings.meshType,
Vector4.zero, textureSettings.generatePhysics);
sprite.name = string.Format("{0}_{1}", name, index);
ctx.AddObjectToAsset(sprite.name, sprite);
index++;
}
}
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var serializer = new DataContractJsonSerializer(typeof(PiskelFile));
var layerSerializer = new DataContractJsonSerializer(typeof(PiskelLayer));
using (var assetFile = File.OpenRead(ctx.assetPath)) {
var piskelFile = (PiskelFile)serializer.ReadObject(assetFile);
var frameWidth = piskelFile.piskel.width;
var frameHeight = piskelFile.piskel.height;
if (piskelFile.modelVersion != 2)
{
ctx.LogImportWarning("expected piskel model version 2");
}
var layers = piskelFile.piskel.layers
.Select(layerJson => {
using (var textReader = new MemoryStream(Encoding.Unicode.GetBytes(layerJson))) {
return(layerSerializer.ReadObject(textReader));
}
})
.Cast <PiskelLayer>()
.ToList();
var layerTextures = layers
.Select((layer, l) => {
if (layer.chunks.Length != 1)
{
ctx.LogImportWarning("not supported: piskel layer with no chunks, or more than one chunk:"
+ layer.name);
return(default);
public void EndFileVisit(AseFile file)
{
// Add sprites to sprite atlas (or more correctly, add the scritable object that will add the sprites when import completes)
var spriteAtlasUser = SpriteAtlasUserAsset.CreateSpriteAtlasUserAsset(m_SpriteAtlas);
m_Context.AddObjectToAsset("__atlas", spriteAtlasUser);
BuildAnimations();
var renderer = m_GameObject.AddComponent <SpriteRenderer>();
renderer.sprite = m_Sprites[0];
renderer.sortingLayerName = m_SortingLayerName;
renderer.sortingOrder = m_SortingOrder;
var animator = m_GameObject.AddComponent <Animator>();
animator.runtimeAnimatorController = m_AnimatorController;
animator.cullingMode = m_AnimatorCullingMode;
m_AseFile = null;
m_Context = null;
m_Palette.Clear();
m_Layers.Clear();
m_Frames.Clear();
m_Sprites.Clear();
m_Clips.Clear();
m_AseFrameTagsChunk = null;
m_UniqueNameifier.Clear();
m_GameObject = null;
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var text = File.ReadAllText(ctx.assetPath);
var asset = new TextAsset(text);
ctx.AddObjectToAsset("main obj", asset);
ctx.SetMainObject(asset);
}
//TODO: We should deprecate this method, it is unused internally
public static SceneSectionData[] WriteEntityScene(EntityManager entityManager, Hash128 sceneGUID,
string sceneName, AssetImportContext importContext, int framesToRetainBlobAssets = 0,
List <ReferencedUnityObjects> sectionRefObjs = null)
{
ConversionJournalData journalData = new ConversionJournalData();
return(WriteEntitySceneInternal(entityManager, sceneGUID, sceneName, importContext, framesToRetainBlobAssets, sectionRefObjs, new WriteEntitySceneSettings(), ref journalData));
}
public static void AddAsset(this UnityEditor.AssetImporters.AssetImportContext ctx, string identifier, Object obj)
{
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(identifier, obj);
#else
ctx.AddSubAsset(identifier, obj);
#endif
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var loader = new AsepriteLoader();
var file = loader.LoadFile(ctx.assetPath);
var name = Path.GetFileNameWithoutExtension(ctx.assetPath);
var assets = file.CreateAssets(Settings, name);
assets.AddToContext(ctx);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
name = GetFileName(ctx.assetPath);
AseFile aseFile = ReadAseFile(ctx.assetPath);
int frameCount = aseFile.Header.Frames;
SpriteAtlasBuilder atlasBuilder = new SpriteAtlasBuilder(textureSettings, aseFile.Header.Width, aseFile.Header.Height);
Texture2D[] frames = null;
if (importType != AseFileImportType.LayerToSprite)
{
frames = aseFile.GetFrames();
}
else
{
frames = aseFile.GetLayersAsFrames();
}
UnityEditor.AssetImporters.SpriteImportData[] spriteImportData = new UnityEditor.AssetImporters.SpriteImportData[0];
//if (textureSettings.transparentMask)
//{
// atlas = atlasBuilder.GenerateAtlas(frames, out spriteImportData, textureSettings.transparentColor, false);
//}
//else
//{
// atlas = atlasBuilder.GenerateAtlas(frames, out spriteImportData, false);
//}
atlas = atlasBuilder.GenerateAtlas(frames, out spriteImportData, textureSettings.transparentMask, false);
atlas.filterMode = textureSettings.filterMode;
atlas.alphaIsTransparency = false;
atlas.wrapMode = TextureWrapMode.Clamp;
atlas.name = "Texture";
ctx.AddObjectToAsset("Texture", atlas);
ctx.SetMainObject(atlas);
switch (importType)
{
case AseFileImportType.LayerToSprite:
case AseFileImportType.Sprite:
ImportSprites(ctx, aseFile, spriteImportData);
break;
case AseFileImportType.Tileset:
ImportTileset(ctx, atlas);
break;
}
ctx.SetMainObject(atlas);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
// Load asset
GLTFAnimation.ImportResult[] animations;
GameObject root = Importer.LoadFromFile(ctx.assetPath, importSettings, out animations, Format.GLTF);
// Save asset
GLTFAssetUtility.SaveToAsset(root, animations, ctx);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var model = File.ReadAllBytes(ctx.assetPath);
var asset = ScriptableObject.CreateInstance <NNModel>();
asset.Value = model;
ctx.AddObjectToAsset("main obj", asset, LoadIconTexture());
ctx.SetMainObject(asset);
}
public void AddDependency(AssetImportContext context, string assetPath)
{
if (!m_AssetDependencies.Contains(assetPath))
{
#if UNITY_2018_3_OR_NEWER
context.DependsOnSourceAsset(assetPath);
#endif
m_AssetDependencies.Add(assetPath);
}
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext context)
{
if (_containerType == ContainerType.Mesh)
{
// Mesh container
// Create a prefab with MeshFilter/MeshRenderer.
var gameObject = new GameObject();
var mesh = ImportAsMesh(context.assetPath);
var meshFilter = gameObject.AddComponent <MeshFilter>();
meshFilter.sharedMesh = mesh;
var meshRenderer = gameObject.AddComponent <MeshRenderer>();
meshRenderer.sharedMaterial = GetDefaultMaterial();
context.AddObjectToAsset("prefab", gameObject);
if (mesh != null)
{
context.AddObjectToAsset("mesh", mesh);
}
context.SetMainObject(gameObject);
}
else if (_containerType == ContainerType.ComputeBuffer)
{
// ComputeBuffer container
// Create a prefab with PointCloudRenderer.
var gameObject = new GameObject();
var data = ImportAsPointCloudData(context.assetPath);
var renderer = gameObject.AddComponent <PointCloudRenderer>();
renderer.sourceData = data;
context.AddObjectToAsset("prefab", gameObject);
if (data != null)
{
context.AddObjectToAsset("data", data);
}
context.SetMainObject(gameObject);
}
else // _containerType == ContainerType.Texture
{
// Texture container
// No prefab is available for this type.
var data = ImportAsBakedPointCloud(context.assetPath);
if (data != null)
{
context.AddObjectToAsset("container", data);
context.AddObjectToAsset("position", data.positionMap);
context.AddObjectToAsset("color", data.colorMap);
context.SetMainObject(data);
}
}
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
string txt = File.ReadAllText(ctx.assetPath);
var cartridge = ScriptableObject.CreateInstance <CartridgeP8>();
cartridge.ReadData(txt);
ctx.AddObjectToAsset("cartridge", cartridge);
ctx.SetMainObject(cartridge);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
Logger.Info("Importing VPX table at {0}...", ctx.assetPath);
// create root object
var rootGameObj = new GameObject();
// add lazy importer, will do a normal in memory import once the object ends up in a scene
rootGameObj.AddComponent <VpxAssetLazyImporter>();
ctx.AddObjectToAsset("main obj", rootGameObj);
ctx.SetMainObject(rootGameObj);
}
public void AddToContext(UnityEditor.AssetImporters.AssetImportContext ctx)
{
ctx.AddObjectToAsset(_spritesheet.name, _spritesheet);
foreach (var sprite in _sprites)
{
ctx.AddObjectToAsset(sprite.name, sprite);
}
foreach (var animation in _animations)
{
ctx.AddObjectToAsset(animation.name, animation);
}
ctx.SetMainObject(_spritesheet);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var graphAsset = ScriptableObject.CreateInstance <SubGraphAsset>();
var subGraphPath = ctx.assetPath;
var subGraphGuid = AssetDatabase.AssetPathToGUID(subGraphPath);
graphAsset.assetGuid = subGraphGuid;
var textGraph = File.ReadAllText(subGraphPath, Encoding.UTF8);
var graphData = new GraphData {
isSubGraph = true, assetGuid = subGraphGuid
};
var messageManager = new MessageManager();
graphData.messageManager = messageManager;
JsonUtility.FromJsonOverwrite(textGraph, graphData);
try
{
ProcessSubGraph(graphAsset, graphData);
}
catch (Exception e)
{
graphAsset.isValid = false;
Debug.LogException(e, graphAsset);
}
finally
{
if (messageManager.nodeMessagesChanged)
{
graphAsset.isValid = false;
foreach (var pair in messageManager.GetNodeMessages())
{
var node = graphData.GetNodeFromTempId(pair.Key);
foreach (var message in pair.Value)
{
MessageManager.Log(node, subGraphPath, message, graphAsset);
}
}
}
messageManager.ClearAll();
}
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_subgraph_icon@64");
ctx.AddObjectToAsset("MainAsset", graphAsset, texture);
ctx.SetMainObject(graphAsset);
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var name = Path.GetFileNameWithoutExtension(ctx.assetPath);
var meshes = Importer.Import(ctx.assetPath, m_CoordinateSpace, m_UpAxis, m_Smooth).ToArray();
if (meshes.Length < 1)
{
return;
}
if (meshes.Length < 2)
{
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
Object.DestroyImmediate(go.GetComponent <BoxCollider>());
go.name = name;
meshes[0].name = "Mesh-" + name;
go.GetComponent <MeshFilter>().sharedMesh = meshes[0];
ctx.AddObjectToAsset(go.name, go);
ctx.AddObjectToAsset(meshes[0].name, meshes[0]);
ctx.SetMainObject(go);
}
else
{
var parent = new GameObject();
parent.name = name;
for (int i = 0, c = meshes.Length; i < c; i++)
{
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
Object.DestroyImmediate(go.GetComponent <BoxCollider>());
go.transform.SetParent(parent.transform, false);
go.name = name + "(" + i + ")";
var mesh = meshes[i];
mesh.name = "Mesh-" + name + "(" + i + ")";
go.GetComponent <MeshFilter>().sharedMesh = mesh;
// ctx.AddObjectToAsset(go.name, go);
ctx.AddObjectToAsset(mesh.name, mesh);
}
ctx.AddObjectToAsset(parent.name, parent);
ctx.SetMainObject(parent);
}
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
m_Errors.Clear();
#if UNITY_2018_3_OR_NEWER
m_Context = ctx;
using (var reader = new AseReader(ctx.assetPath))
{
m_AseFile = new AseFile(reader);
m_AseFile.VisitContents(this);
}
#else
string msg = string.Format("Aesprite2Unity requires Unity 2018.3 or later. You are using {0}", Application.unityVersion);
m_Errors.Add(msg);
Debug.LogError(msg);
#endif
}
public static bool SetupSpinePrefabMesh(GameObject g, UnityEditor.AssetImporters.AssetImportContext context)
{
Dictionary <string, int> nameUsageCount = new Dictionary <string, int>();
bool wasModified = false;
var skeletonRenderers = g.GetComponentsInChildren <SkeletonRenderer>(true);
foreach (SkeletonRenderer renderer in skeletonRenderers)
{
wasModified = true;
var meshFilter = renderer.GetComponent <MeshFilter>();
if (meshFilter == null)
{
meshFilter = renderer.gameObject.AddComponent <MeshFilter>();
}
renderer.EditorUpdateMeshFilterHideFlags();
renderer.Initialize(true, true);
renderer.LateUpdateMesh();
var mesh = meshFilter.sharedMesh;
if (mesh == null)
{
continue;
}
string meshName = string.Format("Skeleton Prefab Mesh \"{0}\"", renderer.name);
if (nameUsageCount.ContainsKey(meshName))
{
nameUsageCount[meshName]++;
meshName = string.Format("Skeleton Prefab Mesh \"{0} ({1})\"", renderer.name, nameUsageCount[meshName]);
}
else
{
nameUsageCount.Add(meshName, 0);
}
mesh.name = meshName;
mesh.hideFlags = HideFlags.None;
if (context != null)
{
context.AddObjectToAsset(meshFilter.sharedMesh.name, meshFilter.sharedMesh);
}
}
return(wasModified);
}
public override void OnImportAsset(ASSET_IMPORT_CONTEXT c)
{
var importer = new TemplateXImporter();
var context = new AssetImportContext(c.assetPath);
importer.OnImportAsset(context);
foreach (var obj in context.Objects)
{
c.AddObjectToAsset(obj.Identifier, obj.Object, obj.Icon);
}
c.SetMainObject(context.MainObject);
foreach (var path in context.Dependencies)
{
c.DependsOnSourceAsset(path);
}
}
public static void AddAnimations(GLTFAnimation.ImportResult[] animations, UnityEditor.AssetImporters.AssetImportContext ctx)
{
if (animations == null)
{
return;
}
HashSet <AnimationClip> visitedAnimations = new HashSet <AnimationClip>();
for (int i = 0; i < animations.Length; i++)
{
AnimationClip clip = animations[i].clip;
if (visitedAnimations.Contains(clip))
{
continue;
}
ctx.AddAsset(clip.name, clip);
visitedAnimations.Add(clip);
}
}
public override sealed void OnImportAsset(AssetImportContext ctx)
{
m_CachedDatabase.Clear();
m_MissingFiles.Clear();
m_Errors.Clear();
m_Warnings.Clear();
m_MissingSortingLayers.Clear();
m_MissingLayers.Clear();
m_MissingTags.Clear();
m_SuperAsset = null;
AssetImportContext = ctx;
#if UNITY_2018_3_OR_NEWER
try
{
InternalOnImportAsset();
InternalOnImportAssetCompleted();
}
catch (TiledException tiled)
{
// Exceptions that SuperTiled2Unity is aware of
// These are the kind of errors a user should be able to fix
m_Errors.Add(tiled.Message);
}
catch (XmlException xml)
{
// Xml exceptions are common if the Tiled data file somehow becomes corrupted
m_Errors.Add("Asset file may contained corrupted XML data. Trying opening in Tiled Map Editor to resolve.");
m_Errors.Add(xml.Message);
}
catch (Exception ex)
{
// Last-chance collection of unknown errors while importing
// This should be reported for bug fixing
m_Errors.Add("Unknown error encountered. Please report as bug. Stack track is in the console output.");
m_Errors.Add(ex.Message);
Debug.LogErrorFormat("Unknown error of type {0}: {1}\nStack Trace:\n{2}", ex.GetType(), ex.Message, ex.StackTrace);
}
#else
ReportUnityVersionError();
#endif
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var inputType = Path.GetExtension(ctx.assetPath);
if (inputType == null)
{
throw new Exception("Demonstration import error.");
}
try
{
// Read first two proto objects containing metadata and brain parameters.
Stream reader = File.OpenRead(ctx.assetPath);
var metaDataProto = DemonstrationMetaProto.Parser.ParseDelimitedFrom(reader);
var metaData = new DemonstrationMetaData(metaDataProto);
reader.Seek(DemonstrationStore.MetaDataBytes + 1, 0);
var brainParamsProto = BrainParametersProto.Parser.ParseDelimitedFrom(reader);
var brainParameters = new BrainParameters(brainParamsProto);
reader.Close();
var demonstration = ScriptableObject.CreateInstance <Demonstration>();
demonstration.Initialize(brainParameters, metaData);
userData = demonstration.ToString();
var texture = (Texture2D)
AssetDatabase.LoadAssetAtPath(k_IconPath, typeof(Texture2D));
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(ctx.assetPath, demonstration, texture);
ctx.SetMainObject(demonstration);
#else
ctx.SetMainAsset(ctx.assetPath, demonstration);
#endif
}
catch
{
// ignored
}
}
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
var text = File.ReadAllText(ctx.assetPath);
var asset = new TextAsset(text);
ctx.AddObjectToAsset("main obj", asset);
ctx.SetMainObject(asset);
if (!Application.isPlaying)
{
return;
}
var luaVm = CSharpServiceManager.Get <LuaVM>(CSharpServiceManager.ServiceType.LUA_SERVICE);
var get = luaVm.Global.GetInPath <GetLuaService>("_ServiceManager.GetService");
var configService = get(1);
var reloadFunc = configService.Get <LuaFunction>("Reload");
reloadFunc.Call(Path.GetFileNameWithoutExtension(ctx.assetPath));
}
private void ImportSprites(UnityEditor.AssetImporters.AssetImportContext ctx, AseFile aseFile, UnityEditor.AssetImporters.SpriteImportData[] spriteImportData)
{
int spriteCount = spriteImportData.Length;
Sprite[] sprites = new Sprite[spriteCount];
for (int i = 0; i < spriteCount; i++)
{
Sprite sprite = Sprite.Create(atlas,
spriteImportData[i].rect,
spriteImportData[i].pivot, textureSettings.pixelsPerUnit, textureSettings.extrudeEdges,
textureSettings.meshType, spriteImportData[i].border, textureSettings.generatePhysics);
sprite.name = string.Format("{0}_{1}", name, spriteImportData[i].name);
ctx.AddObjectToAsset(sprite.name, sprite);
sprites[i] = sprite;
}
GenerateAnimations(ctx, aseFile, sprites);
}
