/// <summary> /// Initializes the stage block. /// </summary> /// <param name="stageBlock">The stage block.</param> /// <param name="logger">The logger.</param> private void InitStageBlock(StageBlock stageBlock, Logger logger) { // If null shader, then skip init if (stageBlock.Index < 0) { return; } stageBlock.Shader = Effect.Pool.GetOrCompileShader(stageBlock.Type, stageBlock.Index); var shaderRaw = Effect.Pool.EffectData.Shaders[stageBlock.Index]; // Cache the input signature if (shaderRaw.Type == EffectShaderType.Vertex) { inputSignatureManager = graphicsDevice.GetOrCreateInputSignatureManager(shaderRaw.InputSignature.Bytecode, shaderRaw.InputSignature.Hashcode); } for (int i = 0; i < shaderRaw.ConstantBuffers.Count; i++) { var constantBufferRaw = shaderRaw.ConstantBuffers[i]; // Constant buffers with a null size are skipped if (constantBufferRaw.Size == 0) continue; var constantBuffer = Effect.GetOrCreateConstantBuffer(Effect.GraphicsDevice, constantBufferRaw); // IF constant buffer is null, it means that there is a conflict if (constantBuffer == null) { logger.Error("Constant buffer [{0}] cannot have multiple size or different content declaration inside the same effect pool", constantBufferRaw.Name); continue; } // Test if this constant buffer is not already part of the effect if (Effect.ConstantBuffers[constantBufferRaw.Name] == null) { // Add the declared constant buffer to the effect shader. Effect.ConstantBuffers.Add(constantBuffer); // Declare all parameter from constant buffer at the effect level. foreach (var parameter in constantBuffer.Parameters) { var previousParameter = Effect.Parameters[parameter.Name]; if (previousParameter == null) { // Add an effect parameter linked to the approriate constant buffer at the effect level. Effect.Parameters.Add(new EffectParameter((EffectData.ValueTypeParameter) parameter.ParameterDescription, constantBuffer)); } else if (parameter.ParameterDescription != previousParameter.ParameterDescription || parameter.buffer != previousParameter.buffer) { // If registered parameters is different logger.Error("Parameter [{0}] defined in Constant buffer [{0}] is already defined by another constant buffer with the definition [{2}]", parameter, constantBuffer.Name, previousParameter); } } } } var constantBufferLinks = new List<ConstantBufferLink>(); // Declare all resource parameters at the effect level. foreach (var parameterRaw in shaderRaw.ResourceParameters) { EffectParameter parameter; var previousParameter = Effect.Parameters[parameterRaw.Name]; // Skip enmpty constant buffers. if (parameterRaw.Type == EffectParameterType.ConstantBuffer && Effect.ConstantBuffers[parameterRaw.Name] == null) { continue; } int resourceIndex = Effect.ResourceLinker.Count; if (previousParameter == null) { parameter = new EffectParameter(parameterRaw, EffectResourceTypeHelper.ConvertFromParameterType(parameterRaw.Type), Effect.ResourceLinker.Count, Effect.ResourceLinker); Effect.Parameters.Add(parameter); Effect.ResourceLinker.Count += parameterRaw.Count; } else { resourceIndex = ((EffectData.ResourceParameter) previousParameter.ParameterDescription).Slot; if (CompareResourceParameter(parameterRaw, (EffectData.ResourceParameter) previousParameter.ParameterDescription)) { // If registered parameters is different logger.Error("Resource Parameter [{0}] is already defined with a different definition [{1}]", parameterRaw, previousParameter.ParameterDescription); } parameter = previousParameter; } // For constant buffers, we need to store explicit link if (parameter.ResourceType == EffectResourceType.ConstantBuffer) { constantBufferLinks.Add(new ConstantBufferLink(Effect.ConstantBuffers[parameter.Name], parameter)); } if (stageBlock.Parameters == null) { stageBlock.Parameters = new List<EffectParameter>(); } stageBlock.Parameters.Add(parameter); } stageBlock.ConstantBufferLinks = constantBufferLinks.ToArray(); }
private AttributeCollection PrepareAttributes(Logger logger, List<AttributeData> attributes) { attributes = new List<AttributeData>(attributes); for (int i = 0; i < attributes.Count; i++) { var attribute = attributes[i]; bool attributeHandled = true; switch (attribute.Name) { case EffectData.AttributeKeys.Blending: BlendState = graphicsDevice.BlendStates[(string) attribute.Value]; if (BlendState == null) logger.Error("Unable to find registered BlendState [{0}]", (string)attribute.Value); break; case EffectData.AttributeKeys.BlendingColor: BlendStateColor = (Color4) (Vector4) attribute.Value; break; case EffectData.AttributeKeys.BlendingSampleMask: BlendStateSampleMask = (uint) attribute.Value; break; case EffectData.AttributeKeys.DepthStencil: DepthStencilState = graphicsDevice.DepthStencilStates[(string) attribute.Value]; if (DepthStencilState == null) logger.Error("Unable to find registered DepthStencilState [{0}]", (string)attribute.Value); break; case EffectData.AttributeKeys.DepthStencilReference: DepthStencilReference = (int) attribute.Value; break; case EffectData.AttributeKeys.Rasterizer: RasterizerState = graphicsDevice.RasterizerStates[(string) attribute.Value]; if (RasterizerState == null) logger.Error("Unable to find registered RasterizerState [{0}]", (string)attribute.Value); break; default: attributeHandled = false; break; } if (attributeHandled) { attributes.RemoveAt(i); i--; } } return new AttributeCollection(attributes); }
/// <summary> /// Merges an existing <see cref="EffectData" /> into this instance. /// </summary> /// <param name="source">The EffectData to merge.</param> /// <param name="logger">Logger used to report merging errors.</param> /// <param name="allowOverride">if set to <c>true</c> [allow override].</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns> /// <remarks>This method is useful to build an archive of several effects.</remarks> public bool MergeFrom(EffectData source, Logger logger, bool allowOverride = false) { bool isMergeOk = true; foreach (var effect in source.Effects) { bool effectAlreadyRegistered = false; // Add effect that is not already in the archive with this same name. int previousEffectIndex = 0; for (; previousEffectIndex < Effects.Count; previousEffectIndex++) { var effect2 = Effects[previousEffectIndex]; if (effect2.Name == effect.Name) { effectAlreadyRegistered = true; break; } } if (effectAlreadyRegistered) { if (allowOverride) { Effects[previousEffectIndex] = effect; } else { // Skip the effect it it is already registered continue; } } else { Effects.Add(effect); } foreach (var technique in effect.Techniques) { foreach (var pass in technique.Passes) { foreach (var shaderLink in pass.Pipeline) { if (shaderLink == null) continue; if (shaderLink.IsImport) { // If this is an import, we try first to resolve it directly // Else we keep the name as-is var index = FindShaderByName(shaderLink.ImportName); if (index >= 0) { shaderLink.ImportName = null; shaderLink.Index = index; } } else if (!shaderLink.IsNullShader) { var shader = source.Shaders[shaderLink.Index]; var index = FindShader(shader); if (index >= 0) { var previousShader = Shaders[index]; if (shader.Name != null) { // if shader from this instance is local and shader from source is global => transform current shader to global if (previousShader.Name == null) { previousShader.Name = shader.Name; } else if (shader.Name != previousShader.Name) { // If shader from this instance is global and shader from source is global => check names. If exported names are different, this is an error logger.Error("Cannot merge shader [{0}] into this instance, as there is already a global shader with a different name [{1}]", shader.Name, previousShader.Name); isMergeOk = false; } } shaderLink.Index = index; } else { shaderLink.Index = Shaders.Count; Shaders.Add(shader); } } } } } } return isMergeOk; }
/// <summary> /// Compiles an XML font file description to a file. Optionally output dependency file. /// </summary> /// <param name="sourceXmlFile">The source XML file.</param> /// <param name="outputFile">The output file.</param> /// <param name="dependencyFile">The dependency file.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns> public static ContentCompilerResult CompileAndSave(string sourceXmlFile, string outputFile, string dependencyFile = null) { var logger = new Logger(); var result = new ContentCompilerResult { Logger = logger }; try { var fontDescription = FontDescription.Load(sourceXmlFile); var defaultOutputFile = Path.GetFileNameWithoutExtension(sourceXmlFile); // Compiles to SpriteData outputFile = outputFile ?? defaultOutputFile; result.IsContentGenerated = true; if(dependencyFile != null) { if(!FileDependencyList.CheckForChanges(dependencyFile)) { result.IsContentGenerated = false; } } if(result.IsContentGenerated) { // Make sure that directory name doesn't collide with filename var directoryName = Path.GetDirectoryName(outputFile + ".tmp"); if(!string.IsNullOrEmpty(directoryName) && !Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } using(var stream = new NativeFileStream(outputFile, NativeFileMode.Create, NativeFileAccess.Write)) { Compile(fontDescription, stream); if(dependencyFile != null) { var dependencies = new FileDependencyList(); dependencies.AddDefaultDependencies(); dependencies.AddDependencyPath(sourceXmlFile); dependencies.Save(dependencyFile); } } } } catch(FontException ex) { logger.Error(ex.Message); } catch (Exception ex) { logger.Error(ex.ToString()); } return result; }
private PropertyCollection PrepareProperties(Logger logger, CommonData.PropertyCollection properties) { var passProperties = new PropertyCollection(); foreach (var property in properties) { switch (property.Key) { case EffectData.PropertyKeys.Blending: BlendState = graphicsDevice.BlendStates[(string)property.Value]; if (BlendState == null) logger.Error("Unable to find registered BlendState [{0}]", (string)property.Value); break; case EffectData.PropertyKeys.BlendingColor: BlendStateColor = (Color4)(Vector4)property.Value; break; case EffectData.PropertyKeys.BlendingSampleMask: BlendStateSampleMask = (uint)property.Value; break; case EffectData.PropertyKeys.DepthStencil: DepthStencilState = graphicsDevice.DepthStencilStates[(string)property.Value]; if (DepthStencilState == null) logger.Error("Unable to find registered DepthStencilState [{0}]", (string)property.Value); break; case EffectData.PropertyKeys.DepthStencilReference: DepthStencilReference = (int)property.Value; break; case EffectData.PropertyKeys.Rasterizer: RasterizerState = graphicsDevice.RasterizerStates[(string)property.Value]; if (RasterizerState == null) logger.Error("Unable to find registered RasterizerState [{0}]", (string)property.Value); break; default: passProperties[new PropertyKey(property.Key)] = property.Value; break; } } return passProperties; }
/// <summary> /// Binds the specified effect data to this instance. /// </summary> /// <param name="effectDataArg">The effect data arg.</param> /// <param name="cloneFromEffect">The clone from effect.</param> /// <exception cref="System.InvalidOperationException">If no techniques found in this effect.</exception> /// <exception cref="System.ArgumentException">If unable to find effect [effectName] from the EffectPool.</exception> internal void InitializeFrom(EffectData.Effect effectDataArg, Effect cloneFromEffect) { RawEffectData = effectDataArg; // Clean any previously allocated resources if (DisposeCollector != null) { DisposeCollector.DisposeAndClear(); } ConstantBuffers.Clear(); Parameters.Clear(); Techniques.Clear(); ResourceLinker = ToDispose(new EffectResourceLinker()); if (effectConstantBuffersCache != null) { effectConstantBuffersCache.Clear(); } // Copy data IsSupportingDynamicCompilation = RawEffectData.Arguments != null; ShareConstantBuffers = RawEffectData.ShareConstantBuffers; // Create the local effect constant buffers cache if (!ShareConstantBuffers) effectConstantBuffersCache = new Dictionary<EffectConstantBufferKey, EffectConstantBuffer>(); var logger = new Logger(); int techniqueIndex = 0; int totalPassCount = 0; EffectPass parentPass = null; foreach (var techniqueRaw in RawEffectData.Techniques) { var name = techniqueRaw.Name; if (string.IsNullOrEmpty(name)) name = string.Format("${0}", techniqueIndex++); var technique = new EffectTechnique(this, name); Techniques.Add(technique); int passIndex = 0; foreach (var passRaw in techniqueRaw.Passes) { name = passRaw.Name; if (string.IsNullOrEmpty(name)) name = string.Format("${0}", passIndex++); var pass = new EffectPass(logger, this, technique, passRaw, name); pass.Initialize(logger); // If this is a subpass, add it to the parent pass if (passRaw.IsSubPass) { if (parentPass == null) { logger.Error("Pass [{0}] is declared as a subpass but has no parent."); } else { parentPass.SubPasses.Add(pass); } } else { technique.Passes.Add(pass); parentPass = pass; } } // Count the number of passes totalPassCount += technique.Passes.Count; } if (totalPassCount == 0) throw new InvalidOperationException("No passes found in this effect."); // Log all the exception in a single throw if (logger.HasErrors) throw new InvalidOperationException(Utilities.Join("\n", logger.Messages)); // Initialize the resource linker when we are done with all pass/parameters ResourceLinker.Initialize(); //// Sort all parameters by their resource types //// in order to achieve better local cache coherency in resource linker Parameters.Items.Sort((left, right) => { // First, order first all value types, then resource type var comparison = left.IsValueType != right.IsValueType ? left.IsValueType ? -1 : 1 : 0; // If same type if (comparison == 0) { // Order by resource type comparison = ((int)left.ResourceType).CompareTo((int)right.ResourceType); // If same, order by resource index if (comparison == 0) { comparison = left.Offset.CompareTo(right.Offset); } } return comparison; }); // Prelink constant buffers int resourceIndex = 0; foreach (var parameter in Parameters) { // Recalculate parameter resource index if (!parameter.IsValueType) { parameter.Offset = resourceIndex++; } // Set the default values parameter.SetDefaultValue(); if (parameter.ResourceType == EffectResourceType.ConstantBuffer) parameter.SetResource(ConstantBuffers[parameter.Name]); } // Compute slot links foreach (var technique in Techniques) { foreach (var pass in technique.Passes) { foreach (var subPass in pass.SubPasses) { subPass.ComputeSlotLinks(); } pass.ComputeSlotLinks(); } } // Setup the first Current Technique. CurrentTechnique = this.Techniques[0]; // Initialize predefined parameters used by Model.Draw (to speedup things internally) DefaultParameters = new EffectDefaultParameters(this); // If this is a clone, we need to if (cloneFromEffect != null) { // Copy the content of the constant buffers to the new instance. for (int i = 0; i < ConstantBuffers.Count; i++) { cloneFromEffect.ConstantBuffers[i].CopyTo(ConstantBuffers[i]); } // Copy back all bound resources except constant buffers // that are already initialized with InitializeFrom method. for (int i = 0; i < cloneFromEffect.ResourceLinker.Count; i++) { if (cloneFromEffect.ResourceLinker.BoundResources[i] is EffectConstantBuffer) continue; ResourceLinker.BoundResources[i] = cloneFromEffect.ResourceLinker.BoundResources[i]; unsafe { ResourceLinker.Pointers[i] = cloneFromEffect.ResourceLinker.Pointers[i]; } } // If everything was fine, then we can register it into the pool Pool.AddEffect(this); } // Allow subclasses to complete initialization. Initialize(); }
/// <summary> /// Initializes the specified effect bytecode. /// </summary> /// <param name="effectDataArg">The effect bytecode.</param> /// <exception cref="System.InvalidOperationException"></exception> private void Initialize(EffectData.Effect effectDataArg) { if (effectDataArg == null) throw new ArgumentException(string.Format("Unable to find effect [{0}] from the EffectPool", Name), "effectName"); rawEffect = effectDataArg; ShareConstantBuffers = effectDataArg.ShareConstantBuffers; // Create the local effect constant buffers cache if (!ShareConstantBuffers) effectConstantBuffersCache = new Dictionary<EffectConstantBufferKey, EffectConstantBuffer>(); if (effectDataArg.Techniques.Count == 0) throw new InvalidOperationException("No techniques found in this effect"); var logger = new Logger(); int techniqueIndex = 0; int totalPassCount = 0; EffectPass parentPass = null; foreach (var techniqueRaw in effectDataArg.Techniques) { var name = techniqueRaw.Name; if (string.IsNullOrEmpty(name)) name = string.Format("${0}", techniqueIndex++); var technique = new EffectTechnique(this, name); Techniques.Add(technique); int passIndex = 0; foreach (var passRaw in techniqueRaw.Passes) { name = passRaw.Name; if (string.IsNullOrEmpty(name)) name = string.Format("${0}", passIndex++); var pass = new EffectPass(logger, this, technique, passRaw, name); pass.Initialize(logger); // If this is a subpass, add it to the parent pass if (passRaw.IsSubPass) { if (parentPass == null) { logger.Error("Pass [{0}] is declared as a subpass but has no parent"); } else { parentPass.SubPasses.Add(pass); } } else { technique.Passes.Add(pass); parentPass = pass; } } // Count the number of passes totalPassCount += technique.Passes.Count; } if (totalPassCount == 0) throw new InvalidOperationException("No passes found in this effect"); // Log all the exception in a single throw if (logger.HasErrors) throw new InvalidOperationException(Utilities.Join("\n", logger.Messages)); // Initialize the resource linker when we are done with all pass/parameters ResourceLinker.Initialize(); //// Sort all parameters by their resource types //// in order to achieve better local cache coherency in resource linker Parameters.Items.Sort((left, right) => { // First, order first all value types, then resource type var comparison = left.IsValueType != right.IsValueType ? left.IsValueType ? -1 : 1 : 0; // If same type if (comparison == 0) { // Order by resource type comparison = ((int)left.ResourceType).CompareTo((int)right.ResourceType); // If same, order by resource index if (comparison == 0) { comparison = left.Offset.CompareTo(right.Offset); } } return comparison; }); // Prelink constant buffers int resourceIndex = 0; foreach (var parameter in Parameters) { // Recalculate parameter resource index if (!parameter.IsValueType) { parameter.Offset = resourceIndex++; } // Set the default values parameter.SetDefaultValue(); if (parameter.ResourceType == EffectResourceType.ConstantBuffer) parameter.SetResource(0, ConstantBuffers[parameter.Name]); } // Compute slot links foreach (var technique in Techniques) { foreach (var pass in technique.Passes) { foreach (var subPass in pass.SubPasses) { subPass.ComputeSlotLinks(); } pass.ComputeSlotLinks(); } } // Setup the first Current Technique. CurrentTechnique = this.Techniques[0]; }