public void TestShaderCompilation()
{
var generics = new string[3];
generics[0] = "Texturing.Texture1";
generics[1] = "TEXCOORD0";
generics[2] = "float4(2.0,1,1,1)";
var compilerParameters = new ShaderMixinParameters();
compilerParameters.Set(EffectSourceCodeKeys.Enable, true);
compilerParameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var mixinSource = new ShaderMixinSource {
Name = "TestShaderCompilationGenericClass", UsedParameters = compilerParameters
};
mixinSource.Mixins.Add(new ShaderClassSource("GenericClass2", generics));
var log = new CompilerResults();
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
var effectByteCode = compiler.Compile(mixinSource, new CompilerParameters());
}
public void TestComplexParams()
{
var properties = new ShaderMixinParameters();
ShaderMixinParameters usedProperties;
// Populate the the properties used by the mixin
var subParam1 = new Test1.SubParameters();
var subParameters = new Test1.SubParameters[4];
for (int i = 0; i < subParameters.Length; i++)
{
subParameters[i] = new Test1.SubParameters();
}
properties.Set(Test1.TestParameters.subParam1, subParam1);
properties.Set(Test1.TestParameters.subParameters, subParameters);
// Generate the mixin with default properties
var mixin = GenerateMixin("DefaultComplexParams", properties, out usedProperties);
mixin.CheckMixin("A", "B", "C", "D");
// Modify properties in order to modify mixin
for (int i = 0; i < subParameters.Length; i++)
{
subParameters[i].Set(Test1.SubParameters.param1, (i & 1) == 0);
}
subParam1.Set(Test1.SubParameters.param2, 2);
mixin = GenerateMixin("DefaultComplexParams", properties, out usedProperties);
mixin.CheckMixin("A", "B", "C", "C1", "C3");
}
public void TestMixinAndComposeKeys()
{
var properties = new ShaderMixinParameters();
var subCompute1Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute1");
var subCompute2Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute2");
var subComputesKey = TestABC.TestParameters.UseComputeColorRedirect.ComposeWith("SubComputes[0]");
properties.Set(subCompute1Key, true);
properties.Set(subComputesKey, true);
ShaderMixinParameters usedProperties;
var mixin = GenerateMixin("test_mixin_compose_keys", properties, out usedProperties);
mixin.CheckMixin("A");
Assert.AreEqual(3, mixin.Compositions.Count);
Assert.IsTrue(mixin.Compositions.ContainsKey("SubCompute1"));
Assert.IsTrue(mixin.Compositions.ContainsKey("SubCompute2"));
Assert.IsTrue(mixin.Compositions.ContainsKey("SubComputes"));
Assert.AreEqual("mixin ComputeColor2", mixin.Compositions["SubCompute1"].ToString());
Assert.AreEqual("mixin ComputeColor", mixin.Compositions["SubCompute2"].ToString());
Assert.AreEqual("[mixin ComputeColorRedirect [{ColorRedirect = mixin ComputeColor2}]]", mixin.Compositions["SubComputes"].ToString());
Assert.IsTrue(mixin.UsedParameters.ContainsKey(subCompute1Key));
Assert.IsTrue(mixin.UsedParameters.ContainsKey(subCompute2Key));
Assert.IsTrue(mixin.UsedParameters.ContainsKey(subComputesKey));
Assert.IsTrue(mixin.UsedParameters.Get(subCompute1Key));
Assert.IsFalse(mixin.UsedParameters.Get(subCompute2Key));
Assert.IsTrue(mixin.UsedParameters.Get(subComputesKey));
}
public void Compile()
{
Console.WriteLine(@"Inside Thread");
var parameters = new ShaderMixinParameters();
parameters.Set(CompilerParameters.GraphicsPlatformKey, GraphicsPlatform.Direct3D11);
parameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var logger = new LoggerResult();
var result = effectCompiler.Compile(mixinSource, "TestParallelMix", parameters, null, null, logger);
Assert.IsFalse(logger.HasErrors);
Assert.IsNotNull(result);
Console.WriteLine(@"Thread end");
}
public void Compile()
{
Console.WriteLine(@"Inside Thread");
var parameters = new ShaderMixinParameters();
parameters.Set(CompilerParameters.GraphicsPlatformKey, GraphicsPlatform.Direct3D11);
parameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var mixinTree = new ShaderMixinSource() { Name = "TestParallelMix", UsedParameters = parameters };
var result = effectCompiler.Compile(mixinTree, new CompilerParameters()).WaitForResult();
Assert.IsFalse(result.CompilationLog.HasErrors);
Assert.IsNotNull(result);
Console.WriteLine(@"Thread end");
}
public void Compile()
{
Console.WriteLine(@"Inside Thread");
var parameters = new ShaderMixinParameters();
parameters.Set(CompilerParameters.GraphicsPlatformKey, GraphicsPlatform.Direct3D11);
parameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var mixinTree = new ShaderMixinSource()
{
Name = "TestParallelMix", UsedParameters = parameters
};
var result = effectCompiler.Compile(mixinTree, new CompilerParameters()).WaitForResult();
Assert.IsFalse(result.CompilationLog.HasErrors);
Assert.IsNotNull(result);
Console.WriteLine(@"Thread end");
}
public void TestShaderCompilation()
{
var generics = new string[3];
generics[0] = "Texturing.Texture1";
generics[1] = "TEXCOORD0";
generics[2] = "float4(2.0,1,1,1)";
var compilerParameters = new ShaderMixinParameters();
compilerParameters.Set(EffectSourceCodeKeys.Enable, true);
compilerParameters.Set(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0);
var mixinSource = new ShaderMixinSource { Name = "TestShaderCompilationGenericClass", UsedParameters = compilerParameters };
mixinSource.Mixins.Add(new ShaderClassSource("GenericClass2", generics));
var log = new CompilerResults();
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
var effectByteCode = compiler.Compile(mixinSource, new CompilerParameters());
}
public void TestSimpleChildParams()
{
var properties = new ShaderMixinParameters();
properties.Set(Test4.TestParameters.TestCount, 0);
ShaderMixinParameters usedProperties;
var mixin = GenerateMixin("DefaultSimpleChildParams", properties, out usedProperties);
mixin.Mixin.CheckMixin("A", "B", "C");
Assert.That(mixin.Children.Count, Is.EqualTo(1), "Expecting one children mixin");
mixin.Children.Values.First().Mixin.CheckMixin("A", "B", "C1");
}
public void TestShaderParametersSerialization()
{
// Test serialization
var shaderParameters = new ShaderMixinParameters("Test");
shaderParameters.Set(PropertyInt, 5);
var subShaderParameters = new ShaderMixinParameters("Sub");
subShaderParameters.Set(PropertyInt, 6);
shaderParameters.Set(PropertySub, subShaderParameters);
var subShaderParametersArray = new ShaderMixinParameters[1];
var subShaderParametersArray1 = new ShaderMixinParameters("InArray1");
subShaderParametersArray[0] = subShaderParametersArray1;
subShaderParametersArray1.Set(PropertyInt, 7);
shaderParameters.Set(PropertySubs, subShaderParametersArray);
var memoryStream = new MemoryStream();
var writer = new BinarySerializationWriter(memoryStream);
writer.Write(shaderParameters);
writer.Flush();
memoryStream.Position = 0;
var reader = new BinarySerializationReader(memoryStream);
var shaderParametersReloaded = reader.Read <ShaderMixinParameters>();
// They should be strictly equal
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.True);
Assert.That(shaderParameters.IsSubsetOf(shaderParametersReloaded), Is.True);
// Test subset
// Check that by removing one key from the original parameters, the reloaded version is
// no longer a subset
subShaderParametersArray1.Remove(PropertyInt);
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.False);
}
public void TestSimpleChildParams()
{
var properties = new ShaderMixinParameters();
properties.Set(Test4.TestParameters.TestCount, 0);
ShaderMixinParameters usedProperties;
var mixin = GenerateMixin("DefaultSimpleChildParams", properties, out usedProperties);
mixin.CheckMixin("A", "B", "C");
var childMixin = GenerateMixin("DefaultSimpleChildParams.ChildParamsMixin", properties, out usedProperties);
childMixin.CheckMixin("A", "B", "C1");
Assert.IsTrue(childMixin.UsedParameters.ContainsKey(Test4.TestParameters.TestCount));
Assert.AreEqual(0, childMixin.UsedParameters.Get(Test4.TestParameters.TestCount));
}
public void TestSimpleParams()
{
var properties = new ShaderMixinParameters();
var mixin = GenerateMixin("DefaultSimpleParams", properties);
mixin.CheckMixin("A", "B", "D");
mixin.CheckComposition("y", "Y");
mixin.CheckMacro("Test", "ok");
// Set a key to modify the mixin
properties.Set(Test7.TestParameters.param1, true);
mixin = GenerateMixin("DefaultSimpleParams", properties);
mixin.CheckMixin("A", "B", "C");
mixin.CheckComposition("x", "X");
mixin.CheckMacro("param2", 1);
}
public void TestSimpleParams()
{
var properties = new ShaderMixinParameters();
var mixin = GenerateMixin("DefaultSimpleParams", properties);
mixin.CheckMixin("A", "B", "D");
mixin.CheckComposition("y", "Y");
mixin.CheckMacro("Test", "ok");
// Set a key to modify the mixin
properties.Set(Test7.TestParameters.param1, true);
mixin = GenerateMixin("DefaultSimpleParams", properties);
mixin.CheckMixin("A", "B", "C");
mixin.CheckComposition("x", "X");
mixin.CheckMacro("param2", 1);
}
public void TestComplexParams()
{
var properties = new ShaderMixinParameters();
// Populate the the properties used by the mixin
var subParam1 = new Test1.SubParameters();
var subParameters = new Test1.SubParameters[4];
for (int i = 0; i < subParameters.Length; i++)
{
subParameters[i] = new Test1.SubParameters();
}
properties.Set(Test1.TestParameters.subParam1, subParam1);
properties.Set(Test1.TestParameters.subParameters, subParameters);
// Generate the mixin with default properties
var mixin = GenerateMixin("DefaultComplexParams", properties);
mixin.CheckMixin("A", "B", "C", "D");
// Modify properties in order to modify mixin
for (int i = 0; i < subParameters.Length; i++)
{
subParameters[i].Set(Test1.SubParameters.param1, (i & 1) == 0);
}
subParam1.Set(Test1.SubParameters.param2, 2);
mixin = GenerateMixin("DefaultComplexParams", properties);
mixin.CheckMixin("A", "B", "C", "C1", "C3");
}
public void TestShaderParametersSerialization()
{
// Test serialization
var shaderParameters = new ShaderMixinParameters("Test");
shaderParameters.Set(PropertyInt, 5);
var subShaderParameters = new ShaderMixinParameters("Sub");
subShaderParameters.Set(PropertyInt, 6);
shaderParameters.Set(PropertySub, subShaderParameters);
var subShaderParametersArray = new ShaderMixinParameters[1];
var subShaderParametersArray1 = new ShaderMixinParameters("InArray1");
subShaderParametersArray[0] = subShaderParametersArray1;
subShaderParametersArray1.Set(PropertyInt, 7);
shaderParameters.Set(PropertySubs, subShaderParametersArray);
var memoryStream = new MemoryStream();
var writer = new BinarySerializationWriter(memoryStream);
writer.Write(shaderParameters);
writer.Flush();
memoryStream.Position = 0;
var reader = new BinarySerializationReader(memoryStream);
var shaderParametersReloaded = reader.Read<ShaderMixinParameters>();
// They should be strictly equal
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.True);
Assert.That(shaderParameters.IsSubsetOf(shaderParametersReloaded), Is.True);
// Test subset
// Check that by removing one key from the original parameters, the reloaded version is
// no longer a subset
subShaderParametersArray1.Remove(PropertyInt);
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.False);
}
public void TestSimpleChildParams()
{
var properties = new ShaderMixinParameters();
properties.Set(Test4.TestParameters.TestCount, 0);
ShaderMixinParameters usedProperties;
var mixin = GenerateMixin("DefaultSimpleChildParams", properties, out usedProperties);
mixin.CheckMixin("A", "B", "C");
var childMixin = GenerateMixin("DefaultSimpleChildParams.ChildParamsMixin", properties, out usedProperties);
childMixin.CheckMixin("A", "B", "C1");
Assert.IsTrue(childMixin.UsedParameters.ContainsKey(Test4.TestParameters.TestCount));
Assert.AreEqual(0, childMixin.UsedParameters.Get(Test4.TestParameters.TestCount));
}
public void TestMixinAndComposeKeys()
{
var properties = new ShaderMixinParameters();
var subCompute1Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute1");
var subCompute2Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute2");
var subComputesKey = TestABC.TestParameters.UseComputeColorRedirect.ComposeWith("SubComputes[0]");
properties.Set(subCompute1Key, true);
properties.Set(subComputesKey, true);
var mixin = GenerateMixin("test_mixin_compose_keys", properties);
mixin.CheckMixin("A");
Assert.AreEqual(3, mixin.Compositions.Count);
Assert.IsTrue(mixin.Compositions.ContainsKey("SubCompute1"));
Assert.IsTrue(mixin.Compositions.ContainsKey("SubCompute2"));
Assert.IsTrue(mixin.Compositions.ContainsKey("SubComputes"));
Assert.AreEqual("mixin ComputeColor2", mixin.Compositions["SubCompute1"].ToString());
Assert.AreEqual("mixin ComputeColor", mixin.Compositions["SubCompute2"].ToString());
Assert.AreEqual("[mixin ComputeColorRedirect [{ColorRedirect = mixin ComputeColor2}]]", mixin.Compositions["SubComputes"].ToString());
}
public CompilerResults Compile(ShaderSource shaderSource, CompilerParameters compilerParameters, HashSet <string> modifiedShaders, HashSet <string> recentlyModifiedShaders)
{
ShaderMixinSourceTree mixinTree;
var shaderMixinGeneratorSource = shaderSource as ShaderMixinGeneratorSource;
var mainUsedParameters = new ShaderMixinParameters();
var usedParameters = new List <ShaderMixinParameters>();
string effectName = null;
if (shaderMixinGeneratorSource != null)
{
effectName = shaderMixinGeneratorSource.Name;
// getting the effect from the used parameters only makes sense when the source files are the same
// TODO: improve this by updating earlyCompilerCache - cache can still be relevant
if (modifiedShaders == null || modifiedShaders.Count == 0)
{
// perform an early test only based on the parameters
var foundCompilerResults = GetShaderFromParameters(effectName, compilerParameters);
if (foundCompilerResults != null)
{
var earlyCompilerResults = new CompilerResults();
earlyCompilerResults.Module = string.Format("EffectCompile [{0}]", effectName);
earlyCompilerResults.MainBytecode = foundCompilerResults.MainBytecode;
earlyCompilerResults.MainUsedParameters = foundCompilerResults.MainUsedParameters;
foreach (var foundBytecode in foundCompilerResults.Bytecodes)
{
earlyCompilerResults.Bytecodes.Add(foundBytecode.Key, foundBytecode.Value);
}
foreach (var foundUsedParameters in foundCompilerResults.UsedParameters)
{
earlyCompilerResults.UsedParameters.Add(foundUsedParameters.Key, foundUsedParameters.Value);
}
return(earlyCompilerResults);
}
}
mixinTree = ShaderMixinManager.Generate(effectName, compilerParameters, out mainUsedParameters, out usedParameters);
}
else
{
effectName = "Effect";
var shaderMixinSource = shaderSource as ShaderMixinSource;
var shaderClassSource = shaderSource as ShaderClassSource;
if (shaderClassSource != null)
{
shaderMixinSource = new ShaderMixinSource();
shaderMixinSource.Mixins.Add(shaderClassSource);
}
if (shaderMixinSource != null)
{
mixinTree = new ShaderMixinSourceTree()
{
Mixin = shaderMixinSource
};
}
else
{
throw new ArgumentException("Unsupported ShaderSource type [{0}]. Supporting only ShaderMixinSource/pdxfx, ShaderClassSource", "shaderSource");
}
}
// Copy global parameters to used Parameters by default, as it is used by the compiler
mainUsedParameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform);
mainUsedParameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile);
mainUsedParameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug);
foreach (var parameters in usedParameters)
{
parameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform);
parameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile);
parameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug);
}
// Compile the whole mixin tree
var compilerResults = new CompilerResults();
compilerResults.Module = string.Format("EffectCompile [{0}]", effectName);
var wasCompiled = Compile(string.Empty, effectName, mixinTree, mainUsedParameters, usedParameters, modifiedShaders, recentlyModifiedShaders, compilerResults);
if (wasCompiled && shaderMixinGeneratorSource != null)
{
lock (earlyCompilerCache)
{
List <CompilerResults> effectCompilerResults;
if (!earlyCompilerCache.TryGetValue(effectName, out effectCompilerResults))
{
effectCompilerResults = new List <CompilerResults>();
earlyCompilerCache.Add(effectName, effectCompilerResults);
}
// Register bytecode used parameters so that they are checked when another effect is instanced
effectCompilerResults.Add(compilerResults);
}
}
return(compilerResults);
}