117 lines
4.0 KiB
C++
117 lines
4.0 KiB
C++
/* _______________ ,----------------------------------------------------------------.
|
|
//`````````````\\ \ \
|
|
//~~~~~~~~~~~~~~~\\ \ by @ohsqueezy & @sleepin \
|
|
//=================\\ \ [ohsqueezy.itch.io] [sleepin.itch.io] \
|
|
// \\ \ \
|
|
// \\ \ code released under the zlib license [git.nugget.fun/pudding] \
|
|
// ☆ GUNKISS ☆ \\ \ \
|
|
//_________________________\\ `---------------------------------------------------------------*/
|
|
|
|
#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.first, attributes.second);
|
|
}
|
|
}
|
|
|
|
/* 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.first, attributes.second);
|
|
}
|
|
}
|
|
|
|
/* 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. Use
|
|
* this 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 model_attributes.at(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 std::string& name, const sb::Attributes& attributes)
|
|
{
|
|
this->attributes(name, std::make_shared<sb::Attributes>(attributes));
|
|
}
|
|
|
|
/* Assign name to attributes and share ownership. */
|
|
void Model::attributes(const std::string& name, const std::shared_ptr<sb::Attributes>& attributes)
|
|
{
|
|
model_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();
|
|
}
|
|
}
|
|
|
|
/* 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 model_texture.at(name);
|
|
}
|
|
|
|
/* Assign name to texture and share ownership. */
|
|
void Model::texture(const std::string& name, const sb::Texture& texture)
|
|
{
|
|
model_texture[name] = texture;
|
|
}
|
|
|
|
/* Set the 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;
|
|
}
|