Autoformat everything + minor include fixes
This commit is contained in:
parent
8e4eacf48f
commit
9c1417a8f9
@ -9,13 +9,14 @@
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
|
||||
struct Camera {
|
||||
/// Create a camera with a field of view (in degrees), width and height (in any unit) and near and far distances
|
||||
Camera(float fov, float width, float height, float near, float far) : projection(
|
||||
glm::perspective(glm::radians(fov), width / height, near, far)) {}
|
||||
/// Create a camera with a field of view (in degrees), width and height (in any unit) and near
|
||||
/// and far distances
|
||||
Camera(float fov, float width, float height, float near, float far)
|
||||
: projection(glm::perspective(glm::radians(fov), width / height, near, far)) {}
|
||||
|
||||
glm::mat4 projection;
|
||||
|
||||
glm::mat4 view;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_CAMERA_H
|
||||
#endif // ECSGAME_CAMERA_H
|
||||
|
||||
@ -5,10 +5,12 @@
|
||||
#ifndef ECSGAME_DIRECTIONALLIGHT_H
|
||||
#define ECSGAME_DIRECTIONALLIGHT_H
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
struct DirectionalLight {
|
||||
explicit DirectionalLight(const glm::vec3 &direction) : direction(direction) {}
|
||||
|
||||
glm::vec3 direction;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_DIRECTIONALLIGHT_H
|
||||
#endif // ECSGAME_DIRECTIONALLIGHT_H
|
||||
|
||||
@ -5,9 +5,9 @@
|
||||
#ifndef ECSGAME_LODOBJMESH_H
|
||||
#define ECSGAME_LODOBJMESH_H
|
||||
|
||||
#include "ObjMesh.h"
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include "ObjMesh.h"
|
||||
|
||||
struct LODObjMesh {
|
||||
explicit LODObjMesh(std::vector<ObjMesh> meshes) : meshes(std::move(meshes)) {}
|
||||
@ -15,4 +15,4 @@ struct LODObjMesh {
|
||||
std::vector<ObjMesh> meshes;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_LODOBJMESH_H
|
||||
#endif // ECSGAME_LODOBJMESH_H
|
||||
|
||||
@ -5,13 +5,15 @@
|
||||
#ifndef ECSGAME_MESH_H
|
||||
#define ECSGAME_MESH_H
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <GLFW/glfw3.h>
|
||||
#include <glad/glad.h>
|
||||
#include <vector>
|
||||
|
||||
struct Mesh {
|
||||
explicit Mesh(const std::vector<float> &_vertices, const std::vector<unsigned int> &_indices) : vertex_count(_indices.size()) {
|
||||
// Copy the vertices into a local classic float array. Nothing was displayed without this, maybe
|
||||
explicit Mesh(const std::vector<float> &_vertices, const std::vector<unsigned int> &_indices)
|
||||
: vertex_count(_indices.size()) {
|
||||
// Copy the vertices into a local classic float array. Nothing was displayed without this,
|
||||
// maybe
|
||||
// due to weird hidden type incompatibility or out of scope issues?
|
||||
float vertices[_vertices.size()];
|
||||
std::copy(_vertices.begin(), _vertices.end(), vertices);
|
||||
@ -23,7 +25,8 @@ struct Mesh {
|
||||
glGenBuffers(1, &VBO);
|
||||
glGenBuffers(1, &EBO);
|
||||
|
||||
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
|
||||
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then
|
||||
// configure vertex attributes(s).
|
||||
glBindVertexArray(VAO);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
||||
@ -33,23 +36,27 @@ struct Mesh {
|
||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
|
||||
|
||||
// position attribute
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)0);
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void *)0);
|
||||
glEnableVertexAttribArray(0);
|
||||
|
||||
// Normal attribute
|
||||
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
|
||||
(void *)(3 * sizeof(float)));
|
||||
glEnableVertexAttribArray(1);
|
||||
|
||||
// texture coord attribute
|
||||
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(6 * sizeof(float)));
|
||||
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
|
||||
(void *)(6 * sizeof(float)));
|
||||
glEnableVertexAttribArray(2);
|
||||
|
||||
// Tangent attribute
|
||||
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(8 * sizeof(float)));
|
||||
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
|
||||
(void *)(8 * sizeof(float)));
|
||||
glEnableVertexAttribArray(3);
|
||||
|
||||
// Bitangent attribute
|
||||
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(11 * sizeof(float)));
|
||||
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
|
||||
(void *)(11 * sizeof(float)));
|
||||
glEnableVertexAttribArray(4);
|
||||
|
||||
glBindVertexArray(0);
|
||||
@ -61,11 +68,11 @@ struct Mesh {
|
||||
glDrawElements(GL_TRIANGLES, vertex_count, GL_UNSIGNED_INT, 0);
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
unsigned int EBO;
|
||||
unsigned int VBO;
|
||||
unsigned int VAO;
|
||||
unsigned int vertex_count;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_MESH_H
|
||||
#endif // ECSGAME_MESH_H
|
||||
|
||||
@ -5,6 +5,9 @@
|
||||
#ifndef ECSGAME_MOUSELOOK_H
|
||||
#define ECSGAME_MOUSELOOK_H
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/quaternion.hpp>
|
||||
|
||||
struct MouseLook {
|
||||
explicit MouseLook(float sensitivity) : sensitivity(sensitivity) {}
|
||||
|
||||
@ -18,4 +21,4 @@ struct MouseLook {
|
||||
bool is_active = true;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_MOUSELOOK_H
|
||||
#endif // ECSGAME_MOUSELOOK_H
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#ifndef ECSGAME_MOVEMENT_H
|
||||
#define ECSGAME_MOVEMENT_H
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
struct Movement {
|
||||
Movement(glm::vec3 speed) : speed(speed) {}
|
||||
|
||||
@ -17,4 +19,4 @@ struct Movement {
|
||||
bool is_active = true;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_MOVEMENT_H
|
||||
#endif // ECSGAME_MOVEMENT_H
|
||||
|
||||
@ -5,29 +5,31 @@
|
||||
#ifndef ECSGAME_OBJMESH_H
|
||||
#define ECSGAME_OBJMESH_H
|
||||
|
||||
#include "Mesh.h"
|
||||
#include "../../Util/OBJ_Loader.h"
|
||||
#include "Mesh.h"
|
||||
|
||||
struct ObjMesh : public Mesh {
|
||||
struct Settings {
|
||||
Settings() = default;
|
||||
|
||||
Settings(float minDistanceForRender, float maxDistanceForRender, float diffuse, float specular)
|
||||
: minDistanceForRender(minDistanceForRender), maxDistanceForRender(maxDistanceForRender) {}
|
||||
Settings(float minDistanceForRender, float maxDistanceForRender, float diffuse,
|
||||
float specular)
|
||||
: minDistanceForRender(minDistanceForRender),
|
||||
maxDistanceForRender(maxDistanceForRender) {}
|
||||
|
||||
float minDistanceForRender = 0.0;
|
||||
float maxDistanceForRender = 1000.0;
|
||||
};
|
||||
|
||||
explicit ObjMesh(const std::string &path, const Settings &settings) : Mesh(getVerticesFromFile(path), getIndicesFromFile(path)),
|
||||
minDistance(settings.minDistanceForRender),
|
||||
maxDistance(settings.maxDistanceForRender) {}
|
||||
explicit ObjMesh(const std::string &path, const Settings &settings)
|
||||
: Mesh(getVerticesFromFile(path), getIndicesFromFile(path)),
|
||||
minDistance(settings.minDistanceForRender), maxDistance(settings.maxDistanceForRender) {}
|
||||
|
||||
float minDistance;
|
||||
|
||||
float maxDistance;
|
||||
|
||||
private:
|
||||
private:
|
||||
static std::vector<float> getVerticesFromFile(const std::string &path) {
|
||||
objl::Loader loader;
|
||||
|
||||
@ -65,13 +67,16 @@ private:
|
||||
return vertexData;
|
||||
} else {
|
||||
// Output Error
|
||||
std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
std::cout
|
||||
<< "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
}
|
||||
}
|
||||
|
||||
static std::pair<std::vector<glm::vec3>, std::vector<glm::vec3>> getTangentsFromVertices(const std::vector<objl::Vertex> &vertices, const std::vector<unsigned int> indices) {
|
||||
// These vectors hold tangents and bitangents in the same way in which the vertices vectors holds vertices:
|
||||
// Their index in the vector corresponds to indices in the indices vector.
|
||||
static std::pair<std::vector<glm::vec3>, std::vector<glm::vec3>>
|
||||
getTangentsFromVertices(const std::vector<objl::Vertex> &vertices,
|
||||
const std::vector<unsigned int> indices) {
|
||||
// These vectors hold tangents and bitangents in the same way in which the vertices vectors
|
||||
// holds vertices: Their index in the vector corresponds to indices in the indices vector.
|
||||
std::vector<glm::vec3> tangents(vertices.size());
|
||||
std::vector<glm::vec3> bitangents(vertices.size());
|
||||
|
||||
@ -83,17 +88,26 @@ private:
|
||||
uint i2 = indices[index + 2];
|
||||
|
||||
// Inputs
|
||||
glm::vec3 vertex0 = glm::vec3(vertices[i0].Position.X, vertices[i0].Position.Y, vertices[i0].Position.Z);
|
||||
glm::vec3 vertex1 = glm::vec3(vertices[i1].Position.X, vertices[i1].Position.Y, vertices[i1].Position.Z);
|
||||
glm::vec3 vertex2 = glm::vec3(vertices[i2].Position.X, vertices[i2].Position.Y, vertices[i2].Position.Z);
|
||||
glm::vec3 vertex0 = glm::vec3(vertices[i0].Position.X, vertices[i0].Position.Y,
|
||||
vertices[i0].Position.Z);
|
||||
glm::vec3 vertex1 = glm::vec3(vertices[i1].Position.X, vertices[i1].Position.Y,
|
||||
vertices[i1].Position.Z);
|
||||
glm::vec3 vertex2 = glm::vec3(vertices[i2].Position.X, vertices[i2].Position.Y,
|
||||
vertices[i2].Position.Z);
|
||||
|
||||
glm::vec2 uv0 = glm::vec2(vertices[i0].TextureCoordinate.X, vertices[i0].TextureCoordinate.Y);
|
||||
glm::vec2 uv1 = glm::vec2(vertices[i1].TextureCoordinate.X, vertices[i1].TextureCoordinate.Y);
|
||||
glm::vec2 uv2 = glm::vec2(vertices[i2].TextureCoordinate.X, vertices[i2].TextureCoordinate.Y);
|
||||
glm::vec2 uv0 =
|
||||
glm::vec2(vertices[i0].TextureCoordinate.X, vertices[i0].TextureCoordinate.Y);
|
||||
glm::vec2 uv1 =
|
||||
glm::vec2(vertices[i1].TextureCoordinate.X, vertices[i1].TextureCoordinate.Y);
|
||||
glm::vec2 uv2 =
|
||||
glm::vec2(vertices[i2].TextureCoordinate.X, vertices[i2].TextureCoordinate.Y);
|
||||
|
||||
glm::vec3 normal0 = glm::vec3(vertices[i0].Normal.X, vertices[i0].Normal.Y, vertices[i0].Normal.Z);
|
||||
glm::vec3 normal1 = glm::vec3(vertices[i1].Normal.X, vertices[i1].Normal.Y, vertices[i1].Normal.Z);
|
||||
glm::vec3 normal2 = glm::vec3(vertices[i2].Normal.X, vertices[i2].Normal.Y, vertices[i2].Normal.Z);
|
||||
glm::vec3 normal0 =
|
||||
glm::vec3(vertices[i0].Normal.X, vertices[i0].Normal.Y, vertices[i0].Normal.Z);
|
||||
glm::vec3 normal1 =
|
||||
glm::vec3(vertices[i1].Normal.X, vertices[i1].Normal.Y, vertices[i1].Normal.Z);
|
||||
glm::vec3 normal2 =
|
||||
glm::vec3(vertices[i2].Normal.X, vertices[i2].Normal.Y, vertices[i2].Normal.Z);
|
||||
|
||||
// Edges of the triangle : position delta
|
||||
glm::vec3 deltaPos1 = vertex1 - vertex0;
|
||||
@ -104,8 +118,8 @@ private:
|
||||
glm::vec2 deltaUV2 = uv2 - uv0;
|
||||
|
||||
float r = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV1.y * deltaUV2.x);
|
||||
glm::vec3 tangent = (deltaPos1 * deltaUV2.y - deltaPos2 * deltaUV1.y)*r;
|
||||
glm::vec3 bitangent = (deltaPos2 * deltaUV1.x - deltaPos1 * deltaUV2.x)*r;
|
||||
glm::vec3 tangent = (deltaPos1 * deltaUV2.y - deltaPos2 * deltaUV1.y) * r;
|
||||
glm::vec3 bitangent = (deltaPos2 * deltaUV1.x - deltaPos1 * deltaUV2.x) * r;
|
||||
|
||||
// Add the tangent and bitangent to the current value in the array.
|
||||
// This is done to get an average in the end.
|
||||
@ -140,7 +154,8 @@ private:
|
||||
return indices;
|
||||
} else {
|
||||
// Output Error
|
||||
std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
std::cout
|
||||
<< "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
}
|
||||
}
|
||||
|
||||
@ -158,12 +173,12 @@ private:
|
||||
|
||||
// Print Material
|
||||
std::cout << "Material: " << curMesh.MeshMaterial.name << "\n";
|
||||
std::cout << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", " << curMesh.MeshMaterial.Ka.Y << ", "
|
||||
<< curMesh.MeshMaterial.Ka.Z << "\n";
|
||||
std::cout << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", " << curMesh.MeshMaterial.Kd.Y << ", "
|
||||
<< curMesh.MeshMaterial.Kd.Z << "\n";
|
||||
std::cout << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", " << curMesh.MeshMaterial.Ks.Y << ", "
|
||||
<< curMesh.MeshMaterial.Ks.Z << "\n";
|
||||
std::cout << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", "
|
||||
<< curMesh.MeshMaterial.Ka.Y << ", " << curMesh.MeshMaterial.Ka.Z << "\n";
|
||||
std::cout << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", "
|
||||
<< curMesh.MeshMaterial.Kd.Y << ", " << curMesh.MeshMaterial.Kd.Z << "\n";
|
||||
std::cout << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", "
|
||||
<< curMesh.MeshMaterial.Ks.Y << ", " << curMesh.MeshMaterial.Ks.Z << "\n";
|
||||
std::cout << "Specular Exponent: " << curMesh.MeshMaterial.Ns << "\n";
|
||||
std::cout << "Optical Density: " << curMesh.MeshMaterial.Ni << "\n";
|
||||
std::cout << "Dissolve: " << curMesh.MeshMaterial.d << "\n";
|
||||
@ -177,9 +192,10 @@ private:
|
||||
return vertexData;
|
||||
} else {
|
||||
// Output Error
|
||||
std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
std::cout
|
||||
<< "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#endif //ECSGAME_OBJMESH_H
|
||||
#endif // ECSGAME_OBJMESH_H
|
||||
|
||||
@ -26,9 +26,7 @@ struct PathMove {
|
||||
struct Views {
|
||||
Views(std::vector<glm::quat> views) : views(views) {}
|
||||
|
||||
void add_view(glm::quat new_quat) {
|
||||
views.emplace_back(new_quat);
|
||||
}
|
||||
void add_view(glm::quat new_quat) { views.emplace_back(new_quat); }
|
||||
|
||||
std::vector<glm::quat> views;
|
||||
};
|
||||
@ -40,7 +38,8 @@ struct PathMove {
|
||||
float time_passed = 0.0;
|
||||
int current_point_index = 0;
|
||||
|
||||
int speed_addition = 0; // 0, -1 or 1 depending on whether the speed should stay, decrease or increase
|
||||
int speed_addition =
|
||||
0; // 0, -1 or 1 depending on whether the speed should stay, decrease or increase
|
||||
|
||||
Path path;
|
||||
Views views;
|
||||
|
||||
@ -5,11 +5,14 @@
|
||||
#ifndef ECSGAME_SINEANIMATION_H
|
||||
#define ECSGAME_SINEANIMATION_H
|
||||
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
|
||||
struct SineAnimation {
|
||||
SineAnimation(const glm::vec3 &maxDistance, float speedScale) : maxDistance(maxDistance), speedScale(speedScale) {}
|
||||
SineAnimation(const glm::vec3 &maxDistance, float speedScale)
|
||||
: maxDistance(maxDistance), speedScale(speedScale) {}
|
||||
|
||||
glm::vec3 maxDistance;
|
||||
float speedScale;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_SINEANIMATION_H
|
||||
#endif // ECSGAME_SINEANIMATION_H
|
||||
|
||||
@ -19,7 +19,7 @@ struct Texture {
|
||||
};
|
||||
|
||||
// Bind a texture from the given path and return its ID
|
||||
uint loadTexture(const std::string& path, Settings settings) {
|
||||
uint loadTexture(const std::string &path, Settings settings) {
|
||||
uint gl_id;
|
||||
|
||||
glGenTextures(1, &gl_id);
|
||||
@ -41,15 +41,12 @@ struct Texture {
|
||||
if (data) {
|
||||
// Alpha channel?
|
||||
unsigned int glChannels = GL_RGB;
|
||||
if (nrChannels == 4) {
|
||||
glChannels = GL_RGBA;
|
||||
}
|
||||
if (nrChannels == 4) { glChannels = GL_RGBA; }
|
||||
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, glChannels, width, height, 0, glChannels, GL_UNSIGNED_BYTE, data);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, glChannels, width, height, 0, glChannels,
|
||||
GL_UNSIGNED_BYTE, data);
|
||||
|
||||
if (settings.mipmaps) {
|
||||
glGenerateMipmap(GL_TEXTURE_2D);
|
||||
}
|
||||
if (settings.mipmaps) { glGenerateMipmap(GL_TEXTURE_2D); }
|
||||
} else {
|
||||
std::cout << "Failed to load texture" << std::endl;
|
||||
}
|
||||
@ -59,11 +56,12 @@ struct Texture {
|
||||
return gl_id;
|
||||
}
|
||||
|
||||
explicit Texture(const std::string& path, Settings settings, bool transparent) : id(loadTexture(path, settings)), render_transparent(transparent) {}
|
||||
explicit Texture(const std::string &path, Settings settings, bool transparent)
|
||||
: id(loadTexture(path, settings)), render_transparent(transparent) {}
|
||||
|
||||
void addNormalmap(const std::string& path, Settings settings) {
|
||||
normal_id = loadTexture(path, settings);
|
||||
void addNormalmap(const std::string &path, Settings settings) {
|
||||
normal_id = loadTexture(path, settings);
|
||||
}
|
||||
};
|
||||
|
||||
#endif //ECSGAME_TEXTURE_H
|
||||
#endif // ECSGAME_TEXTURE_H
|
||||
|
||||
@ -17,33 +17,21 @@ struct Transform {
|
||||
glm::mat4 matrix = glm::mat4(1.0f); // Initialize as identity
|
||||
glm::vec3 origin = glm::vec3(0.0f, 0.0f, 0.0f);
|
||||
|
||||
void translate(glm::vec3 offset) {
|
||||
matrix = glm::translate(matrix, offset);
|
||||
}
|
||||
void translate(glm::vec3 offset) { matrix = glm::translate(matrix, offset); }
|
||||
|
||||
glm::vec3 get_translation() {
|
||||
return glm::vec3(matrix[3]);
|
||||
}
|
||||
glm::vec3 get_translation() { return glm::vec3(matrix[3]); }
|
||||
|
||||
void uniform_scale(float factor) {
|
||||
scale(glm::vec3(factor, factor, factor));
|
||||
}
|
||||
void uniform_scale(float factor) { scale(glm::vec3(factor, factor, factor)); }
|
||||
|
||||
void scale(glm::vec3 factors) {
|
||||
matrix = glm::scale(matrix, factors);
|
||||
}
|
||||
void scale(glm::vec3 factors) { matrix = glm::scale(matrix, factors); }
|
||||
|
||||
void rotate(float degrees, glm::vec3 axis) {
|
||||
matrix = glm::rotate(matrix, glm::radians(degrees), axis);
|
||||
}
|
||||
|
||||
void set_origin(glm::vec3 position) {
|
||||
origin = position;
|
||||
}
|
||||
void set_origin(glm::vec3 position) { origin = position; }
|
||||
|
||||
void add_to_origin(glm::vec3 addition) {
|
||||
origin += addition;
|
||||
}
|
||||
void add_to_origin(glm::vec3 addition) { origin += addition; }
|
||||
|
||||
void set_rotation_from_quat(glm::quat quaternion) {
|
||||
// Remember translation
|
||||
@ -53,21 +41,13 @@ struct Transform {
|
||||
matrix[3] = save;
|
||||
}
|
||||
|
||||
glm::vec3 get_origin() const {
|
||||
return origin;
|
||||
}
|
||||
glm::vec3 get_origin() const { return origin; }
|
||||
|
||||
glm::vec3 forward() const {
|
||||
return matrix * glm::vec4(0.0, 0.0, -1.0, 0.0);
|
||||
}
|
||||
glm::vec3 forward() const { return matrix * glm::vec4(0.0, 0.0, -1.0, 0.0); }
|
||||
|
||||
glm::vec3 up() const {
|
||||
return matrix * glm::vec4(0.0, 1.0, 0.0, 0.0);
|
||||
}
|
||||
glm::vec3 up() const { return matrix * glm::vec4(0.0, 1.0, 0.0, 0.0); }
|
||||
|
||||
glm::vec3 right() const {
|
||||
return matrix * glm::vec4(1.0, 0.0, 0.0, 0.0);
|
||||
}
|
||||
glm::vec3 right() const { return matrix * glm::vec4(1.0, 0.0, 0.0, 0.0); }
|
||||
};
|
||||
|
||||
#endif //ECSGAME_TRANSFORM_H
|
||||
#endif // ECSGAME_TRANSFORM_H
|
||||
|
||||
@ -10,4 +10,4 @@ struct InputEvent {
|
||||
int action;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_INPUTEVENT_H
|
||||
#endif // ECSGAME_INPUTEVENT_H
|
||||
|
||||
@ -10,4 +10,4 @@ struct MouseMoveEvent {
|
||||
double newY;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_INPUTEVENT_H
|
||||
#endif // ECSGAME_INPUTEVENT_H
|
||||
|
||||
@ -5,16 +5,14 @@
|
||||
#ifndef ECSGAME_GRAVITYSYSTEM_H
|
||||
#define ECSGAME_GRAVITYSYSTEM_H
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
class GravitySystem : public EntitySystem {
|
||||
public:
|
||||
explicit GravitySystem(float amount) {
|
||||
gravityAmount = amount;
|
||||
}
|
||||
public:
|
||||
explicit GravitySystem(float amount) { gravityAmount = amount; }
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform>([&](Entity *ent, ComponentHandle<Transform> position) {
|
||||
@ -22,8 +20,8 @@ public:
|
||||
});
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
float gravityAmount;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_GRAVITYSYSTEM_H
|
||||
#endif // ECSGAME_GRAVITYSYSTEM_H
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
#ifndef __PATHMOVEMENTSWITCHSYSTEM_H__
|
||||
#define __PATHMOVEMENTSWITCHSYSTEM_H__
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <GLFW/glfw3.h>
|
||||
#include <glad/glad.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/MouseLook.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/PathMove.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/MouseLook.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -23,36 +23,39 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
|
||||
|
||||
void receive(World *pWorld, const InputEvent &event) override {
|
||||
if (event.key == GLFW_KEY_P) {
|
||||
myWorld->each<PathMove, Movement, MouseLook>([&](Entity *ent, ComponentHandle<PathMove> pathmove, ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook) {
|
||||
if (event.action == GLFW_PRESS) {
|
||||
// Switch between them
|
||||
if (pathmove->is_active) {
|
||||
pathmove->is_active = false;
|
||||
movement->is_active = true;
|
||||
mouselook->is_active = true;
|
||||
} else {
|
||||
pathmove->is_active = true;
|
||||
movement->is_active = false;
|
||||
mouselook->is_active = false;
|
||||
myWorld->each<PathMove, Movement, MouseLook>(
|
||||
[&](Entity *ent, ComponentHandle<PathMove> pathmove,
|
||||
ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook) {
|
||||
if (event.action == GLFW_PRESS) {
|
||||
// Switch between them
|
||||
if (pathmove->is_active) {
|
||||
pathmove->is_active = false;
|
||||
movement->is_active = true;
|
||||
mouselook->is_active = true;
|
||||
} else {
|
||||
pathmove->is_active = true;
|
||||
movement->is_active = false;
|
||||
mouselook->is_active = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
} else if (event.key == GLFW_KEY_R) {
|
||||
myWorld->each<PathMove, Movement, MouseLook, Transform>([&](Entity *ent, ComponentHandle<PathMove> pathmove, ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook, ComponentHandle<Transform> transform) {
|
||||
if (event.action == GLFW_PRESS) {
|
||||
// Add this point to the path
|
||||
pathmove->path.add_point(transform->origin);
|
||||
pathmove->views.add_view(mouselook->rotation);
|
||||
}
|
||||
});
|
||||
myWorld->each<PathMove, Movement, MouseLook, Transform>(
|
||||
[&](Entity *ent, ComponentHandle<PathMove> pathmove,
|
||||
ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook,
|
||||
ComponentHandle<Transform> transform) {
|
||||
if (event.action == GLFW_PRESS) {
|
||||
// Add this point to the path
|
||||
pathmove->path.add_point(transform->origin);
|
||||
pathmove->views.add_view(mouselook->rotation);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void unconfigure(World *pWorld) override {
|
||||
pWorld->unsubscribeAll(this);
|
||||
}
|
||||
void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
|
||||
|
||||
private:
|
||||
private:
|
||||
World *myWorld;
|
||||
};
|
||||
|
||||
|
||||
@ -5,15 +5,15 @@
|
||||
#ifndef ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
|
||||
#define ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <GLFW/glfw3.h>
|
||||
#include <glad/glad.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
#include "../Components/Movement.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -61,20 +61,20 @@ class KeyboardMovementSystem : public EntitySystem, public EventSubscriber<Input
|
||||
}
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform, Movement>(
|
||||
[&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<Movement> movement) {
|
||||
if (!movement->is_active) return;
|
||||
pWorld->each<Transform, Movement>([&](Entity *ent, ComponentHandle<Transform> transform,
|
||||
ComponentHandle<Movement> movement) {
|
||||
if (!movement->is_active) return;
|
||||
|
||||
transform->add_to_origin(transform->matrix * glm::vec4((glm::vec3(movement->moving) * movement->speed * deltaTime), 0.0));
|
||||
});
|
||||
transform->add_to_origin(
|
||||
transform->matrix *
|
||||
glm::vec4((glm::vec3(movement->moving) * movement->speed * deltaTime), 0.0));
|
||||
});
|
||||
}
|
||||
|
||||
void unconfigure(World *pWorld) override {
|
||||
pWorld->unsubscribeAll(this);
|
||||
}
|
||||
void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
|
||||
|
||||
private:
|
||||
private:
|
||||
World *myWorld;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
|
||||
#endif // ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
|
||||
|
||||
@ -5,15 +5,16 @@
|
||||
#ifndef ECSGAME_MOUSELOOKSYSTEM_H
|
||||
#define ECSGAME_MOUSELOOKSYSTEM_H
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../Components/Camera.h"
|
||||
#include "../Components/MouseLook.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/MouseMoveEvent.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
class MouseLookSystem : public EntitySystem, public EventSubscriber<MouseMoveEvent> {
|
||||
public:
|
||||
class MouseLookSystem : public EntitySystem, public EventSubscriber<MouseMoveEvent> {
|
||||
public:
|
||||
explicit MouseLookSystem(int width, int height) : lastX(width / 2.0), lastY(height / 2.0) {}
|
||||
|
||||
void configure(World *pWorld) override {
|
||||
@ -22,44 +23,46 @@ public:
|
||||
myWorld->subscribe<MouseMoveEvent>(this);
|
||||
}
|
||||
|
||||
void unconfigure(World *pWorld) override {
|
||||
pWorld->unsubscribeAll(this);
|
||||
}
|
||||
void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
|
||||
|
||||
void receive(World *pWorld, const MouseMoveEvent &event) override {
|
||||
pWorld->each<Transform, MouseLook, Camera>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse, ComponentHandle<Camera> camera) {
|
||||
double xOffset = lastX - event.newX;
|
||||
double yOffset = lastY - event.newY;
|
||||
pWorld->each<Transform, MouseLook, Camera>(
|
||||
[&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse,
|
||||
ComponentHandle<Camera> camera) {
|
||||
double xOffset = lastX - event.newX;
|
||||
double yOffset = lastY - event.newY;
|
||||
|
||||
lastX = event.newX;
|
||||
lastY = event.newY;
|
||||
lastX = event.newX;
|
||||
lastY = event.newY;
|
||||
|
||||
mouse->yaw += xOffset * mouse->sensitivity;
|
||||
mouse->pitch += yOffset * mouse->sensitivity;
|
||||
});
|
||||
mouse->yaw += xOffset * mouse->sensitivity;
|
||||
mouse->pitch += yOffset * mouse->sensitivity;
|
||||
});
|
||||
}
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform, MouseLook, Camera>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse, ComponentHandle<Camera> camera) {
|
||||
if (!mouse->is_active) return;
|
||||
pWorld->each<Transform, MouseLook, Camera>(
|
||||
[&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse,
|
||||
ComponentHandle<Camera> camera) {
|
||||
if (!mouse->is_active) return;
|
||||
|
||||
if(mouse->pitch > 80.0f)
|
||||
mouse->pitch = 80.0f;
|
||||
if(mouse->pitch < -80.0f)
|
||||
mouse->pitch = -80.0f;
|
||||
if (mouse->pitch > 80.0f) mouse->pitch = 80.0f;
|
||||
if (mouse->pitch < -80.0f) mouse->pitch = -80.0f;
|
||||
|
||||
mouse->rotation = glm::angleAxis(glm::radians((float)mouse->yaw), glm::vec3(0.f, 1.f, 0.f));
|
||||
mouse->rotation *= glm::angleAxis(glm::radians((float)mouse->pitch), glm::vec3(1.f, 0.f, 0.f));
|
||||
mouse->rotation =
|
||||
glm::angleAxis(glm::radians((float)mouse->yaw), glm::vec3(0.f, 1.f, 0.f));
|
||||
mouse->rotation *=
|
||||
glm::angleAxis(glm::radians((float)mouse->pitch), glm::vec3(1.f, 0.f, 0.f));
|
||||
|
||||
transform->set_rotation_from_quat(mouse->rotation);
|
||||
});
|
||||
transform->set_rotation_from_quat(mouse->rotation);
|
||||
});
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
double lastX;
|
||||
double lastY;
|
||||
|
||||
World *myWorld;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_MOUSELOOKSYSTEM_H
|
||||
#endif // ECSGAME_MOUSELOOKSYSTEM_H
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
#ifndef __PATHMOVESYSTEM_H__
|
||||
#define __PATHMOVESYSTEM_H__
|
||||
|
||||
#include <glad/glad.h>
|
||||
#include <GLFW/glfw3.h>
|
||||
#include <glad/glad.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
#include "../Components/PathMove.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -19,7 +19,7 @@ using namespace ECS;
|
||||
float get_t(float alpha, float t, glm::vec3 p0, glm::vec3 p1) {
|
||||
float a = pow((p1.x - p0.x), 2.0f) + pow((p1.y - p0.y), 2.0f) + pow((p1.z - p0.z), 2.0f);
|
||||
float b = pow(a, alpha * 0.5f);
|
||||
|
||||
|
||||
return (b + t);
|
||||
}
|
||||
|
||||
@ -34,14 +34,14 @@ glm::vec3 catmul(float alpha, glm::vec3 p0, glm::vec3 p1, glm::vec3 p2, glm::vec
|
||||
// Lerp t to be between t1 and t2
|
||||
t = t1 + t * (t2 - t1);
|
||||
|
||||
glm::vec3 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
|
||||
glm::vec3 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
|
||||
glm::vec3 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
|
||||
|
||||
glm::vec3 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
|
||||
glm::vec3 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
|
||||
|
||||
glm::vec3 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
|
||||
glm::vec3 A1 = (t1 - t) / (t1 - t0) * p0 + (t - t0) / (t1 - t0) * p1;
|
||||
glm::vec3 A2 = (t2 - t) / (t2 - t1) * p1 + (t - t1) / (t2 - t1) * p2;
|
||||
glm::vec3 A3 = (t3 - t) / (t3 - t2) * p2 + (t - t2) / (t3 - t2) * p3;
|
||||
|
||||
glm::vec3 B1 = (t2 - t) / (t2 - t0) * A1 + (t - t0) / (t2 - t0) * A2;
|
||||
glm::vec3 B2 = (t3 - t) / (t3 - t1) * A2 + (t - t1) / (t3 - t1) * A3;
|
||||
|
||||
glm::vec3 C = (t2 - t) / (t2 - t1) * B1 + (t - t1) / (t2 - t1) * B2;
|
||||
|
||||
return C;
|
||||
}
|
||||
@ -75,113 +75,113 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
}
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform, PathMove>(
|
||||
[&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<PathMove> pathmove) {
|
||||
if (!pathmove->is_active) return;
|
||||
pWorld->each<Transform, PathMove>([&](Entity *ent, ComponentHandle<Transform> transform,
|
||||
ComponentHandle<PathMove> pathmove) {
|
||||
if (!pathmove->is_active) return;
|
||||
|
||||
// Handle change in speed
|
||||
pathmove->speed += pathmove->speed_addition * deltaTime;
|
||||
pathmove->speed = glm::clamp(pathmove->speed, 0.0, 10.0);
|
||||
// Handle change in speed
|
||||
pathmove->speed += pathmove->speed_addition * deltaTime;
|
||||
pathmove->speed = glm::clamp(pathmove->speed, 0.0, 10.0);
|
||||
|
||||
// Shorthand for the path (we'll use this a lot)
|
||||
PathMove::Path path = pathmove->path;
|
||||
// Shorthand for the path (we'll use this a lot)
|
||||
PathMove::Path path = pathmove->path;
|
||||
|
||||
// Add the passed time
|
||||
float desired_distance = deltaTime * pathmove->speed; // TODO
|
||||
pathmove->time_passed += desired_distance / path.distances[pathmove->current_point_index];
|
||||
// Add the passed time
|
||||
float desired_distance = deltaTime * pathmove->speed; // TODO
|
||||
pathmove->time_passed +=
|
||||
desired_distance / path.distances[pathmove->current_point_index];
|
||||
|
||||
// Shorthand for number of points in the path
|
||||
int num_points = path.points.size();
|
||||
// Shorthand for number of points in the path
|
||||
int num_points = path.points.size();
|
||||
|
||||
if (pathmove->time_passed >= 1.0) {
|
||||
// If we passed the last target, set the current_point_index to that target
|
||||
pathmove->time_passed -= 1.0;
|
||||
pathmove->current_point_index += 1;
|
||||
if (pathmove->time_passed >= 1.0) {
|
||||
// If we passed the last target, set the current_point_index to that target
|
||||
pathmove->time_passed -= 1.0;
|
||||
pathmove->current_point_index += 1;
|
||||
|
||||
// If the point index is greater than the second to last one, reset
|
||||
// (The point index specifies the point we're coming from, not the one we're moving towards)
|
||||
if (pathmove->current_point_index >= num_points - 1) {
|
||||
pathmove->current_point_index = 0;
|
||||
}
|
||||
}
|
||||
// If the point index is greater than the second to last one, reset
|
||||
// (The point index specifies the point we're coming from, not the one we're moving
|
||||
// towards)
|
||||
if (pathmove->current_point_index >= num_points - 1) {
|
||||
pathmove->current_point_index = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// The four points which are needed for the spline
|
||||
// p1 and p2 are always the same (the current origin and the current target), but the rest depends on edge cases
|
||||
glm::vec3 p0;
|
||||
glm::vec3 p1 = path.points[pathmove->current_point_index];
|
||||
glm::vec3 p2 = path.points[pathmove->current_point_index + 1];
|
||||
glm::vec3 p3;
|
||||
// The four points which are needed for the spline
|
||||
// p1 and p2 are always the same (the current origin and the current target), but the
|
||||
// rest depends on edge cases
|
||||
glm::vec3 p0;
|
||||
glm::vec3 p1 = path.points[pathmove->current_point_index];
|
||||
glm::vec3 p2 = path.points[pathmove->current_point_index + 1];
|
||||
glm::vec3 p3;
|
||||
|
||||
if (pathmove->current_point_index == num_points - 2) {
|
||||
// We're moving towards the last point, so the point after that needs to be interpolated.
|
||||
// We interpolate linearly along the line from this point to the target point.
|
||||
glm::vec3 interp_direction = p2 - p1;
|
||||
p3 = p2 + interp_direction * 2.0f;
|
||||
} else {
|
||||
// We're fine - use the point after the target for p3
|
||||
p3 = path.points[pathmove->current_point_index + 2];
|
||||
}
|
||||
if (pathmove->current_point_index == num_points - 2) {
|
||||
// We're moving towards the last point, so the point after that needs to be
|
||||
// interpolated. We interpolate linearly along the line from this point to the
|
||||
// target point.
|
||||
glm::vec3 interp_direction = p2 - p1;
|
||||
p3 = p2 + interp_direction * 2.0f;
|
||||
} else {
|
||||
// We're fine - use the point after the target for p3
|
||||
p3 = path.points[pathmove->current_point_index + 2];
|
||||
}
|
||||
|
||||
if (pathmove->current_point_index == 0) {
|
||||
// We're at the first point, so the point before this needs to be interpolated.
|
||||
// We interpolate linearly along the line from this to the next point (backwards).
|
||||
glm::vec3 interp_direction = path.points[pathmove->current_point_index] - path.points[pathmove->current_point_index + 1];
|
||||
p0 = path.points[pathmove->current_point_index] + interp_direction;
|
||||
} else {
|
||||
// We're fine - use the point before the current point
|
||||
p0 = path.points[pathmove->current_point_index - 1];
|
||||
}
|
||||
if (pathmove->current_point_index == 0) {
|
||||
// We're at the first point, so the point before this needs to be interpolated.
|
||||
// We interpolate linearly along the line from this to the next point (backwards).
|
||||
glm::vec3 interp_direction = path.points[pathmove->current_point_index] -
|
||||
path.points[pathmove->current_point_index + 1];
|
||||
p0 = path.points[pathmove->current_point_index] + interp_direction;
|
||||
} else {
|
||||
// We're fine - use the point before the current point
|
||||
p0 = path.points[pathmove->current_point_index - 1];
|
||||
}
|
||||
|
||||
// Calculate the point on the spline
|
||||
glm::vec3 point = catmul(1.f,
|
||||
p0,
|
||||
p1,
|
||||
p2,
|
||||
p3,
|
||||
pathmove->time_passed);
|
||||
|
||||
// Apply
|
||||
transform->set_origin(point);
|
||||
// Calculate the point on the spline
|
||||
glm::vec3 point = catmul(1.f, p0, p1, p2, p3, pathmove->time_passed);
|
||||
|
||||
// Rotation
|
||||
// https://www.3dgep.com/understanding-quaternions/#SQUAD
|
||||
PathMove::Views views = pathmove->views;
|
||||
// Apply
|
||||
transform->set_origin(point);
|
||||
|
||||
// Similar procedure as with position to get the relevant values
|
||||
glm::quat q0;
|
||||
glm::quat q1 = views.views[pathmove->current_point_index];
|
||||
glm::quat q2 = views.views[pathmove->current_point_index + 1];
|
||||
glm::quat q3;
|
||||
// Rotation
|
||||
// https://www.3dgep.com/understanding-quaternions/#SQUAD
|
||||
PathMove::Views views = pathmove->views;
|
||||
|
||||
if (pathmove->current_point_index == num_points - 2) {
|
||||
// Interpolate what q3 would be if the change from q1 to q2 continues
|
||||
q3 = glm::fastMix(q1, q2, 2.0f);
|
||||
} else {
|
||||
// We're fine - use the point after the target for p3
|
||||
q3 = views.views[pathmove->current_point_index + 2];
|
||||
}
|
||||
// Similar procedure as with position to get the relevant values
|
||||
glm::quat q0;
|
||||
glm::quat q1 = views.views[pathmove->current_point_index];
|
||||
glm::quat q2 = views.views[pathmove->current_point_index + 1];
|
||||
glm::quat q3;
|
||||
|
||||
if (pathmove->current_point_index == 0) {
|
||||
// Interpolate what q0 would be if the same change happened from q0 to q1 as from q1 to q2
|
||||
q0 = glm::fastMix(q1, q2, -1.0f);
|
||||
} else {
|
||||
// We're fine - use the point before the current point
|
||||
q0 = views.views[pathmove->current_point_index - 1];
|
||||
}
|
||||
if (pathmove->current_point_index == num_points - 2) {
|
||||
// Interpolate what q3 would be if the change from q1 to q2 continues
|
||||
q3 = glm::fastMix(q1, q2, 2.0f);
|
||||
} else {
|
||||
// We're fine - use the point after the target for p3
|
||||
q3 = views.views[pathmove->current_point_index + 2];
|
||||
}
|
||||
|
||||
// Interpolate
|
||||
glm::quat result = glm::squad(q1, q2, glm::intermediate(q0, q1, q2), glm::intermediate(q1, q2, q3), pathmove->time_passed);
|
||||
if (pathmove->current_point_index == 0) {
|
||||
// Interpolate what q0 would be if the same change happened from q0 to q1 as from q1
|
||||
// to q2
|
||||
q0 = glm::fastMix(q1, q2, -1.0f);
|
||||
} else {
|
||||
// We're fine - use the point before the current point
|
||||
q0 = views.views[pathmove->current_point_index - 1];
|
||||
}
|
||||
|
||||
// Apply
|
||||
transform->set_rotation_from_quat(result);
|
||||
});
|
||||
// Interpolate
|
||||
glm::quat result = glm::squad(q1, q2, glm::intermediate(q0, q1, q2),
|
||||
glm::intermediate(q1, q2, q3), pathmove->time_passed);
|
||||
|
||||
// Apply
|
||||
transform->set_rotation_from_quat(result);
|
||||
});
|
||||
}
|
||||
|
||||
void unconfigure(World *pWorld) override {
|
||||
pWorld->unsubscribeAll(this);
|
||||
}
|
||||
void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
|
||||
|
||||
private:
|
||||
private:
|
||||
World *myWorld;
|
||||
};
|
||||
|
||||
|
||||
@ -7,22 +7,20 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
class PositionDebugOutputSystem : public EntitySystem {
|
||||
public:
|
||||
public:
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform>([&](Entity *ent, ComponentHandle<Transform> transform) {
|
||||
std::cout << ent->getEntityId() << ": "
|
||||
<< transform->get_origin().x << ", "
|
||||
<< transform->get_origin().y << ", "
|
||||
<< transform->get_origin().z
|
||||
std::cout << ent->getEntityId() << ": " << transform->get_origin().x << ", "
|
||||
<< transform->get_origin().y << ", " << transform->get_origin().z
|
||||
<< std::endl;
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
#endif //ECSGAME_POSITIONDEBUGSYSTEM_H
|
||||
#endif // ECSGAME_POSITIONDEBUGSYSTEM_H
|
||||
|
||||
@ -5,32 +5,28 @@
|
||||
#ifndef ECSGAME_RENDERSYSTEM_H
|
||||
#define ECSGAME_RENDERSYSTEM_H
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../Components/Mesh.h"
|
||||
#include "../Components/Camera.h"
|
||||
#include "../../Rendering/Material.h"
|
||||
#include "../../Rendering/Shader.h"
|
||||
#include "../Components/Camera.h"
|
||||
#include "../Components/DirectionalLight.h"
|
||||
#include "../Components/LODObjMesh.h"
|
||||
#include "../Components/Mesh.h"
|
||||
#include "../Components/ObjMesh.h"
|
||||
#include "../Components/Texture.h"
|
||||
#include "../Components/LODObjMesh.h"
|
||||
#include "../Components/DirectionalLight.h"
|
||||
#include "../../Rendering/Material.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
// For Debugging
|
||||
unsigned int quadVAO = 0;
|
||||
unsigned int quadVBO;
|
||||
void renderQuad()
|
||||
{
|
||||
if (quadVAO == 0)
|
||||
{
|
||||
void renderQuad() {
|
||||
if (quadVAO == 0) {
|
||||
float quadVertices[] = {
|
||||
// positions // texture Coords
|
||||
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
|
||||
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
|
||||
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
|
||||
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
|
||||
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
|
||||
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
|
||||
};
|
||||
// setup plane VAO
|
||||
glGenVertexArrays(1, &quadVAO);
|
||||
@ -39,9 +35,10 @@ void renderQuad()
|
||||
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
|
||||
glEnableVertexAttribArray(0);
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
|
||||
glEnableVertexAttribArray(1);
|
||||
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
|
||||
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
|
||||
(void *)(3 * sizeof(float)));
|
||||
}
|
||||
glBindVertexArray(quadVAO);
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
@ -49,16 +46,13 @@ void renderQuad()
|
||||
}
|
||||
|
||||
class RenderSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
public:
|
||||
public:
|
||||
struct RenderObject {
|
||||
RenderObject(const glm::mat4 &matrix, const glm::vec3 &origin, unsigned int textureId, unsigned int normalId, const Mesh &mesh, float distance, const Material &material)
|
||||
: matrix(matrix),
|
||||
origin(origin),
|
||||
texture_id(textureId),
|
||||
normal_id(normalId),
|
||||
mesh(mesh),
|
||||
distance(distance),
|
||||
material(material) {}
|
||||
RenderObject(const glm::mat4 &matrix, const glm::vec3 &origin, unsigned int textureId,
|
||||
unsigned int normalId, const Mesh &mesh, float distance,
|
||||
const Material &material)
|
||||
: matrix(matrix), origin(origin), texture_id(textureId), normal_id(normalId),
|
||||
mesh(mesh), distance(distance), material(material) {}
|
||||
|
||||
void render(Shader shader) const {
|
||||
glm::mat4 model_matrix = matrix;
|
||||
@ -95,26 +89,33 @@ public:
|
||||
|
||||
// Fill the passed vector with render objects of the given world
|
||||
std::vector<std::vector<RenderObject>> getRenderObjects(World *world, glm::vec3 cameraPos) {
|
||||
std::vector<std::vector<RenderObject>> renderObjects(2); // First normal, then transparent
|
||||
std::vector<std::vector<RenderObject>> renderObjects(2); // First normal, then transparent
|
||||
|
||||
/*pWorld->each<Mesh, Transform>([&](Entity *ent, ComponentHandle<Mesh> mesh, ComponentHandle<Transform> transform) {
|
||||
/*pWorld->each<Mesh, Transform>([&](Entity *ent, ComponentHandle<Mesh> mesh,
|
||||
ComponentHandle<Transform> transform) {
|
||||
renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(), 0));
|
||||
});*/
|
||||
|
||||
/*// TODO: Is it possible to do get ObjMeshes in the Mesh loop above implicitly via polymorphism?
|
||||
* // TODO: Commented out because of double rendering - we only want to get objects that explicitly DON'T have a texture here!
|
||||
pWorld->each<ObjMesh, Transform>([&](Entity *ent, ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform) {
|
||||
// Add the object to the renderObjects to draw if the distance is within the min and max distance of the mesh
|
||||
float distance = glm::distance(cameraPos, transform->getPosition());
|
||||
/*// TODO: Is it possible to do get ObjMeshes in the Mesh loop above implicitly via
|
||||
polymorphism?
|
||||
* // TODO: Commented out because of double rendering - we only want to get objects that
|
||||
explicitly DON'T have a texture here! pWorld->each<ObjMesh, Transform>([&](Entity *ent,
|
||||
ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform) {
|
||||
// Add the object to the renderObjects to draw if the distance is within the min and max
|
||||
distance of the mesh float distance = glm::distance(cameraPos, transform->getPosition());
|
||||
|
||||
if (distance > mesh->minDistance && distance < mesh->maxDistance) {
|
||||
renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(), distance));
|
||||
renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(),
|
||||
distance));
|
||||
}
|
||||
});*/
|
||||
|
||||
// ObjMesh with textures
|
||||
world->each<ObjMesh, Transform, Texture>([&](Entity *ent, ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform, ComponentHandle<Texture> texture) {
|
||||
// Add the object to the renderObjects to draw if the distance is within the min and max distance of the mesh
|
||||
world->each<ObjMesh, Transform, Texture>([&](Entity *ent, ComponentHandle<ObjMesh> mesh,
|
||||
ComponentHandle<Transform> transform,
|
||||
ComponentHandle<Texture> texture) {
|
||||
// Add the object to the renderObjects to draw if the distance is within the min and max
|
||||
// distance of the mesh
|
||||
float distance = glm::distance(cameraPos, transform->get_origin());
|
||||
|
||||
if (distance > mesh->minDistance && distance < mesh->maxDistance) {
|
||||
@ -122,21 +123,29 @@ public:
|
||||
ComponentHandle<Texture> textureComponent = ent->get<Texture>();
|
||||
ComponentHandle<Material> materialComponent = ent->get<Material>();
|
||||
|
||||
Material material = materialComponent.isValid() ? materialComponent.get() : Material();
|
||||
Material material =
|
||||
materialComponent.isValid() ? materialComponent.get() : Material();
|
||||
unsigned int textureID = textureComponent.isValid() ? textureComponent->id : 0;
|
||||
unsigned int normalID = textureComponent.isValid() ? textureComponent->normal_id : 0;
|
||||
unsigned int normalID =
|
||||
textureComponent.isValid() ? textureComponent->normal_id : 0;
|
||||
|
||||
// Put it into the list of transparent render objects if the texture wants to be rendered transparently
|
||||
// Put it into the list of transparent render objects if the texture wants to be
|
||||
// rendered transparently
|
||||
if (textureComponent.isValid() && textureComponent->render_transparent) {
|
||||
renderObjects[1].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh.get(), distance, material));
|
||||
renderObjects[1].emplace_back(
|
||||
RenderObject(transform->matrix, transform->get_origin(), textureID,
|
||||
normalID, mesh.get(), distance, material));
|
||||
} else {
|
||||
renderObjects[0].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh.get(), distance, material));
|
||||
renderObjects[0].emplace_back(
|
||||
RenderObject(transform->matrix, transform->get_origin(), textureID,
|
||||
normalID, mesh.get(), distance, material));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// LODObjMesh with Texture
|
||||
world->each<LODObjMesh, Transform>([&](Entity *ent, ComponentHandle<LODObjMesh> lodMesh, ComponentHandle<Transform> transform) {
|
||||
world->each<LODObjMesh, Transform>([&](Entity *ent, ComponentHandle<LODObjMesh> lodMesh,
|
||||
ComponentHandle<Transform> transform) {
|
||||
float distance = glm::distance(cameraPos, transform->get_origin());
|
||||
|
||||
for (const auto &mesh : lodMesh->meshes) {
|
||||
@ -145,31 +154,37 @@ public:
|
||||
ComponentHandle<Texture> textureComponent = ent->get<Texture>();
|
||||
ComponentHandle<Material> materialComponent = ent->get<Material>();
|
||||
|
||||
Material material = materialComponent.isValid() ? materialComponent.get() : Material();
|
||||
Material material =
|
||||
materialComponent.isValid() ? materialComponent.get() : Material();
|
||||
unsigned int textureID = textureComponent.isValid() ? textureComponent->id : 0;
|
||||
unsigned int normalID = textureComponent.isValid() ? textureComponent->normal_id : 0;
|
||||
unsigned int normalID =
|
||||
textureComponent.isValid() ? textureComponent->normal_id : 0;
|
||||
|
||||
// Put it into the list of transparent render objects if the texture wants to be rendered transparently
|
||||
// Put it into the list of transparent render objects if the texture wants to be
|
||||
// rendered transparently
|
||||
if (textureComponent.isValid() && textureComponent->render_transparent) {
|
||||
renderObjects[1].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh, distance, material));
|
||||
renderObjects[1].emplace_back(
|
||||
RenderObject(transform->matrix, transform->get_origin(), textureID,
|
||||
normalID, mesh, distance, material));
|
||||
} else {
|
||||
renderObjects[0].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh, distance, material));
|
||||
renderObjects[0].emplace_back(
|
||||
RenderObject(transform->matrix, transform->get_origin(), textureID,
|
||||
normalID, mesh, distance, material));
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Sort transparent objects
|
||||
std::sort(renderObjects[1].begin(), renderObjects[1].end(), [](const RenderObject &first, const RenderObject &second) -> bool {
|
||||
return first.distance > second.distance;
|
||||
});
|
||||
std::sort(renderObjects[1].begin(), renderObjects[1].end(),
|
||||
[](const RenderObject &first, const RenderObject &second) -> bool {
|
||||
return first.distance > second.distance;
|
||||
});
|
||||
|
||||
return renderObjects;
|
||||
}
|
||||
|
||||
RenderSystem() {
|
||||
setup();
|
||||
}
|
||||
RenderSystem() { setup(); }
|
||||
|
||||
void configure(World *pWorld) override {
|
||||
myWorld = pWorld;
|
||||
@ -196,12 +211,13 @@ public:
|
||||
// Create depth texture
|
||||
glGenTextures(1, &depthMap);
|
||||
glBindTexture(GL_TEXTURE_2D, depthMap);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_width, shadow_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_width, shadow_height, 0,
|
||||
GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
|
||||
|
||||
// Attach depth texture as FBO's depth buffer
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
|
||||
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap, 0);
|
||||
@ -210,11 +226,12 @@ public:
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
||||
}
|
||||
|
||||
|
||||
void render(World *pWorld, Shader normalShader, Shader shadowShader, Shader debugShader) {
|
||||
pWorld->each<Camera, Transform>([&](Entity *ent, ComponentHandle<Camera> camera, ComponentHandle<Transform> cameraTransform) {
|
||||
pWorld->each<Camera, Transform>([&](Entity *ent, ComponentHandle<Camera> camera,
|
||||
ComponentHandle<Transform> cameraTransform) {
|
||||
// Get render objects
|
||||
std::vector<std::vector<RenderObject>> allRenderObjects = getRenderObjects(pWorld, cameraTransform->get_origin());
|
||||
std::vector<std::vector<RenderObject>> allRenderObjects =
|
||||
getRenderObjects(pWorld, cameraTransform->get_origin());
|
||||
std::vector<RenderObject> renderObjects = allRenderObjects[0];
|
||||
std::vector<RenderObject> transparentRenderObjects = allRenderObjects[1];
|
||||
|
||||
@ -222,19 +239,22 @@ public:
|
||||
// Get light direction
|
||||
// TODO: Currently only the last light is used!
|
||||
glm::vec3 lightDirection;
|
||||
pWorld->each<DirectionalLight>([&](Entity *ent, ComponentHandle<DirectionalLight> light) {
|
||||
lightDirection = light->direction;
|
||||
});
|
||||
pWorld->each<DirectionalLight>(
|
||||
[&](Entity *ent, ComponentHandle<DirectionalLight> light) {
|
||||
lightDirection = light->direction;
|
||||
});
|
||||
float near_plane = 1.0f, far_plane = 100.0f;
|
||||
glm::mat4 lightProjection = glm::ortho(-20.0f, 20.0f, -20.0f, 20.0f, near_plane, far_plane);
|
||||
glm::mat4 lightView = glm::lookAt(lightDirection * 40.0f, -lightDirection, glm::vec3(0.0, 1.0, 0.0));
|
||||
glm::mat4 lightProjection =
|
||||
glm::ortho(-20.0f, 20.0f, -20.0f, 20.0f, near_plane, far_plane);
|
||||
glm::mat4 lightView =
|
||||
glm::lookAt(lightDirection * 40.0f, -lightDirection, glm::vec3(0.0, 1.0, 0.0));
|
||||
glm::mat4 lightSpaceMatrix = lightProjection * lightView;
|
||||
|
||||
// Render shadows
|
||||
shadowShader.use();
|
||||
|
||||
shadowShader.setMat4("lightSpaceMatrix", lightSpaceMatrix);
|
||||
|
||||
|
||||
glViewport(0, 0, shadow_width, shadow_height);
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
@ -249,7 +269,7 @@ public:
|
||||
|
||||
// Render Normal
|
||||
glViewport(0, 0, screen_width, screen_height);
|
||||
|
||||
|
||||
glClearColor(0.6f, 0.9f, 0.9f, 1.0f);
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
@ -301,4 +321,4 @@ public:
|
||||
World *myWorld;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_RENDERSYSTEM_H
|
||||
#endif // ECSGAME_RENDERSYSTEM_H
|
||||
|
||||
@ -5,24 +5,27 @@
|
||||
#ifndef ECSGAME_SINEANIMATIONSYSTEM_H
|
||||
#define ECSGAME_SINEANIMATIONSYSTEM_H
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../Components/SineAnimation.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
class SineAnimationSystem : public EntitySystem {
|
||||
public:
|
||||
public:
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
passedTime += deltaTime;
|
||||
|
||||
pWorld->each<Transform, SineAnimation>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<SineAnimation> anim) {
|
||||
transform->translate(anim->maxDistance * glm::sin(passedTime * anim->speedScale) * deltaTime);
|
||||
pWorld->each<Transform, SineAnimation>([&](Entity *ent,
|
||||
ComponentHandle<Transform> transform,
|
||||
ComponentHandle<SineAnimation> anim) {
|
||||
transform->translate(anim->maxDistance * glm::sin(passedTime * anim->speedScale) *
|
||||
deltaTime);
|
||||
});
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
float passedTime = 0.0;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_SINEANIMATIONSYSTEM_H
|
||||
#endif // ECSGAME_SINEANIMATIONSYSTEM_H
|
||||
|
||||
@ -17,4 +17,4 @@ struct Material {
|
||||
float normal_scale = 3.0;
|
||||
};
|
||||
|
||||
#endif //ECSGAME_MATERIAL_H
|
||||
#endif // ECSGAME_MATERIAL_H
|
||||
|
||||
@ -5,11 +5,11 @@
|
||||
#include "Shader.h"
|
||||
#include <glad/glad.h>
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <glm/gtc/type_ptr.hpp>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
Shader::Shader(const char *vertexPath, const char *fragmentPath) {
|
||||
// 1. retrieve the vertex/fragment source code from filePath
|
||||
@ -36,8 +36,7 @@ Shader::Shader(const char *vertexPath, const char *fragmentPath) {
|
||||
// convert stream into string
|
||||
vertexCode = vShaderStream.str();
|
||||
fragmentCode = fShaderStream.str();
|
||||
}
|
||||
catch (std::ifstream::failure &e) {
|
||||
} catch (std::ifstream::failure &e) {
|
||||
std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
|
||||
}
|
||||
|
||||
@ -69,7 +68,6 @@ Shader::Shader(const char *vertexPath, const char *fragmentPath) {
|
||||
// delete the shaders as they're linked into our program now and no longer necessary
|
||||
glDeleteShader(vertex);
|
||||
glDeleteShader(fragment);
|
||||
|
||||
}
|
||||
|
||||
void Shader::use() {
|
||||
@ -77,7 +75,7 @@ void Shader::use() {
|
||||
}
|
||||
|
||||
void Shader::setBool(const std::string &name, bool value) const {
|
||||
glUniform1i(glGetUniformLocation(ID, name.c_str()), (int) value);
|
||||
glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
|
||||
}
|
||||
|
||||
void Shader::setInt(const std::string &name, int value) const {
|
||||
@ -92,7 +90,6 @@ void Shader::setMat4(const std::string &name, glm::mat4 mat) const {
|
||||
glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
|
||||
}
|
||||
|
||||
|
||||
void Shader::setVec3(const std::string &name, glm::vec3 vec) const {
|
||||
glUniform3f(glGetUniformLocation(ID, name.c_str()), vec.x, vec.y, vec.z);
|
||||
}
|
||||
@ -104,15 +101,17 @@ void Shader::checkCompileErrors(unsigned int shader, const std::string &type) {
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
|
||||
if (!success) {
|
||||
glGetShaderInfoLog(shader, 1024, nullptr, infoLog);
|
||||
std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog
|
||||
<< "\n -- --------------------------------------------------- -- " << std::endl;
|
||||
std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n"
|
||||
<< infoLog << "\n -- --------------------------------------------------- -- "
|
||||
<< std::endl;
|
||||
}
|
||||
} else {
|
||||
glGetProgramiv(shader, GL_LINK_STATUS, &success);
|
||||
if (!success) {
|
||||
glGetProgramInfoLog(shader, 1024, nullptr, infoLog);
|
||||
std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog
|
||||
<< "\n -- --------------------------------------------------- -- " << std::endl;
|
||||
std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n"
|
||||
<< infoLog << "\n -- --------------------------------------------------- -- "
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -5,16 +5,17 @@
|
||||
#ifndef ECSGAME_SHADER_H
|
||||
#define ECSGAME_SHADER_H
|
||||
|
||||
#include <string>
|
||||
#include <glm/glm.hpp>
|
||||
#include <string>
|
||||
|
||||
class Shader {
|
||||
public:
|
||||
public:
|
||||
/// Program ID
|
||||
unsigned int ID;
|
||||
|
||||
/// Read and build the shader from the files at vertexPath and fragmentPath.
|
||||
/// Note that an OpenGL context has to be initialized before calling this! Otherwise a SIGSEGV will be thrown.
|
||||
/// Note that an OpenGL context has to be initialized before calling this! Otherwise a SIGSEGV
|
||||
/// will be thrown.
|
||||
Shader(const char *vertexPath, const char *fragmentPath);
|
||||
|
||||
/// Activate the shader - usually called before rendering.
|
||||
@ -35,9 +36,8 @@ public:
|
||||
/// Set a uniform vec3 in the shader
|
||||
void setVec3(const std::string &name, glm::vec3 vec) const;
|
||||
|
||||
private:
|
||||
private:
|
||||
static void checkCompileErrors(unsigned int shader, const std::string &type);
|
||||
};
|
||||
|
||||
|
||||
#endif //ECSGAME_SHADER_H
|
||||
#endif // ECSGAME_SHADER_H
|
||||
|
||||
2090
Util/OBJ_Loader.h
2090
Util/OBJ_Loader.h
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user