feat: add Lights(mesh layer); rewrite model_t(vertices) to support quaternion

Author: MrAMS

core/entity_layer.hpp

@@ -1,15 +1,16 @@
 #include "core/mesh_layer.hpp"
+#include "core/vertices_layer.hpp"
+#include "utils/debug.hpp"
 
 namespace Ez3DGL{
 
-class MotionObj{
+class DynamicObj{
 public:
-    float mass=1;
-    void apply_force(glm::vec3 force){
+    DynamicObj(glm::vec3 pos, float mass=1): position(pos), velocity(0), acceleration(0), mass(mass){}
+    glm::vec3 update_dynamic(const glm::vec3 force, float delta_time_seconds){
         acceleration = force / mass;
-    }
-    glm::vec3 update(float delta_time_seconds){
         position += velocity * delta_time_seconds + acceleration * delta_time_seconds * delta_time_seconds * 0.5f;
+        velocity += acceleration * delta_time_seconds;
         return position;
     }
     glm::vec3 pos() const{
@@ -19,20 +20,25 @@ class MotionObj{
         return velocity;
     }
 private:
+    float mass=1;
     glm::vec3 position;
     glm::vec3 velocity;
     glm::vec3 acceleration;
 };
 
-class RenderObj{
-public:
-    void render(){
-        // render
-    }
-private:
-    Model* model;
-    Shader* shader;
+// class RenderObj{
+// public:
+//     RenderObj(Shader* shader, Model* model, model_t* mat_model):
+//         shader(shader), model(model), mat_model(mat_model){}
+//     void render(const Lights* lights, const camera_t* camera){
+//         lights->apply_shader(shader);
+//         model->draw(shader, camera, mat_model);
+//     }
+// private:
+//     model_t* mat_model;
+//     Model* model;
+//     Shader* shader;
 
-};
+// };
 
 }

core/mesh_layer.hpp

@@ -33,10 +33,13 @@ struct Texture {
 
 class Shader{
 public:
+    float tmp_material_shininess=32;
+
     void setup_shader(){
         assert_with_info(shader==nullptr, "shader is already setup");
         shader = new shader_t("../shader/fragpos_normal_texcoord_lightpos.vs", "../shader/multiple_lights.fs", "view", "projection", "model");
     }
+    // TODO update_lights
     void bind(const std::vector<Texture>& textures, const camera_t* camera, const model_t* model){
         assert_with_info(shader!=nullptr, "forget to setup shader");
         shader->use();
@@ -60,6 +63,7 @@ class Shader{
             }
         // shader->set_uniform("diffuse_num", diffuse_cnt);
         // shader->set_uniform("specular_num", spaiTexecular_cnt);
+        shader->set_uniform("material.shininess", tmp_material_shininess);
         shader->set_uniform("viewPos", camera->position);
         shader->update_camera(camera);
         shader->update_model(model);
@@ -68,8 +72,11 @@ class Shader{
         if(shader!=nullptr)
             delete shader;
     }
-    shader_t* shader=nullptr;
+    friend class LightDir;
+    friend class LightPoint;
+    friend class LightSpot;
 private:
+    shader_t* shader=nullptr;
 };
 
 class Mesh{
@@ -87,9 +94,9 @@ class Mesh{
             delete vert;
     }
 
-    void draw(Shader& shader, const camera_t* camera, const model_t* model) const{
+    void draw(Shader* shader, const camera_t* camera, const model_t* model) const{
         assert_with_info(vert!=nullptr, "forget to setup vertices");
-        shader.bind(textures, camera, model);
+        shader->bind(textures, camera, model);
         vert->draw_element(GL_TRIANGLES);
     }
 private:
@@ -98,13 +105,20 @@ class Mesh{
 
 class Model{
 public:
+    Model()=default;
     Model(std::string path){
+        setup_model(path);
+    }
+    void setup_model(std::string path){
+        assert_with_info(model_path.empty(), "model is already setup");
+        model_path = path;
         load_model(path);
         for(auto& mesh: meshes){
             mesh.setup_vertices();
         }
     }
-    void draw(Shader& shader, const camera_t* camera, const model_t* model){
+    void draw(Shader* shader, const camera_t* camera, const model_t* model){
+        assert_with_info(!model_path.empty(), "forget to setup model");
         for(const auto& mesh: meshes){
             mesh.draw(shader, camera, model);
         }
@@ -116,6 +130,7 @@ class Model{
 private:
     std::vector<Mesh> meshes;
     std::vector<Texture> loaded_textures;
+    std::string model_path;
     std::string directory;
     void load_model(std::string path){
         Assimp::Importer import;
@@ -205,19 +220,125 @@ class Model{
     }
 };
 
+class LightBase{
+public:
+    glm::vec3 ambient=glm::vec3(0.2f, 0.2f, 0.2f);
+    glm::vec3 diffuse=glm::vec3(0.5f, 0.5f, 0.5f);
+    glm::vec3 specular=glm::vec3(1.0f, 1.0f, 1.0f);
+
+    LightBase(glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular):ambient(ambient), diffuse(diffuse), specular(specular) {
+
+    }
+
+    virtual void apply_shader(Shader* shader) const = 0;
+};
+
+class LightDir : public LightBase {
+public:
+    glm::vec3 direction;
+    LightDir(glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular, glm::vec3 direction):
+        LightBase(ambient, diffuse, specular), direction(direction) {
+
+    }
+    void apply_shader(Shader* shader) const override{
+        shader->shader->use();
+
+        shader->shader->set_uniform("light_dir.ambient", ambient);
+        shader->shader->set_uniform("light_dir.diffuse", diffuse);
+        shader->shader->set_uniform("light_dir.specular", specular);
+
+        shader->shader->set_uniform("light_dir.direction", direction);
+    }
+};
+
+class LightPoint : public LightBase{
+public:
+    glm::vec3 position;
+
+    float constant = 1.f;
+    float linear = 0.0014f;
+    float quadratic = 0.000007f;
+
+    LightPoint(glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular,
+        glm::vec3 position,
+        float constant, float linear, float quadratic):
+            LightBase(ambient, diffuse, specular), position(position), constant(constant), linear(linear), quadratic(quadratic) {
+    }
+    void apply_shader(Shader* shader) const override{
+        shader->shader->use();
+
+        shader->shader->set_uniform("light_point.ambient", ambient);
+        shader->shader->set_uniform("light_point.diffuse", diffuse);
+        shader->shader->set_uniform("light_point.specular", specular);
+
+        shader->shader->set_uniform("light_point.position", position);
+
+        shader->shader->set_uniform("light_point.constant", constant);
+        shader->shader->set_uniform("light_point.linear", linear);
+        shader->shader->set_uniform("light_point.quadratic", quadratic);
+    }
+};
+
+class LightSpot : public LightPoint{
+public:
+    glm::vec3 direction;
+    float inner_degree;
+    float outer_degree;
+
+    LightSpot(glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular,
+        glm::vec3 position, glm::vec3 direction,
+        float constant, float linear, float quadratic,
+        float inner_degree, float outer_degree):
+            LightPoint(ambient, diffuse, specular, position, constant, linear, quadratic),
+            direction(direction),
+            inner_degree(inner_degree), outer_degree(outer_degree) {
+                assert_with_info(inner_degree<outer_degree, "inner degree must be less than outer degree");
+            }
+    void apply_shader(Shader* shader) const override{
+        shader->shader->use();
+
+        auto cutoff = glm::cos(glm::radians(inner_degree));
+        auto cutoff_outer = glm::cos(glm::radians(outer_degree));
+        shader->shader->set_uniform("light_spot.ambient", ambient);
+        shader->shader->set_uniform("light_spot.diffuse", diffuse);
+        shader->shader->set_uniform("light_spot.specular", specular);
+
+        shader->shader->set_uniform("light_spot.position", position);
+        shader->shader->set_uniform("light_spot.direction", direction);
+
+        shader->shader->set_uniform("light_spot.constant", constant);
+        shader->shader->set_uniform("light_spot.linear", linear);
+        shader->shader->set_uniform("light_spot.quadratic", quadratic);
+
+        shader->shader->set_uniform("light_spot.cutoff", cutoff);
+        shader->shader->set_uniform("light_spot.cutoff_outer", cutoff_outer);
+    }
+private:
+
+};
+
+
 /**
  * @brief 光源对象,支持定向光源,点光源,聚光
  * 
  */
-class Light{
+class Lights{
 public:
-
-    light_dir_t dir_light;
+    std::vector<LightDir> dir_light;
     // note that the size has limited
-    std::vector<light_point_t> point_lights;
-    light_spot_t spot_light;
-
-
+    std::vector<LightPoint> point_lights;
+    std::vector<LightSpot> spot_light;
+    void apply_shader(Shader* shader) const{
+        for(const auto& dir : dir_light){
+            dir.apply_shader(shader);
+        }
+        for(const auto& point : point_lights){
+            point.apply_shader(shader);
+        }
+        for(const auto& spot : spot_light){
+            spot.apply_shader(shader);
+        }
+    }
 };
 
 }

core/vertices_layer.cpp

@@ -12,6 +12,7 @@
 #include "stb_image.h"
 #include <cmath>
 #include "utils/debug.hpp"
+#include <glm/gtx/quaternion.hpp>
 
 using namespace Ez3DGL;
 
@@ -403,7 +404,13 @@ void camera_t::input_fov(double scroll){
 }
 
 glm::mat4 model_t::get_model() const{
-    return get_trans_mat(pos, scale, rotate_degree, rotate_axis);
+    auto parent_trans = glm::mat4(1.);
+    if(parent)
+        parent_trans = parent->get_model();
+    const auto transl_trans = glm::translate(glm::mat4(1.), pos);
+    const auto rotate_trans = glm::toMat4(quaternion);
+    const auto scala_trans = glm::scale(glm::mat4(1.), scale);
+    return parent_trans * transl_trans * rotate_trans * scala_trans;
 }
 
 glm::mat4 model_t::move_to(glm::vec3 x){
@@ -431,27 +438,32 @@ glm::mat4 model_t::scale_to(glm::vec3 x){
     return get_model();
 }
 
-glm::mat4 model_t::rotate_to(float x, glm::vec3 axis){
-    rotate_degree = x;
-    rotate_axis = axis;
+glm::mat4 model_t::rotate_to(float degree, glm::vec3 axis){
+    quaternion =glm::angleAxis(glm::radians(degree), axis);
+    return get_model();
+}
+
+glm::mat4 model_t::rotate_to(glm::vec3 pitch_yaw_roll_degree){
+    quaternion = glm::quat(pitch_yaw_roll_degree);
     return get_model();
 }
 
+glm::mat4 model_t::rotate(glm::vec3 pitch_yaw_roll_degree){
+    const auto q = glm::quat(glm::radians(pitch_yaw_roll_degree));
+    quaternion *= q;
+    return get_model();
+}
+
+glm::vec3 model_t::look_at_dir() const{
+    return glm::normalize(quaternion * dir);
+}
+
 void model_t::set_parent_model(struct model_t *p) {
     parent = p;
 }
 
-glm::mat4 model_t::get_trans_mat(glm::vec3 pos, glm::vec3 scale, float rotate_degree, glm::vec3 rotate_axis) const{
-    auto trans = glm::mat4(1.);
-    if(parent)
-        trans = parent->get_model();
-    trans = glm::translate(trans, pos);
-    trans = glm::rotate(trans, glm::radians(rotate_degree), rotate_axis);
-    trans = glm::scale(trans, scale);
-    return trans;
-}
 
-model_t::model_t(glm::vec3 pos, glm::vec3 scale, class model_t *p):pos(pos), scale(scale), parent(p)  {
+model_t::model_t(glm::vec3 pos, glm::vec3 scale, glm::vec3 init_dir, class model_t *p):pos(pos), scale(scale), dir(init_dir), parent(p)  {
 
 }
 

core/vertices_layer.hpp

@@ -18,6 +18,7 @@
 #include <initializer_list>
 #include <memory>
 #include <vector>
+#include <glm/gtc/quaternion.hpp>
 
 namespace Ez3DGL {
 
@@ -158,11 +159,11 @@ class model_t{
 public:
     glm::vec3 pos;
     glm::vec3 scale=glm::vec3(1.);
-    glm::vec3 rotate_axis=glm::vec3(0, 0, 1);
-    float rotate_degree=0;
+    glm::vec3 dir;
+    glm::quat quaternion;
 
     model_t()=default;
-    model_t(glm::vec3 pos, glm::vec3 scale=glm::vec3(1.), class model_t* p=nullptr);
+    model_t(glm::vec3 pos, glm::vec3 scale=glm::vec3(1.), glm::vec3 init_dir=glm::vec3(0, 0, 1), class model_t* p=nullptr);
 
     glm::mat4 get_model() const;
     glm::mat4 move_to(glm::vec3 pos);
@@ -171,9 +172,10 @@ class model_t{
     glm::mat4 scale_to(glm::vec3 x);
     glm::mat4 scale_to(float x, float y, float z);
     glm::mat4 rotate_to(float degree, glm::vec3 axis);
+    glm::mat4 rotate_to(glm::vec3 pitch_yaw_roll_degree);
+    glm::mat4 rotate(glm::vec3 pitch_yaw_roll_degree);
+    glm::vec3 look_at_dir() const;
     void set_parent_model(class model_t* p);
-
-    glm::mat4 get_trans_mat(glm::vec3 pos, glm::vec3 scale, float rotate_degree, glm::vec3 rotate_axis) const;
 private:
     class model_t* parent = nullptr;
 };