Beispiel #1
0
        void OnUpdated(AssetSource source)
        {
            TreeView.Nodes.Clear();
            var gltf = source.GLTF;

            if (gltf == null)
            {
                return;
            }

            m_nodes = gltf.nodes.Select((x, i) => new TreeNode(string.Format("[{0}]{1}", i, x.name))).ToArray();

            for (int i = 0; i < gltf.nodes.Count; ++i)
            {
                var parent = m_nodes[i];

                var node = gltf.nodes[i];
                if (node.children != null)
                {
                    foreach (var j in node.children)
                    {
                        parent.Nodes.Add(m_nodes[j]);
                    }
                }
            }

            TreeView.Nodes.Add(m_nodes[0]);
            TreeView.ExpandAll();
        }
Beispiel #2
0
        public void SetAssetSource(AssetSource source)
        {
            // clear
            m_nodeMap.Clear();
            TreeView.Nodes.Clear();
            _source = source;

            var gltf = source.GLTF;

            if (gltf == null)
            {
                return;
            }

            var select = default(TreeNode);

            foreach (var kv in source.JSON.ObjectItems())
            {
                var node = Traverse(TreeView.Nodes, kv.Key.GetString(), kv.Value);
                if (kv.Key.GetString() == "nodes")
                {
                    select = node;
                }
            }

            TreeView.SelectedNode = select;
        }
Beispiel #3
0
 /// <summary>
 /// 添加资源进入缓存池
 /// </summary>
 /// <param name="path"></param>
 /// <param name="obj"></param>
 /// <param name="src"></param>
 private static void Track(string path, Object obj, AssetSource src)
 {
     if (obj != null)
     {
         CoreAssets.Instance.Add(path, obj, src);
     }
 }
Beispiel #4
0
        /// <summary>
        /// 添加资源进入缓存池
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="asset">资源</param>
        /// <param name="source">资源类型</param>
        public void Add(string path, Object asset, AssetSource source)
        {
            var index = IndexOf(path);

            if (index == -1)
            {
                index = Loaded.Count;
                Loaded.Add(new Info()
                {
                    path = path, asset = asset, source = source, refCount = 0
                });
                //
                StringBuilder str = new StringBuilder();

                /*
                 *              for (int i=0;i< Loaded.Count;i++)
                 *              {
                 *                      str.Append(string.Format("[{0}]<color=#00ff00>{1}</color>", i, Loaded[i].path));
                 *              }*/
#if ENABLE_LOGGING
                EB.Debug.LogCoreAsset(string.Format("CoreAssets:<color=#00ff00>加入资源缓存池</color>path:<color=#00ff00>{0}</color>,资源对象:<color=#00ff00>{1}</color>,资源加载类型:<color=#00ff00>{2}</color>,资源缓存池个数:<color=#00ff00>{3}</color>,-----------{4}"
                                                    , path, asset, source, Loaded.Count, str));
#endif
            }
            else
            {
                //EB.Debug.LogWarning("Warning: loaded asset more than once for path " + path);
            }
            Loaded[index].refCount++;
        }
        private SavedInstance CreateSavedInstance(string assetId, AssetSource source)
        {
            var prefab = _assetResolver.Resolve(assetId, source);
            // We will temporarily set the resource to disabled. Because we don't want to enable any
            // of the components yet.
            bool prefabActiveState = prefab.gameObject.activeSelf;

            prefab.SetActive(false);

            GameObject instance = Object.Instantiate(prefab);

            SceneManager.MoveGameObjectToScene(instance, _scene);

            // After instantiating we reset the resource back to it's original state.
            prefab.SetActive(prefabActiveState);

            Saveable saveable = instance.GetComponent <Saveable>();

            if (saveable == null)
            {
                Debug.LogWarning("Save Instance Manager: No saveable added to spawned object." +
                                 $" Scanning for ({nameof(ISaveableComponent)})s during runtime is more costly.");

                saveable = instance.AddComponent <Saveable>();
                saveable.ScanAddSaveableComponents();
            }

            var guidProvider = instance.GetComponent <GuidComponent>() ?? instance.AddComponent <GuidComponent>();

            SavedInstance savedInstance = instance.AddComponent <SavedInstance>();

            savedInstance.Configure(saveable, this);

            return(savedInstance);
        }
