Fixing linux build (4) #5

dtrajko · Apr 11, 2021 · 550e5cc · 550e5cc
1 parent f6615fd
commit 550e5cc
Show file tree

Hide file tree

Showing 17 changed files with 48 additions and 50 deletions.
diff --git a/MoravaEngine/src/Hazel/Editor/EditorCamera.cpp b/MoravaEngine/src/Hazel/Editor/EditorCamera.cpp
@@ -138,8 +138,8 @@ namespace Hazel {
 	{
 		if (width == 0.0f || height == 0.0f) return;
 
-		m_ViewportWidth = (uint32_t)width;
-		m_ViewportHeight = (uint32_t)height;
+		m_ViewportWidth = width;
+		m_ViewportHeight = height;
 
 		UpdateProjection();
 	}

diff --git a/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanAllocator.h b/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanAllocator.h
@@ -22,5 +22,4 @@ namespace Hazel {
 		std::string m_Tag;
 	};
 
-
 }
diff --git a/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanShader.cpp b/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanShader.cpp
@@ -508,7 +508,7 @@ namespace Hazel {
 		// This buffer will be used as a uniform buffer
 		bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 
-		VulkanAllocator allocator("UniformBuffer");
+		VulkanAllocator allocator(std::string("UniformBuffer"));
 
 		// Create a new buffer
 		VK_CHECK_RESULT(vkCreateBuffer(device, &bufferInfo, nullptr, &uniformBuffer.Buffer));

diff --git a/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanTexture.cpp b/MoravaEngine/src/Hazel/Platform/Vulkan/VulkanTexture.cpp
@@ -130,7 +130,7 @@ namespace Hazel {
 		VkMemoryAllocateInfo memAllocInfo{};
 		memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 
-		VulkanAllocator allocator("Texture2D");
+		VulkanAllocator allocator(std::string("Texture2D"));
 
 		// Create staging buffer
 		VkBuffer stagingBuffer;
@@ -706,7 +706,7 @@ namespace Hazel {
 		VkMemoryAllocateInfo memAllocInfo{};
 		memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 
-		VulkanAllocator allocator("TextureCube");
+		VulkanAllocator allocator(std::string("TextureCube"));
 
 		// Create optimal tiled target image on the device
 		VkImageCreateInfo imageCreateInfo{};

diff --git a/MoravaEngine/src/Hazel/Renderer/HazelShader.cpp b/MoravaEngine/src/Hazel/Renderer/HazelShader.cpp
@@ -14,11 +14,11 @@ namespace Hazel {
 	{
 		Log::GetLogger()->info("HazelShader::Create('{0}')", filepath.c_str());
 
-		Ref<HazelShader> result = nullptr;
+		Ref<HazelShader> result = Ref<HazelShader>();
 
 		switch (RendererAPI::Current())
 		{
-			case RendererAPIType::None: return nullptr;
+			case RendererAPIType::None: return Ref<HazelShader>();
 			case RendererAPIType::OpenGL:
 				result = Ref<OpenGLShader>::Create(filepath, forceCompile);
 				break;
@@ -34,11 +34,11 @@ namespace Hazel {
 	{
 		Log::GetLogger()->info("HazelShader::CreateFromString('{0}')", source.c_str());
 
-		Ref<HazelShader> result = nullptr;
+		Ref<HazelShader> result = Ref<HazelShader>();
 
 		switch (RendererAPI::Current())
 		{
-			case RendererAPIType::None: return nullptr;
+			case RendererAPIType::None: return Ref<HazelShader>();
 			case RendererAPIType::OpenGL: result = OpenGLShader::CreateFromString(source);
 		}
 		s_AllShaders.push_back(result);

diff --git a/MoravaEngine/src/Hazel/Renderer/HazelTexture.cpp b/MoravaEngine/src/Hazel/Renderer/HazelTexture.cpp
@@ -10,40 +10,40 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None: return nullptr;
+		case RendererAPIType::None: return Ref<HazelTexture2D>();
 		case RendererAPIType::OpenGL: return Ref<OpenGLTexture2D>::Create(format, width, height, wrap);
 		}
-		return nullptr;
+		return Ref<HazelTexture2D>();
 	}
 
 	Ref<HazelTexture2D> HazelTexture2D::Create(const std::string& path, bool srgb, HazelTextureWrap wrap)
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None: return nullptr;
+		case RendererAPIType::None: return Ref<HazelTexture2D>();
 		case RendererAPIType::OpenGL: return Ref<OpenGLTexture2D>::Create(path, srgb, wrap);
 		}
-		return nullptr;
+		return Ref<HazelTexture2D>();
 	}
 
 	Ref<HazelTextureCube> HazelTextureCube::Create(HazelImageFormat format, uint32_t width, uint32_t height)
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None: return nullptr;
+		case RendererAPIType::None: return Ref<HazelTextureCube>();
 		case RendererAPIType::OpenGL: return Ref<OpenGLTextureCube>::Create(format, width, height);
 		}
-		return nullptr;
+		return Ref<HazelTextureCube>();
 	}
 
 	Ref<HazelTextureCube> HazelTextureCube::Create(const std::string& path)
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None: return nullptr;
+		case RendererAPIType::None: return Ref<HazelTextureCube>();
 		case RendererAPIType::OpenGL: return Ref<OpenGLTextureCube>::Create(path);
 		}
-		return nullptr;
+		return Ref<HazelTextureCube>();
 	}
 
 	void HazelTexture::SetData(void* data, uint32_t size)

