Latest ReWindow

Fixed a bug that would sometimes cause rendering text after rendering an alpha-masked sprite to be invisible.

.gitignore

@@ -1,2 +1,4 @@
 /cmake-build-debug
 /.idea
+
+/assets/test_files

CMakeLists.txt

@@ -17,22 +17,22 @@ include(cmake/CPM.cmake)
 
 CPMAddPackage(
         NAME mcolor
-        URL https://git.redacted.cc/maxine/mcolor/archive/Prerelease-4.zip
+        URL https://git.redacted.cc/maxine/mcolor/archive/Prerelease-5.zip
 )
 
 CPMAddPackage(
         NAME J3ML
-        URL https://git.redacted.cc/josh/j3ml/archive/Release-3.2.zip
+        URL https://git.redacted.cc/josh/j3ml/archive/3.4.3.zip
 )
 
 CPMAddPackage(
         NAME ReWindow
-        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-21.zip
+        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-31.zip
 )
 
 CPMAddPackage(
         NAME GLAD
-        URL https://git.redacted.cc/Redacted/glad/archive/v2.1ext_fboV2.zip
+        URL https://git.redacted.cc/Redacted/glad/archive/v2.1ext_fbo_depthtexture_shadow.zip
 )
 
 CPMAddPackage(
@@ -61,8 +61,8 @@ endif()
 
 file(COPY "assets" DESTINATION "${PROJECT_BINARY_DIR}")
 file(GLOB_RECURSE ASSETS  "assets/*")
-file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")
-file(GLOB_RECURSE SOURCES "src/*.c"     "src/*.cpp"    )
+file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp"            )
+file(GLOB_RECURSE SOURCES "src/*.c" "src/*.cpp" "src/internals/*.h")
 
 find_package(OpenGL REQUIRED)
 
@@ -89,23 +89,23 @@ target_include_directories(JGL PUBLIC
         ${ReImage_SOURCE_DIR}/include
         ${mcolor_SOURCE_DIR}/include
         ${J3ML_SOURCE_DIR}/include
-        ${glad_SOURCE_DIR}/include
         ${jlog_SOURCE_DIR}/include
+        ${glad_SOURCE_DIR}/include
 )
 
 add_executable(JGL_Demo main.cpp)
 #set_target_properties(JGL_Demo PROPERTIES LINK_FLAGS "-Wl,-rpath,./lib")
 
 if (UNIX AND NOT APPLE)
-    target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS})
+    target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS} )
     target_link_libraries(JGL PRIVATE ${FREETYPE_LIBRARIES})
-    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage)
+    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML jlog ReImage glad)
 endif()
 
 if (WIN32)
     target_include_directories(JGL PRIVATE ${freetype_SOURCE_DIR}/include)
     target_link_libraries(JGL PRIVATE freetype)
-    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage)
+    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage glad)
 endif()
 
-target_link_libraries(JGL_Demo PUBLIC JGL ReWindowLibrary Event)
+target_link_libraries(JGL_Demo PUBLIC JGL ReWindowLibrary Event glad)

Doxyfile

@@ -1,4 +1,4 @@
-# Doxyfile 1.9.6
+# Doxyfile 1.9.4
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -19,8 +19,7 @@
 # configuration file:
 # doxygen -x [configFile]
 # Use doxygen to compare the used configuration file with the template
-# configuration file without replacing the environment variables or CMake type
-# replacement variables:
+# configuration file without replacing the environment variables:
 # doxygen -x_noenv [configFile]
 
 #---------------------------------------------------------------------------
@@ -42,7 +41,7 @@ DOXYFILE_ENCODING      = UTF-8
 # title of most generated pages and in a few other places.
 # The default value is: My Project.
 
-PROJECT_NAME           = JGL
+PROJECT_NAME           = "Josh's Graphics Library"
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
@@ -54,21 +53,21 @@ PROJECT_NUMBER         =
 # for a project that appears at the top of each page and should give viewer a
 # quick idea about the purpose of the project. Keep the description short.
 
-PROJECT_BRIEF          = "Linear Algebra, Geometry, and Algorithms in C++"
+PROJECT_BRIEF          =
 
 # With the PROJECT_LOGO tag one can specify a logo or an icon that is included
 # in the documentation. The maximum height of the logo should not exceed 55
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = logo_light_small.png
+PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = .
+OUTPUT_DIRECTORY       = "../../JGL DOXY"
 
 # If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096
 # sub-directories (in 2 levels) under the output directory of each output format
@@ -79,14 +78,14 @@ OUTPUT_DIRECTORY       = .
 # control the number of sub-directories.
 # The default value is: NO.
 
-CREATE_SUBDIRS         = NO
+CREATE_SUBDIRS         = YES
 
 # Controls the number of sub-directories that will be created when
 # CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every
 # level increment doubles the number of directories, resulting in 4096
 # directories at level 8 which is the default and also the maximum value. The
 # sub-directories are organized in 2 levels, the first level always has a fixed
-# number of 16 directories.
+# numer of 16 directories.
 # Minimum value: 0, maximum value: 8, default value: 8.
 # This tag requires that the tag CREATE_SUBDIRS is set to YES.
 
@@ -568,8 +567,7 @@ HIDE_UNDOC_MEMBERS     = NO
 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy. If set
 # to NO, these classes will be included in the various overviews. This option
-# will also hide undocumented C++ concepts if enabled. This option has no effect
-# if EXTRACT_ALL is enabled.
+# has no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
 HIDE_UNDOC_CLASSES     = NO
@@ -607,10 +605,9 @@ INTERNAL_DOCS          = NO
 # Windows (including Cygwin) and MacOS, users should typically set this option
 # to NO, whereas on Linux or other Unix flavors it should typically be set to
 # YES.
-# Possible values are: SYSTEM, NO and YES.
-# The default value is: SYSTEM.
+# The default value is: system dependent.
 
-CASE_SENSE_NAMES       = SYSTEM
+CASE_SENSE_NAMES       = NO
 
 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
 # their full class and namespace scopes in the documentation. If set to YES, the
@@ -860,14 +857,6 @@ WARN_IF_INCOMPLETE_DOC = YES
 
 WARN_NO_PARAMDOC       = NO
 
-# If WARN_IF_UNDOC_ENUM_VAL option is set to YES, doxygen will warn about
-# undocumented enumeration values. If set to NO, doxygen will accept
-# undocumented enumeration values. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: NO.
-
-WARN_IF_UNDOC_ENUM_VAL = NO
-
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
 # a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
 # then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
@@ -926,21 +915,10 @@ INPUT                  = include \
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
 # documentation (see:
 # https://www.gnu.org/software/libiconv/) for the list of possible encodings.
-# See also: INPUT_FILE_ENCODING
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
 
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses The INPUT_FILE_ENCODING tag can be used to specify
-# character encoding on a per file pattern basis. Doxygen will compare the file
-# name with each pattern and apply the encoding instead of the default
-# INPUT_ENCODING) if there is a match. The character encodings are a list of the
-# form: pattern=encoding (like *.php=ISO-8859-1). See cfg_input_encoding
-# "INPUT_ENCODING" for further information on supported encodings.
-
-INPUT_FILE_ENCODING    =
-
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
 # *.h) to filter out the source-files in the directories.
@@ -1089,11 +1067,6 @@ IMAGE_PATH             =
 # code is scanned, but not when the output code is generated. If lines are added
 # or removed, the anchors will not be placed correctly.
 #
-# Note that doxygen will use the data processed and written to standard output
-# for further processing, therefore nothing else, like debug statements or used
-# commands (so in case of a Windows batch file always use @echo OFF), should be
-# written to standard output.
-#
 # Note that for custom extensions or not directly supported extensions you also
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # properly processed by doxygen.
@@ -1135,15 +1108,6 @@ FILTER_SOURCE_PATTERNS =
 
 USE_MDFILE_AS_MAINPAGE =
 
-# The Fortran standard specifies that for fixed formatted Fortran code all
-# characters from position 72 are to be considered as comment. A common
-# extension is to allow longer lines before the automatic comment starts. The
-# setting FORTRAN_COMMENT_AFTER will also make it possible that longer lines can
-# be processed before the automatic comment starts.
-# Minimum value: 7, maximum value: 10000, default value: 72.
-
-FORTRAN_COMMENT_AFTER  = 72
-
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
 #---------------------------------------------------------------------------
@@ -1281,11 +1245,10 @@ CLANG_DATABASE_PATH    =
 
 ALPHABETICAL_INDEX     = YES
 
-# The IGNORE_PREFIX tag can be used to specify a prefix (or a list of prefixes)
-# that should be ignored while generating the index headers. The IGNORE_PREFIX
-# tag works for classes, function and member names. The entity will be placed in
-# the alphabetical list under the first letter of the entity name that remains
-# after removing the prefix.
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
 IGNORE_PREFIX          =
@@ -1364,15 +1327,10 @@ HTML_STYLESHEET        =
 # Doxygen will copy the style sheet files to the output directory.
 # Note: The order of the extra style sheet files is of importance (e.g. the last
 # style sheet in the list overrules the setting of the previous ones in the
-# list).
-# Note: Since the styling of scrollbars can currently not be overruled in
-# Webkit/Chromium, the styling will be left out of the default doxygen.css if
-# one or more extra stylesheets have been specified. So if scrollbar
-# customization is desired it has to be added explicitly. For an example see the
-# documentation.
+# list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_STYLESHEET  = ../../doxygen_theme_flat_design/src/doxygen-style.css
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
@@ -1382,20 +1340,11 @@ HTML_EXTRA_STYLESHEET  =
 # files will be copied as-is; there are no commands or markers available.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_FILES       =
-
-# The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
-# should be rendered with a dark or light theme.
-# Possible values are: LIGHT always generate light mode output, DARK always
-# generate dark mode output, AUTO_LIGHT automatically set the mode according to
-# the user preference, use light mode if no preference is set (the default),
-# AUTO_DARK automatically set the mode according to the user preference, use
-# dark mode if no preference is set and TOGGLE allow to user to switch between
-# light and dark mode via a button.
-# The default value is: AUTO_LIGHT.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE        = AUTO_DARK
+HTML_EXTRA_FILES       = ../../doxygen_theme_flat_design/src/img/opened-folder.png \
+                         ../../doxygen_theme_flat_design/src/img/on_sync.png \
+                         ../../doxygen_theme_flat_design/src/img/off_sync.png \
+                         ../../doxygen_theme_flat_design/src/img/document.png \
+                         ../../doxygen_theme_flat_design/src/img/closed-folder.png
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
@@ -1406,7 +1355,7 @@ HTML_COLORSTYLE        = AUTO_DARK
 # Minimum value: 0, maximum value: 359, default value: 220.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_HUE    = 337
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
 # in the HTML output. For a value of 0 the output will use gray-scales only. A
@@ -1414,7 +1363,7 @@ HTML_COLORSTYLE_HUE    = 220
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_SAT    = 15
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
 # luminance component of the colors in the HTML output. Values below 100
@@ -1425,7 +1374,7 @@ HTML_COLORSTYLE_SAT    = 100
 # Minimum value: 40, maximum value: 240, default value: 80.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_GAMMA  = 80
+HTML_COLORSTYLE_GAMMA  = 169
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting this
@@ -1695,7 +1644,7 @@ DISABLE_INDEX          = NO
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-GENERATE_TREEVIEW      = YES
+GENERATE_TREEVIEW      = NO
 
 # When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
 # FULL_SIDEBAR option determines if the side bar is limited to only the treeview
@@ -1760,6 +1709,17 @@ HTML_FORMULA_FORMAT    = png
 
 FORMULA_FONTSIZE       = 10
 
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
 # The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
 # to create new LaTeX commands to be used in formulas as building blocks. See
 # the section "Including formulas" for details.
@@ -1859,7 +1819,7 @@ MATHJAX_CODEFILE       =
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-SEARCHENGINE           = YES
+SEARCHENGINE           = NO
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
 # implemented using a web server instead of a web client using JavaScript. There
@@ -2465,7 +2425,7 @@ HIDE_UNDOC_RELATIONS   = YES
 # http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
 # Bell Labs. The other options in this section have no effect if this option is
 # set to NO
-# The default value is: NO.
+# The default value is: YES.
 
 HAVE_DOT               = YES
 
@@ -2479,38 +2439,26 @@ HAVE_DOT               = YES
 
 DOT_NUM_THREADS        = 0
 
-# DOT_COMMON_ATTR is common attributes for nodes, edges and labels of
-# subgraphs. When you want a differently looking font in the dot files that
-# doxygen generates you can specify fontname, fontcolor and fontsize attributes.
-# For details please see <a href=https://graphviz.org/doc/info/attrs.html>Node,
-# Edge and Graph Attributes specification</a> You need to make sure dot is able
-# to find the font, which can be done by putting it in a standard location or by
-# setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
-# directory containing the font. Default graphviz fontsize is 14.
-# The default value is: fontname=Helvetica,fontsize=10.
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
+DOT_FONTNAME           = Helvetica
 
-# DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can
-# add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. <a
-# href=https://graphviz.org/doc/info/arrows.html>Complete documentation about
-# arrows shapes.</a>
-# The default value is: labelfontname=Helvetica,labelfontsize=10.
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
+DOT_FONTSIZE           = 10
 
-# DOT_NODE_ATTR is concatenated with DOT_COMMON_ATTR. For view without boxes
-# around nodes set 'shape=plain' or 'shape=plaintext' <a
-# href=https://www.graphviz.org/doc/info/shapes.html>Shapes specification</a>
-# The default value is: shape=box,height=0.2,width=0.4.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
-
-# You can set the path where dot can find font specified with fontname in
-# DOT_COMMON_ATTR and others dot attributes.
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_FONTPATH           =
@@ -2666,8 +2614,9 @@ DIR_GRAPH_MAX_DEPTH    = 1
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
-# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
-# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# Possible values are: png, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd,
+# gif, gif:cairo, gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd,
+# png:cairo, png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
 # png:gdiplus:gdiplus.
 # The default value is: png.
 # This tag requires that the tag HAVE_DOT is set to YES.
@@ -2753,6 +2702,18 @@ DOT_GRAPH_MAX_NODES    = 50
 
 MAX_DOT_GRAPH_DEPTH    = 0
 
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support

README.md

@@ -1,30 +1,31 @@
-# Josh Graphics Library
+# Josh's Graphics Library
 
 Yet Another C++ Rendering Toolkit
 
-![Static Badge](https://img.shields.io/badge/Lit-Based-%20)
+[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/) ![Static Badge](https://img.shields.io/badge/Lit-Based-%20)
 
 
 ## Features
 
-* Modern C++ (20)
-* Provides single-function-calls to render various graphics primitives in 2D and 3D.
-* Integrates directly with our other toolkits (ReWindow, J3ML)
-* Quick Rendering of Debug Text, Geometric Widgets, Textures, and so forth.
-* Little-to-no overhead.
+* Modern C++ (20).
+* Cross Platform (Linux & Windows 10 1909 or newer).
+* Provides single-function-calls to render various graphics in 2D and 3D.
 * Integrates right into an existing OpenGL rendering system.
+* Quick Rendering of Text, Shapes, Sprites / Textures, etc.
 * High-performance text rendering.
+* Little-to-no overhead.
 
 ## API Overview
 
 ### J2D
 * DrawPoint
 * DrawLine / DrawGradientLine
-* DrawSprite
+* DrawSprite / DrawPartialSprite
 * OutlineRect / FillRect / FillGradientRect / FillRoundedRect
 * OutlineCircle / FillCircle
 * OutlineTriangle / FillTriangle
 * DrawString
+
 ### J3D
 * DrawLine
 * DrawString
@@ -33,27 +34,44 @@ Yet Another C++ Rendering Toolkit
 * DrawQuaternionGizmo (WIP)
 
 ### Types
+* RenderTarget
+* VRamList
+* Texture
 * Font
-* Sprite
-* Color4/Color3
-* Gradient
 
 ## Usage
+```cpp
+// Makes sure the glViewport will be the correct size.
+// Typically done once per frame.
+JGL::Update(window_size);
 
-Install instructions and code samples coming soon :tm: !
+JGL::J2D::Begin();
+    JGL::J2D::FillRect(Colors::Blue, {0,0}, {16,16});
+JGL::J2D::End();
+
+// See the example program in main.cpp for more in-depth usage.
+```
+## Requirements
+
+An OpenGL 2.1 or newer accelerator with at-least two texture mappers that supports the `GL_ARB_framebuffer_object` extension or
+an implementation that can provide those features through alternative means (common on ArmSoC and Risc-V).
+
+## Compatability
+
+* AMD ✓
+* NVIDIA ✓
+* Intel ✓
+* Zink (OpenGL-on-Vulkan) ✓
+* GL4ES ✓
 
 ## Documentation
 
-Documentation is (sic: will be) automatically generated from latest commit and is hosted at https://doc.redacted.cc/jgl .
+Documentation is available [here](https://doc.redacted.cc/JGL/d3/dcc/md__r_e_a_d_m_e.html).
 
 ## Contributing
 
 Contributions to JGL are welcome! If you find a bug, have a feature request, or would like to contribute code, please submit an issue or pull request to our repository!
 
-## License
-
-JGL is licensed under the Public Domain. See the LICENSE file for details.
-
 ## Acknowledgements
 
 JGL is developed and maintained by Josh O'Leary @ Co from Redacted Software and contributors. Special thanks to Redacted.

assets/models/cone.obj

@@ -0,0 +1,164 @@
+# Blender v3.6.4 OBJ File: ''
+# www.blender.org
+o Cone
+v 0.000000 -1.000000 -1.000000
+v 0.195090 -1.000000 -0.980785
+v 0.382683 -1.000000 -0.923880
+v 0.555570 -1.000000 -0.831470
+v 0.707107 -1.000000 -0.707107
+v 0.831470 -1.000000 -0.555570
+v 0.923880 -1.000000 -0.382683
+v 0.980785 -1.000000 -0.195090
+v 1.000000 -1.000000 0.000000
+v 0.980785 -1.000000 0.195090
+v 0.923880 -1.000000 0.382683
+v 0.831470 -1.000000 0.555570
+v 0.707107 -1.000000 0.707107
+v 0.555570 -1.000000 0.831470
+v 0.382683 -1.000000 0.923880
+v 0.195090 -1.000000 0.980785
+v 0.000000 -1.000000 1.000000
+v -0.195090 -1.000000 0.980785
+v -0.382683 -1.000000 0.923880
+v -0.555570 -1.000000 0.831470
+v -0.707107 -1.000000 0.707107
+v -0.831470 -1.000000 0.555570
+v -0.923880 -1.000000 0.382683
+v -0.980785 -1.000000 0.195090
+v -1.000000 -1.000000 0.000000
+v -0.980785 -1.000000 -0.195090
+v -0.923880 -1.000000 -0.382683
+v -0.831470 -1.000000 -0.555570
+v -0.707107 -1.000000 -0.707107
+v -0.555570 -1.000000 -0.831470
+v -0.382683 -1.000000 -0.923880
+v -0.195090 -1.000000 -0.980785
+v 0.000000 1.000000 0.000000
+vt 0.250000 0.490000
+vt 0.250000 0.250000
+vt 0.296822 0.485388
+vt 0.341844 0.471731
+vt 0.383337 0.449553
+vt 0.419706 0.419706
+vt 0.449553 0.383337
+vt 0.471731 0.341844
+vt 0.485388 0.296822
+vt 0.490000 0.250000
+vt 0.485388 0.203178
+vt 0.471731 0.158156
+vt 0.449553 0.116663
+vt 0.419706 0.080294
+vt 0.383337 0.050447
+vt 0.341844 0.028269
+vt 0.296822 0.014612
+vt 0.250000 0.010000
+vt 0.203178 0.014612
+vt 0.158156 0.028269
+vt 0.116663 0.050447
+vt 0.080294 0.080294
+vt 0.050447 0.116663
+vt 0.028269 0.158156
+vt 0.014612 0.203178
+vt 0.010000 0.250000
+vt 0.014612 0.296822
+vt 0.028269 0.341844
+vt 0.050447 0.383337
+vt 0.080294 0.419706
+vt 0.116663 0.449553
+vt 0.158156 0.471731
+vt 0.796822 0.014612
+vt 0.514612 0.203178
+vt 0.703178 0.485388
+vt 0.203178 0.485388
+vt 0.750000 0.490000
+vt 0.796822 0.485388
+vt 0.841844 0.471731
+vt 0.883337 0.449553
+vt 0.919706 0.419706
+vt 0.949553 0.383337
+vt 0.971731 0.341844
+vt 0.985388 0.296822
+vt 0.990000 0.250000
+vt 0.985388 0.203178
+vt 0.971731 0.158156
+vt 0.949553 0.116663
+vt 0.919706 0.080294
+vt 0.883337 0.050447
+vt 0.841844 0.028269
+vt 0.750000 0.010000
+vt 0.703178 0.014612
+vt 0.658156 0.028269
+vt 0.616663 0.050447
+vt 0.580294 0.080294
+vt 0.550447 0.116663
+vt 0.528269 0.158156
+vt 0.510000 0.250000
+vt 0.514612 0.296822
+vt 0.528269 0.341844
+vt 0.550447 0.383337
+vt 0.580294 0.419706
+vt 0.616663 0.449553
+vt 0.658156 0.471731
+s off
+f 1/1 33/2 2/3
+f 2/3 33/2 3/4
+f 3/4 33/2 4/5
+f 4/5 33/2 5/6
+f 5/6 33/2 6/7
+f 6/7 33/2 7/8
+f 7/8 33/2 8/9
+f 8/9 33/2 9/10
+f 9/10 33/2 10/11
+f 10/11 33/2 11/12
+f 11/12 33/2 12/13
+f 12/13 33/2 13/14
+f 13/14 33/2 14/15
+f 14/15 33/2 15/16
+f 15/16 33/2 16/17
+f 16/17 33/2 17/18
+f 17/18 33/2 18/19
+f 18/19 33/2 19/20
+f 19/20 33/2 20/21
+f 20/21 33/2 21/22
+f 21/22 33/2 22/23
+f 22/23 33/2 23/24
+f 23/24 33/2 24/25
+f 24/25 33/2 25/26
+f 25/26 33/2 26/27
+f 26/27 33/2 27/28
+f 27/28 33/2 28/29
+f 28/29 33/2 29/30
+f 29/30 33/2 30/31
+f 30/31 33/2 31/32
+f 16/33 24/34 32/35
+f 31/32 33/2 32/36
+f 32/36 33/2 1/1
+f 32/35 1/37 2/38
+f 2/38 3/39 4/40
+f 4/40 5/41 6/42
+f 6/42 7/43 8/44
+f 8/44 9/45 10/46
+f 10/46 11/47 12/48
+f 12/48 13/49 14/50
+f 14/50 15/51 16/33
+f 16/33 17/52 18/53
+f 18/53 19/54 20/55
+f 20/55 21/56 22/57
+f 22/57 23/58 24/34
+f 24/34 25/59 26/60
+f 26/60 27/61 28/62
+f 28/62 29/63 30/64
+f 30/64 31/65 32/35
+f 32/35 2/38 8/44
+f 2/38 4/40 8/44
+f 4/40 6/42 8/44
+f 8/44 10/46 16/33
+f 10/46 12/48 16/33
+f 12/48 14/50 16/33
+f 16/33 18/53 24/34
+f 18/53 20/55 24/34
+f 20/55 22/57 24/34
+f 24/34 26/60 32/35
+f 26/60 28/62 32/35
+f 28/62 30/64 32/35
+f 32/35 8/44 16/33

assets/models/cube.amo

@@ -0,0 +1,46 @@
+ao Cube 1
+v 8
+1.000000 1.000000 1.000000
+1.000000 1.000000 -1.000000
+1.000000 -1.000000 1.000000
+1.000000 -1.000000 -1.000000
+-1.000000 1.000000 1.000000
+-1.000000 1.000000 -1.000000
+-1.000000 -1.000000 1.000000
+-1.000000 -1.000000 -1.000000
+vt 14
+0.625000 0.500000
+0.875000 0.500000
+0.875000 0.750000
+0.625000 0.750000
+0.375000 0.750000
+0.625000 1.000000
+0.375000 1.000000
+0.375000 0.000000
+0.625000 0.000000
+0.625000 0.250000
+0.375000 0.250000
+0.125000 0.500000
+0.375000 0.500000
+0.125000 0.750000
+vn 6
+0.000000 0.000000 1.000000
+0.000000 -1.000000 0.000000
+-1.000000 0.000000 0.000000
+0.000000 0.000000 -1.000000
+1.000000 0.000000 0.000000
+0.000000 1.000000 0.000000
+f 12
+2 0 0 0 1 0 4 2 0 
+7 3 1 3 4 1 2 3 1 
+5 5 2 7 6 2 6 7 2 
+7 8 3 5 9 3 1 10 3 
+3 11 4 1 12 4 0 4 4 
+1 13 5 5 12 5 4 0 5 
+2 0 0 4 1 0 6 2 0 
+7 3 1 2 4 1 6 3 1 
+5 5 2 6 6 2 4 7 2 
+7 8 3 1 9 3 3 10 3 
+3 11 4 0 12 4 2 4 4 
+1 13 5 4 12 5 0 0 5 
+end

assets/models/cube.obj

@@ -0,0 +1,38 @@
+# Blender v3.6.4 OBJ File: ''
+# www.blender.org
+o Cube
+v 1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 1.000000 -1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 -1.000000 1.000000
+vt 0.875000 0.500000
+vt 0.625000 0.750000
+vt 0.625000 0.500000
+vt 0.375000 1.000000
+vt 0.375000 0.750000
+vt 0.625000 0.000000
+vt 0.375000 0.250000
+vt 0.375000 0.000000
+vt 0.375000 0.500000
+vt 0.125000 0.750000
+vt 0.125000 0.500000
+vt 0.625000 0.250000
+vt 0.875000 0.750000
+vt 0.625000 1.000000
+s off
+f 5/1 3/2 1/3
+f 3/2 8/4 4/5
+f 7/6 6/7 8/8
+f 2/9 8/10 6/11
+f 1/3 4/5 2/9
+f 5/12 2/9 6/7
+f 5/1 7/13 3/2
+f 3/2 7/14 8/4
+f 7/6 5/12 6/7
+f 2/9 4/5 8/10
+f 1/3 3/2 4/5
+f 5/12 1/3 2/9

include/JGL/JGL.h

@@ -7,7 +7,7 @@
 
 /// @file JGL.h
 /// @desc All JGL usable functions are defined here. This is the public API.
-/// @edit 2024-07-16
+/// @edit 2024-10-24
 
 
 #pragma once
@@ -26,323 +26,668 @@
 #include <J3ML/Geometry/Sphere.hpp>
 #include <J3ML/Geometry/Capsule.hpp>
 #include <J3ML/Geometry/Triangle2D.hpp>
+#include <JGL/types/Font.h>
+#include <JGL/types/VRamList.h>
+#include <JGL/types/VertexArray.h>
+
+// Fonts that are included by default.
+namespace JGL::Fonts {
+    void Init();
+    // Built in fonts.
+    inline Font Jupiteroid;
+}
+
+// Simple shapes that are pre-computed and used in some draw functions.
+namespace JGL::ShapeCache {
+    inline VRamList* cube_vertex_data = nullptr;
+    inline VRamList* cube_index_data = nullptr;
+    inline VRamList* cube_normal_data = nullptr;
+    // Facing straight out.
+    inline VRamList* j2d_default_normal_data = nullptr;
+    void Init();
+}
 
 /// OpenGL Wrapper for rendering 2D & 3D graphics in both a 2D and 3D context.
 namespace JGL {
     using namespace J3ML::LinearAlgebra;
     using namespace J3ML::Geometry;
 
-
-    /// @param window_size
+    [[nodiscard]] bool Init(const Vector2& window_size, float fovY, float far_plane);
     void Update(const Vector2& window_size);
     inline void PurgeFontCache() { JGL::fontCache.purgeCache(); }
+
+
     std::array<GLfloat, 16> OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far);
-    /// Returns true if the graphics driver meets the requirements (GL Version & Extensions).
+
+    /// @returns true if the graphics driver meets the requirements (GL Version & Extensions).
     bool MeetsRequirements();
-    /// Drawing functions for primitive 2D Shapes.
-    namespace J2D {
-        /// Open a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
-        /// @note This call may not strictly be necessary on some setups, but is provided to keep the API constant.
-        /// It is recommended to always open a JGL 2D context to render your content, then close when completed.
-        /// This keeps our code from, say, clobbering the OpenGL rendering context driving 3D content in between our calls.
-        /// @param render_target
-        /// @param clear_buffers
-        void Begin(RenderTarget* render_target = nullptr, bool clear_buffers = false);
-        /// Closes a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
-        /// @see Begin().
-        void End();
-        /// Provide a list of lights to be used in 2D space. Typically directly after J2D::Begin();
-        /// 8 lights maximum for now. Some kind of light sorting will eventually be needed per j2d element.
-        void LightArray(Light*, size_t size);
-        void LightArray(std::vector<Light> lights);
+}
 
-        /// Plots a single pixel on the screen.
-        /// @param color  A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param coordinates The pixel-point on-screen at which to plot the pixel.
-        /// @param radius The size of the point to plot. By default, a single pixel.
-        void DrawPoint(const Color4& color, const Vector2& coordinates, float radius = 1.f);
-        void DrawPoint(const Color4& color, float x, float y, float radius = 1.f);
+/// Drawing functions for 2D objects.
+namespace JGL::J2D {
+    /// Open a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
+    /// @note This call may not strictly be necessary on some setups, but is provided to keep the API constant.
+    /// It is recommended to always open a JGL 2D context to render your content, then close when completed.
+    /// This keeps our code from, say, clobbering the OpenGL rendering context driving 3D content in between our calls.
+    /// @param render_target
+    /// @param clear_buffers
+    void Begin(RenderTarget* render_target = nullptr, bool clear_buffers = false);
 
-        /// Plots a series of pixel-points on the screen, in a batch.
-        /// @note This is more performant for multiple points than plotting them individually.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param points A set of x,y points to render.
-        /// @param radius The size of the point to plot. By default, a single pixel.
-        void DrawPoints(const Color4& color, const Vector2* points, int num_points, float radius = 1.f);
+    /// Closes a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
+    /// @see Begin().
+    void End();
 
-        /// Plots a line (segment) on the screen.
-        /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
-        /// @param A The starting point of the line segment.
-        /// @param B The end point of the line segment.
-        /// @param thickness The width at which to render the line.
-        void DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness = 1);
-        void DrawLine(const Color4& color, float x1, float y1, float x2, float y2, float thickness = 1);
+    /// Provide a list of lights to be used in 2D space. Typically directly after J2D::Begin();
+    /// 8 lights maximum for now. Some kind of light sorting will eventually be needed per j2d element.
+    void OptionalLights(const LightBase** lights, const size_t& light_count);
 
-        /// Draws a line with a color gradient that transitions across it.
-        /// @param color_a A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param color_b A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param A The starting point of the line segment.
-        /// @param B The end point of the line segment.
-        /// @param thickness The width at which to render the line.
-        void DrawGradientLine(const Color4& color_a, const Color4& color_b, const Vector2& A, const Vector2& B, float thickness = 1);
-        void DrawGradientLine(const Color4& color_a, const Color4& color_b, float x, float y, float w, float h, float thickness = 1);
+    /// Specifies a light which is required for every object in the scene.
+    void RequiredLight(const LightBase* light);
 
-        /// Draws an outline of a rectangle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @param thickness The width at which to render the lines.
-        void OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness = 1);
+    /// Plots a single pixel on the screen.
+    /// @param color  A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param coordinates The pixel-point on-screen at which to plot the pixel.
+    /// @param radius The size of the point to plot. By default, a single pixel.
+    void DrawPoint(const Color4& color, const Vector2& coordinates, float radius = 1.f);
+    void DrawPoint(const Color4& color, float x, float y, float radius = 1.f);
 
-        /// Draws an outline of a rectangle with rounded corners onto the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @param radius The corner-rounding radius (in radians).
-        /// @param thickness The width at which to render the lines.
-        void OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
+    /// Plots a series of pixel-points on the screen, in a batch.
+    /// @note This is more performant for multiple points than plotting them individually.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param points A set of x,y points to render.
+    /// @param radius The size of the point to plot. By default, a single pixel.
+    void DrawPoints(const Color4& color, const Vector2* points, int point_count, float radius = 1.f);
 
-        /// Draws an outline of a rectangle with chamfered corners onto the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @param radius The corner-rounding radius (in radians).
-        /// @param thickness The width at which to render the lines.
-        void OutlineChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
+    /// Plots a line (segment) on the screen.
+    /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
+    /// @param A The starting point of the line segment.
+    /// @param B The end point of the line segment.
+    /// @param thickness The width at which to render the line.
+    void DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness = 1);
+    void DrawLine(const Color4& color, float x1, float y1, float x2, float y2, float thickness = 1);
 
-        /// Draws a filled rectangle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @see FillRoundedRect, FillGradientRect, FillChamferRect.
-        void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);
+    /// Plots several line segments defined by a series of points to be connected together.
+    /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
+    /// @param points pointer to the first point in the list.
+    /// @param point_count the number of points to draw.
+    /// @param thickness The width at which to render the line.
+    void DrawLines(const Color4& color, const Vector2* points, const size_t& point_count, float thickness = 1);
 
