ed/DuctTaped_GL
1
0
Fork 0
mirror of https://github.com/Ed94/DuctTaped_GL.git synced 2024-11-12 21:34:53 -08:00
Code Issues Packages Projects Releases Wiki Activity

Appied some gafting tape, getting ready to do lighting as well.

Browse Source
This commit is contained in:
Edward R. Gonzalez 2020-02-15 22:32:26 -05:00
parent b3b81b65fe
commit 98851f32a4
11 changed files with 731 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
Actions.hpp Normal file
View File

@ -0,0 +1,119 @@
/*
Title : Actions
Author: Edward R. Gonzalez
Description: This was a little experiment of mine to mess with action binding...
Allows for non-member functions to be binded to an action, implements a functioning queue as well.
TODO: Possibly add support for member functions. Have it so that deduction of delegate typef is not required to add to queue properly (right now it does, see input procedure for example);
*/
#pragma once
#include "Cpp_Alias.hpp"
namespace Actions
{
struct IAction
{
virtual void DoAction() = NULL;
};
template<typename FunctionType, typename... ActionParams>
struct AAction : IAction
{
using ActionType = Delegate< FunctionType >;
public:
AAction(ActionType _actionToAssign, ActionParams... _params) :
action(_actionToAssign),
params(_params...)
{};
private:
using IndexType = DataSize;
void DoAction_Implementation(ActionParams... _params) { action(_params...); }
template<IndexType... TuplePackIndex> // TuplePackSequence<TuplePackIndex...>
void ExpandTuple_CallDoActionImplementaiton(const Ref(Tuple<ActionParams...>) _paramsToExpand, std::index_sequence <TuplePackIndex...>)
{
// ExpandTuplePack<TuplePackIndex>
DoAction_Implementation(std::get <TuplePackIndex>(_paramsToExpand)...);
}
Tuple<ActionParams...> params;
ActionType action;
public: // IAction
virtual void DoAction() override
{
ExpandTuple_CallDoActionImplementaiton
(
params,
// MakeTuplePackSequence <ActionParams...>()
std::index_sequence_for<ActionParams...>()
);
};
};
struct ActionQueue
{
sfn HasAction()
{
return actionQueue.size() > 0;
}
template<typename FunctionType, typename... ActionParams>
sfn AddToQueue(Delegate< FunctionType> _actionToQueue, ActionParams... _paramsForAction)
{
// This is extremely inefficient, but in order to fix requires an object pool or something else...
SPtr< AAction<FunctionType, ActionParams...> > ptrToAction = MakeSPtr< AAction<FunctionType, ActionParams...> >(_actionToQueue, _paramsForAction...);
if (HasAction())
{
bool found = false;
using Element = decltype(actionQueue.begin());
for (Element element = actionQueue.begin(); element != actionQueue.end(); element++)
{
if ((*element).get() == ptrToAction.get())
{
found = true;
}
}
if (not found)
{
actionQueue.push_front(std::move(ptrToAction));
}
}
else
{
actionQueue.push_front(std::move(ptrToAction));
}
}
sfn DoNextAction()
{
if (actionQueue.size() > 0)
{
actionQueue.back()->DoAction();
actionQueue.pop_back();
}
}
using QueueType = std::deque< SPtr<IAction>>;
QueueType actionQueue;
};
}

63
Cpp_Alias.hpp
View File

@ -12,19 +12,22 @@ This merely removes the need to use operators I don't like and wraps them in eas
#pragma once #pragma once
#include <algorithm> #include <algorithm >
#include <cstdarg> #include <chrono >
#include <exception> #include <cstdarg >
#include <fstream> #include <exception >
#include <iostream> #include <fstream >
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <chrono>
#include <thread>
#include <memory>
#include <functional> #include <functional>
#include <iostream >
#include <memory >
#include <queue >
#include <sstream >
#include <stdexcept >
#include <string >
#include <vector >
#include <thread >
#include <tuple >
#include <utility >
@ -43,12 +46,15 @@ _type&
_type&& _type&&
// Aliases // Aliases
// Fundamental // Fundamental
using uInt64 = unsigned long long int; using uInt64 = unsigned long long int;
// Pointers // Pointers
template<typename Type> template<typename Type>
@ -63,12 +69,31 @@ 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
template<typename CharType> template<typename CharType>
using RawString = ptr<CharType>; using RawString = ptr<CharType>;
using std::cout;
using std::endl;
using DataSize = std::size_t;
using Thread = std::thread;
template<typename... ObjectTypes>
using Tuple = std::tuple<ObjectTypes...>;
// Enum // Enum
enum class ExitCode enum class ExitCode
@ -78,6 +103,7 @@ enum class ExitCode
}; };
// Functions // Functions
// Ptr // Ptr
@ -94,6 +120,19 @@ sfn Dref(ptr<Type> _type) -> Ref(Type)
return *_type; return *_type;
} }
template<typename Type, typename... ParamTypes>
sfn MakeUPtr(rRef(ParamTypes)... _params) -> UPtr<Type>
{
return std::make_unique<Type>(_params...);
}
template<typename Type, typename... ParamTypes>
sfn MakeSPtr(rRef(ParamTypes)... _params) -> SPtr<Type>
{
return std::make_shared<Type>(_params...);
}
// Exit // Exit

93
DGL.hpp
View File

