//导入
public override void OnImportAsset(AssetImportContext ctx)
{
name = GetFileName(ctx.assetPath);
AseFile aseFile = ReadAseFile(ctx.assetPath);
Texture2D[] frames = aseFile.GetFrames();
//翻转贴图
//if (textureSettings.flipTexture) {
// for (int i = 0; i < frames.Length; i++) {
// frames[i] = FlipTexture(frames[i]);
// }
//}
SpriteImportData[] spriteImportData = new SpriteImportData[0];
Vector2Int size = new Vector2Int(aseFile.Header.Width, aseFile.Header.Height);
atlas = AseAtlasGenerator.GenerateAtlas(frames, out spriteImportData, size, textureSettings);
atlas.filterMode = FilterMode.Point;
ctx.AddObjectToAsset("Texture", atlas);
//生成贴图文件
GenerateSprites(ctx, aseFile, spriteImportData);
ctx.SetMainObject(atlas);
}
// replaces color to transparent
public Texture2D GenerateAtlas(Texture2D[] sprites, out SpriteImportData[] spriteData, int cols, int rows,
Color mask, bool baseTwo = true)
{
var spriteImportData = new List <SpriteImportData>();
var width = cols * spriteSize.x;
var height = rows * spriteSize.y;
if (baseTwo)
{
var baseTwoValue = CalculateNextBaseTwoValue(Math.Max(width, height));
width = baseTwoValue;
height = baseTwoValue;
}
// blank transparent canvas
var atlas = Texture2DUtil.CreateTransparentTexture(width, height);
var index = 0;
// step through each pixel
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
Rect spriteRect = new Rect(col * spriteSize.x, atlas.height - ((row + 1) * spriteSize.y),
spriteSize.x, spriteSize.y);
// change pixel mask to transparent
Color[] pixelPallete = ReplaceMaskToTransparent(mask, sprites[index].GetPixels());
atlas.SetPixels((int)spriteRect.x, (int)spriteRect.y, (int)spriteRect.width,
(int)spriteRect.height, pixelPallete);
atlas.Apply();
var importData = new SpriteImportData
{
rect = spriteRect,
pivot = textureSettings.spritePivot,
border = Vector4.zero,
name = index.ToString()
};
spriteImportData.Add(importData);
index++;
if (index >= sprites.Length)
{
break;
}
}
if (index >= sprites.Length)
{
break;
}
}
spriteData = spriteImportData.ToArray();
return(atlas);
}
public override void OnImportAsset(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();
}
SpriteImportData[] spriteImportData = new 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);
}
private static SpriteImportData[] ConvertAseFileSpriteImportDataToUnity(AseFileSpriteImportData[] spriteImportData)
{
SpriteImportData[] importData = new SpriteImportData[spriteImportData.Length];
for (int i = 0; i < spriteImportData.Length; i++)
{
importData[i] = spriteImportData[i].ToSpriteImportData();
}
return(importData);
}
private static Sprite CreateNamedSprite(
string name,
Texture2D texture,
SpriteImportData importData,
AsepriteImporterSettings settings)
{
var sprite = Sprite.Create(
texture,
importData.rect,
importData.pivot,
settings.PixelsPerUnit,
settings.ExtrudeEdges,
settings.MeshType,
importData.border,
settings.GeneratePhysicsShape);
sprite.name = name;
return(sprite);
}
static Texture2D GenerateAtlas(Texture2D[] sprites, out SpriteImportData[] spriteData, Vector2Int spriteSize, AseTextureSettings textureSettings, int cols, int rows)
{
var spriteImportData = new List <SpriteImportData>();
var width = cols * spriteSize.x;
var height = rows * spriteSize.y;
var atlas = CreateTransparentTexture(width, height);
var index = 0;
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
Rect spriteRect = new Rect(col * spriteSize.x, atlas.height - ((row + 1) * spriteSize.y), spriteSize.x, spriteSize.y);
atlas.SetPixels((int)spriteRect.x, (int)spriteRect.y, (int)spriteRect.width, (int)spriteRect.height, sprites[index].GetPixels());
atlas.Apply();
var importData = new SpriteImportData {
rect = spriteRect,
pivot = textureSettings.spritePivot,
border = Vector4.zero,
name = index.ToString()
};
spriteImportData.Add(importData);
index++;
if (index >= sprites.Length)
{
break;
}
}
if (index >= sprites.Length)
{
break;
}
}
spriteData = spriteImportData.ToArray();
return(atlas);
}
private void GenerateSeparateTexturesFromLayers(AssetImportContext ctx, AseFile aseFile)
{
SpriteAtlasBuilder atlasBuilder = new SpriteAtlasBuilder(textureSettings, aseFile.Header.Width, aseFile.Header.Height);
SpriteImportData[] spriteImportData = new SpriteImportData[0];
List <LayerChunk> layers = aseFile.GetChunks <LayerChunk>();
for (int i = 0; i < layers.Count; i++)
{
List <Texture2D> layerFrames = aseFile.GetLayerTexture(i, layers[i]);
Texture2D layerAtlas;
layerAtlas = atlasBuilder.GenerateAtlas(layerFrames.ToArray(), out spriteImportData, textureSettings.transparentMask, false);
layerAtlas.filterMode = textureSettings.filterMode;
layerAtlas.alphaIsTransparency = false;
layerAtlas.wrapMode = TextureWrapMode.Clamp;
layerAtlas.name = layers[i].LayerName;
//AssetDatabase.CreateAsset( layerAtlas, Path.GetDirectoryName( ctx.assetPath ) + "/" + Path.GetFileNameWithoutExtension( ctx.assetPath ) + "-" + layers[i].LayerName + ".asset" );
ctx.AddObjectToAsset(layers[i].LayerName, layerAtlas);
if (i == 0)
{
// assign member "atlas" for ImportSprites() etc below
atlas = layerAtlas;
ctx.SetMainObject(layerAtlas);
}
}
switch (importType)
{
case AseFileImportType.LayerToSprite:
case AseFileImportType.Sprite:
ImportSprites(ctx, aseFile, spriteImportData);
break;
case AseFileImportType.Tileset:
ImportTileset(ctx);
break;
}
}
public Texture2D GenerateAtlas(Texture2D[] sprites, out SpriteImportData[] spriteData, int cols, int rows,
bool baseTwo = true)
{
var spriteImportData = new List <SpriteImportData>();
var width = cols * spriteSize.x;
var height = rows * spriteSize.y;
if (baseTwo)
{
var baseTwoValue = CalculateNextBaseTwoValue(Math.Max(width, height));
width = baseTwoValue;
height = baseTwoValue;
}
var atlas = Texture2DUtil.CreateTransparentTexture(width, height);
var index = 0;
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
Rect spriteRect = new Rect(col * spriteSize.x, atlas.height - ((row + 1) * spriteSize.y),
spriteSize.x, spriteSize.y);
switch (textureSettings.mirror)
{
case MirrorOption.X:
sprites[index] = FlipAtlas(sprites[index]);
break;
case MirrorOption.Y:
sprites[index] = FlipAtlas(sprites[index], true);
break;
}
atlas.SetPixels((int)spriteRect.x, (int)spriteRect.y, (int)spriteRect.width,
(int)spriteRect.height, sprites[index].GetPixels());
atlas.Apply();
var importData = new SpriteImportData
{
rect = spriteRect,
pivot = textureSettings.spritePivot,
border = Vector4.zero,
name = index.ToString()
};
spriteImportData.Add(importData);
index++;
if (index >= sprites.Length)
{
break;
}
}
if (index >= sprites.Length)
{
break;
}
}
spriteData = spriteImportData.ToArray();
return(atlas);
}
public override void OnImportAsset(AssetImportContext ctx)
{
name = GetFileName(ctx.assetPath);
AseFile aseFile = ReadAseFile(ctx.assetPath);
//Debug.Log(string.Format("导入Ase动画文件：{0}，帧间隔为{1}（相当于动画帧率{2})", name, aseFile.Header.Speed, Mathf.RoundToInt(1000 / aseFile.Header.Speed)));
this.aseFile = aseFile;
SpriteAtlasBuilder atlasBuilder = new SpriteAtlasBuilder(textureSettings, aseFile.Header.Width, aseFile.Header.Height);
Texture2D[] frames;
if (importType != AseFileImportType.LayerToSprite)
{
frames = aseFile.GetFrames();
}
else
{
frames = aseFile.GetLayersAsFrames();
}
SpriteImportData[] spriteImportData = new SpriteImportData[0];
//if (textureSettings.transparentMask)
//{
// atlas = atlasBuilder.GenerateAtlas(frames, out spriteImportData, textureSettings.transparentColor, false);
//}
//else
//{
// atlas = atlasBuilder.GenerateAtlas(frames, out spriteImportData, false);
//}
//翻转贴图
if (textureSettings.flipTexture)
{
for (int i = 0; i < frames.Length; i++)
{
frames[i] = FlipTexture(frames[i]);
}
}
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);
}
//生成动画
static void GenerateAnimation(string name, GifFile gif, string path, ref AnimationInfo info)
{
AnimationClip clip = new AnimationClip();
clip.name = name;
clip.frameRate = 25;
//创建动画文件
string asset = string.Format("{0}/{1}.anim", path, name);
AssetDatabase.CreateAsset(clip, asset);
SpriteImportData[] spriteImportData = new SpriteImportData[0];
Texture2D atlas = AtlasGenerator.GenerateAtlas(gif, out spriteImportData);
atlas.filterMode = FilterMode.Point;
atlas.name = name;
//AssetDatabase.AddObjectToAsset(atlas, clip);
byte[] pngBytes = atlas.EncodeToPNG();
string atlasPath = string.Format("{0}/{1}.png", path, name);
File.WriteAllBytes(atlasPath, pngBytes);
AssetDatabase.Refresh();
//生成的贴图
Texture2D atlasObject = (Texture2D)AssetDatabase.LoadAssetAtPath(atlasPath, typeof(Texture2D));
atlasObject.filterMode = FilterMode.Point;
//生成贴图
List <Sprite> sprites = GenerateSprites(atlasObject, spriteImportData, clip);
//帧数
int length = sprites.Count;
EditorCurveBinding spriteBinding = new EditorCurveBinding();
spriteBinding.type = typeof(SpriteRenderer);
spriteBinding.path = "";
spriteBinding.propertyName = "m_Sprite";
//设置帧信息
ObjectReferenceKeyframe[] spriteKeyFrames = new ObjectReferenceKeyframe[length + 1];
float time = 0;
for (int i = 0; i < length; i++)
{
ObjectReferenceKeyframe frame = new ObjectReferenceKeyframe();
frame.time = time;
frame.value = sprites[i];
time += gif.textureList[i].m_delaySec;
spriteKeyFrames[i] = frame;
}
//单独设置最后一帧
float frameTime = 1f / clip.frameRate;
ObjectReferenceKeyframe lastFrame = new ObjectReferenceKeyframe();
lastFrame.time = time - frameTime;
lastFrame.value = sprites[length - 1];
spriteKeyFrames[spriteKeyFrames.Length - 1] = lastFrame;
AnimationUtility.SetObjectReferenceCurve(clip, spriteBinding, spriteKeyFrames);
//循环设置
AnimationClipSettings settings = AnimationUtility.GetAnimationClipSettings(clip);
//循环设置
//if (animationSetting.loop) {
// settings.loopTime = true;
// clip.wrapMode = WrapMode.Loop;
//} else {
// settings.loopTime = false;
// clip.wrapMode = WrapMode.Once;
//}
AnimationUtility.SetAnimationClipSettings(clip, settings);
info.animationClip = clip;
info.texture = atlasObject;
}
public AsepriteAssets CreateAssets(AsepriteImporterSettings settings, string name)
{
var padding = settings.InnerPadding;
var paddedFrameSize = new Vector2Int(
_frameSize.x + padding * 2,
_frameSize.y + padding * 2);
var spritesheet = CreateBlankSpritesheet(
settings,
paddedFrameSize,
_frames.Count,
out int cols);
var sprites = new List <Sprite>();
for (var i = 0; i < _frames.Count; ++i)
{
var frame = _frames[i];
var col = i % cols;
var row = Mathf.FloorToInt(i / (float)cols) + 1;
var spriteRect = new Rect(
col * paddedFrameSize.x,
spritesheet.height - (row * paddedFrameSize.y),
paddedFrameSize.x,
paddedFrameSize.y);
var framePixels = frame.GetFramePixels(_frameSize);
spritesheet.SetPixels(
(int)spriteRect.x + padding,
(int)spriteRect.y + padding,
_frameSize.x,
_frameSize.y,
framePixels);
var spriteData = new SpriteImportData
{
rect = spriteRect,
pivot = settings.PivotValue
+ new Vector2(
padding / (float)paddedFrameSize.x,
padding / (float)paddedFrameSize.y),
name = i.ToString()
};
var sprite = CreateNamedSprite(
string.Format("{0}_{1}", name, spriteData.name),
spritesheet,
spriteData,
settings);
sprites.Add(sprite);
}
spritesheet.Apply();
var animations = CreateAnimations(name, sprites, typeof(SpriteRenderer));
var uiAnimName = $"UI_{name}";
var uiAnimations = CreateAnimations(uiAnimName, sprites, typeof(Image));
return(new AsepriteAssets(
spritesheet,
sprites,
animations.Concat(uiAnimations)));
}
private void GenerateSeparateTexturesFromLayers(AssetImportContext ctx, AseFile aseFile)
{
SpriteAtlasBuilder atlasBuilder = new SpriteAtlasBuilder(textureSettings, aseFile.Header.Width, aseFile.Header.Height);
List <LayerChunk> layers = aseFile.GetChunks <LayerChunk>();
SpriteImportData[] spriteImportData = new SpriteImportData[0];
{
List <Texture2D> layerFrames = aseFile.GetLayerTexture(0, layers[0]);
Texture2D layerAtlas = atlasBuilder.GenerateAtlas(layerFrames.ToArray(), out spriteImportData, textureSettings.transparentMask, false);
layerAtlas.filterMode = textureSettings.filterMode;
layerAtlas.alphaIsTransparency = false;
layerAtlas.wrapMode = TextureWrapMode.Clamp;
layerAtlas.name = layers[0].LayerName;
//string assetpath = Path.GetDirectoryName( ctx.assetPath ) + "/" + Path.GetFileNameWithoutExtension( ctx.assetPath ) + "-" + layers[0].LayerName + ".asset";
//AssetDatabase.CreateAsset( layerAtlas, assetpath );
ctx.AddObjectToAsset(layers[0].LayerName, layerAtlas);
switch (importType)
{
case AseFileImportType.LayerToSprite:
case AseFileImportType.Sprite:
ImportSprites(ctx, aseFile, spriteImportData, layerAtlas);
break;
case AseFileImportType.Tileset:
ImportTileset(ctx, layerAtlas);
break;
}
}
for (int i = 1; i < layers.Count; i++)
{
List <Texture2D> layerFrames = aseFile.GetLayerTexture(i, layers[i]);
Texture2D layerAtlas = atlasBuilder.GenerateAtlas(layerFrames.ToArray(), out _, textureSettings.transparentMask, false);
layerAtlas.filterMode = textureSettings.filterMode;
layerAtlas.alphaIsTransparency = false;
layerAtlas.wrapMode = TextureWrapMode.Clamp;
layerAtlas.name = layers[i].LayerName;
ctx.AddObjectToAsset(layers[i].LayerName, layerAtlas);
/*
* string imagepath = Path.GetDirectoryName( ctx.assetPath ) + "/" + Path.GetFileNameWithoutExtension( ctx.assetPath ) + "-" + layers[i].LayerName + ".png";
*
* Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>( imagepath );
* if( texture == null )
* {
* File.WriteAllBytes( imagepath, layerAtlas.EncodeToPNG() );
* AssetDatabase.SaveAssets();
* }
* else
* {
*
* //texture.SetPixelData( layerAtlas.GetRawTextureData(), 0 );
* //EditorUtility.SetDirty( texture );
* }
* AssetDatabase.Refresh();
* Texture2D asdf = AssetDatabase.LoadAssetAtPath<Texture2D>( imagepath );
*
* //AssetDatabase.CreateAsset( layerAtlas, assetpath );
*
*
* TextureImporter textureImporter = GetAtPath( imagepath ) as TextureImporter;
* if( textureImporter != null )
* {
* SecondarySpriteTexture[] sst = new SecondarySpriteTexture[1];
* sst[0].name = "_NormalMap";
* sst[0].texture = layerAtlas;
* textureImporter.secondarySpriteTextures = sst;
*
* EditorUtility.SetDirty( textureImporter );
* textureImporter.SaveAndReimport();
*
* }
*/
}
}
