Elevate::Mesh Class Reference

#include <Mesh.h>

Public Member Functions
	Mesh ()=default
	Mesh (const MeshData &data)
	Mesh (const std::vector< Vertex > &vertices, const std::vector< uint32_t > &indices, const std::vector< std::shared_ptr< Texture > > &textures)
std::shared_ptr< VertexBuffer >	GetVertexBuffer () const
std::shared_ptr< IndexBuffer >	GetIndexBuffer () const
std::shared_ptr< VertexArray >	GetVertexArray () const
const std::vector< std::shared_ptr< Texture > > &	GetTextures () const

Static Public Member Functions
static Mesh *	Create (const MeshData &data)
static Mesh *	Create (std::vector< Vertex > &vertices, std::vector< uint32_t > &indices, std::vector< std::shared_ptr< Texture > > &textures)
static Mesh	GenerateCube (float size=1.0f)
static Mesh	GenerateUVSphere (float radius, int latitudes, int longitudes)
static Mesh	GenerateCubephere (float radius, int subdivision)
static Mesh	GenerateQuad (float size=1.0f)
static Mesh	GeneratePlane (float size, int resolution)
static Mesh	CombineMeshes (std::vector< Mesh > &meshes)

Detailed Description

Definition at line 40 of file Mesh.h.

Constructor & Destructor Documentation

Mesh() [1/3]

Elevate::Mesh::Mesh ( )

default

Mesh() [2/3]

Elevate::Mesh::Mesh

(

const MeshData &

data

)

Definition at line 12 of file Mesh.cpp.

        : m_data(data)
    {
        // Creating the Layout and the VertexBuffer
        m_VertexBuffer.reset(VertexBuffer::Create(&data.Vertices[0], (uint32_t)data.Vertices.size() * sizeof(Vertex)));
        // Creating the layout sent to the shader and the layout of the buffer
        m_VertexBuffer->SetLayout({ // The layout is based on the Vertex struct (see Vertex.h)
            { ShaderDataType::Float3, "a_Position" },
            { ShaderDataType::Float3, "a_Normal" },
            { ShaderDataType::Float2, "a_TexCord" },
            { ShaderDataType::Float3, "a_Tangent" },
            { ShaderDataType::Float3, "a_Bitangent" }
        });
 
        //Creating the IndexBuffer (containing indices)
        m_IndexBuffer.reset(IndexBuffer::Create(&data.Indices[0], (uint32_t)data.Indices.size()));
 
        m_VertexArray.reset(VertexArray::Create());
        m_VertexArray->AddVertexBuffer(m_VertexBuffer);
        m_VertexArray->SetIndexBuffer(m_IndexBuffer);
 
        m_VertexArray->Unbind();
 
        if (m_data.Textures.empty())
        {
            m_data.Textures.push_back(TextureManager::GetDefaultTexture());
        }
    }

Mesh() [3/3]

Elevate::Mesh::Mesh	(	const std::vector< Vertex > &	vertices,
		const std::vector< uint32_t > &	indices,
		const std::vector< std::shared_ptr< Texture > > &	textures
	)

Definition at line 41 of file Mesh.cpp.

        : Mesh(MeshData(vertices, indices, textures)) { }

Member Function Documentation

CombineMeshes()

Mesh Elevate::Mesh::CombineMeshes ( std::vector< Mesh > &  meshes )

static

Definition at line 231 of file Mesh.cpp.

    {
        size_t indexOffset = 0;
 
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
        std::vector<std::shared_ptr<Texture>> textures;
 
        for (const Mesh& mesh : meshes)
        {
            vertices.insert(
                vertices.end(),
                mesh.m_data.Vertices.begin(),
                mesh.m_data.Vertices.end()
            );
 
            for (uint32_t index : mesh.m_data.Indices)
            {
                indices.push_back(index + (uint32_t)indexOffset);
            }
            indexOffset += mesh.m_data.Vertices.size();
 
            for (std::shared_ptr<Texture> tex : mesh.m_data.Textures)
            {
                if (!tex) continue; // TODO FIND IF AND WHY A TEXTURE COULD BE NULL
 
                bool found = false;
                for (std::shared_ptr<Texture> insertedTex : textures)
                {
                    if (insertedTex->GetNativeHandle() == tex->GetNativeHandle())
                    {
                        found = true;
                        break;
                    }
                }
 
                if (!found)
                {
                    textures.push_back(tex);
                }
            }
        }
 
        return Mesh(vertices, indices, textures);
    }

