Autoformat everything + minor include fixes
This commit is contained in:
parent
8e4eacf48f
commit
9c1417a8f9
@ -9,9 +9,10 @@
|
||||
#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;
|
||||
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#ifndef ECSGAME_DIRECTIONALLIGHT_H
|
||||
#define ECSGAME_DIRECTIONALLIGHT_H
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
struct DirectionalLight {
|
||||
explicit DirectionalLight(const glm::vec3 &direction) : direction(direction) {}
|
||||
|
||||
|
||||
@ -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)) {}
|
||||
|
||||
@ -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);
|
||||
@ -37,19 +40,23 @@ struct Mesh {
|
||||
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);
|
||||
|
||||
@ -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) {}
|
||||
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#ifndef ECSGAME_MOVEMENT_H
|
||||
#define ECSGAME_MOVEMENT_H
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
struct Movement {
|
||||
Movement(glm::vec3 speed) : speed(speed) {}
|
||||
|
||||
|
||||
@ -5,23 +5,25 @@
|
||||
#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;
|
||||
|
||||
@ -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;
|
||||
@ -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,7 +192,8 @@ 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";
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@ -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,8 +5,11 @@
|
||||
#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;
|
||||
|
||||
@ -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,7 +56,8 @@ 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);
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
}
|
||||
explicit GravitySystem(float amount) { gravityAmount = amount; }
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform>([&](Entity *ent, ComponentHandle<Transform> position) {
|
||||
|
||||
@ -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/PathMove.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/MouseLook.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/PathMove.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -23,7 +23,9 @@ 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) {
|
||||
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) {
|
||||
@ -38,7 +40,10 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
|
||||
}
|
||||
});
|
||||
} 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) {
|
||||
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);
|
||||
@ -48,9 +53,7 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
|
||||
}
|
||||
}
|
||||
|
||||
void unconfigure(World *pWorld) override {
|
||||
pWorld->unsubscribeAll(this);
|
||||
}
|
||||
void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
|
||||
|
||||
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/Transform.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
#include "../Components/Movement.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
#include "../Events/InputEvent.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -61,17 +61,17 @@ 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) {
|
||||
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:
|
||||
World *myWorld;
|
||||
|
||||
@ -5,9 +5,10 @@
|
||||
#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;
|
||||
@ -22,12 +23,12 @@ 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) {
|
||||
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;
|
||||
|
||||
@ -40,16 +41,18 @@ public:
|
||||
}
|
||||
|
||||
void tick(World *pWorld, float deltaTime) override {
|
||||
pWorld->each<Transform, MouseLook, Camera>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse, ComponentHandle<Camera> camera) {
|
||||
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);
|
||||
});
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -75,8 +75,8 @@ 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) {
|
||||
pWorld->each<Transform, PathMove>([&](Entity *ent, ComponentHandle<Transform> transform,
|
||||
ComponentHandle<PathMove> pathmove) {
|
||||
if (!pathmove->is_active) return;
|
||||
|
||||
// Handle change in speed
|
||||
@ -88,7 +88,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
|
||||
// Add the passed time
|
||||
float desired_distance = deltaTime * pathmove->speed; // TODO
|
||||
pathmove->time_passed += desired_distance / path.distances[pathmove->current_point_index];
|
||||
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();
|
||||
@ -99,22 +100,25 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
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)
|
||||
// (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
|
||||
// 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.
|
||||
// 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 {
|
||||
@ -125,7 +129,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
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];
|
||||
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
|
||||
@ -133,12 +138,7 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
}
|
||||
|
||||
// Calculate the point on the spline
|
||||
glm::vec3 point = catmul(1.f,
|
||||
p0,
|
||||
p1,
|
||||
p2,
|
||||
p3,
|
||||
pathmove->time_passed);
|
||||
glm::vec3 point = catmul(1.f, p0, p1, p2, p3, pathmove->time_passed);
|
||||
|
||||
// Apply
|
||||
transform->set_origin(point);
|
||||
@ -162,7 +162,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
}
|
||||
|
||||
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
|
||||
// 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
|
||||
@ -170,16 +171,15 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
}
|
||||
|
||||
// Interpolate
|
||||
glm::quat result = glm::squad(q1, q2, glm::intermediate(q0, q1, q2), glm::intermediate(q1, q2, q3), pathmove->time_passed);
|
||||
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:
|
||||
World *myWorld;
|
||||
|
||||
@ -7,8 +7,8 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "../ECS.h"
|
||||
#include "../Components/Transform.h"
|
||||
#include "../ECS.h"
|
||||
|
||||
using namespace ECS;
|
||||
|
||||
@ -16,10 +16,8 @@ class PositionDebugOutputSystem : public EntitySystem {
|
||||
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;
|
||||
});
|
||||
}
|
||||
|
||||
@ -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);
|
||||
@ -41,7 +37,8 @@ void renderQuad()
|
||||
glEnableVertexAttribArray(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);
|
||||
@ -51,14 +48,11 @@ void renderQuad()
|
||||
class RenderSystem : public EntitySystem, public EventSubscriber<InputEvent> {
|
||||
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;
|
||||
@ -97,24 +91,31 @@ public:
|
||||
std::vector<std::vector<RenderObject>> getRenderObjects(World *world, glm::vec3 cameraPos) {
|
||||
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 {
|
||||
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,7 +211,8 @@ 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);
|
||||
@ -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,12 +239,15 @@ public:
|
||||
// Get light direction
|
||||
// TODO: Currently only the last light is used!
|
||||
glm::vec3 lightDirection;
|
||||
pWorld->each<DirectionalLight>([&](Entity *ent, ComponentHandle<DirectionalLight> light) {
|
||||
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
|
||||
|
||||
@ -5,9 +5,9 @@
|
||||
#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;
|
||||
|
||||
@ -16,8 +16,11 @@ 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);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@ -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() {
|
||||
@ -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,8 +5,8 @@
|
||||
#ifndef ECSGAME_SHADER_H
|
||||
#define ECSGAME_SHADER_H
|
||||
|
||||
#include <string>
|
||||
#include <glm/glm.hpp>
|
||||
#include <string>
|
||||
|
||||
class Shader {
|
||||
public:
|
||||
@ -14,7 +14,8 @@ public:
|
||||
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.
|
||||
@ -39,5 +40,4 @@ private:
|
||||
static void checkCompileErrors(unsigned int shader, const std::string &type);
|
||||
};
|
||||
|
||||
|
||||
#endif // ECSGAME_SHADER_H
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user