func (c *Context) NewShader(shaderType ShaderType, source string) (Shader, error) {
var shader Shader
if err := c.runOnContextThread(func() error {
s := gl.CreateShader(uint32(shaderType))
if s == 0 {
return fmt.Errorf("opengl: glCreateShader failed: shader type: %d", shaderType)
}
cSources, free := gl.Strs(source + "\x00")
gl.ShaderSource(uint32(s), 1, cSources, nil)
free()
gl.CompileShader(s)
var v int32
gl.GetShaderiv(s, gl.COMPILE_STATUS, &v)
if v == gl.FALSE {
log := []uint8{}
gl.GetShaderiv(uint32(s), gl.INFO_LOG_LENGTH, &v)
if v != 0 {
log = make([]uint8, int(v))
gl.GetShaderInfoLog(uint32(s), v, nil, (*uint8)(gl.Ptr(log)))
}
return fmt.Errorf("opengl: shader compile failed: %s", log)
}
shader = Shader(s)
return nil
}); err != nil {
return 0, err
}
return shader, nil
}
func initResources() (uint32, int32) {
vSrc0 := fixupSrc(vShaderSrc)
vSrc := gl.Str(vSrc0)
vs := gl.CreateShader(gl.VERTEX_SHADER)
gl.ShaderSource(vs, 1, &vSrc, nil)
gl.CompileShader(vs)
var vok int32
gl.GetShaderiv(vs, gl.COMPILE_STATUS, &vok)
if vok == 0 {
log.Fatal("error in vertex shader")
}
fSrc := gl.Str(fShaderSrc)
fs := gl.CreateShader(gl.FRAGMENT_SHADER)
gl.ShaderSource(fs, 1, &fSrc, nil)
gl.CompileShader(fs)
var fok int32
gl.GetShaderiv(vs, gl.COMPILE_STATUS, &fok)
if fok == 0 {
log.Fatal("error in fragment shader")
}
var linkOk int32
program := gl.CreateProgram()
gl.AttachShader(program, vs)
gl.AttachShader(program, fs)
gl.LinkProgram(program)
gl.GetProgramiv(program, gl.LINK_STATUS, &linkOk)
if linkOk == 0 {
log.Fatal("gl.LinkProgram")
}
attribName := fixupSrc("coord2d")
attribCoord2d := gl.GetAttribLocation(program, gl.Str(attribName))
if attribCoord2d == -1 {
log.Fatal("failed to bind attribute")
}
return program, attribCoord2d
}
func (*backend) CreateShader(src []byte, typ gg.Enum) (*gg.Shader, error) {
csrc := gl.Str(string(append([]byte(src), 0)))
shader := gl.CreateShader(uint32(typ))
gl.ShaderSource(shader, 1, &csrc, nil)
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.TRUE {
return &gg.Shader{Value: shader}, nil
}
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return nil, fmt.Errorf("compile shader: %s%s", src, log)
}
func (s *Shader) addProgram(text string, typ uint32) error {
shader := gl.CreateShader(typ)
if shader == 0 {
return errors.New("could not find valid memory location when adding shader")
}
cStr := gl.Str(text + "\000")
gl.ShaderSource(shader, 1, &cStr, nil)
gl.CompileShader(shader)
var result int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &result)
if result == 0 {
return s.getShaderInfoLog(shader, "get shader error")
}
gl.AttachShader(s.program, shader)
return nil
}
func loadShader(shaderType uint32, source string) uint32 {
shader := gl.CreateShader(shaderType)
if err := gl.GetError(); err != gl.NO_ERROR {
panic(fmt.Errorf("gl error: %v", err))
}
csource := gl.Str(source)
gl.ShaderSource(shader, 1, &csource, nil)
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status != gl.TRUE {
//log := shader.GetInfoLog()
panic(fmt.Errorf("Failed to compile shader: shader: %v", source))
}
return shader
}
// CreateShader creates a shader object from a source file.
func CreateShader(filename string, xtype uint32) uint32 {
data, err := ioutil.ReadFile(filename)
if err != nil {
log.Fatal(err)
}
dataString := "#version 120\n" + string(data) + "\x00"
dataSrc := gl.Str(dataString)
res := gl.CreateShader(xtype)
gl.ShaderSource(res, 1, &dataSrc, nil)
gl.CompileShader(res)
var compileOk int32
gl.GetShaderiv(res, gl.COMPILE_STATUS, &compileOk)
if compileOk == gl.FALSE {
PrintLog(res)
gl.DeleteShader(res)
}
return res
}
func (c *Context) NewShader(shaderType ShaderType, source string) (Shader, error) {
s := gl.CreateShader(uint32(shaderType))
if s == 0 {
return 0, errors.New("glCreateShader failed")
}
glSource := gl.Str(source + "\x00")
gl.ShaderSource(uint32(s), 1, &glSource, nil)
gl.CompileShader(s)
var v int32
gl.GetShaderiv(s, gl.COMPILE_STATUS, &v)
if v == gl.FALSE {
log := []uint8{}
gl.GetShaderiv(uint32(s), gl.INFO_LOG_LENGTH, &v)
if v != 0 {
log = make([]uint8, int(v))
gl.GetShaderInfoLog(uint32(s), v, nil, (*uint8)(gl.Ptr(log)))
}
return 0, errors.New(fmt.Sprintf("shader compile failed: %s", string(log)))
}
return Shader(s), nil
}
func newShader(source string, shaderType uint32) (uint32, error) {
id := gl.CreateShader(shaderType)
if id == 0 {
return 0, fmt.Errorf("Unable to allocate shader")
}
ptr, free := convc.StringToC(source)
defer free()
gl.ShaderSource(id, 1, &ptr, nil)
gl.CompileShader(id)
var result int32
gl.GetShaderiv(id, gl.COMPILE_STATUS, &result)
if result == int32(gl.FALSE) {
var loglength int32
gl.GetShaderiv(id, gl.INFO_LOG_LENGTH, &loglength)
log := make([]byte, loglength)
var length int32
gl.GetShaderInfoLog(id, loglength, &length, &log[0])
gl.DeleteShader(id)
return 0, fmt.Errorf("Unable to compile shader: %s", log[:length])
}
return id, nil
}
// CompileShader compiles the source code of s.
//
// http://www.khronos.org/opengles/sdk/docs/man3/html/glCompileShader.xhtml
func CompileShader(s Shader) {
gl.CompileShader(s.Value)
}
func (c *Context) CompileShader(shader *Shader) {
gl.CompileShader(shader.uint32)
}