added mouse move component

include/components/input_component.h

@@ -0,0 +1,18 @@
+//
+// Created by anonymus-raccoon on 3/2/20.
+//
+
+#ifndef _INPUT_COMPONENT_H_
+#define _INPUT_COMPONENT_H_
+
+#include "component.h"
+
+struct input_component
+{
+	gc_component base;
+	int value;
+};
+
+extern const struct input_component input_component;
+
+#endif //_INPUT_COMPONENT_H_

include/engine.h

@@ -91,5 +91,6 @@ int engine_use_sfml(gc_engine *engine, const char *title, int framerate);
 gc_vector2 engine_get_cursor_pos(gc_engine *engine);
 
 #define GETSYS(x) ((struct x *)engine->get_system(engine, #x))
+#define GETSYS(engine, x) ((struct x *)engine->get_system(engine, #x))
 
 #endif

include/sfml_renderer.h

@@ -27,8 +27,9 @@ void sfmlrenderer_draw_texture(struct sfml_renderer_system *renderer, \
 struct transform_component *tra, gc_entity *entity, gc_sprite *sprite);
 void sfmlrenderer_draw_anim(struct sfml_renderer_system *renderer, \
 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_txt(gc_engine *engine, \
+struct sfml_renderer_system *renderer, struct transform_component *tra, \
+gc_text *txt);
 void sfmlrenderer_draw_tilemap(struct sfml_renderer_system *this, \
 struct vertex_component *txt);
 
@@ -45,6 +46,8 @@ void sfml_play_music(void *music);
 void sfml_stop_music(gc_engine *engine);
 void sfml_resize(gc_engine *engine, gc_vector2 size);
 gc_vector2 sfml_get_screen_size(gc_engine *engine);
+gc_vector2 sfml_engine_get_cursor_pos(gc_engine *engine);
+
 void entities_update_to_cam(gc_scene *scene, \
 struct sfml_renderer_system *renderer, struct camerafollow_system *cam);
 void entities_update_to_cam_size(gc_scene *scene, gc_vector2 size);

include/systems/sfml_renderer_system.h

@@ -25,6 +25,8 @@ struct sfml_renderer_system
     sfVertexArray *vertices;
     sfRenderStates *states;
     gc_vector2 (*get_text_size)(sf_renderer *this, gc_text *text);
+    bool is_fullscreen;
+    gc_vector2i resolution;
 };
 
 gc_system *gc_new_sfml_renderer(gc_engine *engine, \

include/text.h

@@ -11,5 +11,7 @@ typedef struct gc_text
 {
     char *text;
     void *font;
+    int size;
     int color;
+    bool resize;
 } gc_text;

include/xml.h

@@ -42,4 +42,6 @@ float xml_getfloatprop(node *n, const char *key);
 int xml_getchildcount(node *n);
 int xml_getchildcount_filtered(node *n, char *name);
 bool xml_propcontains(node *n, const char *key, const char *tofind);
+bool xml_getbool(node *n, const char *key, bool default_value);
+char *xml_gettmpstring(node *n, const char *key, char *def);
 void xml_destroy(node *n);

src/components/input_component.c

@@ -0,0 +1,49 @@
+//
+// Created by anonymus-raccoon on 3/2/20.
+//
+
+#include "xml.h"
+#include "entity.h"
+#include "scene.h"
+#include "components/input_component.h"
+
+static void ctr(void *component, va_list args)
+{
+	struct input_component *cmp = (struct input_component *)component;
+
+	cmp->value = 0;
+}
+
+static void fdctr(gc_entity *entity, gc_scene *scene, void *component, node *n)
+{
+	struct input_component *cmp = (struct input_component *)component;
+
+	cmp->value = 0;
+	(void)scene;
+	(void)entity;
+}
+
+static void dtr(void *component)
+{
+	(void)component;
+}
+
+static char *serialize(void *component)
+{
+	(void)component;
+	return (NULL);
+}
+
+const struct input_component input_component = {
+	base: {
+		name: "input_component",
+		size: sizeof(struct input_component),
+		dependencies: (char *[]){ NULL },
+		ctr: &ctr,
+		fdctr: &fdctr,
+		dtr: &dtr,
+		serialize: &serialize,
+		destroy: &component_destroy
+	},
+	value: 0
+};

src/components/renderers/text_renderer.c

@@ -34,7 +34,12 @@ void text_ctr(struct renderer *cmp, va_list args)
     cmp->data = gctext;
     gctext->text = va_arg(args, char *);
     gctext->font = va_arg(args, sfFont *);
+    gctext->size = va_arg(args, int);
     gctext->color = color_from_text(va_arg(args, char *));
+    gctext->resize = va_arg(args, int);
+
+    if (gctext->size <= 0)
+    	gctext->size = 30;
 }
 
 void text_fdctr(gc_scene *scene, struct renderer *cmp, node *n)
