/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="compilerParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, CompilerParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isOpenGLES = compilerParameters.EffectParameters.Platform == GraphicsPlatform.OpenGLES;
var isOpenGLES3 = compilerParameters.EffectParameters.Profile >= GraphicsProfile.Level_10_0;
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var shader = Compile(shaderSource, entryPoint, stage, isOpenGLES, isOpenGLES3, shaderBytecodeResult, reflection, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (isOpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (isOpenGLES3)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, true, true, shaderBytecodeResult, reflection, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="compilerParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, ShaderMixinParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isOpenGLES = compilerParameters.Get(CompilerParameters.GraphicsPlatformKey) == GraphicsPlatform.OpenGLES;
var isOpenGLES3 = compilerParameters.Get(CompilerParameters.GraphicsProfileKey) >= GraphicsProfile.Level_10_0;
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var shader = Compile(shaderSource, entryPoint, stage, isOpenGLES, isOpenGLES3, shaderBytecodeResult, sourceFilename);
if (shader == null)
return shaderBytecodeResult;
if (isOpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (isOpenGLES3)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, true, true, shaderBytecodeResult, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return shaderBytecodeResult;
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="compilerParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, ShaderMixinParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isOpenGLES = compilerParameters.Get(CompilerParameters.GraphicsPlatformKey) == GraphicsPlatform.OpenGLES;
var isOpenGLES3 = compilerParameters.Get(CompilerParameters.GraphicsProfileKey) >= GraphicsProfile.Level_10_0;
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var shader = Compile(shaderSource, entryPoint, stage, isOpenGLES, isOpenGLES3, shaderBytecodeResult, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (isOpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (isOpenGLES3)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, true, true, shaderBytecodeResult, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.GetBuffer();
}
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, ShaderMixinParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isDebug = compilerParameters.Get(CompilerParameters.DebugKey);
var profile = compilerParameters.Get(CompilerParameters.GraphicsProfileKey);
var shaderModel = ShaderStageToString(stage) + "_" + ShaderProfileFromGraphicsProfile(profile);
var shaderFlags = ShaderFlags.None;
if (isDebug)
{
shaderFlags = ShaderFlags.OptimizationLevel0 | ShaderFlags.Debug;
}
SharpDX.Configuration.ThrowOnShaderCompileError = false;
// Compile using D3DCompiler
var compilationResult = SharpDX.D3DCompiler.ShaderBytecode.Compile(shaderSource, entryPoint, shaderModel, shaderFlags, EffectFlags.None, null, null, sourceFilename);
var byteCodeResult = new ShaderBytecodeResult();
if (compilationResult.HasErrors || compilationResult.Bytecode == null)
{
// Log compilation errors
byteCodeResult.Error(compilationResult.Message);
}
else
{
// As effect bytecode binary can changed when having debug infos (with d3dcompiler_47), we are calculating a bytecodeId on the stripped version
var rawData = compilationResult.Bytecode.Strip(StripFlags.CompilerStripDebugInformation | StripFlags.CompilerStripReflectionData);
var bytecodeId = ObjectId.FromBytes(rawData);
byteCodeResult.Bytecode = new ShaderBytecode(bytecodeId, compilationResult.Bytecode.Data)
{
Stage = stage
};
// If compilation succeed, then we can update reflection.
UpdateReflection(byteCodeResult.Bytecode, reflection, byteCodeResult);
if (!string.IsNullOrEmpty(compilationResult.Message))
{
byteCodeResult.Warning(compilationResult.Message);
}
}
return(byteCodeResult);
}
private string RunOptimizer(ShaderBytecodeResult shaderBytecodeResult, string baseShader, GlslShaderPlatform shaderPlatform, int shaderVersion, bool vertex)
{
lock (GlslOptimizerLock)
{
IntPtr ctx = IntPtr.Zero;
var inputShader = baseShader;
if (shaderPlatform == GlslShaderPlatform.OpenGLES)
{
if (shaderVersion >= 300)
{
ctx = glslopt_initialize(2); // kGlslTargetOpenGLES30
}
else
{
ctx = glslopt_initialize(1); // kGlslTargetOpenGLES20
}
}
else
{
ctx = glslopt_initialize(0); // kGlslTargetOpenGL
}
int type = vertex ? 0 : 1;
var shader = glslopt_optimize(ctx, type, inputShader, 0);
bool optimizeOk = glslopt_get_status(shader);
string shaderAsString = null;
if (optimizeOk)
{
IntPtr optShader = glslopt_get_output(shader);
shaderAsString = Marshal.PtrToStringAnsi(optShader);
}
else
{
IntPtr log = glslopt_get_log(shader);
var logAsString = Marshal.PtrToStringAnsi(log);
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n glsl_opt: {0}", string.Join("\r\n glsl_opt: ", logAsString.Split(new[] { "\n", "\r", "\r\n" }, StringSplitOptions.RemoveEmptyEntries)));
}
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return(shaderAsString);
}
}
private string RunOptimizer(ShaderBytecodeResult shaderBytecodeResult, string baseShader, bool openGLES, bool es30, bool vertex)
{
lock (GlslOptimizerLock)
{
IntPtr ctx = IntPtr.Zero;
var inputShader = baseShader;
if (openGLES)
{
if (es30)
{
ctx = glslopt_initialize(2); // kGlslTargetOpenGLES30
}
else
{
ctx = glslopt_initialize(1); // kGlslTargetOpenGLES20
}
}
else
{
ctx = glslopt_initialize(0); // kGlslTargetOpenGL
}
int type = vertex ? 0 : 1;
var shader = glslopt_optimize(ctx, type, inputShader, 0);
bool optimizeOk = glslopt_get_status(shader);
string shaderAsString = null;
if (optimizeOk)
{
IntPtr optShader = glslopt_get_output(shader);
shaderAsString = Marshal.PtrToStringAnsi(optShader);
}
else
{
IntPtr log = glslopt_get_log(shader);
var logAsString = Marshal.PtrToStringAnsi(log);
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", logAsString);
}
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return(shaderAsString);
}
}
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, ShaderMixinParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isDebug = compilerParameters.Get(CompilerParameters.DebugKey);
var profile = compilerParameters.Get(CompilerParameters.GraphicsProfileKey);
var shaderModel = ShaderStageToString(stage) + "_" + ShaderProfileFromGraphicsProfile(profile);
var shaderFlags = ShaderFlags.None;
if (isDebug)
{
shaderFlags = ShaderFlags.OptimizationLevel0 | ShaderFlags.Debug;
}
SharpDX.Configuration.ThrowOnShaderCompileError = false;
// Compile using D3DCompiler
var compilationResult = SharpDX.D3DCompiler.ShaderBytecode.Compile(shaderSource, entryPoint, shaderModel, shaderFlags, EffectFlags.None, null, null, sourceFilename);
var byteCodeResult = new ShaderBytecodeResult();
if (compilationResult.HasErrors)
{
// Log compilation errors
byteCodeResult.Error(compilationResult.Message);
}
else
{
// As effect bytecode binary can changed when having debug infos (with d3dcompiler_47), we are calculating a bytecodeId on the stripped version
var rawData = compilationResult.Bytecode.Strip(StripFlags.CompilerStripDebugInformation | StripFlags.CompilerStripReflectionData);
var bytecodeId = ObjectId.FromBytes(rawData);
byteCodeResult.Bytecode = new ShaderBytecode(bytecodeId, compilationResult.Bytecode.Data) { Stage = stage };
// If compilation succeed, then we can update reflection.
UpdateReflection(byteCodeResult.Bytecode, reflection, byteCodeResult);
if (!string.IsNullOrEmpty(compilationResult.Message))
{
byteCodeResult.Warning(compilationResult.Message);
}
}
return byteCodeResult;
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, GlslShaderPlatform shaderPlatform, int shaderVersion, ShaderBytecodeResult shaderBytecodeResult, EffectReflection reflection, IDictionary <int, string> inputAttributeNames, Dictionary <string, int> resourceBindings, string sourceFilename = null)
{
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 300 && renderTargetCount > 1)
{
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
}
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
{
return(null);
}
Shader glslShader;
// null entry point means no shader. In that case, we return a default function in HlslToGlslWriter
// TODO: support that directly in HlslToGlslConvertor?
if (entryPoint == null)
{
glslShader = null;
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(shaderPlatform, shaderVersion);
glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, inputAttributeNames, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
{
return(null);
}
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
// Update constant buffer itself (first time only)
var reflectionConstantBuffer = reflection.ConstantBuffers.FirstOrDefault(x => x.Name == constantBuffer.Name && x.Size == 0);
if (reflectionConstantBuffer != null)
{
// Used to compute constant buffer size and member offsets (std140 rule)
int constantBufferOffset = 0;
// Fill members
for (int index = 0; index < reflectionConstantBuffer.Members.Length; index++)
{
var member = reflectionConstantBuffer.Members[index];
// Properly compute size and offset according to std140 rules
var memberSize = ComputeMemberSize(ref member.Type, ref constantBufferOffset);
// Store size/offset info
member.Offset = constantBufferOffset;
member.Size = memberSize;
// Adjust offset for next item
constantBufferOffset += memberSize;
reflectionConstantBuffer.Members[index] = member;
}
reflectionConstantBuffer.Size = constantBufferOffset;
}
// Find binding
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == constantBuffer.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
foreach (var variable in glslShader.Declarations.OfType <Variable>().Where(x => (x.Qualifiers.Contains(StorageQualifier.Uniform))))
{
// Check if we have a variable that starts or ends with this name (in case of samplers)
// TODO: Have real AST support for all the list in Keywords.glsl
if (variable.Type.Name.Text.Contains("sampler1D") ||
variable.Type.Name.Text.Contains("sampler2D") ||
variable.Type.Name.Text.Contains("sampler3D") ||
variable.Type.Name.Text.Contains("samplerCube") ||
variable.Type.Name.Text.Contains("samplerBuffer"))
{
// TODO: Make more robust
var textureBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().StartsWith(x.RawName));
var samplerBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().EndsWith(x.RawName));
if (textureBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, textureBindingIndex, stage);
}
if (samplerBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, samplerBindingIndex, stage);
}
}
else
{
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == variable.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
}
if (shaderPlatform == GlslShaderPlatform.Vulkan)
{
// Defines the ordering of resource groups in Vulkan. This is mirrored in the PipelineState
var resourceGroups = reflection.ResourceBindings.Select(x => x.ResourceGroup ?? "Globals").Distinct().ToList();
// Register "NoSampler", required by HLSL=>GLSL translation to support HLSL such as texture.Load().
var noSampler = new EffectResourceBindingDescription {
KeyInfo = { KeyName = "NoSampler" }, RawName = "NoSampler", Class = EffectParameterClass.Sampler, SlotStart = -1, SlotCount = 1
};
reflection.ResourceBindings.Add(noSampler);
var bindings = resourceGroups.SelectMany(resourceGroup => reflection.ResourceBindings
.Where(x => x.ResourceGroup == resourceGroup || (x.ResourceGroup == null && resourceGroup == "Globals"))
.GroupBy(x => new { KeyName = x.KeyInfo.KeyName, RawName = x.RawName, Class = x.Class, Type = x.Type, SlotCount = x.SlotCount, LogicalGroup = x.LogicalGroup })
.OrderBy(x => x.Key.Class == EffectParameterClass.ConstantBuffer ? 0 : 1))
.ToList();
// Add layout(set, bindings) qualifier to all constant buffers
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
var layoutBindingIndex = bindings.IndexOf(x => x.Key.RawName == constantBuffer.Name);
if (layoutBindingIndex != -1)
{
var layoutQualifier = constantBuffer.Qualifiers.OfType <Xenko.Core.Shaders.Ast.Glsl.LayoutQualifier>().FirstOrDefault();
if (layoutQualifier == null)
{
layoutQualifier = new Xenko.Core.Shaders.Ast.Glsl.LayoutQualifier();
constantBuffer.Qualifiers |= layoutQualifier;
}
//layoutQualifier.Layouts.Add(new LayoutKeyValue("set", resourceGroups.IndexOf(resourceGroup)));
layoutQualifier.Layouts.Add(new LayoutKeyValue("set", 0));
layoutQualifier.Layouts.Add(new LayoutKeyValue("binding", layoutBindingIndex + 1));
resourceBindings.Add(bindings[layoutBindingIndex].Key.KeyName, layoutBindingIndex + 1);
}
}
// Add layout(set, bindings) qualifier to all other uniforms
foreach (var variable in glslShader.Declarations.OfType <Variable>().Where(x => (x.Qualifiers.Contains(StorageQualifier.Uniform))))
{
var layoutBindingIndex = bindings.IndexOf(x => variable.Name.Text.StartsWith(x.Key.RawName));
if (layoutBindingIndex != -1)
{
var layoutQualifier = variable.Qualifiers.OfType <Xenko.Core.Shaders.Ast.Glsl.LayoutQualifier>().FirstOrDefault();
if (layoutQualifier == null)
{
layoutQualifier = new Xenko.Core.Shaders.Ast.Glsl.LayoutQualifier();
variable.Qualifiers |= layoutQualifier;
}
//layoutQualifier.Layouts.Add(new LayoutKeyValue("set", resourceGroups.IndexOf(resourceGroup)));
layoutQualifier.Layouts.Add(new LayoutKeyValue("set", 0));
layoutQualifier.Layouts.Add(new LayoutKeyValue("binding", layoutBindingIndex + 1));
resourceBindings.Add(bindings[layoutBindingIndex].Key.KeyName, layoutBindingIndex + 1);
}
}
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter(shaderPlatform, shaderVersion, pipelineStage);
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 320)
{
glslShaderWriter.ExtraHeaders = "#define texelFetchBufferPlaceholder";
}
// Write shader
glslShaderWriter.Visit(glslShader);
var shaderString = glslShaderWriter.Text;
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
//if (isOpenGLES)
//{
// if (isOpenGLES3)
// {
// glslShaderCode
// .AppendLine("#version 300 es") // TODO: 310 version?
// .AppendLine();
// }
//
// if (pipelineStage == PipelineStage.Pixel)
// glslShaderCode
// .AppendLine("precision highp float;")
// .AppendLine();
//}
//else
//{
// glslShaderCode
// .AppendLine("#version 420")
// .AppendLine()
// .AppendLine("#define samplerBuffer sampler2D")
// .AppendLine("#define isamplerBuffer isampler2D")
// .AppendLine("#define usamplerBuffer usampler2D")
// .AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, ivec2((P) & 0xFFF, (P) >> 12), 0)");
// //.AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, P)");
//}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
return(realShaderSource);
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, GlslShaderPlatform shaderPlatform, int shaderVersion, ShaderBytecodeResult shaderBytecodeResult, EffectReflection reflection, string sourceFilename = null)
{
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 300 && renderTargetCount > 1)
{
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
}
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
{
return(null);
}
Shader glslShader;
// null entry point means no shader. In that case, we return a default function in HlslToGlslWriter
// TODO: support that directly in HlslToGlslConvertor?
if (entryPoint == null)
{
glslShader = null;
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(shaderPlatform, shaderVersion);
glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
{
return(null);
}
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
// Update constant buffer itself (first time only)
var reflectionConstantBuffer = reflection.ConstantBuffers.FirstOrDefault(x => x.Name == constantBuffer.Name && x.Size == 0);
if (reflectionConstantBuffer != null)
{
// Used to compute constant buffer size and member offsets (std140 rule)
int constantBufferOffset = 0;
// Fill members
for (int index = 0; index < reflectionConstantBuffer.Members.Length; index++)
{
var member = reflectionConstantBuffer.Members[index];
// Properly compute size and offset according to std140 rules
var memberSize = ComputeMemberSize(ref member.Type, ref constantBufferOffset);
// Store size/offset info
member.Offset = constantBufferOffset;
member.Size = memberSize;
// Adjust offset for next item
constantBufferOffset += memberSize;
reflectionConstantBuffer.Members[index] = member;
}
reflectionConstantBuffer.Size = constantBufferOffset;
}
// Find binding
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == constantBuffer.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
foreach (var variable in glslShader.Declarations.OfType <Variable>().Where(x => (x.Qualifiers.Contains(StorageQualifier.Uniform))))
{
// Check if we have a variable that starts or ends with this name (in case of samplers)
// TODO: Have real AST support for all the list in Keywords.glsl
if (variable.Type.Name.Text.Contains("sampler1D") ||
variable.Type.Name.Text.Contains("sampler2D") ||
variable.Type.Name.Text.Contains("sampler3D") ||
variable.Type.Name.Text.Contains("samplerCube"))
{
// TODO: Make more robust
var textureBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().StartsWith(x.RawName));
var samplerBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().EndsWith(x.RawName));
if (textureBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, textureBindingIndex, stage);
}
if (samplerBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, samplerBindingIndex, stage);
}
}
else
{
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == variable.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter(shaderPlatform, shaderVersion, pipelineStage);
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 320)
{
glslShaderWriter.ExtraHeaders = "#define texelFetchBufferPlaceholder";
}
// Write shader
glslShaderWriter.Visit(glslShader);
var shaderString = glslShaderWriter.Text;
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
//if (isOpenGLES)
//{
// if (isOpenGLES3)
// {
// glslShaderCode
// .AppendLine("#version 300 es") // TODO: 310 version?
// .AppendLine();
// }
//
// if (pipelineStage == PipelineStage.Pixel)
// glslShaderCode
// .AppendLine("precision highp float;")
// .AppendLine();
//}
//else
//{
// glslShaderCode
// .AppendLine("#version 420")
// .AppendLine()
// .AppendLine("#define samplerBuffer sampler2D")
// .AppendLine("#define isamplerBuffer isampler2D")
// .AppendLine("#define usamplerBuffer usampler2D")
// .AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, ivec2((P) & 0xFFF, (P) >> 12), 0)");
// //.AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, P)");
//}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
// optimize shader
try
{
var optShaderSource = RunOptimizer(shaderBytecodeResult, realShaderSource, shaderPlatform, shaderVersion, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
{
realShaderSource = optShaderSource;
}
}
catch (Exception e)
{
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", e.Message);
}
#else
shaderBytecodeResult.Warning("GLSL optimized has not been executed because it is currently not supported on this platform.");
#endif
return(realShaderSource);
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, GlslShaderPlatform shaderPlatform, int shaderVersion, ShaderBytecodeResult shaderBytecodeResult, EffectReflection reflection, string sourceFilename = null)
{
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 300 && renderTargetCount > 1)
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
return null;
Shader glslShader;
// null entry point means no shader. In that case, we return a default function in HlslToGlslWriter
// TODO: support that directly in HlslToGlslConvertor?
if (entryPoint == null)
{
glslShader = null;
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(shaderPlatform, shaderVersion);
glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
return null;
foreach (var constantBuffer in glslShader.Declarations.OfType<ConstantBuffer>())
{
// Update constant buffer itself (first time only)
var reflectionConstantBuffer = reflection.ConstantBuffers.FirstOrDefault(x => x.Name == constantBuffer.Name && x.Size == 0);
if (reflectionConstantBuffer != null)
{
// Used to compute constant buffer size and member offsets (std140 rule)
int constantBufferOffset = 0;
// Fill members
for (int index = 0; index < reflectionConstantBuffer.Members.Length; index++)
{
var member = reflectionConstantBuffer.Members[index];
// Properly compute size and offset according to std140 rules
var memberSize = ComputeMemberSize(ref member.Type, ref constantBufferOffset);
// Store size/offset info
member.Offset = constantBufferOffset;
member.Size = memberSize;
// Adjust offset for next item
constantBufferOffset += memberSize;
reflectionConstantBuffer.Members[index] = member;
}
reflectionConstantBuffer.Size = constantBufferOffset;
}
// Find binding
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == constantBuffer.Name);
if (resourceBindingIndex != -1)
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
foreach (var variable in glslShader.Declarations.OfType<Variable>().Where(x => (x.Qualifiers.Contains(StorageQualifier.Uniform))))
{
// Check if we have a variable that starts or ends with this name (in case of samplers)
// TODO: Have real AST support for all the list in Keywords.glsl
if (variable.Type.Name.Text.Contains("sampler1D")
|| variable.Type.Name.Text.Contains("sampler2D")
|| variable.Type.Name.Text.Contains("sampler3D")
|| variable.Type.Name.Text.Contains("samplerCube"))
{
// TODO: Make more robust
var textureBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().StartsWith(x.RawName));
var samplerBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().EndsWith(x.RawName));
if (textureBindingIndex != -1)
MarkResourceBindingAsUsed(reflection, textureBindingIndex, stage);
if (samplerBindingIndex != -1)
MarkResourceBindingAsUsed(reflection, samplerBindingIndex, stage);
}
else
{
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.RawName == variable.Name);
if (resourceBindingIndex != -1)
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter(shaderPlatform, shaderVersion, pipelineStage);
if (shaderPlatform == GlslShaderPlatform.OpenGLES && shaderVersion < 320)
{
glslShaderWriter.ExtraHeaders = "#define texelFetchBufferPlaceholder";
}
// Write shader
glslShaderWriter.Visit(glslShader);
var shaderString = glslShaderWriter.Text;
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
//if (isOpenGLES)
//{
// if (isOpenGLES3)
// {
// glslShaderCode
// .AppendLine("#version 300 es") // TODO: 310 version?
// .AppendLine();
// }
//
// if (pipelineStage == PipelineStage.Pixel)
// glslShaderCode
// .AppendLine("precision highp float;")
// .AppendLine();
//}
//else
//{
// glslShaderCode
// .AppendLine("#version 420")
// .AppendLine()
// .AppendLine("#define samplerBuffer sampler2D")
// .AppendLine("#define isamplerBuffer isampler2D")
// .AppendLine("#define usamplerBuffer usampler2D")
// .AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, ivec2((P) & 0xFFF, (P) >> 12), 0)");
// //.AppendLine("#define texelFetchBuffer(sampler, P) texelFetch(sampler, P)");
//}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
// optimize shader
try
{
var optShaderSource = RunOptimizer(shaderBytecodeResult, realShaderSource, shaderPlatform, shaderVersion, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
realShaderSource = optShaderSource;
}
catch (Exception e)
{
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", e.Message);
}
#else
shaderBytecodeResult.Warning("GLSL optimized has not been executed because it is currently not supported on this platform.");
#endif
return realShaderSource;
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, bool isOpenGLES, bool isOpenGLES3, ShaderBytecodeResult shaderBytecodeResult, EffectReflection reflection, string sourceFilename = null)
{
if (isOpenGLES && !isOpenGLES3 && renderTargetCount > 1)
{
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
}
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
{
return(null);
}
string shaderString = null;
var generateUniformBlocks = isOpenGLES && isOpenGLES3;
// null entry point for pixel shader means no pixel shader. In that case, we return a default function.
if (entryPoint == null && stage == ShaderStage.Pixel && isOpenGLES)
{
shaderString = "out float fragmentdepth; void main(){ fragmentdepth = gl_FragCoord.z; }";
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(isOpenGLES, isOpenGLES3);
var glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
{
return(null);
}
// Add std140 layout
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
if (isOpenGLES3) // TODO: for OpenGL too?
{
var layoutQualifier = constantBuffer.Qualifiers.OfType <SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier>().FirstOrDefault();
if (layoutQualifier == null)
{
layoutQualifier = new SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier();
constantBuffer.Qualifiers |= layoutQualifier;
}
layoutQualifier.Layouts.Add(new LayoutKeyValue("std140"));
}
else
{
constantBuffer.Qualifiers |= new LayoutQualifier(new LayoutKeyValue("std140"));
}
}
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
// Update constant buffer itself (first time only)
var reflectionConstantBuffer = reflection.ConstantBuffers.FirstOrDefault(x => x.Name == constantBuffer.Name && x.Size == 0);
if (reflectionConstantBuffer != null)
{
// Used to compute constant buffer size and member offsets (std140 rule)
int constantBufferOffset = 0;
// Fill members
for (int index = 0; index < reflectionConstantBuffer.Members.Length; index++)
{
var member = reflectionConstantBuffer.Members[index];
// Properly compute size and offset according to std140 rules
var memberSize = ComputeMemberSize(ref member, ref constantBufferOffset);
member.Offset = constantBufferOffset;
member.Size = memberSize;
// Adjust offset for next item
constantBufferOffset += memberSize;
reflectionConstantBuffer.Members[index] = member;
}
reflectionConstantBuffer.Size = constantBufferOffset;
reflectionConstantBuffer.Stage = stage; // Should we store a flag/bitfield?
}
// Find binding
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.Param.RawName == constantBuffer.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
foreach (var variable in glslShader.Declarations.OfType <Variable>().Where(x => (x.Qualifiers.Contains(StorageQualifier.Uniform))))
{
// Check if we have a variable that starts or ends with this name (in case of samplers)
// TODO: Have real AST support for all the list in Keywords.glsl
if (variable.Type.Name.Text.Contains("sampler1D") ||
variable.Type.Name.Text.Contains("sampler2D") ||
variable.Type.Name.Text.Contains("sampler3D") ||
variable.Type.Name.Text.Contains("samplerCube"))
{
// TODO: Make more robust
var textureBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().StartsWith(x.Param.RawName));
var samplerBindingIndex = reflection.ResourceBindings.IndexOf(x => variable.Name.ToString().EndsWith(x.Param.RawName));
if (textureBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, textureBindingIndex, stage);
}
if (samplerBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, samplerBindingIndex, stage);
}
}
else
{
var resourceBindingIndex = reflection.ResourceBindings.IndexOf(x => x.Param.RawName == variable.Name);
if (resourceBindingIndex != -1)
{
MarkResourceBindingAsUsed(reflection, resourceBindingIndex, stage);
}
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter();
if (isOpenGLES)
{
glslShaderWriter.TrimFloatSuffix = true;
glslShaderWriter.GenerateUniformBlocks = generateUniformBlocks;
if (!isOpenGLES3)
{
foreach (var variable in glslShader.Declarations.OfType <Variable>())
{
if (variable.Qualifiers.Contains(ParameterQualifier.In))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.In);
// "in" becomes "attribute" in VS, "varying" in other stages
variable.Qualifiers.Values.Add(
pipelineStage == PipelineStage.Vertex
? global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Attribute
: global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
if (variable.Qualifiers.Contains(ParameterQualifier.Out))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.Out);
variable.Qualifiers.Values.Add(global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
}
}
}
// Write shader
glslShaderWriter.Visit(glslShader);
shaderString = glslShaderWriter.Text;
}
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
if (isOpenGLES)
{
if (isOpenGLES3)
{
glslShaderCode
.AppendLine("#version 300 es") // TODO: 310 version?
.AppendLine();
}
if (pipelineStage == PipelineStage.Pixel)
{
glslShaderCode
.AppendLine("precision highp float;")
.AppendLine();
}
}
else
{
glslShaderCode
.AppendLine("#version 420")
.AppendLine();
}
if ((!isOpenGLES || isOpenGLES3) && pipelineStage == PipelineStage.Pixel && renderTargetCount > 0)
{
// TODO: identifiers starting with "gl_" should be reserved. Compilers usually accept them but it may should be prevented.
glslShaderCode
.AppendLine("#define gl_FragData _glesFragData")
.AppendLine("out vec4 gl_FragData[" + renderTargetCount + "];")
.AppendLine();
}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
// optimize shader
try
{
var optShaderSource = RunOptimizer(shaderBytecodeResult, realShaderSource, isOpenGLES, isOpenGLES3, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
{
realShaderSource = optShaderSource;
}
}
catch (Exception e)
{
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", e.Message);
}
#else
shaderBytecodeResult.Warning("GLSL optimized has not been executed because it is currently not supported on this platform.");
#endif
return(realShaderSource);
}
private string RunOptimizer(ShaderBytecodeResult shaderBytecodeResult, string baseShader, GlslShaderPlatform shaderPlatform, int shaderVersion, bool vertex)
{
lock (GlslOptimizerLock)
{
IntPtr ctx = IntPtr.Zero;
var inputShader = baseShader;
if (shaderPlatform == GlslShaderPlatform.OpenGLES)
{
if (shaderVersion >= 300)
ctx = glslopt_initialize(2); // kGlslTargetOpenGLES30
else
ctx = glslopt_initialize(1); // kGlslTargetOpenGLES20
}
else
{
ctx = glslopt_initialize(0); // kGlslTargetOpenGL
}
int type = vertex ? 0 : 1;
var shader = glslopt_optimize(ctx, type, inputShader, 0);
bool optimizeOk = glslopt_get_status(shader);
string shaderAsString = null;
if (optimizeOk)
{
IntPtr optShader = glslopt_get_output(shader);
shaderAsString = Marshal.PtrToStringAnsi(optShader);
}
else
{
IntPtr log = glslopt_get_log(shader);
var logAsString = Marshal.PtrToStringAnsi(log);
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n glsl_opt: {0}", string.Join("\r\n glsl_opt: ", logAsString.Split(new[] { "\n", "\r", "\r\n" }, StringSplitOptions.RemoveEmptyEntries)));
}
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return shaderAsString;
}
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var inputAttributeNames = new Dictionary <int, string>();
var resourceBindings = new Dictionary <string, int>();
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.Vulkan:
shaderPlatform = GlslShaderPlatform.Vulkan;
shaderVersion = 450;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (effectParameters.Platform == GraphicsPlatform.Vulkan)
{
string inputFileExtension;
switch (stage)
{
case ShaderStage.Vertex: inputFileExtension = ".vert"; break;
case ShaderStage.Pixel: inputFileExtension = ".frag"; break;
case ShaderStage.Geometry: inputFileExtension = ".geom"; break;
case ShaderStage.Domain: inputFileExtension = ".tese"; break;
case ShaderStage.Hull: inputFileExtension = ".tesc"; break;
case ShaderStage.Compute: inputFileExtension = ".comp"; break;
default:
shaderBytecodeResult.Error("Unknown shader profile");
return(shaderBytecodeResult);
}
var inputFileName = Path.ChangeExtension(Path.GetTempFileName(), inputFileExtension);
var outputFileName = Path.ChangeExtension(inputFileName, ".spv");
// Write shader source to disk
File.WriteAllBytes(inputFileName, Encoding.ASCII.GetBytes(shader));
// Run shader compiler
var filename = Platform.Type == PlatformType.Windows ? "glslangValidator.exe" : "glslangValidator";
ShellHelper.RunProcessAndRedirectToLogger(filename, $"-V -o {outputFileName} {inputFileName}", null, shaderBytecodeResult);
if (!File.Exists(outputFileName))
{
shaderBytecodeResult.Error("Failed to generate SPIR-V from GLSL");
return(shaderBytecodeResult);
}
// Read compiled shader
var shaderBytecodes = new ShaderInputBytecode
{
InputAttributeNames = inputAttributeNames,
ResourceBindings = resourceBindings,
Data = File.ReadAllBytes(outputFileName),
};
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.ToArray();
}
// Cleanup temp files
File.Delete(inputFileName);
File.Delete(outputFileName);
}
else
{
// store string on OpenGL platforms
rawData = Encoding.UTF8.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.OpenGL:
shaderPlatform = GlslShaderPlatform.OpenGL;
shaderVersion = 420;
break;
case GraphicsPlatform.OpenGLES:
shaderPlatform = GlslShaderPlatform.OpenGLES;
shaderVersion = effectParameters.Profile >= GraphicsProfile.Level_10_0 ? 300 : 100;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (effectParameters.Platform == GraphicsPlatform.OpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (effectParameters.Profile >= GraphicsProfile.Level_10_0)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, GlslShaderPlatform.OpenGLES, 300, shaderBytecodeResult, reflection, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var inputAttributeNames = new Dictionary <int, string>();
var resourceBindings = new Dictionary <string, int>();
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.OpenGL:
shaderPlatform = GlslShaderPlatform.OpenGL;
shaderVersion = 420;
break;
case GraphicsPlatform.OpenGLES:
shaderPlatform = GlslShaderPlatform.OpenGLES;
shaderVersion = effectParameters.Profile >= GraphicsProfile.Level_10_0 ? 300 : 100;
break;
case GraphicsPlatform.Vulkan:
shaderPlatform = GlslShaderPlatform.Vulkan;
shaderVersion = 450;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (effectParameters.Platform == GraphicsPlatform.OpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (effectParameters.Profile >= GraphicsProfile.Level_10_0)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, GlslShaderPlatform.OpenGLES, 300, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
else if (effectParameters.Platform == GraphicsPlatform.Vulkan)
{
string inputFileExtension;
switch (stage)
{
case ShaderStage.Vertex: inputFileExtension = ".vert"; break;
case ShaderStage.Pixel: inputFileExtension = ".frag"; break;
case ShaderStage.Geometry: inputFileExtension = ".geom"; break;
case ShaderStage.Domain: inputFileExtension = ".tese"; break;
case ShaderStage.Hull: inputFileExtension = ".tesc"; break;
case ShaderStage.Compute: inputFileExtension = ".comp"; break;
default:
shaderBytecodeResult.Error("Unknown shader profile");
return(shaderBytecodeResult);
}
var inputFileName = Path.ChangeExtension(Path.GetTempFileName(), inputFileExtension);
var outputFileName = Path.ChangeExtension(inputFileName, ".spv");
// Write shader source to disk
File.WriteAllBytes(inputFileName, Encoding.ASCII.GetBytes(shader));
// Run shader compiler
var process = new Process
{
StartInfo =
{
FileName = "glslangValidator.exe",
Arguments = $"-V -s -o {outputFileName} {inputFileName}",
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true
}
};
process.Start();
process.WaitForExit();
if (!File.Exists(outputFileName))
{
shaderBytecodeResult.Error("Failed to generate SPIR-V from GLSL");
return(shaderBytecodeResult);
}
// Read compiled shader
var shaderBytecodes = new ShaderInputBytecode
{
InputAttributeNames = inputAttributeNames,
ResourceBindings = resourceBindings,
Data = File.ReadAllBytes(outputFileName),
};
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.ToArray();
}
// Cleanup temp files
File.Delete(inputFileName);
File.Delete(outputFileName);
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.OpenGL:
shaderPlatform = GlslShaderPlatform.OpenGL;
shaderVersion = 420;
break;
case GraphicsPlatform.OpenGLES:
shaderPlatform = GlslShaderPlatform.OpenGLES;
shaderVersion = effectParameters.Profile >= GraphicsProfile.Level_10_0 ? 300 : 100;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, sourceFilename);
if (shader == null)
return shaderBytecodeResult;
if (effectParameters.Platform == GraphicsPlatform.OpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (effectParameters.Profile >= GraphicsProfile.Level_10_0)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, GlslShaderPlatform.OpenGLES, 300, shaderBytecodeResult, reflection, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
else
{
// store string on OpenGL platforms
rawData = Encoding.ASCII.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return shaderBytecodeResult;
}
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var isDebug = effectParameters.Debug;
var optimLevel = effectParameters.OptimizationLevel;
var profile = effectParameters.Profile;
var shaderModel = ShaderStageToString(stage) + "_" + ShaderProfileFromGraphicsProfile(profile);
var shaderFlags = ShaderFlags.None;
if (isDebug)
{
shaderFlags = ShaderFlags.Debug;
}
switch (optimLevel)
{
case 0:
shaderFlags |= ShaderFlags.OptimizationLevel0;
break;
case 1:
shaderFlags |= ShaderFlags.OptimizationLevel1;
break;
case 2:
shaderFlags |= ShaderFlags.OptimizationLevel2;
break;
case 3:
shaderFlags |= ShaderFlags.OptimizationLevel3;
break;
}
SharpDX.Configuration.ThrowOnShaderCompileError = false;
// Compile using D3DCompiler
var compilationResult = SharpDX.D3DCompiler.ShaderBytecode.Compile(shaderSource, entryPoint, shaderModel, shaderFlags, EffectFlags.None, null, null, sourceFilename);
var byteCodeResult = new ShaderBytecodeResult();
if (compilationResult.HasErrors || compilationResult.Bytecode == null)
{
// Log compilation errors
byteCodeResult.Error(compilationResult.Message);
}
else
{
// TODO: Make this optional
try
{
byteCodeResult.DisassembleText = compilationResult.Bytecode.Disassemble();
}
catch (SharpDXException)
{
}
// As effect bytecode binary can changed when having debug infos (with d3dcompiler_47), we are calculating a bytecodeId on the stripped version
var rawData = compilationResult.Bytecode.Strip(StripFlags.CompilerStripDebugInformation | StripFlags.CompilerStripReflectionData);
var bytecodeId = ObjectId.FromBytes(rawData);
byteCodeResult.Bytecode = new ShaderBytecode(bytecodeId, compilationResult.Bytecode.Data) { Stage = stage };
// If compilation succeed, then we can update reflection.
UpdateReflection(byteCodeResult.Bytecode, reflection, byteCodeResult);
if (!string.IsNullOrEmpty(compilationResult.Message))
{
byteCodeResult.Warning(compilationResult.Message);
}
}
return byteCodeResult;
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="compilerParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, ShaderMixinParameters compilerParameters, EffectReflection reflection, string sourceFilename = null)
{
var isOpenGLES = compilerParameters.Get(CompilerParameters.GraphicsPlatformKey) == GraphicsPlatform.OpenGLES;
var shaderBytecodeResult = new ShaderBytecodeResult();
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
{
return(shaderBytecodeResult);
}
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(isOpenGLES);
var glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
// Add std140 layout
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
constantBuffer.Qualifiers |= new LayoutQualifier(new LayoutKeyValue("std140"));
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter();
if (isOpenGLES)
{
glslShaderWriter.TrimFloatSuffix = true;
glslShaderWriter.GenerateUniformBlocks = false;
foreach (var variable in glslShader.Declarations.OfType <Variable>())
{
if (variable.Qualifiers.Contains(ParameterQualifier.In))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.In);
// "in" becomes "attribute" in VS, "varying" in other stages
variable.Qualifiers.Values.Add(
pipelineStage == PipelineStage.Vertex
? global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Attribute
: global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
if (variable.Qualifiers.Contains(ParameterQualifier.Out))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.Out);
variable.Qualifiers.Values.Add(global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
}
}
// Write shader
glslShaderWriter.Visit(glslShader);
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
if (!isOpenGLES)
{
glslShaderCode
.AppendLine("#version 420")
.AppendLine();
if (pipelineStage == PipelineStage.Pixel)
{
glslShaderCode
.AppendLine("out vec4 gl_FragData[1];")
.AppendLine();
}
}
if (isOpenGLES)
{
if (pipelineStage == PipelineStage.Pixel)
{
glslShaderCode
.AppendLine("precision highp float;")
.AppendLine();
}
}
glslShaderCode.Append(glslShaderWriter.Text);
var realShaderSource = glslShaderCode.ToString();
// optimize shader
var optShaderSource = RunOptimizer(realShaderSource, isOpenGLES, false, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
{
realShaderSource = optShaderSource;
}
var rawData = Encoding.ASCII.GetBytes(realShaderSource);
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, bool isOpenGLES, bool isOpenGLES3, ShaderBytecodeResult shaderBytecodeResult, string sourceFilename = null)
{
if (isOpenGLES && !isOpenGLES3 && renderTargetCount > 1)
{
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
}
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
{
return(null);
}
string shaderString = null;
var generateUniformBlocks = isOpenGLES && isOpenGLES3;
// null entry point for pixel shader means no pixel shader. In that case, we return a default function.
if (entryPoint == null && stage == ShaderStage.Pixel && isOpenGLES)
{
shaderString = "out float fragmentdepth; void main(){ fragmentdepth = gl_FragCoord.z; }";
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(isOpenGLES, isOpenGLES3);
var glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
{
return(null);
}
// Add std140 layout
foreach (var constantBuffer in glslShader.Declarations.OfType <ConstantBuffer>())
{
if (isOpenGLES3) // TODO: for OpenGL too?
{
var layoutQualifier = constantBuffer.Qualifiers.OfType <SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier>().FirstOrDefault();
if (layoutQualifier == null)
{
layoutQualifier = new SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier();
constantBuffer.Qualifiers |= layoutQualifier;
}
layoutQualifier.Layouts.Add(new LayoutKeyValue("std140"));
}
else
{
constantBuffer.Qualifiers |= new LayoutQualifier(new LayoutKeyValue("std140"));
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter();
if (isOpenGLES)
{
glslShaderWriter.TrimFloatSuffix = true;
glslShaderWriter.GenerateUniformBlocks = generateUniformBlocks;
if (!isOpenGLES3)
{
foreach (var variable in glslShader.Declarations.OfType <Variable>())
{
if (variable.Qualifiers.Contains(ParameterQualifier.In))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.In);
// "in" becomes "attribute" in VS, "varying" in other stages
variable.Qualifiers.Values.Add(
pipelineStage == PipelineStage.Vertex
? global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Attribute
: global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
if (variable.Qualifiers.Contains(ParameterQualifier.Out))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.Out);
variable.Qualifiers.Values.Add(global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
}
}
}
// Write shader
glslShaderWriter.Visit(glslShader);
shaderString = glslShaderWriter.Text;
}
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
if (isOpenGLES)
{
if (isOpenGLES3)
{
glslShaderCode
.AppendLine("#version 300 es") // TODO: 310 version?
.AppendLine();
}
if (pipelineStage == PipelineStage.Pixel)
{
glslShaderCode
.AppendLine("precision highp float;")
.AppendLine();
}
}
else
{
glslShaderCode
.AppendLine("#version 420")
.AppendLine();
}
if ((!isOpenGLES || isOpenGLES3) && pipelineStage == PipelineStage.Pixel && renderTargetCount > 0)
{
// TODO: identifiers starting with "gl_" should be reserved. Compilers usually accept them but it may should be prevented.
glslShaderCode
.AppendLine("#define gl_FragData _glesFragData")
.AppendLine("out vec4 gl_FragData[" + renderTargetCount + "];")
.AppendLine();
}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
// optimize shader
try
{
var optShaderSource = RunOptimizer(shaderBytecodeResult, realShaderSource, isOpenGLES, isOpenGLES3, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
{
realShaderSource = optShaderSource;
}
}
catch (Exception e)
{
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", e.Message);
}
#else
shaderBytecodeResult.Warning("GLSL optimized has not been executed because it is currently not supported on this platform.");
#endif
return(realShaderSource);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var inputAttributeNames = new Dictionary <int, string>();
var resourceBindings = new Dictionary <string, int>();
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.OpenGL:
shaderPlatform = GlslShaderPlatform.OpenGL;
shaderVersion = 410;
break;
case GraphicsPlatform.OpenGLES:
shaderPlatform = GlslShaderPlatform.OpenGLES;
shaderVersion = effectParameters.Profile >= GraphicsProfile.Level_10_0 ? 300 : 100;
break;
case GraphicsPlatform.Vulkan:
shaderPlatform = GlslShaderPlatform.Vulkan;
shaderVersion = 450;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
if (shader == null)
{
return(shaderBytecodeResult);
}
if (effectParameters.Platform == GraphicsPlatform.OpenGLES) // TODO: Add check to run on android only. The current version breaks OpenGL ES on windows.
{
//TODO: Remove this ugly hack!
if (shaderSource.Contains($"Texture2D XenkoInternal_TextureExt0") && shader.Contains("uniform sampler2D"))
{
if (shaderPlatform != GlslShaderPlatform.OpenGLES || shaderVersion != 300)
{
throw new Exception("Invalid GLES platform or version: require OpenGLES 300");
}
shader = shader.Replace("uniform sampler2D", "uniform samplerExternalOES");
shader = shader.Replace("#version 300 es", "#version 300 es\n#extension GL_OES_EGL_image_external_essl3 : require");
}
}
if (effectParameters.Platform == GraphicsPlatform.OpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (effectParameters.Profile >= GraphicsProfile.Level_10_0)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, GlslShaderPlatform.OpenGLES, 300, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.GetBuffer();
}
}
else if (effectParameters.Platform == GraphicsPlatform.Vulkan)
{
string inputFileExtension;
switch (stage)
{
case ShaderStage.Vertex: inputFileExtension = ".vert"; break;
case ShaderStage.Pixel: inputFileExtension = ".frag"; break;
case ShaderStage.Geometry: inputFileExtension = ".geom"; break;
case ShaderStage.Domain: inputFileExtension = ".tese"; break;
case ShaderStage.Hull: inputFileExtension = ".tesc"; break;
case ShaderStage.Compute: inputFileExtension = ".comp"; break;
default:
shaderBytecodeResult.Error("Unknown shader profile");
return(shaderBytecodeResult);
}
var inputFileName = Path.ChangeExtension(Path.GetTempFileName(), inputFileExtension);
var outputFileName = Path.ChangeExtension(inputFileName, ".spv");
// Write shader source to disk
File.WriteAllBytes(inputFileName, Encoding.ASCII.GetBytes(shader));
// Run shader compiler
var filename = Platform.Type == PlatformType.Windows ? "glslangValidator.exe" : "glslangValidator";
ShellHelper.RunProcessAndRedirectToLogger(filename, $"-V -o {outputFileName} {inputFileName}", null, shaderBytecodeResult);
if (!File.Exists(outputFileName))
{
shaderBytecodeResult.Error("Failed to generate SPIR-V from GLSL");
return(shaderBytecodeResult);
}
// Read compiled shader
var shaderBytecodes = new ShaderInputBytecode
{
InputAttributeNames = inputAttributeNames,
ResourceBindings = resourceBindings,
Data = File.ReadAllBytes(outputFileName),
};
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.ToArray();
}
// Cleanup temp files
File.Delete(inputFileName);
File.Delete(outputFileName);
}
else
{
// store string on OpenGL platforms
rawData = Encoding.UTF8.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return(shaderBytecodeResult);
}
private string Compile(string shaderSource, string entryPoint, ShaderStage stage, bool isOpenGLES, bool isOpenGLES3, ShaderBytecodeResult shaderBytecodeResult, string sourceFilename = null)
{
if (isOpenGLES && !isOpenGLES3 && renderTargetCount > 1)
shaderBytecodeResult.Error("OpenGL ES 2 does not support multiple render targets.");
PipelineStage pipelineStage = PipelineStage.None;
switch (stage)
{
case ShaderStage.Vertex:
pipelineStage = PipelineStage.Vertex;
break;
case ShaderStage.Pixel:
pipelineStage = PipelineStage.Pixel;
break;
case ShaderStage.Geometry:
shaderBytecodeResult.Error("Geometry stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Hull:
shaderBytecodeResult.Error("Hull stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Domain:
shaderBytecodeResult.Error("Domain stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
case ShaderStage.Compute:
shaderBytecodeResult.Error("Compute stage can't be converted to OpenGL. Only Vertex and Pixel shaders are supported");
break;
default:
shaderBytecodeResult.Error("Unknown shader profile.");
break;
}
if (shaderBytecodeResult.HasErrors)
return null;
string shaderString = null;
var generateUniformBlocks = isOpenGLES && isOpenGLES3;
// null entry point for pixel shader means no pixel shader. In that case, we return a default function.
if (entryPoint == null && stage == ShaderStage.Pixel && isOpenGLES)
{
shaderString = "out float fragmentdepth; void main(){ fragmentdepth = gl_FragCoord.z; }";
}
else
{
// Convert from HLSL to GLSL
// Note that for now we parse from shader as a string, but we could simply clone effectPass.Shader to avoid multiple parsing.
var glslConvertor = new ShaderConverter(isOpenGLES, isOpenGLES3);
var glslShader = glslConvertor.Convert(shaderSource, entryPoint, pipelineStage, sourceFilename, shaderBytecodeResult);
if (glslShader == null || shaderBytecodeResult.HasErrors)
return null;
// Add std140 layout
foreach (var constantBuffer in glslShader.Declarations.OfType<ConstantBuffer>())
{
if (isOpenGLES3) // TODO: for OpenGL too?
{
var layoutQualifier = constantBuffer.Qualifiers.OfType<SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier>().FirstOrDefault();
if (layoutQualifier == null)
{
layoutQualifier = new SiliconStudio.Shaders.Ast.Glsl.LayoutQualifier();
constantBuffer.Qualifiers |= layoutQualifier;
}
layoutQualifier.Layouts.Add(new LayoutKeyValue("std140"));
}
else
{
constantBuffer.Qualifiers |= new LayoutQualifier(new LayoutKeyValue("std140"));
}
}
// Output the result
var glslShaderWriter = new HlslToGlslWriter();
if (isOpenGLES)
{
glslShaderWriter.TrimFloatSuffix = true;
glslShaderWriter.GenerateUniformBlocks = generateUniformBlocks;
if (!isOpenGLES3)
{
foreach (var variable in glslShader.Declarations.OfType<Variable>())
{
if (variable.Qualifiers.Contains(ParameterQualifier.In))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.In);
// "in" becomes "attribute" in VS, "varying" in other stages
variable.Qualifiers.Values.Add(
pipelineStage == PipelineStage.Vertex
? global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Attribute
: global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
if (variable.Qualifiers.Contains(ParameterQualifier.Out))
{
variable.Qualifiers.Values.Remove(ParameterQualifier.Out);
variable.Qualifiers.Values.Add(global::SiliconStudio.Shaders.Ast.Glsl.ParameterQualifier.Varying);
}
}
}
}
// Write shader
glslShaderWriter.Visit(glslShader);
shaderString = glslShaderWriter.Text;
}
// Build shader source
var glslShaderCode = new StringBuilder();
// Append some header depending on target
if (isOpenGLES)
{
if (isOpenGLES3)
glslShaderCode
.AppendLine("#version 300 es") // TODO: 310 version?
.AppendLine();
if (pipelineStage == PipelineStage.Pixel)
glslShaderCode
.AppendLine("precision highp float;")
.AppendLine();
}
else
{
glslShaderCode
.AppendLine("#version 420")
.AppendLine();
}
if ((!isOpenGLES || isOpenGLES3) && pipelineStage == PipelineStage.Pixel && renderTargetCount > 0)
{
// TODO: identifiers starting with "gl_" should be reserved. Compilers usually accept them but it may should be prevented.
glslShaderCode
.AppendLine("#define gl_FragData _glesFragData")
.AppendLine("out vec4 gl_FragData[" + renderTargetCount + "];")
.AppendLine();
}
glslShaderCode.Append(shaderString);
var realShaderSource = glslShaderCode.ToString();
#if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP
// optimize shader
try
{
var optShaderSource = RunOptimizer(shaderBytecodeResult, realShaderSource, isOpenGLES, isOpenGLES3, pipelineStage == PipelineStage.Vertex);
if (!String.IsNullOrEmpty(optShaderSource))
realShaderSource = optShaderSource;
}
catch (Exception e)
{
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", e.Message);
}
#else
shaderBytecodeResult.Warning("GLSL optimized has not been executed because it is currently not supported on this platform.");
#endif
return realShaderSource;
}
private string RunOptimizer(ShaderBytecodeResult shaderBytecodeResult, string baseShader, bool openGLES, bool es30, bool vertex)
{
lock (GlslOptimizerLock)
{
IntPtr ctx = IntPtr.Zero;
var inputShader = baseShader;
if (openGLES)
{
if (es30)
ctx = glslopt_initialize(2); // kGlslTargetOpenGLES30
else
ctx = glslopt_initialize(1); // kGlslTargetOpenGLES20
}
else
{
ctx = glslopt_initialize(0); // kGlslTargetOpenGL
}
int type = vertex ? 0 : 1;
var shader = glslopt_optimize(ctx, type, inputShader, 0);
bool optimizeOk = glslopt_get_status(shader);
string shaderAsString = null;
if (optimizeOk)
{
IntPtr optShader = glslopt_get_output(shader);
shaderAsString = Marshal.PtrToStringAnsi(optShader);
}
else
{
IntPtr log = glslopt_get_log(shader);
var logAsString = Marshal.PtrToStringAnsi(log);
shaderBytecodeResult.Warning("Could not run GLSL optimizer:\n{0}", logAsString);
}
glslopt_shader_delete(shader);
glslopt_cleanup(ctx);
return shaderAsString;
}
}
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var isDebug = effectParameters.Debug;
var optimLevel = effectParameters.OptimizationLevel;
var profile = effectParameters.Profile;
var shaderModel = ShaderStageToString(stage) + "_" + ShaderProfileFromGraphicsProfile(profile);
var shaderFlags = ShaderFlags.None;
if (isDebug)
{
shaderFlags = ShaderFlags.Debug;
}
switch (optimLevel)
{
case 0:
shaderFlags |= ShaderFlags.OptimizationLevel0;
break;
case 1:
shaderFlags |= ShaderFlags.OptimizationLevel1;
break;
case 2:
shaderFlags |= ShaderFlags.OptimizationLevel2;
break;
case 3:
shaderFlags |= ShaderFlags.OptimizationLevel3;
break;
}
SharpDX.Configuration.ThrowOnShaderCompileError = false;
// Compile using D3DCompiler
var compilationResult = SharpDX.D3DCompiler.ShaderBytecode.Compile(shaderSource, entryPoint, shaderModel, shaderFlags, EffectFlags.None, null, null, sourceFilename);
var byteCodeResult = new ShaderBytecodeResult();
if (compilationResult.HasErrors || compilationResult.Bytecode == null)
{
// Log compilation errors
byteCodeResult.Error(compilationResult.Message);
}
else
{
// TODO: Make this optional
try
{
byteCodeResult.DisassembleText = compilationResult.Bytecode.Disassemble();
}
catch (SharpDXException)
{
}
// As effect bytecode binary can changed when having debug infos (with d3dcompiler_47), we are calculating a bytecodeId on the stripped version
var rawData = compilationResult.Bytecode.Strip(StripFlags.CompilerStripDebugInformation | StripFlags.CompilerStripReflectionData);
var bytecodeId = ObjectId.FromBytes(rawData);
byteCodeResult.Bytecode = new ShaderBytecode(bytecodeId, compilationResult.Bytecode.Data)
{
Stage = stage
};
// If compilation succeed, then we can update reflection.
UpdateReflection(byteCodeResult.Bytecode, reflection, byteCodeResult);
if (!string.IsNullOrEmpty(compilationResult.Message))
{
byteCodeResult.Warning(compilationResult.Message);
}
}
return(byteCodeResult);
}
/// <summary>
/// Converts the hlsl code into glsl and stores the result as plain text
/// </summary>
/// <param name="shaderSource">the hlsl shader</param>
/// <param name="entryPoint">the entrypoint function name</param>
/// <param name="stage">the shader pipeline stage</param>
/// <param name="effectParameters"></param>
/// <param name="reflection">the reflection gathered from the hlsl analysis</param>
/// <param name="sourceFilename">the name of the source file</param>
/// <returns></returns>
public ShaderBytecodeResult Compile(string shaderSource, string entryPoint, ShaderStage stage, EffectCompilerParameters effectParameters, EffectReflection reflection, string sourceFilename = null)
{
var shaderBytecodeResult = new ShaderBytecodeResult();
byte[] rawData;
var inputAttributeNames = new Dictionary<int, string>();
var resourceBindings = new Dictionary<string, int>();
GlslShaderPlatform shaderPlatform;
int shaderVersion;
switch (effectParameters.Platform)
{
case GraphicsPlatform.OpenGL:
shaderPlatform = GlslShaderPlatform.OpenGL;
shaderVersion = 410;
break;
case GraphicsPlatform.OpenGLES:
shaderPlatform = GlslShaderPlatform.OpenGLES;
shaderVersion = effectParameters.Profile >= GraphicsProfile.Level_10_0 ? 300 : 100;
break;
case GraphicsPlatform.Vulkan:
shaderPlatform = GlslShaderPlatform.Vulkan;
shaderVersion = 450;
break;
default:
throw new ArgumentOutOfRangeException("effectParameters.Platform");
}
var shader = Compile(shaderSource, entryPoint, stage, shaderPlatform, shaderVersion, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
if (shader == null)
return shaderBytecodeResult;
if (effectParameters.Platform == GraphicsPlatform.OpenGLES)
{
// store both ES 2 and ES 3 on OpenGL ES platforms
var shaderBytecodes = new ShaderLevelBytecode();
if (effectParameters.Profile >= GraphicsProfile.Level_10_0)
{
shaderBytecodes.DataES3 = shader;
shaderBytecodes.DataES2 = null;
}
else
{
shaderBytecodes.DataES2 = shader;
shaderBytecodes.DataES3 = Compile(shaderSource, entryPoint, stage, GlslShaderPlatform.OpenGLES, 300, shaderBytecodeResult, reflection, inputAttributeNames, resourceBindings, sourceFilename);
}
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
#if !SILICONSTUDIO_RUNTIME_CORECLR && !SILICONSTUDIO_PLATFORM_UWP
rawData = stream.GetBuffer();
#else
// FIXME: Manu: The call to "ToArray()" might be slower than "GetBuffer()"
rawData = stream.ToArray();
#endif
}
}
#if !SILICONSTUDIO_RUNTIME_CORECLR && !SILICONSTUDIO_PLATFORM_UWP
else if (effectParameters.Platform == GraphicsPlatform.Vulkan)
{
string inputFileExtension;
switch (stage)
{
case ShaderStage.Vertex: inputFileExtension = ".vert"; break;
case ShaderStage.Pixel: inputFileExtension = ".frag"; break;
case ShaderStage.Geometry: inputFileExtension = ".geom"; break;
case ShaderStage.Domain: inputFileExtension = ".tese"; break;
case ShaderStage.Hull: inputFileExtension = ".tesc"; break;
case ShaderStage.Compute: inputFileExtension = ".comp"; break;
default:
shaderBytecodeResult.Error("Unknown shader profile");
return shaderBytecodeResult;
}
var inputFileName = Path.ChangeExtension(Path.GetTempFileName(), inputFileExtension);
var outputFileName = Path.ChangeExtension(inputFileName, ".spv");
// Write shader source to disk
File.WriteAllBytes(inputFileName, Encoding.ASCII.GetBytes(shader));
// Run shader compiler
var filename = Platform.Type == PlatformType.Windows ? "glslangValidator.exe" : "glslangValidator";
ShellHelper.RunProcessAndRedirectToLogger(filename, $"-V -o {outputFileName} {inputFileName}", null, shaderBytecodeResult);
if (!File.Exists(outputFileName))
{
shaderBytecodeResult.Error("Failed to generate SPIR-V from GLSL");
return shaderBytecodeResult;
}
// Read compiled shader
var shaderBytecodes = new ShaderInputBytecode
{
InputAttributeNames = inputAttributeNames,
ResourceBindings = resourceBindings,
Data = File.ReadAllBytes(outputFileName),
};
using (var stream = new MemoryStream())
{
BinarySerialization.Write(stream, shaderBytecodes);
rawData = stream.ToArray();
}
// Cleanup temp files
File.Delete(inputFileName);
File.Delete(outputFileName);
}
#endif
else
{
// store string on OpenGL platforms
rawData = Encoding.UTF8.GetBytes(shader);
}
var bytecodeId = ObjectId.FromBytes(rawData);
var bytecode = new ShaderBytecode(bytecodeId, rawData);
bytecode.Stage = stage;
shaderBytecodeResult.Bytecode = bytecode;
return shaderBytecodeResult;
}
