Merge branch 'Warnings-Simon'

Warnings adam

include/Engine/Core/ComponentWrapper.h

@@ -81,7 +81,7 @@ class ComponentWrapperFactory
 {
 public:
     ComponentWrapperFactory() = default;
-    ComponentWrapperFactory(std::string componentTypeName, std::size_t allocation = 0)
+    ComponentWrapperFactory(std::string componentTypeName, unsigned int allocation = 0)
     {
         m_ComponentInfo.Name = componentTypeName;
         m_ComponentInfo.Meta->Allocation = allocation;

include/Engine/Core/EntityFile.h

@@ -143,7 +143,7 @@ private:
     ~EntityFile();
 
 public:
-    static std::size_t GetTypeStride(std::string typeName);
+    static unsigned int GetTypeStride(std::string typeName);
     static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
     static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
 

include/Engine/Core/Util/FileWatcher.h

@@ -42,7 +42,7 @@ enum class FileWatcher::FileEventFlags
 };
 
 inline FileWatcher::FileEventFlags operator|(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<FileWatcher::FileEventFlags>(static_cast<int>(a) | static_cast<int>(b)); }
-inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<int>(a)& static_cast<int>(b); }
+inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return (static_cast<int>(a) & static_cast<int>(b)) != 0; }
 
 class FileWatcher::Worker
 {
@@ -54,7 +54,7 @@ public:
 private:
 	struct FileInfo
 	{
-		int Size;
+		std::size_t Size;
 		std::time_t Timestamp;
 	};
 

include/Engine/Editor/EditorCameraInputController.h

@@ -23,7 +23,7 @@ public:
         m_SpeedMultiplier = m_Config->Get<float>("Editor.CameraSpeed", 3.f);
     }
     
-    virtual const glm::vec3 Movement() const override { return m_Movement * m_SpeedMultiplier; }
+    virtual const glm::vec3 Movement() const override { return m_Movement * static_cast<float>(m_SpeedMultiplier); }
 
     void Enable() { m_Enabled = true; }
     void Disable() { m_Enabled = false; }
@@ -69,7 +69,7 @@ public:
 protected:
     ConfigFile* m_Config;
     bool m_Enabled = false;
-    float m_SpeedMultiplier = 1.f;
+    double m_SpeedMultiplier = 1.f;
 
     EventRelay<EventContext, Events::MousePress> m_EMousePress;
     bool OnMousePress(const Events::MousePress& e)
@@ -105,7 +105,7 @@ protected:
             return false;
         }
 
-        m_SpeedMultiplier += e.DeltaY * (0.1f * m_SpeedMultiplier);
+        m_SpeedMultiplier += e.DeltaY * (0.1 * m_SpeedMultiplier);
         m_Config->Set("Editor.CameraSpeed", m_SpeedMultiplier);
         m_Config->SaveToDisk();
         return true;

include/Engine/Rendering/DirectionalLightJob.h

@@ -19,7 +19,7 @@ struct DirectionalLightJob : RenderJob
         Direction = glm::vec4(0,0,-1,0) * glm::inverse(Transform::AbsoluteOrientation(m_World, transformComponent.EntityID));
         //Direction = glm::vec4((glm::vec3)directionalLightComponent["Direction"], 0.f);
         Color = (glm::vec4)directionalLightComponent["Color"];
-        Intensity = (float)directionalLightComponent["Intensity"];
+        Intensity = (double)directionalLightComponent["Intensity"];
     };
 
     glm::vec4 Direction;

include/Engine/Rendering/ExplosionEffectJob.h

@@ -23,7 +23,7 @@ struct ExplosionEffectJob : ModelJob
         ExplosionDuration = (double)explosionEffectComponent["ExplosionDuration"];
         EndColor = (glm::vec4)explosionEffectComponent["EndColor"];
         Randomness = (bool)explosionEffectComponent["Randomness"];
-        RandomnessScalar = (float)((double)explosionEffectComponent["RandomnessScalar"]);
+        RandomnessScalar = (double)explosionEffectComponent["RandomnessScalar"];
         Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
         ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
         ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];

include/Engine/Rendering/ModelJob.h