@ -1,12 +1,12 @@
#pragma once #pragma once
// GL // GLFW, GLEW, GLM
//#include <gl/GLU.h> #include <glew.h >
#include <glew.h> #include <glfw3.h >
#include <glfw3.h> #include <glm/glm.hpp >
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
// DGL
#include "DGL_FundamentalTypes.hpp" #include "DGL_FundamentalTypes.hpp"
#include "DGL_MiscTypes.hpp" #include "DGL_MiscTypes.hpp"
#include "DGL_Enum.hpp" #include "DGL_Enum.hpp"
@ -63,6 +63,11 @@ namespace DGL
return glfwWindowShouldClose(_theWindow); return glfwWindowShouldClose(_theWindow);
} }
sfn CanUseRawMouse()
{
return glfwRawMouseMotionSupported();
}
sfn CreateWindow sfn CreateWindow
( (
int _width, int _width,
@ -92,6 +97,11 @@ namespace DGL
return Windows.back(); return Windows.back();
} }
sfn CursorPositionUpdateBind(ptr<Window> _window, FnPtr<void, double, double> _functionToCall)
{
glfwSetCursorPosCallback(_window, GLFWcursorposfun(_functionToCall));
}
sfn DestoryWindow(const ptr<Window> _window) sfn DestoryWindow(const ptr<Window> _window)
{ {
using ElementType = decltype(Windows.begin()); using ElementType = decltype(Windows.begin());
@ -109,16 +119,6 @@ namespace DGL
return; return;
} }
sfn CanUseRawMouse()
{
return glfwRawMouseMotionSupported();
}
sfn CursorPositionUpdateBind(ptr<Window> _window, FnPtr<void, double, double> _functionToCall)
{
glfwSetCursorPosCallback(_window, GLFWcursorposfun(_functionToCall));
}
sfn DrawArrays(EPrimitives _primitive, gInt _startingIndex, gInt _numToRender) sfn DrawArrays(EPrimitives _primitive, gInt _startingIndex, gInt _numToRender)
{ {
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.
@ -129,15 +129,9 @@ namespace DGL
glDrawElements(GLenum(_primitive), _numElements, GLenum(_dataType), _offfsetAddressFromFirstIndex); glDrawElements(GLenum(_primitive), _numElements, GLenum(_dataType), _offfsetAddressFromFirstIndex);
} }
sfn KeyPressed(ptr<Window> _contextWindowRef, EKeyCodes _keyToCheck) -> bool sfn GetCursorPosition(ptr<Window> _window, ptr<double> _xAxis, ptr<double> _yAxis)
{ {
return glfwGetKey(_contextWindowRef, int(_keyToCheck)) ; glfwGetCursorPos(_window, _xAxis, _yAxis);
}
template<typename... CodeType, typename = EKeyCodes>
sfn KeysPressed(ptr<Window> _contextWindowRef, CodeType... _otherKeys) -> bool
{
return ( KeyPressed(_contextWindowRef, _otherKeys) && ... ) == true;
} }
sfn GetMouseInputMode(ptr<Window> _contextWindowRef, EMouseMode _mode) sfn GetMouseInputMode(ptr<Window> _contextWindowRef, EMouseMode _mode)
@ -145,27 +139,14 @@ namespace DGL
return glfwGetInputMode(_contextWindowRef, GLenum(_mode)); return glfwGetInputMode(_contextWindowRef, GLenum(_mode));
} }
sfn GetTime() -> TimeValDec
{
return glfwGetTime();
}
sfn GetRawTime() -> TimeValInt sfn GetRawTime() -> TimeValInt
{ {
return glfwGetTimerValue(); return glfwGetTimerValue();
} }
sfn GetCursorPosition(ptr<Window> _window, ptr<double> _xAxis, ptr<double> _yAxis) sfn GetTime() -> TimeValDec
{ {
glfwGetCursorPos(_window, _xAxis, _yAxis); return glfwGetTime();
}
sfn ResetCursor(ptr<Window> _window, gFloat _screenCenterWidth, gFloat _screenCenterHeight)
{
glfwSetCursorPos(_window, _screenCenterWidth, _screenCenterHeight);
glfwSetCursorPos(_window, 0, 0);
} }
sfn InitalizeGLFW() sfn InitalizeGLFW()
@ -219,6 +200,17 @@ namespace DGL
} }
} }
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() sfn PollEvents()
{ {
glfwPollEvents(); glfwPollEvents();
@ -226,6 +218,14 @@ namespace DGL
return; return;
} }
sfn ResetCursor(ptr<Window> _window, gFloat _screenCenterWidth, gFloat _screenCenterHeight)
{
glfwSetCursorPos(_window, _screenCenterWidth, _screenCenterHeight);
glfwSetCursorPos(_window, 0, 0);
}
sfn RunBasicWindowLoop(const ptr<Window> _window) sfn RunBasicWindowLoop(const ptr<Window> _window)
{ {
/* Loop until the user closes the window */ /* Loop until the user closes the window */
@ -280,17 +280,6 @@ namespace DGL
glClearColor(_colorToSet.Red, _colorToSet.Green, _colorToSet.Blue, _colorToSet.Alpha); glClearColor(_colorToSet.Red, _colorToSet.Green, _colorToSet.Blue, _colorToSet.Alpha);
} }
template<typename ModeParam>
sfn SetInputMode(ptr<Window> _window, EMouseMode _mouseMode, ModeParam _modeParam)
{
glfwSetInputMode(_window, GLenum(_mouseMode), GLenum(_modeParam));
}
sfn RunTimingLoop()
{
return;
}
sfn SetCurrentContext(const ptr<Window> _window) sfn SetCurrentContext(const ptr<Window> _window)
{ {
try try
@ -316,6 +305,12 @@ namespace DGL
return; 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) sfn SetPolygonMode(EFace _desiredFaces, ERenderMode _desiredMode)
{ {
glPolygonMode(GLenum(_desiredFaces), GLenum(_desiredMode)); glPolygonMode(GLenum(_desiredFaces), GLenum(_desiredMode));

45
DGL_Enum.hpp
View File

@ -12,33 +12,12 @@ namespace DGL
X, Y, Z X, Y, Z
}; };
enum class ERotationAxis
{
Pitch, Yaw, Roll
};
enum class EBool enum class EBool
{ {
True = GL_TRUE , True = GL_TRUE ,
False = GL_FALSE False = GL_FALSE
}; };
enum class EMouseMode
{
Cursor = GLFW_CURSOR ,
RawMouse = GLFW_RAW_MOUSE_MOTION ,
StickyKeys = GLFW_STICKY_KEYS ,
StickMouse = GLFW_STICKY_MOUSE_BUTTONS,
LockKey = GLFW_LOCK_KEY_MODS ,
};
enum class ECursorMode
{
Normal = GLFW_CURSOR_NORMAL ,
Hidden = GLFW_CURSOR_HIDDEN ,
Disable = GLFW_CURSOR_DISABLED
};
enum class EBufferTarget enum class EBufferTarget
{ {
VertexAttributes = GL_ARRAY_BUFFER , VertexAttributes = GL_ARRAY_BUFFER ,
@ -78,6 +57,13 @@ namespace DGL
None = GL_NONE None = GL_NONE
}; };
enum class ECursorMode
{
Normal = GLFW_CURSOR_NORMAL ,
Hidden = GLFW_CURSOR_HIDDEN ,
Disable = GLFW_CURSOR_DISABLED
};
enum class EDataType enum class EDataType
{ {
Byte = GL_BYTE , Byte = GL_BYTE ,
@ -126,7 +112,8 @@ namespace DGL
Q = GLFW_KEY_Q , Q = GLFW_KEY_Q ,
S = GLFW_KEY_S , S = GLFW_KEY_S ,
W = GLFW_KEY_W , W = GLFW_KEY_W ,
LeftShift = GLFW_KEY_LEFT_SHIFT LeftShift = GLFW_KEY_LEFT_SHIFT,
Escape = GLFW_KEY_ESCAPE
}; };
enum class EKeyState enum class EKeyState
@ -156,6 +143,15 @@ namespace DGL
LinearToLinear = GL_LINEAR_MIPMAP_LINEAR LinearToLinear = GL_LINEAR_MIPMAP_LINEAR
}; };
enum class EMouseMode
{
Cursor = GLFW_CURSOR ,
RawMouse = GLFW_RAW_MOUSE_MOTION ,
StickyKeys = GLFW_STICKY_KEYS ,
StickMouse = GLFW_STICKY_MOUSE_BUTTONS,
LockKey = GLFW_LOCK_KEY_MODS ,
};
enum class ERenderMode enum class ERenderMode
{ {
Point = GL_POINT, Point = GL_POINT,
@ -163,7 +159,10 @@ namespace DGL
Fill = GL_FILL Fill = GL_FILL
}; };
enum class ERotationAxis
{
Pitch, Yaw, Roll
};
enum class EPrimitives enum class EPrimitives
{ {

10
DGL_MiscTypes.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
// OpenGL // OpenGL
#include <glew.h> #include <glew.h >
#include <glm/detail/type_vec3.hpp> #include <glm/detail/type_vec3.hpp>
@ -37,11 +37,11 @@ namespace DGL
// ID Reference Types // ID Reference Types
class Buffer; class Buffer ;
class Matrix; class Matrix ;
class Shader; class Shader ;
class ShaderProgram; class ShaderProgram;
class VertexBuffer; class VertexBuffer ;
class ElementBuffer; class ElementBuffer;
using Matrix4x4 = glm::mat4; using Matrix4x4 = glm::mat4;

1
DGL_Primitive.hpp
View File

@ -4,7 +4,6 @@
namespace DGL namespace DGL
{ {

118
DGL_Shader.hpp
View File

@ -36,19 +36,17 @@ namespace DGL
// Default Shaders // Default Shaders
ID<ShaderProgram> RawShader , ID<ShaderProgram> RawShader ,
SimpleShader , SimpleShader ;
SimpleShader_Transformed ;
ID<CoordSpace> ScreenSpaceVarID;
// 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 , 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; sfn MakeShaderProgram(Ref(ID<ShaderProgram>) _shaderProgramIDHolder, const ID<Shader> _vertexShader , const ID<Shader> _fragShader ) -> void;
@ -60,7 +58,7 @@ namespace DGL
glGetProgramiv(_shaderToQueryForUniforms, GL_ACTIVE_UNIFORMS, &uniforms); glGetProgramiv(_shaderToQueryForUniforms, GL_ACTIVE_UNIFORMS, &uniforms);
for (int i = 0; i < uniforms; i++) for (int uniformIndex = 0; uniformIndex < uniforms; uniformIndex++)
{ {
int name_len = -1, num = -1; int name_len = -1, num = -1;
@ -68,7 +66,7 @@ namespace DGL
char name[100]; char name[100];
glGetActiveUniform(_shaderToQueryForUniforms, GLuint(i), sizeof(name) - 1, &name_len, &num, &type, name); glGetActiveUniform(_shaderToQueryForUniforms, GLuint(uniformIndex), sizeof(name) - 1, &name_len, &num, &type, name);
name[name_len] = 0; name[name_len] = 0;
} }
@ -264,47 +262,6 @@ namespace DGL
} }
} }
sfn LoadRawShader()
{
ID<Shader> VertexShader ;
ID<Shader> FragmentShader;
MakeShader(VertexShader , EShaderType::Vertex , 1, Address(DGL::RawVertextShaderSource ), NULL);
MakeShader(FragmentShader, EShaderType::Fragment, 1, Address(DGL::RawFragmentShaderSource), NULL);
DGL::MakeShaderProgram(RawShader, VertexShader, FragmentShader);
DGL::DeleteShader(VertexShader );
DGL::DeleteShader(FragmentShader);
return;
}
sfn LoadSimpleShader()
{
SimpleShader = LoadShaders("SimpleVertexShader.vert", "SimpleFragmentShader.frag");
return;
}
sfn LoadSimpleShader_Transformed()
{
SimpleShader_Transformed = LoadShaders("SimpleTransform.vert", "SingleColor.frag");
ScreenSpaceVarID = DGL::GetUniformVariable(DGL::SimpleShader_Transformed, "modelViewProjection");
return;
}
sfn LoadDefaultShaders()
{
LoadRawShader ();
LoadSimpleShader ();
LoadSimpleShader_Transformed();
return;
}
sfn MakeShader sfn MakeShader
( (
Ref(ID<Shader>) _shaderIDHolder , Ref(ID<Shader>) _shaderIDHolder ,
@ -363,7 +320,8 @@ namespace DGL
return; return;
} }
sfn SetUniformVariable_MatrixVariableArray(const ID<Matrix> _matrixID, const gSize _numMatricies, const EBool _shouldTransposeValues, ptr<const float> _dataPtr) // MVA: MatrixVariableArray
sfn SetUniformVariable_MVA(const ID<Matrix> _matrixID, const gSize _numMatricies, const EBool _shouldTransposeValues, ptr<const float> _dataPtr)
{ {
glUniformMatrix4fv(_matrixID, _numMatricies, GLenum(_shouldTransposeValues), _dataPtr); glUniformMatrix4fv(_matrixID, _numMatricies, GLenum(_shouldTransposeValues), _dataPtr);
@ -376,4 +334,60 @@ namespace DGL
return; return;
} }
namespace SS_Transformed
{
ID<ShaderProgram> Shader;
ID<CoordSpace> ScreenSpaceVarID;
sfn UpdateShader(Ref(CoordSpace) _screenSpace)
{
SetUniformVariable_MVA(ScreenSpaceVarID, 1, DGL::EBool::False, Address(_screenSpace[0][0]));
return;
}
sfn LoadShader()
{
Shader = LoadShaders("SimpleTransform.vert", "SingleColor.frag");
ScreenSpaceVarID = DGL::GetUniformVariable(Shader, "ScreenSpaceTransform");
return;
}
}
sfn LoadRawShader()
{
ID<Shader> VertexShader;
ID<Shader> FragmentShader;
MakeShader(VertexShader, EShaderType::Vertex, 1, Address(DGL::RawVertextShaderSource), NULL);
MakeShader(FragmentShader, EShaderType::Fragment, 1, Address(DGL::RawFragmentShaderSource), NULL);
MakeShaderProgram(RawShader, VertexShader, FragmentShader);
DeleteShader(VertexShader);
DeleteShader(FragmentShader);
return;
}
sfn LoadSimpleShader()
{
SimpleShader = LoadShaders("SimpleVertexShader.vert", "SimpleFragmentShader.frag");
return;
}
sfn LoadDefaultShaders()
{
LoadRawShader ();
LoadSimpleShader();
SS_Transformed::LoadShader ();
return;
}
} }

