BlackMATov/unity-flash-tools
1
0
Fork 0
mirror of https://github.com/BlackMATov/unity-flash-tools.git synced 2026-03-22 12:55:32 +07:00
Code Issues Packages Projects Releases Wiki Activity

remove old impl

Browse Source
This commit is contained in:
Matvey Cherevko
2016-07-28 22:30:15 +07:00
parent 3b9030ec24
commit 616118ffd5
15 changed files with 0 additions and 1188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Assembly-CSharp-Editor.csproj
View File

@@ -45,10 +45,6 @@
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\FlashAnimAssetEditor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\FlashAnimAssetPostprocessor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\FlashAnimEditor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\FlashAnimFtaPostprocessor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\SwfAnimationAssetEditor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\SwfAnimationAssetPostprocessor.cs" />
<Compile Include="Assets\FlashTools\Scripts\Internal\Editor\SwfAnimationEditor.cs" />

2
Assembly-CSharp.csproj
View File

@@ -45,8 +45,6 @@
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="Assets\FlashTools\Scripts\FlashAnim.cs" />
<Compile Include="Assets\FlashTools\Scripts\FlashAnimAsset.cs" />
<Compile Include="Assets\FlashTools\Scripts\SwfAnimation.cs" />
<Compile Include="Assets\FlashTools\Scripts\SwfAnimationAsset.cs" />
<None Include="Assets\FlashTools\Shaders\FlashMaskReset.shader" />

BIN
Assets/FlashTools/Examples/Animations/Tests/6_masks.fla
View File

Binary file not shown.

264
Assets/FlashTools/Scripts/FlashAnim.cs
View File

