*******************************************************************************/
-#include "deserializer.hh"
-#include "mippleton.hh"
-#include "opengl.hh"
-#include "serializable.hh"
+#include "Deserializer.hh"
+#include "Mippleton.hh"
+#include "OpenGL.hh"
+#include "Serializable.hh"
+#include "Tilemap.hh"
-#include "tilemap.hh"
+namespace Mf {
-namespace dc {
-
-class tilemap::tilemap_impl : public mippleton<tilemap_impl>
+class Tilemap::TilemapImpl : public Mippleton<TilemapImpl>
{
public:
- tilemap_impl(const std::string& name) :
- mippleton<tilemap_impl>(name),
+ TilemapImpl(const std::string& name) :
+ Mippleton<TilemapImpl>(name),
tilesU_(1),
tilesV_(1),
minFilter_(GL_NEAREST),
void loadFromFile()
{
- deserializer in(tilemap::getPathToResource(getName()));
+ Deserializer deserializer(Tilemap::getPathToResource(getName()));
- serializable_ptr root = in.deserialize();
+ SerializablePtr root = deserializer.deserialize();
if (root)
{
- std::map<std::string,serializable_ptr> rootMap;
+ std::map<std::string,SerializablePtr> rootObj;
- if (root->get(rootMap))
+ if (root->get(rootObj))
{
- std::map<std::string,serializable_ptr>::iterator it;
+ std::map<std::string,SerializablePtr>::iterator it;
- if ((it = rootMap.find("TilesU")) != rootMap.end())
+ if ((it = rootObj.find("TilesU")) != rootObj.end())
{
long value;
if ((*it).second->get(value))
tilesU_ = unsigned(value);
}
}
- if ((it = rootMap.find("TilesV")) != rootMap.end())
+ if ((it = rootObj.find("TilesV")) != rootObj.end())
{
long value;
if ((*it).second->get(value))
tilesV_ = unsigned(value);
}
}
- if ((it = rootMap.find("MinFilter")) != rootMap.end())
+ if ((it = rootObj.find("MinFilter")) != rootObj.end())
{
std::string value;
if ((*it).second->get(value))
}
}
}
- if ((it = rootMap.find("MaxFilter")) != rootMap.end())
+ if ((it = rootObj.find("MaxFilter")) != rootObj.end())
{
std::string value;
if ((*it).second->get(value))
}
}
}
- if ((it = rootMap.find("WrapU")) != rootMap.end())
+ if ((it = rootObj.find("WrapU")) != rootObj.end())
{
std::string value;
if ((*it).second->get(value))
}
}
}
- if ((it = rootMap.find("WrapV")) != rootMap.end())
+ if ((it = rootObj.find("WrapV")) != rootObj.end())
{
std::string value;
if ((*it).second->get(value))
}
}
- unsigned tilesU_;
- unsigned tilesV_;
- GLuint minFilter_;
- GLuint maxFilter_;
- GLuint wrapU_;
- GLuint wrapV_;
+ unsigned tilesU_;
+ unsigned tilesV_;
+ GLuint minFilter_;
+ GLuint maxFilter_;
+ GLuint wrapU_;
+ GLuint wrapV_;
};
-tilemap::tilemap(const std::string& name) :
- texture(name),
- impl(tilemap::tilemap_impl::retain(name), &tilemap::tilemap_impl::release)
+Tilemap::Tilemap(const std::string& name) :
+ Texture(name),
+ impl_(Tilemap::TilemapImpl::retain(name), &Tilemap::TilemapImpl::release)
{
- setMinFilter(impl->minFilter_);
- setMaxFilter(impl->maxFilter_);
- setWrapU(impl->wrapU_);
- setWrapV(impl->wrapV_);
+ setMinFilter(impl_->minFilter_);
+ setMaxFilter(impl_->maxFilter_);
+ setWrapU(impl_->wrapU_);
+ setWrapV(impl_->wrapV_);
applyChanges();
}
-bool tilemap::getTileCoords(unsigned index, scalar coords[8])
+bool Tilemap::getTileCoords(unsigned index, Scalar coords[8])
{
// make sure the index represents a real tile
- if (index >= impl->tilesU_ * impl->tilesV_) return false;
+ if (index >= impl_->tilesU_ * impl_->tilesV_) return false;
- scalar w = 1.0 / scalar(impl->tilesU_);
- scalar h = 1.0 / scalar(impl->tilesV_);
+ Scalar w = 1.0 / Scalar(impl_->tilesU_);
+ Scalar h = 1.0 / Scalar(impl_->tilesV_);
- coords[0] = scalar(index % impl->tilesU_) * w;
- coords[1] = (scalar(impl->tilesV_ - 1) - scalar(index / impl->tilesU_)) * h;
+ coords[0] = Scalar(index % impl_->tilesU_) * w;
+ coords[1] = (Scalar(impl_->tilesV_ - 1) -
+ Scalar(index / impl_->tilesU_)) * h;
coords[2] = coords[0] + w;
coords[3] = coords[1];
coords[4] = coords[2];
return true;
}
-bool tilemap::getTileCoords(unsigned index, scalar coords[8], orientation what)
+bool Tilemap::getTileCoords(unsigned index, Scalar coords[8],
+ Orientation orientation)
{
if (getTileCoords(index, coords))
{
- if (what & flip)
+ if (orientation & FLIP)
{
// this looks kinda weird, but it's just swapping in a way that
// doesn't require an intermediate variable
coords[3] = coords[7];
coords[7] = coords[5];
}
- if (what & reverse)
+ if (orientation & REVERSE)
{
coords[0] = coords[2];
coords[2] = coords[6];
}
-std::string tilemap::getPathToResource(const std::string& name)
+std::string Tilemap::getPathToResource(const std::string& name)
{
- return resource::getPathToResource("tilemaps/" + name + ".json");
+ return Resource::getPathToResource("tilemaps/" + name + ".json");
}
-} // namespace dc
+} // namespace Mf
/** vim: set ts=4 sw=4 tw=80: *************************************************/