Work

Author: Notiooo

AimGL/resources/Models/shooting-board/diffuse.png

@@ -27,9 +27,13 @@ set(PROJECT_SOURCES
         Player/Player.cpp
         World/Camera.cpp
         World/InfiniteGridFloor.cpp
+        World/Scene/Nodes/Node.cpp
         World/Scene/GameObjects/Rifle.cpp
         World/Scene/GameObjects/Target.cpp
+        World/Scene/GameObjects/TargetManager.cpp
         World/Scene/GameObjects/ButtonStand.cpp
+        World/Scene/GameObjects/ShootingRange.cpp
+        World/Scene/GameObjects/SidewayMovingTargetsRange.cpp
         World/Scene/GameObjects/LongCrate.cpp
         World/Physics/Drawable/AABB.cpp
         World/Physics/Drawable/Ray.cpp
@@ -40,5 +44,6 @@ set(PROJECT_SOURCES
         World/Physics/RectangleCollider.cpp
         World/Physics/SphereCollider.cpp
         World/Physics/Collisions.cpp
+        Utils/Transform.cpp
         Utils/Mouse.cpp
         )

AimGL/resources/Models/shooting-board/shooting-board.obj

@@ -114,5 +114,5 @@ class Sprite3D
     glm::vec2 mScale;
     glm::vec2 mDimensionsNormalized;
     Rotation3D mRotation;
-    float mOpacity;
+    float mOpacity{1};
 };

AimGL/resources/Models/shooting-board/specular.png

@@ -87,7 +87,7 @@ Rotation3D& Rotation3D::operator*=(const Rotation3D& rhs)
     return *this;
 }
 
-Rotation3D::operator glm::vec<3, float>()
+Rotation3D::operator glm::vec<3, float>() const
 {
     return mRotation;
 }

AimGL/resources/Textures/arrow-up.png

@@ -20,7 +20,7 @@ class Rotation3D
     Rotation3D& operator-=(const Rotation3D&);
     Rotation3D& operator*=(const Rotation3D&);
     friend Rotation3D operator*(const Rotation3D& lhs, float rhs);