101
DGL_Space.hpp
View File

@ -1,6 +1,11 @@
#pragma once #pragma once
// GLM
#include <glm/glm.hpp >
#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp >
// DGL
#include "DGL_FundamentalTypes.hpp" #include "DGL_FundamentalTypes.hpp"
#include "DGL_MiscTypes.hpp" #include "DGL_MiscTypes.hpp"
@ -45,9 +50,14 @@ namespace DGL
return glm::perspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane); return glm::perspective(_fieldOfView, _aspectRatio, _nearPlane, _farPlane);
} }
sfn Translate(const Matrix4x4 _matrix, Vector3 _translationAmount) sfn GetCrossNormal(Vector3 _subj, Vector3 _ref) -> Vector3
{ {
return glm::translate(_matrix, _translationAmount); return glm::cross(_subj, _ref);
}
sfn GetDirection(Vector3 _vectorSpecified)
{
return glm::normalize(_vectorSpecified);
} }
sfn Rotate(const Matrix4x4 _matrix, gFloat _rotationAngleAmount, Vector3 _axis) -> Matrix4x4 sfn Rotate(const Matrix4x4 _matrix, gFloat _rotationAngleAmount, Vector3 _axis) -> Matrix4x4
@ -61,14 +71,9 @@ namespace DGL
return glm::radians(_degrees); return glm::radians(_degrees);
} }
sfn GetCrossNormal(Vector3 _subj, Vector3 _ref) -> Vector3 sfn Translate(const Matrix4x4 _matrix, Vector3 _translationAmount)
{ {
return glm::cross(_subj, _ref); return glm::translate(_matrix, _translationAmount);
}
sfn GetDirection(Vector3 _vectorSpecified)
{
return glm::normalize(_vectorSpecified);
} }
@ -97,8 +102,6 @@ namespace DGL
gFloat ScreenWidth = 720.0f, ScreenHeight = 540.0f, ScreenCenterWidth = ScreenWidth / 2, ScreenCenterHeight = ScreenHeight / 2; gFloat ScreenWidth = 720.0f, ScreenHeight = 540.0f, ScreenCenterWidth = ScreenWidth / 2, ScreenCenterHeight = ScreenHeight / 2;
} }
using std::cout; using std::endl;
struct Camera struct Camera
{ {
gFloat AspectRatio, FieldOfView, Yaw, Pitch, Roll; gFloat AspectRatio, FieldOfView, Yaw, Pitch, Roll;
@ -130,16 +133,10 @@ namespace DGL
UpDirection (_upDirection ), UpDirection (_upDirection ),
FrontDirection(_frontDirection) FrontDirection(_frontDirection)
{ {
std::cout << UpDirection.x << ", " << UpDirection.y << ", " << UpDirection.z << std::endl;
Yaw = -90.0f; Pitch = 0; Roll = 0; Yaw = -90.0f; Pitch = 0; Roll = 0;
//Yaw = 0;
UpdateCamera(); UpdateCamera();
std::cout << UpDirection.x << ", " << UpDirection.y << ", " << UpDirection.z << std::endl;
Orthographic = CreateOrthographic(0.0f, DefaultSpace::ScreenWidth, 0.0f, DefaultSpace::ScreenHeight, ClipSpace.Near, ClipSpace.Far); Orthographic = CreateOrthographic(0.0f, DefaultSpace::ScreenWidth, 0.0f, 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);
@ -152,49 +149,37 @@ namespace DGL
{ {
case EDirection::Up: case EDirection::Up:
{ {
Position += UpDirection * _translationAmount * _deltaTime; Position -= UpDirection * _translationAmount * _deltaTime;
LookAtPosition += UpDirection * _translationAmount * _deltaTime;
break; break;
} }
case EDirection::Down: case EDirection::Down:
{ {
Position -= UpDirection * _translationAmount * _deltaTime; Position += UpDirection * _translationAmount * _deltaTime;
LookAtPosition -= UpDirection * _translationAmount * _deltaTime;
break; break;
} }
case EDirection::Left: case EDirection::Left:
{ {
Position += GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime; Position -= GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime;
//LookAtPosition += GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime;
break; break;
} }
case EDirection::Right: case EDirection::Right:
{ {
Position -= GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime; Position += GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime;
//LookAtPosition -= GetDirection(GetCrossNormal(FrontDirection, UpDirection)) * _translationAmount * _deltaTime;
break; break;
} }
case EDirection::Forward: case EDirection::Forward:
{ {
Position -= FrontDirection * _translationAmount * _deltaTime; Position += FrontDirection * _translationAmount * _deltaTime;
LookAtPosition -= FrontDirection * _translationAmount * _deltaTime;
break; break;
} }
case EDirection::Backward: case EDirection::Backward:
{ {
Position += FrontDirection * _translationAmount * _deltaTime; Position -= FrontDirection * _translationAmount * _deltaTime;
LookAtPosition += FrontDirection * _translationAmount * _deltaTime;
break; break;
} }
@ -203,11 +188,15 @@ namespace DGL
throw std::logic_error("Direction move not defined."); throw std::logic_error("Direction move not defined.");
} }
} }
return;
} }
sfn Move(Vector3 _translationAmount, Ref(gFloat) _deltaTime) sfn Move(Vector3 _translationAmount, Ref(gFloat) _deltaTime)
{ {
Position += _translationAmount * _deltaTime; Position += _translationAmount * _deltaTime;
return;
} }
sfn Rotate(ERotationAxis _pivot, gFloat _rotationAmount, gFloat _deltaTime) sfn Rotate(ERotationAxis _pivot, gFloat _rotationAmount, gFloat _deltaTime)
@ -227,8 +216,6 @@ namespace DGL
Pitch = -89.9f; Pitch = -89.9f;
} }
//std::cout << "Pitch: " << Pitch << std::endl;
break; break;
} }
case ERotationAxis::Roll: case ERotationAxis::Roll:
@ -250,34 +237,16 @@ namespace DGL
{ {
Yaw += _rotationAmount * _deltaTime; Yaw += _rotationAmount * _deltaTime;
/*if (Yaw > 89.9f)
{
Yaw = 89.9f;
}
else if (Yaw < -89.9f)
{
Pitch = -89.9f;
}*/
//std::cout << "Yaw: " << Yaw << std::endl;
break; break;
} }
} }
return;
/*std::cout << "Front Direction: " << FrontDirection.x << ", " << FrontDirection.y << ", " << FrontDirection.z << std::endl;
std::cout << "Right Direction: " << RightDirection.x << ", " << RightDirection.y << ", " << RightDirection.z << std::endl;
std::cout << "Up Direction: " << UpDirection.x << ", " << UpDirection.y << ", " << UpDirection.z << std::endl;*/
} }
sfn UpdateCamera() -> void sfn UpdateCamera() -> void
{ {
//cout << Pitch << Yaw << Roll << endl;
//cout << "Cosine: " << Cosine(ToRadians(Yaw)) << endl;
FrontDirection.x = Cosine(ToRadians(Yaw )) * Cosine(ToRadians(Pitch)); FrontDirection.x = Cosine(ToRadians(Yaw )) * Cosine(ToRadians(Pitch));
FrontDirection.y = Sine (ToRadians(Pitch)) ; FrontDirection.y = Sine (ToRadians(Pitch)) ;
FrontDirection.z = Sine (ToRadians(Yaw )) * Cosine(ToRadians(Pitch)); FrontDirection.z = Sine (ToRadians(Yaw )) * Cosine(ToRadians(Pitch));
@ -286,19 +255,11 @@ namespace DGL
RightDirection = GetDirection(GetCrossNormal(FrontDirection, DefaultSpace::UpDirection )); RightDirection = GetDirection(GetCrossNormal(FrontDirection, DefaultSpace::UpDirection ));
UpDirection = GetDirection(GetCrossNormal(RightDirection, FrontDirection)); UpDirection = GetDirection(GetCrossNormal(RightDirection, FrontDirection));
//Matrix4x4 mRoll = glm::rotate(mRoll , Roll , DefaultSpace::FrontDirection); LookAtPosition = Position + FrontDirection;
//Matrix4x4 mPitch = glm::rotate(mPitch, Pitch, DefaultSpace::RightDirection);
//Matrix4x4 mYaw = glm::rotate(mYaw , Roll , DefaultSpace::UpDirection );
//Matrix4x4 rotation = mPitch * mYaw; Viewport = CreateLookAtView(Position, LookAtPosition, UpDirection);
Viewport = CreateLookAtView(Position, LookAtPosition - FrontDirection, UpDirection); return;
//glm::mat4 translate = glm::mat4(1.0f);
//translate = glm::translate(translate, -LookAtPosition);
//Viewport = rotation * translate;
} }
}; };
@ -321,9 +282,9 @@ namespace DGL
sfn UpdateScreenspace() sfn UpdateScreenspace()
{ {
//Screenspace = WorldCamera.Perspective * WorldCamera.Viewport * WorldSpace; Screenspace = WorldCamera.Perspective * WorldCamera.Viewport * WorldSpace;
return;
} }
} }
} }

