Skip to content

Add MeshUnmanaged (#299) #304

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 9, 2024
Merged

Add MeshUnmanaged (#299) #304

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion examples/models/models_first_person_maze.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ int main(void)

raylib::Image imMap("resources/cubicmap.png"); // Load cubicmap image (RAM)
raylib::Texture cubicmap(imMap); // Convert image to texture to display (VRAM)
Mesh mesh = raylib::Mesh::Cubicmap(imMap, Vector3{ 1.0f, 1.0f, 1.0f });
raylib::MeshUnmanaged mesh = raylib::MeshUnmanaged::Cubicmap(imMap, Vector3{ 1.0f, 1.0f, 1.0f }); // Use MeshUnmanaged, Mesh will be handled by Model
raylib::Model model(mesh);
Copy link
Owner

@RobLoach RobLoach Mar 9, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for taking this on! Definitely does make sense since Model ends up taking ownership of the Model.

In addition to having MeshUnmanaged, I think having an overloaded method for raylib::Model(raylib::Mesh) that creates a copy of the Mesh as MeshUnmanaged, and uses that. This way the example code wouldn't need to change, but memory would still be 👌

Copy link
Owner

@RobLoach RobLoach Mar 9, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I'll merge this forwards, and then we can take it on as a follow up PR.


// NOTE: By default each cube is mapped to one part of texture atlas
Expand Down
233 changes: 17 additions & 216 deletions include/Mesh.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,28 +8,33 @@
#include "./raylib-cpp-utils.hpp"
#include "./BoundingBox.hpp"
#include "./Model.hpp"
#include "./MeshUnmanaged.hpp"

namespace raylib {
/**
* Vertex data definning a mesh
* Vertex data defining a mesh
*
* The Mesh will be unloaded on object destruction.
*
* @see raylib::MeshUnmanaged
*/
class Mesh : public ::Mesh {
class Mesh : public MeshUnmanaged {
public:
Mesh(const ::Mesh& mesh) {
set(mesh);
}
using MeshUnmanaged::MeshUnmanaged;

/**
* Load meshes from model file
* Explicitly forbid the copy constructor.
*/
// static std::vector<Mesh> Load(const std::string& fileName) {
// int count = 0;
// ::Mesh* meshes = LoadMeshes(fileName.c_str(), &count);
// return std::vector<Mesh>(meshes, meshes + count);
// }

Mesh(const Mesh&) = delete;

/**
* Explicitly forbid copy assignment.
*/
Mesh& operator=(const Mesh&) = delete;

/**
* Move constructor.
*/
Mesh(Mesh&& other) {
set(other);

Expand All @@ -50,106 +55,6 @@ class Mesh : public ::Mesh {
other.vboId = nullptr;
}

/**
* Generate polygonal mesh
*/
static ::Mesh Poly(int sides, float radius) {
return ::GenMeshPoly(sides, radius);
}

/**
* Generate plane mesh (with subdivisions)
*/
static ::Mesh Plane(float width, float length, int resX, int resZ) {
return ::GenMeshPlane(width, length, resX, resZ);
}

/**
* Generate cuboid mesh
*/
static ::Mesh Cube(float width, float height, float length) {
return ::GenMeshCube(width, height, length);
}

/**
* Generate sphere mesh (standard sphere)
*/
static ::Mesh Sphere(float radius, int rings, int slices) {
return ::GenMeshSphere(radius, rings, slices);
}

/**
* Generate half-sphere mesh (no bottom cap)
*/
static ::Mesh HemiSphere(float radius, int rings, int slices) {
return ::GenMeshHemiSphere(radius, rings, slices);
}

/**
* Generate cylinder mesh
*/
static ::Mesh Cylinder(float radius, float height, int slices) {
return ::GenMeshCylinder(radius, height, slices);
}

/**
* Generate cone/pyramid mesh
*/
static ::Mesh Cone(float radius, float height, int slices) {
return ::GenMeshCone(radius, height, slices);
}

/**
* Generate torus mesh
*/
static ::Mesh Torus(float radius, float size, int radSeg, int sides) {
return ::GenMeshTorus(radius, size, radSeg, sides);
}

/**
* Generate trefoil knot mesh
*/
static ::Mesh Knot(float radius, float size, int radSeg, int sides) {
return ::GenMeshKnot(radius, size, radSeg, sides);
}

/**
* Generate heightmap mesh from image data
*/
static ::Mesh Heightmap(const ::Image& heightmap, ::Vector3 size) {
return ::GenMeshHeightmap(heightmap, size);
}

/**
* Generate cubes-based map mesh from image data
*/
static ::Mesh Cubicmap(const ::Image& cubicmap, ::Vector3 cubeSize) {
return ::GenMeshCubicmap(cubicmap, cubeSize);
}

GETTERSETTER(int, VertexCount, vertexCount)
GETTERSETTER(int, TriangleCount, triangleCount)
GETTERSETTER(float*, Vertices, vertices)
GETTERSETTER(float *, TexCoords, texcoords)
GETTERSETTER(float *, TexCoords2, texcoords2)
GETTERSETTER(float *, Normals, normals)
GETTERSETTER(float *, Tangents, tangents)
GETTERSETTER(unsigned char *, Colors, colors)
GETTERSETTER(unsigned short *, Indices, indices) // NOLINT
GETTERSETTER(float *, AnimVertices, animVertices)
GETTERSETTER(float *, AnimNormals, animNormals)
GETTERSETTER(unsigned char *, BoneIds, boneIds)
GETTERSETTER(float *, BoneWeights, boneWeights)
GETTERSETTER(unsigned int, VaoId, vaoId)
GETTERSETTER(unsigned int *, VboId, vboId)

Mesh& operator=(const ::Mesh& mesh) {
set(mesh);
return *this;
}

Mesh& operator=(const Mesh&) = delete;

Mesh& operator=(Mesh&& other) noexcept {
if (this == &other) {
return *this;
Expand Down Expand Up @@ -180,110 +85,6 @@ class Mesh : public ::Mesh {
~Mesh() {
Unload();
}

/**
* Upload mesh vertex data to GPU (VRAM)
*/
void Upload(bool dynamic = false) {
::UploadMesh(this, dynamic);
}

/**
* Upload mesh vertex data to GPU (VRAM)
*/
void UpdateBuffer(int index, void *data, int dataSize, int offset = 0) {
::UpdateMeshBuffer(*this, index, data, dataSize, offset);
}

/**
* Draw a 3d mesh with material and transform
*/
void Draw(const ::Material& material, const ::Matrix& transform) const {
::DrawMesh(*this, material, transform);
}

/**
* Draw multiple mesh instances with material and different transforms
*/
void Draw(const ::Material& material, ::Matrix* transforms, int instances) const {
::DrawMeshInstanced(*this, material, transforms, instances);
}

/**
* Export mesh data to file
*
* @throws raylib::RaylibException Throws if failed to export the Mesh.
*/
void Export(const std::string& fileName) {
if (!::ExportMesh(*this, fileName.c_str())) {
throw RaylibException("Failed to export the Mesh");
}
}

/**
* Unload mesh from memory (RAM and/or VRAM)
*/
void Unload() {
if (vboId != nullptr) {
::UnloadMesh(*this);
vboId = nullptr;
}
}

/**
* Compute mesh bounding box limits
*/
raylib::BoundingBox BoundingBox() const {
return ::GetMeshBoundingBox(*this);
}

/**
* Compute mesh bounding box limits
*/
operator raylib::BoundingBox() {
return BoundingBox();
}

/**
* Compute mesh tangents
*/
Mesh& GenTangents() {
::GenMeshTangents(this);
return *this;
}

/**
* Load model from generated mesh
*/
raylib::Model LoadModelFrom() const {
return ::LoadModelFromMesh(*this);
}

/**
* Load model from generated mesh
*/
operator raylib::Model() {
return ::LoadModelFromMesh(*this);
}

protected:
void set(const ::Mesh& mesh) {
vertexCount = mesh.vertexCount;
triangleCount = mesh.triangleCount;
vertices = mesh.vertices;
texcoords = mesh.texcoords;
texcoords2 = mesh.texcoords2;
normals = mesh.normals;
tangents = mesh.tangents;
colors = mesh.colors;
indices = mesh.indices;
animVertices = mesh.animVertices;
animNormals = mesh.animNormals;
boneIds = mesh.boneIds;
boneWeights = mesh.boneWeights;
vaoId = mesh.vaoId;
vboId = mesh.vboId;
}
};
} // namespace raylib

Expand Down
Loading