-        /// Draws a filled rectangle where the color transitions across it.
-        /// @param color1 A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param color2 A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param gradient See enum Direction
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        void FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size);
+    /// Plots a line segment using a series of points separated by a given distance.
+    /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
+    /// @param A The starting point of the line segment.
+    /// @param B The end point of the line segment.
+    /// @param spacing The distance between each point (px)
+    /// @param thickness The width at which to render the line.
+    /// @note With diagonal lines, the distance between points can differ by one px.
+    void DrawDottedLine(const Color4& color, const Vector2& A, const Vector2& B, float spacing = 1.f, float thickness = 1.f);
+    void DrawDottedLine(const Color4& color, float x1, float y1, float x2, float y2, float spacing = 1.f, float thickness = 1.f);
 
-        /// Draws a filled rectangle with rounded corners on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @param radius The corner-rounding radius (in radians).
-        /// @param subdivisions The amount of sub-divisions (and calculations) to be performed per-arc rounding corner.
-        void FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, unsigned int subdivisions = 8);
+    /// Plots a line segment using a series of points separated by a given distance.
+    /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
+    /// @param A The starting point of the line segment.
+    /// @param B The end point of the line segment.
+    /// @param spacing The distance between each point (px)
+    /// @param dash_length The length of each dash making up the line.
+    /// @param thickness The width at which to render the line.
+    /// @note With diagonal lines, the distance between dashes can differ by one px.
+    void DrawDashedLine(const Color4& color, const Vector2& A, const Vector2& B, float spacing = 4.f, float dash_length = 6.f, float thickness = 1.f);
+    void DrawDashedLine(const Color4& color, float x1, float y1, float x2, float y2, float spacing = 4.f, float dash_length = 6.f, float thickness = 1.f);
 
