Sprites are good. Merged.

1 files changed, 118 insertions, 114 deletions

diff --git a/include/texture.hpp b/include/texture.hpp
index ad5211c..e9082b3 100644
--- a/include/texture.hpp
+++ b/include/texture.hpp
@@ -1,11 +1,10 @@
-/** @file Texture.h
+/**
+ * @file Texture.h
  * @brief Defines a method for loading textures.
- *
  * This file gives facilities for easily loading and binding textures.
  */
-
-#ifndef TEXTURE_H
-#define TEXTURE_H
+#ifndef TEXTURE_HPP_
+#define TEXTURE_HPP_
 
 #include <common.hpp>
 
@@ -16,137 +15,142 @@
 #define DEBUG
 
 /**
- * Texture functions are given a namespace for better organization.
+ * @class Texture
+ * Handles a single texture, loaded from the given file.
  */
-namespace Texture {
+class Texture {
+private:
+	std::string name; /**< The name (path) of the loaded file. */
+	GLuint tex;       /**< The GLuint for the loaded texture. */
+	vec2 dim;         /**< The dimensions of the loaded texture. */
 
+public:
 	/**
-	 * Loads a texture from the given file name, returning the GLuint used for
-	 * later referencing of the texture.
+	 * Attempts to create a texture.
+	 * Either:
+	 * - Creates an empty class (no arguments given)
+	 * - Load a texture from the given file, crashing if file not found
+	 * - Fills the class with the given values
+	 * @param file the path to the desired texture
+	 * @param t the GLuint for the texture, if known
+	 * @param v the size of the texture, if known
 	 */
+	Texture(const std::string& file = "", const GLuint& t = 0xFFFFF, const vec2& v = vec2(0, 0));
 
-	GLuint loadTexture(std::string fileName);
-    GLuint genColor(Color c);
+	/**
+	 * Gets the name (path) of the loaded texture.
+	 * @return the texture's name
+	 */
+	const std::string& getName(void) const;
 
-	void freeTextures(void);
+	/**
+	 * Gets the dimensions of the loaded texture.
+	 * @return the texture's dimensions
+	 */
+	const vec2& getDim(void) const;
 
-	void initColorIndex();
-	vec2 getIndex(Color c);
-	vec2 imageDim(std::string fileName);
-}
+	/**
+	 * Binds the texture, so it may be used for rendering.
+	 */
+	inline void use(void) const
+	{ glBindTexture(GL_TEXTURE_2D, tex); }
 
-class SpriteLoader {
-private:
-	std::unordered_map<uint64_t, GLuint> sprites;
-	std::unordered_map<std::string, uint64_t> spritesLoc;
-
-	uint64_t freeID = 0;
-	uint64_t increaseID() {
-		uint64_t id_t = 0;
-		while (1) {
-			try {
-				sprites.at(id_t);
-			} catch (const std::out_of_range& oor) {
-				freeID = id_t;
-				return freeID;
-			}
-			id_t++;
-		}
-	}
-public:
-	uint64_t loadSprite(std::string s)	{
-		uint64_t tex_e = 0;
-		try {
-			tex_e = spritesLoc.at(s);
-		} catch (const std::out_of_range& oor) {
-			sprites.emplace(increaseID(), Texture::loadTexture (s));
-			spritesLoc.emplace(s, freeID);
-			return freeID;
-		}
-		return tex_e;
-	}
-
-	GLuint getSprite(uint64_t id) {
-		return sprites.at(id);
-	}
+	/**
+	 * Frees GPU resources for the loaded texture.
+	 */
+	inline void destroy(void)
+	{ glDeleteTextures(1, &tex), tex = 0xFFFFF; }
+
+	/**
+	 * Checks if a texture is currently loaded in this class.
+	 * @return true if there is not a loaded texture
+	 */
+	inline bool isEmpty(void) const
+	{ return (tex == 0xFFFFF); }
 };
 
 /**
- * DRAFT texture iterator?
+ * @class ColorTex
+ * Creates a single-pixel texture of the given color.
  */
-class TextureIterator {
-private:
-	std::vector<std::pair<GLuint, std::string>> textures;
-	std::vector<std::pair<GLuint, std::string>>::iterator position;
+class ColorTex : public Texture {
 public:
-	TextureIterator(void) {
-		position = std::begin(textures);
-	}
-	~TextureIterator(void) {
-		textures.clear();
-	}
-	TextureIterator(const std::vector<std::string> &l) {
-		for (const auto &s : l)
-			textures.emplace_back(Texture::loadTexture(s), s);
-
-		position = std::begin(textures);
-	}
-	void operator++(int) noexcept {
-		if (++position < std::end(textures))
-			glBindTexture(GL_TEXTURE_2D, (*position).first);
-		else
-			position = std::end(textures) - 1;
-	}
-	void operator--(int) noexcept {
-		if (--position >= std::begin(textures))
-			glBindTexture(GL_TEXTURE_2D, (*position).first);
-		else
-			position = std::begin(textures);
-	}
-	void operator()(const int &index) {
-		if (index < 0 || index > static_cast<int>(textures.size()))
-			throw std::invalid_argument("texture index out of range");
-
-		position = std::begin(textures) + index;
-		glBindTexture(GL_TEXTURE_2D, (*position).first);
-	}
-	const std::string& getTexturePath(const int &index) {
-		if (index < 0 || index > static_cast<int>(textures.size()))
-			throw std::invalid_argument("texture index out of range");
-
-		return textures[index].second;
-	}
-	const vec2 getTextureDim(void) {
-		return Texture::imageDim((*position).second);
-	}
+	ColorTex(void);
+
+	/**
+	 * Creates a texture of the given color.
+	 * @param color the desired color
+	 */
+	ColorTex(const Color& color);
 };
 
 /**
- * The Texturec class.
- *
- * This class can handle an array of textures and allows easy binding of those
- * textures.
+ * A collection of preloaded colors, to save resources.
  */
+namespace Colors {
+	extern ColorTex white; /**< A solid white texture. */
+	extern ColorTex black; /**< A solid black texture. */
+	extern ColorTex red;   /**< A solid red texture. */
 
-class Texturec{
+	/**
+	 * Creates the colors.
+	 */
+	void init(void);
+}
+
+/**
+ * @class TextureIterator
+ * Keeps a collection of textures for easy usage/looping.
+ */
+class TextureIterator {
 private:
-	unsigned int texState;
+	/**
+	 * The set of textures to loop through.
+	 */
+	std::vector<Texture> textures;
 
+	/**
+	 * The current position in the texture array.
+	 * @see textures
+	 */
+	std::vector<Texture>::iterator position;
 public:
+	TextureIterator(void)
+		: position(std::begin(textures)) {}
+	~TextureIterator(void) {}
 
-	std::vector<GLuint> image;
-	std::vector<std::string> texLoc;
-
-	Texturec(uint amt, ...);
-	Texturec(uint amt,const char **paths);
-	Texturec(std::vector<std::string>vec);
-	Texturec(std::initializer_list<std::string> l);
-
-	~Texturec();
+	/**
+	 * Constructs a set of textures from the given list.
+	 * @param l the list of textures
+	 */
+	TextureIterator(const std::vector<std::string> &l);
+	/**
+	 * Shifts to the next texture in the array, stopping at the end if we're there.
+	 * Also binds the texture.
+	 */
+	void operator++(int) noexcept;
 
-	void bindNext();
-	void bindPrev();
-	void bind(unsigned int);
+	/**
+	 * Shifts back in the array, staying at the beginning if we're there.
+	 * Also binds the texture.
+	 */
+	void operator--(int) noexcept;
+	/**
+	 * Goes to the given index in the list.
+	 * @param index the index to use
+	 */
+	void operator()(const int &index);
+	/**
+	 * Gets the dimensions of the currently selected texture.
+	 * @return the texture's dimensions
+	 */
+	inline const vec2& getTextureDim(void)
+	{ return position->getDim(); }
 };
 
-#endif //TEXTURE_H
+/**
+ * Frees all loaded textures, rendering them all useless.
+ */
+void unloadTextures(void);
+
+#endif //TEXTURE_HPP_