refactoring rendering backend a little

CMakeLists.txt

@@ -17,8 +17,8 @@ add_library(blah
 	public/blah/time.cpp
 	public/blah/time.h
 
-	public/blah/graphics/graphics.cpp
 	public/blah/graphics/graphics.h
+	public/blah/graphics/graphics.cpp
 	public/blah/graphics/texture.h
 	public/blah/graphics/framebuffer.h
 	public/blah/graphics/shader.h
@@ -27,8 +27,8 @@ add_library(blah
 	public/blah/graphics/material.h
 	public/blah/graphics/material.cpp
 
-	public/blah/input/input.cpp
 	public/blah/input/input.h
+	public/blah/input/input.cpp
 	public/blah/input/virtual_stick.cpp
 	public/blah/input/virtual_stick.h
 	public/blah/input/virtual_button.cpp
@@ -94,14 +94,15 @@ add_library(blah
 	public/blah/streams/stream.cpp
 	public/blah/streams/stream.h
 
+	private/blah/internal/graphics_backend.h
+	private/blah/internal/graphics_backend_gl.cpp
+	private/blah/internal/input_backend.h
+	private/blah/internal/platform_backend.h
+	private/blah/internal/platform_backend_sdl2.cpp
+	
 	private/blah/third_party/stb_image.h
 	private/blah/third_party/stb_image_write.h
-	private/blah/third_party/stb_truetype.h
+	private/blah/third_party/stb_truetype.h)
-	private/blah/internal/graphics.h
-	private/blah/internal/graphics_opengl.cpp
-	private/blah/internal/input.h
-	private/blah/internal/platform.h
-	private/blah/internal/platform_sdl2.cpp)
 
 target_include_directories(blah
 	PUBLIC

private/blah/internal/graphics.h

@@ -1,68 +0,0 @@
-#pragma once
-#include <blah/graphics/graphics.h>
-
-namespace Blah
-{
-	namespace Internal
-	{
-		class GraphicsDevice;
-
-		// graphics device metadata used to instantiate and destroy
-		// devices of specific apis
-		struct GraphicsDeviceInfo
-		{
-			GfxAPI api;
-			bool (*supported)();
-			GraphicsDevice* (*create)();
-			void (*destroy)(GraphicsDevice*);
-		};
-
-		// graphics implementations
-		extern GraphicsDeviceInfo OpenGL_DeviceInfo;
-
-		// graphics device
-		// each graphics implementation needs to implement this
-		// ex. one for opengl, one for vulkan, etc
-		class GraphicsDevice
-		{
-		public:
-			bool valid = false;
-			GraphicsInfo info;
-
-			virtual ~GraphicsDevice() = default;
-			virtual void startup() = 0;
-			virtual void update() = 0;
-			virtual void shutdown() = 0;
-			virtual void before_render() = 0;
-			virtual void after_render() = 0;
-
-			virtual TextureRef create_texture(int width, int height, TextureFilter filter, TextureWrap wrap_x, TextureWrap wrap_y, TextureFormat format) = 0;
-			virtual FrameBufferRef create_framebuffer(int width, int height, const TextureFormat* attachments, int attachmentCount) = 0;
-			virtual ShaderRef create_shader(const ShaderData* data) = 0;
-			virtual MeshRef create_mesh() = 0;
-			virtual void render(RenderCall* call) = 0;
-			virtual void clear(const FrameBufferRef& target, uint32_t rgba) = 0;
-		};
-
-		namespace Graphics
-		{
-			// Picks a graphics API based on the available APIs
-			GfxAPI pick_api();
-
-			// Initializes the Graphics with the given API
-			bool init(GfxAPI api);
-
-			// Is called internally by the Application every update
-			void frame();
-
-			// Is called internally by the Application before every render
-			void before_render();
-
-			// Is called internally by the Application after every render
-			void after_render();
-
-			// Called when the Application is shutting down
-			void shutdown();
-		}
-	}
-}

private/blah/internal/graphics_backend.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <blah/graphics/graphics.h>
+
+namespace Blah
+{
+	namespace GraphicsBackend
+	{
+		bool init();
+		void shutdown();
+
+		const GraphicsInfo* info();
+		GraphicsRenderer renderer();
+		void frame();
+		void before_render();
+		void after_render();
+		void render(RenderCall* call);
+		void clear(const FrameBufferRef& target, uint32_t rgba);
+
+		TextureRef create_texture(int width, int height, TextureFilter filter, TextureWrap wrap_x, TextureWrap wrap_y, TextureFormat format);
+		FrameBufferRef create_framebuffer(int width, int height, const TextureFormat* attachments, int attachmentCount);
+		ShaderRef create_shader(const ShaderData* data);
+		MeshRef create_mesh();
+	}
+}

private/blah/internal/input.h

@@ -1,57 +0,0 @@
-#pragma once
-#include <blah/input/input.h>
-
-namespace Blah
-{
-	namespace Internal
-	{
-		namespace Input
-		{
-			// This is called internally by the app, and initializes the input state
-			void init();
-
-			// This is called internally by the app, and updates the input state
-			void frame();
-
-			// Call this when the Mouse moves relative to the window
-			void on_mouse_move(float x, float y);
-
-			// Call this when the Mouse moves relative to the screen
-			void on_mouse_screen_move(float x, float y);
-
-			// Call this when a Mouse Button is pressed
-			void on_mouse_down(MouseButton button);
-
-			// Call this when a Mouse Button is released
-			void on_mouse_up(MouseButton button);
-
-			// Call this when the Mouse Wheel moves
-			void on_mouse_wheel(Point wheel);
-
-			// Call this when a keyboard key is pressed
-			void on_key_down(Key key);
-
-			// Call this when a keyboard key is released
-			void on_key_up(Key key);
-
-			// Call this on Text Input
-			void on_text_utf8(const char* text);
-
-			// Call this when a Controller is connected. Note that the Name parameter must be kept valid
-			// until on_controller_disconnect is called with the same index.
-			void on_controller_connect(int index, const char* name, int isGamepad, int buttonCount, int axisCount);
-
-			// Call this when a controller is disconnected
-			void on_controller_disconnect(int index);
-
-			// Call this when a controller button is pressed
-			void on_button_down(int index, int button);
-
-			// Call this when a controller button is released
-			void on_button_up(int index, int button);
-
-			/// Call this when a controller axis is moved
-			void on_axis_move(int index, int axis, float value);
-		}
-	}
-}

private/blah/internal/input_backend.h

@@ -0,0 +1,54 @@
+#pragma once
+#include <blah/input/input.h>
+
+namespace Blah
+{
+	namespace InputBackend
+	{
+		// This is called internally by the app, and initializes the input state
+		void init();
+
+		// This is called internally by the app, and updates the input state
+		void frame();
+
+		// Call this when the Mouse moves relative to the window
+		void on_mouse_move(float x, float y);
+
+		// Call this when the Mouse moves relative to the screen
+		void on_mouse_screen_move(float x, float y);
+
+		// Call this when a Mouse Button is pressed
+		void on_mouse_down(MouseButton button);
+
+		// Call this when a Mouse Button is released
+		void on_mouse_up(MouseButton button);
+
+		// Call this when the Mouse Wheel moves
+		void on_mouse_wheel(Point wheel);
+
+		// Call this when a keyboard key is pressed
+		void on_key_down(Key key);
+
+		// Call this when a keyboard key is released
+		void on_key_up(Key key);
+
+		// Call this on Text Input
+		void on_text_utf8(const char* text);
+
+		// Call this when a Controller is connected. Note that the Name parameter must be kept valid
+		// until on_controller_disconnect is called with the same index.
+		void on_controller_connect(int index, const char* name, int isGamepad, int buttonCount, int axisCount);
+
+		// Call this when a controller is disconnected
+		void on_controller_disconnect(int index);
+
+		// Call this when a controller button is pressed
+		void on_button_down(int index, int button);
+
+		// Call this when a controller button is released
+		void on_button_up(int index, int button);
+
+		/// Call this when a controller axis is moved
+		void on_axis_move(int index, int axis, float value);
+	}
+}

private/blah/internal/platform.h

@@ -1,120 +0,0 @@
-#pragma once
-#include <inttypes.h>
-#include <blah/filesystem.h>
-#include <blah/containers/vector.h>
-
-namespace Blah
-{
-	struct Config;
-	enum class FileMode;
-
-	namespace Internal
-	{
-		namespace Platform
-		{
-			typedef void* FileHandle;
-
-			// Initialize the System
-			bool init(const Config* config);
-
-			// Called after the on_startup callback, but before the update loop begins
-			void ready();
-
-			// Called during shutdown
-			void shutdown();
-
-			// The time, in milliseconds, since the Application was started
-			uint64_t time();
-
-			// Called every frame
-			void frame();
-
-			// Sleeps the current thread
-			void sleep(int milliseconds);
-
-			// Called to present the window contents
-			void present();
-
-			// Gets the Application Window Title in UTF-8
-			const char* get_title();
-
-			// Sets the Application Window Title in UTF-8
-			void set_title(const char* title);
-
-			// Gets the Application Window Position, in Screen Coordinates
-			void get_position(int* x, int* y);
-
-			// Sets the Application Window Position, in Screen Coordinates
-			void set_position(int x, int y);
-
-			// Sets the Window Fullscreen if enabled is not 0
-			void set_fullscreen(bool enabled);
-
-			// Gets the Application Window Size, in Screen Coordinates
-			void get_size(int* width, int* height);
-
-			// Sets the Application Window Size, in Screen Coordinates
-			void set_size(int width, int height);
-
-			// Gets the Application Window Drawing Size, in Pixels. This may differ from the Window Size on hi-dpi displays.
-			void get_draw_size(int* width, int* height);
-
-			// Gets the Desktop Content Scale. Gui should be scaled by this value
-			float get_content_scale();
-
-			// Returns the absoluate path to the directory that the application was started from
-			const char* app_path();
-
-			// Returns the absolute path to the user directory where save data and settings should be stored
-			const char* user_path();
-
-			// Returns true if a file with the given path exists
-			bool file_exists(const char* path);
-
-			// Returns true if a file with the given path was deleted
-			bool file_delete(const char* path);
-
-			// Returns true if a directory with the given path was successfully created
-			bool dir_create(const char* path);
-
-			// Returns true if a directory with the given path exists
-			bool dir_exists(const char* path);
-
-			// Returns true if a directory with the given path was deleted
-			bool dir_delete(const char* path);
-
-			// enumerates a directory and appends each file to the given list
-			void dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive);
-
-			// opens a directory in the OS file explorer / finder
-			void dir_explore(const char* path);
-
-			// Opens a file and sets the handle. returns true if the file was successfully opened
-			bool file_open(const char* path, FileHandle* handle, FileMode mode);
-
-			// Returns the length of the file
-			int64_t file_length(FileHandle file);
-
-			// Returns the Position of the file
-			int64_t file_position(FileHandle file);
-
-			// Seeks the Position of the file and returns the new position from the start of the file
-			int64_t file_seek(FileHandle file, int64_t seekTo);
-
-			// Reads a specific number of elements of a given size from the file into ptr
-			int64_t file_read(FileHandle file, void* ptr, int64_t size);
-
-			// Writes a specific number of elements of the given size from ptr to the file
-			int64_t file_write(FileHandle file, const void* ptr, int64_t size);
-
-			// Closes a file
-			void file_close(FileHandle file);
-
-			// OpenGL Methods
-			void* gl_get_func(const char* name);
-			void* gl_context_create();
-			void gl_context_make_current(void* context);
-			void gl_context_destroy(void* context);
-		}
-	}
-}

private/blah/internal/platform_backend.h

@@ -0,0 +1,117 @@
+#pragma once
+#include <inttypes.h>
+#include <blah/filesystem.h>
+#include <blah/containers/vector.h>
+
+namespace Blah
+{
+	struct Config;
+	enum class FileMode;
+
+	namespace PlatformBackend
+	{
+		typedef void* FileHandle;
+
+		// Initialize the System
+		bool init(const Config* config);
+
+		// Called after the on_startup callback, but before the update loop begins
+		void ready();
+
+		// Called during shutdown
+		void shutdown();
+
+		// The time, in milliseconds, since the Application was started
+		uint64_t time();
+
+		// Called every frame
+		void frame();
+
+		// Sleeps the current thread
+		void sleep(int milliseconds);
+
+		// Called to present the window contents
+		void present();
+
+		// Gets the Application Window Title in UTF-8
+		const char* get_title();
+
+		// Sets the Application Window Title in UTF-8
+		void set_title(const char* title);
+
+		// Gets the Application Window Position, in Screen Coordinates
+		void get_position(int* x, int* y);
+
+		// Sets the Application Window Position, in Screen Coordinates
+		void set_position(int x, int y);
+
+		// Sets the Window Fullscreen if enabled is not 0
+		void set_fullscreen(bool enabled);
+
+		// Gets the Application Window Size, in Screen Coordinates
+		void get_size(int* width, int* height);
+
+		// Sets the Application Window Size, in Screen Coordinates
+		void set_size(int width, int height);
+
+		// Gets the Application Window Drawing Size, in Pixels. This may differ from the Window Size on hi-dpi displays.
+		void get_draw_size(int* width, int* height);
+
+		// Gets the Desktop Content Scale. Gui should be scaled by this value
+		float get_content_scale();
+
+		// Returns the absoluate path to the directory that the application was started from
+		const char* app_path();
+
+		// Returns the absolute path to the user directory where save data and settings should be stored
+		const char* user_path();
+
+		// Returns true if a file with the given path exists
+		bool file_exists(const char* path);
+
+		// Returns true if a file with the given path was deleted
+		bool file_delete(const char* path);
+
+		// Returns true if a directory with the given path was successfully created
+		bool dir_create(const char* path);
+
+		// Returns true if a directory with the given path exists
+		bool dir_exists(const char* path);
+
+		// Returns true if a directory with the given path was deleted
+		bool dir_delete(const char* path);
+
+		// enumerates a directory and appends each file to the given list
+		void dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive);
+
+		// opens a directory in the OS file explorer / finder
+		void dir_explore(const char* path);
+
+		// Opens a file and sets the handle. returns true if the file was successfully opened
+		bool file_open(const char* path, FileHandle* handle, FileMode mode);
+
+		// Returns the length of the file
+		int64_t file_length(FileHandle file);
+
+		// Returns the Position of the file
+		int64_t file_position(FileHandle file);
+
+		// Seeks the Position of the file and returns the new position from the start of the file
+		int64_t file_seek(FileHandle file, int64_t seekTo);
+
+		// Reads a specific number of elements of a given size from the file into ptr
+		int64_t file_read(FileHandle file, void* ptr, int64_t size);
+
+		// Writes a specific number of elements of the given size from ptr to the file
+		int64_t file_write(FileHandle file, const void* ptr, int64_t size);
+
+		// Closes a file
+		void file_close(FileHandle file);
+
+		// OpenGL Methods
+		void* gl_get_func(const char* name);
+		void* gl_context_create();
+		void gl_context_make_current(void* context);
+		void gl_context_destroy(void* context);
+	}
+}

