public CompilerResults Compile(ShaderSource shaderSource, CompilerParameters compilerParameters)
{
ShaderMixinSource mixinToCompile;
var shaderMixinGeneratorSource = shaderSource as ShaderMixinGeneratorSource;
if (shaderMixinGeneratorSource != null)
{
mixinToCompile = ShaderMixinManager.Generate(shaderMixinGeneratorSource.Name, compilerParameters);
}
else
{
mixinToCompile = shaderSource as ShaderMixinSource;
var shaderClassSource = shaderSource as ShaderClassSource;
if (shaderClassSource != null)
{
mixinToCompile = new ShaderMixinSource { Name = shaderClassSource.ClassName };
mixinToCompile.Mixins.Add(shaderClassSource);
}
if (mixinToCompile == null)
{
throw new ArgumentException("Unsupported ShaderSource type [{0}]. Supporting only ShaderMixinSource/pdxfx, ShaderClassSource", "shaderSource");
}
if (string.IsNullOrEmpty(mixinToCompile.Name))
{
throw new ArgumentException("ShaderMixinSource must have a name", "shaderSource");
}
}
// Copy global parameters to used Parameters by default, as it is used by the compiler
mixinToCompile.UsedParameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform);
mixinToCompile.UsedParameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile);
mixinToCompile.UsedParameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug);
// Compile the whole mixin tree
var compilerResults = new CompilerResults { Module = string.Format("EffectCompile [{0}]", mixinToCompile.Name) };
var bytecode = Compile(mixinToCompile, compilerParameters);
// Since bytecode.Result is a struct, we check if any of its member has been set to know if it's valid
if (bytecode.Result.CompilationLog != null || bytecode.Task != null)
{
if (bytecode.Result.CompilationLog != null)
{
bytecode.Result.CompilationLog.CopyTo(compilerResults);
}
compilerResults.Bytecode = bytecode;
compilerResults.UsedParameters = mixinToCompile.UsedParameters;
}
return compilerResults;
}
public void TestNoClean(out CompilerResults left, out CompilerResults right)
{
// Create and mount database file system
var objDatabase = ObjectDatabase.CreateDefaultDatabase();
using (var assetIndexMap = AssetIndexMap.Load(VirtualFileSystem.ApplicationDatabaseIndexPath))
{
var database = new DatabaseFileProvider(assetIndexMap, objDatabase);
AssetManager.GetFileProvider = () => database;
foreach (var shaderName in Directory.EnumerateFiles(@"..\..\sources\shaders", "*.pdxsl"))
CopyStream(database, shaderName);
foreach (var shaderName in Directory.EnumerateFiles(@"..\..\sources\engine\SiliconStudio.Paradox.Shaders.Tests\GameAssets\Compiler", "*.pdxsl"))
CopyStream(database, shaderName);
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("assets/shaders");
var compilerCache = new EffectCompilerCache(compiler);
var compilerParameters = new CompilerParameters {Platform = GraphicsPlatform.Direct3D11};
left = compilerCache.Compile(new ShaderMixinGeneratorSource("SimpleEffect"), compilerParameters);
right = compilerCache.Compile(new ShaderMixinGeneratorSource("SimpleEffect"), 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());
}
private Effect CreateEffect(string effectName, EffectBytecodeCompilerResult effectBytecodeCompilerResult, CompilerResults compilerResult)
{
Effect effect;
lock (cachedEffects)
{
if (!isInitialized)
throw new InvalidOperationException("EffectSystem has been disposed. This Effect compilation has been cancelled.");
var usedParameters = compilerResult.UsedParameters;
if (effectBytecodeCompilerResult.CompilationLog.HasErrors)
{
// Unregister result (or should we keep it so that failure never change?)
List<CompilerResults> effectCompilerResults;
if (earlyCompilerCache.TryGetValue(effectName, out effectCompilerResults))
{
effectCompilerResults.Remove(compilerResult);
}
}
CheckResult(effectBytecodeCompilerResult.CompilationLog);
var bytecode = effectBytecodeCompilerResult.Bytecode;
if (bytecode == null)
throw new InvalidOperationException("EffectCompiler returned no shader and no compilation error.");
if (!cachedEffects.TryGetValue(bytecode, out effect))
{
effect = new Effect(graphicsDeviceService.GraphicsDevice, bytecode, usedParameters) { Name = effectName };
cachedEffects.Add(bytecode, effect);
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
foreach (var type in bytecode.HashSources.Keys)
{
// TODO: the "/path" is hardcoded, used in ImportStreamCommand and ShaderSourceManager. Find a place to share this correctly.
using (var pathStream = FileProvider.OpenStream(EffectCompilerBase.GetStoragePathFromShaderType(type) + "/path", VirtualFileMode.Open, VirtualFileAccess.Read))
using (var reader = new StreamReader(pathStream))
{
var path = reader.ReadToEnd();
directoryWatcher.Track(path);
}
}
#endif
}
}
return effect;
}