tofu

shader.go (5986B)

---

 package tofu
 
 import (
 	"fmt"
 	"os"
 	"reflect"
 	"strings"
 
 	"github.com/go-gl/gl/v3.3-core/gl"
 )
 
 // CompileShader compiles a shader of type xtype using the source file specified by path.
 // It returns the resulting shader ID.
 func compileShader(path string, xtype uint32) (shaderID uint32, err error) {
 	src, err := os.ReadFile(path)
 	if err != nil {
 		return 0, fmt.Errorf("readfile %s: %v", path, err)
 	}
 	shaderID = gl.CreateShader(xtype)
 	if shaderID == 0 {
 		return 0, fmt.Errorf("can't create shader")
 	}
 	cstrs, free := gl.Strs(string(src) + "\x00")
 	defer free()
 	gl.ShaderSource(shaderID, 1, cstrs, nil)
 	gl.CompileShader(shaderID)
 
 	var success int32
 	gl.GetShaderiv(shaderID, gl.COMPILE_STATUS, &success)
 	if success == gl.FALSE {
 		var logLength int32
 		gl.GetShaderiv(shaderID, gl.INFO_LOG_LENGTH, &logLength)
 		l := gl.Str(strings.Repeat("\x00", int(logLength)))
 		gl.GetShaderInfoLog(shaderID, logLength, nil, l)
 		gl.DeleteShader(shaderID)
 		errmsg := gl.GoStr(l)
 		if strings.HasPrefix(errmsg, "0:") {
 			errmsg = errmsg[2:]
 		}
 		return 0, fmt.Errorf("%v", errmsg)
 	}
 	return shaderID, nil
 }
 
 // LinkShaders links vertex shader vsID and fragment shader fsID and returns the
 // resulting shader program.
 func linkShaders(vsID, fsID uint32) (shaderID uint32, err error) {
 	shaderID = gl.CreateProgram()
 	gl.AttachShader(shaderID, vsID)
 	gl.AttachShader(shaderID, fsID)
 	gl.LinkProgram(shaderID)
 
 	var success int32
 	gl.GetProgramiv(shaderID, gl.LINK_STATUS, &success)
 	if success == gl.FALSE {
 		var logLength int32
 		gl.GetProgramiv(shaderID, gl.INFO_LOG_LENGTH, &logLength)
 		l := gl.Str(strings.Repeat("\x00", int(logLength)))
 		gl.GetProgramInfoLog(shaderID, logLength, nil, l)
 		return 0, fmt.Errorf("%v", gl.GoStr(l))
 	}
 	return shaderID, nil
 }
 
 type Program struct {
 	id              uint32
 	Uniforms        any
 	nextTextureUnit uint32 // 0-indexed
 }
 
 // NewProgram creates a shader program from a vertex shader source file
 // specified by vpath and a fragment shader source file
 // specified by fpath, and returns the resulting Program object.
 func NewProgram(vpath, fpath string) (*Program, error) {
 	vid, err := compileShader(vpath, gl.VERTEX_SHADER)
 	if err != nil {
 		return nil, fmt.Errorf("compile %s:%v", vpath, err)
 	}
 	fid, err := compileShader(fpath, gl.FRAGMENT_SHADER)
 	if err != nil {
 		return nil, fmt.Errorf("compile %s:%v", fpath, err)
 	}
 	pid, err := linkShaders(vid, fid)
 	if err != nil {
 		return nil, fmt.Errorf("link shaders: %v", err)
 	}
 	gl.DeleteShader(vid)
 	gl.DeleteShader(fid)
 	return &Program{id: pid}, nil
 }
 
 // Use activates the shader.
 func (p *Program) Use() {
 	gl.UseProgram(p.id)
 }
 
 func (p *Program) SetUniforms() error {
 	p.nextTextureUnit = 0
 	return p.setUniforms(p.Uniforms, "")
 }
 
 func (p *Program) setUniforms(uniforms any, prefix string) error {
 	if uniforms == nil {
 		return nil
 	}
 	if reflect.TypeOf(uniforms).Kind() == reflect.Pointer {
 		uniforms = reflect.ValueOf(uniforms).Elem().Interface()
 	}
 	s := reflect.ValueOf(uniforms)
 	fields := reflect.VisibleFields(s.Type())
 	for i := 0; i < s.NumField(); i++ {
 		fv := s.Field(i)
 		ft := fields[i]
 		tag, ok := ft.Tag.Lookup("tofu")
 		if !ok {
 			tag = ft.Name
 		}
 		if prefix != "" {
 			tag = prefix + "." + tag
 		}
 		switch ft.Type.String() {
 		case "tofu.Mat4":
 			if err := p.SetMat4(tag, fv.Interface().(Mat4)); err != nil {
 				return fmt.Errorf("set %s: %v", tag, err)
 			}
 		case "tofu.Vec3":
 			if err := p.SetVec3(tag, fv.Interface().(Vec3)); err != nil {
 				return fmt.Errorf("set %s: %v", tag, err)
 			}
 		case "float32":
 			if err := p.SetFloat32(tag, fv.Interface().(float32)); err != nil {
 				return fmt.Errorf("set %s: %v", tag, err)
 			}
 		case "*tofu.Texture":
 			if err := p.SetTexture(tag, fv.Interface().(*Texture)); err != nil {
 				return fmt.Errorf("set %s: %v", tag, err)
 			}
 		default:
 			switch fv.Kind() {
 			case reflect.Struct:
 				if err := p.setUniforms(fv.Interface(), tag); err != nil {
 					return err
 				}
 			case reflect.Pointer:
 				if err := p.setUniforms(fv.Elem().Interface(), tag); err != nil {
 					return err
 				}
 			case reflect.Slice:
 				for i := 0; i < fv.Len(); i++ {
 					item := fv.Index(i).Interface()
 					tagi := fmt.Sprintf("%s[%d]", tag, i)
 					if err := p.setUniforms(item, tagi); err != nil {
 						return err
 					}
 				}
 			default:
 				return fmt.Errorf("unknown uniform type: %s", ft.Type)
 			}
 		}
 	}
 	return nil
 }
 
 // SetFloat32 set the value of the uniform name.
 func (p *Program) SetFloat32(name string, val float32) error {
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("uniform %s not found", name)
 	}
 	gl.Uniform1f(l, val)
 	return nil
 }
 
 func (p *Program) SetVec2(name string, val Vec2) error {
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("uniform %s not found", name)
 	}
 	gl.Uniform2fv(l, 1, &val[0])
 	return nil
 }
 
 func (p *Program) SetVec3(name string, val Vec3) error {
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("uniform %s not found", name)
 	}
 	gl.Uniform3fv(l, 1, &val[0])
 	return nil
 }
 
 func (p *Program) SetMat4(name string, val Mat4) error {
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("uniform %s not found", name)
 	}
 	gl.UniformMatrix4fv(l, 1, false, &val[0])
 	return nil
 }
 
 func (p *Program) SetTexture(name string, t *Texture) error {
 	p.Use()
 	gl.ActiveTexture(p.nextTextureUnit + gl.TEXTURE0)
 	gl.BindTexture(gl.TEXTURE_2D, t.id)
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("no such uniform: %s", name)
 	}
 	gl.Uniform1i(l, int32(p.nextTextureUnit))
 	p.nextTextureUnit++
 	return nil
 }
 
 func (p *Program) SetBool(name string, t bool) error {
 	l := gl.GetUniformLocation(p.id, gl.Str(name+"\x00"))
 	if l == -1 {
 		return fmt.Errorf("no such uniform: %s", name)
 	}
 	if t {
 		gl.Uniform1i(l, gl.TRUE)
 	} else {
 		gl.Uniform1i(l, gl.FALSE)
 	}
 	return nil
 }