various memory cleanup, move/copy simplifications

include/blah/common.h

@@ -81,61 +81,46 @@ namespace Blah
 #else
 namespace Blah
 {
+	struct RefDel { virtual ~RefDel() = default; virtual void delete_it(void* it) = 0; };
+	template<class Y> struct RefDelOf : public RefDel { void delete_it(void* it) { delete (Y*)it; } };
+
 	template<typename T>
 	class Ref
 	{
 	template<class Y> friend class Ref;
 	private:
-		T* m_instance;
+		inline static RefDelOf<T> del;
-		i32* m_counter;
+
-		Ref(T* instance, i32* counter) : m_instance(instance), m_counter(counter) {}
+		T* m_obj = nullptr;
+		u32* m_num = nullptr;
+		RefDel* m_del = nullptr;
+
+		Ref(T* o, u32* n, RefDel* d) : m_obj(o), m_num(n), m_del(d) {}
+
+		void copy(const Ref& rhs) { m_obj = rhs.m_obj; m_num = rhs.m_num; m_del = rhs.m_del; }
+		void zero() { m_obj = nullptr; m_num = nullptr; m_del = nullptr; }
+		void steal(Ref& rhs) { copy(rhs); rhs.zero(); }
+		void increment() { if (m_num) (*m_num)++; }
 
 	public:
-		Ref() : m_instance(nullptr), m_counter(nullptr) {}
+		Ref() = default;
-
 		template<class Y>
-		Ref(Y* instance) : Ref(static_cast<T*>(instance), new i32(1)) {}
+		Ref(Y* instance) : Ref(static_cast<T*>(instance), new u32(1), &Ref<Y>::del) {}
-		Ref(const Ref& rhs) : Ref(rhs.m_instance, rhs.m_counter) { if (m_counter) (*m_counter)++; }
+		Ref(const Ref& rhs) { copy(rhs); increment(); }
-		Ref(Ref&& rhs) : Ref(rhs.m_instance, rhs.m_counter) { rhs.m_instance = nullptr; rhs.m_counter = nullptr; }
+		Ref(Ref&& rhs) { steal(rhs); }
-
-		Ref& operator=(const Ref& rhs)
-		{
-			if (this != &rhs)
-			{
-				reset();
-				m_instance = rhs.m_instance; m_counter = rhs.m_counter;
-				if (m_counter) (*m_counter)++;
-			}
-			return *this;
-		}
-
-		Ref& operator=(Ref&& rhs)
-		{
-			if (this != &rhs)
-			{
-				reset();
-				m_instance = rhs.m_instance; m_counter = rhs.m_counter;
-				rhs.m_instance = nullptr; rhs.m_counter = nullptr;
-			}
-			return *this;
-		}
-
 		~Ref() { reset(); }
 
-		void reset()
+		Ref& operator=(const Ref& rhs) { if (this != &rhs) { reset(); copy(rhs); increment(); } return *this; }
-		{
+		Ref& operator=(Ref&& rhs) { if (this != &rhs) { reset(); steal(rhs); } return *this; }
-			if (m_counter) (*m_counter)--;
-			if (m_counter && (*m_counter) <= 0) { delete m_instance; delete m_counter; }
-			m_instance = nullptr; m_counter = nullptr;
-		}
 
-		int use_count() const { return (m_counter ? (*m_counter) : 0); }
+		void reset() { if (m_num && --(*m_num) <= 0) { m_del->delete_it(m_obj); delete m_num; } zero(); }
-		T* get() const { return m_instance; }
+		int use_count() const { return (m_num ? (*m_num) : 0); }
-		T* operator->() const { return m_instance; }
+		T* get() const { return m_obj; }
-		operator bool() const { return m_counter && (*m_counter) > 0; }
+		T* operator->() const { return m_obj; }
-		template<class Y> bool operator==(const Ref<Y>& rhs) const { return m_counter == rhs.m_counter; }
+		operator bool() const { return m_num && (*m_num) > 0; }
-		template<class Y> bool operator!=(const Ref<Y>& rhs) const { return m_counter != rhs.m_counter; }
+		template<class Y> bool operator==(const Ref<Y>& rhs) const { return m_num == rhs.m_num; }
-		template<class Y> operator Ref<Y>() { if (m_counter) (*m_counter)++; return Ref<Y>(static_cast<Y*>(m_instance), m_counter); }
+		template<class Y> bool operator!=(const Ref<Y>& rhs) const { return m_num != rhs.m_num; }
+		template<class Y> operator Ref<Y>() { increment(); return Ref<Y>(static_cast<Y*>(m_obj), m_num, m_del); }
 	};
 }
 #endif

include/blah/graphics/spritefont.h

@@ -3,13 +3,12 @@
 #include <blah/containers/str.h>
 #include <blah/containers/vector.h>
 #include <blah/graphics/subtexture.h>
