Started to apply the adhesive... A triangle is rotating on a invisible super elastic rubberband and the camera is attached with ethereal paperclips.

3.3.shader.frag

@@ -0,0 +1,10 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec3 ourColor;
+
+void main()
+{
+    FragColor = vec4(ourColor, 1.0f);
+}
+

3.3.shader.vert

@@ -0,0 +1,11 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+out vec3 ourColor;
+
+void main()
+{
+    gl_Position = vec4(aPos, 1.0);
+    ourColor = aColor;
+}#pragma once

5.1.transform.frag

@@ -0,0 +1,15 @@
+#version 330 core
+out vec4 FragColor;
+
+//  in vec2 TexCoord;
+
+// texture samplers
+// uniform sampler2D texture1;
+// uniform sampler2D texture2;
+
+void main()
+{
+	// linearly interpolate between both textures (80% container, 20% awesomeface)
+	//FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
+}
+

5.1.transform.vert

@@ -0,0 +1,16 @@
+
+
+#version 330 core
+layout (location = 0) in vec3 aPos;
+// layout (location = 1) in vec2 aTexCoord;
+
+// out vec2 TexCoord;
+
+uniform mat4 transform;
+
+void main()
+{
+	gl_Position = transform * vec4(aPos, 1.0);
+	// TexCoord = vec2(aTexCoord.x, aTexCoord.y);
+}
+

6.3.coordinate_systems.frag

@@ -0,0 +1,15 @@
+
+
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+
+void main()
+{
+    FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
+}
+

6.3.coordinate_systems.vert

@@ -0,0 +1,18 @@
+
+
+#version 330 core
+layout (location = 0) in vec3 aPos;
+// layout (location = 1) in vec2 aTexCoord;
+
+// out vec2 TexCoord;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+
+void main()
+{
+    gl_Position = projection * view * model * vec4(aPos, 1.0);
+    // TexCoord = vec2(aTexCoord.x, 1.0 - aTexCoord.y);
+}
+

Cpp_Alias.hpp

@@ -12,6 +12,18 @@ This merely removes the need to use operators I don't like and wraps them in eas
 
 #pragma once
 
+#include <algorithm>
+#include <cstdarg>
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+
+
 // Macros
 
 #define sfn \
@@ -79,3 +91,12 @@ sfn Exit(ExitCode _code)
 {
 	exit(int(_code));
 }
+
+// Error Stuff
+
+sfn ErrorRuntime(const Ref(std::runtime_error) _error)
+{
+	std::cout << "Runtime error occurred: " << _error.what() << std::endl;
+
+	return;
+}

DGL.hpp

@@ -1,19 +1,18 @@
 #pragma once
 
-// C++ STL
-#include <iostream>
-#include <stdexcept>
-#include <vector>
-
 // GL
+//#include <gl/GLU.h>
 #include <glew.h>
 #include <glfw3.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
 
 #include "DGL_FundamentalTypes.hpp"
 #include "DGL_MiscTypes.hpp"
 #include "DGL_Enum.hpp"
 #include "DGL_Shader.hpp"
 #include "DGL_Buffers.hpp"
+#include "DGL_Space.hpp"
 
 // Non-Standard C++
 #include "Cpp_Alias.hpp"
@@ -45,18 +44,6 @@ namespace GL
 	WindowRefList Windows;
 
 
-
-	// Error Stuff
-
-	sfn ErrorRuntime(Ref(std::runtime_error) _error)
-	{
-		cout << "Runtime error occurred: " << _error.what() << endl;
-
-		return;
-	}
-
-
-
 	// Constants
 
 	sfn constexpr NotShared   () -> ptr<Window > { return NULL; }
@@ -64,15 +51,13 @@ namespace GL
 
 
 
+	// Forward Declares
+
+	sfn SwapBuffers(const ptr<Window> _window) -> void;
+
+
 	// Functionality
 
-	sfn SwapBuffers(const ptr<Window> _window) -> void
-	{
-		glfwSwapBuffers(_window);
-
-		return;
-	}
-
 	sfn CanClose(const ptr<Window> _theWindow)
 	{
 		return glfwWindowShouldClose(_theWindow);
@@ -124,6 +109,16 @@ namespace GL
 		return;
 	}
 
+	sfn DrawArrays(EPrimitives _primitive, gInt _startingIndex, gInt _numToRender)
+	{
+		glDrawArrays(GLenum(_primitive), _startingIndex, _numToRender);   // Starting from vertex 0; 3 vertices total -> 1 triangle.
+	}
+
+	sfn DrawElements(EPrimitives _primitive, gSize _numElements, EDataType _dataType, DataPtr _offfsetAddressFromFirstIndex)
+	{
+		glDrawElements(GLenum(_primitive), _numElements, GLenum(_dataType), _offfsetAddressFromFirstIndex);
+	}
+
 	sfn GetTime() -> TimeValDec
 	{
 		return glfwGetTime();
@@ -146,7 +141,7 @@ namespace GL
 				throw std::runtime_error("Failed to initialize GLFW");
 			}
 		}
-		catch (std::runtime_error _error)
+		catch (const std::runtime_error _error)
 		{
 			ErrorRuntime(_error);
 
@@ -177,7 +172,7 @@ namespace GL
 
 			cout << "OpenGL Version: " << glGetString(GL_VERSION) << endl;
 		}