Beispiel #6
0
 public LazyAsset(ICustomImporter importer, string name, string path = "", bool embedded = true)
 {
     Source         = (embedded ? AssetSource.EmbeddedCustom : AssetSource.ExternalCustom);
     CustomImporter = importer;
     Name           = name;
     Path           = path;
 }
Beispiel #7
0
    public IView CreateViewAndLink(IEntity entity, IContext context, string Name, AssetSource Source, IView parent = null)
    {
        var view = CreateView(Name, Source, parent);

        view.Link(entity, context);
        return(view);
    }
Beispiel #8
0
 private Task <IEnumerable <IProxyAsset> > BuildAsset(BuildContext context, AssetSource source)
 {
     return(_cache.FetchOrCreate(Identity, _memoryManager, source, async s => {
         var imported = await ImportAsset(context, source);
         return await Task.WhenAll(imported.Select(a => ProcessAsset(context, a)));
     }));
 }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			using ( var sourceStream = assetFile.OpenSourceStream() ) {
				using ( var targetStream = assetFile.OpenTargetStream() ) {
					sourceStream.CopyTo( targetStream );
				}
			}
		}
Beispiel #10
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="sourceStream"></param>
 /// <param name="targetStream"></param>
 public override void Process(AssetSource assetFile, BuildContext context)
 {
     using (var sourceStream = assetFile.OpenSourceStream()) {
         using (var targetStream = assetFile.OpenTargetStream()) {
             sourceStream.CopyTo(targetStream);
         }
     }
 }
    public void ReplaceShield(string newName, AssetSource newSource)
    {
        var index     = GameComponentsLookup.Shield;
        var component = CreateComponent <ShieldComponent>(index);

        component.Name   = newName;
        component.Source = newSource;
        ReplaceComponent(index, component);
    }
Beispiel #12
0
        public void SetAssetSource(AssetSource source)
        {
            if (source.GLTF == null)
            {
                return;
            }

            // indent
            richTextBox1.Text = source.JSON.ToString("  ");
        }
Beispiel #13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sourceStream"></param>
        /// <param name="targetStream"></param>
        public override void Process(AssetSource assetFile, BuildContext context)
        {
            var src = assetFile.FullSourcePath;
            var dst = context.GetTempFileFullPath(assetFile.KeyPath, ".dds");

            RunNVCompress(context, src, dst, NoMips, Fast, ToNormal, Color, Alpha, Normal, Compression);

            using (var target = assetFile.OpenTargetStream()) {
                context.CopyFileTo(dst, target);
            }
        }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var src	=	assetFile.FullSourcePath;
			var dst	=	context.GetTempFileName( assetFile.KeyPath, ".dds" );

			RunNVCompress( context, src, dst, NoMips, Fast, ToNormal, Color, Alpha, Normal, Compression );

			using ( var target = assetFile.OpenTargetStream() ) {
				context.CopyFileTo( dst, target );
			}
		}
Beispiel #15
0
        public GameObject Instantiate(string assetId, AssetSource source = AssetSource.Resources, Scene scene = default)
        {
            if (scene == default)
            {
                scene = SceneManager.GetActiveScene();
            }
            if (!_sceneRuntimeInstancesManagers.TryGetValue(scene.GetHashCode(), out var instancesManager))
            {
                throw new ArgumentException($"Trying to create object in scene that does not exist yet. Scene: '{scene.path}'", nameof(scene));
            }

            return(instancesManager.Instantiate(assetId, source));
        }
