tofu

object.go (7803B)

---

 package tofu
 
 import (
 	"bufio"
 	"errors"
 	"fmt"
 	"log"
 	"math"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 
 	"github.com/go-gl/gl/v3.3-core/gl"
 )
 
 type ErrUnsupported string
 
 func (e ErrUnsupported) Error() string {
 	return string(e) + " unsupported, ignoring"
 }
 
 var NoIndex = math.MinInt
 
 type VertexIndex struct {
 	V, N, T int
 }
 
 type Face [3]VertexIndex
 
 type Object struct {
 	Vertices  []Vec3
 	TexCoords []Vec2
 	Normals   []Vec3
 	Tangents  []Vec3
 	Faces     []Face
 	Materials map[string]*Material
 	vao       *VAO
 }
 
 func DecodeObject(filename string) (*Object, error) {
 	f, err := os.Open(filename)
 	if err != nil {
 		return nil, fmt.Errorf("open file %s: %v", filename, err)
 	}
 	defer f.Close()
 	obj := new(Object)
 	s := bufio.NewScanner(f)
 	nl := 1
 	for s.Scan() {
 		if err := decodeObjectLine(obj, s.Text(), filename); err != nil {
 			var perr ErrUnsupported
 			if errors.As(err, &perr) {
 				//log.Printf("%s:%d %v", filename, nl, perr)
 			} else {
 				return nil, fmt.Errorf("%s:%d %s", filename, nl, err)
 			}
 		}
 		nl++
 	}
 	if err := s.Err(); err != nil {
 		return nil, err
 	}
 	return obj, nil
 }
 
 func decodeObjectLine(obj *Object, line string, filename string) error {
 	if len(line) == 0 || line[0] == '#' {
 		return nil
 	}
 	sf := strings.Fields(line)
 	if len(sf) == 0 {
 		return nil
 	}
 	switch t := sf[0]; t {
 	case "v":
 		if err := obj.addVertex(sf[1:]); err != nil {
 			return fmt.Errorf("addVertex: %v", err)
 		}
 	case "vt":
 		if err := obj.addTexCoord(sf[1:]); err != nil {
 			return fmt.Errorf("addTexCoords: %v", err)
 		}
 	case "vn":
 		if err := obj.addNormal(sf[1:]); err != nil {
 			return fmt.Errorf("addNormal: %v", err)
 		}
 	case "f":
 		if err := obj.addFace(sf[1:]); err != nil {
 			return fmt.Errorf("addFace: %v", err)
 		}
 	case "mtllib":
 		if len(sf) < 2 {
 			return fmt.Errorf("no mtllib file specified")
 		}
 		m, err := decodeMaterial(filepath.Join(filepath.Dir(filename), sf[1]))
 		if err != nil {
 			return fmt.Errorf("decode mtl file: %v", err)
 		}
 		if obj.Materials == nil {
 			obj.Materials = make(map[string]*Material)
 		}
 		obj.Materials[m.Name] = m
 		log.Printf("mtl: %+v", m)
 	default:
 		return ErrUnsupported(t)
 	}
 	return nil
 }
 
 func (obj *Object) addVertex(s []string) error {
 	if len(s) != 3 {
 		return fmt.Errorf("want 3 coordinates, got %d", len(s))
 	}
 	var v Vec3
 	for i := 0; i < 3; i++ {
 		f, err := strconv.ParseFloat(s[i], 32)
 		if err != nil {
 			return err
 		}
 		v[i] = float32(f)
 	}
 	obj.Vertices = append(obj.Vertices, v)
 	return nil
 }
 
 func (obj *Object) addTexCoord(s []string) error {
 	if len(s) != 2 {
 		log.Println("only 2D texture is supported, ignoring the third element")
 	}
 	var t Vec2
 	for i := 0; i < 2; i++ {
 		f, err := strconv.ParseFloat(s[i], 32)
 		if err != nil {
 			return err
 		}
 		t[i] = float32(f)
 	}
 	obj.TexCoords = append(obj.TexCoords, t)
 	return nil
 }
 
 func (obj *Object) addNormal(s []string) error {
 	if len(s) != 3 {
 		return fmt.Errorf("want 3 coordinates, got %d", len(s))
 	}
 	var n Vec3
 	for i := 0; i < 3; i++ {
 		f, err := strconv.ParseFloat(s[i], 32)
 		if err != nil {
 			return err
 		}
 		n[i] = float32(f)
 	}
 	obj.Normals = append(obj.Normals, n)
 	return nil
 }
 
 func (obj *Object) addFace(s []string) error {
 	if len(s) != 3 {
 		return fmt.Errorf("want 3 pairs of indices, got %d", len(s))
 	}
 	var f Face
 	for i := 0; i < 3; i++ {
 		tuple := strings.Split(s[i], "/")
 		if len(tuple) == 0 || len(tuple) > 3 {
 			return fmt.Errorf("invalid face: %q", s[i])
 		}
 		v, err := strconv.Atoi(tuple[0])
 		if err != nil {
 			return fmt.Errorf("invalid index: %s", tuple[0])
 		}
 		f[i].V = v - 1
 		if len(tuple) > 1 && tuple[1] != "" {
 			t, err := strconv.Atoi(tuple[1])
 			if err != nil {
 				return fmt.Errorf("invalid index: %s", tuple[1])
 			}
 			f[i].T = t - 1
 		} else {
 			f[i].T = NoIndex
 		}
 		if len(tuple) == 3 {
 			n, err := strconv.Atoi(tuple[2])
 			if err != nil {
 				return fmt.Errorf("invalid index: %s", tuple[2])
 			}
 			f[i].N = n - 1
 		} else {
 			f[i].N = NoIndex
 		}
 	}
 	obj.Faces = append(obj.Faces, f)
 	return nil
 }
 
 func (obj *Object) hasNormals() bool {
 	return obj.Faces[0][0].N != NoIndex
 }
 
 func (obj *Object) hasTexCoords() bool {
 	return obj.Faces[0][0].T != NoIndex
 }
 
 func (obj *Object) hasTangents() bool {
 	return obj.Tangents != nil
 }
 
 const stride = 3 + 2 + 3 + 3
 
 func (obj *Object) data() []float32 {
 	data := make([]float32, stride*3*len(obj.Faces))
 	for i, f := range obj.Faces {
 		for j := 0; j < 3; j++ {
 			data[stride*(3*i+j)] = obj.Vertices[f[j].V][0]
 			data[stride*(3*i+j)+1] = obj.Vertices[f[j].V][1]
 			data[stride*(3*i+j)+2] = obj.Vertices[f[j].V][2]
 			if obj.hasTexCoords() {
 				data[stride*(3*i+j)+3] = obj.TexCoords[f[j].T][0]
 				data[stride*(3*i+j)+4] = obj.TexCoords[f[j].T][1]
 			}
 			if obj.hasNormals() {
 				data[stride*(3*i+j)+5] = obj.Normals[f[j].N][0]
 				data[stride*(3*i+j)+6] = obj.Normals[f[j].N][1]
 				data[stride*(3*i+j)+7] = obj.Normals[f[j].N][2]
 			}
 			if obj.hasTangents() {
 				data[stride*(3*i+j)+8] = obj.Tangents[f[j].N][0]
 				data[stride*(3*i+j)+9] = obj.Tangents[f[j].N][1]
 				data[stride*(3*i+j)+10] = obj.Tangents[f[j].N][2]
 			}
 		}
 	}
 	return data
 }
 
 func (obj *Object) faceData() []uint32 {
 	fdata := make([]uint32, 3*len(obj.Faces))
 	for i := 0; i < 3*len(obj.Faces); i++ {
 		fdata[i] = uint32(i)
 	}
 	return fdata
 }
 
 func (obj *Object) SetNormals() {
 	obj.Normals = make([]Vec3, len(obj.Faces))
 	for i, f := range obj.Faces {
 		v := obj.Vertices[f[0].V].Sub(obj.Vertices[f[1].V])
 		w := obj.Vertices[f[0].V].Sub(obj.Vertices[f[2].V])
 		n := v.Cross(w).Normalize()
 		obj.Normals[i] = n
 		obj.Faces[i][0].N = i
 		obj.Faces[i][1].N = i
 		obj.Faces[i][2].N = i
 	}
 }
 
 func (obj *Object) SetTangents() {
 	if !obj.hasNormals() {
 		panic(fmt.Errorf("object does not have normals"))
 	}
 	if !obj.hasTexCoords() {
 		panic(fmt.Errorf("object does not have texCoords"))
 	}
 	obj.Tangents = make([]Vec3, len(obj.Normals))
 	for i, f := range obj.Normals {
 // WIP
 	}
 }
 
 // Load copies object data into the GPU.
 func (obj *Object) Load() {
 	obj.vao = newVAO(obj)
 }
 
 func (obj *Object) Draw(prog *Program) {
 	// TODO: performance?
 	obj.vao.bind()
 	for _, m := range obj.Materials {
 		prog.SetBool("Teapot.useTexture", true)
 		prog.SetTexture("Teapot.map_Kd", m.map_Kd)
 		prog.SetTexture("Teapot.map_Bump", m.map_Bump)
 		prog.SetTexture("Teapot.map_Ks", m.map_Ks)
 	}
 	gl.DrawElements(gl.TRIANGLES,
 		int32(stride*3*len(obj.Faces)),
 		gl.UNSIGNED_INT, nil)
 }
 
 type VAO struct {
 	id  uint32
 	vbo *Buffer
 	ebo *Buffer
 }
 
 const (
 	UniformVertex    = 0
 	UniformColor     = 1
 	UniformTexCoords = 2
 	UniformNormal    = 3
 	UniformTangent   = 4
 )
 
 func newVAO(obj *Object) *VAO {
 	var id uint32
 	gl.GenVertexArrays(1, &id)
 	vao := &VAO{id: id, vbo: newBuffer(), ebo: newBuffer()}
 	vao.bind()
 	data := obj.data()
 	vao.setData(data)
 	vao.setAttribute(UniformVertex, 3, stride, 0)
 	vao.setAttribute(UniformTexCoords, 2, stride, 3)
 	vao.setAttribute(UniformNormal, 3, stride, 5)
 	vao.setAttribute(UniformTangent, 3, stride, 8)
 	fdata := obj.faceData()
 	vao.setFaces(fdata)
 	return vao
 }
 
 func (vao *VAO) bind() {
 	gl.BindVertexArray(vao.id)
 }
 
 func (vao *VAO) setAttribute(uniformNum uint32, size int, stride int, offset int) {
 	gl.VertexAttribPointerWithOffset(uniformNum, int32(size), gl.FLOAT,
 		false, int32(stride)*4, uintptr(offset)*4)
 	gl.EnableVertexAttribArray(uniformNum)
 }
 
 func (vao *VAO) setData(data []float32) {
 	gl.BindBuffer(gl.ARRAY_BUFFER, vao.vbo.id)
 	gl.BufferData(gl.ARRAY_BUFFER, len(data)*4,
 		gl.Ptr(data), gl.STATIC_DRAW)
 }
 
 func (vao *VAO) setFaces(data []uint32) {
 	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, vao.ebo.id)
 	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(data)*4,
 		gl.Ptr(data), gl.STATIC_DRAW)
 }
 
 type Buffer struct {
 	id uint32
 }
 
 func newBuffer() *Buffer {
 	var id uint32
 	gl.GenBuffers(1, &id)
 	return &Buffer{id: id}
 }