private/blah/internal/platform_backend_sdl2.cpp

@@ -1,7 +1,8 @@
 #ifdef BLAH_USE_SDL2
 
-#include <blah/internal/platform.h>
+#include <blah/internal/platform_backend.h>
-#include <blah/internal/input.h>
+#include <blah/internal/input_backend.h>
+#include <blah/internal/graphics_backend.h>
 #include <blah/input/input.h>
 #include <blah/app.h>
 #include <blah/filesystem.h>
@@ -26,7 +27,6 @@ namespace fs = std::filesystem;
 #endif
 
 using namespace Blah;
-using namespace Internal;
 
 namespace
 {
@@ -48,7 +48,7 @@ namespace
 	}
 }
 
-bool Platform::init(const Config* config)
+bool PlatformBackend::init(const Config* config)
 {
 	// Required to call this for Windows
 	// I'm not sure why SDL2 doesn't do this on Windows automatically?
@@ -73,9 +73,13 @@ bool Platform::init(const Config* config)
 		return false;
 	}
 
+	int flags = SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
+
 	// GL Attributes
-	if (config->graphics == GfxAPI::OpenGL)
+	if (GraphicsBackend::renderer() == GraphicsRenderer::OpenGL)
 	{
+		flags |= SDL_WINDOW_OPENGL;
+
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
 		SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
@@ -90,11 +94,6 @@ bool Platform::init(const Config* config)
 		SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
 	}
 
-	// set up window flags
-	int flags = SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
-	if (config->graphics == GfxAPI::OpenGL)
-		flags |= SDL_WINDOW_OPENGL;
-
 	// create the window
 	window = SDL_CreateWindow(config->name, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, config->width, config->height, flags);
 	if (window == nullptr)
@@ -133,14 +132,14 @@ bool Platform::init(const Config* config)
 	return true;
 }
 
-void Platform::ready()
+void PlatformBackend::ready()
 {
 	// enable V-Sync
-	if (App::config()->graphics == GfxAPI::OpenGL)
+	if (GraphicsBackend::renderer() == GraphicsRenderer::OpenGL)
 		SDL_GL_SetSwapInterval(1);
 }
 
-void Platform::shutdown()
+void PlatformBackend::shutdown()
 {
 	if (window != nullptr)
 		SDL_DestroyWindow(window);
@@ -156,12 +155,12 @@ void Platform::shutdown()
 	SDL_Quit();
 }
 
