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.Profile = platform == MonoGamePlatform.Windows8 ? ShaderProfile.DirectX_11 : ShaderProfile.OpenGL; 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); foreach (var dep in shaderInfo.Dependencies) context.AddDependency(dep); } catch (Exception ex) { // TODO: Extract good line numbers from mgfx parser! throw new InvalidContentException(ex.Message, input.Identity, ex); } // Create the effect object. EffectObject effect = null; var shaderErrorsAndWarnings = string.Empty; try { effect = EffectObject.CompileEffect(shaderInfo, out shaderErrorsAndWarnings); } catch (ShaderCompilerException) { throw ProcessErrorsAndWarnings(shaderErrorsAndWarnings, 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; }
private Exception ProcessErrorsAndWarnings(string errorsAndWarnings, EffectContent input, ContentProcessorContext context) { // Split the errors by lines. var errors = errorsAndWarnings.Split('\n'); // Process each error line extracting the location and message information. for (var i = 0; i < errors.Length; i++) { // Skip blank lines. if (errors[i].StartsWith(Environment.NewLine)) break; // find some unique characters in the error string var openIndex = errors[i].IndexOf('('); var closeIndex = errors[i].IndexOf(')'); // can't process the message if it has no line counter if (openIndex == -1 || closeIndex == -1) continue; // find the error number, then move forward into the message var errorIndex = errors[i].IndexOf('X', closeIndex); if (errorIndex < 0) return new InvalidContentException(errors[i], input.Identity); // trim out the data we need to feed the logger var fileName = errors[i].Remove(openIndex); var lineAndColumn = errors[i].Substring(openIndex + 1, closeIndex - openIndex - 1); var description = errors[i].Substring(errorIndex); // when the file name is not present, the error can be found in the root file if (string.IsNullOrEmpty(fileName)) fileName = input.Identity.SourceFilename; // ensure that the file data points toward the correct file var fileInfo = new FileInfo(fileName); if (!fileInfo.Exists) { var parentFile = new FileInfo(input.Identity.SourceFilename); fileInfo = new FileInfo(Path.Combine(parentFile.Directory.FullName, fileName)); } fileName = fileInfo.FullName; // construct the temporary content identity and file the error or warning var identity = new ContentIdentity(fileName, input.Identity.SourceTool, lineAndColumn); if (errors[i].Contains("warning")) { description = "A warning was generated when compiling the effect.\n" + description; context.Logger.LogWarning(string.Empty, identity, description, string.Empty); } else if (errors[i].Contains("error")) { description = "Unable to compile the effect.\n" + description; return new InvalidContentException(description, identity); } } // if no exceptions were created in the above loop, generate a generic one here return new InvalidContentException(errorsAndWarnings, input.Identity); }
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.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) { throw new InvalidContentException("Failed to parse the effect!", ex); } // Create the effect object. DXEffectObject effect; try { effect = DXEffectObject.FromShaderInfo(shaderInfo); } catch (Exception ex) { throw new InvalidContentException("Failed to create the effect!", ex); } // 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!", ex); } return result; }
public static CompiledEffectContent Compile(EffectContent output, string tempOutputPath, TargetPlatform platform, bool isDebug, string defines) { var processor = new EffectProcessor(); var context = new DummyContentProcessorContext(TargetPlatformCast.ToMonoGamePlatform(platform)); context.ActualOutputFilename = tempOutputPath; processor.DebugMode = isDebug ? EffectProcessorDebugMode.Debug : EffectProcessorDebugMode.Optimize; processor.Defines = defines + ";" + GetPlatformDefineForEffect(platform) + ";" + (isDebug ? "CONFIGURATION_DEBUG" : "CONFIGURATION_RELEASE"); return processor.Process(output, context); }
private void LoadByteCodeFromSource(string text) { try { EffectImporter importer = new EffectImporter(); EffectContent effectContent = new EffectContent { Identity = new ContentIdentity { SourceFilename = "myshader.fx" }, EffectCode = text, }; EffectProcessor processor = new EffectProcessor(); processor.DebugMode = EffectProcessorDebugMode.Optimize; CompiledEffectContent compiledEffect = processor.Process(effectContent, new FlaiProcessorContext((GraphicsProfile)_targetProfile.SelectedValue, (TargetPlatform)_targetPlatform.SelectedValue)); byte[] bytes = compiledEffect.GetEffectCode(); StringBuilder sb = new StringBuilder(bytes.Length * 3); sb.AppendLine("#region Effect Byte Code"); sb.AppendLine(); sb.Append("byte[] ByteCode = new byte[]").Append(Environment.NewLine).Append("{").Append(Environment.NewLine); for (int i = 0; i < bytes.Length;) { sb.Append('\t'); int max = Math.Min(i + 8, bytes.Length); for (; i < max; i++) { sb.Append(bytes[i]).Append(", "); } sb.Append(Environment.NewLine); } sb.Append("};").Append(Environment.NewLine); sb.AppendLine(); sb.Append("#endregion"); _byteCodeTextBox.Text = sb.ToString(); } catch (InvalidContentException e) { _byteCodeTextBox.Text = e.Message; } }
public override void Load() { try { using (StreamReader reader = new StreamReader(Settings.GetLocation(typeof(Shader)) + filename)) { EffectContent effectSource = new EffectContent(); effectSource.Name = name; effectSource.Identity = new ContentIdentity(filename); effectSource.EffectCode = reader.ReadToEnd(); EffectProcessor processor = new EffectProcessor(); CompiledEffectContent compiledEffect = processor.Process(effectSource, new ProcessorContext()); HLSL_Shader = new Effect(Bootstrap.graphics.GraphicsDevice, compiledEffect.GetEffectCode()); } this.loaded = true; } catch (System.Exception e) { Debug.LogError(e.Message); } }
protected virtual void ProcessMaterial(MaterialContent input, MaterialContent output, ContentProcessorContext context) { BasicMaterialContent basicMaterial = input as BasicMaterialContent; if (basicMaterial != null) { if (output is SkinnedModelMaterialContent) { SkinnedModelMaterialContent skinnedModelMaterial = output as SkinnedModelMaterialContent; skinnedModelMaterial.EmissiveColor = basicMaterial.EmissiveColor.GetValueOrDefault( Vector3.Zero); skinnedModelMaterial.DiffuseColor = basicMaterial.DiffuseColor.GetValueOrDefault( Vector3.One); skinnedModelMaterial.SpecularColor = basicMaterial.SpecularColor.GetValueOrDefault( Vector3.One); skinnedModelMaterial.SpecularPower = basicMaterial.SpecularPower.GetValueOrDefault( 16); EffectContent effectContent = new EffectContent(); effectContent.EffectCode = Resources.SkinnedModelEffect; EffectProcessor effectProcessor = new EffectProcessor(); skinnedModelMaterial.SkinnedEffectContent = effectProcessor.Process(effectContent, context); } else if (output is SkinnedMaterialContent) { SkinnedMaterialContent skinnedModelMaterial = output as SkinnedMaterialContent; skinnedModelMaterial.EmissiveColor = basicMaterial.EmissiveColor.GetValueOrDefault( Vector3.Zero); skinnedModelMaterial.DiffuseColor = basicMaterial.DiffuseColor.GetValueOrDefault( Vector3.One); skinnedModelMaterial.SpecularColor = basicMaterial.SpecularColor.GetValueOrDefault( Vector3.One); skinnedModelMaterial.SpecularPower = basicMaterial.SpecularPower.GetValueOrDefault( 16); } } }