public static Shader LoadShader(string file, bool usePath = false) { string source = LoadSource(file, usePath); if (!(source.Contains("#type vertex") && source.Contains("#type fragment"))) { Log.Error(""); return(null); } var sources = source.Split(new string[] { "#type vertex", "#type fragment" }, StringSplitOptions.RemoveEmptyEntries); var vertexID = CompileShader(sources[0], ShaderType.VertexShader); var fragmentID = CompileShader(sources[1], ShaderType.FragmentShader); int programID = GL.CreateProgram(); GL.AttachShader(programID, vertexID); GL.AttachShader(programID, fragmentID); GL.BindAttribLocation(programID, 0, "position"); GL.BindAttribLocation(programID, 1, "textureCoords"); GL.LinkProgram(programID); GL.ValidateProgram(programID); Shader shader = new Shader(programID, vertexID, fragmentID); Shaders.Add(shader); return(shader); }
/// <summary> /// Create Program and load shader /// </summary> private void GetProgram() { string vertexShaderSrc = "uniform mat4 uMVPMatrix; \n" + "attribute vec4 aPosition; \n" + "attribute vec2 a_TextureCoordinates; \n" + "varying vec2 v_TextureCoordinates;" + "void main() \n" + "{ \n" + " gl_Position = uMVPMatrix * aPosition; \n" + " v_TextureCoordinates = a_TextureCoordinates;\n" + "} \n"; string fragmentShaderSrc = "precision mediump float; \n" + "uniform sampler2D u_TextureUnit; \n" + "varying vec2 v_TextureCoordinates; \n" + "void main() \n" + "{ \n" + " gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);\n" + "} \n"; program = ShaderHelper.BuildProgram(vertexShaderSrc, fragmentShaderSrc); GL.BindAttribLocation(program, 0, "aPosition"); GL.LinkProgram(program); GL.UseProgram(program); }
public void BindAttributes() { foreach (KeyValuePair <string, int> attrib in Attributes) { GL.BindAttribLocation(ProgramID, attrib.Value, attrib.Key); } }
/* * public bool LoadFromFile(string vs, string fs) * { * string vss = ""; * string fss = ""; * return LoadFromString(vss, fss); * } */ public bool LoadFromString(string vss, string fss) { program = GL.CreateProgram(); vs = GL.CreateShader(ShaderType.VertexShader); fs = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(vs, vss); GL.ShaderSource(fs, fss); GL.CompileShader(vs); GL.CompileShader(fs); GL.AttachShader(program, vs); GL.AttachShader(program, fs); GL.BindAttribLocation(program, 0, "in_position"); GL.BindAttribLocation(program, 1, "in_color"); GL.BindFragDataLocation(program, 0, "out_color"); GL.LinkProgram(program); GL.UseProgram(program); if (!PrintLog("Vertex Shader", vs) || !PrintLog("Fragment Shader", fs) || !PrintLog("Shader Program", program) ) { return(false); } return(true); }
public void BindAttribute(string attrName) { AttributeProperties attr = this.GetAttributeByName(attrName); GL.BindAttribLocation(ProgramId, attr.Id, attr.Name); //GL.BindAttribLocation(ProgramId, 0, "vPosition") }
public void BindLayouts(int shader) { foreach (KeyValuePair <int, string> pair in _layout) { GL.BindAttribLocation(shader, pair.Key, pair.Value); } }
private protected virtual bool CompileInternal() { foreach (ShaderPart p in parts) { if (!p.Compiled) { p.Compile(); } GL.AttachShader(this, p); foreach (ShaderInputInfo input in p.ShaderInputs) { GL.BindAttribLocation(this, input.Location, input.Name); } } GL.LinkProgram(this); GL.GetProgram(this, GetProgramParameterName.LinkStatus, out int linkResult); foreach (var part in parts) { GL.DetachShader(this, part); } return(linkResult == 1); }
void CreateShaders() { ShaderProgramHandle = GL.CreateProgram(); VertexShaderHandle = GL.CreateShader(ShaderType.VertexShader); 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)); GL.AttachShader(ShaderProgramHandle, VertexShaderHandle); GL.AttachShader(ShaderProgramHandle, FragmentShaderHandle); GL.BindAttribLocation(ShaderProgramHandle, 0, "vertex_position"); GL.BindAttribLocation(ShaderProgramHandle, 1, "vertex_color"); Console.WriteLine(GL.GetProgramInfoLog(ShaderProgramHandle)); GL.LinkProgram(ShaderProgramHandle); Console.WriteLine(GL.GetProgramInfoLog(ShaderProgramHandle)); GL.UseProgram(ShaderProgramHandle); }
internal void BindAttribute(VertexElementUsage usage, string name) { ThreadingHelper.BlockOnUIThread(() => { GL.BindAttribLocation(program, (int)usage, name); }); }
protected override void CreateShaderFromFile(string vertShader, string fragShader) { //Initialize the OpenGL Program _programId = GL.CreateProgram(); int vertShaderId, fragShaderId; LoadShader(vertShader, ShaderType.VertexShader, _programId, out vertShaderId); LoadShader(fragShader, ShaderType.FragmentShader, _programId, out fragShaderId); //Deincriment the reference count on the shaders so that they //don't exist until the context is destroyed. GL.DeleteShader(vertShaderId); GL.DeleteShader(fragShaderId); GL.BindAttribLocation(_programId, (int)ShaderAttributeIds.Position, "vertexPos"); GL.BindAttribLocation(_programId, (int)ShaderAttributeIds.Color, "inColor"); GL.BindAttribLocation(_programId, (int)ShaderAttributeIds.TexCoord, "vertexUV"); //Link shaders GL.LinkProgram(_programId); _uniformMVP = GL.GetUniformLocation(_programId, "modelview"); if (GL.GetError() != ErrorCode.NoError) { Console.WriteLine(GL.GetProgramInfoLog(_programId)); } }
private void Compile() { ShaderProgram = GL.CreateProgram(); var vertexShader = LoadShader(ShaderType.VertexShader, vertexShaderCode); var fragmentShader = LoadShader(ShaderType.FragmentShader, fragmentShaderCode); GL.AttachShader(ShaderProgram, vertexShader); GL.AttachShader(ShaderProgram, fragmentShader); GL.BindAttribLocation(ShaderProgram, (int)ShaderAttributeEntity.Vertex, "a_vertex"); GL.BindAttribLocation(ShaderProgram, (int)ShaderAttributeEntity.Color, "a_color"); GL.LinkProgram(ShaderProgram); MatrixHandle = GL.GetUniformLocation(ShaderProgram, "u_matrix"); PointSizeHandle = GL.GetUniformLocation(ShaderProgram, "u_pointSize"); if (vertexShader != 0) { GL.DetachShader(ShaderProgram, vertexShader); GL.DeleteShader(vertexShader); } if (fragmentShader != 0) { GL.DetachShader(ShaderProgram, fragmentShader); GL.DeleteShader(fragmentShader); } GL.UseProgram(ShaderProgram); }
private void PlatformCreateShaders() { GLDebug.CheckAccess(); var vertexShaderHandle = GL.CreateShader(ShaderType.VertexShader); var fragmentShaderHandle = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(vertexShaderHandle, vertexShaderSource); GL.ShaderSource(fragmentShaderHandle, fragmentShaderSource); GL.CompileShader(vertexShaderHandle); GL.CompileShader(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_color"); GL.BindAttribLocation(shaderProgramHandle, 2, "in_uv"); GL.LinkProgram(shaderProgramHandle); Debug.WriteLine(GL.GetProgramInfoLog(shaderProgramHandle)); GL.UseProgram(shaderProgramHandle); // Set uniforms transformLocation = GL.GetUniformLocation(shaderProgramHandle, "transform"); }
public IShader Load(string vertexShaderName, string fragmentShaderName) { string vSource = EmbeddedShaderLoader.GetShader <GL20ShaderLoader>(vertexShaderName, "vert"); string fSource = EmbeddedShaderLoader.GetShader <GL20ShaderLoader>(fragmentShaderName, "frag"); int vShader = GL.CreateShader(ShaderType.VertexShader); int fShader = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(vShader, vSource); GL.ShaderSource(fShader, fSource); // Compile shaders GL.CompileShader(vShader); GL.CompileShader(fShader); Debug.WriteLine(GL.GetShaderInfoLog(vShader)); Debug.WriteLine(GL.GetShaderInfoLog(fShader)); int program = GL.CreateProgram(); // Link and attach shaders to program GL.AttachShader(program, vShader); GL.AttachShader(program, fShader); GL.BindAttribLocation(program, 0, "in_screen_coords"); GL.BindAttribLocation(program, 1, "in_uv"); GL.BindAttribLocation(program, 2, "in_color"); GL.LinkProgram(program); Debug.WriteLine(GL.GetProgramInfoLog(program)); return(new GLShader(program, vShader, fShader)); }
protected override void BindAttributes(int programHandle) { base.BindAttributes(programHandle); GL.BindAttribLocation(programHandle, 1, "vertex_normal"); GL.BindAttribLocation(programHandle, 2, "left_color"); GL.BindAttribLocation(programHandle, 3, "right_color"); }
private int GenVertexArray(VBO vbo) { Console.WriteLine(@"In GenVertexArray"); GL.GenVertexArrays(1, out int vaoHandle); GL.BindVertexArray(vaoHandle); switch (vbo.VertexFormat) { case InterleavedArrayFormat.T2fN3fV3f: { var stride = 32; GL.EnableVertexAttribArray(0); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo.VboID); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, stride, 20); GL.BindAttribLocation(Handle, 0, "vertexPosition_modelspace"); GL.EnableVertexAttribArray(1); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo.VboID); GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, true, stride, 8); GL.BindAttribLocation(Handle, 1, "vertexNormal_modelspace"); GL.EnableVertexAttribArray(2); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo.VboID); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, stride, 0); GL.BindAttribLocation(Handle, 2, "in_texture"); GL.BindVertexArray(0); } break; default: throw new Exception(@"unrecognized InterleavedArrayFormat"); } return(vaoHandle); }
protected void Load2() { string vShaderStr = "uniform mat4 u_mvpMatrix; \n" + "attribute vec4 a_position; \n" + "varying vec4 vColor; \n" + "void main() \n" + "{ \n" + " vColor = a_position; \n" + " gl_Position = u_mvpMatrix * a_position; \n" + "} \n"; string fShaderStr = "precision mediump float; \n" + "varying vec4 vColor; \n" + "void main() \n" + "{ \n" + " gl_FragColor = vColor; \n" + "} \n"; programObject2 = ShaderHelper.BuildProgram(vShaderStr, fShaderStr); GL.BindAttribLocation(programObject2, 0, "a_position"); GL.LinkProgram(programObject2); vertices2 = new float[] { -0.5f, 0.5f, 0.5f, 1.0f, 0.5f, 0.5f, 0.5f, 1.0f, -0.5f, 0.5f, -0.5f, 1.0f, 0.5f, 0.5f, -0.5f, 1.0f, -0.5f, -0.5f, -0.5f, 1.0f, 0.5f, -0.5f, -0.5f, 1.0f, 0.5f, -0.5f, 0.5f, 1.0f, -0.5f, -0.5f, 0.5f, 1.0f }; }
public Shader(string vertexCode, string fragmentCode) { VertexID = LoadShader(vertexCode, ShaderType.VertexShader); FragmentID = LoadShader(fragmentCode, ShaderType.FragmentShader); ProgramID = GL.CreateProgram(); GL.AttachShader(ProgramID, VertexID); GL.AttachShader(ProgramID, FragmentID); // Binds the matrix to the vertex shader sort of GL.BindAttribLocation(ProgramID, 0, "mvp"); GL.LinkProgram(ProgramID); // Check if linked GL.GetProgram(ProgramID, GetProgramParameterName.LinkStatus, out int linked); if (linked < 1) { GL.GetProgramInfoLog(ProgramID, out string info); Console.WriteLine($"Failed to link shader program :\n{info}"); } MVPID = GL.GetUniformLocation(ProgramID, "mvp"); GL.DetachShader(ProgramID, VertexID); GL.DetachShader(ProgramID, FragmentID); GL.DeleteShader(VertexID); GL.DeleteShader(FragmentID); }
protected override void BindVertexAttributes() { base.BindVertexAttributes(); GL.BindAttribLocation(pgmId, 2, "in_normal"); GL.BindAttribLocation(pgmId, 3, "in_model"); }
/// <summary> /// Creates a camera and sets up shaders for use in the viewport. /// </summary> private void SetUpViewport() { _programID = GL.CreateProgram(); Cam = new Camera(); int vertShaderId, fragShaderId; LoadShader("vs.glsl", ShaderType.VertexShader, _programID, out vertShaderId); LoadShader("fs.glsl", ShaderType.FragmentShader, _programID, out fragShaderId); GL.DeleteShader(vertShaderId); GL.DeleteShader(fragShaderId); GL.BindAttribLocation(_programID, (int)ShaderAttributeIds.Position, "vertexPos"); GL.LinkProgram(_programID); _uniformMVP = GL.GetUniformLocation(_programID, "modelview"); _uniformColor = GL.GetUniformLocation(_programID, "col"); if (GL.GetError() != ErrorCode.NoError) { Console.WriteLine(GL.GetProgramInfoLog(_programID)); } }
public void CreateShader() { 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)); }
public void Load() { _squareVertices = new[] { //Front Face -Size, -Size, Size, Size, -Size, Size, Size, Size, Size, -Size, Size, Size, //Back Face -Size, -Size, -Size, -Size, Size, -Size, Size, Size, -Size, Size, -Size, -Size, //Top Face -Size, Size, -Size, -Size, Size, Size, Size, Size, Size, Size, Size, -Size, //Bottom Face -Size, -Size, -Size, Size, -Size, -Size, Size, -Size, Size, -Size, -Size, Size, //Right Face Size, -Size, -Size, Size, Size, -Size, Size, Size, Size, Size, -Size, Size, //Left Face -Size, -Size, -Size, -Size, -Size, Size, -Size, Size, Size, -Size, Size, -Size }; _shader = new ShaderProgram(); using (var sr = new StreamReader("Shaders/Voxel.Vert")) { _shader.AddShader(ShaderType.VertexShader, sr.ReadToEnd()); } using (var sr = new StreamReader("Shaders/VoxelGreen.Frag")) { _shader.AddShader(ShaderType.FragmentShader, sr.ReadToEnd()); } GL.BindAttribLocation(_shader.Program, 0, "position"); GL.BindAttribLocation(_shader.Program, 1, "instance_position"); GL.BindAttribLocation(_shader.Program, 2, "instance_rotation"); _shader.Link(); GL.GenVertexArrays(1, out _squareVao); GL.GenBuffers(1, out _squareVbo); GL.BindVertexArray(_squareVao); GL.BindBuffer(BufferTarget.ArrayBuffer, _squareVbo); GL.EnableVertexAttribArray(0); GL.EnableVertexAttribArray(1); GL.EnableVertexAttribArray(2); GL.Arb.VertexAttribDivisor(1, 1); GL.Arb.VertexAttribDivisor(2, 1); Loaded = true; }
public void Bind(int shaderProgram) { GL.GenVertexArrays(1, out modelBuffer); GL.BindVertexArray(modelBuffer); GL.EnableVertexAttribArray(0); GL.BindBuffer(BufferTarget.ArrayBuffer, positionBuffer); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0); GL.BindAttribLocation(shaderProgram, 0, "in_position"); GL.EnableVertexAttribArray(1); GL.BindBuffer(BufferTarget.ArrayBuffer, normalBuffer); GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0); GL.BindAttribLocation(shaderProgram, 1, "in_normal"); if (textures != null) { GL.EnableVertexAttribArray(2); GL.BindBuffer(BufferTarget.ArrayBuffer, textureBuffer); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, true, Vector2.SizeInBytes, 0); GL.BindAttribLocation(shaderProgram, 2, "in_texture"); } if (colors != null) { GL.EnableVertexAttribArray(3); GL.BindBuffer(BufferTarget.ArrayBuffer, colorBuffer); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0); GL.BindAttribLocation(shaderProgram, 3, "in_color"); } GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer); GL.BindVertexArray(0); }
public void Load() { string vSource = m_vShaderSource; string fSource = m_fShaderSource; int vShader = GL.CreateShader(ShaderType.VertexShader); int fShader = GL.CreateShader(ShaderType.FragmentShader); GL.ShaderSource(vShader, vSource); GL.ShaderSource(fShader, fSource); // Compile shaders GL.CompileShader(vShader); GL.CompileShader(fShader); Debug.WriteLine(GL.GetShaderInfoLog(vShader)); Debug.WriteLine(GL.GetShaderInfoLog(fShader)); int program = GL.CreateProgram(); // Link and attach shaders to program GL.AttachShader(program, vShader); GL.AttachShader(program, fShader); GL.BindAttribLocation(program, 0, "in_screen_coords"); GL.BindAttribLocation(program, 1, "in_uv"); GL.BindAttribLocation(program, 2, "in_color"); GL.LinkProgram(program); Debug.WriteLine(GL.GetProgramInfoLog(program)); m_Program = program; m_VertexShader = vShader; m_FragmentShader = fShader; m_Uniforms = new UniformDictionary(m_Program); }
/// <summary> /// Creates the shader program. /// </summary> /// <param name="vertexShaderSource">The vertex shader source.</param> /// <param name="fragmentShaderSource">The fragment shader source.</param> /// <param name="attributeLocations">The attribute locations. This is an optional array of /// uint attribute locations to their names.</param> public void Create(string vertexShaderSource, string fragmentShaderSource, Dictionary <uint, string> attributeLocations) { // Create the shaders. vertexShader.Create(GL.GL_VERTEX_SHADER, vertexShaderSource); fragmentShader.Create(GL.GL_FRAGMENT_SHADER, fragmentShaderSource); // Create the program, attach the shaders. shaderProgramObject = GL.CreateProgram(); GL.AttachShader(shaderProgramObject, vertexShader.ShaderObject); GL.AttachShader(shaderProgramObject, fragmentShader.ShaderObject); // Before we link, bind any vertex attribute locations. if (attributeLocations != null) { foreach (var vertexAttributeLocation in attributeLocations) { GL.BindAttribLocation(shaderProgramObject, vertexAttributeLocation.Key, vertexAttributeLocation.Value); } } // Now we can link the program. GL.LinkProgram(shaderProgramObject); // Now that we've compiled and linked the shader, check it's link status. If it's not linked properly, we're // going to throw an exception. if (GetLinkStatus() == false) { throw new Exception(); } }
protected override void createVAOs() { if (material == null) { Log.WriteLine(Log.LOG_ERROR, "can not create VAOs without material set for model '" + Name + "'"); return; } GL.GenVertexArrays(1, out vaoHandle); GL.BindVertexArray(vaoHandle); GL.EnableVertexAttribArray(0); GL.BindBuffer(BufferTarget.ArrayBuffer, positionVboHandle); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0); GL.BindAttribLocation(material.ProgramHandle, 0, "in_position"); GL.EnableVertexAttribArray(1); GL.BindBuffer(BufferTarget.ArrayBuffer, normalVboHandle); GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0); GL.BindAttribLocation(material.ProgramHandle, 1, "in_normal"); GL.BindBuffer(BufferTarget.ElementArrayBuffer, eboHandle); GL.BindVertexArray(0); }
/// <summary> /// Creates the shader program. /// </summary> /// <param name="gl">The gl.</param> /// <param name="vertexShaderSource">The vertex shader source.</param> /// <param name="fragmentShaderSource">The fragment shader source.</param> /// <param name="attributeLocations">The attribute locations. This is an optional array of /// uint attribute locations to their names.</param> /// <exception cref="ShaderCompilationException"></exception> public void Create(GL gl, string vertexShaderSource, string fragmentShaderSource, Dictionary <uint, string> attributeLocations) { // Create the shaders. vertexShader.Create(gl, (uint)GLEnum.VertexShader, vertexShaderSource); fragmentShader.Create(gl, (uint)GLEnum.FragmentShader, fragmentShaderSource); // Create the program, attach the shaders. shaderProgramObject = gl.CreateProgram(); gl.AttachShader(shaderProgramObject, vertexShader.ShaderObject); gl.AttachShader(shaderProgramObject, fragmentShader.ShaderObject); // Before we link, bind any vertex attribute locations. if (attributeLocations != null) { foreach (var vertexAttributeLocation in attributeLocations) { gl.BindAttribLocation(shaderProgramObject, vertexAttributeLocation.Key, vertexAttributeLocation.Value); } } // Now we can link the program. gl.LinkProgram(shaderProgramObject); // Now that we've compiled and linked the shader, check it's link status. If it's not linked properly, we're // going to throw an exception. if (GetLinkStatus(gl) == false) { throw new ShaderCompilationException(string.Format("Failed to link shader program with ID {0}.", shaderProgramObject), GetInfoLog(gl)); } }
private void bindAttributes(string[] inVariables) { for (int i = 0; i < inVariables.Length; i++) { GL.BindAttribLocation(programID, i, inVariables[i]); } }
public ShaderProgram(string vertexShaderPath, string fragmentShaderPath) { ProgramId = GL.CreateProgram(); LoadShader(vertexShaderPath, ShaderType.VertexShader, ProgramId); LoadShader(fragmentShaderPath, ShaderType.FragmentShader, ProgramId); GL.BindAttribLocation(ProgramId, (int)ShaderAttributeIds.Position, "vertexPos"); GL.BindAttribLocation(ProgramId, (int)ShaderAttributeIds.Color0, "color0"); GL.BindAttribLocation(ProgramId, (int)ShaderAttributeIds.Tex0, "texCoord0"); GL.LinkProgram(ProgramId); if (GL.GetError() != ErrorCode.NoError) { Console.WriteLine("[EditorCore.Rendering] Error linking shader. Result: {0}", GL.GetProgramInfoLog(ProgramId)); } UniformMVP = GL.GetUniformLocation(ProgramId, "modelview"); UniformColor = GL.GetUniformLocation(ProgramId, "inColor"); if (GL.GetError() != ErrorCode.NoError) { Console.WriteLine("[EditorCore.Rendering] Failed to get modelview uniform for shader. Result: {0}", GL.GetProgramInfoLog(ProgramId)); } }
/// <summary> /// Links a vertex and fragment shader together to create a shader program. /// </summary> /// <param name="vertexShader">Specifies the vertex shader.</param> /// <param name="fragmentShader">Specifies the fragment shader.</param> public ShaderProgram(Shader vertexShader, Shader fragmentShader) { this.VertexShader = vertexShader; this.FragmentShader = fragmentShader; this.ProgramId = GL.CreateProgram(); this.DisposeChildren = false; GL.BindAttribLocation(ProgramId, VertexPosition, "vertexPosition"); GL.BindAttribLocation(ProgramId, VertexColor, "vertexColor"); GL.BindAttribLocation(ProgramId, VertexSize, "vertexSize"); GL.BindAttribLocation(ProgramId, TextureCoords, "textureCoord"); GL.AttachShader(ProgramId, vertexShader.ShaderID); GL.AttachShader(ProgramId, fragmentShader.ShaderID); GL.LinkProgram(ProgramId); int status; GL.GetProgram(ProgramId, GetProgramParameterName.LinkStatus, out status); if (status == 0) { Logging.Error("Error Linking Program: {0}", ProgramLog); } GetParams(); }
private void LoadBuffers() { var positionAttributeLocation = GL.GetAttribLocation(programId, "a_verts"); var texCoordsAttribLocation = GL.GetAttribLocation(programId, "a_texCoords"); GL.BindAttribLocation(programId, positionAttributeLocation, "a_verts"); GL.BindAttribLocation(programId, texCoordsAttribLocation, "a_texCoords"); vertexArrayId = GL.GenVertexArray(); GL.BindVertexArray(vertexArrayId); var positionBuffer = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ArrayBuffer, positionBuffer); GL.BufferData <Vector3>(BufferTarget.ArrayBuffer, (IntPtr)(cubeVertices.Count() * Vector3.SizeInBytes), cubeVertices, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(positionAttributeLocation, 3, VertexAttribPointerType.Float, false, 0, 0); var textureBuffer = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ArrayBuffer, textureBuffer); GL.BufferData <Vector2>(BufferTarget.ArrayBuffer, (IntPtr)(texCoords.Count() * Vector2.SizeInBytes), texCoords, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(texCoordsAttribLocation, 2, VertexAttribPointerType.Float, false, 0, 0); var indexBuffer = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer); GL.BufferData <int>(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(int)), indices, BufferUsageHint.StaticDraw); GL.EnableVertexAttribArray(positionAttributeLocation); GL.EnableVertexAttribArray(texCoordsAttribLocation); }