-        /// Draws a filled rectangle with chamfered (beveled) corners on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param pos The top-left corner of the rectangle.
-        /// @param size The width and height of the rectangle.
-        /// @param radius The corner-rounding radius (in radians).
-        void FillChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5);
+    /// Draws a line with a color gradient that transitions across it.
+    /// @param color_a A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param color_b A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param A The starting point of the line segment.
+    /// @param B The end point of the line segment.
+    /// @param thickness The width at which to render the line.
+    void DrawGradientLine(const Color4& color_a, const Color4& color_b, const Vector2& A, const Vector2& B, float thickness = 1);
+    void DrawGradientLine(const Color4& color_a, const Color4& color_b, float x1, float y1, float x2, float y2, float thickness = 1);
+
+    /// Draws an outline of a rectangle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @param thickness The width at which to render the lines.
+    void OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness = 1);
+
+    /// Draws an outline of a rectangle with rounded corners onto the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @param radius The corner-rounding radius (in radians).
+    /// @param thickness The width at which to render the lines.
+    void OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
+
+    /// Draws an outline of a rectangle with chamfered corners onto the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @param radius The corner-rounding radius (in radians).
+    /// @param thickness The width at which to render the lines.
+    void OutlineChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
+
+    /// Draws a filled rectangle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @see FillRoundedRect, FillGradientRect, FillChamferRect.
+    void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);
+
+    /// Draws a filled rectangle where the color transitions across it.
+    /// @param color1 A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param color2 A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param gradient See enum Direction
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    void FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size);
+
+    /// Draws a filled rectangle with rounded corners on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @param radius The corner-rounding radius (in radians).
+    /// @param subdivisions The amount of sub-divisions (and calculations) to be performed per-arc rounding corner.
+    void FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, unsigned int subdivisions = 8);
+
+    /// Draws a filled rectangle with chamfered (beveled) corners on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The top-left corner of the rectangle.
+    /// @param size The width and height of the rectangle.
+    /// @param radius The corner-rounding radius (in radians).
+    void FillChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5);
+
+    /// Draws a render-target (runtime-modifiable texture) to the screen.
+    /// @param render_target A RenderTarget instance to be displayed.
+    /// @param position The position at which to render this object from it's center-point, defined by the origin parameter.
+    /// @param rad_rotation The amount of radians to rotate this render-target about it's center-point.
+    /// @param origin The center-point in the image to use for rendering, rotation, and scaling. Top-left is {0,0} and bottom right is {1, 1}.
+    /// @param scale The amount (in both x, and y axis) to scale the image, with {1,1} being default scaling.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param inversion @see Direction
+    void DrawRenderTarget(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+                          const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawRenderTarget(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+                          const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+
+    void DrawPartialRenderTarget(const RenderTarget&, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
+                           const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawPartialRenderTarget(const RenderTarget*, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
+                                 const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+
+    /// Draws a sprite (technically, actually a render target) to the screen.
+    /// @note This similar overload exists because we expect someone will be an idiot and turn all of their sprites into RenderTargets. ~william
+    /// @param render_target A RenderTarget instance to be displayed.
+    /// @param position The position at which to render this object from it's center-point, defined by the origin parameter.
+    /// @param rad_rotation The amount of radians to rotate this render-target about it's center-point.
+    /// @param origin The center-point in the image to use for rendering, rotation, and scaling. Top-left is {0,0} and bottom right is {1, 1}.
+    /// @param scale The amount (in both x, and y axis) to scale the image, with {1,1} being default scaling.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param inversion @see Direction
+    /// @see DrawSprite
+    void DrawSprite(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+                    const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+                    const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+
+    /// Draws a sprite to the screen by passing a G̶L̶u̶i̶n̶t̶ JGL Texture that represents a handle to a loaded texture.
+    /// @param texture A texture instance to be displayed.
+    /// @param position The point at which to draw the sprite (from the top-left down).
+    /// @param origin The center point around which the image should have all transformations applied to it.
+    /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
+    /// @param rad_rotation A float representing the rotation of the sprite where 0 is no rotation and 1 is the maximum rotation (would look the same as 0).
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param inversion @see Direction
+    /// @see class Texture
+    void DrawSprite(const Texture& texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
+                    const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture* texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
+                    const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture& texture, float positionX, float positionY, float rad_rotation = 0, float originX = 0, float originY = 0,
+                    float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture* texture, float positionX, float positionY, float rad_rotation = 0,
+                    float originX = 0, float originY = 0,float scaleX = 1, float scaleY = 1,
+                    const Color4& color = Colors::White, Direction inversion = Direction::None);
 
 
+    /// Draws a sprite to the screen by passing a G̶L̶u̶i̶n̶t̶ JGL Texture that represents a handle to a loaded texture.
+    /// @param texture A texture instance to be displayed.
+    /// @param alpha_mask A texture which determines how much of the sprite you can see. Grayscale image exported as "8bpc RGBA".
+    /// @param position The point at which to draw the sprite (from the top-left down).
+    /// @param origin The center point around which the image should have all transformations applied to it.
+    /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
+    /// @param rad_rotation A float representing the rotation of the sprite where 0 is no rotation and 1 is the maximum rotation (would look the same as 0).
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param inversion @see Direction
+    /// @see class Texture
+    void DrawSprite(const Texture& texture, const Texture& alpha_mask, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
+                    const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture* texture, const Texture* alpha_mask, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
+                    const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture& texture, const Texture& alpha_mask, float positionX, float positionY, float rad_rotation = 0, float originX = 0, float originY = 0,
+                    float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawSprite(const Texture* texture, const Texture* alpha_mask, float positionX, float positionY, float rad_rotation = 0, float originX = 0, float originY = 0,
+                    float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
 
-        /// Draws a render-target (runtime-modifiable texture) to the screen.
-        /// @param render_target A RenderTarget instance to be displayed.
-        /// @param position The position at which to render this object from it's center-point, defined by the origin parameter.
-        /// @param rad_rotation The amount of radians to rotate this render-target about it's center-point.
-        /// @param origin The center-point in the image to use for rendering, rotation, and scaling. Top-left is {0,0} and bottom right is {1, 1}.
-        /// @param scale The amount (in both x, and y axis) to scale the image, with {1,1} being default scaling.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param inversion @see Direction
-        void DrawRenderTarget(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
-                              const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawRenderTarget(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
-                              const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    /// Draws a piece of a sprite to the screen, similar to DrawSprite.
+    /// @param texture A texture instance to be displayed.
+    /// @param position The point at which to draw the sprite (from the top-left down).
+    /// @param sub_texture_position The top left corner of the sub-texture to be drawn.
+    /// @param sub_texture_size The size of the sub-texture in px.
+    /// @param origin The center point around which the image should have all transformations applied to it.
+    /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param inversion @see Direction
+    void DrawPartialSprite(const Texture& texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
+                           const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawPartialSprite(const Texture* texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
+                           const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawPartialSprite(const Texture& texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,
+                           float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
+    void DrawPartialSprite(const Texture* texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,
+                           float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
+
+    /// To save v-ram, Use if a sprite would be identical if mirrored horizontally, vertically, or both. For example, a circle.
+    /// Assumes the input texture is the top left quadrant. You can use "SoftwareTexture" to invert it correctly so that's the case.
+    /// @param texture A texture instance to be displayed.
+    /// @param position The point at which to draw the sprite (from the top-left down).
+    /// @param mirror_axis The axes to mirror across, Vertical and Horizontal or both only.
+    /// @param rad_rotation The rotation of the final result.
+    /// @param origin The point at which transformations are done about.
+    /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    void DrawMirrorSprite(const Texture& texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);
+    void DrawMirrorSprite(const Texture* texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);
+
+    /// Draws an outline of a circle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param center The point in cartesian space at which to draw the circle. This will by-definition be the centroid of this circle.
+    /// @param radius The radius of the circle to be drawn. AKA Half the diameter.
+    /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
+    /// @param thickness The line-width of the circle to be rendered at.
+    void OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 16, float thickness = 1);
+
+    /// Draws a filled circle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param center The point in cartesian space at which to draw the circle. This will by-definition be the centroid of this circle.
+    /// @param radius The radius of the circle to be drawn. AKA Half the diameter.
+    /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
+    void FillCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 8);
+
+    /// Draws an outline of a triangle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param tri The triangle defined by its vertices (A, B, and C).
+    /// @param thickness The line-width of the triangle to be rendered at.
+    void OutlineTriangle(const Color4& color, const Triangle2D& tri, float thickness = 1);
+    void OutlineTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC, float thickness = 1);
+
+    /// Draws a filled triangle on the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param tri The triangle defined by its vertices (A, B, and C).
+    void FillTriangle(const Color4& color, const Triangle2D& tri);
+    void FIllTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC);
+
+    /// Fills a triangle defined by the provided vertices with a gradient that transitions smoothly between the three specified colors at each corner.
+    /// @param a_color The color at vertex A of the triangle.
+    /// @param b_color The color at vertex B of the triangle.
+    /// @param c_color The color at vertex C of the triangle.
+    /// @param tri The triangle defined by its vertices (A, B, and C).
+    void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Triangle2D& tri);
+    void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Vector2& tri_a, const Vector2& tri_b, const Vector2& tri_c);
+
+    /// Draws a smooth, curved line segment between two control points, with the curve controlled by the two inner points.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param controlA The first control point, which can be considered the start of the line.
+    /// @param pointA The first inner point, which controls the contour of the curve.
+    /// @param pointB The second inner point, which controls the contour of the curve.
+    /// @param controlB The second control point, which can be considered the end of the line.
+    /// @param subdivisions The accuracy of the approximation of the curve, measured in iteration steps taken.
+    /// @param thickness The line-width to draw the curve with.
+    /// @see J3ML::Algorithm::Bezier
+    void DrawCubicBezierCurve(const Color4& color, const Vector2& controlA, const Vector2& pointA, const Vector2& pointB, const Vector2& controlB,
+                              int subdivisions = 10, float thickness = 1);
+
+    /// Draws a series of points where the last point always connects to the first point.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param points The array of vector2's to draw as a polygon.
+    /// @param point_count The number of points
+    /// @param thickness The line-width of the polygon
+    void OutlinePolygon(const Color4& color, const Vector2* points, int point_count, float thickness = 1);
+
+    /// Draws a text string on the screen with a given point-size and font.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param text The text to be rendered.
+    /// @param x The position on the screen at which to draw the text, from the top-left.
+    /// @param y The position on the screen at which to draw the text, from the top-left.
+    /// @param scale The value (in both axes) to scale the text by. Defaults to {1,1}.
+    /// @param size The point-size at which to render the font out. Re-using the same point-size allows efficient glyph caching.
+    /// @param font The font to use for rendering. @see Font.
+    void DrawString(const Color4& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font = Fonts::Jupiteroid);
 
 
-        /// Draws a sprite (technically, actually a render target) to the screen.
-        /// @note This similar overload exists because we expect someone will be an idiot and turn all of their sprites into RenderTargets. ~william
-        /// @param render_target A RenderTarget instance to be displayed.
-        /// @param position The position at which to render this object from it's center-point, defined by the origin parameter.
-        /// @param rad_rotation The amount of radians to rotate this render-target about it's center-point.
-        /// @param origin The center-point in the image to use for rendering, rotation, and scaling. Top-left is {0,0} and bottom right is {1, 1}.
-        /// @param scale The amount (in both x, and y axis) to scale the image, with {1,1} being default scaling.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param inversion @see Direction
-        /// @see DrawSprite
-        void DrawSprite(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
-                const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawSprite(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
-                        const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+    /// Draws an Arc (section of a circle) to the screen.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param center The point in cartesian space at which to draw the arc. This will by-definition be the centroid of this partial circle.
+    /// @param radius The radius of the partial circle to be drawn. AKA Half the diameter.
+    /// @param arc_begin The point (0 - 2pi) around a unit-circle of which to start the arc.
+    /// @param arc_end The point (0 - 2pi) around a unit-circle of which to start the arc.
+    /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
+    /// @param thickness The line-width to draw the arc with.
+    void DrawArc(const Color4& color, const Vector2& center, float radius, float arc_begin, float arc_end,
+                 unsigned int subdivisions, float thickness);
 
-        /// Draws a sprite to the screen by passing a G̶L̶u̶i̶n̶t̶ JGL Texture that represents a handle to a loaded texture.
-        /// @param texture A texture instance to be displayed.
-        /// @param position The point at which to draw the sprite (from the top-left down).
-        /// @param origin The center point around which the image should have all transformations applied to it.
-        /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
-        /// @param rad_rotation A float representing the rotation of the sprite where 0 is no rotation and 1 is the maximum rotation (would look the same as 0).
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param inversion @see Direction
-        /// @see class Texture
-        void DrawSprite(const Texture& texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
-                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawSprite(const Texture* texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
-                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawSprite(const Texture& texture, float positionX, float positionY, float rad_rotation = 0, float originX = 0, float originY = 0,
-                        float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawSprite(const Texture* texture, float positionX, float positionY, float rad_rotation = 0,
-                        float originX = 0, float originY = 0,float scaleX = 1, float scaleY = 1,
-                        const Color4& color = Colors::White, Direction inversion = Direction::None);
 
-        /// Draws a piece of a sprite to the screen, similar to DrawSprite.
-        /// @param texture A texture instance to be displayed.
-        /// @param position The point at which to draw the sprite (from the top-left down).
-        /// @param sub_texture_position The top left corner of the sub-texture to be drawn.
-        /// @param sub_texture_size The size of the sub-texture in px.
-        /// @param origin The center point around which the image should have all transformations applied to it.
-        /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param inversion @see Direction
-        void DrawPartialSprite(const Texture& texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
-                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawPartialSprite(const Texture* texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
-                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawPartialSprite(const Texture& texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,
-                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
-        void DrawPartialSprite(const Texture* texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,
-                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
+    /// TODO Implement the following. These ones are going to be extremely annoying.
+    void FillPolygon(const Color4& color, const std::vector<Vector2>& points);
+    void OutlineEllipse(const Color4& color, const Vector2& position, float radius_x, float radius_y, float thickness = 1, int subdivisions = 8);
+    void FillEllipse(const Color4& color, const Vector2& position, float radius_x, float radius_y, int subdivisions = 8);
+}
 
-        /// To save v-ram, Use if a sprite would be identical if mirrored horizontally, vertically, or both. For example, a circle.
-        /// Assumes the input texture is the top left quadrant. You can use "SoftwareTexture" to invert it correctly so that's the case.
-        /// @param texture A texture instance to be displayed.
-        /// @param position The point at which to draw the sprite (from the top-left down).
-        /// @param mirror_axis The axes to mirror across, Vertical and Horizontal or both only.
-        /// @param rad_rotation The rotation of the final result.
-        /// @param origin The point at which transformations are done about.
-        /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        void DrawMirrorSprite(const Texture& texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);
-        void DrawMirrorSprite(const Texture* texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);
+/// Drawing functions for 3D objects.
+namespace JGL::J3D {
+    /// A light for this 3D render that should never be culled out. up-to 8.
+    /// The more you put here, The less we will solve for if you're also using LightArray.
+    /// @note More than 8 lights will cause an error to be printed.
+    void RequiredLight(const LightBase* light);
 
-        /// Draws an outline of a circle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param center The point in cartesian space at which to draw the circle. This will by-definition be the centroid of this circle.
-        /// @param radius The radius of the circle to be drawn. AKA Half the diameter.
-        /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
-        /// @param thickness The line-width of the circle to be rendered at.
-        void OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 16, float thickness = 1);
+    /// When each 3D object is drawn, We'll do our best to determine which lights would effect it the most and use those ones.
+    void OptionalLights(const LightBase** lights, const size_t& light_count);
 
-        /// Draws a filled circle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param center The point in cartesian space at which to draw the circle. This will by-definition be the centroid of this circle.
-        /// @param radius The radius of the circle to be drawn. AKA Half the diameter.
-        /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
-        void FillCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 8);
+    /// Helper function to conveniently change the Field-Of-View.
+    void ChangeFOV(float fov);
 
-        /// Draws an outline of a triangle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param tri The triangle structure / set of 3 points in cartesian space used to draw the triangle.
-        /// @param thickness The line-width of the triangle to be rendered at.
-        void OutlineTriangle(const Color4& color, const Triangle2D& tri, float thickness = 1);
-        void OutlineTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC, float thickness = 1);
+    /// Helper function to change the far-plane, which is the cutoff distance for rendering.
+    void ChangeFarPlane(float far_plane);
 
-        /// Draws a filled triangle on the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param tri The triangle structure / set of 3 points in cartesian space used to draw the triangle.
-        void FillTriangle(const Color4& color, const Triangle2D& tri);
-        void FIllTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC);
+    /// Open a 3-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
+    /// It is recommended to always open a JGL 3D context to render your content, then close when completed.
+    /// @param two_pass Whether or not we'll use two-pass rendering for occlusion.
+    void Begin(bool two_pass = false);
 
-        /// Draws a triangle where each corner is defined by a given color, Smoothly transitioning between them.
-        /// @param a_color
-        /// @param b_color
-        /// @param c_color
-        /// @param tri
-        void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Triangle2D& tri);
+    /// Closes a 3-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
+    /// @see Begin().
+    void End();
 
-        /// Draws a smooth, curved line segment between two control points, with the curve controlled by the two inner points.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param controlA The first control point, which can be considered the start of the line.
-        /// @param pointA The first inner point, which controls the contour of the curve.
-        /// @param pointB The second inner point, which controls the contour of the curve.
-        /// @param controlB The second control point, which can be considered the end of the line.
-        /// @see J3ML::Algorithm::Bezier
-        void DrawCubicBezierCurve(const Color4& color, const Vector2& controlA, const Vector2& pointA, const Vector2& pointB, const Vector2& controlB,
+    void SetMatrix(const std::vector<GLfloat>& matrix, const Vector2& window_size);
+
+    /// Draws a line in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param A The start-point of the line segment.
+    /// @param B The end-point of the line segment.
+    /// @param thickness The line-width to draw the line segment with.
+    void DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness = 1.f);
+
+    /// Draws a smooth, curved line segment between two control points, with the curve controlled by the two inner points.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param controlA The first control point, which can be considered the start of the line.
+    /// @param pointA The first inner point, which controls the contour of the curve.
+    /// @param pointB The second inner point, which controls the contour of the curve.
+    /// @param controlB The second control point, which can be considered the end of the line.
+    /// @param subdivisions The accuracy of the approximation of the curve, measured in iteration steps taken.
+    /// @param thickness The line-width to draw the curve with.
+    /// @see J3ML::Algorithm::Bezier
+    void DrawCubicBezierCurve(const Color4& color, const Vector3& controlA, const Vector3& pointA, const Vector3& pointB, const Vector3& controlB,
                                   int subdivisions = 10, float thickness = 1);
 
+    /// Draws the outline of an Icosahedron in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Icosahedron.
+    /// @param radius The size to draw the Icosahedron at.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    void WireframeIcosahedron(const Color4& color, const Vector3& position, float radius, float thickness = 1.f);
 
-        // TODO: Implement OutlinePolygon overload which takes a std::vector of points as well.
+    /// Draws a solid Icosahedron in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Icosahedron.
+    /// @param radius The size to draw the Icosahedron at.
+    void FillIcosahedron(const Color4& color, const Vector3& position, float radius);
 
-        /// Draws a series of points where the last point always connects to the first point.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param points The array of vector2's to draw as a polygon.
-        /// @param points_size The length of the array of vector2's.
-        /// @param thickness The line-width of the polygon
-        void OutlinePolygon(const Color4& color, const Vector2* points, int points_size, float thickness = 1);
+    /// Draws the outline of a Sphere in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    void WireframeSphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f,  unsigned int sectors = 10, unsigned int stacks = 10);
 
-        /// Draws a text string on the screen with a given point-size and font.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param text The text to be rendered.
-        /// @param x The position on the screen at which to draw the text, from the top-left.
-        /// @param y The position on the screen at which to draw the text, from the top-left.
-        /// @param scale The value (in both axes) to scale the text by. Defaults to {1,1}.
-        /// @param size The point-size at which to render the font out. Re-using the same point-size allows efficient glyph caching.
-        /// @param font The font to use for rendering. @see Font.
-        void DrawString(const Color4& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font);
+    /// Draws the outline of a Sphere in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    void WireframeSphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int sectors = 10, unsigned int stacks = 10);
 
+    /// Draws outlines of multiple spheres in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param spheres The mathematically-defined sphere objects to be rendered.
+    /// @param sphere_count The number of spheres.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    /// @note The "Position" of the spheres is expected to be in world space.
+    void BatchWireframeSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, float thickness = 1.f, unsigned int sectors = 10, unsigned int stacks = 10);
 
-        /// Draws an Arc (section of a circle) to the screen.
-        /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
-        /// @param center The point in cartesian space at which to draw the arc. This will by-definition be the centroid of this partial circle.
-        /// @param radius The radius of the partial circle to be drawn. AKA Half the diameter.
-        /// @param arc_begin The point (0 - 2pi) around a unit-circle of which to start the arc.
-        /// @param arc_end The point (0 - 2pi) around a unit-circle of which to start the arc.
-        /// @param subdivisions The accuracy of the approximation of the circle, measured in iteration steps taken.
-        /// @param thickness The line-width to draw the arc with.
-        void DrawArc(const Color4& color, const Vector2& center, float radius, float arc_begin, float arc_end,
-                     unsigned int subdivisions, float thickness);
+    /// Draws outlines of a sphere in 3D space. Calculates a cross section and revolves it around the center.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param revolutions The number of times to revolve the cross section about the center.
+    /// @param draw_stacks Whether or not to draw the stacks of the sphere.
+    void WireframeRevoSphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, unsigned int sectors = 10, unsigned int revolutions = 10, bool draw_stacks = false);
 
+    /// Draws the outline of a Sphere in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param revolutions The number of times to revolve the cross section about the center.
+    /// @param draw_stacks Whether or not to draw the stacks of the sphere.
+    void WireframeRevoSphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int sectors = 10, unsigned int revolutions = 10, bool draw_stacks = false);
 
-        /// TODO Implement the following. These ones are going to be extremely annoying.
-        void FillPolygon(const Color4& color, const std::vector<Vector2>& points);
-        void FillTexturedPolygon();
-        void FillTexturedTriangle();
-    }
+    /// Draws outlines of multiple spheres in 3D space. Calculates a cross section and revolves it around the center.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param spheres The mathematically-defined sphere objects to be rendered.
+    /// @param sphere_count The number of spheres.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param revolutions The number of times to revolve the cross section about the center.
+    /// @param draw_stacks Whether or not to draw the stacks of the sphere.
+    /// @note The "Position" of the spheres is expected to be in world space.
+    /// @note This method of drawing a sphere is *probably* the fastest out of all of them.
+    void BatchWireframeRevoSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, float thickness = 1.f, unsigned int sectors = 10, unsigned int revolutions = 10, bool draw_stacks = false);
 
-    /// Drawing functions for primitive 3D Shapes.
-    namespace J3D {
-        void Init(const Vector2& window_size, float fov, float far_plane);
-        void ChangeFOV(float fov);
-        void ChangeFarPlane(float far_plane);
-        void Begin();
-        void End();
-        void SetMatrix(const std::vector<GLfloat>& matrix, const Vector2& window_size);
-        void DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness = 1);
-        void FillSphere(const Color3& color, const Sphere& sphere);
-        void WireframeSphere(const Color3& color, const Sphere& sphere, float thickness = 1);
-        void FillOBB(const Color3& color, const OBB& obb);
-        void WireframeOBB(const Color3& color, const OBB& obb, float thickness = 1);
-        void FillCapsule(const Color3& color, const Capsule& capsule);
-        void WireframeCapsule(const Color3& color, const Capsule& cap, float thickness = 1);
-        void FillTriangleMesh(const Color3& color, const TriangleMesh& mesh);
-        void WireframeTriangleMesh(const Color3& color, const TriangleMesh& mesh, float thickness = 1);
+    /// Draws the outline of an Icosphere in 3D space.
+    /// @note An Icosphere is an approximation of a sphere that is generated by recursively subdividing an Icosahedron.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    /// @param subdivisions The accuracy of the approximation of the Icosphere, measured in iteration steps taken.
+    void WireframeIcosphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, unsigned int subdivisions = 10);
 
-        /// Draws a string of text in 3D space, with an arbitrary rotation.
-        /// @param color
-        /// @param text
-        /// @param pos
-        /// @param scale
-        /// @param size
-        /// @param font
-        /// @param angle
-        /// @param draw_back_face
-        void DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngle& angle = {0, 0, 0}, bool draw_back_face = false);
+    /// Draws the outline of an Icosphere in 3D space.
+    /// @note An Icosphere is an approximation of a sphere that is generated by recursively subdividing an Icosahedron.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param thickness The line-width to draw the Icosphere outline with.
+    /// @param subdivisions The accuracy of the approximation of the Icosphere, measured in iteration steps taken.
+    void WireframeIcosphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int subdivisions = 10);
 
-        /// Draws a string of text in 3D space that is always facing the exact direction of the camera projection.
-        void DrawBillboardString();
+    /// Draws the outline of a Cubesphere in 3D space.
+    /// @note A Cubesphere is an approximation of a sphere that is generated by recursively subdividing a Cube.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param thickness The line-width to draw the Cubesphere outline with.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void WireframeCubesphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, unsigned int subdivisions = 10);
 
-        /// Draws a texture sprite in 3D space that is always facing the exact direction of the camera projection.
-        void DrawBillboardSprite();
+    /// Draws the outline of a Cubesphere in 3D space.
+    /// @note A Cubesphere is an approximation of a sphere that is generated by recursively subdividing a Cube.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param thickness The line-width to draw the Cubesphere outline with.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void WireframeCubesphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int subdivisions = 10);
 
-        void DrawSprite();
-        void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);
-        void DrawMatrixGizmo     (const Matrix4x4&);
-        void DrawAxisAngleGizmo  (const AxisAngle&,  const Vector3&);
-        void DrawQuaternionGizmo (const Quaternion&, const Vector3&);
-    }
+    /// Draws a solid Sphere in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    void FillSphere(const Color4& color, const Vector3& position, float radius, unsigned int sectors = 10, unsigned int stacks = 10);
+
+    /// Draws a solid Sphere in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    void FillSphere(const Color4& color, const Sphere& sphere, unsigned int sectors = 10, unsigned int stacks = 10);
+
+    /// Draws multiple solid Spheres in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param spheres The mathematically-defined sphere objects to be rendered.
+    /// @param sphere_count The number of spheres to be rendered.
+    /// @param sectors The amount of latitudinal subdivisions to perform when computing the sphere.
+    /// @param stacks The amount of longitudinal subdivisions to perform when computing the sphere.
+    void BatchFillSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, unsigned int sectors = 10, unsigned int stacks = 10);
+
+    /// Draws a solid Icosphere in 3D space.
+    /// @note An Icosphere is an approximation of a sphere that is generated by recursively subdividing an Icosahedron.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void FillIcosphere(const Color4& color, const Vector3& position, float radius, unsigned int subdivisions = 10);
+
+    /// Draws a solid Icosphere in 3D space.
+    /// @note An Icosphere is an approximation of a sphere that is generated by recursively subdividing an Icosahedron.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void FillIcosphere(const Color4& color, const Sphere& sphere, unsigned int subdivisions = 10);
+
+    /// Draws a solid Cubesphere in 3D space.
+    /// @note A Cubesphere is an approximation of a sphere that is generated by recursively subdividing a Cube.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space at which to draw the Sphere.
+    /// @param radius The size to draw the Sphere at.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void FillCubesphere(const Color4& color, const Vector3& position, float radius, unsigned int subdivisions = 10);
+
+    /// Draws a solid Cubesphere in 3D space.
+    /// @note A Cubesphere is an approximation of a sphere that is generated by recursively subdividing a Cube.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param sphere The mathematically-defined sphere object to be rendered.
+    /// @param subdivisions The accuracy of the approximation of the Cubesphere, measured in iteration steps taken.
+    void FillCubesphere(const Color4& color, const Sphere& sphere, unsigned int subdivisions = 10);
+
+    /// Draws an outline of an axis-aligned bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The point in 3D space that is the center of the AABB.
+    /// @param radii The radii along x,y,z axes to size the bounding box.
+    /// @param thickness The line-width to draw the Icosphere outline with.
+    void WireframeAABB(const Color4& color, const Vector3& pos, const Vector3& radii, float thickness = 1.f);
+
+    /// Draws an outline of an axis-aligned bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param aabb The AABB object to render.
+    /// @param thickness The line-width to draw the Icosphere outline with.
+    void WireframeAABB(const Color4& color, const AABB& aabb, float thickness = 1.f);
+
+    /// Draws outlines of multiple axis-aligned bounding-boxes in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param boxes The boxes to be drawn.
+    /// @param box_count The number of boxes to be drawn.
+    /// @param thickness The line-width to draw the Icosahedron outline with.
+    void BatchWireframeAABB(const Color4& color, const AABB* boxes, const size_t& box_count, float thickness = 1.f);
+
+    /// Draws a solid axis-aligned bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param pos The point in 3D space that is the center of the AABB.
+    /// @param radii The radii along x,y,z axes to size the bounding box.
+    void FillAABB(const Color4& color, const Vector3& pos, const Vector3& radii);
+
+    /// Draws a solid axis-aligned bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param aabb The AABB object to visualize.
+    void FillAABB(const Color4& color, const AABB& aabb);
+
+    /// Draws solid axis-aligned bounding boxes in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param aabb The AABB objects to visualize.
+    /// @param box_count The number of AABBs to draw.
+    void BatchFillAABB(const Color4& color, const AABB* boxes, const size_t& box_count);
+
+    /// Draws an outline of an oriented bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The point in 3D space that is the center of the AABB.
+    /// @param radii The radii along x,y,z axes to size the bounding box.
+    /// @param orientation The rotation in 3D space of the OBB.
+    /// @param thickness The line-width to draw the OBB outline with.
+    void WireframeOBB(const Color4& color, const Vector3& position, const Vector3& radii, const Matrix3x3& orientation, float thickness = 1.f);
+
+    /// Draws an outline of an oriented bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param obb The OBB object to visualize.
+    /// @param thickness The line-width to draw the OBB outline with.
+    void WireframeOBB(const Color4& color, const OBB& obb, float thickness = 1.f);
+
+    void BatchWireframeOBB(const Color4& color, const OBB* boxes, const size_t& box_count, float thickness = 1.f);
+
+    /// Draws a solid oriented bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param position The center-position of the oriented bounding box.
+    /// @param radii The radii along x,y,z axes to size the bounding box.
+    /// @param orientation The rotation in 3D space of the OBB.
+    void FillOBB(const Color4& color, const Vector3& position, const Vector3& radii, const EulerAngleXYZ& orientation);
+
+    /// Draws a solid oriented bounding box in 3D space.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param obb The oriented-bounding-box object to visualize.
+    void FillOBB(const Color4& color, const OBB& obb);
+
+    void WireframeCylinder();
+    void FillCylinder();
+    void WireframePrism();
+    void FillPrism();
+    void WireframePipe();
+    void FillPipe();
+    void WireframeCone();
+    void FillCone();
+    void WireframeTorus();
+    void FillTorus();
+
+    void FillCapsule(const Color3& color, const Capsule& capsule);
+    void WireframeCapsule(const Color3& color, const Capsule& cap, float thickness = 1.f);
+    void FillTriangleMesh(const Color3& color, const TriangleMesh& mesh);
+    void WireframeTriangleMesh(const Color3& color, const TriangleMesh& mesh, float thickness = 1.f);
+
+    /// Draws a string of text in 3D space, with an arbitrary rotation.
+    /// @param color A 3-or-4 channel color value. @see class Color3, class Color4
+    /// @param text The content to display on the screen.
+    /// @param pos The position in 3D space to display the text.
+    /// @param scale The scaling factor to render the text with, 1 being default. TODO: Vector2 scaling?
+    /// @param size The pixel size to rasterize the font with.
+    /// @param font The font object to use when drawing.
+    /// @param angle The orientation in 3D space.
+    /// @param draw_back_face
+    void DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font = Fonts::Jupiteroid, const EulerAngleXYZ& angle = {0, 0, 0}, bool draw_back_face = false);
+
+    void DrawVertexArray(const Color4& color, const VertexArray& vertex_array, const Vector3& position);
+    /// Draws a string of text in 3D space that is always facing the exact direction of the camera projection.
+    void DrawBillboardString();
+
+    /// Draws a texture sprite in 3D space that is always facing the exact direction of the camera projection.
+    void DrawBillboardSprite();
+
+    void DrawSprite();
+    void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);
+    void DrawMatrixGizmo     (const Matrix4x4&);
+    void DrawAxisAngleGizmo  (const AxisAngle&,  const Vector3&);
+    void DrawQuaternionGizmo (const Quaternion&, const Vector3&);
 }

include/JGL/types/Font.h

@@ -13,8 +13,6 @@ extern "C" typedef struct FT_LibraryRec_* FT_Library;
 
 namespace JGL
 {
-
-    /// Initializes FreeType engine. Remember to call this during program initialization.
     bool InitTextEngine();
 
     /// A Font class implementation.
@@ -23,7 +21,8 @@ namespace JGL
     public:
         /// Default constructor does not initialize any members
         Font() = default;
-        Font(const std::filesystem::path& path);
+        explicit Font(const std::filesystem::path& path);
+        Font(const unsigned char* data, const size_t& size);
         /// Destructor handles freeing of the underlying asset handle.
         ~Font();
         static Font LoadTTF(const std::filesystem::path& filepath);
@@ -35,6 +34,6 @@ namespace JGL
         Vector2 MeasureString(const std::string& text, unsigned int ptSize);
     public:
         int index = 0;
-        FT_Face face;
+        FT_Face face = nullptr;
     };
 }

include/JGL/types/Light.h

@@ -1,30 +1,70 @@
 #pragma once
 #include <J3ML/LinearAlgebra/Vector4.hpp>
 #include <J3ML/LinearAlgebra/Vector3.hpp>
+#include <J3ML/LinearAlgebra/DirectionVector.hpp>
+#include <J3ML/Geometry/Frustum.hpp>
 #include <Color4.hpp>
 
 namespace JGL {
-    class Light;
-    class OmnidirectionalLight2D;
-    class PointLight2D;
+    class LightBase;
+    class PointLight;
+    class SpotLight;
 }
 
