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(); }
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; }
/// <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); } }
/// <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); }
public LazyAsset(ICustomImporter importer, string name, string path = "", bool embedded = true) { Source = (embedded ? AssetSource.EmbeddedCustom : AssetSource.ExternalCustom); CustomImporter = importer; Name = name; Path = path; }
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); }
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 ); } } }
/// <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); }
public void SetAssetSource(AssetSource source) { if (source.GLTF == null) { return; } // indent richTextBox1.Text = source.JSON.ToString(" "); }
/// <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 ); } }
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)); }
/// <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 ); } } } } }
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); }
/// <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); } } }
/// <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); } } }
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); }
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(); }
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); }
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()); }
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(); }
/// <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); }
/// <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)); } }
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>())); }
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 ); } } }