+#include <blah/images/font.h>
 #include <blah/math/spatial.h>
 #include <blah/filesystem.h>
 
 namespace Blah
 {
-	class Font;
-
 	// Sprite Font is a bitmap font implementation for font rendering.
 	// It can be constructed from a Font (ttf) and will automatically create 
 	// texture atlases for rendering. You can add your own characters
@@ -59,30 +58,25 @@ namespace Blah
 		String name;
 
 		// Height, in pixels
-		float size;
+		float size = 0;
 
 		// Ascent, in pixels
-		float ascent;
+		float ascent = 0;
 
 		// Descent, in pixels
-		float descent;
+		float descent = 0;
 
 		// Line Gap, in pixels
-		float line_gap;
+		float line_gap = 0;
 
-		SpriteFont();
+		SpriteFont() = default;
 		SpriteFont(const FilePath& file, float size);
 		SpriteFont(const FilePath& file, float size, const CharSet& charset);
-		SpriteFont(const Font& font, float size);
+		SpriteFont(const FontRef& font, float size);
-		SpriteFont(const Font& font, float size, const CharSet& charset);
+		SpriteFont(const FontRef& font, float size, const CharSet& charset);
-		SpriteFont(const SpriteFont&) = delete;
-		SpriteFont& operator=(const SpriteFont&) = delete;
-		SpriteFont(SpriteFont&& src) noexcept;
-		SpriteFont& operator=(SpriteFont&& src) noexcept;
-		~SpriteFont();
 
 		// releases all assets used by the spritefont
-		void dispose();
+		void clear();
 
 		// gets the height of the sprite font
 		float height() const { return ascent - descent; }
@@ -106,7 +100,7 @@ namespace Blah
 		void rebuild(const FilePath& file, float size, const CharSet& charset);
 
 		// disposes the existing spritefont data and rebuilds from the given font
-		void rebuild(const Font& font, float size, const CharSet& charset);
+		void rebuild(const FontRef& font, float size, const CharSet& charset);
 
 		// gets the kerning between two characters
 		float get_kerning(Codepoint codepoint0, Codepoint codepoint1) const;

include/blah/images/font.h

@@ -1,14 +1,23 @@
 #pragma once
+#include <blah/common.h>
 #include <blah/streams/stream.h>
 #include <blah/images/image.h>
 #include <blah/containers/str.h>
+#include <blah/containers/vector.h>
 #include <blah/filesystem.h>
 
 namespace Blah
 {
-	// Loads fonts from file and can blit individual characters to images
+	class Font;
+	using FontRef = Ref<Font>;
+
+	// Loads fonts from file and can blit individual characters to images.
+	// Use Font::create() to instantiate a FontRef.
 	class Font
 	{
+	private:
+		Font() = default;
+
 	public:
 
 		// Font uses u32 Codepoints
@@ -42,18 +51,11 @@ namespace Blah
 			bool has_glyph = false;
 		};
 
-		Font();
+		// creates a new font from the given file path
-		Font(Stream& stream);
+		static FontRef create(const FilePath& path);
-		Font(const FilePath& path);
-		Font(const Font&) = delete;
-		Font& operator=(const Font&) = delete;
-		Font(Font&& src) noexcept;
-		Font& operator=(Font&& src) noexcept;
-		~Font();
 
-		// Releases all Font resources
+		// creates a new font from the Stream
-		// Note that after doing this various properties may become invalid (ex. font name)
+		static FontRef create(Stream& stream);
-		void dispose();
 
 		// returns the font family name
 		const String& family_name() const;
@@ -97,18 +99,13 @@ namespace Blah
 		// If the character doesn't exist, this will return an empty image.
 		Image get_image(const Character& ch) const;
 
-		// checks if the Font is valid
-		bool is_valid() const;
-
 	private:
-		void load(Stream& stream);
+		Ref<void> m_font;
-		void* m_font;
+		Vector<u8> m_buffer;
-		unsigned char* m_data;
 		String m_family_name;
 		String m_style_name;
-		int m_ascent;
+		int m_ascent = 0;
-		int m_descent;
+		int m_descent = 0;
-		int m_line_gap;
+		int m_line_gap = 0;
-		bool m_valid;
 	};
 }

include/blah/images/packer.h

@@ -69,11 +69,6 @@ namespace Blah
 
 		Packer();
 		Packer(int max_size, int spacing, bool power_of_two);
-		Packer(const Packer&) = delete;
-		Packer& operator=(const Packer&) = delete;
-		Packer(Packer&& src) noexcept;
-		Packer& operator=(Packer&& src) noexcept;
-		~Packer();
 		
 		// add a new entry
 		void add(u64 id, int width, int height, const Color* pixels);
@@ -96,9 +91,6 @@ namespace Blah
 		// clear the current packer data
 		void clear();
 