-class JGL::Light {
-private:
-    /// W in position seems to determine whether or not the light is omni-directional. 1 = omni 0 = point.
-    /// Position is un-normalized screen space. For ex 500, 500, 1 for a light coming from where you're sitting.
+// TODO this can be consolidated.
+class JGL::LightBase {
+protected:
+    /* The 4th number represents whether the light is a positional light.
+     * In OpenGL, You can have positional lights, Like Point Lights or Spot Lights,
+     * Or global lights, Like the sun. */
     Vector4 position = {0, 0, 0, 1};
     Color4 ambient = {0, 0, 0, 0};
     Color4 diffuse = {0, 0, 0, 0};
     Color4 specular = {0, 0, 0, 0};
+
+    float constant_attenuation = 1;
+    float linear_attenuation = 0;
+    float quadratic_attenuation = 0;
 public:
-    Light(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular);
-    Vector3 GetNormalizedSceenSpaceCoordinates() const;
+    [[nodiscard]] Vector4 GetPosition() const;
+    [[nodiscard]] Color4 GetAmbient() const;
+    [[nodiscard]] Color4 GetDiffuse() const;
+    [[nodiscard]] Color4 GetSpecular() const;
+
+    [[nodiscard]] float GetConstantAttenuation() const;
+    [[nodiscard]] float GetLinearAttenuation() const;
+    [[nodiscard]] float GetQuadraticAttenuation() const;
+public:
+    /// Runs a calculation to determine the lights influence on a given point in 3D space.
+    /// @note 0 would be no impact, 1 would be the light is at the same position.
+    [[nodiscard]] virtual float GetAttenuationAtPosition(const Vector3& pos) const { return 0; }
+public:
+    virtual ~LightBase() = default;
 };
 
-class JGL::OmnidirectionalLight2D {
-private:
+/// Omni-directional lights.
+class JGL::PointLight : public LightBase {
 public:
-    OmnidirectionalLight2D(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular);
-
+    [[nodiscard]] float GetAttenuationAtPosition(const Vector3& pos) const final;
+public:
+    PointLight(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular, float constant_attenuation = 1, float linear_attenuation = 0, float quadratic_attenuation = 0);
 };
+
+/// Lights which only effect things in a given cone.
+// TODO get attenuation at position for this.
+class JGL::SpotLight : public LightBase {
+protected:
+    Matrix3x3 orientation;
+    float exponent;
+    float cut;
+public:
+    /// Create a spotlight in 3D space.
+    /// @param position The position of the light in 3D space.
+    /// @param ro_mat Orientation of the light in 3D space.
+    /// @param cone_size_degrees The size of the cone.
+    /// @param exponent How focused the beam should be, Higher is more focused, Lower is less.
+    /// @param ambient How much this light should effect the ambient light of the scene.
+    /// @param diffuse
+    /// @param specular How much this light should effect specular highlights of objects being influenced by it.
+    SpotLight(const Vector3& position, const Matrix3x3& ro_mat, float cone_size_degrees, float exponent, const Color4& ambient, const Color4& diffuse, const Color4& specular, float constant_attenuation = 1, float linear_attenuation = 0, float quadratic_attenuation = 0);
+};

include/JGL/types/Material.h

@@ -1,4 +1,19 @@
 /// A simple wrapper for OpenGL materials. Lets you set things such as the "shininess" of your elements.
-class Material {
 
+#include <Color4.hpp>
+#include <glad/glad.h>
+namespace JGL {
+    class Material;
+}
+class JGL::Material {
+public:
+    Color4 ambient_ref;
+    Color4 diffuse_ref;
+    Color4 specular_ref;
+    Color4 emission;
+    float shininess;
+public:
+    Material(const Color4& ambient_reflection, const Color4& diffuse_reflection, const Color4& specular_reflection, const Color4& light_emission, float& shine);
+    /// @param material Material to use.
+    static void SetActiveMaterial(const Material& material);
 };

include/JGL/types/RenderTarget.h

@@ -1,20 +1,21 @@
 #pragma once
+#include <vector>
 #include <glad/glad.h>
 #include <Color4.hpp>
 #include <Colors.hpp>
 #include <JGL/types/Enums.h>
-#include <J3ML/LinearAlgebra/Vector2.hpp>
+#include <J3ML/LinearAlgebra/Vector2i.hpp>
 
 namespace JGL {
     class RenderTarget;
-    class Texture; // Forward declare.
+    class Texture;
 }
 
+using J3ML::LinearAlgebra::Vector2i;
 class JGL::RenderTarget {
 private:
     Color4 clear_color{0,0,0,0};
-    /// "Size" in this sense is the "Renderable Area" because OpenGL textures behave strangely if they're not square.
-    Vector2 size{0, 0};
+    Vector2i size{0, 0};
     bool using_depth = false;
     bool texture_created_by_us = false;
     GLuint framebuffer_object = 0;
@@ -26,41 +27,97 @@ private:
     GLuint msaa_render_buffer = 0;
     void Erase();
 public:
+    /// @returns The Render Target currently in use by OpenGL.
+    /// @note Zero is the screen.
     static GLuint GetActiveGLFramebufferHandle();
+
+    /// Changes the Render Target that OpenGL will draw on.
+    /// @param render_target The new Render Target for OpenGL to draw on.
     static void SetActiveGLRenderTarget(const RenderTarget& render_target);
 
-    /** Change the size of the renderable area of the Render Target. **/
-    /// @param new_size new size in px.
-    void Resize(const Vector2& new_size);
-    void SetMSAAEnabled(MSAA_SAMPLE_RATE sample_rate);
-    /// If you're using raw OpenGL commands to draw to this outside of J2D or J3D don't forget to do this.
-    /// Blits the MSAA FBO onto the regular FBO if MSAA is enabled and or If you're rendering to a texture which uses mipmaps,
-    /// It regenerates them so what you drew doesn't disappear at a distance. Otherwise it does nothing.
-    void Blit() const;
+    /// Changes the size of the renderable area of this Render Target.
+    /// @param new_size new width & height in pixels.
+    /// @note The data stored in this Render Target will be lost.
+    void Resize(const Vector2i& new_size);
 
-    /// Blit a render target onto another. Will break if they're not the same size.
-    static void Blit(const RenderTarget& source, RenderTarget* destination);
-    [[nodiscard]] bool TextureCreatedByRenderTarget() const;
+    /// Sets the MSAA mode for this Render Target.
+    /// @returns false if the mode isn't available, true for success.
+    [[nodiscard]] bool SetMSAAEnabled(MSAA_SAMPLE_RATE sample_rate);
+
+    /// If you're using MSAA and not using J2D || J3D Begin & End you must do this.
+    void MSAABlit() const;
+
+    /// Copy one Render Target onto another. Will break if they're not the same size.
+    // TODO support different sizes. If the destination is too small fix it for them but log a warning.
+    static void Blit(const RenderTarget& source, RenderTarget* destination, const Vector2i& position = {0, 0});
+
+    /// Plots a single pixel onto a Render Target.
+    /// @param color The color to render.
+    /// @param position The position in the destination to draw the pixel.
+    /// @param destination The destination RenderTarget.
+    static void Blit(const Color4& color, const Vector2i& position, RenderTarget* destination);
+
+    /// Blit an input texture onto this render target at the given position.
+    /// @param source Source texture.
+    /// @param destination Render Target to draw on.
+    /// @param position Where in the destination to draw.
+    static void Blit(const Texture* source, RenderTarget* destination, const Vector2i& position = {0, 0});
+
+    /// @returns Whether or not this Render Target created it's Texture.
+    [[nodiscard]] bool OwnsTexture() const;
 public:
-    [[nodiscard]] Vector2 GetDimensions() const;
+    /// @returns the size of the renderable area.
+    [[nodiscard]] Vector2i GetDimensions() const;
+
+    /// @returns The currently selected MSAA Sample Rate.
     [[nodiscard]] MSAA_SAMPLE_RATE GetMSAASampleRate() const;
-    /// Returns whether or not MSAA is enabled, If it is and you're not using J2D || J3D Begin / End,
-    /// You need to run "Blit()" after rendering to your FBO before you show it.
-    /// @note Also, If the texture wasn't made by the RenderTarget you don't want this. It would destroy the texture.
+
+    /// @returns Whether or not this Render Target is using MSAA.
     [[nodiscard]] bool MSAAEnabled() const;
+
+    /// @returns The JGL texture this Render Target draws on.
     [[nodiscard]] const Texture* GetJGLTexture() const;
+
+    /// @returns The OpenGL handle for the texture this Render Target draws on.
     [[nodiscard]] GLuint GetGLTextureHandle() const;
+
+    /// @returns The OpenGL handle for this Render Target.
     [[nodiscard]] GLuint GetGLFramebufferObjectHandle() const;
+
+    /// @returns The handle to the OpenGL buffer containing depth information
+    /// @note Only valid if this Render Target is being used for 3D.
     [[nodiscard]] GLuint GetGLDepthBufferHandle() const;
+
+    /// @returns The color that should be used to clear this Render Target.
     [[nodiscard]] Color4 GetClearColor() const;
-    /// Get the data back from the FBO. This is *not* async friendly.
-    [[nodiscard]] std::vector<GLfloat> GetData() const;
+
+
+    /// @returns The color information for this Render Target.
+    /// @note Both the CPU & GPU cannot do anything while this takes place. It's very slow.
+    [[nodiscard]] std::vector<GLfloat> GetPixels() const;
 public:
-    /// Copy constructor. Will always set "texture_created_by_us" to true and use our own texture to avoid memleaks.
+    /// Create a Render Target from a Render Target that already exists.
+    /** @note Render Targets that are copies of another will copy the Texture.
+     * This is so that deleting the copy doesn't delete the Texture of the original.
+    */
     RenderTarget(const RenderTarget& rhs);
-    /// Create a render target for a texture that already exists. For adding to an existing texture.
-    explicit RenderTarget(const Texture* texture, const Color4& clear_color = Colors::Black);
-    /// Create a Render Target with a brand new texture. Want to render JGL elements onto a texture and display it as a sprite?
-    explicit RenderTarget(const Vector2& size, const Color4& clear_color = Colors::Black, bool use_depth = false, MSAA_SAMPLE_RATE sample_rate = MSAA_SAMPLE_RATE::MSAA_NONE);
+
+    /// Create a Render Target for a texture that already exists.
+    /// @param texture The Texture that using this Render Target would draw on.
+    /// @param clear_color The color to be used if you want to clear the Render Target.
+    /// @note For Render Targets created this way, The destructor will not delete the texture.
+    explicit RenderTarget(const Texture* texture, const Color4& clear_color = Colors::Transparent);
+
+    /// Create a Render Target with a new texture.
+    /// @param size The width & height the Render Target should have.
+    /// @param clear_color The color to be used if you want to clear the Render Target.
+    /// @param use_depth Whether or not this Render Target will have depth information.
+    /// @param sample_rate The MSAA sample rate this Render Target will use.
+    explicit RenderTarget(const Vector2i& size, const Color4& clear_color = Colors::Transparent, bool use_depth = false, MSAA_SAMPLE_RATE sample_rate = MSAA_SAMPLE_RATE::MSAA_NONE);
+
+    /// Deletes this Render Target.
+    /** @note If this Render Target was made with a Texture that already existed
+     * the Texture will not be deleted. */
     ~RenderTarget();
+
 };

include/JGL/types/ShadowMap.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <JGL/types/RenderTarget.h>
+#include <JGL/types/Light.h>
+
+namespace JGL {
+    class ShadowMap;
+}
+
+/// You render your scene with all the static objects from the perspective of each static light to a ShadowMap.
+/// Then, for shadow casters which move. Or lights that move. You only redraw that object from the perspective of each light.
+/// Some of the approaches I saw for this were disgusting - Redacted.
+
+class JGL::ShadowMap {
+private:
+    RenderTarget shadow_map;
+private:
+    void Create(const LightBase* Light);
+};

include/JGL/types/Skeleton.h

@@ -0,0 +1,124 @@
+#pragma once
+#include <vector>
+#include <array>
+#include <J3ML/LinearAlgebra/Vector3.hpp>
+#include <J3ML/LinearAlgebra/Matrix4x4.hpp>
+#include <unordered_map>
+
+namespace JGL {
+    class Bone;
+    class SkeletalVertexAttribute;
+    class Skeleton;
+    class KeyFrame;
+    class Animation;
+    class AnimationState;
+}
+
+class JGL::SkeletalVertexAttribute {
+private:
+    std::array<int, 4> bone_ids = { 0, 0, 0, 0 };
+    std::array<float, 4> bone_weights = { 0, 0, 0, 0 };
+public:
+    [[nodiscard]] std::array<int, 4> GetAffectingBoneIDs() const;
+    [[nodiscard]] std::array<float, 4> GetAffectingBoneWeights() const;
+public:
+    SkeletalVertexAttribute() = default;
+    /// These cannpt be longer than 4.
+    SkeletalVertexAttribute(const std::vector<int>& ids, const std::vector<float>& weights);
+};
+
+class JGL::Bone {
+private:
+    int id = 0;
+    // Not every gltf2 model includes names, but I'll still include it.
+    std::string name;
+    Matrix4x4 inverse_bind_matrix = Matrix4x4::Identity;
+    Matrix4x4 offset_matrix = Matrix4x4::Identity;
+    Matrix4x4 final_transform = Matrix4x4::Identity;
+    int parent_id = -1;
+    std::vector<int> children{};
+public:
+    [[nodiscard]] int GetID() const;
+    [[nodiscard]] std::string GetName() const;
+    [[nodiscard]] Matrix4x4 GetInverseBindMatrix() const;
+    [[nodiscard]] Matrix4x4 GetOffsetMatrix() const;
+    [[nodiscard]] Matrix4x4 GetFinalTransform() const;
+    [[nodiscard]] bool IsRootBone() const;
+public:
+    [[nodiscard]] int GetParentID() const;
+    [[nodiscard]] std::vector<int> GetChildren() const;
+public:
+    void SetParent(int parent_id);
+    void AppendChild(int new_child);
+    void SetID(int numeric_id);
+    void SetName(const std::string& string_id);
+    void SetInverseBindMatrix(const Matrix4x4& inverse_bind);
+    void SetOffsetMatrix(const Matrix4x4& offset);
+    void SetFinalTransformMatrix(const Matrix4x4& final);
+public:
+    ~Bone() = default;
+    Bone() = default;
+    explicit Bone(int numeric_id, const std::string& string_id = "", int parent_id = -1, const std::vector<int>& children_ids = {},
+         const Matrix4x4& inverse_bind = Matrix4x4::Identity, const Matrix4x4& offset = Matrix4x4::Identity, const Matrix4x4& final = Matrix4x4::Identity);
+};
+
+class JGL::Skeleton {
+private:
+    Bone root;
+    std::vector<Bone> bones;
+public:
+    [[nodiscard]] Bone* GetRootBone();
+    [[nodiscard]] Bone* FindBone(int id);
+    [[nodiscard]] Bone* FindBone(const std::string& string_id);
+public:
+    void AppendBone(const Bone& bone);
+public:
+    explicit Skeleton(const Bone& root_bone, const std::vector<Bone>& children = {});
+    ~Skeleton() = default;
+    Skeleton() = default;
+};
+
+class JGL::KeyFrame {
+private:
+    float time_stamp = 0;
+    Skeleton pose;
+public:
+    [[nodiscard]] float GetTimeStamp() const;
+    [[nodiscard]] Skeleton GetSkeleton() const;
+public:
+    KeyFrame(const Skeleton& pose, float time_stamp);
+};
+
+class JGL::Animation {
+private:
+    int id = -1;
+    // Not all animations have names.
+    std::string name;
+    float length = 0;
+    std::vector<KeyFrame> key_frames;
+    std::vector<SkeletalVertexAttribute> vertex_attributes{};
+public:
+    [[nodiscard]] float GetDuratrion() const;
+    [[nodiscard]] std::vector<KeyFrame> GetKeyFrames() const;
+    [[nodiscard]] int GetID() const;
+    [[nodiscard]] std::string GetName() const;
+    [[nodiscard]] std::vector<SkeletalVertexAttribute> GetSkeletalVertexAttributes() const;
+public:
+    void AppendKeyFrame(const KeyFrame& new_key);
+    void SetDuration(float duration);
+    void SetID(int identifier);
+    void SetName(const std::string& name_id);
+public:
+    ~Animation() = default;
+    Animation(int id, float duration, const std::vector<KeyFrame>& key_frames, const std::vector<SkeletalVertexAttribute>& skeletal_vertex_attributes,
+                       const std::string& name = "");
+};
+
+class JGL::AnimationState {
+private:
+    int animation_id = -1;
+    float animation_time = 0;
+public:
+
+};
+

include/JGL/types/Texture.h

@@ -8,19 +8,19 @@
 namespace JGL {
     using namespace ReImage;
     enum class TextureFilteringMode : u8 {
-        NEAREST = 0, //Fastest for 2D, Sometimes causes graphical issues.
-        BILINEAR = 1, //Fast and pretty, The best for 2D.
+        NEAREST = 0, // Fastest for 2D, Sometimes causes graphical issues.
+        BILINEAR = 1, // Fast and pretty, The best for 2D.
 
-        MIPMAP_NEAREST = 2, //Nearest with mipmaps. The fastest for 3D, Sometimes causes graphical issues. Uses more vram.
-        MIPMAP_BILINEAR = 3, //Bilinear with mipmaps, Fast and pretty. Uses more vram.
-        MIPMAP_TRILINEAR = 4 //The prettiest. Still decent speed. Uses more vram.
+        MIPMAP_NEAREST = 2, // Nearest with mipmaps. The fastest for 3D, Sometimes causes graphical issues. Uses more vram.
+        MIPMAP_BILINEAR = 3, // Bilinear with mipmaps, Fast and pretty. Uses more vram.
+        MIPMAP_TRILINEAR = 4 // The prettiest. Still decent speed. Uses more vram.
     };
 
     enum class TextureWrappingMode : u8 {
         REPEAT = 0,
         MIRRORED_REPEAT = 1,
         CLAMP_TO_EDGE = 2,
-        CLAMP_TO_BORDER = 3 //Effectively the same as clamp_to_edge
+        CLAMP_TO_BORDER = 3 // Effectively the same as clamp_to_edge
     };
 
     /// Represents texture data loaded on the GPU. Contains a handle that can be passed to OpenGL draw calls.
@@ -39,6 +39,8 @@ namespace JGL {
         /// Load a texture from a file,
         explicit Texture(const std::string& file, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE, const TextureFlag& flags = TextureFlag::INVERT_Y);
         Texture(Image* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
+        // Texture atlas.
+        Texture(const Texture* textures, const size_t& texture_count);
         /* Initialize a texture filled with trash data
         this is primarily for the RenderTarget */
         explicit Texture(const Vector2& size);

include/JGL/types/VRamList.h

@@ -16,53 +16,53 @@ private:
     GLuint list_handle = 0;
     long num_elements = 0;
     bool element_array_buffer = false;
+    /// "Spin Locking" fix for multi-threading.
+    bool spin_lock = false;
     void load(const GLfloat* data, const long& size);
     void load(const GLuint* data, const long& size);
-    void SetData(void* data, const long& length);
-    void UpdateData(void* data, const long& offset, const long& length);
+    void SetData(void* data, const long& count);
+    void UpdateData(void* data, const long& offset, const long& count);
     void Erase();
 public:
-    VRamList(const GLuint* data, const long& length);
-    VRamList(const GLfloat* data, const long& length);
-    VRamList(Vector2* data, const long& length);
-    VRamList(Vector3* data, const long& length);
-    VRamList(Vector4* data, const long& length);
+    VRamList(const GLuint* data, const long& count);
+    VRamList(const GLfloat* data, const long& count);
+    VRamList(const Vector2* data, const long& count);
+    VRamList(const Vector3* data, const long& count);
+    VRamList(const Vector4* data, const long& count);
 
     ~VRamList();
     /** Copying around the VBO data to a new VBO like this is slow.
      * Pass to function by const reference or pointer always. */
     VRamList(const VRamList& rhs);
-
+    VRamList() : list_handle(0), num_elements(0), element_array_buffer(false), spin_lock(false) {}
 public:
     [[nodiscard]] GLuint GetHandle() const;
     /// Returns the number of elements in the list.
     [[nodiscard]] long GetLength() const;
     /// Returns the size of the data in bytes.
-    [[nodiscard]] size_t GetSize() const;
+    [[nodiscard]] size_t GetDataSize() const;
     /** Get VBO data back from the GPU. This is *bad* because the CPU is going to wait
     * for the transfer to finish. Has limited use other than testing. */
     [[nodiscard]] std::vector<GLfloat> GetDataF() const;
     [[nodiscard]] std::vector<GLuint> GetDataUI() const;
     [[nodiscard]] bool IsFloatArray() const;
-    /** Replace the data of an existing VBO in it's entirety. Must be same type.
-      * "length" refers to the number of elements in data. Not the number of bytes. */
-    void SetData(const GLfloat* data, const long& length);
-    void SetData(const Vector2* data, const long& length);
-    void SetData(const Vector3* data, const long& length);
-    void SetData(const Vector4* data, const long& length);
+    /** Replace the data of an existing VBO in it's entirety. Must be same type. */
+    void SetData(const GLfloat* data, const long& count);
+    void SetData(const Vector2* data, const long& count);
+    void SetData(const Vector3* data, const long& count);
+    void SetData(const Vector4* data, const long& count);
 
-    void SetData(const GLuint* data, const long& length);
-    void SetData(const Vector2i* data, const long& length);
+    void SetData(const GLuint* data, const long& count);
+    void SetData(const Vector2i* data, const long& count);
 
     /** Update only a portion of the data in a VBO. Must be same type.
-     * "length" refers to the number of elements in data. Not the number of bytes.
      * "offset" refers the number of Typename T into the buffer the data you want to change is.
      * For ex, offset 0 and length of 1 overwrites the first value. Offset 1 the second etc */
-     void UpdateData(const GLfloat* data, const long& offset, const long& length);
-     void UpdateData(const Vector2* data, const long& offset, const long& length);
-     void UpdateData(const Vector3* data, const long& offset, const long& length);
-     void UpdateData(const Vector4* data, const long& offset, const long& length);
+     void UpdateData(const GLfloat* data, const long& offset, const long& count);
+     void UpdateData(const Vector2* data, const long& offset, const long& count);
+     void UpdateData(const Vector3* data, const long& offset, const long& count);
+     void UpdateData(const Vector4* data, const long& offset, const long& count);
 
-     void UpdateData(const GLuint* data, const long& offset, const long& length);
-     void UpdateData(const Vector2i* data, const long& offset, const long& length);
+     void UpdateData(const GLuint* data, const long& offset, const long& count);
+     void UpdateData(const Vector2i* data, const long& offset, const long& count);
 };

include/JGL/types/VertexArray.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <vector>
+#include <JGL/types/VRamList.h>
+#include <JGL/types/Skeleton.h>
+#include <J3ML/LinearAlgebra/Vector3.hpp>
+#include <J3ML/Geometry/Sphere.hpp>
+#include <J3ML/Geometry/AABB.hpp>
+#include <J3ML/Geometry/OBB.hpp>
+
+namespace JGL {
+    /// A point that is part of an object in 3D space.
+    typedef Vector3 Vertex;
+    /// A direction vector which describes which way a triangle is facing.
+    typedef Vector3 Normal;
+    /// 2D positions that describe how a texture is to be wrapped around a 3D object.
+    typedef Vector2 TextureCoordinate;
+    /// Container for storing 3D models in v-ram, system memory, or both.
+    class VertexArray;
+}
+
+class JGL::VertexArray {
+private:
+    Sphere me_sphere;
+    OBB me_obb;
+protected:
+    virtual void CreateMESphere();
+    virtual void CreateMEOBB();
+protected:
+    std::vector<Animation> animations{};
+protected:
+    VRamList* vertices;
+    VRamList* indices;
+    VRamList* normals;
+    VRamList* texture_coordinates;
+protected:
+    /** For models which are not animated, This is intended for a low quality version in
+     * system memory for calculations to be done on the CPU. For models that are, the default pose of the model is here.
+     */
+    std::vector<Vertex> local_vertices{};
+    std::vector<unsigned int> local_indices{};
+    std::vector<TextureCoordinate> local_texture_coordinates{};
+    std::vector<Normal> local_normals{};
+public:
+    /** Don't use these for anything other than drawing because the GPU is gonna spin during read-back */
+    [[nodiscard]] const VRamList* GetVertices() const;
+    [[nodiscard]] const VRamList* GetIndices() const;
+    [[nodiscard]] const VRamList* GetNormals() const;
+    [[nodiscard]] const VRamList* GetTextureCoordinates() const;
+
+    /** These are for cpu side calculations */
+    [[nodiscard]] std::vector<Vertex> GetLocalVertices() const;
+    [[nodiscard]] std::vector<unsigned int> GetLocalIndices() const;
+    [[nodiscard]] std::vector<TextureCoordinate> GetLocalTextureCoordinates() const;
+    [[nodiscard]] std::vector<Normal> GetLocalNormals() const;
+public:
+    /// Returns true if the VertexArray does not have any animations.
+    bool Static();
+public:
+    /// Provides the minimally enclosing bounding sphere of the vertex array given information from the instance.
+    /// @param scale The scale of the instance.
+    /// @param translate_part The center of the sphere would be shifted in 3D space by this. Primarily for world space.
+    [[nodiscard]] Sphere GetMESphere(const Vector3& scale = Vector3::One, const Vector3& translate_part = Vector3::Zero) const;
+    /// Provides the minimally enclosing bounding sphere of the vertex array given information from the instance.
+    /// @param instance_matrix A Matrix4x4 which contains scale, rotation, and translation.
+    /// @param translate Whether or not to translate to world space by the translate part of the Matrix.
+    [[nodiscard]] Sphere GetMESphere(const Matrix4x4& instance_matrix, bool translate = false) const;
+
+    /// Provides the minimally enclosing oriented bounding box of the vertex array given information from the instance.
+    /// @param rotation_matrix A Matrix3x3 representing rotation in 3D space.
+    /// @param scale The scale of the instance.
+    /// @param translate_part The center of the box would be shifted in 3D space by this. Primarily for world space.
+    [[nodiscard]] OBB GetMEOBB(const Matrix3x3& rotation_matrix, const Vector3& scale = Vector3::One, const Vector3& translate_part = Vector3::Zero) const;
+    /// Provides the minimally enclosing oriented bounding box of the vertex array given information from the instance.
+    /// @param instance_matrix A Matrix4x4 which contains scale, rotation, and translation.
+    /// @param translate Whether or not to translate to world space by the translate part of the Matrix.
+    [[nodiscard]] OBB GetMEOBB(const Matrix4x4& instance_matrix, bool translate = false) const;
+
+    /// Provides the minimally enclosing axis-aligned bounding box of the vertex array given information from the instance.
+    /// @param rotation_matrix A Matrix3x3 representing rotation in 3D space.
+    /// @param scale The scale of the instance.
+    /// @param translate_part The center of the box would be shifted in 3D space by this. Primarily for world space.
+    [[nodiscard]] AABB GetMEAABB(const Matrix3x3& rotation_matrix, const Vector3& scale = Vector3::One, const Vector3& translate_part = Vector3::Zero) const;
+    [[nodiscard]] AABB GetMEAABB(const Matrix4x4& instance_matrix, bool translate = false) const;
+public:
+    VertexArray() = default;
+    /// Vertices are required, Everything else is optional.
+    VertexArray(const Vertex* vertex_positions, const long& vp_length, const unsigned int* vertex_indices = nullptr, const long& vi_length = 0,
+                const Normal* vertex_normals = nullptr, const long& vn_length = 0, const TextureCoordinate* texture_coordinates = nullptr, const long& vt_length = 0);
+
+    /// Vertices are required, Everything else is optional.
+    explicit VertexArray(const std::vector<Vertex>& vertex_positions, const std::vector<unsigned int>& vertex_indices = {},
+                         const std::vector<Normal>& vertex_normals = {}, const std::vector<TextureCoordinate>& texture_coordinates = {});
+
+    static VertexArray LoadWavefrontOBJ(const std::string& file_text);
+    static VertexArray LoadAMO(const std::string& file_text);
+};
+
+
+using namespace JGL;
+
+static VertexArray Animate(int animation_id, float animation_time);
+static VertexArray Animate(const AnimationState& anim_state);

main.cpp

@@ -4,14 +4,17 @@
 #include <chrono>
 #include <J3ML/LinearAlgebra/Vector2.hpp>
 #include <JGL/logger/logger.h>
+#include <J3ML/Geometry/AABB.hpp>
+#include <rewindow/logger/logger.h>
+#include <JGL/types/VertexArray.h>
 
 using J3ML::LinearAlgebra::Vector2;
+using namespace JGL::Fonts;
 using namespace JGL;
 
-JGL::Font FreeSans;
-JGL::Font Jupiteroid;
 float fps = 0.0f;
 
+/// A draggable 2D point that highlights when moused over and when clicked.
 class Gizmo
 {
 public:
@@ -21,6 +24,15 @@ public:
     bool hovered = false;
     Vector2 position;
     float range = 6.f;
+    float base_radius = 3.f;
+    float hover_radius = 6.f;
+    float drag_radius = 4.f;
+    Color4 base_color = Colors::Reds::Salmon;
+    Color4 hover_color = Colors::Reds::Firebrick;
+    Color4 drag_color = Colors::White;
+    float lerp_rate = 0.25f;
+    float text_scale = 1.f;
+    int text_size = 12;
 
     void Grab() {
         if (hovered)
@@ -32,27 +44,25 @@ public:
 
     void Update(const Vector2& mouse) {
         if (dragging)
-            position = position.Lerp(mouse, 0.25f);
+            position = position.Lerp(mouse, lerp_rate);
 
         hovered = mouse.Distance(position) < range;
     }
 
     void Draw() {
-
-
         if (dragging)
-            J2D::DrawPoint(Colors::White, position, 4.f);
+            J2D::DrawPoint(drag_color, position, drag_radius);
         else if (hovered)
-            J2D::DrawPoint(Colors::Reds::Crimson, position, 6.f);
+            J2D::DrawPoint(hover_color, position, hover_radius);
         else
-            J2D::DrawPoint(Colors::Reds::Salmon, position, 3.f);
-
-        J2D::DrawString(Colors::White, std::format("{:.1f},{:.1f}", position.x, position.y), position.x, position.y, 1.f, 10, FreeSans);
+            J2D::DrawPoint(base_color, position, base_radius);
 
+        J2D::DrawString(Colors::White, std::format("{:.1f},{:.1f}", position.x, position.y), position.x, position.y, text_scale, text_size);
 
     }
 };
 
+/// A 3D Camera Controller.
 class Camera {
 public:
     Vector3 position = {0,0,0};
@@ -96,61 +106,60 @@ Gizmo b({200, 250});
 Gizmo c({350, 300});
 Gizmo d({450, 250});
 
+JGL::Font FreeSans;
 Texture* image;
-Texture* image2;
+Texture* image_mask;
 RenderTarget* j2d_render_target;
-RenderTarget* image2_render_target;
 
 class JGLDemoWindow : public ReWindow::RWindow
 {
 public:
     void initGL() {
         camera = new Camera;
-        gladLoadGL();
-        if (!JGL::MeetsRequirements())
-            Logger::Warning("The graphics driver does not meet the minimum requirements to run this program.");
 
-        JGL::InitTextEngine();
-        JGL::Update(getSize());
-        J3D::Init(getSize(), 90, 100);
+        if (!JGL::Init(GetSize(), 75, 100))
+            Logger::Fatal("Initialization failed.");
+
+        // Load a custom font.
         FreeSans = JGL::Font("assets/fonts/FreeSans.ttf");
-        Jupiteroid = JGL::Font("assets/fonts/Jupiteroid.ttf");
 
         glClearColor(0.f, 0.f, 0.f, 0.f);
         glEnable(GL_DEPTH_TEST);
         glDepthFunc(GL_LESS);
         glDepthMask(GL_TRUE);
         image = new Texture("assets/sprites/Re3D.png", TextureFilteringMode::BILINEAR);
+        image_mask = new Texture("assets/sprites/alpha_mask_2.png");
         j2d_render_target = new RenderTarget({540, 540}, {0,0,0,0}, false, MSAA_SAMPLE_RATE::MSAA_NONE);
-        image2 = image;
-        image2_render_target = new RenderTarget(image2);
 
-        J2D::Begin(image2_render_target);
-            J2D::DrawString(Colors::Red, "TEST", 0, 16, 1, 16, FreeSans);
-            J2D::FillRect(Colors::Blue, {0,0}, {4,4});
-        J2D::End();
+        //Texture::MultiplyByAlphaMask(*image, *image_mask);
     }
 
-    Vector3 textAngle = {0,0,0};
+    EulerAngleXYZ textAngle = {0,0,0};
     float fov = 90;
+    u8 pulse = 0;
     float sprite_radians = 0;
     bool fov_increasing = true;
+    int blit_pos = 0;
 
     void display() {
-        JGL::Update(getSize());
+        pulse++;
+        float dt = GetDeltaTime();
+
+        JGL::Update(GetSize());
+
         if (fov_increasing)
-            fov += 0.25;
+            fov += 0.025;
         else
-            fov -= 0.50;
+            fov -= 0.050;
 
         if (fov >= 120)
             fov_increasing = false;
         else if (fov <= 75)
             fov_increasing = true;
-        J3D::ChangeFOV(fov);
+        //J3D::ChangeFOV(fov);
 
-        sprite_radians += 0.05;
-        textAngle.y += 2.0f;
+        sprite_radians += 0.005;
+        textAngle.yaw += 1;
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
@@ -158,16 +167,32 @@ public:
         camera->render();
         // All 3D elements of the scene and JGL elements *must* be rendered before the 2D stuff
         /* if rendering to screen space directly. */
-
+        auto test_light = PointLight({2,1,2}, {pulse,pulse,pulse, 255}, {pulse, pulse, pulse, 255}, {0,0,0}, 1, 0.1, 0.01);
+        // If a 3D object has transparency. The things you'd like to see through it must be drawn before.
         J3D::Begin();
             J3D::DrawLine(Colors::Red, {-0.33,-0.125,1}, {-1,-0.125,1});
             J3D::DrawLine(Colors::Red, {-0.33,-0.125,1}, {-0.33,0.25,1});
             J3D::DrawString(Colors::Red, "JGL Sample Text", {-0.33, -0.1, 1.0f}, 1.f, 32, FreeSans, textAngle, true);
+            //J3D::WireframeSphere(Colors::Green, {0,0,0.5f}, 0.25f, 1, 128, 128);
+            Sphere sphere = {{0,0, 0.5f}, 0.2125};
+            J3D::BatchWireframeRevoSphere(Colors::Green, &sphere, 1, 1, 8, 8, true);
+            J3D::RequiredLight(&test_light);
+            J3D::FillAABB(Colors::Whites::AliceBlue, {0,0,0.5f}, {0.05f, 0.05f, 0.05f});
+            J3D::WireframeAABB(Colors::Gray, {0,0,0.5f}, {0.11f, 0.06f, 0.11f});
+
+            AABB boxes[1] = {{Vector3(-0.2125, -0.2125,0.28750), Vector3(0.2125,0.2125,0.7125)}};
+            J3D::BatchWireframeAABB(Colors::Yellow, boxes, 1, 1);
+            //J3D::WireframeOBB(Colors::Red, {0, 0, 1.5f}, {0.40f, 0.10f, 0.10f}, {0,textAngle.y, 0});
+            //J3D::FillSphere({0,255,0,120}, sphere);
+
+            //J3D::DrawCubicBezierCurve(Colors::Blue, {0,0,0.3}, {0,0,0.5}, {0.2,0,0.3}, {0.2, 0.3, 0.1}, 30);
+
+            //J3D::WireframeIcosahedron(Colors::Green, {0,0,0.5f}, 0.125f, 1.f);
         J3D::End();
 
         J2D::Begin(j2d_render_target, true);
             J2D::FillRect(Colors::Blue, {0,52}, {100,100});
-            J2D::DrawSprite(image2, {300, 400}, sprite_radians * 0.10f, {0.5,0.5}, {1, 1}, Colors::White);
+            J2D::DrawSprite(image, {300, 400}, sprite_radians * 0.10f, {0.5,0.5}, {1, 1}, Colors::White);
             J2D::DrawMirrorSprite(image, {400, 300}, Direction::Horizontal | Direction::Vertical, sprite_radians, {0.5,0.5}, {1, 1}, Colors::White);
             J2D::DrawPartialSprite(image, {225, 300}, image->GetDimensions() * 0.25, image->GetDimensions() * 0.75, sprite_radians, {0.5, 0.5}, {1,1}, Colors::White);
             J2D::FillRect(Colors::Pinks::HotPink, {68, 120}, {32, 32});
@@ -185,7 +210,7 @@ public:
             J2D::DrawGradientLine(Colors::Red, Colors::Blue, {105, 375}, {200, 275}, 2);
             auto result = Jupiteroid.MeasureString("Jupiteroid Font", 16);
 
-            J2D::FillRect(Colors::Gray, {0, 0}, result);
+            //J2D::FillRect(Colors::Gray, {0, 0}, result);
             J2D::DrawString(Colors::Green, "Jupteroid Font", 0.f, 0, 1.f, 16, Jupiteroid);
             J2D::DrawString(Colors::White, "Position: " + std::to_string(camera->position.x) + " " + std::to_string(camera->position.y) + " " + std::to_string(camera->position.z), 0, 16, 1,16, Jupiteroid);
             J2D::DrawString(Colors::White, "ViewAngle: " + std::to_string(camera->angle.x) + " " + std::to_string(camera->angle.y) + " " + std::to_string(camera->angle.z), 0, 33, 1,16, Jupiteroid);
@@ -205,17 +230,48 @@ public:
             c.Draw();
             d.Draw();
         J2D::End();
+        RenderTarget::Blit(Colors::Red, {0, 0}, j2d_render_target);
 
         //Draw the Render Target that we just drew all that stuff onto.
 
         J2D::Begin();
-            J2D::DrawSprite(j2d_render_target, {0, 0}, 0, {0.5, 0.5}, {1,1}, Colors::White);
-            J2D::DrawSprite(image2_render_target, {300, 500}, 0, {0.5, 0.5}, {1,1}, Colors::White);
+            J2D::DrawPartialRenderTarget(j2d_render_target, {0, 0}, {0,0}, {512, 512});
+            J2D::DrawSprite(image, image_mask, {0, 0}, 0.25, {0.5, 0.5}, {1,1});
+            //J2D::DrawSprite(, {0, 0}, 0, {0.5, 0.5}, {1,1}, Colors::White);
+
+            //J2D::DrawSprite( {0, 0}, 0, {0.5, 0.5}, {1,1}, Colors::White);
         J2D::End();
 
     }
 
     void OnRefresh(float elapsed) override {
+
+        fps = GetRefreshRate();
+
+        if (IsKeyDown(Keys::RightArrow))
+            camera->angle.y += 45.f * elapsed;
+        if (IsKeyDown(Keys::LeftArrow))
+            camera->angle.y -= 45.f * elapsed;
+        if (IsKeyDown(Keys::UpArrow))
+            camera->angle.x -= 45.f * elapsed;
+        if (IsKeyDown(Keys::DownArrow))
+            camera->angle.x += 45.f * elapsed;
+        if (IsKeyDown(Keys::Space))
+            camera->position.y += 1.f * elapsed;
+        if (IsKeyDown(Keys::LeftShift))
+            camera->position.y -= 1.f * elapsed;
+
+         //This is wrong of course. Just for testing purposes.
+        if (IsKeyDown(Keys::W))
+            camera->position.z += 1.f * elapsed;
+        if (IsKeyDown(Keys::S))
+            camera->position.z -= 1.f * elapsed;
+        if (IsKeyDown(Keys::A))
+            camera->position.x += 1.f * elapsed;
+        if (IsKeyDown(Keys::D))
+            camera->position.x -= 1.f * elapsed;
+
+
         auto mouse = GetMouseCoordinates();
         a.Update(mouse);
         b.Update(mouse);
@@ -225,11 +281,11 @@ public:
         int glError = glGetError();
         if (glError != GL_NO_ERROR)
             std::cout << glError << std::endl;
-        glSwapBuffers();
+        GLSwapBuffers();
     }
 
 
-    void OnMouseButtonDown(const ReWindow::WindowEvents::MouseButtonDownEvent & ev) override
+    void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent & ev) override
     {
         RWindow::OnMouseButtonDown(ev);
         a.Grab();
@@ -238,7 +294,7 @@ public:
         d.Grab();
     }
 
-    void OnMouseButtonUp(const ReWindow::WindowEvents::MouseButtonUpEvent & ev) override
+    void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent & ev) override
     {
         RWindow::OnMouseButtonUp(ev);
         a.Release();
@@ -249,24 +305,37 @@ public:
 
     bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {return true;}
     JGLDemoWindow() : ReWindow::RWindow() {}
-    JGLDemoWindow(const std::string& title, int width, int height) : ReWindow::RWindow(title, width, height){}
+    JGLDemoWindow(const std::string& title, int width, int height) : ReWindow::RWindow(title, width, height) {}
 };
 
 int main(int argc, char** argv) {
+
     auto* window = new JGLDemoWindow("JGL Demo Window", 1280, 720);
-    window->setRenderer(RenderingAPI::OPENGL);
+    window->SetRenderer(RenderingAPI::OPENGL);
     window->Open();
     window->initGL();
-    window->setResizable(true);
-    window->setVsyncEnabled(false);
+    window->SetResizable(true);
+    window->SetVsyncEnabled(true);
 
-    while (window->isAlive()) {
-        std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
-        window->pollEvents();
-        window->refresh();
-        std::chrono::high_resolution_clock::time_point stop = std::chrono::high_resolution_clock::now();
-        std::chrono::duration<float> frame_time = stop - start;
-        fps = 1.0f / frame_time.count();
-    }
+    std::ifstream file("assets/models/cube.amo");
+    if (!file.is_open())
+        return -1;
+
+    /*
+    std::stringstream buffer;
+    buffer << file.rdbuf();
+    std::string file_text = buffer.str();
+    file.close();
+    std::cout << file_text << std::endl;
+
+    auto result = VertexArray::LoadAMO(file_text);
+     */
+    
+    //ReWindow::Logger::Error.EnableConsole(false);
+    //ReWindow::Logger::Warning.EnableConsole(false);
+    //ReWindow::Logger::Debug.EnableConsole(false);
+
+    while (window->IsAlive())
+        window->ManagedRefresh();
     return 0;
 }

src/internals/include/AMO.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <string>
+
+namespace JGL {
+    class VertexArray;
+    /*
+    VertexArray LoadAMO(const std::string& file_text);
+     */
+}

src/internals/include/WavefrontOBJ.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <string>
+
+namespace JGL {
+    class VertexArray;
+    // Currently requires "Triangulate Mesh" ticked in Blender.
+    // TODO use the number of slashes in the first "face-line" to detect quads.
+    VertexArray LoadWavefrontOBJ(const std::string& file_text);
+}

src/internals/include/internals.h

@@ -0,0 +1,59 @@
+/// Things used in J2D and J3D that should not be exposed to the user of the library.
+#pragma once
+
+#include "glad/glad.h"
+#include <array>
+#include <vector>
+#include "J3ML/LinearAlgebra/Vector2.hpp"
+#include "JGL/types/RenderTarget.h"
+#include "JGL/types/Light.h"
+#include "JGL/logger/logger.h"
+
+namespace JGL {
+    inline constexpr std::array<const LightBase*, 8> empty_light_array = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+    inline bool inJ2D = false;
+    inline bool inJ3D = false;
+    std::vector<Vector3> TriangleMeshVertexNormals(const Vector3* vertices, const size_t& vertex_count, const unsigned int* indices, const size_t& index_count);
+}
+
+namespace JGL::OpenGLState {
+    inline JGL::RenderTarget* render_target = nullptr;
+    inline Vector2 window_size;
+
+    inline GLfloat oldColor[4] = {0, 0, 0, 1};
+    inline GLfloat baseColor[4] = {1, 1, 1, 1};
+
+    inline GLuint current_fbo = 0;
+    inline GLint viewport[4] = {0, 0, 0, 0};
+
+    inline bool wasTexture2DEnabled = false;
+    inline bool wasTextureCoordArrayEnabled = false;
+    inline bool wasNormalArrayEnabled = false;
+
+    inline bool wasDepthTestEnabled = false;
+    inline bool wasVertexArraysEnabled = false;
+    inline bool wasCullFaceEnabled = false;
+    inline bool wasBlendEnabled = false;
+    inline bool wasColorArrayEnabled = false;
+    inline GLint activeTextureUnit = 0;
+}
+
+namespace JGL::J2D {
+    inline std::array<const LightBase*, 8> required_lights;
+    inline std::vector<const LightBase*> light_array;
+}
+
+namespace JGL::J3D {
+    // List of lights required for each objects in the scene. up-to 8. For example, the sun. Or a flash-light.
+    inline std::array<const LightBase*, 8> required_lights;
+    // List of all lights in the scene.
+    inline std::vector<const LightBase*> optional_lights;
+    inline float far_plane = 0;
+    inline float fov = 0;
+    // Enables lighting and selects the correct lights to use.
+    void SelectLights(const Vector3& position);
+    // Resets the GL lights to default and disables them. Then, disables lighting.
+    void ResetLights();
+    [[nodiscard]] bool UsingLighting();
+
+}

src/internals/src/ShapeCache.cpp

@@ -0,0 +1,54 @@
+#include <JGL/JGL.h>
+
+void JGL::ShapeCache::Init() {
+    std::array<Vector3, 8> vertices = {
+            Vector3(1.0f,  1.0f, -1.0f),
+            Vector3(1.0f, -1.0f, -1.0f),
+            Vector3(1.0f,  1.0f,  1.0f),
+            Vector3(1.0f, -1.0f,  1.0f),
+            Vector3(-1.0f,  1.0f, -1.0f),
+            Vector3(-1.0f, -1.0f, -1.0f),
+            Vector3(-1.0f,  1.0f,  1.0f),
+            Vector3(-1.0f, -1.0f,  1.0f)
+    };
+    std::array<unsigned int, 36> indices = {
+            4, 2, 0,
+            2, 7, 3,
+            6, 5, 7,
+            1, 7, 5,
+            0, 3, 1,
+            4, 1, 5,
+            4, 6, 2,
+            2, 6, 7,
+            6, 4, 5,
+            1, 3, 7,
+            0, 2, 3,
+            4, 0, 1
+    };
+
+    std::array<Vector3, 8> vertex_normals = {
+            Vector3( 0.816f,  0.408f, -0.408f),
+            Vector3( 0.333f, -0.667f, -0.667f),
+            Vector3( 0.333f,  0.667f,  0.667f),
+            Vector3( 0.816f, -0.408f,  0.408f),
+            Vector3(-0.333f,  0.667f, -0.667f),
+            Vector3(-0.816f, -0.408f, -0.408f),
+            Vector3(-0.816f,  0.408f,  0.408f),
+            Vector3(-0.333f, -0.667f,  0.667f)
+    };
+
+    if (!cube_vertex_data)
+        cube_vertex_data = new VRamList(vertices.data(), vertices.size());
+
+    if (!cube_index_data)
+        cube_index_data = new VRamList(indices.data(), indices.size());
+
+    if (!cube_normal_data) {
+        cube_normal_data = new VRamList(vertex_normals.data(), vertex_normals.size());
+    }
+
+    if (!j2d_default_normal_data) {
+        std::array<GLfloat, 3> normal {0, 0, 1};
+        j2d_default_normal_data = new VRamList(normal.data(), normal.size());
+    }
+}

src/internals/src/WavefrontOBJ.cpp

@@ -0,0 +1,336 @@
+#include "../include/WavefrontOBJ.h"
+#include "../include/AMO.h"
+#include <JGL/types/VertexArray.h>
+#include <JGL/logger/logger.h>
+
+std::pair<float, unsigned long> ParseNumber(const std::string& file_text, const unsigned long& offset) {
+    std::string number;
+    unsigned long new_offset = offset;
+    bool decimal_used = false;
+
+    if (offset >= file_text.size())
+        return {0.0f, offset};
+
+    for (; new_offset < file_text.size(); new_offset++) {
+        if (file_text[new_offset] == '-') {
+            if (number.empty()) {
+                number.push_back(file_text[new_offset]);
+                continue;
+            }
+            Logger::Error("Error while parsing number, Index: " + std::to_string(new_offset) + " Extra negative sign.");
+            return {0.0f, offset};
+        }
+
+        else if (file_text[new_offset] == '.') {
+            if (!decimal_used) {
+                number.push_back(file_text[new_offset]);
+                decimal_used = true;
+                continue;
+            }
+            Logger::Error("Error parsing number at: " + std::to_string(new_offset) + " Extra decimal point.");
+            return {0.0f, offset};
+        }
+
+        else if (isdigit(file_text[new_offset]))
+            number.push_back(file_text[new_offset]);
+        else
+            break;
+    }
+    return {std::stof(number), new_offset};
+}
+
+std::pair<Vector2, unsigned long> ParseVector2(const std::string& file_text, const unsigned long& offset) {
+    auto x_result = ParseNumber(file_text, offset);
+    auto y_result = ParseNumber(file_text, x_result.second + 1);
+
+    // If the new offset is the same as the offset we passed in then we know it didn't work.
+    if (x_result.second == offset || y_result.second == x_result.second)
+        return {Vector2(0, 0), offset};
+
+    return {Vector2(x_result.first, y_result.first), y_result.second + 1};
+}
+
+std::pair<Vector3, unsigned long> ParseVector3(const std::string& file_text, const unsigned long& offset) {
+    auto x_result = ParseNumber(file_text, offset);
+    auto y_result = ParseNumber(file_text, x_result.second + 1);
+    auto z_result = ParseNumber(file_text, y_result.second + 1);
+
+    // If the new offset is the same as the offset we passed in then we know it didn't work.
+    if (x_result.second == offset || y_result.second == x_result.second || z_result.second == y_result.second)
+        return {Vector3(0,0,0), offset};
+
+    return {Vector3(x_result.first, y_result.first, z_result.first), z_result.second + 1};
+}
+
+std::pair<Vector4, unsigned long> ParseVector4(const std::string& file_text, const unsigned long& offset) {
+    auto x_result = ParseNumber(file_text, offset);
+    auto y_result = ParseNumber(file_text, x_result.second + 1);
+    auto z_result = ParseNumber(file_text, y_result.second + 1);
+    auto w_result = ParseNumber(file_text, z_result.second + 1);
+
+    if (x_result.second == offset || y_result.second == x_result.second || z_result.second == y_result.second || w_result.second == z_result.second)
+        return {Vector4(0, 0, 0, 0), offset};
+
+    return {Vector4(x_result.first, y_result.first, z_result.first, w_result.first), w_result.second + 1};
+}
+
+std::pair<std::array<Vector3, 3>, unsigned long> ParseWavefrontFaceData(const std::string& file_text, const unsigned long& offset) {
+    unsigned long new_offset = offset;
+    std::array<Vector3, 3> face_data;
+
+    for (unsigned int i = 0; i < 3; i++) {
+        Vector3 vertex = {-1, -1, -1};
+
+        // Vertex
+        if (std::isdigit(file_text[new_offset])) {
+            auto v_result = ParseNumber(file_text, new_offset);
+            vertex.x = v_result.first;
+            new_offset = v_result.second;
+        }
+
+        // UV
+        if (new_offset < file_text.size() && file_text[new_offset] == '/') {
+            new_offset++;
+
+            if (new_offset < file_text.size() && (std::isdigit(file_text[new_offset]))) {
+                auto vt_result = ParseNumber(file_text, new_offset);
+                vertex.y = vt_result.first;
+                new_offset = vt_result.second;
+            }
+        }
+
+        // Normal
+        if (new_offset < file_text.size() && file_text[new_offset] == '/') {
+            new_offset++;
+
+            if (new_offset < file_text.size() && (std::isdigit(file_text[new_offset]))) {
+                auto vn_result = ParseNumber(file_text, new_offset);
+                vertex.z = vn_result.first;
+                new_offset = vn_result.second;
+            }
+        }
+
+        face_data[i] = vertex;
+        new_offset++;
+    }
+    return {face_data, new_offset};
+}
+
+VertexArray JGL::LoadWavefrontOBJ(const std::string &file_text) {
+    std::vector<std::array<Vector3, 3>> faceline_data;
+
+    std::vector<TextureCoordinate> temp_uvs;
+    std::vector<Normal> temp_normals;
+    std::vector<Vertex> temp_vertices;
+
+    unsigned long offset = 0;
+    while (offset < file_text.size()) {
+        char c = file_text[offset];
+
+        // TODO the entire line a comment is on should be skipped.
+        // Skip forward to the character after the next newline.
+        if (c == '#' || c == '\n' || c == '\r') {
+            offset++;
+            continue;
+        }
+
+        // Vertices
+        if (c == 'v' && offset + 1 < file_text.size() && file_text[offset + 1] == ' ') {
+            offset += 2;
+
+            auto vertex_result = ParseVector3(file_text, offset);
+            if (vertex_result.second != offset) {
+                temp_vertices.push_back(vertex_result.first);
+                offset = vertex_result.second;
+            }
+        }
+
+            // Normals.
+        else if (c == 'v' && offset + 2 < file_text.size() && file_text[offset + 1] == 'n' &&
+                 file_text[offset + 2] == ' ') {
+            offset += 3;
+
+            auto normal_result = ParseVector3(file_text, offset);
+            if (normal_result.second != offset) {
+                temp_normals.push_back(normal_result.first);
+                offset = normal_result.second;
+            }
+        }
+
+            // Texture Coordinates
+        else if (c == 'v' && offset + 2 < file_text.size() && file_text[offset + 1] == 't' &&
+                 file_text[offset + 2] == ' ') {
+            offset += 3;
+
+            auto uv_result = ParseVector2(file_text, offset);
+            if (uv_result.second != offset) {
+                temp_uvs.push_back(uv_result.first);
+                offset = uv_result.second;
+            }
+        }
+
+            // Face lines.
+        else if (c == 'f' && offset + 1 < file_text.size() && file_text[offset + 1] == ' ') {
+            offset += 2;
+
+            auto faceline_result = ParseWavefrontFaceData(file_text, offset);
+            if (faceline_result.second != offset) {
+                faceline_data.push_back(faceline_result.first);
+                offset = faceline_result.second;
+            }
+        } else
+            offset++;
+    }
+
+// Pick everything out of the face lines and set up how OpenGL expects.
+    std::vector<Vertex> final_vertices;
+    std::vector<TextureCoordinate> final_uvs;
+    std::vector<Normal> final_normals;
+    std::vector<unsigned int> final_indices;
+    for (const auto &face: faceline_data) {
+        for (const auto &vp: face) {
+            Vertex vertex;
+            TextureCoordinate uv;
+            Normal normal;
+
+            if (vp.x != -1)
+                vertex = temp_vertices[vp.x - 1];
+            if (vp.y != -1)
+                uv = temp_uvs[vp.y - 1];
+            if (vp.z != -1)
+                normal = temp_normals[vp.z - 1];
+
+            final_vertices.push_back(vertex);
+            final_uvs.push_back(uv);
+            final_normals.push_back(normal);
+            final_indices.push_back((unsigned int) final_vertices.size() - 1);
+        }
+    }
+
+    return VertexArray(
+            final_vertices.data(), final_vertices.size(),
+            final_indices.data(), final_indices.size(),
+            final_normals.data(), final_normals.size(),
+            final_uvs.data(), final_uvs.size());
+}
+
+/*
+VertexArray JGL::LoadAMO(const std::string& file_text) {
+    std::vector<Vector3> temp_vertices;
+    std::vector<Vector3> temp_normals;
+    std::vector<Vector2> temp_uvs;
+    std::vector<std::array<Vector3, 3>> faceline_data;
+    std::string name;
+
+    unsigned long offset = 0;
+    while (offset < file_text.size()) {
+        char c = file_text[offset];
+
+        // If we've dropped on a newline character somehow then just skip passed it.
+        if (c == '\n' || c == '\r') {
+            offset++; continue;
+        }
+
+        // File name.
+        else if (offset + 2 < file_text.size() && c == 'a' && file_text[offset + 1] == 'o' && file_text[offset + 2] == ' ') {
+            offset += 3;
+            while (offset < file_text.size()) {
+                if (file_text[offset] != '\n' && file_text[offset] != '\r')
+                    name.push_back(file_text[offset]), offset++;
+                else
+                    break;
+            }
+        }
+
+        // Vertices
+        else if (offset + 1 < file_text.size() && c == 'v' && file_text[offset + 1] == ' ') {
+            offset += 2; auto parsed_number = ParseNumber(file_text, offset);
+
+            if (parsed_number.second == offset)
+                Logger::Fatal("We couldn't interpret the Vertex count at: " + std::to_string(offset));
+
+            unsigned long vertex_count = parsed_number.first;
+            offset = parsed_number.second;
+
+            for (unsigned long i = 0; i < vertex_count; i++) {
+                // Skip by newlines.
+                while (file_text[offset] == '\n' || file_text[offset] == '\r')
+                    offset++;
+
+                auto parsed_vector3 = ParseVector3(file_text, offset);
+                if (parsed_vector3.second == offset)
+                    Logger::Fatal("We couldn't interpret the Vertex at: " + std::to_string(offset));
+
+                temp_vertices.push_back(parsed_vector3.first);
+                offset = parsed_vector3.second;
+            }
+        }
+
+        // UVs
+        else if (offset + 2 < file_text.size() && c == 'v' && file_text[offset + 1] == 't' && file_text[offset + 2] == ' ') {
+            offset += 3; auto parsed_number = ParseNumber(file_text, offset);
+
+            if (parsed_number.second == offset)
+                Logger::Fatal("We couldn't interpret the UV count at: " + std::to_string(offset));
+
+            unsigned long uv_count = parsed_number.first;
+            offset = parsed_number.second;
+
+            for (unsigned long i = 0; i < uv_count; i++) {
+                // Skip by newlines.
+                while (file_text[offset] == '\n' || file_text[offset] == '\r')
+                    offset++;
+
+                auto parsed_vector2 = ParseVector2(file_text, offset);
+                if (parsed_vector2.second == offset)
+                    Logger::Fatal("We couldn't interpret the UV at: " + std::to_string(offset));
+
+                temp_uvs.push_back(parsed_vector2.first);
+                offset = parsed_vector2.second;
+            }
+        }
+
+        // Normals
+        else if (offset + 2 < file_text.size() && c == 'v' && file_text[offset + 1] == 'n' && file_text[offset + 2] == ' ') {
+            offset += 3; auto parsed_number = ParseNumber(file_text, offset);
+
+            if (parsed_number.second == offset)
+                Logger::Fatal("We couldn't interpret the Normal count at: " + std::to_string(offset));
+
+            unsigned long uv_count = parsed_number.first;
+            offset = parsed_number.second;
+
+            for (unsigned long i = 0; i < uv_count; i++) {
+                // Skip by newlines.
+                while (file_text[offset] == '\n' || file_text[offset] == '\r')
+                    offset++;
+
+                auto parsed_vector3 = ParseVector3(file_text, offset);
+                if (parsed_vector3.second == offset)
+                    Logger::Fatal("We couldn't interpret the Normal at: " + std::to_string(offset));
+
+                temp_normals.push_back(parsed_vector3.first);
+                offset = parsed_vector3.second;
+            }
+        }
+
+        // Face Lines
+        else if (offset + 1 < file_text.size() && c == 'f'  && file_text[offset + 1] == ' ') {
+            offset += 2; auto parsed_number = ParseNumber(file_text, offset);
+
+            if (parsed_number.second == offset)
+                Logger::Fatal("We couldn't interpret the Face Line count at: " + std::to_string(offset));
+
+            unsigned long faceline_count = parsed_number.first;
+            for (unsigned long i = 0; i < faceline_count; i++) {
+                // Skip by newlines.
+                while (file_text[offset] == '\n' || file_text[offset] == '\r')
+                    offset++;
+
+                
+            }
+        }
+
+    }
+}
+ */

src/internals/src/internals.cpp

@@ -0,0 +1,119 @@
+#include "../include/internals.h"
+#include "J3ML/LinearAlgebra/Vector4.hpp"
+#include "JGL/types/Light.h"
+
+// TODO handle the case that a required light is in the list of optional lights.
+void JGL::J3D::SelectLights(const Vector3& position) {
+    std::array<const LightBase*, 8> result = required_lights;
+
+    unsigned int required_light_count = 0;
+    for (const auto& i : result)
+        if (i) required_light_count++;
+
+    // If there is optional lights.
+    if (!optional_lights.empty()) {
+        // The number of lights we need to solve for
+        unsigned int remaining_lights = 8 - required_light_count;
+
+        std::vector<std::pair<float, const LightBase*>> light_influence;
+        for (const auto* light: optional_lights)
+            light_influence.emplace_back(light->GetAttenuationAtPosition(position), light);
+
+        // Sort by biggest influence.
+        std::sort(light_influence.begin(), light_influence.end(),
+                  [](const auto &a, const auto &b) { return a.first > b.first; });
+
+        // Add in optional lights.
+        for (unsigned int i = 0; i < remaining_lights && i < light_influence.size(); i++)
+            result[required_light_count++] = light_influence[i].second;
+    }
+
+    glEnable(GL_LIGHTING);
+    for (unsigned int i = 0; i < result.size(); i++) {
+        // Terminate early if we have less than 8 lights.
+        if (!result[i])
+            break;
+
+        Vector4 ambient = { result[i]->GetAmbient().RN(), result[i]->GetAmbient().GN(), result[i]->GetAmbient().BN(), result[i]->GetAmbient().AN() };
+        Vector4 diffuse = { result[i]->GetDiffuse().RN(), result[i]->GetDiffuse().GN(), result[i]->GetDiffuse().BN(), result[i]->GetDiffuse().AN() };
+        Vector4 specular = { result[i]->GetSpecular().RN(), result[i]->GetSpecular().GN(), result[i]->GetSpecular().BN(), result[i]->GetSpecular().AN() };
+        GLenum current_light = GL_LIGHT0 + i;
+
+        glEnable(GL_LIGHT0 + i);
+        glLightfv(current_light, GL_POSITION, result[i]->GetPosition().ptr());
+
+        // How the light will affect different materials.
+        glLightfv(current_light, GL_AMBIENT, ambient.ptr());
+        glLightfv(current_light, GL_DIFFUSE, diffuse.ptr());
+        glLightfv(current_light, GL_SPECULAR, specular.ptr());
+
+        // How far the light goes.
+        glLightf(current_light, GL_CONSTANT_ATTENUATION, result[i]->GetConstantAttenuation());
+        glLightf(current_light, GL_LINEAR_ATTENUATION, result[i]->GetLinearAttenuation());
+        glLightf(current_light, GL_QUADRATIC_ATTENUATION, result[i]->GetQuadraticAttenuation());
+    }
+}
+
+void JGL::J3D::ResetLights() {
+    Vector4 position = {0, 0, 1, 0};
+    Vector4 ambient = {0, 0, 0, 1};
+    Vector4 diffuse_light0 = {1,1,1,1};
+    Vector4 diffuse = {0,0,0,1};
+    Vector4 specular_light0 = {1,1,1,1};
+    Vector4 specular = {0,0,0,1};
+    Vector3 spot_direction = {0.0, 0.0, -1.0};
+
+    for (unsigned int i = 0; i < 8; i++) {
+        GLenum current_light = GL_LIGHT0 + i;
+
+        glLightfv(current_light, GL_POSITION, position.ptr());
+        glLightfv(current_light, GL_AMBIENT, ambient.ptr());
+        glLightf(current_light, GL_CONSTANT_ATTENUATION, 1);
+        glLightf(current_light, GL_LINEAR_ATTENUATION, 0);
+        glLightf(current_light, GL_QUADRATIC_ATTENUATION, 0);
+        glLightf(current_light, GL_SPOT_CUTOFF, 180.0);
+        glLightfv(current_light, GL_SPOT_DIRECTION, spot_direction.ptr());
+        glLightf(current_light, GL_SPOT_EXPONENT, 0.0);
+        glLightfv(current_light, GL_DIFFUSE, (i == 0 ? diffuse_light0.ptr() : diffuse.ptr()));
+        glLightfv(current_light, GL_SPECULAR, (i == 0 ? specular_light0.ptr() : specular.ptr()));
+        glDisable(current_light);
+    }
+    glDisable(GL_LIGHTING);
+}
+
+bool JGL::J3D::UsingLighting() {
+    if (!optional_lights.empty())
+        return true;
+
+    for (unsigned int i = 0; i < required_lights.size(); i++)
+        if (required_lights[i])
+            return true;
+    return false;
+}
+
+std::vector<Vector3> JGL::TriangleMeshVertexNormals(const Vector3* vertices, const size_t& vertex_count, const unsigned int* indices, const size_t& index_count) {
+    std::vector<Vector3> normals(vertex_count, Vector3(0, 0, 0));
+
+    for (size_t i = 0; i < index_count; i += 3) {
+        GLuint i1 = indices[i];
+        GLuint i2 = indices[i + 1];
+        GLuint i3 = indices[i + 2];
+
+        Vector3 v1 = vertices[i1];
+        Vector3 v2 = vertices[i2];
+        Vector3 v3 = vertices[i3];
+
+        Vector3 edge1 = v2 - v1;
+        Vector3 edge2 = v3 - v1;
+
+        Vector3 faceNormal = Vector3::Cross(edge1, edge2);
+
+        normals[i1] += faceNormal;
+        normals[i2] += faceNormal;
+        normals[i3] += faceNormal;
+    }
+    for (auto& normal : normals)
+        normal = normal.Normalized();
+
+    return normals;
+}

src/renderer/J3D.cpp

@@ -0,0 +1,608 @@
+#include <JGL/JGL.h>
+#include <JGL/logger/logger.h>
+#include <J3ML/Geometry/AABB.hpp>
+#include <J3ML/Geometry/OBB.hpp>
+#include <J3ML/Algorithm/Bezier.hpp>
+#include <JGL/types/Light.h>
+#include "../internals/include/internals.h"
+
+
+std::array<GLfloat, 16> JGL::OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far) {
+    std::array<GLfloat, 16> result{};
+    GLfloat f = 1.0f / std::tan(fovY * 0.5f * Math::Pi / 180.0f);
+    result[0] = f / aspect;
+    result[5] = f;
+    result[10] = (z_far + z_near) / (z_near - z_far);
+    result[11] = -1.0f;
+    result[14] = (2.0f * z_far * z_near) / (z_near - z_far);
+    return result;
+}
+
+void JGL::J3D::ChangeFOV(float fov) {
+    JGL::J3D::fov = fov;
+}
+
+void JGL::J3D::ChangeFarPlane(float far_plane) {
+    JGL::J3D::far_plane = far_plane;
+}
+
+void JGL::J3D::RequiredLight(const JGL::LightBase* light) {
+    bool success = false;
+    for (auto& i : required_lights)
+        if (i == nullptr) {
+            i = light;
+            success = true;
+            break;
+        }
+
+    if (!success)
+        Logger::Error("You cannot specify more than 8 required lights.");
+}
+
+void JGL::J3D::OptionalLights(const JGL::LightBase** lights, const size_t& light_count) {
+    for (size_t i = 0; i < light_count; i++)
+        optional_lights.push_back(lights[i]);
+}
+
+void JGL::J3D::Begin(bool two_pass) {
+    auto aspect = (float) OpenGLState::window_size.x / (float) OpenGLState::window_size.y;
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMultMatrixf(OpenGLPerspectiveProjectionRH(fov, aspect, 0.001, far_plane).data());
+    glMatrixMode(GL_MODELVIEW);
+
+    //Get what the draw color was before we did anything.
+    glGetFloatv(GL_CURRENT_COLOR, OpenGLState::oldColor);
+    glColor4fv(OpenGLState::baseColor);
+
+    if (!glIsEnabled(GL_DEPTH_TEST))
+        OpenGLState::wasDepthTestEnabled = false,
+        glEnable(GL_DEPTH_TEST);
+    else
+        OpenGLState::wasDepthTestEnabled = true;
+
+    OpenGLState::wasVertexArraysEnabled = false;
+    if (!glIsEnabled(GL_VERTEX_ARRAY))
+        OpenGLState::wasVertexArraysEnabled = false,
+        glEnableClientState(GL_VERTEX_ARRAY);
+
+    if (glIsEnabled(GL_NORMAL_ARRAY))
+        OpenGLState::wasNormalArrayEnabled = true,
+        glDisableClientState(GL_NORMAL_ARRAY);
+
+    if (glIsEnabled(GL_TEXTURE_COORD_ARRAY))
+        OpenGLState::wasTextureCoordArrayEnabled = true,
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    if (glIsEnabled(GL_TEXTURE_2D))
+        OpenGLState::wasTexture2DEnabled = true,
+        glDisable(GL_TEXTURE_2D);
+
+    OpenGLState::wasCullFaceEnabled = false;
+    if (glIsEnabled(GL_CULL_FACE))
+        OpenGLState::wasCullFaceEnabled = true,
+        glDisable(GL_CULL_FACE);
+
+    if (!glIsEnabled(GL_BLEND))
+        OpenGLState::wasBlendEnabled = false,
+        glEnable(GL_BLEND),
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    else
+        OpenGLState::wasBlendEnabled = true;
+
+    // Reset the lights.
+    required_lights = empty_light_array;
+    optional_lights = {};
+
+    glDisable(GL_LIGHTING);
+    if (!inJ2D)
+        inJ3D = true;
+    else
+        Logger::Error("Beginning J3D context inside of J2D context?");
+}
+
+void JGL::J3D::End() {
+    if (!OpenGLState::wasDepthTestEnabled)
+        glDisable(GL_DEPTH_TEST);
+
+    if (!OpenGLState::wasVertexArraysEnabled)
+        glDisableClientState(GL_VERTEX_ARRAY);
+
+    if (OpenGLState::wasTexture2DEnabled)
+        glEnable(GL_TEXTURE_2D);
+
+    if (!OpenGLState::wasBlendEnabled)
+        glDisable(GL_BLEND);
+
+    if (OpenGLState::wasCullFaceEnabled)
+        glEnable(GL_CULL_FACE);
+
+    if (OpenGLState::wasNormalArrayEnabled)
+        glEnableClientState(GL_NORMAL_ARRAY);
+
+    if (OpenGLState::wasTextureCoordArrayEnabled)
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    if (glIsEnabled(GL_LIGHTING)) {
+        glDisable(GL_LIGHTING);
+        glDisable(GL_LIGHT0);
+        glDisable(GL_LIGHT1);
+        glDisable(GL_LIGHT2);
+        glDisable(GL_LIGHT3);
+        glDisable(GL_LIGHT4);
+        glDisable(GL_LIGHT5);
+        glDisable(GL_LIGHT6);
+        glDisable(GL_LIGHT7);
+    }
+
+    required_lights = empty_light_array;
+    optional_lights = {};
+
+    //Put the draw color back how it was before.
+    glColor4fv(OpenGLState::oldColor);
+    inJ3D = false;
+}
+
+void JGL::J3D::DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+
+    Vector3 vertices[] = {A, B};
+
+    glLineWidth(thickness);
+    glColor4ubv(color.ptr());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), vertices);
+    glDrawArrays(GL_LINES, 0, 2);
+    glColor4fv(OpenGLState::baseColor);
+}
+
+void JGL::J3D::WireframeSphere(const Color4& color, const Vector3& position, float radius, float thickness, unsigned int sectors, unsigned int stacks) {
+    Sphere sphere = {position, radius};
+    BatchWireframeSphere(color,& sphere, 1, thickness, sectors, stacks);
+}
+
+void JGL::J3D::WireframeSphere(const Color4& color, const Sphere& sphere, float thickness, unsigned int sectors, unsigned int stacks) {
+    BatchWireframeSphere(color,& sphere, 1, thickness, sectors, stacks);
+}
+
+void JGL::J3D::BatchWireframeSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, float thickness, unsigned int sectors, unsigned int stacks) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+
+    // Create one sphere with a radius of 1 about 0, 0.
+    float r = 1;
+    std::vector<Vector3> vertices((sectors + 1) * (stacks + 1));
+
+    int index = 0;
+    for (int i = 0; i <= sectors; i++) {
+        float lat = J3ML::Math::Pi * (-0.5 + (float) i / sectors);
+        float z = J3ML::Math::Sin(lat);
+        float zr = J3ML::Math::Cos(lat);
+
+        for (int j = 0; j <= stacks; j++) {
+            float lng = 2 * J3ML::Math::Pi * (float) (j - 1) / stacks;
+            float x = J3ML::Math::Cos(lng);
+            float y = J3ML::Math::Sin(lng);
+
+            float pos_x = r * x * zr;
+            float pos_y = r * y * zr;
+            float pos_z = r * z;
+
+            vertices[index++] = Vector3(pos_x, pos_y, pos_z);
+        }
+    }
+
+    glLineWidth(thickness);
+    glColor4ubv(color.ptr());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), vertices.data());
+
+    // Render each sphere in the batch at their given position and radius.
+    for(size_t i = 0; i < sphere_count; i++) {
+        glPushMatrix();
+        glTranslatef(spheres[i].Position.x, spheres[i].Position.y, spheres[i].Position.z);
+        glScalef(spheres[i].Radius, spheres[i].Radius, spheres[i].Radius);
+        glDrawArrays(GL_LINE_LOOP, 0, vertices.size());
+        glPopMatrix();
+    }
+    glColor4fv(OpenGLState::baseColor);
+}
+
+void JGL::J3D::WireframeRevoSphere(const Color4& color, const Vector3& position, float radius, float thickness, unsigned int sectors, unsigned int revolutions, bool draw_stacks) {
+    Sphere sphere = {position, radius};
+    BatchWireframeRevoSphere(color,& sphere, 1, thickness, sectors, revolutions, draw_stacks);
+}
+
+void JGL::J3D::WireframeRevoSphere(const Color4& color, const Sphere& sphere, float thickness, unsigned int sectors, unsigned int revolutions, bool draw_stacks) {
+    BatchWireframeRevoSphere(color,& sphere, 1, thickness, sectors, revolutions, draw_stacks);
+}
+
+void JGL::J3D::BatchWireframeRevoSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, float thickness, unsigned int sectors, unsigned int revolutions, bool draw_stacks) {
+    float r = 1;
+    std::vector<Vector3> vertices;
+    vertices.reserve((sectors + 1) * (revolutions + 1));
+
+    std::vector<Vector3> cross_section(sectors + 1);
+    for (int i = 0; i <= sectors; i++) {
+        float lat = J3ML::Math::Pi * (-0.5 + (float)i / sectors);
+        float z = J3ML::Math::Sin(lat);
+        float zr = J3ML::Math::Cos(lat);
+        cross_section[i] = Vector3(0, zr * r, z * r);
+    }
+
+    // Revolve
+    for (int j = 0; j <= revolutions; j++) {
+        float lng = 2 * J3ML::Math::Pi * (float)j / revolutions;
+        float cosLng = J3ML::Math::Cos(lng);
+        float sinLng = J3ML::Math::Sin(lng);
+
+        for (const auto& point : cross_section) {
+            float pos_x = point.y * cosLng;
+            float pos_y = point.y * sinLng;
+            float pos_z = point.z;
+
+            vertices.emplace_back(pos_x, pos_y, pos_z);
+        }
+    }
+
+    glLineWidth(thickness);
+    glColor4ubv(color.ptr());
+
+    VRamList vertex_data(vertices.data(), vertices.size());
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_data.GetHandle());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), nullptr);
+
+    // Render each sphere in the batch at their given position and radius.
+    for(size_t i = 0; i < sphere_count; i++) {
+        glPushMatrix();
+        glTranslatef(spheres[i].Position.x, spheres[i].Position.y, spheres[i].Position.z);
+        glScalef(spheres[i].Radius, spheres[i].Radius, spheres[i].Radius);
+        glDrawArrays(GL_LINE_LOOP, 0, vertex_data.GetLength());
+        if (draw_stacks)
+            glRotatef(90, 0, 1, 0),
+                    glDrawArrays(GL_LINE_LOOP, 0, vertex_data.GetLength());
+        glPopMatrix();
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glColor4fv(OpenGLState::baseColor);
+}
+
+void JGL::J3D::WireframeIcosphere(const Color4& color, const Vector3& position, float radius, float thickness,
+                             unsigned int subdivisions) {
+
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+
+    // NOTE2SELF: Code i'm borrowing this from uses float-packed-arrays rather than discrete Vectors
+    // working on translating that correctly...
+
+    // TODO: Revise this once J3ML::Geometry::Icosahedron is implemented.
+    const float h_angle = J3ML::Math::Pi / 180.f * 72.f;    // 72 degree = 360 / 5;
+    const float v_angle = J3ML::Math::Atan(1.0f / 2.f);     // elevation = 26.565;
+
+    std::vector<Vector3> vertices;                   // array of 12 vertices (x,y,z)
+    unsigned int index = 0;                                      // indices
+    float z, xy;                                        // coords
+    float hAngle1 = -Math::Pi / 2.f - h_angle / 2.f;    // start from -126 at 1st row
+    float hAngle2 = -Math::Pi / 2.f;                    // start from -90 deg at 2nd row
+
+    // the first top vertex at (0,0,r)
+    vertices[0] = position + Vector3{0,0,radius};
+
+
+
+    // compute 10 vertices at 1st and 2nd rows
+    for (int i = 1; i <= 5; ++i)
+    {
+
+        z  = radius * Math::Sin(v_angle);   // elevation
+        xy = radius * Math::Cos(v_angle);   // length on XY plane
+
+        vertices[index++] = position + Vector3{xy * Math::Cos(hAngle1), xy * Math::Sin(hAngle1), z} ;
+        vertices[index++] = position + Vector3{xy * Math::Cos(hAngle2), xy * Math::Sin(hAngle2), -z};
+
+        // next horizontal angles
+        hAngle1 += h_angle;
+        hAngle2 += h_angle;
+    }
+
+    // the last bottom vertex at (0, 0, -r)
+    vertices[11] = position + Vector3{0,0, -radius};
+
+    //glLineWidth(thickness);
+    //glColor4ubv(color.ptr());
+    //glBindBuffer(GL_ARRAY_BUFFER, vertices.size());
+    //glVertexPointer(3, GL_FLOAT, sizeof(Vector3), vertices.data());
+    //glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size());
+    //glColor4fv(baseColor);
+
+    std::vector<Vector3> tmpVertices;
+    std::vector<Vector3> tmpIndices;
+    std::vector<Vector2> newVs((subdivisions+1) * (subdivisions+2) / 2 * 3);
+    const Vector3 v1, v2, v3;
+    Vector3 newV1, newV2, newV3;
+
+    int i, j, k;
+    index = 0;              // unsigned int
+    float a;                // lerp alpha
+    unsigned int i1, i2;    // indices
+
+    // copy prev arrays
+    tmpVertices = vertices;
+    //tmpIndices = indices;
+
+    // iterate each triangle of icosahedron
+    for (i = 0; i < tmpIndices.size(); i++)
+    {
+        //v1 = tmpVertices[tmpIndices[i]];
+        //v2 = tmpVertices[tmpIndices[i+1]];
+        //v3 = tmpVertices[tmpIndices[i+2]];
+
+    }
+}
+
+void JGL::J3D::WireframeIcosahedron(const Color4& color, const Vector3& position, float radius, float thickness) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+
+    // TODO: Revise this once J3ML::Geometry::Icosahedron is implemented.
+    const float h_angle = J3ML::Math::Pi / 180.f * 72.f;    // 72 degree = 360 / 5;
+    const float v_angle = J3ML::Math::Atan(1.0f / 2.f);     // elevation = 26.565;
+
+    std::array<Vector3, 12> vertices;                   // array of 12 vertices (x,y,z)
+    int index = 0;                                      // indices
+    float z, xy;                                        // coords
+    float hAngle1 = -Math::Pi / 2.f - h_angle / 2.f;    // start from -126 at 1st row
+    float hAngle2 = -Math::Pi / 2.f;                    // start from -90 deg at 2nd row
+
+    // the first top vertex at (0,0,r)
+    vertices[0] = position + Vector3{0,0,radius};
+
+
+
+    // compute 10 vertices at 1st and 2nd rows
+    for (int i = 1; i <= 5; ++i)
+    {
+
+        z  = radius * Math::Sin(v_angle);   // elevation
+        xy = radius * Math::Cos(v_angle);   // length on XY plane
+
+        vertices[index++] = position + Vector3{xy * Math::Cos(hAngle1), xy * Math::Sin(hAngle1), z} ;
+        vertices[index++] = position + Vector3{xy * Math::Cos(hAngle2), xy * Math::Sin(hAngle2), -z};
+
+        // next horizontal angles
+        hAngle1 += h_angle;
+        hAngle2 += h_angle;
+    }
+
+    // the last bottom vertex at (0, 0, -r)
+    vertices[11] = position + Vector3{0,0, -radius};
+
+    glLineWidth(thickness);
+    glColor4ubv(color.ptr());
+    //glBindBuffer(GL_ARRAY_BUFFER, vertices.size());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), vertices.data());
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size());
+    glColor4fv(OpenGLState::baseColor);
+}
+
+void JGL::J3D::BatchWireframeAABB(const Color4& color, const AABB* boxes, const size_t& box_count, float thickness) {
+    glColor4ubv(color.ptr());
+    glLineWidth(thickness);
+
+    glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::cube_vertex_data->GetHandle());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), nullptr);
+
+    for (size_t i = 0; i < box_count; i++) {
+        Vector3 delta = (boxes[i].maxPoint - boxes[i].minPoint) / 2;
+        Vector3 center = boxes[i].Centroid();
+        glPushMatrix();
+        glTranslatef(center.x, center.y, center.z);
+        glScalef(delta.x, delta.y, delta.z);
+        glDrawArrays(GL_LINES, 0, ShapeCache::cube_vertex_data->GetLength());
+        glPopMatrix();
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glColor4fv(OpenGLState::baseColor);
+}
+
+void JGL::J3D::WireframeAABB(const Color4& color, const Vector3& pos, const Vector3& radii, float thickness) {
+    AABB aabb = {Vector3(pos.x - radii.x, pos.y - radii.y, pos.z - radii.z), Vector3(pos.x + radii.x, pos.y + radii.y, pos.z + radii.z)};
+    BatchWireframeAABB(color, &aabb, 1, thickness);
+}
+
+void JGL::J3D::BatchFillAABB(const Color4& color, const AABB* boxes, const size_t& box_count) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+    glColor4ubv(color.ptr());
+
+    glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::cube_vertex_data->GetHandle());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), nullptr);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ShapeCache::cube_index_data->GetHandle());
+
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+
+    bool using_lights = false;
+    if (UsingLighting()) {
+        using_lights = true;
+        glEnableClientState(GL_NORMAL_ARRAY);
+        glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::cube_normal_data->GetHandle());
+        glNormalPointer(GL_FLOAT, sizeof(float), nullptr);
+    }
+
+    for (size_t i = 0; i < box_count; i++) {
+        Vector3 delta = (boxes[i].maxPoint - boxes[i].minPoint) / 2;
+        Vector3 center = boxes[i].Centroid();
+        glPushMatrix();
+        glTranslatef(center.x, center.y, center.z);
+        glScalef(delta.x, delta.y, delta.z);
+        if (using_lights)
+            SelectLights(center);
+        glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, nullptr);
+        if (using_lights)
+            ResetLights();
+
+        glPopMatrix();
+    }
+    glColor4fv(OpenGLState::oldColor);
+    if (using_lights)
+        glDisable(GL_NORMAL_ARRAY);
+    glDisable(GL_CULL_FACE);
+}
+void JGL::J3D::FillAABB(const Color4& color, const Vector3& pos, const Vector3& radii) {
+    AABB box = {pos - radii, pos + radii};
+    BatchFillAABB(color, &box, 1);
+}
+
+void JGL::J3D::FillAABB(const Color4& color, const AABB& aabb) {
+    BatchFillAABB(color, &aabb, 1);
+}
+
+void JGL::J3D::FillSphere(const Color4& color, const Sphere& sphere, unsigned int sectors, unsigned int stacks) {
+    BatchFillSphere(color, &sphere, 1, sectors, stacks);
+}
+
+void JGL::J3D::BatchFillSphere(const Color4& color, const Sphere* spheres, const size_t& sphere_count, unsigned int sectors, unsigned int stacks) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+
+    float r = 1;
+    std::vector<Vector3> vertices((sectors + 1) * (stacks + 1));
+    std::vector<unsigned int> indices; indices.reserve(sectors * stacks * 6);
+
+    float two_pi = 2 * J3ML::Math::Pi;
+    int index = 0;
+    for (int i = 0; i <= sectors; i++) {
+        float lat = J3ML::Math::Pi * (-0.5 + (float) i / sectors);
+        float z = J3ML::Math::Sin(lat);
+        float zr = J3ML::Math::Cos(lat);
+
+        for (int j = 0; j <= stacks; j++) {
+            float lng =  two_pi * (float) (j - 1) / stacks;
+            float x = J3ML::Math::Cos(lng);
+            float y = J3ML::Math::Sin(lng);
+
+            float pos_x = r * x * zr;
+            float pos_y = r * y * zr;
+            float pos_z = r * z;
+            vertices[index++] = Vector3(pos_x, pos_y, pos_z);
+        }
+    }
+
+    for (int i = 0; i < sectors; i++) {
+        for (int j = 0; j < stacks; j++) {
+            int first_index = i * (stacks + 1) + j;
+            int second_index = first_index + stacks + 1;
+
+            indices.push_back(first_index);
+            indices.push_back(second_index);
+            indices.push_back(first_index + 1);
+
+            indices.push_back(second_index);
+            indices.push_back(second_index + 1);
+            indices.push_back(first_index + 1);
+        }
+    }
+
+    VRamList vertex_data(vertices.data(), vertices.size());
+    VRamList index_data(indices.data(), indices.size());
+
+    glColor4ubv(color.ptr());
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_data.GetHandle());
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_data.GetHandle());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), nullptr);
+
+    for (size_t i = 0; i < sphere_count; i++) {
+        const Vector3 position = spheres[i].Position;
+        glPushMatrix();
+        glTranslatef(position.x, position.y, position.z);
+        glScalef(spheres[i].Radius, spheres[i].Radius, spheres[i].Radius);
+        glDrawElements(GL_TRIANGLES, index_data.GetLength(), GL_UNSIGNED_INT, nullptr);
+        glPopMatrix();
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    glColor4fv(OpenGLState::oldColor);
+}
+
+void JGL::J3D::FillSphere(const Color4& color, const Vector3& position, float radius, unsigned int sectors, unsigned int stacks) {
+    Sphere sphere = {position, radius};
+    BatchFillSphere(color, &sphere, 1, sectors, stacks);
+}
+
+void JGL::J3D::WireframeAABB(const Color4& color, const AABB& aabb, float thickness) {
+    BatchWireframeAABB(color, &aabb, 1, thickness);
+}
+
+// TODO Make it work the same as AABB batching. I couldn't get rotation to do anything more than twitch in place :(.
+void JGL::J3D::BatchWireframeOBB(const Color4& color, const OBB* boxes, const size_t& box_count, float thickness) {
+    std::array<Vector3, 8> corner_points;
+    std::array<GLuint, 24> indices =
+            {
+                    0, 1, 1, 2, 2, 3, 3, 0,
+                    4, 5, 5, 6, 6, 7, 7, 4,
+                    0, 4, 1, 5, 2, 6, 3, 7
+            };
+
+    glLineWidth(thickness);
+    glColor4ubv(color.ptr());
+    glVertexPointer(3, GL_FLOAT, sizeof(Vector3), corner_points.data());
+
+    for (size_t i = 0; i < box_count; i++) {
+        boxes[i].GetCornerPoints(corner_points.data());
+        glPushMatrix();
+        glTranslatef(boxes[i].pos.x, boxes[i].pos.y, boxes[i].pos.z);
+        glDrawElements(GL_LINES, indices.size(), GL_UNSIGNED_INT, indices.data());
+        glPopMatrix();
+    }
+    glColor4fv(OpenGLState::oldColor);
+}
+
+void JGL::J3D::WireframeOBB(const Color4& color, const OBB& obb, float thickness) {
+    BatchWireframeOBB(color, &obb, 1, thickness);
+}
+
+/*
+void JGL::J3D::WireframeOBB(const Color4& color, const Vector3& position, const Vector3& radii, const Matrix3x3& orientation, float thickness) {
+    WireframeOBB(color, OBB(position, radii, orientation. * Vector3::UnitX, rotation * Vector3::UnitY, rotation * Vector3::UnitZ), thickness);
+}
+ */
+
+void JGL::J3D::DrawCubicBezierCurve(const Color4& color, const Vector3& controlA, const Vector3& pointA,
+                               const Vector3& pointB, const Vector3& controlB, int subdivisions, float thickness) {
+    Vector3 last = controlA;
+    const Vector3& first = controlB;
+    for (int i = 0; i < subdivisions; ++i)
+    {
+        float alpha = (float) i / (float) subdivisions;
+        Vector3 step = J3ML::Algorithm::Bezier(alpha, controlA, pointA, pointB, controlB);
+        DrawLine(color, last, step, thickness);
+        last = step;
+    }
+
+    // Have to manually draw the last segment of the curve.
+    DrawLine(color, last, first, thickness);
+}
+
+void JGL::J3D::DrawVertexArray(const Color4& color, const VertexArray& vertex_array, const Vector3& position) {
+    if (!inJ3D)
+        Logger::Error("Drawing J3D element before J3D begin.");
+    glColor4ubv(color.ptr());
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_array.GetVertices()->GetHandle());
+    glVertexPointer(3, GL_FLOAT, 0, nullptr);
+
+    glPushMatrix();
+    glTranslatef(position.x, position.y, position.z);
+        //glScalef(1,1,1);
+        glDrawArrays(GL_TRIANGLES, 0, vertex_array.GetVertices()->GetLength());
+    glPopMatrix();
+
+        //glDrawElements(GL_LINES, vertex_array.GetIndices()->GetLength(), GL_UNSIGNED_INT, nullptr);
+        //std::cout << vertex_array.GetVertices()->GetLength() << std::endl;
+    glColor4fv(OpenGLState::oldColor);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+}

