feat: abstracted CameraComponent implementation in CameraComponentImpl

Alexandre jublot · 0xSwapFeeder · commit 1ca4a4fb44dc · 2022-11-02T19:49:59.000+01:00
diff --git a/Factory/include/initializers/CameraInitializer.hpp b/Factory/include/initializers/CameraInitializer.hpp
@@ -9,13 +9,12 @@
 #define ENGINE_CAMERAINITIALIZER_HPP
 
 #include "polymorph/Core.hpp"
-#include "../../../Scripts/include/CameraComponent.hpp"
+#include "CameraComponentImpl.hpp"
 
 namespace polymorph::engine
 {
-    class CameraComponent;
 
-    class CameraInitializer : public AComponentInitializer<CameraComponent>
+    class CameraInitializer : public AComponentInitializer<CameraComponentImpl>
     {
 ///////////////////////////////// Constructors /////////////////////////////////
 
diff --git a/Scripts/include/CameraComponent.hpp b/Scripts/include/CameraComponent.hpp
@@ -14,7 +14,7 @@
 #include "Utilities/safe_ptr.hpp"
 #include "Utilities/types/Vector.hpp"
 #include "Utilities/Time.hpp"
-#include "../../Core/include/modules/CameraModule.hpp"
+#include "modules/CameraModule.hpp"
 
 namespace polymorph::engine
 {
@@ -30,7 +30,7 @@ namespace polymorph::engine
 ////////////////////// CONSTRUCTORS/DESTRUCTORS /////////////////////////
 
         public:
-            explicit CameraComponent(GameObject gameObject);
+            explicit CameraComponent(GameObject gameObject) : Component("Camera", gameObject) {};
 
 
 //////////////////////--------------------------/////////////////////////
@@ -48,12 +48,7 @@ namespace polymorph::engine
             GameObject ObjectTarget;
             Vector3 PointTarget;
 
-            void update() override;
-
-            void start() override;
-
             std::shared_ptr<graphical::CameraModule> camera;
-            static inline CameraComponent *Current = nullptr;
 
         private:
 
@@ -64,21 +59,21 @@ namespace polymorph::engine
 
 /////////////////////////////// METHODS /////////////////////////////////
         public:
-            bool isTargetingObject();
+            virtual bool isTargetingObject() = 0;
 
-            GameObject getTargetObject();
+            virtual GameObject getTargetObject() = 0;
 
-            void setTargetPosition(Vector3 targetPosition);
+            virtual void setTargetPosition(Vector3 targetPosition) = 0;
 
-            void setTargetObject(GameObject object);
+            virtual void setTargetObject(GameObject object) = 0;
 
-            void setUp(Vector3 up);
+            virtual void setUp(Vector3 up) = 0;
 
-            void setFov(float fov);
+            virtual void setFov(float fov) = 0;
 
-            void begin3dMode();
+            virtual void begin3dMode() = 0;
 
-            void end3dMode();
+            virtual void end3dMode() = 0;
 
 
         private:
diff --git a/Scripts/include/CameraComponentImpl.hpp b/Scripts/include/CameraComponentImpl.hpp
@@ -0,0 +1,81 @@
+/*
+** EPITECH PROJECT, 2020
+** CameraComponentImpl.hpp
+** File description:
+** header for CameraComponentImpl.c
+*/
+
+
+#pragma once
+
+#include <vector>
+#include <functional>
+#include "CameraComponent.hpp"
+
+namespace polymorph::engine
+{
+
+    class CameraComponentImpl : public CameraComponent
+    {
+
+////////////////////// CONSTRUCTORS/DESTRUCTORS /////////////////////////
+
+        public:
+            explicit CameraComponentImpl(GameObject gameObject);
+
+
+//////////////////////--------------------------/////////////////////////
+
+
+
+///////////////////////////// PROPERTIES ////////////////////////////////
+        public:
+            enum CameraTargetType : int
+            {
+                Point,
+                Object,
+            };
+            CameraTargetType TargetType;
+            GameObject ObjectTarget;
+            Vector3 PointTarget;
+
+            std::shared_ptr<graphical::CameraModule> camera;
+
+        private:
+
+
+//////////////////////--------------------------/////////////////////////
+
+
+
+/////////////////////////////// METHODS /////////////////////////////////
+        public:
+            void update() override;
+
+            void start() override;
+
+            bool isTargetingObject() override;
+
+            GameObject getTargetObject() override;
+
+            void setTargetPosition(Vector3 targetPosition) override;
+
+            void setTargetObject(GameObject object) override;
+
+            void setUp(Vector3 up) override;
+
+            void setFov(float fov) override;
+
+            void begin3dMode() override;
+
+            void end3dMode() override;
+
+
+        private:
+
+
+//////////////////////--------------------------/////////////////////////
+
+    };
+
+}
diff --git a/Scripts/src/CameraComponentImpl.cpp b/Scripts/src/CameraComponentImpl.cpp
@@ -1,60 +1,57 @@
 /*
 ** EPITECH PROJECT, 2022
-** CameraComponent.cpp
+** CameraComponentImpl.cpp
 ** File description:
-** CameraComponent.cpp
+** CameraComponentImpl.cpp
 */
 
 #include "polymorph/Core.hpp"
-#include "CameraComponent.hpp"
+#include "CameraComponentImpl.hpp"
 
 
 namespace polymorph::engine
 {
 
-    CameraComponent::CameraComponent(GameObject gameObject) : Component("Camera", gameObject)
-    {
-        Current = this;
-    }
+    CameraComponentImpl::CameraComponentImpl(GameObject gameObject) : CameraComponent(gameObject) {}
 
-    bool CameraComponent::isTargetingObject()
+    bool CameraComponentImpl::isTargetingObject()
     {
         return (TargetType == Object);
     }
 
-    GameObject CameraComponent::getTargetObject()
+    GameObject CameraComponentImpl::getTargetObject()
     {
         return ObjectTarget;
     }
 
-    void CameraComponent::setTargetPosition(Vector3 targetPosition)
+    void CameraComponentImpl::setTargetPosition(Vector3 targetPosition)
     {
         PointTarget = targetPosition;
         camera->setTarget(PointTarget);
-        TargetType = CameraComponent::Point;
+        TargetType = CameraComponentImpl::Point;
     }
 
-    void CameraComponent::setUp(Vector3 up)
+    void CameraComponentImpl::setUp(Vector3 up)
     {
         camera->setUp(up);
     }
 
-    void CameraComponent::setFov(float fov)
+    void CameraComponentImpl::setFov(float fov)
     {
         camera->setFOV(fov);
     }
 
-    void CameraComponent::begin3dMode()
+    void CameraComponentImpl::begin3dMode()
     {
         camera->begin3DMode();
     }
 
-    void CameraComponent::end3dMode()
+    void CameraComponentImpl::end3dMode()
     {
         camera->end3DMode();
     }
 
-    void CameraComponent::update()
+    void CameraComponentImpl::update()
     {
         if (TargetType == CameraTargetType::Object && !!ObjectTarget)
         {
@@ -66,7 +63,7 @@ namespace polymorph::engine
         }
     }
 
-    void CameraComponent::start()
+    void CameraComponentImpl::start()
     {
         if (TargetType == CameraTargetType::Object && !!ObjectTarget)
         {
@@ -78,10 +75,10 @@ namespace polymorph::engine
         }
     }
 
-    void CameraComponent::setTargetObject(GameObject object)
+    void CameraComponentImpl::setTargetObject(GameObject object)
     {
         ObjectTarget = object;
         camera->setTarget(ObjectTarget->transform->getPosition());
-        TargetType = CameraComponent::Object;
+        TargetType = CameraComponentImpl::Object;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,12 @@`
`9`	`9`	`#define ENGINE_CAMERAINITIALIZER_HPP`
`10`	`10`
`11`	`11`	`#include "polymorph/Core.hpp"`
`12`		`-#include "../../../Scripts/include/CameraComponent.hpp"`
	`12`	`+#include "CameraComponentImpl.hpp"`
`13`	`13`
`14`	`14`	`namespace polymorph::engine`
`15`	`15`	`{`
`16`		`- class CameraComponent;`
`17`	`16`
`18`		`- class CameraInitializer : public AComponentInitializer<CameraComponent>`
	`17`	`+ class CameraInitializer : public AComponentInitializer<CameraComponentImpl>`
`19`	`18`	`{`
`20`	`19`	`///////////////////////////////// Constructors /////////////////////////////////`
`21`	`20`
Original file line number	Diff line number	Diff line change
`@@ -1,60 +1,57 @@`
`1`	`1`	`/*`
`2`	`2`	`** EPITECH PROJECT, 2022`
`3`		`-** CameraComponent.cpp`
	`3`	`+** CameraComponentImpl.cpp`
`4`	`4`	`** File description:`
`5`		`-** CameraComponent.cpp`
	`5`	`+** CameraComponentImpl.cpp`
`6`	`6`	`*/`
`7`	`7`
`8`	`8`	`#include "polymorph/Core.hpp"`
`9`		`-#include "CameraComponent.hpp"`
	`9`	`+#include "CameraComponentImpl.hpp"`
`10`	`10`
`11`	`11`
`12`	`12`	`namespace polymorph::engine`
`13`	`13`	`{`
`14`	`14`
`15`		`- CameraComponent::CameraComponent(GameObject gameObject) : Component("Camera", gameObject)`
`16`		`- {`
`17`		`- Current = this;`
`18`		`- }`
	`15`	`+ CameraComponentImpl::CameraComponentImpl(GameObject gameObject) : CameraComponent(gameObject) {}`
`19`	`16`
`20`		`- bool CameraComponent::isTargetingObject()`
	`17`	`+ bool CameraComponentImpl::isTargetingObject()`
`21`	`18`	`{`
`22`	`19`	`return (TargetType == Object);`
`23`	`20`	`}`
`24`	`21`
`25`		`- GameObject CameraComponent::getTargetObject()`
	`22`	`+ GameObject CameraComponentImpl::getTargetObject()`
`26`	`23`	`{`
`27`	`24`	`return ObjectTarget;`
`28`	`25`	`}`
`29`	`26`
`30`		`- void CameraComponent::setTargetPosition(Vector3 targetPosition)`
	`27`	`+ void CameraComponentImpl::setTargetPosition(Vector3 targetPosition)`
`31`	`28`	`{`
`32`	`29`	`PointTarget = targetPosition;`
`33`	`30`	`camera->setTarget(PointTarget);`
`34`		`- TargetType = CameraComponent::Point;`
	`31`	`+ TargetType = CameraComponentImpl::Point;`
`35`	`32`	`}`
`36`	`33`
`37`		`- void CameraComponent::setUp(Vector3 up)`
	`34`	`+ void CameraComponentImpl::setUp(Vector3 up)`
`38`	`35`	`{`
`39`	`36`	`camera->setUp(up);`
`40`	`37`	`}`
`41`	`38`
`42`		`- void CameraComponent::setFov(float fov)`
	`39`	`+ void CameraComponentImpl::setFov(float fov)`
`43`	`40`	`{`
`44`	`41`	`camera->setFOV(fov);`
`45`	`42`	`}`
`46`	`43`
`47`		`- void CameraComponent::begin3dMode()`
	`44`	`+ void CameraComponentImpl::begin3dMode()`
`48`	`45`	`{`
`49`	`46`	`camera->begin3DMode();`
`50`	`47`	`}`
`51`	`48`
`52`		`- void CameraComponent::end3dMode()`
	`49`	`+ void CameraComponentImpl::end3dMode()`
`53`	`50`	`{`
`54`	`51`	`camera->end3DMode();`
`55`	`52`	`}`
`56`	`53`
`57`		`- void CameraComponent::update()`
	`54`	`+ void CameraComponentImpl::update()`
`58`	`55`	`{`
`59`	`56`	`if (TargetType == CameraTargetType::Object && !!ObjectTarget)`
`60`	`57`	`{`
`@@ -66,7 +63,7 @@ namespace polymorph::engine`
`66`	`63`	`}`
`67`	`64`	`}`
`68`	`65`
`69`		`- void CameraComponent::start()`
	`66`	`+ void CameraComponentImpl::start()`
`70`	`67`	`{`
`71`	`68`	`if (TargetType == CameraTargetType::Object && !!ObjectTarget)`
`72`	`69`	`{`
`@@ -78,10 +75,10 @@ namespace polymorph::engine`
`78`	`75`	`}`
`79`	`76`	`}`
`80`	`77`
`81`		`- void CameraComponent::setTargetObject(GameObject object)`
	`78`	`+ void CameraComponentImpl::setTargetObject(GameObject object)`
`82`	`79`	`{`
`83`	`80`	`ObjectTarget = object;`
`84`	`81`	`camera->setTarget(ObjectTarget->transform->getPosition());`
`85`		`- TargetType = CameraComponent::Object;`
	`82`	`+ TargetType = CameraComponentImpl::Object;`
`86`	`83`	`}`
`87`	`84`	`}`