texttttttt object

@@ -217,7 +217,7 @@ function _M:makeFrame(base, w, h, iw, ih)
 	return f
 end
 
-function _M:makeFrameDO(base, w, h, iw, ih)
+function _M:makeFrameDO(base, w, h, iw, ih, center)
 	local f = {}
 	f.container = core.renderer.container()
 	if base then
@@ -233,7 +233,8 @@ function _M:makeFrameDO(base, w, h, iw, ih)
 		if not w then w = iw + f.b4.w + f.b6.w end
 		if not h then h = ih + f.b8.h + f.b2.h end
 
-		local cx, cy = -math.floor(w / 2), -math.floor(h / 2)
+		local cx, cy = 0,0
+		if center then cx, cy = -math.floor(w / 2), -math.floor(h / 2) end
 
 		f.container:add(core.renderer.fromTextureTable(f.b5, cx + f.b4.w, cy + f.b8.h, w - f.b6.w - f.b4.w, h - f.b8.h - f.b2.h, true))
 
@@ -251,6 +252,7 @@ function _M:makeFrameDO(base, w, h, iw, ih)
 	end
 	f.w = math.floor(w)
 	f.h = math.floor(h)
+
 	return f
 end
 

@@ -530,11 +530,11 @@ end
 
 local renderer = core.renderer.renderer()
 local UIBase = require "engine.ui.Base"
-local f = UIBase:makeFrameDO("ui/dialogframe_", 400, 400)
+local f = UIBase:makeFrameDO("ui/dialogframe_", 400, 400, nil, nil, true)
 f.container:translate(400, 400)
-local f2 = UIBase:makeFrameDO("ui/button", 100, 40)
+local f2 = UIBase:makeFrameDO("ui/button", 100, 40, nil, nil, true)
 -- f2.container:translate(100, 150)
-local f3 = UIBase:makeFrameDO("ui/textbox", 25, 25)
+local f3 = UIBase:makeFrameDO("ui/textbox", 25, 25, nil, nil, true)
 -- f3.container:translate(20, 10)
 -- f3.container:rotate(0, 0, math.rad(45))
 -- f2.container:add(core.renderer.redPoint())
@@ -546,15 +546,21 @@ f.container:add(f2.container)
 f2.container:add(f3.container)
 renderer:add(f.container)
 
+local t = core.renderer.text(UIBase.font)
+t:text("Coco l'asticot!")
+t:translate(50, 50)
+t:rotate(0, 0, math.rad(45))
+f.container:add(t)
 
 function _M:display()
 	renderer:toScreen(0, 0, 1, 1, 1, 1)
 	-- f.container:scale(0.01, 0.01, 0, true)
-	f.container:rotate(0, 0, math.rad(1), true)
-	f2.container:rotate(0, 0, math.rad(1), true)
-	f3.container:rotate(0, 0, -math.rad(2), true)
+	-- f.container:rotate(0, 0, math.rad(1), true)
+	-- f2.container:rotate(0, 0, math.rad(1), true)
+	-- f3.container:rotate(0, 0, -math.rad(2), true)
 	-- f.container:translate(2, 1)
 	f3.container:scale(1, 2 + math.sin(core.game.getTime()/500), 1)
+	t:rotate(0, math.rad(1.5), 0, true)
 end
 
 --- Ask if we really want to close, if so, save the game first

@@ -24,6 +24,7 @@
 extern "C" {
 #include "tgl.h"
 #include "useshader.h"
+#include "font.h"
 }
 
 #include <vector>
@@ -58,7 +59,9 @@ protected:
 	bool changed = false;
 public:
 	DisplayObject() { model = mat4(); };
-	virtual ~DisplayObject() {};
+	virtual ~DisplayObject() {
+		if (lua_ref != LUA_NOREF && L) luaL_unref(L, LUA_REGISTRYINDEX, lua_ref);
+	};
 	void setLuaState(lua_State *L) { this->L = L; };
 	void setLuaRef(int ref) {lua_ref = ref; };
 	int unsetLuaRef() { int ref = lua_ref; lua_ref = LUA_NOREF; return ref; };
