sprites on screen yay

src/game/GAME_COMMON.h

@@ -1,15 +1,21 @@
 #pragma once
 
-#include "../engine/event.h"
-#include "../engine/renderer.h"
-#include "../engine/window.h"
-#include "../engine/sdl.h"
-#include "../engine/tick.h"
-
+#include "state/STATE_COMMON.h"
 #include "ecs/ECS_COMMON.h"
 
+#include "../engine/renderer.h"
+#include "../engine/tick.h"
+#include "../engine/atlas.h"
+#include "../engine/json.h"
+#include "../engine/file.h"
+#include "../engine/atlas.h"
+#include "../engine/sdl.h"
+#include "../engine/event.h"
+
 typedef struct Game
 {
+	State state;
+	Resources resources;
 	Renderer renderer;
 	Window window;
 	Event event;

src/game/ecs/ECS_COMMON.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "component/COMPONENT_COMMON.h"
+
 #include "../../engine/vector.h"
 
 #define ECS_FUNCTION_COUNT ECS_FUNCTION_DRAW + 1
@@ -11,16 +13,9 @@ typedef enum ECSFunctionType
 	ECS_FUNCTION_DRAW
 } ECSFunctionType;
 
-#define ECS_COMPONENT_COUNT ECS_COMPONENT_SPRITE + 1
-typedef enum ECSComponentType
-{
-	ECS_COMPONENT_SPRITE
-} ECSComponentType;
-
 typedef struct ECS ECS;
 typedef struct Game Game;
 
-typedef void (*ECSRegister)(ECS*);
 typedef void (*ECSFunction)(void*, ECS*);
 
 typedef struct ECSsystem

src/game/ecs/component/COMPONENT_COMMON.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../../../COMMON.h"
+
+#define ECS_COMPONENT_COUNT ECS_COMPONENT_SPRITE + 1
+typedef enum ECSComponentType
+{
+	ECS_COMPONENT_SPRITE
+} ECSComponentType;

src/game/ecs/component/component_sprite.c

@@ -1,66 +1,133 @@
 #include "component_sprite.h"
 
-static void _tick(ComponentSprite* self, ECS* ecs);
-static void _draw(ComponentSprite* self, ECS* ecs);
-
-const ECSComponentInfo COMPONENT_SPRITE_INFO = 
+/* Returns sprite rectangle. */
+void
+component_sprite_rectangle_get(ComponentSprite* self, vec4 rectangle)
 {
-	.system = 
-	{
-		.functions = 
-		{ 
-			NULL, 
-			NULL, 
-			(ECSFunction)_tick, 
-			(ECSFunction)_draw
-		}
-	},
-	.type = ECS_COMPONENT_SPRITE,
-	.size = sizeof(ComponentSprite)
-};
-
-/* Ticks sprite component. */
-static void
-_tick(ComponentSprite* self, ECS* ecs)
-{
-
-
-
+	vec2 size;
+	vec2 origin;
+	vec2 difference;
 
+	component_sprite_size_get(self, size);
 
+	rectangle[0] = self->position[0];
+	rectangle[1] = self->position[1];
+	rectangle[2] = self->position[0] + size[0];
+	rectangle[3] = self->position[1] + size[1];
 }
 
-/* Draws sprite component. */
-static void
-_draw(ComponentSprite* self, ECS* ecs)
+
+/* Sets sprite component info, additionally given atlas rows/columns. */
+void
+component_sprite_atlas_init
+(
+	ComponentSprite* self, 
+	Texture texture, 
+	ShaderType shader,
+	OriginType origin,
+	const ivec2 frameSize,
+	const ivec2 atlasSize,
+	const vec2 size, 
+	const vec4 color, 
+	const vec3 position
+)
 {
+	self->shader = shader;
+	self->origin = origin;
 
+	atlas_init(&self->atlas, texture, frameSize, atlasSize);
 
-
-
-
+	glm_vec2_copy((f32*)size, self->size);
+	glm_vec3_copy((f32*)position, self->position);
+	glm_vec4_copy((f32*)color, self->color);
 }
 