diff --git a/MoravaEngine/src/Hazel/Renderer/IndexBuffer.cpp b/MoravaEngine/src/Hazel/Renderer/IndexBuffer.cpp
@@ -9,22 +9,22 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-			case RendererAPIType::None:    return nullptr;
+			case RendererAPIType::None:    return Ref<IndexBuffer>();
 			case RendererAPIType::OpenGL:  return Ref<OpenGLIndexBuffer>::Create(size);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<IndexBuffer>();
 	}
 
 	Ref<IndexBuffer> IndexBuffer::Create(void* data, uint32_t size)
 	{
 		switch (RendererAPI::Current())
 		{
-			case RendererAPIType::None:    return nullptr;
+			case RendererAPIType::None:    return Ref<IndexBuffer>();
 			case RendererAPIType::OpenGL:  return Ref<OpenGLIndexBuffer>::Create(data, size);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<IndexBuffer>();
 	}
 
 }
diff --git a/MoravaEngine/src/Hazel/Renderer/Pipeline.cpp b/MoravaEngine/src/Hazel/Renderer/Pipeline.cpp
@@ -9,10 +9,10 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-			case RendererAPIType::None:    return nullptr;
+			case RendererAPIType::None:    return Ref<Pipeline>();
 			case RendererAPIType::OpenGL:  return Ref<OpenGLPipeline>::Create(spec);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<Pipeline>();
 	}
 }
diff --git a/MoravaEngine/src/Hazel/Renderer/RenderPass.cpp b/MoravaEngine/src/Hazel/Renderer/RenderPass.cpp
@@ -14,12 +14,12 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None:    HZ_CORE_ASSERT(false, "RendererAPI::None is currently not supported!"); return nullptr;
+		case RendererAPIType::None:    HZ_CORE_ASSERT(false, "RendererAPI::None is currently not supported!"); return Ref<RenderPass>();
 		case RendererAPIType::OpenGL:  return Ref<OpenGLRenderPass>::Create(spec);
 		}
 
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI!");
-		return nullptr;
+		return Ref<RenderPass>();
 	}
 
 }
diff --git a/MoravaEngine/src/Hazel/Renderer/RendererContext.cpp b/MoravaEngine/src/Hazel/Renderer/RendererContext.cpp
@@ -12,12 +12,12 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None:    return nullptr;
+		case RendererAPIType::None:    return Ref<RendererContext>();
 		case RendererAPIType::OpenGL:  return Ref<OpenGLContext>::Create(windowHandle);
 		case RendererAPIType::Vulkan:  return Ref<VulkanContext>::Create(windowHandle);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<RendererContext>();
 	}
 
 }
