Added File: ResourceWrapper.h

Added the file ResourceWrapper.h which contains the class
IResourceWrapper<T>.

This class is used as part of the resource management system, the purpose
of this system is to make task of importing, removing, loading and
unloading resources within the program, making things simpler and
standardised across multiple types.
This class is the first layer of abstaction and encapsulation which allows
for a standard set of methods:
	- AddResource(); two types one referencing to file, other to
	  prebuilt resource
	- DeleteResource();
and storage of the resource - as a pointer

This class is later abstacted so the is managed by a higher system which
will store a collection of classes (of a specific type) which is derived
from IResourceWrapper<T>, which is then further used by another class
which encapsulates what the loaders do
Initial Workspace Setup (part 2) commit

List of files that should have been added originally in the original
Initial Workspace Setup Commit. The files include:
	- .gitignore
	- .gitattributes
	- Visual Studios files

Fixed Conflicts:
	.gitattributes
	.gitignore
Added ResourceLoader.h

ResourceLoader.h contains the virtual class IResourceLoader.

IResourceLoader is used to manage the adding, removing and loading of resources
it also is used to manage a collection of resources at anyone time through
the use of std::map (unless of resource has special requirements)
The class is part of the resource management system

Added the header files <string> and <map> to ResourceWrapper.h, as they
were missing
Minor Change: Added the memory header

This allows smart pointers to be used without the header being called in
the file that uses this or one of the other Resource Management system
header files
DeleteResource() can now take data as a parameter

This has been add in case some form of data needs to be passed
This makes the resource manager more flexable, meaning direct and low
level management is no longer required
Added ResourceManager.[h/cpp]

This is that last piece of the resource management system
This part manages everything it is given to manage
The system may get altered in the future
As of now this is how it works:

A resource (int, GLint, etc which may be shader, tree, map, etc) is
wrapped using a derived class of the virtual class IResourceWrapper<T>
this class abstracts the type and standardises some of the core
manipulations that can be done
Next, the resource is added to a derivative of IResourceLoader this
abstacts it even more while also managing multiple different resources (of
the same type), the resource loader can managed a group of types as no
feature of the resource loader adds such a limitations
Finally comes the ResourceManager Class. This class is the ultimate level
of encapsulation, managing any loaders given to it this means that you can
effectively manage everything from within one object, giving a high level
of control.

Future versions of it will be some content aware so that it limits how
much is added of a specific resource, also a type safety to prevent the
wrong type being given to a resource as there is nothing as of right now
other than makiing sure that right type is passed to prevent such an
error
Merge branch 'Resource' into 'master'

Added the resource management feature within resource branch to the master
branch