@@ -62,7 +62,7 @@ struct ModelJob : RenderJob
         if (world->HasComponent(Entity, "Animation") && Skeleton != nullptr) {
             auto animationComponent = world->GetComponent(Entity, "Animation");
             Animation = model->m_RawModel->m_Skeleton->GetAnimation(animationComponent["Name"]);
-            AnimationTime = (float)((double)animationComponent["Time"]);
+            AnimationTime = (double)animationComponent["Time"];
         }
     };
 

include/Engine/Rendering/PointLightJob.h

@@ -18,9 +18,9 @@ struct PointLightJob : RenderJob
         Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
         Position = glm::vec4(Transform::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
         Color = (glm::vec4)pointLightComponent["Color"];
-        Radius = (float)((double)pointLightComponent["Radius"]);
-        Intensity = (float)pointLightComponent["Intensity"];
-        Falloff = (float)pointLightComponent["Falloff"];
+        Radius = (double)pointLightComponent["Radius"];
+        Intensity = (double)pointLightComponent["Intensity"];
+        Falloff = (double)pointLightComponent["Falloff"];
     };
 
     glm::vec4 Position;

include/Engine/Rendering/RawModelCustom.h

@@ -75,21 +75,21 @@ private:
    
 
     void ReadMeshFile(std::string filePath);
-    void ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
+    void ReadMeshFileHeader(std::size_t& offset, char* fileData);
+    void ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
 
     void ReadMaterialFile(std::string filePath);
-    void ReadMaterials(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
+    void ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
 
     void ReadAnimationFile(std::string filePath);
-    void ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadAnimationClips(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfClips);
-    void ReadAnimationClipSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int clipIndex);
-    void ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfJoints, Skeleton::Animation& animation);
+    void ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips);
+    void ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex);
+    void ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfJoints, Skeleton::Animation& animation);
     
     //void CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID);
 };

include/Engine/Rendering/Util/UnorderedMapiVec2.h

@@ -11,7 +11,7 @@ struct std::hash<glm::ivec2>
 {
     inline std::size_t operator()(const glm::ivec2 &v) const
     {
-        return boost::hash<int>()(v.x) ^ boost::hash<int>()(v.y);
+        return boost::hash<float>()(v.x) ^ boost::hash<float>()(v.y);
     }
 
     inline bool operator()(const glm::ivec2& a, const glm::ivec2& b)const

src/Engine/Core/EntityFile.cpp

@@ -40,9 +40,9 @@ void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
     reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
 }
 