src/renderer/TextRendering.cpp

@@ -1,4 +1,5 @@
 #include <JGL/JGL.h>
+#include "../internals/include/internals.h"
 
 
 #if __linux__
@@ -157,12 +158,12 @@ namespace JGL {
         glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), texcoords.data());
         glDrawArrays(GL_TRIANGLES, 0, (int) vertices.size() * 6);
         glBindTexture(GL_TEXTURE_2D, 0);
-        glColor4f(1, 1, 1, 1);
+        glColor4fv(OpenGLState::oldColor);
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         glDisable(GL_TEXTURE_2D);
     }
 
-    void J3D::DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngle& angle, bool draw_back_face) {
+    void J3D::DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngleXYZ& angle, bool draw_back_face) {
         // TODO: Determine the proper scale factor mathematically
         // This number was arrived at holistically.
         scale = scale * 0.002f;
@@ -243,7 +244,7 @@ namespace JGL {
             glDisable(GL_CULL_FACE);
 
         glBindTexture(GL_TEXTURE_2D, 0);
-        glColor4f(1, 1, 1, 1);
+        glColor4fv(OpenGLState::oldColor);
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         glDisable(GL_TEXTURE_2D);
         glPopMatrix();

src/types/Font.cpp

@@ -3,7 +3,8 @@
 #include <string>
 #include <iostream>
 #include <glad/glad.h>
-#include <jlog/Logger.hpp>
+#include <JGL/logger/logger.h>
+#include <JGL/JGL.h>
 
 #if __linux__
     #include <freetype2/ft2build.h>
@@ -32,7 +33,7 @@ namespace JGL::Detail
         // Keep note of this, might cause problems later?
 
         if (ft != nullptr)
-            throw std::runtime_error("Error::FREETYPE: FT_Library was initialized but is already initialized.");
+            Logger::Fatal("Error::FREETYPE: FT_Library was initialized but is already initialized.");
         
         if (FT_Init_FreeType(&ft))
             return true;
@@ -52,34 +53,44 @@ namespace JGL::Detail
     }
 }
 
