public override void Process(ImportContext ctx, Layer layer)
{
var eventFrames = new HashSet <int>();
var file = ctx.file;
for (int i = 0; i < file.frames.Count; ++i)
{
bool isEvent = file.frames[i].cels.ContainsKey(layer.layerIndex);
if (isEvent)
{
eventFrames.Add(i);
}
}
LayerParamType paramType = layer.GetParamType(1);
foreach (var frametag in file.frameTags)
{
var clip = ctx.generatedClips[frametag];
var events = new List <AnimationEvent>(clip.events);
var time = 0.0f;
for (int f = frametag.from; f <= frametag.to; ++f)
{
if (eventFrames.Contains(f))
{
var evt = new AnimationEvent
{
time = time,
functionName = layer.GetParamString(0),
messageOptions = SendMessageOptions.DontRequireReceiver
};
// Debug.Log(paramType + ", " + layer.metaInfo.ParamCount);
if (paramType == LayerParamType.String)
{
evt.stringParameter = layer.GetParamString(1);
}
else if (paramType == LayerParamType.Number)
{
var fval = layer.GetParamFloat(1);
evt.floatParameter = fval;
if (fval == Math.Floor(fval))
{
evt.intParameter = (int)fval;
}
}
events.Add(evt);
}
time += file.frames[f].duration * 1e-3f;
}
events.Sort((lhs, rhs) => lhs.time.CompareTo(rhs.time));
AnimationUtility.SetAnimationEvents(clip, events.ToArray());
EditorUtility.SetDirty(clip);
}
}
public override void Process(ImportContext context, Layer layer) {
string subImageName = layer.GetParamString(0);
string targetChildObject = layer.GetParamString(1);
List<Layer> layers;
context.subImageLayers.TryGetValue(subImageName, out layers);
var sprites = AtlasGenerator.GenerateAtlas(context, layers,
Path.GetDirectoryName(context.atlasPath) + "/" +
context.fileNameNoExt + "_" + subImageName + ".png");
ASEImporter.GenerateClipImageLayer(context, targetChildObject, sprites);
}
public override void Process(ImportContext ctx, Layer layer)
{
var file = ctx.file;
var eventFlags = new List <int>(file.frames.Count);
for (int i = 0; i < file.frames.Count; ++i)
{
file.frames[i].cels.TryGetValue(layer.index, out Cel cel);
if (cel != null)
{
eventFlags.Add(i);
}
}
if (eventFlags.Count == 0)
{
return;
}
var eventName = layer.GetParamString(0);
foreach (var freame in eventFlags)
{
var sprites = ctx.generatedSprites[freame];
if (sprites.eventSet.Add(eventName) == false)
{
Love.Log.Error($"duplicate event {eventName}");
}
}
}
public override void Process(ImportContext context, Layer layer)
{
string subImageName = layer.GetParamString(0);
List <Layer> layers;
context.subImageLayers.TryGetValue(subImageName, out layers);
if (layers == null)
{
context.subImageLayers.Add(subImageName, layers = new List <Layer>());
}
layers.Add(layer);
}
public override void Process(ImportContext ctx, Layer layer)
{
var pivots = new List <RectFrame>();
var file = ctx.file;
//var importer = AssetImporter.GetAtPath(ctx.atlasPath) as TextureImporter;
var spriteSheet = ctx.generatedSprites;
for (int i = 0; i < file.frames.Count; ++i)
{
Cel cel;
file.frames[i].cels.TryGetValue(layer.index, out cel);
if (cel != null)
{
pivots.Add(new RectFrame {
frame = i, name = layer.GetParamString(0), rect = RectOfCel(cel)
});
}
}
if (pivots.Count == 0)
{
return;
}
for (int i = 0; i < spriteSheet.Count; ++i)
{
int j = 1;
while (j < pivots.Count && pivots[j].frame <= i)
{
++j; // j = index after found item
}
var data = pivots[j - 1];
spriteSheet[i].rectDict[data.name] = data.rect;
}
}
public override void Process(ImportContext ctx, Layer layer)
{
var path = layer.GetParamString(0);
EditorCurveBinding
bindingOffX = Binding(path, typeof(BoxCollider2D), "m_Offset.x"),
bindingOffY = Binding(path, typeof(BoxCollider2D), "m_Offset.y"),
bindingSizeX = Binding(path, typeof(BoxCollider2D), "m_Size.x"),
bindingSizeY = Binding(path, typeof(BoxCollider2D), "m_Size.y"),
bindingEnable = Binding(path, typeof(BoxCollider2D), "m_Enabled");
bool changeEnable = layer.ParamCount >= 2 ? layer.GetParamBool(1) : true;
List <Rect> frameRects = new List <Rect>();
for (int i = 0; i < ctx.file.frames.Count; ++i)
{
var frame = ctx.file.frames[i];
Cel cel;
frame.cels.TryGetValue(layer.index, out cel);
if (cel == null)
{
frameRects.Add(new Rect(0, 0, 0, 0));
}
else
{
int minx = int.MaxValue, miny = int.MaxValue, maxx = int.MinValue, maxy = int.MinValue;
for (int y = 0; y < cel.height; ++y)
{
for (int x = 0; x < cel.width; ++x)
{
var col = cel.GetPixelRaw(x, y);
if (col.a > 0.1f)
{
int texX = cel.x + x;
int texY = ctx.file.height - (cel.y + y) - 1;
minx = Mathf.Min(minx, texX);
miny = Mathf.Min(miny, texY);
maxx = Mathf.Max(maxx, texX);
maxy = Mathf.Max(maxy, texY);
}
}
}
if (maxx == int.MinValue)
{
frameRects.Add(new Rect(0, 0, 0, 0));
}
else
{
var texCenter = new Vector2((maxx + minx) / 2.0f, (maxy + miny) / 2.0f);
var texSize = new Vector2(maxx - minx, maxy - miny);
var pivot = Vector2.Scale(ctx.settings.PivotRelativePos, new Vector2(ctx.file.width, ctx.file.height));
var posWorld = (texCenter - pivot) / ctx.settings.ppu;
var sizeWorld = texSize / ctx.settings.ppu;
frameRects.Add(new Rect(posWorld, sizeWorld));
}
}
}
foreach (var frameTag in ctx.file.frameTags)
{
var clip = ctx.generatedClips[frameTag];
AnimationCurve
curveOffX = new AnimationCurve(),
curveOffY = new AnimationCurve(),
curveSizeX = new AnimationCurve(),
curveSizeY = new AnimationCurve(),
curveEnable = new AnimationCurve();
float t = 0;
bool hasEnable = false;
for (int f = frameTag.from; f <= frameTag.to; ++f)
{
var rect = frameRects[f];
var enable = rect.size != Vector2.zero;
curveEnable.AddKey(new Keyframe(t, enable ? 1 : 0));
if (enable)
{
hasEnable = true;
curveOffX.AddKey(t, rect.position.x);
curveOffY.AddKey(t, rect.position.y);
curveSizeX.AddKey(t, rect.size.x);
curveSizeY.AddKey(t, rect.size.y);
}
t += ctx.file.frames[f].duration / 1000.0f;
}
if (hasEnable)
{
MakeConstant(curveOffX);
MakeConstant(curveOffY);
MakeConstant(curveSizeX);
MakeConstant(curveSizeY);
MakeConstant(curveEnable);
AnimationUtility.SetEditorCurve(clip, bindingOffX, curveOffX);
AnimationUtility.SetEditorCurve(clip, bindingOffY, curveOffY);
AnimationUtility.SetEditorCurve(clip, bindingSizeX, curveSizeX);
AnimationUtility.SetEditorCurve(clip, bindingSizeY, curveSizeY);
if (changeEnable)
{
AnimationUtility.SetEditorCurve(clip, bindingEnable, curveEnable);
}
EditorUtility.SetDirty(clip);
}
}
}
public void Process(ImportContext ctx, Layer layer)
{
var childName = layer.GetParamString(0);
EditorCurveBinding
bindingX = new EditorCurveBinding {
path = childName, type = typeof(Transform), propertyName = "m_LocalPosition.x"
},
bindingY = new EditorCurveBinding {
path = childName, type = typeof(Transform), propertyName = "m_LocalPosition.y"
};
var frames = new Dictionary <int, Vector2>();
var file = ctx.file;
for (int i = 0; i < file.frames.Count; ++i)
{
Vector2 center = Vector2.zero;
int pixelCount = 0;
Cel cel;
file.frames[i].cels.TryGetValue(layer.index, out cel);
if (cel == null)
{
continue;
}
for (int y = 0; y < cel.height; ++y)
{
for (int x = 0; x < cel.width; ++x)
{
int texX = cel.x + x;
int texY = -(cel.y + y) + file.height - 1;
var col = cel.GetPixelRaw(x, y);
if (col.a > 0.1f)
{
center += new Vector2(texX, texY);
pixelCount++;
}
}
}
if (pixelCount > 0)
{
center /= pixelCount;
var pivot = Vector2.Scale(ctx.settings.PivotRelativePos, new Vector2(file.width, file.height));
var posWorld = (center - pivot) / ctx.settings.ppu;
frames.Add(i, posWorld);
}
}
foreach (var frameTag in file.frameTags)
{
var clip = ctx.generatedClips[frameTag];
AnimationCurve curveX = new AnimationCurve(),
curveY = new AnimationCurve();
float t = 0;
for (int f = frameTag.from; f <= frameTag.to; ++f)
{
if (frames.ContainsKey(f))
{
var pos = frames[f];
curveX.AddKey(t, pos.x);
curveY.AddKey(t, pos.y);
}
t += file.frames[f].duration * 1e-3f;
}
if (curveX.length > 0)
{
MakeConstant(curveX);
MakeConstant(curveY);
AnimationUtility.SetEditorCurve(clip, bindingX, curveX);
AnimationUtility.SetEditorCurve(clip, bindingY, curveY);
EditorUtility.SetDirty(clip);
}
}
}
public override void Process(ImportContext ctx, Layer layer)
{
// the name of the data variable should be the first parameter. eg @data("leg l")
string dataName = layer.GetParamString(0);
var file = ctx.file;
var importer = AssetImporter.GetAtPath(ctx.atlasPath) as TextureImporter;
var spriteSheet = importer.spritesheet;
// each tag represents a different animation. look at each frame of each tag. store coordinates of any visible pixels.
// these represent the data points.
foreach (var tag in ctx.file.frameTags)
{
string animName = tag.name;
Vector3 distance = Vector3.zero;
var frameDataList = new FrameDataList {
frames = new List <FrameData>()
};
int numFrames = tag.to - tag.from + 1;
for (int i = tag.from, j = 0; i <= tag.to; ++i, j++)
{
var frameData = new FrameData {
frame = j, coords = new List <Vector2>()
};
Cel cel;
file.frames[i].cels.TryGetValue(layer.index, out cel);
if (cel != null)
{
int pixelCount = 0;
for (int y = 0; y < cel.height; ++y)
{
for (int x = 0; x < cel.width; ++x)
{
// tex coords relative to full texture boundaries
int texX = cel.x + x;
int texY = -(cel.y + y) + file.height - 1;
// store position of any visible pixels
var pxl = cel.GetPixelRaw(x, y);
if (pxl.a > 0.1f)
{
// start the coordinate of the pixel on the layer (from bottom left corner)
Vector2 coord = new Vector2(texX, texY);
// default pixel origin is bottom left. if centered, add half a pixel in x and y directions
if (ctx.settings.pixelOrigin == PixelOrigin.Center)
{
coord += new Vector2(0.5f, 0.5f);
}
// calculate position in relation to pivot
Vector2 pivot = spriteSheet[i].pivot;
Vector2 pivotPxl = new Vector2(pivot.x * spriteSheet[i].rect.width, pivot.y * spriteSheet[i].rect.height);
// get coordinate relative to pivot
coord -= ctx.spriteCropPositions[i];
coord -= pivotPxl;
// if calculating "prev pivot" data, and this is first pixel (should only be one), then store its distance
if (dataName == "prev pivot" && pixelCount == 0)
{
// coord is distance from pivot. negate to make positive, and round to get rid of float errors
distance += new Vector3(-Mathf.Round(coord.x), -Mathf.Round(coord.y), 0);
}
// points are all relative to the sprite's bounding rectangle, which is 1 by 1 in both dimensions
// regardless of sprite size. So (0.5, 0.5) would be the center of the sprite.
// it's ok for points to be outside the bounding rectangle. they'll just be less than 0, or greater than 1.
// WHY? so if the sprite is transformed, everything stays relative. You can multiply points by the transforms
// to get their position relative to the transform.
// NOTE: spriteSheet[i].rect.width/height are in pixels
coord = new Vector2(coord.x / spriteSheet[i].rect.width, coord.y / spriteSheet[i].rect.height);
frameData.coords.Add(coord);
++pixelCount;
}
}
}
if (pixelCount > 0)
{
frameDataList.frames.Add(frameData);
}
}
}
// if we've collected all the data for this animation, save it in appropriate dictionary spot
if (frameDataList.frames.Count > 0)
{
if (ctx.animData.animDict.ContainsKey(animName))
{
ctx.animData.animDict[animName].frameDict.Add(dataName, frameDataList);
if (dataName == "prev pivot")
{
ctx.animData.animDict[animName].distance = distance;
}
}
else
{
ctx.animData.animDict.Add(animName, new AnimList {
numFrames = numFrames,
distance = distance,
frameDict = new FrameDictionary()
{
{
dataName,
frameDataList
}
}
});
}
// Debug.Log(ctx.animData.data["run e"]);
}
}
// Debug.Log(data);
}
