pepy/src/Model.cpp

/* Cuckoo by @ohsqueezy [ohsqueezy.itch.io] */

#include "Model.hpp"

/* Default constructor for Model */
Model::Model() {};

/* Construct a Model, adding Attributes each already wrapped in a shared pointer. The attributes should
 * be passed as a map with each key being a name and each value being a shared pointer to attributes. */
Model::Model(const std::map<std::string, std::shared_ptr<sb::Attributes>>& attributes_pack)
{
    for (auto attributes : attributes_pack)
    {
        this->attributes(attributes.second, attributes.first);
    }
}

/* Construct a Model, adding Attributes, which will each be wrapped in a shared pointer and stored in the
 * created object. The attributes should be passed as a map with each key being a name and each value being
 * an attributes object. */
Model::Model(const std::map<std::string, sb::Attributes>& attributes_pack)
{
    for (auto attributes : attributes_pack)
    {
        this->attributes(attributes.second, attributes.first);
    }
}

/* Construct a new model object by passing a list of names which will be used to initialize
 * empty attributes objects with the given names */
Model::Model(const std::initializer_list<std::string>& names)
{
    for (const std::string& name : names)
    {
        this->attributes(sb::Attributes(), name);
    }
}

/* Get the entire map of attributes, each wrapped in its shared pointer held by this object.
 * Can be used to iterate through the attributes. */
std::map<std::string, std::shared_ptr<sb::Attributes>>& Model::attributes()
{
    return model_attributes;
}

/* Get the attributes under name, wrapped in the shared pointer held by this object. This
 * function uses the at method of std::map, so name must refer to attributes already
 * stored in this model. Use this function to share ownership of the attributes or to gain
 * access to the public interface of the attributes. */
std::shared_ptr<sb::Attributes>& Model::attributes(const std::string& name)
{
    return attributes().at(name);
}

/* Get the attributes under name, wrapped in the shared pointer held by this object. This
 * function uses operator[] or std::map, so this can be used to add new attributes to the
 * object if they are wrapped in a shared pointer. */
std::shared_ptr<sb::Attributes>& Model::operator[](const std::string& name)
{
    auto element = attributes().find(name);
    /* add an empty Attributes at name if it doesn't exist yet */
    if (element == attributes().end())
    {
        attributes(sb::Attributes{}, name);
    }
    return attributes()[name];
}

/* Assign name to attributes, copy and wrap in a shared pointer. The model can share
 * ownership of the created attribute memory with callers that request it. */
void Model::attributes(const sb::Attributes& attributes, const std::string& name)
{
    this->attributes(std::make_shared<sb::Attributes>(attributes), name);
}

/* Assign name to attributes and share ownership. */
void Model::attributes(const std::shared_ptr<sb::Attributes>& attributes, const std::string& name)
{
    this->attributes()[name] = attributes;
}

/* Enable all attributes. */
void Model::enable()
{
    for (const auto& attributes : this->attributes())
    {        
        attributes.second->enable();
    }
}

/* Disable all attributes. */
void Model::disable()
{
    for (const auto& attributes : this->attributes())
    {
        attributes.second->disable();
    }
}

/* Return a reference to the texture container. */
std::map<std::string, sb::Texture>& Model::textures()
{
    return model_textures;
}

/* Get the texture at name. This can be used to read the texture memory, share ownership of it, or
 * anything else a Texture object can be used for with direct calls to GL functions. */
sb::Texture& Model::texture(const std::string& name)
{
    return textures().at(name);
}

/* Get the default texture. The default texture must have previously been set with the default key as
 * the name, which can be done using Model::texture(sb::Texture). */
sb::Texture& Model::texture()
{
    return texture(DEFAULT_TEXTURE_NAME);
}

/* Assign name to texture and share ownership. */
void Model::texture(const sb::Texture& texture, const std::string& name)
{
    textures()[name] = texture;
}

/* If no name is specified, use the default texture. This can be used to conveniently setup a model
 * with only one texture. */
void Model::texture(const sb::Texture& texture)
{
    this->texture(texture, DEFAULT_TEXTURE_NAME);
}

/* Get the model's transformation matrix. */
const glm::mat4& Model::transformation() const
{
    return model_transformation;
}

/* Set the model's transformation matrix. */
void Model::transformation(const glm::mat4& transformation)
{
    model_transformation = transformation;
}

/* Return the size in bytes of the sum of the attributes. */
std::size_t Model::size()
{
    std::size_t sum = 0;
    for (const auto& attributes : this->attributes())
    {
        sum += attributes.second->size();
    }
    return sum;
}

/* Return the transformation matrix. */
Model::operator glm::mat4() const
{
    return model_transformation;
}