From 43a87590f45aa6e55724d30d0c2d0d34b407a57e Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Sun, 17 Jan 2021 18:54:26 +0000 Subject: First cut modernizing and sanitizing --- Jamroot.jam | 38 +++++++++++- camera.cpp | 46 +++++++++++++++ camera.h | 49 +++------------- cb.bmp | Bin 54294 -> 0 bytes debugTimer.h | 27 --------- display.cpp | 19 +++--- display.h | 20 +++---- iwyu.json | 42 ++++++++++++++ main.cpp | 72 +++++------------------ math3d.h | 180 --------------------------------------------------------- mesh.cpp | 63 ++++++++++---------- mesh.h | 60 +++++-------------- obj_loader.cpp | 118 +++++++++++++++++++++++-------------- obj_loader.h | 2 +- ptr.hpp | 25 ++++++++ shader.cpp | 100 +++++++++++++------------------- shader.h | 37 ++++++------ stb_image.c | 10 +++- texture.cpp | 11 ++-- texture.h | 13 ++--- transform.cpp | 27 +++++++++ transform.h | 66 ++++++++------------- util.h | 1 - vertex.hpp | 36 ++++++++++++ 24 files changed, 470 insertions(+), 592 deletions(-) create mode 100644 camera.cpp delete mode 100644 cb.bmp delete mode 100644 debugTimer.h create mode 100644 iwyu.json delete mode 100644 math3d.h create mode 100644 ptr.hpp create mode 100644 transform.cpp create mode 100644 vertex.hpp diff --git a/Jamroot.jam b/Jamroot.jam index 33c67c4..5058f6a 100644 --- a/Jamroot.jam +++ b/Jamroot.jam @@ -1,13 +1,49 @@ using gcc ; using pkg-config ; import pkg-config ; +import type : register ; +import generators : register-standard ; pkg-config.import sdl2 ; pkg-config.import glew ; lib stb : : : : /usr/include/stb ; +project : requirements + 20 + debug:extra + debug:on + release:on + tidy:bin/res/fs-basicShader.h + tidy:bin/res/vs-basicShader.h + tidy:boost-* + tidy:bugprone-* + tidy:clang-* + tidy:misc-* + tidy:modernize-* + tidy:modernize-use-trailing-return-type + tidy:hicpp-* + tidy:hicpp-signed-bitwise + tidy:hicpp-named-parameter + tidy:performance-* + tidy:no + tidy:iwyu.json + tidy:TIDY + ; + +type.register VERTEXSHADER : vs ; +type.register FRAGMENTSHADER : fs ; + +generators.register-standard xxd.i : VERTEXSHADER : C(vs-%) H(vs-%) ; +generators.register-standard xxd.i : FRAGMENTSHADER : C(fs-%) H(fs-%) ; + +actions xxd.i +{ + ( cd $(2:D) ; xxd -i $(2:B)$(2:S) ) | tee $(1[1]) | cproto -veo $(1[2]) +} +IMPORT $(__name__) : xxd.i : : xxd.i ; + exe test : - [ glob *.cpp *.c ] + [ glob-tree *.cpp *.c *.vs *.fs : bin ] : sdl2 glew diff --git a/camera.cpp b/camera.cpp new file mode 100644 index 0000000..b4a76d0 --- /dev/null +++ b/camera.cpp @@ -0,0 +1,46 @@ +#include "camera.h" +#include + +Camera::Camera(glm::vec3 pos, float fov, float aspect, float zNear, float zFar) : + projection {glm::perspective(fov, aspect, zNear, zFar)}, pos {pos}, forward {0.0F, 0.0F, 1.0F}, up {0.0F, 1.0F, + 0.0F} +{ +} + +glm::mat4 +Camera::GetViewProjection() const +{ + return projection * glm::lookAt(pos, pos + forward, up); +} + +void +Camera::MoveForward(float amt) +{ + pos += forward * amt; +} + +void +Camera::MoveRight(float amt) +{ + pos += glm::cross(up, forward) * amt; +} + +void +Camera::Pitch(float angle) +{ + const auto right = glm::normalize(glm::cross(up, forward)); + + forward = glm::vec3(glm::normalize(glm::rotate(angle, right) * glm::vec4(forward, 0.0))); + up = glm::normalize(glm::cross(forward, right)); +} + +void +Camera::RotateY(float angle) +{ + static constexpr glm::vec3 UP {0.0F, 1.0F, 0.0F}; + + const auto rotation = glm::rotate(angle, UP); + + forward = glm::vec3(glm::normalize(rotation * glm::vec4(forward, 0.0))); + up = glm::vec3(glm::normalize(rotation * glm::vec4(up, 0.0))); +} diff --git a/camera.h b/camera.h index 86b59d1..3c1e40c 100644 --- a/camera.h +++ b/camera.h @@ -2,53 +2,18 @@ #define CAMERA_INCLUDED_H #include -#include -struct Camera { +class Camera { public: - Camera(const glm::vec3 & pos, float fov, float aspect, float zNear, float zFar) - { - this->pos = pos; - this->forward = glm::vec3(0.0f, 0.0f, 1.0f); - this->up = glm::vec3(0.0f, 1.0f, 0.0f); - this->projection = glm::perspective(fov, aspect, zNear, zFar); - } + Camera(glm::vec3 pos, float fov, float aspect, float zNear, float zFar); - inline glm::mat4 - GetViewProjection() const - { - return projection * glm::lookAt(pos, pos + forward, up); - } + glm::mat4 GetViewProjection() const; - // void MoveForward(float amt) - //{ - // pos += forward * amt; - //} + void MoveForward(float amt); + void MoveRight(float amt); + void Pitch(float angle); + void RotateY(float angle); - // void MoveRight(float amt) - //{ - // pos += glm::cross(up, forward) * amt; - //} - - // void Pitch(float angle) - //{ - // glm::vec3 right = glm::normalize(glm::cross(up, forward)); - - // forward = glm::vec3(glm::normalize(glm::rotate(angle, right) * glm::vec4(forward, 0.0))); - // up = glm::normalize(glm::cross(forward, right)); - //} - - // void RotateY(float angle) - //{ - // static const glm::vec3 UP(0.0f, 1.0f, 0.0f); - - // glm::mat4 rotation = glm::rotate(angle, UP); - - // forward = glm::vec3(glm::normalize(rotation * glm::vec4(forward, 0.0))); - // up = glm::vec3(glm::normalize(rotation * glm::vec4(up, 0.0))); - //} - -protected: private: glm::mat4 projection; glm::vec3 pos; diff --git a/cb.bmp b/cb.bmp deleted file mode 100644 index f912a9e..0000000 Binary files a/cb.bmp and /dev/null differ diff --git a/debugTimer.h b/debugTimer.h deleted file mode 100644 index fb95eec..0000000 --- a/debugTimer.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef DEBUGTIMER_H_INCLUDED -#define DEBUGTIMER_H_INCLUDED - -#include -#include - -class DebugTimer { -public: - void - Start() - { - startTime = SDL_GetTicks(); - } - - void - End(const std::string & message) - { - unsigned int endTime = SDL_GetTicks(); - std::cout << message << (endTime - startTime) << "ms" << std::endl; - } - -protected: -private: - unsigned int startTime; -}; - -#endif // DEBUGTIMER_H_INCLUDED diff --git a/display.cpp b/display.cpp index 4317933..b4a42d7 100644 --- a/display.cpp +++ b/display.cpp @@ -1,6 +1,6 @@ #include "display.h" #include -#include +#include Display::Display(int width, int height, const std::string & title) { @@ -14,13 +14,12 @@ Display::Display(int width, int height, const std::string & title) SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - m_window = SDL_CreateWindow( - title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL); - m_glContext = SDL_GL_CreateContext(m_window); + m_window = m_window.create(SDL_CreateWindow, SDL_DestroyWindow, title.c_str(), SDL_WINDOWPOS_CENTERED, + SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL); + m_glContext = m_glContext.create(SDL_GL_CreateContext, SDL_GL_DeleteContext, m_window); - GLenum res = glewInit(); - if (res != GLEW_OK) { - std::cerr << "Glew failed to initialize!" << std::endl; + if (glewInit() != GLEW_OK) { + throw std::runtime_error {"Glew failed to initialize!"}; } glEnable(GL_DEPTH_TEST); @@ -31,20 +30,18 @@ Display::Display(int width, int height, const std::string & title) Display::~Display() { - SDL_GL_DeleteContext(m_glContext); - SDL_DestroyWindow(m_window); SDL_Quit(); } void -Display::Clear(float r, float g, float b, float a) +Display::Clear(float r, float g, float b, float a) const { glClearColor(r, g, b, a); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } void -Display::SwapBuffers() +Display::SwapBuffers() const { SDL_GL_SwapWindow(m_window); } diff --git a/display.h b/display.h index 2573130..e5fcc73 100644 --- a/display.h +++ b/display.h @@ -1,28 +1,26 @@ #ifndef DISPLAY_INCLUDED_H #define DISPLAY_INCLUDED_H +#include "ptr.hpp" #include #include +#include class Display { public: Display(int width, int height, const std::string & title); - void Clear(float r, float g, float b, float a); - void SwapBuffers(); + Display(const Display &) = delete; + void operator=(const Display &) = delete; virtual ~Display(); -protected: -private: - void - operator=(const Display & display) - { - } - Display(const Display & display) { } + void Clear(float r, float g, float b, float a) const; + void SwapBuffers() const; - SDL_Window * m_window; - SDL_GLContext m_glContext; +private: + wrapped_ptr m_window; + wrapped_ptr> m_glContext; }; #endif diff --git a/iwyu.json b/iwyu.json new file mode 100644 index 0000000..ccf35c5 --- /dev/null +++ b/iwyu.json @@ -0,0 +1,42 @@ +[ + { + "include": [ + "", + "private", + "", + "public" + ] + }, + { + "include": [ + "@\"SDL.*.h\"", + "private", + "", + "public" + ] + }, + { + "include": [ + "@", + "private", + "", + "public" + ] + }, + { + "include": [ + "@", + "private", + "", + "public" + ] + }, + { + "include": [ + "@", + "private", + "", + "public" + ] + } +] diff --git a/main.cpp b/main.cpp index 431610b..7f67ad4 100644 --- a/main.cpp +++ b/main.cpp @@ -5,84 +5,43 @@ #include "texture.h" #include "transform.h" #include -#include +#include +#include +#include +#include static const int DISPLAY_WIDTH = 800; static const int DISPLAY_HEIGHT = 600; int -main(int argc, char ** argv) +main(int, char **) { Display display(DISPLAY_WIDTH, DISPLAY_HEIGHT, "OpenGL"); - Vertex vertices[] = { - Vertex(glm::vec3(-1, -1, -1), glm::vec2(1, 0), glm::vec3(0, 0, -1)), - Vertex(glm::vec3(-1, 1, -1), glm::vec2(0, 0), glm::vec3(0, 0, -1)), - Vertex(glm::vec3(1, 1, -1), glm::vec2(0, 1), glm::vec3(0, 0, -1)), - Vertex(glm::vec3(1, -1, -1), glm::vec2(1, 1), glm::vec3(0, 0, -1)), - - Vertex(glm::vec3(-1, -1, 1), glm::vec2(1, 0), glm::vec3(0, 0, 1)), - Vertex(glm::vec3(-1, 1, 1), glm::vec2(0, 0), glm::vec3(0, 0, 1)), - Vertex(glm::vec3(1, 1, 1), glm::vec2(0, 1), glm::vec3(0, 0, 1)), - Vertex(glm::vec3(1, -1, 1), glm::vec2(1, 1), glm::vec3(0, 0, 1)), - - Vertex(glm::vec3(-1, -1, -1), glm::vec2(0, 1), glm::vec3(0, -1, 0)), - Vertex(glm::vec3(-1, -1, 1), glm::vec2(1, 1), glm::vec3(0, -1, 0)), - Vertex(glm::vec3(1, -1, 1), glm::vec2(1, 0), glm::vec3(0, -1, 0)), - Vertex(glm::vec3(1, -1, -1), glm::vec2(0, 0), glm::vec3(0, -1, 0)), - - Vertex(glm::vec3(-1, 1, -1), glm::vec2(0, 1), glm::vec3(0, 1, 0)), - Vertex(glm::vec3(-1, 1, 1), glm::vec2(1, 1), glm::vec3(0, 1, 0)), - Vertex(glm::vec3(1, 1, 1), glm::vec2(1, 0), glm::vec3(0, 1, 0)), - Vertex(glm::vec3(1, 1, -1), glm::vec2(0, 0), glm::vec3(0, 1, 0)), - - Vertex(glm::vec3(-1, -1, -1), glm::vec2(1, 1), glm::vec3(-1, 0, 0)), - Vertex(glm::vec3(-1, -1, 1), glm::vec2(1, 0), glm::vec3(-1, 0, 0)), - Vertex(glm::vec3(-1, 1, 1), glm::vec2(0, 0), glm::vec3(-1, 0, 0)), - Vertex(glm::vec3(-1, 1, -1), glm::vec2(0, 1), glm::vec3(-1, 0, 0)), - - Vertex(glm::vec3(1, -1, -1), glm::vec2(1, 1), glm::vec3(1, 0, 0)), - Vertex(glm::vec3(1, -1, 1), glm::vec2(1, 0), glm::vec3(1, 0, 0)), - Vertex(glm::vec3(1, 1, 1), glm::vec2(0, 0), glm::vec3(1, 0, 0)), - Vertex(glm::vec3(1, 1, -1), glm::vec2(0, 1), glm::vec3(1, 0, 0)), - }; - - unsigned int indices[] = {0, 1, 2, 0, 2, 3, - - 6, 5, 4, 7, 6, 4, - - 10, 9, 8, 11, 10, 8, - - 12, 13, 14, 12, 14, 15, - - 16, 17, 18, 16, 18, 19, - - 22, 21, 20, 23, 22, 20}; - - Mesh mesh(vertices, sizeof(vertices) / sizeof(vertices[0]), indices, sizeof(indices) / sizeof(indices[0])); Mesh monkey("./res/monkey3.obj"); Shader shader("./res/basicShader"); Texture texture("./res/bricks.jpg"); Transform transform; - Camera camera(glm::vec3(0.0f, 0.0f, -5.0f), 70.0f, (float)DISPLAY_WIDTH / (float)DISPLAY_HEIGHT, 0.1f, 100.0f); + Camera camera(glm::vec3(0.0F, 0.0F, -5.0F), 70.0F, (float)DISPLAY_WIDTH / (float)DISPLAY_HEIGHT, 0.1F, 100.0F); SDL_Event e; bool isRunning = true; - float counter = 0.0f; + float counter = 0.0F; while (isRunning) { while (SDL_PollEvent(&e)) { - if (e.type == SDL_QUIT) + if (e.type == SDL_QUIT) { isRunning = false; + } } - display.Clear(0.0f, 0.0f, 0.0f, 1.0f); + display.Clear(0.0F, 0.0F, 0.0F, 1.0F); - float sinCounter = sinf(counter); - float absSinCounter = abs(sinCounter); + // float sinCounter = sinf(counter); + // float absSinCounter = abs(sinCounter); // transform.GetPos()->x = sinCounter; - transform.GetRot()->y = counter * 100; - // transform.GetRot()->z = counter * 100; + transform.GetRot().y = std::numbers::pi_v + sin(counter); + transform.GetRot().z = 0.3 * cos(counter * 10); // transform.GetScale()->x = absSinCounter; // transform.GetScale()->y = absSinCounter; @@ -90,11 +49,10 @@ main(int argc, char ** argv) texture.Bind(); shader.Update(transform, camera); monkey.Draw(); - // mesh.Draw(); display.SwapBuffers(); SDL_Delay(1); - counter += 0.01f; + counter += 0.01F; } return 0; diff --git a/math3d.h b/math3d.h deleted file mode 100644 index 8cdb756..0000000 --- a/math3d.h +++ /dev/null @@ -1,180 +0,0 @@ -#ifndef MATH3D_INCLUDED_H -#define MATH3D_INCLUDED_H - -#include -/* -namespace Math3D -{ - static const double PI = 3.1415926535897932384626433832795; - static const double PIOVER2 = PI / 2.0; - static const double PIOVER180 = PI / 180.0; - - static inline double ToRadians(double x) { return PIOVER180 * x; } - static inline double ToDegrees(double x) { return 180.0 * x / PI; } -}; - -struct Vector3f -{ -public: - Vector3f(float x = 0.0f, float y = 0.0f, float z = 0.0f) - { - data.x = x; - data.y = y; - data.z = z; - } - - inline float GetX() const { return data.x; } - inline float GetY() const { return data.y; } - inline float GetZ() const { return data.z; } - - inline void SetX(float x) { data.x = x; } - inline void SetY(float y) { data.y = y; } - inline void SetZ(float z) { data.z = z; } - - inline glm::vec3& GetRawVector() const { return glm::vec3(data); } - - inline float Length() - { - return sqrtf(this->Dot(*this)); - } - - inline Vector3f Normalized() - { - return *this / Length(); - } - - inline float Dot(const Vector3f& r) const - { - return glm::dot(data, r.GetRawVector()); - } - - inline Vector3f Cross(const Vector3f& r) const - { - return Vector3f(glm::cross(data, r.GetRawVector())); - } - - inline Vector3f Rotate(const Vector3f& axis, float angle) const - { - float sinAngle = sinf(angle); - float cosAngle = cosf(angle); - - return this->Cross(axis * sinAngle) + //Rotation on local X - (*this * cosAngle) + //Rotation on local Z - axis * this->Dot(axis * (1 - cosAngle)); //Rotation on local Y - } - - inline void operator+=(const Vector3f& r) - { - data.x += r.GetX(); - data.y += r.GetY(); - data.z += r.GetZ(); - } - - inline Vector3f operator+(const Vector3f& r) const - { - return Vector3f(data.x + r.GetX(), - data.y + r.GetY(), - data.z + r.GetZ()); - } - - inline Vector3f operator*(float r) const - { - return Vector3f(data.x * r, - data.y * r, - data.z * r); - } - - inline Vector3f operator/(float r) const - { - return Vector3f(data.x / r, - data.y / r, - data.z / r); - } - -private: - Vector3f(glm::vec3& data) - { - this->data.x = data.x; - this->data.y = data.y; - this->data.z = data.z; - } - glm::vec3 data; -}; - -struct Vector2f -{ -public: - Vector2f(float x = 0.0f, float y = 0.0f) - { - data.x = x; - data.y = y; - } - - inline float GetX() const { return data.x; } - inline float GetY() const { return data.y; } - - inline void SetX(float x) { data.x = x; } - inline void SetY(float y) { data.y = y; } - -private: - DirectX::XMFLOAT2 data; -}; - -struct Matrix4f -{ -public: - static Matrix4f InitTranslation(const Vector3f& translation) - { - return Matrix4f(DirectX::XMMatrixTranslation(translation.GetX(), translation.GetY(), translation.GetZ())); - } - - static Matrix4f InitRotation(const Vector3f& eulerAngles) - { - return Matrix4f(DirectX::XMMatrixRotationRollPitchYaw(eulerAngles.GetX(), eulerAngles.GetY(), -eulerAngles.GetZ())); - } - - static Matrix4f InitScale(const Vector3f& scale) - { - return Matrix4f(DirectX::XMMatrixScaling(scale.GetX(), scale.GetY(), scale.GetZ())); - } - - static Matrix4f InitLookTo(const Vector3f& eye, const Vector3f& direction, const Vector3f& up) - { - return Matrix4f(DirectX::XMMatrixLookToLH(eye.GetDXVector(), direction.GetDXVector(), up.GetDXVector())); - } - - static Matrix4f InitPerspective(float angle, float aspect, float zNear, float zFar) - { - return Matrix4f(DirectX::XMMatrixPerspectiveFovLH(angle, aspect, zNear, zFar)); - } - - Matrix4f() - { - m_Data = DirectX::XMMatrixIdentity(); - } - - Matrix4f Inverse() const - { - return Matrix4f(DirectX::XMMatrixInverse(NULL, m_Data)); - } - - Matrix4f Transpose() const - { - return Matrix4f(DirectX::XMMatrixTranspose(m_Data)); - } - - inline Matrix4f operator*(const Matrix4f& r) const - { - return Matrix4f(m_Data * r.m_Data); - } -private: - Matrix4f(const DirectX::XMMATRIX& data) - { - m_Data = data; - } - - DirectX::XMMATRIX m_Data; -}; -*/ -#endif \ No newline at end of file diff --git a/mesh.cpp b/mesh.cpp index 19f3a82..8c304b3 100644 --- a/mesh.cpp +++ b/mesh.cpp @@ -1,43 +1,36 @@ #include "mesh.h" -#include "debugTimer.h" -#include "util.h" -#include -#include -#include -#include -#include - -Mesh::Mesh(const std::string & fileName) -{ - InitMesh(OBJModel(fileName).ToIndexedModel()); -} +#include "obj_loader.h" +#include "vertex.hpp" +#include +#include +#include -void -Mesh::InitMesh(const IndexedModel & model) -{ - m_numIndices = model.indices.size(); +Mesh::Mesh(const std::string & fileName) : Mesh(OBJModel(fileName).ToIndexedModel()) { } +Mesh::Mesh(const IndexedModel & model) : + m_vertexArrayObject {}, m_vertexArrayBuffers {}, m_numIndices {model.indices.size()} +{ glGenVertexArrays(1, &m_vertexArrayObject); glBindVertexArray(m_vertexArrayObject); - glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers); + glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers.data()); glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[POSITION_VB]); glBufferData( GL_ARRAY_BUFFER, sizeof(model.positions[0]) * model.positions.size(), &model.positions[0], GL_STATIC_DRAW); glEnableVertexAttribArray(0); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr); glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[TEXCOORD_VB]); glBufferData( GL_ARRAY_BUFFER, sizeof(model.texCoords[0]) * model.texCoords.size(), &model.texCoords[0], GL_STATIC_DRAW); glEnableVertexAttribArray(1); - glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr); glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[NORMAL_VB]); glBufferData(GL_ARRAY_BUFFER, sizeof(model.normals[0]) * model.normals.size(), &model.normals[0], GL_STATIC_DRAW); glEnableVertexAttribArray(2); - glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, 0); + glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, nullptr); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_vertexArrayBuffers[INDEX_VB]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(model.indices[0]) * model.indices.size(), &model.indices[0], @@ -46,25 +39,28 @@ Mesh::InitMesh(const IndexedModel & model) glBindVertexArray(0); } -Mesh::Mesh(Vertex * vertices, unsigned int numVertices, unsigned int * indices, unsigned int numIndices) -{ - IndexedModel model; +Mesh::Mesh(Vertex * vertices, unsigned int numVertices, unsigned int * indices, unsigned int numIndices) : + Mesh {[vertices, numVertices, indices, numIndices]() { + IndexedModel model; - for (unsigned int i = 0; i < numVertices; i++) { - model.positions.push_back(*vertices[i].GetPos()); - model.texCoords.push_back(*vertices[i].GetTexCoord()); - model.normals.push_back(*vertices[i].GetNormal()); - } + for (unsigned int i = 0; i < numVertices; i++) { + model.positions.push_back(vertices[i].GetPos()); + model.texCoords.push_back(vertices[i].GetTexCoord()); + model.normals.push_back(vertices[i].GetNormal()); + } - for (unsigned int i = 0; i < numIndices; i++) - model.indices.push_back(indices[i]); + for (unsigned int i = 0; i < numIndices; i++) { + model.indices.push_back(indices[i]); + } - InitMesh(model); + return model; + }()} +{ } Mesh::~Mesh() { - glDeleteBuffers(NUM_BUFFERS, m_vertexArrayBuffers); + glDeleteBuffers(NUM_BUFFERS, m_vertexArrayBuffers.data()); glDeleteVertexArrays(1, &m_vertexArrayObject); } @@ -73,8 +69,7 @@ Mesh::Draw() { glBindVertexArray(m_vertexArrayObject); - // glDrawElements(GL_TRIANGLES, m_numIndices, GL_UNSIGNED_INT, 0); - glDrawElementsBaseVertex(GL_TRIANGLES, m_numIndices, GL_UNSIGNED_INT, 0, 0); + glDrawElementsBaseVertex(GL_TRIANGLES, m_numIndices, GL_UNSIGNED_INT, nullptr, 0); glBindVertexArray(0); } diff --git a/mesh.h b/mesh.h index aceaafe..69f41b9 100644 --- a/mesh.h +++ b/mesh.h @@ -1,68 +1,34 @@ #ifndef MESH_INCLUDED_H #define MESH_INCLUDED_H -#include "obj_loader.h" #include -#include +#include +#include #include -#include -struct Vertex { -public: - Vertex(const glm::vec3 & pos, const glm::vec2 & texCoord, const glm::vec3 & normal) - { - this->pos = pos; - this->texCoord = texCoord; - this->normal = normal; - } - - glm::vec3 * - GetPos() - { - return &pos; - } - glm::vec2 * - GetTexCoord() - { - return &texCoord; - } - glm::vec3 * - GetNormal() - { - return &normal; - } - -private: - glm::vec3 pos; - glm::vec2 texCoord; - glm::vec3 normal; -}; +class IndexedModel; +class Vertex; enum MeshBufferPositions { POSITION_VB, TEXCOORD_VB, NORMAL_VB, INDEX_VB }; class Mesh { public: - Mesh(const std::string & fileName); + explicit Mesh(const std::string & fileName); + explicit Mesh(const IndexedModel & model); Mesh(Vertex * vertices, unsigned int numVertices, unsigned int * indices, unsigned int numIndices); - - void Draw(); + Mesh(const Mesh &) = delete; + void operator=(const Mesh &) = delete; virtual ~Mesh(); -protected: -private: - static const unsigned int NUM_BUFFERS = 4; - void - operator=(const Mesh & mesh) - { - } - Mesh(const Mesh & mesh) { } + void Draw(); - void InitMesh(const IndexedModel & model); +private: + static constexpr unsigned int NUM_BUFFERS {4}; GLuint m_vertexArrayObject; - GLuint m_vertexArrayBuffers[NUM_BUFFERS]; - unsigned int m_numIndices; + std::array m_vertexArrayBuffers; + size_t m_numIndices; }; #endif diff --git a/obj_loader.cpp b/obj_loader.cpp index b3cb517..7611a2c 100644 --- a/obj_loader.cpp +++ b/obj_loader.cpp @@ -1,8 +1,10 @@ #include "obj_loader.h" #include #include -#include #include +#include +#include +#include static bool CompareOBJIndexPtr(const OBJIndex * a, const OBJIndex * b); static inline unsigned int FindNextChar(unsigned int start, const char * str, unsigned int length, char token); @@ -24,19 +26,25 @@ OBJModel::OBJModel(const std::string & fileName) unsigned int lineLength = line.length(); - if (lineLength < 2) + if (lineLength < 2) { continue; + } const char * lineCStr = line.c_str(); switch (lineCStr[0]) { case 'v': - if (lineCStr[1] == 't') - this->uvs.push_back(ParseOBJVec2(line)); - else if (lineCStr[1] == 'n') - this->normals.push_back(ParseOBJVec3(line)); - else if (lineCStr[1] == ' ' || lineCStr[1] == '\t') - this->vertices.push_back(ParseOBJVec3(line)); + switch (lineCStr[1]) { + case 't': + this->uvs.push_back(ParseOBJVec2(line)); + break; + case 'n': + this->normals.push_back(ParseOBJVec3(line)); + break; + case ' ': + case '\t': + this->vertices.push_back(ParseOBJVec3(line)); + } break; case 'f': CreateOBJFace(line); @@ -47,7 +55,7 @@ OBJModel::OBJModel(const std::string & fileName) } } else { - std::cerr << "Unable to load mesh: " << fileName << std::endl; + throw std::runtime_error {"Unable to load mesh: " + fileName}; } } @@ -69,8 +77,9 @@ IndexedModel::CalcNormals() normals[i2] += normal; } - for (unsigned int i = 0; i < positions.size(); i++) + for (unsigned int i = 0; i < positions.size(); i++) { normals[i] = glm::normalize(normals[i]); + } } IndexedModel @@ -83,8 +92,9 @@ OBJModel::ToIndexedModel() std::vector indexLookup; - for (unsigned int i = 0; i < numIndices; i++) + for (unsigned int i = 0; i < numIndices; i++) { indexLookup.push_back(&OBJIndices[i]); + } std::sort(indexLookup.begin(), indexLookup.end(), CompareOBJIndexPtr); @@ -98,21 +108,25 @@ OBJModel::ToIndexedModel() glm::vec2 currentTexCoord; glm::vec3 currentNormal; - if (hasUVs) + if (hasUVs) { currentTexCoord = uvs[currentIndex->uvIndex]; - else + } + else { currentTexCoord = glm::vec2(0, 0); + } - if (hasNormals) + if (hasNormals) { currentNormal = normals[currentIndex->normalIndex]; - else + } + else { currentNormal = glm::vec3(0, 0, 0); + } unsigned int normalModelIndex; unsigned int resultModelIndex; // Create model to properly generate normals on - std::map::iterator it = normalModelIndexMap.find(*currentIndex); + const auto it = normalModelIndexMap.find(*currentIndex); if (it == normalModelIndexMap.end()) { normalModelIndex = normalModel.positions.size(); @@ -121,8 +135,9 @@ OBJModel::ToIndexedModel() normalModel.texCoords.push_back(currentTexCoord); normalModel.normals.push_back(currentNormal); } - else + else { normalModelIndex = it->second; + } // Create model which properly separates texture coordinates unsigned int previousVertexLocation = FindLastVertexIndex(indexLookup, currentIndex, result); @@ -134,8 +149,9 @@ OBJModel::ToIndexedModel() result.texCoords.push_back(currentTexCoord); result.normals.push_back(currentNormal); } - else + else { resultModelIndex = previousVertexLocation; + } normalModel.indices.push_back(normalModelIndex); result.indices.push_back(resultModelIndex); @@ -145,8 +161,9 @@ OBJModel::ToIndexedModel() if (!hasNormals) { normalModel.CalcNormals(); - for (unsigned int i = 0; i < result.positions.size(); i++) + for (unsigned int i = 0; i < result.positions.size(); i++) { result.normals[i] = normalModel.normals[indexMap[i]]; + } } return result; @@ -170,11 +187,13 @@ OBJModel::FindLastVertexIndex( for (unsigned int i = 0; i < current; i++) { OBJIndex * possibleIndex = indexLookup[current - i]; - if (possibleIndex == currentIndex) + if (possibleIndex == currentIndex) { continue; + } - if (possibleIndex->vertexIndex != currentIndex->vertexIndex) + if (possibleIndex->vertexIndex != currentIndex->vertexIndex) { break; + } countStart--; } @@ -182,26 +201,32 @@ OBJModel::FindLastVertexIndex( for (unsigned int i = countStart; i < indexLookup.size() - countStart; i++) { OBJIndex * possibleIndex = indexLookup[current + i]; - if (possibleIndex == currentIndex) + if (possibleIndex == currentIndex) { continue; + } - if (possibleIndex->vertexIndex != currentIndex->vertexIndex) + if (possibleIndex->vertexIndex != currentIndex->vertexIndex) { break; + } else if ((!hasUVs || possibleIndex->uvIndex == currentIndex->uvIndex) && (!hasNormals || possibleIndex->normalIndex == currentIndex->normalIndex)) { glm::vec3 currentPosition = vertices[currentIndex->vertexIndex]; glm::vec2 currentTexCoord; glm::vec3 currentNormal; - if (hasUVs) + if (hasUVs) { currentTexCoord = uvs[currentIndex->uvIndex]; - else + } + else { currentTexCoord = glm::vec2(0, 0); + } - if (hasNormals) + if (hasNormals) { currentNormal = normals[currentIndex->normalIndex]; - else + } + else { currentNormal = glm::vec3(0, 0, 0); + } for (unsigned int j = 0; j < result.positions.size(); j++) { if (currentPosition == result.positions[j] @@ -216,10 +241,12 @@ OBJModel::FindLastVertexIndex( return -1; } else { - if (testIndex->vertexIndex < currentIndex->vertexIndex) + if (testIndex->vertexIndex < currentIndex->vertexIndex) { start = current; - else + } + else { end = current; + } } previous = current; @@ -254,13 +281,15 @@ OBJModel::ParseOBJIndex(const std::string & token, bool * hasUVs, bool * hasNorm unsigned int vertIndexStart = 0; unsigned int vertIndexEnd = FindNextChar(vertIndexStart, tokenString, tokenLength, '/'); - OBJIndex result; - result.vertexIndex = ParseOBJIndexValue(token, vertIndexStart, vertIndexEnd); - result.uvIndex = 0; - result.normalIndex = 0; + OBJIndex result { + .vertexIndex = ParseOBJIndexValue(token, vertIndexStart, vertIndexEnd), + .uvIndex = 0, + .normalIndex = 0, + }; - if (vertIndexEnd >= tokenLength) + if (vertIndexEnd >= tokenLength) { return result; + } vertIndexStart = vertIndexEnd + 1; vertIndexEnd = FindNextChar(vertIndexStart, tokenString, tokenLength, '/'); @@ -268,8 +297,9 @@ OBJModel::ParseOBJIndex(const std::string & token, bool * hasUVs, bool * hasNorm result.uvIndex = ParseOBJIndexValue(token, vertIndexStart, vertIndexEnd); *hasUVs = true; - if (vertIndexEnd >= tokenLength) + if (vertIndexEnd >= tokenLength) { return result; + } vertIndexStart = vertIndexEnd + 1; vertIndexEnd = FindNextChar(vertIndexStart, tokenString, tokenLength, '/'); @@ -289,8 +319,9 @@ OBJModel::ParseOBJVec3(const std::string & line) unsigned int vertIndexStart = 2; while (vertIndexStart < tokenLength) { - if (tokenString[vertIndexStart] != ' ') + if (tokenString[vertIndexStart] != ' ') { break; + } vertIndexStart++; } @@ -309,8 +340,6 @@ OBJModel::ParseOBJVec3(const std::string & line) float z = ParseOBJFloatValue(line, vertIndexStart, vertIndexEnd); return glm::vec3(x, y, z); - - // glm::vec3(atof(tokens[1].c_str()), atof(tokens[2].c_str()), atof(tokens[3].c_str())) } glm::vec2 @@ -322,8 +351,9 @@ OBJModel::ParseOBJVec2(const std::string & line) unsigned int vertIndexStart = 3; while (vertIndexStart < tokenLength) { - if (tokenString[vertIndexStart] != ' ') + if (tokenString[vertIndexStart] != ' ') { break; + } vertIndexStart++; } @@ -351,8 +381,9 @@ FindNextChar(unsigned int start, const char * str, unsigned int length, char tok unsigned int result = start; while (result < length) { result++; - if (str[result] == token) + if (str[result] == token) { break; + } } return result; @@ -361,13 +392,13 @@ FindNextChar(unsigned int start, const char * str, unsigned int length, char tok static inline unsigned int ParseOBJIndexValue(const std::string & token, unsigned int start, unsigned int end) { - return atoi(token.substr(start, end - start).c_str()) - 1; + return std::stoul(token.substr(start, end - start)) - 1; } static inline float ParseOBJFloatValue(const std::string & token, unsigned int start, unsigned int end) { - return atof(token.substr(start, end - start).c_str()); + return std::stof(token.substr(start, end - start)); } static inline std::vector @@ -382,8 +413,9 @@ SplitString(const std::string & s, char delim) while (end <= strLength) { while (end <= strLength) { - if (cstr[end] == delim) + if (cstr[end] == delim) { break; + } end++; } diff --git a/obj_loader.h b/obj_loader.h index 5a1eabf..11c6b38 100644 --- a/obj_loader.h +++ b/obj_loader.h @@ -36,7 +36,7 @@ public: bool hasUVs; bool hasNormals; - OBJModel(const std::string & fileName); + explicit OBJModel(const std::string & fileName); IndexedModel ToIndexedModel(); diff --git a/ptr.hpp b/ptr.hpp new file mode 100644 index 0000000..b92b63e --- /dev/null +++ b/ptr.hpp @@ -0,0 +1,25 @@ +#ifndef PTR_H +#define PTR_H + +#include + +template class wrapped_ptr : public std::unique_ptr { +public: + using std::unique_ptr::unique_ptr; + wrapped_ptr() : std::unique_ptr {{}, {}} { } + + inline + operator Obj *() const + { + return this->get(); + } + + template + static auto + create(Obj * (*factory)(Args...), void (*deleter)(Obj *), Params &&... params) + { + return wrapped_ptr {factory(std::forward(params)...), deleter}; + } +}; + +#endif diff --git a/shader.cpp b/shader.cpp index 21098bd..4d9f43b 100644 --- a/shader.cpp +++ b/shader.cpp @@ -1,15 +1,20 @@ #include "shader.h" -#include -#include - -Shader::Shader(const std::string & fileName) +#include "transform.h" +#include +#include +#include +#include + +Shader::Shader(const std::string &) : + m_program {glCreateProgram()}, m_shaders {CreateShader( + (GLchar *)(basicShader_vs), basicShader_vs_len, GL_VERTEX_SHADER), + CreateShader( + (GLchar *)basicShader_fs, basicShader_fs_len, GL_FRAGMENT_SHADER)}, + m_uniforms {} { - m_program = glCreateProgram(); - m_shaders[0] = CreateShader(LoadShader(fileName + ".vs"), GL_VERTEX_SHADER); - m_shaders[1] = CreateShader(LoadShader(fileName + ".fs"), GL_FRAGMENT_SHADER); - - for (unsigned int i = 0; i < NUM_SHADERS; i++) - glAttachShader(m_program, m_shaders[i]); + for (auto m_shader : m_shaders) { + glAttachShader(m_program, m_shader); + } glBindAttribLocation(m_program, 0, "position"); glBindAttribLocation(m_program, 1, "texCoord"); @@ -19,97 +24,74 @@ Shader::Shader(const std::string & fileName) CheckShaderError(m_program, GL_LINK_STATUS, true, "Error linking shader program"); glValidateProgram(m_program); - CheckShaderError(m_program, GL_LINK_STATUS, true, "Invalid shader program"); + CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Invalid shader program"); - m_uniforms[0] = glGetUniformLocation(m_program, "MVP"); - m_uniforms[1] = glGetUniformLocation(m_program, "Normal"); - m_uniforms[2] = glGetUniformLocation(m_program, "lightDirection"); + m_uniforms = {glGetUniformLocation(m_program, "MVP"), glGetUniformLocation(m_program, "Normal"), + glGetUniformLocation(m_program, "lightDirection")}; } Shader::~Shader() { - for (unsigned int i = 0; i < NUM_SHADERS; i++) { - glDetachShader(m_program, m_shaders[i]); - glDeleteShader(m_shaders[i]); + for (auto m_shader : m_shaders) { + glDetachShader(m_program, m_shader); + glDeleteShader(m_shader); } glDeleteProgram(m_program); } void -Shader::Bind() +Shader::Bind() const { glUseProgram(m_program); } void -Shader::Update(const Transform & transform, const Camera & camera) +Shader::Update(const Transform & transform, const Camera & camera) const { glm::mat4 MVP = transform.GetMVP(camera); glm::mat4 Normal = transform.GetModel(); glUniformMatrix4fv(m_uniforms[0], 1, GL_FALSE, &MVP[0][0]); glUniformMatrix4fv(m_uniforms[1], 1, GL_FALSE, &Normal[0][0]); - glUniform3f(m_uniforms[2], 0.0f, 0.0f, 1.0f); -} - -std::string -Shader::LoadShader(const std::string & fileName) -{ - std::ifstream file; - file.open((fileName).c_str()); - - std::string output; - std::string line; - - if (file.is_open()) { - while (file.good()) { - getline(file, line); - output.append(line + "\n"); - } - } - else { - std::cerr << "Unable to load shader: " << fileName << std::endl; - } - - return output; + glUniform3f(m_uniforms[2], 0.0F, 0.0F, 1.0F); } void Shader::CheckShaderError(GLuint shader, GLuint flag, bool isProgram, const std::string & errorMessage) { GLint success = 0; - GLchar error[1024] = {0}; + std::array error {}; - if (isProgram) + if (isProgram) { glGetProgramiv(shader, flag, &success); - else + } + else { glGetShaderiv(shader, flag, &success); + } if (success == GL_FALSE) { - if (isProgram) - glGetProgramInfoLog(shader, sizeof(error), NULL, error); - else - glGetShaderInfoLog(shader, sizeof(error), NULL, error); + if (isProgram) { + glGetProgramInfoLog(shader, error.size(), nullptr, error.data()); + } + else { + glGetShaderInfoLog(shader, error.size(), nullptr, error.data()); + } - std::cerr << errorMessage << ": '" << error << "'" << std::endl; + throw std::runtime_error {errorMessage + ": '" + std::string {error.data(), error.size()} + "'"}; } } GLuint -Shader::CreateShader(const std::string & text, unsigned int type) +Shader::CreateShader(const GLchar * text, GLint len, unsigned int type) { GLuint shader = glCreateShader(type); - if (shader == 0) - std::cerr << "Error compiling shader type " << type << std::endl; - - const GLchar * p[1]; - p[0] = text.c_str(); - GLint lengths[1]; - lengths[0] = text.length(); + if (shader == 0) { + throw std::runtime_error {"Error compiling shader type " + std::to_string(type)}; + } - glShaderSource(shader, 1, p, lengths); + glShaderSource(shader, 1, &text, &len); glCompileShader(shader); CheckShaderError(shader, GL_COMPILE_STATUS, false, "Error compiling shader!"); diff --git a/shader.h b/shader.h index bd3ac38..85a7d58 100644 --- a/shader.h +++ b/shader.h @@ -1,36 +1,33 @@ #ifndef SHADER_INCLUDED_H #define SHADER_INCLUDED_H -#include "transform.h" #include +#include #include +class Camera; +class Transform; + class Shader { public: - Shader(const std::string & fileName); - - void Bind(); - void Update(const Transform & transform, const Camera & camera); - + explicit Shader(const std::string & fileName); virtual ~Shader(); + void operator=(const Shader &) = delete; + Shader(const Shader &) = delete; + + void Bind() const; + void Update(const Transform & transform, const Camera & camera) const; -protected: private: - static const unsigned int NUM_SHADERS = 2; - static const unsigned int NUM_UNIFORMS = 3; - void - operator=(const Shader & shader) - { - } - Shader(const Shader & shader) { } - - std::string LoadShader(const std::string & fileName); - void CheckShaderError(GLuint shader, GLuint flag, bool isProgram, const std::string & errorMessage); - GLuint CreateShader(const std::string & text, unsigned int type); + static constexpr unsigned int NUM_SHADERS = 2; + static constexpr unsigned int NUM_UNIFORMS = 3; + + static void CheckShaderError(GLuint shader, GLuint flag, bool isProgram, const std::string & errorMessage); + static GLuint CreateShader(const GLchar * text, GLint len, unsigned int type); GLuint m_program; - GLuint m_shaders[NUM_SHADERS]; - GLuint m_uniforms[NUM_UNIFORMS]; + std::array m_shaders; + std::array m_uniforms; }; #endif diff --git a/stb_image.c b/stb_image.c index 8ddfd1f..a839b61 100644 --- a/stb_image.c +++ b/stb_image.c @@ -1,2 +1,8 @@ -#define STB_IMAGE_IMPLEMENTATION -#include "stb_image.h" +#ifndef TIDY +# define STB_IMAGE_IMPLEMENTATION +# pragma GCC diagnostic ignored "-Wsign-compare" +# ifndef __clang__ +# pragma GCC diagnostic ignored "-Wunused-but-set-variable" +# endif +# include "stb_image.h" +#endif diff --git a/texture.cpp b/texture.cpp index aae16b3..a388b32 100644 --- a/texture.cpp +++ b/texture.cpp @@ -1,14 +1,15 @@ #include "texture.h" #include "stb_image.h" -#include +#include -Texture::Texture(const std::string & fileName) +Texture::Texture(const std::string & fileName) : m_texture {} { int width, height, numComponents; unsigned char * data = stbi_load((fileName).c_str(), &width, &height, &numComponents, 4); - if (data == NULL) - std::cerr << "Unable to load texture: " << fileName << std::endl; + if (!data) { + throw std::runtime_error {"Unable to load texture: " + fileName}; + } glGenTextures(1, &m_texture); glBindTexture(GL_TEXTURE_2D, m_texture); @@ -28,7 +29,7 @@ Texture::~Texture() } void -Texture::Bind() +Texture::Bind() const { glBindTexture(GL_TEXTURE_2D, m_texture); } diff --git a/texture.h b/texture.h index df9f287..9955f01 100644 --- a/texture.h +++ b/texture.h @@ -6,20 +6,17 @@ class Texture { public: - Texture(const std::string & fileName); + explicit Texture(const std::string & fileName); - void Bind(); + Texture(const Texture &) = delete; + void operator=(const Texture &) = delete; virtual ~Texture(); + void Bind() const; + protected: private: - Texture(const Texture & texture) { } - void - operator=(const Texture & texture) - { - } - GLuint m_texture; }; diff --git a/transform.cpp b/transform.cpp new file mode 100644 index 0000000..7b256af --- /dev/null +++ b/transform.cpp @@ -0,0 +1,27 @@ +#include "transform.h" +#include "camera.h" +#include + +Transform::Transform(glm::vec3 pos, glm::vec3 rot, glm::vec3 scale) : pos {pos}, rot {rot}, scale {scale} { } + +glm::mat4 +Transform::GetModel() const +{ + const auto posMat = glm::translate(pos); + const auto scaleMat = glm::scale(scale); + const auto rotX = glm::rotate(rot.x, glm::vec3(1.0, 0.0, 0.0)); + const auto rotY = glm::rotate(rot.y, glm::vec3(0.0, 1.0, 0.0)); + const auto rotZ = glm::rotate(rot.z, glm::vec3(0.0, 0.0, 1.0)); + const auto rotMat = rotX * rotY * rotZ; + + return posMat * rotMat * scaleMat; +} + +glm::mat4 +Transform::GetMVP(const Camera & camera) const +{ + const auto VP = camera.GetViewProjection(); + const auto M = GetModel(); + + return VP * M; +} diff --git a/transform.h b/transform.h index ed9b703..783ef31 100644 --- a/transform.h +++ b/transform.h @@ -1,75 +1,55 @@ #ifndef TRANSFORM_INCLUDED_H #define TRANSFORM_INCLUDED_H -#include "camera.h" #include -#include +#include -struct Transform { -public: - Transform(const glm::vec3 & pos = glm::vec3(), const glm::vec3 & rot = glm::vec3(), - const glm::vec3 & scale = glm::vec3(1.0f, 1.0f, 1.0f)) - { - this->pos = pos; - this->rot = rot; - this->scale = scale; - } +class Camera; - inline glm::mat4 - GetModel() const - { - glm::mat4 posMat = glm::translate(pos); - glm::mat4 scaleMat = glm::scale(scale); - glm::mat4 rotX = glm::rotate(rot.x, glm::vec3(1.0, 0.0, 0.0)); - glm::mat4 rotY = glm::rotate(rot.y, glm::vec3(0.0, 1.0, 0.0)); - glm::mat4 rotZ = glm::rotate(rot.z, glm::vec3(0.0, 0.0, 1.0)); - glm::mat4 rotMat = rotX * rotY * rotZ; +class Transform { +public: + Transform(glm::vec3 pos = {}, glm::vec3 rot = {}, glm::vec3 scale = {1.0f, 1.0f, 1.0f}); - return posMat * rotMat * scaleMat; - } + glm::mat4 GetModel() const; - inline glm::mat4 - GetMVP(const Camera & camera) const - { - glm::mat4 VP = camera.GetViewProjection(); - glm::mat4 M = GetModel(); + glm::mat4 GetMVP(const Camera & camera) const; - return VP * M; // camera.GetViewProjection() * GetModel(); - } - - inline glm::vec3 * + inline glm::vec3 & GetPos() { - return &pos; + return pos; } - inline glm::vec3 * + + inline glm::vec3 & GetRot() { - return &rot; + return rot; } - inline glm::vec3 * + + inline glm::vec3 & GetScale() { - return &scale; + return scale; } inline void - SetPos(glm::vec3 & pos) + SetPos(glm::vec3 && pos) { - this->pos = pos; + this->pos = std::move(pos); } + inline void - SetRot(glm::vec3 & rot) + SetRot(glm::vec3 && rot) { - this->rot = rot; + this->rot = std::move(rot); } + inline void - SetScale(glm::vec3 & scale) + SetScale(glm::vec3 && scale) { - this->scale = scale; + this->scale = std::move(scale); } -protected: private: glm::vec3 pos; glm::vec3 rot; diff --git a/util.h b/util.h index cbabdb8..83de626 100644 --- a/util.h +++ b/util.h @@ -1,7 +1,6 @@ #ifndef UTIL_H_INCLUDED #define UTIL_H_INCLUDED -#include "debugTimer.h" #include #include diff --git a/vertex.hpp b/vertex.hpp new file mode 100644 index 0000000..3f6514b --- /dev/null +++ b/vertex.hpp @@ -0,0 +1,36 @@ +#ifndef VERTEX_H +#define VERTEX_H + +#include + +class Vertex { +public: + Vertex(glm::vec3 pos, glm::vec2 texCoord, glm::vec3 normal) : + pos {std::move(pos)}, texCoord {std::move(texCoord)}, normal {std::move(normal)} + { + } + + glm::vec3 & + GetPos() + { + return pos; + } + + glm::vec2 & + GetTexCoord() + { + return texCoord; + } + + glm::vec3 & + GetNormal() + { + return normal; + } + +private: + glm::vec3 pos; + glm::vec2 texCoord; + glm::vec3 normal; +}; +#endif -- cgit v1.2.3