public void TestRenaming()
{
Init();
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"
};
mixinSource.Mixins.Add(new ShaderClassSource("ShadingBase"));
mixinSource.Mixins.Add(new ShaderClassSource("AlbedoFlatShading"));
mixinSource.AddComposition("albedoDiffuse", compMixin);
var byteCode = Compiler.Compile(mixinSource, MixinParameters.EffectParameters, MixinParameters);
Assert.NotNull(byteCode);
}
public void TestShaderCompilation()
{
Init();
var generics = new string[3];
generics[0] = "Texturing.Texture1";
generics[1] = "TEXCOORD0";
generics[2] = "float4(2.0,1,1,1)";
var compilerParameters = new CompilerParameters();
compilerParameters.Set(EffectSourceCodeKeys.Enable, true);
compilerParameters.EffectParameters.Profile = GraphicsProfile.Level_11_0;
var mixinSource = new ShaderMixinSource {
Name = "TestShaderCompilationGenericClass"
};
mixinSource.Mixins.Add(new ShaderClassSource("GenericClass2", generics));
var log = new CompilerResults();
var compiler = new EffectCompiler(TestHelper.CreateDatabaseProvider().FileProvider);
compiler.SourceDirectories.Add("shaders");
var effectByteCode = compiler.Compile(mixinSource, compilerParameters.EffectParameters, compilerParameters);
}
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 TestStream()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Shaders.Tests\GameAssets\Compiler");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Graphics\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Engine\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Core");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Lights");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Materials");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shadows");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\ComputeColor");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Skinning");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shading");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Transformation");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Utils");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.Direct3D11
};
var results = compiler.Compile(new ShaderClassSource("TestStream"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public void TestStream()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
var currentPath = Core.PlatformFolders.ApplicationBinaryDirectory;
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Shaders.Tests\GameAssets\Compiler"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Graphics\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Core"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Lights"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shadows"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\ComputeColors\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Skinning"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shading"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Transformation"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Utils"));
var compilerParameters = new CompilerParameters {
EffectParameters = { Platform = GraphicsPlatform.Direct3D11 }
};
var results = compiler.Compile(new ShaderClassSource("TestStream"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public EffectData Rebuild()
{
// assemble the source text
var source = GetSource();
// compile the library
var compilationResult = ShaderBytecode.Compile(source, "lib_5_0", ShaderFlags.OptimizationLevel3, EffectFlags.None);
// if compilation failed - try to reset to the initial data and rebuild again
if (compilationResult.HasErrors)
{
if (_isRebuildingAfterReset)
{
// something is messed up, we alraedy tried to rebuild once
throw new InvalidOperationException();
}
try
{
_isRebuildingAfterReset = true;
// reset the data
_data.Reset();
// rebuild
return(Rebuild());
}
finally
{
_isRebuildingAfterReset = false;
}
}
var bytecode = compilationResult.Bytecode;
// create the shader library module
var shaderLibrary = new Module(bytecode);
// create the shader library module instance
var shaderLibraryInstance = new ModuleInstance(shaderLibrary);
// mark the implicit constant buffer (for single parameter) as bindable
shaderLibraryInstance.BindConstantBuffer(0, 0, 0);
// assemble vertex shader
var vertexShaderBytecode = AssembleVertexShader(shaderLibrary, shaderLibraryInstance);
// assemble pixel shader
var pixelShaderBytecode = AssemblePixelShader(shaderLibrary, shaderLibraryInstance);
try
{
// assemble the effect data from the bytecodes
return(_effectCompiler.Compile(vertexShaderBytecode, pixelShaderBytecode));
}
finally
{
_data.IsDirty = false;
}
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine($"Compiling shader: {remoteEffectCompilerEffectRequest.MixinTree.Name}");
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, remoteEffectCompilerEffectRequest.EffectParameters, null).AwaitResult();
// Send compiled shader
await socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer { StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode });
}
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 mixinSourceTree = new ShaderMixinSourceTree {
Name = "testRenaming", Mixin = mixinSource, UsedParameters = MixinParameters
};
var byteCode = Compiler.Compile(mixinSourceTree, new CompilerParameters(), ResultLogger);
Assert.IsNotNull(byteCode);
}
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 TestMixinAndComposeKeys()
{
var compiler = new EffectCompiler(TestHelper.CreateDatabaseProvider().FileProvider)
{
UseFileSystem = true
};
var currentPath = Core.PlatformFolders.ApplicationBinaryDirectory;
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\Stride.Graphics\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\Stride.Shaders.Tests\GameAssets\Mixins"));
var compilerParameters = new CompilerParameters {
EffectParameters = { Platform = GraphicsPlatform.Direct3D11 }
};
var subCompute1Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute1");
var subCompute2Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute2");
var subComputesKey = TestABC.TestParameters.UseComputeColorRedirect.ComposeWith("SubComputes[0]");
compilerParameters.Set(subCompute1Key, true);
compilerParameters.Set(subComputesKey, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("test_mixin_compose_keys"), compilerParameters);
Assert.False(results.HasErrors);
var mainBytecode = results.Bytecode.WaitForResult();
Assert.False(mainBytecode.CompilationLog.HasErrors);
Assert.NotNull(mainBytecode.Bytecode.Reflection.ConstantBuffers);
Assert.Single(mainBytecode.Bytecode.Reflection.ConstantBuffers);
var cbuffer = mainBytecode.Bytecode.Reflection.ConstantBuffers[0];
Assert.NotNull(cbuffer.Members);
Assert.Equal(2, cbuffer.Members.Length);
// Check that ComputeColor2.Color is correctly composed for variables
var computeColorSubCompute2 = ComputeColor2Keys.Color.ComposeWith("SubCompute1");
var computeColorSubComputes = ComputeColor2Keys.Color.ComposeWith("ColorRedirect.SubComputes[0]");
var members = cbuffer.Members.Select(member => member.KeyInfo.KeyName).ToList();
Assert.Contains(computeColorSubCompute2.Name, members);
Assert.Contains(computeColorSubComputes.Name, members);
}
public void TestSimple()
{
VirtualFileSystem.RemountFileSystem("/shaders", "../../../../shaders");
VirtualFileSystem.RemountFileSystem("/compiler", "Compiler");
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
compiler.SourceDirectories.Add("compiler");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.Direct3D11
};
var results = compiler.Compile(new ShaderMixinGeneratorSource("SimpleEffect"), compilerParameters, null, null);
}
public void TestMixinAndComposeKeys()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Graphics\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Shaders.Tests\GameAssets\Mixins");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.Direct3D11
};
var subCompute1Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute1");
var subCompute2Key = TestABC.TestParameters.UseComputeColor2.ComposeWith("SubCompute2");
var subComputesKey = TestABC.TestParameters.UseComputeColorRedirect.ComposeWith("SubComputes[0]");
compilerParameters.Set(subCompute1Key, true);
compilerParameters.Set(subComputesKey, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("test_mixin_compose_keys"), compilerParameters);
Assert.IsFalse(results.HasErrors);
var mainBytecode = results.Bytecode.WaitForResult();
Assert.IsFalse(mainBytecode.CompilationLog.HasErrors);
Assert.NotNull(mainBytecode.Bytecode.Reflection.ConstantBuffers);
Assert.AreEqual(1, mainBytecode.Bytecode.Reflection.ConstantBuffers.Count);
var cbuffer = mainBytecode.Bytecode.Reflection.ConstantBuffers[0];
Assert.NotNull(cbuffer.Members);
Assert.AreEqual(2, cbuffer.Members.Length);
// Check that ComputeColor2.Color is correctly composed for variables
var computeColorSubCompute2 = ComputeColor2Keys.Color.ComposeWith("SubCompute1");
var computeColorSubComputes = ComputeColor2Keys.Color.ComposeWith("ColorRedirect.SubComputes[0]");
var members = cbuffer.Members.Select(member => member.Param.KeyName).ToList();
Assert.IsTrue(members.Contains(computeColorSubCompute2.Name));
Assert.IsTrue(members.Contains(computeColorSubComputes.Name));
}
public void TestGlslESCompiler()
{
VirtualFileSystem.RemountFileSystem("/shaders", "../../../../shaders");
VirtualFileSystem.RemountFileSystem("/baseShaders", "../../../../engine/SiliconStudio.Paradox.Graphics/Shaders");
VirtualFileSystem.RemountFileSystem("/compiler", "Compiler");
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
compiler.SourceDirectories.Add("compiler");
compiler.SourceDirectories.Add("baseShaders");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.OpenGLES
};
var results = compiler.Compile(new ShaderMixinGeneratorSource("ToGlslEffect"), compilerParameters);
}
public void TestGlslESCompiler()
{
VirtualFileSystem.RemountFileSystem("/shaders", "../../../../shaders");
VirtualFileSystem.RemountFileSystem("/baseShaders", "../../../../engine/Stride.Graphics/Shaders");
VirtualFileSystem.RemountFileSystem("/compiler", "Compiler");
var compiler = new EffectCompiler(TestHelper.CreateDatabaseProvider().FileProvider);
compiler.SourceDirectories.Add("shaders");
compiler.SourceDirectories.Add("compiler");
compiler.SourceDirectories.Add("baseShaders");
var compilerParameters = new CompilerParameters {
EffectParameters = { Platform = GraphicsPlatform.OpenGLES }
};
var results = compiler.Compile(new ShaderMixinGeneratorSource("ToGlslEffect"), compilerParameters);
}
public void Compile()
{
Console.WriteLine(@"Inside Thread");
var parameters = new CompilerParameters();
parameters.EffectParameters.Platform = GraphicsPlatform.Direct3D11;
parameters.EffectParameters.Profile = GraphicsProfile.Level_11_0;
var mixinTree = new ShaderMixinSource()
{
Name = "TestParallelMix"
};
var result = effectCompiler.Compile(mixinTree, parameters.EffectParameters, parameters).WaitForResult();
Assert.False(result.CompilationLog.HasErrors);
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");
}
private async void ShaderCompilerRequestHandler(SocketContext clientSocketContext, EffectLogStore recordedEffectCompile, EffectCompiler effectCompiler, ShaderCompilerRequest shaderCompilerRequest)
{
// Wait for a client to be connected
await clientConnectedTCS.Task;
// Yield so that this socket can continue its message loop to answer to shader file request.
await Task.Yield();
Console.WriteLine("Compiling shader");
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(shaderCompilerRequest.MixinTree, null).AwaitResult();
// Record compilation to asset file (only if parent)
recordedEffectCompile[new EffectCompileRequest(shaderCompilerRequest.MixinTree.Name, shaderCompilerRequest.MixinTree.UsedParameters)] = true;
// Send compiled shader
clientSocketContext.Send(new ShaderCompilerAnswer {
StreamId = shaderCompilerRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode
});
}
private static async Task ShaderCompilerRequestHandler(SocketMessageLayer socketMessageLayer, EffectLogStore recordedEffectCompile, EffectCompiler effectCompiler, RemoteEffectCompilerEffectRequest remoteEffectCompilerEffectRequest)
{
// Yield so that this socket can continue its message loop to answer to shader file request
// TODO: maybe not necessary anymore with RouterServiceServer?
await Task.Yield();
Console.WriteLine("Compiling shader");
// Restore MixinTree.UsedParameters (since it is DataMemberIgnore)
remoteEffectCompilerEffectRequest.MixinTree.UsedParameters = remoteEffectCompilerEffectRequest.UsedParameters;
// A shader has been requested, compile it (asynchronously)!
var precompiledEffectShaderPass = await effectCompiler.Compile(remoteEffectCompilerEffectRequest.MixinTree, null).AwaitResult();
// Record compilation to asset file (only if parent)
recordedEffectCompile[new EffectCompileRequest(remoteEffectCompilerEffectRequest.MixinTree.Name, remoteEffectCompilerEffectRequest.MixinTree.UsedParameters)] = true;
// Send compiled shader
socketMessageLayer.Send(new RemoteEffectCompilerEffectAnswer {
StreamId = remoteEffectCompilerEffectRequest.StreamId, EffectBytecode = precompiledEffectShaderPass.Bytecode
});
}
public void TestMaterial()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Graphics\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\engine\SiliconStudio.Paradox.Engine\Shaders");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Core");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Lights");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Materials");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shadows");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\ComputeColor");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Skinning");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Shading");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Transformation");
compiler.SourceDirectories.Add(@"..\..\sources\shaders\Utils");
var compilerParameters = new CompilerParameters {
Platform = GraphicsPlatform.Direct3D11
};
var layers = new MaterialBlendLayers();
layers.Add(new MaterialBlendLayer
{
BlendMap = new ComputeFloat(0.5f),
Material = AttachedReferenceManager.CreateSerializableVersion <Material>(Guid.Empty, "fake")
});
var materialAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color4.White)
},
DiffuseModel = new MaterialDiffuseLambertModelFeature()
},
Layers = layers
};
var fakeAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color.Blue)
},
}
};
var context = new MaterialGeneratorContext {
FindAsset = reference => fakeAsset
};
var result = MaterialGenerator.Generate(new MaterialDescriptor {
Attributes = materialAsset.Attributes, Layers = materialAsset.Layers
}, context, "TestMaterial");
compilerParameters.Set(MaterialKeys.PixelStageSurfaceShaders, result.Material.Parameters.Get(MaterialKeys.PixelStageSurfaceShaders));
var directionalLightGroup = new ShaderClassSource("LightDirectionalGroup", 1);
compilerParameters.Set(LightingKeys.DirectLightGroups, new List <ShaderSource> {
directionalLightGroup
});
//compilerParameters.Set(LightingKeys.CastShadows, false);
//compilerParameters.Set(MaterialParameters.HasSkinningPosition, true);
//compilerParameters.Set(MaterialParameters.HasSkinningNormal, true);
compilerParameters.Set(MaterialKeys.HasNormalMap, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("ParadoxEffectBase"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public void TestMaterial()
{
var compiler = new EffectCompiler {
UseFileSystem = true
};
var currentPath = Core.PlatformFolders.ApplicationBinaryDirectory;
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Graphics\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Core"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Lights"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shadows"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Materials\ComputeColors\Shaders"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Skinning"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Shading"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Transformation"));
compiler.SourceDirectories.Add(Path.Combine(currentPath, @"..\..\sources\engine\SiliconStudio.Xenko.Engine\Rendering\Utils"));
var compilerParameters = new CompilerParameters {
EffectParameters = { Platform = GraphicsPlatform.OpenGL }
};
var layers = new MaterialBlendLayers();
layers.Add(new MaterialBlendLayer
{
BlendMap = new ComputeFloat(0.5f),
Material = AttachedReferenceManager.CreateProxyObject <Material>(AssetId.Empty, "fake")
});
var materialAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color4.White)
},
DiffuseModel = new MaterialDiffuseLambertModelFeature()
},
Layers = layers
};
var fakeAsset = new MaterialAsset
{
Attributes = new MaterialAttributes()
{
Diffuse = new MaterialDiffuseMapFeature()
{
DiffuseMap = new ComputeColor(Color.Blue)
},
}
};
var context = new MaterialGeneratorContext {
FindAsset = reference => fakeAsset
};
var result = MaterialGenerator.Generate(new MaterialDescriptor {
Attributes = materialAsset.Attributes, Layers = materialAsset.Layers
}, context, "TestMaterial");
compilerParameters.Set(MaterialKeys.PixelStageSurfaceShaders, result.Material.Parameters.Get(MaterialKeys.PixelStageSurfaceShaders));
var directionalLightGroup = new ShaderClassSource("LightDirectionalGroup", 1);
compilerParameters.Set(LightingKeys.DirectLightGroups, new ShaderSourceCollection {
directionalLightGroup
});
//compilerParameters.Set(LightingKeys.CastShadows, false);
//compilerParameters.Set(MaterialParameters.HasSkinningPosition, true);
//compilerParameters.Set(MaterialParameters.HasSkinningNormal, true);
compilerParameters.Set(MaterialKeys.HasNormalMap, true);
var results = compiler.Compile(new ShaderMixinGeneratorSource("XenkoEffectBase"), compilerParameters);
Assert.IsFalse(results.HasErrors);
}
public void TestDefaultValuesBeingPresentInReflection()
{
Init();
var shaderClassName = "DefaultValuesTest";
var variables = new List <(string name, string type, string value, object clrValue)>();
variables.Add((name: "floatVar", type: "float", value: "1", clrValue: 1f));
variables.Add((name: "doubleVar", type: "double", value: "1", clrValue: 1d));
variables.Add((name: "intVar", type: "int", value: "1", clrValue: 1));
variables.Add((name: "uintVar", type: "uint", value: "1", clrValue: 1u));
variables.Add((name: "boolVar", type: "bool", value: "true", clrValue: true));
AddVectorVariable(VectorType.Float2, 1f, Vector2.One);
AddVectorVariable(VectorType.Float3, 1f, Vector3.One);
AddVectorVariable(VectorType.Float4, 1f, Vector4.One);
AddVectorVariable(VectorType.Double2, 1d, Double2.One);
AddVectorVariable(VectorType.Double3, 1d, Double3.One);
AddVectorVariable(VectorType.Double4, 1d, Double4.One);
// error X3650: global variables cannot use the 'half' type in vs_5_0. To treat this variable as a float, use the backwards compatibility flag.
//AddVectorVariable(VectorType.Half2, (Half)1f, Half2.One);
//AddVectorVariable(VectorType.Half3, (Half)1f, Half3.One);
//AddVectorVariable(VectorType.Half4, (Half)1f, Half4.One);
AddVectorVariable(VectorType.Int2, 1, Int2.One);
AddVectorVariable(VectorType.Int3, 1, Int3.One);
AddVectorVariable(VectorType.Int4, 1, Int4.One);
AddVectorVariable(VectorType.UInt4, 1u, UInt4.One);
AddVectorVariable(new MatrixType(ScalarType.Float, 4, 4), 1f, new Matrix(1f));
var assignments = new StringBuilder();
foreach (var v in variables)
{
assignments.AppendLine($"{v.type} {v.name} = {v.value};");
}
var mixinSource = new ShaderMixinSource()
{
Name = shaderClassName
};
mixinSource.Mixins.Add(CreateShaderClassCode(shaderClassName, assignments.ToString()));
var byteCodeTask = Compiler.Compile(mixinSource, MixinParameters.EffectParameters, MixinParameters);
Assert.False(byteCodeTask.Result.CompilationLog.HasErrors);
var byteCode = byteCodeTask.Result.Bytecode;
var members = byteCode.Reflection.ConstantBuffers[0].Members;
foreach (var v in variables)
{
var defaultValue = members.FirstOrDefault(k => k.KeyInfo.KeyName == $"{shaderClassName}.{v.name}").DefaultValue;
Assert.NotNull(defaultValue);
Assert.Equal(v.clrValue, defaultValue);
}
unsafe void AddVectorVariable <TVector, TComponent>(TypeBase type, TComponent scalarValue, TVector vectorValue)
where TVector : unmanaged
where TComponent : unmanaged
{
var name = $"{typeof(TVector).Name}Var";
var dimension = sizeof(TVector) / sizeof(TComponent);
var components = string.Join(", ", Enumerable.Repeat(scalarValue, dimension));
variables.Add((
name: name,
type: type.ToString(),
value: $"{type}({components})",
clrValue: vectorValue));
variables.Add((
name: $"{name}_Promoted",
type: type.ToString(),
value: $"{scalarValue}",
clrValue: vectorValue));
variables.Add((
name: $"{name}_Array",
type: type.ToString(),
value: $"{{{components}}}",
clrValue: vectorValue));
var aliasType =
type is MatrixType m ? $"{m.Type}{m.RowCount}x{m.ColumnCount}" :
type is VectorType v ? $"{v.Type}{v.Dimension}" :
default;
if (aliasType != null)
{
// Check type alias like float4 for vector<float, 4>
variables.Add((
name: $"{name}_Alias",
type: aliasType,
value: $"{{{components}}}",
clrValue: vectorValue));
}
}
}