-std::size_t EntityFile::GetTypeStride(std::string typeName)
+unsigned int EntityFile::GetTypeStride(std::string typeName)
 {
-    std::map<std::string, size_t> typeStrides{
+    std::map<std::string, unsigned int> typeStrides{
         { "bool", sizeof(bool) },
         { "int", sizeof(int) },
         { "float", sizeof(float) },

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -114,7 +114,7 @@ void EntityFilePreprocessor::parseComponentInfo()
             std::string baseType = XS::ToString(elementDeclaration->getTypeDefinition()->getBaseType()->getName());
 
             std::string effectiveType = type;
-            size_t stride = EntityFile::GetTypeStride(type);
+            unsigned int stride = EntityFile::GetTypeStride(type);
             if (stride == 0) {
                 stride = EntityFile::GetTypeStride(baseType);
                 if (stride == 0) {

src/Engine/Core/InputManager.cpp

@@ -218,7 +218,7 @@ void InputManager::PublishGamepadAxisIfChanged(int gamepadID, Gamepad::Axis axis
 void InputManager::PublishGamepadButtonIfChanged(int gamepadID, Gamepad::Button button)
 {
 	bool currentState = m_CurrentGamepadButtonState[gamepadID][static_cast<int>(button)];
-	float lastState = m_LastGamepadButtonState[gamepadID][static_cast<int>(button)];
+	bool lastState = m_LastGamepadButtonState[gamepadID][static_cast<int>(button)];
 	if (currentState != lastState) {
 		if (currentState == true) {
 			Events::GamepadButtonDown e;

src/Engine/Editor/EditorGUI.cpp

@@ -69,7 +69,7 @@ void EditorGUI::drawTools()
     } else if (m_CurrentWidgetSpace == WidgetSpace::Local) {
         spaceTexture = tryLoadTexture("Textures/Icons/Local.png");
     }
-    if (ImGui::ImageButton((void*)spaceTexture, ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1))) {
+    if (ImGui::ImageButton(reinterpret_cast<void*>(spaceTexture), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1))) {
         toggleWidgetSpace();
     }
     if (ImGui::IsItemHovered()) {
@@ -85,14 +85,14 @@ void EditorGUI::drawTools()
 
     // Play button
     ImGui::SameLine();
-    if (ImGui::ImageButton((void*)tryLoadTexture("Textures/Icons/Play.png"), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (!m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
+    if (ImGui::ImageButton(reinterpret_cast<void*>(tryLoadTexture("Textures/Icons/Play.png")), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (!m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
         Events::Resume e;
         e.World = m_World;
         m_EventBroker->Publish(e);
     }
     // Pause button
     ImGui::SameLine();
-    if (ImGui::ImageButton((void*)tryLoadTexture("Textures/Icons/Pause.png"), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
+    if (ImGui::ImageButton(reinterpret_cast<void*>(tryLoadTexture("Textures/Icons/Pause.png")), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
         Events::Pause e;
         e.World = m_World;
         m_EventBroker->Publish(e);
@@ -262,7 +262,7 @@ void EditorGUI::drawComponents(EntityWrapper entity)
     // Draw combo box
     ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth() - 10.f);
     int selectedItem = -1;
-    if (ImGui::Combo("", &selectedItem, componentTypes.data(), componentTypes.size(), componentTypes.size())) {
+    if (ImGui::Combo("", &selectedItem, componentTypes.data(), static_cast<int>(componentTypes.size()), static_cast<int>(componentTypes.size()))) {
         if (selectedItem != -1) {
             if (m_OnComponentAttach != nullptr) {
                 std::string chosenComponentType(componentTypes.at(selectedItem));
@@ -565,7 +565,7 @@ void EditorGUI::createWidgetToolButton(WidgetMode mode)
         break;
     }
     if (ImGui::ImageButton(
-            (void*)texture, 
+            reinterpret_cast<void*>(texture),
             ImVec2(24, 24), 
             ImVec2(0, 1), 
             ImVec2(1, 0), 

src/Engine/Editor/EditorRenderSystem.cpp

@@ -80,9 +80,9 @@ bool EditorRenderSystem::OnSetCamera(Events::SetCamera& e)
 {
     ComponentWrapper cTransform = e.CameraEntity["Transform"];
     ComponentWrapper cCamera = e.CameraEntity["Camera"];
-    m_EditorCamera->SetFOV((double)cCamera["FOV"]);
-    m_EditorCamera->SetNearClip((double)cCamera["NearClip"]);
-    m_EditorCamera->SetFarClip((double)cCamera["FarClip"]);
+    m_EditorCamera->SetFOV(static_cast<float>((double)cCamera["FOV"]));
+    m_EditorCamera->SetNearClip(static_cast<float>((double)cCamera["NearClip"]));
+    m_EditorCamera->SetFarClip(static_cast<float>((double)cCamera["FarClip"]));
     m_EditorCamera->SetPosition(cTransform["Position"]);
     m_EditorCamera->SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
     m_CurrentCamera = e.CameraEntity;

src/Engine/Input/MouseInputHandler.cpp

@@ -98,7 +98,7 @@ bool MouseInputHandler::OnMouseMove(const Events::MouseMove& e)
             Events::InputCommand ic;
             ic.PlayerID = -1;
             std::tie(ic.Command, ic.Value) = it->second;
-            ic.Value *= e.DeltaX;
+            ic.Value *= static_cast<float>(e.DeltaX);
             m_InputProxy->Publish(ic);
         }
     }
@@ -109,7 +109,7 @@ bool MouseInputHandler::OnMouseMove(const Events::MouseMove& e)
             Events::InputCommand ic;
             ic.PlayerID = -1;
             std::tie(ic.Command, ic.Value) = it->second;
-            ic.Value *= e.DeltaY;
+            ic.Value *= static_cast<float>(e.DeltaY);
             m_InputProxy->Publish(ic);
         }
     }

src/Engine/Rendering/DrawBloomPass.cpp

@@ -81,7 +81,7 @@ void DrawBloomPass::Draw(GLuint texture)
         , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
 
     //Iterate some times to make it more gaussian.
-    for (int i = 1; i < (int)m_iterations; i++) {
+    for (int i = 1; i < m_iterations; i++) {
         //Vertical pass
         m_GaussianFrameBuffer_vert.Bind();
         m_GaussianProgram_vert->Bind();
@@ -129,6 +129,6 @@ void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum fil
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, (GLsizei)dimensions.x, (GLsizei)dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
     GLERROR("Texture initialization failed");
 }

src/Engine/Rendering/DrawFinalPass.cpp

@@ -90,7 +90,7 @@ void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum fil
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, (GLsizei)dimensions.x, (GLsizei)dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
     GLERROR("Texture initialization failed");
 }
 
@@ -98,8 +98,8 @@ void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm:
 {
     glGenTextures(1, texture);
     glBindTexture(GL_TEXTURE_2D, *texture);
-    glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, (GLsizei)dimensions.x, (GLsizei)dimensions.y);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, (GLsizei)dimensions.x, (GLsizei)dimensions.y, format, type, texture);
+    glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, dimensions.x, dimensions.y);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, dimensions.x, dimensions.y, format, type, texture);
     glGenerateMipmap(GL_TEXTURE_2D);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
@@ -131,7 +131,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
                 if (explosionEffectJob->Animation != nullptr) {
                     std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), (GLsizei)frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
             }
 
@@ -147,7 +147,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
             if (modelJob) {
                 //bind forward program
                 m_ForwardPlusProgram->Bind();
-                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), (GLfloat)m_Renderer->GetViewportSize().Width, (GLfloat)m_Renderer->GetViewportSize().Height);
+                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 
                 //bind uniforms
                 BindModelUniforms(forwardHandle, modelJob, scene);
@@ -159,7 +159,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
                     if (modelJob->Animation != nullptr) {
                         std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), (GLsizei)frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                     }
                 }
 
@@ -178,13 +178,13 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 {
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), (GLfloat)m_Renderer->Resolution().Width, (GLfloat)m_Renderer->Resolution().Height);
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
     glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
-    glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), (GLfloat)job->TimeSinceDeath);
-    glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), (GLfloat)job->ExplosionDuration);
+    glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
+    glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), job->ExplosionDuration);
     glUniform4fv(glGetUniformLocation(shaderHandle, "EndColor"), 1, glm::value_ptr(job->EndColor));
     glUniform1i(glGetUniformLocation(shaderHandle, "Randomness"), job->Randomness);
     glUniform1f(glGetUniformLocation(shaderHandle, "RandomnessScalar"), job->RandomnessScalar);
@@ -199,7 +199,7 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 {
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), (GLfloat)m_Renderer->Resolution().Width, (GLfloat)m_Renderer->Resolution().Height);
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
     glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));

src/Engine/Rendering/FrameBuffer.cpp

@@ -71,7 +71,7 @@ void FrameBuffer::Generate()
     }
         
     GLenum* bufferTextures = &attachments[0];
