/// <summary>
/// Gets a <see cref="ShaderProgram"/> for the specified shader type. If one is not already in the cache, it
/// will be created.
/// </summary>
/// <param name="shader">The type of shader to retrieve.</param>
/// <returns>A shader program object.</returns>
public ShaderProgram GetShader(EverlookShader shader)
{
if (HasCachedShader(shader))
{
return(GetCachedShader(shader));
}
return(CreateCachedShader(shader));
}
/// <summary>
/// Determines whether or not the rendering cache has a cached shader
/// for the specified shader type.
/// </summary>
private bool HasCachedShader(EverlookShader shader)
{
if (!Enum.IsDefined(typeof(EverlookShader), shader))
{
throw new ArgumentException("An unknown shader was passed to the rendering cache.", nameof(shader));
}
return(_shaderCache.ContainsKey(shader));
}
/// <summary>
/// Creates a cached shader for the specifed shader, using the specified shader enumeration
/// as a lookup key.
/// </summary>
private ShaderProgram CreateCachedShader(EverlookShader shader)
{
if (!Enum.IsDefined(typeof(EverlookShader), shader))
{
throw new ArgumentException("An unknown shader was passed to the rendering cache.", nameof(shader));
}
Log.Info($"Creating cached shader for \"{shader}\"");
ShaderProgram shaderProgram;
switch (shader)
{
case EverlookShader.Plain2D:
{
shaderProgram = new Plain2DShader();
break;
}
case EverlookShader.WorldModel:
{
shaderProgram = new WorldModelShader();
break;
}
case EverlookShader.BoundingBox:
{
shaderProgram = new BoundingBoxShader();
break;
}
case EverlookShader.GameModel:
{
shaderProgram = new GameModelShader();
break;
}
case EverlookShader.BaseGrid:
{
shaderProgram = new BaseGridShader();
break;
}
default:
{
throw new ArgumentOutOfRangeException
(
nameof(shader),
"No implemented shader class for this shader."
);
}
}
_shaderCache.Add(shader, shaderProgram);
return(shaderProgram);
}
/// <summary>
/// Gets a <see cref="ShaderProgram"/> for the specified shader type. If one is not already in the cache, it
/// will be created.
/// </summary>
/// <param name="shader">The type of shader to retrieve.</param>
/// <returns>A shader program object.</returns>
public ShaderProgram GetShader(EverlookShader shader)
{
ThrowIfDisposed();
if (HasCachedShader(shader))
{
return(GetCachedShader(shader));
}
return(CreateCachedShader(shader));
}
/// <summary>
/// Gets a cached shader ID from the rendering cache.
/// </summary>
private ShaderProgram GetCachedShader(EverlookShader shader)
{
ThrowIfDisposed();
return(_shaderCache[shader]);
}
/// <summary>
/// Creates a cached shader for the specifed shader, using the specified shader enumeration
/// as a lookup key.
/// </summary>
public int CreateCachedShader(EverlookShader shader)
{
if (!Enum.IsDefined(typeof(EverlookShader), shader))
{
throw new ArgumentException("An unknown shader was passed to the rendering cache.", nameof(shader));
}
Log.Info($"Creating cached shader for \"{shader}\"");
int vertexShaderID = GL.CreateShader(ShaderType.VertexShader);
int fragmentShaderID = GL.CreateShader(ShaderType.FragmentShader);
string vertexShaderSource;
string fragmentShaderSource;
switch (shader)
{
case EverlookShader.Plain2D:
{
vertexShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.Adapted.PlainImage.PlainImageVertex.glsl");
fragmentShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.Adapted.PlainImage.PlainImageFragment.glsl");
break;
}
case EverlookShader.UnlitWorldModel:
{
vertexShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.Adapted.WorldModel.WorldModelVertex.glsl");
fragmentShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.Adapted.WorldModel.WorldModelFragment.glsl");
break;
}
case EverlookShader.BoundingBox:
{
vertexShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.BoundingBoxVertex.glsl");
fragmentShaderSource = AssetManager.LoadEmbeddedText("Everlook.Content.Shaders.BoundingBoxFragment.glsl");
break;
}
default:
{
vertexShaderSource = "";
fragmentShaderSource = "";
break;
}
}
int result;
int compilationLogLength;
Log.Info("Compiling vertex shader...");
GL.ShaderSource(vertexShaderID, vertexShaderSource);
GL.CompileShader(vertexShaderID);
GL.GetShader(vertexShaderID, ShaderParameter.CompileStatus, out result);
GL.GetShader(vertexShaderID, ShaderParameter.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetShaderInfoLog(vertexShaderID, out compilationLog);
Log.Warn($"Vertex shader compilation failed or had warnings. Please review the following log: \n" +
$"{compilationLog}");
}
Log.Info("Compiling fragment shader...");
GL.ShaderSource(fragmentShaderID, fragmentShaderSource);
GL.CompileShader(fragmentShaderID);
GL.GetShader(fragmentShaderID, ShaderParameter.CompileStatus, out result);
GL.GetShader(fragmentShaderID, ShaderParameter.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetShaderInfoLog(fragmentShaderID, out compilationLog);
Log.Warn($"Fragment shader compilation failed or had warnings. Please review the following log: \n" +
$"{compilationLog}");
}
Log.Info("Linking shader program...");
int shaderProgramID = GL.CreateProgram();
GL.AttachShader(shaderProgramID, vertexShaderID);
GL.AttachShader(shaderProgramID, fragmentShaderID);
GL.LinkProgram(shaderProgramID);
GL.GetProgram(shaderProgramID, GetProgramParameterName.LinkStatus, out result);
GL.GetProgram(shaderProgramID, GetProgramParameterName.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetProgramInfoLog(shaderProgramID, out compilationLog);
Log.Warn($"Shader linking failed or had warnings. Please review the following log: \n" +
$"{compilationLog}");
}
// Clean up the shader source code and unlinked object files from graphics memory
GL.DetachShader(shaderProgramID, vertexShaderID);
GL.DetachShader(shaderProgramID, fragmentShaderID);
GL.DeleteShader(vertexShaderID);
GL.DeleteShader(fragmentShaderID);
this.GLShaderCache.Add(shader, shaderProgramID);
return(shaderProgramID);
}
/// <summary>
/// Gets a cached shader ID from the rendering cache.
/// </summary>
public int GetCachedShader(EverlookShader shader)
{
return(this.GLShaderCache[shader]);
}
/// <summary>
/// Creates a cached shader for the specifed shader, using the specified shader enumeration
/// as a lookup key.
/// </summary>
public int CreateCachedShader(EverlookShader shader)
{
if (!Enum.IsDefined(typeof(EverlookShader), shader))
{
throw new ArgumentException("An unknown shader was passed to the rendering cache.", nameof(shader));
}
int vertexShaderID = GL.CreateShader(ShaderType.VertexShader);
int fragmentShaderID = GL.CreateShader(ShaderType.FragmentShader);
string vertexShaderSource;
string fragmentShaderSource;
switch (shader)
{
case EverlookShader.Plain2D:
{
vertexShaderSource = LoadShaderSource("Everlook.Content.Shaders.Adapted.PlainImage.PlainImageVertex.glsl");
fragmentShaderSource = LoadShaderSource("Everlook.Content.Shaders.Adapted.PlainImage.PlainImageFragment.glsl");
break;
}
case EverlookShader.UnlitWorldModel:
{
vertexShaderSource = LoadShaderSource("Everlook.Content.Shaders.Adapted.WorldModel.WorldModelVertex.glsl");
fragmentShaderSource = LoadShaderSource("Everlook.Content.Shaders.Adapted.WorldModel.WorldModelFragment.glsl");
break;
}
default:
{
vertexShaderSource = "";
fragmentShaderSource = "";
break;
}
}
int result;
int compilationLogLength;
Console.WriteLine("Compiling vertex shader...");
GL.ShaderSource(vertexShaderID, vertexShaderSource);
GL.CompileShader(vertexShaderID);
GL.GetShader(vertexShaderID, ShaderParameter.CompileStatus, out result);
GL.GetShader(vertexShaderID, ShaderParameter.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetShaderInfoLog(vertexShaderID, out compilationLog);
Console.WriteLine(compilationLog);
}
Console.WriteLine("Compiling fragment shader...");
GL.ShaderSource(fragmentShaderID, fragmentShaderSource);
GL.CompileShader(fragmentShaderID);
GL.GetShader(fragmentShaderID, ShaderParameter.CompileStatus, out result);
GL.GetShader(fragmentShaderID, ShaderParameter.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetShaderInfoLog(fragmentShaderID, out compilationLog);
Console.WriteLine(compilationLog);
}
Console.WriteLine("Linking shader program...");
int shaderProgramID = GL.CreateProgram();
GL.AttachShader(shaderProgramID, vertexShaderID);
GL.AttachShader(shaderProgramID, fragmentShaderID);
GL.LinkProgram(shaderProgramID);
GL.GetProgram(shaderProgramID, ProgramParameter.LinkStatus, out result);
GL.GetProgram(shaderProgramID, ProgramParameter.InfoLogLength, out compilationLogLength);
if (compilationLogLength > 0)
{
string compilationLog;
GL.GetProgramInfoLog(shaderProgramID, out compilationLog);
Console.WriteLine(compilationLog);
}
// Clean up the shader source code and unlinked object files from graphics memory
GL.DetachShader(shaderProgramID, vertexShaderID);
GL.DetachShader(shaderProgramID, fragmentShaderID);
GL.DeleteShader(vertexShaderID);
GL.DeleteShader(fragmentShaderID);
this.GLShaderCache.Add(shader, shaderProgramID);
return(shaderProgramID);
}
/// <summary>
/// Gets a cached shader ID from the rendering cache.
/// </summary>
private ShaderProgram GetCachedShader(EverlookShader shader)
{
return(this.ShaderCache[shader]);
}
