MeshBuffer.cpp

Go to the documentation of this file.

#include "lvr2/io/MeshBuffer.hpp"
#include "lvr2/io/Timestamp.hpp"

#include <iostream>
using std::cout;
using std::endl;

namespace lvr2
{

MeshBuffer::MeshBuffer()
:base()
{
    
}

void MeshBuffer::setVertices(floatArr vertices, size_t n)
{
    if(n)
    {
        this->addFloatChannel(vertices, "vertices", n, 3);
    }
}

void MeshBuffer::setVertexNormals(floatArr normals)
{
    if(hasVertices())
    {
        this->addFloatChannel(normals, "vertex_normals", numVertices(), 3);
    }
    else
    {
        cout << "MeshBuffer::setVertexNormals(): "
             << "Cannot add vertex normals without vertex definitions" << endl;
    }
}

void MeshBuffer::setVertexColors(ucharArr colors, size_t w)
{
    if(hasVertices())
    {
        this->addUCharChannel(colors, "vertex_colors", numVertices(), w);
    }
    else
    {
        cout << "MeshBuffer::setVertexColors(): "
             << "Cannot add vertex colors without vertex definitions" << endl;
    }
}

void MeshBuffer::setTextureCoordinates(floatArr coordinates)
{
    if(hasVertices())
    {
        this->addFloatChannel(coordinates, "texture_coordinates", numVertices(), 2);
    }
    else
    {
        cout << "MeshBuffer::setTextureCoordinates(): "
             << "Cannot add vertex colors without vertex definitions" << endl;
    }
}

void MeshBuffer::setFaceIndices(indexArray indices, size_t n)
{
    if(n)
    {
        this->addIndexChannel(indices, "face_indices", n, 3);
    }
}

void MeshBuffer::setFaceMaterialIndices(indexArray indices)
{
    if(hasFaces())
    {
        this->addIndexChannel(indices, "face_material_indices", numFaces(), 1);
    }
    else
    {
        cout << "MeshBuffer::setFaceMaterialIndices(): "
             << "Cannot add material indices without face definitions" << endl;
    }
}

void MeshBuffer::setFaceNormals(floatArr normals)
{
    if(hasFaces())
    {
        this->addFloatChannel(normals, "face_normals", numFaces(), 3);
    }
    else
    {
        cout << "MeshBuffer::setFaceMaterialIndices(): "
             << "Cannot add material indices without face definitions" << endl;
    }
}

void MeshBuffer::setFaceColors(ucharArr colors, size_t w)
{
    if(hasFaces())
    {
        this->addUCharChannel(colors, "face_colors", numFaces(), w);
    }
    else
    {
        cout << "MeshBuffer::setFaceColors(): "
             << "Cannot add face colors without face definitions" << endl;
    }
}

size_t MeshBuffer::numVertices() const
{
    const typename Channel<float>::Optional opt = getChannel<float>("vertices");
    if(opt)
    {
        return opt->numElements();
    }
    else
    {
        return 0;
    }
}

size_t MeshBuffer::numFaces() const
{
    const typename Channel<unsigned int>::Optional opt = getChannel<unsigned int>("face_indices");
    if(opt)
    {
        return opt->numElements();
    }
    else
    {
        return 0;
    }
}

floatArr MeshBuffer::getVertices()
{
    size_t n;
    size_t w;
    return this->getFloatArray("vertices", n, w);
}

ucharArr MeshBuffer::getVertexColors(size_t& w)
{
    size_t n;
    return this->getUCharArray("vertex_colors", n, w);

}

floatArr MeshBuffer::getVertexNormals()
{
    size_t n;
    size_t w;
    return this->getFloatArray("vertex_normals", n, w);
}

floatArr MeshBuffer::getFaceNormals()
{
    size_t n;
    size_t w;
    return this->getFloatArray("face_normals", n, w);
}

floatArr MeshBuffer::getTextureCoordinates()
{
    size_t n;
    size_t w;
    return this->getFloatArray("texture_coordinates", n, w);
}

indexArray MeshBuffer::getFaceIndices()
{
    size_t n;
    size_t w;
    return this->getIndexArray("face_indices", n, w);
}

ucharArr MeshBuffer::getFaceColors(size_t& w)
{
    size_t n;
    ucharArr arr = this->getUCharArray("face_colors", n, w);
    return arr;
}

indexArray MeshBuffer::getFaceMaterialIndices()
{
    size_t n;
    size_t w;
    return this->getIndexArray("face_material_indices", n, w);
}

std::vector<Texture>& MeshBuffer::getTextures()
{
    return m_textures;
}

std::vector<Material>& MeshBuffer::getMaterials()
{
    return m_materials;
}

bool MeshBuffer::hasVertices() const 
{
    const FloatChannelOptional channel = this->getChannel<float>("vertices");
    if(channel)
    {
        return true;
    }
    return false;
}

bool MeshBuffer::hasFaces() const 
{
    const IndexChannelOptional channel = this->getChannel<unsigned int>("face_indices");
    if(channel)
    {
        return true;
    }
    return false;
}

bool MeshBuffer::hasFaceColors() const
{
    const UCharChannelOptional channel = this->getChannel<unsigned char>("face_colors");
    if(channel)
    {
        return true;
    }
    return false;
}

bool MeshBuffer::hasVertexColors() const
{
    const UCharChannelOptional channel = this->getChannel<unsigned char>("vertex_colors");
    if(channel)
    {
        return true;
    }
    return false;
}

bool MeshBuffer::hasFaceNormals() const
{
    FloatChannelOptional channel = this->getChannel<float>("face_normals");
    if(channel)
    {
        return true;
    }
    return false;
}

bool MeshBuffer::hasVertexNormals() const
{
    const FloatChannelOptional channel = this->getChannel<float>("vertex_normals");
    if(channel)
    {
        return true;
    }
    return false;
}

}