Beispiel #16
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			string tempFileName		= context.GetTempFileName( assetFile.KeyPath, ".fnt" );
			string resolvedPath		= assetFile.FullSourcePath;	

			//	Launch 'bmfont.com' with temporary output file :
			context.RunTool( @"bmfont.com",  string.Format("-c \"{0}\" -o \"{1}\"", resolvedPath, tempFileName ) );


			//	load temporary output :
			SpriteFont.FontFile font;
			using ( var stream = File.OpenRead( tempFileName ) ) {
				font = SpriteFont.FontLoader.Load( stream );
			}


			//	perform some checks :
			if (font.Common.Pages!=1) {
				throw new BuildException("Only one page of font image is supported");
			}


			//	patch font description and add children (e.g. "secondary") content :
			using ( var stream = assetFile.OpenTargetStream() ) {

				using ( var sw = new BinaryWriter( stream ) ) {

					var xml = SpriteFont.FontLoader.SaveToString( font );

					sw.Write( xml );

					//	write pages :
					foreach (var p in font.Pages) {

						var pageFile	=	Path.Combine( Path.GetDirectoryName( tempFileName ), p.File );

						if ( Path.GetExtension( pageFile ).ToLower() == ".dds" ) {

							context.CopyFileTo( pageFile, sw );

						} else {

							TextureProcessor.RunNVCompress( context, pageFile, pageFile + ".dds", true, false, false, true, true, false, TextureProcessor.TextureCompression.RGB );

							context.CopyFileTo( pageFile + ".dds", sw );

						}
					}
				}
			}
		}
Beispiel #17
0
        public static async Task <IEnumerable <IProxyAsset> > FetchOrCreate(
            this IBuildCache cache,
            string pipeline, AssetMemoryManager mem, AssetSource source,
            Func <AssetSource, Task <IEnumerable <IProxyAsset> > > build)
        {
            var cacheKey = BuildCache.ComputeCacheKey(pipeline, source);

            while (true)
            {
                var cached = await cache.Fetch(cacheKey);

                if (cached.Type == CacheResult.Cached)
                {
                    var cachedAssets = await Task.WhenAll(cached.Assets.Select(mem.DeserializeProxy));

                    if (cachedAssets.All(a => a != null))
                    {
                        return(cachedAssets);
                    }
                }

                if (cached.Type == CacheResult.IncompleteKey)
                {
                    cacheKey = BuildCache.ComputeCacheKey(pipeline, source, cached.MissingInputs);
                }
                else
                {
                    break;
                }
            }

            var assets = (await build(source)).ToList();

            var extraFiles        = new string[0]; //TODO: record extra input files
            var serializedProxies = assets.Select(mem.SerializeProxy).ToList();

            if (extraFiles.Length == 0)
            {
                await cache.Store(cacheKey, CacheRecord.Found(serializedProxies));
            }
            else
            {
                await cache.Store(cacheKey, CacheRecord.Incomplete(extraFiles));

                await cache.Store(BuildCache.ComputeCacheKey(pipeline, source, extraFiles),
                                  CacheRecord.Found(serializedProxies));
            }

            return(assets);
        }
        private static AssetSource GetAssetSource(int random = 1)
        {
            var assetSource = new AssetSource
            {
                Key         = $"AssetSource-Key-{random}",
                ContentType = "image/gif",
                Uri         = $"http://www.commercetools.com/assets/img/logo_{random}.gif",
                Dimensions  = new AssetDimensions {
                    H = 100, W = 100
                }
            };

            return(assetSource);
        }