-		// dispose all resources used by the packer
-		void dispose();
-
 	private:
 		struct Node
 		{

include/blah/streams/bufferstream.h

@@ -8,34 +8,28 @@ namespace Blah
 	class BufferStream : public Stream
 	{
 	public:
-		BufferStream();
+		BufferStream() = default;
 		BufferStream(int capacity);
-		BufferStream(BufferStream&& bs) noexcept;
-		BufferStream& operator=(BufferStream&& bs) noexcept;
-		~BufferStream();
 
 		size_t length() const override;
 		size_t position() const override;
-		size_t seek(size_t seekTo) override;
+		size_t seek(size_t seek_to) override;
 		bool is_open() const override;
 		bool is_readable() const override;
 		bool is_writable() const override;
-		void close() override;
 
 		void resize(size_t length);
 		void clear();
 
-		char* data();
+		u8* data();
-		const char* data() const;
+		const u8* data() const;
 
 	protected:
 		size_t read_data(void* ptr, size_t length) override;
 		size_t write_data(const void* ptr, size_t length) override;
 
 	private:
-		char* m_buffer;
+		Vector<u8> m_buffer;
-		size_t m_capacity;
+		size_t m_position = 0;
-		size_t m_length;
-		size_t m_position;
 	};
 }

include/blah/streams/filestream.h

@@ -7,7 +7,7 @@ namespace Blah
 	class FileStream : public Stream
 	{
 	public:
-		FileStream();
+		FileStream() = default;
 		FileStream(const FilePath& path, FileMode mode);
 		FileStream(FileStream&& fs) noexcept;
 		FileStream& operator=(FileStream&& fs) noexcept;
@@ -18,14 +18,13 @@ namespace Blah
 		bool is_open() const override;
 		bool is_readable() const override;
 		bool is_writable() const override;
-		void close() override;
 
 	protected:
 		size_t read_data(void* ptr, size_t length) override;
 		size_t write_data(const void* ptr, size_t length) override;
 
 	private:
-		FileMode m_mode;
+		FileMode m_mode = FileMode::OpenRead;
 		FileRef m_file;
 	};
 }

include/blah/streams/memorystream.h

@@ -8,30 +8,28 @@ namespace Blah
 	class MemoryStream : public Stream
 	{
 	public:
-		MemoryStream();
+		MemoryStream() = default;
-		MemoryStream(unsigned char* data, size_t length);
+		MemoryStream(u8* data, size_t length);
-		MemoryStream(MemoryStream&& ms) noexcept;
+		MemoryStream(const u8* data, size_t length);
-		MemoryStream& operator=(MemoryStream&& ms) noexcept;
-		~MemoryStream() override { m_data = nullptr; m_length = m_position = 0; }
 
 		size_t length() const override;
 		size_t position() const override;
-		size_t seek(size_t seekTo) override;
+		size_t seek(size_t seek_to) override;
 		bool is_open() const override;
 		bool is_readable() const override;
 		bool is_writable() const override;
-		void close() override;
 
-		unsigned char* data();
+		u8* data();
-		const unsigned char* data() const;
+		const u8* data() const;
 
 	protected:
 		size_t read_data(void* ptr, size_t length) override;
 		size_t write_data(const void* ptr, size_t length) override;
 
 	private:
-		unsigned char* m_data;
+		u8* m_data = nullptr;
-		size_t m_length;
+		const u8* m_const_data = nullptr;
-		size_t m_position;
+		size_t m_length = 0;
+		size_t m_position = 0;
 	};
 }

include/blah/streams/stream.h

@@ -2,7 +2,6 @@
 #include <blah/common.h>
 #include <blah/containers/str.h>
 #include <blah/math/calc.h>