-		catch (std::runtime_error _error)
+		catch (const std::runtime_error _error)
 		{
 			ErrorRuntime(_error);
 
@@ -197,7 +192,7 @@ namespace GL
 		/* Loop until the user closes the window */
 		while (not CanClose(_window))
 		{
-			ClearBuffer();
+			ClearBuffer(EFrameBuffer::Color);
 
 			SwapBuffers(_window);
 
@@ -217,7 +212,14 @@ namespace GL
 
 			if (deltaSinceClear > _interval)
 			{
-				ClearBuffer();
+
+				ClearBuffer(EFrameBuffer::Color, EFrameBuffer::Depth);
+				//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+				glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
+
+				//glMatrixMode(GL_MODELVIEW);
+
+				//glLoadIdentity();
 
 				_renderProcedure();
 
@@ -254,7 +256,7 @@ namespace GL
 				throw std::runtime_error( Dref(ErrorMsg) );
 			}
 		}
-		catch (std::runtime_error _error)
+		catch (const std::runtime_error _error)
 		{
 			ErrorRuntime(_error);
 
@@ -264,6 +266,18 @@ namespace GL
 		return;
 	}
 
+	sfn SetPolygonMode(EFace _desiredFaces, EMode _desiredMode)
+	{
+		glPolygonMode(GLenum(_desiredFaces), GLenum(_desiredMode));
+	}
+
+	sfn SwapBuffers(const ptr<Window> _window) -> void
+	{
+		glfwSwapBuffers(_window);
+
+		return;
+	}
+
 	sfn TerminateGLFW()
 	{
 		glfwTerminate();

DGL_Buffers.hpp

@@ -15,35 +15,46 @@
 
 namespace GL
 {
-	sfn ClearBuffer()
+	sfn BindBuffer(const EBufferTarget _targetType, const ID<Buffer> _buffer)
-	{
-		glClear(GL_COLOR_BUFFER_BIT);
-
-		return;
-	}
-
-	sfn BindBuffer(EBufferTarget _targetType, ID<Buffer> _buffer)
 	{
 		glBindBuffer(GLenum(_targetType), _buffer);
 
 		return;
 	}
 
-	sfn BindVertexArray(ptr<gUInt> _referenceToTrackArray)
+	sfn BindVertexArray(const gUInt _referenceToTrackArray)
 	{
-		glBindVertexArray(Dref(_referenceToTrackArray));
+		glBindVertexArray(_referenceToTrackArray);
 
 		return;
 	}
 
 	template<typename TypeOfData>
-	sfn BufferData(ptr<TypeOfData> _data, EBufferTarget _targetType, EBufferUsage _usageType)
+	sfn BufferData(ptr<TypeOfData> _data, const EBufferTarget _targetType, const EBufferUsage _usageType)
 	{
 		glBufferData(GLenum(_targetType), sizeof(TypeOfData), _data, GLenum(_usageType));
 
 		return;
 	}
 
+	template<typename... Type, typename = EFrameBuffer>
+	sfn ClearBuffer(const Type... _buffersToClear)
+	{
+		glClear((gBitfield(_buffersToClear) | ...));
+
+		return;
+	}
+
+	sfn DisableVertexAttributeArray(const gInt _vertexAttributeArrayIndex)
+	{
+		glDisableVertexAttribArray(_vertexAttributeArrayIndex);
+	}
+
+	sfn EnableVertexAttributeArray(const gInt _vertexAttributeArrayIndex)
+	{
+		glEnableVertexAttribArray(_vertexAttributeArrayIndex);
+	}
+
 	template<typename VertType>
 	sfn FormatVertexAttributes
 	(

DGL_Enum.hpp

@@ -46,6 +46,12 @@ namespace GL
 		StaticRead = GL_STATIC_READ
 	};
 
+	enum class ECompareMode
+	{
+		RefToTexture = GL_COMPARE_REF_TO_TEXTURE,
+		None         = GL_NONE
+	};
+
 	enum class EDataType
 	{
 		Byte          = GL_BYTE          ,
@@ -60,10 +66,47 @@ namespace GL
 		Double        = GL_DOUBLE
 	};
 
-	enum class EShaderType
+	enum class EFace
 	{
-		Vertex   = GL_VERTEX_SHADER  ,
+		Front = GL_FRONT,
-		Fragment = GL_FRAGMENT_SHADER
+		Back = GL_BACK,
+		Front_and_Back = GL_FRONT_AND_BACK
+	};
+
+	enum class EFrameBuffer
+	{
+		Accumulation = GL_ACCUM_BUFFER_BIT  ,
+		Color        = GL_COLOR_BUFFER_BIT  ,
+		Depth        = GL_DEPTH_BUFFER_BIT  ,
+		Stencil      = GL_STENCIL_BUFFER_BIT
+	};
+
+	enum class ELODBias
+	{
+		Max = GL_MAX_TEXTURE_LOD_BIAS
+	};
+
+	enum class EMaxFilter
+	{
+		Nearest = GL_NEAREST,
+		Linear  = GL_LINEAR
+	};
+
+	enum class EMinFilter
+	{
+		Nearest          = GL_NEAREST               ,
+		Linear           = GL_LINEAR                ,
+		NearestToNearest = GL_NEAREST_MIPMAP_NEAREST,
+		LinearToNearest  = GL_NEAREST_MIPMAP_LINEAR ,
+		NearestToLinear  = GL_NEAREST_MIPMAP_LINEAR ,
+		LinearToLinear   = GL_LINEAR_MIPMAP_LINEAR
+	};
+
+	enum class EMode
+	{
+		Point = GL_POINT,
+		Line  = GL_LINE ,
+		Fill  = GL_FILL
 	};
 
 	enum class EPrimitives
@@ -81,6 +124,119 @@ namespace GL
 		Quads      = GL_QUADS     ,
 		QuadsStrip = GL_QUAD_STRIP,
 
-		Patches = GL_PATCHES
+		Patches = GL_PATCHES,
+
+		Polygon = GL_POLYGON
+	};
+
+	enum class EShaderInfo
+	{
+		Type               = GL_SHADER_TYPE         ,
+		DeleteStatus       = GL_DELETE_STATUS       ,
+		CompileStatus      = GL_COMPILE_STATUS      ,
+		InfoLogLength      = GL_INFO_LOG_LENGTH     ,
+		ShaderSourceLength = GL_SHADER_SOURCE_LENGTH
+	};
+
+	enum class EShaderProgramInfo
+	{
+		DeleteStatus                 = GL_DELETE_STATUS                        ,
+		LinkStatus                   = GL_LINK_STATUS                          ,
+		ValidateStatus               = GL_VALIDATE_STATUS                      ,
+		InfoLogLength                = GL_INFO_LOG_LENGTH                      ,
+		AttachedShaders              = GL_ATTACHED_SHADERS                     ,
+		ActiveAttributes             = GL_ACTIVE_ATTRIBUTES                    ,
+		ActiveAttributesMaxLength    = GL_ACTIVE_ATTRIBUTE_MAX_LENGTH          ,
+		ActiveUniforms               = GL_ACTIVE_UNIFORMS                      ,
+		TransformFeedbackActive      = GL_TRANSFORM_FEEDBACK_BUFFER_MODE       ,
+		TransformFeedbackVaryings    = GL_TRANSFORM_FEEDBACK_VARYING           ,
+		TransformFeedbackVaryingsMax = GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,
+		ShaderVerticiesMax           = GL_GEOMETRY_VERTICES_OUT                ,
+		GeometryInputType            = GL_GEOMETRY_INPUT_TYPE                  ,
+		GeometryOutputType           = GL_GEOMETRY_OUTPUT_TYPE
+	};
+
+	enum class EShaderType
+	{
+		Vertex   = GL_VERTEX_SHADER  ,
+		Fragment = GL_FRAGMENT_SHADER
+	};
+
+	enum class EStencilMode
+	{
+		DepthComponent = GL_DEPTH_COMPONENT,
+		StencilIndex   = GL_STENCIL_INDEX  
+	};
+
+	enum class ESWIZZLE
+	{
+		Red   = GL_RED  ,
+		Green = GL_GREEN,
+		Blue  = GL_BLUE ,
+		Alpha = GL_ALPHA,
+		Zero  = GL_ZERO ,
+		One   = GL_ONE
+	};
+
+	enum class ETexCompareFuncs
+	{
+		LessOrEqual    = GL_LEQUAL  ,
+		GreaterOrEqual = GL_GEQUAL  ,
+		Less           = GL_LESS    ,
+		Greater        = GL_GREATER ,
+		Equal          = GL_EQUAL   ,
+		NotEqual       = GL_NOTEQUAL,
+		Always         = GL_ALWAYS  ,
+		Never          = GL_NEVER
+	};
+
+	enum class ETextureMode
+	{
+		DepthStencil        = GL_DEPTH_STENCIL_TEXTURE_MODE, 
+		MipmapLowest        = GL_TEXTURE_BASE_LEVEL        , 
+		ComparisonOperator  = GL_TEXTURE_COMPARE_FUNC      , 
+		Comparision         = GL_TEXTURE_COMPARE_MODE      , 
+		LevelOfDetailBias   = GL_TEXTURE_LOD_BIAS          , 
+		MinimizingFilter    = GL_TEXTURE_MIN_FILTER        , 
+		MagnificationFilter = GL_TEXTURE_MAG_FILTER        , 
+		MinimumLOD          = GL_TEXTURE_MIN_LOD           , 
+		MaximumLOD          = GL_TEXTURE_MAX_LOD           , 
+		MipmapMax           = GL_TEXTURE_MAX_LEVEL         , 
+		Swizzle_R           = GL_TEXTURE_SWIZZLE_R         , 
+		Swizzle_G           = GL_TEXTURE_SWIZZLE_G         , 
+		Swizzle_B           = GL_TEXTURE_SWIZZLE_B         , 
+		Swizzle_A           = GL_TEXTURE_SWIZZLE_A         , 
+		Swizzle_RGBA        = GL_TEXTURE_SWIZZLE_RGBA      ,
+		Wrap_S              = GL_TEXTURE_WRAP_S            , 
+		Wrap_T              = GL_TEXTURE_WRAP_T            , 
+		Wrap_R              = GL_TEXTURE_WRAP_R
+	};
+
+	enum class ETextureType
+	{
+		_1D = GL_TEXTURE_1D,
+		_2D = GL_TEXTURE_2D,
+		_3D = GL_TEXTURE_3D,
+
+		Rectangle = GL_TEXTURE_RECTANGLE,
+		Buffer    = GL_TEXTURE_BUFFER   ,
+		
+		CubeMap      = GL_TEXTURE_CUBE_MAP      ,	 
+		CubeMapArray = GL_TEXTURE_CUBE_MAP_ARRAY,
+		
+		Array1D = GL_TEXTURE_1D_ARRAY,
+		Array2D = GL_TEXTURE_2D_ARRAY,
+		
+		Multisample   = GL_TEXTURE_2D_MULTISAMPLE      ,
+		Multisample2D = GL_TEXTURE_2D_MULTISAMPLE_ARRAY
+	};
+
+	enum class EWrap
+	{
+		ClampToEdge       = GL_CLAMP_TO_EDGE       ,
+		ClampToBorder     = GL_CLAMP_TO_BORDER     ,
+		MirroredRepeat    = GL_MIRRORED_REPEAT     ,
+		Repeat            = GL_REPEAT              ,
+		MirrorClampToEdge = GL_MIRROR_CLAMP_TO_EDGE
 	};
 }

DGL_FundamentalTypes.hpp

@@ -10,6 +10,7 @@ namespace GL
 	// Fundamental Types
 
 	using gChar     = GLchar    ;
+	using gBitfield = GLbitfield;
 	using gFloat    = GLfloat   ;
 	using gInt      = GLint     ;
 	using gUInt     = GLuint    ;

DGL_MiscTypes.hpp

@@ -2,6 +2,8 @@
 
 // OpenGL
 #include <glew.h>
+#include <glm/detail/type_vec3.hpp>
+
 
 // Duck Tape
 #include "DGL_FundamentalTypes.hpp"
@@ -13,7 +15,13 @@
 
 namespace GL
 {
-	// Made up types.
+	namespace Generic
+	{
+		template<typename Type>
+		using Vector3 = glm::tvec3<Type>;
+	}
+
+	using DataPtr = ptr<GLvoid>;
 
 	template<typename ReferenceType>
 	using ID = gUInt;
@@ -21,9 +29,14 @@ namespace GL
 	// ID Reference Types
 
 	class Buffer;
+	class Matrix;
 	class Shader;
 	class ShaderProgram;
+	class VertexBuffer;
+	class ElementBuffer;
 
-	using DataPtr      = ptr<GLvoid>;
+	using Matrix4x4 = glm::mat4;
-	using VertexBuffer = gUInt      ;
+
+	using Vector3 = glm::vec3;
+	using Vector4 = glm::vec4;
 }

DGL_Primitive.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "DGL_Space.hpp"
+
+
+
+
+namespace GL
+{
+
+	struct Primitive
+	{
+	};
+}

DGL_Shader.hpp

@@ -1,12 +1,10 @@
 #pragma once
 
-// C++
-#include <cstdarg>
-
 //DGL
 #include "DGL_FundamentalTypes.hpp"
 #include "DGL_MiscTypes.hpp"
 #include "DGL_Enum.hpp"
+#include "DGL_Space.hpp"
 
 
 
@@ -36,8 +34,48 @@ namespace GL
 		"}";
 
 
+	// Default Shaders
+
+	ID<ShaderProgram> RawShader               ,
+		              SimpleShader            ,
+		              SimpleShader_Transformed ;
+
+	ID<CoordSpace> ScreenSpaceVarID;
+
+
+	// Forward Declarations
+
+	sfn GetShaderInfo(ID<Shader> _shader       , gSize       _logLength        , ptr<gSize> _infoLengthRef      , RawString<gChar> _infoLogRef) -> void;
+	sfn QueryShader  (ID<Shader> _shaderToQuery, EShaderInfo _shaderInfoDesired, ptr<gInt > _requestedInfoObject                              ) -> void;
+	sfn MakeShader(Ref(ID<Shader>) _shaderIDHolder, EShaderType _typeOfShader, uInt64 _numberOfStringElements, ptr<RawString<const gChar>> _sourceCode, ptr<const gInt> _lengthsOfStrings) -> void;
+	sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, const ID<Shader> _vertexShader, const ID<Shader> _fragShader) -> void;
+
+
+
 	// Functions
 