-    glDrawBuffers((GLsizei)attachments.size(), bufferTextures);
+    glDrawBuffers(attachments.size(), bufferTextures);
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
         LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);

src/Engine/Rendering/ImGuiRenderPass.cpp

@@ -134,8 +134,8 @@ bool ImGuiRenderPass::OnMouseRelease(const Events::MouseRelease& e)
 bool ImGuiRenderPass::OnMouseMove(const Events::MouseMove& e)
 {
     ImGuiIO& io = ImGui::GetIO();
-    io.MousePos.x = e.X;
-    io.MousePos.y = e.Y;
+    io.MousePos.x = static_cast<float>(e.X);
+    io.MousePos.y = static_cast<float>(e.Y);
     return true;
 }
 
@@ -271,7 +271,7 @@ bool ImGuiRenderPass::createFontsTexture()
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
     // Store our identifier
-    io.Fonts->TexID = (void*)g_FontTexture;
+    io.Fonts->TexID = reinterpret_cast<void*>(g_FontTexture);
 
     // Restore state
     glBindTexture(GL_TEXTURE_2D, last_texture);
@@ -291,7 +291,7 @@ void ImGuiRenderPass::newFrame()
     io.DisplaySize = ImVec2((float)w, (float)h);
     io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
 
-    io.DeltaTime = g_DeltaTime;
+    io.DeltaTime = static_cast<float>(g_DeltaTime);
 
     io.KeyCtrl = glfwGetKey(g_Window, GLFW_KEY_LEFT_CONTROL) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_CONTROL);
     io.KeyShift = glfwGetKey(g_Window, GLFW_KEY_LEFT_SHIFT) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_SHIFT);

src/Engine/Rendering/LightCullingPass.cpp