@@ -76,20 +79,19 @@ public:
 
 class DOVertexes : public DisplayObject{
 public:
-	// static long next_id = 1;
-	vector<long> ids;
 	vector<vertex> vertices;
 	int tex_lua_ref = LUA_NOREF;
 	GLuint tex;
 	shader_type *shader;
 
 	DOVertexes() {
-		ids.reserve(4);
 		vertices.reserve(4);
 		tex = 0;
 		shader = default_shader;
 	};
-	virtual ~DOVertexes() {};
+	virtual ~DOVertexes() {
+		if (tex_lua_ref != LUA_NOREF && L) luaL_unref(L, LUA_REGISTRYINDEX, tex_lua_ref);		
+	};
 
 	int addQuad(
 		float x1, float y1, float u1, float v1, 

@@ -25,6 +25,7 @@
 using namespace glm;
 
 #include "displayobjects/DisplayObject.hpp"
+#include "displayobjects/TextObject.hpp"
 
 class Renderer {
 private:

+/*
+	TE4 - T-Engine 4
+	Copyright (C) 2009 - 2015 Nicolas Casalini
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+	Nicolas Casalini "DarkGod"
+	darkgod@te4.org
+*/
+
+extern "C" {
+#include "lua.h"
+#include "lauxlib.h"
+#include "display.h"
+#include "types.h"
+#include "physfs.h"
+#include "physfsrwops.h"
+#include "main.h"
+}
+
+#include "displayobjects/TextObject.hpp"
+
+int DOText::addCharQuad(const char *str, size_t len, font_style style, int bx, int by, float r, float g, float b, float a) {
+	int x = 0, y = by;
+	ssize_t off = 1;
+	int32_t c;
+	float italic = 0;
+	if (style == FONT_STYLE_ITALIC) { style = FONT_STYLE_NORMAL; italic = 0.2; }
+	while (off > 0) {
+		off = utf8proc_iterate((const uint8_t*)str, len, &c);
+		str += off;
+		len -= off;
+
+		if (c > 0 && c < MAX_ATLAS_DATA) {
+			font_atlas_data_style *d = &font->atlas_data[c].data[style];
+			if (!d->w) font_add_atlas(font, c, style);
+			if (d->w) {
+				addQuad(
+					d->w * italic + bx + x,		y,		d->tx1, d->ty1,
+					d->w * italic + bx + x + d->w,	y,		d->tx2, d->ty1,
+					bx + x + d->w,			y + d->h,	d->tx2, d->ty2,
+					bx + x,				y + d->h,	d->tx1, d->ty2,
+					r, g, b, a
+				);
+				x += d->w;
+			}
+		}
+	}
+	return x;
+}
+
+int DOText::getTextChunkSize(const char *str, size_t len, font_style style) {
+	int x = 0, y = 0;
+	ssize_t off = 1;
+	int32_t c;
+	float italic = 0;
+	if (style == FONT_STYLE_ITALIC) { style = FONT_STYLE_NORMAL; italic = 0.2; }
+	while (off > 0) {
+		off = utf8proc_iterate((const uint8_t*)str, len, &c);
+		str += off;
+		len -= off;
+
+		if (c > 0 && c < MAX_ATLAS_DATA) {
+			font_atlas_data_style *d = &font->atlas_data[c].data[style];
+			if (!d->w) font_add_atlas(font, c, style);
+			if (d->w) {
+				x += d->w;
+			}
+		}
+	}
+	return x;
+}
+
+void DOText::parseText() {
+	font_type *f = font;
+	if (!f) return;
+	if (!f->atlas) font_make_atlas(f, 0, 0);
+	size_t len = strlen(text);
+	if (!len) return;
+	const char *str = text;
+	float r = 1, g = 1, b = 1, a = 1;
+	float lr = 1, lg = 1, lb = 1, la = 1;
+	int max_width = line_max_width;
+	int bx = 0, by = 0;
+	bool no_linefeed = lua_toboolean(L, 11);
+
+	setTexture(f->atlas_tex, LUA_NOREF);
+
+	// Update VO size once, we are allocating a few more than neede in case of utf8 or control sequences, but we dont care
+	vertices.reserve(len * 4);
+
+	int font_h = TTF_FontHeight(f->font);
+	int id_dduid = 1;
+	int nb_lines = 1;
+	int id_real_line = 1;
+	char *line_data = NULL;
+	int line_data_size = 0;
+	char *start = (char*)str, *stop = (char*)str, *next = (char*)str;
+	int max_size = 0;
+	int size = 0;
+	bool is_separator = false;
+	int i;
+	bool force_nl = false;
+	font_style style = FONT_STYLE_NORMAL;
+	while (true)
+	{
+		if ((*next == '\n') || (*next == ' ') || (*next == '\0') || (*next == '#'))
+		{
+			bool inced = false;
+			if (*next == ' ' && *(next+1))
+			{
+				inced = true;
+				stop = next;
+				next++;
+			}
+			else stop = next - 1;
+
+			// Make a surface for the word
+			int len = next - start;
+			int future_size = getTextChunkSize(start, len, style);
+
+			// If we must do a newline, flush the previous word and the start the new line
+			if (!no_linefeed && (force_nl || (future_size && max_width && (size + future_size > max_width))))
+			{
+				// Push it & reset the surface
+				id_dduid = 1;
+				is_separator = false;
+//				printf("Ending previous line at size %d\n", size);
+				if (size > max_size) max_size = size;
+				size = 0;
+				nb_lines++;
+				if (force_nl)
+				{
+					id_real_line++;
+					if (line_data) { line_data = NULL; }
+				}
+				force_nl = false;
+			}
+
+			if (len)
+			{
+				// Detect separators
+				if ((*start == '-') && (*(start+1) == '-') && (*(start+2) == '-') && !(*(start+3))) is_separator = true;
+
+//				printf("Drawing word '%s'\n", start);
+				size += addCharQuad(start, len, style, bx + size, by + (nb_lines-1) * font_h, r, g, b, a);
+			}
+			if (inced) next--;
+			start = next + 1;
+
+			// Force a linefeed
+			if (*next == '\n') force_nl = true;
+
+			// Handle special codes
+			else if (*next == '#')
+			{
+				char *codestop = next + 1;
+				while (*codestop && *codestop != '#') codestop++;
+				// Font style
+				if (*(next+1) == '{') {
+					if (*(next+2) == 'n') style = FONT_STYLE_NORMAL;
+					else if (*(next+2) == 'b') style = FONT_STYLE_BOLD;
+					else if (*(next+2) == 'i') style = FONT_STYLE_ITALIC;
+					else if (*(next+2) == 'u') style = FONT_STYLE_UNDERLINED;
+				}
+				// Entity UID
+				else if ((codestop - (next+1) > 4) && (*(next+1) == 'U') && (*(next+2) == 'I') && (*(next+3) == 'D') && (*(next+4) == ':')) {
+// 					lua_getglobal(L, "__get_uid_entity");
+// 					char *colon = next + 5;
+// 					while (*colon && *colon != ':') colon++;
+// 					lua_pushlstring(L, next+5, colon - (next+5));
+// 					lua_call(L, 1, 1);
+// 					if (lua_istable(L, -1))
+// 					{
+// //							printf("DirectDrawUID in font:draw %d : %d\n", size, h);
+// 						lua_createtable(L, 0, 4);
+
+// 						lua_pushliteral(L, "e");
+// 						lua_pushvalue(L, -3);
+// 						lua_rawset(L, -3);
+
+// 						lua_pushliteral(L, "x");
+// 						lua_pushnumber(L, size);
+// 						lua_rawset(L, -3);
+
+// 						lua_pushliteral(L, "w");
+// 						lua_pushnumber(L, h);
+// 						lua_rawset(L, -3);
+
+// 						lua_rawseti(L, -4, id_dduid++); // __dduids
+
+// 						size += h;
+// 					}
+// 					lua_pop(L, 1);
+				}
+				// Extra data
+				else if (*(next+1) == '&') {
+					line_data = next + 2;
+					line_data_size = codestop - (next+2);
+				}
+				// Color
+				else {
+					if ((codestop - (next+1) == 4) && (*(next+1) == 'L') && (*(next+2) == 'A') && (*(next+3) == 'S') && (*(next+4) == 'T'))
+					{
+						r = lr;
+						g = lg;
+						b = lb;
+						a = la;
+					}
+
+					lua_getglobal(L, "colors");
+					lua_pushlstring(L, next+1, codestop - (next+1));
+					lua_rawget(L, -2);
+					if (lua_istable(L, -1)) {
+						lr = r;
+						lg = g;
+						lb = b;
+						la = a;
+
+						lua_pushliteral(L, "r");
+						lua_rawget(L, -2);
+						r = lua_tonumber(L, -1) / 255;
+						lua_pushliteral(L, "g");
+						lua_rawget(L, -3);
+						g = lua_tonumber(L, -1) / 255;
+						lua_pushliteral(L, "b");
+						lua_rawget(L, -4);
+						b = lua_tonumber(L, -1) / 255;
+						lua_pop(L, 3);
+						a = 1;
+					}
+					// Hexacolor
+					else if (codestop - (next+1) == 6)
+					{
+						lr = r;
+						lg = g;
+						lb = b;
+						la = a;
+
+						int rh = 0, gh = 0, bh = 0;
+
+						if ((*(next+1) >= '0') && (*(next+1) <= '9')) rh += 16 * (*(next+1) - '0');
+						else if ((*(next+1) >= 'a') && (*(next+1) <= 'f')) rh += 16 * (10 + *(next+1) - 'a');
+						else if ((*(next+1) >= 'A') && (*(next+1) <= 'F')) rh += 16 * (10 + *(next+1) - 'A');
+						if ((*(next+2) >= '0') && (*(next+2) <= '9')) rh += (*(next+2) - '0');
+						else if ((*(next+2) >= 'a') && (*(next+2) <= 'f')) rh += (10 + *(next+2) - 'a');
+						else if ((*(next+2) >= 'A') && (*(next+2) <= 'F')) rh += (10 + *(next+2) - 'A');
+
+						if ((*(next+3) >= '0') && (*(next+3) <= '9')) gh += 16 * (*(next+3) - '0');
+						else if ((*(next+3) >= 'a') && (*(next+3) <= 'f')) gh += 16 * (10 + *(next+3) - 'a');
+						else if ((*(next+3) >= 'A') && (*(next+3) <= 'F')) gh += 16 * (10 + *(next+3) - 'A');
+						if ((*(next+4) >= '0') && (*(next+4) <= '9')) gh += (*(next+4) - '0');
+						else if ((*(next+4) >= 'a') && (*(next+4) <= 'f')) gh += (10 + *(next+4) - 'a');
+						else if ((*(next+4) >= 'A') && (*(next+4) <= 'F')) gh += (10 + *(next+4) - 'A');
+
+						if ((*(next+5) >= '0') && (*(next+5) <= '9')) bh += 16 * (*(next+5) - '0');
+						else if ((*(next+5) >= 'a') && (*(next+5) <= 'f')) bh += 16 * (10 + *(next+5) - 'a');
+						else if ((*(next+5) >= 'A') && (*(next+5) <= 'F')) bh += 16 * (10 + *(next+5) - 'A');
+						if ((*(next+6) >= '0') && (*(next+6) <= '9')) bh += (*(next+6) - '0');
+						else if ((*(next+6) >= 'a') && (*(next+6) <= 'f')) bh += (10 + *(next+6) - 'a');
+						else if ((*(next+6) >= 'A') && (*(next+6) <= 'F')) bh += (10 + *(next+6) - 'A');
+
+						r = (float)rh / 255;
+						g = (float)gh / 255;
+						b = (float)bh / 255;
+						a = 1;
+					}
+					lua_pop(L, 2);
+				}
+
+				char old = *codestop;
+				*codestop = '\0';
+//				printf("Found code: %s\n", next+1);
+				*codestop = old;
+
+				start = codestop + 1;
+				next = codestop; // The while will increment it, so we dont so it here
+			}
+		}
+		if (*next == '\0') break;
+		next++;
+	}
+
+	id_dduid = 1;
+	if (size > max_size) max_size = size;
+
+	this->nb_lines = nb_lines;
+	this->w = max_size;
+	this->h = nb_lines * font_h;
+}
+
+void DOText::setText(const char *text) {
+	free((void*)this->text);
+	this->text = strdup(text);
+	parseText();
+}

+/*
+	TE4 - T-Engine 4
+	Copyright (C) 2009 - 2015 Nicolas Casalini
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+	Nicolas Casalini "DarkGod"
+	darkgod@te4.org
+*/
+#ifndef TEXTOBJECTS_H
+#define TEXTOBJECTS_H
+
+#include "displayobjects/DisplayObject.hpp"
+extern "C" {
+#include "font.h"
+#include "utf8proc/utf8proc.h"
+}
+
+class DOText : public DOVertexes{
+private:
+	int font_lua_ref = LUA_NOREF;
+	font_type *font = NULL;
+
+	char *text;
+	int line_max_width = 99999;
+	bool no_linefeed = false;
+	int nb_lines = 1;
+	int w = 0;
+	int h = 0;
+
+public:
+
+	DOText() {
+		text = strdup("");
+	};
+	virtual ~DOText() {
+		free((void*)text);
+		if (font_lua_ref != LUA_NOREF && L) luaL_unref(L, LUA_REGISTRYINDEX, font_lua_ref);
+	};
+	
+	void setFont(font_type *font, int lua_ref) {
+		if (font_lua_ref != LUA_NOREF && L) luaL_unref(L, LUA_REGISTRYINDEX, font_lua_ref);
+		this->font = font;
+		font_lua_ref = lua_ref;
+	};
+
+	void setNoLinefeed(bool no_linefeed) { this->no_linefeed = no_linefeed; parseText(); };
+	void setMaxWidth(int width) { this->line_max_width = width; parseText(); };
+
+	void setText(const char *text);
+
+private:
+	void parseText();
+	int getTextChunkSize(const char *str, size_t len, font_style style);
+	int addCharQuad(const char *str, size_t len, font_style style, int bx, int by, float r, float g, float b, float a);
+};
+
+#endif

@@ -55,7 +55,7 @@ static int set_default_atlas_chars(lua_State *L) {
 
 static int sdl_free_font(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	if (f->font) TTF_CloseFont(f->font);
 	if (f->atlas) {
 		SDL_FreeSurface(f->atlas);
@@ -73,7 +73,7 @@ static int sdl_new_font(lua_State *L)
 	const char *name = luaL_checkstring(L, 1);
 	int size = luaL_checknumber(L, 2);
 
-	lua_font *f = (lua_font*)lua_newuserdata(L, sizeof(lua_font));
+	font_type *f = (font_type*)lua_newuserdata(L, sizeof(font_type));
 	auxiliar_setclass(L, "sdl{font}", -1);
 
 	SDL_RWops *src = PHYSFSRWOPS_openRead(name);
@@ -95,7 +95,7 @@ static int sdl_new_font(lua_State *L)
 	return 1;
 }
 
-bool font_add_atlas(lua_font *f, int32_t c, font_style style) {
+bool font_add_atlas(font_type *f, int32_t c, font_style style) {
 	if (c < 1 || c >= MAX_ATLAS_DATA) return FALSE;
 
 	SDL_Color color = {255, 255, 255};
@@ -126,7 +126,15 @@ bool font_add_atlas(lua_font *f, int32_t c, font_style style) {
 	}
 }
 
-void font_make_atlas(lua_font *f, int w, int h) {
+void font_update_atlas(font_type *f) {
+	if (f->atlas_changed) {
+		tfglBindTexture(GL_TEXTURE_2D, f->atlas_tex);
+		copy_surface_to_texture(f->atlas);
+		f->atlas_changed = FALSE;
+	}
+}
+
+void font_make_atlas(font_type *f, int w, int h) {
 	if (!w) w = DEFAULT_ATLAS_W;
 	if (!h) h = DEFAULT_ATLAS_H;
 
@@ -183,14 +191,14 @@ void font_make_atlas(lua_font *f, int w, int h) {
 
 static int sdl_font_make_atlas(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	if (!f->atlas) font_make_atlas(f, lua_tonumber(L, 2), lua_tonumber(L, 3));
 	return 0;
 }
 
 static int sdl_font_get_atlas_size(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	if (!f->atlas) font_make_atlas(f, 0, 0);
 	lua_pushnumber(L, f->atlas_w);
 	lua_pushnumber(L, f->atlas_h);
@@ -199,7 +207,7 @@ static int sdl_font_get_atlas_size(lua_State *L)
 
 // static int sdl_font_atlas_debug(lua_State *L)
 // {
-// 	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+// 	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 // 	if (!f->atlas) font_make_atlas(f, 0, 0);
 // 	int x = luaL_checknumber(L, 2);
 // 	int y = luaL_checknumber(L, 3);
@@ -221,7 +229,7 @@ static int sdl_font_get_atlas_size(lua_State *L)
 
 static int sdl_font_size(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	const char *str = luaL_checkstring(L, 2);
 	int w, h;
 
@@ -236,21 +244,21 @@ static int sdl_font_size(lua_State *L)
 
 static int sdl_font_height(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	lua_pushnumber(L, TTF_FontHeight(f->font));
 	return 1;
 }
 
 static int sdl_font_lineskip(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	lua_pushnumber(L, TTF_FontLineSkip(f->font));
 	return 1;
 }
 
 static int sdl_font_style_get(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	int style = TTF_GetFontStyle(f->font);
 
 	if (style & TTF_STYLE_BOLD) lua_pushliteral(L, "bold");
@@ -263,7 +271,7 @@ static int sdl_font_style_get(lua_State *L)
 
 static int sdl_font_style(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	const char *style = luaL_checkstring(L, 2);
 
 	if (!strcmp(style, "normal")) TTF_SetFontStyle(f->font, 0);
@@ -276,7 +284,7 @@ static int sdl_font_style(lua_State *L)
 int sdl_surface_drawstring(lua_State *L)
 {
 	SDL_Surface **s = (SDL_Surface**)auxiliar_checkclass(L, "sdl{surface}", 1);
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 2);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 2);
 	const char *str = luaL_checkstring(L, 3);
 	int x = luaL_checknumber(L, 4);
 	int y = luaL_checknumber(L, 5);
@@ -301,7 +309,7 @@ int sdl_surface_drawstring_aa(lua_State *L)
 {
 	if (no_text_aa) return sdl_surface_drawstring(L);
 	SDL_Surface **s = (SDL_Surface**)auxiliar_checkclass(L, "sdl{surface}", 1);
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 2);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 2);
 	const char *str = luaL_checkstring(L, 3);
 	int x = luaL_checknumber(L, 4);
 	int y = luaL_checknumber(L, 5);
@@ -324,7 +332,7 @@ int sdl_surface_drawstring_aa(lua_State *L)
 
 static int sdl_surface_drawstring_newsurface(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	const char *str = luaL_checkstring(L, 2);
 	int r = luaL_checknumber(L, 3);
 	int g = luaL_checknumber(L, 4);
@@ -349,7 +357,7 @@ static int sdl_surface_drawstring_newsurface(lua_State *L)
 static int sdl_surface_drawstring_newsurface_aa(lua_State *L)
 {
 	if (no_text_aa) return sdl_surface_drawstring_newsurface(L);
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	const char *str = luaL_checkstring(L, 2);
 	int r = luaL_checknumber(L, 3);
 	int g = luaL_checknumber(L, 4);
@@ -374,7 +382,7 @@ static int sdl_new_tile(lua_State *L)
 {
 	int w = luaL_checknumber(L, 1);
 	int h = luaL_checknumber(L, 2);
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 3);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 3);
 	const char *str = luaL_checkstring(L, 4);
 	int x = luaL_checknumber(L, 5);
 	int y = luaL_checknumber(L, 6);
@@ -494,7 +502,7 @@ static void font_make_texture_line(lua_State *L, SDL_Surface *s, int id, bool is
 
 static int sdl_font_draw(lua_State *L)
 {
-	lua_font *f = (lua_font*)auxiliar_checkclass(L, "sdl{font}", 1);
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
 	const char *str = luaL_checkstring(L, 2);
 	int max_width = luaL_checknumber(L, 3);
 	int r = luaL_checknumber(L, 4);

@@ -57,8 +57,13 @@ typedef struct
 	int atlas_x, atlas_y;
 	font_atlas_data *atlas_data;
 	bool atlas_changed;
-} lua_font;
+} font_type;
 
 extern int luaopen_font(lua_State *L);
 
+extern bool font_add_atlas(font_type *f, int32_t c, font_style style);
+extern void font_update_atlas(font_type *f);
+extern void font_make_atlas(font_type *f, int w, int h);
+
+
 #endif

@@ -133,6 +133,26 @@ void DORVertexes::render(DORContainer *container, mat4 cur_model) {
 	resetChanged();
 }
 
+void DORText::render(DORContainer *container, mat4 cur_model) {
+	cur_model *= model;
+	auto dl = getDisplayList(container, tex, shader);
+
+	// Make sure we do not have to reallocate each step
+	int nb = vertices.size();
+	int startat = dl->list.size();
+	dl->list.reserve(startat + nb);
+
+	// Copy & apply the model matrix
+	// DG: is it better to first copy it all and then alter it ? most likely not, change me
+	dl->list.insert(std::end(dl->list), std::begin(this->vertices), std::end(this->vertices));
+	vertex *dest = dl->list.data();
+	for (int di = startat; di < startat + nb; di++) {
+		dest[di].pos = cur_model * dest[di].pos;
+	}
+
+	resetChanged();
+}
+
 void DORContainer::render(DORContainer *container, mat4 cur_model) {
 	cur_model *= model;
 	for (auto it = dos.begin() ; it != dos.end(); ++it) {

@@ -70,6 +70,16 @@ public:
 };
 
 /****************************************************************************
+ ** GL DO for text
+ ****************************************************************************/
+class DORText : public DOText, public DisplayObjectGL {
+public:
+	DORText() : DOText(), DisplayObjectGL() {};
+	virtual ~DORText() {};
+	virtual void render(DORContainer *container, mat4 cur_model);
+};
+
+/****************************************************************************
  ** GL DO Container, the base of the rendering pyramid
  ****************************************************************************/
 class DORContainer : public DOContainer, public DisplayObjectGL {
@@ -99,7 +109,7 @@ private:
 public:
 	RendererGL();
 	RendererGL(int w, int h);
-	~RendererGL();
+	virtual ~RendererGL();
 
 	virtual void update();
 	virtual void toScreen(float x, float y, float r, float g, float b, float a);

@@ -218,6 +218,71 @@ static int gl_vertexes_scale(lua_State *L)
 }
 
 /******************************************************************
+ ** Text
+ ******************************************************************/
+static int gl_text_new(lua_State *L)
+{
+	DORText **v = (DORText**)lua_newuserdata(L, sizeof(DORText*));
+	auxiliar_setclass(L, "gl{text}", -1);
+	*v = new DORText();
+	(*v)->setLuaState(L);
+
+	font_type *f = (font_type*)auxiliar_checkclass(L, "sdl{font}", 1);
+	if (lua_isnumber(L, 2)) (*v)->setMaxWidth(lua_tonumber(L, 2));
+	(*v)->setNoLinefeed(lua_toboolean(L, 3));
+
+	lua_pushvalue(L, 1);
+	(*v)->setFont(f, luaL_ref(L, LUA_REGISTRYINDEX));
+
+	return 1;
+}
+
+static int gl_text_free(lua_State *L)
+{
+	DORText **v = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	delete(*v);
+	lua_pushnumber(L, 1);
+	return 1;
+}
+
+static int gl_text_set(lua_State *L)
+{
+	DORText **v = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	(*v)->setText(lua_tostring(L, 2));
+
+	return 0;
+}
+
+static int gl_text_shader(lua_State *L)
+{
+	DORText **v = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	shader_type *shader = (shader_type*)lua_touserdata(L, 2);
+	(*v)->setShader(shader);
+	return 0;
+}
+
+static int gl_text_translate(lua_State *L)
+{
+	DORText **v = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	(*v)->translate(lua_tonumber(L, 2), lua_tonumber(L, 3), lua_tonumber(L, 4), lua_toboolean(L, 5));
+	return 0;
+}
+
+static int gl_text_rotate(lua_State *L)
+{
+	DORText **v = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	(*v)->rotate(lua_tonumber(L, 2), lua_tonumber(L, 3), lua_tonumber(L, 4), lua_toboolean(L, 5));
+	return 0;
+}
+
+static int gl_text_scale(lua_State *L)
+{
+	DORText **c = (DORText**)auxiliar_checkclass(L, "gl{text}", 1);
+	(*c)->scale(lua_tonumber(L, 2), lua_tonumber(L, 3), lua_tonumber(L, 4), lua_toboolean(L, 5));
+	return 0;
+}
+
+/******************************************************************
  ** Lua declarations
  ******************************************************************/
 
@@ -253,9 +318,21 @@ static const struct luaL_Reg gl_vertexes_reg[] =
 	{NULL, NULL},
 };
 
+static const struct luaL_Reg gl_text_reg[] =
+{
+	{"__gc", gl_text_free},
+	{"text", gl_text_set},
+	{"shader", gl_text_shader},
+	{"translate", gl_text_translate},
+	{"rotate", gl_text_rotate},
+	{"scale", gl_text_scale},
+	{NULL, NULL},
+};
+
 const luaL_Reg rendererlib[] = {
 	{"renderer", gl_renderer_new},
 	{"vertexes", gl_vertexes_new},
+	{"text", gl_text_new},
 	{"container", gl_container_new},
 	{NULL, NULL}
 };
@@ -264,6 +341,7 @@ int luaopen_renderer(lua_State *L)
 {
 	auxiliar_newclass(L, "gl{renderer}", gl_renderer_reg);
 	auxiliar_newclass(L, "gl{vertexes}", gl_vertexes_reg);
+	auxiliar_newclass(L, "gl{text}", gl_text_reg);
 	auxiliar_newclass(L, "gl{container}", gl_container_reg);
 	luaL_openlib(L, "core.renderer", rendererlib, 0);
 	return 1;