diff --git a/MoravaEngine/src/Hazel/Renderer/SceneRenderer.cpp b/MoravaEngine/src/Hazel/Renderer/SceneRenderer.cpp
@@ -117,7 +117,7 @@ namespace Hazel {
 
 	void SceneRenderer::SubmitMesh(MeshComponent meshComponent, TransformComponent transformComponent)
 	{
-		SubmitMesh(meshComponent.Mesh, transformComponent.GetTransform(), nullptr);
+		SubmitMesh(meshComponent.Mesh, transformComponent.GetTransform(), Ref<Material>());
 	}
 
 	void SceneRenderer::SubmitSelectedMesh(MeshComponent meshComponent, TransformComponent transformComponent)
@@ -133,7 +133,7 @@ namespace Hazel {
 
 	void SceneRenderer::SubmitSelectedMesh(Ref<Mesh> mesh, const glm::mat4& transform)
 	{
-		s_Data.SelectedMeshDrawList.push_back({ mesh, nullptr, transform });
+		s_Data.SelectedMeshDrawList.push_back({ mesh, Ref<HazelMaterial>(), transform });
 	}
 
 	static Ref<HazelShader> equirectangularConversionShader, envFilteringShader, envIrradianceShader;
@@ -351,7 +351,7 @@ namespace Hazel {
 			const glm::mat4 transform = glm::rotate(glm::mat4(1.0f), glm::radians(90.0f), glm::vec3(1.0f, 0.0f, 0.0f)) * glm::scale(glm::mat4(1.0f), glm::vec3(16.0f));
 			s_Data.GridShader->Bind();
 			s_Data.GridShader->SetUniform("u_VertexUniforms.Transform", transform);
-			HazelRenderer::SubmitQuad(nullptr);
+			HazelRenderer::SubmitQuad(Ref<HazelMaterial>());
 		}
 
 		if (GetOptions().ShowBoundingBoxes)
@@ -376,7 +376,7 @@ namespace Hazel {
 		s_Data.CompositeShader->SetUniform("u_Uniforms.Exposure", exposure);
 		s_Data.CompositeShader->SetUniform("u_Uniforms.TextureSamples", textureSamples);
 		s_Data.GeoPass->GetSpecification().TargetFramebuffer->BindTexture();
-		HazelRenderer::SubmitFullscreenQuad(nullptr);
+		HazelRenderer::SubmitFullscreenQuad(Ref<HazelMaterial>());
 		HazelRenderer::EndRenderPass();
 	}
 

diff --git a/MoravaEngine/src/Hazel/Renderer/VertexArray.cpp b/MoravaEngine/src/Hazel/Renderer/VertexArray.cpp
@@ -9,12 +9,12 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None:    HZ_CORE_ASSERT(false, "RendererAPI::None is currently not supported!"); return nullptr;
+		case RendererAPIType::None:    HZ_CORE_ASSERT(false, "RendererAPI::None is currently not supported!"); return Ref<VertexArray>();
 		case RendererAPIType::OpenGL:  return Ref<OpenGLVertexArray>::Create();
 		}
 
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<VertexArray>();
 	}
 
 }
diff --git a/MoravaEngine/src/Hazel/Renderer/VertexBuffer.cpp b/MoravaEngine/src/Hazel/Renderer/VertexBuffer.cpp
@@ -9,22 +9,22 @@ namespace Hazel {
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None:    return nullptr;
+		case RendererAPIType::None:    return Ref<VertexBuffer>();
 		case RendererAPIType::OpenGL:  return Ref<OpenGLVertexBuffer>::Create(data, size, usage);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<VertexBuffer>();
 	}
 
 	Ref<VertexBuffer> VertexBuffer::Create(uint32_t size, VertexBufferUsage usage)
 	{
 		switch (RendererAPI::Current())
 		{
-		case RendererAPIType::None:    return nullptr;
+		case RendererAPIType::None:    return Ref<VertexBuffer>();
 		case RendererAPIType::OpenGL:  return Ref<OpenGLVertexBuffer>::Create(size, usage);
 		}
 		HZ_CORE_ASSERT(false, "Unknown RendererAPI");
-		return nullptr;
+		return Ref<VertexBuffer>();
 	}
 
 }
