public override ShaderSource GenerateShaderFromFallbackValue(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
return(FallbackValue?.GenerateShaderSource(context, baseKeys));
}
public abstract ShaderSource GenerateShaderFromFallbackValue(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys);
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
if (!Enabled || Texture == null) // generate shader from default value when the texture is null or disabled
{
var fallbackValue = GenerateShaderFromFallbackValue(context, baseKeys);
if (fallbackValue != null)
{
return(fallbackValue);
}
}
// 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 = (ValueParameterKey <Vector2>)context.GetParameterKey(MaterialKeys.TextureScale);
var textureOffset = (ValueParameterKey <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 override ShaderSource GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var key = (ValueParameterKey <float>)context.GetParameterKey(Key ?? baseKeys.ValueBaseKey ?? MaterialKeys.GenericValueFloat);
context.Parameters.Set(key, Value);
UsedKey = key;
return(new ShaderClassSource("ComputeColorConstantFloatLink", key));
}
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
return(new ShaderClassSource("ComputeSphericalHarmonics", 5));
}
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 = Value.ToLinear();
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));
}
/// <summary> /// Generates the shader source equivalent for this node /// </summary> /// <returns>ShaderSource.</returns> public abstract ShaderSource GenerateShaderSource(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys);
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext 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 GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var channel = GetColorChannelAsString();
return(Stream == null || string.IsNullOrWhiteSpace(Stream.GetSemanticName()) ? new ShaderClassSource("ComputeColor") : new ShaderClassSource("ComputeColorFromStream", Stream.GetSemanticName(), channel));
}
public override ShaderSource GenerateShaderFromFallbackValue(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
return FallbackValue.GenerateShaderSource(context, baseKeys);
}
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext 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);
}
/// <summary> /// Generates the shader source equivalent for this node /// </summary> /// <returns>ShaderSource.</returns> public abstract ShaderSource GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys);
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 abstract ShaderSource GenerateShaderFromFallbackValue(MaterialGeneratorContext context, MaterialComputeColorKeys baseKeys);
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext 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 ValueParameterKey <Color4> )
{
context.Parameters.Set((ValueParameterKey <Color4>)key, color);
}
else if (key is ValueParameterKey <Vector4> )
{
context.Parameters.Set((ValueParameterKey <Vector4>)key, color);
}
else if (key is ValueParameterKey <Color3> )
{
context.Parameters.Set((ValueParameterKey <Color3>)key, (Color3)color);
}
else if (key is ValueParameterKey <Vector3> )
{
context.Parameters.Set((ValueParameterKey <Vector3>)key, (Vector3)color);
}
else
{
context.Log.Error($"Unexpected ParameterKey [{key}] for type [{key.PropertyType}]. Expecting a [Vector3/Color3] or [Vector4/Color4]");
}
UsedKey = key;
return(new ShaderClassSource("ComputeColorConstantColorLink", key));
// return new ShaderClassSource("ComputeColorFixed", MaterialUtility.GetAsShaderString(Value));
}
public override ShaderSource GenerateShaderSource(ShaderGeneratorContext context, MaterialComputeColorKeys baseKeys)
{
var key = context.GetParameterKey(Key ?? baseKeys.ValueBaseKey ?? MaterialKeys.GenericValueVector4);
// Store the color in Linear space
var color = Value;
// Convert from Vector4 to (Color4|Vector4|Color3|Vector3)
if (key is ValueParameterKey <Color4> )
{
context.Parameters.Set((ValueParameterKey <Color4>)key, (Color4)color);
}
else if (key is ValueParameterKey <Vector4> )
{
context.Parameters.Set((ValueParameterKey <Vector4>)key, color);
}
else if (key is ValueParameterKey <Color3> )
{
context.Parameters.Set((ValueParameterKey <Color3>)key, (Color3)(Vector3)color);
}
else if (key is ValueParameterKey <Vector3> )
{
context.Parameters.Set((ValueParameterKey <Vector3>)key, (Vector3)color);
}
else
{
context.Log.Error($"Unexpected ParameterKey [{key}] for type [{key.PropertyType}]. Expecting a [Vector3/Color3] or [Vector4/Color4]");
}
UsedKey = key;
return(new ShaderClassSource("ComputeColorConstantColorLink", key));
}
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);
}
public ObjectParameterKey <Texture> GetTextureKey(ComputeTextureBase computeTexture, MaterialComputeColorKeys baseKeys)
{
var keyResolved = (ObjectParameterKey <Texture>)(computeTexture.Key ?? baseKeys.TextureBaseKey ?? MaterialKeys.GenericTexture);
return(GetTextureKey(computeTexture.Texture, keyResolved, baseKeys.DefaultTextureValue));
}