@@ -48,4 +53,7 @@ void text_fdctr(gc_scene *scene, struct renderer *cmp, node *n)
     if (!gctext->text)
         return;
     gctext->font = scene->get_data(scene, "font", xml_getproperty(n, "src"));
+	gctext->size = 30;
+	gctext->color = *(int *)&sfWhite;
+	gctext->resize = true;
 }

src/engine/engine_component_builder.c

@@ -21,6 +21,7 @@
 #include "components/vertex_component.h"
 #include <stdlib.h>
 #include "components/clickable_component.h"
+#include "components/input_component.h"
 
 void engine_add_component(gc_engine *engine, const void *component)
 {
@@ -45,4 +46,5 @@ void engine_add_buildin_components(gc_engine *engine)
     engine->add_component(engine, &collision_component);
     engine->add_component(engine, &clickable_component);
     engine->add_component(engine, &vertex_component);
+    engine->add_component(engine, &input_component);
 }

src/sfml_renderer/sfml_drawer.c

@@ -73,15 +73,20 @@ gc_entity *entity, gc_animholder *holder, float dtime)
     sfmlrenderer_draw_texture(renderer, tra, entity, holder->sprite);
 }
 
-void sfmlrenderer_draw_txt(struct sfml_renderer_system *renderer, \
-struct transform_component *tra, gc_text *txt)
+void sfmlrenderer_draw_txt(gc_engine *engine, \
+struct sfml_renderer_system *renderer, struct transform_component *tra, \
+gc_text *txt)
 {
 	sfFloatRect bounds;
+	float size = 1;
 
+	if (txt->resize)
+		size = 800 / engine->get_screen_size(engine).x;
 	sfText_setString(renderer->text, txt->text);
     if (!txt->font)
     	my_printf("%s has a font not loaded. Rendering impossible.", txt->font);
     sfText_setFont(renderer->text, txt->font);
+    sfText_setCharacterSize(renderer->text, txt->size / size);
     bounds = sfText_getLocalBounds(renderer->text);
     sfText_setColor(renderer->text, *(sfColor*)&txt->color);
     sfText_setPosition(renderer->text, (sfVector2f){

src/sfml_renderer/sfml_events.c

@@ -13,14 +13,14 @@
 
 void sfml_handle_events(gc_engine *engine)
 {
-	struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
+	struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
 	sfEvent event;
 	sfVector2i mousePos;
 	sfVector2f pos;
 
-	while (sfRenderWindow_pollEvent(renderer->window, &event)) {
+	while (sfRenderWindow_pollEvent(rend->window, &event)) {
 		if (event.type == sfEvtClosed)
-			sfRenderWindow_close(renderer->window);
+			sfRenderWindow_close(rend->window);
 		if (event.type == sfEvtResized)
 			engine->on_resize(engine, (gc_vector2)
 			{
@@ -28,25 +28,25 @@ void sfml_handle_events(gc_engine *engine)
 				event.size.height
 			});
 		if (event.type == sfEvtMouseButtonReleased) {
-			mousePos = sfMouse_getPosition(renderer->window);
-			pos = sfRenderWindow_mapPixelToCoords(renderer->window, mousePos, renderer->view);
+			mousePos = sfMouse_getPosition(rend->window);
+			pos = sfRenderWindow_mapPixelToCoords(rend->window, mousePos, rend->view);
 			pos.y *= -1;
 			clickable_onclick(engine, (gc_vector2){pos.x, pos.y});
 		}
 	}
 }
 
-gc_vector2 engine_get_cursor_pos(gc_engine *engine)
+gc_vector2 sfml_engine_get_cursor_pos(gc_engine *engine)
 {
 	sfMouseMoveEvent mouse;
-	sfMouse_getPositionRenderWindow(GETSYS(sfml_renderer_system));
+	sfMouse_getPositionRenderWindow(GETSYS(engine, sfml_renderer_system));
 }
 
 void sfml_resize(gc_engine *engine, gc_vector2 size)
 {
-	struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
+	struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
 
-	sfView_setSize(renderer->view, (sfVector2f){
+	sfView_setSize(rend->view, (sfVector2f){
 		size.x,
 		size.y
 	});
@@ -55,8 +55,8 @@ void sfml_resize(gc_engine *engine, gc_vector2 size)
 
 gc_vector2 sfml_get_screen_size(gc_engine *engine)
 {
-	struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
-	sfVector2u size = sfRenderWindow_getSize(renderer->window);
+	struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
+	sfVector2u size = sfRenderWindow_getSize(rend->window);
 
 	return (gc_vector2){size.x, size.y};
 }

src/sfml_renderer/sfml_functions.c

@@ -15,18 +15,18 @@
 
 bool sfml_is_open(gc_engine *engine)
 {
-    struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
+    struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
 
     if (engine->should_close)
         return (false);
-    return (sfRenderWindow_isOpen(renderer->window));
+    return (sfRenderWindow_isOpen(rend->window));
 }
 
 bool sfml_has_focus(gc_engine *engine)
 {
-    struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
+    struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
 
-    return (sfRenderWindow_hasFocus(renderer->window));
+    return (sfRenderWindow_hasFocus(rend->window));
 }
 
 bool sfml_is_keypressed(int key)
@@ -36,17 +36,17 @@ bool sfml_is_keypressed(int key)
 
 void sfml_draw(gc_engine *engine)
 {
-    struct sfml_renderer_system *renderer = GETSYS(sfml_renderer_system);
-    struct camerafollow_system *cam = GETSYS(camerafollow_system);
+    struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
+    struct camerafollow_system *cam = GETSYS(engine, camerafollow_system);
 
     if (cam) {
-        sfView_setCenter(renderer->view, (sfVector2f){
+        sfView_setCenter(rend->view, (sfVector2f){
             cam->cam_pos.x,
             -cam->cam_pos.y
         });
-        sfRenderWindow_setView(renderer->window, renderer->view);
-        entities_update_to_cam(engine->scene, renderer, cam);
+        sfRenderWindow_setView(rend->window, rend->view);
+        entities_update_to_cam(engine->scene, rend, cam);
     }
-    sfRenderWindow_display(renderer->window);
-    sfRenderWindow_clear(renderer->window, sfBlack);
+    sfRenderWindow_display(rend->window);
+    sfRenderWindow_clear(rend->window, sfBlack);
 }

src/systems/fixed_to_cam_pseudosystem.c

@@ -51,8 +51,12 @@ void entities_update_to_cam_size(gc_scene *scene, gc_vector2 size)
         if (!tra)
             continue;
         tra->size = (gc_vector2) {
-            fc->per_w != 0 ? size.x * fc->size_x / 100 : tra->size.x,
-			fc->per_h != 0 ? size.y * fc->size_y / 100 : tra->size.y
+            fc->per_w ? size.x * fc->size_x / 100 : tra->size.x,
+			fc->per_h ? size.y * fc->size_y / 100 : tra->size.y
         };
+        if (fc->per_w && fc->size_x == 0)
+        	tra->size.x = tra->size.y;
+		if (fc->per_h && fc->size_y == 0)
+			tra->size.y = tra->size.x;
     }
 }

src/systems/sfml_renderer_system.c

@@ -44,7 +44,7 @@ gc_entity *entity, float dt)
         sfmlrenderer_draw_anim(rend, entity, (gc_animholder *)text->data, dt);
         break;
     case GC_TXTREND:
-        sfmlrenderer_draw_txt(rend, pos, (gc_text *)text->data);
+        sfmlrenderer_draw_txt(engine, rend, pos, (gc_text *)text->data);
         break;
     case GC_MAP:
         sfmlrenderer_draw_tilemap(rend, (struct vertex_component *)text->data);
@@ -53,11 +53,12 @@ gc_entity *entity, float dt)
         my_printf("Trying to render a texture with an unknown type.\n");
         break;
     }
-    (void)engine;
 }
 
-void sfml_setup_options(gc_engine *engine)
+void sfml_setup_options(struct sfml_renderer_system *this, gc_engine *engine)
 {
+	this->is_fullscreen = false;
+	this->resolution = (gc_vector2i){800, 600};
     engine->is_open = &sfml_is_open;
     engine->has_focus = &sfml_has_focus;
     engine->is_keypressed = &sfml_is_keypressed;
@@ -67,6 +68,7 @@ void sfml_setup_options(gc_engine *engine)
     engine->stop_music = &sfml_stop_music;
     engine->on_resize = &sfml_resize;
     engine->get_screen_size = &sfml_get_screen_size;
+    engine->get_cursor_pos = &sfml_engine_get_cursor_pos;
 }
 
 void sfmlrend_ctr(void *rend, va_list list)
@@ -91,7 +93,7 @@ void sfmlrend_ctr(void *rend, va_list list)
     sfView_setSize(renderer->view, (sfVector2f){800, 600});
     sfView_setCenter(renderer->view, (sfVector2f){400, -300});
     sfRenderWindow_setView(renderer->window, renderer->view);
-    sfml_setup_options(engine);
+    sfml_setup_options(renderer, engine);
 }
 
 void sfmlrend_dtr(void *system)

src/ui/button.c

@@ -14,30 +14,30 @@
 #include "systems/sfml_renderer_system.h"
 #include "ui.h"
 #include <malloc.h>
+#include "components/input_component.h"
 
 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");
+	struct sfml_renderer_system *rend = GETSYS(engine, sfml_renderer_system);
+	char *texture_name = xml_gettmpstring(n, "sprite", "button_background");
+	sfTexture *texture = scene->get_data(scene, "sprite", texture_name);
+	gc_vector2i s = {xml_getintprop(n, "width"), xml_getintprop(n, "height")};
+	gc_vector2 ts = rend->get_text_size(rend, text);
 
-	if (!renderer)
+	if (!rend)
 		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)));