412
Execution.cpp
View File

@ -2,225 +2,212 @@
// Project // Project
#include "DGL.hpp" #include "DGL.hpp"
#include "TriangleRaw.hpp" #include "Actions.hpp"
#include "Testing.hpp"
#include "Cpp_Alias.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 namespace Execution
{ {
// C++ STL inline namespace Alias
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...); // DGL
using DGL::Camera ;
using DGL::ECursorMode ;
using DGL::EDirection ;
using DGL::EFrameBuffer ;
using DGL::EKeyCodes ;
using DGL::EMouseMode ;
using DGL::EPrimitives ;
using DGL::ERotationAxis;
using DGL::gFloat ;
using DGL::LinearColor ;
using DGL::Matrix ;
using DGL::Matrix4x4 ;
using DGL::TimeValDec ;
using DGL::Vector3 ;
using DGL::Window ;
using DGL::SimpleShader;
using DGL::CanUseRawMouse ;
using DGL::ClearBuffer ;
using DGL::CreateWindow ;
using DGL::BindVertexArray ;
using DGL::DisableVertexAttributeArray;
using DGL::EnableVertexAttributeArray ;
using DGL::GetCursorPosition ;
using DGL::GetTime ;
using DGL::InitalizeGLEW ;
using DGL::InitalizeGLFW ;
using DGL::KeyPressed ;
using DGL::NotShared ;
using DGL::PollEvents ;
using DGL::ResetCursor ;
using DGL::SetClearColor ;
using DGL::SetCurrentContext ;
using DGL::SetInputMode ;
using DGL::SetPolygonMode ;
using DGL::SetUniformVariable_MVA ;
using DGL::SwapBuffers ;
using DGL::UseProgramShader ;
using DGL::TerminateGLFW ;
using DGL::WindowedMode ;
using DGL::DefaultSpace::ScreenWidth ;
using DGL::DefaultSpace::ScreenHeight ;
using DGL::DefaultSpace::ScreenCenterHeight;
using DGL::DefaultSpace::ScreenCenterWidth ;
using DGL::DefaultSpace::Screenspace ;
using DGL::DefaultSpace::WorldCamera ;
using DGL::DefaultSpace::UpdateScreenspace;
// Actions
using Actions::ActionQueue;
} }
// Globals
// GL bool Exist = true; // Determines if the the execution should exit cycler.
using DGL::TimeValDec; TimeValDec CycleStart , // Snapshot of cycle loop start time.
using DGL::Window ; CycleEnd , // Snapshot of cycle loop end time.
using DGL::Matrix ; DeltaTime , // Delta between last cycle start and end.
using DGL::Matrix4x4 ; InputInterval = 1.0f / 240.0f, // Interval per second to complete the input process of the cycle.
using DGL::Vector3 ; PhysicsInterval = 1.0f / 120.0f, // Interval per second to complete the physics process of hte cycle.
using DGL::gFloat ; RenderInterval = 1.0f / 60.0f ; // Interval per second to complete the render process of the cycle.
ptr<Window> DefaultWindow; // Default window to use for execution.
bool Exist = true; double CursorX, CursorY; // Cursor axis position on the window.
TimeValDec CycleStart, CycleEnd, DeltaTime, InputPollingInterval = 1.0f / 240.0f, PhysicsInterval = 1.0f / 120.0f, RenderInterval = 1.0f / 60.0f; gFloat CamMoveSpeed = 8.0f, // Rate at which the camera should move.
CamRotationSpeed = 5.0f ; // Rate at which the camera should rotate.
UPtr<thread> BasicLoop, BasicTimedLoop; TimeValDec InputDelta = 0.0, // Current delta since last input process.
PhysicsDelta = 0.0, // Current delta since last physics process.
RenderDelta = 0.0 ; // Current delta since last render process.
ptr<Window> DefaultWindow; ActionQueue ActionsToComplete; // Actions queue to run during the physics process of the cycle.
gFloat CamMoveSpeed = 3.0f, CamRotationSpeed = 1.0f;
enum class CameraActions // 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)
{ {
WorldCamera.Rotate(_rotationAxis, _rotationAmount, _delta);
};
enum class EMovement
{
};
template<typename Device>
struct ActionBind
{
Delegate< Func<void>> Action;
};
struct Keyboard
{
};
struct ActionBinds
{
static ActionBind<Keyboard> MoveFoward;
};
// Testing
// Forward Declares
sfn RenderProcedure () -> void;
sfn PrepareRenderObjects() -> void;
sfn CreateWindow_BasicLoop()
{
DGL::InitalizeGLFW();
deduce windowObj = DGL::CreateWindow(720, 540, "Assignment 1: RawLoop", DGL::WindowedMode(), DGL::NotShared());
DGL::SetCurrentContext(windowObj);
DGL::RunBasicWindowLoop(windowObj);
} }
sfn CreateWindow_TimedRender() deduce RotateCamDelegate = Delegate<decltype(RotateCamera)>(RotateCamera);
sfn MoveCamera(EDirection _direction, gFloat _translationAmount, gFloat _delta)
{ {
DGL::InitalizeGLFW(); WorldCamera.Move(_direction, _translationAmount, _delta);
}
deduce windowObj = DGL::CreateWindow(720, 540, "Assignment 1: Timed Render", DGL::WindowedMode(), DGL::NotShared()); deduce MoveCamDelegate = Delegate<decltype(MoveCamera)>(MoveCamera);
DGL::SetCurrentContext(windowObj); // End of temp stuff...
DGL::InitalizeGLEW();
// Currently Does everything required before entering the cycler.
sfn PrepWorkspace()
{
InitalizeGLFW();
DefaultWindow = CreateWindow(ScreenWidth, ScreenHeight, "Assignment 1: Lighting Test", WindowedMode(), NotShared());
SetCurrentContext(DefaultWindow);
InitalizeGLEW(); // Glew must initialize only after a context is set.
// Cursor stuff
SetInputMode(DefaultWindow, DGL::EMouseMode::Cursor, DGL::ECursorMode::Disable);
ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight);
if (CanUseRawMouse())
{
SetInputMode(DefaultWindow, DGL::EMouseMode::RawMouse, DGL::EBool::True);
}
// End of cursor stuff...
PrepareRenderObjects(); PrepareRenderObjects();
DGL::RunBasicWindowLoop_Timed(windowObj, 1.0 / 60.0, Address(RenderProcedure)); SetPolygonMode(DGL::EFace::Front_and_Back, DGL::ERenderMode::Fill);
} }
sfn PrepareRenderObjects() -> void
{
RAW_SetupBuffers();
RAW_BindAndBufferDataToIDs();
DGL::LoadDefaultShaders();
DGL::FormatVertexAttributes<Vertex3>(VertexAttributeIndex, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::False);
DGL::BindBuffer(EBufferTarget::VertexAttributes, 0); // Dunno. Prob unbinding...
DGL::BindVertexArray(0);
}
using DGL::EFrameBuffer;
using DGL::LinearColor;
using DGL::DefaultSpace::WorldCamera;
using std::cout; using std::endl;
using DGL::KeyPressed;
using DGL::EKeyCodes;
using DGL::DefaultSpace::WorldCamera;
using DGL::EDirection;
struct CamShouldMove /*
{ Cycles the process of what to do while a window is open.
bool Up, Down, Left, Right, Forward, Backward;
short int numActive; The input, physics, and render procedures can be specified with extra functionality by specifying delegates to those procedures.
};
CamShouldMove CamMoveRequests = { false, false, false, false, false, false, 0 }; Cycler is hardcoded to exit if escape key is pressed.
*/
double CursorX, CursorY; sfn Cycler(Delegate< Func<void, ptr<Window>> > _inputProcedure, Delegate< Func<void>> _physicsProcedure, Delegate< Func<void>> _renderProcedure)
using DGL::DefaultSpace::ScreenCenterWidth; using DGL::DefaultSpace::ScreenCenterHeight;
TimeValDec InputDelta = 0.0, PhysicsDelta = 0.0, RenderDelta = 0.0;
using DGL::DefaultSpace::Screenspace;
sfn Cycler(Delegate< Func<void, ptr<Window>> > _inputProcedure, Delegate< Func<void>> _renderProcedure)
{ {
while (Exist) while (Exist)
{ {
CycleStart = DGL::GetTime(); CycleStart = GetTime();
if (InputDelta >= InputPollingInterval) if (InputDelta >= InputInterval)
{ {
DGL::PollEvents(); PollEvents();
glfwGetCursorPos(DefaultWindow, Address(CursorX), Address(CursorY)); if (KeyPressed(DefaultWindow, EKeyCodes::Escape))
{
Exist = false;
}
GetCursorPosition(DefaultWindow, Address(CursorX), Address(CursorY));
_inputProcedure(DefaultWindow); _inputProcedure(DefaultWindow);
DGL::ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight); ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight);
InputDelta = 0.0; InputDelta = 0.0;
} }
if (PhysicsDelta >= PhysicsInterval) if (PhysicsDelta >= PhysicsInterval)
{ {
if (CamMoveRequests.Up ) WorldCamera.Move(EDirection::Up , CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta); while (ActionsToComplete.HasAction())
if (CamMoveRequests.Down ) WorldCamera.Move(EDirection::Down , CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta); {
if (CamMoveRequests.Left ) WorldCamera.Move(EDirection::Left , CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta); ActionsToComplete.DoNextAction();
if (CamMoveRequests.Right ) WorldCamera.Move(EDirection::Right , CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta); }
if (CamMoveRequests.Forward ) WorldCamera.Move(EDirection::Forward , CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta);
if (CamMoveRequests.Backward) WorldCamera.Move(EDirection::Backward, CamMoveSpeed / CamMoveRequests.numActive, PhysicsDelta);
WorldCamera.UpdateCamera(); _physicsProcedure();
//WorldCamera.Position.y = 0.0;
//WorldCamera.LookAtPosition.y = 0.0;
DGL::DefaultSpace::UpdateScreenspace();
CamMoveRequests = { false, false, false, false, false, false, 0 };
PhysicsDelta = 0.0; PhysicsDelta = 0.0;
} }
if (RenderDelta >= RenderInterval) if (RenderDelta >= RenderInterval)
{ {
DGL::ClearBuffer(EFrameBuffer::Color, EFrameBuffer::Depth); ClearBuffer(EFrameBuffer::Color, EFrameBuffer::Depth);
DGL::SetClearColor(LinearColor(0.12f, 0.12f, 0.12f, 1.0f)); SetClearColor(LinearColor(0.12f, 0.12f, 0.12f, 1.0f));
_renderProcedure(); _renderProcedure();
DGL::SwapBuffers(DefaultWindow); SwapBuffers(DefaultWindow);
RenderDelta = 0.0; RenderDelta = 0.0;
} }
CycleEnd = DGL::GetTime(); CycleEnd = GetTime();
DeltaTime = CycleEnd - CycleStart; DeltaTime = CycleEnd - CycleStart;
@ -232,9 +219,7 @@ namespace Execution
return; return;
} }
using DGL::EMouseMode; using DGL::ECursorMode;
using DGL::DefaultSpace::ScreenCenterWidth; using DGL::DefaultSpace::ScreenCenterHeight;
sfn InputProcedure(ptr<Window> _currentWindowContext) sfn InputProcedure(ptr<Window> _currentWindowContext)
{ {
@ -242,145 +227,96 @@ namespace Execution
{ {
ECursorMode cursorMode = ECursorMode(GetMouseInputMode(DefaultWindow, EMouseMode::Cursor)); ECursorMode cursorMode = ECursorMode(GetMouseInputMode(DefaultWindow, EMouseMode::Cursor));
deduce delegate = Delegate<decltype(SetInputMode<ECursorMode>)>(SetInputMode<ECursorMode>);
if (cursorMode == ECursorMode::Normal || cursorMode == ECursorMode::Hidden) if (cursorMode == ECursorMode::Normal || cursorMode == ECursorMode::Hidden)
{ {
SetInputMode(_currentWindowContext, EMouseMode::Cursor, ECursorMode::Disable); ActionsToComplete.AddToQueue(delegate, _currentWindowContext, EMouseMode::Cursor, ECursorMode::Disable);
} }
else else
{ {
SetInputMode(_currentWindowContext, EMouseMode::Cursor, ECursorMode::Normal); ActionsToComplete.AddToQueue(delegate, _currentWindowContext, EMouseMode::Cursor, ECursorMode::Normal);
} }
} }
if (CursorX != 0)//!= ScreenCenterWidth) if (CursorX != 0)
{ {
WorldCamera.Rotate(DGL::ERotationAxis::Yaw, CursorX * CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Yaw, CursorX * CamMoveSpeed, PhysicsDelta);
//cout << "Cursor X: " << CursorX << endl;
} }
if (CursorY != 0) if (CursorY != 0)
{ {
WorldCamera.Rotate(DGL::ERotationAxis::Pitch, CursorY * CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(RotateCamDelegate, ERotationAxis::Pitch, CursorY * CamMoveSpeed, PhysicsDelta);
//cout << "Cursor Y: " << CursorX << endl;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::E)) if (KeyPressed(_currentWindowContext, EKeyCodes::E))
{ {
WorldCamera.Move(EDirection::Up, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Up, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Up = true;
CamMoveRequests.numActive++;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::Q)) if (KeyPressed(_currentWindowContext, EKeyCodes::Q))
{ {
WorldCamera.Move(EDirection::Down, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Down, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Down = true;
CamMoveRequests.numActive++;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::A)) if (KeyPressed(_currentWindowContext, EKeyCodes::A))
{ {
WorldCamera.Move(EDirection::Left, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Left, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Left = true;
CamMoveRequests.numActive++;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::D)) if (KeyPressed(_currentWindowContext, EKeyCodes::D))
{ {
WorldCamera.Move(EDirection::Right, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Right, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Right = true;
CamMoveRequests.numActive++;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::W)) if (KeyPressed(_currentWindowContext, EKeyCodes::W))
{ {
WorldCamera.Move(EDirection::Forward, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Forward, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Forward = true;
CamMoveRequests.numActive++;
} }
if (KeyPressed(_currentWindowContext, EKeyCodes::S)) if (KeyPressed(_currentWindowContext, EKeyCodes::S))
{ {
WorldCamera.Move(EDirection::Backward, CamMoveSpeed, InputDelta); ActionsToComplete.AddToQueue(MoveCamDelegate, EDirection::Backward, CamMoveSpeed, PhysicsDelta);
CamMoveRequests.Backward = true;
CamMoveRequests.numActive++;
} }
} }
sfn PhysicsProcedure()
{
WorldCamera.UpdateCamera();
UpdateScreenspace();
DGL::SS_Transformed::UpdateShader(Screenspace);
}
sfn RenderProcedure() -> void sfn RenderProcedure() -> void
{ {
DGL::EnableVertexAttributeArray(VertexAttributeIndex); EnableVertexAttributeArray(VertexAttributeIndex);
DGL::SetPolygonMode(DGL::EFace::Front_and_Back, DGL::ERenderMode::Line); UseProgramShader(DGL::SS_Transformed::Shader);
DGL::DefaultSpace::WorldSpace = DGL::Rotate(DGL::DefaultSpace::WorldSpace, 0.0035f, Vector3(0.0f, 0.5f, 0.0f)); BindVertexArray(VertexArrayObj);
DGL::DefaultSpace::Screenspace = DGL::DefaultSpace::WorldCamera.Perspective * DGL::DefaultSpace::WorldCamera.Viewport * DGL::DefaultSpace::WorldSpace; DrawElements(EPrimitives::Triangles, 6, EDataType::UnsignedInt, ZeroOffset());
DGL::UseProgramShader(DGL::SimpleShader_Transformed); DisableVertexAttributeArray(VertexAttributeIndex);
DGL::SetUniformVariable_MatrixVariableArray(DGL::ScreenSpaceVarID, 1, DGL::EBool::False, Address(DGL::DefaultSpace::Screenspace[0][0]));
DGL::BindVertexArray(VertexArrayObj);
DGL::DrawArrays(DGL::EPrimitives::Triangles, 0, TriangleRaw::VertexCount());
DGL::DrawElements(DGL::EPrimitives::Triangles, 6, EDataType::UnsignedInt, ZeroOffset());
//GL::BindVertexArray(0);
DGL::DisableVertexAttributeArray(VertexAttributeIndex);
}
sfn PrepWorkspace()
{
using DGL::DefaultSpace::ScreenWidth ;
using DGL::DefaultSpace::ScreenHeight;
DGL::InitalizeGLFW();
DefaultWindow = DGL::CreateWindow(ScreenWidth, ScreenHeight, "Assignment 1: Cam Movement Test", DGL::WindowedMode(), DGL::NotShared());
DGL::SetCurrentContext(DefaultWindow);
DGL::SetInputMode(DefaultWindow, DGL::EMouseMode::Cursor, DGL::ECursorMode::Disable);
DGL::ResetCursor(DefaultWindow, ScreenCenterWidth, ScreenCenterHeight);
if (DGL::CanUseRawMouse())
{
DGL::SetInputMode(DefaultWindow, DGL::EMouseMode::RawMouse, DGL::EBool::True);
}
DGL::InitalizeGLEW();
PrepareRenderObjects();
} }
// Runtime Execution: Loop must be specified here to use.
// Runtime Execution: Default Execution
sfn Execute() -> ExitCode sfn Execute() -> ExitCode
{ {
PrepWorkspace(); PrepWorkspace();
Cycler(InputProcedure, RenderProcedure); Cycler(InputProcedure, PhysicsProcedure, RenderProcedure);
DGL::TerminateGLFW(); TerminateGLFW();
return ExitCode::Success; return ExitCode::Success;
} }

4
SimpleTransform.vert
View File

@ -5,11 +5,11 @@ layout (location = 0) in vec3 aPos;
// uniform mat4 view; // uniform mat4 view;
// uniform mat4 projection; // uniform mat4 projection;
uniform mat4 modelViewProjection; uniform mat4 ScreenSpaceTransform;
void main() void main()
{ {
//gl_Position = projection * view * model * vec4(aPos, 1.0); //gl_Position = projection * view * model * vec4(aPos, 1.0);
gl_Position = modelViewProjection * vec4(aPos, 1.0); gl_Position = ScreenSpaceTransform * vec4(aPos, 1.0);
} }

212
Testing.hpp Normal file
View File

@ -0,0 +1,212 @@
#pragma once
#include "DGL.hpp"
#include "Cpp_Alias.hpp"
using DGL::gFloat;
using DGL::VertexBuffer;
using DGL::EBufferTarget;
using DGL::EBufferUsage;
using DGL::Buffer;
using DGL::ID;
using DGL::gInt;
using DGL::gSize;
//DGL::DefaultSpace::WorldSpace = DGL::Rotate(DGL::DefaultSpace::WorldSpace, 0.015f, Vector3(0.0f, 1.0f, 0.0f));
// 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 }, // Vert1
{ 1.0f, -1.0f, 0.0f }, // Vert2
{ 0.0f, 1.0f, 0.0f } // Vert 3
};
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 =
{
{ 1.0f, 1.0f, 0.0f },
{ 1.0f, -1.0f, 0.0f },
{ -1.0f, -1.0f, 0.0f },
{ -1.0f, 1.0f, 0.0f }
};
RectangleIndices rectIndices =
{
{ 0, 1, 3 },
{ 1, 2, 3 }
};
using DGL::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()
{
DGL::GenerateVertexBuffers(Address(VertexArrayObj ), 1);
DGL::GenerateBuffers (Address(VertexBufferObj), 1);
DGL::GenerateBuffers (Address(ElemBufferObj ), 1);
}
sfn RAW_SetupTriangleBuffer()
{
DGL::GenerateBuffers(Address(VertexBufferObj), 1);
}
sfn RAW_BindAndBufferDataToIDs()
{
DGL::BindVertexArray(VertexArrayObj);
DGL::BindBuffer(EBufferTarget::VertexAttributes, VertexBufferObj);
//GL::BufferData<TriangleRaw>(Address(EquilateralTriangleVerticies), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
DGL::BufferData<RectangleCompressed>(Address(rectCompress), EBufferTarget::VertexAttributes, EBufferUsage::StaticDraw);
DGL::BindBuffer(EBufferTarget::VertexIndices, ElemBufferObj);
DGL::BufferData<RectangleIndices>(Address(rectIndices), EBufferTarget::VertexIndices, EBufferUsage::StaticDraw);
}
DGL::gInt VertexAttributeIndex = 0; // See shader source: (layout = 0).
using DGL::EBool;
using DGL::EDataType;
constexpr sfn ZeroOffset() -> ptr<void>
{
return 0;
}
// Testing
// Forward Declares
sfn RenderProcedure () -> void;
sfn PrepareRenderObjects() -> void;
sfn CreateWindow_BasicLoop()
{
DGL::InitalizeGLFW();
deduce windowObj = DGL::CreateWindow(720, 540, "Assignment 1: RawLoop", DGL::WindowedMode(), DGL::NotShared());
DGL::SetCurrentContext(windowObj);
DGL::RunBasicWindowLoop(windowObj);
}
sfn CreateWindow_TimedRender()
{
DGL::InitalizeGLFW();
deduce windowObj = DGL::CreateWindow(720, 540, "Assignment 1: Timed Render", DGL::WindowedMode(), DGL::NotShared());
DGL::SetCurrentContext(windowObj);
DGL::InitalizeGLEW();
PrepareRenderObjects();
//DGL::RunBasicWindowLoop_Timed(windowObj, 1.0 / 60.0, Address(RenderProcedure));
}
sfn PrepareRenderObjects() -> void
{
RAW_SetupBuffers();
RAW_BindAndBufferDataToIDs();
DGL::LoadDefaultShaders();
DGL::FormatVertexAttributes<Vertex3>(VertexAttributeIndex, EDataType::Float, ZeroOffset(), Vertex3::ValueCount(), EBool::False);
DGL::BindBuffer(EBufferTarget::VertexAttributes, 0); // Dunno. Prob unbinding...
DGL::BindVertexArray(0);
}