@@ -25,7 +25,7 @@ void LightCullingPass::GenerateNewFrustum(RenderScene& scene)
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glUniformMatrix4fv(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "P"), 1, false, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), (GLfloat)m_Renderer->GetViewportSize().Width, (GLfloat)m_Renderer->GetViewportSize().Height);
+    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glDispatchCompute((int)(m_Renderer->GetViewportSize().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->GetViewportSize().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
 
     GLERROR("CalculateFrustum Error: End");
@@ -67,14 +67,14 @@ void LightCullingPass::CullLights(RenderScene& scene)
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
     m_LightCullProgram->Bind();
-    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), (GLfloat)m_Renderer->GetViewportSize().Width, (GLfloat)m_Renderer->GetViewportSize().Height);
+    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glUniformMatrix4fv(glGetUniformLocation(m_LightCullProgram->GetHandle(), "V"), 1, false, glm::value_ptr(scene.Camera->ViewMatrix()));
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
-    glDispatchCompute(glm::ceil((GLuint)m_Renderer->GetViewportSize().Width/ TILE_SIZE), glm::ceil((GLuint)m_Renderer->GetViewportSize().Height / TILE_SIZE), 1);
+    glDispatchCompute(glm::ceil(m_Renderer->GetViewportSize().Width/ TILE_SIZE), glm::ceil(m_Renderer->GetViewportSize().Height / TILE_SIZE), 1);
 
     GLERROR("CullLights Error: End");
 }

src/Engine/Rendering/PNG.cpp

@@ -71,12 +71,12 @@ PNG::PNG(std::string path)
 		png_read_update_info(png_ptr, info_ptr);
 	}
 	
-	unsigned int row_bytes = png_get_rowbytes(png_ptr, info_ptr);
+	std::size_t row_bytes = png_get_rowbytes(png_ptr, info_ptr);
 	this->Data = new unsigned char[height * row_bytes];
 	png_bytep* row_pointers = new png_bytep[height];
 
 	// Point each row to the continuous data array
-	for (int i = 0; i < height; ++i) {
+	for (unsigned int i = 0; i < height; ++i) {
 		// Invert Y for OpenGL
 		row_pointers[height - 1 - i] = this->Data + i * row_bytes;
 	}

src/Engine/Rendering/PickingPass.cpp

@@ -92,7 +92,7 @@ void PickingPass::Draw(RenderScene& scene)
 
                 if (modelJob->Animation != nullptr) {
                     std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), (GLsizei)frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
             }
 
@@ -138,7 +138,7 @@ void PickingPass::Draw(RenderScene& scene)
 
                 if (modelJob->Animation != nullptr) {
                     std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), (GLsizei)frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
             }
 
@@ -208,6 +208,6 @@ void PickingPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filte
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, (GLsizei)dimensions.x, (GLsizei)dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
     GLERROR("Texture initialization failed");
 }

src/Engine/Rendering/RawModelCustom.cpp

@@ -22,42 +22,42 @@ void RawModelCustom::ReadMeshFile(std::string filePath)
     if (!in.is_open()) {
         throw Resource::FailedLoadingException("Open mesh file failed");
     }
-    unsigned int fileByteSize = in.tellg();
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
-        ReadMeshFileHeader(offset, fileData, fileByteSize);
+        ReadMeshFileHeader(offset, fileData);
         ReadMesh(offset, fileData, fileByteSize);
     }
     delete fileData;
 }
 
-void RawModelCustom::ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMeshFileHeader(std::size_t& offset, char* fileData)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-    m_Vertices.resize(*(unsigned int*)(fileData + offset));
+    m_Vertices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
     offset += sizeof(unsigned int);
-    m_Indices.resize(*(unsigned int*)(fileData + offset));
+    m_Indices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
     offset += sizeof(unsigned int);
 #else
 #endif
 }
 
-void RawModelCustom::ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
     ReadVertices(offset, fileData, fileByteSize);
     ReadIndices(offset, fileData, fileByteSize);
 }
 