+	sfn ActiveUniforms(ID<Shader> _shaderToQueryForUniforms) -> GLint
+	{
+		GLint uniforms;
+
+		glGetProgramiv(_shaderToQueryForUniforms, GL_ACTIVE_UNIFORMS, &uniforms);
+
+		for (int i = 0; i < uniforms; i++)
+		{
+			int name_len = -1, num = -1;
+
+			GLenum type = GL_ZERO;
+
+			char name[100];
+
+			glGetActiveUniform(_shaderToQueryForUniforms, GLuint(i), sizeof(name) - 1, &name_len, &num, &type, name);
+
+			name[name_len] = 0;
+		}
+
+		return uniforms;
+	}
+
 	sfn AttachShader(ID<ShaderProgram> _shaderProgram, ID<Shader> _shaderToAttach)
 	{
 		glAttachShader(_shaderProgram, _shaderToAttach);
@@ -52,10 +90,34 @@ namespace GL
 		return;
 	}
 
-	sfn CompileShader(ID<Shader> _shaderToCompile)
+	sfn CompileShader(const ID<Shader> _shaderToCompile)
 	{
 		glCompileShader(_shaderToCompile);
 
+		gInt Result = gInt(EBool::False);
+
+		gSize InfoLogLength;
+
+		QueryShader(_shaderToCompile, EShaderInfo::CompileStatus, Address(Result));
+
+		if (!Result)
+		{
+			QueryShader(_shaderToCompile, EShaderInfo::InfoLogLength, Address(InfoLogLength));
+
+			if (InfoLogLength > 0)
+			{
+				std::vector<char> ErrorMessage(InfoLogLength + 1);
+
+				GetShaderInfo(_shaderToCompile, InfoLogLength, nullptr, Address(ErrorMessage.at(0)));
+
+				throw std::runtime_error(Address(ErrorMessage.at(0)));
+			}
+			else
+			{
+				throw std::runtime_error("Shader compilation failed and did not get a proper info log.");
+			}
+		}
+
 		return;
 	}
 