-uint64_t Platform::time()
+uint64_t PlatformBackend::time()
 {
 	return (uint64_t)SDL_GetTicks();
 }
 
-void Platform::frame()
+void PlatformBackend::frame()
 {
 	// update the mouse every frame
 	{
@@ -169,8 +168,8 @@ void Platform::frame()
 		SDL_GetWindowPosition(window, &winX, &winY);
 		SDL_GetGlobalMouseState(&x, &y);
 
-		Internal::Input::on_mouse_move((float)(x - winX), (float)(y - winY));
+		InputBackend::on_mouse_move((float)(x - winX), (float)(y - winY));
-		Internal::Input::on_mouse_screen_move((float)x, (float)y);
+		InputBackend::on_mouse_screen_move((float)x, (float)y);
 	}
 
 	// poll normal events
@@ -193,7 +192,7 @@ void Platform::frame()
 				btn = MouseButton::Right;
 			else if (event.button.button == SDL_BUTTON_MIDDLE)
 				btn = MouseButton::Middle;
-			Internal::Input::on_mouse_down(btn);
+			InputBackend::on_mouse_down(btn);
 		}
 		else if (event.type == SDL_MOUSEBUTTONUP)
 		{
@@ -204,26 +203,26 @@ void Platform::frame()
 				btn = MouseButton::Right;
 			else if (event.button.button == SDL_BUTTON_MIDDLE)
 				btn = MouseButton::Middle;
-			Internal::Input::on_mouse_up(btn);
+			InputBackend::on_mouse_up(btn);
 		}
 		else if (event.type == SDL_MOUSEWHEEL)
 		{
-			Internal::Input::on_mouse_wheel(Point(event.wheel.x, event.wheel.y));
+			InputBackend::on_mouse_wheel(Point(event.wheel.x, event.wheel.y));
 		}
 		// Keyboard
 		else if (event.type == SDL_KEYDOWN)
 		{
 			if (event.key.repeat == 0)
-				Internal::Input::on_key_down((Key)event.key.keysym.scancode);
+				InputBackend::on_key_down((Key)event.key.keysym.scancode);
 		}
 		else if (event.type == SDL_KEYUP)
 		{
 			if (event.key.repeat == 0)
-				Internal::Input::on_key_up((Key)event.key.keysym.scancode);
+				InputBackend::on_key_up((Key)event.key.keysym.scancode);
 		}
 		else if (event.type == SDL_TEXTINPUT)
 		{
-			Internal::Input::on_text_utf8(event.text.text);
+			InputBackend::on_text_utf8(event.text.text);
 		}
 		// Joystick Controller
 		else if (event.type == SDL_JOYDEVICEADDED)
@@ -237,7 +236,7 @@ void Platform::frame()
 				int button_count = SDL_JoystickNumButtons(ptr);
 				int axis_count = SDL_JoystickNumAxes(ptr);
 
-				Internal::Input::on_controller_connect(index, name, 0, button_count, axis_count);
+				InputBackend::on_controller_connect(index, name, 0, button_count, axis_count);
 			}
 		}
 		else if (event.type == SDL_JOYDEVICEREMOVED)
@@ -246,7 +245,7 @@ void Platform::frame()
 
 			if (SDL_IsGameController(index) == SDL_FALSE)
 			{
-				Internal::Input::on_controller_disconnect(index);
+				InputBackend::on_controller_disconnect(index);
 				SDL_JoystickClose(joysticks[index]);
 			}
 		}
@@ -254,13 +253,13 @@ void Platform::frame()
 		{
 			Sint32 index = event.jdevice.which;
 			if (SDL_IsGameController(index) == SDL_FALSE)
-				Internal::Input::on_button_down(index, event.jbutton.button);
+				InputBackend::on_button_down(index, event.jbutton.button);
 		}
 		else if (event.type == SDL_JOYBUTTONUP)
 		{
 			Sint32 index = event.jdevice.which;
 			if (SDL_IsGameController(index) == SDL_FALSE)
-				Internal::Input::on_button_up(index, event.jbutton.button);
+				InputBackend::on_button_up(index, event.jbutton.button);
 		}
 		else if (event.type == SDL_JOYAXISMOTION)
 		{
@@ -272,7 +271,7 @@ void Platform::frame()
 					value = event.jaxis.value / 32767.0f;
 				else
 					value = event.jaxis.value / 32768.0f;
-				Internal::Input::on_axis_move(index, event.jaxis.axis, value);
+				InputBackend::on_axis_move(index, event.jaxis.axis, value);
 			}
 		}
 		// Gamepad Controller
@@ -281,12 +280,12 @@ void Platform::frame()
 			Sint32 index = event.cdevice.which;
 			SDL_GameController* ptr = gamepads[index] = SDL_GameControllerOpen(index);
 			const char* name = SDL_GameControllerName(ptr);
-			Internal::Input::on_controller_connect(index, name, 1, 15, 6);
+			InputBackend::on_controller_connect(index, name, 1, 15, 6);
 		}
 		else if (event.type == SDL_CONTROLLERDEVICEREMOVED)
 		{
 			Sint32 index = event.cdevice.which;
-			Internal::Input::on_controller_disconnect(index);
+			InputBackend::on_controller_disconnect(index);
 			SDL_GameControllerClose(gamepads[index]);
 		}
 		else if (event.type == SDL_CONTROLLERBUTTONDOWN)
@@ -297,7 +296,7 @@ void Platform::frame()
 			if (event.cbutton.button >= 0 && event.cbutton.button < 15)
 				button = event.cbutton.button; // NOTE: These map directly to Engine Buttons enum!
 
-			Internal::Input::on_button_down(index, button);
+			InputBackend::on_button_down(index, button);
 		}
 		else if (event.type == SDL_CONTROLLERBUTTONUP)
 		{
@@ -307,7 +306,7 @@ void Platform::frame()
 			if (event.cbutton.button >= 0 && event.cbutton.button < 15)
 				button = event.cbutton.button; // NOTE: These map directly to Engine Buttons enum!
 
-			Internal::Input::on_button_up(index, button);
+			InputBackend::on_button_up(index, button);
 		}
 		else if (event.type == SDL_CONTROLLERAXISMOTION)
 		{
@@ -323,20 +322,20 @@ void Platform::frame()
 			else
 				value = event.caxis.value / 32768.0f;
 
-			Internal::Input::on_axis_move(index, axis, value);
+			InputBackend::on_axis_move(index, axis, value);
 		}
 	}
 }
 
-void Platform::sleep(int milliseconds)
+void PlatformBackend::sleep(int milliseconds)
 {
 	if (milliseconds >= 0)
 		SDL_Delay((uint32_t)milliseconds);
 }
 
-void Platform::present()
+void PlatformBackend::present()
 {
-	if (App::config()->graphics == GfxAPI::OpenGL)
+	if (GraphicsBackend::renderer() == GraphicsRenderer::OpenGL)
 	{
 		SDL_GL_SwapWindow(window);
 	}
@@ -350,27 +349,27 @@ void Platform::present()
 	}
 }
 
-const char* Platform::get_title()
+const char* PlatformBackend::get_title()
 {
 	return nullptr;
 }
 
-void Platform::set_title(const char* title)
+void PlatformBackend::set_title(const char* title)
 {
 	SDL_SetWindowTitle(window, title);
 }
 
-void Platform::get_position(int* x, int* y)
+void PlatformBackend::get_position(int* x, int* y)
 {
 	SDL_GetWindowPosition(window, x, y);
 }
 
-void Platform::set_position(int x, int y)
+void PlatformBackend::set_position(int x, int y)
 {
 	SDL_SetWindowPosition(window, x, y);
 }
 
-void Platform::set_fullscreen(bool enabled)
+void PlatformBackend::set_fullscreen(bool enabled)
 {
 	if (enabled)
 		SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
@@ -378,36 +377,30 @@ void Platform::set_fullscreen(bool enabled)
 		SDL_SetWindowFullscreen(window, 0);
 }
 
-void Platform::get_size(int* width, int* height)
+void PlatformBackend::get_size(int* width, int* height)
 {
 	SDL_GetWindowSize(window, width, height);
 }
 
-void Platform::set_size(int width, int height)
+void PlatformBackend::set_size(int width, int height)
 {
 	SDL_SetWindowSize(window, width, height);
 }
 
-void Platform::get_draw_size(int* width, int* height)
+void PlatformBackend::get_draw_size(int* width, int* height)
 {
 	auto config = App::config();
-	if (config->graphics == GfxAPI::OpenGL)
+	if (GraphicsBackend::renderer() == GraphicsRenderer::OpenGL)
 	{
 		SDL_GL_GetDrawableSize(window, width, height);
 	}
-	/*
-	else if (config->graphics == GfxAPI::Vulkan)
-	{
-		SDL_Vulkan_GetDrawableSize(window, width, height);
-	}
-	*/
 	else
 	{
 		SDL_GetWindowSize(window, width, height);
 	}
 }
 
