197 lines
6.2 KiB
C++
197 lines
6.2 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.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;
|
||
|
}
|
||
|
|
||
|
PlaneDoubleBuffer::PlaneDoubleBuffer() : Plane()
|
||
|
{
|
||
|
texture(sb::Texture(), "front");
|
||
|
texture(sb::Texture(), "back");
|
||
|
}
|
||
|
|
||
|
void PlaneDoubleBuffer::generate(const glm::vec2& size)
|
||
|
{
|
||
|
for (sb::Texture* buffer : {&texture("front"), &texture("back")})
|
||
|
{
|
||
|
buffer->generate(size);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
sb::Texture& PlaneDoubleBuffer::active()
|
||
|
{
|
||
|
return swapped ? texture("back") : texture("front");
|
||
|
}
|
||
|
|
||
|
sb::Texture& PlaneDoubleBuffer::inactive()
|
||
|
{
|
||
|
return swapped ? texture("front") : texture("back");
|
||
|
}
|
||
|
|
||
|
void PlaneDoubleBuffer::swap()
|
||
|
{
|
||
|
swapped = !swapped;
|
||
|
}
|