-/* Initializes sprite component. */
+/* Sets sprite component info. */
 void
 component_sprite_init
 (
-	ComponentSprite* self
-
-
-
-
-
+	ComponentSprite* self, 
+	Texture texture, 
+	ShaderType shader, 
+	OriginType origin, 
+	const vec2 size, 
+	const vec4 color, 
+	const vec3 position
 )
 {
+	ivec2 atlasSize;
 
+	glm_ivec2_one(atlasSize);
 
-
-
-
-
-
-
-
-
+	component_sprite_atlas_init
+	(
+		self, 
+		texture, 
+		shader, 
+		origin,
+		texture.size,
+		atlasSize,
+		size,
+		color, 
+		position
+	);
+}
+
+/* Gets the true size of a sprite, accounting for scaling. */
+void
+component_sprite_size_get(ComponentSprite* self, vec2 size)
+{
+	glm_vec2_copy(self->size, size);
+	glm_vec2_scale(size, self->scale, size);
+}
+
+/* Ticks sprite component. */
+void
+component_sprite_add(ComponentSprite* self, ECS* ecs)
+{
+	memset(self, '\0', sizeof(ComponentSprite));
+
+	self->scale = COMPONENT_SPRITE_SCALE_DEFAULT;
+}
+
+/* Ticks sprite component. */
+void
+component_sprite_tick(ComponentSprite* self, ECS* ecs)
+{
+	vec4 rectangle;
+
+	component_sprite_rectangle_get(self, rectangle);
+}
+
+/* Draws sprite component. */
+void
+component_sprite_draw(ComponentSprite* self, ECS* ecs)
+{
+	mat4 model;
+	vec2 size;
+	vec2 origin;
+	vec3 position;
+	vec3 modelOrigin;
+
+	component_sprite_size_get(self, size);
+	
+	glm_vec3_copy(self->position, position);
+
+	modelOrigin[0] = 0.0f;
+	modelOrigin[1] = 0.0f;
+	modelOrigin[2] = 0.0f;
+
+	glm_mat4_identity(model);
+	glm_translate(model, position);
+	glm_rotate_at(model, modelOrigin, self->rotation, (f32*)COMPONENT_SPRITE_ROTATION_AXIS);
+
+	texture_quad_draw
+	(
+		&ecs->game->renderer, 
+		&self->atlas, 
+		&ecs->game->resources.shaders[self->shader], 
+		model, 
+		size, 
+		self->color
+	);
 }

src/game/ecs/component/component_sprite.h

@@ -1,12 +1,19 @@
 #pragma once
 
 #include "../../GAME_COMMON.h"
+#include "../../render/texture_quad.h"
+#include "../ecs_entity.h"
 
-extern ECSComponentInfo COMPONENT_SPRITE_INFO;
+#define COMPONENT_SPRITE_SCALE_DEFAULT 1.0f
+
+static const vec3 COMPONENT_SPRITE_ROTATION_AXIS = {0.0f, 0.0f, 1.0f};
 
 typedef struct ComponentSprite
 {
 	u32 id;
+	Atlas atlas;
+	ShaderType shader;
+	OriginType origin;
 	vec2 size;
 	vec3 offset;
 	vec3 position;
@@ -15,4 +22,52 @@ typedef struct ComponentSprite
 	f32 rotation;
 } ComponentSprite;
 
-void component_sprite_init(ComponentSprite* self);
+void component_sprite_rectangle_get(ComponentSprite* self, vec4 rectangle);
+
+void component_sprite_atlas_init
+(
+	ComponentSprite* self, 
+	Texture texture, 
+	ShaderType shader,
+	OriginType origin,
+	const ivec2 frameSize,
+	const ivec2 atlasSize,
+	const vec2 size, 
+	const vec4 color, 
+	const vec3 position
+);
+
+void
+component_sprite_init
+(
+	ComponentSprite* self, 
+	Texture texture, 
+	ShaderType shader, 
+	OriginType origin, 
+	const vec2 size, 
+	const vec4 color, 
+	const vec3 position
+);
+
+void component_sprite_size_get(ComponentSprite* self, vec2 size);
+void component_sprite_add(ComponentSprite* self, ECS* ecs);
+void component_sprite_tick(ComponentSprite* self, ECS* ecs);
+void component_sprite_draw(ComponentSprite* self, ECS* ecs);
+
+static const ECSComponentInfo COMPONENT_SPRITE_INFO = 
+{
+	.system = 
+	{
+		.functions = 
+		{ 
+			(ECSFunction)component_sprite_add, 
+			NULL, 
+			(ECSFunction)component_sprite_tick, 
+			(ECSFunction)component_sprite_draw
+		}
+	},
+	.type = ECS_COMPONENT_SPRITE,
+	.size = sizeof(ComponentSprite)
+};
+
+

src/game/ecs/ecs.c

@@ -41,7 +41,7 @@ ecs_init(ECS* self, Game* game)
 		ecs_component_list_init(&self->lists[i], self, ECS_COMPONENT_INFO[i]);
 }
 
-/* Clears ECS. */
+/* Clears ECS (removes all components, but does not free the greater ECS struct). */
 void
 ecs_clear(ECS* self)
 {

src/game/ecs/ecs.h

@@ -1,8 +1,11 @@
 #pragma once
 
-#include "ecs_component_list.h"
 #include "component/component_sprite.h"
 
+#include "entity/entity_test.h"
+
+#include "ecs_component_list.h"
+
 static const ECSComponentInfo ECS_COMPONENT_INFO[ECS_COMPONENT_COUNT] = 
 {
 	COMPONENT_SPRITE_INFO

src/game/ecs/ecs_component.c

@@ -0,0 +1,48 @@
+#include "ecs_component.h"
+
+/* Adds and returns a new component, executing system's add function. */
+void*
+ecs_component_add(ECS* ecs, ECSComponentType type, u32 id)
+{
+	void* component;
+	ECSFunction add;
+
+	component = vector_push(&ecs->lists[type].components, NULL);
+
+	add = ecs->lists[type].system.functions[ECS_FUNCTION_ADD];
+
+	if (add)
+		add(component, ecs);
+
+	/* all components have id as their first member so this is ok */
+	memcpy(component, (void*)&id, sizeof(u32));
+
+	return component;
+}
+
+/* Deletes a component, given a valid id. */
+void
+ecs_component_delete(ECS* ecs, ECSComponentType type, u32 id)
+{
+	for (s32 i = 0; i < (s32)ecs->lists[type].components.count; i++)
+	{
+		u32 checkID;
+		void* component;
+
+		component = vector_get(&ecs->lists[type].components, i);
+
+		memcpy(&checkID, component, sizeof(u32));
+
+		if (checkID == id)
+		{
+			ECSFunction delete;
+
+			delete = ecs->lists[type].system.functions[ECS_FUNCTION_DELETE];
+
+			if (delete)
+				delete(component, ecs);
+
+			vector_remove(&ecs->lists[type].components, i);
+		}
+	}
+}

src/game/ecs/ecs_component.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "ECS_COMMON.h"
+
+void* ecs_component_add(ECS* ecs, ECSComponentType type, u32 id);
+void ecs_component_delete(ECS* ecs, ECSComponentType type, u32 id);

src/game/ecs/ecs_component_list.c

@@ -7,7 +7,7 @@ ecs_component_list_init(ECSComponentList* self, ECS* ecs, ECSComponentInfo info)
 	self->ecs = ecs;
 	self->type = info.type;
 	self->system = info.system;
-	vector_init(&self->vector, info.size);
+	vector_init(&self->components, info.size);
 }
 
 /* Executes a function on a component list. */
@@ -22,8 +22,8 @@ ecs_component_list_function(ECSComponentList* self, ECSFunctionType type)
 	if (!function)
 		return;
 
-	for (s32 i = 0; i < self->components.count; i++)
-		function(vector_get(i), self->ecs);
+	for (s32 i = 0; i < (s32)self->components.count; i++)
+		function(vector_get(&self->components, i), self->ecs);
 }
 
 /* Clears all elements in a component list. */

src/game/ecs/ecs_entity.c

@@ -0,0 +1,18 @@
+#include "ecs_entity.h"
+
+/* Returns a new entity ID. */
+u32
+ecs_entity_add(ECS* self)
+{
+	self->nextID++;
+
+	return self->nextID;
+}
+
+/* Removes all components associated with an entity. */
+void
+ecs_entity_delete(ECS* self, u32 id)
+{
+	for (s32 i = 0; i < ECS_COMPONENT_COUNT; i++)
+		ecs_component_delete(self, (ECSComponentType)i, id);
+}

src/game/ecs/ecs_entity.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "ecs_component.h"
+
+u32 ecs_entity_add(ECS* ecs);
+void ecs_entity_delete(ECS* ecs, u32 id);

src/game/ecs/entity/entity_test.c

@@ -0,0 +1,21 @@
+#include "entity_test.h"
+
+/* Initializes a test entity. */
+void
+entity_test_init(ECS* ecs, u32 id)
+{
+	ComponentSprite* sprite;
+
+	sprite = ecs_component_add(ecs, ECS_COMPONENT_SPRITE, id);
+
+	component_sprite_init
+	(
+		sprite,
+		ecs->game->resources.textures[TEXTURE_TEST],
+		SHADER_TEXTURE_QUAD,
+		ORIGIN_CENTER,
+		(f32*)TEST_SIZE,
+		COLOR_OPAQUE,
+		(f32*)TEST_POSITION
+	);
+}

src/game/ecs/entity/entity_test.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../ecs_component.h"
+#include "../component/component_sprite.h"
+
+static const vec2 TEST_SIZE = {50.0f, 50.0f};
+static const vec3 TEST_POSITION = {50.0f, 50.0f, 0.0f};
+
+void entity_test_init(ECS* ecs, u32 id);

src/game/game.c

@@ -10,6 +10,10 @@ static void _game_quit(Game* self);
 static void
 _game_quit(Game* self)
 {
+	state_free(&self->state);
+
+	ecs_free(&self->ecs);
+
 	window_free(&self->window);
 
 	sdl_quit();
@@ -23,7 +27,7 @@ _game_quit(Game* self)
 static void
 _game_tick(Game* self)
 {
-	renderer_update(&self->renderer);
+	ecs_tick(&self->ecs);
 
 	event_update(&self->event);
 
@@ -35,9 +39,13 @@ _game_tick(Game* self)
 static void
 _game_draw(Game* self)
 {
-	renderer_present(&self->renderer);
+	renderer_update(&self->renderer);
 
 	renderer_clear(&self->renderer);
+
+	ecs_draw(&self->ecs);
+
+	renderer_present(&self->renderer);
 }
 
 /* Initializes game. */
@@ -46,6 +54,8 @@ game_init(Game* self)
 {
 	memset(self, '\0', sizeof(Game));
 
+	resource_shader_read(&self->resources);
+
 	sdl_init();
 
 	window_init
@@ -56,9 +66,12 @@ game_init(Game* self)
 		WINDOW_FLAGS
 	);
 
-	renderer_init(&self->renderer, &self->window);
-
+	renderer_init(&self->renderer, &self->window, CAMERA_ORTHOGRAPHIC);
 	renderer_clear_color_set(&self->renderer, (f32*)RENDERER_CLEAR_COLOR);
+
+	ecs_init(&self->ecs, self);
+
+	state_init(&self->state, self, STATE_PLAY);
 }
 
 /* Main game loop. */

src/game/game.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include "ecs/ecs.h"
+#include "state/state.h"
 
-#define WINDOW_TITLE "Sneed"
+#define WINDOW_TITLE "Calamity Cobra in 'A Sweeter Reprise'"
 #define WINDOW_FLAGS SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
 
-static const ivec2 WINDOW_SIZE = {800, 600};
+static const ivec2 WINDOW_SIZE = {1280, 720};
 static const vec4 RENDERER_CLEAR_COLOR = {0.0f, 0.0f, 0.0f, 1.0f};
 
 void game_init(Game* game);

src/game/render/RENDER_COMMON.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../../engine/atlas.h"
+#include "../../engine/renderer.h"
+#include "../../engine/shader.h"

src/game/render/texture_quad.c

@@ -0,0 +1,62 @@
+#include "texture_quad.h"
+
+/* Draws a textured quad. */
+void
+texture_quad_draw(Renderer* renderer, Atlas* atlas, Shader* shader, mat4 model, vec2 size, vec4 color)
+{
+	vec2 uvMin;
+	vec2 uvMax;
+	mat4 view;
+	mat4 projection;
+
+	atlas_uv_get(atlas, uvMin, uvMax);
+
+	f32 vertices[4][5] = 
+	{
+		{0.0f   , 0.0f   , 0.0f, uvMin[0], uvMin[1]},
+		{0.0f   , size[1], 0.0f, uvMin[0], uvMax[1]},
+		{size[0], size[1], 0.0f, uvMax[0], uvMax[1]},
+		{size[0], 0.0f   , 0.0f, uvMax[0], uvMin[1]},
+	};
+
+	u32 indices[2][3] = 
+	{
+		{1, 2, 3},
+		{0, 1, 3}
+	};
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+
+	camera_view_get(&renderer->camera, view);
+	camera_projection_get(&renderer->camera, projection);
+
+	model[3][0] = 25.0f;
+	model[3][1] = 25.0f;
+
+	vao_bind(&renderer->vao);
+
+	vbo_bind(&renderer->vbo);
+	vbo_buffer(&renderer->vbo, sizeof(vertices), vertices);
+
+	vbo_bind(&renderer->ebo);
+	vbo_buffer(&renderer->ebo, sizeof(indices), indices);
+
+	vertex_attribute_set(0, 3, GL_FLOAT, 5 * sizeof(f32), 0);
+	vertex_attribute_set(1, 2, GL_FLOAT, 5 * sizeof(f32), 3 * sizeof(f32));
+
+	vao_bind(&renderer->vao);
+
+	renderer_shader_use(renderer, shader);
+
+	shader_uniform_mat4_set(shader, TEXTURE_QUAD_UNIFORM_VIEW, view);
+	shader_uniform_mat4_set(shader, TEXTURE_QUAD_UNIFORM_PROJECTION, projection);
+	shader_uniform_mat4_set(shader, TEXTURE_QUAD_UNIFORM_MODEL, model);
+	shader_uniform_vec4_set(shader, TEXTURE_QUAD_UNIFORM_COLOR, color);
+	shader_uniform_texture_set(shader, TEXTURE_QUAD_UNIFORM_TEXTURE, &atlas->texture, 0);
+
+	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+	
+	vao_unbind();
+}	

src/game/render/texture_quad.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "RENDER_COMMON.h"
+
+#define TEXTURE_QUAD_UNIFORM_COLOR "uColor"
+#define TEXTURE_QUAD_UNIFORM_MODEL "uModel"
+#define TEXTURE_QUAD_UNIFORM_PROJECTION "uProjection"
+#define TEXTURE_QUAD_UNIFORM_TEXTURE "uTexture"
+#define TEXTURE_QUAD_UNIFORM_VIEW "uView"
+
+void texture_quad_draw(Renderer* renderer, Atlas* atlas, Shader* shader, mat4 model, vec2 size, vec4 color); 

src/game/render/triangle.c

@@ -0,0 +1,26 @@
+#include "triangle.h"
+
+/* Draws a triangle. */
+void 
+triangle_draw(Renderer* renderer, Shader* shader)
+{
+	f32 vertices[] = {
+	    -0.5f, -0.5f, 0.0f,
+	     0.5f, -0.5f, 0.0f,
+	     0.0f,  0.5f, 0.0f
+	};  
+
+	vao_bind(&renderer->vao);
+
+	vbo_bind(&renderer->vbo);
+	renderer->vbo.isDynamic = false;
+	vbo_buffer(&renderer->vbo, sizeof(vertices), vertices);
+
+	vertex_attribute_set(0, 3, GL_FLOAT, 3 * sizeof(f32), 0);
+
+	renderer_shader_use(renderer, shader);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	vao_unbind();
+}

src/game/render/triangle.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "RENDER_COMMON.h"
+
+void triangle_draw(Renderer* renderer, Shader* shader); 

src/game/resource/RESOURCE_COMMON.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "../../engine/file.h"
+#include "../../engine/shader.h"
+#include "../../engine/texture.h"
+
+#define SHADER_COUNT SHADER_TRIANGLE + 1
+typedef enum ShaderType
+{
+	SHADER_TEXTURE_QUAD,
+	SHADER_TRIANGLE
+} ShaderType;
+
+typedef struct ShaderPaths
+{
+	const char* vertex;
+	const char* fragment;
+} ShaderPaths;
+
+static const ShaderPaths SHADER_PATHS[SHADER_COUNT] =
+{
+	{
+		.vertex = "res/shader/texture_quad.vs",
+		.fragment = "res/shader/texture_quad.fs"
+	},
+	{
+		.vertex = "res/shader/triangle.vs",
+		.fragment = "res/shader/triangle.fs"
+	},
+
+};
+
+#define TEXTURE_COUNT TEXTURE_TEST + 1
+typedef enum TextureType
+{
+	TEXTURE_TEST
+} TextureType;
+
+static const char* TEXTURE_PATHS[TEXTURE_COUNT] =
+{
+	"res/gfx/test.png"
+};
+
+typedef struct Resources
+{
+	Shader shaders[SHADER_COUNT];
+	Texture textures[TEXTURE_COUNT];
+} Resources;

src/game/resource/resource_shader.c

@@ -0,0 +1,83 @@
+#include "resource_shader.h"
+
+typedef struct ShaderData
+{
+	char vertex[SHADER_BUFFER_SIZE];
+	char fragment[SHADER_BUFFER_SIZE];
+} ShaderData;
+
+static ShaderData shaderData[SHADER_COUNT];
+
+/* Reads in shader data. */
+void
+resource_shader_read(Resources* self)
+{
+	for (s32 i = 0; i < SHADER_COUNT; i++)
+	{
+		file_read
+		(
+			SHADER_PATHS[i].vertex, 
+			(void*)shaderData[i].vertex, 
+			SHADER_BUFFER_SIZE, 
+			"r"
+		); 
+		
+		file_read
+		(
+			SHADER_PATHS[i].fragment, 
+			(void*)shaderData[i].fragment, 
+			SHADER_BUFFER_SIZE, 
+			"r"
+		);
+	}
+}
+
+/* Initializes shader resource. */
+bool
+resource_shader_init(Resources* self, ShaderType type)
+{
+	if 
+	(
+		!shader_init
+		(
+			&self->shaders[type], 
+			shaderData[type].vertex,
+			shaderData[type].fragment
+		)
+	)
+	{
+		printf(STRING_RESOURCE_SHADER_ERROR, SHADER_PATHS[type].vertex, SHADER_PATHS[type].fragment);
+		return false;
+	}
+
+	printf(STRING_RESOURCE_SHADER_INIT, SHADER_PATHS[type].vertex, SHADER_PATHS[type].fragment);
+	return true;
+}
+
+/* Frees shader resources. */
+void
+resource_shader_free(Resources* self, ShaderType type)
+{
+	if (self->shaders[type].isInit)
+	{
+		shader_free(&self->shaders[type]);
+		printf(STRING_RESOURCE_SHADER_FREE, SHADER_PATHS[type].vertex, SHADER_PATHS[type].fragment);
+	}
+}
+
+
+/* Given an array of shader types, intializes each. */
+void
+resource_shader_state_init(Resources* self, const ShaderType* types, u32 count)
+{
+	for (s32 i = 0; i < (s32)count; i++)
+		resource_shader_init(self, types[i]);
+}
+
+/* Given an array of shader types, frees each. */
+void
+resource_shader_state_free(Resources* self, const ShaderType* types, u32 count)
+{
+	for (s32 i = 0; i < (s32)count; i++)
+		resource_shader_free(self, types[i]);
+}

src/game/resource/resource_shader.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "RESOURCE_COMMON.h"
+
+#define SHADER_BUFFER_SIZE 2048
+
+void resource_shader_free(Resources* self, ShaderType type);
+bool resource_shader_init(Resources* self, ShaderType type);
+void resource_shader_read(Resources* self);
+void resource_shader_state_free(Resources* self, const ShaderType* types, u32 count);
+void resource_shader_state_init(Resources* self, const ShaderType* types, u32 count);

src/game/resource/resource_texture.c

@@ -0,0 +1,44 @@
+#include "resource_texture.h"
+
+/* Initializes texture resource. */
+bool
+resource_texture_init(Resources* self, TextureType type)
+{
+	if (!texture_init(&self->textures[type], TEXTURE_PATHS[type]))
+	{
+		printf(STRING_RESOURCE_ERROR, TEXTURE_PATHS[type]);
+		return false;
+	}
+
+	printf(STRING_RESOURCE_INIT, TEXTURE_PATHS[type]);
+
+	return true;
+}
+
+/* Frees texture resources. */
+void
+resource_texture_free(Resources* self, TextureType type)
+{
+	if (self->textures[type].isInit)
+	{
+		texture_free(&self->textures[type]);
+
+		printf(STRING_RESOURCE_FREE, TEXTURE_PATHS[type]);
+	}
+}
+
+/* Given an array, initializes texture resources. */
+void
+resource_texture_state_init(Resources* self, const TextureType* types, u32 count)
+{
+	for (s32 i = 0; i < (s32)count; i++)
+		resource_texture_init(self, types[i]);
+}
+
+/* Frees texture resources. */
+void
+resource_texture_state_free(Resources* self, const TextureType* types, u32 count)
+{
+	for (s32 i = 0; i < (s32)count; i++)
+		resource_texture_free(self, types[i]);
+}

src/game/resource/resource_texture.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "RESOURCE_COMMON.h"
+
+void resource_texture_state_free(Resources* self, const TextureType* types, u32 count);
+void resource_texture_state_init(Resources* self, const TextureType* types, u32 count);
+void resource_texture_free(Resources* self, TextureType type);
+bool resource_texture_init(Resources* self, TextureType type);

src/game/state/STATE_COMMON.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "play/PLAY_COMMON.h"
+
+#define STATE_COUNT STATE_PLAY + 1
+typedef enum StateType
+{
+	STATE_PLAY
+} StateType;
+
+typedef struct Game Game;
+
+typedef struct State
+{
+	Game* game;
+	StateType type;
+	union
+	{
+		Play play;
+	};
+} State;

src/game/state/play/PLAY_COMMON.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../../resource/resource_shader.h"
+#include "../../resource/resource_texture.h"
+
+typedef struct State State;
+
+typedef struct Play
+{
+	State* state;
+	u32 testID;
+} Play;
+

src/game/state/play/play.c

@@ -0,0 +1,14 @@
+#include "play.h"
+
+/* Initializes play state. */
+void
+play_init(Play* self, State* state)
+{
+	memset(self, '\0', sizeof(Play));
+
+	self->state = state;
+
+	self->testID = ecs_entity_add(&self->state->game->ecs);
+
+	entity_test_init(&self->state->game->ecs, self->testID);
+}

src/game/state/play/play.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../STATE_COMMON.h"
+
+#include "../../ecs/ecs.h"
+
+#define PLAY_SHADER_COUNT 2
+static const ShaderType PLAY_SHADERS[PLAY_SHADER_COUNT] =
+{
+	SHADER_TEXTURE_QUAD,
+	SHADER_TRIANGLE
+};
+
+
+#define PLAY_TEXTURE_COUNT 1
+static const TextureType PLAY_TEXTURES[PLAY_TEXTURE_COUNT] =
+{
+	TEXTURE_TEST
+};
+
+void play_init(Play* play, State* state);

src/game/state/state.c

@@ -0,0 +1,71 @@
+#include "state.h"
+
+static void _state_set(State* state, StateType type);
+
+/* Sets the game state. */
+static void
+_state_set(State* state, StateType type)
+{
+	resource_shader_state_init
+	(
+		&state->game->resources, 
+		STATE_SHADERS[state->type], 
+		STATE_SHADER_COUNT[state->type]
+	);
+
+	resource_texture_state_init
+	(
+		&state->game->resources, 
+		STATE_TEXTURES[state->type], 
+		STATE_TEXTURE_COUNT[state->type]
+	);
+
+	switch (state->type)
+	{
+		case STATE_PLAY:
+			play_init(&state->play, state);
+			break;
+		default:
+			break;
+	}
+}
+
+/* Initializes game state; does not free past resources. */
+void
+state_init(State* state, Game* game, StateType type)
+{
+	memset(state, '\0', sizeof(State));
+
+	state->game = game;
+
+	_state_set(state, type);
+}
+
+/* Frees current stare resources. */
+void
+state_free(State* state)
+{
+	ecs_clear(&state->game->ecs);
+
+	resource_shader_state_free
+	(
+		&state->game->resources, 
+		STATE_SHADERS[state->type], 
+		STATE_SHADER_COUNT[state->type]
+	);
+
+	resource_texture_state_free
+	(
+		&state->game->resources, 
+		STATE_TEXTURES[state->type], 
+		STATE_TEXTURE_COUNT[state->type]
+	);
+}
+
+/* Changes game state and initializes new resources. */
+void
+state_change(State* state, StateType type)
+{
+	state_free(state);
+	_state_set(state, type);
+}

src/game/state/state.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "play/play.h"
+
+#include "../resource/resource_shader.h"
+#include "../resource/resource_texture.h"
+
+static const ShaderType* STATE_SHADERS[STATE_COUNT] =
+{
+	PLAY_SHADERS
+};
+
+static const u32 STATE_SHADER_COUNT[STATE_COUNT] = 
+{
+	PLAY_SHADER_COUNT
+};
+
+static const TextureType* STATE_TEXTURES[STATE_COUNT] =
+{
+	PLAY_TEXTURES
+};
+
+static const u32 STATE_TEXTURE_COUNT[STATE_COUNT] =
+{
+	PLAY_TEXTURE_COUNT
+};
+
+void state_change(State* state, StateType type);
+void state_init(State* state, Game* game, StateType type);
+void state_free(State* state);