@@ -76,6 +138,30 @@ namespace GL
 		return;
 	}
 
+	sfn DetachShader(ID<ShaderProgram> _shaderProgram, ID<Shader> _shaderToDetach)
+	{
+		glDetachShader(_shaderProgram, _shaderToDetach);
+
+		return;
+	}
+
+	sfn GetShaderInfo(ID<Shader> _shader, gSize _logLength, ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void
+	{
+		glGetShaderInfoLog(_shader, _logLength, _infoLengthRef, _infoLogRef);
+
+		return;
+	}
+
+	sfn GetShaderProgramInfo(ID<ShaderProgram> _shaderProgram, gSize _logLength, ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void
+	{
+		glGetProgramInfoLog(_shaderProgram, _logLength, _infoLengthRef, _infoLogRef);
+	}
+
+	sfn GetUniformVariable(const ID<ShaderProgram> _programID, RawString<const char> _nameOfVariable) -> ID<Matrix>
+	{
+		return glGetUniformLocation(_programID, _nameOfVariable);
+	}
+
 	sfn LinkProgramShader(ID<ShaderProgram> _shaderProgramToLink)
 	{
 		glLinkProgram(_shaderProgramToLink);
@@ -83,15 +169,127 @@ namespace GL
 		return;
 	}
 
-	sfn UseProgramShader(ID<ShaderProgram> _shaderProgramToUse)
+	sfn QueryShader(ID<Shader> _shaderToQuery, EShaderInfo _shaderInfoDesired, ptr<gInt> _requestedInfoObject) -> void
 	{
-		glUseProgram(_shaderProgramToUse);
+		glGetShaderiv(_shaderToQuery, GLenum(_shaderInfoDesired), _requestedInfoObject);
+	}
 
-		return;
+	sfn QueryShaderProgram(ID<ShaderProgram> _shaderToQuery, EShaderProgramInfo _shaderProgramInfoDesired, ptr<gInt> _requestedInfoObject) -> void
+	{
+		glGetProgramiv(_shaderToQuery, GLenum(_shaderProgramInfoDesired), _requestedInfoObject);
+	}
+
+	sfn LoadShaders(RawString<const char> _vertexShaderFilePath, RawString<const char> _fragmentShaderFilePath) -> ID<ShaderProgram>
+	{
+		using std::cout        ;
+		using std::endl        ;
+		using std::ifstream    ;
+		using std::ios         ;
+		using std::string      ;
+		using std::stringstream;
+		using std::vector      ;
+
+
+		string   vertexShaderCode        ;
+		string   fragmentShaderCode      ;
+
+		ifstream vertexShaderFileStream  ;
+		ifstream fragmentShaderFileStream;
+
+		vertexShaderFileStream  .open(_vertexShaderFilePath);
+		fragmentShaderFileStream.open(_fragmentShaderFilePath);
+
+		try
+		{
+			if (vertexShaderFileStream.is_open() and fragmentShaderFileStream.is_open())
+			{
+				stringstream vertSourceStrStream;
+				stringstream fragSourceStrStream;
+
+				vertSourceStrStream << vertexShaderFileStream  .rdbuf();
+				fragSourceStrStream << fragmentShaderFileStream.rdbuf();
+
+				vertexShaderFileStream  .close();
+				fragmentShaderFileStream.close();
+
+				vertexShaderCode   = vertSourceStrStream.str();
+				fragmentShaderCode = fragSourceStrStream.str();
+			}
+			else
+			{
+				throw std::runtime_error("Impossible to open% s.Are you in the right directory ? Don't forget to read the FAQ !");
 			}
 
 
-	// Raw Tape
+			RawString<const char> vertexSourcePtr   = vertexShaderCode  .c_str();
+			RawString<const char> fragmentSourcePtr = fragmentShaderCode.c_str();
+
+			cout << "Compiling shader: " << _vertexShaderFilePath << endl;
+
+			ID<Shader> vertexShader = CreateShader(EShaderType::Vertex);
+
+			BindShaderSource(vertexShader, 1, Address(vertexSourcePtr), NULL);
+			CompileShader   (vertexShader                                   );
+
+			cout << "Compiling shader: " << _fragmentShaderFilePath << endl;
+
+			ID<Shader> fragmentShader = CreateShader(EShaderType::Fragment);
+
+			BindShaderSource(fragmentShader, 1, Address(fragmentSourcePtr), NULL);
+			CompileShader   (fragmentShader                                     );
+
+			
+			cout << "Making Shader Program and Linking..." << endl;
+
+			ID<ShaderProgram> generatedProgram;
+
+			MakeShaderProgram(generatedProgram, vertexShader, fragmentShader);
+
+			DeleteShader(vertexShader  );
+			DeleteShader(fragmentShader);
+
+			return generatedProgram;
+		}
+		catch (const std::runtime_error _error)
+		{
+			ErrorRuntime(_error);
+
+			Exit(ExitCode::Failed);
+		}
+	}
+
+	sfn LoadRawShader()
+	{
+		ID<Shader> VertexShader  ;
+		ID<Shader> FragmentShader;
+
+		MakeShader(VertexShader  , EShaderType::Vertex  , 1, Address(GL::RawVertextShaderSource ), NULL);
+		MakeShader(FragmentShader, EShaderType::Fragment, 1, Address(GL::RawFragmentShaderSource), NULL);
+
+		GL::MakeShaderProgram(RawShader, VertexShader, FragmentShader);
+
+		GL::DeleteShader(VertexShader  );
+		GL::DeleteShader(FragmentShader);
+	}
+
+	sfn LoadSimpleShader()
+	{
+		SimpleShader = LoadShaders("SimpleVertexShader.vert", "SimpleFragmentShader.frag");
+	}
+
+	sfn LoadSimpleShader_Transformed()
+	{
+		SimpleShader_Transformed = LoadShaders("SimpleTransform.vert", "SingleColor.frag");
+
+		ScreenSpaceVarID = GL::GetUniformVariable(GL::SimpleShader_Transformed, "modelViewProjection");
+	}
+
+	sfn LoadDefaultShaders()
+	{
+		LoadRawShader               ();
+		LoadSimpleShader            ();
+		LoadSimpleShader_Transformed();
+	}
 
 	sfn MakeShader
 	(
@@ -101,6 +299,7 @@ namespace GL
 		ptr<RawString<const gChar>> _sourceCode            ,
 		ptr<          const gInt  > _lengthsOfStrings
 	)
+		-> void
 	{
 		_shaderIDHolder = CreateShader(_typeOfShader);
 
@@ -109,18 +308,54 @@ namespace GL
 		CompileShader(_shaderIDHolder);
 	}
 
-	sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, ID<Shader> _shadersToAttach...)
+	sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, const ID<Shader> _vertexShader, const ID<Shader> _fragShader) -> void
 	{
 		_shaderProgramIDHolder = CreateShaderProgram();
 
-		va_list args;
+		AttachShader(_shaderProgramIDHolder, _vertexShader);
-
+		AttachShader(_shaderProgramIDHolder, _fragShader  );
-		va_start(args, _shadersToAttach);
-
-		AttachShader(_shaderProgramIDHolder, va_arg(args, ID<Shader>));
-
-		va_end(args);
 
 		LinkProgramShader(_shaderProgramIDHolder);
+
+		gInt Result = false;
+
+		QueryShaderProgram(_shaderProgramIDHolder, EShaderProgramInfo::LinkStatus, Address(Result));
+
+		if (!Result)
+		{
+			gInt infoLogLength;
+
+			QueryShaderProgram(_shaderProgramIDHolder, EShaderProgramInfo::InfoLogLength, Address(infoLogLength));
+
+			if (infoLogLength > 0)
+			{
+				std::vector<char> ErrorMessage(infoLogLength + 1);
+
+				GetShaderProgramInfo(_shaderProgramIDHolder, infoLogLength, NULL, Address(ErrorMessage.at(0)));
+
+				throw std::runtime_error(Address(ErrorMessage.at(0)));
+			}
+			else
+			{
+				throw std::runtime_error("ShaderProgram compilation failed and did not get a proper info log.");
+			}
+		}
+
+		DetachShader(_shaderProgramIDHolder, _vertexShader);
+		DetachShader(_shaderProgramIDHolder, _fragShader  );
+
+		return;
+	}
+
+	sfn SetUniformVariable_MatrixVariableArray(const ID<Matrix> _matrixID, const gSize _numMatricies, const EBool _shouldTransposeValues, ptr<const float> _dataPtr)
+	{
+		glUniformMatrix4fv(_matrixID, _numMatricies, GLenum(_shouldTransposeValues), _dataPtr);
+	}
+
+	sfn UseProgramShader(ID<ShaderProgram> _shaderProgramToUse)
+	{
+		glUseProgram(_shaderProgramToUse);
+
+		return;
 	}
 }

