public override void Visit(MaterialGeneratorContext context) { base.Visit(context); if (HasAlreadyTessellationFeature) { return; } // set the tessellation method used enumeration context.Material.TessellationMethod |= ParadoxTessellationMethod.Flat; // create and affect the shader source var tessellationShader = new ShaderMixinSource(); tessellationShader.Mixins.Add(new ShaderClassSource("TessellationFlat")); context.Parameters.Set(MaterialKeys.TessellationShader, tessellationShader); }
public override void VisitFeature(MaterialGeneratorContext context) { // Push overrides of this attributes context.PushOverrides(Overrides); // Order is important, as some features are dependent on other // (For example, Specular can depend on Diffuse in case of Metalness) // We may be able to describe a dependency system here, but for now, assume // that it won't change much so it is hardcoded // Diffuse context.Visit(Diffuse); context.Visit(DiffuseModel); // Surface Geometry context.Visit(Tessellation); context.Visit(Displacement); context.Visit(Surface); context.Visit(MicroSurface); // If Specular has energy conservative, copy this to the diffuse lambertian model // TODO: Should we apply it to any Diffuse Model? bool isEnergyConservative = (Specular is MaterialSpecularMapFeature && ((MaterialSpecularMapFeature)Specular).IsEnergyConservative); var lambert = DiffuseModel as MaterialDiffuseLambertModelFeature; if (lambert != null) { lambert.IsEnergyConservative = isEnergyConservative; } // Specular context.Visit(Specular); context.Visit(SpecularModel); // Misc context.Visit(Occlusion); context.Visit(Emissive); context.Visit(Transparency); // Pop overrides context.PopOverrides(); }
public override void VisitFeature(MaterialGeneratorContext context) { var alpha = Alpha ?? new ComputeFloat(1f); var tint = Tint ?? new ComputeColor(Color.White); // Use pre-multiplied alpha to support both additive and alpha blending var blendDesc = new BlendStateDescription(Blend.One, Blend.InverseSourceAlpha); context.Material.HasTransparency = true; context.Parameters.Set(Effect.BlendStateKey, BlendState.NewFake(blendDesc)); context.SetStream(AlphaBlendStream.Stream, alpha, MaterialKeys.DiffuseSpecularAlphaBlendMap, MaterialKeys.DiffuseSpecularAlphaBlendValue, Color.White); context.SetStream(AlphaBlendColorStream.Stream, tint, MaterialKeys.AlphaBlendColorMap, MaterialKeys.AlphaBlendColorValue, Color.White); if (!context.Tags.Get(HasFinalCallback)) { context.Tags.Set(HasFinalCallback, true); context.AddFinalCallback(MaterialShaderStage.Pixel, AddDiffuseSpecularAlphaBlendColor); } }
public void Visit(MaterialGeneratorContext context) { // Exclude ambient occlusion from uv-scale overrides var revertOverrides = new MaterialOverrides(); revertOverrides.UVScale = 1.0f / context.CurrentOverrides.UVScale; context.PushOverrides(revertOverrides); context.SetStream(OcclusionStream.Stream, AmbientOcclusionMap, MaterialKeys.AmbientOcclusionMap, MaterialKeys.AmbientOcclusionValue, Color.White); context.PopOverrides(); context.SetStream("matAmbientOcclusionDirectLightingFactor", DirectLightingFactor, null, MaterialKeys.AmbientOcclusionDirectLightingFactorValue); if (CavityMap != null) { context.SetStream(CavityStream.Stream, CavityMap, MaterialKeys.CavityMap, MaterialKeys.CavityValue, Color.White); context.SetStream("matCavityDiffuse", DiffuseCavity, null, MaterialKeys.CavityDiffuseValue); context.SetStream("matCavitySpecular", SpecularCavity, null, MaterialKeys.CavitySpecularValue); } }
public override void VisitFeature(MaterialGeneratorContext context) { base.VisitFeature(context); if (HasAlreadyTessellationFeature) { return; } // set the tessellation method used enumeration context.Material.TessellationMethod |= ParadoxTessellationMethod.PointNormal; // create and affect the shader source var tessellationShader = new ShaderMixinSource(); tessellationShader.Mixins.Add(new ShaderClassSource("TessellationPN")); if (AdjacentEdgeAverage) { tessellationShader.Mixins.Add(new ShaderClassSource("TessellationAE4", "PositionWS")); } context.Parameters.Set(MaterialKeys.TessellationShader, tessellationShader); }
public override void VisitFeature(MaterialGeneratorContext context) { var shaderSource = new ShaderMixinSource(); shaderSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingSpecularMicrofacet")); if (Fresnel != null) { shaderSource.AddComposition("fresnelFunction", Fresnel.Generate()); } if (Visibility != null) { shaderSource.AddComposition("geometricShadowingFunction", Visibility.Generate()); } if (NormalDistribution != null) { shaderSource.AddComposition("normalDistributionFunction", NormalDistribution.Generate()); } context.AddShading(this, shaderSource); }
public virtual void Visit(MaterialGeneratorContext context) { // If not enabled, or Material or BlendMap are null, skip this layer if (!Enabled || Material == null || BlendMap == null || context.FindAsset == null) { return; } // Find the material from the reference var material = context.FindAsset(Material); if (material == null) { context.Log.Error("Unable to find material [{0}]", Material); return; } // TODO: Because we are not fully supporting Streams declaration in shaders, we have to workaround this limitation by using a dynamic shader (inline) // TODO: Handle MaterialOverrides // Push a layer for the sub-material context.PushOverrides(Overrides); context.PushLayer(); // Generate the material shaders into the current context material.Visit(context); // Generate Vertex and Pixel surface shaders foreach (MaterialShaderStage stage in Enum.GetValues(typeof(MaterialShaderStage))) { Generate(stage, context); } // Pop the stack context.PopLayer(); context.PopOverrides(); }
public override void VisitFeature(MaterialGeneratorContext context) { if (NormalMap != null) { // Inform the context that we are using matNormal (from the MaterialSurfaceNormalMap shader) context.UseStreamWithCustomBlend(MaterialShaderStage.Pixel, NormalStream.Stream, new ShaderClassSource("MaterialStreamNormalBlend")); context.Parameters.Set(MaterialKeys.HasNormalMap, true); var normalMap = NormalMap; // Workaround to make sure that normal map are setup var computeTextureColor = normalMap as ComputeTextureColor; if (computeTextureColor != null) { if (computeTextureColor.FallbackValue.Value == Color.White) { computeTextureColor.FallbackValue.Value = DefaultNormalColor; } } else { var computeColor = normalMap as ComputeColor; if (computeColor != null) { if (computeColor.Value == Color.Black || computeColor.Value == Color.White) { computeColor.Value = DefaultNormalColor; } } } var computeColorSource = NormalMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.NormalMap, MaterialKeys.NormalValue, DefaultNormalColor, false)); var mixin = new ShaderMixinSource(); mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceNormalMap", IsXYNormal, ScaleAndBias)); mixin.AddComposition("normalMap", computeColorSource); context.AddSurfaceShader(MaterialShaderStage.Pixel, mixin); } }
public void Visit(MaterialGeneratorContext context) { if (DisplacementMap == null) { return; } var materialStage = (MaterialShaderStage)Stage; // reset the displacement streams at the beginning of the stage context.AddStreamInitializer(materialStage, "MaterialDisplacementStream"); // set the blending mode of displacement map to additive (and not default linear blending) context.UseStreamWithCustomBlend(materialStage, DisplacementStream, new ShaderClassSource("MaterialStreamAdditiveBlend", DisplacementStream)); // build the displacement computer var displacement = DisplacementMap; if (ScaleAndBias) // scale and bias should be done by layer { displacement = new ComputeBinaryScalar(displacement, new ComputeFloat(2f), BinaryOperator.Multiply); displacement = new ComputeBinaryScalar(displacement, new ComputeFloat(1f), BinaryOperator.Subtract); } displacement = new ComputeBinaryScalar(displacement, Intensity, BinaryOperator.Multiply); // Workaround to inform compute colors that sampling is occurring from a vertex shader context.IsNotPixelStage = materialStage != MaterialShaderStage.Pixel; context.SetStream(materialStage, DisplacementStream, displacement, MaterialKeys.DisplacementMap, MaterialKeys.DisplacementValue); context.IsNotPixelStage = false; var scaleNormal = materialStage != MaterialShaderStage.Vertex; var positionMember = materialStage == MaterialShaderStage.Vertex ? "Position" : "PositionWS"; var normalMember = materialStage == MaterialShaderStage.Vertex ? "meshNormal" : "normalWS"; context.SetStreamFinalModifier <MaterialDisplacementMapFeature>(materialStage, new ShaderClassSource("MaterialSurfaceDisplacement", positionMember, normalMember, scaleNormal)); }
public virtual void Visit(MaterialGeneratorContext context) { var shaderSource = new ShaderClassSource("MaterialSurfaceShadingDiffuseLambert", IsEnergyConservative); context.AddShading(this, shaderSource); }
public void Visit(MaterialGeneratorContext context) { context.SetStream(SpecularStream.Stream, SpecularMap, MaterialKeys.SpecularMap, MaterialKeys.SpecularValue); context.SetStream("matSpecularIntensity", Intensity, null, MaterialKeys.SpecularIntensityValue); }
private void AddDiscardFromLuminance(MaterialShaderStage stage, MaterialGeneratorContext context) { context.AddSurfaceShader(MaterialShaderStage.Pixel, new ShaderClassSource("MaterialSurfaceTransparentAlphaDiscard")); }
private void AddDiffuseSpecularAlphaBlendColor(MaterialShaderStage stage, MaterialGeneratorContext context) { context.AddSurfaceShader(MaterialShaderStage.Pixel, new ShaderClassSource("MaterialSurfaceDiffuseSpecularAlphaBlendColor")); }
public static MaterialShaderResult Generate(MaterialDescriptor materialDescriptor, MaterialGeneratorContext context, string rootMaterialFriendlyName) { if (materialDescriptor == null) { throw new ArgumentNullException("materialDescriptor"); } if (context == null) { throw new ArgumentNullException("context"); } var result = new MaterialShaderResult(); context.Log = result; var material = context.Material; result.Material = context.Material; context.Parameters = material.Parameters; context.PushMaterial(materialDescriptor, rootMaterialFriendlyName); context.PushLayer(); materialDescriptor.Visit(context); context.PopLayer(); context.PopMaterial(); if (!material.Parameters.ContainsKey(MaterialKeys.TessellationShader)) { material.Parameters.Set(MaterialKeys.TessellationShader, null); } material.Parameters.Set(MaterialKeys.VertexStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Vertex)); material.Parameters.Set(MaterialKeys.DomainStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Domain)); material.Parameters.Set(MaterialKeys.PixelStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Pixel)); material.Parameters.Set(MaterialKeys.VertexStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Vertex)); material.Parameters.Set(MaterialKeys.DomainStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Domain)); material.Parameters.Set(MaterialKeys.PixelStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Pixel)); return(result); }
public static MaterialShaderResult Generate(MaterialDescriptor materialDescriptor, MaterialGeneratorContext context = null) { if (materialDescriptor == null) { throw new ArgumentNullException("materialDescriptor"); } var result = new MaterialShaderResult(); if (context == null) { context = new MaterialGeneratorContext(new Material()); } context.Log = result; var material = context.Material; result.Material = context.Material; context.Parameters = material.Parameters; context.PushLayer(); materialDescriptor.Visit(context); context.PopLayer(); material.Parameters.Set(MaterialKeys.VertexStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Vertex)); material.Parameters.Set(MaterialKeys.DomainStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Domain)); material.Parameters.Set(MaterialKeys.PixelStageSurfaceShaders, context.GenerateSurfaceShader(MaterialShaderStage.Pixel)); material.Parameters.Set(MaterialKeys.VertexStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Vertex)); material.Parameters.Set(MaterialKeys.DomainStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Domain)); material.Parameters.Set(MaterialKeys.PixelStageStreamInitializer, context.GenerateStreamInitializer(MaterialShaderStage.Pixel)); return(result); }
/// <summary> /// Generates the for the feature shader. /// </summary> /// <param name="context">The context.</param> public abstract void VisitFeature(MaterialGeneratorContext context);