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)); }