DGL_Space.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+
+#include "DGL_FundamentalTypes.hpp"
+#include "DGL_MiscTypes.hpp"
+
+
+
+#include "Cpp_Alias.hpp"
+
+
+
+namespace GL
+{
+	using CoordSpace = Matrix4x4;
+	using Projection = Matrix4x4;
+
+
+	// Function
+
+	template<typename Type>
+	sfn CreateLookAtView(const Generic::Vector3<Type> _viewPosition, const Generic::Vector3<Type> _lookAtPosition, const Generic::Vector3<Type> _upDirection) -> Matrix4x4
+	{
+		return glm::lookAt(_viewPosition, _lookAtPosition, _upDirection);
+	}
+
+	sfn CreateOrthographic(gFloat _leftScreenCoord, gFloat _rightScreenCoord, gFloat _bottomScreenCoord, gFloat _topScreenCoord, gFloat _nearPlane, gFloat _farPlane)
+	{
+		return glm::ortho(_leftScreenCoord, _rightScreenCoord, _bottomScreenCoord, _topScreenCoord, _nearPlane, _farPlane);
+	}
+
+	template<typename FloatType>
+	sfn CreatePerspective(const FloatType _fieldOfView, const FloatType _aspectRatio, const FloatType _nearPlane, const FloatType _farPlane)
+	{
+		return glm::perspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane);
+	}
+
+	sfn Rotate(const Matrix4x4 _matrix, gFloat _rotationAngleAmount, Vector3 _axis) -> Matrix4x4
+	{
+		return glm::rotate(_matrix, _rotationAngleAmount, _axis);
+	}
+
+	template<typename Type>
+	sfn ToRadians(const Ref(Type) _degrees) -> Type
+	{
+		return glm::radians(_degrees);
+	}
+
+	struct ClippingPlanes
+	{
+		gFloat Near, Far;
+
+		ClippingPlanes(gFloat _near, gFloat _far) : Near(_near), Far(_far) {};
+	};
+
+	namespace DefaultSpace
+	{
+		gFloat 
+			   AspectRatio       = 16.0f / 10.0f,
+			   FieldOfView       = 90.0f        ,
+			   NearClippingPlane = 0.1f         ,
+			   FarClippingPlane  = 100.0f        ;
+
+		Vector3 CameraPosition(-3, 0, 0),
+			    LookAtPosition( 0, 0, 0),
+			    UpDirection   ( 0, 1, 0) ;
+
+		gFloat ScreenWidth = 720.0f, ScreenHeight = 450.0f;
+	}
+
+	struct Camera
+	{
+		gFloat AspectRatio, FieldOfView;
+
+		ClippingPlanes ClipSpace;
+
+		CoordSpace ViewPort;
+
+		Projection Orthographic, Perspective;
+
+		Vector3 Position, LookAtPosition, UpDirection;
+
+
+		Camera
+		(
+			gFloat         _aspectRatio   ,
+			gFloat         _fieldOfView   ,
+			ClippingPlanes _clippingPlanes,
+			Vector3        _position      ,
+			Vector3        _lookAtPosition,
+			Vector3        _upDirection
+		) :
+			AspectRatio   (_aspectRatio   ),
+			FieldOfView   (_fieldOfView   ),
+			ClipSpace     (_clippingPlanes),
+			Position      (_position      ),
+			LookAtPosition(_lookAtPosition),
+			UpDirection   (_upDirection   )
+		{
+			ViewPort = CreateLookAtView(Position, LookAtPosition, UpDirection);
+
+			Orthographic = CreateOrthographic(0.0f, DefaultSpace::ScreenWidth, 0.0f, DefaultSpace::ScreenHeight, ClipSpace.Near, ClipSpace.Far);
+
+			Perspective = CreatePerspective<gFloat>(ToRadians(FieldOfView), AspectRatio, ClipSpace.Near, ClipSpace.Far);
+		}
+	};
+
+	namespace DefaultSpace
+	{
+		Camera WorldCamera(AspectRatio, FieldOfView, ClippingPlanes(NearClippingPlane, FarClippingPlane), CameraPosition, LookAtPosition, UpDirection);
+
+		CoordSpace WorldSpace(Matrix4x4(1.0f));
+
+		CoordSpace Screenspace = WorldCamera.Perspective * WorldCamera.ViewPort * WorldSpace;
+	}
+}