-#include <string.h>
 
 namespace Blah
 {
@@ -33,9 +32,6 @@ namespace Blah
 		// returns true of the stream is writable
 		virtual bool is_writable() const = 0;
 
-		// closes the stream
-		virtual void close() = 0;
-
 		// pipes the contents of this stream to another stream
 		size_t pipe(Stream& to, size_t length);
 

src/graphics/spritefont.cpp

@@ -14,14 +14,6 @@ SpriteFont::CharRange::CharRange(Codepoint from, Codepoint to)
 
 const SpriteFont::CharSet SpriteFont::CharRange::ASCII = SpriteFont::CharSet({ CharRange(32, 128) });
 
-SpriteFont::SpriteFont()
-{
-	size = 0;
-	ascent = 0;
-	descent = 0;
-	line_gap = 0;
-}
-
 SpriteFont::SpriteFont(const FilePath& file, float size)
 {
 	rebuild(file, size, CharRange::ASCII);
@@ -32,52 +24,22 @@ SpriteFont::SpriteFont(const FilePath& file, float size, const CharSet& charset)
 	rebuild(file, size, charset);
 }
 
-SpriteFont::SpriteFont(const Font& font, float size)
+SpriteFont::SpriteFont(const FontRef& font, float size)
 {
 	rebuild(font, size, CharRange::ASCII);
 }
 
-SpriteFont::SpriteFont(const Font& font, float size, const CharSet& charset)
+SpriteFont::SpriteFont(const FontRef& font, float size, const CharSet& charset)
 {
 	rebuild(font, size, charset);
 }
 
-SpriteFont::SpriteFont(SpriteFont&& src) noexcept
+void SpriteFont::clear()
-{
-	name = src.name;
-	size = src.size;
-	ascent = src.ascent;
-	descent = src.descent;
-	line_gap = src.line_gap;
-	m_characters = std::move(src.m_characters);
-	m_kerning = std::move(src.m_kerning);
-	m_atlas = std::move(src.m_atlas);
-}
-
-SpriteFont::~SpriteFont()
-{
-	dispose();
-}
-
-void SpriteFont::dispose()
 {
 	m_atlas.clear();
 	m_characters.clear();
 	m_kerning.clear();
-	name.dispose();
+	name.clear();
-}
-
-SpriteFont& SpriteFont::operator=(SpriteFont && src) noexcept
-{
-	name = src.name;
-	size = src.size;
-	ascent = src.ascent;
-	descent = src.descent;
-	line_gap = src.line_gap;
-	m_characters = std::move(src.m_characters);
-	m_kerning = std::move(src.m_kerning);
-	m_atlas = std::move(src.m_atlas);
-	return *this;
 }
 
 float SpriteFont::width_of(const String& text) const
@@ -86,7 +48,7 @@ float SpriteFont::width_of(const String& text) const
 	float line_width = 0;
 
 	Codepoint last = 0;
-	for (int i = 0; i < text.length(); i ++)
+	for (int i = 0; i < text.length(); i += text.utf8_length(i))
 	{
 		if (text[i] == '\n')
 		{
@@ -94,21 +56,12 @@ float SpriteFont::width_of(const String& text) const
 			continue;
 		}
 
-		// get codepoint
 		auto next = text.utf8_at(i);
-
+		line_width += get_character(next).advance;
-		// increment length
-		line_width += this->operator[](next).advance;
-		
-		// add kerning
 		if (i > 0)
 			line_width += get_kerning(last, next);
-
 		if (line_width > width)
 			width = line_width;
-
-		// move to thext utf8 character
-		i += text.utf8_length(i) - 1;
 		last = next;
 	}
 
@@ -123,26 +76,15 @@ float SpriteFont::width_of_line(const String& text, int start) const
 	float width = 0;
 
 	Codepoint last = 0;
-	for (auto i = start; i < text.length(); i ++)
+	for (auto i = start; i < text.length(); i += text.utf8_length(i))
 	{
 		if (text[i] == '\n')
 			return width;
 
-		// get codepoint
 		auto next = text.utf8_at(i);
-
+		width += get_character(next).advance;
-		// increment length
-		width += this->operator[](next).advance;
-		
-		// add kerning
 		if (i > 0)
 			width += get_kerning(last, next);
-
-		// move to thext utf8 character
-		auto len = text.utf8_length(i);
-		if (len > 0)
-			i += len - 1;
-
 		last = next;
 	}
 
@@ -155,11 +97,10 @@ float SpriteFont::height_of(const String& text) const
 		return 0;
 
 	float height = line_height();
-	for (auto i = 0; i < text.length(); i ++)
+	for (auto i = 0; i < text.length(); i += text.utf8_length(i))
 	{
 		if (text[i] == '\n')
 			height += line_height();
-		i += text.utf8_length(i) - 1;
 	}
 
 	return height - line_gap;
@@ -167,23 +108,24 @@ float SpriteFont::height_of(const String& text) const
 
 void SpriteFont::rebuild(const FilePath& file, float sz, const CharSet& charset)
 {
-	dispose();
+	clear();
 
-	Font font(file);
+	if (auto font = Font::create(file))
-	if (font.is_valid())
 		rebuild(font, sz, charset);
 }
 
-void SpriteFont::rebuild(const Font& font, float size, const CharSet& charset)
+void SpriteFont::rebuild(const FontRef& font, float size, const CharSet& charset)
 {
-	dispose();
+	clear();
+	if (!font)
+		return;
 
-	float scale = font.get_scale(size);
+	float scale = font->get_scale(size);
 
-	name = font.family_name();
+	name = font->family_name();
-	ascent = font.ascent() * scale;
+	ascent = font->ascent() * scale;
-	descent = font.descent() * scale;
+	descent = font->descent() * scale;
-	line_gap = font.line_gap() * scale;
+	line_gap = font->line_gap() * scale;
 	this->size = size;
 
 	Packer packer;
@@ -203,12 +145,12 @@ void SpriteFont::rebuild(const Font& font, float size, const CharSet& charset)
 
 		for (auto i = from; i < to; i++)
 		{
-			auto glyph = font.get_glyph(i);
+			auto glyph = font->get_glyph(i);
 			if (glyph <= 0)
 				continue;
 
 			// add character
-			auto ch = font.get_character(glyph, scale);
+			auto ch = font->get_character(glyph, scale);
 			auto& sfch = get_character(i);
 			sfch.codepoint = i;
 			sfch.advance = ch.advance;
@@ -220,7 +162,7 @@ void SpriteFont::rebuild(const Font& font, float size, const CharSet& charset)
 				if (buffer.size() < ch.width * ch.height)
 					buffer.resize(ch.width * ch.height);
 
-				if (font.get_image(ch, buffer.data()))
+				if (font->get_image(ch, buffer.data()))
 					packer.add(i, ch.width, ch.height, buffer.data());
 			}
 		}
@@ -242,7 +184,7 @@ void SpriteFont::rebuild(const Font& font, float size, const CharSet& charset)
 	{
 		for (auto& b : m_characters)
 		{
-			auto kerning_value = font.get_kerning(a.glyph, b.glyph, scale);
+			auto kerning_value = font->get_kerning(a.glyph, b.glyph, scale);
 			if (kerning_value != 0)
 				set_kerning(a.codepoint, b.codepoint, kerning_value);
 		}

src/images/font.cpp

@@ -32,105 +32,44 @@ namespace
 	}
 }
 