Beispiel #19
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sourceStream"></param>
        /// <param name="targetStream"></param>
        public override void Process(AssetSource assetFile, BuildContext context)
        {
            string tempFileName = context.GetTempFileFullPath(assetFile.KeyPath, ".fnt");
            string resolvedPath = assetFile.FullSourcePath;

            //	Launch 'bmfont.com' with temporary output file :
            context.RunTool(@"bmfont.com", string.Format("-c \"{0}\" -o \"{1}\"", resolvedPath, tempFileName));


            //	load temporary output :
            SpriteFont.FontFile font;
            using (var stream = File.OpenRead(tempFileName)) {
                font = SpriteFont.FontLoader.Load(stream);
            }


            //	perform some checks :
            if (font.Common.Pages != 1)
            {
                throw new BuildException("Only one page of font image is supported");
            }


            //	patch font description and add children (e.g. "secondary") content :
            using (var stream = assetFile.OpenTargetStream()) {
                using (var sw = new BinaryWriter(stream)) {
                    var xml = SpriteFont.FontLoader.SaveToString(font);

                    sw.Write(xml);

                    //	write pages :
                    foreach (var p in font.Pages)
                    {
                        var pageFile = Path.Combine(Path.GetDirectoryName(tempFileName), p.File);

                        if (Path.GetExtension(pageFile).ToLower() == ".dds")
                        {
                            context.CopyFileTo(pageFile, sw);
                        }
                        else
                        {
                            TextureProcessor.RunNVCompress(context, pageFile, pageFile + ".dds", true, false, false, true, true, false, TextureProcessor.TextureCompression.RGB);

                            context.CopyFileTo(pageFile + ".dds", sw);
                        }
                    }
                }
            }
        }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var mtrl	=	BaseIllum.ImportFromXml ( File.ReadAllText(assetFile.FullSourcePath) );

			//	get dependencies :
			var deps	=	mtrl.GetDependencies().ToArray();

			var file	=	BaseIllum.ExportToXml(mtrl);

			using ( var target = assetFile.OpenTargetStream(deps) ) {
				using ( var bw = new BinaryWriter(target) ) {
					bw.Write(file);
				}
			}
		}
Beispiel #21
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sourceStream"></param>
        /// <param name="targetStream"></param>
        public override void Process(AssetSource assetFile, BuildContext context)
        {
            var mtrl = BaseIllum.ImportFromXml(File.ReadAllText(assetFile.FullSourcePath));

            //	get dependencies :
            var deps = mtrl.GetDependencies().ToArray();

            var file = BaseIllum.ExportToXml(mtrl);

            using (var target = assetFile.OpenTargetStream(deps)) {
                using (var bw = new BinaryWriter(target)) {
                    bw.Write(file);
                }
            }
        }
Beispiel #22
0
    public IView CreateView(string Name, AssetSource Source, IView parent = null)
    {
        if (Source == AssetSource.Resources)
        {
            if (!_prefabs.ContainsKey(Name))
            {
                _prefabs.Add(Name, Resources.Load <GameObject>(Name));
            }
        }

        var go = parent == null?Instantiate(_prefabs[Name]) : Instantiate(_prefabs[Name], parent.GetGameObject().transform);

        var view = go.GetComponent <IView>();

        return(view);
    }
Beispiel #23
0
        protected override void OnUpdated(AssetSource source)
        {
            m_items.Clear();
            var gltf = source.GLTF;

            if (gltf == null)
            {
                return;
            }

            foreach (var x in gltf.bufferViews)
            {
                m_items.Add(new Item(x));
            }
            AutoResizeColumns();
        }
Beispiel #24
0
            async Task Load(string path)
            {
                if (string.IsNullOrEmpty(path))
                {
                    return;
                }

                Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} open: {path}");
                var source = await Task.Run(() => AssetSource.Load(path));

                Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} loaded: {source}");
                var asset = await Task.Run(() => AssetContext.Load(source));

                Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} build: {source}");
                m_app.SetAsset(asset);
            }
Beispiel #25
0
        public static string ComputeCacheKey(string pipeline, AssetSource asset, params string[] inputFiles)
        {
            var key = new StringBuilder();

            key.AppendLine(pipeline);
            key.AppendLine(asset.Path);
            key.AppendLine(HashFile(asset.Path));
            key.AppendLine(JsonConvert.SerializeObject(asset.Configuration));

            foreach (var file in inputFiles)
            {
                key.AppendLine(HashFile(file));
            }

            return(key.ToString().ToShaString());
        }
Beispiel #26
0
        protected override void OnUpdated(AssetSource source)
        {
            m_items.Clear();
            var gltf = source.GLTF;

            if (gltf == null)
            {
                return;
            }

            foreach (var x in gltf.meshes)
            {
                for (int i = 0; i < x.primitives.Count; ++i)
                {
                    m_items.Add(new Item($"{x.name}[{i}]", x.primitives[i]));
                }
            }
            AutoResizeColumns();
        }
