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++; } } }