Adding a UI library

Makefile

@@ -54,7 +54,9 @@ SRC = src/engine/engine.c \
 	src/sfml_renderer/texture_utility.c \
 	src/sfml_renderer/sfml_drawer.c \
 	src/sfml_renderer/sfml_functions.c \
-	src/sfml_renderer/sfml_vertex.c
+	src/sfml_renderer/sfml_vertex.c \
+	src/ui/setup_ui.c \
+	src/ui/button.c
 
 OBJ = $(SRC:%.c=%.o)
 

include/components/fixed_to_cam_component.h

@@ -16,6 +16,7 @@ struct fixed_to_cam
     gc_vector2 pos;
     bool per_x;
     bool per_y;
+    bool set_size;
 };
 
 extern const struct fixed_to_cam fixed_to_cam;

include/data.h

@@ -5,11 +5,16 @@
 ** data
 */
 
-#pragma once
+#include "engine.h"
+
+typedef struct gc_data gc_data;
+typedef gc_data *(*gc_loader)(gc_engine *engine, gc_scene *scene, node *n);
+
+#ifndef DATA
+#define DATA
 
 #include "xml.h"
 
-typedef struct gc_data gc_data;
 struct gc_data
 {
     char *type;
@@ -18,10 +23,10 @@ struct gc_data
     void (*destroy)(gc_data *data);
 };
 
-typedef int (*gc_loader)(gc_data *data, node *n);
-
 typedef struct gc_dataloader
 {
     char *type;
     gc_loader load;
-} gc_dataloader;
+} gc_dataloader;
+
+#endif

include/engine.h

@@ -6,7 +6,8 @@
 */
 typedef struct gc_engine gc_engine;
 
-#pragma once
+#ifndef ENGINE
+#define ENGINE
 
 #include "xml.h"
 #include "scene.h"
@@ -43,6 +44,7 @@ struct gc_engine
 
     gc_list *dataloaders;
     void (*add_dataloader)(gc_engine *engine, char *type, gc_loader loader);
+    gc_dataloader *(*get_dataloader)(gc_engine *engine, const char *type);
 };
 
 gc_engine *engine_create(void);
@@ -56,7 +58,7 @@ void engine_stop_music(gc_engine *engine);
 
 int change_scene(gc_engine *engine, gc_scene *scene);
 
-void engine_add_buildin_systems(gc_engine *engine);
+void engine_add_builtin_systems(gc_engine *engine);
 void *engine_get_system(gc_engine *engine, const char *name);
 void engine_add_system(gc_engine *engine, const void *system);
 
@@ -64,8 +66,12 @@ void engine_add_buildin_components(gc_engine *engine);
 const void *engine_get_component(gc_engine *engine, const char *name);
 void engine_add_component(gc_engine *engine, const void *component);
 
+void engine_init_dataloaders(gc_engine *this);
 void engine_add_dataloader(gc_engine *engine, char *type, gc_loader loader);
+gc_dataloader *engine_get_dataloader(gc_engine *this, const char *type);
 
 int engine_use_sfml(gc_engine *engine, const char *title, int framerate);
 
-#define GETSYS(x) ((struct x *)engine->get_system(engine, #x))
+#define GETSYS(x) ((struct x *)engine->get_system(engine, #x))
+
+#endif

include/errors.h

@@ -0,0 +1,13 @@
+//
+// Created by anonymus-raccoon on 2/21/20.
+//
+
+#ifndef _ERRORS_H_
+#define _ERRORS_H_
+
+#define NO_CUSTOM_ENTITY_LOADER ("Could not load the custom entity (type %s)"\
+", the loader was not found.\n")
+#define DATALOADER_NOT_FOUND ("Couldn't find data loader for the type %s\n")
+#define DATALOADER_ERROR ("Error while loading data %s (type %s).\n")
+
+#endif //_ERRORS_H_

include/list.h

@@ -15,4 +15,6 @@ struct gc_list
     gc_list *next;
 };
 
-gc_list *list_add(gc_list *list, void *obj);
+gc_list *list_add(gc_list *list, void *obj);
+
+#define LISTADD(list, obj) (list = list_add(list, obj))

include/scene.h

