static List <SwfClipAsset.Sequence> LoadClipSequences(
SwfAsset asset, SwfAssetData data, SwfSymbolData symbol)
{
var sequences = new List <SwfClipAsset.Sequence>();
if (IsValidAssetsForFrame(asset, symbol))
{
foreach (var frame in symbol.Frames)
{
var baked_frame = BakeClipFrame(asset, data, frame);
if (!string.IsNullOrEmpty(frame.Anchor) &&
(sequences.Count < 1 || sequences.Last().Name != frame.Anchor))
{
sequences.Add(new SwfClipAsset.Sequence {
Name = frame.Anchor
});
}
else if (sequences.Count < 1)
{
sequences.Add(new SwfClipAsset.Sequence {
Name = "Default"
});
}
sequences.Last().Frames.Add(baked_frame);
}
}
return(sequences);
}
// ---------------------------------------------------------------------
//
// ConfigureBitmaps
//
// ---------------------------------------------------------------------
static SwfAssetData ConfigureBitmaps(SwfAsset asset, SwfAssetData data)
{
var textures = new List <KeyValuePair <ushort, Texture2D> >(data.Bitmaps.Count);
for (var i = 0; i < data.Bitmaps.Count; ++i)
{
_progressBar.UpdateProgress(
"configure bitmaps",
(float)(i + 1) / data.Bitmaps.Count);
var bitmap = data.Bitmaps[i];
if (bitmap.Redirect == 0)
{
textures.Add(new KeyValuePair <ushort, Texture2D>(
bitmap.Id,
LoadTextureFromData(bitmap, asset.Settings)));
}
}
var rects = PackAndSaveBitmapsAtlas(
GetAtlasPath(asset),
textures.Select(p => p.Value).ToArray(),
asset.Settings);
for (var i = 0; i < data.Bitmaps.Count; ++i)
{
var bitmap = data.Bitmaps[i];
var texture_key = bitmap.Redirect > 0 ? bitmap.Redirect : bitmap.Id;
bitmap.SourceRect = SwfRectData.FromURect(
rects[textures.FindIndex(p => p.Key == texture_key)]);
}
return(data);
}
public static void Apply(AbcTrait trait, SwfAsset asset, SwfMovie lib)
{
if (trait.Embed != null)
{
return;
}
var klass = trait.Class;
if (klass == null)
{
throw new InvalidOperationException("Embed can be applied to class trait only");
}
var instance = klass.Instance;
var embed = new Embed
{
Asset = asset,
Movie = lib,
Instance = instance
};
trait.Embed = embed;
trait.AssetInstance = instance;
}
static bool IsValidAssetsForFrame(
SwfAsset asset, SwfSymbolData symbol)
{
return
(asset && asset.Atlas && asset.Data != null &&
symbol != null && symbol.Frames != null);
}
static bool SafeLoadSwfAsset(string swf_path, string swf_hash, SwfAsset swf_asset)
{
try {
_progressBar.UpdateTitle(Path.GetFileName(swf_path));
var new_data = LoadSwfAssetData(swf_path);
swf_asset.Data = SwfEditorUtils.CompressAsset(new_data, progress => {
_progressBar.UpdateProgress("swf asset compression", progress);
});
swf_asset.Hash = swf_hash;
if (swf_asset.Atlas)
{
AssetDatabase.DeleteAsset(
AssetDatabase.GetAssetPath(swf_asset.Atlas));
swf_asset.Atlas = null;
}
EditorUtility.SetDirty(swf_asset);
return(true);
} catch (Exception e) {
Debug.LogErrorFormat(
AssetDatabase.LoadMainAssetAtPath(swf_path),
"<b>[FlashTools]</b> Parsing swf error: {0}\nSwf path: {1}",
e.Message, swf_path);
return(false);
} finally {
_progressBar.HideProgress();
}
}
private SwfAsset AddSymbol(ISwfCharacter obj, AbcInstance instance)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
var tag = obj as SwfTag;
if (tag == null)
{
throw new ArgumentException("Character is not swf tag");
}
if (!Swf.Tags.Contains(tag))
{
Swf.Tags.Add(tag);
}
string name = instance.FullName;
var asset = new SwfAsset(obj, name)
{
IsSymbol = true,
};
_symbols.Add(asset);
return(asset);
}
static void SwfAssetProcess(SwfAsset asset)
{
try {
EditorUtility.SetDirty(asset);
var asset_data = SwfEditorUtils.DecompressAsset <SwfAssetData>(asset.Data, progress => {
_progressBar.UpdateProgress("decompress swf asset", progress);
});
asset.Atlas = LoadAssetAtlas(asset);
if (asset.Atlas)
{
ConfigureAtlas(asset);
ConfigureClips(asset, asset_data);
}
else
{
_progressBar.UpdateTitle(asset.name);
var new_data = ConfigureBitmaps(asset, asset_data);
asset.Data = SwfEditorUtils.CompressAsset(new_data, progress => {
_progressBar.UpdateProgress("compress swf asset", progress);
});
}
} catch (Exception e) {
Debug.LogErrorFormat(
asset,
"<b>[FlashTools]</b> Postprocess swf asset error: {0}\nPath: {1}",
e.Message, AssetDatabase.GetAssetPath(asset));
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(asset));
} finally {
if (asset)
{
UpdateAssetClips(asset);
}
_progressBar.HideProgress();
}
}
private ISwfCharacter ImportCharacter(SwfMovie from, SwfAsset asset)
{
var c = _charCache[asset.Name] as ISwfCharacter;
if (c != null)
{
return(c);
}
var tag = asset.Character as SwfTag;
CheckCharacter(tag);
var mytag = Swf.Import(from, tag);
CheckCharacter(mytag);
c = (ISwfCharacter)mytag;
if (asset.IsExported)
{
_exports.Add(c, asset.Name);
}
_charCache[asset.Name] = c;
return(c);
}
// ---------------------------------------------------------------------
//
// ConfigureClips
//
// ---------------------------------------------------------------------
static SwfAssetData ConfigureClips(SwfAsset asset, SwfAssetData data)
{
for (var i = 0; i < data.Symbols.Count; ++i)
{
_progressBar.UpdateProgress(
"configure clips",
(float)(i + 1) / data.Symbols.Count);
ConfigureClip(asset, data, data.Symbols[i]);
}
return(data);
}
static void ReconvertAsset(SwfAsset asset)
{
if (asset.Atlas)
{
AssetDatabase.DeleteAsset(
AssetDatabase.GetAssetPath(asset.Atlas));
asset.Atlas = null;
}
EditorUtility.SetDirty(asset);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(asset));
}
private static SwfAsset Link(SwfAsset asset, ISwfCharacter character, bool isExport)
{
asset.Character = character;
if (isExport)
{
character.Name = asset.Name;
}
return(asset);
}
static string GetAtlasPath(SwfAsset asset)
{
if (asset.Atlas)
{
return(AssetDatabase.GetAssetPath(asset.Atlas));
}
else
{
var asset_path = AssetDatabase.GetAssetPath(asset);
return(Path.ChangeExtension(asset_path, "._Atlas_.png"));
}
}
static TextureImporter GetBitmapsAtlasImporter(SwfAsset asset)
{
var atlas_path = AssetDatabase.GetAssetPath(asset.Atlas);
var atlas_importer = UnityEditor.AssetImporter.GetAtPath(atlas_path) as TextureImporter;
if (!atlas_importer)
{
throw new UnityException(string.Format(
"atlas texture importer not found ({0})",
atlas_path));
}
return(atlas_importer);
}
static void ConfigureClipAsset(
SwfClipAsset clip_asset, SwfAsset asset, SwfAssetData data, SwfSymbolData symbol)
{
var asset_guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(asset));
var asset_atlas = AssetDatabase.LoadAssetAtPath <Sprite>(AssetDatabase.GetAssetPath(asset.Atlas));
clip_asset.Name = symbol.Name;
clip_asset.Sprite = asset_atlas;
clip_asset.FrameRate = data.FrameRate;
clip_asset.AssetGUID = asset_guid;
clip_asset.Sequences = LoadClipSequences(asset, data, symbol);
EditorUtility.SetDirty(clip_asset);
}
// ---------------------------------------------------------------------
//
// UpdateAssetClips
//
// ---------------------------------------------------------------------
static void UpdateAssetClips(SwfAsset asset)
{
var asset_guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(asset));
var scene_clips = GameObject.FindObjectsOfType <SwfClip>()
.Where(p => p && p.clip && p.clip.AssetGUID == asset_guid)
.ToList();
for (var i = 0; i < scene_clips.Count; ++i)
{
_progressBar.UpdateProgress(
"update scene clips",
(float)(i + 1) / scene_clips.Count);
scene_clips[i].Internal_UpdateAllProperties();
}
}
private static SwfAsset Link(SwfAsset asset, ISwfCharacter character)
{
asset.Character = character;
if (asset.IsExported)
{
character.Name = asset.Name;
}
else if (asset.IsSymbol)
{
if (string.IsNullOrEmpty(character.Name))
{
character.Name = asset.Name;
}
}
return(asset);
}
// ---------------------------------------------------------------------
//
// ConfigureAtlas
//
// ---------------------------------------------------------------------
static void ConfigureAtlas(SwfAsset asset)
{
var atlas_importer = GetBitmapsAtlasImporter(asset);
atlas_importer.textureType = TextureImporterType.Sprite;
atlas_importer.spriteImportMode = SpriteImportMode.Single;
atlas_importer.spritePixelsPerUnit = asset.Settings.PixelsPerUnit;
atlas_importer.mipmapEnabled = asset.Settings.GenerateMipMaps;
atlas_importer.filterMode = SwfAtlasFilterToImporterFilter(asset.Settings.AtlasTextureFilter);
atlas_importer.textureCompression = SwfAtlasFormatToImporterCompression(asset.Settings.AtlasTextureFormat);
var atlas_settings = new TextureImporterSettings();
atlas_importer.ReadTextureSettings(atlas_settings);
atlas_settings.spriteMeshType = SpriteMeshType.FullRect;
atlas_importer.SetTextureSettings(atlas_settings);
atlas_importer.SaveAndReimport();
}
static void ConfigureClip(SwfAsset asset, SwfAssetData data, SwfSymbolData symbol)
{
var asset_guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(asset));
var clip_assets = SwfEditorUtils.LoadAllAssetsDBByFilter <SwfClipAsset>("t:SwfClipAsset")
.Where(p => p.AssetGUID == asset_guid && p.Name == symbol.Name);
if (clip_assets.Any())
{
foreach (var clip_asset in clip_assets)
{
ConfigureClipAsset(clip_asset, asset, data, symbol);
}
}
else
{
var asset_path = AssetDatabase.GetAssetPath(asset);
var clip_asset_path = Path.ChangeExtension(asset_path, symbol.Name + ".asset");
SwfEditorUtils.LoadOrCreateAsset <SwfClipAsset>(clip_asset_path, (new_clip_asset, created) => {
ConfigureClipAsset(new_clip_asset, asset, data, symbol);
return(true);
});
}
}
private static void DumpAsset(TextWriter writer, SwfMovie swf, SwfAsset asset)
{
var tag = asset.Character as SwfTag;
if (tag != null)
{
writer.WriteLine("[{0}] {1} - {2}", asset.Id, asset.Name, tag.TagCode);
var refs = tag.GetRefs();
if (refs != null && refs.Length > 0)
{
foreach (int rid in refs)
{
var rc = swf.GetCharacter((ushort)rid);
if (rc != null)
{
if (string.IsNullOrEmpty(rc.Name))
{
writer.WriteLine("\t{0}[{1}]", rc.TagCode, rid);
}
else
{
writer.WriteLine("\t{0}[{1}]", rc.Name, rid);
}
}
else
{
writer.Write("\tnull[{0}]", rid);
}
}
}
}
else
{
writer.WriteLine("[{0}] {1}", asset.Id, asset.Name);
}
}
public static bool CheckForOutdatedAsset(SwfAsset asset)
{
return(asset &&
GetVersionFromFileHashWithVersion(asset.Hash) != SwfVersion.AsString);
}
//
//
//
static void RevertOverriddenSettings(SwfAsset asset)
{
asset.Overridden = asset.Settings;
}
static void OverriddenSettingsToDefault(SwfAsset asset)
{
asset.Overridden = GetSettingsHolder().Settings;
}
static Texture2D LoadAssetAtlas(SwfAsset asset)
{
return(AssetDatabase.LoadAssetAtPath <Texture2D>(
GetAtlasPath(asset)));
}
static void ApplyOverriddenSettings(SwfAsset asset)
{
asset.Settings = asset.Overridden;
ReconvertAsset(asset);
}
static SwfClipAsset.Frame BakeClipFrame(
SwfAsset asset, SwfAssetData data, SwfFrameData frame)
{
List <uint> baked_uvs = new List <uint>();
List <uint> baked_mulcolors = new List <uint>();
List <uint> baked_addcolors = new List <uint>();
List <Vector2> baked_vertices = new List <Vector2>();
List <BakedGroup> baked_groups = new List <BakedGroup>();
List <Material> baked_materials = new List <Material>();
foreach (var inst in frame.Instances)
{
var bitmap = inst != null
? FindBitmapFromAssetData(data, inst.Bitmap)
: null;
while (bitmap != null && bitmap.Redirect > 0)
{
bitmap = FindBitmapFromAssetData(data, bitmap.Redirect);
}
if (bitmap != null)
{
var br = asset.Settings.BitmapTrimming
? bitmap.TrimmedRect
: new SwfRectIntData(bitmap.RealWidth, bitmap.RealHeight);
var v0 = new Vector2(br.xMin, br.yMin);
var v1 = new Vector2(br.xMax, br.yMin);
var v2 = new Vector2(br.xMax, br.yMax);
var v3 = new Vector2(br.xMin, br.yMax);
var matrix =
Matrix4x4.Scale(new Vector3(1.0f, -1.0f, 1.0f) / asset.Settings.PixelsPerUnit) *
inst.Matrix.ToUMatrix() *
Matrix4x4.Scale(new Vector3(1.0f / 20.0f, 1.0f / 20.0f, 1.0f));
baked_vertices.Add(matrix.MultiplyPoint3x4(v0));
baked_vertices.Add(matrix.MultiplyPoint3x4(v1));
baked_vertices.Add(matrix.MultiplyPoint3x4(v2));
baked_vertices.Add(matrix.MultiplyPoint3x4(v3));
var source_rect = bitmap.SourceRect;
baked_uvs.Add(SwfEditorUtils.PackUV(source_rect.xMin, source_rect.yMin));
baked_uvs.Add(SwfEditorUtils.PackUV(source_rect.xMax, source_rect.yMax));
uint mul_pack0, mul_pack1;
SwfEditorUtils.PackFColorToUInts(
inst.ColorTrans.mulColor.ToUVector4(),
out mul_pack0, out mul_pack1);
baked_mulcolors.Add(mul_pack0);
baked_mulcolors.Add(mul_pack1);
uint add_pack0, add_pack1;
SwfEditorUtils.PackFColorToUInts(
inst.ColorTrans.addColor.ToUVector4(),
out add_pack0, out add_pack1);
baked_addcolors.Add(add_pack0);
baked_addcolors.Add(add_pack1);
if (baked_groups.Count == 0 ||
baked_groups[baked_groups.Count - 1].Type != inst.Type ||
baked_groups[baked_groups.Count - 1].BlendMode != inst.BlendMode.type ||
baked_groups[baked_groups.Count - 1].ClipDepth != inst.ClipDepth)
{
baked_groups.Add(new BakedGroup {
Type = inst.Type,
BlendMode = inst.BlendMode.type,
ClipDepth = inst.ClipDepth,
StartVertex = baked_vertices.Count - 4,
TriangleCount = 0,
Material = null
});
}
baked_groups.Last().TriangleCount += 6;
}
}
for (var i = 0; i < baked_groups.Count; ++i)
{
var group = baked_groups[i];
switch (group.Type)
{
case SwfInstanceData.Types.Mask:
group.Material = SwfMaterialCache.GetIncrMaskMaterial();
break;
case SwfInstanceData.Types.Group:
group.Material = SwfMaterialCache.GetSimpleMaterial(group.BlendMode);
break;
case SwfInstanceData.Types.Masked:
group.Material = SwfMaterialCache.GetMaskedMaterial(group.BlendMode, group.ClipDepth);
break;
case SwfInstanceData.Types.MaskReset:
group.Material = SwfMaterialCache.GetDecrMaskMaterial();
break;
default:
throw new UnityException(string.Format(
"SwfAssetPostprocessor. Incorrect instance type: {0}",
group.Type));
}
if (group.Material)
{
baked_materials.Add(group.Material);
}
else
{
throw new UnityException(string.Format(
"SwfAssetPostprocessor. Material for baked group ({0}) not found",
group.Type));
}
}
var mesh_data = new SwfClipAsset.MeshData {
SubMeshes = baked_groups
.Select(p => new SwfClipAsset.SubMeshData {
StartVertex = p.StartVertex,
IndexCount = p.TriangleCount
})
.ToArray(),
Vertices = baked_vertices.ToArray(),
UVs = baked_uvs.ToArray(),
AddColors = baked_addcolors.ToArray(),
MulColors = baked_mulcolors.ToArray()
};
return(new SwfClipAsset.Frame(
frame.Labels.ToArray(),
mesh_data,
baked_materials.ToArray()));
}