-void RawModelCustom::ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-    if (offset +  m_Vertices.size() * sizeof(Vertex) > fileByteSize) {
+    if (offset + m_Vertices.size() * sizeof(Vertex) > fileByteSize) {
         throw Resource::FailedLoadingException("Reading vertices failed");
     }
 
@@ -67,7 +67,7 @@ void RawModelCustom::ReadVertices(unsigned int& offset, char* fileData, unsigned
 #endif
 }
 
-void RawModelCustom::ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     if (offset + m_Indices.size() * sizeof(unsigned int) > fileByteSize) {
@@ -90,35 +90,36 @@ void RawModelCustom::ReadMaterialFile(std::string filePath)
     if (!in.is_open()) {
         throw Resource::FailedLoadingException("Open material file failed");
     }
-    unsigned int fileByteSize = in.tellg();
+
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
         ReadMaterials(offset, fileData, fileByteSize);
     }
     delete fileData;
 }
 
-void RawModelCustom::ReadMaterials(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 { 
 #ifdef BOOST_LITTLE_ENDIAN
     unsigned int* numMaterials = (unsigned int*)(fileData);
     MaterialGroups.reserve(*numMaterials);
     offset += sizeof(unsigned int);
 
-    for (int i = 0; i < *numMaterials; i++) {
+    for (unsigned int i = 0; i < *numMaterials; i++) {
         ReadMaterialSingle(offset, fileData, fileByteSize);
     }
 #else
 #endif
 }
 
-void RawModelCustom::ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 { 
     MaterialGroup newMaterial;
 
@@ -210,14 +211,14 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
         return;
     }
 
-    unsigned int fileByteSize = in.tellg();
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
         m_Skeleton = new Skeleton();
 
@@ -235,7 +236,7 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
     delete fileData;
 }
 
-void RawModelCustom::ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     unsigned int* numBones = (unsigned int*)(fileData + offset);
@@ -248,7 +249,7 @@ void RawModelCustom::ReadAnimationBindPoses(unsigned int &offset, char* fileData
 #endif
 }
 
-void RawModelCustom::ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     if (offset + sizeof(unsigned int) > fileByteSize) {
@@ -290,14 +291,14 @@ void RawModelCustom::ReadAnimationJoint(unsigned int &offset, char* fileData, un
 #endif
 }
 
-void RawModelCustom::ReadAnimationClips(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfClips)
+void RawModelCustom::ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips)
 {
     for (unsigned int i = 0; i < numberOfClips; i++) {
         ReadAnimationClipSingle(offset, fileData, fileByteSize, i);
     }
 }
 
-void RawModelCustom::ReadAnimationClipSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int clipIndex)
+void RawModelCustom::ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     Skeleton::Animation newAnimation;
@@ -342,7 +343,7 @@ void RawModelCustom::ReadAnimationClipSingle(unsigned int &offset, char* fileDat
 #endif
 }
 
