private void BlendShadingModel(MaterialBlendLayerContext parent, MaterialBlendLayerPerStageContext pendingPixelLayerContext, MaterialBlendLayerPerStageContext parentPixelLayerContext)
{
var shaderBlendingSource = new ShaderMixinSource();
shaderBlendingSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingBlend"));
parent.SetStreamBlend(MaterialShaderStage.Pixel, parent.BlendMapForShadingModel);
// Add shader source already setup for the parent
foreach (var shaderSource in pendingPixelLayerContext.ShaderSources)
{
shaderBlendingSource.AddCompositionToArray("layers", shaderSource);
}
// Add shader source generated for blending this layer
foreach (var shaderSource in parent.ShadingModels.Generate(this))
{
shaderBlendingSource.AddCompositionToArray("layers", shaderSource);
}
parent.ShadingModels.Clear();
parentPixelLayerContext.ShaderSources.Add(shaderBlendingSource);
pendingPixelLayerContext.Reset();
parent.BlendMapForShadingModel = null;
}
public ShaderSource GetSource(RenderVoxelVolumeData data)
{
var writermixin = new ShaderMixinSource();
writermixin.Mixins.Add(storage);
foreach (var attr in data.AttributeIndirect)
{
writermixin.AddCompositionToArray("AttributesIndirect", attr);
}
foreach (var attr in data.AttributeModifiers)
{
writermixin.AddCompositionToArray("Modifiers", attr);
}
return(writermixin);
}
private void Generate(MaterialShaderStage stage, MaterialGeneratorContext context)
{
if (!context.HasSurfaceShaders(stage))
{
return;
}
// Blend setup for this layer
context.SetStream(stage, BlendStream, BlendMap, MaterialKeys.BlendMap, MaterialKeys.BlendValue);
// Generate a dynamic shader name
// Create a mixin
var shaderMixinSource = new ShaderMixinSource();
shaderMixinSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceStreamsBlend"));
// Add all streams
foreach (var stream in context.Streams[stage])
{
shaderMixinSource.AddCompositionToArray("blends", context.GetStreamBlendShaderSource(stream));
}
var materialBlendLayerMixin = context.GenerateSurfaceShader(stage);
// Add the shader to the mixin
shaderMixinSource.AddComposition("layer", materialBlendLayerMixin);
context.ResetSurfaceShaders(stage);
context.AddSurfaceShader(stage, shaderMixinSource);
}
/// <summary>
/// Squash <see cref="ShaderSources"/> to a single ShaderSource (compatible with IComputeColor)
/// </summary>
/// <returns>The squashed <see cref="ShaderSource"/> or null if nothing to squash</returns>
public ShaderSource ComputeShaderSource()
{
if (ShaderSources.Count == 0)
{
return(null);
}
ShaderSource result;
// If there is only a single op, don't generate a mixin
if (ShaderSources.Count == 1)
{
result = ShaderSources[0];
}
else
{
var mixin = new ShaderMixinSource();
result = mixin;
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceArray"));
// Squash all operations into MaterialLayerArray
foreach (var operation in ShaderSources)
{
mixin.AddCompositionToArray("layers", operation);
}
}
return(result);
}
public ShaderSource GenerateSurfaceShader(MaterialShaderStage stage)
{
var surfaceShaders = GetSurfaceShaders(stage);
if (surfaceShaders.Count == 0)
{
return(null);
}
ShaderSource result;
// If there is only a single op, don't generate a mixin
if (surfaceShaders.Count == 1)
{
result = surfaceShaders[0];
}
else
{
var mixin = new ShaderMixinSource();
result = mixin;
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceArray"));
// Squash all operations into MaterialLayerArray
foreach (var operation in surfaceShaders)
{
mixin.AddCompositionToArray("layers", operation);
}
}
surfaceShaders.Clear();
Streams[stage].Clear();
return(result);
}
/// <summary>
/// Squash <see cref="ShaderSources"/> to a single ShaderSource (compatible with IComputeColor)
/// </summary>
/// <returns>The squashed <see cref="ShaderSource"/> or null if nothing to squash</returns>
public ShaderSource ComputeShaderSource()
{
if (ShaderSources.Count == 0)
{
return null;
}
ShaderSource result;
// If there is only a single op, don't generate a mixin
if (ShaderSources.Count == 1)
{
result = ShaderSources[0];
}
else
{
var mixin = new ShaderMixinSource();
result = mixin;
mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceArray"));
// Squash all operations into MaterialLayerArray
foreach (var operation in ShaderSources)
{
mixin.AddCompositionToArray("layers", operation);
}
}
return result;
}
public ShaderSource GetVoxelizationShader(VoxelizationPass pass, ProcessedVoxelVolume data)
{
bool singleClip = UpdatesOneClipPerFrame();
ShaderSource VoxelizationMethodSource = pass.method.GetVoxelizationShader();
ShaderMixinSource cachedMixin = new ShaderMixinSource();
cachedMixin.Mixins.Add(storage);
cachedMixin.AddComposition("method", VoxelizationMethodSource);
if (singleClip)
{
cachedMixin.AddMacro("singleClip", true);
}
string IndirectStoreMacro = "";
for (int i = 0; i < pass.AttributesIndirect.Count; i++)
{
string iStr = i.ToString();
IndirectStoreMacro += $"AttributesIndirect[{iStr}].IndirectWrite(fragmentsBuffer, writeindex + {pass.AttributesIndirect[i].BufferOffset});\n";
}
cachedMixin.AddMacro("IndirectStoreMacro", IndirectStoreMacro);
foreach (var attr in pass.AttributesTemp)
{
cachedMixin.AddCompositionToArray("AttributesTemp", attr.GetVoxelizationShader());
}
foreach (var attr in pass.AttributesDirect)
{
cachedMixin.AddCompositionToArray("AttributesDirect", attr.GetVoxelizationShader());
}
foreach (var attr in pass.AttributesIndirect)
{
cachedMixin.AddCompositionToArray("AttributesIndirect", attr.GetVoxelizationShader());
}
return(cachedMixin);
}
public ShaderSource GetShaderFloat4(List <IVoxelModifierEmissionOpacity> modifiers)
{
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(writer);
StorageMethod.Apply(mixin);
foreach (var attr in modifiers)
{
ShaderSource applier = attr.GetApplier("Anisotropic");
if (applier != null)
{
mixin.AddCompositionToArray("Modifiers", applier);
}
}
return(mixin);
}
virtual public ShaderSource GetVoxelizationShader(List <VoxelModifierEmissionOpacity> modifiers)
{
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(Writer);
StorageMethod.Apply(mixin);
foreach (var modifier in modifiers)
{
if (!modifier.Enabled)
{
continue;
}
ShaderSource applier = modifier.GetApplier(ApplierKey);
if (applier != null)
{
mixin.AddCompositionToArray("Modifiers", applier);
}
}
return(mixin);
}
private void BlendStreams(MaterialBlendLayerContext layer)
{
// Generate Vertex and Pixel surface shaders
foreach (MaterialShaderStage stage in Enum.GetValues(typeof(MaterialShaderStage)))
{
// If we don't have any stream set, we have nothing to blend
var stageContext = layer.GetContextPerStage(stage);
if (stageContext.Streams.Count == 0)
{
continue;
}
// Blend setup for this layer
layer.SetStreamBlend(stage, layer.BlendMap);
// Generate a dynamic shader name
// Create a mixin
var shaderMixinSource = new ShaderMixinSource();
shaderMixinSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceStreamsBlend"));
// Add all streams that we need to blend
foreach (var stream in stageContext.Streams)
{
shaderMixinSource.AddCompositionToArray("blends", GetStreamBlendShaderSource(stream));
}
stageContext.Streams.Clear();
// Squash all ShaderSources to a single shader source
var materialBlendLayerMixin = stageContext.ComputeShaderSource();
stageContext.ShaderSources.Clear();
// Add the shader to the mixin
shaderMixinSource.AddComposition("layer", materialBlendLayerMixin);
// Squash the shader sources
stageContext.ShaderSources.Add(shaderMixinSource);
}
}
public void PopLayer()
{
// If current shading model is not set,
if (CurrentShadingModel == null && Current.ShadingModels.Count > 0)
{
CurrentShadingModel = Current.ShadingModels;
}
var sameShadingModel = Current.ShadingModels.Equals(CurrentShadingModel);
if (!sameShadingModel)
{
shadingModelCount++;
}
var shouldBlendShadingModels = CurrentShadingModel != null && (!sameShadingModel || Current.Parent == null); // current shading model different from next shading model
// --------------------------------------------------------------------
// Copy the shading surfaces and the stream initializer to the parent.
// --------------------------------------------------------------------
if (Current.Parent != null)
{
foreach (MaterialShaderStage stage in Enum.GetValues(typeof(MaterialShaderStage)))
{
// the initializers
Current.Parent.StreamInitializers[stage].AddRange(Current.StreamInitializers[stage]);
// skip pixel shader if shading model need to be blended
if (stage == MaterialShaderStage.Pixel && shouldBlendShadingModels)
{
continue;
}
// the surface shaders
Current.Parent.SurfaceShaders[stage].AddRange(Current.SurfaceShaders[stage]);
}
}
// -------------------------------------------------
// Blend shading models between layers if necessary
// -------------------------------------------------
if (shouldBlendShadingModels)
{
var shadingSources = CurrentShadingModel.Generate(this);
// If we are in a multi-shading-blending, only blend shading models after 1st shading model
if (shadingModelCount > 1)
{
var shaderBlendingSource = new ShaderMixinSource();
shaderBlendingSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceBlendShading"));
foreach (var shaderSource in shadingSources)
{
shaderBlendingSource.AddCompositionToArray("layers", shaderSource);
}
shadingSources = new List <ShaderSource>()
{
shaderBlendingSource
};
}
var currentOrParentLayer = Current.Parent ?? Current;
foreach (var shaderSource in shadingSources)
{
currentOrParentLayer.SurfaceShaders[MaterialShaderStage.Pixel].Add(shaderSource);
}
}
// In case of the root material, add all stream modifiers just at the end and call final callbacks
if (Current.Parent == null)
{
foreach (var modifierKey in inputStreamModifiers.Keys)
{
Current.SurfaceShaders[modifierKey.Key].Add(inputStreamModifiers[modifierKey]);
}
// Clear final callback
foreach (var callbackKeyPair in finalCallbacks)
{
var stage = callbackKeyPair.Key;
var callbacks = callbackKeyPair.Value;
foreach (var callback in callbacks)
{
callback(stage, this);
}
callbacks.Clear();
}
}
// ----------------------------------------------
// Pop to Parent and set Current
// ----------------------------------------------
if (Current.Parent != null && !sameShadingModel)
{
CurrentShadingModel = Current.ShadingModels;
}
if (Current.Parent != null)
{
Current = Current.Parent;
}
}
private void Generate(MaterialShaderStage stage, MaterialGeneratorContext context)
{
if (!context.HasSurfaceShaders(stage))
{
return;
}
// Blend setup for this layer
context.SetStream(stage, BlendStream, BlendMap, MaterialKeys.BlendMap, MaterialKeys.BlendValue);
// Generate a dynamic shader name
// Create a mixin
var shaderMixinSource = new ShaderMixinSource();
shaderMixinSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceStreamsBlend"));
// Add all streams
foreach (var stream in context.Streams[stage])
{
shaderMixinSource.AddCompositionToArray("blends", context.GetStreamBlendShaderSource(stream));
}
var materialBlendLayerMixin = context.GenerateSurfaceShader(stage);
// Add the shader to the mixin
shaderMixinSource.AddComposition("layer", materialBlendLayerMixin);
context.ResetSurfaceShaders(stage);
context.AddSurfaceShader(stage, shaderMixinSource);
}
private void ProcessIntermediateLayer(MaterialBlendLayerContext layer, bool isLastChild)
{
var parent = layer.Parent;
var hasParentShadingModel = parent.ShadingModelCount > 0;
// If current shading model is not set,
if (!hasParentShadingModel && layer.ShadingModelCount > 0)
{
layer.ShadingModels.CopyTo(parent.ShadingModels);
hasParentShadingModel = true;
parent.ShadingModelCount++;
}
var sameShadingModel = hasParentShadingModel && layer.ShadingModels.Equals(parent.ShadingModels);
if (sameShadingModel)
{
// If shading model is not changing, we generate the BlendStream shaders
BlendStreams(layer);
}
else
{
parent.ShadingModelCount++;
}
var parentPixelLayerContext = parent.GetContextPerStage(MaterialShaderStage.Pixel);
var pendingPixelLayerContext = parent.PendingPixelLayerContext;
// Copy streams to parent
foreach (MaterialShaderStage stage in Enum.GetValues(typeof(MaterialShaderStage)))
{
var stageContext = layer.GetContextPerStage(stage);
var parentStageContext = parent.GetContextPerStage(stage);
// the Initializers
parentStageContext.StreamInitializers.AddRange(stageContext.StreamInitializers);
// skip pixel shader if shading model need to be blended
if (stage == MaterialShaderStage.Pixel)
{
if (!sameShadingModel)
{
continue;
}
// If same shading model, use temporarely the ParentPixelLayerContext
parentStageContext = pendingPixelLayerContext;
}
// Add shaders except Pixels if we have a different ShadingModel
parentStageContext.ShaderSources.AddRange(stageContext.ShaderSources);
}
var forceBlendingShadingModel = isLastChild && (parent.ShadingModelCount > 1 || !sameShadingModel);
if (!sameShadingModel || forceBlendingShadingModel)
{
if (forceBlendingShadingModel && parent.BlendMapForShadingModel == null)
{
if (!sameShadingModel)
{
foreach (var shaderSource in pendingPixelLayerContext.ShaderSources)
{
parentPixelLayerContext.ShaderSources.Add(shaderSource);
}
pendingPixelLayerContext.Reset();
foreach (var shaderSource in parent.ShadingModels.Generate(this))
{
parentPixelLayerContext.ShaderSources.Add(shaderSource);
}
parent.ShadingModels.Clear();
layer.ShadingModels.CopyTo(parent.ShadingModels);
}
parent.BlendMapForShadingModel = layer.BlendMap;
var currentPixelLayerContext = layer.GetContextPerStage(MaterialShaderStage.Pixel);
pendingPixelLayerContext.ShaderSources.AddRange(currentPixelLayerContext.ShaderSources);
}
// Do we need to blend shading model?
if (parent.BlendMapForShadingModel != null)
{
var shaderBlendingSource = new ShaderMixinSource();
shaderBlendingSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingBlend"));
parent.SetStreamBlend(MaterialShaderStage.Pixel, parent.BlendMapForShadingModel);
// Add shader source already setup for the parent
foreach (var shaderSource in pendingPixelLayerContext.ShaderSources)
{
shaderBlendingSource.AddCompositionToArray("layers", shaderSource);
}
// Add shader source generated for blending this layer
foreach (var shaderSource in parent.ShadingModels.Generate(this))
{
shaderBlendingSource.AddCompositionToArray("layers", shaderSource);
}
parent.ShadingModels.Clear();
parentPixelLayerContext.ShaderSources.Add(shaderBlendingSource);
pendingPixelLayerContext.Reset();
parent.BlendMapForShadingModel = null;
}
else
{
foreach (var shaderSource in pendingPixelLayerContext.ShaderSources)
{
parentPixelLayerContext.ShaderSources.Add(shaderSource);
}
pendingPixelLayerContext.Reset();
foreach (var shaderSource in parent.ShadingModels.Generate(this))
{
parentPixelLayerContext.ShaderSources.Add(shaderSource);
}
parent.ShadingModels.Clear();
parent.BlendMapForShadingModel = layer.BlendMap;
// Copy the shading model of this layer to the parent
layer.ShadingModels.CopyTo(parent.ShadingModels);
}
// If the shading model is different, the current attributes of the layer are not part of this blending
// So they will contribute to the next blending
if (!sameShadingModel && !forceBlendingShadingModel)
{
var currentPixelLayerContext = layer.GetContextPerStage(MaterialShaderStage.Pixel);
pendingPixelLayerContext.ShaderSources.AddRange(currentPixelLayerContext.ShaderSources);
}
}
}