GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'Geometry & GeometryFactory memory leaks' (#85) from geometry_mem_leaks into master

Browse Source 
Reviewed-on: https://git.madvoxel.net/OpenVulkano/OpenVulkano/pulls/85
Reviewed-by: Georg Hagen <georg.hagen@madvoxel.com>
This commit is contained in:
Georg Hagen
2024-07-24 20:44:27 +02:00
parent a1babfe978 10d6240555
commit 6a1a76f4d1
10 changed files with 257 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
openVulkanoCpp/Scene/Geometry.cpp
View File

@@ -19,6 +19,102 @@
namespace OpenVulkano::Scene
{
Geometry::Geometry(const Geometry& other)
{
this->vertexCount = other.vertexCount;
this->indexCount = other.indexCount;
this->indexType = other.indexType;
this->aabb = other.aabb;
this->ownsMemory = other.ownsMemory;
this->freeAfterUpload = other.freeAfterUpload;
this->renderGeo = nullptr;
this->vertices = new Vertex[vertexCount];
if (other.vertices)
{
std::copy(other.vertices, other.vertices + other.vertexCount, this->vertices);
}
this->indices = malloc(static_cast<size_t>(Utils::EnumAsInt(other.indexType)) * other.indexCount);
if (other.indices)
{
if (other.indexType == VertexIndexType::UINT16)
{
std::copy(static_cast<uint16_t*>(other.indices),
static_cast<uint16_t*>(other.indices) + other.indexCount,
static_cast<uint16_t*>(this->indices));
}
else
{
std::copy(static_cast<uint32_t*>(other.indices),
static_cast<uint32_t*>(other.indices) + other.indexCount,
static_cast<uint32_t*>(this->indices));
}
}
}
Geometry& Geometry::operator=(const Geometry& other)
{
Geometry tmp(other);
this->Swap(tmp);
return *this;
}
Geometry::Geometry(Geometry&& other) noexcept
{
this->vertexCount = other.vertexCount;
this->indexCount = other.indexCount;
this->indexType = other.indexType;
this->ownsMemory = other.ownsMemory;
this->freeAfterUpload = other.freeAfterUpload;
this->aabb = std::move(other.aabb);
this->vertices = other.vertices;
this->indices = other.indices;
this->renderGeo = other.renderGeo;
other.vertexCount = other.indexCount = 0;
other.vertices = nullptr;
other.indices = nullptr;
other.renderGeo = nullptr;
}
Geometry& Geometry::operator=(Geometry&& other) noexcept
{
if (this != &other)
{
Close();
this->vertexCount = other.vertexCount;
this->indexCount = other.indexCount;
this->indexType = other.indexType;
this->ownsMemory = other.ownsMemory;
this->freeAfterUpload = other.freeAfterUpload;
this->aabb = std::move(other.aabb);
this->vertices = other.vertices;
this->indices = other.indices;
this->renderGeo = other.renderGeo;
other.vertexCount = other.indexCount = 0;
other.vertices = nullptr;
other.indices = nullptr;
other.renderGeo = nullptr;
}
return *this;
}
Geometry::~Geometry()
{
Geometry::Close();
}
void Geometry::Swap(Geometry& other) noexcept
{
std::swap(this->vertexCount, other.vertexCount);
std::swap(this->indexCount, other.indexCount);
std::swap(this->aabb, other.aabb);
std::swap(this->indexType, other.indexType);
std::swap(this->vertices, other.vertices);
std::swap(this->indices, other.indices);
std::swap(this->renderGeo, other.renderGeo);
std::swap(this->ownsMemory, other.ownsMemory);
std::swap(this->freeAfterUpload, other.freeAfterUpload);
}
void Geometry::Init(uint32_t vertexCount, uint32_t indexCount)
{
if (this->vertexCount || this->indexCount) throw std::runtime_error("Geometry is already initialized.");
@@ -110,11 +206,17 @@ namespace OpenVulkano::Scene
void Geometry::Close()
{
vertexCount = 0;
indexCount = 0;
Free();
renderGeo->Close();
renderGeo = nullptr;
if (ownsMemory)
{
vertexCount = 0;
indexCount = 0;
Free();
}
if (renderGeo)
{
renderGeo->Close();
renderGeo = nullptr;
}
}
void Geometry::Free()

44
openVulkanoCpp/Scene/Geometry.hpp
View File

@@ -8,6 +8,7 @@
#include "Base/ICloseable.hpp"
#include "Math/AABB.hpp"
#include "Base/Utils.hpp"
#include <string>
class aiMesh;
@@ -27,18 +28,19 @@ namespace OpenVulkano
{
public:
uint32_t vertexCount = 0, indexCount = 0;
Vertex* vertices;
void* indices;
VertexIndexType indexType;
Vertex* vertices = nullptr;
void* indices = nullptr;
VertexIndexType indexType = VertexIndexType::UINT16;
bool ownsMemory = true, freeAfterUpload = true;
Math::AABB aabb;
ICloseable* renderGeo = nullptr;
Vertex* GetVertices() const { return vertices; }
void* GetIndices() const { return indices; }
uint16_t* GetIndices16() const { return static_cast<uint16_t*>(indices); }
uint32_t* GetIndices32() const { return static_cast<uint32_t*>(indices); }
uint32_t GetIndexCount() const { return indexCount; }
uint32_t GetVertexCount() const { return vertexCount; }
public:
Geometry() = default;
Geometry(const Geometry& other);
Geometry& operator=(const Geometry& other);
Geometry(Geometry&& other) noexcept;
Geometry& operator=(Geometry&& other) noexcept;
~Geometry();
static Geometry* LoadFromFile(const std::string& file)
{
@@ -47,13 +49,6 @@ namespace OpenVulkano
return mesh;
}
Geometry() : vertexCount(0), indexCount(0), vertices(nullptr), indices(nullptr), indexType(VertexIndexType::UINT16) {}
~Geometry()
{
if (vertices) Geometry::Close();
}
void InitFromFile(const std::string& file);
/**
@@ -68,8 +63,21 @@ namespace OpenVulkano
void SetIndices(const uint32_t* data, uint32_t size, uint32_t offset = 0) const;
void Close() override;
void Free();
Vertex* GetVertices() const { return vertices; }
void* GetIndices() const { return indices; }
uint16_t* GetIndices16() const { return static_cast<uint16_t*>(indices); }
uint32_t* GetIndices32() const { return static_cast<uint32_t*>(indices); }
uint32_t GetIndexCount() const { return indexCount; }
uint32_t GetVertexCount() const { return vertexCount; }
bool OwnsMemory() const { return ownsMemory; }
void SetOwnsMemory(bool val) { ownsMemory = val; }
bool FreeAfterUpload() const { return freeAfterUpload; }
void SetFreeAfterUpload(bool val) { freeAfterUpload = val; }
private:
void Swap(Geometry& other) noexcept;
};
}
}

161
openVulkanoCpp/Scene/GeometryFactory.cpp
View File

@@ -13,11 +13,11 @@
namespace OpenVulkano::Scene
{
Geometry* GeometryFactory::MakeCube(float x, float y, float z, const Math::Vector4f& color)
Geometry GeometryFactory::MakeCube(float x, float y, float z, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
Geometry result;
const int indexCount = 36;
result->Init(24, indexCount);
result.Init(24, indexCount);
uint32_t indices[indexCount] =
{
0, 1, 2, 0, 2, 3, // front face index data
@@ -27,78 +27,77 @@ namespace OpenVulkano::Scene
16, 17, 18, 16, 18, 19, // left face index data
20, 21, 22, 20, 22, 23 // right face index data
};
result->SetIndices(indices, result->indexCount);
result.SetIndices(indices, result.indexCount);
x *= 0.5f; y *= 0.5f; z *= 0.5f;
uint32_t i = 0;
// front face vertex data
result->vertices[i++].Set(+x, -y, +z, +0, +0, +1, +0, +1);
result->vertices[i++].Set(+x, +y, +z, +0, +0, +1, +0, +0);
result->vertices[i++].Set(-x, +y, +z, +0, +0, +1, +1, +0);
result->vertices[i++].Set(-x, -y, +z, +0, +0, +1, +1, +1);
result.vertices[i++].Set(+x, -y, +z, +0, +0, +1, +0, +1);
result.vertices[i++].Set(+x, +y, +z, +0, +0, +1, +0, +0);
result.vertices[i++].Set(-x, +y, +z, +0, +0, +1, +1, +0);
result.vertices[i++].Set(-x, -y, +z, +0, +0, +1, +1, +1);
// back face vertex data
result->vertices[i++].Set(+x, -y, -z, +0, +0, -1, +1, +1);
result->vertices[i++].Set(-x, -y, -z, +0, +0, -1, +0, +1);
result->vertices[i++].Set(-x, +y, -z, +0, +0, -1, +0, +0);
result->vertices[i++].Set(+x, +y, -z, +0, +0, -1, +1, +0);
result.vertices[i++].Set(+x, -y, -z, +0, +0, -1, +1, +1);
result.vertices[i++].Set(-x, -y, -z, +0, +0, -1, +0, +1);
result.vertices[i++].Set(-x, +y, -z, +0, +0, -1, +0, +0);
result.vertices[i++].Set(+x, +y, -z, +0, +0, -1, +1, +0);
// top face vertex data
result->vertices[i++].Set(+x, +y, +z, +0, -1, +0, +0, +1);
result->vertices[i++].Set(+x, +y, -z, +0, -1, +0, +0, +0);
result->vertices[i++].Set(-x, +y, -z, +0, -1, +0, +1, +0);
result->vertices[i++].Set(-x, +y, +z, +0, -1, +0, +1, +1);
result.vertices[i++].Set(+x, +y, +z, +0, -1, +0, +0, +1);
result.vertices[i++].Set(+x, +y, -z, +0, -1, +0, +0, +0);
result.vertices[i++].Set(-x, +y, -z, +0, -1, +0, +1, +0);
result.vertices[i++].Set(-x, +y, +z, +0, -1, +0, +1, +1);
// bottom face vertex data
result->vertices[i++].Set(+x, -y, +z, +0, +1, +0, +1, +1);
result->vertices[i++].Set(-x, -y, +z, +0, +1, +0, +0, +1);
result->vertices[i++].Set(-x, -y, -z, +0, +1, +0, +0, +0);
result->vertices[i++].Set(+x, -y, -z, +0, +1, +0, +1, +0);
result.vertices[i++].Set(+x, -y, +z, +0, +1, +0, +1, +1);
result.vertices[i++].Set(-x, -y, +z, +0, +1, +0, +0, +1);
result.vertices[i++].Set(-x, -y, -z, +0, +1, +0, +0, +0);
result.vertices[i++].Set(+x, -y, -z, +0, +1, +0, +1, +0);
// Fill in the left face vertex data
result->vertices[i++].Set(-x, -y, -z, -1, +0, +0, +1, +1);
result->vertices[i++].Set(-x, -y, +z, -1, +0, +0, +0, +1);
result->vertices[i++].Set(-x, +y, +z, -1, +0, +0, +0, +0);
result->vertices[i++].Set(-x, +y, -z, -1, +0, +0, +1, +0);
result.vertices[i++].Set(-x, -y, -z, -1, +0, +0, +1, +1);
result.vertices[i++].Set(-x, -y, +z, -1, +0, +0, +0, +1);
result.vertices[i++].Set(-x, +y, +z, -1, +0, +0, +0, +0);
result.vertices[i++].Set(-x, +y, -z, -1, +0, +0, +1, +0);
// Fill in the right face vertex data
result->vertices[i++].Set(+x, -y, +z, +1, +0, +0, +1, +1);
result->vertices[i++].Set(+x, -y, -z, +1, +0, +0, +0, +1);
result->vertices[i++].Set(+x, +y, -z, +1, +0, +0, +0, +0);
result->vertices[i].Set(+x, +y, +z, +1, +0, +0, +1, +0);
result.vertices[i++].Set(+x, -y, +z, +1, +0, +0, +1, +1);
result.vertices[i++].Set(+x, -y, -z, +1, +0, +0, +0, +1);
result.vertices[i++].Set(+x, +y, -z, +1, +0, +0, +0, +0);
result.vertices[i].Set(+x, +y, +z, +1, +0, +0, +1, +0);
for(i = 0; i < result->vertexCount; i++)
for(i = 0; i < result.vertexCount; i++)
{
result->vertices[i].color = color;
result.vertices[i].color = color;
}
return result;
}
Geometry* GeometryFactory::MakePlane(float width, float height, const Math::Vector4f& color)
Geometry GeometryFactory::MakePlane(float width, float height, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
result->Init(4, 6);
Geometry result;
result.Init(4, 6);
uint32_t indices[] = { 0, 2, 1, 0, 3, 2 };
result->SetIndices(indices, result->indexCount);
result.SetIndices(indices, result.indexCount);
width *= 0.5f; height *= 0.5f;
result->vertices[0].Set(-width, -height, 0, 0, 0, 1, 0, 1);
result->vertices[1].Set(-width, height, 0, 0, 0, 1, 0, 0);
result->vertices[2].Set(width, height, 0, 0, 0, 1, 1, 0);
result->vertices[3].Set(width, -height, 0, 0, 0, 1, 1, 1);
result.vertices[0].Set(-width, -height, 0, 0, 0, 1, 0, 1);
result.vertices[1].Set(-width, height, 0, 0, 0, 1, 0, 0);
result.vertices[2].Set(width, height, 0, 0, 0, 1, 1, 0);
result.vertices[3].Set(width, -height, 0, 0, 0, 1, 1, 1);
for (uint32_t i = 0; i < result->vertexCount; i++)
for (uint32_t i = 0; i < result.vertexCount; i++)
{
result->vertices[i].color = color;
result.vertices[i].color = color;
}
return result;
}
Geometry* GeometryFactory::MakeSphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color)
Geometry GeometryFactory::MakeSphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
Geometry result;
uint32_t vertexCount = (rings + 1) * (segments + 1);
uint32_t indexCount = 6 * rings * segments;
result->Init(vertexCount, indexCount);
result.Init(vertexCount, indexCount);
uint32_t i = 0;
for (uint32_t ring = 0; ring <= rings; ++ring)
@@ -119,8 +118,8 @@ namespace OpenVulkano::Scene
float u = 1 - (float(segment) / segments);
float v = float(ring) / rings;
result->vertices[i].Set(radius * x, radius * y, radius * z, x, y, z, u, v);
result->vertices[i].color = color;
result.vertices[i].Set(radius * x, radius * y, radius * z, x, y, z, u, v);
result.vertices[i].color = color;
++i;
}
}
@@ -143,18 +142,18 @@ namespace OpenVulkano::Scene
indices[i++] = second + 1;
}
}
result->SetIndices(indices, indexCount);
result.SetIndices(indices, indexCount);
delete[] indices;
return result;
}
Geometry* GeometryFactory::MakeHemisphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color)
Geometry GeometryFactory::MakeHemisphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
Geometry result;
uint32_t vertexCount = (rings + 1) * (segments + 1);
uint32_t indexCount = 6 * rings * segments;
result->Init(vertexCount, indexCount);
result.Init(vertexCount, indexCount);
uint32_t i = 0;
for (uint32_t ring = 0; ring <= rings; ++ring)
@@ -175,8 +174,8 @@ namespace OpenVulkano::Scene
float u = 1 - (float(segment) / segments);
float v = float(ring) / rings;
result->vertices[i].Set(radius * x, radius * y, radius * z, x, y, z, u, v);
result->vertices[i].color = color;
result.vertices[i].Set(radius * x, radius * y, radius * z, x, y, z, u, v);
result.vertices[i].color = color;
++i;
}
}
@@ -199,37 +198,37 @@ namespace OpenVulkano::Scene
indices[i++] = second + 1;
}
}
result->SetIndices(indices, indexCount);
result.SetIndices(indices, indexCount);
delete[] indices;
return result;
}
Geometry* GeometryFactory::MakeTriangle(const Math::Vector3f& p1, const Math::Vector3f& p2, const Math::Vector3f& p3, const Math::Vector4f& color)
Geometry GeometryFactory::MakeTriangle(const Math::Vector3f& p1, const Math::Vector3f& p2, const Math::Vector3f& p3, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
result->Init(3, 3);
Geometry result;
result.Init(3, 3);
uint32_t indices[] = { 0, 1, 2 };
result->SetIndices(indices, result->indexCount);
result.SetIndices(indices, result.indexCount);
result->vertices[0].Set(p1.x, p1.y, p1.z, 0, 0, 1, 0, 0);
result->vertices[1].Set(p2.x, p2.y, p2.z, 0, 0, 1, 1, 0);
result->vertices[2].Set(p3.x, p3.y, p3.z, 0, 0, 1, 0, 1);
result.vertices[0].Set(p1.x, p1.y, p1.z, 0, 0, 1, 0, 0);
result.vertices[1].Set(p2.x, p2.y, p2.z, 0, 0, 1, 1, 0);
result.vertices[2].Set(p3.x, p3.y, p3.z, 0, 0, 1, 0, 1);
for (uint32_t i = 0; i < result->vertexCount; i++)
for (uint32_t i = 0; i < result.vertexCount; i++)
{
result->vertices[i].color = color;
result.vertices[i].color = color;
}
return result;
}
Geometry* GeometryFactory::MakeCylinder(float radius, float height, uint32_t segments, const Math::Vector4f& color)
Geometry GeometryFactory::MakeCylinder(float radius, float height, uint32_t segments, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
Geometry result;
uint32_t vertexCount = 2 * (segments + 1);
uint32_t indexCount = 12 * segments;
result->Init(vertexCount, indexCount);
result.Init(vertexCount, indexCount);
float halfHeight = height * 0.5f;
uint32_t i = 0;
@@ -240,10 +239,10 @@ namespace OpenVulkano::Scene
float z = radius * sin(theta);
float u = float(segment) / segments;
result->vertices[i].Set(x, -halfHeight, z, x, 0, z, u, 0);
result->vertices[i++].color = color;
result->vertices[i].Set(x, halfHeight, z, x, 0, z, u, 1);
result->vertices[i++].color = color;
result.vertices[i].Set(x, -halfHeight, z, x, 0, z, u, 0);
result.vertices[i++].color = color;
result.vertices[i].Set(x, halfHeight, z, x, 0, z, u, 1);
result.vertices[i++].color = color;
}
i = 0;
@@ -269,16 +268,16 @@ namespace OpenVulkano::Scene
indices[i++] = first;
indices[i++] = second + 2;
}
result->SetIndices(indices, indexCount);
result.SetIndices(indices, indexCount);
delete[] indices;
return result;
}
Geometry* GeometryFactory::MakePyramid(float baseLength, float height, const Math::Vector4f& color)
Geometry GeometryFactory::MakePyramid(float baseLength, float height, const Math::Vector4f& color)
{
Geometry* result = new Geometry();
result->Init(5, 18);
Geometry result;
result.Init(5, 18);
uint32_t indices[] = {
// Base
1, 2, 3,
@@ -289,21 +288,21 @@ namespace OpenVulkano::Scene
0, 3, 4,
0, 4, 1
};
result->SetIndices(indices, result->indexCount);
result.SetIndices(indices, result.indexCount);
float halfBase = baseLength * 0.5f;
// Top vertex
result->vertices[0].Set(0, height, 0, 0, 1, 0, 0.5f, 1);
result.vertices[0].Set(0, height, 0, 0, 1, 0, 0.5f, 1);
// Base vertices
result->vertices[1].Set(-halfBase, 0, halfBase, 0, -1, 0, 0, 0);
result->vertices[2].Set(halfBase, 0, halfBase, 0, -1, 0, 1, 0);
result->vertices[3].Set(halfBase, 0, -halfBase, 0, -1, 0, 1, 1);
result->vertices[4].Set(-halfBase, 0, -halfBase, 0, -1, 0, 0, 1);
result.vertices[1].Set(-halfBase, 0, halfBase, 0, -1, 0, 0, 0);
result.vertices[2].Set(halfBase, 0, halfBase, 0, -1, 0, 1, 0);
result.vertices[3].Set(halfBase, 0, -halfBase, 0, -1, 0, 1, 1);
result.vertices[4].Set(-halfBase, 0, -halfBase, 0, -1, 0, 0, 1);
for (uint32_t i = 0; i < result->vertexCount; i++)
for (uint32_t i = 0; i < result.vertexCount; i++)
{
result->vertices[i].color = color;
result.vertices[i].color = color;
}
return result;

14
openVulkanoCpp/Scene/GeometryFactory.hpp
View File

@@ -13,12 +13,12 @@ namespace OpenVulkano::Scene
class GeometryFactory
{
public:
static Geometry* MakeCube(float x = 1, float y = 1, float z = 1, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakePlane(float width = 1, float height = 1, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakeSphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakeHemisphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakeTriangle(const Math::Vector3f& p1, const Math::Vector3f& p2, const Math::Vector3f& p3, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakeCylinder(float radius, float height, uint32_t segments, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry* MakePyramid(float baseLength = 1, float height = 1, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakeCube(float x = 1, float y = 1, float z = 1, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakePlane(float width = 1, float height = 1, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakeSphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakeHemisphere(float radius, uint32_t segments, uint32_t rings, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakeTriangle(const Math::Vector3f& p1, const Math::Vector3f& p2, const Math::Vector3f& p3, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakeCylinder(float radius, float height, uint32_t segments, const Math::Vector4f& color = Math::Vector4f(1));
static Geometry MakePyramid(float baseLength = 1, float height = 1, const Math::Vector4f& color = Math::Vector4f(1));
};
}