-void RawModelCustom::ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int nrOfJoints, Skeleton::Animation& animation)
+void RawModelCustom::ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfJoints, Skeleton::Animation& animation)
 {
     Skeleton::Animation::Keyframe newKeyFrame;
 
@@ -358,12 +359,12 @@ void RawModelCustom::ReadAnimationKeyFrame(unsigned int &offset, char* fileData,
     newKeyFrame.Time = *(float*)(fileData + offset);
     offset += sizeof(float);
 
-    if (offset + sizeof(Skeleton::Animation::Keyframe::BoneProperty) * nrOfJoints> fileByteSize) {
+    if (offset + sizeof(Skeleton::Animation::Keyframe::BoneProperty) * numberOfJoints> fileByteSize) {
         throw Resource::FailedLoadingException("Reading AnimationKeyFrame joints failed");
     }
 
     Skeleton::Animation::Keyframe::BoneProperty newBone;
-    for (unsigned int i = 0; i < nrOfJoints; i++) {
+    for (unsigned int i = 0; i < numberOfJoints; i++) {
         memcpy(&newBone, (fileData + offset), sizeof(Skeleton::Animation::Keyframe::BoneProperty));
         offset += sizeof(Skeleton::Animation::Keyframe::BoneProperty);
         newKeyFrame.BoneProperties[newBone.ID] = newBone;

src/Engine/Rendering/RenderSystem.cpp

@@ -22,9 +22,9 @@ bool RenderSystem::OnSetCamera(Events::SetCamera& e)
 {
     ComponentWrapper cTransform = e.CameraEntity["Transform"];
     ComponentWrapper cCamera = e.CameraEntity["Camera"];
-    m_Camera->SetFOV((float)cCamera["FOV"]);
-    m_Camera->SetNearClip((float)cCamera["NearClip"]);
-    m_Camera->SetFarClip((float)cCamera["FarClip"]);
+    m_Camera->SetFOV((double)cCamera["FOV"]);
+    m_Camera->SetNearClip((double)cCamera["NearClip"]);
+    m_Camera->SetFarClip((double)cCamera["FarClip"]);
     m_Camera->SetPosition(cTransform["Position"]);
     m_Camera->SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
     m_CurrentCamera = e.CameraEntity;

src/Engine/Rendering/Renderer.cpp

@@ -165,7 +165,7 @@ void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filterin
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, (GLsizei)dimensions.x, (GLsizei)dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
     GLERROR("Texture initialization failed");
 }
 

src/Engine/Rendering/ShaderProgram.cpp

@@ -21,7 +21,7 @@ GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
 		return 0;
 
 	const GLchar* shaderFiles = shaderFile.c_str();
-	const GLint length = shaderFile.length();
+	const GLint length = static_cast<GLint>(shaderFile.length());
 	glShaderSource(shader, 1, &shaderFiles, &length);
 	if (GLERROR("glShaderSource"))
 		return 0;

src/Engine/Rendering/Skeleton.cpp

@@ -53,11 +53,11 @@ std::vector<glm::mat4> Skeleton::GetFrameBones(const Animation& animation, doubl
 
 	const Animation::Keyframe& currentFrame = animation.Keyframes[currentKeyframeIndex];
 	const Animation::Keyframe&	nextFrame = animation.Keyframes[(currentKeyframeIndex + 1) % animation.Keyframes.size()];
-	float alpha = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+	double alpha = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
 
 	//auto animationFrame = Animations[""].Keyframes[frame];
 	std::map<int, glm::mat4> frameBones;
-	AccumulateBoneTransforms(noRootMotion, currentFrame, nextFrame, alpha, frameBones, RootBone, glm::mat4(1));
+	AccumulateBoneTransforms(noRootMotion, currentFrame, nextFrame, static_cast<float>(alpha), frameBones, RootBone, glm::mat4(1));
 
 	std::vector<glm::mat4> finalMatrices;
 	for (auto &kv : frameBones) {

src/Engine/Sound/SoundSystem.cpp

@@ -116,7 +116,11 @@ void SoundSystem::updateEmitters(double dt)
         setSourcePos(it->second->ALsource, nextPos);
         setSourceVel(it->second->ALsource, velocity);
         float gain;
-        (bool)(it->second->Type) ? gain = m_SFXVolumeChannel : gain = m_BGMVolumeChannel;
+        if (it->second->Type == SoundType::SFX) {
+            gain = m_SFXVolumeChannel;
+        } else if (it->second->Type == SoundType::BGM) {
+            gain = m_BGMVolumeChannel;
+        }
         auto emitter = m_World->GetComponent(it->first, "SoundEmitter");
         setSoundProperties(it->second->ALsource, &emitter);
 

src/Game/Systems/CapturePointSystem.cpp

@@ -64,7 +64,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     std::map<std::string, int> nextPossibleCapturePoint;
     nextPossibleCapturePoint["Red"] = -1;
     nextPossibleCapturePoint["Blue"] = -1;
-    for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
+    for (int i = 0; i < m_NumberOfCapturePoints; i++)
     {
         if (m_CapturePointNumberToEntityMap[i].HasComponent("Team")) {
             continue;
@@ -93,7 +93,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
     //reset timers and reset the bool that triggers this
     if (m_ResetTimers) {
-        for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
+        for (int i = 0; i < m_NumberOfCapturePoints; i++)
         {
             ComponentWrapper& capturePoint = m_CapturePointNumberToEntityMap[i]["CapturePoint"];
             if ((int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Red"] &&

src/Game/Systems/SpawnerSystem.cpp

@@ -30,7 +30,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
         if (spawnPoints.size() > 1) {
             static std::random_device randomDevice;
             static std::mt19937 randomGenerator(randomDevice());
-            std::uniform_int_distribution<> distribution(0, std::distance(spawnPoints.begin(), spawnPoints.end()) - 1);
+            std::uniform_int_distribution<> distribution(0, static_cast<int>(std::distance(spawnPoints.begin(), spawnPoints.end())) - 1);
             auto randomSpawnPointIt = spawnPoints.begin();
             std::advance(randomSpawnPointIt, distribution(randomGenerator));
             spawnPoint = *randomSpawnPointIt;