Beispiel #27
0
        /// <summary>
        /// Converts the string representation of an asset identifier to an instance of the <see cref="SourcedAssetID"/> structure.
        /// </summary>
        /// <param name="manifests">The content manifest registry that contains the currently-loaded content manifests.</param>
        /// <param name="s">A string containing the asset identifier to convert.</param>
        /// <param name="value">An instance of the <see cref="SourcedAssetID"/> structure that is equivalent to the specified string.</param>
        /// <returns><see langword="true"/> if the string was successfully parsed; otherwise, <see langword="false"/>.</returns>
        private static Boolean TryParseInternal(ContentManifestRegistry manifests, String s, out SourcedAssetID value)
        {
            var parts = s.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            if (parts.Length > 2)
            {
                throw new FormatException();
            }

            // Parse the asset identifier
            var assetID       = default(AssetID);
            var assetIDParsed = false;

            if (manifests == null)
            {
                assetIDParsed = AssetID.TryParse(parts[0], out assetID);
            }
            else
            {
                assetIDParsed = AssetID.TryParse(manifests, parts[0], out assetID);
            }

            if (!assetIDParsed)
            {
                value = default(SourcedAssetID);
                return(false);
            }

            // Parse the asset source
            AssetSource assetSource = AssetSource.Global;

            if (parts.Length == 2)
            {
                if (!Enum.TryParse(parts[1], true, out assetSource))
                {
                    value = default(SourcedAssetID);
                    return(false);
                }
            }

            value = new SourcedAssetID(assetID, assetSource);
            return(true);
        }
        public GameObject Instantiate(string assetId, AssetSource source = AssetSource.Resources)
        {
            _changesMade++;
            var savedInstance = CreateSavedInstance(assetId, source);

            // we need to enable instance first so that GuidComponent will generate new Guid
            savedInstance.gameObject.SetActive(true);

            var guidProvider = savedInstance.GetComponent <GuidComponent>();

            guidProvider.RegenerateGuid();

            _spawnInfo.Add(savedInstance, new SpawnInfo()
            {
                _assetId = assetId,
                _guid    = guidProvider.GetStringGuid(),
                _source  = source
            });

            return(savedInstance.gameObject);
        }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var resolvedPath	=	assetFile.FullSourcePath;
			var destPath		=	context.GetTempFileName( assetFile.KeyPath, ".scene" );

			var cmdLine			=	string.Format("\"{0}\" /out:\"{1}\" /base:\"{2}\" /merge:{3} {4} {5} {6} {7}", 
				resolvedPath, 
				destPath, 
				assetFile.BaseDirectory,
				MergeTolerance, 
				ImportAnimation ? "/anim":"", 
				ImportGeometry ? "/geom":"", 
				OutputReport ? "/report":"" ,
				GenerateMissingMaterials ? "/genmtrl":""
			);

			context.RunTool( "FScene.exe", cmdLine );

			using ( var target = assetFile.OpenTargetStream() ) {
				context.CopyFileTo( destPath, target );
			}
		}
        public GameObject Resolve(string assetId, AssetSource source)
        {
            switch (source)
            {
            case AssetSource.Resources:
                var res = Resources.Load(assetId) as GameObject;
                if (res == null)
                {
                    throw new Exception($"Can't resolve asset with id: '{assetId}' from Resources");
                }
                return(res);

            case AssetSource.Registered:
                if (!_assetIdToAssetMap.TryGetValue(assetId, out var asset))
                {
                    throw new ArgumentOutOfRangeException(nameof(assetId), $"Can't resolve asset from registered assets.");
                }
                return(asset);

            default:
                throw new NotImplementedException($"Instance source '{source.ToString()}' is not implemented.");
            }
        }
        private SavedInstance InstantiateInternal(string assetId, Guid guid, AssetSource source)
        {
            if (string.IsNullOrEmpty(assetId))
            {
                throw new ArgumentNullException(nameof(assetId));
            }
            if (guid == Guid.Empty)
            {
                throw new ArgumentNullException(nameof(guid));
            }

            var savedInstance = CreateSavedInstance(assetId, source);

            var guidProvider = savedInstance.GetComponent <GuidComponent>();

            guidProvider.SetGuid(guid);

            _loadedIDs.Add(savedInstance.GetComponent <Saveable>().Id);

            savedInstance.gameObject.SetActive(true);

            return(savedInstance);
        }
