Removed shader, added 3D rendering (no demo yet, coming next), started bitmap font rendering, a few fixes and improvements.

text.go

@@ -0,0 +1,402 @@
+package goga
+
+/*
+import (
+	"core"
+	"dp"
+	"encoding/json"
+	"geo"
+	"github.com/go-gl/gl/v4.5-core/gl"
+	"io/ioutil"
+	"util"
+)
+
+const (
+	char_padding = 2
+)
+
+// Returns a new renderable text object.
+func NewText(font *Font, text string) *Text {
+	t := &Text{id: core.NextId()}
+	t.text = text
+	t.index = dp.NewVBO(gl.ELEMENT_ARRAY_BUFFER)
+	t.vertex = dp.NewVBO(gl.ARRAY_BUFFER)
+	t.texCoord = dp.NewVBO(gl.ARRAY_BUFFER)
+	t.vao = dp.NewVAO()
+	t.SetText(font, text)
+	t.Size = geo.Vec2{1, 1}
+	t.Scale = geo.Vec2{1, 1}
+	t.Visible = true
+
+	return t
+}
+
+type Character struct {
+	char           byte
+	min, max, size geo.Vec2
+	offset         float64
+}
+
+type Font struct {
+	Tex              *dp.Tex
+	tileSize         float64
+	CharPadding      geo.Vec2
+	Space, Tab, Line float64
+	chars            []Character
+}
+
+type jsonChar struct {
+	Char         string
+	X, Y, Offset float64
+}
+
+// Creates a new font from texture. Characters must be added afterwards.
+// The characters must be placed within a grid,
+// the second parameter describes the width and height of one tile in pixel.
+func NewFont(tex *dp.Tex, tileSize int) *Font {
+	font := &Font{}
+	font.Tex = tex
+	font.tileSize = float64(tileSize)
+	font.CharPadding = geo.Vec2{0.05, 0.05}
+	font.Space = 0.3
+	font.Tab = 1.2
+	font.Line = 1
+	font.chars = make([]Character, 0)
+
+	return font
+}
+
+// Loads characters from JSON file.
+// Format:
+//
+// [
+//     {
+//         "char": "a",
+//         "x": 0,
+//         "y": 0,
+//		   "offset": 0
+//     },
+//     ...
+// ]
+//
+// Where x and y start in the upper left corner of the texture, both of type int.
+// Offset is optional and can be used to move a character up or down (relative to others).
+// If cut is set to true, the characters will be true typed.
+func (f *Font) LoadFromJson(path string, cut bool) error {
+	// load file content
+	content, err := ioutil.ReadFile(path)
+
+	if err != nil {
+		return err
+	}
+
+	// read json
+	chars := make([]jsonChar, 0)
+
+	if err = json.Unmarshal(content, &chars); err != nil {
+		return err
+	}
+
+	f.extractChars(chars, cut)
+
+	return nil
+}
+
+func (f *Font) extractChars(chars []jsonChar, cut bool) {
+	for _, char := range chars {
+		if len(char.Char) != 1 {
+			continue
+		}
+
+		var min, max, size geo.Vec2
+
+		if !cut {
+			min = geo.Vec2{char.X * f.tileSize, char.Y * f.tileSize}
+			max = geo.Vec2{min.X + f.tileSize, min.Y + f.tileSize}
+			size = geo.Vec2{1, 1}
+		} else {
+			min, max, size = f.cutChar(int(char.X), int(char.Y))
+		}
+
+		f.chars = append(f.chars, Character{char.Char[0], min, max, size, char.Offset})
+	}
+}
+
+func (f *Font) cutChar(x, y int) (geo.Vec2, geo.Vec2, geo.Vec2) {
+	minX := int(f.Tex.GetSize().X)
+	minY := int(f.Tex.GetSize().Y)
+	maxX := 0
+	maxY := 0
+	rgba := f.Tex.GetRGBA()
+
+	for ry := y * int(f.tileSize); ry < (y+1)*int(f.tileSize); ry++ {
+		for rx := x * int(f.tileSize); rx < (x+1)*int(f.tileSize); rx++ {
+			_, _, _, a := rgba.At(rx, ry).RGBA()
+
+			if a == 0 {
+				continue
+			}
+
+			if rx < minX {
+				minX = rx
+			} else if rx > maxX {
+				maxX = rx
+			}
+
+			if ry < minY {
+				minY = ry
+			} else if ry > maxY {
+				maxY = ry
+			}
+		}
+	}
+
+	minX -= char_padding
+	maxX += char_padding
+	minY -= char_padding
+	maxY += char_padding
+
+	texSize := f.Tex.GetSize()
+	min := geo.Vec2{float64(minX) / texSize.X, float64(maxY) / texSize.Y}
+	max := geo.Vec2{float64(maxX) / texSize.X, float64(minY) / texSize.Y}
+
+	// size
+	size := geo.Vec2{float64(maxX-minX) / f.tileSize, float64(maxY-minY) / f.tileSize}
+
+	return min, max, size
+}
+
+func (f *Font) getChar(char byte) *Character {
+	for _, character := range f.chars {
+		if character.char == char {
+			return &character
+		}
+	}
+
+	return nil
+}
+
+type Text struct {
+	*Actor
+	*Pos2D
+
+	id     int
+	text   string
+	bounds geo.Vec2
+
+	index, vertex, texCoord *dp.VBO
+	vao                     *dp.VAO
+}
+
+// Deletes GL buffers bound to this text.
+func (t *Text) Drop() {
+	t.index.Drop()
+	t.vertex.Drop()
+	t.texCoord.Drop()
+	t.vao.Drop()
+}
+
+// Sets the given string as text and (re)creates buffers.
+func (t *Text) SetText(font *Font, text string) {
+	t.text = text
+
+	indices := make([]uint32, len(text)*6)
+	vertices := make([]float32, len(text)*8)
+	texCoords := make([]float32, len(text)*8)
+	chars := 0
+
+	// create indices
+	var index uint32 = 0
+
+	for i := 0; i < len(text)*6; i += 6 {
+		indices[i] = index
+		indices[i+1] = index + 1
+		indices[i+2] = index + 2
+		indices[i+3] = index + 1
+		indices[i+4] = index + 2
+		indices[i+5] = index + 3
+
+		index += 4
+	}
+
+	// create vertices/texCoords
+	index = 0
+	offset := geo.Vec2{}
+	var width, height float64
+
+	for i := 0; i < len(text)*8 && int(index) < len(text); i += 8 {
+		c := font.getChar(text[index])
+		index++
+
+		// whitespace and new line
+		if text[index-1] == ' ' {
+			offset.X += font.Space
+			i -= 8
+			continue
+		}
+
+		if text[index-1] == '\n' {
+			offset.X = 0
+			offset.Y -= font.Line
+			i -= 8
+			continue
+		}
+
+		if text[index-1] == '\t' {
+			offset.X += font.Tab
+			i -= 8
+			continue
+		}
+
+		// character not found
+		if c == nil {
+			i -= 8
+			continue
+		}
+
+		// usual character
+		vertices[i] = float32(offset.X)
+		vertices[i+1] = float32(offset.Y + c.offset)
+		vertices[i+2] = float32(offset.X + c.size.X)
+		vertices[i+3] = float32(offset.Y + c.offset)
+		vertices[i+4] = float32(offset.X)
+		vertices[i+5] = float32(offset.Y + c.size.Y + c.offset)
+		vertices[i+6] = float32(offset.X + c.size.X)
+		vertices[i+7] = float32(offset.Y + c.size.Y + c.offset)
+
+		texCoords[i] = float32(c.min.X)
+		texCoords[i+1] = float32(c.min.Y)
+		texCoords[i+2] = float32(c.max.X)
+		texCoords[i+3] = float32(c.min.Y)
+		texCoords[i+4] = float32(c.min.X)
+		texCoords[i+5] = float32(c.max.Y)
+		texCoords[i+6] = float32(c.max.X)
+		texCoords[i+7] = float32(c.max.Y)
+
+		offset.X += c.size.X + font.CharPadding.X
+		chars++
+
+		if offset.X > width {
+			width = offset.X
+		}
+
+		if offset.Y*-1+font.Line > height {
+			height = offset.Y*-1 + font.Line
+		}
+	}
+
+	t.bounds = geo.Vec2{width, height}
+
+	// fill GL buffer
+	t.index.Fill(gl.Ptr(indices[:chars*6]), 4, chars*6, gl.STATIC_DRAW)
+	t.vertex.Fill(gl.Ptr(vertices[:chars*8]), 4, chars*8, gl.STATIC_DRAW)
+	t.texCoord.Fill(gl.Ptr(texCoords[:chars*8]), 4, chars*8, gl.STATIC_DRAW)
+
+	util.CheckGLError()
+}
+
+func (t *Text) GetId() int {
+	return t.id
+}
+
+// Returns the text as string.
+func (t *Text) GetText() string {
+	return t.text
+}
+
+// Returns bounds of text, which is the size of characters.
+func (t *Text) GetBounds() geo.Vec2 {
+	return geo.Vec2{t.bounds.X * t.Size.X * t.Scale.X, t.bounds.Y * t.Size.Y * t.Scale.Y}
+}
+
+type TextRenderer struct {
+	Pos2D
+
+	Shader *dp.Shader
+	Camera *Camera
+	Font   *Font
+	Color  geo.Vec4
+	texts  []*Text
+}
+
+// Creates a new text renderer using given shader, camera and font.
+// If shader and/or camera are nil, the default one will be used.
+func NewTextRenderer(shader *dp.Shader, camera *Camera, font *Font) *TextRenderer {
+	renderer := &TextRenderer{}
+	renderer.Shader = shader
+	renderer.Camera = camera
+	renderer.Font = font
+	renderer.Color = geo.Vec4{1, 1, 1, 1}
+	renderer.texts = make([]*Text, 0)
+	renderer.Size = geo.Vec2{1, 1}
+	renderer.Scale = geo.Vec2{1, 1}
+
+	return renderer
+}
+
+// Prepares a text for rendering.
+func (r *TextRenderer) Prepare(text *Text) {
+	text.vao = dp.NewVAO()
+	text.vao.Bind()
+	r.Shader.EnableVertexAttribArrays()
+	text.index.Bind()
+	text.vertex.Bind()
+	text.vertex.AttribPointer(r.Shader.GetAttribLocation(TEXTRENDERER_VERTEX_ATTRIB), 2, gl.FLOAT, false, 0)
+	text.texCoord.Bind()
+	text.texCoord.AttribPointer(r.Shader.GetAttribLocation(TEXTRENDERER_TEXCOORD_ATTRIB), 2, gl.FLOAT, false, 0)
+	text.vao.Unbind()
+}
+
+// Adds text to the renderer.
+func (r *TextRenderer) Add(text *Text) {
+	r.texts = append(r.texts, text)
+}
+
+// Returns text by ID.
+func (r *TextRenderer) Get(id int) *Text {
+	for _, text := range r.texts {
+		if text.GetId() == id {
+			return text
+		}
+	}
+
+	return nil
+}
+
+// Removes text from renderer by ID.
+func (r *TextRenderer) Remove(id int) *Text {
+	for i, text := range r.texts {
+		if text.GetId() == id {
+			r.texts = append(r.texts[:i], r.texts[i+1:]...)
+			return text
+		}
+	}
+
+	return nil
+}
+
+// Removes all sprites.
+func (r *TextRenderer) Clear() {
+	r.texts = make([]*Text, 0)
+}
+
+// Renders sprites.
+func (r *TextRenderer) Render() {
+	r.Shader.Bind()
+	r.Shader.SendMat3(TEXTRENDERER_ORTHO, *geo.MultMat3(r.Camera.CalcOrtho(), r.CalcModel()))
+	r.Shader.SendUniform1i(TEXTRENDERER_TEX, 0)
+	r.Shader.SendUniform4f(TEXTRENDERER_COLOR, float32(r.Color.X), float32(r.Color.Y), float32(r.Color.Z), float32(r.Color.W))
+	r.Font.Tex.Bind()
+
+	for i := range r.texts {
+		if !r.texts[i].Visible {
+			continue
+		}
+
+		r.texts[i].vao.Bind()
+		r.Shader.SendMat3(TEXTRENDERER_MODEL, *r.texts[i].CalcModel())
+
+		gl.DrawElements(gl.TRIANGLES, r.texts[i].index.Size(), gl.UNSIGNED_INT, nil)
+	}
+}
+*/