protected override void Initialize(ContentCompiler compiler) { worldObjectWriter = compiler.GetTypeWriter(typeof(WorldObject)) as WorldObjectWriter; base.Initialize(compiler); }
protected override void Initialize(ContentCompiler compiler) { fightingCharacterWriter = compiler.GetTypeWriter(typeof(FightingCharacter)) as FightingCharacterWriter; base.Initialize(compiler); }
private static void DeserializeCompileAndLoad <T>(string file, Action <T> doAsserts) { var result = Deserialize(file, doAsserts); var xnbStream = new MemoryStream(); #if XNA // In MS XNA the ContentCompiler is completely internal, so we need // to use just a little reflection to get access to what we need. const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public; var ctor = typeof(ContentCompiler).GetConstructors(flags)[0]; var compiler = (ContentCompiler)ctor.Invoke(null); var compileMethod = typeof(ContentCompiler).GetMethod("Compile", flags); compileMethod.Invoke(compiler, new object[] { xnbStream, result, TargetPlatform.Windows, GraphicsProfile.Reach, false, Directory.GetCurrentDirectory(), "referenceRelocationPath" }); #else var compiler = new ContentCompiler(); compiler.Compile(xnbStream, result, TargetPlatform.Windows, GraphicsProfile.Reach, false, "rootDirectory", "referenceRelocationPath"); #endif var content = new TestContentManager(xnbStream); var loaded = content.Load <T>("Whatever"); doAsserts(loaded); }
protected override void Initialize(ContentCompiler compiler) { mapEntryWriter = compiler.GetTypeWriter(typeof(MapEntry <T>)) as MapEntryWriter <T>; base.Initialize(compiler); }
protected override void Initialize(ContentCompiler compiler) { equipmentWriter = compiler.GetTypeWriter(typeof(Equipment)) as EquipmentWriter; base.Initialize(compiler); }
private void WriteXnb(object content, PipelineBuildEvent pipelineEvent) { // Make sure the output directory exists. var outputFileDir = Path.GetDirectoryName(pipelineEvent.DestFile); Directory.CreateDirectory(outputFileDir); if (_compiler == null) { _compiler = new ContentCompiler(); } var type = content.GetType(); var attrib = type.GetCustomAttribute <CompressedContentAttribute>(true); bool compress = attrib == null && CompressContent; // Write the XNB. using (var fs = new FileStream( pipelineEvent.DestFile, FileMode.Create, FileAccess.Write, FileShare.None)) _compiler.Compile(fs, content, Platform, Profile, compress, OutputDirectory, outputFileDir); // Store the last write time of the output XNB here // so we can verify it hasn't been tampered with. pipelineEvent.DestTime = File.GetLastWriteTime(pipelineEvent.DestFile); }
/// <summary> /// <para> /// Enable SassAndCoffee support in the application. /// </para> /// <para> /// SassAndCoffee supports on the fly compilation and caching of CoffeeScript and Sass, /// along with concatenation and minification. /// </para> /// </summary> /// <param name="pipelines">Application pipelines to hook into</param> /// <param name="cache">Cache provider to use</param> /// <param name="rootPathProvider">Root path provider</param> public static void Enable(IPipelines pipelines, ICompiledCache cache, IRootPathProvider rootPathProvider) { var host = new NancyCompilerHost(rootPathProvider); var compiler = new ContentCompiler(host, cache); pipelines.BeforeRequest.AddItemToStartOfPipeline(GetPipelineHook(compiler)); }
/// <summary> /// <para> /// Enable SassAndCoffee support in the application. /// </para> /// <para> /// SassAndCoffee supports on the fly compilation and caching of CoffeeScript and Sass, /// along with concatenation and minification. /// </para> /// </summary> /// <param name="pipelines">Application pipelines to hook into</param> /// <param name="cache">Cache provider to use</param> /// <param name="rootPathProvider">Root path provider</param> public static void Enable(IApplicationPipelines pipelines, ICompiledCache cache, IRootPathProvider rootPathProvider) { var host = new NancyCompilerHost(rootPathProvider); var compiler = new ContentCompiler(host, cache); pipelines.BeforeRequest.AddItemToStartOfPipeline(GetPipelineHook(compiler)); }
private static Func <NancyContext, Response> GetPipelineHook(ContentCompiler compiler) { return(ctx => { if (ctx.Request == null) { return null; } if (!compiler.CanCompile(ctx.Request.Url.Path)) { return null; } var content = compiler.GetCompiledContent(ctx.Request.Url.Path); return content.Compiled ? GetResponse(content) : null; }); }
public override bool Execute() { Log.LogMessage("Building content:"); XBuildLogger logger = new XBuildLogger(this.Log); ContentCompiler compiler = new ContentCompiler(PipelineAssemblies); foreach (ITaskItem sourceItem in SourceAssets) { //foreach (string name in sourceItem.MetadataNames) // Log.LogMessage(name + " : " + sourceItem.GetMetadata(name)); string assetName = sourceItem.GetMetadata("Name"); Log.LogMessage("Building " + assetName); Stream outputStream = new FileStream(OutputDirectory + assetName + ".xnb", FileMode.OpenOrCreate); ContentWriter contentWriter = new ContentWriter(outputStream, getTargetPlatform(), CompressContent); string importerName = sourceItem.GetMetadata("Importer"); string processorName = sourceItem.GetMetadata("Processor"); IContentImporter importer = getImporterInstance(importerName); if (importer == null) { Log.LogError("Could not find the importer (" + importerName + ")"); } IContentProcessor processor = getProcessorInstance(processorName); if (importer == null) { Log.LogError("Could not find the processor (" + processorName + ")"); } Log.LogMessage("Using " + importerName + " and " + processorName); ContentImporterContext importerContext = new ContentImporterContext(this, IntermediateDirectory, OutputDirectory, logger); ContentProcessorContext processorContext = new ContentProcessorContext(); processor.Process(importer.Import(sourceItem.GetMetadata("Include"), importerContext), processorContext); } return(true); }
private static Func<NancyContext, Response> GetPipelineHook(ContentCompiler compiler) { return ctx => { if (ctx.Request == null) { return null; } if (!compiler.CanCompile(ctx.Request.Url.Path)) { return null; } var content = compiler.GetCompiledContent(ctx.Request.Url.Path); return content.Compiled ? GetResponse(content) : null; }; }
private void WriteXnb(object content, PipelineBuildEvent pipelineEvent) { // Make sure the output directory exists. var outputFileDir = Path.GetDirectoryName(pipelineEvent.DestFile); Directory.CreateDirectory(outputFileDir); if (_compiler == null) { _compiler = new ContentCompiler(); } // Write the XNB. using (var stream = new FileStream(pipelineEvent.DestFile, FileMode.Create, FileAccess.Write, FileShare.None)) _compiler.Compile(stream, content, Platform, Profile, false, OutputDirectory, outputFileDir); // Store the last write time of the output XNB here // so we can verify it hasn't been tampered with. pipelineEvent.DestTime = File.GetLastWriteTime(pipelineEvent.DestFile); }
public Generator() { _graphics = new GraphicsDeviceManager(this); _englishChars = new List <char> { '©' }; for (var c = '!'; c < '~'; c++) { _englishChars.Add(c); } _characters = File.ReadAllText("chars.txt") .Except(_englishChars) .ToArray(); _compiler = new ContentCompiler(); _processor = new DynamicFontDescriptionProcessor(); _context = new DfgContext(this); Content.RootDirectory = "Content"; }
public static void BuildGame(params string[] args) { BuildTarget[] targets = args.Skip(1).Select(x => (BuildTarget)Enum.Parse(typeof(BuildTarget), x)).ToArray(); ContentCompiler.CompileAll(); string buildDir = args[0]; DateTime lastMinorRelease = new DateTime(2021, 7, 8); string patch = (DateTime.Now - lastMinorRelease).Days.ToString(); string build = (DateTime.Now.Second + DateTime.Now.Minute * 60 + DateTime.Now.Hour * 3600).ToString(); PlayerSettings.bundleVersion = $"0.2.{patch}.{build}"; if (Directory.Exists(buildDir)) { Directory.Delete(buildDir, true); } Directory.CreateDirectory(buildDir); foreach (var target in targets) { string dir = Path.Combine(buildDir, target.ToString()); Directory.CreateDirectory(dir); BuildPlayerOptions options = new BuildPlayerOptions() { targetGroup = BuildTargetGroup.Standalone, target = target, scenes = buildScenes, options = BuildOptions.None, locationPathName = Path.Combine(dir, $"{buildPrefix}-{buildSuffixes[target]}{buildExtensions[target]}") }; BuildPipeline.BuildPlayer(options); File.WriteAllText(Path.Combine(dir, "version.txt"), PlayerSettings.bundleVersion); File.WriteAllText(Path.Combine(dir, "channel.txt"), buildChannels[target]); } }
public static void CompileAndLoadAssets <T>(T data, Action <T> validation) { ContentCompiler compiler = new ContentCompiler(); foreach (var platform in Platforms) { foreach (var gfxProfile in GraphicsProfiles) { foreach (var compress in CompressContents) { using (var xnbStream = new MemoryStream()) { compiler.Compile(xnbStream, data, platform, gfxProfile, compress, "", ""); using (var content = new TestContentManager(xnbStream)) { var result = content.Load <T>("foo"); validation(result); } } } } } }
/// <summary> /// Compile the specified input object and return the XNB file as a byte array. /// </summary> /// <param name="content"> /// The content to compile. /// </param> /// <returns> /// The compiled XNB file as a byte array. /// </returns> protected byte[] CompileAndGetBytes(object content) { var temp = Path.GetTempFileName(); var compiler = new ContentCompiler(); try { using (var stream = new FileStream(temp, FileMode.Open, FileAccess.Write)) { compiler.Compile( stream, content, MonoGamePlatform.Windows, GraphicsProfile.Reach, false, Environment.CurrentDirectory, Environment.CurrentDirectory); } byte[] result; using (var stream = new FileStream(temp, FileMode.Open, FileAccess.Read)) { stream.Position = 0; using (var reader = new BinaryReader(stream)) { result = reader.ReadBytes((int)stream.Length); } } File.Delete(temp); return(result); } finally { File.Delete(temp); } }
protected override void Initialize(ContentCompiler compiler) { gearWriter = compiler.GetTypeWriter(typeof(Gear)) as GearWriter; base.Initialize(compiler); }
protected override void Initialize(ContentCompiler compiler) { base.Initialize(compiler); }
/// <inheritdoc/> protected override void Initialize(ContentCompiler compiler) { base.Initialize(compiler); _targetWriter = compiler.GetTypeWriter(typeof(T)); }
protected override void Initialize(ContentCompiler compiler) { playerWriter = compiler.GetTypeWriter(typeof(Player)) as PlayerContentWriter; base.Initialize(compiler); }
protected override void Initialize(ContentCompiler compiler) { gameobjectWriter = compiler.GetTypeWriter(typeof(GameplayObject)) as GameplayObjectWriter; base.Initialize(compiler); }