public Program(CompiledEffectContent compiledEffect) { var code = compiledEffect.GetEffectCode(); _effect = new Effect(SLSharp.Device, code); _pass = _effect.Techniques.First().Passes.First(); }
/// <summary> /// Processes a PaletteInfo object into a PaletteMaterialContent object. /// </summary> /// <param name="input">The PaletteInfo to process.</param> /// <param name="context">The processor context.</param> /// <returns>The processed PaletteMaterialContent</returns> public override PaletteMaterialContent Process(PaletteInfo input, ContentProcessorContext context) { // Set all the variables based on the input. EffectProcessor effectProcessor = new EffectProcessor(); EffectContent effectContent = new EffectContent(); effectContent.EffectCode = input.SourceCode; CompiledEffectContent compiled = effectProcessor.Process(effectContent, context); PaletteMaterialContent content = new PaletteMaterialContent(); content.PaletteSize = input.PaletteSize; content.ByteCode = compiled.GetEffectCode(); BasicMaterialContent basic = input.BasicContent; content.Alpha = basic.Alpha; content.DiffuseColor = basic.DiffuseColor; content.EmissiveColor = basic.EmissiveColor; content.Name = basic.Name; content.SpecularColor = basic.SpecularColor; content.SpecularPower = basic.SpecularPower; content.Texture = basic.Texture; content.VertexColorEnabled = basic.VertexColorEnabled; return(content); }
public static byte[] GetEffectCodeBytes(string filename) { EffectContent content = importer.Import("./" + filename, new CustomImporterContext( )); CompiledEffectContent compiled = processor.Process(content, new CustomProcessorContext( )); return(compiled.GetEffectCode( )); }
static byte[] GetEffectCode(string filename) { var basePath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath), "Content"); var effectFileName = System.IO.Path.Combine(basePath, filename + ".fx"); EffectContent effectSource = new EffectContent { Identity = new ContentIdentity(effectFileName), EffectCode = File.ReadAllText(effectFileName), }; EffectProcessor processor = new EffectProcessor(); CompiledEffectContent compiledEffect = processor.Process(effectSource, new ProcessorContext()); return(compiledEffect.GetEffectCode()); #if DEBUG_SHADER_CODE // NOTE: We may need to implement a CompilerIncludeHandler here if we ever use #include in our shaders. var compiledEffect = Effect.CompileEffectFromFile(effectFileName, null, null, CompilerOptions.Debug, TargetPlatform.Windows); if (!compiledEffect.Success) { throw new InvalidOperationException(compiledEffect.ErrorsAndWarnings); } return(compiledEffect.GetEffectCode()); #else // We have to use a file stream instead of passing the file name directly because the latter method just botches up non-ASCII paths. :( //using (var effectFileStream = File.OpenRead(effectFileName)) //{ // // NOTE: We may need to implement a CompilerIncludeHandler here if we ever use #include in our shaders. // var compiledEffect = Effect.CompileEffectFromFile(effectFileStream, null, null, CompilerOptions.None, TargetPlatform.Windows); // if (!compiledEffect.Success) // throw new InvalidOperationException(compiledEffect.ErrorsAndWarnings); // return compiledEffect.GetEffectCode(); //} #endif }
static int Main(string[] args) { // Make sure we have the right number of commandline arguments. if (args.Length != 4) { Console.Error.WriteLine("Usage: CompileEffect <targetPlatform> <targetProfile> <input.fx> <output.bin>"); return(1); } // Parse the commandline arguments. TargetPlatform targetPlatform; if (!Enum.TryParse(args[0], true, out targetPlatform)) { Console.Error.WriteLine("Invalid target platform {0}. Valid options are {1}.", args[0], GetEnumValues <TargetPlatform>()); return(1); } GraphicsProfile targetProfile; if (!Enum.TryParse(args[1], true, out targetProfile)) { Console.Error.WriteLine("Invalid target profile {0}. Valid options are {1}.", args[1], GetEnumValues <GraphicsProfile>()); return(1); } string inputFilename = args[2]; string outputFilename = args[3]; try { Console.WriteLine("Compiling {0} -> {1} for {2}, {3}", Path.GetFileName(inputFilename), outputFilename, targetPlatform, targetProfile); ContentBuildLogger logger = new CustomLogger(); // Import the effect source code. EffectImporter importer = new EffectImporter(); ContentImporterContext importerContext = new CustomImporterContext(logger); EffectContent sourceEffect = importer.Import(inputFilename, importerContext); // Compile the effect. EffectProcessor processor = new EffectProcessor(); ContentProcessorContext processorContext = new CustomProcessorContext(targetPlatform, targetProfile, logger); CompiledEffectContent compiledEffect = processor.Process(sourceEffect, processorContext); // Write out the compiled effect code. File.WriteAllBytes(outputFilename, compiledEffect.GetEffectCode()); } catch (Exception e) { Console.Error.WriteLine("Error: {0}", e.Message); return(1); } return(0); }
public static byte[] ReadBytesFromSourceFile(string fileName) { EffectImporter importer = new EffectImporter( ); EffectProcessor processor = new EffectProcessor( ); EffectContent content = importer.Import(fileName, new ShaderImporterContext( )); CompiledEffectContent compiled = processor.Process(content, new ShaderProcessorContext( )); return(compiled.GetEffectCode( )); }
public override CompiledShaderContent Process(ShaderContent input, ContentProcessorContext context) { // Build new .fx file. string effectCode = BuildFxFile(input); // Save to temporary .stitchedeffect file. string tempFxFile = GetTempFileName(input, ".fx"); File.WriteAllText(tempFxFile, effectCode, Encoding.GetEncoding(1252)); // Run standard effect processor. CompiledEffectContent compiledEffect = context.BuildAndLoadAsset <EffectContent, CompiledEffectContent>( new ExternalReference <EffectContent>(tempFxFile), "EffectProcessor"); return(new CompiledShaderContent { Effect = compiledEffect }); }
public override Effect Load(IResource resource, LoaderParameters parameters) { FileInfo info = new FileInfo(resource.FullName); if (!info.Exists) { throw new FileNotFoundException("Effect file does not exist in directory"); } EffectContent content = new EffectContent(); content.Identity = new ContentIdentity(resource.FullName); content.EffectCode = File.ReadAllText(resource.FullName); CompiledEffectContent compiled = _processor.Process(content, _xnaContext); Effect effect = new Effect(compiled.GetEffectCode()); effect.Name = resource.Name; return(effect); }
public override CompiledEffectContent Process(EffectContent input, ContentProcessorContext context) { //System.Diagnostics.Debugger.Launch(); // If this isn't a MonoGame platform then do the default processing. var platform = ContentHelper.GetMonoGamePlatform(); if (platform == MonoGamePlatform.None) { return(base.Process(input, context)); } var options = new Options(); options.SourceFile = input.Identity.SourceFilename; options.DX11Profile = platform == MonoGamePlatform.Windows8 ? true : false; options.Debug = DebugMode == EffectProcessorDebugMode.Debug; options.OutputFile = context.OutputFilename; // Parse the MGFX file expanding includes, macros, and returning the techniques. ShaderInfo shaderInfo; try { shaderInfo = ShaderInfo.FromFile(options.SourceFile, options); } catch (Exception ex) { // TODO: Extract good line numbers from mgfx parser! throw new InvalidContentException(ex.Message, input.Identity, ex); } // Create the effect object. DXEffectObject effect = null; try { effect = DXEffectObject.FromShaderInfo(shaderInfo); } catch (Exception ex) { throw ProcessErrorsAndWarnings(ex.Message, input, context); } // Write out the effect to a runtime format. CompiledEffectContent result; try { using (var stream = new MemoryStream()) { using (var writer = new BinaryWriter(stream)) effect.Write(writer, options); result = new CompiledEffectContent(stream.GetBuffer()); } } catch (Exception ex) { throw new InvalidContentException("Failed to serialize the effect!", input.Identity, ex); } return(result); }
public override TOutput Process(TInput input, ContentProcessorContext context) { Dictionary <string, Q3BSPMaterialContent> processedDictionary = new Dictionary <string, Q3BSPMaterialContent>(); #region Initialize StreamWriter, if necessary #if DEBUG StreamWriter sw = new StreamWriter(context.OutputFilename.Substring(0, context.OutputFilename.LastIndexOf('.')) + ".compiled.txt"); #else StreamWriter sw = null; #endif #endregion for (int i = 0; i < input.Count; i++) { Q3BSPMaterialContent shader = input[i]; #region Throw any errors in the parsed shader if (shader.stages.Count > 8) { throw new InvalidContentException(shader.shaderName + " has " + shader.stages.Count + " stages, but the maximum supported is 8."); } if (processedDictionary.ContainsKey(shader.shaderName)) { context.Logger.LogWarning("", new ContentIdentity(), "Material " + shader.shaderName + " is defined more than once."); continue; //throw new InvalidContentException("Material " + shader.shaderName + " is defined more than once."); } #endregion #region Log any needed warnings if (shader.stages.Count > 4 && shaderModel == ShaderModel.ShaderModel1) { context.Logger.LogWarning("", new ContentIdentity(), shader.shaderName + " has more than 4 stages, Shader Model 2.0 is required."); } #endregion EffectProcessor processor = new EffectProcessor(); processor.DebugMode = EffectProcessorDebugMode.Debug; EffectContent effectContent = new EffectContent(); effectContent.EffectCode = GenerateEffectFromShader(shader, sw); #region Compile the Effect #if DEBUG CompiledEffectContent compiledEffect = processor.Process(effectContent, context); //CompiledEffect compiledEffect = Effect.CompileEffectFromSource(GenerateEffectFromShader(shader, sw), null, null, CompilerOptions.Debug, TargetPlatform.Windows); #else processor.DebugMode = EffectProcessorDebugMode.Auto; CompiledEffectContent compiledEffect = processor.Process(effectContent, context); //CompiledEffect compiledEffect = Effect.CompileEffectFromSource(GenerateEffectFromShader(shader, sw), null, null, CompilerOptions.None, TargetPlatform.Windows); #endif #endregion /* * if (compiledEffect.ErrorsAndWarnings.Contains("error")) * { * throw new InvalidContentException(shader.shaderName + ": " + compiledEffect.ErrorsAndWarnings); * } */ shader.compiledEffect = compiledEffect; shader.ShaderCode = compiledEffect.GetEffectCode(); processedDictionary.Add(shader.shaderName, shader); } #if DEBUG sw.Flush(); sw.Dispose(); #endif return(processedDictionary); }