@@ -26,11 +26,11 @@ struct gc_scene
     int (*add_entity)(gc_scene *scene, gc_entity *entity);
     gc_entity *(*get_entity)(gc_scene *scene, int id);
     gc_list *(*get_entity_by_cmp)(gc_scene *scene, const char *cmp_name);
+    void (*load_entity)(gc_scene *this, gc_engine *engine, node *xml);
 };
 
 gc_scene *scene_create(gc_engine *engine, const char *mappath);
-int scene_add_entity(gc_scene *scene, gc_entity *entity);
 void scene_load_data(gc_engine *engine, gc_scene *scene, node *n);
 void *scene_get_data(gc_scene *scene, const char *type, const char *name);
 void scene_destroy(gc_scene *scene);
-int scene_load_musics(gc_scene *scene, node *n);
+void scene_load_entity(gc_scene *this, gc_engine *engine, node *n);

include/sfml_renderer.h

@@ -15,17 +15,17 @@
 #include "systems/sfml_renderer_system.h"
 #include "components/vertex_component.h"
 
-int sfml_music_loader(gc_data *data, node *n);
-int sfml_sprite_loader(gc_data *data, node *n);
-int sfml_font_loader(gc_data *data, node *n);
+gc_data *sfml_music_loader(gc_engine *engine, gc_scene *scene, node *n);
+gc_data *sfml_sprite_loader(gc_engine *engine, gc_scene *scene, node *n);
+gc_data *sfml_font_loader(gc_engine *engine, gc_scene *scene, node *n);
 
 sfTexture *get_texture(gc_scene *scene, char *name);
 sfVertexArray *sfml_init_verticies(void);
 
 void sfmlrenderer_draw_texture(struct sfml_renderer_system *renderer, \
-struct transform_component *tra, gc_sprite *sprite);
+struct transform_component *tra, gc_entity *entity, gc_sprite *sprite);
 void sfmlrenderer_draw_anim(struct sfml_renderer_system *renderer, \
-struct transform_component *tra, gc_animholder *holder, float dtime);
+gc_entity *entity, gc_animholder *holder, float dtime);
 void sfmlrenderer_draw_txt(struct sfml_renderer_system *renderer, \
 struct transform_component *tra, gc_text *txt);
 void sfmlrenderer_draw_tilemap(struct sfml_renderer_system *this, \

include/systems/sfml_renderer_system.h

@@ -10,9 +10,11 @@
 #include "system.h"
 #include <SFML/Graphics.h>
 #include "scene.h"
+#include "text.h"
 #include "systems/sfml_renderer_system.h"
 #include "systems/camerafollow_system.h"
 
+typedef struct sfml_renderer_system sf_renderer;
 struct sfml_renderer_system
 {
     gc_system system;
@@ -21,6 +23,7 @@ struct sfml_renderer_system
     sfText *text;
     sfView *view;
     sfVertexArray *vertices;
+    gc_vector2 (*get_text_size)(sf_renderer *this, gc_text *text);
 };
 
 gc_system *gc_new_sfml_renderer(gc_engine *engine, \

include/ui.h

@@ -0,0 +1,12 @@
+//
+// Created by anonymus-raccoon on 2/21/20.
+//
+
+#ifndef _UI_H_
+#define _UI_H_
+
+#include "engine.h"
+
+void ui_setup(gc_engine *engine);
+
+#endif //_UI_H_

src/components/fixed_to_cam.c

@@ -16,6 +16,9 @@ static void ctr(void *component, va_list args)
     struct fixed_to_cam *cmp = (struct fixed_to_cam *)component;
 
     cmp->pos = va_arg(args, gc_vector2);
+    cmp->per_x = va_arg(args, int);
+    cmp->per_y = va_arg(args, int);
+    cmp->set_size = va_arg(args, int);
 }
 
 static void fdctr(gc_entity *entity, gc_scene *scene, void *component, node *n)
@@ -30,6 +33,7 @@ static void fdctr(gc_entity *entity, gc_scene *scene, void *component, node *n)
 	cmp->per_x = tmp && my_strchr(tmp, '%');
 	tmp = xml_gettempprop(n, "y");
 	cmp->per_y = tmp && my_strchr(tmp, '%');
+	cmp->set_size = xml_hasproperty(n, "size");
     (void)scene;
     (void)entity;
 }

src/components/renderers/sprite_renderer.c