-namespace JGL
-{
+namespace JGL {
 
-    bool InitTextEngine()
-    {
+    bool InitTextEngine() {
         return Detail::InitTextEngine();
     }
 
-    Font::Font(const std::filesystem::path& path)
-    {
+    Font::Font(const unsigned char* data, const size_t& size) {
         if (Detail::ft == nullptr)
-            throw new std::runtime_error("Error::FREETYPE: FT_Library was not initialized before attempting to load a font!");
+            throw std::runtime_error("Error::FREETYPE: FT_Library was not initialized before attempting to load a font!");
 
-        Font font;
-        if (FT_New_Face(Detail::ft, path.string().c_str(), 0, &face)) {
-            std::cout << "Error::FREETYPE: Failed to load font!" << std::endl;
-            throw new std::runtime_error("Error::FREETYPE: Failed to load font!");
-            //return -1;
-        }
-        unsigned int newIndex = 0;
+        if (FT_New_Memory_Face(Detail::ft, data, size, 0, &face))
+            throw std::runtime_error("Error::FREETYPE: Failed to load font!");
+
+        unsigned int new_index = 0;
         for (const auto& f : Detail::fonts)
-            if (f.index >= newIndex)
-                newIndex = f.index + 1;
+            if (f.index >= new_index)
+                new_index = f.index + 1;
+        index = new_index;
 
-        index = newIndex;
-        Detail::fonts.push_back(font);
-        std::cout << "Loaded font from " << path << " with index " << newIndex << std::endl;
-        //return newIndex;
+        Detail::fonts.push_back(*this);
+        std::cout << "Loaded font from memory at " << static_cast<const void*>(data) << " with index " << new_index << std::endl;
+    }
+
+    Font::Font(const std::filesystem::path& path) {
+        if (Detail::ft == nullptr)
+            throw std::runtime_error("Error::FREETYPE: FT_Library was not initialized before attempting to load a font!");
+
+        if (FT_New_Face(Detail::ft, path.string().c_str(), 0, &face))
+            throw std::runtime_error("Error::FREETYPE: Failed to load font!");
+
+        unsigned int new_index = 0;
+        for (const auto& f : Detail::fonts)
+            if (f.index >= new_index)
+                new_index = f.index + 1;
+
+        index = new_index;
+        Detail::fonts.push_back(*this);
+        std::cout << "Loaded font from " << path << " with index " << new_index << std::endl;
     }
 
     Font::~Font() {
@@ -122,14 +133,18 @@ namespace JGL
             return extents;
         }
 
-        jlog::Warning("Measuring a font size that is not cached, This is *super* slow.");
-        FT_Set_Pixel_Sizes(this->face, ptSize, ptSize);
+        jlog::Warning("Measuring a font size that is not cached, Defaulting to Jupiteroid.");
+        FT_Set_Pixel_Sizes(Fonts::Jupiteroid.face, ptSize, ptSize);
 
         for (const char& c : text) {
+            // TODO: Fix segfault
+            //FT_GlyphSlot slot = Fonts::Jupiteroid.face->glyph;
+            //auto glyph_index = FT_Get_Char_Index(Fonts::Jupiteroid.face, c);
             FT_GlyphSlot slot = face->glyph;
             auto glyph_index = FT_Get_Char_Index(this->face, c);
 
-            auto error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
+            //auto error = FT_Load_Glyph(Fonts::Jupiteroid.face, glyph_index, FT_LOAD_DEFAULT);
+            auto error = FT_Load_Glyph(this->face, glyph_index, FT_LOAD_DEFAULT);
 
             if (error)
                 continue;
@@ -149,9 +164,6 @@ namespace JGL
             if (extents.y < ptSize)
                 extents.y = ptSize;
         }
-
         return extents;
     }
-
-
 }

src/types/Light.cpp

@@ -1,19 +1,64 @@
 #include <JGL/types/Light.h>
-#include <glad/glad.h>
 
-JGL::Light::Light(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular) {
+JGL::PointLight::PointLight(const Vector3& position, const Color4& ambient, const Color4& diffuse, const Color4& specular, float constant_attenuation, float linear_attenuation, float quadratic_attenuation) {
     this->position = Vector4(position, 1.0f);
     this->ambient = ambient;
     this->diffuse = diffuse;
     this->specular = specular;
+    this->constant_attenuation = constant_attenuation;
+    this->linear_attenuation = linear_attenuation;
+    this->quadratic_attenuation = quadratic_attenuation;
 }
 
-Vector3 JGL::Light::GetNormalizedSceenSpaceCoordinates() const {
-    GLint viewport[4];
-    glGetIntegerv(GL_VIEWPORT, viewport);
+float JGL::PointLight::GetAttenuationAtPosition(const Vector3& pos) const {
+    Vector3 light_pos = {position.x, position.y, position.z};
+    Vector3 vector_to_position = pos - light_pos;
+    float distance = vector_to_position.Length();
 
-    float normalized_x = 2.0f * (position.x - viewport[0]) / viewport[2] - 1.0f;
-    float normalized_y = 2.0f * (position.y - viewport[1]) / viewport[3] - 1.0f;
-
-    return {normalized_x, normalized_y, position.z};
+    return 1.0f / (GetConstantAttenuation() + GetLinearAttenuation() * distance + GetQuadraticAttenuation() * distance * distance);
 }
+
+JGL::SpotLight::SpotLight(const Vector3& position, const Matrix3x3& ro_mat, float cone_size_degrees, float exponent, const Color4& ambient, const Color4& diffuse, const Color4& specular,
+                          float constant_attenuation, float linear_attenuation, float quadratic_attenuation) {
+    this->position = Vector4(position, 1);
+    //TODO RotationMatrix to "Normalized direction vector."
+    orientation = ro_mat;
+    this->cut = cone_size_degrees;
+    this->exponent = exponent;
+    this->ambient = ambient;
+    this->diffuse = diffuse;
+    this->specular = specular;
+    this->constant_attenuation = constant_attenuation;
+    this->linear_attenuation = linear_attenuation;
+    this->quadratic_attenuation = quadratic_attenuation;
+}
+
+Vector4 JGL::LightBase::GetPosition() const {
+    return position;
+}
+
+Color4 JGL::LightBase::GetAmbient() const {
+    return ambient;
+}
+
+Color4 JGL::LightBase::GetDiffuse() const {
+    return diffuse;
+}
+
+Color4 JGL::LightBase::GetSpecular() const {
+    return specular;
+}
+
+float JGL::LightBase::GetConstantAttenuation() const {
+    return constant_attenuation;
+}
+
+float JGL::LightBase::GetLinearAttenuation() const {
+    return linear_attenuation;
+}
+
+float JGL::LightBase::GetQuadraticAttenuation() const {
+    return quadratic_attenuation;
+}
+
+

src/types/Material.cpp

@@ -0,0 +1,31 @@
+#include <JGL/types/Material.h>
+#include <J3ML/LinearAlgebra/Vector4.hpp>
+
+JGL::Material::Material(const Color4& ambient_reflection, const Color4& diffuse_reflection, const Color4& specular_reflection, const Color4& light_emission, float& shine) {
+    ambient_ref = ambient_reflection;
+    diffuse_ref = diffuse_reflection;
+    specular_ref = specular_reflection;
+    emission = light_emission;
+    shininess = shine;
+}
+
+void JGL::Material::SetActiveMaterial(const Material& material) {
+    Vector4 ambient = { material.ambient_ref.RN(), material.ambient_ref.BN(), material.ambient_ref.GN(), material.ambient_ref.AN() };
+    Vector4 diffuse = { material.diffuse_ref.RN(), material.diffuse_ref.BN(), material.diffuse_ref.GN(), material.diffuse_ref.AN() };
+    Vector4 specular = { material.specular_ref.RN(), material.specular_ref.BN(), material.specular_ref.GN(), material.specular_ref.AN() };
+    Vector4 emission = { material.emission.RN(), material.emission.BN(), material.emission.GN(), material.emission.AN() };
+
+    // Determine which faces we're going to apply this material to.
+    GLenum face = GL_FRONT;
+    if (glIsEnabled(GL_CULL_FACE)) {
+        GLint current; glGetIntegerv(GL_CULL_FACE_MODE, &current);
+        if (current == GL_FRONT)
+            face = GL_BACK;
+    }
+
+    glMaterialfv(face, GL_AMBIENT, ambient.ptr());
+    glMaterialfv(face, GL_DIFFUSE, diffuse.ptr());
+    glMaterialfv(face, GL_SPECULAR, specular.ptr());
+    glMaterialfv(face, GL_EMISSION, emission.ptr());
+    glMaterialf(face, GL_SHININESS, material.shininess);
+}

src/types/RenderTarget.cpp

@@ -30,7 +30,7 @@ void JGL::RenderTarget::SetActiveGLRenderTarget(const RenderTarget& render_targe
     glViewport(0,0, render_target.GetDimensions().x, render_target.GetDimensions().y);
 }
 
-Vector2 JGL::RenderTarget::GetDimensions() const {
+Vector2i JGL::RenderTarget::GetDimensions() const {
     return size;
 }
 
@@ -53,6 +53,9 @@ Color4 JGL::RenderTarget::GetClearColor() const {
 
 /// Idk why you'd ever want to clear it out if you're rendering onto a texture you passed in :shrug:.
 JGL::RenderTarget::RenderTarget(const JGL::Texture* texture, const Color4& clear_color) {
+    if (texture->GetDimensions().x < 1 || texture->GetDimensions().y < 1)
+        Logger::Fatal("Creating a render target where the color attachment is empty?");
+
     GLuint current_fbo = GetActiveGLFramebufferHandle();
     GLint viewport[4] = {0, 0, 0, 0};
     glGetIntegerv(GL_VIEWPORT, viewport);
@@ -68,12 +71,15 @@ JGL::RenderTarget::RenderTarget(const JGL::Texture* texture, const Color4& clear
     glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
     glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
     this->clear_color = clear_color;
-    this->size = texture->GetDimensions();
+    this->size = {(int) size.x, (int) size.y};
     this->texture = texture;
     texture_created_by_us = false;
 }
 
-JGL::RenderTarget::RenderTarget(const Vector2& size, const Color4& clear_color, bool use_depth, MSAA_SAMPLE_RATE sample_rate) {
+JGL::RenderTarget::RenderTarget(const Vector2i& size, const Color4& clear_color, bool use_depth, MSAA_SAMPLE_RATE sample_rate) {
+    if (size.x < 1 || size.y < 1)
+        Logger::Fatal("Creating a render target where the color attachment is empty?");
+
     GLuint current_fbo = GetActiveGLFramebufferHandle();
     GLint viewport[4] = {0, 0, 0, 0};
     glGetIntegerv(GL_VIEWPORT, viewport);
@@ -118,7 +124,7 @@ JGL::RenderTarget::RenderTarget(const Vector2& size, const Color4& clear_color,
         SetMSAAEnabled(sample_rate);
 }
 
-std::vector<GLfloat> JGL::RenderTarget::GetData() const {
+std::vector<GLfloat> JGL::RenderTarget::GetPixels() const {
     std::vector<GLfloat> data(GetDimensions().x * GetDimensions().y * 4);
     GLuint current_fbo = GetActiveGLFramebufferHandle();
 
@@ -126,12 +132,11 @@ std::vector<GLfloat> JGL::RenderTarget::GetData() const {
     glReadPixels(0, 0, GetDimensions().x, GetDimensions().y, GL_RGBA, GL_FLOAT, data.data());
     glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
     return data;
-
 }
 
-void JGL::RenderTarget::Resize(const Vector2& new_size) {
+void JGL::RenderTarget::Resize(const Vector2i& new_size) {
     if (!texture_created_by_us)
-        Logger::Fatal("Resizing a texture that already existed?");
+        Logger::Error("Resizing a Render Target that does not own it's texture?");
 
     GLuint current_fbo = GetActiveGLFramebufferHandle();
     GLfloat old_clear_color[4];
@@ -139,8 +144,8 @@ void JGL::RenderTarget::Resize(const Vector2& new_size) {
     glGetIntegerv(GL_VIEWPORT, old_viewport);
     glGetFloatv(GL_COLOR_CLEAR_VALUE, old_clear_color);
 
-    /* If what was previously not part of the renderable area is big enough to
-     * just set the new size without reading data back */
+    /* If what was previously not part of the renderable area is big enough
+     * to just set the new size. */
     if (new_size.x <= texture->GetDimensions().x && new_size.y <= texture->GetDimensions().y) {
         size = new_size;
 
@@ -176,7 +181,7 @@ void JGL::RenderTarget::Resize(const Vector2& new_size) {
     glClearColor(cc.RedChannelNormalized(), cc.GreenChannelNormalized(), cc.BlueChannelNormalized(), cc.AlphaChannelNormalized());
     glViewport(0,0, size.x, size.y);
 
-    texture = new Texture(Vector2((float) biggest, (float) biggest));
+    texture = new Texture(Vector2(biggest, biggest));
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetGLTextureHandle(), 0);
 
     glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
@@ -198,7 +203,7 @@ JGL::RenderTarget::~RenderTarget() {
         delete texture;
 }
 
-bool JGL::RenderTarget::TextureCreatedByRenderTarget() const {
+bool JGL::RenderTarget::OwnsTexture() const {
     return texture_created_by_us;
 }
 
@@ -207,22 +212,23 @@ JGL::MSAA_SAMPLE_RATE JGL::RenderTarget::GetMSAASampleRate() const {
 }
 
 bool JGL::RenderTarget::MSAAEnabled() const {
-        return msaa_sample_rate != MSAA_SAMPLE_RATE::MSAA_NONE;
+    return msaa_sample_rate != MSAA_SAMPLE_RATE::MSAA_NONE;
 }
 
-void JGL::RenderTarget::SetMSAAEnabled(JGL::MSAA_SAMPLE_RATE sample_rate) {
+bool JGL::RenderTarget::SetMSAAEnabled(JGL::MSAA_SAMPLE_RATE sample_rate) {
     // If we'd be setting the same sample_rate we already have.
     if (sample_rate == msaa_sample_rate)
-        return;
+        return false;
 
     // If we'd be rendering onto a texture and not a plain render target we don't want this.
-    if (!TextureCreatedByRenderTarget())
-        return;
+    if (!OwnsTexture())
+        return false;
 
     // Remove it if they request no msaa or if what they requested is different than what they already have.
     if (sample_rate == MSAA_SAMPLE_RATE::MSAA_NONE || msaa_sample_rate != MSAA_SAMPLE_RATE::MSAA_NONE) {
         if(using_depth)
             glDeleteRenderbuffers(1, &msaa_depth_buffer);
+
         glDeleteRenderbuffers(1, &msaa_render_buffer);
         glDeleteFramebuffers(1, &msaa_framebuffer_object);
 
@@ -233,7 +239,7 @@ void JGL::RenderTarget::SetMSAAEnabled(JGL::MSAA_SAMPLE_RATE sample_rate) {
 
         // Only return here if they specifically requested no MSAA. else continue to change mode.
         if (sample_rate == MSAA_SAMPLE_RATE::MSAA_NONE)
-            return;
+            return true;
     }
 
     GLuint current_fbo = GetActiveGLFramebufferHandle();
@@ -265,11 +271,11 @@ void JGL::RenderTarget::SetMSAAEnabled(JGL::MSAA_SAMPLE_RATE sample_rate) {
 
     if (failure)
         SetMSAAEnabled(MSAA_SAMPLE_RATE::MSAA_NONE);
+    return failure;
 }
 
-void JGL::RenderTarget::Blit() const {
-    if (MSAAEnabled() && TextureCreatedByRenderTarget()) {
-
+void JGL::RenderTarget::MSAABlit() const {
+    if (MSAAEnabled() && OwnsTexture()) {
         // Save the GL state.
         GLuint current_fbo = GetActiveGLFramebufferHandle();
         GLint current_draw_fbo = 0;
@@ -302,9 +308,9 @@ void JGL::RenderTarget::Blit() const {
     }
 }
 
-void JGL::RenderTarget::Blit(const JGL::RenderTarget& source, JGL::RenderTarget* destination) {
-    if (source.size != destination->size)
-        Logger::Warning("Blitting a render target but they're not the same size?");
+void JGL::RenderTarget::Blit(const JGL::RenderTarget& source, JGL::RenderTarget* destination, const Vector2i& position) {
+    if (source.GetDimensions().x > destination->GetDimensions().x || source.GetDimensions().y > destination->GetDimensions().y)
+        Logger::Warning("Blitting a Render Target onto another Render Target but the destination Render Target is too small?");
 
     // Save the GL state.
     GLuint current_fbo = GetActiveGLFramebufferHandle();
@@ -316,7 +322,7 @@ void JGL::RenderTarget::Blit(const JGL::RenderTarget& source, JGL::RenderTarget*
     // Draw the contents of one into the other.
     glBindFramebuffer(GL_READ_FRAMEBUFFER, source.framebuffer_object);
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, destination->framebuffer_object);
-    glBlitFramebuffer(0, 0, source.size.x, source.size.y, 0, 0, source.size.x, source.size.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    glBlitFramebuffer(0, 0, source.size.x, source.size.y, position.x, position.y, position.x + source.size.x, position.y + source.size.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
     // Put the GL state back.
     glBindFramebuffer(GL_READ_FRAMEBUFFER, current_read_fbo);
@@ -324,6 +330,49 @@ void JGL::RenderTarget::Blit(const JGL::RenderTarget& source, JGL::RenderTarget*
     glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
 }
 
+void JGL::RenderTarget::Blit(const Texture* source, RenderTarget* destination, const Vector2i& position) {
+    auto temp = new RenderTarget(source);
+    Blit(*temp, destination);
+    delete temp;
+}
+
+// To avoid repeatedly allocating and deallocating.
+JGL::RenderTarget* pixel = nullptr;
+void JGL::RenderTarget::Blit(const Color4& color, const Vector2i& position, JGL::RenderTarget* destination) {
+    if (position.x > destination->size.x || position.y > destination->size.y)
+        Logger::Warning("Blitting outside of the renderable area of the destination.");
+
+    if (pixel == nullptr)
+        pixel = new RenderTarget({1,1});
+
+    GLint current_draw_fbo = 0;
+    GLint current_read_fbo = 0;
+    GLint viewport[4];
+    GLfloat clear_color[4];
+    GLuint current_fbo = GetActiveGLFramebufferHandle();
+    glGetIntegerv(GL_VIEWPORT, viewport);
+    glGetFloatv(GL_COLOR_CLEAR_VALUE, clear_color);
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &current_read_fbo);
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &current_draw_fbo);
+
+    SetActiveGLRenderTarget(*pixel);
+    glClearColor(color.RedChannelNormalized(), color.GreenChannelNormalized(), color.BlueChannelNormalized(), color.AlphaChannelNormalized());
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    // Invert so it's relative to the top left corner.
+    int target_y = destination->size.y - position.y - 1;
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, pixel->framebuffer_object);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, destination->framebuffer_object);
+    glBlitFramebuffer(0, 0, 1, 1, position.x, target_y, position.x + 1, target_y + 1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, current_read_fbo);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, current_draw_fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
+    glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
+    glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
+}
+
 JGL::RenderTarget::RenderTarget(const JGL::RenderTarget& rhs) {
     auto* this_render_target = new RenderTarget(rhs.size, rhs.clear_color, rhs.using_depth, rhs.msaa_sample_rate);
     RenderTarget::Blit(rhs, this_render_target);

src/types/Skeleton.cpp

@@ -0,0 +1,186 @@
+#include <JGL/types/Skeleton.h>
+#include <JGL/logger/logger.h>
+#include <cstring>
+
+using namespace JGL;
+
+std::array<int, 4> JGL::SkeletalVertexAttribute::GetAffectingBoneIDs() const {
+    return bone_ids;
+}
+
+std::array<float, 4> JGL::SkeletalVertexAttribute::GetAffectingBoneWeights() const {
+    return bone_weights;
+}
+
+JGL::SkeletalVertexAttribute::SkeletalVertexAttribute(const std::vector<int>& ids, const std::vector<float>& weights) {
+
+    if (bone_ids.size() > 4 || bone_weights.size() > 4)
+        Logger::Fatal("Initialization of a skeletal vertex that is effected by more than 4 bones.");
+
+    memcpy(this->bone_ids.data(), bone_ids.data(), sizeof(int) * 4);
+    memcpy(this->bone_weights.data(), bone_weights.data(), sizeof(float) * 4);
+}
+
+bool JGL::Bone::IsRootBone() const {
+    if (parent_id == -1)
+        return true;
+    return false;
+}
+
+int JGL::Bone::GetID() const {
+    return id;
+}
+
+std::string JGL::Bone::GetName() const {
+    return name;
+}
+
+Matrix4x4 JGL::Bone::GetInverseBindMatrix() const {
+    return inverse_bind_matrix;
+}
+
+Matrix4x4 JGL::Bone::GetOffsetMatrix() const {
+    return offset_matrix;
+}
+
+Matrix4x4 JGL::Bone::GetFinalTransform() const {
+    return final_transform;
+}
+
+std::vector<int> JGL::Bone::GetChildren() const {
+    return children;
+}
+
+void Bone::SetParent(int parent_identifier) {
+    parent_id = parent_identifier;
+}
+
+void Bone::AppendChild(int new_child) {
+    children.push_back(new_child);
+}
+
+void Bone::SetID(int numeric_id) {
+    id = numeric_id;
+}
+
+void Bone::SetName(const std::string& string_id) {
+    name = string_id;
+}
+
+void Bone::SetInverseBindMatrix(const Matrix4x4& inverse_bind) {
+    inverse_bind_matrix = inverse_bind;
+}
+
+void Bone::SetOffsetMatrix(const Matrix4x4& offset) {
+    offset_matrix = offset;
+}
+
+void Bone::SetFinalTransformMatrix(const Matrix4x4& final) {
+    final_transform = final;
+}
+
+int Bone::GetParentID() const {
+    return parent_id;
+}
+
+Bone::Bone(int numeric_id, const std::string& string_id, int parent_bone, const std::vector<int>& children_ids, const Matrix4x4& inverse_bind, const Matrix4x4& offset, const Matrix4x4& final) {
+    id = numeric_id;
+    name = string_id;
+    parent_id = parent_bone;
+    inverse_bind_matrix = inverse_bind;
+    offset_matrix = offset;
+    final_transform = final;
+    children = children_ids;
+}
+
+Bone* Skeleton::GetRootBone() {
+    return &root;
+}
+
+Bone* Skeleton::FindBone(int id) {
+    if (root.GetID() == id)
+        return &root;
+
+    for (auto& bone : bones)
+        if (bone.GetID() == id)
+            return &bone;
+    // If we couldn't find it.
+    return nullptr;
+}
+
+Bone* Skeleton::FindBone(const std::string& string_id) {
+    if (root.GetName() == string_id)
+        return &root;
+
+    for (auto& bone : bones)
+        if (bone.GetName() == string_id)
+            return &bone;
+    return nullptr;
+}
+
+void Skeleton::AppendBone(const Bone& new_bone) {
+    bones.push_back(new_bone);
+}
+
+Skeleton::Skeleton(const Bone& root_bone, const std::vector<Bone>& children) {
+    root = root_bone;
+     bones = children;
+}
+
+float KeyFrame::GetTimeStamp() const {
+    return time_stamp;
+}
+
+Skeleton KeyFrame::GetSkeleton() const {
+    return pose;
+}
+
+KeyFrame::KeyFrame(const Skeleton& pose, float time_stamp) {
+    this->pose = pose;
+    this->time_stamp = time_stamp;
+}
+
+Animation::Animation(int id, float duration, const std::vector<KeyFrame>& key_frames, const std::vector<SkeletalVertexAttribute>& skeletal_vertex_attributes,
+                     const std::string& name) {
+    length = duration;
+    this->key_frames = key_frames;
+    this->id = id;
+    this->name = name;
+    this->vertex_attributes = skeletal_vertex_attributes;
+}
+
+float Animation::GetDuratrion() const {
+    return length;
+}
+
+std::vector<KeyFrame> Animation::GetKeyFrames() const {
+    return key_frames;
+}
+
+void Animation::AppendKeyFrame(const KeyFrame& new_key) {
+    key_frames.push_back(new_key);
+}
+
+void Animation::SetDuration(float duration) {
+    length = duration;
+}
+
+int Animation::GetID() const {
+    return id;
+}
+
+std::string Animation::GetName() const {
+    return name;
+}
+
+void Animation::SetID(int identifier) {
+    id = identifier;
+}
+
+void Animation::SetName(const std::string& name_id) {
+    name = name_id;
+}
+
+std::vector<SkeletalVertexAttribute> Animation::GetSkeletalVertexAttributes() const {
+    return vertex_attributes;
+}

src/types/Texture.cpp

@@ -189,4 +189,24 @@ namespace JGL
         // In 99% of cases you wouldn't want this. But in this scenario we do.
         operator delete(this_texture);
     }
+
+    Texture::Texture(const Texture* textures, const size_t& texture_count) {
+        float length = 0;
+        float biggest_y = 0;
+
+        for (int i = 0; i < texture_count; i++) {
+            if (biggest_y < textures[i].texture_size.y)
+                biggest_y = textures[i].texture_size.y;
+            length += textures[i].texture_size.x;
+        }
+
+        auto* result = new Texture(Vector2(length, biggest_y));
+        auto render_target = RenderTarget(result);
+
+        int next_x = 0;
+        for (int i = 0; i < texture_count; i++) {
+            RenderTarget::Blit(&textures[i], &render_target, Vector2i(next_x, 0));
+            next_x += textures[i].GetDimensions().x;
+        }
+    }
 }

src/types/VRamList.cpp

@@ -3,6 +3,9 @@
 #include <cstring>
 
 void JGL::VRamList::load(const GLfloat* data, const long& size) {
+    while (spin_lock) {}
+    spin_lock = true;
+
     GLint current_array_buffer = 0;
     glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &current_array_buffer);
     glGenBuffers(1, &list_handle);
@@ -11,9 +14,14 @@ void JGL::VRamList::load(const GLfloat* data, const long& size) {
     glBindBuffer(GL_ARRAY_BUFFER, current_array_buffer);
     element_array_buffer = false;
     num_elements = size / sizeof(GLfloat);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::load(const GLuint* data, const long& size) {
+    while (spin_lock) {}
+    spin_lock = true;
+
     GLint current_element_array_buffer = 0;
     glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &current_element_array_buffer);
     glGenBuffers(1, &list_handle);
@@ -22,13 +30,16 @@ void JGL::VRamList::load(const GLuint* data, const long& size) {
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_element_array_buffer);
     element_array_buffer = true;
     num_elements = size / sizeof(GLuint);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::Erase() {
-    if (list_handle == 0) {
-        JGL::Logger::Warning("Erasing an uninitialized VRamList?");
+    if (list_handle == 0)
         return;
-    }
+
+    while (spin_lock) {}
+    spin_lock = true;
 
     GLint current_element_array_buffer = 0;
     glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &current_element_array_buffer);
@@ -43,6 +54,8 @@ void JGL::VRamList::Erase() {
 
     glDeleteBuffers(1, &list_handle);
     list_handle = 0;
+
+    spin_lock = false;
 }
 
 GLuint JGL::VRamList::GetHandle() const {
@@ -57,26 +70,26 @@ long JGL::VRamList::GetLength() const {
     return num_elements;
 }
 
-size_t JGL::VRamList::GetSize() const {
+size_t JGL::VRamList::GetDataSize() const {
     if (element_array_buffer)
         return sizeof(GLuint) * num_elements;
     return sizeof(GLfloat) * num_elements;
 }
 
 void JGL::VRamList::SetData(void* data, const long& length) {
-    bool should_resize = (this->num_elements != length);
+    while (spin_lock) {}
+    spin_lock = true;
 
+    bool should_resize = (this->num_elements != length);
     if (should_resize) {
         glDeleteBuffers(1, &list_handle);
         list_handle = 0;
-
-        if (!element_array_buffer)
-            load((GLfloat*) data, sizeof(GLfloat) * length);
-        else
-            load((GLuint*) data, sizeof(GLuint) * length);
+        spin_lock = false;
+        element_array_buffer ? load((GLuint*) data, sizeof(GLuint) * length) : load((GLfloat*) data, sizeof(GLfloat) * length);
         return;
     }
 
+    // if (!should resize)
     GLint current_buffer = 0;
     GLenum buffer_type = GL_ARRAY_BUFFER;
     GLenum buffer_binding = GL_ARRAY_BUFFER_BINDING;
@@ -97,9 +110,13 @@ void JGL::VRamList::SetData(void* data, const long& length) {
         JGL::Logger::Fatal("We couldn't unmap the buffer?");
 
     glBindBuffer(buffer_type, current_buffer);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::UpdateData(void* data, const long& offset, const long& length) {
+    while (spin_lock) {}
+    spin_lock = true;
 
     if (offset + length > num_elements) {
         JGL::Logger::Warning("Using UpdateData to out-of-bounds write the VRamList? I'll resize it for you, But this is slow.");
@@ -109,14 +126,16 @@ void JGL::VRamList::UpdateData(void* data, const long& offset, const long& lengt
             auto list_data = GetDataUI();
             list_data.resize(list_data.size() + oob_delta);
             memcpy(list_data.data() + (offset * sizeof(GLuint)), data, length * sizeof(GLuint));
-            SetData(list_data.data(), list_data.size());
-        }
-        else {
-            auto list_data = GetDataF();
-            list_data.resize(list_data.size() + oob_delta);
-            memcpy(list_data.data() + (offset * sizeof(GLfloat)), data, length * sizeof(GLfloat));
-            SetData(list_data.data(), list_data.size());
+            spin_lock = false; // This is going unlock and relock really fast, But this code fixes something considered wrong anyway - Redacted.
+            return SetData(list_data.data(), list_data.size());
         }
+
+        // if (!element_array_buffer)
+        auto list_data = GetDataF();
+        list_data.resize(list_data.size() + oob_delta);
+        memcpy(list_data.data() + (offset * sizeof(GLfloat)), data, length * sizeof(GLfloat));
+        spin_lock = false;
+        return SetData(list_data.data(), list_data.size());
     }
 
     GLint current_buffer = 0;
@@ -141,12 +160,20 @@ void JGL::VRamList::UpdateData(void* data, const long& offset, const long& lengt
         JGL::Logger::Fatal("We couldn't unmap the buffer?");
 
     glBindBuffer(buffer_type, current_buffer);
+
+    spin_lock = false;
 }
 
 std::vector<GLfloat> JGL::VRamList::GetDataF() const {
+    while (spin_lock) {}
+
     if (element_array_buffer)
         JGL::Logger::Warning("Getting data as GLfloat but the buffer data is GLuint?");
 
+    bool vertex_array_enabled = glIsEnabled(GL_VERTEX_ARRAY);
+    if (!vertex_array_enabled)
+        glEnableClientState(GL_VERTEX_ARRAY);
+
     GLint current_buffer = 0;
     glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &current_buffer);
     glBindBuffer(GL_ARRAY_BUFFER, list_handle);
@@ -161,10 +188,14 @@ std::vector<GLfloat> JGL::VRamList::GetDataF() const {
     glUnmapBuffer(GL_ARRAY_BUFFER);
     glBindBuffer(GL_ARRAY_BUFFER, current_buffer);
 
+    if (!vertex_array_enabled)
+        glDisableClientState(GL_VERTEX_ARRAY);
     return data;
 }
 
 std::vector<GLuint> JGL::VRamList::GetDataUI() const {
+    while (spin_lock) {}
+
     if (!element_array_buffer)
         JGL::Logger::Warning("Getting data as GLuint but the buffer data is GLfloat?");
 
@@ -194,16 +225,16 @@ JGL::VRamList::VRamList(const GLuint* data, const long& length) {
     load(data, (long) sizeof(GLuint) * length);
 }
 
-JGL::VRamList::VRamList(Vector2* data, const long& length) {
-    load(reinterpret_cast<GLfloat*>(data), (long) sizeof(Vector2) * length);
+JGL::VRamList::VRamList(const Vector2* data, const long& length) {
+    load(reinterpret_cast<const GLfloat*>(data), (long) sizeof(Vector2) * length);
 }
 
-JGL::VRamList::VRamList(Vector3* data, const long& length) {
-    load(reinterpret_cast<GLfloat*>(data), (long) sizeof(Vector3) * length);
+JGL::VRamList::VRamList(const Vector3* data, const long& length) {
+    load(reinterpret_cast<const GLfloat*>(data), (long) sizeof(Vector3) * length);
 }
 
-JGL::VRamList::VRamList(Vector4* data, const long& length) {
-    load(reinterpret_cast<GLfloat*>(data), (long) sizeof(Vector4) * length);
+JGL::VRamList::VRamList(const Vector4* data, const long& length) {
+    load(reinterpret_cast<const GLfloat*>(data), (long) sizeof(Vector4) * length);
 }
 
 void JGL::VRamList::SetData(const GLfloat* data, const long& length) {
@@ -259,10 +290,11 @@ JGL::VRamList::~VRamList() {
 }
 
 JGL::VRamList::VRamList(const JGL::VRamList& rhs) {
+    while (rhs.spin_lock) {}
+
     if (rhs.element_array_buffer) {
         auto data_array = rhs.GetDataUI();
         this->load(data_array.data(), data_array.size());
-        return;
     }
 
     auto data_array = rhs.GetDataF();

src/types/VertexArray.cpp

@@ -0,0 +1,189 @@
+#include <JGL/types/VertexArray.h>
+#include <JGL/logger/logger.h>
+#include "../internals/include/WavefrontOBJ.h"
+#include "../internals/include/AMO.h"
+
+using namespace JGL;
+
+const VRamList* VertexArray::GetVertices() const {
+    return vertices;
+}
+
+const VRamList* VertexArray::GetIndices() const {
+    return indices;
+}
+
+const VRamList* VertexArray::GetNormals() const {
+    return normals;
+}
+
+const VRamList* VertexArray::GetTextureCoordinates() const {
+    return texture_coordinates;
+}
+
+std::vector<Vertex> VertexArray::GetLocalVertices() const {
+    return local_vertices;
+}
+
+std::vector<unsigned int> VertexArray::GetLocalIndices() const {
+    return local_indices;
+}
+
+std::vector<TextureCoordinate> VertexArray::GetLocalTextureCoordinates() const {
+    return local_texture_coordinates;
+}
+
+std::vector<Normal> VertexArray::GetLocalNormals() const {
+    return local_normals;
+}
+
+Sphere VertexArray::GetMESphere(const Vector3& scale, const Vector3& translate_part) const {
+    if (scale == Vector3::One)
+        return { me_sphere.Position + translate_part, me_sphere.Radius };
+
+    float scale_factor = 0;
+    if (scale.x > scale_factor)
+        scale_factor = scale.x;
+    if (scale.y > scale_factor)
+        scale_factor = scale.y;
+    if (scale.z > scale_factor)
+        scale_factor = scale.z;
+
+    return { me_sphere.Position + translate_part, me_sphere.Radius * scale_factor };
+}
+
+Sphere VertexArray::GetMESphere(const Matrix4x4& instance_matrix, bool translate) const {
+    Vector3 scale = instance_matrix.GetScale();
+    Vector3 origin = Vector3::Zero;
+    if (translate)
+        origin = instance_matrix.GetTranslatePart();
+
+    return GetMESphere(scale, origin);
+}
+
+void VertexArray::CreateMESphere() {
+    Sphere result = {Vector3::Zero, 0};
+    Vector3 minimum = {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max() };
+    Vector3 maximum = { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest()};
+
+    for (const auto& vertex : local_vertices) {
+        if (vertex.x < minimum.x)
+            minimum.x = vertex.x;
+        if (vertex.x > maximum.x)
+            maximum.x = vertex.x;
+
+        if (vertex.y < minimum.y)
+            minimum.y = vertex.y;
+        if (vertex.y > maximum.y)
+            maximum.y = vertex.y;
+
+        if (vertex.z < minimum.z)
+            minimum.z = vertex.z;
+        if (vertex.z > maximum.z)
+            maximum.z = vertex.z;
+    }
+    result.Position = (minimum + maximum) * 0.5f;
+    for (const auto& vertex : local_vertices) {
+        float distance_squared = Vector3::DistanceSquared(result.Position, vertex);
+        if (distance_squared > result.Radius)
+            result.Radius = distance_squared;
+    }
+    result.Radius = std::sqrt(result.Radius);
+    me_sphere = result;
+}
+
+void VertexArray::CreateMEOBB() {
+    Vector3 minimum(std::numeric_limits<float>::max());
+    Vector3 maximum (std::numeric_limits<float>::min());
+
+    for (const auto& vertex : local_vertices) {
+        if (vertex.x < minimum.x)
+            minimum.x = vertex.x;
+        if (vertex.x > maximum.x)
+            maximum.x = vertex.x;
+
+        if (vertex.y < minimum.y)
+            minimum.y = vertex.y;
+        if (vertex.y > maximum.y)
+            maximum.y = vertex.y;
+
+        if (vertex.z < minimum.z)
+            minimum.z = vertex.z;
+        if (vertex.z > maximum.z)
+            maximum.z = vertex.z;
+    }
+
+    Vector3 position = (minimum + maximum) * 0.5f;
+    Vector3 half_extents = (maximum - minimum) * 0.5f;
+
+    me_obb = { position, half_extents, Vector3::UnitX, Vector3::UnitY, Vector3::UnitZ };
+}
+
+OBB VertexArray::GetMEOBB(const Matrix3x3& rotation_matrix, const Vector3& scale, const Vector3& translate_part) const {
+    Vector3 half_extents = me_obb.r.Mul(scale);
+    Vector3 axis0 = rotation_matrix * me_obb.axis[0];
+    Vector3 axis1 = rotation_matrix * me_obb.axis[1];
+    Vector3 axis2 = rotation_matrix * me_obb.axis[2];
+    Vector3 position = me_obb.pos + translate_part;
+
+    return { position, half_extents, axis0, axis1, axis2 };
+}
+
+OBB VertexArray::GetMEOBB(const Matrix4x4& instance_matrix, bool translate) const {
+    return GetMEOBB(instance_matrix.GetRotatePart(), instance_matrix.GetScale(), translate ? instance_matrix.GetTranslatePart() : Vector3::Zero);
+}
+
+AABB VertexArray::GetMEAABB(const Matrix3x3& rotation_matrix, const Vector3& scale, const Vector3& translate_part) const {
+    /* kind-of a cheat. It's faster to calculate the oriented bounding box and then put the axis-aligned one around that
+     * than to loop over the whole model like an idiot. You gain back all the speed with the simplicity of the physics anyways. - Redacted */
+    return GetMEOBB(rotation_matrix, scale, translate_part).MinimalEnclosingAABB();
+}
+
+AABB VertexArray::GetMEAABB(const Matrix4x4& instance_matrix, bool translate) const {
+    return GetMEAABB(instance_matrix.GetRotatePart(), instance_matrix.GetScale(), translate ? instance_matrix.GetTranslatePart() : Vector3::Zero);
+}
+
+VertexArray::VertexArray(const Vector3* vertex_positions, const long& vp_length, const unsigned int* vertex_indices, const long& vi_length,
+                         const Normal* vertex_normals, const long& vn_length, const TextureCoordinate* texture_coordinates, const long& vt_length) {
+
+    // TODO decimator. This is a total waste of memory as it sits.
+    this->vertices = new VRamList(vertex_positions, vp_length);
+
+    local_vertices.resize(vp_length);
+    memcpy(local_vertices.data(), vertex_positions, sizeof(Vector3) * vp_length);
+
+    if (vertex_indices && vi_length) {
+        indices = new VRamList(vertex_indices, vi_length);
+        local_indices.resize(vi_length);
+        memcpy(local_indices.data(), vertex_indices, sizeof(unsigned int) * vi_length);
+    }
+
+    if (vertex_normals && vn_length) {
+        normals = new VRamList(vertex_normals, vn_length);
+        local_normals.resize(vn_length);
+        memcpy(local_normals.data(), vertex_indices, sizeof(Normal) * vn_length);
+    }
+
+    if (texture_coordinates && vt_length) {
+        this->texture_coordinates = new VRamList(texture_coordinates, vt_length);
+        local_texture_coordinates.resize(vt_length);
+        memcpy(local_texture_coordinates.data(), texture_coordinates, sizeof(TextureCoordinate) * vt_length);
+    }
+
+}
+
+VertexArray::VertexArray(const std::vector<Vertex>& vertex_positions, const std::vector<unsigned int>& vertex_indices, const std::vector<Normal>& vertex_normals, const std::vector<TextureCoordinate>& texture_coordinates) {
+    *this = VertexArray(vertex_positions.data(), vertex_positions.size(), vertex_indices.data(), vertex_indices.size(), vertex_normals.data(), vertex_normals.size(), texture_coordinates.data(), texture_coordinates.size());
+}
+
+bool VertexArray::Static() {
+    return animations.empty();
+}
+
+VertexArray VertexArray::LoadWavefrontOBJ(const std::string& file_text) {
+    return JGL::LoadWavefrontOBJ(file_text);
+}
+
+VertexArray VertexArray::LoadAMO(const std::string& file_text) {
+    //return JGL::LoadAMO(file_text);
+}