Started removing the excess adhesive... still a bit more to go...

This commit is contained in:
Edward R. Gonzalez 2020-02-21 01:18:07 -05:00
parent d4bfec3944
commit 6d7750ebfb
15 changed files with 1436 additions and 902 deletions

View File

@ -38,7 +38,7 @@ namespace Actions
using ActionType = Delegate< FunctionType >; using ActionType = Delegate< FunctionType >;
public: public:
AAction(ActionType _actionToAssign, ActionParams... _params) : AAction(ro Ref(ActionType) _actionToAssign, ro Ref(ActionParams)... _params) :
action(_actionToAssign), action(_actionToAssign),
params(_params... ), params(_params... ),
done (false ) done (false )
@ -49,7 +49,7 @@ namespace Actions
return done; return done;
} }
sfn IsSame(ActionParams... _paramsForAction) -> bool sfn IsSame(ro Ref(ActionParams)... _paramsForAction) -> bool
{ {
Tuple<ActionParams...> paramsToCheck(_paramsForAction...); Tuple<ActionParams...> paramsToCheck(_paramsForAction...);
@ -63,7 +63,7 @@ namespace Actions
} }
} }
sfn ReInitalize(ActionParams... _params) sfn ReInitalize(ro Ref(ActionParams)... _params)
{ {
params = Tuple<ActionParams...> (_params...); params = Tuple<ActionParams...> (_params...);
@ -71,10 +71,10 @@ namespace Actions
} }
private: private:
sfn DoAction_Implementation(ActionParams... _params) { action(_params...); } sfn DoAction_Implementation(ro Ref(ActionParams)... _params) { action(_params...); }
template<IndexType... TuplePackIndex> // TuplePackSequence<TuplePackIndex...> template<IndexType... TuplePackIndex> // TuplePackSequence<TuplePackIndex...>
sfn ExpandTuple_CallDoActionImplementaiton(const Ref(Tuple<ActionParams...>) _paramsToExpand, std::index_sequence <TuplePackIndex...>) sfn ExpandTuple_CallDoActionImplementaiton(ro Ref(Tuple<ActionParams...>) _paramsToExpand, std::index_sequence <TuplePackIndex...>)
{ {
// ExpandTuplePack<TuplePackIndex> // ExpandTuplePack<TuplePackIndex>
DoAction_Implementation(std::get<TuplePackIndex>(_paramsToExpand)...); DoAction_Implementation(std::get<TuplePackIndex>(_paramsToExpand)...);
@ -112,11 +112,6 @@ namespace Actions
using AActions_Registry = std::map <TypeIndex , Managed_AActions>; using AActions_Registry = std::map <TypeIndex , Managed_AActions>;
public: public:
template<typename Entry>
sfn Available(Ref(Entry) _entry) -> bool
{
return _entry != aActions_Available.end() ? true : false;
}
template<typename Entry> template<typename Entry>
sfn Contains(Ref(Entry) _entry) -> bool sfn Contains(Ref(Entry) _entry) -> bool
@ -132,7 +127,7 @@ namespace Actions
} }
template<typename FunctionType, typename... ActionParams> template<typename FunctionType, typename... ActionParams>
sfn Request_AAction(Delegate< FunctionType> _actionToQueue, ActionParams... _paramsForAction) -> ptr<IAction> sfn Request_AAction(ro Ref(Delegate< FunctionType>) _actionToQueue, ro Ref(ActionParams)... _paramsForAction) -> ptr<IAction>
{ {
using ActionType = AAction < FunctionType, ActionParams...>; using ActionType = AAction < FunctionType, ActionParams...>;
@ -196,7 +191,7 @@ namespace Actions
public: public:
template<typename FunctionType, typename... ActionParams> template<typename FunctionType, typename... ActionParams>
sfn AddToQueue(Delegate< FunctionType> _actionToQueue, ActionParams... _paramsForAction) sfn AddToQueue(ro Ref(Delegate< FunctionType>) _actionToQueue, ro Ref(ActionParams)... _paramsForAction)
{ {
using GeneratedActionType = AAction<FunctionType, ActionParams...>; using GeneratedActionType = AAction<FunctionType, ActionParams...>;

View File

@ -44,8 +44,11 @@ auto
#define deduce \ #define deduce \
auto auto
#define Ref(_type) \ #define ro \
_type& const
#define Ref(...) \
__VA_ARGS__&
#define rRef(_type) \ #define rRef(_type) \
_type&& _type&&
@ -68,18 +71,21 @@ using ptr = Type*;
template<typename ReturnType, typename... ParamTypes> template<typename ReturnType, typename... ParamTypes>
using FnPtr = ReturnType(*)(ParamTypes...); using FnPtr = ReturnType(*)(ParamTypes...);
template<typename Type>
using SPtr = std::shared_ptr<Type>;
template<typename Type>
using UPtr = std::unique_ptr<Type>;
// Delegating
template<typename FnType> template<typename FnType>
using Delegate = std::function<FnType>; using Delegate = std::function<FnType>;
template<typename ReturnType, typename... ParamTypes> template<typename ReturnType, typename... ParamTypes>
using Func = ReturnType(ParamTypes...); using Func = ReturnType(ParamTypes...);
template<typename Type>
using UPtr = std::unique_ptr<Type>;
template<typename Type>
using SPtr = std::shared_ptr<Type>;
// Strings // Strings
@ -90,8 +96,13 @@ using RawString = ptr<CharType>;
using std::cout; using std::cout;
using std::endl; using std::endl;
using DataSize = std::size_t;
using std::ifstream ;
using std::ios ;
using std::string ;
using std::stringstream;
using DataSize = std::size_t;
using Thread = std::thread; using Thread = std::thread;
template<typename... ObjectTypes> template<typename... ObjectTypes>
@ -120,7 +131,7 @@ sfn Address(Ref(Type) _instance) -> ptr<Type>
} }
template<typename Type> template<typename Type>
sfn Dref(ptr<Type> _type) -> Ref(Type) sfn Dref(ro ptr<Type> _type) -> Ref(Type)
{ {
return *_type; return *_type;
} }
@ -141,14 +152,14 @@ sfn MakeSPtr(rRef(ParamTypes)... _params) -> SPtr<Type>
// Exit // Exit
sfn Exit(ExitCode _code) sfn Exit(ro ExitCode _code)
{ {
exit(int(_code)); exit(int(_code));
} }
// Error Stuff // Error Stuff
sfn ErrorRuntime(const Ref(std::runtime_error) _error) sfn ErrorRuntime(ro Ref(std::runtime_error) _error)
{ {
std::cout << "Runtime error occurred: " << _error.what() << std::endl; std::cout << "Runtime error occurred: " << _error.what() << std::endl;

325
DGL.hpp
View File

@ -1,331 +1,10 @@
#pragma once #pragma once
// GLFW, GLEW, GLM
#include <glew.h >
#include <glfw3.h >
#include <glm/glm.hpp >
#include <glm/gtc/matrix_transform.hpp>
// DGL // DGL
#include "DGL_FundamentalTypes.hpp" #include "DGL_Types.hpp"
#include "DGL_MiscTypes.hpp"
#include "DGL_Enum.hpp" #include "DGL_Enum.hpp"
#include "DGL_Shader.hpp" #include "DGL_Shader.hpp"
#include "DGL_Buffers.hpp" #include "DGL_Buffers.hpp"
#include "DGL_Space.hpp" #include "DGL_Space.hpp"
#include "DGL_Model.hpp" #include "DGL_Model.hpp"
#include "DGL_Entity.hpp"
// Non-Standard C++
#include "Cpp_Alias.hpp"
namespace DGL
{
// Aliases
// C++ STL
using std::cout;
using std::endl;
// GLFW
using Monitor = GLFWmonitor;
using TimeValInt = uint64_t;
using TimeValDec = double;
using Window = GLFWwindow;
using WindowRefList = std::vector< ptr<Window> >;
// Object Instances
WindowRefList Windows;
// Constants
sfn constexpr NotShared () -> ptr<Window > { return NULL; }
sfn constexpr WindowedMode() -> ptr<Monitor> { return NULL; }
// Forward Declares
sfn SwapBuffers(const ptr<Window> _window) -> void;
// Functionality
sfn CanClose(const ptr<Window> _theWindow)
{
return glfwWindowShouldClose(_theWindow);
}
sfn CanUseRawMouse()
{
return glfwRawMouseMotionSupported();
}
sfn CreateWindow
(
int _width,
int _height,
RawString<const char> _title,
ptr <Monitor > _monitorToFullscreen,
ptr <Window > _windowToShareResourcesWith
)
-> ptr<Window>
{
Windows.push_back(glfwCreateWindow(_width, _height, _title, _monitorToFullscreen, _windowToShareResourcesWith));
try
{
if (Windows.back() == NULL)
{
throw std::runtime_error("Failed to create a window");
}
}
catch (std::runtime_error _error)
{
ErrorRuntime(_error);
Exit(ExitCode::Failed);
}
return Windows.back();
}
sfn CursorPositionUpdateBind(ptr<Window> _window, FnPtr<void, double, double> _functionToCall)
{
glfwSetCursorPosCallback(_window, GLFWcursorposfun(_functionToCall));
}
sfn DestoryWindow(const ptr<Window> _window)
{
using ElementType = decltype(Windows.begin());
for (ElementType element = Windows.begin(); element != Windows.end(); element++)
{
if (*element == _window)
{
glfwDestroyWindow(_window);
Windows.erase(element);
}
}
return;
}
sfn GetCursorPosition(ptr<Window> _window, ptr<double> _xAxis, ptr<double> _yAxis)
{
glfwGetCursorPos(_window, _xAxis, _yAxis);
}
sfn GetMouseInputMode(ptr<Window> _contextWindowRef, EMouseMode _mode)
{
return glfwGetInputMode(_contextWindowRef, GLenum(_mode));
}
sfn GetRawTime() -> TimeValInt
{
return glfwGetTimerValue();
}
sfn GetTime() -> TimeValDec
{
return glfwGetTime();
}
sfn InitalizeGLFW()
{
try
{
std::cout << "Initializing GLFW Version: " << glfwGetVersionString() << std::endl;
/* Initialize the library */
if (!glfwInit())
{
throw std::runtime_error("Failed to initialize GLFW");
}
}
catch (const std::runtime_error _error)
{
ErrorRuntime(_error);
Exit(ExitCode::Failed);
}
return;
}
sfn InitalizeGLEW()
{
try
{
// If using GLEW version 1.13 or earlier
//glewExperimental = true;
std::cout << "Initializing Glew Version: " << glewGetString(GLEW_VERSION) << std::endl;
GLenum err = glewInit();
if (err != GLEW_OK)
{
// Problem: glewInit failed, something is seriously wrong.
std::cout << "glewInit failed: " << glewGetErrorString(err) << std::endl;
throw std::runtime_error("Failed to initialize GLFW");
}
cout << "OpenGL Version: " << glGetString(GL_VERSION) << endl;
}
catch (const std::runtime_error _error)
{
ErrorRuntime(_error);
Exit(ExitCode::Failed);
}
}
sfn KeyPressed(ptr<Window> _contextWindowRef, EKeyCodes _keyToCheck) -> bool
{
return glfwGetKey(_contextWindowRef, int(_keyToCheck));
}
template<typename... CodeType, typename = EKeyCodes>
sfn KeysPressed(ptr<Window> _contextWindowRef, CodeType... _otherKeys) -> bool
{
return (KeyPressed(_contextWindowRef, _otherKeys) && ...) == true;
}
sfn PollEvents()
{
glfwPollEvents();
return;
}
sfn ResetCursor(ptr<Window> _window, gFloat _screenCenterWidth, gFloat _screenCenterHeight)
{
glfwSetCursorPos(_window, _screenCenterWidth, _screenCenterHeight);
glfwSetCursorPos(_window, 0, 0);
}
sfn RunBasicWindowLoop(const ptr<Window> _window)
{
/* Loop until the user closes the window */
while (not CanClose(_window))
{
ClearBuffer(EFrameBuffer::Color);
SwapBuffers(_window);
PollEvents();
}
return;
}
sfn RunBasicWindowLoop_Timed(const ptr<Window> _window, TimeValDec _interval, Delegate< Func<void>> _renderProcedure)
{
TimeValDec start, end, deltaSinceClear = 0.0;
while (not CanClose(_window))
{
start = GetTime();
if (deltaSinceClear > _interval)
{
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();
SwapBuffers(_window);
PollEvents();
}
end = GetTime();
deltaSinceClear = deltaSinceClear + end - start;
}
return;
}
sfn SetClearColor(LinearColor _colorToSet)
{
glClearColor(_colorToSet.Red, _colorToSet.Green, _colorToSet.Blue, _colorToSet.Alpha);
}
sfn SetCurrentContext(const ptr<Window> _window)
{
try
{
glfwMakeContextCurrent(_window);
ptr< RawString<const char> > ErrorMsg = NULL;
int code = glfwGetError(ErrorMsg);
if (code == GLFW_NO_WINDOW_CONTEXT)
{
throw std::runtime_error( Dref(ErrorMsg) );
}
}
catch (const std::runtime_error _error)
{
ErrorRuntime(_error);
Exit(ExitCode::Failed);
}
return;
}
template<typename ModeParam>
sfn SetInputMode(ptr<Window> _window, EMouseMode _mouseMode, ModeParam _modeParam)
{
glfwSetInputMode(_window, GLenum(_mouseMode), GLenum(_modeParam));
}
sfn SetPolygonMode(EFace _desiredFaces, ERenderMode _desiredMode)
{
glPolygonMode(GLenum(_desiredFaces), GLenum(_desiredMode));
}
sfn SwapBuffers(const ptr<Window> _window) -> void
{
glfwSwapBuffers(_window);
return;
}
sfn TerminateGLFW()
{
glfwTerminate();
return;
}
// RawTape
}

View File

@ -4,9 +4,8 @@
#include <glew.h> #include <glew.h>
// DGL // DGL
#include "DGL_FundamentalTypes.hpp"
#include "DGL_MiscTypes.hpp"
#include "DGL_Enum.hpp" #include "DGL_Enum.hpp"
#include "DGL_Types.hpp"
// Non-Standard C++ // Non-Standard C++
#include "Cpp_Alias.hpp" #include "Cpp_Alias.hpp"
@ -15,14 +14,14 @@
namespace DGL namespace DGL
{ {
sfn BindBuffer(const EBufferTarget _targetType, const ID<VertexBuffer> _buffer) sfn BindBuffer(EBufferTarget _targetType, ID<VertexBuffer> _buffer)
{ {
glBindBuffer(GLenum(_targetType), _buffer); glBindBuffer(GLenum(_targetType), _buffer);
return; return;
} }
sfn BindVertexArray(const gUInt _referenceToTrackArray) sfn BindVertexArray(gUInt _referenceToTrackArray)
{ {
glBindVertexArray(_referenceToTrackArray); glBindVertexArray(_referenceToTrackArray);
@ -30,27 +29,28 @@ namespace DGL
} }
template<typename TypeOfData> template<typename TypeOfData>
sfn BufferData(ptr<TypeOfData> _data, const EBufferTarget _targetType, const EBufferUsage _usageType) sfn BufferData(ro Ref(TypeOfData) _data, EBufferTarget _targetType, EBufferUsage _usageType)
{ {
glBufferData(GLenum(_targetType), sizeof(TypeOfData), _data, GLenum(_usageType)); glBufferData(GLenum(_targetType), sizeof(TypeOfData), Address(_data), GLenum(_usageType));
return; return;
} }
sfn BufferData(DataPtr _data, gSize _sizeOfData, const EBufferTarget _targetType, const EBufferUsage _usageType) template<typename Type>
sfn BufferData(ro Ref(Type) _data, gSize _sizeOfData, EBufferTarget _targetType, EBufferUsage _usageType)
{ {
glBufferData(GLenum(_targetType), _sizeOfData, _data, GLenum(_usageType)); glBufferData(GLenum(_targetType), _sizeOfData, Address(_data), GLenum(_usageType));
} }
template<typename... Type, typename = EFrameBuffer> template<typename... Type, typename = EFrameBuffer>
sfn ClearBuffer(const Type... _buffersToClear) sfn ClearBuffer(Type... _buffersToClear)
{ {
glClear( (gBitfield(_buffersToClear) | ...) ); glClear( (gBitfield(_buffersToClear) | ...) );
return; return;
} }
sfn DisableVertexAttributeArray(const gInt _vertexAttributeArrayIndex) sfn DisableVertexAttributeArray(gInt _vertexAttributeArrayIndex)
{ {
glDisableVertexAttribArray(_vertexAttributeArrayIndex); glDisableVertexAttribArray(_vertexAttributeArrayIndex);
} }
@ -60,12 +60,12 @@ namespace DGL
glDrawArrays(GLenum(_primitive), _startingIndex, _numToRender); // Starting from vertex 0; 3 vertices total -> 1 triangle. glDrawArrays(GLenum(_primitive), _startingIndex, _numToRender); // Starting from vertex 0; 3 vertices total -> 1 triangle.
} }
sfn DrawElements(EPrimitives _primitive, gSize _numElements, EDataType _dataType, DataPtr _offfsetAddressFromFirstIndex) sfn DrawElements(EPrimitives _primitive, gSize _numElements, EDataType _dataType, ro DataPtr _offfsetAddressFromFirstIndex)
{ {
glDrawElements(GLenum(_primitive), _numElements, GLenum(_dataType), _offfsetAddressFromFirstIndex); glDrawElements(GLenum(_primitive), _numElements, GLenum(_dataType), _offfsetAddressFromFirstIndex);
} }
sfn EnableVertexAttributeArray(const gInt _vertexAttributeArrayIndex) sfn EnableVertexAttributeArray(gInt _vertexAttributeArrayIndex)
{ {
glEnableVertexAttribArray(_vertexAttributeArrayIndex); glEnableVertexAttribArray(_vertexAttributeArrayIndex);
} }
@ -75,9 +75,9 @@ namespace DGL
( (
gUInt _attributeIndex , gUInt _attributeIndex ,
EDataType _vertexComponenetType , EDataType _vertexComponenetType ,
ptr<void> _firstVertexComponentLocation, ro ptr<void> _firstVertexComponentLocation,
gInt _numberOfVertexComponents , gInt _numberOfVertexComponents ,
EBool _shouldNormalize gBoolean _shouldNormalize
) )
{ {
glVertexAttribPointer glVertexAttribPointer
@ -85,30 +85,47 @@ namespace DGL
_attributeIndex , _attributeIndex ,
_numberOfVertexComponents , _numberOfVertexComponents ,
GLenum(_vertexComponenetType), GLenum(_vertexComponenetType),
GLenum(_shouldNormalize ), _shouldNormalize ,
sizeof(VertType ), sizeof(VertType ),
_firstVertexComponentLocation _firstVertexComponentLocation
); );
} }
sfn GenerateBuffers(ptr<gUInt> _bufferReferencer, uInt64 _numberOfBuffersToReserve) sfn GenerateBuffers(Ref(gUInt) _bufferReferencer, gSize _numberOfBuffersToReserve)
{ {
glGenBuffers(_numberOfBuffersToReserve, _bufferReferencer); glGenBuffers(_numberOfBuffersToReserve, Address(_bufferReferencer));
return; return;
} }
sfn GenerateVertexBuffers(ptr<gUInt> __referenceRetainerToBuffer, uInt64 _numOfObjectsToReserveFor) sfn GenerateVertexBuffers(Ref(gUInt) __referenceRetainerToBuffer, gSize _numOfObjectsToReserveFor)
{ {
glGenVertexArrays(_numOfObjectsToReserveFor, __referenceRetainerToBuffer); glGenVertexArrays(_numOfObjectsToReserveFor, Address(__referenceRetainerToBuffer));
return; return;
} }
sfn GetBufferParameterIV(EBufferTarget _target, EBufferParam _param, ptr<gInt> _data) sfn GetBufferParameterIV(EBufferTarget _target, EBufferParam _param, Ref(gInt) _dataStore)
{ {
glGetBufferParameteriv(GLenum(_target), GLenum(_param), _data); glGetBufferParameteriv(GLenum(_target), GLenum(_param), Address(_dataStore));
return; return;
} }
// Used to get an offset from a specified location.
sfn Offset(uInt64 _offsetAmount)
{
return DataPtr(_offsetAmount);
}
sfn UnbindVertexArray()
{
BindVertexArray(0);
}
// Provides an zero offset pointer specifier.
constexpr sfn ZeroOffset() -> ptr<void>
{
return 0;
}
} }