-Font::Font()
+FontRef Font::create(Stream& stream)
 {
-	m_font = nullptr;
+	if (!stream.is_readable())
-	m_data = nullptr;
+	{
-	m_ascent = 0;
+		Log::error("Unable to load a font as the Stream was not readable");
-	m_descent = 0;
+		return FontRef();
-	m_line_gap = 0;
+	}
-	m_valid = false;
+
+	// read into buffer
+	Vector<u8> buffer;
+	buffer.reserve(stream.length());
+	stream.read(buffer.data(), stream.length());
+
+	// init font
+	auto stbtt = Ref<stbtt_fontinfo>(new stbtt_fontinfo());
+	auto fn = (stbtt_fontinfo*)stbtt.get();
+	if (stbtt_InitFont(fn, buffer.data(), 0) == 0)
+	{
+		Log::error("Unable to parse Font file");
+		return false;
+	}
+
+	// setup
+	auto font = FontRef(new Font());
+	font->m_font = stbtt;
+	font->m_buffer = std::move(buffer);
+	font->m_family_name = get_font_name(fn, 1);
+	font->m_style_name = get_font_name(fn, 2);
+	stbtt_GetFontVMetrics(fn, &font->m_ascent, &font->m_descent, &font->m_line_gap);
+	return font;
 }
 
-Font::Font(Stream& stream) : Font()
+FontRef Font::create(const FilePath& path)
-{
-	load(stream);
-}
-
-Font::Font(const FilePath& path) : Font()
 {
 	FileStream fs(path, FileMode::OpenRead);
 	if (fs.is_readable())
-		load(fs);
+		return create(fs);
-}
+	return FontRef();
-
-Font::Font(Font&& src) noexcept
-{
-	m_font = src.m_font;
-	m_data = src.m_data;
-	m_family_name = src.m_family_name;
-	m_style_name = src.m_style_name;
-	m_ascent = src.m_ascent;
-	m_descent = src.m_descent;
-	m_line_gap = src.m_line_gap;
-	m_valid = src.m_valid;
-
-	src.m_family_name.clear();
-	src.m_style_name.clear();
-	src.m_valid = false;
-	src.m_font = nullptr;
-	src.m_data = nullptr;
-}
-
-Font& Font::operator=(Font&& src) noexcept
-{
-	m_font = src.m_font;
-	m_data = src.m_data;
-	m_family_name = src.m_family_name;
-	m_style_name = src.m_style_name;
-	m_ascent = src.m_ascent;
-	m_descent = src.m_descent;
-	m_line_gap = src.m_line_gap;
-	m_valid = src.m_valid;
-
-	src.m_family_name.clear();
-	src.m_style_name.clear();
-	src.m_valid = false;
-	src.m_font = nullptr;
-	src.m_data = nullptr;
-	return *this;
-}
-
-Font::~Font()
-{
-	dispose();
-}
-
-void Font::load(Stream& stream)
-{
-	dispose();
-
-	if (!stream.is_readable())
-	{
-		BLAH_ASSERT(false, "Unable to load a font as the Stream was not readable");
-		return;
-	}
-
-	// create data buffer
-	auto size = stream.length();
-	m_data = new unsigned char[size];
-	stream.read(m_data, size);
-
-	// init font
-	m_font = new stbtt_fontinfo();
-	auto fn = (stbtt_fontinfo*)m_font;
-	stbtt_InitFont(fn, m_data, 0);
-	m_family_name = get_font_name(fn, 1);
-	m_style_name = get_font_name(fn, 2);
-	
-	// properties
-	stbtt_GetFontVMetrics(fn, &m_ascent, &m_descent, &m_line_gap);
-	m_valid = true;
-}
-
-void Font::dispose()
-{
-	delete (stbtt_fontinfo*)m_font;
-	delete[] m_data;
-	m_font = nullptr;
-	m_data = nullptr;
-	m_family_name.dispose();
-	m_style_name.dispose();
 }
 
 const String& Font::family_name() const
@@ -172,7 +111,7 @@ int Font::get_glyph(Codepoint codepoint) const
 {
 	if (!m_font)
 		return 0;
-	return stbtt_FindGlyphIndex((stbtt_fontinfo*)m_font, codepoint);
+	return stbtt_FindGlyphIndex((stbtt_fontinfo*)m_font.get(), codepoint);
 }
 
 float Font::get_scale(float size) const