-float Platform::get_content_scale()
+float PlatformBackend::get_content_scale()
 {
 	// TODO:
 	// This is incorrect! but for some reason the scale
@@ -435,14 +428,14 @@ float Platform::get_content_scale()
 
 // FILE IO
 
-const char* Platform::app_path()
+const char* PlatformBackend::app_path()
 {
 	if (basePath == nullptr)
 		basePath = SDL_GetBasePath();
 	return basePath;
 }
 
-const char* Platform::user_path()
+const char* PlatformBackend::user_path()
 {
 	if (userPath == nullptr)
 	{
@@ -456,34 +449,34 @@ const char* Platform::user_path()
 // Windows File System methods
 #if _WIN32
 
-bool Platform::file_exists(const char* path)
+bool PlatformBackend::file_exists(const char* path)
 {
 	return fs::is_regular_file(path);
 }
 
-bool Platform::file_delete(const char* path)
+bool PlatformBackend::file_delete(const char* path)
 {
 	return fs::remove(path);
 }
 
-bool Platform::dir_create(const char* path)
+bool PlatformBackend::dir_create(const char* path)
 {
 	std::error_code error;
 	return fs::create_directories(path, error);
 }
 
-bool Platform::dir_exists(const char* path)
+bool PlatformBackend::dir_exists(const char* path)
 {
 	return fs::is_directory(path);
 }
 
-bool Platform::dir_delete(const char* path)
+bool PlatformBackend::dir_delete(const char* path)
 {
 	BLAH_ERROR("not implemented");
 	return false;
 }
 
-void Platform::dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive)
+void PlatformBackend::dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive)
 {
 	if (fs::is_directory(path))
 	{
@@ -500,7 +493,7 @@ void Platform::dir_enumerate(Vector<FilePath>& list, const char* path, bool recu
 	}
 }
 
-void Platform::dir_explore(const char* path)
+void PlatformBackend::dir_explore(const char* path)
 {
 	ShellExecute(NULL, "open", path, NULL, NULL, SW_SHOWDEFAULT);
 }
@@ -508,19 +501,19 @@ void Platform::dir_explore(const char* path)
 // Non-Windows File System Methods
 #else
 
-bool Platform::file_exists(const char* path)
+bool PlatformBackend::file_exists(const char* path)
 {
 	struct stat buffer;
 	return (stat(path, &buffer) == 0) && S_ISREG(buffer.st_mode);
 }
 
-bool Platform::file_delete(const char* path)
+bool PlatformBackend::file_delete(const char* path)
 {
 	BLAH_ERROR("not implemented");
 	return false;
 }
 
-bool Platform::dir_create(const char* path)
+bool PlatformBackend::dir_create(const char* path)
 {
 	char tmp[265];
 	char* p = NULL;
@@ -539,19 +532,19 @@ bool Platform::dir_create(const char* path)
 	return mkdir(tmp, S_IRWXU) == 0;
 }
 
-bool Platform::dir_exists(const char* path)
+bool PlatformBackend::dir_exists(const char* path)
 {
 	struct stat buffer;
 	return (stat(path, &buffer) == 0) && S_ISDIR(buffer.st_mode);
 }
 
-bool Platform::dir_delete(const char* path)
+bool PlatformBackend::dir_delete(const char* path)
 {
 	BLAH_ERROR("not implemented");
 	return false;
 }
 
-void Platform::dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive)
+void PlatformBackend::dir_enumerate(Vector<FilePath>& list, const char* path, bool recursive)
 {
 	DIR* dirp = opendir(path);
 	if (dirp != NULL)
@@ -572,61 +565,61 @@ void Platform::dir_enumerate(Vector<FilePath>& list, const char* path, bool recu
 	}
 }
 
-void Platform::dir_explore(const char* path)
+void PlatformBackend::dir_explore(const char* path)
 {
 	BLAH_ERROR("'dir_explore' Not Implemented");
 }
 
 #endif
 
-bool Platform::file_open(const char* path, Platform::FileHandle* handle, FileMode mode)
+bool PlatformBackend::file_open(const char* path, PlatformBackend::FileHandle* handle, FileMode mode)
 {
 	const char* sdlMode = "rb";
 	if (mode == FileMode::Write)
 		sdlMode = "wb";
 
 	auto ptr = SDL_RWFromFile(path, sdlMode);
-	*handle = (Platform::FileHandle)ptr;
+	*handle = (PlatformBackend::FileHandle)ptr;
 	return ptr != nullptr;
 }
 
-int64_t Platform::file_length(Platform::FileHandle stream)
+int64_t PlatformBackend::file_length(PlatformBackend::FileHandle stream)
 {
 	return SDL_RWsize((SDL_RWops*)stream);
 }
 
-int64_t Platform::file_position(Platform::FileHandle stream)
+int64_t PlatformBackend::file_position(PlatformBackend::FileHandle stream)
 {
 	return SDL_RWtell((SDL_RWops*)stream);
 }
 
-int64_t Platform::file_seek(Platform::FileHandle stream, int64_t seekTo)
+int64_t PlatformBackend::file_seek(PlatformBackend::FileHandle stream, int64_t seekTo)
 {
 	return SDL_RWseek((SDL_RWops*)stream, seekTo, RW_SEEK_SET);
 }
 
-int64_t Platform::file_read(Platform::FileHandle stream, void* ptr, int64_t length)
+int64_t PlatformBackend::file_read(PlatformBackend::FileHandle stream, void* ptr, int64_t length)
 {
 	return SDL_RWread((SDL_RWops*)stream, ptr, sizeof(char), length);
 }
 
-int64_t Platform::file_write(Platform::FileHandle stream, const void* ptr, int64_t length)
+int64_t PlatformBackend::file_write(PlatformBackend::FileHandle stream, const void* ptr, int64_t length)
 {
 	return SDL_RWwrite((SDL_RWops*)stream, ptr, sizeof(char), length);
 }
 
-void Platform::file_close(Platform::FileHandle stream)
+void PlatformBackend::file_close(PlatformBackend::FileHandle stream)
 {
 	if (stream != nullptr)
 		SDL_RWclose((SDL_RWops*)stream);
 }
 
-void* Platform::gl_get_func(const char* name)
+void* PlatformBackend::gl_get_func(const char* name)
 {
 	return SDL_GL_GetProcAddress(name);
 }
 
-void* Platform::gl_context_create()
+void* PlatformBackend::gl_context_create()
 {
 	void* pointer = SDL_GL_CreateContext(window);
 	if (pointer == nullptr)
@@ -634,12 +627,12 @@ void* Platform::gl_context_create()
 	return pointer;
 }
 
-void Platform::gl_context_make_current(void* context)
+void PlatformBackend::gl_context_make_current(void* context)
 {
 	SDL_GL_MakeCurrent(window, context);
 }
 
-void Platform::gl_context_destroy(void* context)
+void PlatformBackend::gl_context_destroy(void* context)
 {
 	SDL_GL_DeleteContext(context);
 }

public/blah/app.cpp

@@ -3,9 +3,9 @@
 #include <blah/time.h>
 #include <blah/math/point.h>
 
-#include <blah/internal/platform.h>
+#include <blah/internal/platform_backend.h>
-#include <blah/internal/graphics.h>
+#include <blah/internal/graphics_backend.h>
-#include <blah/internal/input.h>
+#include <blah/internal/input_backend.h>
 
 using namespace Blah;
 
@@ -24,7 +24,6 @@ Config::Config()
 	target_framerate = 60;
 	max_updates = 5;
 
-	graphics = GfxAPI::Any;
 	on_startup = nullptr;
 	on_shutdown = nullptr;
 	on_update = nullptr;
@@ -50,54 +49,43 @@ bool App::run(const Config* c)
 
 	Log::print("Starting Up ...");
 
-	// figure out the graphics api
-	if (app_config.graphics == GfxAPI::Any)
-	{
-		app_config.graphics = Internal::Graphics::pick_api();
-		if (app_config.graphics == GfxAPI::Any)
-		{
-			Log::error("Failed to find a supported graphics api");
-			return false;
-		}
-	}
-
 	// initialize the system
-	if (!Internal::Platform::init(&app_config))
+	if (!PlatformBackend::init(&app_config))
 	{
-		Log::error("Failed to initialize system module");
+		Log::error("Failed to initialize Platform module");
 		return false;
 	}
 
 	// initialize graphics
-	if (!Internal::Graphics::init(app_config.graphics))
+	if (!GraphicsBackend::init())
 	{
-		Log::error("Failed to initialize graphics module");
+		Log::error("Failed to initialize Graphics module");
 		return false;
 	}
 
 	// input
-	Internal::Input::init();
+	InputBackend::init();
 
 	// startup
 	if (app_config.on_startup != nullptr)
 		app_config.on_startup();
 
-	uint64_t time_last = Internal::Platform::time();
+	uint64_t time_last = PlatformBackend::time();
 	uint64_t time_accumulator = 0;
 
 	// display window
-	Internal::Platform::ready();
+	PlatformBackend::ready();
 
 	while (!app_is_exiting)
 	{
 		// poll system events
-		Internal::Platform::frame();
+		PlatformBackend::frame();
 
 		// update at a fixed timerate
 		// TODO: allow a non-fixed step update?
 		{
 			uint64_t time_target = (uint64_t)((1.0f / app_config.target_framerate) * 1000);
-			uint64_t time_curr = Internal::Platform::time();
+			uint64_t time_curr = PlatformBackend::time();
 			uint64_t time_diff = time_curr - time_last;
 			time_last = time_curr;
 			time_accumulator += time_diff;
@@ -105,9 +93,9 @@ bool App::run(const Config* c)
 			// do not let us run too fast
 			while (time_accumulator < time_target)
 			{
-				Internal::Platform::sleep((int)(time_target - time_accumulator));
+				PlatformBackend::sleep((int)(time_target - time_accumulator));
 
-				time_curr = Internal::Platform::time();
+				time_curr = PlatformBackend::time();
 				time_diff = time_curr - time_last;
 				time_last = time_curr;
 				time_accumulator += time_diff;
@@ -139,8 +127,8 @@ bool App::run(const Config* c)
 				Time::previous_elapsed = Time::elapsed;
 				Time::elapsed += Time::delta;
 
-				Internal::Input::frame();
+				InputBackend::frame();
-				Internal::Graphics::frame();
+				GraphicsBackend::frame();
 
 				if (app_config.on_update != nullptr)
 					app_config.on_update();
@@ -149,13 +137,13 @@ bool App::run(const Config* c)
 
 		// render
 		{
-			Internal::Graphics::before_render();
+			GraphicsBackend::before_render();
 
 			if (app_config.on_render != nullptr)
 				app_config.on_render();
 
-			Internal::Graphics::after_render();
+			GraphicsBackend::after_render();
-			Internal::Platform::present();
+			PlatformBackend::present();
 		}
 
 	}
@@ -166,8 +154,8 @@ bool App::run(const Config* c)
 	if (app_config.on_shutdown != nullptr)
 		app_config.on_shutdown();
 
-	Internal::Graphics::shutdown();
+	GraphicsBackend::shutdown();
-	Internal::Platform::shutdown();
+	PlatformBackend::shutdown();
 
 	// clear static state
 	Log::print("Exited");
@@ -198,48 +186,48 @@ const Config* App::config()
 
 const char* App::path()
 {
-	return Internal::Platform::app_path();
+	return PlatformBackend::app_path();
 }
 
 const char* App::user_path()
 {
-	return Internal::Platform::user_path();
+	return PlatformBackend::user_path();
 }
 
 int App::width()
 {
 	int w, h;
-	Internal::Platform::get_size(&w, &h);
+	PlatformBackend::get_size(&w, &h);
 	return w;
 }
 
 int App::height()
 {
 	int w, h;
-	Internal::Platform::get_size(&w, &h);
+	PlatformBackend::get_size(&w, &h);
 	return h;
 }
 
 int App::draw_width()
 {
 	int w, h;
-	Internal::Platform::get_draw_size(&w, &h);
+	PlatformBackend::get_draw_size(&w, &h);
 	return w;
 }
 
 int App::draw_height()
 {
 	int w, h;
-	Internal::Platform::get_draw_size(&w, &h);
+	PlatformBackend::get_draw_size(&w, &h);
 	return h;
 }
 
 float App::content_scale()
 {
-	return Internal::Platform::get_content_scale();
+	return PlatformBackend::get_content_scale();
 }
 
 void App::fullscreen(bool enabled)
 {
-	Internal::Platform::set_fullscreen(enabled);
+	PlatformBackend::set_fullscreen(enabled);
 }

public/blah/app.h

@@ -2,13 +2,6 @@
 
 namespace Blah
 {
-	enum class GfxAPI
-	{
-		Any = -1,
-		OpenGL,
-		Count
-	};
-
 	struct Config
 	{
 		const char* name;
@@ -17,8 +10,6 @@ namespace Blah
 		int max_updates;
 		int target_framerate;
 
-		GfxAPI graphics;
-
 		void (*on_startup)();
 		void (*on_shutdown)();
 		void (*on_update)();

public/blah/drawing/batch.cpp

@@ -135,15 +135,20 @@ Batch::~Batch()
 	dispose();
 }
 
-void Batch::push_matrix(const Mat3x2& matrix)
+void Batch::push_matrix(const Mat3x2& matrix, bool absolute)
 {
 	m_matrix_stack.push_back(m_matrix);
+	if (absolute)
+		m_matrix = matrix;
+	else
 		m_matrix = matrix * m_matrix;
 }
 
-void Batch::pop_matrix()
+Mat3x2 Batch::pop_matrix()
 {
+	auto was = m_matrix;
 	m_matrix = m_matrix_stack.pop();
+	return was;
 }
 
 void Batch::push_scissor(const Rect& scissor)
@@ -212,7 +217,7 @@ void Batch::pop_color_mode()
 
 void Batch::set_texture(const TextureRef& texture)
 {
-	if (m_batch.elements > 0 && texture != m_batch.texture && m_batch.texture && m_batch.texture->is_valid())
+	if (m_batch.elements > 0 && texture != m_batch.texture && m_batch.texture)
 	{
 		m_batches.push_back(m_batch);
 		m_batch.offset += m_batch.elements;
@@ -222,14 +227,14 @@ void Batch::set_texture(const TextureRef& texture)
 	if (m_batch.texture != texture)
 	{
 		m_batch.texture = texture;
-		m_batch.flip_vertically = Graphics::info()->origin_bottom_left && texture && texture->is_valid() && texture->is_framebuffer();
+		m_batch.flip_vertically = Graphics::info()->origin_bottom_left && texture && texture->is_framebuffer();
 	}
 }
 
 void Batch::render(const FrameBufferRef& target)
 {
 	Point size;
-	if (!target || !target->is_valid())
+	if (!target)
 		size = Point(App::draw_width(), App::draw_height());
 	else
 		size = Point(target->width(), target->height());
@@ -245,7 +250,7 @@ void Batch::render(const FrameBufferRef& target, const Mat4x4& matrix)
 
 	// define defaults
 	{
-		if (!m_mesh || !m_mesh->is_valid())
+		if (!m_mesh)
 		{
 			m_mesh = Graphics::create_mesh();
 			m_mesh->vertex_format(attributes, 4, sizeof(Vertex));
@@ -281,7 +286,7 @@ void Batch::render(const FrameBufferRef& target, const Mat4x4& matrix)
 void Batch::render_single_batch(RenderCall& call, const DrawBatch& b, const Mat4x4& matrix)
 {
 	call.material = b.material;
-	if (!call.material || !call.material->is_valid())
+	if (!call.material)
 		call.material = m_default_material;
 
 	call.material->set_texture(texture_uniform, b.texture, 0);
@@ -635,6 +640,11 @@ void Batch::semi_circle_line(Vec2 center, float start_radians, float end_radians
 }
 
 void Batch::circle(const Vec2 center, float radius, int steps, Color color)
+{
+	circle(center, radius, steps, color, color);
+}
+
+void Batch::circle(const Vec2 center, float radius, int steps, Color center_color, Color outer_color)
 {
 	Vec2 last = Vec2(center.x + radius, center.y);
 
@@ -643,7 +653,7 @@ void Batch::circle(const Vec2 center, float radius, int steps, Color color)
 		const auto radians = (i / (float)steps) * Calc::TAU;
 		const auto next = Vec2(center.x + Calc::cos(radians) * radius, center.y + Calc::sin(radians) * radius);
 
-		tri(last, next, center, color);
+		tri(last, next, center, outer_color, outer_color, center_color);
 
 		last = next;
 	}
@@ -761,7 +771,7 @@ void Batch::tex()
 
 void Batch::tex(const Subtexture& sub, const Vec2& pos, Color color)
 {
-	if (!sub.texture || !sub.texture->is_valid())
+	if (!sub.texture)
 	{
 		PUSH_QUAD(
 			pos.x + sub.draw_coords[0].x, pos.y + sub.draw_coords[0].y,
@@ -794,7 +804,7 @@ void Batch::tex(const Subtexture& sub, const Vec2& pos, const Vec2& origin, cons
 {
 	push_matrix(Mat3x2::create_transform(pos, origin, scale, rotation));
 
-	if (!sub.texture || !sub.texture->is_valid())
+	if (!sub.texture)
 	{
 		PUSH_QUAD(
 			sub.draw_coords[0].x, sub.draw_coords[0].y,

public/blah/drawing/batch.h

@@ -44,8 +44,8 @@ namespace Blah
 		Batch& operator=(const Batch& other) = delete;
 		~Batch();
 
-		void push_matrix(const Mat3x2& matrix);
+		void push_matrix(const Mat3x2& matrix, bool absolute = false);
-		void pop_matrix();
+		Mat3x2 pop_matrix();
 		void push_scissor(const Rect& scissor);
 		void pop_scissor();
 		void push_blend(const BlendMode& blend);
@@ -90,6 +90,7 @@ namespace Blah
 		void semi_circle_line(Vec2 center, float start_radians, float end_radians, float radius, int steps, float t, Color color);
 
 		void circle(const Vec2 center, float radius, int steps, Color color);
+		void circle(const Vec2 center, float radius, int steps, Color center_color, Color outer_color);
 		void circle_line(const Vec2 center, float raidus, float t, int steps, Color color);
 
 		void quad(const Vec2& pos0, const Vec2& pos1, const Vec2& pos2, const Vec2& pos3, Color color);

public/blah/drawing/subtexture.cpp

@@ -24,7 +24,7 @@ void Subtexture::update()
 	draw_coords[3].x = -frame.x;
 	draw_coords[3].y = -frame.y + source.h;
 
-	if (texture && texture->is_valid())
+	if (texture)
 	{
 		float uvx = 1.0f / (float)texture->width();
 		float uvy = 1.0f / (float)texture->height();

public/blah/filesystem.cpp

@@ -1,31 +1,31 @@
 #include <blah/filesystem.h>
-#include <blah/internal/platform.h>
+#include <blah/internal/platform_backend.h>
 
 using namespace Blah;
 
 bool File::exists(const FilePath& path)
 {
-	return Internal::Platform::file_exists(path.cstr());
+	return PlatformBackend::file_exists(path.cstr());
 }
 
 bool File::remove(const FilePath& path)
 {
-	return Internal::Platform::file_delete(path.cstr());
+	return PlatformBackend::file_delete(path.cstr());
 }
 
 bool Directory::create(const FilePath& path)
 {
-	return Internal::Platform::dir_create(path.cstr());
+	return PlatformBackend::dir_create(path.cstr());
 }
 
 bool Directory::exists(const FilePath& path)
 {
-	return Internal::Platform::dir_exists(path.cstr());
+	return PlatformBackend::dir_exists(path.cstr());
 }
 
 bool Directory::remove(const FilePath& path)
 {
-	return Internal::Platform::dir_delete(path.cstr());
+	return PlatformBackend::dir_delete(path.cstr());
 }
 
 Vector<FilePath> Directory::enumerate(const FilePath& path, bool recursive)
@@ -33,7 +33,7 @@ Vector<FilePath> Directory::enumerate(const FilePath& path, bool recursive)
 	Vector<FilePath> list;
 
 	// get files
-	Internal::Platform::dir_enumerate(list, path.cstr(), recursive);
+	PlatformBackend::dir_enumerate(list, path.cstr(), recursive);
 
 	// normalize path names
 	for (auto& it : list)
@@ -44,7 +44,7 @@ Vector<FilePath> Directory::enumerate(const FilePath& path, bool recursive)
 
 void Directory::explore(const FilePath& path)
 {
-	Internal::Platform::dir_explore(path);
+	PlatformBackend::dir_explore(path);
 }
 
 FilePath Path::get_file_name(const FilePath& path)

public/blah/graphics/framebuffer.h

@@ -19,17 +19,17 @@ namespace Blah
 		// Gets the list of Attachments from the FrameBuffer
 		virtual const Attachments& attachments() const = 0;
 
+		// Gets the Attachment at a given index from the FrameBuffer
+		virtual TextureRef& attachment(int index) = 0;
+
+		// Gets the Attachment at a given index from the FrameBuffer
+		virtual const TextureRef& attachment(int index) const = 0;
+
 		// Gets the width of the FrameBuffer
 		virtual int width() const = 0;
 
 		// Gets the height of the FrameBuffer
 		virtual int height() const = 0;
-
-		// Returns true if the FrameBuffer is valid
-		virtual bool is_valid() const = 0;
-
-		// Destroys the given FrameBuffer
-		virtual void dispose() = 0;
 	};
 
 	typedef std::shared_ptr<FrameBuffer> FrameBufferRef;

public/blah/graphics/graphics.cpp

@@ -5,27 +5,12 @@
 #include <blah/graphics/material.h>
 #include <blah/graphics/shader.h>
 #include <blah/log.h>
-#include <blah/internal/graphics.h>
+#include <blah/internal/graphics_backend.h>
 #include <blah/images/image.h>
 #include <string.h>
 
 using namespace Blah;
 
-namespace
-{
-	// active graphics device
-	Internal::GraphicsDevice* device;
-
-	// active graphics device info
-	Internal::GraphicsDeviceInfo* device_info;
-
-	// list of possible device info
-	Internal::GraphicsDeviceInfo* device_options[] =
-	{
-		&Internal::OpenGL_DeviceInfo
-	};
-}
-
 const BlendMode BlendMode::Normal = BlendMode(
 	BlendOp::Add,
 	BlendFactor::One,
@@ -37,74 +22,25 @@ const BlendMode BlendMode::Normal = BlendMode(
 	0xffffffff
 );
 
-GfxAPI Internal::Graphics::pick_api()
+const BlendMode BlendMode::Subtract = BlendMode(
-{
+	BlendOp::ReverseSubtract,
-	for (int i = 0; i < (int)GfxAPI::Count; i++)
+	BlendFactor::One,
-	{
+	BlendFactor::One,
-		if (device_options[i]->supported())
+	BlendOp::Add,
-			return device_options[i]->api;
+	BlendFactor::One,
-	}
+	BlendFactor::One,
-
+	BlendMask::RGBA,
-	return GfxAPI::Any;
+	0xffffffff
-}
+);
-
-bool Internal::Graphics::init(GfxAPI api)
-{
-	for (int i = 0; i < (int)GfxAPI::Count; i++)
-	{
-		if (device_options[i]->api == api)
-		{
-			device_info = device_options[i];
-			device = device_info->create();
-			if (device != nullptr)
-			{
-				device->startup();
-				if (device->valid)
-					break;
-
-				device_info->destroy(device);
-				device = nullptr;
-			}
-		}
-	}
-
-	return device != nullptr && device->valid;
-}
 
 const GraphicsInfo* Graphics::info()
 {
-	if (device == nullptr || !device->valid)
+	return GraphicsBackend::info();
-		return nullptr;
-	return &device->info;
 }
 
-void Internal::Graphics::shutdown()
+GraphicsRenderer Graphics::renderer()
 {
-	if (device != nullptr && device_info != nullptr)
+	return GraphicsBackend::renderer();
-	{
-		device->shutdown();
-		device_info->destroy(device);
-		device = nullptr;
-		device_info = nullptr;
-	}
-}
-
-void Internal::Graphics::frame()
-{
-	if (device != nullptr && device->valid)
-		device->update();
-}
-
-void Internal::Graphics::before_render()
-{
-	if (device != nullptr && device->valid)
-		device->before_render();
-}
-
-void Internal::Graphics::after_render()
-{
-	if (device != nullptr && device->valid)
-		device->after_render();
 }
 
 TextureRef Graphics::create_texture(const Image& image)
@@ -125,9 +61,8 @@ TextureRef Graphics::create_texture(int width, int height, TextureFormat format)
 {
 	BLAH_ASSERT(width > 0 && height > 0, "Texture width and height must be larger than 0");
 	BLAH_ASSERT((int)format > (int)TextureFormat::None && (int)format < (int)TextureFormat::Count, "Invalid texture format");
-	BLAH_ASSERT(device != nullptr && device->valid, "The graphics device has not been created");
 
-	return device->create_texture(width, height, TextureFilter::Linear, TextureWrap::Repeat, TextureWrap::Repeat, format);
+	return GraphicsBackend::create_texture(width, height, TextureFilter::Linear, TextureWrap::Repeat, TextureWrap::Repeat, format);
 }
 
 TextureRef Graphics::create_texture(Stream& stream)
@@ -171,31 +106,27 @@ FrameBufferRef Graphics::create_framebuffer(int width, int height, const Texture
 	BLAH_ASSERT(attachment_count > 0, "At least one attachment must be provided");
 	for (int i = 0; i < attachment_count; i++)
 		BLAH_ASSERT((int)attachments[i] > (int)TextureFormat::None && (int)attachments[i] < (int)TextureFormat::Count, "Invalid texture format");
-	BLAH_ASSERT(device != nullptr && device->valid, "The graphics device has not been created");
 
-	return device->create_framebuffer(width, height, attachments, attachment_count);
+	return GraphicsBackend::create_framebuffer(width, height, attachments, attachment_count);
 }
 
 ShaderRef Graphics::create_shader(const ShaderData* data)
 {
-	BLAH_ASSERT(device != nullptr && device->valid, "The graphics device has not been created");
+	return GraphicsBackend::create_shader(data);
-	return device->create_shader(data);
 }
 
 MaterialRef Graphics::create_material(const ShaderRef& shader)
 {
-	BLAH_ASSERT(device != nullptr && device->valid, "The graphics device has not been created");
+	BLAH_ASSERT(shader, "The provided shader is invalid");
-	BLAH_ASSERT(shader && shader->is_valid(), "The provided shader is invalid");
 
 	// TODO:
-	// use a pool for Materials
+	// use a pool for Materials?
 	return MaterialRef(new Material(shader));
 }
 
 MeshRef Graphics::create_mesh()
 {
-	BLAH_ASSERT(device != nullptr && device->valid, "Graphics device has not been created");
+	return GraphicsBackend::create_mesh();
-	return device->create_mesh();
 }
 
 RenderCall::RenderCall()
@@ -217,36 +148,27 @@ RenderCall::RenderCall()
 
 void Graphics::render(const RenderCall& render_call)
 {
-	BLAH_ASSERT(device != nullptr && device->valid, "Graphics device has not been created");
-
 	// Validate Material
-	if (!render_call.material || !render_call.material->is_valid())
+	if (!render_call.material)
 	{
 		Log::warn("Trying to draw with an invalid Material");
 		return;
 	}
 
 	// Validate Shader
-	if (!render_call.material->shader() || !render_call.material->shader()->is_valid())
+	if (!render_call.material->shader())
 	{
 		Log::warn("Trying to draw with an invalid Shader");
 		return;
 	}
 
 	// Validate Mesh
-	if (!render_call.mesh || !render_call.mesh->is_valid())
+	if (!render_call.mesh)
 	{
 		Log::warn("Trying to draw with an invalid Mesh");
 		return;
 	}
 
-	// Validate FrameBuffer
-	if (render_call.target && !render_call.target->is_valid())
-	{
-		Log::warn("Trying to draw with an invalid FrameBuffer");
-		return;
-	}
-
 	// copy call
 	RenderCall call = render_call;
 
@@ -330,11 +252,10 @@ void Graphics::render(const RenderCall& render_call)
 			call.scissor.h = 0;
 	}
 	
-	device->render(&call);
+	GraphicsBackend::render(&call);
 }
 
 void Graphics::clear(const FrameBufferRef& target, uint32_t rgba)
 {
-	BLAH_ASSERT(device != nullptr && device->valid, "Graphics device has not been created");
+	GraphicsBackend::clear(target, rgba);
-	device->clear(target, rgba);
 }

public/blah/graphics/graphics.h

@@ -32,9 +32,17 @@ namespace Blah
 	class Mesh;
 	typedef std::shared_ptr<Mesh> MeshRef;
 
+	enum class GraphicsRenderer
+	{
+		None = -1,
+		OpenGL,
+		D3D11,
+		Metal,
+		Count
+	};
+
 	struct GraphicsInfo
 	{
-		GfxAPI api = GfxAPI::Any;
 		bool instancing = false;
 		bool origin_bottom_left = false;
 		int max_texture_size = 0;
@@ -174,6 +182,7 @@ namespace Blah
 		inline bool operator!=(const BlendMode& rhs) const { return !(*this == rhs); }
 
 		static const BlendMode Normal;
+		static const BlendMode Subtract;
 	};
 
 	enum class UniformType
@@ -300,6 +309,9 @@ namespace Blah
 		// Gets graphics information from the graphics device
 		const GraphicsInfo* info();
 
+		// Gets the Renderer implementation type
+		GraphicsRenderer renderer();
+
 		// Creates a new Texture.
 		// If the Texture creation fails, it will return an invalid TextureRef.
 		TextureRef create_texture(const Image& image);

public/blah/graphics/material.cpp

@@ -28,16 +28,8 @@ namespace
 
 Material::Material(const ShaderRef& shader)
 {
+	BLAH_ASSERT(shader, "Material is being created with an invalid shader");
 	m_shader = shader;
-	m_data = nullptr;
-	m_disposed = false;
-
-	// invalid shader
-	if (!m_shader || !m_shader->is_valid())
-	{
-		m_disposed = true;
-		return;
-	}
 
 	Uniforms uniforms = shader->uniforms();
 	StackVector<size_t, BLAH_UNIFORMS> float_offsets;
@@ -59,16 +51,9 @@ Material::Material(const ShaderRef& shader)
 		float_size += calc_uniform_size(uniform);
 	}
 
-	m_data = new float[float_size];
+	m_data.expand(float_size);
-	memset(m_data, 0, sizeof(float) * float_size);
-
 	for (auto& it : float_offsets)
-		m_floats.push_back(m_data + it);
+		m_floats.push_back(m_data.begin() + it);
-}
-
-Material::~Material()
-{
-	dispose();
 }
 
 const ShaderRef Material::shader() const
@@ -78,8 +63,7 @@ const ShaderRef Material::shader() const
 
 void Material::set_texture(const char* name, const TextureRef& texture, int index)
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 
 	if (m_textures.size() > 0)
 	{
@@ -106,8 +90,7 @@ void Material::set_texture(const char* name, const TextureRef& texture, int inde
 
 TextureRef Material::get_texture(const char* name, int index) const
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 
 	int offset = 0;
 	for (auto& uniform : m_shader->uniforms())
@@ -129,8 +112,7 @@ TextureRef Material::get_texture(const char* name, int index) const
 
 TextureRef Material::get_texture(int slot, int index) const
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 
 	int offset = 0;
 	int s = 0;
@@ -155,8 +137,7 @@ TextureRef Material::get_texture(int slot, int index) const
 
 void Material::set_value(const char* name, const float* value, int64_t length)
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 	BLAH_ASSERT(length >= 0, "Length must be >= 0");
 
 	int index = 0;
@@ -186,8 +167,7 @@ void Material::set_value(const char* name, const float* value, int64_t length)
 
 const float* Material::get_value(const char* name, int64_t* length) const
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 
 	int index = 0;
 	for (auto& uniform : m_shader->uniforms())
@@ -212,8 +192,7 @@ const float* Material::get_value(const char* name, int64_t* length) const
 
 const float* Material::get_value(int slot, int64_t* length) const
 {
-	BLAH_ASSERT(!m_disposed, "Material has been disposed");
+	BLAH_ASSERT(m_shader, "Material Shader is invalid");
-	BLAH_ASSERT(m_shader && m_shader->is_valid(), "Material Shader is invalid");
 
 	int index = 0;
 	int s = 0;
@@ -233,21 +212,7 @@ const float* Material::get_value(int slot, int64_t* length) const
 		s++;
 	}
 
+	Log::warn("No Uniform [%i] exists", slot);
 	*length = 0;
 	return nullptr;
-	Log::warn("No Uniform [%i] exists", slot);
-}
-
-bool Material::is_valid() const
-{
-	return !m_disposed && m_shader && m_shader->is_valid();
-}
-
-void Material::dispose()
-{
-	delete[] m_data;
-	m_data = nullptr;
-	m_shader.reset();
-	m_textures.clear();
-	m_floats.clear();
 }

public/blah/graphics/material.h

@@ -10,8 +10,6 @@ namespace Blah
 	{
 	public:
 		Material(const ShaderRef& shader);
-		~Material();
-
 		Material(const Material& src) = delete;
 		Material(Material&& src) = delete;
 		Material& operator=(const Material& src) = delete;
@@ -48,18 +46,11 @@ namespace Blah
 		// is a float2, and there are 4 elements, the length should be 8.
 		const float* get_value(int slot, int64_t* length = nullptr) const;
 
-		// Returns true if the Material is valid
-		bool is_valid() const;
-
-		// Destroys the Material
-		void dispose();
-
 	private:
 		ShaderRef m_shader;
 		Vector<TextureRef> m_textures;
 		Vector<float*> m_floats;
-		float* m_data;
+		Vector<float> m_data;
-		bool m_disposed;
 	};
 
 	typedef std::shared_ptr<Material> MaterialRef;

public/blah/graphics/mesh.h

@@ -36,12 +36,6 @@ namespace Blah
 		// Gets the instance count of the Mesh
 		virtual int64_t instance_count() const = 0;
 
-		// Returns true if the Mesh is valid
-		virtual bool is_valid() const = 0;
-
-		// Destroys the given Mesh
-		virtual void dispose() = 0;
-
 	protected:
 		virtual void vertex_format_internal(const VertexAttribute* attributes, int count, int stride) = 0;
 		virtual void instance_format_internal(const VertexAttribute* attributes, int count, int stride) = 0;

public/blah/graphics/shader.h

@@ -24,12 +24,6 @@ namespace Blah
 
 		// Gets a list of Shader Attributes from Shader
 		virtual const Attributes& attributes() const = 0;
-
-		// Returns true if the Shader is valid
-		virtual bool is_valid() const = 0;
-
-		// Destroys the given Shader
-		virtual void dispose() = 0;
 	};
 
 	typedef std::shared_ptr<Shader> ShaderRef;

public/blah/graphics/texture.h

@@ -45,12 +45,6 @@ namespace Blah
 
 		// Returns true if the Texture is part of a FrameBuffer
 		virtual bool is_framebuffer() const = 0;
-
-		// Returns true if the Texture
-		virtual bool is_valid() const = 0;
-
-		// Destroys the given Texture
-		virtual void dispose() = 0;
 	};
 
 	typedef std::shared_ptr<Texture> TextureRef;

public/blah/input/input.cpp

@@ -3,7 +3,7 @@
 #include <blah/time.h>
 #include <blah/log.h>
 #include <blah/math/point.h>
-#include <blah/internal/input.h>
+#include <blah/internal/input_backend.h>
 #include <string.h>
 
 using namespace Blah;
@@ -17,7 +17,7 @@ namespace
 	ControllerState g_empty_controller;
 }
 
-void Internal::Input::init()
+void InputBackend::init()
 {
 	g_empty_controller.name = "Disconnected";
 	for (int i = 0; i < Blah::Input::max_controllers; i++)
@@ -28,7 +28,7 @@ void Internal::Input::init()
 	g_next_state = g_empty_state;
 }
 
-void Internal::Input::frame()
+void InputBackend::frame()
 {
 	// cycle states
 	g_last_state = g_curr_state;
@@ -68,7 +68,7 @@ void Internal::Input::frame()
 	}
 }
 
-void Internal::Input::on_mouse_move(float x, float y)
+void InputBackend::on_mouse_move(float x, float y)
 {
 	g_next_state.mouse.position.x = x;
 	g_next_state.mouse.position.y = y;
@@ -80,13 +80,13 @@ void Internal::Input::on_mouse_move(float x, float y)
 	g_next_state.mouse.draw_position.y = (y / (float)size.y) * draw.y;
 }
 
-void Internal::Input::on_mouse_screen_move(float x, float y)
+void InputBackend::on_mouse_screen_move(float x, float y)
 {
 	g_next_state.mouse.screen_position.x = x;
 	g_next_state.mouse.screen_position.y = y;
 }
 
-void Internal::Input::on_mouse_down(MouseButton button)
+void InputBackend::on_mouse_down(MouseButton button)
 {
 	int i = (int)button;
 	if (i >= 0 && i < Blah::Input::max_mouse_buttons)
@@ -97,7 +97,7 @@ void Internal::Input::on_mouse_down(MouseButton button)
 	}
 }
 
-void Internal::Input::on_mouse_up(MouseButton button)
+void InputBackend::on_mouse_up(MouseButton button)
 {
 	int i = (int)button;
 	if (i >= 0 && i < Blah::Input::max_mouse_buttons)
@@ -107,7 +107,7 @@ void Internal::Input::on_mouse_up(MouseButton button)
 	}
 }
 
-void Internal::Input::on_key_down(Key key)
+void InputBackend::on_key_down(Key key)
 {
 	int i = (int)key;
 	if (i >= 0 && i < Blah::Input::max_keyboard_keys)
@@ -118,12 +118,12 @@ void Internal::Input::on_key_down(Key key)
 	}
 }
 
-void Internal::Input::on_mouse_wheel(Point wheel)
+void InputBackend::on_mouse_wheel(Point wheel)
 {
 	g_next_state.mouse.wheel = wheel;
 }
 
-void Internal::Input::on_key_up(Key key)
+void InputBackend::on_key_up(Key key)
 {
 	int i = (int)key;
 	if (i >= 0 && i < Blah::Input::max_keyboard_keys)
@@ -133,12 +133,12 @@ void Internal::Input::on_key_up(Key key)
 	}
 }
 
-void Internal::Input::on_text_utf8(const char* text)
+void InputBackend::on_text_utf8(const char* text)
 {
 	strncat(g_next_state.keyboard.text, text, Blah::Input::max_text_input);
 }
 
-void Internal::Input::on_controller_connect(int index, const char* name, int is_gamepad, int button_count, int axis_count)
+void InputBackend::on_controller_connect(int index, const char* name, int is_gamepad, int button_count, int axis_count)
 {
 	if (index < Blah::Input::max_controllers)
 	{
@@ -152,13 +152,13 @@ void Internal::Input::on_controller_connect(int index, const char* name, int is_
 	}
 }
 
-void Internal::Input::on_controller_disconnect(int index)
+void InputBackend::on_controller_disconnect(int index)
 {
 	if (index < Blah::Input::max_controllers)
 		g_next_state.controllers[index] = g_empty_controller;
 }
 
-void Internal::Input::on_button_down(int index, int button)
+void InputBackend::on_button_down(int index, int button)
 {
 	if (index < Blah::Input::max_controllers &&
 		button < Blah::Input::max_controller_buttons &&
@@ -171,7 +171,7 @@ void Internal::Input::on_button_down(int index, int button)
 	}
 }
 
-void Internal::Input::on_button_up(int index, int button)
+void InputBackend::on_button_up(int index, int button)
 {
 	if (index < Blah::Input::max_controllers &&
 		button < Blah::Input::max_controller_buttons &&
@@ -183,7 +183,7 @@ void Internal::Input::on_button_up(int index, int button)
 	}
 }
 
-void Internal::Input::on_axis_move(int index, int axis, float value)
+void InputBackend::on_axis_move(int index, int axis, float value)
 {
 	if (index < Blah::Input::max_controllers &&
 		axis < Blah::Input::max_controller_axis &&

public/blah/streams/filestream.cpp

@@ -1,5 +1,5 @@
 #include <blah/streams/filestream.h>
-#include <blah/internal/platform.h>
+#include <blah/internal/platform_backend.h>
 #include <blah/log.h>
 #include <string.h>
 
@@ -14,7 +14,7 @@ FileStream::FileStream()
 FileStream::FileStream(const char* path, FileMode mode)
 	: m_mode(mode)
 {
-	if (!Internal::Platform::file_open(path, &m_handle, mode))
+	if (!PlatformBackend::file_open(path, &m_handle, mode))
 		m_handle = nullptr;
 }
 
@@ -36,7 +36,7 @@ FileStream& FileStream::operator=(FileStream&& src) noexcept
 FileStream::~FileStream()
 {
 	if (m_handle != nullptr)
-		Internal::Platform::file_close(m_handle);
+		PlatformBackend::file_close(m_handle);
 }
 
 int64_t FileStream::length() const
@@ -44,7 +44,7 @@ int64_t FileStream::length() const
 	if (m_handle == nullptr)
 		return 0;
 
-	return Internal::Platform::file_length(m_handle);
+	return PlatformBackend::file_length(m_handle);
 }
 
 int64_t FileStream::position() const
@@ -52,7 +52,7 @@ int64_t FileStream::position() const
 	if (m_handle == nullptr)
 		return 0;
 
-	return Internal::Platform::file_position(m_handle);
+	return PlatformBackend::file_position(m_handle);
 }
 
 int64_t FileStream::seek(int64_t seek_to)
@@ -60,7 +60,7 @@ int64_t FileStream::seek(int64_t seek_to)
 	if (m_handle == nullptr)
 		return 0;
 
-	return Internal::Platform::file_seek(m_handle, seek_to);
+	return PlatformBackend::file_seek(m_handle, seek_to);
 }
 
 int64_t FileStream::read_into(void* ptr, int64_t length)
@@ -71,7 +71,7 @@ int64_t FileStream::read_into(void* ptr, int64_t length)
 		return 0;
 	}
 
-	return Internal::Platform::file_read(m_handle, ptr, length);
+	return PlatformBackend::file_read(m_handle, ptr, length);
 }
 
 int64_t FileStream::write_from(const void* ptr, int64_t length)
@@ -85,13 +85,13 @@ int64_t FileStream::write_from(const void* ptr, int64_t length)
 		return 0;
 	}
 
-	return Internal::Platform::file_write(m_handle, ptr, length);
+	return PlatformBackend::file_write(m_handle, ptr, length);
 }
 
 void FileStream::close()
 {
 	if (m_handle != nullptr)
-		Internal::Platform::file_close(m_handle);
+		PlatformBackend::file_close(m_handle);
 	m_handle = nullptr;
 	m_mode = FileMode::None;
 }

public/blah/streams/stream.cpp

@@ -1,6 +1,5 @@
 #include <blah/streams/stream.h>
 #include <blah/containers/str.h>
-#include <blah/internal/platform.h>
 #include <string.h>
 
 using namespace Blah;