233
DGL_Entity.hpp Normal file
View File

@ -0,0 +1,233 @@
#pragma once
// DGL
#include "DGL_Types.hpp"
#include "DGL_Model.hpp"
#include "DGL_Shader.hpp"
#include "DGL_Utilities.hpp"
// Non-Standard C++
#include "Cpp_Alias.hpp"
namespace DGL
{
namespace Colors
{
LinearColor CoralColor(1.0f , 0.5f , 0.31f, 1.0f);
LinearColor GreyColor (0.60f, 0.60f, 0.60f, 1.0f);
LinearColor LightColor(1.0f , 1.0f , 1.0f , 1.0f);
}
class Light_Basic
{
public:
Light_Basic() :
color (Colors::LightColor.Vector()),
position (Vector3 (0.0f) ),
scale (Vector3 (0.2f) ),
transform (CoordSpace(1.0f) ),
translationRadius(4.0f )
{}
sfn GetColor() -> VecColor
{
return color;
}
sfn GetPosition() -> Vector3
{
return position;
}
sfn Load()
{
GenerateVertexBuffers(modelVAO, 1);
GenerateBuffers (modelVBO, 1);
GenerateBuffers (modelEBO, 1);
BindVertexArray(modelVAO);
BindBuffer(EBufferTarget::VertexAttributes, modelVBO);
BufferData<CubeVerts>(DefaultCube, EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
BindBuffer(EBufferTarget::VertexIndices, modelEBO);
BufferData<CubeElements>(DefaultCubeElements, EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
FormatVertexAttributes<CubeVerts::Vertex3>(0, EDataType::Float, ZeroOffset(), CubeVerts::Vertex3::ValueCount(), false);
UnbindVertexArray();
}
sfn Update()
{
transform = CoordSpace(1.0f);
position.x = translationRadius * sin(GetTime());
position.z = translationRadius * cos(GetTime());
transform = Translate(transform, position);
transform = Scale (transform, scale );
}
sfn Render(ro Ref(CoordSpace) _projection, ro Ref(CoordSpace) _viewport)
{
deduce screenspaceTransform = _projection * _viewport * transform;
Basic_LampShader::Use(screenspaceTransform);
BindVertexArray(modelVAO);
BindBuffer(EBufferTarget::VertexIndices, modelEBO);
gInt SizeRef; GetBufferParameterIV(EBufferTarget::VertexIndices, DGL::EBufferParam::Size, SizeRef); SizeRef /= sizeof(unsigned int);
DrawElements(EPrimitives::Triangles, SizeRef, EDataType::UnsignedInt, ZeroOffset());
Basic_LampShader::Stop();
}
private:
VecColor color ;
Vector3 position ;
Vector3 scale ;
CoordSpace transform ;
gFloat translationRadius;
// Hardcoded Model
struct CubeVerts
{
struct Vertex3
{
gFloat x, y, z;
static constexpr sfn ValueCount() -> gSize { return 3; }
};
Vertex3
f1, f2, f3, f4, // Front
b1, b2, b3, b4; // Back
}
DefaultCube =
{
// Front
{-1.0f, -1.0f, 1.0f},
{ 1.0f, -1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f},
{-1.0f, 1.0f, 1.0f},
// Back
{-1.0f, -1.0f, -1.0f},
{ 1.0f, -1.0f, -1.0f},
{ 1.0f, 1.0f, -1.0f},
{-1.0f, 1.0f, -1.0f}
};
struct CubeElements
{
struct Edge3
{
struct TriIndex
{
gInt a, b, c;
};
TriIndex a, b;
};
Edge3 front, right, back, left, bottom, top;
}
DefaultCubeElements =
{
// Front
{ { 0, 1, 2 }, { 2, 3, 0 } },
// Right
{ { 1, 5, 6 }, { 6, 2, 1 } },
// Back
{ { 7, 6, 5 }, { 5, 4, 7 } },
// Left
{ { 4, 0, 3 }, { 3, 7, 4 } },
// Bottom
{ { 4, 5, 1 }, { 1, 0, 4 } },
// Top
{ { 3, 2, 6 }, { 6, 7, 3 } }
};
ID<VertexArray > modelVAO;
ID<VertexBuffer > modelVBO;
ID<ElementBuffer> modelEBO;
};
class Entity_Basic
{
public:
Entity_Basic() :
position (Vector3(0.0f) ),
model ("" ),
transform(CoordSpace(1.0f))
{};
Entity_Basic(Ref(Model) _model, Ref(Material_Phong) _material) :
position (Vector3(0.0f) ),
model (_model ),
transform(CoordSpace(1.0f)),
material (_material )
//type (_type )
{};
sfn Update()
{
}
sfn Render(ro Ref(CoordSpace) _projection, ro Ref(CoordSpace) _viewport, ro Ref(Vector3) _lightPosition, ro Ref(VecColor) _lightColor)
{
PhongShader::Use(_projection, _viewport, transform, _lightPosition,_lightColor, material);
model.Render();
PhongShader::Stop();
return;
}
sfn operator= (ro Ref(Entity_Basic) _entity)->Ref(Entity_Basic)
{
position = _entity.position ;
model = _entity.model ;
transform = _entity.transform;
material = _entity.material ;
return Dref(this);
}
private:
//EEntityType type;
Vector3 position ;
Model model ;
CoordSpace transform ;
Material_Phong material ;
};
}

View File

@ -3,57 +3,37 @@
// DGL // DGL
#include "DGL_Buffers.hpp" #include "DGL_Buffers.hpp"
#include "DGL_Space.hpp" #include "DGL_Space.hpp"
#include "DGL_Types.hpp"
// C++ // Non-Standard C++
#include "Cpp_Alias.hpp" #include "Cpp_Alias.hpp"
namespace DGL namespace DGL
{ {
using std::string;
using UVList = std ::vector < Vector2>;
using Vec3Int = Generic::Vector3< gUInt >;
using Vec2Int = Generic::Vector2< gUInt >;
using VertexList = std ::vector < Vector3>;
using VIndexList = std ::vector < gInt >;
sfn Offset(gInt _offsetAmount)
{
return ptr<void>(_offsetAmount);
}
constexpr sfn ZeroOffset() -> ptr<void>
{
return 0;
}
struct VertexGenerator struct VertexGenerator
{ {
using ComponentList = std::vector< gFloat>; using ComponentList = std::vector< gFloat>;
public:
sfn AddComponent(gFloat _float)
ComponentList comp;
// TODO: De-hard-code this generator to do any vector size.
sfn GetVector() -> Vector3
{ {
return Vector3(comp.at(0), comp.at(1), comp.at(2)); comp.push_back(_float);
} }
// TODO: De-hard-code this generator to do any vector size.
sfn GetVector2() -> Vector2 sfn GetVector2() -> Vector2
{ {
return Vector2(comp.at(0), comp.at(1)); return Vector2(comp.at(0), comp.at(1));
} }
sfn GetVector3() -> Vector3
{
return Vector3(comp.at(0), comp.at(1), comp.at(2));
}
void Normalize() void Normalize()
{ {
using std::pow ; using std::pow ;
@ -75,6 +55,10 @@ namespace DGL
*element /= magnitude; *element /= magnitude;
} }
} }
private:
ComponentList comp;
}; };
@ -141,46 +125,122 @@ namespace DGL
}; };
// TODO: Add support for textures...
struct Model class Model
{ {
ID<VertexArray > VAO; private:
ID<VertexBuffer > VBO; // Not the most efficient method to do normals, but works.
ID<NormalBuffer > NBO; sfn generateNormals() -> void
ID<TextureBuffer> TBO; {
ID<ElementBuffer> EBO; normals.resize(verticies.size(), Vector3(0.0f));
const string FilePath; for (int faceIndex = 0; faceIndex < faces.size(); faceIndex++)
{
int vertexIndex1 = faces[faceIndex].Vertexes[0],
vertexIndex2 = faces[faceIndex].Vertexes[1],
vertexIndex3 = faces[faceIndex].Vertexes[2];
VertexList Verticies ; Vector3 edge1 = verticies[vertexIndex2] - verticies[vertexIndex1],
VertexList VertNormals; edge2 = verticies[vertexIndex3] - verticies[vertexIndex1],
VertexList RAWVertex ; normal = GetDirection(GetCrossNormal(edge1, edge2));
VertexList VertNormalsRAW;
UVList TextureMap ; faces[faceIndex].Normals[0] = vertexIndex1;
FaceList Faces ; faces[faceIndex].Normals[1] = vertexIndex2;
VIndexList Indicies ; faces[faceIndex].Normals[2] = vertexIndex3;
normals[vertexIndex1] = normal;
normals[vertexIndex2] = normal;
normals[vertexIndex3] = normal;
}
}
public:
Model(const Ref(string) _filePath) : Model(ro Ref(string) _filePath) :
VAO(-1), vertexArrayID (0 ),
VBO(-1), vertexBufferID (0 ),
NBO(-1), normalBuffferID(0 ),
EBO(-1), textureBufferID(0 ),
FilePath (_filePath ), elementBufferID(0 ),
Verticies (VertexList()), filePath (_filePath ),
VertNormals(VertexList()), verticies (VertexList()),
TextureMap (UVList ()), normals (VertexList()),
Faces (FaceList ()) textureUVs (UVList ()),
faces (FaceList ())
{} {}
// TODO: Add support for textures...
// Hardcoded to only do the verticies and normals for now...
sfn Buffer()
{
GenerateVertexBuffers(vertexArrayID , 1);
GenerateBuffers (vertexBufferID , 1);
GenerateBuffers (normalBuffferID, 1);
GenerateBuffers (elementBufferID, 1);
if (normals.size() == 0)
{
generateNormals();
}
BindVertexArray(vertexArrayID);
// Vertex Position Buffering
BindBuffer(EBufferTarget::VertexAttributes, vertexBufferID);
BufferData(verticies[0], gSize(verticies.size() * sizeof(Vector3)), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
FormatVertexAttributes<Vector3>(0, EDataType::Float, ZeroOffset(), 3, false);
EnableVertexAttributeArray(0);
// Normal Buffering
if (normals.size() != 0)
{
BindBuffer(EBufferTarget::VertexAttributes, normalBuffferID);
BufferData(normals[0], gSize(normals.size() * sizeof(Vector3)), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
FormatVertexAttributes<Vector3>(1, EDataType::Float, ZeroOffset(), 3, false);
EnableVertexAttributeArray(1);
}
// Texture buffering
// TODO: Fix this.
if (textureUVs.size() != 0)
{
//glBindTexture(TBO, GL_TEXTURE_2D);
//BufferData(Address(TextureMap[0]), TextureMap.size() * sizeof(Vector2), EBufferTarget::TextureData, EBufferUsage::StaticDraw);
//FormatVertexAttributes<Vector2>(2, EDataType::Float, ZeroOffset(), 2, EBool::False);
//EnableVertexAttributeArray(2);
}
BindBuffer(EBufferTarget::VertexIndices, elementBufferID);
BufferData(faces[0], gSize(faces.size() * sizeof(Face)), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
UnbindVertexArray(); // Unbind vertex array.
}
sfn Load() sfn Load()
{ {
using std::cout ;
using std::endl ;
using std::get ; using std::get ;
using std::getline ; using std::getline ;
using std::ifstream ; using std::ifstream ;
@ -190,7 +250,7 @@ namespace DGL
ifstream fileBuffer; fileBuffer.open(FilePath); ifstream fileBuffer; fileBuffer.open(filePath);
@ -202,10 +262,10 @@ namespace DGL
{ {
_vertexStream >> componentValue >> ws; _vertexStream >> componentValue >> ws;
vertex.comp.push_back(componentValue); vertex.AddComponent(componentValue);
} }
Verticies.push_back(vertex.GetVector()); verticies.push_back(vertex.GetVector3());
}; };
deduce processNormals = [&](Ref(stringstream) _normalStream) deduce processNormals = [&](Ref(stringstream) _normalStream)
@ -216,12 +276,12 @@ namespace DGL
{ {
_normalStream >> componentValue >> ws; _normalStream >> componentValue >> ws;
normal.comp.push_back(componentValue); normal.AddComponent(componentValue);
} }
normal.Normalize(); normal.Normalize();
VertNormals.push_back(normal.GetVector()); normals.push_back(normal.GetVector3());
}; };
deduce processTexture = [&](Ref(stringstream) _normalStream) deduce processTexture = [&](Ref(stringstream) _normalStream)
@ -232,10 +292,10 @@ namespace DGL
{ {
_normalStream >> componentValue >> ws; _normalStream >> componentValue >> ws;
texture.comp.push_back(componentValue); texture.AddComponent(componentValue);
} }
TextureMap.push_back(texture.GetVector2()); textureUVs.push_back(texture.GetVector2());
}; };
deduce processFace = [&](Ref(stringstream) _faceStream) deduce processFace = [&](Ref(stringstream) _faceStream)
@ -248,7 +308,7 @@ namespace DGL
faceMade.AddVertexIndex(vertexIndex - 1); faceMade.AddVertexIndex(vertexIndex - 1);
Indicies.push_back(vertexIndex - 1); indicies.push_back(vertexIndex - 1);
if (_faceStream.peek() == '/') if (_faceStream.peek() == '/')
{ {
@ -262,7 +322,7 @@ namespace DGL
faceMade.AddNormalIndex(normalIndex -1); faceMade.AddNormalIndex(normalIndex -1);
Indicies.push_back(normalIndex - 1); indicies.push_back(normalIndex - 1);
} }
else else
{ {
@ -278,17 +338,15 @@ namespace DGL
faceMade.AddNormalIndex(normalIndex - 1); faceMade.AddNormalIndex(normalIndex - 1);
Indicies.push_back(normalIndex - 1); indicies.push_back(normalIndex - 1);
} }
} }
} }
} }
Faces.push_back(faceMade.GetFace()); faces.push_back(faceMade.GetFace());
}; };
if (fileBuffer.is_open()) if (fileBuffer.is_open())
{ {
stringstream stringBuffer; stringstream stringBuffer;
@ -325,130 +383,65 @@ namespace DGL
} }
} }
fileBuffer.close();
return; return;
} }
else else
{ {
throw std::runtime_error("Could not open file to load model."); throw std::runtime_error("Could not open file to load model.");
} }
fileBuffer.close();
}
sfn GenerateNormals()
{
VertNormals.resize(Verticies.size());
for (int index = 0; index < Faces.size(); index++)
{
int vertexIndex1 = Faces[index].Vertexes[0],
vertexIndex2 = Faces[index].Vertexes[1],
vertexIndex3 = Faces[index].Vertexes[2];
Vector3 edge1 = Verticies[vertexIndex2] - Verticies[vertexIndex1],
edge2 = Verticies[vertexIndex3] - Verticies[vertexIndex1],
normal = GetDirection(GetCrossNormal(edge1, edge2));
Faces[index].Normals[0] = vertexIndex1;
Faces[index].Normals[1] = vertexIndex2;
Faces[index].Normals[2] = vertexIndex3;
VertNormals[vertexIndex1] = normal;
VertNormals[vertexIndex2] = normal;
VertNormals[vertexIndex3] = normal;
}
}
template<typename Type>
sfn RoundOff(Type _value, gInt _numDigitsToKeep) -> Type
{
uInt64 Rounder = pow(10, _numDigitsToKeep);
return round(_value * Rounder) / Rounder;
}
// Hardcoded to only do the verticies and normals for now...
sfn Buffer()
{
GenerateVertexBuffers(Address(VAO), 1);
GenerateBuffers (Address(VBO), 1);
GenerateBuffers (Address(NBO), 1);
//glGenTextures (1, Address(TBO));
GenerateBuffers (Address(EBO), 1);
if (VertNormals.size() == 0)
{
GenerateNormals();
}
BindVertexArray(VAO);
BindBuffer(EBufferTarget::VertexAttributes, VBO);
BufferData(Address(Verticies[0]), Verticies.size() * sizeof(Vector3), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
FormatVertexAttributes<Vector3>(0, EDataType::Float, ZeroOffset(), 3, EBool::False);
EnableVertexAttributeArray(0);
if (VertNormals.size() != 0)
{
BindBuffer(EBufferTarget::VertexAttributes, NBO);
BufferData(Address(VertNormals[0]), VertNormals.size() * sizeof(Vector3), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
FormatVertexAttributes<Vector3>(1, EDataType::Float, ZeroOffset(), 3, EBool::False);
EnableVertexAttributeArray(1);
}
/*if (TextureMap.size() != 0)
{
glBindTexture(TBO, GL_TEXTURE_2D);
BufferData(Address(TextureMap[0]), TextureMap.size() * sizeof(Vector2), EBufferTarget::TextureData, EBufferUsage::StaticDraw);
FormatVertexAttributes<Vector2>(2, EDataType::Float, ZeroOffset(), 2, EBool::False);
EnableVertexAttributeArray(2);
}*/
BindBuffer(EBufferTarget::VertexIndices, EBO);
BufferData(Address(Faces[0]), Faces.size() * sizeof(Face), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
BindVertexArray(0);
} }
sfn Render() sfn Render()
{ {
BindVertexArray(VAO); BindVertexArray(vertexArrayID);
gInt Size; GetBufferParameterIV(EBufferTarget::VertexIndices, EBufferParam::Size, Address(Size)); gInt SizeRef; GetBufferParameterIV(EBufferTarget::VertexIndices, EBufferParam::Size, SizeRef); SizeRef /= sizeof(gUInt);
Size /= sizeof(gUInt);
DrawElements(EPrimitives::Triangles, Size, EDataType::UnsignedInt, ZeroOffset()); DrawElements(EPrimitives::Triangles, SizeRef, EDataType::UnsignedInt, ZeroOffset());
BindVertexArray(0);
UnbindVertexArray();
} }
sfn operator= (ro Ref(Model) _model) -> Ref(Model)
{
vertexArrayID = _model.vertexArrayID ;
vertexBufferID = _model.vertexBufferID ;
normalBuffferID = _model.normalBuffferID;
textureBufferID = _model.textureBufferID;
elementBufferID = _model.elementBufferID;
filePath = _model.filePath;
verticies = _model.verticies ;
normals = _model.normals ;
textureUVs = _model.textureUVs;
faces = _model.faces ;
indicies = _model.indicies ;
return Dref(this);
}
private:
// Components
ID<VertexArray > vertexArrayID ;
ID<VertexBuffer > vertexBufferID ;
ID<NormalBuffer > normalBuffferID;
ID<TextureBuffer> textureBufferID;
ID<ElementBuffer> elementBufferID;
string filePath;
VertexList verticies ;
VertexList normals ;
UVList textureUVs;
FaceList faces ;
VIndexList indicies ;
}; };
}; };

