feat(weapon): add WeaponComponent with deserialization correct rendering

Author: AhmedAmrNabil

CMakeLists.txt

@@ -262,6 +262,7 @@ add_executable(${PROJECT_NAME}
     src/game/components/enemy.cpp
     src/game/components/health.cpp
     src/game/components/player.cpp
+    src/game/components/weapon.cpp
     src/game/game-registration.cpp
     src/game/systems/collision-system.cpp
     src/game/systems/collision-debug-drawer.cpp

config/playgrounds/model.jsonc

@@ -288,6 +288,12 @@
                             {
                                 "type": "Model Renderer",
                                 "model": "gun"
+                            },
+                            {
+                                "type": "Weapon",
+                                "damage": 25,
+                                "range": 50.0,
+                                "fireRate": 0.5
                             }
                         ],
                         "children": [

src/common/systems/forward-renderer.cpp

@@ -3,6 +3,7 @@
 #include "../components/model-renderer.hpp"
 #include "../mesh/mesh-utils.hpp"
 #include "../texture/texture-utils.hpp"
+#include "components/weapon.hpp"
 
 namespace our {
 
@@ -132,9 +133,12 @@ namespace our {
         opaqueCommands.clear();
         transparentCommands.clear();
         sceneLights.clear();
+        weaponCommands.clear();
         for (auto entity : world->getEntities()) {
             // If we hadn't found a camera yet, we look for a camera in this entity
             if (!camera) camera = entity->getComponent<CameraComponent>();
+
+            bool isWeapon = entity->getComponent<gameplay::WeaponComponent>() != nullptr;
             // If this entity has a mesh renderer component
             if (auto meshRenderer = entity->getComponent<MeshRendererComponent>(); meshRenderer) {
                 // We construct a command from it
@@ -143,8 +147,9 @@ namespace our {
                 command.center = glm::vec3(command.localToWorld * glm::vec4(0, 0, 0, 1));
                 command.mesh = meshRenderer->mesh;
                 command.material = meshRenderer->material;
-                // if it is transparent, we add it to the transparent commands list
-                if (command.material->transparent) {
+                if (isWeapon) {
+                    weaponCommands.push_back(command);
+                } else if (command.material->transparent) {
                     transparentCommands.push_back(command);
                 } else {
                     // Otherwise, we add it to the opaque command list
@@ -176,7 +181,10 @@ namespace our {
                     command.center = glm::vec3(command.localToWorld * glm::vec4(0, 0, 0, 1));
                     command.mesh = submesh->mesh;
                     command.material = submesh->material;
-                    if (command.material->transparent) {
+
+                    if (isWeapon) {
+                        weaponCommands.push_back(command);
+                    } else if (command.material->transparent) {
                         transparentCommands.push_back(command);
                     } else {
                         opaqueCommands.push_back(command);
@@ -263,6 +271,22 @@ namespace our {
             command.mesh->draw();
         }
 
+        // render weapon at the end with depth testing cleared
+        glClear(GL_DEPTH_BUFFER_BIT);
+        for (const RenderCommand& command : weaponCommands) {
+            command.material->pipelineState.depthMask = false;
+            command.material->setup();
+            glm::mat4 MVP = VP * command.localToWorld;
+            command.material->shader->set("transform", MVP);
+            if (LitMaterial* litMaterial = dynamic_cast<LitMaterial*>(command.material); litMaterial) {
+                // if the material is a lit material, we need to set the light uniforms
+                litMaterial->setLightUniforms(sceneLights);
+                litMaterial->shader->set("cameraPos", cameraPosition);
+                litMaterial->shader->set("model", command.localToWorld);
+            }
+            command.mesh->draw();
+        }
+
         // If there is a postprocess material, apply postprocessing
         if (postprocessMaterial) {
             glBindFramebuffer(GL_FRAMEBUFFER, 0);

src/common/systems/forward-renderer.hpp

@@ -34,6 +34,7 @@ namespace our {
         // reallocating them every frame
         std::vector<RenderCommand> opaqueCommands;
         std::vector<RenderCommand> transparentCommands;
+        std::vector<RenderCommand> weaponCommands;
         // Objects used for rendering a skybox
         Mesh* skySphere;
         TexturedMaterial* skyMaterial;

src/game/components/weapon.cpp

@@ -0,0 +1,14 @@
+#include "weapon.hpp"
+
+namespace gameplay {
+
+    void WeaponComponent::deserialize(const nlohmann::json& data) {
+        if (!data.is_object()) {
+            return;
+        }
+        damage = data.value("damage", 0);
+        range = data.value("range", 0.0f);
+        fireRate = data.value("fireRate", 0.0f);
+    }
+
+}  // namespace gameplay

src/game/components/weapon.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <ecs/component.hpp>
+
+namespace gameplay {
+
+    class WeaponComponent : public our::Component {
+    public:
+        int damage;
+        float range;
+        float fireRate;
+        static std::string getID() {
+            return "Weapon";
+        }
+
+        void deserialize(const nlohmann::json& data) override;
+    };
+
+}  // namespace gameplay

src/game/game-registration.cpp

@@ -6,7 +6,7 @@
 #include "components/enemy.hpp"
 #include "components/health.hpp"
 #include "components/player.hpp"
-
+#include "components/weapon.hpp"
 namespace gameplay {
 
     void registerGameComponents() {
@@ -17,6 +17,7 @@ namespace gameplay {
         our::ComponentRegistry::registerType<EnemyComponent>();
         our::ComponentRegistry::registerType<HealthComponent>();
         our::ComponentRegistry::registerType<PlayerComponent>();
+        our::ComponentRegistry::registerType<WeaponComponent>();
 
         initialized = true;
     }