public int LoadShader(ParsedShader shader, string name = null)
{
var vertexSource = _shaderWrapCodeSpriteVert;
var fragmentSource = _shaderWrapCodeSpriteFrag;
var(header, vertBody, fragBody) = _getShaderCode(shader);
vertexSource = vertexSource.Replace("[SHADER_HEADER_CODE]", header);
vertexSource = vertexSource.Replace("[SHADER_CODE]", vertBody);
fragmentSource = fragmentSource.Replace("[SHADER_HEADER_CODE]", header);
fragmentSource = fragmentSource.Replace("[SHADER_CODE]", fragBody);
var program = _compileProgram(vertexSource, fragmentSource, name);
program.BindBlock("projectionViewMatrices", ProjViewBindingIndex);
program.BindBlock("uniformConstants", UniformConstantsBindingIndex);
var loaded = new LoadedShader
{
Program = program,
HasLighting = (shader.RenderMode & ShaderRenderMode.Unshaded) == 0
};
var ret = _loadedShaders.Count;
_loadedShaders.Add(loaded);
return(ret);
}
public override void Reload(IResourceCache cache, ResourcePath path, CancellationToken ct = default)
{
ct = ct != default ? ct : new CancellationTokenSource(30000).Token;
for (;;)
{
try
{
using var stream = cache.ContentFileRead(path);
using var reader = new StreamReader(stream, EncodingHelpers.UTF8);
ParsedShader = ShaderParser.Parse(reader, cache);
break;
}
catch (IOException ioe)
{
if (!PathHelpers.IsFileInUse(ioe))
{
throw;
}
ct.ThrowIfCancellationRequested();
Thread.Sleep(3);
}
}
var clyde = IoCManager.Resolve <IClydeInternal>();
clyde.ReloadShader(ClydeHandle, ParsedShader);
}
public ClydeHandle LoadShader(ParsedShader shader, string name = null)
{
var vertexSource = _shaderWrapCodeSpriteVert;
var fragmentSource = _shaderWrapCodeSpriteFrag;
var(header, vertBody, fragBody) = _getShaderCode(shader);
vertexSource = vertexSource.Replace("[SHADER_HEADER_CODE]", header);
vertexSource = vertexSource.Replace("[SHADER_CODE]", vertBody);
fragmentSource = fragmentSource.Replace("[SHADER_HEADER_CODE]", header);
fragmentSource = fragmentSource.Replace("[SHADER_CODE]", fragBody);
var program = _compileProgram(vertexSource, fragmentSource, name);
program.BindBlock("projectionViewMatrices", ProjViewBindingIndex);
program.BindBlock("uniformConstants", UniformConstantsBindingIndex);
var loaded = new LoadedShader
{
Program = program,
HasLighting = shader.LightMode != ShaderLightMode.Unshaded,
BlendMode = shader.BlendMode
};
var handle = AllocRid();
_loadedShaders.Add(handle, loaded);
return(handle);
}
_getShaderCode(ParsedShader shader)
{
var header = new StringBuilder();
foreach (var uniform in shader.Uniforms.Values)
{
if (uniform.DefaultValue != null)
{
header.AppendFormat("uniform {0} {1} = {2};", uniform.Type.GetNativeType(), uniform.Name,
uniform.DefaultValue);
}
else
{
header.AppendFormat("uniform {0} {1};", uniform.Type.GetNativeType(), uniform.Name);
}
}
// TODO: Varyings.
ShaderFunctionDefinition fragmentMain = null;
ShaderFunctionDefinition vertexMain = null;
foreach (var function in shader.Functions)
{
if (function.Name == "fragment")
{
fragmentMain = function;
continue;
}
if (function.Name == "vertex")
{
vertexMain = function;
continue;
}
header.AppendFormat("{0} {1}(", function.ReturnType.GetNativeType(), function.Name);
var first = true;
foreach (var parameter in function.Parameters)
{
if (!first)
{
header.Append(", ");
}
first = false;
header.AppendFormat("{0} {1} {2}", parameter.Qualifiers.GetString(), parameter.Type.GetNativeType(),
parameter.Name);
}
header.AppendFormat(") {{\n{0}\n}}\n", function.Body);
}
return(header.ToString(), vertexMain?.Body ?? "", fragmentMain?.Body ?? "");
}
public override void Load(IResourceCache cache, ResourcePath path)
{
using (var stream = cache.ContentFileRead(path))
using (var reader = new StreamReader(stream, EncodingHelpers.UTF8))
{
ParsedShader = ShaderParser.Parse(reader, cache);
}
var clyde = IoCManager.Resolve <IClydeInternal>();
ClydeHandle = clyde.LoadShader(ParsedShader, path.ToString());
}
public void ReloadShader(ClydeHandle handle, ParsedShader newShader)
{
var loaded = _loadedShaders[handle];
loaded.HasLighting = newShader.LightMode != ShaderLightMode.Unshaded;
loaded.BlendMode = newShader.BlendMode;
var(vertBody, fragBody) = GetShaderCode(newShader);
var program = _compileProgram(vertBody, fragBody, loaded.Name);
loaded.Program.Delete();
loaded.Program = program;
program.BindBlock(UniProjViewMatrices, ProjViewBindingIndex);
program.BindBlock(UniUniformConstants, UniformConstantsBindingIndex);
}
public override void Load(IResourceCache cache, ResourcePath path)
{
using (var stream = cache.ContentFileRead(path))
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
ParsedShader = ShaderParser.Parse(reader);
}
switch (GameController.Mode)
{
case GameController.DisplayMode.Headless:
return;
case GameController.DisplayMode.Godot:
GodotShader = new Godot.Shader
{
Code = _getGodotCode(),
};
break;
case GameController.DisplayMode.Clyde:
ClydeHandle = IoCManager.Resolve <IClyde>().LoadShader(ParsedShader);
break;
default:
throw new ArgumentOutOfRangeException();
}
if (GameController.OnGodot)
{
GodotShader = new Godot.Shader
{
Code = _getGodotCode(),
};
}
else
{
var clyde = IoCManager.Resolve <IClyde>();
// TODO: vertex shaders.
ClydeHandle = clyde.LoadShader(ParsedShader, path.ToString());
}
}
public ClydeHandle LoadShader(ParsedShader shader, string name = null)
{
var(vertBody, fragBody) = GetShaderCode(shader);
var program = _compileProgram(vertBody, fragBody, name);
program.BindBlock(UniProjViewMatrices, ProjViewBindingIndex);
program.BindBlock(UniUniformConstants, UniformConstantsBindingIndex);
var loaded = new LoadedShader
{
Program = program,
HasLighting = shader.LightMode != ShaderLightMode.Unshaded,
BlendMode = shader.BlendMode,
Name = name
};
var handle = AllocRid();
_loadedShaders.Add(handle, loaded);
return(handle);
}
public void ReloadShader(ClydeHandle handle, ParsedShader newShader)
{
var loaded = _loadedShaders[handle];
loaded.HasLighting = newShader.LightMode != ShaderLightMode.Unshaded;
loaded.BlendMode = newShader.BlendMode;
var(vertBody, fragBody) = GetShaderCode(newShader);
var program = _compileProgram(vertBody, fragBody, BaseShaderAttribLocations, loaded.Name);
loaded.Program.Delete();
loaded.Program = program;
if (_hasGLUniformBuffers)
{
program.BindBlock(UniProjViewMatrices, BindingIndexProjView);
program.BindBlock(UniUniformConstants, BindingIndexUniformConstants);
}
}
public ClydeHandle LoadShader(ParsedShader shader, string?name = null)
{
var(vertBody, fragBody) = GetShaderCode(shader);
var program = _compileProgram(vertBody, fragBody, BaseShaderAttribLocations, name);
if (_hasGLUniformBuffers)
{
program.BindBlock(UniProjViewMatrices, BindingIndexProjView);
program.BindBlock(UniUniformConstants, BindingIndexUniformConstants);
}
var loaded = new LoadedShader
{
Program = program,
HasLighting = shader.LightMode != ShaderLightMode.Unshaded,
BlendMode = shader.BlendMode,
Name = name
};
var handle = AllocRid();
_loadedShaders.Add(handle, loaded);
return(handle);
}
public ClydeHandle LoadShader(ParsedShader shader, string name = null)
{
return(default);
private (string vertBody, string fragBody) GetShaderCode(ParsedShader shader)
{
var headerUniforms = new StringBuilder();
foreach (var constant in shader.Constants.Values)
{
headerUniforms.AppendFormat("const {0} {1} = {2};\n", constant.Type.GetNativeType(), constant.Name,
constant.Value);
}
foreach (var uniform in shader.Uniforms.Values)
{
if (uniform.DefaultValue != null)
{
headerUniforms.AppendFormat("uniform {0} {1} = {2};\n", uniform.Type.GetNativeType(), uniform.Name,
uniform.DefaultValue);
}
else
{
headerUniforms.AppendFormat("uniform {0} {1};\n", uniform.Type.GetNativeType(), uniform.Name);
}
}
var varyingsFragment = new StringBuilder();
var varyingsVertex = new StringBuilder();
foreach (var(name, varying) in shader.Varyings)
{
varyingsFragment.AppendFormat("in {0} {1};\n", varying.Type.GetNativeType(), name);
varyingsVertex.AppendFormat("out {0} {1};\n", varying.Type.GetNativeType(), name);
}
ShaderFunctionDefinition fragmentMain = null;
ShaderFunctionDefinition vertexMain = null;
var functionsBuilder = new StringBuilder();
foreach (var function in shader.Functions)
{
if (function.Name == "fragment")
{
fragmentMain = function;
continue;
}
if (function.Name == "vertex")
{
vertexMain = function;
continue;
}
functionsBuilder.AppendFormat("{0} {1}(", function.ReturnType.GetNativeType(), function.Name);
var first = true;
foreach (var parameter in function.Parameters)
{
if (!first)
{
functionsBuilder.Append(", ");
}
first = false;
functionsBuilder.AppendFormat("{0} {1} {2}", parameter.Qualifiers.GetString(), parameter.Type.GetNativeType(),
parameter.Name);
}
functionsBuilder.AppendFormat(") {{\n{0}\n}}\n", function.Body);
}
var(wrapVert, wrapFrag) = shader.Preset switch
{
ShaderPreset.Default => (_shaderWrapCodeDefaultVert, _shaderWrapCodeDefaultFrag),
ShaderPreset.Raw => (_shaderWrapCodeRawVert, _shaderWrapCodeRawFrag),
_ => throw new NotSupportedException()
};
var vertexHeader = $"{headerUniforms}\n{varyingsVertex}\n{functionsBuilder}";
var fragmentHeader = $"{headerUniforms}\n{varyingsFragment}\n{functionsBuilder}";
// These are prefixed with comments because the syntax highlighter I'm using doesn't like the brackets.
// And it's producing a lot of squigly lines.
var vertexSource = wrapVert.Replace("// [SHADER_HEADER_CODE]", vertexHeader);
var fragmentSource = wrapFrag.Replace("// [SHADER_HEADER_CODE]", fragmentHeader);
if (vertexMain != null)
{
vertexSource = vertexSource.Replace("// [SHADER_CODE]", vertexMain.Body);
}
if (fragmentMain != null)
{
fragmentSource = fragmentSource.Replace("// [SHADER_CODE]", fragmentMain.Body);
}
return(vertexSource, fragmentSource);
}
public int LoadShader(ParsedShader shader, string name = null)
{
return(default);