diff --git a/MoravaEngine/src/Hazel/Script/ScriptWrappers.cpp b/MoravaEngine/src/Hazel/Script/ScriptWrappers.cpp
@@ -146,7 +146,7 @@ namespace Hazel { namespace Script {
 
 		Entity entity = Entity{ entityMap.at(entityID), scene.Raw() };
 		auto& meshComponent = entity.GetComponent<MeshComponent>();
-		meshComponent.Mesh = inMesh ? *inMesh : nullptr;
+		meshComponent.Mesh = inMesh ? *inMesh : Hazel::Ref<Hazel::HazelMesh>();
 	}
 
 	void Hazel_RigidBody2DComponent_ApplyLinearImpulse(uint64_t entityID, glm::vec2* impulse, glm::vec2* offset, bool wake)

diff --git a/MoravaEngine/src/Material/Material.cpp b/MoravaEngine/src/Material/Material.cpp
@@ -5,7 +5,7 @@
 #include <GL/glew.h>
 
 
-Material::Material() : Hazel::HazelMaterial(nullptr)
+Material::Material() : Hazel::HazelMaterial(Hazel::Ref<Hazel::HazelShader>())
 {
 	m_SpecularIntensity = 0.0f;
 	m_Shininess = 0.0f;

diff --git a/MoravaEngine/src/Material/MaterialLibrary.cpp b/MoravaEngine/src/Material/MaterialLibrary.cpp
@@ -59,7 +59,7 @@ Hazel::Ref<MaterialData> MaterialLibrary::CreateMaterialData(std::string name, H
 
     Hazel::Ref<EnvMapMaterial> defaultEnvMapMaterial = MaterialLibrary::CreateDefaultMaterial(materialData->Name);
     AddEnvMapMaterial(defaultEnvMapMaterial->GetUUID(), defaultEnvMapMaterial);
-    materialData->EnvMapMaterial = defaultEnvMapMaterial;
+    materialData->EnvMapMaterialRef = defaultEnvMapMaterial;
 
     return materialData;
 }
@@ -253,12 +253,12 @@ void MaterialLibrary::SetMaterialsToSubmeshes(Hazel::Ref<Hazel::HazelMesh> mesh,
         // Let's try to detect a correct material from the list of loaded materials in MaterialLibrary
         for (auto materialData : s_MaterialData)
         {
-            if (materialData->Submesh != nullptr && materialData->EnvMapMaterial)
+            if (materialData->Submesh != nullptr && materialData->EnvMapMaterialRef)
             {
                 if (submesh.MeshName == materialData->Submesh->MeshName)
                 {
                     SubmeshUUID submeshUUID = GetSubmeshUUID(&entity, &submesh);
-                    MaterialUUID materialUUID = materialData->EnvMapMaterial->GetUUID();
+                    MaterialUUID materialUUID = materialData->EnvMapMaterialRef->GetUUID();
                     MaterialLibrary::AddSubmeshMaterialRelation(submeshUUID, materialUUID);
                     correctMaterialFound = true;
                     break;
@@ -321,4 +321,3 @@ MaterialUUID MaterialLibrary::GetSubmeshMaterialUUID(Hazel::Ref<Hazel::HazelMesh
 
     return materialUUID;
 }
-
diff --git a/MoravaEngine/src/Shader/Shader.cpp b/MoravaEngine/src/Shader/Shader.cpp
@@ -55,11 +55,11 @@ Shader::Shader(const char* computeLocation, bool forceCompile)
 
 Hazel::Ref<Shader> Shader::Create(const char* vertexLocation, const char* fragmentLocation, bool forceCompile)
 {
-	Hazel::Ref<Shader> result = nullptr;
+	Hazel::Ref<Shader> result = Hazel::Ref<Shader>();
 
 	switch (Hazel::RendererAPI::Current())
 	{
-	case Hazel::RendererAPIType::None: return nullptr;
+	case Hazel::RendererAPIType::None: return Hazel::Ref<Shader>();
 	case Hazel::RendererAPIType::OpenGL:
 		result = Hazel::Ref<Shader>::Create(vertexLocation, fragmentLocation, forceCompile);
 		break;
@@ -73,11 +73,11 @@ Hazel::Ref<Shader> Shader::Create(const char* vertexLocation, const char* fragme
 
 Hazel::Ref<Shader> Shader::Create(const char* vertexLocation, const char* geometryLocation, const char* fragmentLocation, bool forceCompile)
 {
-	Hazel::Ref<Shader> result = nullptr;
+	Hazel::Ref<Shader> result = Hazel::Ref<Shader>();
 
 	switch (Hazel::RendererAPI::Current())
 	{
-	case Hazel::RendererAPIType::None: return nullptr;
+	case Hazel::RendererAPIType::None: return Hazel::Ref<Shader>();
 	case Hazel::RendererAPIType::OpenGL:
 		result = Hazel::Ref<Shader>::Create(vertexLocation, geometryLocation, fragmentLocation, forceCompile);
 		break;
@@ -91,11 +91,11 @@ Hazel::Ref<Shader> Shader::Create(const char* vertexLocation, const char* geomet
 
 Hazel::Ref<Shader> Shader::Create(const char* computeLocation, bool forceCompile)
 {
-	Hazel::Ref<Shader> result = nullptr;
+	Hazel::Ref<Shader> result = Hazel::Ref<Shader>();
 
 	switch (Hazel::RendererAPI::Current())
 	{
-	case Hazel::RendererAPIType::None: return nullptr;
+	case Hazel::RendererAPIType::None: return Hazel::Ref<Shader>();
 	case Hazel::RendererAPIType::OpenGL:
 		result = Hazel::Ref<Shader>::Create(computeLocation, forceCompile);
 		break;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -22,5 +22,4 @@ namespace Hazel {
		std::string m_Tag;
		};


		}