public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 129
context.CloneProperties();
#line 129
mixin.Mixin.CloneFrom(mixin.Parent.Mixin);
#line 130
context.Mixin(mixin, "DeferredShadowLightingShader");
#line 132
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Nearest)
{
#line 133
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 133
context.Mixin(__subMixin, "NearestFilterGroup");
mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
}
#line 134
else
#line 134
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.PercentageCloserFiltering)
{
#line 135
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 135
context.Mixin(__subMixin, "PcfGroup");
mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
}
#line 136
else
#line 136
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Variance)
{
#line 137
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 137
context.Mixin(__subMixin, "VsmGroup");
mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "BRDFDiffuseBase");
context.Mixin(mixin, "BRDFSpecularBase");
if (context.GetParam(MaterialParameters.AlbedoSpecular) != null)
{
context.Mixin(mixin, "AlbedoSpecularBase");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "albedoSpecular", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoSpecular));
context.PopComposition();
}
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "SpecularLighting", __subMixin);
context.Mixin(__subMixin, "ParadoxSpecularLighting");
context.PopComposition();
}
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 114
mixin.Mixin.AddMacro("LIGHTING_MAX_LIGHT_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
#line 117
context.Mixin(mixin, "ParadoxLightingTypeShader");
#line 118
context.Mixin(mixin, "ShadingPerPixelShadow");
#line 119
context.Mixin(mixin, "SpotShading");
#line 120
context.Mixin(mixin, "ShadingEyeNormalVS");
#line 123
context.Mixin(mixin, "ForwardShadowMapBase");
#line 124
context.Mixin(mixin, "ShadowMapCascadeBase");
#line 126
mixin.Mixin.AddMacro("SHADOWMAP_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
#line 127
mixin.Mixin.AddMacro("SHADOWMAP_CASCADE_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
#line 128
mixin.Mixin.AddMacro("SHADOWMAP_TOTAL_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount) * context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
#line 131
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Nearest)
#line 132
{
context.Mixin(mixin, "ShadowMapFilterDefault");
}
#line 133
else
#line 133
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.PercentageCloserFiltering)
#line 134
{
context.Mixin(mixin, "ShadowMapFilterPcf");
}
#line 135
else
#line 135
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Variance)
#line 136
{
context.Mixin(mixin, "ShadowMapFilterVsm");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "A");
context.Mixin(mixin, "B");
if (context.GetParam(TestParameters.param1))
{
context.Mixin(mixin, "C");
mixin.Mixin.AddMacro("param2", context.GetParam(TestParameters.param2));
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "x", __subMixin);
context.Mixin(__subMixin, "X");
context.PopComposition();
}
}
else
{
context.Mixin(mixin, "D");
mixin.Mixin.AddMacro("Test", context.GetParam(TestParameters.param3));
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "y", __subMixin);
context.Mixin(__subMixin, "Y");
context.PopComposition();
}
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ParadoxBaseShader");
context.Mixin(mixin, "ParadoxSkinning");
context.Mixin(mixin, "ParadoxShadowCast");
context.Mixin(mixin, "ParadoxDiffuseForward");
context.Mixin(mixin, "ParadoxSpecularForward");
if (context.GetParam(MaterialParameters.AmbientMap) != null)
{
context.Mixin(mixin, "AmbientMapShading");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "AmbientMap", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AmbientMap));
context.PopComposition();
}
}
if (context.GetParam(MaterialParameters.UseTransparentMask))
{
context.Mixin(mixin, "TransparentShading");
context.Mixin(mixin, "DiscardTransparentThreshold", context.GetParam(MaterialParameters.AlphaDiscardThreshold));
}
else if (context.GetParam(MaterialParameters.UseTransparent))
{
context.Mixin(mixin, "TransparentShading");
context.Mixin(mixin, "DiscardTransparent");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
{
#line 43
var __subMixin = new ShaderMixinSourceTree()
{
Name = "ParadoxGBufferShaderPass", Parent = mixin
};
mixin.Children.Add(__subMixin);
#line 43
context.BeginChild(__subMixin);
#line 43
context.Mixin(__subMixin, "ParadoxGBufferShaderPass");
#line 43
context.EndChild();
}
#line 47
context.RemoveMixin(mixin, "NormalVSStream");
#line 48
context.RemoveMixin(mixin, "SpecularPowerMap");
#line 49
context.RemoveMixin(mixin, "SpecularPowerPerMesh");
#line 52
context.Mixin(mixin, "NormalVSGBuffer");
#line 54
context.Mixin(mixin, "SpecularPowerGBuffer");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
{
var __subMixin = new ShaderMixinSourceTree()
{
Name = "ShadowMapCaster"
};
context.BeginChild(__subMixin);
context.Mixin(__subMixin, "ShadowMapCaster");
context.EndChild();
}
if (context.GetParam(ShadowMapParameters.ShadowMaps) == null || context.GetParam(ShadowMapParameters.ShadowMaps).Length == 0)
{
return;
}
context.Mixin(mixin, "ShadowMapReceiver");
foreach (var ____1 in context.GetParam(ShadowMapParameters.ShadowMaps))
{
context.PushParameters(____1);
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushCompositionArray(mixin, "shadows", __subMixin);
context.Mixin(__subMixin, "ShadowMapReceiverEffect");
context.PopComposition();
}
context.PopParameters();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 26
context.Mixin(mixin, "ShaderBase");
#line 27
context.Mixin(mixin, "TransformationWAndVP");
#line 29
mixin.Mixin.AddMacro("MAX_VERTEX_COUNT", 9);
#line 30
context.Mixin(mixin, "CameraCube");
#line 32
context.Mixin(mixin, "AlbedoFlatShading");
#line 34
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
#line 35
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 35
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
mixin.Mixin.AddComposition("albedoDiffuse", __subMixin.Mixin);
}
}
public void TestRenaming2()
{
var color1Mixin = new ShaderMixinSource();
color1Mixin.Mixins.Add(new ShaderClassSource("ComputeColorFixed", "Material.DiffuseColorValue"));
var color2Mixin = new ShaderMixinSource();
color2Mixin.Mixins.Add(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 mixinSourceTree = new ShaderMixinSourceTree {
Name = "TestRenaming2", Mixin = mixinSource, UsedParameters = MixinParameters
};
var byteCode = Compiler.Compile(mixinSourceTree, new CompilerParameters(), ResultLogger);
Assert.IsNotNull(byteCode);
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
if (context.GetParam(MaterialParameters.HasSkinningPosition))
{
if (context.GetParam(MaterialParameters.SkinningBones) > context.GetParam(MaterialParameters.SkinningMaxBones))
{
context.SetParam(MaterialParameters.SkinningMaxBones, context.GetParam(MaterialParameters.SkinningBones));
}
mixin.Mixin.AddMacro("SkinningMaxBones", context.GetParam(MaterialParameters.SkinningMaxBones));
context.Mixin(mixin, "TransformationSkinning");
if (context.GetParam(MaterialParameters.HasSkinningNormal))
{
if (context.GetParam(MaterialParameters.NormalMap) != null)
{
context.Mixin(mixin, "TangentToViewSkinning");
}
else
{
context.Mixin(mixin, "NormalVSSkinning");
}
context.Mixin(mixin, "NormalSkinning");
}
if (context.GetParam(MaterialParameters.HasSkinningTangent))
{
context.Mixin(mixin, "TangentSkinning");
}
}
}
public void TestShaderCompilation()
{
var generics = new string[3];
generics[0] = "Texturing.Texture1";
generics[1] = "TEXCOORD0";
generics[2] = "float4(2.0,1,1,1)";
var mixinSource = new ShaderMixinSource();
mixinSource.Mixins.Add(new ShaderClassSource("GenericClass2", generics));
var compilerParameters = new ShaderMixinParameters();
compilerParameters.Set(EffectSourceCodeKeys.Enable, true);
compilerParameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var log = new CompilerResults();
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
var mixinTree = new ShaderMixinSourceTree()
{
Name = "TestShaderCompilationGenericClass", Mixin = mixinSource, UsedParameters = compilerParameters
};
var effectByteCode = compiler.Compile(mixinTree, new CompilerParameters(), log);
}
/// <summary>
/// Compile the effect and its children.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="mixinTree">The mixin tree.</param>
/// <param name="compilerParameters">The compiler parameters.</param>
/// <param name="compilerResults">The compiler results.</param>
/// <returns>true if the compilation succeded, false otherwise.</returns>
/// <exception cref="System.ArgumentNullException">name</exception>
private void Compile(string name, ShaderMixinSourceTree mixinTree, CompilerParameters compilerParameters, CompilerResults compilerResults)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
var bytecode = Compile(mixinTree, compilerParameters, compilerResults);
if (bytecode != null)
{
if (mixinTree.Parent == null)
{
compilerResults.MainBytecode = bytecode;
compilerResults.MainUsedParameters = mixinTree.UsedParameters;
}
compilerResults.Bytecodes.Add(name, bytecode);
compilerResults.UsedParameters.Add(name, mixinTree.UsedParameters);
}
foreach (var childTree in mixinTree.Children)
{
var childName = (string.IsNullOrEmpty(name) ? string.Empty : name + ".") + childTree.Value.Name;
Compile(childName, childTree.Value, compilerParameters, compilerResults);
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "ShadingBase");
context.Mixin(mixin, "TransformationWAndVP");
context.Mixin(mixin, "PositionVSStream");
if (context.GetParam(MaterialParameters.NormalMap) != null)
{
context.Mixin(mixin, "NormalMapTexture");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "normalMap", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.NormalMap));
context.PopComposition();
}
}
else
{
context.Mixin(mixin, "NormalVSStream");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 14
context.Mixin(mixin, "A");
#line 15
context.Mixin(mixin, "B");
#line 16
context.Mixin(mixin, "C");
{
#line 18
var __subMixin = new ShaderMixinSourceTree()
{
Name = "Test", Parent = mixin
};
mixin.Children.Add(__subMixin);
#line 18
context.BeginChild(__subMixin);
#line 18
context.Mixin(__subMixin, "ChildClone");
#line 18
context.EndChild();
}
}
/// <summary>
/// Compile the effect and its children.
/// </summary>
/// <param name="effectName">The name of the effect (without the base effect name).</param>
/// <param name="fullEffectName">The full name of the effect (with the base effect name).</param>
/// <param name="mixinTree">The ShaderMixinSourceTree.</param>
/// <param name="mainCompilerParameters">The parameters used to create the main effect.</param>
/// <param name="compilerParameters">The parameters used to create the child effects</param>
/// <param name="modifiedShaders">The list of modified shaders since the beginning of the runtime.</param>
/// <param name="recentlyModifiedShaders">The list of modified shaders that have not been replaced yet.</param>
/// <param name="compilerResults">The result of the compilation.</param>
/// <returns>true if the compilation succeded, false otherwise.</returns>
protected virtual bool Compile(string effectName, string fullEffectName, ShaderMixinSourceTree mixinTree, ShaderMixinParameters mainCompilerParameters, List <ShaderMixinParameters> compilerParameters, HashSet <string> modifiedShaders, HashSet <string> recentlyModifiedShaders, CompilerResults compilerResults)
{
if (mixinTree.Mixin == null)
{
return(false);
}
var cp = compilerParameters.FirstOrDefault(x => x.Name == fullEffectName);
var bytecode = Compile(mixinTree.Mixin, fullEffectName, cp ?? mainCompilerParameters, modifiedShaders, recentlyModifiedShaders, compilerResults);
var wasCompiled = false;
if (bytecode != null)
{
if (effectName == string.Empty)
{
compilerResults.MainBytecode = bytecode;
compilerResults.MainUsedParameters = mainCompilerParameters;
}
compilerResults.Bytecodes.Add(effectName, bytecode);
compilerResults.UsedParameters.Add(effectName, cp);
wasCompiled = true;
}
foreach (var childTree in mixinTree.Children)
{
var childEffectName = effectName == string.Empty ? childTree.Key : effectName + "." + childTree.Key;
var fullChildEffectName = fullEffectName == string.Empty ? childTree.Key : fullEffectName + "." + childTree.Key;
wasCompiled |= Compile(childEffectName, fullChildEffectName, childTree.Value, mainCompilerParameters, compilerParameters, modifiedShaders, recentlyModifiedShaders, compilerResults);
}
return(wasCompiled);
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 82
mixin.Mixin.AddMacro("LIGHTING_MAX_LIGHT_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
#line 85
context.Mixin(mixin, "ParadoxLightingTypeShader");
#line 86
context.Mixin(mixin, "ShadingPerPixelShadow");
#line 87
context.Mixin(mixin, "DirectionalShading");
#line 88
context.Mixin(mixin, "ShadingEyeNormalVS");
#line 91
context.Mixin(mixin, "ForwardShadowMapBase");
#line 92
context.Mixin(mixin, "ShadowMapCascadeBase");
#line 94
mixin.Mixin.AddMacro("SHADOWMAP_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
#line 95
mixin.Mixin.AddMacro("SHADOWMAP_CASCADE_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
#line 96
mixin.Mixin.AddMacro("SHADOWMAP_TOTAL_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount) * context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
#line 99
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Nearest)
#line 100
{
context.Mixin(mixin, "ShadowMapFilterDefault");
}
#line 101
else
#line 101
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.PercentageCloserFiltering)
#line 102
{
context.Mixin(mixin, "ShadowMapFilterPcf");
}
#line 103
else
#line 103
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Variance)
#line 104
{
context.Mixin(mixin, "ShadowMapFilterVsm");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 99
if (context.GetParam(ShadowMapParameters.LightType) == LightType.Directional)
#line 100
{
context.Mixin(mixin, "DeferredLightingDirectShadowGroup");
}
#line 101
else
#line 101
if (context.GetParam(ShadowMapParameters.LightType) == LightType.Spot)
#line 102
{
context.Mixin(mixin, "DeferredLightingSpotShadowGroup");
}
#line 104
else
#line 104
{
context.Mixin(mixin, "DeferredLightingDirectShadowGroup");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
mixin.Mixin.AddMacro("LIGHTING_MAX_LIGHT_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
context.Mixin(mixin, "ParadoxLightingTypeShader");
context.Mixin(mixin, "ShadingPerPixelShadow");
context.Mixin(mixin, "SpotShading");
context.Mixin(mixin, "ShadingEyeNormalVS");
context.Mixin(mixin, "ForwardShadowMapBase");
context.Mixin(mixin, "ShadowMapCascadeBase");
mixin.Mixin.AddMacro("SHADOWMAP_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount));
mixin.Mixin.AddMacro("SHADOWMAP_CASCADE_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
mixin.Mixin.AddMacro("SHADOWMAP_TOTAL_COUNT", context.GetParam(ShadowMapParameters.ShadowMapCount) * context.GetParam(ShadowMapParameters.ShadowMapCascadeCount));
if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Nearest)
{
context.Mixin(mixin, "ShadowMapFilterDefault");
}
else if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.PercentageCloserFiltering)
{
context.Mixin(mixin, "ShadowMapFilterPcf");
}
else if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Variance)
{
context.Mixin(mixin, "ShadowMapFilterVsm");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "A");
context.Mixin(mixin, "B");
context.Mixin(mixin, "C");
int x = 1;
foreach (var ____1 in context.GetParam(TestParameters.subParameters))
{
context.PushParameters(____1);
if (context.GetParam(SubParameters.param1))
{
context.Mixin(mixin, "C" + x);
}
x++;
context.PopParameters();
}
{
context.PushParameters(context.GetParam(TestParameters.subParam1));
if (context.GetParam(SubParameters.param2) == 1)
{
context.Mixin(mixin, "D");
}
context.PopParameters();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
if (context.GetParam(TestParameters.UseComputeColor2))
{
context.Mixin(mixin, "ComputeColor2");
}
else if (context.GetParam(TestParameters.UseComputeColorRedirect))
{
context.Mixin(mixin, "ComputeColorRedirect");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "ColorRedirect", __subMixin);
context.Mixin(__subMixin, "ComputeColor2");
context.PopComposition();
}
}
else
{
context.Mixin(mixin, "ComputeColor");
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.CloneParentMixinToCurrent();
context.Mixin(mixin, "GBuffer");
context.Mixin(mixin, "NormalVSStream");
if (context.GetParam(MaterialParameters.SpecularPowerMap) != null)
{
context.Mixin(mixin, "SpecularPower");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "SpecularPowerMap", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.SpecularPowerMap));
context.PopComposition();
}
}
if (context.GetParam(MaterialParameters.SpecularIntensityMap) != null)
{
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "SpecularIntensityMap", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.SpecularIntensityMap));
context.PopComposition();
}
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "TransformationWAndVP");
context.Mixin(mixin, "AlbedoFlatShading");
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
context.PopComposition();
}
else
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, "ComputeColorTextureCubeReflect", TexturingKeys.TextureCube0);
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "A");
context.Mixin(mixin, "B");
context.Mixin(mixin, "C");
context.Mixin(mixin, "ChildMixin");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "ImageEffectShader");
mixin.Mixin.AddMacro("TEXTURECUBE_BLEND_COUNT", context.GetParam(CubemapBlendRenderer.CubemapCount));
if (context.GetParam(CubemapBlendRenderer.UseMultipleRenderTargets))
{
context.Mixin(mixin, "CubemapBlenderMRT");
}
else
{
context.Mixin(mixin, "CubemapBlender");
}
foreach (var ____1 in context.GetParam(CubemapBlendRenderer.Cubemaps))
{
context.PushParameters(____1);
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushCompositionArray(mixin, "Cubemaps", __subMixin);
context.Mixin(__subMixin, "CubemapFace", context.GetParam(CubemapBlendRenderer.CubemapKey));
context.PopComposition();
}
context.PopParameters();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "TransformationWVP");
context.Mixin(mixin, "BRDFDiffuseBase");
context.Mixin(mixin, "BRDFSpecularBase");
context.Mixin(mixin, "AlbedoFlatShading");
context.Mixin(mixin, "TransparentShading");
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
context.PopComposition();
}
if (context.GetParam(MaterialParameters.AlbedoSpecular) != null)
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "albedoSpecular", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoSpecular));
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "A");
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "SubCompute1", __subMixin);
context.Mixin(__subMixin, "ABCSubEffect");
context.PopComposition();
}
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushComposition(mixin, "SubCompute2", __subMixin);
context.Mixin(__subMixin, "ABCSubEffect");
context.PopComposition();
}
{
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
context.PushCompositionArray(mixin, "SubComputes", __subMixin);
context.Mixin(__subMixin, "ABCSubEffect");
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
mixin.Mixin.AddMacro("LIGHTING_MAX_LIGHT_COUNT", context.GetParam(LightingKeys.MaxDirectionalLights));
if (context.GetParam(LightingKeys.UnrollDirectionalLightLoop))
{
mixin.Mixin.AddMacro("LIGHTING_UNROLL_LOOP", true);
}
if (context.GetParam(MaterialParameters.LightingType) == MaterialLightingType.DiffusePixel)
{
context.Mixin(mixin, "ShadingDiffusePerPixel");
}
else if (context.GetParam(MaterialParameters.LightingType) == MaterialLightingType.DiffuseVertex)
{
context.Mixin(mixin, "ShadingDiffusePerVertex");
}
else if (context.GetParam(MaterialParameters.LightingType) == MaterialLightingType.DiffuseSpecularPixel)
{
context.Mixin(mixin, "ShadingDiffuseSpecularPerPixel");
}
else if (context.GetParam(MaterialParameters.LightingType) == MaterialLightingType.DiffuseVertexSpecularPixel)
{
context.Mixin(mixin, "ShadingDiffusePerVertexSpecularPerPixel");
}
context.Mixin(mixin, "DirectionalShading");
context.Mixin(mixin, "ShadingEyeNormalVS");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
mixin.Mixin.AddMacro("LIGHTING_MAX_LIGHT_COUNT", context.GetParam(LightingKeys.MaxDirectionalLights));
context.Mixin(mixin, "ParadoxLightingTypeShader");
context.Mixin(mixin, "DirectionalShading");
context.Mixin(mixin, "ShadingEyeNormalVS");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 13
context.Mixin(mixin, "ShaderBase");
#line 14
context.Mixin(mixin, "TransformationWAndVP");
#line 15
context.Mixin(mixin, "PositionVSStream");
#line 16
context.Mixin(mixin, "NormalVSStream");
#line 18
mixin.Mixin.AddMacro("RENDER_TARGET_COUNT", 3);
#line 19
context.Mixin(mixin, "ShadingBase");
#line 20
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
#line 21
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 21
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
mixin.Mixin.AddComposition("ShadingColor0", __subMixin.Mixin);
}
{
#line 22
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 22
context.Mixin(__subMixin, "LinearDepth");
mixin.Mixin.AddComposition("ShadingColor1", __subMixin.Mixin);
}
{
#line 23
var __subMixin = new ShaderMixinSourceTree()
{
Parent = mixin
};
#line 23
context.Mixin(__subMixin, "NormalColor");
mixin.Mixin.AddComposition("ShadingColor2", __subMixin.Mixin);
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
#line 7
context.Mixin(mixin, "C1");
#line 8
context.Mixin(mixin, "C2");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "TransformationWAndVP");
context.Mixin(mixin, "AlbedoFlatShading");
{
var __subMixin = new ShaderMixinSourceTree() { Parent = mixin };
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, "ComputeColorTextureCubeBasic", TexturingKeys.TextureCube0);
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "TransformationWAndVP");
mixin.Mixin.AddMacro("MAX_VERTEX_COUNT", 9);
context.Mixin(mixin, "CameraCube");
context.Mixin(mixin, "AlbedoFlatShading");
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
var __subMixin = new ShaderMixinSourceTree() { Parent = mixin };
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ShaderBase");
context.Mixin(mixin, "TransformationWAndVP");
context.Mixin(mixin, "AlbedoFlatShading");
if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
{
var __subMixin = new ShaderMixinSourceTree() { Parent = mixin };
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
context.PopComposition();
}
else
{
var __subMixin = new ShaderMixinSourceTree() { Parent = mixin };
context.PushComposition(mixin, "albedoDiffuse", __subMixin);
context.Mixin(__subMixin, "ComputeColorTextureCubeReflect", TexturingKeys.TextureCube0);
context.PopComposition();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "XenkoBaseShader");
{
var __subMixin = new ShaderMixinSourceTree() { Name = "XenkoGBufferShaderPass" };
context.BeginChild(__subMixin);
context.Mixin(__subMixin, "XenkoGBufferShaderPass");
context.EndChild();
}
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ParadoxDefaultLightPrepassEffect");
}
public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
{
context.Mixin(mixin, "ParadoxDefaultDeferredShader");
}