DGL_Variable.hpp

@@ -0,0 +1 @@
+#pragma once

Execution.cpp

@@ -0,0 +1,183 @@
+// Cpp STL
+#include <chrono>
+#include <thread>
+#include <memory>
+
+
+
+// Project
+#include "DGL.hpp"
+#include "TriangleRaw.hpp"
+
+#include "Cpp_Alias.hpp"
+
+
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+
+namespace Execution
+{
+	// C++ STL
+
+	using std::thread;
+	
+	template<typename Type>
+	using UPtr = std::unique_ptr<Type>;
+
+	template<typename Type, typename... ParamTypes>
+	sfn MakeUPtr(rRef(ParamTypes)... _params) -> UPtr<Type>
+	{
+		return std::make_unique<Type>(_params...);
+	}
+
+
+
+	// GL
+
+	using GL::TimeValDec;
+	using GL::Window    ;
+	using GL::Matrix    ;
+	using GL::Matrix4x4 ;
+	using GL::Vector3   ;
+	using GL::gFloat    ;
+
+
+	bool Exist = true;
+
+	TimeValDec CycleStart, CycleEnd, DeltaTime, InputPollingInterval = 1.0f / 240.0f, RenderInterval = 1.0f / 60.0f;
+
+	UPtr<thread> BasicLoop, BasicTimedLoop;
+
+
+
+	// Testing
+
+	// Foward Declares
+
+	sfn RenderProcedure     () -> void;
+	sfn PrepareRenderObjects() -> void;
+
+	sfn CreateWindow_BasicLoop()
+	{
+		GL::InitalizeGLFW();
+
+		deduce windowObj = GL::CreateWindow(720, 450, "Assignment 1: RawLoop", GL::WindowedMode(), GL::NotShared());
+
+		GL::SetCurrentContext(windowObj);
+
+		GL::RunBasicWindowLoop(windowObj);
+	}
+
+	sfn CreateWindow_TimedRender()
+	{
+		GL::InitalizeGLFW();
+
+		deduce windowObj = GL::CreateWindow(720, 540, "Assignment 1: Timed Render", GL::WindowedMode(), GL::NotShared());
+
+		GL::SetCurrentContext(windowObj);
+
+		GL::InitalizeGLEW();
+
+		PrepareRenderObjects();
+
+		GL::RunBasicWindowLoop_Timed(windowObj, 1.0 / 60.0, Address(RenderProcedure));
+	}
+
+	sfn PrepareRenderObjects() -> void
+	{
+		RAW_SetupBuffers();
+
+		RAW_BindAndBufferDataToIDs();
+
+		GL::LoadDefaultShaders();
+
+		GL::FormatVertexAttributes<Vertex3>(VertexAttributeIndex, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::True);
+
+		GL::BindBuffer(EBufferTarget::VertexAttributes, 0);   // Dunno. Prob unbinding...
+
+		GL::BindVertexArray(0);
+	}
+
+	sfn Cycler(FnPtr<void> _inputProcedure, FnPtr<void> _renderProcedure)
+	{
+		while (Exist)
+		{
+			CycleStart = GL::GetTime();
+
+			if (DeltaTime >= InputPollingInterval)
+			{
+				GL::PollEvents();
+
+				_inputProcedure();
+			}
+
+			if (DeltaTime >= RenderInterval)
+			{
+				_renderProcedure();
+			}
+
+			CycleEnd = GL::GetTime();
+
+			DeltaTime = DeltaTime + CycleEnd - CycleStart;
+		}
+
+		return;
+	}
+
+	sfn InputProcedure()
+	{
+
+	}
+
+	sfn RenderProcedure() -> void
+	{
+		GL::EnableVertexAttributeArray(VertexAttributeIndex);
+
+		GL::SetPolygonMode(GL::EFace::Front_and_Back, GL::EMode::Fill);
+
+		GL::DefaultSpace::WorldSpace = GL::Rotate(GL::DefaultSpace::WorldSpace, 0.0035f, Vector3(0.0f, 0.5f, 0.0f));
+
+		GL::DefaultSpace::Screenspace = GL::DefaultSpace::WorldCamera.Perspective * GL::DefaultSpace::WorldCamera.ViewPort * GL::DefaultSpace::WorldSpace;
+
+		GL::UseProgramShader(GL::SimpleShader_Transformed);
+
+		GL::SetUniformVariable_MatrixVariableArray(GL::ScreenSpaceVarID, 1, GL::EBool::False, Address(GL::DefaultSpace::Screenspace[0][0]));
+
+		GL::BindVertexArray(VertexArrayObj);
+
+		GL::DrawArrays(GL::EPrimitives::Triangles, 0, TriangleRaw::VertexCount());
+
+		GL::DisableVertexAttributeArray(VertexAttributeIndex);
+	}
+
+	sfn PrepWorkspace()
+	{
+
+	}
+
+
+	// Runtime Execution: Loop must be specified here to use.
+
+	sfn Execute() -> ExitCode
+	{
+		/*PrepWorkspace();*/
+
+		//Cycler(Address(InputProcedure), Address(RenderProcedure));
+
+		CreateWindow_TimedRender();
+
+		GL::TerminateGLFW();
+
+		return ExitCode::Success;
+	}
+}
+
+
+
+int main(void)
+{
+	return int(Execution::Execute());
+}
+