View File

@ -2,52 +2,23 @@
//DGL //DGL
#include "DGL_Enum.hpp" #include "DGL_Enum.hpp"
#include "DGL_FundamentalTypes.hpp" #include "DGL_Types.hpp"
#include "DGL_MiscTypes.hpp"
#include "DGL_Buffers.hpp" #include "DGL_Buffers.hpp"
#include "DGL_Space.hpp" #include "DGL_Space.hpp"
// Non-Standard C++
#include "Cpp_Alias.hpp"
namespace DGL namespace DGL
{ {
// Some Raw Source Defaults:
RawString<const char> RawVertextShaderSource =
"#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
RawString<const char> RawFragmentShaderSource =
"#version 400\n"
"out vec4 frag_colour;"
"void main() {"
" frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
"}";
// Default Shaders
ID<ShaderProgram> RawShader ,
SimpleShader ;
// Forward Declarations // Forward Declarations
sfn GetShaderInfo ( ID<Shader > _shader , gSize _logLength , ptr<gSize> _infoLengthRef , RawString<gChar> _infoLogRef ) -> void; 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 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 MakeShader (Ref(ID<Shader >) _shaderIDHolder , EShaderType _typeOfShader , uInt64 _numberOfStringElements , ro ptr<RawString<ro gChar>> _sourceCode, ro ptr<gInt> _lengthsOfStrings) -> void;
sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, const ID<Shader> _vertexShader , const ID<Shader> _fragShader ) -> void; sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder,ro ID<Shader> _vertexShader , ro ID<Shader> _fragShader ) -> void;
@ -57,7 +28,7 @@ namespace DGL
{ {
GLint uniforms; GLint uniforms;
glGetProgramiv(_shaderToQueryForUniforms, GL_ACTIVE_UNIFORMS, &uniforms); glGetProgramiv(_shaderToQueryForUniforms, GL_ACTIVE_UNIFORMS, Address(uniforms));
for (int uniformIndex = 0; uniformIndex < uniforms; uniformIndex++) for (int uniformIndex = 0; uniformIndex < uniforms; uniformIndex++)
{ {
@ -67,7 +38,7 @@ namespace DGL
char name[100]; char name[100];
glGetActiveUniform(_shaderToQueryForUniforms, GLuint(uniformIndex), sizeof(name) - 1, &name_len, &num, &type, name); glGetActiveUniform(_shaderToQueryForUniforms, GLuint(uniformIndex), sizeof(name) - 1, Address(name_len), Address(num), Address(type), name);
name[name_len] = 0; name[name_len] = 0;
} }
@ -82,14 +53,14 @@ namespace DGL
return; return;
} }
sfn BindShaderSource(ID<Shader> _shader, uInt64 _numberOfStringElements, ptr< RawString<const gChar>> _sourceCode, ptr<const gInt> _lengthsOfStrings) sfn BindShaderSource(ID<Shader> _shader, gSize _numberOfStringElements, ro ptr<RawString<ro gChar>> _sourceCode, ro ptr<gInt> _lengthsOfStrings)
{ {
glShaderSource(_shader, _numberOfStringElements, _sourceCode, _lengthsOfStrings); glShaderSource(_shader, _numberOfStringElements, _sourceCode, _lengthsOfStrings); //Address(_sourceCode), Address(_lengthsOfStrings));
return; return;
} }
sfn CompileShader(const ID<Shader> _shaderToCompile) sfn CompileShader(ID<Shader> _shaderToCompile)
{ {
glCompileShader(_shaderToCompile); glCompileShader(_shaderToCompile);
@ -144,21 +115,21 @@ namespace DGL
return; return;
} }
sfn GetShaderInfo(ID<Shader> _shader, gSize _logLength, ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void sfn GetShaderInfo(ID<Shader> _shader, gSize _logLength, ro ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void
{ {
glGetShaderInfoLog(_shader, _logLength, _infoLengthRef, _infoLogRef); glGetShaderInfoLog(_shader, _logLength, _infoLengthRef, _infoLogRef);
return; return;
} }
sfn GetShaderProgramInfo(ID<ShaderProgram> _shaderProgram, gSize _logLength, ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void sfn GetShaderProgramInfo(ID<ShaderProgram> _shaderProgram, gSize _logLength, ro ptr<gSize> _infoLengthRef, RawString<gChar> _infoLogRef) -> void
{ {
glGetProgramInfoLog(_shaderProgram, _logLength, _infoLengthRef, _infoLogRef); glGetProgramInfoLog(_shaderProgram, _logLength, _infoLengthRef, _infoLogRef);
return; return;
} }
sfn GetUniformVariable(const ID<ShaderProgram> _programID, RawString<const char> _nameOfVariable) -> ID<Matrix> sfn GetUniformVariable(const ID<ShaderProgram> _programID, ro RawString<const char> _nameOfVariable) -> ID<Matrix>
{ {
return glGetUniformLocation(_programID, _nameOfVariable); return glGetUniformLocation(_programID, _nameOfVariable);
} }
@ -184,14 +155,8 @@ namespace DGL
return; return;
} }
sfn LoadShaders(RawString<const char> _vertexShaderFilePath, RawString<const char> _fragmentShaderFilePath) -> ID<ShaderProgram> sfn LoadShaders(RawString<ro char> _vertexShaderFilePath, RawString<ro 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; using std::vector;
@ -204,8 +169,6 @@ namespace DGL
vertexShaderFileStream .open(_vertexShaderFilePath); vertexShaderFileStream .open(_vertexShaderFilePath);
fragmentShaderFileStream.open(_fragmentShaderFilePath); fragmentShaderFileStream.open(_fragmentShaderFilePath);
try
{
if (vertexShaderFileStream.is_open() and fragmentShaderFileStream.is_open()) if (vertexShaderFileStream.is_open() and fragmentShaderFileStream.is_open())
{ {
stringstream vertSourceStrStream; stringstream vertSourceStrStream;
@ -255,21 +218,14 @@ namespace DGL
return generatedProgram; return generatedProgram;
} }
catch (const std::runtime_error _error)
{
ErrorRuntime(_error);
Exit(ExitCode::Failed);
}
}
sfn MakeShader sfn MakeShader
( (
Ref(ID<Shader> ) _shaderIDHolder , Ref(ID<Shader> ) _shaderIDHolder ,
EShaderType _typeOfShader , EShaderType _typeOfShader ,
uInt64 _numberOfStringElements, gSize _numberOfStringElements,
ptr<RawString<const gChar>> _sourceCode , ro ptr<RawString<ro gChar>> _sourceCode ,
ptr< const gInt > _lengthsOfStrings ro ptr< gInt > _lengthsOfStrings
) )
-> void -> void
{ {
@ -282,7 +238,7 @@ namespace DGL
return; return;
} }
sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, const ID<Shader> _vertexShader, const ID<Shader> _fragShader) -> void sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, ID<Shader> _vertexShader, ID<Shader> _fragShader) -> void
{ {
_shaderProgramIDHolder = CreateShaderProgram(); _shaderProgramIDHolder = CreateShaderProgram();
@ -307,6 +263,8 @@ namespace DGL
GetShaderProgramInfo(_shaderProgramIDHolder, infoLogLength, NULL, Address(ErrorMessage.at(0))); GetShaderProgramInfo(_shaderProgramIDHolder, infoLogLength, NULL, Address(ErrorMessage.at(0)));
cout << (char*)&ErrorMessage[0] << endl;
throw std::runtime_error(Address(ErrorMessage.at(0))); throw std::runtime_error(Address(ErrorMessage.at(0)));
} }
else else
@ -322,16 +280,23 @@ namespace DGL
} }
// MVA: MatrixVariableArray // MVA: MatrixVariableArray
sfn SetUniformVariable_MVA(const ID<Matrix> _matrixID, const gSize _numMatricies, const EBool _shouldTransposeValues, ptr<const float> _dataPtr) sfn SetUniformVariable_MVA(ID<Matrix> _matrixID, gSize _numMatricies, gBoolean _shouldTransposeValues, ro Ref(gFloat) _dataPtr)
{ {
glUniformMatrix4fv(_matrixID, _numMatricies, GLenum(_shouldTransposeValues), _dataPtr); glUniformMatrix4fv(_matrixID, _numMatricies, _shouldTransposeValues, Address(_dataPtr));
return; return;
} }
sfn SetUniformVariable_Vector3(const ID<Vec3> _ID, const gSize _numColor3, ptr<const gFloat> _dataPtr) sfn SetUniformVariable_Vector3(ID<Vec3> _ID, gSize _num, ro Ref(gFloat) _dataPtr)
{ {
glUniform3fv(_ID, _numColor3, _dataPtr); glUniform3fv(_ID, _num, Address(_dataPtr));
return;
}
sfn SetUniformVariable_Float(ID<gFloat> _ID, gFloat _data)
{
glUniform1f(_ID, _data);
return; return;
} }
@ -344,15 +309,137 @@ namespace DGL
} }
// Shader Class
//class Shader_PhongBasic
//{
//public:
// Shader_PhongBasic()
// {
// LoadShader();
// };
// sfn LoadShader()
// {
// shaderID = LoadShaders("PhongShader_Deprecated.vert", "PhongShader_Deprecated.frag");
// inverseModelSpaceID = GetUniformVariable(shaderID, "InverseModelSpace");
// modelSpaceID = GetUniformVariable(shaderID, "ModelSpace" );
// projectionID = GetUniformVariable(shaderID, "Projection" );
// viewportID = GetUniformVariable(shaderID, "Viewport" );
// objectColorID = GetUniformVariable(shaderID, "ObjectColor" );
// lightColorID = GetUniformVariable(shaderID, "LightColor" );
// lightPositionID = GetUniformVariable(shaderID, "LightPosition");
// viewPositionID = GetUniformVariable(shaderID, "ViewPosition" );
// return;
// }
// sfn Use
// (
// ro Ref(CoordSpace) _projection ,
// ro Ref(CoordSpace) _viewport ,
// ro Ref(CoordSpace) _objectTransform ,
// ro Ref(Vector3 ) _objectColor ,
// ro Ref(Vector3 ) _lightPosition ,
// ro Ref(Vector3 ) _lightColor ,
// ro Ref(Vector3 ) _viewPosition
// )
// {
// CoordSpace inverseTransform = Inverse(_viewport * _objectTransform);
// UseProgramShader(shaderID);
// SetUniformVariable_MVA(inverseModelSpaceID, 1, false, inverseTransform[0][0]);
// SetUniformVariable_MVA(modelSpaceID , 1, false, _objectTransform[0][0]);
// SetUniformVariable_MVA(projectionID , 1, false, _projection [0][0]);
// SetUniformVariable_MVA(viewportID , 1, false, _viewport [0][0]);
// SetUniformVariable_Vector3(lightPositionID, 1, _lightPosition[0]);
// SetUniformVariable_Vector3(objectColorID , 1, _objectColor [0]);
// SetUniformVariable_Vector3(lightColorID , 1, _lightColor [0]);
// SetUniformVariable_Vector3(viewPositionID, 1, _viewPosition[0]);
// EnableVertexAttributeArray(0);
// EnableVertexAttributeArray(1);
// //EnableVertexAttributeArray(2);
// return;
// }
// sfn Stop()
// {
// //DisableVertexAttributeArray(2);
// DisableVertexAttributeArray(1);
// DisableVertexAttributeArray(0);
// return;
// }
// Declarations
//private:
// ID<ShaderProgram> shaderID;
// ID<CoordSpace> modelSpaceID, inverseModelSpaceID, viewportID, projectionID;
// ID<Vec3> lightPositionID, viewPositionID, objectColorID, lightColorID;
// gInt vertexIndexID, normalIndexID;
//};
// Old
// Some Raw Source Defaults:
RawString<const char> RawVertextShaderSource =
"#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
RawString<const char> RawFragmentShaderSource =
"#version 400\n"
"out vec4 frag_colour;"
"void main() {"
" frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
"}";
// Default Shaders
ID<ShaderProgram> RawShader ,
SimpleShader ;
namespace SS_Transformed namespace SS_Transformed
{ {
ID<ShaderProgram> Shader; ID<ShaderProgram> Shader;
ID<CoordSpace> ScreenSpaceVarID; ID<CoordSpace> ScreenSpaceVarID;
sfn UpdateShader(Ref(CoordSpace) _screenSpace) sfn UpdateShader(ro Ref(CoordSpace) _screenSpace)
{ {
SetUniformVariable_MVA(ScreenSpaceVarID, 1, DGL::EBool::False, Address(_screenSpace[0][0])); SetUniformVariable_MVA(ScreenSpaceVarID, 1, false, _screenSpace[0][0]);
return; return;
} }
@ -385,23 +472,27 @@ namespace DGL
LightColorID = GetUniformVariable(Shader, "LightColor" ); LightColorID = GetUniformVariable(Shader, "LightColor" );
} }
sfn Use(Ref(CoordSpace) _cubeTransform, Ref(Vector3) _objectColor, Ref(Vector3) _lightColor)
{
UseProgramShader(Shader);
SetUniformVariable_MVA(ScreenSpaceVarID, 1, EBool::False, Address(_cubeTransform[0][0]));
SetUniformVariable_Vector3(ObjectColorID, 1, Address(_objectColor[0]));
SetUniformVariable_Vector3(LightColorID , 1, Address(_lightColor [0]));
EnableVertexAttributeArray(0);
EnableVertexAttributeArray(1);
}
sfn Stop() sfn Stop()
{ {
DisableVertexAttributeArray(0); DisableVertexAttributeArray(0);
DisableVertexAttributeArray(1); DisableVertexAttributeArray(1);
return;
}
sfn Use(Ref(CoordSpace) _cubeTransform, Ref(Vector3) _objectColor, Ref(Vector3) _lightColor)
{
UseProgramShader(Shader);
SetUniformVariable_MVA(ScreenSpaceVarID, 1, false, _cubeTransform[0][0]);
SetUniformVariable_Vector3(ObjectColorID, 1, _objectColor[0]);
SetUniformVariable_Vector3(LightColorID , 1, _lightColor [0]);
EnableVertexAttributeArray(0);
EnableVertexAttributeArray(1);
return;
} }
} }
@ -416,34 +507,50 @@ namespace DGL
Shader = LoadShaders("SimpleTransform.vert", "BasicLamp.frag"); Shader = LoadShaders("SimpleTransform.vert", "BasicLamp.frag");
ScreenSpaceVarID = GetUniformVariable(Shader, "ScreenSpaceTransform"); ScreenSpaceVarID = GetUniformVariable(Shader, "ScreenSpaceTransform");
return;
} }
sfn SetupLampRender(Ref(CoordSpace) _lampTransform) sfn Use(ro Ref(CoordSpace) _lampTransform)
{ {
UseProgramShader(Shader); UseProgramShader(Shader);
SetUniformVariable_MVA(ScreenSpaceVarID, 1, EBool::False, Address(_lampTransform[0][0])); SetUniformVariable_MVA(ScreenSpaceVarID, 1, false, _lampTransform[0][0]);
EnableVertexAttributeArray(0); EnableVertexAttributeArray(0);
EnableVertexAttributeArray(1); EnableVertexAttributeArray(1);
return;
} }
sfn Stop() sfn Stop()
{ {
DisableVertexAttributeArray(0); DisableVertexAttributeArray(0);
DisableVertexAttributeArray(1); DisableVertexAttributeArray(1);
return;
} }
} }
struct Material_Phong
{
VecColor Color ;
gFloat Ambience;
gFloat Diffuse ;
gFloat Specular;
};
namespace PhongShader namespace PhongShader
{ {
ID<ShaderProgram> ShaderID; ID<ShaderProgram> ShaderID;
ID<CoordSpace> ModelSpaceID, InverseModelSpaceID, ViewportID, ProjectionID; ID<CoordSpace> ModelSpaceID, InverseModelSpaceID, ViewportID, ProjectionID;
ID<Vec3> LightPositionID, ViewPositionID; ID<Vec3> LightPositionID, ObjectColorID, LightColorID;
ID<Vec3> ObjectColorID, LightColorID; ID<gFloat> AmbientStrengthID, DiffuseStrengthID, SpecularStrengthID;
gInt VertexIndexID, NormalIndexID;
sfn LoadShader() sfn LoadShader()
{ {
@ -457,55 +564,95 @@ namespace DGL
ObjectColorID = GetUniformVariable(ShaderID, "ObjectColor" ); ObjectColorID = GetUniformVariable(ShaderID, "ObjectColor" );
LightColorID = GetUniformVariable(ShaderID, "LightColor" ); LightColorID = GetUniformVariable(ShaderID, "LightColor" );
LightPositionID = GetUniformVariable(ShaderID, "LightPosition"); LightPositionID = GetUniformVariable(ShaderID, "LightPosition");
ViewPositionID = GetUniformVariable(ShaderID, "ViewPosition" );
AmbientStrengthID = GetUniformVariable(ShaderID, "AmbientStrength" );
DiffuseStrengthID = GetUniformVariable(ShaderID, "DiffuseStrength" );
SpecularStrengthID = GetUniformVariable(ShaderID, "SpecularStrength");
return;
} }
sfn Use sfn Use_Old
( (
Ref(CoordSpace) _projection , ro Ref(CoordSpace) _projection ,
Ref(CoordSpace) _viewport , ro Ref(CoordSpace) _viewport ,
Ref(CoordSpace) _objectTransform , ro Ref(CoordSpace) _objectTransform ,
Ref(Vector3 ) _objectColor , ro Ref(Vector3 ) _objectColor ,
Ref(Vector3 ) _lightPosition , ro Ref(Vector3 ) _lightPosition ,
Ref(Vector3 ) _lightColor , ro Ref(Vector3 ) _lightColor ,
Ref(Vector3 ) _viewPosition ro Ref(Vector3 ) _viewPosition
) )
{ {
CoordSpace inverseTransform = Inverse(_viewport * _objectTransform); CoordSpace inverseTransform = Inverse(_viewport * _objectTransform);
UseProgramShader(ShaderID); UseProgramShader(ShaderID);
SetUniformVariable_MVA(InverseModelSpaceID, 1, EBool::False, Address(inverseTransform[0][0])); SetUniformVariable_MVA(InverseModelSpaceID, 1, false, inverseTransform[0][0]);
SetUniformVariable_MVA(ModelSpaceID , 1, EBool::False, Address(_objectTransform[0][0])); SetUniformVariable_MVA(ModelSpaceID , 1, false, _objectTransform[0][0]);
SetUniformVariable_MVA(ProjectionID , 1, EBool::False, Address(_projection [0][0])); SetUniformVariable_MVA(ProjectionID , 1, false, _projection [0][0]);
SetUniformVariable_MVA(ViewportID , 1, EBool::False, Address(_viewport [0][0])); SetUniformVariable_MVA(ViewportID , 1, false, _viewport [0][0]);
SetUniformVariable_Vector3(LightPositionID, 1, Address(_lightPosition[0])); SetUniformVariable_Vector3(LightPositionID, 1, _lightPosition[0]);
SetUniformVariable_Vector3(ObjectColorID , 1, Address(_objectColor [0])); SetUniformVariable_Vector3(ObjectColorID , 1, _objectColor [0]);
SetUniformVariable_Vector3(LightColorID , 1, Address(_lightColor [0])); SetUniformVariable_Vector3(LightColorID , 1, _lightColor [0]);
SetUniformVariable_Vector3(ViewPositionID, 1, Address(_viewPosition[0]));
EnableVertexAttributeArray(0); EnableVertexAttributeArray(0);
EnableVertexAttributeArray(1); EnableVertexAttributeArray(1);
//EnableVertexAttributeArray(2);
return;
}
sfn Use
(
ro Ref(CoordSpace ) _projection ,
ro Ref(CoordSpace ) _viewport ,
ro Ref(CoordSpace ) _objectTransform ,
ro Ref(Vector3 ) _lightPosition ,
ro Ref(Vector3 ) _lightColor ,
ro Ref(Material_Phong) _material
)
{
CoordSpace inverseTransform = Inverse(_viewport * _objectTransform);
UseProgramShader(ShaderID);
SetUniformVariable_MVA(InverseModelSpaceID, 1, false, inverseTransform[0][0]);
SetUniformVariable_MVA(ModelSpaceID , 1, false, _objectTransform[0][0]);
SetUniformVariable_MVA(ProjectionID , 1, false, _projection [0][0]);
SetUniformVariable_MVA(ViewportID , 1, false, _viewport [0][0]);
SetUniformVariable_Vector3(LightPositionID, 1, _lightPosition[0]);
SetUniformVariable_Vector3(ObjectColorID , 1, _material.Color[0]);
SetUniformVariable_Vector3(LightColorID , 1, _lightColor [0]);
SetUniformVariable_Float(AmbientStrengthID , _material.Ambience);
SetUniformVariable_Float(DiffuseStrengthID , _material.Diffuse );
SetUniformVariable_Float(SpecularStrengthID, _material.Specular);
EnableVertexAttributeArray(0);
EnableVertexAttributeArray(1);
return;
} }
sfn Stop() sfn Stop()
{ {
//DisableVertexAttributeArray(2);
DisableVertexAttributeArray(1); DisableVertexAttributeArray(1);
DisableVertexAttributeArray(0); DisableVertexAttributeArray(0);
return;
} }
} }
sfn LoadRawShader() sfn LoadRawShader()
{ {
ID<Shader> VertexShader; ID<Shader> VertexShader = 0;
ID<Shader> FragmentShader; ID<Shader> FragmentShader = 0;
MakeShader(VertexShader , EShaderType::Vertex , 1, Address(DGL::RawVertextShaderSource ), NULL); MakeShader(VertexShader , EShaderType::Vertex , 1, Address(RawVertextShaderSource ), NULL);
MakeShader(FragmentShader, EShaderType::Fragment, 1, Address(DGL::RawFragmentShaderSource), NULL); MakeShader(FragmentShader, EShaderType::Fragment, 1, Address(RawFragmentShaderSource), NULL);
MakeShaderProgram(RawShader, VertexShader, FragmentShader); MakeShaderProgram(RawShader, VertexShader, FragmentShader);

View File

@ -6,19 +6,16 @@
#include <glm/ext/matrix_transform.hpp > #include <glm/ext/matrix_transform.hpp >
// DGL // DGL
#include "DGL_FundamentalTypes.hpp" #include "DGL_Types.hpp"
#include "DGL_MiscTypes.hpp"
// Non-Standard C++
#include "Cpp_Alias.hpp" #include "Cpp_Alias.hpp"
namespace DGL namespace DGL
{ {
using CoordSpace = Matrix4x4;
using Projection = Matrix4x4;
// Function // Function
@ -34,7 +31,7 @@ namespace DGL
} }
template<typename Type> template<typename Type>
sfn CreateLookAtView(const Generic::Vector3<Type> _viewPosition, const Generic::Vector3<Type> _lookAtPosition, const Generic::Vector3<Type> _upDirection) -> Matrix4x4 sfn CreateLookAtView(ro Ref(Generic::Vector3<Type>) _viewPosition, ro Ref(Generic::Vector3<Type>) _lookAtPosition, ro Ref(Generic::Vector3<Type>) _upDirection) -> Matrix4x4
{ {
return glm::lookAt(_viewPosition, _lookAtPosition, _upDirection); return glm::lookAt(_viewPosition, _lookAtPosition, _upDirection);
} }
@ -45,43 +42,43 @@ namespace DGL
} }
template<typename FloatType> template<typename FloatType>
sfn CreatePerspective(const FloatType _fieldOfView, const FloatType _aspectRatio, const FloatType _nearPlane, const FloatType _farPlane) sfn CreatePerspective(FloatType _fieldOfView, FloatType _aspectRatio, FloatType _nearPlane, FloatType _farPlane)
{ {
return glm::perspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane); return glm::perspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane);
} }
sfn GetCrossNormal(Vector3 _subj, Vector3 _ref) -> Vector3 sfn GetCrossNormal(ro Ref(Vector3) _subj, ro Ref(Vector3) _ref) -> Vector3
{ {
return glm::cross(_subj, _ref); return glm::cross(_subj, _ref);
} }
sfn GetDirection(Vector3 _vectorSpecified) sfn GetDirection(ro Ref(Vector3) _vectorSpecified)
{ {
return glm::normalize(_vectorSpecified); return glm::normalize(_vectorSpecified);
} }
sfn Inverse(const Matrix4x4 _matrix) sfn Inverse(ro Ref(Matrix4x4) _matrix)
{ {
return glm::inverse(_matrix); return glm::inverse(_matrix);
} }
sfn Rotate(const Matrix4x4 _matrix, gFloat _rotationAngleAmount, Vector3 _axis) -> Matrix4x4 sfn Rotate(ro Ref(Matrix4x4) _matrix, gFloat _rotationAngleAmount, ro Ref(Vector3) _axis) -> Matrix4x4
{ {
return glm::rotate(_matrix, _rotationAngleAmount, _axis); return glm::rotate(_matrix, _rotationAngleAmount, _axis);
} }
sfn Scale(const Matrix4x4 _matrix, Vector3 _scaleBy) sfn Scale(ro Ref(Matrix4x4) _matrix, ro Ref(Vector3) _scaleBy)
{ {
return glm::scale(_matrix, _scaleBy); return glm::scale(_matrix, _scaleBy);
} }
template<typename Type> template<typename Type>
sfn ToRadians(const Ref(Type) _degrees) -> Type sfn ToRadians(Type _degrees) -> Type
{ {
return glm::radians(_degrees); return glm::radians(_degrees);
} }
sfn Translate(const Matrix4x4 _matrix, Vector3 _translationAmount) sfn Translate(ro Ref(Matrix4x4) _matrix, ro Ref(Vector3) _translationAmount)
{ {
return glm::translate(_matrix, _translationAmount); return glm::translate(_matrix, _translationAmount);
} }
@ -109,7 +106,7 @@ namespace DGL
UpDirection ( 0, 1, 0), UpDirection ( 0, 1, 0),
FrontDirection( 0, 0, 1) ; FrontDirection( 0, 0, 1) ;
gFloat ScreenWidth = 720.0f, ScreenHeight = 540.0f, ScreenCenterWidth = ScreenWidth / 2, ScreenCenterHeight = ScreenHeight / 2; gInt ScreenWidth = 720, ScreenHeight = 540, ScreenCenterWidth = ScreenWidth / 2, ScreenCenterHeight = ScreenHeight / 2;
} }
struct Camera struct Camera
@ -129,11 +126,11 @@ namespace DGL
( (
gFloat _aspectRatio , gFloat _aspectRatio ,
gFloat _fieldOfView , gFloat _fieldOfView ,
ClippingPlanes _clippingPlanes, ro Ref(ClippingPlanes) _clippingPlanes,
Vector3 _position , ro Ref(Vector3 ) _position ,
Vector3 _lookAtPosition, ro Ref(Vector3 ) _lookAtPosition,
Vector3 _upDirection , ro Ref(Vector3 ) _upDirection ,
Vector3 _frontDirection ro Ref(Vector3 ) _frontDirection
) : ) :
AspectRatio (_aspectRatio ), AspectRatio (_aspectRatio ),
FieldOfView (_fieldOfView ), FieldOfView (_fieldOfView ),
@ -143,11 +140,11 @@ namespace DGL
UpDirection (_upDirection ), UpDirection (_upDirection ),
FrontDirection(_frontDirection) FrontDirection(_frontDirection)
{ {
Yaw = -90.0f; Pitch = 0; Roll = 0; Yaw = -90.0f; Pitch = 0.0f; Roll = 0.0f;
UpdateCamera(); UpdateCamera();
Orthographic = CreateOrthographic(0.0f, DefaultSpace::ScreenWidth, 0.0f, DefaultSpace::ScreenHeight, ClipSpace.Near, ClipSpace.Far); Orthographic = CreateOrthographic(0.0f, gFloat(DefaultSpace::ScreenWidth), 0.0f, gFloat(DefaultSpace::ScreenHeight), ClipSpace.Near, ClipSpace.Far);
Perspective = CreatePerspective<gFloat>(ToRadians(FieldOfView), AspectRatio, ClipSpace.Near, ClipSpace.Far); Perspective = CreatePerspective<gFloat>(ToRadians(FieldOfView), AspectRatio, ClipSpace.Near, ClipSpace.Far);
} }
@ -202,7 +199,7 @@ namespace DGL
return; return;
} }
sfn Move(Vector3 _translationAmount, Ref(gFloat) _deltaTime) sfn Move(ro Ref(Vector3) _translationAmount, gFloat _deltaTime)
{ {
Position += _translationAmount * _deltaTime; Position += _translationAmount * _deltaTime;

117
DGL_Types.hpp Normal file
View File

@ -0,0 +1,117 @@
/*
Title : Ducktaped GL: Types
Author: Edward R. Gonzalez
Description:
Provides type definitions and aliases for the various types used in DGL library.
*/
#pragma once
// GLEW
#include <glew.h>
// GLFW
#include <glfw3.h>
// GLM
#include <glm/glm.hpp>
// C++
#include "Cpp_Alias.hpp"
namespace DGL
{
// OpenGL
// Fundamental Types
using gBitfield = GLbitfield;
using gBoolean = GLboolean ;
using gChar = GLchar ;
using gFloat = GLfloat ;
using gFloatClamped = GLclampf ;
using gInt = GLint ;
using gUInt = GLuint ;
using gSize = GLsizei ;
using gVoid = GLvoid ;
using DataPtr = ptr<gVoid>;
// Type used to indicate the context of an integer used as an ID for an object managed by OpenGL.
template<typename ReferenceType>
using ID = gUInt;
// ID Reference Types
class ElementBuffer;
class Matrix ;
class NormalBuffer ;
class Shader ;
class ShaderProgram;
class TextureBuffer;
class Vec3 ;
class VertexArray ;
class VertexBuffer ;
// GLM
namespace Generic
{
template<typename Type>
using Vector3 = glm::tvec3<Type>;
template<typename Type>
using Vector2 = glm::tvec2<Type>;
}
using Matrix4x4 = glm::mat4;
using CoordSpace = Matrix4x4;
using Projection = Matrix4x4;
using Vector2 = glm::vec2;
using Vector3 = glm::vec3;
using Vector4 = glm::vec4;
using UVList = std::vector < Vector2>;
using Vec2Int = Generic::Vector2< gUInt >;
using Vec3Int = Generic::Vector3< gUInt >;
using VertexList = std ::vector < Vector3>;
// GLFW
using Monitor = GLFWmonitor ;
using TimeValInt = uint64_t ;
using TimeValDec = double ;
using Window = GLFWwindow ;
using WindowRefList = std::vector< ptr<Window> >;
// DGL
using VecColor = Vector3;
struct LinearColor
{
gFloatClamped Red, Green, Blue, Alpha;
LinearColor(gFloatClamped _red, gFloatClamped _green, gFloatClamped _blue, gFloatClamped _alpha) :
Red(_red), Green(_green), Blue(_blue), Alpha(_alpha) {};
sfn Vector() -> Vector3
{
return Vector3(Red, Green, Blue);
}
};
using VIndexList = std ::vector < gInt >;
}

301
DGL_Utilities.hpp Normal file
View File

@ -0,0 +1,301 @@
#pragma once
// GLFW, GLEW, GLM
#include <glew.h >
#include <glfw3.h >
#include <glm/glm.hpp >
#include <glm/gtc/matrix_transform.hpp>
// DGL
#include "DGL_Types.hpp"
#include "DGL_Enum.hpp"
#include "DGL_Shader.hpp"
#include "DGL_Buffers.hpp"
#include "DGL_Space.hpp"
#include "DGL_Model.hpp"
// Non-Standard C+
#include "Cpp_Alias.hpp"
namespace DGL
{
// Object Instances
WindowRefList Windows;
// Constants
sfn constexpr NotShared () -> ptr<Window > { return NULL; }
sfn constexpr WindowedMode() -> ptr<Monitor> { return NULL; }
// Forward Declarations
sfn SwapBuffers(ro ptr<Window> _window) -> void;
// Functionality
sfn CanClose(ro ptr<Window> _theWindow)
{
return glfwWindowShouldClose(_theWindow);
}
sfn CanUseRawMouse()
{
return glfwRawMouseMotionSupported();
}
sfn CreateWindow
(
int _width ,
int _height ,
ro RawString<ro char> _title ,
ro ptr <Monitor> _monitorToFullscreen ,
ro ptr <Window > _windowToShareResourcesWith
)
-> ptr<Window>
{
Windows.push_back(glfwCreateWindow(_width, _height, _title, _monitorToFullscreen, _windowToShareResourcesWith));
if (Windows.back() == NULL)
{
throw std::runtime_error("Failed to create a window");
}
return Windows.back();
}
sfn CursorPositionUpdateBind(ro ptr<Window> _window, ro FnPtr<void, double, double> _functionToCall)
{
glfwSetCursorPosCallback(_window, GLFWcursorposfun(_functionToCall));
}
sfn DestoryWindow(ro ptr<Window> _window)
{
using ElementType = decltype(Windows.begin());
for (ElementType element = Windows.begin(); element != Windows.end(); element++)
{
if (Dref(element._Ptr) == _window)
{
glfwDestroyWindow(_window);
Windows.erase(element);
return;
}
}
return;
}
sfn EnableDepth()
{
// TODO: Clean.
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
}
sfn GetCursorPosition(ro ptr<Window> _window, ro ptr<double> _xAxis, ro ptr<double> _yAxis)
{
glfwGetCursorPos(_window, _xAxis, _yAxis);
}
sfn GetMouseInputMode(ro ptr<Window> _contextWindowRef, EMouseMode _mode)
{
return glfwGetInputMode(_contextWindowRef, GLenum(_mode));
}
sfn GetRawTime() -> TimeValInt
{
return glfwGetTimerValue();
}
sfn GetTime() -> TimeValDec
{
return glfwGetTime();
}
sfn InitalizeGLFW()
{
std::cout << "Initializing GLFW Version: " << glfwGetVersionString() << std::endl;
/* Initialize the library */
if (!glfwInit())
{
throw std::runtime_error("Failed to initialize GLFW");
}
return;
}
sfn InitalizeGLEW()
{
// If using GLEW version 1.13 or earlier
//glewExperimental = true;
std::cout << "Initializing Glew Version: " << glewGetString(GLEW_VERSION) << std::endl;
GLenum err = glewInit();
if (err != GLEW_OK)
{
// Problem: glewInit failed, something is seriously wrong.
std::cout << "glewInit failed: " << glewGetErrorString(err) << std::endl;
throw std::runtime_error("Failed to initialize GLFW");
}
cout << "OpenGL Version: " << glGetString(GL_VERSION) << endl;
}
sfn KeyPressed(ro ptr<Window> _contextWindowRef, EKeyCodes _keyToCheck) -> bool
{
return glfwGetKey(_contextWindowRef, int(_keyToCheck));
}
template<typename... CodeType, typename = EKeyCodes>
sfn KeysPressed(ro ptr<Window> _contextWindowRef, CodeType... _otherKeys) -> bool
{
return (KeyPressed(_contextWindowRef, _otherKeys) && ...) == true;
}
sfn PollEvents()
{
glfwPollEvents();
return;
}
sfn ResetCursor(ro ptr<Window> _window, gUInt _screenCenterWidth, gUInt _screenCenterHeight)
{
//glfwSetCursorPos(_window, _screenCenterWidth, _screenCenterHeight);
ECursorMode cursorMode = ECursorMode(GetMouseInputMode(_window, EMouseMode::Cursor));
if (cursorMode == ECursorMode::Normal || cursorMode == ECursorMode::Hidden) // Normal Cursor Mode
{
glfwSetCursorPos(_window, double(_screenCenterWidth), double(_screenCenterHeight));
}
else // Raw Cursor mode
{
glfwSetCursorPos(_window, 0, 0);
}
return;
}
sfn SetClearColor(ro Ref(LinearColor) _colorToSet)
{
glClearColor(_colorToSet.Red, _colorToSet.Green, _colorToSet.Blue, _colorToSet.Alpha);
return;
}
sfn SetCurrentContext(ro ptr<Window> _window)
{
glfwMakeContextCurrent(_window);
ptr< RawString<const char> > ErrorMsg = NULL;
int code = glfwGetError(ErrorMsg);
if (code == GLFW_NO_WINDOW_CONTEXT)
{
throw std::runtime_error(Dref(ErrorMsg));
}
return;
}
template<typename ModeParam>
sfn SetInputMode(ro ptr<Window> _window, EMouseMode _mouseMode, ModeParam _modeParam)
{
glfwSetInputMode(_window, GLenum(_mouseMode), GLenum(_modeParam));
return;
}
sfn SetPolygonMode(EFace _desiredFaces, ERenderMode _desiredMode)
{
glPolygonMode(GLenum(_desiredFaces), GLenum(_desiredMode));
return;
}
sfn SwapBuffers(ro ptr<Window> _window) -> void
{
glfwSwapBuffers(_window);
return;
}
sfn TerminateGLFW()
{
glfwTerminate();
return;
}
// Old Tape
[[deprecated]]
sfn RunBasicWindowLoop(ro ptr<Window> _window)
{
/* Loop until the user closes the window */
while (not CanClose(_window))
{
ClearBuffer(EFrameBuffer::Color);
SwapBuffers(_window);
PollEvents();
}
return;
}
[[deprecated]]
sfn RunBasicWindowLoop_Timed(ro ptr<Window> _window, TimeValDec _interval, ro Delegate< Func<void>> _renderProcedure)
{
TimeValDec start, end, deltaSinceClear = 0.0;
while (not CanClose(_window))
{
start = GetTime();
if (deltaSinceClear > _interval)
{
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();
SwapBuffers(_window);
PollEvents();
}
end = GetTime();
deltaSinceClear = deltaSinceClear + end - start;
}
return;
}
}

View File

@ -1,21 +1,29 @@
// Cpp STL /*
// Project
*/
// DGL
#include "DGL.hpp" #include "DGL.hpp"
#include "Actions.hpp"
#include "Testing.hpp"
// Utility
#include "Actions.hpp"
// Non-Standard C++
#include "Cpp_Alias.hpp" #include "Cpp_Alias.hpp"
namespace Execution namespace Execution
{ {
inline namespace Alias inline namespace LibraryReferences
{ {
// DGL // DGL
using DGL::Camera ; using DGL::EBool ;
using DGL::ECursorMode ; using DGL::ECursorMode ;
using DGL::EDirection ; using DGL::EDirection ;
using DGL::EFrameBuffer ; using DGL::EFrameBuffer ;
@ -23,21 +31,27 @@ namespace Execution
using DGL::EMouseMode ; using DGL::EMouseMode ;
using DGL::EPrimitives ; using DGL::EPrimitives ;
using DGL::ERotationAxis; using DGL::ERotationAxis;
using DGL::Camera ;
using DGL::Entity_Basic ;
using DGL::gFloat ; using DGL::gFloat ;
using DGL::Light_Basic ;
using DGL::LinearColor ; using DGL::LinearColor ;
using DGL::Material_Phong;
using DGL::Matrix ; using DGL::Matrix ;
using DGL::Matrix4x4 ; using DGL::Matrix4x4 ;
using DGL::Model ;
using DGL::TimeValDec ; using DGL::TimeValDec ;
using DGL::Vector3 ; using DGL::Vector3 ;
using DGL::Window ; using DGL::Window ;
using DGL::SimpleShader; using DGL::BindVertexArray ;
using DGL::CanUseRawMouse ; using DGL::CanUseRawMouse ;
using DGL::ClearBuffer ; using DGL::ClearBuffer ;
using DGL::CreateWindow ; using DGL::CreateWindow ;
using DGL::BindVertexArray ; using DGL::DestoryWindow ;
using DGL::DisableVertexAttributeArray; using DGL::DisableVertexAttributeArray;
using DGL::EnableDepth ;
using DGL::EnableVertexAttributeArray ; using DGL::EnableVertexAttributeArray ;
using DGL::GetCursorPosition ; using DGL::GetCursorPosition ;
using DGL::GetTime ; using DGL::GetTime ;
@ -80,7 +94,7 @@ namespace Execution
TimeValDec CycleStart , // Snapshot of cycle loop start time. TimeValDec CycleStart , // Snapshot of cycle loop start time.
CycleEnd , // Snapshot of cycle loop end time. CycleEnd , // Snapshot of cycle loop end time.
DeltaTime , // Delta between last cycle start and end. DeltaTime , // Delta between last cycle start and end.
InputInterval = 1.0f / 400.0f, // Interval per second to complete the input process of the cycle. InputInterval = 1.0f / 480.0f, // Interval per second to complete the input process of the cycle.
PhysicsInterval = 1.0f / 240.0f, // Interval per second to complete the physics process of the cycle. PhysicsInterval = 1.0f / 240.0f, // Interval per second to complete the physics process of the cycle.
RenderInterval = 1.0f / 144.0f ; // Interval per second to complete the render process of the cycle. RenderInterval = 1.0f / 144.0f ; // Interval per second to complete the render process of the cycle.
@ -99,41 +113,76 @@ namespace Execution
ActionQueue ActionsToComplete; // Actions queue to run during the physics process of the cycle. ActionQueue ActionsToComplete; // Actions queue to run during the physics process of the cycle.
Model objectModel("torus.obj"); // Hardcoded to specified obj file for now.
Material_Phong ObjectMaterial;
Light_Basic Light ; // Hardcoded light. Rotates around object.
Entity_Basic ObjectToView; // Object that will be currently in the middle with the light source rotating.
// Functionality // Functionality
// Temp fix for now... not sure how to make proper action handling that can reference member function delegates...
sfn RotateCamera(ERotationAxis _rotationAxis, gFloat _rotationAmount, gFloat _delta)
// Input Action common functions...
sfn RotateCamera(ERotationAxis _rotationAxis, gFloat _rotationAmount, double _delta)
{ {
WorldCamera.Rotate(_rotationAxis, _rotationAmount, _delta); WorldCamera.Rotate(_rotationAxis, _rotationAmount, gFloat(_delta));
} }
deduce RotateCamDelegate = Delegate<decltype(RotateCamera)>(RotateCamera); deduce RotateCamDelegate = Delegate<decltype(RotateCamera)>(RotateCamera);
sfn MoveCamera(EDirection _direction, gFloat _translationAmount, gFloat _delta)
sfn MoveCamera(EDirection _direction, gFloat _translationAmount, double _delta)
{ {
WorldCamera.Move(_direction, _translationAmount, _delta); WorldCamera.Move(_direction, _translationAmount, gFloat(_delta));
} }
deduce MoveCamDelegate = Delegate<decltype(MoveCamera)>(MoveCamera); deduce MoveCamDelegate = Delegate<decltype(MoveCamera)>(MoveCamera);
// End of temp stuff...
// This is here cause its super repetitive..
sfn ModifyCamSpeed(bool _isPositive, double _delta)
{
if (_isPositive)
{
CamMoveSpeed += CamMoveSpeed * gFloat(_delta);
}
else
{
CamMoveSpeed -= CamMoveSpeed * gFloat(_delta);
}
}
deduce ModifyCamSpeedDelegate = Delegate<decltype(ModifyCamSpeed)>(ModifyCamSpeed);
deduce SetPolyModeDelegate = Delegate<decltype(SetPolygonMode)>(SetPolygonMode);
// End of common input functions...
// Currently Does everything required before entering the cycler. // Currently Does everything required before entering the cycler.
sfn PrepWorkspace() sfn PrepWorkspace()
{ {
// Baseline
InitalizeGLFW(); InitalizeGLFW();
DefaultWindow = CreateWindow(ScreenWidth, ScreenHeight, "Assignment 1: Lighting Test", WindowedMode(), NotShared()); DefaultWindow = CreateWindow(ScreenWidth, ScreenHeight, "Assignment 1: Loading Model...", WindowedMode(), NotShared());
SetCurrentContext(DefaultWindow); SetCurrentContext(DefaultWindow);
InitalizeGLEW(); // Glew must initialize only after a context is set. InitalizeGLEW(); // Glew must initialize only after a context is set.
EnableDepth();
SetPolygonMode(DGL::EFace::Front_and_Back, DGL::ERenderMode::Fill);
// Cursor stuff // Cursor stuff
SetInputMode(DefaultWindow, DGL::EMouseMode::Cursor, DGL::ECursorMode::Disable); SetInputMode(DefaultWindow, DGL::EMouseMode::Cursor, DGL::ECursorMode::Disable);
@ -147,25 +196,23 @@ namespace Execution
// End of cursor stuff... // End of cursor stuff...
// Shaders
LoadDefaultShaders(); LoadDefaultShaders();
//PrepareRenderObjects(); // Entities
SetPolygonMode(DGL::EFace::Front_and_Back, DGL::ERenderMode::Fill); Light.Load();
RAW_MakeCube(); objectModel.Load ();
objectModel.Buffer();
RAW_MakeLightVAO(); ObjectMaterial.Color = DGL::Colors::GreyColor.Vector();
ObjectMaterial.Ambience = 0.01f ;
ObjectMaterial.Diffuse = 1.0f ;
ObjectMaterial.Specular = 0.4f ;
ProperCube::Setup(); ObjectToView = Entity_Basic(objectModel, ObjectMaterial);
// TODO: Clean THIS
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
} }
@ -176,7 +223,7 @@ namespace Execution
Cycler is hardcoded to exit if escape key is pressed. Cycler is hardcoded to exit if escape key is pressed.
*/ */
sfn Cycler(Delegate< Func<void, ptr<Window>> > _inputProcedure, Delegate< Func<void>> _physicsProcedure, Delegate< Func<void>> _renderProcedure) sfn Cycler(ro Ref(Delegate< Func<void, ptr<Window>> >) _inputProcedure, ro Ref(Delegate< Func<void>>) _physicsProcedure, ro Ref(Delegate< Func<void>>) _renderProcedure)
{ {
while (Exist) while (Exist)
{ {
@ -199,8 +246,6 @@ namespace Execution
{ {
ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight); ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight);
} }
InputDelta = 0.0;
} }
if (PhysicsDelta >= PhysicsInterval) if (PhysicsDelta >= PhysicsInterval)
@ -228,6 +273,11 @@ namespace Execution
RenderDelta = 0.0; RenderDelta = 0.0;
} }
if (InputDelta >= InputInterval)
{
InputDelta = 0.0;
}
CycleEnd = GetTime(); CycleEnd = GetTime();
DeltaTime = CycleEnd - CycleStart; DeltaTime = CycleEnd - CycleStart;
@ -240,24 +290,10 @@ namespace Execution
return; return;
} }
sfn ModifyCamSpeed(bool _isPositive, gFloat _delta)
{
if (_isPositive)
{
CamMoveSpeed += CamMoveSpeed * _delta;
}
else
{
CamMoveSpeed -= CamMoveSpeed * _delta;
}
}
deduce ModifyCamSpeedDelegate = Delegate<decltype(ModifyCamSpeed)>(ModifyCamSpeed);
deduce SetPolyModeDelegate = Delegate<decltype(SetPolygonMode)>(SetPolygonMode);
sfn InputProcedure(ptr<Window> _currentWindowContext) sfn InputProcedure(ptr<Window> _currentWindowContext)
{ {
if (KeysPressed(_currentWindowContext, EKeyCodes::LeftShift, EKeyCodes::F1)) if (KeyPressed(_currentWindowContext, EKeyCodes::F1))
{ {
ECursorMode cursorMode = ECursorMode(GetMouseInputMode(DefaultWindow, EMouseMode::Cursor)); ECursorMode cursorMode = ECursorMode(GetMouseInputMode(DefaultWindow, EMouseMode::Cursor));
@ -304,12 +340,12 @@ namespace Execution
{ {
if (CursorX != 0) if (CursorX != 0)
{ {
ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Yaw, CursorX * CamRotationSpeed, PhysicsDelta); ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Yaw, gFloat(CursorX) * CamRotationSpeed, PhysicsDelta);
} }
if (CursorY != 0) if (CursorY != 0)
{ {
ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Pitch, CursorY * CamRotationSpeed, PhysicsDelta); ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Pitch, gFloat(CursorY) * CamRotationSpeed, PhysicsDelta);
} }
} }
@ -365,15 +401,25 @@ namespace Execution
} }
std::string windowTitle = "Assignment 1", deltaStr = "Delta: ", inputDeltaStr = "Input Delta: ", physicsDeltaStr = "Physics Delta: ", renderDeltaStr = "RenderDeltaStr: "; std::string
windowTitle = "Assignment 1" ,
deltaStr = "Delta: " ,
inputDeltaStr = "Input Delta: " ,
physicsDeltaStr = "Physics Delta: " ,
renderDeltaStr = "RenderDeltaStr: " ;
std::stringstream somethingtoupdate; std::stringstream somethingtoupdate;
sfn UpdateThisShit() sfn UpdateWindowDeltaTitle()
{ {
somethingtoupdate.str(""); somethingtoupdate.str("");
somethingtoupdate << windowTitle << " " << deltaStr << DeltaTime << " " << inputDeltaStr << InputDelta << " " << physicsDeltaStr << PhysicsDelta << " " << renderDeltaStr << RenderDelta; somethingtoupdate
<< windowTitle << " "
<< deltaStr << DeltaTime << " "
<< inputDeltaStr << InputDelta << " "
<< physicsDeltaStr << PhysicsDelta << " "
<< renderDeltaStr << RenderDelta ;
} }
sfn PhysicsProcedure() sfn PhysicsProcedure()
@ -382,26 +428,20 @@ namespace Execution
UpdateScreenspace(); UpdateScreenspace();
DGL::SS_Transformed::UpdateShader(Screenspace); Light.Update();
//RAW_RotateLitCube(PhysicsDelta); ObjectToView.Update();
RAW_UpdateLightTransform(PhysicsDelta); UpdateWindowDeltaTitle();
ProperCube::Rotate(PhysicsDelta);
UpdateThisShit();
} }
sfn RenderProcedure() -> void sfn RenderProcedure() -> void
{ {
glfwSetWindowTitle(DefaultWindow, somethingtoupdate.str().c_str()); glfwSetWindowTitle(DefaultWindow, somethingtoupdate.str().c_str());
RAW_RenderLight(WorldCamera.Perspective, WorldCamera.Viewport); Light.Render(WorldCamera.Perspective, WorldCamera.Viewport);
ProperCube::Render(WorldCamera.Perspective, WorldCamera.Viewport, WorldCamera.Position); ObjectToView.Render(WorldCamera.Perspective, WorldCamera.Viewport, Light.GetPosition(), Light.GetColor());
} }
@ -414,6 +454,10 @@ namespace Execution
Cycler(InputProcedure, PhysicsProcedure, RenderProcedure); Cycler(InputProcedure, PhysicsProcedure, RenderProcedure);
// TODO: There should be more to properly close...
DestoryWindow(DefaultWindow);
TerminateGLFW(); TerminateGLFW();
return ExitCode::Success; return ExitCode::Success;
@ -421,7 +465,7 @@ namespace Execution
} }
// Currently only can do one execution route.
int main(void) int main(void)
{ {
return int(Execution::Execute()); return int(Execution::Execute());

View File

@ -5,11 +5,13 @@ out vec4 FragColor;
in vec3 FragPosition ; in vec3 FragPosition ;
in vec3 Normal ; in vec3 Normal ;
in vec3 LightViewPosition; in vec3 LightViewPosition;
in vec3 LightRawPos ;
uniform vec3 ObjectColor ; uniform vec3 ObjectColor ;
uniform vec3 LightColor ; uniform vec3 LightColor ;
uniform vec3 ViewPosition;
uniform float AmbientStrength ;
uniform float DiffuseStrength ;
uniform float SpecularStrength;
@ -17,30 +19,26 @@ void main()
{ {
// Ambient // Ambient
float ambientStrength = 0.1; vec3 ambient = AmbientStrength * LightColor ;
vec3 ambient = ambientStrength * LightColor ;
// Diffuse // Diffuse
vec3 direction = normalize(Normal ); vec3 direction = normalize(Normal );
vec3 lightDirection = normalize(LightViewPosition - FragPosition); vec3 lightDirection = normalize(LightViewPosition - FragPosition);
float diffuseStrength = max(dot(direction, lightDirection), 0.0); float diffuseMagnitude = max(dot(direction, lightDirection), 0.0);
vec3 diffuse = diffuseStrength * LightColor ;
vec3 diffuse = DiffuseStrength * diffuseMagnitude * LightColor;
// Specular // Specular
float specularStrength = 0.5;
// vec3 viewDirection = normalize(ViewPosition - FragPosition);
vec3 viewDirection = normalize(-FragPosition); vec3 viewDirection = normalize(-FragPosition);
vec3 reflectionDirection = reflect(-lightDirection, direction); vec3 reflectionDirection = reflect(-lightDirection, direction);
float spec = pow(max(dot(viewDirection, reflectionDirection), 0.0), 32); float spec = pow(max(dot(viewDirection, reflectionDirection), 0.0), 32);
vec3 specular = specularStrength * spec * LightColor; vec3 specular = SpecularStrength * spec * LightColor;
// Combining // Combining

View File

@ -1,13 +1,16 @@
#version 330 core #version 330 core
layout (location = 0) in vec3 VertPosition; #define VertexIndex 0
layout (location = 1) in vec3 VertNormal ; #define NormalIndex 1
layout (location = 2) in vec3 VertTexture ; #define TextureIndex 2
layout (location = VertexIndex ) in vec3 VertPosition;
layout (location = NormalIndex ) in vec3 VertNormal ;
layout (location = TextureIndex) in vec3 VertTexture ;
out vec3 FragPosition ; out vec3 FragPosition ;
out vec3 Normal ; out vec3 Normal ;
out vec3 LightViewPosition; out vec3 LightViewPosition;
out vec3 LightRawPos;
uniform mat4 InverseModelSpace; uniform mat4 InverseModelSpace;
@ -25,9 +28,7 @@ void main()
FragPosition = vec3(Viewport * ModelSpace * vec4(VertPosition, 1.0)); FragPosition = vec3(Viewport * ModelSpace * vec4(VertPosition, 1.0));
Normal = mat3(transpose(inverse(Viewport * ModelSpace))) * VertNormal; Normal = mat3(transpose(inverse(InverseModelSpace))) * VertNormal;
LightViewPosition = vec3(Viewport * vec4(LightPosition, 1.0)); LightViewPosition = vec3(Viewport * vec4(LightPosition, 1.0));
LightRawPos = LightPosition;
} }

View File

@ -182,14 +182,14 @@ TriTexCoords textureCoords =
sfn RAW_SetupBuffers() sfn RAW_SetupBuffers()
{ {
DGL::GenerateVertexBuffers(Address(VertexArrayObj ), 1); DGL::GenerateVertexBuffers(VertexArrayObj , 1);
DGL::GenerateBuffers (Address(VertexBufferObj), 1); DGL::GenerateBuffers (VertexBufferObj, 1);
DGL::GenerateBuffers (Address(ElemBufferObj ), 1); DGL::GenerateBuffers (ElemBufferObj , 1);
} }
sfn RAW_SetupTriangleBuffer() sfn RAW_SetupTriangleBuffer()
{ {
DGL::GenerateBuffers(Address(VertexBufferObj), 1); DGL::GenerateBuffers(VertexBufferObj, 1);
} }
sfn RAW_BindAndBufferDataToIDs() sfn RAW_BindAndBufferDataToIDs()
@ -200,11 +200,11 @@ sfn RAW_BindAndBufferDataToIDs()
//GL::BufferData<TriangleRaw>(Address(EquilateralTriangleVerticies), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw); //GL::BufferData<TriangleRaw>(Address(EquilateralTriangleVerticies), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
DGL::BufferData<RectangleCompressed>(Address(rectCompress), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw); DGL::BufferData<RectangleCompressed>(rectCompress, EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
DGL::BindBuffer(EBufferTarget::VertexIndices, ElemBufferObj); DGL::BindBuffer(EBufferTarget::VertexIndices, ElemBufferObj);
DGL::BufferData<RectangleIndices>(Address(rectIndices), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw); DGL::BufferData<RectangleIndices>(rectIndices, EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
} }
DGL::gInt VertexAttributeIndex = 0; // See shader source: (layout = 0). DGL::gInt VertexAttributeIndex = 0; // See shader source: (layout = 0).
@ -229,7 +229,7 @@ sfn CreateWindow_BasicLoop()
DGL::SetCurrentContext(windowObj); DGL::SetCurrentContext(windowObj);
DGL::RunBasicWindowLoop(windowObj); //DGL::RunBasicWindowLoop(windowObj);
} }
sfn CreateWindow_TimedRender() sfn CreateWindow_TimedRender()
@ -272,41 +272,7 @@ struct CubeElements
Edge3 front, right, back, left, bottom, top; Edge3 front, right, back, left, bottom, top;
}; };
CubeVerts DefaultCube =
{
// Front
{-1.0f, -1.0f, 1.0f},
{ 1.0f, -1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f},
{-1.0f, 1.0f, 1.0f},
// Back
{-1.0f, -1.0f, -1.0f},
{ 1.0f, -1.0f, -1.0f},
{ 1.0f, 1.0f, -1.0f},
{-1.0f, 1.0f, -1.0f}
};
CubeElements DefaultCubeElements =
{
// Front
{ { 0, 1, 2 }, { 2, 3, 0 } },
// Right
{ { 1, 5, 6 }, { 6, 2, 1 } },
// Back
{ { 7, 6, 5 }, { 5, 4, 7 } },
// Left
{ { 4, 0, 3 }, { 3, 7, 4 } },
// Bottom
{ { 4, 5, 1 }, { 1, 0, 4 } },
// Top
{ { 3, 2, 6 }, { 6, 7, 3 } }
};
using DGL::CoordSpace; using DGL::CoordSpace;
@ -324,24 +290,24 @@ ID<ElementBuffer> CubeModelElements;
sfn RAW_MakeCube() sfn RAW_MakeCube()
{ {
DGL::GenerateVertexBuffers(Address(CubeVAO ), 1); DGL::GenerateVertexBuffers(CubeVAO , 1);
DGL::GenerateBuffers (Address(CubeModelBuffer ), 1); DGL::GenerateBuffers (CubeModelBuffer , 1);
DGL::GenerateBuffers (Address(CubeModelElements), 1); DGL::GenerateBuffers (CubeModelElements, 1);
DGL::BindVertexArray(CubeVAO); DGL::BindVertexArray(CubeVAO);
DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer); DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer);
DGL::BufferData<CubeVerts>(Address(DefaultCube), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw); DGL::BufferData<CubeVerts>(DefaultCube, EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
DGL::BindBuffer(EBufferTarget::VertexIndices, CubeModelElements); DGL::BindBuffer(EBufferTarget::VertexIndices, CubeModelElements);
DGL::BufferData<CubeElements>(Address(DefaultCubeElements), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw); DGL::BufferData<CubeElements>(DefaultCubeElements, EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::False); DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), false);
DGL::EnableVertexAttributeArray(0); DGL::EnableVertexAttributeArray(0);
} }
@ -350,18 +316,19 @@ sfn RAW_RenderCube()
{ {
DGL::BindBuffer(EBufferTarget::VertexIndices, CubeModelElements); DGL::BindBuffer(EBufferTarget::VertexIndices, CubeModelElements);
gInt Size; GetBufferParameterIV(EBufferTarget::VertexIndices, DGL::EBufferParam::Size, Address(Size)); gInt SizeRef; GetBufferParameterIV(EBufferTarget::VertexIndices, DGL::EBufferParam::Size, SizeRef);
Size /= sizeof(unsigned int); SizeRef /= sizeof(unsigned int);
DGL::DrawElements(DGL::EPrimitives::Triangles, Size, EDataType::UnsignedInt, ZeroOffset()); DGL::DrawElements(DGL::EPrimitives::Triangles, SizeRef, EDataType::UnsignedInt, ZeroOffset());
} }
LinearColor CoralColor(1.0f, 0.5f, 0.31f, 1.0f); LinearColor CoralColor(1.0f, 0.5f, 0.31f, 1.0f);
LinearColor SomeColor(0.60f, 0.60f, 0.60f, 1.0f);
LinearColor LightColor(1.0f, 1.0f, 1.0f , 1.0f); LinearColor LightColor(1.0f, 1.0f, 1.0f , 1.0f);
Vector3 LightPosition(1.2f, 1.0f, 1.75f); Vector3 LightPosition(0, 0, 0);
Vector3 LightScale = Vector3(0.2f); Vector3 LightScale = Vector3(0.2f);
@ -369,18 +336,20 @@ Vector3 result = LightColor.Vector() * CoralColor.Vector();
CoordSpace LightTransform = Matrix4x4(1.0f); CoordSpace LightTransform = Matrix4x4(1.0f);
gFloat TranslationScale = 4.0f;
ID<VertexArray> LightVAO; ID<VertexArray> LightVAO;
sfn RAW_MakeLightVAO() sfn RAW_MakeLightVAO()
{ {
DGL::GenerateVertexBuffers(Address(LightVAO), 1); DGL::GenerateVertexBuffers(LightVAO, 1);
DGL::BindVertexArray(LightVAO); DGL::BindVertexArray(LightVAO);
DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer ); DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer );
DGL::BindBuffer(EBufferTarget::VertexIndices , CubeModelElements); DGL::BindBuffer(EBufferTarget::VertexIndices , CubeModelElements);
DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::False); DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), false);
DGL::EnableVertexAttributeArray(0); DGL::EnableVertexAttributeArray(0);
@ -390,7 +359,7 @@ sfn RAW_MakeLightVAO()
sfn RAW_UpdateLightTransform(gFloat _delta) sfn RAW_UpdateLightTransform(gFloat _delta)
{ {
static bool test = true; /*static bool test = true;
LightTransform = CoordSpace(1.0f); LightTransform = CoordSpace(1.0f);
@ -417,7 +386,17 @@ sfn RAW_UpdateLightTransform(gFloat _delta)
LightTransform = DGL::Translate(LightTransform, LightPosition); LightTransform = DGL::Translate(LightTransform, LightPosition);
LightTransform = DGL::Scale (LightTransform, LightScale ); LightTransform = DGL::Scale (LightTransform, LightScale );
} }*/
LightTransform = CoordSpace(1.0f);
LightPosition.x = TranslationScale * sin(DGL::GetTime());
LightPosition.z = TranslationScale * cos(DGL::GetTime());
LightTransform = DGL::Translate(LightTransform, LightPosition);
LightTransform = DGL::Scale (LightTransform, LightScale );
} }
@ -427,7 +406,7 @@ sfn RAW_RenderLight(CoordSpace _projection, CoordSpace _viewport)
{ {
deduce screenspaceTransform = _projection * _viewport * LightTransform; deduce screenspaceTransform = _projection * _viewport * LightTransform;
DGL::Basic_LampShader::SetupLampRender(screenspaceTransform); DGL::Basic_LampShader::Use(screenspaceTransform);
DGL::BindVertexArray(LightVAO); DGL::BindVertexArray(LightVAO);
@ -450,21 +429,21 @@ ID<VertexArray> LitCubeVAO;
sfn RAW_MakeLitCube() sfn RAW_MakeLitCube()
{ {
DGL::GenerateVertexBuffers(Address(LitCubeVAO), 1); DGL::GenerateVertexBuffers(LitCubeVAO, 1);
DGL::BindVertexArray(LitCubeVAO); DGL::BindVertexArray(LitCubeVAO);
DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer ); DGL::BindBuffer(EBufferTarget::VertexAttributes, CubeModelBuffer );
DGL::BindBuffer(EBufferTarget::VertexIndices , CubeModelElements); DGL::BindBuffer(EBufferTarget::VertexIndices , CubeModelElements);
DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::False); DGL::FormatVertexAttributes<Vertex3>(0, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), false);
DGL::EnableVertexAttributeArray(0); DGL::EnableVertexAttributeArray(0);
} }
sfn RAW_RotateLitCube(gFloat _delta) sfn RAW_RotateLitCube(gFloat _delta)
{ {
LitCubeTransform = DGL::Rotate(LitCubeTransform, RotationRate * _delta, Vector3(0.0f, 1.0f, 0.0f)); //LitCubeTransform = DGL::Rotate(LitCubeTransform, RotationRate * _delta, Vector3(0.0f, 1.0f, 0.0f));
} }
sfn RAW_RenderLitCube(CoordSpace _projection, CoordSpace _viewport) sfn RAW_RenderLitCube(CoordSpace _projection, CoordSpace _viewport)
@ -473,8 +452,6 @@ sfn RAW_RenderLitCube(CoordSpace _projection, CoordSpace _viewport)
Vector3 lightColor = LightColor.Vector(); Vector3 lightColor = LightColor.Vector();
//DGL::PhongShader::SetupRender(screenspaceTransform, LitCubeTransform, CubeColor, LightPosition, lightColor);
DGL::BindVertexArray(LitCubeVAO); DGL::BindVertexArray(LitCubeVAO);
RAW_RenderCube(); RAW_RenderCube();
@ -486,11 +463,11 @@ using DGL::NormalBuffer;
namespace ProperCube namespace ProperCube
{ {
Model model("topology.obj"); Model model("blenderCube2.obj");
Vector3 position = Vector3(0.0f); Vector3 position = Vector3(0.0f);
Vector3 color = CoralColor.Vector(); Vector3 color = SomeColor.Vector();
CoordSpace transform = Matrix4x4(1.0f); CoordSpace transform = Matrix4x4(1.0f);
@ -498,7 +475,7 @@ namespace ProperCube
sfn Rotate(gFloat _delta) sfn Rotate(gFloat _delta)
{ {
transform = DGL::Rotate(transform, 0.75f * _delta, Vector3(0, 1, 0)); //transform = DGL::Rotate(transform, 0.75f * _delta, Vector3(0, 1, 0));
} }
sfn Render(Ref(CoordSpace) _projection, Ref(CoordSpace) _viewport, Ref(Vector3) _cameraPosition) sfn Render(Ref(CoordSpace) _projection, Ref(CoordSpace) _viewport, Ref(Vector3) _cameraPosition)
@ -507,7 +484,7 @@ namespace ProperCube
Vector3 lightColor = LightColor.Vector(); Vector3 lightColor = LightColor.Vector();
DGL::PhongShader::Use DGL::PhongShader::Use_Old
( (
_projection , _projection ,
_viewport , _viewport ,

24
blenderCube2.obj Normal file
View File

@ -0,0 +1,24 @@
# Blender v2.80 (sub 74) 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
s off
f 5 3 1
f 3 8 4
f 7 6 8
f 2 8 6
f 1 4 2
f 5 2 6
f 5 7 3
f 3 7 8
f 7 5 6
f 2 4 8
f 1 3 4
f 5 1 2