public void Visit(MaterialGeneratorContext context)
{
var alpha = Alpha ?? new ComputeFloat(0.5f);
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));
var alphaColor = alpha.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.DiffuseSpecularAlphaBlendMap, MaterialKeys.DiffuseSpecularAlphaBlendValue, Color.White));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(new ShaderClassSource("ComputeColorMaterialAlphaBlend"));
mixin.AddComposition("color", alphaColor);
context.SetStream(MaterialShaderStage.Pixel, AlphaBlendStream.Stream, MaterialStreamType.Float2, mixin);
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 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(null);
materialDescriptor.Visit(context);
context.PopLayer();
context.PopMaterial();
material.Parameters.Set(MaterialKeys.VertexStageSurfaceShaders, context.ComputeShaderSource(MaterialShaderStage.Vertex));
material.Parameters.Set(MaterialKeys.DomainStageSurfaceShaders, context.ComputeShaderSource(MaterialShaderStage.Domain));
material.Parameters.Set(MaterialKeys.PixelStageSurfaceShaders, context.ComputeShaderSource(MaterialShaderStage.Pixel));
material.Parameters.Set(MaterialKeys.VertexStageStreamInitializer, context.GenerateStreamInitializers(MaterialShaderStage.Vertex));
material.Parameters.Set(MaterialKeys.DomainStageStreamInitializer, context.GenerateStreamInitializers(MaterialShaderStage.Domain));
material.Parameters.Set(MaterialKeys.PixelStageStreamInitializer, context.GenerateStreamInitializers(MaterialShaderStage.Pixel));
return result;
}
public void Visit(MaterialGeneratorContext context)
{
if (!Enabled)
return;
VisitFeature(context);
}
public override void VisitFeature(MaterialGeneratorContext context)
{
context.SetStream(EmissiveStream.Stream, EmissiveMap, MaterialKeys.EmissiveMap, MaterialKeys.EmissiveValue);
context.SetStream("matEmissiveIntensity", Intensity, MaterialKeys.EmissiveIntensityMap, MaterialKeys.EmissiveIntensity);
context.AddShading(this, new ShaderClassSource("MaterialSurfaceEmissiveShading", UseAlpha));
}
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 virtual void Visit(MaterialGeneratorContext context)
{
// determine if an tessellation material have already been added in another layer
HasAlreadyTessellationFeature = context.GetStreamFinalModifier<MaterialTessellationBaseFeature>(MaterialShaderStage.Domain) != null;
// Notify problem on multiple tessellation techniques and return
if (HasAlreadyTessellationFeature)
{
context.Log.Warning("A material cannot have more than one layer performing tessellation. The first tessellation method found, will be used.");
return;
}
// reset the tessellation stream at the beginning of the stage
context.AddStreamInitializer(MaterialShaderStage.Domain, "MaterialTessellationStream");
// set the desired triangle size desired for this material
context.Parameters.Set(TessellationKeys.DesiredTriangleSize, TriangleSize);
// set the tessellation method and callback to add Displacement/Normal average shaders.
if (AdjacentEdgeAverage && !context.Tags.Get(HasFinalCallback))
{
context.Tags.Set(HasFinalCallback, true);
context.Material.TessellationMethod = ParadoxTessellationMethod.AdjacentEdgeAverage;
context.AddFinalCallback(MaterialShaderStage.Domain, AddAdjacentEdgeAverageMacros);
context.AddFinalCallback(MaterialShaderStage.Domain, AddAdjacentEdgeAverageShaders);
}
}
public ShaderSource Generate(MaterialGeneratorContext context) // (ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
// If we haven't specified a texture use the default implementation
if (RampTexture == null)
return new ShaderClassSource("MaterialCelShadingLightDefault", false);
context.Material.Parameters.Set(MaterialCelShadingLightRampKeys.CelShaderRamp, RampTexture);
return new ShaderClassSource("MaterialCelShadingLightRamp");
}
public override void VisitFeature(MaterialGeneratorContext context)
{
var alpha = Alpha ?? new ComputeFloat(DefaultAlpha);
context.SetStream(AlphaDiscardStream.Stream, alpha, MaterialKeys.AlphaDiscardMap, MaterialKeys.AlphaDiscardValue, new Color(DefaultAlpha));
if (!context.Tags.Get(HasFinalCallback))
{
context.Tags.Set(HasFinalCallback, true);
context.AddFinalCallback(MaterialShaderStage.Pixel, AddDiscardFromLuminance);
}
}
public void Visit(MaterialGeneratorContext context)
{
if (Attributes != null)
{
Attributes.Visit(context);
}
if (Layers != null)
{
Layers.Visit(context);
}
}
public void Visit(MaterialGeneratorContext context)
{
context.SetStream(OcclusionStream.Stream, AmbientOcclusionMap, MaterialKeys.AmbientOcclusionMap, MaterialKeys.AmbientOcclusionValue, Color.White);
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 void AddAdjacentEdgeAverageShaders(MaterialShaderStage stage, MaterialGeneratorContext context)
{
var tessellationShader = context.Parameters.Get(MaterialKeys.TessellationShader) as ShaderMixinSource;
if(tessellationShader == null)
return;
if (context.GetStreamFinalModifier<MaterialDisplacementMapFeature>(MaterialShaderStage.Domain) != null)
{
tessellationShader.Mixins.Add(new ShaderClassSource("TessellationAE2", "TexCoord")); // this suppose Displacement from Texture -> TODO make it more flexible so that it works with any kind of displacement.
tessellationShader.Mixins.Add(new ShaderClassSource("TessellationAE3", "normalWS"));
}
}
public override void VisitFeature(MaterialGeneratorContext context)
{
if (GlossinessMap != null)
{
context.UseStream(MaterialShaderStage.Pixel, GlossinessStream.Stream);
var computeColorSource = GlossinessMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.GlossinessMap, MaterialKeys.GlossinessValue));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceGlossinessMap", Invert));
mixin.AddComposition("glossinessMap", computeColorSource);
context.AddSurfaceShader(MaterialShaderStage.Pixel, mixin);
}
}
public void Visit(MaterialGeneratorContext context)
{
if (MetalnessMap != null)
{
var computeColorSource = MetalnessMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.MetalnessMap, MaterialKeys.MetalnessValue));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceMetalness"));
mixin.AddComposition("metalnessMap", computeColorSource);
context.UseStream(MaterialShaderStage.Pixel, "matSpecular");
context.AddSurfaceShader(MaterialShaderStage.Pixel, mixin);
}
}
/// <summary>
/// Creates a new material from the specified descriptor.
/// </summary>
/// <param name="descriptor">The material descriptor.</param>
/// <returns>An instance of a <see cref="Material"/>.</returns>
/// <exception cref="System.ArgumentNullException">descriptor</exception>
/// <exception cref="System.InvalidOperationException">If an error occurs with the material description</exception>
public static Material New(MaterialDescriptor descriptor)
{
if (descriptor == null) throw new ArgumentNullException("descriptor");
var context = new MaterialGeneratorContext(new Material());
var result = MaterialGenerator.Generate(descriptor, context);
if (result.HasErrors)
{
throw new InvalidOperationException(string.Format("Error when creating the material [{0}]", result.ToText()));
}
return result.Material;
}
public void Visit(MaterialGeneratorContext context)
{
if (DiffuseMap != null)
{
var computeColorSource = DiffuseMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.DiffuseMap, MaterialKeys.DiffuseValue, Color.White));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceDiffuse"));
mixin.AddComposition("diffuseMap", computeColorSource);
context.UseStream(MaterialShaderStage.Pixel, DiffuseStream.Stream);
context.UseStream(MaterialShaderStage.Pixel, ColorBaseStream.Stream);
context.AddSurfaceShader(MaterialShaderStage.Pixel, mixin);
}
}
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 computeColorSource = NormalMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.NormalMap, MaterialKeys.NormalValue, new Color(0x80, 0x80, 0xFF, 0xFF)));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceNormalMap", IsXYNormal, ScaleAndBias));
mixin.AddComposition("normalMap", computeColorSource);
context.AddSurfaceShader(MaterialShaderStage.Pixel, mixin);
}
}
public override void VisitFeature(MaterialGeneratorContext context)
{
base.VisitFeature(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);
}
/// <summary>
/// Initializes a new instance of <see cref="MaterialBlendLayerContext"/>.
/// </summary>
/// <param name="context">The material generator context</param>
/// <param name="parentLayerContext">The parent layer context</param>
/// <param name="blendMap">The blend map used for this layer</param>
public MaterialBlendLayerContext(MaterialGeneratorContext context, MaterialBlendLayerContext parentLayerContext, IComputeScalar blendMap)
{
if (context == null) throw new ArgumentNullException(nameof(context));
Context = context;
Parent = parentLayerContext;
BlendMap = blendMap;
Children = new List<MaterialBlendLayerContext>();
ShadingModels = new MaterialShadingModelCollection();
ContextPerStage = new Dictionary<MaterialShaderStage, MaterialBlendLayerPerStageContext>();
foreach (MaterialShaderStage stage in Enum.GetValues(typeof(MaterialShaderStage)))
{
ContextPerStage[stage] = new MaterialBlendLayerPerStageContext();
}
PendingPixelLayerContext = new MaterialBlendLayerPerStageContext();
}
public override void Visit(MaterialGeneratorContext context)
{
base.Visit(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 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)
{
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);
}
}
/// <summary>
/// Creates a new material from the specified descriptor.
/// </summary>
/// <param name="device"></param>
/// <param name="descriptor">The material descriptor.</param>
/// <returns>An instance of a <see cref="Material"/>.</returns>
/// <exception cref="System.ArgumentNullException">descriptor</exception>
/// <exception cref="System.InvalidOperationException">If an error occurs with the material description</exception>
public static Material New(GraphicsDevice device, MaterialDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
var context = new MaterialGeneratorContext(new Material(), device)
{
GraphicsProfile = device.Features.RequestedProfile,
};
var result = MaterialGenerator.Generate(descriptor, context, string.Format("{0}:RuntimeMaterial", descriptor.MaterialId));
if (result.HasErrors)
{
throw new InvalidOperationException(string.Format("Error when creating the material [{0}]", result.ToText()));
}
return(result.Material);
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var leftShaderSource = LeftChild.GenerateShaderSource(context, baseKeys);
var rightShaderSource = RightChild.GenerateShaderSource(context, baseKeys);
var shaderSource = new ShaderClassSource(GetCorrespondingShaderSourceName(Operator));
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(shaderSource);
if (leftShaderSource != null)
{
mixin.AddComposition(BackgroundCompositionName, leftShaderSource);
}
if (rightShaderSource != null)
{
mixin.AddComposition(ForegroundCompositionName, rightShaderSource);
}
return(mixin);
}
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) as IMaterialDescriptor;
if (material == null)
{
context.Log.Error("Unable to find material [{0}]", Material);
return;
}
// Check that material is valid
var materialName = context.GetAssetFriendlyName(Material);
if (!context.PushMaterial(material, materialName))
{
return;
}
try
{
// TODO: Because we are not fully supporting Streams declaration in shaders, we have to workaround this limitation by using a dynamic shader (inline)
// Push a layer for the sub-material
context.PushOverrides(Overrides);
context.PushLayer(BlendMap);
// Generate the material shaders into the current context
material.Visit(context);
}
finally
{
// Pop the stack
context.PopLayer();
context.PopOverrides();
context.PopMaterial();
}
}
/// <summary>
/// Creates a new material from the specified descriptor.
/// </summary>
/// <param name="device"></param>
/// <param name="descriptor">The material descriptor.</param>
/// <returns>An instance of a <see cref="Material"/>.</returns>
/// <exception cref="System.ArgumentNullException">descriptor</exception>
/// <exception cref="System.InvalidOperationException">If an error occurs with the material description</exception>
public static Material New(GraphicsDevice device, MaterialDescriptor descriptor)
{
if (descriptor == null) throw new ArgumentNullException("descriptor");
var context = new MaterialGeneratorContext(new Material());
var result = MaterialGenerator.Generate(descriptor, context, string.Format("{0}:RuntimeMaterial", descriptor.MaterialId));
if (result.HasErrors)
{
throw new InvalidOperationException(string.Format("Error when creating the material [{0}]", result.ToText()));
}
var material = result.Material;
var blendState = material.Parameters.Get(Graphics.Effect.BlendStateKey);
if (blendState != null && blendState.GraphicsDevice == null)
{
var newState = BlendState.New(device, blendState.Description);
material.Parameters.Set(Effect.BlendStateKey, newState);
}
// TODO: Add other states?
return material;
}
/// <summary>
/// Creates a new material from the specified descriptor.
/// </summary>
/// <param name="device"></param>
/// <param name="descriptor">The material descriptor.</param>
/// <returns>An instance of a <see cref="Material"/>.</returns>
/// <exception cref="System.ArgumentNullException">descriptor</exception>
/// <exception cref="System.InvalidOperationException">If an error occurs with the material description</exception>
public static Material New(GraphicsDevice device, MaterialDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
// The descriptor is not assigned to the material because
// 1) we don't know whether it will mutate and be used to generate another material
// 2) we don't wanna hold on to memory we actually don't need
var context = new MaterialGeneratorContext(new Material(), device)
{
GraphicsProfile = device.Features.RequestedProfile,
};
var result = MaterialGenerator.Generate(descriptor, context, string.Format("{0}:RuntimeMaterial", descriptor.MaterialId));
if (result.HasErrors)
{
throw new InvalidOperationException(string.Format("Error when creating the material [{0}]", result.ToText()));
}
return(result.Material);
}
/// <summary>
/// Creates a new material from the specified descriptor.
/// </summary>
/// <param name="device">The graphics device.</param>
/// <param name="descriptor">The material descriptor.</param>
/// <returns>An instance of a <see cref="Material"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="descriptor"/> is a <c>null</c> reference.</exception>
/// <exception cref="InvalidOperationException">An error has occured with the material description.</exception>
public static Material New(GraphicsDevice device, MaterialDescriptor descriptor)
{
if (descriptor is null)
{
throw new ArgumentNullException(nameof(descriptor));
}
// The descriptor is not assigned to the material because:
// 1) We don't know whether it will mutate and be used to generate another material.
// 2) We don't want to hold on to memory we actually don't need.
var context = new MaterialGeneratorContext(new Material(), device)
{
GraphicsProfile = device.Features.RequestedProfile,
};
var result = MaterialGenerator.Generate(descriptor, context, $"{descriptor.MaterialId}:RuntimeMaterial");
if (result.HasErrors)
{
throw new InvalidOperationException($"Error when creating the material [{result.ToText()}].");
}
return(result.Material);
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var key = context.GetParameterKey(Key ?? baseKeys.ValueBaseKey ?? MaterialKeys.GenericValueColor4);
// Store the color in Linear space
var color = baseKeys.IsColor ? Value.ToColorSpace(context.ColorSpace) : Value;
if (PremultiplyAlpha)
{
color = Color4.PremultiplyAlpha(color);
}
if (key is ParameterKey <Color4> )
{
context.Parameters.Set((ParameterKey <Color4>)key, color);
}
else if (key is ParameterKey <Vector4> )
{
context.Parameters.Set((ParameterKey <Vector4>)key, color);
}
else if (key is ParameterKey <Color3> )
{
context.Parameters.Set((ParameterKey <Color3>)key, (Color3)color);
}
else if (key is ParameterKey <Vector3> )
{
context.Parameters.Set((ParameterKey <Vector3>)key, (Vector3)color);
}
else
{
context.Log.Error("Unexpected ParameterKey [{0}] for type [{0}]. Expecting a [Vector3/Color3] or [Vector4/Color4]", key, key.PropertyType);
}
UsedKey = key;
return(new ShaderClassSource("ComputeColorConstantColorLink", key));
// return new ShaderClassSource("ComputeColorFixed", MaterialUtility.GetAsShaderString(Value));
}
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.AddShaderSource(MaterialShaderStage.Pixel, mixin);
}
}
public void TestMaterial()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
var currentPath = Core.PlatformFolders.ApplicationBinaryDirectory;
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Graphics\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Core"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Lights"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shadows"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\ComputeColors\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Skinning"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shading"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Transformation"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Utils"));
var compilerParameters = new CompilerParameters {
EffectParameters = { Platform = GraphicsPlatform.OpenGL }
};
var layers = new MaterialBlendLayers();
layers.Add(new MaterialBlendLayer
{
BlendMap = new ComputeFloat(0.5f),
Material = AttachedReferenceManager.CreateProxyObject <Material>(AssetId.Empty, "fake")
});
var materialAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color4.White)
},
DiffuseModel = new MaterialDiffuseLambertModelFeature()
},
Layers = layers
};
var fakeAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color.Blue)
},
}
};
var context = new MaterialGeneratorContext {
FindAsset = reference => fakeAsset
};
var result = MaterialGenerator.Generate(new MaterialDescriptor {
Attributes = materialAsset.Attributes, Layers = materialAsset.Layers
}, context, "TestMaterial");
compilerParameters.Set(MaterialKeys.PixelStageSurfaceShaders, result.Material.Parameters.Get(MaterialKeys.PixelStageSurfaceShaders));
var directionalLightGroup = new ShaderClassSource("LightDirectionalGroup", 1);
compilerParameters.Set(LightingKeys.DirectLightGroups, new ShaderSourceCollection {
directionalLightGroup
});
//compilerParameters.Set(LightingKeys.CastShadows, false);
//compilerParameters.Set(MaterialParameters.HasSkinningPosition, true);
//compilerParameters.Set(MaterialParameters.HasSkinningNormal, true);
compilerParameters.Set(MaterialKeys.HasNormalMap, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("XenkoEffectBase"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
// TODO: Use a generated UsedTexcoordIndex when backing textures
var usedTexcoord = "TEXCOORD" + MaterialUtility.GetTextureIndex(TexcoordIndex);
var textureKey = context.GetTextureKey(this, baseKeys);
var samplerKey = context.GetSamplerKey(Sampler);
UsedKey = textureKey;
var scale = Scale;
var scaleFactor = context.CurrentOverrides.UVScale;
if (scaleFactor != Vector2.One)
{
scale *= scaleFactor;
}
var channelStr = GetTextureChannelAsString();
// "TTEXTURE", "TStream"
ShaderClassSource shaderSource;
// TODO: Workaround bad to have to copy all the new ShaderClassSource(). Check how to improve this
if (context.OptimizeMaterials)
{
var scaleStr = MaterialUtility.GetAsShaderString(scale);
var offsetStr = MaterialUtility.GetAsShaderString(Offset);
// If materials are optimized, we precompute best shader combination (note: will generate shader permutations!)
if (context.IsNotPixelStage)
{
if (Offset != Vector2.Zero)
{
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledOffsetSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, offsetStr, 0.0f);
}
else if (scale != Vector2.One)
{
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, 0.0f);
}
else
{
shaderSource = new ShaderClassSource("ComputeColorTextureLodSampler", textureKey, usedTexcoord, samplerKey, channelStr, 0.0f);
}
}
else
{
if (Offset != Vector2.Zero)
{
shaderSource = new ShaderClassSource("ComputeColorTextureScaledOffsetSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, offsetStr);
}
else if (scale != Vector2.One)
{
shaderSource = new ShaderClassSource("ComputeColorTextureScaledSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr);
}
else
{
shaderSource = new ShaderClassSource("ComputeColorTextureSampler", textureKey, usedTexcoord, samplerKey, channelStr);
}
}
}
else
{
// Try to avoid shader permutations, by putting UV scaling/offset in shader parameters
var textureScale = (ParameterKey <Vector2>)context.GetParameterKey(MaterialKeys.TextureScale);
var textureOffset = (ParameterKey <Vector2>)context.GetParameterKey(MaterialKeys.TextureOffset);
context.Parameters.Set(textureScale, scale);
context.Parameters.Set(textureOffset, Offset);
if (context.IsNotPixelStage)
{
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledOffsetDynamicSampler", textureKey, usedTexcoord, samplerKey, channelStr, textureScale, textureOffset, 0.0f);
}
else
{
shaderSource = new ShaderClassSource("ComputeColorTextureScaledOffsetDynamicSampler", textureKey, usedTexcoord, samplerKey, channelStr, textureScale, textureOffset);
}
}
return(shaderSource);
}
public void Visit(MaterialGeneratorContext context)
{
MainTexture.Visit(context);
DissolveTexture.Visit(context);
DissolveStrength.Visit(context);
}
public void TestMaterial()
{
var compiler = new EffectCompiler { UseFileSystem = true };
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Graphics\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Engine\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Core");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Lights");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Materials");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shadows");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\ComputeColor");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Skinning");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shading");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Transformation");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Utils");
var compilerParameters = new CompilerParameters { Platform = GraphicsPlatform.Direct3D11 };
var layers = new MaterialBlendLayers();
layers.Add(new MaterialBlendLayer
{
BlendMap = new ComputeFloat(0.5f),
Material = AttachedReferenceManager.CreateSerializableVersion<Material>(Guid.Empty, "fake")
});
var materialAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color4.White)
},
DiffuseModel = new MaterialDiffuseLambertModelFeature()
},
Layers = layers
};
var fakeAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color.Blue)
},
}
};
var context = new MaterialGeneratorContext { FindAsset = reference => fakeAsset };
var result = MaterialGenerator.Generate(new MaterialDescriptor { Attributes = materialAsset.Attributes, Layers = materialAsset.Layers }, context, "TestMaterial");
compilerParameters.Set(MaterialKeys.PixelStageSurfaceShaders, result.Material.Parameters.Get(MaterialKeys.PixelStageSurfaceShaders));
var directionalLightGroup = new ShaderClassSource("LightDirectionalGroup", 1);
compilerParameters.Set(LightingKeys.DirectLightGroups, new List<ShaderSource> { directionalLightGroup });
//compilerParameters.Set(LightingKeys.CastShadows, false);
//compilerParameters.Set(MaterialParameters.HasSkinningPosition, true);
//compilerParameters.Set(MaterialParameters.HasSkinningNormal, true);
compilerParameters.Set(MaterialKeys.HasNormalMap, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("ParadoxEffectBase"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public void Visit(MaterialGeneratorContext context)
{
}
public void Visit(MaterialGeneratorContext context)
{
Amplitude.Visit(context);
Frequency.Visit(context);
Speed.Visit(context);
}
public override void Visit(MaterialGeneratorContext context)
{
base.Visit(context);
WobbleStrength.Visit(context);
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
// Reduce trees on CPU
//var materialReducer = new MaterialTreeReducer(material);
//materialReducer.ReduceTrees();
//foreach (var reducedTree in materialReducer.ReducedTrees)
//{
// material.Nodes[reducedTree.Key] = reducedTree.Value;
//}
// Reduce on GPU
// TODO: Adapt GPU reduction so that it is compatible Android color/alpha separation
// TODO: Use the build engine processed output textures instead of the imported one (not existing any more)
// TODO: Set the reduced texture output format
// TODO: The graphics device cannot be shared with the Previewer
//var graphicsDevice = (GraphicsDevice)context.Attributes.GetOrAdd(CompilerContext.GraphicsDeviceKey, key => GraphicsDevice.New(DeviceCreationFlags.None, GraphicsProfile.Level_11_0));
//using (var materialTextureLayerFlattener = new MaterialTextureLayerFlattener(material, graphicsDevice))
//{
// materialTextureLayerFlattener.PrepareForFlattening(new UDirectory(assetUrl.Directory));
// if (materialTextureLayerFlattener.HasCommands)
// {
// var compiler = EffectCompileCommand.GetOrCreateEffectCompiler(context);
// materialTextureLayerFlattener.Run(compiler);
// // store Material with modified textures
// material = materialTextureLayerFlattener.Material;
// }
//}
// Check with Ben why DoCommandOverride is called without going through the constructor?
var assetManager = new ContentManager(MicrothreadLocalDatabases.ProviderService);
var materialContext = new MaterialGeneratorContext
{
GraphicsProfile = graphicsProfile,
Content = assetManager,
ColorSpace = colorSpace
};
materialContext.AddLoadingFromSession(AssetFinder);
var materialClone = AssetCloner.Clone(Parameters);
var result = MaterialGenerator.Generate(new MaterialDescriptor {
MaterialId = materialClone.Id, Attributes = materialClone.Attributes, Layers = materialClone.Layers
}, materialContext, string.Format("{0}:{1}", materialClone.Id, assetUrl));
if (result.HasErrors)
{
result.CopyTo(commandContext.Logger);
return(Task.FromResult(ResultStatus.Failed));
}
// Separate the textures into color/alpha components on Android to be able to use native ETC1 compression
//if (context.Platform == PlatformType.Android)
//{
// var alphaComponentSplitter = new TextureAlphaComponentSplitter(assetItem.Package.Session);
// material = alphaComponentSplitter.Run(material, new UDirectory(assetUrl.GetDirectory())); // store Material with alpha substituted textures
//}
// Create the parameters
//var materialParameterCreator = new MaterialParametersCreator(material, assetUrl);
//if (materialParameterCreator.CreateParameterCollectionData(commandContext.Logger))
// return Task.FromResult(ResultStatus.Failed);
assetManager.Save(assetUrl, result.Material);
return(Task.FromResult(ResultStatus.Successful));
}
public void Visit(MaterialGeneratorContext context)
{
isBlackAndWhiteBuffer ??= GraphicsBuffer.New(context.GraphicsDevice, IsBlackAndWhite, GraphicsBufferFlags.ConstantBuffer, GraphicsHeapType.Upload).DisposeBy(context.GraphicsDevice);
context.ConstantBufferViews.Add(isBlackAndWhiteBuffer);
}
public void Visit(MaterialGeneratorContext context)
{
isBlackAndWhiteBuffer ??= GraphicsBuffer.Constant.New(context.GraphicsDevice, IsBlackAndWhite).DisposeBy(context.GraphicsDevice);
context.ConstantBufferViews.Add(isBlackAndWhiteBuffer);
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
if (string.IsNullOrEmpty(MixinReference))
{
return(new ShaderClassSource("ComputeColor"));
}
var mixinName = MixinReference;
object[] generics = null;
if (Generics.Count > 0)
{
// TODO: correct generic order
var mixinGenerics = new List <object>();
foreach (var genericKey in Generics.Keys)
{
var generic = Generics[genericKey];
if (generic is ComputeColorParameterTexture)
{
var textureParameter = ((ComputeColorParameterTexture)generic);
var textureKey = context.GetTextureKey(textureParameter.Texture, baseKeys);
mixinGenerics.Add(textureKey.ToString());
}
else if (generic is ComputeColorParameterSampler)
{
var pk = context.GetSamplerKey((ComputeColorParameterSampler)generic);
mixinGenerics.Add(pk.ToString());
}
else if (generic is ComputeColorParameterFloat)
{
mixinGenerics.Add(((ComputeColorParameterFloat)generic).Value.ToString(CultureInfo.InvariantCulture));
}
else if (generic is ComputeColorParameterInt)
{
mixinGenerics.Add(((ComputeColorParameterInt)generic).Value.ToString(CultureInfo.InvariantCulture));
}
else if (generic is ComputeColorParameterFloat2)
{
mixinGenerics.Add(MaterialUtility.GetAsShaderString(((ComputeColorParameterFloat2)generic).Value));
}
else if (generic is ComputeColorParameterFloat3)
{
mixinGenerics.Add(MaterialUtility.GetAsShaderString(((ComputeColorParameterFloat3)generic).Value));
}
else if (generic is ComputeColorParameterFloat4)
{
mixinGenerics.Add(MaterialUtility.GetAsShaderString(((ComputeColorParameterFloat4)generic).Value));
}
else if (generic is ComputeColorStringParameter)
{
mixinGenerics.Add(((ComputeColorStringParameter)generic).Value);
}
else
{
throw new Exception("[Material] Unknown node type: " + generic.GetType());
}
}
generics = mixinGenerics.ToArray();
}
var shaderClassSource = new ShaderClassSource(mixinName, generics);
if (CompositionNodes.Count == 0)
{
return(shaderClassSource);
}
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(shaderClassSource);
foreach (var comp in CompositionNodes)
{
if (comp.Value != null)
{
var compShader = comp.Value.GenerateShaderSource(context, baseKeys);
if (compShader != null)
{
mixin.Compositions.Add(comp.Key, compShader);
}
}
}
return(mixin);
}
public override ShaderSource GenerateShaderFromFallbackValue(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
return FallbackValue.GenerateShaderSource(context, baseKeys);
}
public abstract ShaderSource GenerateShaderFromFallbackValue(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys);
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var channel = GetColorChannelAsString();
return(Stream == null || string.IsNullOrWhiteSpace(Stream.GetSemanticName()) ? new ShaderClassSource("ComputeColor") : new ShaderClassSource("ComputeColorFromStream", Stream.GetSemanticName(), channel));
}
private void AddDiffuseSpecularAlphaBlendColor(MaterialShaderStage stage, MaterialGeneratorContext context)
{
context.AddSurfaceShader(MaterialShaderStage.Pixel, new ShaderClassSource("MaterialSurfaceDiffuseSpecularAlphaBlendColor"));
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
if (!Enabled || Texture == null) // generate shader from default value when the texture is null or disabled
return GenerateShaderFromFallbackValue(context, baseKeys);
// generate shader from the texture
// TODO: Use a generated UsedTexcoordIndex when backing textures
var usedTexcoord = "TEXCOORD" + MaterialUtility.GetTextureIndex(TexcoordIndex);
var textureKey = context.GetTextureKey(this, baseKeys);
var samplerKey = context.GetSamplerKey(Sampler);
UsedKey = textureKey;
var scale = Scale;
var scaleFactor = context.CurrentOverrides.UVScale;
if (scaleFactor != Vector2.One)
{
scale *= scaleFactor;
}
var channelStr = GetTextureChannelAsString();
// "TTEXTURE", "TStream"
ShaderClassSource shaderSource;
// TODO: Workaround bad to have to copy all the new ShaderClassSource(). Check how to improve this
if (context.OptimizeMaterials)
{
var scaleStr = MaterialUtility.GetAsShaderString(scale);
var offsetStr = MaterialUtility.GetAsShaderString(Offset);
// If materials are optimized, we precompute best shader combination (note: will generate shader permutations!)
if (context.IsNotPixelStage)
{
if (Offset != Vector2.Zero)
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledOffsetSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, offsetStr, 0.0f);
else if (scale != Vector2.One)
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, 0.0f);
else
shaderSource = new ShaderClassSource("ComputeColorTextureLodSampler", textureKey, usedTexcoord, samplerKey, channelStr, 0.0f);
}
else
{
if (Offset != Vector2.Zero)
shaderSource = new ShaderClassSource("ComputeColorTextureScaledOffsetSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr, offsetStr);
else if (scale != Vector2.One)
shaderSource = new ShaderClassSource("ComputeColorTextureScaledSampler", textureKey, usedTexcoord, samplerKey, channelStr, scaleStr);
else
shaderSource = new ShaderClassSource("ComputeColorTextureSampler", textureKey, usedTexcoord, samplerKey, channelStr);
}
}
else
{
// Try to avoid shader permutations, by putting UV scaling/offset in shader parameters
var textureScale = (ParameterKey<Vector2>)context.GetParameterKey(MaterialKeys.TextureScale);
var textureOffset = (ParameterKey<Vector2>)context.GetParameterKey(MaterialKeys.TextureOffset);
context.Parameters.Set(textureScale, scale);
context.Parameters.Set(textureOffset, Offset);
if (context.IsNotPixelStage)
{
shaderSource = new ShaderClassSource("ComputeColorTextureLodScaledOffsetDynamicSampler", textureKey, usedTexcoord, samplerKey, channelStr, textureScale, textureOffset, 0.0f);
}
else
{
shaderSource = new ShaderClassSource("ComputeColorTextureScaledOffsetDynamicSampler", textureKey, usedTexcoord, samplerKey, channelStr, textureScale, textureOffset);
}
}
return shaderSource;
}
public void Visit(MaterialGeneratorContext context)
{
Attributes.Visit(context);
Layers.Visit(context);
}
/// <summary> /// Generates the shader source equivalent for this node /// </summary> /// <returns>ShaderSource.</returns> public abstract ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys);
public override ShaderSource GenerateShaderFromFallbackValue(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
return(FallbackValue.GenerateShaderSource(context, baseKeys));
}
public void TestMaterial()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Graphics\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Engine\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Core");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Lights");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Materials");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shadows");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\ComputeColor");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Skinning");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shading");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Transformation");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Utils");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.Direct3D11
};
var layers = new MaterialBlendLayers();
layers.Add(new MaterialBlendLayer
{
BlendMap = new ComputeFloat(0.5f),
Material = AttachedReferenceManager.CreateSerializableVersion <Material>(Guid.Empty, "fake")
});
var materialAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color4.White)
},
DiffuseModel = new MaterialDiffuseLambertModelFeature()
},
Layers = layers
};
var fakeAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color.Blue)
},
}
};
var context = new MaterialGeneratorContext {
FindAsset = reference => fakeAsset
};
var result = MaterialGenerator.Generate(new MaterialDescriptor {
Attributes = materialAsset.Attributes, Layers = materialAsset.Layers
}, context, "TestMaterial");
compilerParameters.Set(MaterialKeys.PixelStageSurfaceShaders, result.Material.Parameters.Get(MaterialKeys.PixelStageSurfaceShaders));
var directionalLightGroup = new ShaderClassSource("LightDirectionalGroup", 1);
compilerParameters.Set(LightingKeys.DirectLightGroups, new List <ShaderSource> {
directionalLightGroup
});
//compilerParameters.Set(LightingKeys.CastShadows, false);
//compilerParameters.Set(MaterialParameters.HasSkinningPosition, true);
//compilerParameters.Set(MaterialParameters.HasSkinningNormal, true);
compilerParameters.Set(MaterialKeys.HasNormalMap, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("ParadoxEffectBase"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public void Visit(MaterialGeneratorContext context)
{
RampFunction.Visit(context);
}
public override ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var channel = GetColorChannelAsString();
return Stream == null || string.IsNullOrWhiteSpace(Stream.GetSemanticName()) ? new ShaderClassSource("ComputeColor") : new ShaderClassSource("ComputeColorFromStream", Stream.GetSemanticName(), channel);
}
private void AddDiffuseSpecularAlphaBlendColor(MaterialShaderStage stage, MaterialGeneratorContext context)
{
context.AddShaderSource(MaterialShaderStage.Pixel, new ShaderClassSource("MaterialSurfaceDiffuseSpecularAlphaBlendColor"));
}
