swf manager wip

Assets/FlashTools/Examples/Scenes/Scene00.unity

@@ -145,7 +145,7 @@ Camera:
   far clip plane: 1000
   field of view: 60
   orthographic: 1
-  orthographic size: 4
+  orthographic size: 30
   m_Depth: 0
   m_CullingMask:
     serializedVersion: 2

Assets/FlashTools/Scripts/SwfBakedAnimation.cs

@@ -36,10 +36,6 @@ namespace FlashTools {
 		//
 		// ------------------------------------------------------------------------
 
-		static Material       SwfIncrMask;
-		static Material       SwfSimple;
-		static Material       SwfDecrMask;
-		static Shader         SwfMaskedShader;
 		MaterialPropertyBlock MatPropBlock;
 
 		class Frame {
@@ -73,8 +69,9 @@ namespace FlashTools {
 		}
 
 		public void BakeFrameMeshes() {
-			InitMaterials();
 			if ( Asset && Asset.Atlas && Asset.Data != null && Asset.Data.Frames.Count > 0 ) {
+				MatPropBlock = new MaterialPropertyBlock();
+				MatPropBlock.SetTexture("_MainTex", Asset.Atlas);
 				for ( var i = 0; i < Asset.Data.Frames.Count; ++i ) {
 					var frame = Asset.Data.Frames[i];
 					BakeFrameMesh(frame);
@@ -83,27 +80,8 @@ namespace FlashTools {
 			FixCurrentMesh();
 		}
 
-		void InitMaterials() {
-			if ( !SwfIncrMask ) {
-				Profiler.maxNumberOfSamplesPerFrame = -1;
-				SwfIncrMask = new Material(Shader.Find("FlashTools/SwfIncrMask"));
-			}
-			if ( !SwfSimple ) {
-				SwfSimple   = new Material(Shader.Find("FlashTools/SwfSimple"));
-			}
-			if ( !SwfDecrMask ) {
-				SwfDecrMask = new Material(Shader.Find("FlashTools/SwfDecrMask"));
-			}
-			if ( !SwfMaskedShader ) {
-				SwfMaskedShader = Shader.Find("FlashTools/SwfMasked");
-			}
-			if ( MatPropBlock == null ) {
-				MatPropBlock = new MaterialPropertyBlock();
-				MatPropBlock.SetTexture("_MainTex", Asset.Atlas);
-			}
-		}
-
 		void BakeFrameMesh(SwfAnimationFrameData frame) {
+			var swf_manager = SwfManager.Instance;
 			for ( var i = 0; i < frame.Instances.Count; ++i ) {
 				var inst   = frame.Instances[i];
 				var bitmap = inst != null ? FindBitmap(inst.Bitmap) : null;
@@ -168,17 +146,16 @@ namespace FlashTools {
 				var group = _groups[i];
 				switch ( group.Type ) {
 				case SwfAnimationInstanceType.Mask:
-					group.Material = SwfIncrMask;
+					group.Material = swf_manager.GetIncrMaskMaterial();
 					break;
 				case SwfAnimationInstanceType.Group:
-					group.Material = SwfSimple;
+					group.Material = swf_manager.GetSimpleMaterial();
 					break;
 				case SwfAnimationInstanceType.Masked:
-					group.Material = new Material(SwfMaskedShader);
-					group.Material.SetInt("_StencilID", group.ClipDepth);
+					group.Material = swf_manager.GetMaskedMaterial(group.ClipDepth);
 					break;
 				case SwfAnimationInstanceType.MaskReset:
-					group.Material = SwfDecrMask;
+					group.Material = swf_manager.GetDecrMaskMaterial();
 					break;
 				}
 			}
@@ -246,19 +223,39 @@ namespace FlashTools {
 			}
 		}
 
-		// ------------------------------------------------------------------------
+		// ---------------------------------------------------------------------
+		//
+		// Internal
+		//
+		// ---------------------------------------------------------------------
+
+		public void InternalUpdate() {
+			UpdateFrameTimer();
+		}
+
+		// ---------------------------------------------------------------------
 		//
 		// Messages
 		//
-		// ------------------------------------------------------------------------
+		// ---------------------------------------------------------------------
 
 		void Awake() {
 			_meshFilter   = GetComponent<MeshFilter>();
 			_meshRenderer = GetComponent<MeshRenderer>();
 		}
 
-		void Update() {
-			UpdateFrameTimer();
+		void OnEnable() {
+			var swf_manager = SwfManager.Instance;
+			if ( swf_manager ) {
+				swf_manager.AddSwfBakedAnimation(this);
+			}
+		}
+
+		void OnDisable() {
+			var swf_manager = SwfManager.Instance;
+			if ( swf_manager ) {
+				swf_manager.RemoveSwfBakedAnimation(this);
+			}
 		}
 	}
 }

Assets/FlashTools/Scripts/SwfManager.cs

@@ -0,0 +1,165 @@
+using UnityEngine;
+using System.Collections.Generic;
+using FlashTools.Internal;
+
+namespace FlashTools {
+	[ExecuteInEditMode]
+	public class SwfManager : MonoBehaviour {
+		// ---------------------------------------------------------------------
+		//
+		// Consts
+		//
+		// ---------------------------------------------------------------------
+
+		const int    SwfStencilIdCount     = 10;
+		const string SwfSimpleShaderPath   = "FlashTools/SwfSimple";
+		const string SwfMaskedShaderPath   = "FlashTools/SwfMasked";
+		const string SwfIncrMaskShaderPath = "FlashTools/SwfIncrMask";
+		const string SwfDecrMaskShaderPath = "FlashTools/SwfDecrMask";
+
+		// ---------------------------------------------------------------------
+		//
+		// Properties
+		//
+		// ---------------------------------------------------------------------
+
+		[SerializeField] [HideInInspector] Shader         _maskedShader     = null;
+		[SerializeField] [HideInInspector] List<Material> _maskedMaterials  = null;
+		[SerializeField] [HideInInspector] Material       _simpleMaterial   = null;
+		[SerializeField] [HideInInspector] Material       _incrMaskMaterial = null;
+		[SerializeField] [HideInInspector] Material       _decrMaskMaterial = null;
+
+		HashSet<SwfBakedAnimation> _bakedAnimations = new HashSet<SwfBakedAnimation>();
+
+		// ---------------------------------------------------------------------
+		//
+		// Instance
+		//
+		// ---------------------------------------------------------------------
+
+		static SwfManager _instance;
+		public static SwfManager Instance {
+			get {
+				if ( !_instance ) {
+					_instance = FindObjectOfType<SwfManager>();
+				}
+				return _instance;
+			}
+		}
+
+		// ---------------------------------------------------------------------
+		//
+		// Internal
+		//
+		// ---------------------------------------------------------------------
+
+		public void AddSwfBakedAnimation(SwfBakedAnimation animation) {
+			_bakedAnimations.Add(animation);
+		}
+
+		public void RemoveSwfBakedAnimation(SwfBakedAnimation animation) {
+			_bakedAnimations.Remove(animation);
+		}
+
+		// ---------------------------------------------------------------------
+		//
+		// Private
+		//
+		// ---------------------------------------------------------------------
+
+		void FillMaterialsCache() {
+			if ( !_maskedShader ) {
+				_maskedShader = SafeLoadShader(SwfMaskedShaderPath);
+			}
+			if ( _maskedMaterials == null ) {
+				_maskedMaterials = new List<Material>(SwfStencilIdCount);
+				for ( var i = 0; i < _maskedMaterials.Capacity; ++i ) {
+					var material = new Material(_maskedShader);
+					material.SetInt("_StencilID", i);
+					_maskedMaterials.Add(material);
+				}
+			}
+			if ( !_simpleMaterial ) {
+				_simpleMaterial   = new Material(SafeLoadShader(SwfSimpleShaderPath));
+			}
+			if ( !_incrMaskMaterial ) {
+				_incrMaskMaterial = new Material(SafeLoadShader(SwfIncrMaskShaderPath));
+			}
+			if ( !_decrMaskMaterial ) {
+				_decrMaskMaterial = new Material(SafeLoadShader(SwfDecrMaskShaderPath));
+			}
+		}
+
+		Shader SafeLoadShader(string path) {
+			var shader = Shader.Find(path);
+			if ( !shader ) {
+				throw new UnityException(string.Format(
+					"SwfManager. Shader not found: {0}",
+					path));
+			}
+			return shader;
+		}
+
+		// ---------------------------------------------------------------------
+		//
+		// Functions
+		//
+		// ---------------------------------------------------------------------
+
+		public Material GetMaskedMaterial(int stencil_id) {
+			if ( stencil_id < 0 || stencil_id >= SwfStencilIdCount ) {
+				throw new UnityException(string.Format(
+					"SwfManager. Unsupported stencil id: {0}",
+					stencil_id));
+			}
+			FillMaterialsCache();
+			return _maskedMaterials[stencil_id];
+		}
+
+		public Material GetSimpleMaterial() {
+			FillMaterialsCache();
+			return _simpleMaterial;
+		}
+
+		public Material GetIncrMaskMaterial() {
+			FillMaterialsCache();
+			return _incrMaskMaterial;
+		}
+
+		public Material GetDecrMaskMaterial() {
+			FillMaterialsCache();
+			return _decrMaskMaterial;
+		}
+
+		// ---------------------------------------------------------------------
+		//
+		// Messages
+		//
+		// ---------------------------------------------------------------------
+
+		void Awake() {
+			FillMaterialsCache();
+		}
+
+		void OnEnable() {
+			var all_baked_animations = FindObjectsOfType<SwfBakedAnimation>();
+			for ( int i = 0, e = all_baked_animations.Length; i < e; ++i ) {
+				var baked_animation = all_baked_animations[i];
+				if ( baked_animation.enabled ) {
+					_bakedAnimations.Add(baked_animation);
+				}
+			}
+		}
+
+		void OnDisable() {
+			_bakedAnimations.Clear();
+		}
+
+		void Update() {
+			var iter = _bakedAnimations.GetEnumerator();
+			while ( iter.MoveNext() ) {
+				iter.Current.InternalUpdate();
+			}
+		}
+	}
+}

Assets/FlashTools/Scripts/SwfManager.cs.meta

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