public ShaderProgram(string path)
{
List <Shader> shaders = LoadShaderFromFile(path);
// create program object
handle = GL.CreateProgram();
// assign all shaders
foreach (Shader shader in shaders)
{
GL.AttachShader(handle, shader.Handle);
}
// link program (effectively compiles it)
GL.LinkProgram(handle);
// detach shaders
foreach (Shader shader in shaders)
{
GL.DetachShader(handle, shader.Handle);
}
}
void CreateShaders(string vs, string fs,
out int vertexObject, out int fragmentObject,
out int program)
{
int status_code;
string info;
vertexObject = GL.CreateShader(ShaderType.VertexShader);
fragmentObject = GL.CreateShader(ShaderType.FragmentShader);
// Compile vertex shader
GL.ShaderSource(vertexObject, vs);
GL.CompileShader(vertexObject);
GL.GetShaderInfoLog(vertexObject, out info);
GL.GetShader(vertexObject, ShaderParameter.CompileStatus, out status_code);
if (status_code != 1)
{
throw new ApplicationException(info);
}
// Compile vertex shader
GL.ShaderSource(fragmentObject, fs);
GL.CompileShader(fragmentObject);
GL.GetShaderInfoLog(fragmentObject, out info);
GL.GetShader(fragmentObject, ShaderParameter.CompileStatus, out status_code);
if (status_code != 1)
{
throw new ApplicationException(info);
}
program = GL.CreateProgram();
GL.AttachShader(program, fragmentObject);
GL.AttachShader(program, vertexObject);
GL.LinkProgram(program);
GL.UseProgram(program);
}
public ShaderProgram(params Shader[] shaders)
{
Index = GL.CreateProgram();
foreach (Shader shader in shaders)
{
GL.AttachShader(Index, shader.Index);
}
GL.LinkProgram(Index);
GL.GetProgram(Index, GetProgramParameterName.LinkStatus, out int linkStatus);
if (linkStatus == 0)
{
throw new Exception($"Shader program link: {GL.GetProgramInfoLog(Index)}");
}
foreach (Shader shader in shaders)
{
GL.DeleteShader(shader.Index);
}
}
private void Compile()
{
int program = GL.CreateProgram();
int vertexShader = CompileShader(_vertexShader, ShaderType.VertexShader);
int fragmentShader = CompileShader(_fragmentShader, ShaderType.FragmentShader);
GL.AttachShader(program, vertexShader);
GL.AttachShader(program, fragmentShader);
GL.LinkProgram(program);
#if DEBUG
int linked;
GL.GetProgram(program, ProgramParameter.LinkStatus, out linked);
if (linked == 0)
{
int logLength;
GL.GetProgram(program, ProgramParameter.InfoLogLength, out logLength);
if (logLength != 0)
{
String log;
GL.GetProgramInfoLog(program, out log);
Debug.WriteLine("Sparrow: Error linking program: " + log);
}
}
#endif
Name = program;
UpdateUniforms();
UpdateAttributes();
GL.DetachShader(program, vertexShader);
GL.DetachShader(program, fragmentShader);
GL.DeleteShader(vertexShader);
GL.DeleteShader(fragmentShader);
}
private static int CompileProgram(string vertexShader, string fragmentShader)
{
int program = GL.CreateProgram( );
GL.AttachShader(program, Assets.GetVertexShader(vertexShader));
GL.AttachShader(program, Assets.GetFragmentShader(fragmentShader));
GL.LinkProgram(program);
string log = GL.GetProgramInfoLog(program);
#if DEBUG
Debug.Print(typeof(Program), $"program { program } loaded");
if (!string.IsNullOrWhiteSpace(log))
{
Debug.Print(typeof(Program), "log: " + log);
}
Debug.CheckGL(typeof(Program));
#endif
return(program);
}
public Shader(string vertPath, string fragPath)
{
Vertex = GL.CreateShader(ShaderType.VertexShader);
Fragment = GL.CreateShader(ShaderType.FragmentShader);
string vertShaderSource = System.IO.File.ReadAllText(vertPath);
string fragShaderSource = System.IO.File.ReadAllText(fragPath);
GL.ShaderSource(Vertex, vertShaderSource);
GL.ShaderSource(Fragment, fragShaderSource);
GL.CompileShader(Vertex);
GL.CompileShader(Fragment);
Console.WriteLine(GL.GetShaderInfoLog(Vertex));
Console.WriteLine(GL.GetShaderInfoLog(Fragment));
Program = GL.CreateProgram();
GL.AttachShader(Program, Vertex);
GL.AttachShader(Program, Fragment);
GL.LinkProgram(Program);
Console.WriteLine(GL.GetProgramInfoLog(Program));
//
GL.DeleteShader(Vertex);
GL.DeleteShader(Fragment);
}
private int CreateShader(string shaderCode, ShaderType shaderType)
{
int shaderId = GL.CreateShader(shaderType);
if (shaderId == 0)
{
throw new Exception("Error creating shader. Type: " + shaderType);
}
GL.ShaderSource(shaderId, shaderCode);
GL.CompileShader(shaderId);
GL.GetShader(shaderId, ShaderParameter.CompileStatus, out int shaderState);
if (shaderState == 0)
{
throw new Exception("Error compiling Shader code: " + GL.GetShaderInfoLog(shaderId));
}
GL.AttachShader(programId, shaderId);
return(shaderId);
}
private int CreateShaderProgram(string vertexShaderSource, string fragmentShaderSource)
{
int shaderProgram = GL.CreateProgram();
int vertexShader = CreateShader(ShaderType.VertexShader, vertexShaderSource);
int fragmentShader = CreateShader(ShaderType.FragmentShader, fragmentShaderSource);
GL.AttachShader(shaderProgram, vertexShader);
GL.AttachShader(shaderProgram, fragmentShader);
GL.LinkProgram(shaderProgram);
string infoLog = GL.GetProgramInfoLog(shaderProgram);
if (!String.IsNullOrEmpty(infoLog))
{
throw new ArgumentException("An error occurred during creation of shader program. " + infoLog);
}
GL.DeleteShader(vertexShader);
GL.DeleteShader(fragmentShader);
return(shaderProgram);
}
public static void LoadShaders(SpriteSurface s, string vs, string fs, params string[] attributes)
{
int vertex_shader = GL.CreateShader(ShaderType.VertexShader);
int fragment_shader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(vertex_shader, vs);
GL.ShaderSource(fragment_shader, fs);
GL.CompileShader(vertex_shader);
GL.CompileShader(fragment_shader);
int compiled;
GL.GetShader(vertex_shader, ShaderParameter.CompileStatus, out compiled);
if (compiled < 1)
{
Console.Error.WriteLine(GL.GetShaderInfoLog(vertex_shader));
throw new Exception("vertex shader compilation failed");
}
GL.GetShader(fragment_shader, ShaderParameter.CompileStatus, out compiled);
if (compiled < 1)
{
Console.Error.WriteLine(GL.GetShaderInfoLog(fragment_shader));
throw new Exception("fragment shader compilation failed");
}
int shader_program = GL.CreateProgram();
GL.AttachShader(shader_program, vertex_shader);
GL.AttachShader(shader_program, fragment_shader);
int attrib_index = 0;
foreach (string attr in attributes)
{
GL.BindAttribLocation(shader_program, attrib_index++, attr);
}
GL.LinkProgram(shader_program);
s.ShaderProgramID = shader_program;
GL.UseProgram(shader_program);
s.UniformLocation = GL.GetUniformLocation(shader_program, "texture");
GL.Uniform1(s.UniformLocation, s.TextureIndex);
}
public void link(Shader[] shaders)
{
foreach (var shader in shaders)
{
GL.AttachShader(gl_handle, shader.gl_handle);
}
GL.LinkProgram(gl_handle);
var info = GL.GetProgramInfoLog(gl_handle);
if (!string.IsNullOrWhiteSpace(info))
{
// TODO: log info somewhere
Console.WriteLine(info);
}
foreach (var shader in shaders)
{
GL.DetachShader(gl_handle, shader.gl_handle);
}
}
protected override void LoadToGpu()
{
var allUniforms = new List <string>();
allUniforms.AddRange(new[] { "modelMatrix" });
allUniforms.AddRange(_uniforms);
foreach (var shader in _shaders)
{
// Make sure the shader is compiled before continuing
shader.GpuAllocateImmediate();
GL.AttachShader(GLHandle, shader.GLHandle);
}
GL.LinkProgram(GLHandle);
foreach (var shader in _shaders)
{
GL.DetachShader(GLHandle, shader.GLHandle);
}
GL.UseProgram(GLHandle);
// Get all Attribute locations
foreach (var attrib in _attributes)
{
var location = GL.GetAttribLocation(GLHandle, attrib);
if (location < 0)
{
Console.WriteLine(@"Failed to find the attribute [" + attrib + @"] in shader GLSL.");
}
AttributeLocations.Add(attrib, location);
}
// Get all Uniform locations
foreach (var uniform in allUniforms)
{
var location = GL.GetUniformLocation(GLHandle, uniform);
if (location < 0)
{
Console.WriteLine(@"Failed to find the uniform [" + uniform + @"] in shader GLSL.");
}
UniformLocations.Add(uniform, location);
}
}
public static bool TryCreate(Dictionary <ShaderType, string> subshaders, out ShaderProgram program)
{
bool ret = true;
program = new ShaderProgram();
List <int> shaders = new List <int>();
foreach (KeyValuePair <ShaderType, string> shader in subshaders)
{
program.Log("Compiling Shader: " + shader.Value, DebugChannel.Log, 10);
string code = File.ReadAllText(shader.Value);
bool r = TryCompileShader(shader.Key, code, out int id);
ret &= r;
if (r)
{
shaders.Add(id);
}
}
for (int i = 0; i < shaders.Count; i++)
{
program.Log("Attaching Shader to Program: " + subshaders.ElementAt(i), DebugChannel.Log, 10);
GL.AttachShader(program._prgID, shaders[i]);
}
program.Log("Linking Program...", DebugChannel.Log, 10);
GL.LinkProgram(program._prgID);
GL.GetProgram(program._prgID, GetProgramParameterName.LinkStatus, out int success);
if (success == 0)
{
program.Log(GL.GetProgramInfoLog(program._prgID), DebugChannel.Error, 10);
return(false);
}
return(ret);
}
public Shader(string vert, string frag)
{
_program = GL.CreateProgram();
_frag = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(_frag, frag);
CompileShader(_frag);
_vert = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(_vert, vert);
CompileShader(_vert);
GL.AttachShader(_program, _frag);
GL.AttachShader(_program, _vert);
GL.LinkProgram(_program);
int linkstatus;
GL.GetProgram(_program, GetProgramParameterName.LinkStatus, out linkstatus);
if (linkstatus == 0)
{
throw new Exception("Shader program link error: " + GL.GetProgramInfoLog(_program));
}
GL.ValidateProgram(_program);
}
/// <summary>
/// Creates the shader program object with the shader objects as input
/// </summary>
/// <param name="handles">Array of integer containing the handles of the OpenGL shader objects</param>
/// <returns></returns>
int CreateProgram(int[] handles)
{
int programHandle = GL.CreateProgram();
foreach (int handle in handles)
{
GL.AttachShader(programHandle, handle);
}
BindAttributes(programHandle);
GL.LinkProgram(programHandle);
Debug.WriteLine(GL.GetProgramInfoLog(programHandle));
foreach (int handle in handles)
{
GL.DetachShader(programHandle, handle);
}
return(programHandle);
}
/// <summary>
/// Tries to Create a Shader from source
/// </summary>
/// <param name="subshaders">Dictionary of ShaderType, Path To File</param>
/// <param name="program">Resulting Shader Program</param>
/// <returns>The Success State of the Compilation</returns>
internal static bool TryCreateFromSource(Dictionary <ShaderType, string> subshaders, out ShaderProgram program)
{
bool ret = true;
program = new ShaderProgram();
List <int> shaders = new List <int>();
foreach (KeyValuePair <ShaderType, string> shader in subshaders)
{
Logger.Log(DebugChannel.Log | DebugChannel.EngineRendering, "Compiling Shader: " + shader.Key, 5);
bool r = TryCompileShader(shader.Key, shader.Value, out int id);
ret &= r;
if (r)
{
shaders.Add(id);
}
}
for (int i = 0; i < shaders.Count; i++)
{
Logger.Log(DebugChannel.Log | DebugChannel.EngineRendering,
"Attaching Shader to Program: " + subshaders.ElementAt(i).Key, 6);
GL.AttachShader(program.prgId, shaders[i]);
}
Logger.Log(DebugChannel.Log | DebugChannel.EngineRendering, "Linking Program...", 5);
GL.LinkProgram(program.prgId);
GL.GetProgram(program.prgId, GetProgramParameterName.LinkStatus, out int success);
if (success == 0)
{
Logger.Crash(new OpenGLShaderException(GL.GetProgramInfoLog(program.prgId)), true);
return(false);
}
return(ret);
}
protected virtual void LoadShaderProgram(string vertexShader, string fragmentShader, out int programHandle)
{
Console.WriteLine(@"Loading {0} and {1}.", vertexShader, fragmentShader);
string vertexShaderSource;
string fragmentShaderSource;
using (var sr = new StreamReader(vertexShader))
vertexShaderSource = sr.ReadToEnd();
using (var sr = new StreamReader(fragmentShader))
fragmentShaderSource = sr.ReadToEnd();
int vertexShaderHandle = GL.CreateShader(ShaderType.VertexShader);
int fragmentShaderHandle = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(vertexShaderHandle, vertexShaderSource);
GL.ShaderSource(fragmentShaderHandle, fragmentShaderSource);
GL.CompileShader(vertexShaderHandle);
GL.CompileShader(fragmentShaderHandle);
Console.WriteLine(GL.GetShaderInfoLog(vertexShaderHandle));
Console.WriteLine(GL.GetShaderInfoLog(fragmentShaderHandle));
// Create program
programHandle = GL.CreateProgram();
GL.AttachShader(programHandle, vertexShaderHandle);
GL.AttachShader(programHandle, fragmentShaderHandle);
GL.LinkProgram(programHandle);
GL.GetProgram(programHandle, ProgramParameter.ValidateStatus, out int statusCode);
GL.GetProgramInfoLog(programHandle, out string infoString);
if (statusCode != 1)
{
Console.WriteLine(@"Error validating the shader: " + infoString);
}
}
protected override void OnLoad(EventArgs e)
{
// Load the source of the vertex shader and compile it.
VertexShader = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexShader, VertexShaderSource);
GL.CompileShader(VertexShader);
// Load the source of the fragment shader and compile it.
FragmentShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(FragmentShader, FragmentShaderSource);
GL.CompileShader(FragmentShader);
// Create the shader program, attach the vertex and fragment shaders and link the program.
ShaderProgram = GL.CreateProgram();
GL.AttachShader(ShaderProgram, VertexShader);
GL.AttachShader(ShaderProgram, FragmentShader);
GL.LinkProgram(ShaderProgram);
// Create the vertex buffer object (VBO) for the vertex data.
VertexBufferObject = GL.GenBuffer();
// Bind the VBO and copy the vertex data into it.
GL.BindBuffer(BufferTarget.ArrayBuffer, VertexBufferObject);
GL.BufferData(BufferTarget.ArrayBuffer, Points.Length * sizeof(float), Points, BufferUsageHint.StaticDraw);
// Retrive the position location from the program.
var positionLocation = GL.GetAttribLocation(ShaderProgram, "position");
// Create the vertex array object (VAO) for the program.
VertexArrayObject = GL.GenVertexArray();
// Bind the VAO and setup the position attribute.
GL.BindVertexArray(VertexArrayObject);
GL.VertexAttribPointer(positionLocation, 4, VertexAttribPointerType.Float, false, 0, 0);
GL.EnableVertexAttribArray(positionLocation);
// Set the clear color to blue
GL.ClearColor(0.0f, 0.0f, 1.0f, 1.0f);
base.OnLoad(e);
}
public static int LoadShaderProgram(string vertexShaderPath, string fragmentShaderPath)
{
int vertexShaderIndex, fragmentShaderIndex;
vertexShaderIndex = LoadShader(vertexShaderPath, ShaderType.VertexShader);
fragmentShaderIndex = LoadShader(fragmentShaderPath, ShaderType.FragmentShader);
if (vertexShaderIndex == 0 || fragmentShaderIndex == 0)
{
Logger.Log("Failed to create shader program.");
return(0);
}
int programIndex = GL.CreateProgram();
if (programIndex == 0)
{
Logger.Log("Failed to create shader program object.");
return(0);
}
GL.AttachShader(programIndex, vertexShaderIndex);
GL.AttachShader(programIndex, fragmentShaderIndex);
GL.LinkProgram(programIndex);
int linkingStatus;
GL.GetProgram(programIndex, GetProgramParameterName.LinkStatus, out linkingStatus);
if (linkingStatus == 0)
{
Logger.Log("Failed to link shader program. Linking error: " + GL.GetProgramInfoLog(programIndex));
GL.DeleteProgram(programIndex);
GL.DeleteShader(vertexShaderIndex);
GL.DeleteShader(fragmentShaderIndex);
return(0);
}
return(programIndex);
}
/// <summary>
/// 链接着色器->着色器程序
/// </summary>
/// <param name="pixelShader"></param>
/// <param name="vertexShader"></param>
/// <returns></returns>
private ShaderProgram Link(Shader pixelShader, Shader vertexShader)
{
var program = GL.CreateProgram();
GraphicsExtensions.CheckGLError();
GL.AttachShader(program, vertexShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
GL.AttachShader(program, pixelShader.GetShaderHandle());
GraphicsExtensions.CheckGLError();
GL.LinkProgram(program);
GraphicsExtensions.CheckGLError();
GL.UseProgram(program);
GraphicsExtensions.CheckGLError();
vertexShader.GetVertexAttributeLocations(program);
pixelShader.ApplySamplerTextureUnits(program);
var linked = 0;
GL.GetProgram(program, GetProgramParameterName.LinkStatus, out linked);
if (linked == (int)Bool.False)
{
GL.DetachShader(program, vertexShader.GetShaderHandle());
GL.DetachShader(program, pixelShader.GetShaderHandle());
GL.DeleteProgram(program);
throw new InvalidOperationException("Unable to link effect program");
}
return(new ShaderProgram(program));
}
public GLProgram(string vShaderFilename, string fShaderFilename)
{
attributes = new List <string> ();
program = GL.CreateProgram();
string vertShaderPathName = NSBundle.MainBundle.PathForResource(vShaderFilename, "vsh");
if (!compileShader(ref vertShader, ShaderType.VertexShader, vertShaderPathName))
{
Console.WriteLine("Failed to compile the vertex shader");
}
string fragShaderPathName = NSBundle.MainBundle.PathForResource(fShaderFilename, "fsh");
if (!compileShader(ref fragShader, ShaderType.FragmentShader, fragShaderPathName))
{
Console.WriteLine("Failed to compile the fragment shader");
}
GL.AttachShader(program, vertShader);
GL.AttachShader(program, fragShader);
}
/// <summary>
/// Creates the shaders.
/// </summary>
public static void CreateShader(string vertexShaderSource, string fragmentShaderSource,
out int vertexShaderId, out int fragmentShaderId,
out int programId)
{
int status_code;
string info;
vertexShaderId = GL.CreateShader(ShaderType.VertexShader);
fragmentShaderId = GL.CreateShader(ShaderType.FragmentShader);
// Compile vertex shader
GL.ShaderSource(vertexShaderId, vertexShaderSource);
GL.CompileShader(vertexShaderId);
GL.GetShaderInfoLog(vertexShaderId, out info);
GL.GetShader(vertexShaderId, ShaderParameter.CompileStatus, out status_code);
if (status_code != 1)
{
throw new ApplicationException(info);
}
// Compile vertex shader
GL.ShaderSource(fragmentShaderId, fragmentShaderSource);
GL.CompileShader(fragmentShaderId);
GL.GetShaderInfoLog(fragmentShaderId, out info);
GL.GetShader(fragmentShaderId, ShaderParameter.CompileStatus, out status_code);
if (status_code != 1)
{
throw new ApplicationException(info);
}
programId = GL.CreateProgram();
GL.AttachShader(programId, fragmentShaderId);
GL.AttachShader(programId, vertexShaderId);
GL.LinkProgram(programId);
GL.UseProgram(programId);
}
void CreateShaders()
{
vertexShaderHandle = GL.CreateShader(ShaderType.VertexShader);
fragmentShaderHandle = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(vertexShaderHandle, vertexShaderSource);
GL.ShaderSource(fragmentShaderHandle, fragmentShaderSource);
GL.CompileShader(vertexShaderHandle);
GL.CompileShader(fragmentShaderHandle);
Debug.WriteLine(GL.GetShaderInfoLog(vertexShaderHandle));
Debug.WriteLine(GL.GetShaderInfoLog(fragmentShaderHandle));
// Create program
shaderProgramHandle = GL.CreateProgram();
GL.AttachShader(shaderProgramHandle, vertexShaderHandle);
GL.AttachShader(shaderProgramHandle, fragmentShaderHandle);
GL.BindAttribLocation(shaderProgramHandle, 0, "in_position");
GL.BindAttribLocation(shaderProgramHandle, 1, "in_normal");
GL.LinkProgram(shaderProgramHandle);
Debug.WriteLine(GL.GetProgramInfoLog(shaderProgramHandle));
GL.UseProgram(shaderProgramHandle);
// Set uniforms
projectionMatrixLocation = GL.GetUniformLocation(shaderProgramHandle, "projection_matrix");
modelviewMatrixLocation = GL.GetUniformLocation(shaderProgramHandle, "modelview_matrix");
float aspectRatio = ClientSize.Width / (float)(ClientSize.Height);
Matrix4.CreatePerspectiveFieldOfView((float)Math.PI / 4, aspectRatio, 1, 100, out projectionMatrix);
modelviewMatrix = Matrix4.LookAt(new Vector3(0, 3, 5), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
GL.UniformMatrix4(projectionMatrixLocation, false, ref projectionMatrix);
GL.UniformMatrix4(modelviewMatrixLocation, false, ref modelviewMatrix);
}
/// <summary>
/// Compiles the specified s shader.
/// </summary>
/// <param name="sShader">The s shader.</param>
/// <param name="type">The type.</param>
/// <exception cref="ShaderCompileException">
/// Could not create " + type.ToString() + " object
/// or
/// Error compiling " + type.ToString()
/// </exception>
public void Compile(string sShader, ShaderType type)
{
IsLinked = false;
int shaderObject = GL.CreateShader(ConvertType(type));
if (0 == shaderObject)
{
throw new ShaderCompileException(type, "Could not create " + type.ToString() + " object", string.Empty, sShader);
}
// Compile vertex shader
GL.ShaderSource(shaderObject, sShader);
GL.CompileShader(shaderObject);
GL.GetShader(shaderObject, ShaderParameter.CompileStatus, out int status_code);
LastLog = GL.GetShaderInfoLog(shaderObject);
if (1 != status_code)
{
GL.DeleteShader(shaderObject);
throw new ShaderCompileException(type, "Error compiling " + type.ToString(), LastLog, sShader);
}
GL.AttachShader(ProgramID, shaderObject);
shaderIDs.Add(shaderObject);
}
private int CompileShaders()
{
vertexShader = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(vertexShader, VertexShader);
GL.CompileShader(vertexShader);
fragmentShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(fragmentShader, FragmentShader);
GL.CompileShader(fragmentShader);
var program = GL.CreateProgram();
GL.AttachShader(program, vertexShader);
GL.AttachShader(program, fragmentShader);
GL.LinkProgram(program);
GL.DetachShader(program, vertexShader);
GL.DetachShader(program, fragmentShader);
GL.DeleteShader(vertexShader);
GL.DeleteShader(fragmentShader);
return(program);
}
public void Compile(string sShader, ShaderType type)
{
IsLinked = false;
int shaderObject = GL.CreateShader(type);
if (0 == shaderObject)
{
throw new ShaderException(type.ToString(), "Could not create shader object", string.Empty, sShader);
}
// Compile vertex shader
GL.ShaderSource(shaderObject, sShader);
GL.CompileShader(shaderObject);
int statusCode;
GL.GetShader(shaderObject, ShaderParameter.CompileStatus, out statusCode);
if (1 != statusCode)
{
throw new ShaderException(type.ToString(), "Error compiling shader", GL.GetShaderInfoLog(shaderObject), sShader);
}
GL.AttachShader(_mProgramId, shaderObject);
//shaderIDs.Add(shaderObject);
}
private static void InitShaders()
{
program = GL.CreateProgram();
int vertexShader = GL.CreateShader(ShaderType.VertexShader);
int fragmentShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(vertexShader, VERTEX_SHADER);
GL.CompileShader(vertexShader);
string info = GL.GetShaderInfoLog(vertexShader);
if (!string.IsNullOrEmpty(info))
{
Debug.Print("Vertex shader failed to compile: " + info);
return;
}
GL.ShaderSource(fragmentShader, FRAGMENT_SHADER);
GL.CompileShader(fragmentShader);
info = GL.GetShaderInfoLog(vertexShader);
if (!string.IsNullOrEmpty(info))
{
Debug.Print("Fragment shader failed to compile: " + info);
return;
}
GL.AttachShader(program, vertexShader);
GL.AttachShader(program, fragmentShader);
GL.LinkProgram(program);
info = GL.GetProgramInfoLog(program);
if (!string.IsNullOrEmpty(info))
{
Debug.Print("Program failed to link: " + info);
return;
}
GL.DetachShader(program, vertexShader);
GL.DetachShader(program, fragmentShader);
GL.DeleteShader(vertexShader);
GL.DeleteShader(fragmentShader);
}
private ShaderProgram(List <Shader> shaders)
{
Shaders = shaders;
// Get the next available program handle
handle = GL.CreateProgram();
// Attach each shader to the program
foreach (Shader s in shaders)
{
GL.AttachShader(handle, s.Handle);
}
// Links the shaders now assigned to the program together
GL.LinkProgram(handle);
Console.WriteLine("Sucesfully linked Shader Program Handle " + this.handle + " with the following Shaders:");
foreach (Shader s in shaders)
{
Console.WriteLine(string.Format(" {0} - Handle: {1}", System.IO.Path.GetFileName(s.Name), s.Handle.ToString()));
}
}
public static int _CompilerShader(string vertexShaderSrc, string pixelShaderSrc)
{
int vertexShader = 0;
int pixelShader = 0;
int shaderProgram = 0;
vertexShader = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(vertexShader, vertexShaderSrc);
GL.CompileShader(vertexShader);
int length = 0;
GL.GetShader(vertexShader, ShaderParameter.CompileStatus, out length);
string errorInfo = GL.GetShaderInfoLog(vertexShader);
Console.WriteLine("vertexShader " + errorInfo + " " + length);
pixelShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(pixelShader, pixelShaderSrc);
GL.CompileShader(pixelShader);
GL.GetShader(pixelShader, ShaderParameter.CompileStatus, out length);
errorInfo = GL.GetShaderInfoLog(pixelShader);
Console.WriteLine("pixelShader " + errorInfo + " " + length);
shaderProgram = GL.CreateProgram();
GL.AttachShader(shaderProgram, vertexShader);
GL.AttachShader(shaderProgram, pixelShader);
GL.LinkProgram(shaderProgram);
GL.GetProgram(shaderProgram, GetProgramParameterName.LinkStatus, out length);
errorInfo = GL.GetProgramInfoLog(shaderProgram);
Console.WriteLine("shaderProgram " + errorInfo + " " + length);
GL.DeleteShader(vertexShader);
GL.DeleteShader(pixelShader);
return(shaderProgram);
}
/// <summary>
/// Compiles a VertexShader and FragmentShader to a usable shader program.
/// </summary>
/// <param name="VS">The input VertexShader code.</param>
/// <param name="FS">The input FragmentShader code.</param>
/// <returns>The internal OpenGL program ID.</returns>
public static int CompileShader(string vs, string fs)
{
int VertexObject = GL.CreateShader(ShaderType.VertexShader);
GL.ShaderSource(VertexObject, vs);
GL.CompileShader(VertexObject);
string VS_Info = GL.GetShaderInfoLog(VertexObject);
GL.GetShader(VertexObject, ShaderParameter.CompileStatus, out int VS_Status);
if (VS_Status != 1)
{
throw new Exception("Error creating VertexShader. Error status: " + VS_Status + ", info: " + VS_Info);
}
int FragmentObject = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(FragmentObject, fs);
GL.CompileShader(FragmentObject);
string FS_Info = GL.GetShaderInfoLog(FragmentObject);
GL.GetShader(FragmentObject, ShaderParameter.CompileStatus, out int FS_Status);
if (FS_Status != 1)
{
throw new Exception("Error creating FragmentShader. Error status: " + FS_Status + ", info: " + FS_Info);
}
int Program = GL.CreateProgram();
GL.AttachShader(Program, FragmentObject);
GL.AttachShader(Program, VertexObject);
GL.LinkProgram(Program);
string str = GL.GetProgramInfoLog(Program);
if (str.Length != 0)
{
throw new Exception("Linked shader with message: '" + str + "'" + " -- FOR -- " + vs + " -- -- " + fs);
}
GL.DeleteShader(FragmentObject);
GL.DeleteShader(VertexObject);
return(Program);
}
private void setUpProgram()
{
mProgram = GL.CreateProgram();
mVertexShader = GL.CreateShader(ShaderType.VertexShader);
mFragShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(mVertexShader, File.ReadAllText("Shaders\\Vertex.vert"));
GL.ShaderSource(mFragShader, File.ReadAllText("Shaders\\Fragment.frag"));
GL.CompileShader(mVertexShader);
GL.CompileShader(mFragShader);
Console.WriteLine(GL.GetShaderInfoLog(mVertexShader));
Console.WriteLine(GL.GetShaderInfoLog(mFragShader));
GL.AttachShader(mProgram, mVertexShader);
GL.AttachShader(mProgram, mFragShader);
GL.LinkProgram(mProgram);
Console.WriteLine(GL.GetProgramInfoLog(mProgram));
}
void IMustInit.Init(GL gl)
{
P = gl.CreateProgram();
gl.AttachShader(P,VShader.S);
gl.AttachShader(P,FShader.S);
gl.LinkProgram(P);
////////////////////////////////////////////////////////////////
int ACount = 0;
gl.GetProgramiv(P,ACTIVE_ATTRIBUTES,&ACount);
if(ACount >= 0)
{
uint i = 0;
while(i < ACount)
{
uint T;
int Lng,Sze;
sbyte* pName = stackalloc sbyte[64];
gl.GetActiveAttrib(P,i,64,&Lng,&Sze,&T,pName);
int Location = gl.GetAttribLocation(P,pName);
if(Location >= 0)
{
string AName = new string(pName);
Attributes[AName] = new Attribute(Location,AName);
}
i++;
}
}
int UCount = 0;
gl.GetProgramiv(P,ACTIVE_UNIFORMS,&UCount);
if(UCount >= 0)
{
uint i = 0;
while(i < UCount)
{
int Lng,Sze;
uint T;
sbyte* pName = stackalloc sbyte[64];
gl.GetActiveUniform(P,i,64,&Lng,&Sze,&T,pName);
int Location = gl.GetUniformLocation(P,pName);
if(Location >= 0)
{
string UName = new string(pName);
Uniforms[UName] = new Uniform(gl,Location,UName);
}
i++;
}
}
}