ShaderFromTut.hpp

@@ -0,0 +1,203 @@
+
+
+#ifndef SHADER_H
+#define SHADER_H
+
+//#include <glad/glad.h>
+#include <glew.h>
+#include <glm/glm.hpp>
+#include "DGL.hpp"
+
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+class Shader
+{
+public:
+	unsigned int ID;
+	// constructor generates the shader on the fly
+	// ------------------------------------------------------------------------
+	Shader(const char* vertexPath, const char* fragmentPath, const char* geometryPath = nullptr)
+	{
+		// 1. retrieve the vertex/fragment source code from filePath
+		std::string vertexCode;
+		std::string fragmentCode;
+		std::string geometryCode;
+		std::ifstream vShaderFile;
+		std::ifstream fShaderFile;
+		std::ifstream gShaderFile;
+		// ensure ifstream objects can throw exceptions:
+		vShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+		fShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+		gShaderFile.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+		try
+		{
+			// open files
+			vShaderFile.open(vertexPath);
+			fShaderFile.open(fragmentPath);
+			std::stringstream vShaderStream, fShaderStream;
+			// read file's buffer contents into streams
+			vShaderStream << vShaderFile.rdbuf();
+			fShaderStream << fShaderFile.rdbuf();
+			// close file handlers
+			vShaderFile.close();
+			fShaderFile.close();
+			// convert stream into string
+			vertexCode = vShaderStream.str();
+			fragmentCode = fShaderStream.str();
+			// if geometry shader path is present, also load a geometry shader
+			if (geometryPath != nullptr)
+			{
+				gShaderFile.open(geometryPath);
+				std::stringstream gShaderStream;
+				gShaderStream << gShaderFile.rdbuf();
+				gShaderFile.close();
+				geometryCode = gShaderStream.str();
+			}
+		}
+		catch (std::ifstream::failure e)
+		{
+			std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
+		}
+		const char* vShaderCode = vertexCode.c_str();
+		const char* fShaderCode = fragmentCode.c_str();
+		// 2. compile shaders
+		unsigned int vertex, fragment;
+		// vertex shader
+
+
+		vertex = glCreateShader(GL_VERTEX_SHADER);
+		glShaderSource(vertex, 1, &vShaderCode, NULL);
+		glCompileShader(vertex);
+		checkCompileErrors(vertex, "VERTEX");
+		// fragment Shader
+		fragment = glCreateShader(GL_FRAGMENT_SHADER);
+		glShaderSource(fragment, 1, &fShaderCode, NULL);
+		glCompileShader(fragment);
+		checkCompileErrors(fragment, "FRAGMENT");
+		// if geometry shader is given, compile geometry shader
+		unsigned int geometry;
+		if (geometryPath != nullptr)
+		{
+			const char* gShaderCode = geometryCode.c_str();
+			geometry = glCreateShader(GL_GEOMETRY_SHADER);
+			glShaderSource(geometry, 1, &gShaderCode, NULL);
+			glCompileShader(geometry);
+			checkCompileErrors(geometry, "GEOMETRY");
+		}
+
+		GL::MakeShaderProgram(ID, vertex, fragment);
+
+		// shader Program
+	/*	ID = glCreateProgram();
+		glAttachShader(ID, vertex);
+		glAttachShader(ID, fragment);
+		if (geometryPath != nullptr)
+			glAttachShader(ID, geometry);
+		glLinkProgram(ID);*/
+		checkCompileErrors(ID, "PROGRAM");
+		// delete the shaders as they're linked into our program now and no longer necessery
+		glDeleteShader(vertex);
+		glDeleteShader(fragment);
+		if (geometryPath != nullptr)
+			glDeleteShader(geometry);
+
+	}
+	// activate the shader
+	// ------------------------------------------------------------------------
+	void use()
+	{
+		glUseProgram(ID);
+	}
+	// utility uniform functions
+	// ------------------------------------------------------------------------
+	void setBool(const std::string& name, bool value) const
+	{
+		glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
+	}
+	// ------------------------------------------------------------------------
+	void setInt(const std::string& name, int value) const
+	{
+		glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
+	}
+	// ------------------------------------------------------------------------
+	void setFloat(const std::string& name, float value) const
+	{
+		glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
+	}
+	// ------------------------------------------------------------------------
+	void setVec2(const std::string& name, const glm::vec2& value) const
+	{
+		glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
+	}
+	void setVec2(const std::string& name, float x, float y) const
+	{
+		glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
+	}
+	// ------------------------------------------------------------------------
+	void setVec3(const std::string& name, const glm::vec3& value) const
+	{
+		glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
+	}
+	void setVec3(const std::string& name, float x, float y, float z) const
+	{
+		glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
+	}
+	// ------------------------------------------------------------------------
+	void setVec4(const std::string& name, const glm::vec4& value) const
+	{
+		glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
+	}
+	void setVec4(const std::string& name, float x, float y, float z, float w)
+	{
+		glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
+	}
+	// ------------------------------------------------------------------------
+	void setMat2(const std::string& name, const glm::mat2& mat) const
+	{
+		glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+	}
+	// ------------------------------------------------------------------------
+	void setMat3(const std::string& name, const glm::mat3& mat) const
+	{
+		glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+	}
+	// ------------------------------------------------------------------------
+	void setMat4(const std::string& name, const glm::mat4& mat) const
+	{
+		deduce bullshit = glGetUniformLocation(ID, name.c_str());
+
+		glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+	}
+
+private:
+	// utility function for checking shader compilation/linking errors.
+	// ------------------------------------------------------------------------
+	void checkCompileErrors(GLuint shader, std::string type)
+	{
+		GLint success;
+		GLchar infoLog[1024];
+		if (type != "PROGRAM")
+		{
+			glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+			if (!success)
+			{
+				glGetShaderInfoLog(shader, 1024, NULL, infoLog);
+				std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
+			}
+		}
+		else
+		{
+			glGetProgramiv(shader, GL_LINK_STATUS, &success);
+			if (!success)
+			{
+				glGetProgramInfoLog(shader, 1024, NULL, infoLog);
+				std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
+			}
+		}
+	}
+};
+#endif
+