Create() [1/2]

Mesh * Elevate::Mesh::Create ( const MeshData &  data )

static

Definition at line 44 of file Mesh.cpp.

    {
        return new Mesh(data);
    }

Create() [2/2]

Mesh * Elevate::Mesh::Create ( std::vector< Vertex > &  vertices, std::vector< uint32_t > &  indices, std::vector< std::shared_ptr< Texture > > &  textures  )

static

Definition at line 49 of file Mesh.cpp.

    {
        return new Mesh(vertices, indices, textures);
    }

GenerateCube()

Mesh Elevate::Mesh::GenerateCube ( float  size = 1.0f )

static

Definition at line 54 of file Mesh.cpp.

    {
        const float halfSize = size * 0.5f;
 
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
 
        auto addFace = [&](glm::vec3 normal, glm::vec3 v0, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3) {
            uint32_t startIndex = (uint32_t) vertices.size();
 
            Vertex a{ v0, normal, {0.0f, 0.0f} };
            Vertex b{ v1, normal, {1.0f, 0.0f} };
            Vertex c{ v2, normal, {1.0f, 1.0f} };
            Vertex d{ v3, normal, {0.0f, 1.0f} };
 
            vertices.push_back(a);
            vertices.push_back(b);
            vertices.push_back(c);
            vertices.push_back(d);
 
            indices.push_back(startIndex);
            indices.push_back(startIndex + 1);
            indices.push_back(startIndex + 2);
            indices.push_back(startIndex);
            indices.push_back(startIndex + 2);
            indices.push_back(startIndex + 3);
        };
 
        // Front (+Z)
        addFace({ 0, 0, 1 },
            { -halfSize, -halfSize, halfSize },
            { halfSize, -halfSize, halfSize },
            { halfSize,  halfSize, halfSize },
            { -halfSize,  halfSize, halfSize });
 
        // Back (-Z)
        addFace({ 0, 0, -1 },
            { halfSize, -halfSize, -halfSize },
            { -halfSize, -halfSize, -halfSize },
            { -halfSize,  halfSize, -halfSize },
            { halfSize,  halfSize, -halfSize });
 
        // Right (+X)
        addFace({ 1, 0, 0 },
            { halfSize, -halfSize, halfSize },
            { halfSize, -halfSize, -halfSize },
            { halfSize,  halfSize, -halfSize },
            { halfSize,  halfSize, halfSize });
 
        // Left (-X)
        addFace({ -1, 0, 0 },
            { -halfSize, -halfSize, -halfSize },
            { -halfSize, -halfSize, halfSize },
            { -halfSize,  halfSize, halfSize },
            { -halfSize,  halfSize, -halfSize });
 
        // Top (+Y)
        addFace({ 0, 1, 0 },
            { -halfSize, halfSize, halfSize },
            { halfSize,  halfSize, halfSize },
            { halfSize,  halfSize, -halfSize },
            { -halfSize, halfSize, -halfSize });
 
        // Bottom (-Y)
        addFace({ 0, -1, 0 },
            { -halfSize, -halfSize, -halfSize },
            { halfSize,  -halfSize, -halfSize },
            { halfSize,  -halfSize, halfSize },
            { -halfSize, -halfSize, halfSize });
 
        return Mesh(vertices, indices, {});
    }

GenerateCubephere()

Mesh Elevate::Mesh::GenerateCubephere ( float  radius, int  subdivision  )

static

Definition at line 181 of file Mesh.cpp.

    {
        return Mesh();
    }

GeneratePlane()

Mesh Elevate::Mesh::GeneratePlane ( float  size, int  resolution  )

static