Beispiel #32
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sourceStream"></param>
        /// <param name="targetStream"></param>
        public override void Process(AssetSource assetFile, BuildContext context)
        {
            var resolvedPath = assetFile.FullSourcePath;
            var destPath     = context.GetTempFileFullPath(assetFile.KeyPath, ".scene");
            var reportPath   = context.GetTempFileFullPath(assetFile.KeyPath, ".html");

            var cmdLine = string.Format("\"{0}\" /out:\"{1}\" /base:\"{2}\" /merge:{3} {4} {5} {6} {7}",
                                        resolvedPath,
                                        destPath,
                                        assetFile.BaseDirectory,
                                        MergeTolerance,
                                        ImportAnimation ? "/anim":"",
                                        ImportGeometry ? "/geom":"",
                                        OutputReport ? "/report:" + "\"" + reportPath + "\"":"",
                                        GenerateMissingMaterials ? "/genmtrl":""
                                        );

            context.RunTool("FScene.exe", cmdLine);

            using (var target = assetFile.OpenTargetStream()) {
                context.CopyFileTo(destPath, target);
            }
        }
        public static T LoadOfficialAsset <T>(string assetPath, AssetSource assetType) where T : UnityEngine.Object
        {
            switch (assetType)
            {
            case AssetSource.BraveResources:
                return(ResourceManager.LoadAssetBundle("brave_resources_001").LoadAsset <T>(assetPath));

            case AssetSource.SharedAuto1:
                return(ResourceManager.LoadAssetBundle("shared_auto_001").LoadAsset <T>(assetPath));

            case AssetSource.SharedAuto2:
                return(ResourceManager.LoadAssetBundle("shared_auto_002").LoadAsset <T>(assetPath));

            case AssetSource.EnemiesBase:
                return(ResourceManager.LoadAssetBundle("enemies_base_001").LoadAsset <T>(assetPath));

            case AssetSource.FlowBase:
                return(ResourceManager.LoadAssetBundle("flows_base_001").LoadAsset <T>(assetPath));

            default:
                return(ResourceManager.LoadAssetBundle("brave_resources_001").LoadAsset <T>(assetPath));
            }
        }
Beispiel #34
0
        private Task <IEnumerable <IAsset> > ImportAsset(BuildContext context, AssetSource source)
        {
            var importer = _importers.FirstOrDefault(i => i.Filter.IsMatch(source.Path));

            return(importer != null?importer.Import(context, source) : Task.FromResult(Enumerable.Empty <IAsset>()));
        }
