mirror of
https://github.com/BlackMATov/unity-flash-tools.git
synced 2025-12-16 22:19:31 +07:00
257 lines
9.9 KiB
C#
257 lines
9.9 KiB
C#
using UnityEngine;
|
|
using UnityEditor;
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
using System.Globalization;
|
|
|
|
namespace FlashTools.Internal {
|
|
public class FlashAnimFtaPostprocessor : AssetPostprocessor {
|
|
static void OnPostprocessAllAssets(
|
|
string[] imported_assets, string[] deleted_assets,
|
|
string[] moved_assets, string[] moved_from_asset_paths)
|
|
{
|
|
var fta_asset_paths = imported_assets
|
|
.Where(p => Path.GetExtension(p).ToLower().Equals(".fta"));
|
|
foreach ( var fta_asset_path in fta_asset_paths ) {
|
|
FtaAssetProcess(fta_asset_path);
|
|
}
|
|
}
|
|
|
|
static void FtaAssetProcess(string fta_asset) {
|
|
var flash_anim_data = LoadFlashAnimFromFtaFile(fta_asset);
|
|
if ( flash_anim_data != null ) {
|
|
var new_asset_path = Path.ChangeExtension(fta_asset, ".asset");
|
|
var new_asset = AssetDatabase.LoadAssetAtPath<FlashAnimAsset>(new_asset_path);
|
|
if ( !new_asset ) {
|
|
new_asset = ScriptableObject.CreateInstance<FlashAnimAsset>();
|
|
AssetDatabase.CreateAsset(new_asset, new_asset_path);
|
|
}
|
|
new_asset.Data = flash_anim_data;
|
|
EditorUtility.SetDirty(new_asset);
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.DeleteAsset(fta_asset);
|
|
}
|
|
}
|
|
|
|
static FlashAnimData LoadFlashAnimFromFtaFile(string fta_path) {
|
|
try {
|
|
return LoadFlashAnimDocFromFtaRootElem(
|
|
XDocument.Load(fta_path).Document.Root,
|
|
new FlashAnimData());
|
|
} catch ( Exception e ) {
|
|
Debug.LogErrorFormat("Parsing flash anim .fta file error: {0}", e.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// -----------------------------
|
|
// Document
|
|
// -----------------------------
|
|
|
|
static FlashAnimData LoadFlashAnimDocFromFtaRootElem(XElement root_elem, FlashAnimData data) {
|
|
LoadFlashAnimStageFromFtaRootElem (root_elem, data);
|
|
LoadFlashAnimLibraryFromFtaRootElem(root_elem, data);
|
|
LoadFlashAnimStringsFromFtaRootElem(root_elem, data);
|
|
data.FrameRate = SafeLoadIntFromElemAttr(
|
|
root_elem, "frame_rate", data.FrameRate);
|
|
return data;
|
|
}
|
|
|
|
// -----------------------------
|
|
// Stage
|
|
// -----------------------------
|
|
|
|
static void LoadFlashAnimStageFromFtaRootElem(XElement root_elem, FlashAnimData data) {
|
|
var stage_elem = root_elem.Element("stage");
|
|
LoadFlashAnimLayersFromFtaSymbolElem(stage_elem, data.Stage);
|
|
}
|
|
|
|
// -----------------------------
|
|
// Library
|
|
// -----------------------------
|
|
|
|
static void LoadFlashAnimLibraryFromFtaRootElem(XElement root_elem, FlashAnimData data) {
|
|
var library_elem = root_elem.Element("library");
|
|
LoadFlashAnimBitmapsFromFtaLibraryElem(library_elem, data);
|
|
LoadFlashAnimSymbolsFromFtaLibraryElem(library_elem, data);
|
|
}
|
|
|
|
static void LoadFlashAnimBitmapsFromFtaLibraryElem(XElement library_elem, FlashAnimData data) {
|
|
foreach ( var bitmap_elem in library_elem.Elements("bitmap") ) {
|
|
var bitmap = new FlashAnimBitmapData();
|
|
bitmap.Id = SafeLoadStrFromElemAttr(bitmap_elem, "id", bitmap.Id);
|
|
bitmap.ImageSource = bitmap.Id + ".png";
|
|
data.Library.Bitmaps.Add(bitmap);
|
|
}
|
|
}
|
|
|
|
static void LoadFlashAnimSymbolsFromFtaLibraryElem(XElement library_elem, FlashAnimData data) {
|
|
foreach ( var symbol_elem in library_elem.Elements("symbol") ) {
|
|
var symbol = new FlashAnimSymbolData();
|
|
symbol.Id = SafeLoadStrFromElemAttr(symbol_elem, "id", symbol.Id);
|
|
LoadFlashAnimLayersFromFtaSymbolElem(symbol_elem, symbol);
|
|
data.Library.Symbols.Add(symbol);
|
|
}
|
|
}
|
|
|
|
static void LoadFlashAnimLayersFromFtaSymbolElem(XElement symbol_elem, FlashAnimSymbolData data) {
|
|
foreach ( var layer_elem in symbol_elem.Elements("layer") ) {
|
|
var layer = new FlashAnimLayerData();
|
|
layer.Id = SafeLoadStrFromElemAttr (layer_elem, "id" , layer.Id);
|
|
layer.LayerType = SafeLoadEnumFromElemAttr(layer_elem, "layer_type", FlashAnimLayerType.Normal);
|
|
LoadFlashAnimFramesFromFtaLayerElem(layer_elem, layer);
|
|
data.Layers.Add(layer);
|
|
}
|
|
}
|
|
|
|
static void LoadFlashAnimFramesFromFtaLayerElem(XElement layer_elem, FlashAnimLayerData data) {
|
|
foreach ( var frame_elem in layer_elem.Elements("frame") ) {
|
|
var frame = new FlashAnimFrameData();
|
|
frame.Id = SafeLoadStrFromElemAttr(frame_elem, "id", frame.Id);
|
|
LoadFlashAnimElemsFromFtaFrameElem(frame_elem, frame);
|
|
data.Frames.Add(frame);
|
|
}
|
|
}
|
|
|
|
static void LoadFlashAnimElemsFromFtaFrameElem(XElement frame_elem, FlashAnimFrameData data) {
|
|
foreach ( var elem_elem in frame_elem.Elements("element") ) {
|
|
var elem = new FlashAnimElemData();
|
|
elem.Id = SafeLoadStrFromElemAttr(elem_elem, "id" , elem.Id);
|
|
elem.Matrix = SafeLoadMatFromElemAttr(elem_elem, "matrix", elem.Matrix);
|
|
LoadFlashAnimInstFromFtaElemElem(elem_elem, elem);
|
|
data.Elems.Add(elem);
|
|
}
|
|
}
|
|
|
|
static void LoadFlashAnimInstFromFtaElemElem(XElement elem_elem, FlashAnimElemData data) {
|
|
var inst_elem = elem_elem.Element("instance");
|
|
var instance = new FlashAnimInstData();
|
|
instance.Type = SafeLoadEnumFromElemAttr(inst_elem, "type" , instance.Type);
|
|
instance.BlendMode = SafeLoadEnumFromElemAttr(inst_elem, "blend_mode" , instance.BlendMode);
|
|
instance.Asset = SafeLoadStrFromElemAttr (inst_elem, "asset" , instance.Asset);
|
|
instance.Visible = SafeLoadBoolFromElemAttr(inst_elem, "visible" , instance.Visible);
|
|
instance.FirstFrame = SafeLoadIntFromElemAttr (inst_elem, "first_frame" , instance.FirstFrame);
|
|
instance.LoopingMode = SafeLoadEnumFromElemAttr(inst_elem, "looping_mode", instance.LoopingMode);
|
|
var color_transform_elem = inst_elem.Element("color_effect");
|
|
if ( color_transform_elem != null ) {
|
|
instance.ColorTransform = SafeLoadColFromElemAttr(color_transform_elem, "transform", instance.ColorTransform);
|
|
}
|
|
data.Instance = instance;
|
|
}
|
|
|
|
// -----------------------------
|
|
// Strings
|
|
// -----------------------------
|
|
|
|
static void LoadFlashAnimStringsFromFtaRootElem(XElement root_elem, FlashAnimData data) {
|
|
var strings_elem = root_elem.Element("strings");
|
|
foreach ( var string_elem in strings_elem.Elements("string") ) {
|
|
var string_id = SafeLoadStrFromElemAttr(string_elem, "id" , null);
|
|
var string_str = SafeLoadStrFromElemAttr(string_elem, "str", null);
|
|
if ( !string.IsNullOrEmpty(string_id) && string_str != null ) {
|
|
data.Strings.Add(string_id);
|
|
data.Strings.Add(string_str);
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------
|
|
// Common
|
|
// -----------------------------
|
|
|
|
static string SafeLoadStrFromElemAttr(XElement elem, string attr_name, string def_value) {
|
|
if ( elem != null && elem.Attribute(attr_name) != null ) {
|
|
return elem.Attribute(attr_name).Value;
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static int SafeLoadIntFromElemAttr(XElement elem, string attr_name, int def_value) {
|
|
int value;
|
|
var int_str = SafeLoadStrFromElemAttr(elem, attr_name, string.Empty);
|
|
if ( elem != null && int.TryParse(int_str, out value) ) {
|
|
return value;
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static float SafeLoadFloatFromElemAttr(XElement elem, string attr_name, float def_value) {
|
|
float value;
|
|
var float_str = SafeLoadStrFromElemAttr(elem, attr_name, string.Empty);
|
|
if ( elem != null && float.TryParse(float_str, NumberStyles.Any, CultureInfo.InvariantCulture, out value) ) {
|
|
return value;
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static bool SafeLoadBoolFromElemAttr(XElement elem, string attr_name, bool def_value) {
|
|
bool value;
|
|
var bool_str = SafeLoadStrFromElemAttr(elem, attr_name, string.Empty);
|
|
if ( elem != null && bool.TryParse(bool_str, out value) ) {
|
|
return value;
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static Matrix4x4 SafeLoadMatFromElemAttr(XElement elem, string attr_name, Matrix4x4 def_value) {
|
|
var mat_str = SafeLoadStrFromElemAttr(elem, attr_name, string.Empty);
|
|
var mat_strs = mat_str.Split(';');
|
|
if ( mat_strs.Length == 6 ) {
|
|
float a, b, c, d, tx, ty;
|
|
if (
|
|
float.TryParse(mat_strs[0], NumberStyles.Any, CultureInfo.InvariantCulture, out a ) &&
|
|
float.TryParse(mat_strs[1], NumberStyles.Any, CultureInfo.InvariantCulture, out b ) &&
|
|
float.TryParse(mat_strs[2], NumberStyles.Any, CultureInfo.InvariantCulture, out c ) &&
|
|
float.TryParse(mat_strs[3], NumberStyles.Any, CultureInfo.InvariantCulture, out d ) &&
|
|
float.TryParse(mat_strs[4], NumberStyles.Any, CultureInfo.InvariantCulture, out tx) &&
|
|
float.TryParse(mat_strs[5], NumberStyles.Any, CultureInfo.InvariantCulture, out ty) )
|
|
{
|
|
var mat = Matrix4x4.identity;
|
|
mat.m00 = a;
|
|
mat.m10 = b;
|
|
mat.m01 = c;
|
|
mat.m11 = d;
|
|
mat.m03 = tx;
|
|
mat.m13 = ty;
|
|
return mat;
|
|
}
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static FlashAnimColorTransform SafeLoadColFromElemAttr(XElement elem, string attr_name, FlashAnimColorTransform def_value) {
|
|
var col_str = SafeLoadStrFromElemAttr(elem, attr_name, string.Empty);
|
|
var col_strs = col_str.Split(';');
|
|
if ( col_strs.Length == 8 ) {
|
|
float rp, gp, bp, ap, ra, ga, ba, aa;
|
|
if (
|
|
float.TryParse(col_strs[0], NumberStyles.Any, CultureInfo.InvariantCulture, out rp) &&
|
|
float.TryParse(col_strs[1], NumberStyles.Any, CultureInfo.InvariantCulture, out gp) &&
|
|
float.TryParse(col_strs[2], NumberStyles.Any, CultureInfo.InvariantCulture, out bp) &&
|
|
float.TryParse(col_strs[3], NumberStyles.Any, CultureInfo.InvariantCulture, out ap) &&
|
|
float.TryParse(col_strs[4], NumberStyles.Any, CultureInfo.InvariantCulture, out ra) &&
|
|
float.TryParse(col_strs[5], NumberStyles.Any, CultureInfo.InvariantCulture, out ga) &&
|
|
float.TryParse(col_strs[6], NumberStyles.Any, CultureInfo.InvariantCulture, out ba) &&
|
|
float.TryParse(col_strs[7], NumberStyles.Any, CultureInfo.InvariantCulture, out aa))
|
|
{
|
|
return new FlashAnimColorTransform(
|
|
new Vector4(rp, gp, bp, ap),
|
|
new Vector4(ra, ga, ba, aa)
|
|
);
|
|
}
|
|
}
|
|
return def_value;
|
|
}
|
|
|
|
static T SafeLoadEnumFromElemAttr<T>(XElement elem, string attr_name, T def_value) {
|
|
try {
|
|
return (T)Enum.Parse(typeof(T), SafeLoadStrFromElemAttr(elem, attr_name, string.Empty), true);
|
|
} catch ( Exception ) {
|
|
return def_value;
|
|
}
|
|
}
|
|
}
|
|
}
|