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); } }
private void AddSpecularHighlightsShiftNoiseTexture(MaterialGeneratorContext context, ShaderMixinSource shaderSource) { MaterialComputeColorKeys materialComputeColorKeys = new MaterialComputeColorKeys(PrimarySpecularReflectionNoiseTexture, PrimarySpecularReflectionNoiseValue); var computeColorSource = HairSpecularHighlightsShiftNoise.GenerateShaderSource(context, materialComputeColorKeys); shaderSource.AddComposition("SpecularHighlightsShiftNoiseTexture", computeColorSource); }
public ShaderSource GetMarchingShader(int attrID) { var mixin = new ShaderMixinSource(); mixin.Mixins.Add(new ShaderClassSource("VoxelMarchSetHemisphere6")); mixin.AddComposition("Marcher", Marcher.GetMarchingShader(attrID)); return(mixin); }
virtual public ShaderSource GetSamplingShader() { var mixin = new ShaderMixinSource(); mixin.Mixins.Add(Sampler); mixin.AddComposition("storage", storageTex.GetSamplingShader()); return(mixin); }
public ShaderSource GetShader() { var mixin = new ShaderMixinSource(); mixin.Mixins.Add(source); mixin.AddComposition("layout", VoxelLayout.GetShaderFloat4(Modifiers)); return(mixin); }
public override ShaderSource GetVoxelizationShader() { var mixin = new ShaderMixinSource(); mixin.Mixins.Add(source); mixin.AddComposition("layout", VoxelLayout.GetVoxelizationShader(Modifiers)); return(mixin); }
public void Apply(ShaderMixinSource mixin) { var writermixin = new ShaderMixinSource(); writermixin.Mixins.Add((ShaderClassSource)TempStorageFormat.GetShader()); writermixin.AddComposition("writer", Filter.GetShader()); mixin.AddComposition("writer", writermixin); }
private void AddSecondarySpecularGlintsNoiseTexture(MaterialGeneratorContext context, ShaderMixinSource shaderSource) { MaterialComputeColorKeys materialComputeColorKeys = new MaterialComputeColorKeys(SecondarySpecularReflectionNoiseTexture, SecondarySpecularReflectionNoiseValue); var computeColorSource = HairSecondarySpecularGlintsNoise.GenerateShaderSource(context, materialComputeColorKeys); shaderSource.AddComposition("SecondarySpecularGlintsNoiseTexture", computeColorSource); }
protected override void GenerateShaderCompositions(MaterialGeneratorContext context, ShaderMixinSource shaderSource) { base.GenerateShaderCompositions(context, shaderSource); if (RampFunction != null) { shaderSource.AddComposition("celLightFunction", RampFunction.Generate(context)); } }
public void TestRenaming() { var color1Mixin = new ShaderClassSource("ComputeColorFixed", "Material.DiffuseColorValue"); var color2Mixin = new ShaderClassSource("ComputeColorFixed", "Material.SpecularColorValue"); var compMixin = new ShaderMixinSource(); compMixin.Mixins.Add(new ShaderClassSource("ComputeColorMultiply")); compMixin.AddComposition("color1", color1Mixin); compMixin.AddComposition("color2", color2Mixin); var mixinSource = new ShaderMixinSource { Name = "testRenaming", UsedParameters = MixinParameters }; mixinSource.Mixins.Add(new ShaderClassSource("ShadingBase")); mixinSource.Mixins.Add(new ShaderClassSource("AlbedoFlatShading")); mixinSource.AddComposition("albedoDiffuse", compMixin); var byteCode = Compiler.Compile(mixinSource, new CompilerParameters()); Assert.IsNotNull(byteCode); }
public override void GenerateShader(MaterialGeneratorContext context) { // TODO: Look through the compositions and don't add the discard mixin if it has already been added? // TODO: That doesn't seem to work well because the diffuse shader doesn't get recreated when the specular one is being recreated... unless I'm wrong about that. var shaderSource = new ShaderMixinSource(); shaderSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingSpecularHair", (int)ShadingModel, DebugRenderPasses)); shaderSource.AddComposition("hairLightAttenuationFunction", LightAttenuationFunction.Generate(context)); shaderSource.AddComposition("hairDirectionFunction", HairDirectionFunction.Generate(context)); shaderSource.AddComposition("hairShadowingFunction", HairShadowingFunction.Generate(context)); shaderSource.AddComposition("environmentFunction", Environment.Generate(context)); AddSpecularHighlightsShiftNoiseTexture(context, shaderSource); AddSecondarySpecularGlintsNoiseTexture(context, shaderSource); HairShared.SetMaterialPassParameters(context, shaderSource, AlphaThreshold); // Set the rendering parameters and generate the pass-dependent compositions. // Set the additional parameters used only in the specular shading model: var parameters = context.MaterialPass.Parameters; parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairScalesAngle, MathUtil.DegreesToRadians(ScalesAngle)); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularShiftRatio, SpecularShiftRatio); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularColor1, SpecularColor1); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularColor2, SpecularColor2); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularExponent1, SpecularExponent1); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularExponent2, SpecularExponent2); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularScale1, SpecularScale1); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairSpecularScale2, SpecularScale2); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairShiftNoiseScale, ShiftNoiseScale); parameters.Set(MaterialSurfaceShadingSpecularHairKeys.HairGlintsNoiseStrength, GlintsNoiseStrength); parameters.Set(MaterialKeys.UsePixelShaderWithDepthPass, true); // Indicates that the material requries the full pixel shader durin the depth-only passes (Z prepass or shadow map rendering). if (DebugRenderPasses) { parameters.Set(MaterialHairSharedKeys.PassID, context.PassIndex); // For debugging the different hair passes. } var shaderBuilder = context.AddShading(this); shaderBuilder.LightDependentSurface = shaderSource; }
private void AddMetalFlakesGlossiness(MaterialGeneratorContext context) { var surfaceToEyeDistance = LODDistance.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.GlossinessMap, MaterialKeys.GlossinessValue, Color.White)); // Metal Flakes Glossiness Feature context.UseStream(MaterialShaderStage.Pixel, "matGlossiness"); var baseGlossinessComputeColorMap = BasePaintGlossinessMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.GlossinessMap, MaterialKeys.GlossinessValue)); var mixinGlossiness = new ShaderMixinSource(); // Computes glossiness factor for the metal flakes layer (based on the eye to surface distance and the base glossiness value) mixinGlossiness.Mixins.Add(new ShaderClassSource("MaterialSurfaceGlossinessMapMetalFlakes", BasePaintGlossinessInvert)); mixinGlossiness.AddComposition("glossinessMap", baseGlossinessComputeColorMap); mixinGlossiness.AddComposition("surfaceToEyeDistanceFactor", surfaceToEyeDistance); context.AddShaderSource(MaterialShaderStage.Pixel, mixinGlossiness); }
private void AddMetalFlakesDiffuse(MaterialGeneratorContext context) { var surfaceToEyeDistance = LODDistance.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.GlossinessMap, MaterialKeys.GlossinessValue, Color.White)); // Diffuse Feature (interpolated by the 'regular' diffuse map) var metalFlakesComputeColorSource = MetalFlakesDiffuseMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.DiffuseMap, MaterialKeys.DiffuseValue, Color.White)); var mixinDiffuse = new ShaderMixinSource(); // Diffuse uses a custom shader (to perform the interpolation) mixinDiffuse.Mixins.Add(new ShaderClassSource("MaterialSurfaceDiffuseMetalFlakes")); mixinDiffuse.AddComposition("diffuseMap", metalFlakesComputeColorSource); mixinDiffuse.AddComposition("surfaceToEyeDistanceFactor", surfaceToEyeDistance); context.UseStream(MaterialShaderStage.Pixel, MaterialDiffuseMapFeature.DiffuseStream.Stream); context.UseStream(MaterialShaderStage.Pixel, MaterialDiffuseMapFeature.ColorBaseStream.Stream); context.AddShaderSource(MaterialShaderStage.Pixel, mixinDiffuse); }
public override ShaderSource GetSamplingShader() { var mixin = new ShaderMixinSource(); mixin.Mixins.Add(sampler); if (CoverageTex != null) { mixin.AddComposition("storage", CoverageTex.GetSamplingShader()); } return(mixin); }
// TODO Quantify/clean all the functions private void AddBaseDiffuse(MaterialGeneratorContext context) { var computeColorDiffuse = BasePaintDiffuseMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.DiffuseMap, MaterialKeys.DiffuseValue, Color.White)); var mixinBaseDiffuse = new ShaderMixinSource(); mixinBaseDiffuse.Mixins.Add(new ShaderClassSource("MaterialSurfaceDiffuse")); mixinBaseDiffuse.AddComposition("diffuseMap", computeColorDiffuse); context.UseStream(MaterialShaderStage.Pixel, MaterialDiffuseMapFeature.DiffuseStream.Stream); context.UseStream(MaterialShaderStage.Pixel, MaterialDiffuseMapFeature.ColorBaseStream.Stream); context.AddShaderSource(MaterialShaderStage.Pixel, mixinBaseDiffuse); }
/// <summary> /// Build the ShaderMixinSource to evaluate the binaryNode. /// </summary> /// <param name="binaryNode">The MaterialBinaryNode binaryNode used as source to find the ShaderMixinSource.</param> /// <returns>The corresponding ShaderMixinSource.</returns> private ShaderSource GetShaderSource(MaterialBinaryNode binaryNode) { var leftShaderSource = GetShaderSource(binaryNode.LeftChild); var rightShaderSource = GetShaderSource(binaryNode.RightChild); var shaderSource = new ShaderClassSource(GetCorrespondingShaderSourceName(binaryNode.Operand)); var mixin = new ShaderMixinSource(); mixin.Mixins.Add(shaderSource); if (leftShaderSource != null) { mixin.AddComposition(BackgroundCompositionName, leftShaderSource); } if (binaryNode.Operand != MaterialBinaryOperand.None && binaryNode.Operand != MaterialBinaryOperand.Opaque && rightShaderSource != null) { mixin.AddComposition(ForegroundCompositionName, rightShaderSource); } return(mixin); }
private void AddClearCoatGlossinessMap(MaterialGeneratorContext context) { // Glossiness Feature context.UseStream(MaterialShaderStage.Pixel, "matGlossiness"); var clearCoatGlossinessComputeColorMap = ClearCoatGlossinessMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.GlossinessMap, MaterialKeys.GlossinessValue)); var mixinGlossiness = new ShaderMixinSource(); mixinGlossiness.Mixins.Add(new ShaderClassSource("MaterialSurfaceGlossinessMap", ClearCoatGlossinessInvert)); mixinGlossiness.AddComposition("glossinessMap", clearCoatGlossinessComputeColorMap); context.AddShaderSource(MaterialShaderStage.Pixel, mixinGlossiness); }
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); }
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); } }
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); } }
public void TestRenaming() { var color1Mixin = new ShaderClassSource("ComputeColorFixed", "Material.DiffuseColorValue"); var color2Mixin = new ShaderClassSource("ComputeColorFixed", "Material.SpecularColorValue"); var compMixin = new ShaderMixinSource(); compMixin.Mixins.Add(new ShaderClassSource("ComputeColorMultiply")); compMixin.AddComposition("color1", color1Mixin); compMixin.AddComposition("color2", color2Mixin); var mixinSource = new ShaderMixinSource(); mixinSource.Mixins.Add(new ShaderClassSource("ShadingBase")); mixinSource.Mixins.Add(new ShaderClassSource("AlbedoFlatShading")); mixinSource.AddComposition("albedoDiffuse", compMixin); var byteCode = Compiler.Compile(mixinSource, "testRenaming", MixinParameters, null, null, ResultLogger); Assert.IsNotNull(byteCode); }
public override void VisitFeature(MaterialGeneratorContext context) { var shaderSource = new ShaderMixinSource(); shaderSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingDiffuseCelShading", IsEnergyConservative, FakeNDotL)); if (RampFunction != null) { shaderSource.AddComposition("celLightFunction", RampFunction.Generate(context)); } context.AddShading(this, shaderSource); }
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); } }
private void AddClearCoatMetalnessMap(MaterialGeneratorContext context) { // Metalness Feature var clearCoatMetalness = ClearCoatMetalnessMap.GenerateShaderSource(context, new MaterialComputeColorKeys(MaterialKeys.MetalnessMap, MaterialKeys.MetalnessValue)); var mixin = new ShaderMixinSource(); mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceMetalness")); mixin.AddComposition("metalnessMap", clearCoatMetalness); context.UseStream(MaterialShaderStage.Pixel, "matSpecular"); context.AddShaderSource(MaterialShaderStage.Pixel, mixin); }
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.AddShaderSource(MaterialShaderStage.Pixel, mixin); } }
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); } }
protected virtual void GenerateShaderCompositions(MaterialGeneratorContext context, ShaderMixinSource shaderSource) { if (Fresnel != null) { shaderSource.AddComposition("fresnelFunction", Fresnel.Generate(context)); } if (Visibility != null) { shaderSource.AddComposition("geometricShadowingFunction", Visibility.Generate(context)); } if (NormalDistribution != null) { shaderSource.AddComposition("normalDistributionFunction", NormalDistribution.Generate(context)); } if (Environment != null) { shaderSource.AddComposition("environmentFunction", Environment.Generate(context)); } }
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 GenerateShader(MaterialGeneratorContext context) { var shaderSource = new ShaderMixinSource(); shaderSource.Mixins.Add(new ShaderClassSource("MaterialSurfaceShadingDiffuseHair", IsEnergyConservative, (int)ShadingModel, DebugRenderPasses)); shaderSource.AddComposition("hairLightAttenuationFunction", LightAttenuationFunction.Generate(context)); shaderSource.AddComposition("hairDirectionFunction", HairDirectionFunction.Generate(context)); shaderSource.AddComposition("hairShadowingFunction", HairShadowingFunction.Generate(context)); HairShared.SetMaterialPassParameters(context, shaderSource, AlphaThreshold); // Set the rendering parameters and generate the pass-dependent compositions. context.Parameters.Set(MaterialKeys.UsePixelShaderWithDepthPass, true); // Indicates that material requries using the pixel shader stage during the depth-only pass (Z prepass or shadow map rendering). if (DebugRenderPasses) { context.Parameters.Set(MaterialHairSharedKeys.PassID, context.PassIndex); // For debugging the different hair passes. } var shaderBuilder = context.AddShading(this); shaderBuilder.LightDependentSurface = shaderSource; }
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 override void GenerateShader(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); context.Parameters.Set(MaterialKeys.SkipTangents, SkipTangents); 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; } } else { var computeFloat4 = normalMap as ComputeFloat4; if (computeFloat4 != null) { if (computeFloat4.Value == Vector4.Zero) { computeFloat4.Value = DefaultNormalColor.ToVector4(); } } } } 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 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); } }
} = new ComputeColor(new Color4(1.0f, 0.37f, 0.3f, 1.0f)); // Default falloff for skin. public ShaderSource Generate(MaterialGeneratorContext context) { var shaderSource = new ShaderMixinSource(); MaterialComputeColorKeys materialComputeColorKeys = new MaterialComputeColorKeys(FalloffTexture, FalloffValue, DefaultProfileColor); // Add the shader for computing the transmittance using the custom scattering profile: if (FalloffMap is ComputeTextureColor || FalloffMap is ComputeBinaryColor || FalloffMap is ComputeShaderClassColor || FalloffMap is ComputeVertexStreamColor) { var computeColorSource = FalloffMap.GenerateShaderSource(context, materialComputeColorKeys); shaderSource.AddComposition("FalloffMap", computeColorSource); // Use the expensive pixel shader because the scattering falloff can vary per pixel because we're using a texture: shaderSource.Mixins.Add(new ShaderClassSource("MaterialSubsurfaceScatteringScatteringProfileCustomVarying")); } else { Vector3 falloff = new Vector3(1.0f); ComputeColor falloffComputeColor = FalloffMap as ComputeColor; if (falloffComputeColor != null) { falloff.X = falloffComputeColor.Value.R; falloff.Y = falloffComputeColor.Value.G; falloff.Z = falloffComputeColor.Value.B; } ComputeFloat4 falloffComputeFloat4 = FalloffMap as ComputeFloat4; if (falloffComputeFloat4 != null) { falloff.X = falloffComputeFloat4.Value.X; falloff.Y = falloffComputeFloat4.Value.Y; falloff.Z = falloffComputeFloat4.Value.Z; } // Use the precomputed pixel shader because the scattering falloff is constant across pixels because we're using a texture: Vector4[] scatteringProfile = SubsurfaceScatteringKernelGenerator.CalculateTransmittanceProfile(falloff); // Applied during forward pass. context.MaterialPass.Parameters.Set(MaterialSubsurfaceScatteringScatteringProfileCustomUniformKeys.ScatteringProfile, scatteringProfile); shaderSource.Mixins.Add(new ShaderClassSource("MaterialSubsurfaceScatteringScatteringProfileCustomUniform")); } return(shaderSource); }
private void AddClearCoatNormalMap(MaterialGeneratorContext context) { var computeColorKeys = new MaterialComputeColorKeys(MaterialKeys.NormalMap, MaterialKeys.NormalValue, MaterialNormalMapFeature.DefaultNormalColor, false); var computeColorSource = OrangePeelNormalMap.GenerateShaderSource(context, computeColorKeys); // Orange Peel Normal Map var mixinNormalMap = new ShaderMixinSource(); // Inform the context that we are using matNormal (from the MaterialSurfaceNormalMap shader) context.UseStreamWithCustomBlend(MaterialShaderStage.Pixel, "matNormal", new ShaderClassSource("MaterialStreamNormalBlend")); context.Parameters.Set(MaterialKeys.HasNormalMap, true); mixinNormalMap.Mixins.Add(new ShaderClassSource("MaterialSurfaceNormalMap", OrangePeelIsXYNormal, OrangePeelScaleAndBias)); mixinNormalMap.AddComposition("normalMap", computeColorSource); context.AddShaderSource(MaterialShaderStage.Pixel, mixinNormalMap); }
public override void GenerateShader(MaterialGeneratorContext context) { if (DiffuseMap != null) { Vector4 diffuseMin = Vector4.Zero; Vector4 diffuseMax = Vector4.One; DiffuseMap.ClampFloat4(ref diffuseMin, ref diffuseMax); 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.AddShaderSource(MaterialShaderStage.Pixel, mixin); } }
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); }
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 SetStream(MaterialShaderStage stage, string stream, MaterialStreamType streamType, ShaderSource classSource) { if (stream == null) throw new ArgumentNullException(nameof(stream)); // Blend stream is not part of the stream used if (stream != MaterialBlendLayer.BlendStream) { GetContextPerStage(stage).Streams.Add(stream); } string channel; switch (streamType) { case MaterialStreamType.Float: channel = "r"; break; case MaterialStreamType.Float2: channel = "rg"; break; case MaterialStreamType.Float3: channel = "rgb"; break; case MaterialStreamType.Float4: channel = "rgba"; break; default: throw new NotSupportedException("StreamType [{0}] is not supported".ToFormat(streamType)); } var mixin = new ShaderMixinSource(); mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceSetStreamFromComputeColor", stream, channel)); mixin.AddComposition("computeColorSource", classSource); GetContextPerStage(stage).ShaderSources.Add(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); } }