Beispiel #35
0
 public SourcedCursor(SourcedCursorResource resource, AssetSource source)
 {
     this.resource = resource;
     this.source   = source;
 }
		/// <summary>
		/// 
		/// </summary>
		/// <param name="buildContext"></param>
		public override void Process ( AssetSource assetFile, BuildContext buildContext )
		{
			//
			//	Get combinations :
			//
			string shaderSource	=	File.ReadAllText( assetFile.FullSourcePath );

			var ubershaderDecl	=	shaderSource.Split( new[]{Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries )
									.Select( line0 => line0.Trim() )
									.Where( line1 => line1.StartsWith("$ubershader") )
									.ToList();

			var defineList = new List<string>();

			foreach ( var comb in ubershaderDecl ) {
				var ue = new UbershaderEnumerator( comb, "$ubershader" );
				defineList.AddRange( ue.DefineList );
			}

			

			//
			//	Start listing builder :
			//	
			ListingPath	=	buildContext.GetTempFileName( assetFile.KeyPath, ".html" );
			var htmlBuilder = new StringBuilder();

			htmlBuilder.AppendFormat("<pre>");
			htmlBuilder.AppendLine("<b>Ubershader assembly listing</b>");
			htmlBuilder.AppendLine("");
			htmlBuilder.AppendLine("<b>Source:</b> <i>" + assetFile.KeyPath + "</i>" );
			htmlBuilder.AppendLine("");

			//	insert includes here bit later:
			var includeInsert = htmlBuilder.Length;

			htmlBuilder.AppendLine("<b>Declarations:</b>");

			foreach ( var comb in ubershaderDecl ) {
				htmlBuilder.AppendLine("  <i>" + comb + "</i>");
			}
			htmlBuilder.AppendLine("");

			

			var usdb = new List<UsdbEntry>();

			var include = new IncludeHandler(buildContext);


			//
			//	Build all :
			//
			foreach ( var defines in defineList ) {

				var id		=	defineList.IndexOf( defines );

				var psbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".PS.dxbc" );
				var vsbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".VS.dxbc" );
				var gsbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".GS.dxbc" );
				var hsbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".HS.dxbc" );
				var dsbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".DS.dxbc" );
				var csbc	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".CS.dxbc" );
															  
				var pshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".PS.html" );
				var vshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".VS.html" );
				var gshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".GS.html" );
				var hshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".HS.html" );
				var dshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".DS.html" );
				var cshtm	=	buildContext.GetTempFileName( assetFile.KeyPath, "." + id.ToString("D8") + ".CS.html" );

				var ps = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "ps_5_0", PSEntryPoint, defines, psbc, pshtm );
				var vs = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "vs_5_0", VSEntryPoint, defines, vsbc, vshtm );
				var gs = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "gs_5_0", GSEntryPoint, defines, gsbc, gshtm );
				var hs = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "hs_5_0", HSEntryPoint, defines, hsbc, hshtm );
				var ds = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "ds_5_0", DSEntryPoint, defines, dsbc, dshtm );
				var cs = Compile( buildContext, include, shaderSource, assetFile.FullSourcePath, "cs_5_0", CSEntryPoint, defines, csbc, cshtm );
				

				htmlBuilder.AppendFormat( (vs.Length==0) ? ".. " : "<a href=\"{0}\">vs</a> ",	Path.GetFileName(vshtm) );
				htmlBuilder.AppendFormat( (ps.Length==0) ? ".. " : "<a href=\"{0}\">ps</a> ",	Path.GetFileName(pshtm) );
				htmlBuilder.AppendFormat( (hs.Length==0) ? ".. " : "<a href=\"{0}\">hs</a> ",	Path.GetFileName(hshtm) );
				htmlBuilder.AppendFormat( (ds.Length==0) ? ".. " : "<a href=\"{0}\">ds</a> ",	Path.GetFileName(dshtm) );
				htmlBuilder.AppendFormat( (gs.Length==0) ? ".. " : "<a href=\"{0}\">gs</a> ",	Path.GetFileName(gshtm) );
				htmlBuilder.AppendFormat( (cs.Length==0) ? ".. " : "<a href=\"{0}\">cs</a> ",	Path.GetFileName(cshtm) );

				htmlBuilder.Append( "[" + defines + "]<br>" );

				usdb.Add( new UsdbEntry( defines, ps, vs, gs, hs, ds, cs ) );
			}


			htmlBuilder.Insert( includeInsert, 
				"<b>Includes:</b>\r\n" 
				+ string.Join("", include.Includes.Select(s=>"  <i>" + s + "</i>\r\n") )
				+ "\r\n");


			File.WriteAllText( buildContext.GetTempFileName(assetFile.KeyPath, ".html"), htmlBuilder.ToString() );


			//
			//	Write ubershader :
			//
			using ( var fs = assetFile.OpenTargetStream(include.Includes) ) {

				using ( var bw = new BinaryWriter( fs ) ) {

					bw.WriteFourCC( Ubershader.UbershaderSignature );

					//	params :

					//	bytecodes :
					bw.Write( usdb.Count );

					foreach ( var entry in usdb ) {

						bw.Write( entry.Defines );

						bw.WriteFourCC( Ubershader.PSBytecodeSignature );
						bw.Write( entry.PSBytecode.Length );
						bw.Write( entry.PSBytecode );

						bw.WriteFourCC( Ubershader.VSBytecodeSignature );
						bw.Write( entry.VSBytecode.Length );
						bw.Write( entry.VSBytecode );

						bw.WriteFourCC( Ubershader.GSBytecodeSignature );
						bw.Write( entry.GSBytecode.Length );
						bw.Write( entry.GSBytecode );

						bw.WriteFourCC( Ubershader.HSBytecodeSignature );
						bw.Write( entry.HSBytecode.Length );
						bw.Write( entry.HSBytecode );

						bw.WriteFourCC( Ubershader.DSBytecodeSignature );
						bw.Write( entry.DSBytecode.Length );
						bw.Write( entry.DSBytecode );

						bw.WriteFourCC( Ubershader.CSBytecodeSignature );
						bw.Write( entry.CSBytecode.Length );
						bw.Write( entry.CSBytecode );
					}
				}
			}
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public abstract void Process ( AssetSource assetFile, BuildContext context );
		/// <summary>
		/// 
		/// </summary>
		/// <param name="buildContext"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var fileDir		=	Path.GetDirectoryName( assetFile.FullSourcePath );

			var fileNames	=	File.ReadAllLines(assetFile.FullSourcePath)
								.Select( f1 => f1.Trim() )
								.Where( f2 => !f2.StartsWith("#") && !string.IsNullOrWhiteSpace(f2) )
								.Select( f3 => Path.Combine( fileDir, f3 ) )
								.ToArray();


			var depNames	=	File.ReadAllLines(assetFile.FullSourcePath)
								.Select( f1 => f1.Trim() )
								.Where( f2 => !f2.StartsWith("#") && !string.IsNullOrWhiteSpace(f2) )
								.Select( f3 => Path.Combine( Path.GetDirectoryName(assetFile.KeyPath), f3 ) )
								.ToArray();

			var images		=	fileNames
								.Select( fn => LoadImage( fn ) )
								.OrderByDescending( img0 => img0.Width * img0.Height )
								.ThenByDescending( img1 => img1.Width )
								.ThenByDescending( img2 => img2.Height )
								.ToList();

			if (!images.Any()) {
				throw new InvalidOperationException("At least one subimage must be added to the texture atlas");
			}


			//
			//	Pack atlas :
			//			
			AtlasNode root = new AtlasNode(0,0, Width, Height, Padding );

			foreach ( var img in images ) {
				var n = root.Insert( img );
				if (n==null) {
					throw new InvalidOperationException("No enough room to place image");
				}
			}

			//
			//	Create image and fill it with atlas elements :
			//	
			var targetImage	=	new Image( Width, Height );
			targetImage.Fill( FillColor );

			root.WriteImages( targetImage );

			//
			//	Save and compress :
			//
			var tgaOutput	=	context.GetTempFileName( assetFile.KeyPath, ".tga" );
			var ddsOutput	=	context.GetTempFileName( assetFile.KeyPath, ".dds" );
			Image.SaveTga( targetImage, tgaOutput );

			var compression =	UseDXT ? TextureProcessor.TextureCompression.BC3 : TextureProcessor.TextureCompression.RGB;
			TextureProcessor.RunNVCompress( context, tgaOutput, ddsOutput, NoMips, false, false, true, true, false, compression );


			//
			//	Write binary blob (text + dds texture):
			//
			using ( var fs = assetFile.OpenTargetStream(depNames) ) {
				var bw = new BinaryWriter( fs );

				bw.Write(new[]{'A','T','L','S'});
				bw.Write( images.Count ); 

				root.WriteLayout( bw );

				bw.Write( (int)(new FileInfo(ddsOutput).Length) );
				
				using ( var dds = File.OpenRead( ddsOutput ) ) {
					dds.CopyTo( fs );
				}
			}
		}