+		(gc_vector2){0, 0}, (gc_vector2){s.x ? s.x : ts.x, s.y ? s.y : ts.y}));
 	entity->add_component(entity, new_component(&renderer_component,
-		GC_TEXTUREREND,
-		texture,
-		(gc_int_rect){-1, -1, 0, 0}));
+		GC_TEXTUREREND, texture, (gc_int_rect){-1, -1, 0, 0}));
 	entity->add_component(entity, new_component(&fixed_to_cam,
-		(gc_vector2){
-		xml_getintprop(n, "x"),
-		xml_getintprop(n, "y")
-		}, true, true, 0, 0, false, false));
+		(gc_vector2){xml_getintprop(n, "x"),xml_getintprop(n, "y")},
+		true, true, s.x, s.y,
+		xml_propcontains(n, "width", "%"), xml_propcontains(n, "height", "%")));
 	return (entity);
 }
 
@@ -52,6 +52,10 @@ gc_list *new_button(gc_engine *engine, gc_scene *scene, node *n)
 
 	if (!background)
 		return (NULL);
+	if (xml_hasproperty(n, "background_id"))
+		background->id = xml_getintprop(n, "background_id");
+	if (xml_getbool(n, "input", false))
+		background->add_component(background, new_component(&input_component));
 	background->add_component(background, new_component(&clickable_component,
 		scene, xml_getproperty(n, "click")));
 	LISTADD(entities, background);

