func createprogram() gl.Uint {
// VERTEX SHADER
vs := gl.CreateShader(gl.VERTEX_SHADER)
vs_source := gl.GLString(vertexShaderSource)
gl.ShaderSource(vs, 1, &vs_source, nil)
gl.CompileShader(vs)
var vs_status gl.Int
gl.GetShaderiv(vs, gl.COMPILE_STATUS, &vs_status)
fmt.Printf("Compiled Vertex Shader: %v\n", vs_status)
// FRAGMENT SHADER
fs := gl.CreateShader(gl.FRAGMENT_SHADER)
fs_source := gl.GLString(fragmentShaderSource)
gl.ShaderSource(fs, 1, &fs_source, nil)
gl.CompileShader(fs)
var fstatus gl.Int
gl.GetShaderiv(fs, gl.COMPILE_STATUS, &fstatus)
fmt.Printf("Compiled Fragment Shader: %v\n", fstatus)
// CREATE PROGRAM
program := gl.CreateProgram()
gl.AttachShader(program, vs)
gl.AttachShader(program, fs)
fragoutstring := gl.GLString("outColor")
defer gl.GLStringFree(fragoutstring)
gl.BindFragDataLocation(program, gl.Uint(0), fragoutstring)
gl.LinkProgram(program)
var linkstatus gl.Int
gl.GetProgramiv(program, gl.LINK_STATUS, &linkstatus)
fmt.Printf("Program Link: %v\n", linkstatus)
return program
}
func createShader(name string, shaderType int) (gl.Uint, error) {
data, err := fileRead(name)
if err != nil {
return 0, err
}
if len(data) == 0 {
return 0, errors.New("No shader code.")
}
var shader gl.Uint
switch shaderType {
case VertexShaderType:
shader = gl.CreateShader(gl.VERTEX_SHADER)
case FragmentShaderType:
shader = gl.CreateShader(gl.FRAGMENT_SHADER)
default:
return 0, errors.New("Unknown ShaderType.")
}
src := gl.GLStringArray(string(data))
defer gl.GLStringArrayFree(src)
gl.ShaderSource(shader, gl.Sizei(1), &src[0], nil)
gl.CompileShader(shader)
// Similar to print_log in the C code example
var length gl.Int
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &length)
if length > 1 {
glString := gl.GLStringAlloc(gl.Sizei(length))
defer gl.GLStringFree(glString)
gl.GetShaderInfoLog(shader, gl.Sizei(length), nil, glString)
return 0, errors.New(fmt.Sprintf("Shader log: %s", gl.GoString(glString)))
}
return shader, nil
}
func initResources() {
var compileOk gl.Int
// Vertex Shader
vs = gl.CreateShader(gl.VERTEX_SHADER)
vsSrc := gl.GLStringArray(vsSource)
defer gl.GLStringArrayFree(vsSrc)
gl.ShaderSource(vs, gl.Sizei(len(vsSrc)), &vsSrc[0], nil)
gl.CompileShader(vs)
gl.GetShaderiv(vs, gl.COMPILE_STATUS, &compileOk)
if compileOk == 0 {
errNum := gl.GetError()
fmt.Printf("Error in vertex shader: %d\n", errNum)
}
// Fragment Shader
fs = gl.CreateShader(gl.FRAGMENT_SHADER)
fsSrc := gl.GLStringArray(fsSource)
defer gl.GLStringArrayFree(fsSrc)
gl.ShaderSource(fs, gl.Sizei(1), &fsSrc[0], nil)
gl.CompileShader(fs)
gl.GetShaderiv(fs, gl.COMPILE_STATUS, &compileOk)
if compileOk == 0 {
errNum := gl.GetError()
fmt.Printf("Error in fragment shader: %d\n", errNum)
}
// GLSL program
program = gl.CreateProgram()
gl.AttachShader(program, vs)
gl.AttachShader(program, fs)
gl.LinkProgram(program)
gl.GetProgramiv(program, gl.LINK_STATUS, &compileOk)
if compileOk == 0 {
fmt.Printf("Error in program.\n")
}
// Get the attribute location from the GLSL program (here from the vertex shader)
attributeName := gl.GLString("coord2d")
defer gl.GLStringFree(attributeName)
attributeTemp := gl.GetAttribLocation(program, attributeName)
if attributeTemp == -1 {
fmt.Printf("Could not bind attribute %s\n", gl.GoString(attributeName))
}
attributeCoord2d = gl.Uint(attributeTemp)
}
func (s *Shader) getError() error {
var logLength gl.Int
gl.GetShaderiv(s.id, gl.INFO_LOG_LENGTH, &logLength)
log := gl.GLStringAlloc(gl.Sizei(logLength))
defer gl.GLStringFree(log)
gl.GetShaderInfoLog(s.id, gl.Sizei(logLength), nil, log)
err := gl.GoString(log)
return errors.New(err)
}
func (s *Shader) Compile() error {
compileOk := gl.Int(gl.FALSE)
gl.CompileShader(s.id)
gl.GetShaderiv(s.id, gl.COMPILE_STATUS, &compileOk)
if compileOk == gl.FALSE {
return s.getError()
}
return nil
}
func (shader *Shader) Get(param gl33.Enum) int {
var ret gl33.Int
gl33.GetShaderiv(shader.Id, param, &ret)
return int(ret)
}