-    explicit operator glm::vec3();
+    explicit operator glm::vec3() const;
 
     /**
      * \brief Angles of Euler rotation.

AimGL/resources/Textures/moving-targets.png

@@ -12,47 +12,30 @@ GameState::GameState(StateStack& stack, WindowToRender& window)
     , mWindow(window)
     , mPlayer(window, mColliderRegister)
     , mRenderer(mWindow)
-    , mLogoTexture("resources/Textures/logo_background.png")
-    , mLogo(mLogoTexture)
     , mGameBackground(glm::vec2(1280, 720.f), glm::vec4(0.85f, 0.85f, 0.85f, 1.f))
     , mPhaseInLogoColor({window.getSize().x, window.getSize().y}, {0.067f, 0.11f, 0.18f, 1.1f})
-    , mTree("resources/Models/tree/tree.obj",
-            {{"resources/Models/tree/tree_combined.png", Texture::Type::Diffuse}})
+    , mShootingRange(mColliderRegister, {-2, 0, 5.5})
+    , mSidewayMovingTargetsRange(mColliderRegister, {3, 0, 5.5})
+    , mWelcomeScreenTexture("resources/Textures/welcome-screen.png")
+    , mWelcomeScreen(mWelcomeScreenTexture)
 {
     Mouse::lockMouseAtCenter(mWindow);
-    mTree.setScale(0.2f);
-    mTree.setPosition({4, 0, 4}, Model::Origin::CenterBottom);
-    mLogo.setHeight(2.f);
-    mLogo.setPosition(glm::vec3(4, 0, 4), Sprite3D::Origin::LeftBottom);
-    mLogo.setRotation({225.f, 0.f, 0});
-    mLogo.setOpacity(1);
+    mWelcomeScreen.setScale(2);
+    mWelcomeScreen.setPosition({0, 1, -2}, Sprite3D::Origin::Center);
     mGameBackground.setPosition({0, 0});
     mPhaseInLogoColor.setPosition({0, 0});
     mPhaseInClock.restart();
-
-    std::vector<glm::vec3> samplePreviewTargetsPositons = {
-        {2, 2, 2}, {2, 1, 2}, {2, 3, 2}, {2.5, 2, 2.6}, {3, 3, 3},
-        {3, 2, 1}, {1, 2, 3}, {0, 3, 2}, {0, 1, 1},     {0, 2, 4}};
-    for (auto& position: samplePreviewTargetsPositons)
-    {
-        auto test = std::make_unique<Target>(mColliderRegister, position);
-        mPreviewTargets.push_back(std::move(test));
-    }
 }
 
 void GameState::draw(sf::Window& target) const
 {
     MTR_SCOPE("GameState", "GameState::draw");
     mGameBackground.draw(mRenderer);
     mInfiniteGridFloor.draw(target, mPlayer.camera());
-    mTree.draw(mRenderer, mPlayer.camera());
-    mLogo.draw(mRenderer, mPlayer.camera());
+    mWelcomeScreen.draw(mRenderer, mPlayer.camera());
     mPhaseInLogoColor.draw(mRenderer);
-
-    for (auto& previewTarget: mPreviewTargets)
-    {
-        previewTarget->draw(mRenderer, mPlayer.camera());
-    }
+    mShootingRange.draw(mRenderer, mPlayer.camera());
+    mSidewayMovingTargetsRange.draw(mRenderer, mPlayer.camera());
     mPlayer.draw(mRenderer);
 }
 
@@ -67,11 +50,9 @@ bool GameState::fixedUpdate(const float& deltaTime)
 bool GameState::update(const float& deltaTime)
 {
     MTR_SCOPE("GameState", "GameState::update");
-    for (auto& previewTarget: mPreviewTargets)
-    {
-        previewTarget->update(deltaTime);
-    }
     mPlayer.update(deltaTime);
+    mShootingRange.update(deltaTime);
+    mSidewayMovingTargetsRange.update(deltaTime);
 
     if (mPhaseInLogoColor.opacity() > 0)
     {
@@ -84,6 +65,8 @@ bool GameState::handleEvent(const sf::Event& event)
 {
     MTR_SCOPE("GameState", "GameState::handleEvent");
     mPlayer.handleEvent(event);
+    mShootingRange.handleEvent(event);
+    mSidewayMovingTargetsRange.handleEvent(event);
 
     if (event.type == sf::Event::KeyPressed)
     {

AimGL/resources/Textures/static-muscle-training.png

@@ -8,9 +8,9 @@
 #include "World/InfiniteGridFloor.h"
 
 #include <Player/Player.h>
-#include <Renderer/Graphics/3D/Model.h>
 #include <World/Physics/ColliderRegister.h>
-#include <World/Scene/GameObjects/Target.h>
+#include <World/Scene/GameObjects/ShootingRange.h>
+#include <World/Scene/GameObjects/SidewayMovingTargetsRange.h>
 
 class StateStack;
 
@@ -83,13 +83,13 @@ class GameState : public State
     ColliderRegister mColliderRegister;
     Player mPlayer;
     Renderer mRenderer;
-    Texture mLogoTexture;
-    Sprite3D mLogo;
     Rectangle2D mGameBackground;
     sf::Clock mPhaseInClock;
     Rectangle2D mPhaseInLogoColor;
     InfiniteGridFloor mInfiniteGridFloor;
-    Model mTree;
-    std::vector<std::unique_ptr<Target>> mPreviewTargets;
+    ShootingRange mShootingRange;
+    SidewayMovingTargetsRange mSidewayMovingTargetsRange;
+    Texture mWelcomeScreenTexture;
+    Sprite3D mWelcomeScreen;
     bool mDrawImgui{true};
 };

AimGL/resources/Textures/welcome-screen.png

@@ -67,6 +67,5 @@ bool LogoState::handleEvent(const sf::Event& event)
 bool LogoState::updateImGui(const float& deltaTime)
 {
     MTR_SCOPE("LogoState", "LogoState::updateImGui");
-    ImGui::ShowDemoWindow();
     return true;
 }

AimGL/src/CMakeLists_Sources.txt

@@ -0,0 +1,27 @@
+#include "Transform.h"
+#include "pch.h"
+
+#include <Renderer/Graphics/3D/Utils/Rotation3D.h>
+
+glm::mat4 Transform::matrix() const
+{
+    return mTransform;
+}
+
+Transform& Transform::translate(const glm::vec3& vec)
+{
+    glm::translate(mTransform, vec);
+    return *this;
+}
+
+Transform& Transform::rotate(const Rotation3D& rotation)
+{
+    mTransform = rotation.rotate(mTransform);
+    return *this;
+}
+
+Transform& Transform::operator*=(const Transform& rhs)
+{
+    mTransform *= rhs.mTransform;
+    return *this;
+}

AimGL/src/Renderer/Graphics/3D/Sprite3D.h

@@ -0,0 +1,17 @@
+
+#pragma once
+
+class Rotation3D;
+
+class Transform
+{
+public:
+    [[nodiscard]] glm::mat4 matrix() const;
+    Transform& translate(const glm::vec3& vec);
+    Transform& rotate(const Rotation3D& rotation);
+    Transform& operator*=(const Transform& rhs);
+
+
+private:
+    glm::mat4 mTransform{1};
+};

AimGL/src/Renderer/Graphics/3D/Utils/Rotation3D.cpp

@@ -29,6 +29,10 @@ void Rifle::draw(const Renderer& target) const
 void Rifle::update(const float& deltaTime)
 {
     updateAttachToCamera(deltaTime);
+    if (mLatelyShotRay.has_value() and mShotRayClock.getElapsedTime() > mShotRayDeleteTime)
+    {
+        mLatelyShotRay.reset();
+    }
 }
 
 void Rifle::updateAttachToCamera(const float& deltaTime)
@@ -67,5 +71,6 @@ void Rifle::handleEvent(const sf::Event& event)
         mGunShotSound.play();
         mLatelyShotRay.emplace(mColliderRegister, mCamera.cameraPosition(), mCamera.direction());
         mLatelyShotRay.value().colliderTag(ColliderTag::GunShot);
+        mShotRayClock.restart();
     }
 }

AimGL/src/Renderer/Graphics/3D/Utils/Rotation3D.h

@@ -57,4 +57,6 @@ class Rifle
     std::optional<Ray> mLatelyShotRay;
     std::vector<std::function<void(Ray)>> mRaySubscribers;
     ColliderRegister& mColliderRegister;
+    sf::Clock mShotRayClock;
+    sf::Time mShotRayDeleteTime = sf::seconds(0.5);
 };

AimGL/src/States/CustomStates/GameState.cpp

@@ -0,0 +1,102 @@
+#include "ShootingRange.h"
+#include "pch.h"
+
+ShootingRange::ShootingRange(ColliderRegister& colliderRegister, const glm::vec3& position)
+    : mButtonStand(colliderRegister, position)
+    , mShootingRange("resources/Models/shooting-board/shooting-board.obj",
+                     {{"resources/Models/shooting-board/diffuse.png", Texture::Type::Diffuse},
+                      {"resources/Models/shooting-board/specular.png", Texture::Type::Specular}})
+    , mPosition(position)
+    , mAABB(colliderRegister, {0, 0, 0}, mShootingRange.dimensions())
+    , mSmallerCrate(colliderRegister, position)
+    , mMediumCrate(colliderRegister, position)
+    , mLargeCrate(colliderRegister, position)
+    , mDirectionArrowTexture("resources/Textures/arrow-up.png")
+    , mDirectionArrowPointingUpwardCrates(mDirectionArrowTexture)
+    , mTrainingLogoTexture("resources/Textures/static-muscle-training.png")
+    , mTrainingLogo(mTrainingLogoTexture)
+    , mTargetManager(colliderRegister, {0, 0, -2}, sf::seconds(0.75), sf::seconds(0.75))
+{
+    mLargeCrate.setScale(1.5);
+    mMediumCrate.setScale(1);
+    mSmallerCrate.setScale(0.5);
+    mAABB.colliderTag(ColliderTag::Solid);
+    setPosition(mPosition);
+    mSmallerCrate.setRotation({90, 0, 0});
+    mMediumCrate.setRotation({90, 0, 0});
+    mLargeCrate.setRotation({90, 0, 0});
+    mDirectionArrowPointingUpwardCrates.setRotation({-30, 25, 0});
+    mDirectionArrowPointingUpwardCrates.setScale(0.6);
+    mTrainingLogo.setRotation({180, 0, 0});
+    mTrainingLogo.setScale(3.f);
+    auto halfOfShootingRangeDimensions = mShootingRange.dimensions() / 2.f;
+    mTargetManager.setSpawnRange(
+        {-halfOfShootingRangeDimensions.x, -halfOfShootingRangeDimensions.y, 0},
+        {halfOfShootingRangeDimensions.x, halfOfShootingRangeDimensions.y, 0});
+    mButtonStand.onClick(
+        [this]()
+        {
+            toggleShootingRange();
+        });
+}
+
+void ShootingRange::draw(const Renderer& target, const Camera& camera) const
+{
+    mShootingRange.draw(target, camera);
+    mButtonStand.draw(target, camera);
+    mAABB.draw(target, camera);
+    mLargeCrate.draw(target, camera);
+    mMediumCrate.draw(target, camera);
+    mSmallerCrate.draw(target, camera);
+    mDirectionArrowPointingUpwardCrates.draw(target, camera);
+    mTargetManager.draw(target, camera);
+    mTrainingLogo.draw(target, camera);
+}
+
+void ShootingRange::update(const float& deltaTime)
+{
+    mButtonStand.update(deltaTime);
+    mTargetManager.update(deltaTime);
+}
+
+void ShootingRange::handleEvent(const sf::Event& event)
+{
+    mButtonStand.handleEvent(event);
+}
+
+void ShootingRange::showDebugImGui(std::string name)
+{
+    name = "[Model] " + name;
+    ImGui::Begin(name.c_str());
+    ImGui::SliderFloat3("Position", &mPosition[0], -50, 50.f);
+    ImGui::End();
+    setPosition(mPosition);
+}
+
+void ShootingRange::setPosition(const glm::vec3& newPosition)
+{
+    mShootingRange.setPosition(newPosition + glm::vec3{0, 0, BOXES_DISTANCE});
+    mTargetManager.setPosition(
+        newPosition + glm::vec3{0, mShootingRange.dimensions().y / 2.f, BOXES_DISTANCE - 0.25f});
+    mButtonStand.setPosition(newPosition + glm::vec3{-1.15, 1.5, 0.45});
+    mAABB.setPosition(mShootingRange.position() - mShootingRange.dimensions() / 2.f);
+    mLargeCrate.setPosition(newPosition + glm::vec3{0, 0, 0});
+    mMediumCrate.setPosition(newPosition + glm::vec3{0, 0, -1.25});
+    mSmallerCrate.setPosition(newPosition + glm::vec3{0, 0, -2});
+    mDirectionArrowPointingUpwardCrates.setPosition(newPosition + glm::vec3{1, 0, -2.5});
+    mTrainingLogo.setPosition(newPosition + glm::vec3{-0.5, 5, BOXES_DISTANCE});
+}
+
+void ShootingRange::toggleShootingRange()
+{
+    if (mIsShootingRangeActive)
+    {
+        mTargetManager.stop();
+        mIsShootingRangeActive = false;
+    }
+    else
+    {
+        mTargetManager.start();
+        mIsShootingRangeActive = true;
+    }
+}