@@ -180,14 +119,14 @@ float Font::get_scale(float size) const
 	if (!m_font)
 		return 0;
 	
-	return stbtt_ScaleForMappingEmToPixels((stbtt_fontinfo*)m_font, size);
+	return stbtt_ScaleForMappingEmToPixels((stbtt_fontinfo*)m_font.get(), size);
 }
 
 float Font::get_kerning(int glyph1, int glyph2, float scale) const
 {
 	if (!m_font)
 		return 0;
-	return stbtt_GetGlyphKernAdvance((stbtt_fontinfo*)m_font, glyph1, glyph2) * scale;
+	return stbtt_GetGlyphKernAdvance((stbtt_fontinfo*)m_font.get(), glyph1, glyph2) * scale;
 }
 
 Font::Character Font::get_character(int glyph, float scale) const
@@ -199,8 +138,8 @@ Font::Character Font::get_character(int glyph, float scale) const
 
 	int advance, offsetX, x0, y0, x1, y1;
 
-	stbtt_GetGlyphHMetrics((stbtt_fontinfo*)m_font, glyph, &advance, &offsetX);
+	stbtt_GetGlyphHMetrics((stbtt_fontinfo*)m_font.get(), glyph, &advance, &offsetX);
-	stbtt_GetGlyphBitmapBox((stbtt_fontinfo*)m_font, glyph, scale, scale, &x0, &y0, &x1, &y1);
+	stbtt_GetGlyphBitmapBox((stbtt_fontinfo*)m_font.get(), glyph, scale, scale, &x0, &y0, &x1, &y1);
 
 	int w = (x1 - x0);
 	int h = (y1 - y0);
@@ -213,7 +152,7 @@ Font::Character Font::get_character(int glyph, float scale) const
 	ch.offset_x = offsetX * scale;
 	ch.offset_y = (float)y0;
 	ch.scale = scale;
-	ch.has_glyph = (w > 0 && h > 0 && stbtt_IsGlyphEmpty((stbtt_fontinfo*)m_font, glyph) == 0);
+	ch.has_glyph = (w > 0 && h > 0 && stbtt_IsGlyphEmpty((stbtt_fontinfo*)m_font.get(), glyph) == 0);
 
 	return ch;
 }
@@ -225,7 +164,7 @@ bool Font::get_image(const Font::Character& ch, Color* pixels) const
 		// we actually use the image buffer as our temporary buffer, and fill the pixels out backwards after
 		// kinda weird but it works & saves creating more memory
 		auto* src = (unsigned char*)pixels;
-		stbtt_MakeGlyphBitmap((stbtt_fontinfo*)m_font, src, ch.width, ch.height, ch.width, ch.scale, ch.scale, ch.glyph);
+		stbtt_MakeGlyphBitmap((stbtt_fontinfo*)m_font.get(), src, ch.width, ch.height, ch.width, ch.scale, ch.scale, ch.glyph);
 
 		int len = ch.width * ch.height;
 		for (int a = (len - 1) * 4, b = (len - 1); b >= 0; a -= 4, b -= 1)
@@ -250,9 +189,4 @@ Image Font::get_image(const Font::Character& ch) const
 		return img;
 
 	return Image();
-}
-
-bool Font::is_valid() const
-{
-	return m_valid;
 }

src/images/packer.cpp

@@ -11,36 +11,6 @@ Packer::Packer()
 Packer::Packer(int max_size, int spacing, bool power_of_two)
 	: max_size(max_size), power_of_two(power_of_two), spacing(spacing), padding(1), m_dirty(false) { }
 