src/ui/setup_ui.c

@@ -5,33 +5,33 @@
 #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 "components/clickable_component.h"
 #include "systems/sfml_renderer_system.h"
 #include "ui.h"
 #include <malloc.h>
 
 gc_entity *new_text(gc_engine *engine, gc_scene *scene, node *n)
 {
-	gc_entity *entity = entity_create();
+	gc_entity *entity;
 
+	if (xml_hasproperty(n, "text_id"))
+		entity = entity_create_with_id(xml_getintprop(n, "text_id"));
+	else
+		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), xml_gettempprop(n, "color")));
+		scene->get_data(scene, "font", NULL),
+		xml_getintprop(n, "size"),
+		xml_gettempprop(n, "color"), xml_getbool(n, "resize", true)));
 	entity->add_component(entity, new_component(&fixed_to_cam,
-		(gc_vector2){
-		xml_getintprop(n, "x"),
-		xml_getintprop(n, "y")
-		},
-		xml_propcontains(n, "x", "%"),
-		xml_propcontains(n, "y", "%"),
+		(gc_vector2){xml_getintprop(n, "x"),xml_getintprop(n, "y")},
+		xml_propcontains(n, "x", "%"), xml_propcontains(n, "y", "%"),
 		0, 0, false, false));
 	return (entity);
 }
@@ -43,21 +43,15 @@ gc_entity *new_sprite(gc_engine *engine, gc_scene *scene, node *n)
 	sfTexture *texture = scene->get_data(scene, "sprite", src);
 
 	entity->add_component(entity, new_component(&transform_component,
-		(gc_vector2){0, 0}, (gc_vector2){
-		xml_getintprop(n, "width"),
-		xml_getintprop(n, "height")}));
+		(gc_vector2){0, 0},
+		(gc_vector2){xml_getintprop(n, "width"),xml_getintprop(n, "height")}));
 	entity->add_component(entity, new_component(&renderer_component,
-		GC_TEXTUREREND,
-		texture,
-		(sfIntRect){0, 0, -1, -1}));
+		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") },
-		xml_propcontains(n, "x", "%"),
-		xml_propcontains(n, "y", "%"),
+		(gc_vector2){xml_getintprop(n, "x"),xml_getintprop(n, "y") },
+		xml_propcontains(n, "x", "%"), xml_propcontains(n, "y", "%"),
 		xml_getintprop(n, "width"), xml_getintprop(n, "height"),
-		xml_propcontains(n, "width", "%"),
-		xml_propcontains(n, "height", "%")));
+		xml_propcontains(n, "width", "%"), xml_propcontains(n, "height", "%")));
 	return (entity);
 }