Definition at line 191 of file Mesh.cpp.

                                                       {
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
 
        float step = size / resolution;
        float offset = size * 0.5f;
 
        for (int i = 0; i <= resolution; i++) {
            for (int j = 0; j <= resolution; j++) {
                Vertex v;
                v.Position = { j * step - offset, 0.0f, i * step - offset };
                v.Normal = { 0.0f, 1.0f, 0.0f };
                v.TexCoords = { (float)j / resolution, (float)i / resolution };
                vertices.push_back(v);
            }
        }
 
        for (int i = 0; i < resolution; i++) {
            for (int j = 0; j < resolution; j++) {
                int row1 = i * (resolution + 1);
                int row2 = (i + 1) * (resolution + 1);
 
                uint32_t v0 = row1 + j;
                uint32_t v1 = row1 + j + 1;
                uint32_t v2 = row2 + j;
                uint32_t v3 = row2 + j + 1;
 
                indices.push_back(v0);
                indices.push_back(v2);
                indices.push_back(v1);
 
                indices.push_back(v1);
                indices.push_back(v2);
                indices.push_back(v3);
            }
        }
 
        return Mesh(vertices, indices, {});
    }

GenerateQuad()

Mesh Elevate::Mesh::GenerateQuad ( float  size = 1.0f )

static

Definition at line 186 of file Mesh.cpp.

    {
        return GeneratePlane(size, 1);
    }

GenerateUVSphere()

Mesh Elevate::Mesh::GenerateUVSphere ( float  radius, int  latitudes, int  longitudes  )

static

Definition at line 127 of file Mesh.cpp.

    {
        if (longitudes < 3) longitudes = 3;
        if (latitudes < 2) latitudes = 2;
 
        const float pi = std::acos(-1.0f);
        std::vector<Vertex> vertices;
        std::vector<uint32_t> indices;
        
        float latStep = pi / latitudes;
        float longStep = 2 * pi / longitudes;
 
        for (int lat = 0; lat <= latitudes; ++lat)
        {
            float phi = (pi / 2) - (lat * latStep); // From 90* down (starting from north pole basicly)
            const float xy = radius * cosf(phi);
            const float z = radius * sinf(phi);
 
            for (int lon = 0; lon <= longitudes; ++lon)
            {
                float theta = lon * longStep;
 
                Vertex v;
                v.Position = { 
                    xy * cosf(theta),
                    xy * sinf(theta),
                    z
                };
                v.TexCoords = { 
                    (float) lon / longitudes,
                    (float) lat / latitudes 
                };
                v.Normal = glm::normalize(v.Position);
                vertices.push_back(v);
            }
        }
 
        for (int lat = 0; lat < latitudes; ++lat)
        {
            for (int lon = 0; lon < longitudes; ++lon)
            {
                const uint32_t curr = lat * (longitudes + 1) + lon;
                const uint32_t next = curr + longitudes + 1;
 
                indices.insert(indices.end(), {
                    curr, next, curr + 1,
                    next, next + 1, curr + 1
                });
            }
        }
 
        return Mesh(vertices, indices, {});
    }

GetIndexBuffer()

std::shared_ptr< IndexBuffer > Elevate::Mesh::GetIndexBuffer ( ) const

inline

Definition at line 50 of file Mesh.h.

{ return m_IndexBuffer; }

GetTextures()

const std::vector< std::shared_ptr< Texture > > & Elevate::Mesh::GetTextures ( ) const

inline

Definition at line 52 of file Mesh.h.

{ return m_data.Textures; }

GetVertexArray()

std::shared_ptr< VertexArray > Elevate::Mesh::GetVertexArray ( ) const

inline

Definition at line 51 of file Mesh.h.

{ return m_VertexArray; }

GetVertexBuffer()

std::shared_ptr< VertexBuffer > Elevate::Mesh::GetVertexBuffer ( ) const

inline

Definition at line 49 of file Mesh.h.

{ return m_VertexBuffer; }

---

The documentation for this class was generated from the following files:

• ElevateEngine/src/ElevateEngine/Renderer/Mesh.h
• ElevateEngine/src/ElevateEngine/Renderer/Mesh.cpp