-Packer::Packer(Packer&& src) noexcept
-{
-	max_size = src.max_size;
-	power_of_two = src.power_of_two;
-	spacing = src.spacing;
-	padding = src.padding;
-	m_dirty = src.m_dirty;
-	pages = std::move(src.pages);
-	m_entries = std::move(src.m_entries);
-	m_buffer = std::move(src.m_buffer);
-}
-
-Packer& Packer::operator=(Packer&& src) noexcept
-{
-	max_size = src.max_size;
-	power_of_two = src.power_of_two;
-	spacing = src.spacing;
-	padding = src.padding;
-	m_dirty = src.m_dirty;
-	pages = std::move(src.pages);
-	m_entries = std::move(src.m_entries);
-	m_buffer = std::move(src.m_buffer);
-	return *this;
-}
-
-Packer::~Packer()
-{
-	dispose();
-}
-
 void Packer::add(u64 id, int width, int height, const Color* pixels)
 {
 	add_entry(id, width, height, pixels, Recti(0, 0, width, height));
@@ -308,17 +278,7 @@ void Packer::clear()
 {
 	pages.clear();
 	m_entries.clear();
-	m_dirty = false;
+	m_buffer.clear();
-}
-
-void Packer::dispose()
-{
-	pages.clear();
-	m_entries.clear();
-	m_buffer.close();
-	max_size = 0;
-	power_of_two = 0;
-	spacing = 0;
 	m_dirty = false;
 }
 

src/streams/bufferstream.cpp

@@ -3,51 +3,14 @@
 
 using namespace Blah;
 
-BufferStream::BufferStream()
-	: m_buffer(nullptr), m_capacity(0), m_length(0), m_position(0) {}
-
 BufferStream::BufferStream(int capacity)
-	: m_buffer(nullptr), m_capacity(0), m_length(0), m_position(0)
 {
-	if (capacity > 0)
+	m_buffer.resize(capacity);
-	{
-		m_buffer = new char[capacity];
-		m_capacity = capacity;
-	}
-}
-
-BufferStream::BufferStream(BufferStream&& src) noexcept
-{
-	m_buffer = src.m_buffer;
-	m_length = src.m_length;
-	m_capacity = src.m_capacity;
-	m_position = src.m_position;
-	src.m_buffer = nullptr;
-	src.m_position = src.m_length = src.m_capacity = 0;
-}
-
-BufferStream& BufferStream::operator=(BufferStream&& src) noexcept
-{
-	close();
-
-	m_buffer = src.m_buffer;
-	m_length = src.m_length;
-	m_capacity = src.m_capacity;
-	m_position = src.m_position;
-	src.m_buffer = nullptr;
-	src.m_position = src.m_length = src.m_capacity = 0;
-
-	return *this;
-}
-
-BufferStream::~BufferStream()
-{
-	delete[] m_buffer;
 }
 
 size_t BufferStream::length() const
 {
-	return m_length;
+	return m_buffer.size();
 }
 
 size_t BufferStream::position() const
@@ -55,23 +18,20 @@ size_t BufferStream::position() const
 	return m_position;
 }
 
-size_t BufferStream::seek(size_t seekTo)
+size_t BufferStream::seek(size_t seek_to)
 {
-	return m_position = (seekTo < 0 ? 0 : (seekTo > m_length ? m_length : seekTo));
+	return m_position = (seek_to < 0 ? 0 : (seek_to > m_buffer.size() ? m_buffer.size() : seek_to));
 }
 
 size_t BufferStream::read_data(void* ptr, size_t len)
 {
-	if (m_buffer == nullptr || ptr == nullptr)
+	if (ptr == nullptr || len <= 0)
 		return 0;
 
-	if (len < 0)
+	if (len > m_buffer.size() - m_position)
-		return 0;
+		len = m_buffer.size() - m_position;
 
-	if (len > m_length - m_position)
+	memcpy(ptr, m_buffer.data() + m_position, (size_t)len);
-		len = m_length - m_position;
-
-	memcpy(ptr, m_buffer + m_position, (size_t)len);
 	m_position += len;
 	return len;
 }
@@ -82,12 +42,12 @@ size_t BufferStream::write_data(const void* ptr, size_t len)
 		return 0;
 
 	// resize
-	if (m_position + len > m_length)
+	if (m_position + len > m_buffer.size())
 		resize(m_position + len);
 
 	// copy data
 	if (ptr != nullptr)
-		memcpy(m_buffer + m_position, ptr, (size_t)len);
+		memcpy(m_buffer.data() + m_position, ptr, (size_t)len);
 
 	// increment position
 	m_position += len;
@@ -96,70 +56,27 @@ size_t BufferStream::write_data(const void* ptr, size_t len)
 	return len;
 }
 
-bool BufferStream::is_open() const
+bool BufferStream::is_open() const { return true; }
-{
+bool BufferStream::is_readable() const { return true; }
-	return m_buffer != nullptr;
+bool BufferStream::is_writable() const { return true; }
-}
-
-bool BufferStream::is_readable() const
-{
-	return true;
-}
-
-bool BufferStream::is_writable() const
-{
-	return true;
-}
 
 void BufferStream::resize(size_t length)
 {
-	if (m_capacity > length)
+	m_buffer.resize(length);
-	{
-		m_length = length;
-	}
-	else
-	{
-		auto last_capacity = m_capacity;
-
-		if (m_capacity <= 0)
-			m_capacity = 16;
-		while (length >= m_capacity)
-			m_capacity *= 2;
-
-		char* new_buffer = new char[m_capacity];
-
-		if (m_buffer != nullptr)
-		{
-			memcpy(new_buffer, m_buffer, last_capacity);
-			delete[] m_buffer;
-		}
-
-		m_buffer = new_buffer;
-	}
-
-	m_length = length;
-}
-
-void BufferStream::close()
-{
-	delete[] m_buffer;
-	m_buffer = nullptr;
-	m_position = 0;
-	m_length = 0;
-	m_capacity = 0;
 }
 
 void BufferStream::clear()
 {
-	m_length = m_position = 0;
+	m_buffer.clear();
+	m_position = 0;
 }
 
-char* BufferStream::data()
+u8* BufferStream::data()
 {
-	return m_buffer;
+	return m_buffer.data();
 }
 