@@ -1,264 +0,0 @@
using UnityEngine;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace FlashTools {
[ExecuteInEditMode]
[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class FlashAnim : MonoBehaviour {
public FlashAnimAsset Asset = null;
int _current_frame = 0;
int _current_symbol = -1;
float _frame_timer = 0.0f;
float _current_z = 0.0f;
string _lastAssetPath = string.Empty;
List<Vector2> _uvs = new List<Vector2>();
List<Color> _mulcolors = new List<Color>();
List<Vector4> _addcolors = new List<Vector4>();
List<Vector3> _vertices = new List<Vector3>();
List<int> _triangles = new List<int>();
public void Play() {
}
public void Stop() {
}
public void Pause() {
}
public void GoToFrame(int frame) {
}
public int currentFrame {
get { return _current_frame; }
set {
_current_frame = Mathf.Clamp(value, 0, frameCount - 1);
}
}
public int currentSymbol {
get { return _current_symbol; }
set {
_current_symbol = value;
}
}
public int frameCount {
get {
int frames = 0;
if ( Asset ) {
var layers = GetCurrentSymbol().Layers;
for ( var i = 0; i < layers.Count; ++i ) {
var layer = layers[i];
frames = Mathf.Max(frames, layer.Frames.Count);
}
}
return frames;
}
}
FlashAnimSymbolData GetCurrentSymbol() {
if ( currentSymbol >= 0 && currentSymbol < Asset.Data.Library.Symbols.Count ) {
return Asset.Data.Library.Symbols[currentSymbol];
} else {
return Asset.Data.Stage;
}
}
int GetNumFrameByNum(FlashAnimLayerData layer, int num) {
return num % layer.Frames.Count;
}
FlashAnimFrameData GetFrameByNum(FlashAnimLayerData layer, int num) {
var frame_num = GetNumFrameByNum(layer, num);
if ( frame_num >= 0 && frame_num < layer.Frames.Count ) {
return layer.Frames[frame_num];
}
return layer.Frames.Count > 0 ? layer.Frames[layer.Frames.Count - 1] : null;
}
FlashAnimSymbolData FindSymbol(FlashAnimLibraryData library, string symbol_id) {
for ( var i = 0; i < library.Symbols.Count; ++i ) {
var symbol = library.Symbols[i];
if ( symbol.Id == symbol_id ) {
return symbol;
}
}
return null;
}
FlashAnimBitmapData FindBitmap(FlashAnimLibraryData library, string bitmap_id) {
for ( var i = 0; i < library.Bitmaps.Count; ++i ) {
var bitmap = library.Bitmaps[i];
if ( bitmap.Id == bitmap_id ) {
return bitmap;
}
}
return null;
}
void RenderInstance(FlashAnimInstData elem_data, int frame_num, Matrix4x4 matrix, FlashAnimColorTransform color_trans) {
if ( elem_data.Type == FlashAnimInstType.Bitmap ) {
var bitmap = Asset ? FindBitmap(Asset.Data.Library, elem_data.Asset) : null;
if ( bitmap != null ) {
var width = bitmap.RealSize.x;
var height = bitmap.RealSize.y;
var v0 = new Vector3( 0, 0, _current_z);
var v1 = new Vector3( width, 0, _current_z);
var v2 = new Vector3( width, height, _current_z);
var v3 = new Vector3( 0, height, _current_z);
_current_z -= 20f;
_vertices.Add(matrix.MultiplyPoint3x4(v0));
_vertices.Add(matrix.MultiplyPoint3x4(v1));
_vertices.Add(matrix.MultiplyPoint3x4(v2));
_vertices.Add(matrix.MultiplyPoint3x4(v3));
_triangles.Add(_vertices.Count - 4 + 2);
_triangles.Add(_vertices.Count - 4 + 1);
_triangles.Add(_vertices.Count - 4 + 0);
_triangles.Add(_vertices.Count - 4 + 0);
_triangles.Add(_vertices.Count - 4 + 3);
_triangles.Add(_vertices.Count - 4 + 2);
var source_rect = bitmap.SourceRect;
_uvs.Add(new Vector2(source_rect.xMin, source_rect.yMax));
_uvs.Add(new Vector2(source_rect.xMax, source_rect.yMax));
_uvs.Add(new Vector2(source_rect.xMax, source_rect.yMin));
_uvs.Add(new Vector2(source_rect.xMin, source_rect.yMin));
_mulcolors.Add(color_trans.Mul);
_mulcolors.Add(color_trans.Mul);
_mulcolors.Add(color_trans.Mul);
_mulcolors.Add(color_trans.Mul);
_addcolors.Add(color_trans.Add);
_addcolors.Add(color_trans.Add);
_addcolors.Add(color_trans.Add);
_addcolors.Add(color_trans.Add);
}
} else if ( elem_data.Type == FlashAnimInstType.Symbol ) {
var symbol = Asset ? FindSymbol(Asset.Data.Library, elem_data.Asset) : null;
if ( symbol != null ) {
RenderSymbol(symbol, frame_num, matrix, color_trans);
}
}
}
void RenderSymbol(FlashAnimSymbolData symbol, int frame_num, Matrix4x4 matix, FlashAnimColorTransform color_trans) {
for ( var i = 0; i < symbol.Layers.Count; ++i ) {
var layer = symbol.Layers[i];
if ( layer.LayerType != FlashAnimLayerType.Guide &&
layer.LayerType != FlashAnimLayerType.Mask &&
layer.LayerType != FlashAnimLayerType.Folder )
{
var frame = GetFrameByNum(layer, frame_num);
if ( frame != null ) {
for ( var j = 0; j < frame.Elems.Count; ++j ) {
var elem = frame.Elems[j];
if ( elem.Instance != null && elem.Instance.Visible ) {
RenderInstance(
elem.Instance,
elem.Instance.FirstFrame,
matix * elem.Matrix,
color_trans * elem.Instance.ColorTransform);
}
}
}
}
}
}
void MartDirtySelf() {
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
// ------------------------------------------------------------------------
//
// Messages
//
// ------------------------------------------------------------------------
void Start() {
if ( Asset && Asset.Atlas ) {
var material = new Material(Shader.Find("FlashTools/FlashAnim"));
material.SetTexture("_MainTex", Asset.Atlas);
GetComponent<MeshRenderer>().sharedMaterial = material;
}
}
void Update() {
if ( Asset ) {
_frame_timer += Asset.Data.FrameRate * Time.deltaTime;
while ( _frame_timer > 1.0f ) {
_frame_timer -= 1.0f;
++_current_frame;
if ( _current_frame > frameCount - 1 ) {
_current_frame = 0;
}
//Debug.LogFormat("Cur frame: {0}", _current_frame);
}
} else {
#if UNITY_EDITOR
OnValidate();
#endif
}
}
#if UNITY_EDITOR
void OnValidate() {
if ( Asset ) {
_lastAssetPath = AssetDatabase.GetAssetPath(Asset);
} else {
if ( !string.IsNullOrEmpty(_lastAssetPath) ) {
Asset = AssetDatabase.LoadAssetAtPath<FlashAnimAsset>(_lastAssetPath);
EditorUtility.SetDirty(this);
}
}
}
#endif
void OnRenderObject() {
if ( Asset ) {
_vertices.Clear();
_triangles.Clear();
_uvs.Clear();
_mulcolors.Clear();
_addcolors.Clear();
_current_z = 0.0f;
RenderSymbol(
GetCurrentSymbol(),
_current_frame,
Matrix4x4.Scale(new Vector3(
1.0f / Asset.PixelsPerUnit,
-1.0f / Asset.PixelsPerUnit,
1.0f / Asset.PixelsPerUnit)),
FlashAnimColorTransform.identity);
var mesh_filter = GetComponent<MeshFilter>();
if ( mesh_filter ) {
var mesh = mesh_filter.sharedMesh
? mesh_filter.sharedMesh
: new Mesh();
mesh.Clear();
mesh.SetVertices(_vertices);
mesh.SetTriangles(_triangles, 0);
mesh.SetUVs(0, _uvs);
mesh.SetUVs(1, _addcolors);
mesh.SetColors(_mulcolors);
mesh.RecalculateNormals();
mesh_filter.sharedMesh = mesh;
}
}
}
}
}

12
Assets/FlashTools/Scripts/FlashAnim.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: b97e5bf24f6a64697ae8b7dc211e3127
timeCreated: 1455736843
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

154
Assets/FlashTools/Scripts/FlashAnimAsset.cs
View File

@@ -1,154 +0,0 @@
using UnityEngine;
using System.Collections.Generic;
namespace FlashTools {
public enum FlashAnimBlendMode {
Normal,
Layer,
Multiply,
Screen,
Overlay,
Hardlight,
Lighten,
Darken,
Difference,
Add,
Subtract,
Invert,
Alpha,
Erase
}
public enum FlashAnimLoopingMode {
Loop,
PlayOnce,
SingleFrame
}
public enum FlashAnimLayerType {
Normal,
Guide,
Guided,
Mask,
Masked,
Folder
}
public enum FlashAnimInstType {
Bitmap,
Symbol
}
public enum FlashAnimSymbolType {
Graphic,
MovieClip
}
[System.Serializable]
public struct FlashAnimColorTransform {
public Vector4 Mul;
public Vector4 Add;
public FlashAnimColorTransform(Vector4 Mul, Vector4 Add) {
this.Mul = Mul;
this.Add = Add;
}
public static FlashAnimColorTransform identity {
get {
return new FlashAnimColorTransform(
new Vector4(1,1,1,1),
new Vector4(0,0,0,0));
}
}
public static FlashAnimColorTransform operator*(
FlashAnimColorTransform a, FlashAnimColorTransform b)
{
var res = new FlashAnimColorTransform();
res.Mul.x = b.Mul.x * a.Mul.x;
res.Mul.y = b.Mul.y * a.Mul.y;
res.Mul.z = b.Mul.z * a.Mul.z;
res.Mul.w = b.Mul.w * a.Mul.w;
res.Add.x = b.Add.x * a.Mul.x + a.Add.x;
res.Add.y = b.Add.y * a.Mul.y + a.Add.y;
res.Add.z = b.Add.z * a.Mul.z + a.Add.z;
res.Add.w = b.Add.w * a.Mul.w + a.Add.w;
return res;
}
}
[System.Serializable]
public class FlashAnimBitmapData {
public string Id = string.Empty;
public Vector2 RealSize = Vector2.zero;
public Rect SourceRect = new Rect();
public string ImageSource = string.Empty;
public void CopyDataFrom(FlashAnimBitmapData other) {
RealSize = other.RealSize;
SourceRect = other.SourceRect;
ImageSource = other.ImageSource;
}
}
[System.Serializable]
public class FlashAnimInstData {
public FlashAnimInstType Type = FlashAnimInstType.Bitmap;
public FlashAnimBlendMode BlendMode = FlashAnimBlendMode.Normal;
public FlashAnimSymbolType SymbolType = FlashAnimSymbolType.Graphic;
public string Asset = string.Empty;
public bool Visible = true;
public int FirstFrame = 0;
public FlashAnimLoopingMode LoopingMode = FlashAnimLoopingMode.SingleFrame;
public FlashAnimColorTransform ColorTransform = FlashAnimColorTransform.identity;
}
[System.Serializable]
public class FlashAnimElemData {
public string Id = string.Empty;
public Matrix4x4 Matrix = Matrix4x4.identity;
public FlashAnimInstData Instance = null;
}
[System.Serializable]
public class FlashAnimFrameData {
public string Id = string.Empty;
public List<FlashAnimElemData> Elems = new List<FlashAnimElemData>();
}
[System.Serializable]
public class FlashAnimLayerData {
public string Id = string.Empty;
public FlashAnimLayerType LayerType = FlashAnimLayerType.Normal;
public List<FlashAnimFrameData> Frames = new List<FlashAnimFrameData>();
}
[System.Serializable]
public class FlashAnimSymbolData {
public string Id = string.Empty;
public List<FlashAnimLayerData> Layers = new List<FlashAnimLayerData>();
}
[System.Serializable]
public class FlashAnimLibraryData {
public List<FlashAnimBitmapData> Bitmaps = new List<FlashAnimBitmapData>();
public List<FlashAnimSymbolData> Symbols = new List<FlashAnimSymbolData>();
}
[System.Serializable]
public class FlashAnimData {
public FlashAnimSymbolData Stage = new FlashAnimSymbolData();
public FlashAnimLibraryData Library = new FlashAnimLibraryData();
public List<string> Strings = new List<string>();
public int FrameRate = 24;
}
public class FlashAnimAsset : ScriptableObject {
[HideInInspector]
public FlashAnimData Data = new FlashAnimData();
public Texture2D Atlas = null;
public int MaxAtlasSize = 1024;
public int AtlasPadding = 1;
public int PixelsPerUnit = 100;
}
}

12
Assets/FlashTools/Scripts/FlashAnimAsset.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 06e77921b348447d8afc2d08cad866b6
timeCreated: 1455736827
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

88
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimAssetEditor.cs
View File

@@ -1,88 +0,0 @@
using UnityEngine;
using UnityEngine.Rendering;
using UnityEditor;
using System;
using System.IO;
namespace FlashTools.Internal {
[CustomEditor(typeof(FlashAnimAsset))]
public class FlashAnimAssetEditor : Editor {
FlashAnimAsset _asset = null;
static void ApplySettings(FlashAnimAsset asset) {
if ( asset.Atlas ) {
AssetDatabase.DeleteAsset(
AssetDatabase.GetAssetPath(asset.Atlas));
asset.Atlas = null;
}
AssetDatabase.ImportAsset(
AssetDatabase.GetAssetPath(asset),
ImportAssetOptions.ForceUncompressedImport);
}
static void CreateFlashAnim(FlashAnimAsset asset, GameObject anim_go) {
var mesh_renderer = anim_go.AddComponent<MeshRenderer>();
mesh_renderer.sharedMaterial = null;
mesh_renderer.useLightProbes = false;
mesh_renderer.receiveShadows = false;
mesh_renderer.shadowCastingMode = ShadowCastingMode.Off;
mesh_renderer.reflectionProbeUsage = ReflectionProbeUsage.Off;
anim_go.AddComponent<MeshFilter>().sharedMesh = null;
anim_go.AddComponent<FlashAnim>().Asset = asset;
}
// ------------------------------------------------------------------------
//
// Public
//
// ------------------------------------------------------------------------
public static void CreateFlashAnimPrefab(FlashAnimAsset asset) {
var prefab_path = Path.ChangeExtension(
AssetDatabase.GetAssetPath(asset),
".prefab");
var flash_anim_go = CreateFlashAnimOnScene(asset, false);
if ( flash_anim_go ) {
PrefabUtility.CreatePrefab(prefab_path, flash_anim_go);
GameObject.DestroyImmediate(flash_anim_go, true);
}
}
public static GameObject CreateFlashAnimOnScene(FlashAnimAsset asset, bool undo) {
var anim_go = new GameObject("FlashAnim");
try {
CreateFlashAnim(asset, anim_go);
} catch ( Exception e ) {
Debug.LogErrorFormat("Create animation error: {0}", e.Message);
DestroyImmediate(anim_go, true);
}
Undo.RegisterCreatedObjectUndo(anim_go, "Create Animation");
return anim_go;
}
// ------------------------------------------------------------------------
//
// Messages
//
// ------------------------------------------------------------------------
void OnEnable() {
_asset = target as FlashAnimAsset;
}
public override void OnInspectorGUI() {
DrawDefaultInspector();
if ( GUILayout.Button("Apply settings") ) {
ApplySettings(_asset);
}
GUILayout.BeginHorizontal();
if ( GUILayout.Button("Create animation prefab") ) {
CreateFlashAnimPrefab(_asset);
}
if ( GUILayout.Button("Create animation on scene") ) {
CreateFlashAnimOnScene(_asset, true);
}
GUILayout.EndHorizontal();
}
}
}

12
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimAssetEditor.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: b39a64fff989148cf99d507561558d94
timeCreated: 1455737008
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

241
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimAssetPostprocessor.cs
View File

@@ -1,241 +0,0 @@
using UnityEngine;
using UnityEditor;
using System;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Collections.Generic;
namespace FlashTools.Internal {
public class FlashAnimAssetPostprocessor : AssetPostprocessor {
static void OnPostprocessAllAssets(
string[] imported_assets, string[] deleted_assets,
string[] moved_assets, string[] moved_from_asset_paths)
{
var asset_paths = imported_assets
.Where(p => Path.GetExtension(p).ToLower().Equals(".asset"));
foreach ( var asset_path in asset_paths ) {
var asset = AssetDatabase.LoadAssetAtPath<FlashAnimAsset>(asset_path);
if ( asset ) {
FaAssetProcess(asset_path, asset);
}
}
}
static void FaAssetProcess(string fa_asset_path, FlashAnimAsset fa_asset) {
try {
if ( !fa_asset.Atlas ) {
if ( !MarkAllBitmapsReadable(fa_asset_path, fa_asset) ) {
AssetDatabase.ImportAsset(
fa_asset_path,
ImportAssetOptions.ForceUncompressedImport);
return;
}
RemoveDuplicatedBitmaps(fa_asset_path, fa_asset);
if ( !PackBitmapsAtlas(fa_asset_path, fa_asset) ) {
AssetDatabase.ImportAsset(
fa_asset_path,
ImportAssetOptions.ForceUncompressedImport);
return;
}
ConfigureBitmapsAtlas(fa_asset_path, fa_asset);
FlashAnimAssetEditor.CreateFlashAnimPrefab(fa_asset);
}
} catch ( Exception e ) {
Debug.LogErrorFormat(
"Postprocess flash anim asset error: {0}",
e.Message);
}
}
static bool MarkAllBitmapsReadable(string fa_asset_path, FlashAnimAsset fa_asset) {
return FoldBitmapImporters(fa_asset_path, fa_asset.Data, true, (acc, importer) => {
var readable = importer.isReadable;
if ( !readable ) {
importer.isReadable = true;
AssetDatabase.ImportAsset(
importer.assetPath,
ImportAssetOptions.ForceUncompressedImport);
}
return readable && acc;
});
}
static void RemoveDuplicatedBitmaps(string fa_asset_path, FlashAnimAsset fa_asset) {
var bitmaps = fa_asset.Data.Library.Bitmaps;
for ( var i = 0; i < bitmaps.Count; ++i ) {
for ( var j = i + 1; j < bitmaps.Count; ++j ) {
var fst_bitmap = bitmaps[i];
var snd_bitmap = bitmaps[j];
if ( IsBitmapsExistsAndDifferentButEqual(fa_asset_path, fst_bitmap, snd_bitmap) ) {
var bitmap_importer = GetBitmapImporter(fa_asset_path, snd_bitmap);
if ( AssetDatabase.DeleteAsset(bitmap_importer.assetPath) ) {
snd_bitmap.CopyDataFrom(fst_bitmap);
EditorUtility.SetDirty(fa_asset);
}
}
}
}
}
static bool PackBitmapsAtlas(string fa_asset_path, FlashAnimAsset fa_asset) {
var textures = fa_asset.Data.Library.Bitmaps
.Select(bitmap_data => GetBitmapTexture(fa_asset_path, bitmap_data))
.ToList();
var atlas = new Texture2D(0, 0);
var atlas_path = GetBitmapsAtlasPath(fa_asset_path);
var atlas_rects = atlas.PackTextures(
textures.ToArray(), fa_asset.AtlasPadding, fa_asset.MaxAtlasSize);
File.WriteAllBytes(atlas_path, atlas.EncodeToPNG());
GameObject.DestroyImmediate(atlas, true);
AssetDatabase.ImportAsset(
atlas_path,
ImportAssetOptions.ForceUncompressedImport);
for ( var i = 0; i < textures.Count; ++i ) {
var bitmap_data = fa_asset.Data.Library.Bitmaps[i];
bitmap_data.RealSize = new Vector2(textures[i].width, textures[i].height);
bitmap_data.SourceRect = atlas_rects[i];
}
fa_asset.Atlas = AssetDatabase.LoadAssetAtPath<Texture2D>(atlas_path);
EditorUtility.SetDirty(fa_asset);
return fa_asset.Atlas != null;
}
static void ConfigureBitmapsAtlas(string fa_asset_path, FlashAnimAsset fa_asset) {
var meta_data = new List<SpriteMetaData>();
var atlas_importer = GetBitmapsAtlasImporter(fa_asset_path);
var atlas_size = GetSizeFromTextureImporter(atlas_importer);
var unique_bitmaps = fa_asset.Data.Library.Bitmaps
.GroupBy(p => p.ImageSource)
.Select(p => p.First());
foreach ( var bitmap_data in unique_bitmaps ) {
var meta_elem = new SpriteMetaData();
meta_elem.name = bitmap_data.Id.ToString();
meta_elem.rect = new Rect(
bitmap_data.SourceRect.xMin * atlas_size.x,
bitmap_data.SourceRect.yMin * atlas_size.y,
bitmap_data.SourceRect.width * atlas_size.x,
bitmap_data.SourceRect.height * atlas_size.y);
meta_data.Add(meta_elem);
atlas_importer.spritesheet = meta_data.ToArray();
atlas_importer.textureType = TextureImporterType.Sprite;
atlas_importer.spriteImportMode = SpriteImportMode.Multiple;
atlas_importer.spritePixelsPerUnit = fa_asset.PixelsPerUnit;
AssetDatabase.ImportAsset(
GetBitmapsAtlasPath(fa_asset_path),
ImportAssetOptions.ForceUncompressedImport);
}
}
// -----------------------------
// Common
// -----------------------------
static T FoldBitmapAssetPaths<T>(
string fa_asset_path, FlashAnimData data,
T init, Func<T, string, FlashAnimBitmapData, T> act)
{
return data.Library.Bitmaps.Aggregate(init, (acc, bitmap_data) => {
var asset_path = GetBitmapAssetPath(fa_asset_path, bitmap_data);
return act(acc, asset_path, bitmap_data);
});
}
static T FoldBitmapImporters<T>(
string fa_asset_path, FlashAnimData data,
T init, Func<T, TextureImporter, T> act)
{
return FoldBitmapAssetPaths(fa_asset_path, data, init, (acc, path, bitmap_data) => {
var importer = GetBitmapImporter(fa_asset_path, bitmap_data);
return act(acc, importer);
});
}
static string GetBitmapAssetPath(string fa_asset_path, FlashAnimBitmapData bitmap_data) {
return Path.Combine(
Path.GetDirectoryName(fa_asset_path),
bitmap_data.ImageSource);
}
static Texture2D GetBitmapTexture(string fa_asset_path, FlashAnimBitmapData bitmap_data) {
var asset_path = GetBitmapAssetPath(fa_asset_path, bitmap_data);
var texture = AssetDatabase.LoadAssetAtPath<Texture2D>(asset_path);
if ( !texture ) {
throw new UnityException(string.Format(
"bitmap ({0}) texture not found ({1})",
bitmap_data.Id, asset_path));
}
return texture;
}
static Texture2D FindBitmapTexture(string fa_asset_path, FlashAnimBitmapData bitmap_data) {
try {
return GetBitmapTexture(fa_asset_path, bitmap_data);
} catch ( Exception ) {
return null;
}
}
static TextureImporter GetBitmapImporter(string fa_asset_path, FlashAnimBitmapData bitmap_data) {
var asset_path = GetBitmapAssetPath(fa_asset_path, bitmap_data);
var importer = AssetImporter.GetAtPath(asset_path) as TextureImporter;
if ( !importer ) {
throw new UnityException(string.Format(
"bitmap ({0}) texture importer not found ({1})",
bitmap_data.Id, asset_path));
}
return importer;
}
static TextureImporter FindBitmapImporter(string fa_asset_path, FlashAnimBitmapData bitmap_data) {
try {
return GetBitmapImporter(fa_asset_path, bitmap_data);
} catch ( Exception ) {
return null;
}
}
static bool IsBitmapsExistsAndDifferentButEqual(
string fa_asset_path,
FlashAnimBitmapData bitmap_data_a, FlashAnimBitmapData bitmap_data_b)
{
if ( bitmap_data_a.ImageSource == bitmap_data_b.ImageSource ) {
return false;
}
var texture_a = FindBitmapTexture(fa_asset_path, bitmap_data_a);
var texture_b = FindBitmapTexture(fa_asset_path, bitmap_data_b);
if ( !texture_a || !texture_b ) {
return false;
}
if ( texture_a.width != texture_b.width || texture_a.height != texture_b.height ) {
return false;
}
var tex_data_a = texture_a.GetPixels32();
var tex_data_b = texture_b.GetPixels32();
return tex_data_a.SequenceEqual(tex_data_b);
}
static string GetBitmapsAtlasPath(string fa_asset_path) {
return Path.ChangeExtension(fa_asset_path, ".png");
}
static TextureImporter GetBitmapsAtlasImporter(string fa_asset_path) {
var atlas_path = GetBitmapsAtlasPath(fa_asset_path);
var importer = AssetImporter.GetAtPath(atlas_path) as TextureImporter;
if ( !importer ) {
throw new UnityException(string.Format(
"atlas texture importer not found ({0})",
atlas_path));
}
return importer;
}
static Vector2 GetSizeFromTextureImporter(TextureImporter importer) {
var method_args = new object[2]{0,0};
typeof(TextureImporter)
.GetMethod("GetWidthAndHeight", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(importer, method_args);
return new Vector2((int)method_args[0], (int)method_args[1]);
}
}
}

12
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimAssetPostprocessor.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: ca3ab7e53ac8f4d94988820890b14b55
timeCreated: 1456252226
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

43
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimEditor.cs
View File

@@ -1,43 +0,0 @@
using UnityEngine;
using UnityEditor;
using System.Linq;
namespace FlashTools.Internal {
[CustomEditor(typeof(FlashAnim))]
public class FlashAnimEditor : Editor {
FlashAnim _anim = null;
// ------------------------------------------------------------------------
//
// Messages
//
// ------------------------------------------------------------------------
void OnEnable() {
_anim = target as FlashAnim;
}
public override void OnInspectorGUI() {
DrawDefaultInspector();
if ( _anim.Asset ) {
if ( _anim.frameCount > 1 ) {
var new_current_frame = EditorGUILayout.IntSlider(
"Frame",
_anim.currentFrame, 0, _anim.frameCount - 1);
if ( new_current_frame != _anim.currentFrame ) {
_anim.currentFrame = new_current_frame;
}
}
var symbols = _anim.Asset.Data.Library.Symbols.Select(p => p.Id).ToArray();
var new_current_symbol = EditorGUILayout.Popup(
"Symbol",
_anim.currentSymbol, symbols);
if ( new_current_symbol != _anim.currentSymbol ) {
_anim.currentSymbol = new_current_symbol;
}
}
}
}
}

12
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimEditor.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 781fe7f2449064964aa12b2b41537001
timeCreated: 1455737000
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

320
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimFtaPostprocessor.cs
View File

@@ -1,320 +0,0 @@
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);
ConfigureMovieClips(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.SymbolType = SafeLoadEnumFromElemAttr(inst_elem, "symbol_type" , instance.SymbolType);
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);
}
}
}
static void ConfigureMovieClips(FlashAnimData data) {
ConfigureSymbol(data.Stage);
foreach ( var symbol in data.Library.Symbols ) {
ConfigureSymbol(symbol);
}
}
static void ConfigureSymbol(FlashAnimSymbolData data) {
foreach ( var layer in data.Layers ) {
ConfigureLayer(layer);
}
}
static void ConfigureLayer(FlashAnimLayerData data) {
ResetMovieClipsOnLayer(data);
for ( var i = 0; i < data.Frames.Count; ++i ) {
var frame = data.Frames[i];
foreach ( var elem in frame.Elems ) {
if ( IsInstanceMovieClip(elem.Instance) && elem.Instance.FirstFrame == -1 ) {
elem.Instance.FirstFrame = 0;
int count = 0;
for ( var i2 = i + 1; i2 < data.Frames.Count; ++i2 ) {
var frame2 = data.Frames[i2];
var has_elem = false;
foreach ( var elem2 in frame2.Elems ) {
if ( IsInstanceMovieClip(elem2.Instance) && elem2.Instance.FirstFrame == -1 ) {
if ( elem.Id == elem2.Id && elem.Instance.Asset == elem2.Instance.Asset ) {
Debug.LogFormat("Bingo: {0} - {1}", i, i2);
elem2.Instance.FirstFrame = ++count;
has_elem = true;
break;
}
}
}
if ( !has_elem ) {
break;
}
}
}
}
}
}
static bool IsInstanceMovieClip(FlashAnimInstData instance) {
return
instance.Type == FlashAnimInstType.Symbol &&
instance.SymbolType == FlashAnimSymbolType.MovieClip;
}
static void ResetMovieClipsOnLayer(FlashAnimLayerData data) {
foreach ( var frame in data.Frames ) {
foreach ( var elem in frame.Elems ) {
if (
elem.Instance.Type == FlashAnimInstType.Symbol &&
elem.Instance.SymbolType == FlashAnimSymbolType.MovieClip )
{
elem.Instance.FirstFrame = -1;
}
}
}
}
// -----------------------------
// 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;
}
}
}
}

12
Assets/FlashTools/Scripts/Internal/Editor/FlashAnimFtaPostprocessor.cs.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: f429b99b17de54c74b0c1241e645b3c1
timeCreated: 1455827111
licenseType: Free
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: