kinda big: texture redo, main cleanup

7 files changed, 197 insertions, 331 deletions

diff --git a/src/components.cpp b/src/components.cpp
index a398bec..8a66f80 100644
--- a/src/components.cpp
+++ b/src/components.cpp
@@ -52,11 +52,11 @@ void PhysicsSystem::update(entityx::EntityManager &en, entityx::EventManager &ev
 	});
 }
 
-GLuint RenderSystem::loadTexture(const std::string& file)
+Texture RenderSystem::loadTexture(const std::string& file)
 {
 	loadTexString = file;
-	loadTexResult = 0xFFFF;
-	while (loadTexResult == 0xFFFF)
+	loadTexResult = Texture();
+	while (loadTexResult.isEmpty())
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	return loadTexResult;
 }
@@ -66,7 +66,7 @@ void RenderSystem::update(entityx::EntityManager &en, entityx::EventManager &ev,
 	(void)ev;
 
 	if (!loadTexString.empty()) {
-		loadTexResult = Texture::loadTexture(loadTexString);
+		loadTexResult = Texture(loadTexString);
 		loadTexString.clear();
 	}
 
@@ -95,17 +95,16 @@ void RenderSystem::update(entityx::EntityManager &en, entityx::EventManager &ev,
 		}
 
 		for (auto &S : sprite.sprite) {
-			float width = HLINES(S.first.size.x);
-			float height = HLINES(S.first.size.y);
+			const auto& size = S.first.tex.getDim() * game::HLINE;
 
 			vec2 loc = vec2(pos.x + S.first.offset.x, pos.y + S.first.offset.y);
 
 			GLfloat coords[] = {loc.x, 			loc.y, 			visible.z,
-								loc.x + width, 	loc.y, 			visible.z,
-								loc.x + width, 	loc.y + height, visible.z,
+								loc.x + size.x,	loc.y, 			visible.z,
+								loc.x + size.x, loc.y + size.y, visible.z,
 
-								loc.x + width, 	loc.y + height, visible.z,
-								loc.x, 			loc.y + height, visible.z,
+								loc.x + size.x,	loc.y + size.y, visible.z,
+								loc.x, 			loc.y + size.y, visible.z,
 								loc.x, 			loc.y, 			visible.z};
 
 
@@ -116,7 +115,7 @@ void RenderSystem::update(entityx::EntityManager &en, entityx::EventManager &ev,
 				glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, flashAmt, flashAmt, 1.0);
 			}*/
 
-			glBindTexture(GL_TEXTURE_2D, S.first.pic);
+			S.first.tex.use();
 
 			glUniform1i(Render::worldShader.uniform[WU_texture], 0);
 			Render::worldShader.enable();
@@ -270,7 +269,7 @@ std::vector<Frame> developFrame(XMLElement* xml)
 				std::string sname = sxml->Name();
 				if (sname == "src") {
 					tmpf.push_back(std::make_pair(SpriteData(sxml->GetText(), vec2(0,0)), vec2(0,0)));
-					std::cout << tmpf.back().first.pic << std::endl;
+					//std::cout << tmpf.back().first.pic << std::endl;
 				}
 				sxml = sxml->NextSiblingElement();
 			}
diff --git a/src/engine.cpp b/src/engine.cpp
index e5b2b36..b42b162 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -60,7 +60,7 @@ void Engine::update(entityx::TimeDelta dt)
 namespace game {
 	entityx::EventManager events;
 	entityx::EntityManager entities (events);
-	SpriteLoader sprite_l;
+	//SpriteLoader sprite_l;
 
     Engine engine;
 }
diff --git a/src/inventory.cpp b/src/inventory.cpp
index 91e81da..fb999ea 100644
--- a/src/inventory.cpp
+++ b/src/inventory.cpp
@@ -7,7 +7,7 @@
 
 constexpr const char* ICON_TEX_FILE_PATH = "config/invIcons.txt";
 
-static std::vector<GLuint> iconTextures;
+static std::vector<Texture> iconTextures;
 
 void InventorySystem::configure(entityx::EventManager &ev)
 {
@@ -18,7 +18,7 @@ void InventorySystem::loadIcons(void) {
     iconTextures.clear();
     auto icons = readFileA(ICON_TEX_FILE_PATH);
     for (const auto& s : icons)
-        iconTextures.push_back(Texture::loadTexture(s));
+        iconTextures.push_back(s);
 }
 
 void InventorySystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
@@ -27,14 +27,13 @@ void InventorySystem::update(entityx::EntityManager &en, entityx::EventManager &
     (void)ev;
     (void)dt;
 
-    static auto color = Texture::genColor(Color(0, 0, 0));
     vec2 start = vec2(offset.x, 100);// - game::SCREEN_WIDTH / 2 + 20, game::SCREEN_HEIGHT - 40);
 
     //std::cout << start.x << ' ' << start.y << std::endl;
 
     Render::textShader.use();
         glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, color);
+        Colors::black.use();
         Render::useShader(&Render::textShader);
         Render::drawRect(start, start + 20, -9.9f);
     Render::textShader.unuse();
diff --git a/src/texture.cpp b/src/texture.cpp
index a232e0e..640b06e 100644
--- a/src/texture.cpp
+++ b/src/texture.cpp
@@ -3,265 +3,139 @@
 
 #include <texture.hpp>
 
-/**
- * A structure for keeping track of loaded textures.
- */
-
-typedef struct {
-	std::string name;	/**< The file path of the texture.		*/
-	GLuint tex;			/**< The GLuint for the loaded texture. */
-	dim2 dim;			/**< The dimensions of the texture.		*/
-} texture_t;
+namespace Colors
+{
+	ColorTex white;
+	ColorTex black;
+	ColorTex red;
+
+	void init(void) {
+		white = ColorTex(Color(255, 255, 255));
+		black = ColorTex(Color(0, 0, 0));
+		red = ColorTex(Color(255, 0, 0));
+	}
+}
 
-struct index_t {
-	Color color;
-	int indexx;
-	int indexy;
-};
+void loadTexture(const std::string& file, Texture& texture);
 
-// convert any type to octal
-template <typename T>
-uint toOctal(T toConvert)
+Texture::Texture(const std::string& file, const GLuint& t, const vec2& v)
+	: name(file), tex(t), dim(v)
 {
-    int n = 0;
-    uint t = 0;
-    while (toConvert > 0) {
-        t += (pow(10, n++)) * (static_cast<int>(toConvert) % 8);
-        toConvert /= 8;
-    }
-    return t;
+	if (t == 0xFFFFF && !file.empty())
+		loadTexture(file, *this);
 }
 
-/**
- * A vector of all loaded textures.
- *
- * Should a texture be asked to be loaded twice, loadTexture() can reference
- * this array and reuse GLuint's to save memory.
- */
+const std::string& Texture::getName(void) const
+{
+	return name;
+}
 
-static std::vector<texture_t> LoadedTexture;
+const vec2& Texture::getDim(void) const
+{
+	return dim;
+}
 
-namespace Texture{
-	Color pixels[8][4];
+ColorTex::ColorTex(void)
+{
+	Texture();
+}
 
-	GLuint loadTexture(std::string fileName) {
-		SDL_Surface *image;
+ColorTex::ColorTex(const Color& color)
+{
+	unsigned char data[4] = {
+		static_cast<unsigned char>(color.red),
+		static_cast<unsigned char>(color.green),
+		static_cast<unsigned char>(color.blue),
+		static_cast<unsigned char>(color.alpha),
+	};
+
+	GLuint object;
+	glActiveTexture(GL_TEXTURE0);
+	glGenTextures(1, &object);				// Turns "object" into a texture
+	glBindTexture(GL_TEXTURE_2D, object);	// Binds "object" to the top of the stack
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+
+	Texture("", object, vec2());
+}
 
-		// check if texture is already loaded
-		for(auto &t : LoadedTexture) {
-			if (t.name == fileName) {
+static std::vector<Texture> loadedTextures;
 
-#ifdef DEBUG
-				DEBUG_printf("Reusing loaded texture for %s\n", fileName.c_str());
-#endif // DEBUG
-
-				return t.tex;
-			}
-		}
+void loadTexture(const std::string& file, Texture& texture)
+{
+	auto preloaded =
+		std::find_if(std::begin(loadedTextures), std::end(loadedTextures),
+		[&file](const Texture& t) { return (t.getName() == file); });
 
-		// load SDL_surface of texture
-		if (!(image = IMG_Load(fileName.c_str())))
-			return 0;
+	if (preloaded == std::end(loadedTextures)) {
+		auto image = IMG_Load(file.c_str());
+		if (image == nullptr)
+			UserError("File not found: " + file);
 
 #ifdef DEBUG
-		DEBUG_printf("Loaded image file: %s\n", fileName.c_str());
+		DEBUG_printf("Loaded image file: %s\n", file.c_str());
 #endif // DEBUG
 
-		/*
-		 * Load texture through OpenGL.
-		 */
+		// load texture through OpenGL
 		GLuint object;
 		glGenTextures(1, &object);				// Turns "object" into a texture
 		glBindTexture(GL_TEXTURE_2D, object);	// Binds "object" to the top of the stack
-		glPixelStoref(GL_UNPACK_ALIGNMENT,1);
-
+		glPixelStoref(GL_UNPACK_ALIGNMENT, 1);
 		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	// Sets the "min" filter
 		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	// The the "max" filter of the stack
 		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Wrap the texture to the matrix
 		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //
-		glTexImage2D(GL_TEXTURE_2D,  // Sets the texture to the image file loaded above
-					 0,
-					 GL_RGBA,
-					 image->w,
-					 image->h,
-					 0,
-					 GL_RGBA,
-					 GL_UNSIGNED_BYTE,
-					 image->pixels
-					);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->w, image->h, 0,
+					 GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);
+
+		// add texture to loadedTextures
+		loadedTextures.emplace_back(file, object, vec2(image->w, image->h));
 
-		// add texture to LoadedTexture
-		LoadedTexture.push_back(texture_t{fileName,object,{image->w,image->h}});
+		texture = loadedTextures.back();
 
 		// free the SDL_Surface
 		SDL_FreeSurface(image);
-
-		return object;
-	}
-
-    GLuint genColor(Color c)
-    {
-        std::string out;
-
-        // add the red
-        out += static_cast<int>(c.red);
-
-        // add the green
-        out += static_cast<int>(c.green);
-
-        // add the blue
-        out += static_cast<int>(c.blue);
-
-        // add the alpha
-        out += static_cast<int>(c.alpha);
-
-        GLuint object;
-
-        glActiveTexture(GL_TEXTURE0);
-        glGenTextures(1,&object);				// Turns "object" into a texture
-		glBindTexture(GL_TEXTURE_2D,object);	// Binds "object" to the top of the stack
-		//glPixelStorei(GL_UNPACK_ALIGNMENT,1);
-
-		//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	// Sets the "min" filter
-		//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	// The the "max" filter of the stack
-
-		//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Wrap the texture to the matrix
-		//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //
-
-		glTexImage2D(GL_TEXTURE_2D,     // Sets the texture to the image file loaded above
-					 0,                 // level
-					 GL_RGBA,           // internal format
-					 1,                 // width
-					 1,                 // height
-					 0,                 // border
-					 GL_RGBA,           // image format
-					 GL_UNSIGNED_BYTE,  // type
-					 out.data()         // source
-					);
-
-        return object;
-    }
-
-	vec2 imageDim(std::string fileName) {
-		for(auto &t : LoadedTexture) {
-			if (t.name == fileName)
-				return vec2(t.dim.x, t.dim.y);
-		}
-		return vec2(0,0);
-	}
-
-	void freeTextures(void) {
-		while(!LoadedTexture.empty()) {
-			glDeleteTextures(1, &LoadedTexture.back().tex);
-			LoadedTexture.pop_back();
-		}
-	}
-
-	#define CINDEX_WIDTH (8*4*3)
-	void initColorIndex() {
-		unsigned int i;
-		GLubyte *buffer;
-		GLfloat *bufferf;
-
-		buffer  = new GLubyte[CINDEX_WIDTH];
-		bufferf = new GLfloat[CINDEX_WIDTH];
-
-		colorIndex = loadTexture("assets/colorIndex.png");
-		glActiveTexture(GL_TEXTURE0);
-		glBindTexture(GL_TEXTURE_2D, colorIndex);
-		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);
-
-		for(i = 0; i < CINDEX_WIDTH; i++)
-			bufferf[i] = (float)buffer[i] / 255.0f;
-
-		i = 0;
-		for(unsigned int y = 0; y < 8; y++) {
-			for(unsigned int x = 0; x < 4; x++) {
-					if (i >= CINDEX_WIDTH) {
-						delete[] buffer;
-						delete[] bufferf;
-						return;
-					}
-					pixels[y][x].red = buffer[i++];
-					pixels[y][x].green = buffer[i++];
-					pixels[y][x].blue = buffer[i++];
-			}
-		}
-		delete[] buffer;
-		delete[] bufferf;
-	}
-
-	//sqrt((255-145)^2+(90-145)^2+(0-0)^2);
-	std::vector<index_t>ind;
-	vec2 getIndex(Color c) {
-		for(auto &i : ind) {
-			if (c.red == i.color.red && c.green == i.color.green && c.blue == i.color.blue) {
-				return {float(i.indexx), float(i.indexy)};
-			}
-		}
-		uint buf[2];
-		float buff = 999;
-		float shit = 999;
-		for(uint y = 0; y < 8; y++) {
-			for(uint x = 0; x < 4; x++) {
-				buff = sqrt(pow((pixels[y][x].red-	c.red),  2)+
-							pow((pixels[y][x].green-c.green),2)+
-							pow((pixels[y][x].blue-	c.blue), 2));
-				if (buff < shit) {
-					shit = buff;
-					buf[0] = y;
-					buf[1] = x;
-				}
-			}
-		}
-		ind.push_back({c, (int)buf[1], (int)buf[0]});
-		return {float(buf[1]),float(buf[0])};
+	} else {
+		texture = *preloaded;
 	}
 }
 
-Texturec::Texturec(uint amt, ...) {
-	va_list fNames;
-	texState = 0;
-	va_start(fNames, amt);
-	for (unsigned int i = 0; i < amt; i++) {
-		std::string l = va_arg(fNames, char *);
-		image.push_back(Texture::loadTexture(l));
-		texLoc.push_back(l);
-	}
-	va_end(fNames);
-}
 
-Texturec::Texturec(std::initializer_list<std::string> l)
+TextureIterator::TextureIterator(const std::vector<std::string> &l)
 {
-	texState = 0;
-	std::for_each(l.begin(), l.end(), [&](std::string s) { image.push_back(Texture::loadTexture(s)); texLoc.push_back(s);});
+	for (const auto& s : l)
+		textures.emplace_back(s);
+	position = std::begin(textures);
 }
 
-Texturec::Texturec(std::vector<std::string>v) {
-	texState = 0;
-	std::for_each(v.begin(), v.end(), [&](std::string s) { image.push_back(Texture::loadTexture(s)); texLoc.push_back(s);});
+void TextureIterator::operator++(int) noexcept
+{
+	if (++position >= std::end(textures))
+		position = std::end(textures) - 1;
+	position->use();
 }
 
-Texturec::Texturec(uint amt,const char **paths) {
-	texState = 0;
-	for (unsigned int i = 0; i < amt; i++) {
-		image.push_back(Texture::loadTexture(paths[i]));
-		texLoc.push_back(paths[i]);
-	}
+void TextureIterator::operator--(int) noexcept
+{
+	if (--position < std::begin(textures))
+		position = std::begin(textures);
+	position->use();
 }
 
-Texturec::~Texturec() {
-}
+void TextureIterator::operator()(const int &index)
+{
+	if (index < 0 || index > static_cast<int>(textures.size()))
+		throw std::invalid_argument("texture index out of range");
 
-void Texturec::bind(unsigned int bn) {
-	texState = bn;
-	glBindTexture(GL_TEXTURE_2D,image[(int)texState]);
+	position = std::begin(textures) + index;
+	position->use();
 }
 
-void Texturec::bindNext() {
-	bind(++texState);
-}
 
-void Texturec::bindPrev() {
-	bind(--texState);
+void unloadTextures(void)
+{
+	while (!loadedTextures.empty()) {
+		loadedTextures.back().destroy();
+		loadedTextures.pop_back();
+	}
 }
+
diff --git a/src/ui.cpp b/src/ui.cpp
index 1994382..e87c74a 100644
--- a/src/ui.cpp
+++ b/src/ui.cpp
@@ -667,11 +667,8 @@ namespace ui {
                              0,1,
                              0,0};
 
-        static GLuint boxT = Texture::genColor(Color(0,0,0));
-        static GLuint lineT = Texture::genColor(Color(255,255,255));
-
         glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, boxT);
+		Colors::black.use();
         glUniform1i(Render::textShader.uniform[WU_texture], 0);
 
         Render::textShader.use();
@@ -681,7 +678,7 @@ namespace ui {
         glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, box_tex);
         glDrawArrays(GL_TRIANGLES, 0 ,6);
 
-        glBindTexture(GL_TEXTURE_2D, lineT);
+        Colors::white.use();
         glUniform1i(Render::textShader.uniform[WU_texture], 0);
 
         glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, line_strip);
@@ -698,13 +695,13 @@ namespace ui {
 
 	void drawNiceBoxColor(vec2 c1, vec2 c2, float z, Color c) {
 		// the textures for the box corners
-		static GLuint box_corner =	 	Texture::loadTexture("assets/ui/button_corners.png");
-		static GLuint box_side_top = 	Texture::loadTexture("assets/ui/button_top_bot_borders.png");
-		static GLuint box_side = 		Texture::loadTexture("assets/ui/button_side_borders.png");
+		static Texture boxCorner  ("assets/ui/button_corners.png");
+		static Texture boxSideTop ("assets/ui/button_top_bot_borders.png");
+		static Texture boxSide    ("assets/ui/button_side_borders.png");
 
 		// the dimensions of the corner textures
-		static vec2 box_corner_dim_t = 	Texture::imageDim("assets/ui/button_corners.png");
-		static vec2 box_corner_dim = vec2(box_corner_dim_t.x / 2.0, box_corner_dim_t.y / 2.0);
+		static const auto& boxCornerDim  = boxCorner.getDim();
+		static const auto& boxCornerDim2 = boxCornerDim / 2;
 
 		// the amount of bytes to skip in the OpenGL arrays (see below)
 		auto stride = 5 * sizeof(GLfloat);
@@ -714,81 +711,80 @@ namespace ui {
 		if (c1.y > c2.y) c1.swapY(c2); // std::swap(c1.y, c2.y);
 
 		// if the box is too small, we will not be able to draw it
-		if (c2.x - c1.x < (box_corner_dim_t.x)) return;
-		if (c2.y - c1.y < (box_corner_dim_t.y)) return;
-
+		if (c2.x - c1.x < (boxCornerDim.x) || c2.y - c1.y < (boxCornerDim.y))
+			return;
 
-		GLfloat box_ul[] = {c1.x, 						c2.y - box_corner_dim.y, z,	0.0f, 0.5f,
-                          	c1.x + box_corner_dim.x, 	c2.y - box_corner_dim.y, z,	0.5f, 0.5f,
-                          	c1.x + box_corner_dim.x,	c2.y, 					 z,	0.5f, 1.0f,
+		GLfloat box_ul[] = {c1.x, 						c2.y - boxCornerDim2.y, z,	0.0f, 0.5f,
+                          	c1.x + boxCornerDim2.x, 	c2.y - boxCornerDim2.y, z,	0.5f, 0.5f,
+                          	c1.x + boxCornerDim2.x,	c2.y, 				    z,	0.5f, 1.0f,
 
-                          	c1.x + box_corner_dim.x,	c2.y, 					 z, 0.5f, 1.0f,
-                       	  	c1.x, 						c2.y, 					 z, 0.0f, 1.0f,
-                          	c1.x, 						c2.y - box_corner_dim.y, z,	0.0f, 0.5f};
+                          	c1.x + boxCornerDim2.x,	c2.y, 					z, 0.5f, 1.0f,
+                       	  	c1.x, 						c2.y, 					z, 0.0f, 1.0f,
+                          	c1.x, 						c2.y - boxCornerDim2.y, z,	0.0f, 0.5f};
 
-		GLfloat box_ll[] = {c1.x, 						c1.y, 					 z,	0.0f, 0.0f,
-                          	c1.x + box_corner_dim.x, 	c1.y,					 z,	0.5f, 0.0f,
-                          	c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z,	0.5f, 0.5f,
+		GLfloat box_ll[] = {c1.x, 						c1.y, 					z,	0.0f, 0.0f,
+                          	c1.x + boxCornerDim2.x, 	c1.y,					z,	0.5f, 0.0f,
+                          	c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z,	0.5f, 0.5f,
 
-                          	c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.5f,
-                       	  	c1.x, 						c1.y + box_corner_dim.y, z, 0.0f, 0.5f,
-                          	c1.x, 						c1.y,					 z,	0.0f, 0.0f};
+                          	c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.5f,
+                       	  	c1.x, 						c1.y + boxCornerDim2.y, z, 0.0f, 0.5f,
+                          	c1.x, 						c1.y,					z, 0.0f, 0.0f};
 
-		GLfloat box_ur[] = {c2.x - box_corner_dim.x,	c2.y - box_corner_dim.y, z,	0.5f, 0.5f,
-                          	c2.x, 						c2.y - box_corner_dim.y, z,	1.0f, 0.5f,
+		GLfloat box_ur[] = {c2.x - boxCornerDim2.x,	c2.y - boxCornerDim2.y, z,	0.5f, 0.5f,
+                          	c2.x, 						c2.y - boxCornerDim2.y, z,	1.0f, 0.5f,
                           	c2.x,						c2.y, 					 z,	1.0f, 1.0f,
 
                           	c2.x,						c2.y, 					 z, 1.0f, 1.0f,
-                       	  	c2.x - box_corner_dim.x, 	c2.y, 					 z, 0.5f, 1.0f,
-                          	c2.x - box_corner_dim.x, 	c2.y - box_corner_dim.y, z,	0.5f, 0.5f};
+                       	  	c2.x - boxCornerDim2.x, 	c2.y, 					 z, 0.5f, 1.0f,
+                          	c2.x - boxCornerDim2.x, 	c2.y - boxCornerDim2.y, z,	0.5f, 0.5f};
 
-		GLfloat box_lr[] = {c2.x - box_corner_dim.x, 	c1.y, 					 z,	0.5f, 0.0f,
+		GLfloat box_lr[] = {c2.x - boxCornerDim2.x, 	c1.y, 					 z,	0.5f, 0.0f,
                           	c2.x, 						c1.y,					 z,	1.0f, 0.0f,
-                          	c2.x,						c1.y + box_corner_dim.y, z,	1.0f, 0.5f,
+                          	c2.x,						c1.y + boxCornerDim2.y, z,	1.0f, 0.5f,
 
-                          	c2.x,						c1.y + box_corner_dim.y, z, 1.0f, 0.5f,
-                       	  	c2.x - box_corner_dim.x, 	c1.y + box_corner_dim.y, z, 0.0f, 0.5f,
-                          	c2.x - box_corner_dim.x, 	c1.y,					 z,	0.5f, 0.0f};
+                          	c2.x,						c1.y + boxCornerDim2.y, z, 1.0f, 0.5f,
+                       	  	c2.x - boxCornerDim2.x, 	c1.y + boxCornerDim2.y, z, 0.0f, 0.5f,
+                          	c2.x - boxCornerDim2.x, 	c1.y,					 z,	0.5f, 0.0f};
 
-		GLfloat box_l[] =  {c1.x,						c1.y + box_corner_dim.y, z, 0.0f, 0.0f,
-							c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.0f,
-							c1.x + box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 1.0f,
+		GLfloat box_l[] =  {c1.x,						c1.y + boxCornerDim2.y, z, 0.0f, 0.0f,
+							c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.0f,
+							c1.x + boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 1.0f,
 
-							c1.x + box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 1.0f,
-							c1.x,						c2.y - box_corner_dim.y, z, 0.0f, 1.0f,
-							c1.x,						c1.y + box_corner_dim.y, z, 0.0f, 0.0f};
+							c1.x + boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 1.0f,
+							c1.x,						c2.y - boxCornerDim2.y, z, 0.0f, 1.0f,
+							c1.x,						c1.y + boxCornerDim2.y, z, 0.0f, 0.0f};
 
-		GLfloat box_r[] =  {c2.x - box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.0f,
-							c2.x,						c1.y + box_corner_dim.y, z, 1.0f, 0.0f,
-							c2.x,						c2.y - box_corner_dim.y, z, 1.0f, 1.0f,
+		GLfloat box_r[] =  {c2.x - boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.0f,
+							c2.x,						c1.y + boxCornerDim2.y, z, 1.0f, 0.0f,
+							c2.x,						c2.y - boxCornerDim2.y, z, 1.0f, 1.0f,
 
-							c2.x,						c2.y - box_corner_dim.y, z, 1.0f, 1.0f,
-							c2.x - box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 1.0f,
-							c2.x - box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.0f};
+							c2.x,						c2.y - boxCornerDim2.y, z, 1.0f, 1.0f,
+							c2.x - boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 1.0f,
+							c2.x - boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.0f};
 
-        GLfloat box_b[] =  {c1.x + box_corner_dim.x,	c1.y,					 z,	0.0f, 0.0f,
-							c2.x - box_corner_dim.x,	c1.y,					 z, 1.0f, 0.0f,
-							c2.x - box_corner_dim.x,	c1.y + box_corner_dim.y, z,	1.0f, 0.5f,
+        GLfloat box_b[] =  {c1.x + boxCornerDim2.x,	c1.y,					 z,	0.0f, 0.0f,
+							c2.x - boxCornerDim2.x,	c1.y,					 z, 1.0f, 0.0f,
+							c2.x - boxCornerDim2.x,	c1.y + boxCornerDim2.y, z,	1.0f, 0.5f,
 
-							c2.x - box_corner_dim.x,	c1.y + box_corner_dim.y, z,	1.0f, 0.5f,
-							c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.0f, 0.5f,
-							c1.x + box_corner_dim.x,	c1.y,					 z, 0.0f, 0.0f};
+							c2.x - boxCornerDim2.x,	c1.y + boxCornerDim2.y, z,	1.0f, 0.5f,
+							c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.0f, 0.5f,
+							c1.x + boxCornerDim2.x,	c1.y,					 z, 0.0f, 0.0f};
 
-        GLfloat box_t[] =  {c1.x + box_corner_dim.x,	c2.y - box_corner_dim.y, z,	0.0f, 0.5f,
-							c2.x - box_corner_dim.x,	c2.y - box_corner_dim.y, z, 1.0f, 0.5f,
-							c2.x - box_corner_dim.x,	c2.y, 					 z,	1.0f, 1.0f,
+        GLfloat box_t[] =  {c1.x + boxCornerDim2.x,	c2.y - boxCornerDim2.y, z,	0.0f, 0.5f,
+							c2.x - boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 1.0f, 0.5f,
+							c2.x - boxCornerDim2.x,	c2.y, 					 z,	1.0f, 1.0f,
 
-							c2.x - box_corner_dim.x,	c2.y,					 z,	1.0f, 1.0f,
-							c1.x + box_corner_dim.x,	c2.y,					 z, 0.0f, 1.0f,
-							c1.x + box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.0f, 0.5f};
+							c2.x - boxCornerDim2.x,	c2.y,					 z,	1.0f, 1.0f,
+							c1.x + boxCornerDim2.x,	c2.y,					 z, 0.0f, 1.0f,
+							c1.x + boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.0f, 0.5f};
 
-		GLfloat box_f[] =  {c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.5f,
-							c2.x - box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.5f,
-							c2.x - box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 0.5f,
+		GLfloat box_f[] =  {c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.5f,
+							c2.x - boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.5f,
+							c2.x - boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 0.5f,
 
-							c2.x - box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 0.5f,
-							c1.x + box_corner_dim.x,	c2.y - box_corner_dim.y, z, 0.5f, 0.5f,
-							c1.x + box_corner_dim.x,	c1.y + box_corner_dim.y, z, 0.5f, 0.5f};
+							c2.x - boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 0.5f,
+							c1.x + boxCornerDim2.x,	c2.y - boxCornerDim2.y, z, 0.5f, 0.5f,
+							c1.x + boxCornerDim2.x,	c1.y + boxCornerDim2.y, z, 0.5f, 0.5f};
 
 		glActiveTexture(GL_TEXTURE0);
 		glUniform1f(Render::textShader.uniform[WU_texture], 0);
@@ -797,7 +793,7 @@ namespace ui {
 		Render::textShader.enable();
 
 		glUniform4f(Render::textShader.uniform[WU_tex_color], c.red, c.green, c.blue, c.alpha);
-		glBindTexture(GL_TEXTURE_2D, box_corner);
+		boxCorner.use();
 
 		// draw upper left corner
         glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_ul[0]);
@@ -824,7 +820,7 @@ namespace ui {
         glVertexAttribPointer(Render::textShader.tex,   2, GL_FLOAT, GL_FALSE, stride, &box_f[3]);
         glDrawArrays(GL_TRIANGLES, 0, 6);
 
-		glBindTexture(GL_TEXTURE_2D, box_side);
+		boxSide.use();
 
 		// draw the left edge of the box
 		glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_l[0]);
@@ -836,7 +832,7 @@ namespace ui {
         glVertexAttribPointer(Render::textShader.tex,   2, GL_FLOAT, GL_FALSE, stride, &box_r[3]);
         glDrawArrays(GL_TRIANGLES, 0, 6);
 
-		glBindTexture(GL_TEXTURE_2D, box_side_top);
+		boxSideTop.use();
 
 		// draw bottom of the box
 		glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, stride, &box_b[0]);
@@ -1097,8 +1093,8 @@ EXIT:
 			return;
 		}
 
-		auto fadeTex = Texture::genColor( (fadeWhite ? Color(255, 255, 255, fadeIntensity) :
-		                                               Color(0, 0, 0, fadeIntensity)) );
+		ColorTex fadeTex (fadeWhite ? Color(255, 255, 255, fadeIntensity) :
+		    Color(0, 0, 0, fadeIntensity));
 
 
         GLfloat tex[] = {0.0, 0.0,
@@ -1117,7 +1113,7 @@ EXIT:
 		Render::textShader.use();
 		Render::textShader.enable();
 
-		glBindTexture(GL_TEXTURE_2D, fadeTex);
+		fadeTex.use();
         glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, backdrop);
         glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -1127,7 +1123,7 @@ EXIT:
 
 		setFontZ(-8.0);
 
-		glDeleteTextures(1, &fadeTex);
+		fadeTex.destroy();
     }
 
 	void fadeUpdate(void) {
diff --git a/src/ui_menu.cpp b/src/ui_menu.cpp
index 59b44e6..779feda 100644
--- a/src/ui_menu.cpp
+++ b/src/ui_menu.cpp
@@ -236,14 +236,13 @@ namespace ui {
             }
 
 			static float cMult = 1.0f;
-			static GLuint backTex = Texture::genColor(Color(0, 0, 0, 204));
-			//static GLuint bsTex =	Texture::genColor(Color(30, 30, 30));
+			static const ColorTex back (Color(0, 0, 0, 204));
 
 			//draw the dark transparent background
             glColor4f(0.0f, 0.0f, 0.0f, .8f);
 			Render::textShader.use();
 
-			glBindTexture(GL_TEXTURE_2D, backTex);
+			back.use();
 			Render::drawRect(vec2(offset.x - SCREEN_WIDTH / 2 - 1, offset.y - (SCREEN_HEIGHT / 2)),
 			                 vec2(offset.x + SCREEN_WIDTH / 2, offset.y + (SCREEN_HEIGHT / 2)), -8.5);
 
diff --git a/src/world.cpp b/src/world.cpp
index 68b8f34..059b6c7 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -277,10 +277,11 @@ void WorldSystem::load(const std::string& file)
 			if (!world.indoor)
 				UserError("<house> can only be used inside <IndoorWorld>");
 
-			world.indoorWidth = wxml->FloatAttribute("width");
-			auto str = wxml->StrAttribute("texture");
-			auto tex = render.loadTexture(str);
-			world.indoorTex = tex;
+			//world.indoorWidth = wxml->FloatAttribute("width");
+			world.indoorTex = render.loadTexture(wxml->StrAttribute("texture"));
+			//auto str = wxml->StrAttribute("texture");
+			//auto tex = render.loadTexture(str);
+			//world.indoorTex = tex;
 		}
 
 		// weather tag
@@ -855,26 +856,26 @@ void WorldSystem::render(void)
 	// draw the remaining layers
 	for (int i = 0; i < 4; i++) {
 		bgTex++;
-		auto dim = bgTex.getTextureDim();
-		dim.x = HLINES(dim.x);
-		dim.y = HLINES(dim.y);
 		auto xcoord = offset.x * bgDraw[i][2];
 
 		bg_items.clear();
 		bg_tex.clear();
 
+		vec2 dim = bgTex.getTextureDim() * game::HLINE;
+
 		if (world.indoor && i == 3) {
-			glBindTexture(GL_TEXTURE_2D, world.indoorTex);
+			world.indoorTex.use();
 
 			const auto& startx = world.startX;
+			dim = world.indoorTex.getDim() * game::HLINE;
 
-			bg_items.emplace_back(startx,                     GROUND_HEIGHT_MINIMUM,         7 - (i * 0.1f));
-	        bg_items.emplace_back(startx + world.indoorWidth, GROUND_HEIGHT_MINIMUM,	     7 - (i * 0.1f));
-	        bg_items.emplace_back(startx + world.indoorWidth, GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
+			bg_items.emplace_back(startx,         GROUND_HEIGHT_MINIMUM,         7 - (i * 0.1f));
+	        bg_items.emplace_back(startx + dim.x, GROUND_HEIGHT_MINIMUM,	     7 - (i * 0.1f));
+	        bg_items.emplace_back(startx + dim.x, GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
 
-	        bg_items.emplace_back(startx + world.indoorWidth, GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
-	        bg_items.emplace_back(startx,                     GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
-	        bg_items.emplace_back(startx,                     GROUND_HEIGHT_MINIMUM,         7 - (i * 0.1f));
+	        bg_items.emplace_back(startx + dim.x, GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
+	        bg_items.emplace_back(startx,         GROUND_HEIGHT_MINIMUM + dim.y, 7 - (i * 0.1f));
+	        bg_items.emplace_back(startx,         GROUND_HEIGHT_MINIMUM,         7 - (i * 0.1f));
 		} else {
 			for (int j = world.startX; j <= -world.startX; j += dim.x) {
 	            bg_items.emplace_back(j         + xcoord, GROUND_HEIGHT_MINIMUM,         7 - (i * 0.1f));
@@ -1041,11 +1042,10 @@ void WorldSystem::render(void)
 		// the ending pixel of the world
 		static const float e = static_cast<float>(SCREEN_WIDTH) / 2.0f;
 
-		static const auto blackTex = Texture::genColor(Color(0, 0, 0));
 		static const float sheight = static_cast<float>(SCREEN_HEIGHT);
 
 		if (offset.x + world.startX > s) {
-			glBindTexture(GL_TEXTURE_2D, blackTex);
+			Colors::black.use();
 			glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.0f);
 
 			GLfloat blackBarLeft[] = {
@@ -1064,7 +1064,7 @@ void WorldSystem::render(void)
 		}
 
 		if (offset.x - world.startX < e) {
-			glBindTexture(GL_TEXTURE_2D, blackTex);
+			Colors::black.use();
 			glUniform1f(Render::worldShader.uniform[WU_light_impact], 0.0f);
 
 			GLfloat blackBarRight[] = {
@@ -1088,10 +1088,9 @@ void WorldSystem::render(void)
 	} else {
 		Render::useShader(&Render::worldShader);
 		Render::worldShader.use();
-		static const GLuint rug = Texture::genColor(Color {255, 0, 0});
-		glBindTexture(GL_TEXTURE_2D, rug);
+		Colors::red.use();
 		vec2 ll = vec2 {world.startX, GROUND_HEIGHT_MINIMUM};
-		Render::drawRect(ll, ll + vec2 {world.indoorWidth, 4}, -3);
+		Render::drawRect(ll, ll + vec2(world.indoorTex.getDim().x, 4), -3);
 		Render::worldShader.unuse();
 	}