-const char* BufferStream::data() const
+const u8* BufferStream::data() const
 {
-	return m_buffer;
+	return m_buffer.data();
 }

src/streams/filestream.cpp

@@ -5,11 +5,6 @@
 
 using namespace Blah;
 
-FileStream::FileStream()
-{
-	m_mode = FileMode::OpenRead;
-}
-
 FileStream::FileStream(const FilePath& path, FileMode mode)
 	: m_mode(mode)
 	, m_file(File::open(path, mode))
@@ -58,8 +53,6 @@ size_t FileStream::read_data(void* ptr, size_t length)
 
 	if (m_file)
 		return m_file->read((unsigned char*)ptr, length);
-
-	BLAH_ASSERT(false, "Unable to read from Stream");
 	return 0;
 }
 
@@ -70,8 +63,6 @@ size_t FileStream::write_data(const void* ptr, size_t length)
 
 	if (m_file)
 		return m_file->write((const unsigned char*)ptr, length);
-
-	BLAH_ASSERT(false, "Unable to write to Stream");
 	return 0;
 }
 
@@ -88,9 +79,4 @@ bool FileStream::is_readable() const
 bool FileStream::is_writable() const
 {
 	return m_file.get() && (m_mode != FileMode::OpenRead);
-}
-
-void FileStream::close()
-{
-	m_file.reset();
 }

src/streams/memorystream.cpp

@@ -3,30 +3,11 @@
 
 using namespace Blah;
 
-MemoryStream::MemoryStream()
+MemoryStream::MemoryStream(u8* data, size_t length)
-	: m_data(nullptr), m_length(0), m_position(0) {}
+	: m_data(data), m_const_data(nullptr), m_length(length), m_position(0) {}
 
-MemoryStream::MemoryStream(unsigned char* data, size_t length)
+MemoryStream::MemoryStream(const u8* data, size_t length)
-	: m_data(data), m_length(length), m_position(0) {}
+	: m_data(nullptr), m_const_data(data), m_length(length), m_position(0) {}
-
-MemoryStream::MemoryStream(MemoryStream&& src) noexcept
-{
-	m_data = src.m_data;
-	m_position = src.m_position;
-	m_length = src.m_length;
-	src.m_data = nullptr;
-	src.m_length = src.m_position = 0;
-}
-
-MemoryStream& MemoryStream::operator=(MemoryStream&& src) noexcept
-{
-	m_data = src.m_data;
-	m_position = src.m_position;
-	m_length = src.m_length;
-	src.m_data = nullptr;
-	src.m_length = src.m_position = 0;
-	return *this;
-}
 
 size_t MemoryStream::length() const
 {
@@ -38,63 +19,60 @@ size_t MemoryStream::position() const
 	return m_position;
 }
 
-size_t MemoryStream::seek(size_t seekTo)
+size_t MemoryStream::seek(size_t seek_to)
 {
-	return m_position = (seekTo < 0 ? 0 : (seekTo > m_length ? m_length : seekTo));
+	return m_position = (seek_to < 0 ? 0 : (seek_to > m_length ? m_length : seek_to));
 }
 
 size_t MemoryStream::read_data(void* ptr, size_t len)
 {
-	if (len < 0 || ptr == nullptr)
+	const u8* src = (m_data ? m_data : m_const_data);
+
+	if (src == nullptr || ptr == nullptr || len <= 0 || m_length <= 0 || m_position >= m_length)
 		return 0;
 
 	if (len > m_length - m_position)
 		len = m_length - m_position;
 
-	memcpy(ptr, m_data + m_position, (size_t)len);
+	memcpy(ptr, src + m_position, len);
 	m_position += len;
 	return len;
 }
 
 size_t MemoryStream::write_data(const void* ptr, size_t len)
 {
-	if (len < 0 || ptr == nullptr)
+	if (m_data == nullptr || ptr == nullptr || len <= 0 || m_length <= 0 || m_position >= m_length)
 		return 0;
 
 	if (len > m_length - m_position)
 		len = m_length - m_position;
 
-	memcpy(m_data + m_position, ptr, (size_t)len);
+	memcpy(m_data + m_position, ptr, len);
 	m_position += len;
 	return len;
 }
 
 bool MemoryStream::is_open() const
 {
-	return m_data != nullptr;
+	return (m_data || m_const_data) && m_length > 0;
 }
 
 bool MemoryStream::is_readable() const
 {
-	return true;
+	return (m_data || m_const_data) && m_length > 0;
 }
 
 bool MemoryStream::is_writable() const
 {
-	return true;
+	return m_data != nullptr && m_length > 0;
 }
 
-void MemoryStream::close()
+u8* MemoryStream::data()
-{
-	m_data = nullptr; m_length = m_position = 0;
-}
-
-unsigned char* MemoryStream::data()
 {
 	return m_data;
 }
 
-const unsigned char* MemoryStream::data() const
+const u8* MemoryStream::data() const
 {
-	return m_data;
+	return (m_data ? m_data : m_const_data);
 }