SimpleFragmentShader.frag

@@ -0,0 +1,12 @@
+#version 330 core
+
+
+
+out vec3 color;
+
+
+
+void main()
+{
+	color = vec3(0.345, 0.345, 1);
+}

SimpleTransform.vert

@@ -0,0 +1,15 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;   
+
+// uniform mat4 model;
+// uniform mat4 view;
+// uniform mat4 projection;
+
+uniform mat4 modelViewProjection;
+
+void main()
+{
+    //gl_Position = projection * view * model * vec4(aPos, 1.0);
+
+    gl_Position = modelViewProjection * vec4(aPos, 1.0);
+}

SimpleVertexShader.vert

@@ -0,0 +1,13 @@
+#version 330 core
+
+
+
+layout (location = 0) in vec3 vertexPosition_modelSpace;
+
+
+
+void main()
+{
+	gl_Position.xyz = vertexPosition_modelSpace;
+	gl_Position.w   = 1.0                      ;
+}

SingleColor.frag

@@ -0,0 +1,12 @@
+#version 330 core
+
+// Output data
+out vec3 color;
+
+void main()
+{
+
+	// Output color = red 
+	color = vec3(1,0,0);
+
+}

TriangleRaw.hpp

@@ -0,0 +1,160 @@
+#pragma once
+
+#include "DGL.hpp"
+
+#include "Cpp_Alias.hpp"
+
+
+
+using GL::gFloat;
+using GL::VertexBuffer;
+using GL::EBufferTarget;
+using GL::EBufferUsage;
+using GL::Buffer;
+using GL::ID;
+using GL::gInt;
+using GL::gSize;
+
+
+
+// This will identify our vertex buffer
+ID<Buffer> VertexBufferObj;
+
+struct Vertex3
+{
+	gFloat x, y, z;
+
+	static constexpr sfn ValueCount() -> gSize { return 3; }
+};
+
+struct TriangleRaw
+{
+	Vertex3 a, b, c;
+
+	static constexpr sfn VertexCount() -> gSize { return 3; }
+};
+
+
+TriangleRaw EquilateralTriangleVerticies = 
+{ 
+	{ -1.0f, -1.0f, 0.0f }, 
+	{  1.0f, -1.0f, 0.0f }, 
+	{  0.0f,  1.0f, 0.0f } 
+};
+
+
+struct RectangleRaw
+{
+	TriangleRaw first, second;
+
+	static constexpr sfn VertexCount() -> gSize { return 6;  }
+};
+
+
+RectangleRaw SquareVerticies =
+{
+	{
+		{ -0.5f, -0.5f, 0.0f },
+		{  0.5f, -0.5f, 0.0f },
+		{  0.0f,  0.5f, 0.0f }
+	},
+	{
+		{   0.5f, -0.5f, 0.0f },
+		{  -0.5f, -0.5f, 0.0f },
+		{  -0.5f,  0.5f, 0.0f }
+	}
+};
+
+ID<VertexBuffer> VertexArrayObj;
+
+struct RectangleCompressed
+{
+	Vertex3 a, b, c, d;
+
+	static constexpr sfn VertexCount() -> gSize { return 4; }
+};
+
+struct TriIndex
+{
+	gInt a, b, c;
+};
+
+struct RectangleIndices
+{
+	TriIndex first, second;
+};
+
+
+RectangleCompressed rectCompress =
+{
+	{  0.5f,  0.5f, 0.0f },
+	{  0.5f, -0.5f, 0.0f },
+	{ -0.5f, -0.5f, 0.0f },
+	{ -0.5f,  0.5f, 0.0f }
+};
+
+RectangleIndices rectIndices =
+{
+	{ 0, 1, 3 },
+	{ 1, 2, 3 }
+};
+
+using GL::ElementBuffer;
+
+ID<ElementBuffer> ElemBufferObj;
+
+struct Vertex2
+{
+	gFloat x, y;
+};
+
+struct TriTexCoords
+{
+	Vertex2 a, b, c;
+};
+
+
+TriTexCoords textureCoords =
+{
+	{ 0.0f, 0.0f },
+	{ 1.0f, 0.0f },
+	{ 0.5f, 1.0f }
+};
+
+
+sfn RAW_SetupBuffers()
+{
+	GL::GenerateVertexBuffers(Address(VertexArrayObj ), 1);
+	GL::GenerateBuffers      (Address(VertexBufferObj), 1);
+	GL::GenerateBuffers      (Address(ElemBufferObj  ), 1);
+}
+
+sfn RAW_SetupTriangleBuffer()
+{
+	GL::GenerateBuffers(Address(VertexBufferObj), 1);
+}
+
+sfn RAW_BindAndBufferDataToIDs()
+{
+	GL::BindVertexArray(VertexArrayObj);
+
+	GL::BindBuffer(EBufferTarget::VertexAttributes, VertexBufferObj);
+
+	GL::BufferData<TriangleRaw>(Address(EquilateralTriangleVerticies), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
+
+	//GL::BufferData<RectangleCompressed>(Address(rectCompress), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
+	
+	//GL::BindBuffer(EBufferTarget::VertexIndices, ElemBufferObj);
+
+	//GL::BufferData<RectangleIndices>(Address(rectIndices), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
+}
+
+GL::gInt VertexAttributeIndex = 0;   // See shader source: (layout = 0).
+
+using GL::EBool    ;
+using GL::EDataType;
+
+constexpr sfn ZeroOffset() -> ptr<void>
+{
+	return 0;
+}