@@ -24,7 +24,7 @@ void sprite_ctr(struct renderer *cmp, va_list args)
     cmp->data = sprite;
     sprite->texture = va_arg(args, sfTexture *);
     sprite->rect = va_arg(args, gc_int_rect);
-    if (sprite->texture && sprite->rect.height < 0) {
+    if (sprite->texture && sprite->rect.height <= 0) {
         size = sfTexture_getSize(sprite->texture);
         sprite->rect.height = (float)size.y;
         sprite->rect.width = (float)size.x;
@@ -46,7 +46,7 @@ void sprite_fdctr(gc_scene *scene, struct renderer *cmp, node *n)
     sprite->rect.width = xml_getfloatprop(rect, "width");
     sprite->rect.top = xml_getfloatprop(rect, "top");
     sprite->rect.left = xml_getfloatprop(rect, "left");
-    if (sprite->texture && sprite->rect.height < 0) {
+    if (sprite->texture && sprite->rect.height <= 0) {
         size = sfTexture_getSize(sprite->texture);
         sprite->rect.height = (float)size.y;
         sprite->rect.width = (float)size.x;

src/deserializer/prefab.c

@@ -35,7 +35,11 @@ int prefab_loadentities(node *n, gc_engine *engine, gc_scene *scene)
     if (!n)
         return (-1);
     for (node *ent_n = n->child; ent_n; ent_n = ent_n->next) {
-        entity = deserialize_entity(engine, scene, ent_n);
+		if (my_strcmp(ent_n->name, "gc_entity")) {
+			scene->load_entity(scene, engine, ent_n);
+			continue;
+		}
+		entity = deserialize_entity(engine, scene, ent_n);
         if (!entity)
             return (-1);
         scene->add_entity(scene, entity);

src/engine/engine.c

@@ -9,8 +9,6 @@
 #include "system.h"
 #include "utility.h"
 #include <stdlib.h>
-#include <SFML/Graphics.h>
-#include <SFML/System.h>
 
 void update_system(gc_engine *engine, gc_system *sys, float dtime)
 {
@@ -81,9 +79,8 @@ gc_engine *engine_create(void)
     engine->play_music = &engine_play_music;
     engine->stop_music = &engine_stop_music;
     engine->destroy = &engine_destroy;
-    engine_add_buildin_systems(engine);
+	engine_add_builtin_systems(engine);
     engine_add_buildin_components(engine);
-    engine->dataloaders = NULL;
-    engine->add_dataloader = &engine_add_dataloader;
+    engine_init_dataloaders(engine);
     return (engine);
 }

src/engine/engine_dataloader.c

@@ -9,6 +9,7 @@
 #include "data.h"
 #include "my.h"
 #include <malloc.h>
+#include "ui.h"
 
 void engine_add_dataloader(gc_engine *engine, char *type, gc_loader loader)
 {
@@ -19,4 +20,24 @@ void engine_add_dataloader(gc_engine *engine, char *type, gc_loader loader)
     dataloader->type = type;
     dataloader->load = loader;
     engine->dataloaders = list_add(engine->dataloaders, dataloader);
+}
+
+gc_dataloader *engine_get_dataloader(gc_engine *this, const char *type)
+{
+	gc_dataloader *loader;
+
+	for (gc_list *li = this->dataloaders; li; li = li->next) {
+		loader = (gc_dataloader *)li->data;
+		if (!my_strcmp(loader->type, type))
+			return (loader);
+	}
+	return (NULL);
+}
+
+void engine_init_dataloaders(gc_engine *this)
+{
+	this->dataloaders = NULL;
+	this->add_dataloader = &engine_add_dataloader;
+	this->get_dataloader = &engine_get_dataloader;
+	ui_setup(this);
 }

src/engine/engine_system_builder.c

@@ -27,7 +27,7 @@ void engine_finish_physics(gc_engine *engine)
     engine->add_system(engine, new_system(&movable_system));
 }
 
-void engine_add_buildin_systems(gc_engine *engine)
+void engine_add_builtin_systems(gc_engine *engine)
 {
     engine->systems = NULL;
     engine->add_system = &engine_add_system;

src/entity/entity_factory.c

@@ -10,11 +10,11 @@
 #include "my.h"
 #include <stdlib.h>
 
-static unsigned int next_id = 0;
 const gc_entity entity_prefab;
 
 gc_entity *entity_create(void)
 {
+	static unsigned int next_id = 0;
     gc_entity *entity = malloc(sizeof(gc_entity));
 
     if (!entity)
@@ -40,6 +40,8 @@ int entity_add(gc_scene *scene, gc_entity *e)
 {
     char *name;
 
+    if (!e)
+    	return (0);
     scene->entities = list_add(scene->entities, e);
     if (!scene->entities)
         return (-1);

src/scene/scene.c

@@ -53,6 +53,7 @@ gc_scene *scene_create(gc_engine *engine, const char *xmlpath)
     scene->get_entity_by_cmp = &get_entity_by_cmp;
     scene->destroy = &scene_destroy;
     scene->get_data = &scene_get_data;
+    scene->load_entity = &scene_load_entity;
     prefab_loadentities(n, engine, scene);
     xml_destroy(n);
     return (scene);

src/scene/scene_loader.c

@@ -6,6 +6,7 @@
 */
 
 #include "engine.h"
+#include "errors.h"
 #include "scene.h"
 #include "xml.h"
 #include "my.h"
@@ -14,39 +15,39 @@
 #include <SFML/Graphics.h>
 #include <malloc.h>
 
-gc_dataloader *gc_dataloader_from_type(gc_engine *engine, const char *type)
-{
-    gc_dataloader *loader;
-
-    for (gc_list *li = engine->dataloaders; li; li = li->next) {
-        loader = (gc_dataloader *)li->data;
-        if (!my_strcmp(loader->type, type))
-            return (loader);
-    }
-    return (NULL);
-}
-
 void scene_load_data(gc_engine *engine, gc_scene *scene, node *n)
 {
-    gc_data *data;
     gc_dataloader *loader;
+	gc_data *data;
 
     scene->data = NULL;
     if (!(n = xml_getnode(n, "data")))
         return;
     for (n = n->child; n; n = n->next) {
-        if (!(data = malloc(sizeof(*data))))
-            return;
-        data->type = my_strdup(n->name);
-        data->name = xml_getproperty(n, "name");
-        data->destroy = NULL;
-        loader = gc_dataloader_from_type(engine, data->type);
-        if (!loader)
-            return ((void)my_printf("Couldn't find data loader for the type %s\
-\n", data->type));
-        if (loader->load(data, n) < 0)
-            return ((void)my_printf("Error while loading data %s (type %s).\
-\n", data->name, data->type));
+        loader = engine->get_dataloader(engine, n->name);
+        if (!loader) {
+        	my_printf(DATALOADER_NOT_FOUND, n->name);
+			return;
+		}
+		data = loader->load(engine, scene, n);
+        if (!data) {
+			my_printf(DATALOADER_ERROR, xml_getproperty(n, "name"), n->name);
+			return;
+		}
         scene->data = list_add(scene->data, data);
     }
+}
+
+void scene_load_entity(gc_scene *this, gc_engine *engine, node *n)
+{
+	gc_dataloader *loader = engine->get_dataloader(engine, n->name);
+	gc_data *data;
+
+	if (!loader) {
+		my_printf(NO_CUSTOM_ENTITY_LOADER, n->name);
+		return;
+	}
+	data = loader->load(engine, this, n);
+	for (gc_list *li = (gc_list *)data->custom; li; li = li->next)
+		this->add_entity(this, li->data);
 }

src/sfml_renderer/sfml_dataloaders.c

@@ -13,45 +13,56 @@
 #include <SFML/Graphics.h>
 #include <SFML/Audio.h>
 
-int sfml_music_loader(gc_data *data, node *n)
+gc_data *sfml_music_loader(gc_engine *engine, gc_scene *scene, node *n)
 {
-    char *path = xml_getproperty(n, "src");
+    gc_data *data = malloc(sizeof(*data));
 
-    if (!path)
-        return (-1);
-    data->name = path;
-    data->custom = sfMusic_createFromFile(path);
+    if (!data)
+    	return (NULL);
+	data->type = my_strdup(n->name);
+	data->name = xml_getproperty(n, "src");
+    if (!data->name || !data->type)
+        return (NULL);
+    data->custom = sfMusic_createFromFile(data->name);
     data->destroy = &sfml_music_destroy;
     if (!data->custom)
-        return (-1);
-    return (0);
+        return (NULL);
+    return (data);
 }
 
-int sfml_sprite_loader(gc_data *data, node *n)
+gc_data *sfml_sprite_loader(gc_engine *engine, gc_scene *scene, node *n)
 {
-    char *path = xml_getproperty(n, "src");
+	gc_data *data = malloc(sizeof(*data));
 
-    if (!path)
-        return (-1);
-    data->name = path;
-    data->custom = sfTexture_createFromFile(path, NULL);
-    if (!data->custom || !data->name)
-        return (-1);
+	if (!data)
+		return (NULL);
+	data->type = my_strdup(n->name);
+    data->name = xml_getproperty(n, "src");
+    if (!data->name || !data->type)
+    	return (NULL);
+    data->custom = sfTexture_createFromFile(data->name, NULL);
+    if (!data->custom)
+        return (NULL);
     sfTexture_setRepeated(data->custom, sfTrue);
     data->destroy = &sfml_texture_destroy;
-    return (0);
+	if (xml_hasproperty(n, "name"))
+		data->name = xml_getproperty(n, "name");
+    return (data);
 }
 
-int sfml_font_loader(gc_data *data, node *n)
+gc_data *sfml_font_loader(gc_engine *engine, gc_scene *scene, node *n)
 {
-    char *path = xml_getproperty(n, "src");
+	gc_data *data = malloc(sizeof(*data));
 
-    if (!path)
-        return (-1);
-    data->name = path;
-    data->custom = sfFont_createFromFile(path);
-    if (!data->custom || !data->name)
-        return (-1);
+	if (!data)
+		return (NULL);
+	data->type = my_strdup(n->name);
+    data->name = xml_getproperty(n, "src");
+    if (!data->name || !data->type)
+    	return (NULL);
+    data->custom = sfFont_createFromFile(data->name);
+    if (!data->custom)
+        return (NULL);
     data->destroy = &sfml_font_destroy;
-    return (0);
+    return (data);
 }

src/sfml_renderer/sfml_drawer.c

@@ -14,35 +14,51 @@
 #include "my.h"
 #include <SFML/Graphics.h>
 
+void sfmlrenderer_setorigin(struct sfml_renderer_system *renderer, \
+gc_entity *entity, gc_sprite *sprite, struct transform_component *tra)
+{
+	sfVector2f scale = (sfVector2f){
+		tra->size.x * sprite->scale.x / sprite->rect.width,
+		tra->size.y * sprite->scale.y / sprite->rect.height
+	};
+
+	sfSprite_setScale(renderer->sprite, scale);
+	if (entity->has_component(entity, "fixed_to_cam"))
+		sfSprite_setOrigin(renderer->sprite, (sfVector2f) {
+			sprite->rect.width / 2,
+			0
+		});
+	else
+		sfSprite_setOrigin(renderer->sprite, (sfVector2f){
+			scale.x < 0 ? sprite->rect.width : 0,
+			scale.y < 0 ? sprite->rect.height : 0
+		});
+}
+
 void sfmlrenderer_draw_texture(struct sfml_renderer_system *renderer, \
-struct transform_component *tra, gc_sprite *sprite)
+struct transform_component *tra, gc_entity *entity, gc_sprite *sprite)
 {
     sfVector2f pos = (sfVector2f){tra->position.x, -tra->position.y};
-    sfVector2f scale = (sfVector2f){
-        tra->size.x * sprite->scale.x / sprite->rect.width,
-        tra->size.y * sprite->scale.y / sprite->rect.height
-    };
 
     sprite->pos = tra->position;
-    if (!sprite->texture)
-        return;
+    if (!sprite->texture) {
+		my_printf("Trying to render a sprite without texture.\n");
+		return;
+	}
     sfSprite_setTexture(renderer->sprite, sprite->texture, true);
     sfSprite_setTextureRect(renderer->sprite, (sfIntRect){
         (int)sprite->rect.left, (int)sprite->rect.top,
         (int)sprite->rect.width, (int)sprite->rect.height
     });
     sfSprite_setPosition(renderer->sprite, pos);
-    sfSprite_setScale(renderer->sprite, scale);
-    sfSprite_setOrigin(renderer->sprite, (sfVector2f){
-        scale.x < 0 ? sprite->rect.width : 0,
-        scale.y < 0 ? sprite->rect.height : 0
-    });
+   	sfmlrenderer_setorigin(renderer, entity, sprite, tra);
     sfRenderWindow_drawSprite(renderer->window, renderer->sprite, NULL);
 }
 
 void sfmlrenderer_draw_anim(struct sfml_renderer_system *renderer, \
-struct transform_component *tra, gc_animholder *holder, float dtime)
+gc_entity *entity, gc_animholder *holder, float dtime)
 {
+	struct transform_component *tra = GETCMP(transform_component);
     gc_int_rect *rec = &holder->sprite->rect;
     gc_anim *curr = holder->current;
 
@@ -54,7 +70,7 @@ struct transform_component *tra, gc_animholder *holder, float dtime)
         if (rec->left > curr->rect.left + rec->width * (curr->frame_count - 1))
             rec->left = curr->rect.left;
     }
-    sfmlrenderer_draw_texture(renderer, tra, holder->sprite);
+    sfmlrenderer_draw_texture(renderer, tra, entity, holder->sprite);
 }
 
 void sfmlrenderer_draw_txt(struct sfml_renderer_system *renderer, \

src/systems/fixed_to_cam_pseudosystem.c

@@ -18,24 +18,21 @@
 void entities_update_to_cam(gc_scene *scene, \
 struct sfml_renderer_system *renderer, struct camerafollow_system *cam)
 {
-    gc_list *list;
-    gc_entity *entity;
-    sfVector2f size;
-    struct transform_component *tra;
-	struct fixed_to_cam *fc;
+    gc_list *list = scene->get_entity_by_cmp(scene, "fixed_to_cam");
 
-    list = scene->get_entity_by_cmp(scene, "fixed_to_cam");
     for (gc_list *li = list; li; li = li->next) {
-        entity = (gc_entity *)li->data;
-        tra = GETCMP(transform_component);
-		fc = GETCMP(fixed_to_cam);
+		gc_entity *entity = (gc_entity *)li->data;
+		struct transform_component *tra = GETCMP(transform_component);
+		struct fixed_to_cam *fc = GETCMP(fixed_to_cam);
+		sfVector2f size = sfView_getSize(renderer->view);
+		float x = (cam->cam_pos.x - size.x / 2);
+		float y = (cam->cam_pos.y + size.y / 2);
+
 		if (!tra)
-            continue;
-        size = sfView_getSize(renderer->view);
-        tra->position = (gc_vector2) {
-			(cam->cam_pos.x - size.x / 2 + fc->pos.x) * fc->per_x ? size.x / 100 : 1,
-			(cam->cam_pos.y + size.y / 2 - fc->pos.y) * fc->per_y ? size.y / 100 : 1
-        };
+			continue;
+		x += fc->pos.x * (fc->per_x ? size.x / 100 : 1);
+		y -= fc->pos.y * (fc->per_x ? size.y / 100 : 1);
+        tra->position = (gc_vector2){x, y};
     }
 }
 
@@ -44,12 +41,14 @@ void entities_update_to_cam_size(gc_scene *scene, gc_vector2 size)
     gc_list *list;
     gc_entity *entity;
     struct transform_component *tra;
+    struct fixed_to_cam *fc;
 
     list = scene->get_entity_by_cmp(scene, "fixed_to_cam");
     for (gc_list *li = list; li; li = li->next) {
         entity = (gc_entity *)li->data;
         tra = GETCMP(transform_component);
-        if (!tra)
+        fc = GETCMP(fixed_to_cam);
+        if (!tra || !fc->set_size)
             continue;
         tra->size = (gc_vector2) {
             size.x,

src/systems/sfml_renderer_system.c

@@ -18,8 +18,18 @@
 #include "text.h"
 #include <stdlib.h>
 
+gc_vector2 sfml_get_text_size(sf_renderer *this, gc_text *text)
+{
+	sfFloatRect bounds;
+
+	sfText_setString(this->text, text->text);
+	sfText_setFont(this->text, text->font);
+	bounds = sfText_getLocalBounds(this->text);
+	return (gc_vector2) {bounds.width, bounds.height};
+}
+
 void sfml_update_entity(gc_engine *engine, void *system, \
-gc_entity *entity, float dtime)
+gc_entity *entity, float dt)
 {
     struct transform_component *pos = GETCMP(transform_component);
     struct renderer *text = GETCMP(renderer);
@@ -29,10 +39,10 @@ gc_entity *entity, float dtime)
         return;
     switch (text->type) {
     case GC_TEXTUREREND:
-        sfmlrenderer_draw_texture(rend, pos, (gc_sprite *)text->data);
+        sfmlrenderer_draw_texture(rend, pos, entity, (gc_sprite *)text->data);
         break;
     case GC_ANIMREND:
-        sfmlrenderer_draw_anim(rend, pos, (gc_animholder *)text->data, dtime);
+        sfmlrenderer_draw_anim(rend, entity, (gc_animholder *)text->data, dt);
         break;
     case GC_TXTREND:
         sfmlrenderer_draw_txt(rend, pos, (gc_text *)text->data);
@@ -66,6 +76,7 @@ void sfmlrend_ctr(void *rend, va_list list)
     const char *title = va_arg(list, const char *);
     int framerate = va_arg(list, int);
 
+    renderer->get_text_size = &sfml_get_text_size;
     renderer->window = sfRenderWindow_create(mode, title, sfDefaultStyle, NULL);
     renderer->sprite = sfSprite_create();
     renderer->view = sfView_create();

src/ui/button.c

@@ -0,0 +1,3 @@
+//
+// Created by anonymus-raccoon on 2/21/20.
+//

src/ui/setup_ui.c

@@ -0,0 +1,88 @@
+//
+// Created by anonymus-raccoon on 2/21/20.
+//
+
+#include "engine.h"
+#include "data.h"
+#include "xml.h"
+#include "my.h"
+#include "components/transform_component.h"
+#include "components/renderer.h"
+#include "components/fixed_to_cam_component.h"
+#include "systems/sfml_renderer_system.h"
+#include <malloc.h>
+
+gc_entity *new_text(gc_engine *engine, gc_scene *scene, node *n)
+{
+	gc_entity *entity = entity_create();
+
+	entity->add_component(entity, new_component(&transform_component,
+		(gc_vector2){0, 0},
+		(gc_vector2){0, 0}));
+	entity->add_component(entity, new_component(&renderer_component,
+		GC_TXTREND,
+		xml_getproperty(n, "text"),
+		scene->get_data(scene, "font", NULL)));
+	entity->add_component(entity, new_component(&fixed_to_cam,
+		(gc_vector2){
+		xml_getintprop(n, "x"),
+		xml_getintprop(n, "y")
+		},
+		true, true, false));
+	return (entity);
+}
+
+gc_entity *background_from_text(gc_engine *engine, gc_scene *scene, node *n, \
+gc_text *text)
+{
+	gc_entity *entity = entity_create();
+	struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
+	sfTexture *texture = scene->get_data(scene, "sprite", "button_background");
+
+	if (!renderer)
+		return (NULL);
+	if (!texture)
+		my_printf("No texture defined for the button_background.\n");
+	entity->add_component(entity, new_component(&transform_component,
+		(gc_vector2){0, 0},
+		renderer->get_text_size(renderer, text)));
+	entity->add_component(entity, new_component(&renderer_component,
+		GC_TEXTUREREND,
+		texture,
+		(sfIntRect){0, 0, -1, -1}));
+	entity->add_component(entity, new_component(&fixed_to_cam,
+		(gc_vector2){
+		xml_getintprop(n, "x"),
+		xml_getintprop(n, "y")
+		}, true, true, false));
+	return (entity);
+}
+
+gc_list *new_button(gc_engine *engine, gc_scene *scene, node *n)
+{
+	gc_list *entities = NULL;
+	gc_text text = (gc_text){
+		xml_gettempprop(n, "text"),
+		scene->get_data(scene, "font", NULL)
+	};
+
+	LISTADD(entities, background_from_text(engine, scene, n, &text));
+	LISTADD(entities, new_text(engine, scene, n));
+	return (entities);
+}
+
+gc_data *button_make(gc_engine *engine, gc_scene *scene, node *n)
+{
+	gc_data *data = malloc(sizeof(*data));
+
+	data->name = "button";
+	data->type = "ui";
+	data->destroy = NULL;
+	data->custom = new_button(engine, scene, n);
+	return (data);
+}
+
+void ui_setup(gc_engine *engine)
+{
+	engine->add_dataloader(engine, "button", &button_make);
+}