#include <map>
-#include <Moof/Aabb.hh>
-#include <Moof/Camera.hh>
-#include <Moof/Entity.hh>
-#include <Moof/Manager.hh>
-#include <Moof/Line.hh>
-#include <Moof/Log.hh>
-#include <Moof/Math.hh>
-//#include <Moof/Octree.hh>
-#include <Moof/Script.hh>
-#include <Moof/Settings.hh>
-#include <Moof/Texture.hh>
+#include <moof/aabb.hh>
+#include <moof/camera.hh>
+#include <moof/entity.hh>
+#include <moof/line.hh>
+#include <moof/log.hh>
+#include <moof/manager.hh>
+#include <moof/math.hh>
+#include <moof/script.hh>
+#include <moof/settings.hh>
+#include <moof/texture.hh>
#include "Character.hh"
#include "Scene.hh"
-struct Scene::Impl : public Mf::Manager<Impl>
+struct Scene::impl : public moof::manager<impl>
{
- struct Quad : public Mf::Entity
+ struct Quad : public moof::entity
{
enum Surface
{
TOP = 3
};
- Quad(const Mf::Vector3* vertices[4], const std::string& texture,
- Mf::Texture::TileIndex tileIndex) :
+ Quad(const moof::vector3* vertices[4],
+ const std::string& texture,
+ int tileIndex) :
mTilemap(texture),
mBlending(false),
mFog(false),
//}
}
- if (!mTilemap.getTileCoords(tileIndex, mTexCoords))
+ if (!mTilemap.tile_coordinates(tileIndex, mTexCoords))
{
- Mf::logWarning << "no index " << tileIndex <<
+ moof::log_warning << "no index " << tileIndex <<
" in texture " << texture << std::endl;
mTexCoords[0] = mTexCoords[1] =
mTexCoords[5] = mTexCoords[7] = 1.0;
}
- mAabb.encloseVertices(mVertices, 4);
- mSphere.point = mAabb.getCenter();
- mSphere.radius = (mAabb.min - mSphere.point).length();
+ aabb_.enclose_vertices(mVertices, 4);
+ sphere_.point = aabb_.center();
+ sphere_.radius = (aabb_.min - sphere_.point).length();
}
void setBlending(bool blending)
return mSurface;
}
- void draw(Mf::Scalar alpha = 0.0) const
+ void draw(moof::scalar alpha = 0.0) const
{
if (mBlending)
{
glDisable(GL_FOG);
}
- bool isVisible(const Mf::Frustum& frustum) const
+ bool is_visible(const moof::frustum& frustum) const
{
- return mSphere.isVisible(frustum);
+ return sphere_.is_visible(frustum);
}
- Mf::Vector3 mVertices[4];
- Mf::Scalar mTexCoords[8];
+ moof::vector3 mVertices[4];
+ moof::scalar mTexCoords[8];
- Mf::Texture mTilemap;
+ moof::texture mTilemap;
bool mBlending;
bool mFog;
- Mf::Matrix4 mTransform;
+ moof::matrix4 mTransform;
std::string mTexture;
- //Mf::Octree<Quad>::Ptr mOctree;
- std::list< boost::shared_ptr<Impl::Quad> > mObjects;
- std::list<Mf::Line2> mLines;
+ std::list< boost::shared_ptr<impl::Quad> > mObjects;
+ std::list<moof::line2> mLines;
- Mf::Aabb<3> mBounds;
+ moof::aabb<3> mBounds;
enum AXIS
void init(const std::string& name) {}
- void importSceneBindings(Mf::Settings& settings, Mf::Script& script)
+ void importSceneBindings(moof::settings& settings, moof::script& script)
{
- script.importFunction("SetBounds",
- boost::bind(&Impl::setBounds, this, _1));
- script.importFunction("ResetTransform",
- boost::bind(&Impl::resetTransform, this, _1));
- script.importFunction("Translate",
- boost::bind(&Impl::translate, this, _1));
- script.importFunction("Scale",
- boost::bind(&Impl::scale, this, _1));
- script.importFunction("Rotate",
- boost::bind(&Impl::rotate, this, _1));
- script.importFunction("SetTexture",
- boost::bind(&Impl::setTexture, this, _1));
- script.importFunction("DrawTilemap",
- boost::bind(&Impl::drawTilemap, this, _1));
- script.importFunction("DrawTile",
- boost::bind(&Impl::drawTile, this, _1));
+ script.import_function("SetBounds",
+ boost::bind(&impl::setBounds, this, _1));
+ script.import_function("ResetTransform",
+ boost::bind(&impl::resetTransform, this, _1));
+ script.import_function("Translate",
+ boost::bind(&impl::translate, this, _1));
+ script.import_function("Scale",
+ boost::bind(&impl::scale, this, _1));
+ script.import_function("Rotate",
+ boost::bind(&impl::rotate, this, _1));
+ script.import_function("SetTexture",
+ boost::bind(&impl::setTexture, this, _1));
+ script.import_function("DrawTilemap",
+ boost::bind(&impl::drawTilemap, this, _1));
+ script.import_function("DrawTile",
+ boost::bind(&impl::drawTile, this, _1));
int detail = 3;
settings.get("detail", detail);
- script.globals().setField("detail", detail);
+ script.globals().set_field("detail", detail);
- script.globals().setField("LOW", 1);
- script.globals().setField("MEDIUM", 2);
- script.globals().setField("HIGH", 3);
+ script.globals().set_field("LOW", 1);
+ script.globals().set_field("MEDIUM", 2);
+ script.globals().set_field("HIGH", 3);
- script.globals().setField("X", X);
- script.globals().setField("Y", Y);
- script.globals().setField("Z", Z);
+ script.globals().set_field("X", X);
+ script.globals().set_field("Y", Y);
+ script.globals().set_field("Z", Z);
- script.globals().setField("LEFT", Quad::LEFT);
- script.globals().setField("RIGHT", Quad::RIGHT);
- script.globals().setField("TOP", Quad::TOP);
+ script.globals().set_field("LEFT", Quad::LEFT);
+ script.globals().set_field("RIGHT", Quad::RIGHT);
+ script.globals().set_field("TOP", Quad::TOP);
}
- Mf::Script::Result load(Mf::Settings& settings, Mf::Script& script)
+ moof::script::status load(moof::settings& settings, moof::script& script)
{
- std::string path(getName());
- if (!Scene::getPath(path))
+ std::string path(name());
+ if (!Scene::find_path(path))
{
script.push("the scene file could not be found");
- return Mf::Script::FILE_ERROR;
+ return moof::script::file_error;
}
importSceneBindings(settings, script);
- return script.doFile(path);
+ return script.do_file(path);
}
- static int loadBox(Mf::Script& script, Mf::Aabb3& aabb)
+ static int loadBox(moof::script& script, moof::aabb3& aabb)
{
- script[1].requireTable();
- script[2].requireTable();
+ script[1].require_table();
+ script[2].require_table();
- script[1].pushField(1).get(aabb.min[0]);
- script[1].pushField(2).get(aabb.min[1]);
- script[1].pushField(3).get(aabb.min[2]);
- script[2].pushField(1).get(aabb.max[0]);
- script[2].pushField(2).get(aabb.max[1]);
- script[2].pushField(3).get(aabb.max[2]);
+ script[1].push_field(1).get(aabb.min[0]);
+ script[1].push_field(2).get(aabb.min[1]);
+ script[1].push_field(3).get(aabb.min[2]);
+ script[2].push_field(1).get(aabb.max[0]);
+ script[2].push_field(2).get(aabb.max[1]);
+ script[2].push_field(3).get(aabb.max[2]);
return 0;
}
- int setBounds(Mf::Script& script)
+ int setBounds(moof::script& script)
{
int ret = loadBox(script, mBounds);
- //mOctree = Mf::Octree<Quad>::alloc(mBounds);
return ret;
}
- int resetTransform(Mf::Script& script)
+ int resetTransform(moof::script& script)
{
mTransform.identity();
return 0;
}
- int translate(Mf::Script& script)
+ int translate(moof::script& script)
{
- Mf::Vector3 vec;
- script[1].requireNumber().get(vec[0]);
- script[2].requireNumber().get(vec[1]);
- script[3].requireNumber().get(vec[2]);
+ moof::vector3 vec;
+ script[1].require_number().get(vec[0]);
+ script[2].require_number().get(vec[1]);
+ script[3].require_number().get(vec[2]);
- Mf::Matrix4 translation;
- cml::matrix_translation(translation, vec);
+ moof::matrix4 translation;
+ moof::matrix_translation(translation, vec);
mTransform = translation * mTransform;
return 0;
}
- int scale(Mf::Script& script)
+ int scale(moof::script& script)
{
- int size = script.stackSize();
+ int size = script.stack_size();
if (size == 1)
{
- Mf::Scalar value = 1.0;
- script[1].requireNumber().get(value);
+ moof::scalar value = 1.0;
+ script[1].require_number().get(value);
- Mf::Matrix4 scaling;
- cml::matrix_uniform_scale(scaling, value);
+ moof::matrix4 scaling;
+ moof::matrix_uniform_scale(scaling, value);
mTransform = scaling * mTransform;
}
else if (size == 3)
{
- Mf::Vector3 vec;
- script[1].requireNumber().get(vec[0]);
- script[2].requireNumber().get(vec[1]);
- script[3].requireNumber().get(vec[2]);
+ moof::vector3 vec;
+ script[1].require_number().get(vec[0]);
+ script[2].require_number().get(vec[1]);
+ script[3].require_number().get(vec[2]);
- Mf::Matrix4 scaling;
- cml::matrix_scale(scaling, vec);
+ moof::matrix4 scaling;
+ moof::matrix_scale(scaling, vec);
mTransform = scaling * mTransform;
}
else
return 0;
}
- int rotate(Mf::Script& script)
+ int rotate(moof::script& script)
{
size_t index = 0;
- script[1].requireNumber().get(index);
+ script[1].require_number().get(index);
- Mf::Scalar value;
- script[2].requireNumber().get(value);
+ moof::scalar value;
+ script[2].require_number().get(value);
- cml::matrix_rotate_about_world_axis(mTransform,
- index, cml::rad(value));
+ moof::matrix_rotate_about_world_axis(mTransform, index,
+ moof::rad(value));
return 0;
}
- int setTexture(Mf::Script& script)
+ int setTexture(moof::script& script)
{
- script[1].requireString().get(mTexture);
+ script[1].require_string().get(mTexture);
return 0;
}
- int drawTilemap(Mf::Script& script)
+ int drawTilemap(moof::script& script)
{
- Mf::Script::Slot table = script[1].requireTable();
+ moof::script::slot table = script[1].require_table();
int width = 1;
table.get(width, "width");
if (width == 0) table.raise("width field must not be zero");
int height = nTiles / width;
- Mf::Vector3 vertices[height+1][width+1];
+ moof::vector3 vertices[height+1][width+1];
// the indices are stored upside-down in the scene file so that
// they are easier to edit as text, so we'll need to load them last
for (int w = 0; w <= width; ++w)
{
- vertices[height][w] = Mf::demote(mTransform *
- Mf::Vector4(w, height, 0.0, 1.0));
+ vertices[height][w] = moof::demote(mTransform *
+ moof::vector4(w, height, 0.0, 1.0));
}
for (int h = 0; h < height; ++h)
{
- vertices[h][0] = Mf::demote(mTransform *
- Mf::Vector4(0.0, h, 0.0, 1.0));
+ vertices[h][0] = moof::demote(mTransform *
+ moof::vector4(0.0, h, 0.0, 1.0));
}
size_t i = 1;
int wPlus1 = w + 1;
int hPlus1 = h + 1;
- Mf::Texture::TileIndex index;
+ int index;
table.get(index, i);
- vertices[h][wPlus1] = Mf::demote(mTransform *
- Mf::Vector4(wPlus1, h, 0.0, 1.0));
+ vertices[h][wPlus1] = moof::demote(mTransform *
+ moof::vector4(wPlus1, h, 0.0, 1.0));
- if (index == Mf::Texture::NO_TILE) continue;
+ if (index == moof::texture::no_tile) continue;
- const Mf::Vector3* corners[4] = {
+ const moof::vector3* corners[4] = {
&vertices[h][w],
&vertices[h][wPlus1],
&vertices[hPlus1][wPlus1],
// scene is built, simply demoting the vector again should
// project the points to the xy-plane
- Mf::Vector2 bl = Mf::demote(vertices[0][0]);
- Mf::Vector2 tr = Mf::demote(vertices[height][width]);
+ moof::vector2 bl = moof::demote(vertices[0][0]);
+ moof::vector2 tr = moof::demote(vertices[height][width]);
- mLines.push_back(Mf::Line<2>(bl, tr));
+ mLines.push_back(moof::line<2>(bl, tr));
}
return 0;
}
- int drawTile(Mf::Script& script)
+ int drawTile(moof::script& script)
{
- Mf::Script::Slot param = script[1];
- Mf::Script::Slot top = script[-1];
+ moof::script::slot param = script[1];
+ moof::script::slot top = script[-1];
- Mf::Texture::TileIndex index = 0;
- int width = 1;
- bool blending = false;
- bool fog = false;
+ int index = 0;
+ int width = 1;
+ bool blending = false;
+ bool fog = false;
- if (param.isTable())
+ if (param.is_table())
{
param.get(index, 1);
param.get(width, "u_scale");
param.get(blending, "blend");
param.get(fog, "fog");
}
- else if (param.isNumber())
+ else if (param.is_number())
{
param.get(index);
}
- Mf::Vector3 vertices[2][width+1];
+ moof::vector3 vertices[2][width+1];
- Mf::Scalar xf;
- Mf::Scalar increment = SCALAR(1.0) / Mf::Scalar(width);
+ moof::scalar xf;
+ moof::scalar increment = SCALAR(1.0) / moof::scalar(width);
for (int h = 0; h <= 1; ++h)
{
xf = 0.0;
for (int w = 0; w <= width; ++w, xf += increment)
{
- vertices[h][w] = Mf::demote(mTransform *
- Mf::Vector4(xf, Mf::Scalar(h), 0.0, 1.0));
+ vertices[h][w] = moof::demote(mTransform *
+ moof::vector4(xf, moof::scalar(h), 0.0, 1.0));
}
}
{
int wPlus1 = w + 1;
- const Mf::Vector3* corners[4] = {
+ const moof::vector3* corners[4] = {
&vertices[0][w],
&vertices[0][wPlus1],
&vertices[1][wPlus1],
Scene::Scene(const std::string& name) :
// pass through
- mImpl(Scene::Impl::getInstance(name)) {}
+ impl_(Scene::impl::instance(name)) {}
-Mf::Script::Result Scene::load(Mf::Settings& settings, Mf::Script& script)
+moof::script::status Scene::load(moof::settings& settings, moof::script& script)
{
// pass through
- return mImpl->load(settings, script);
+ return impl_->load(settings, script);
}
-void Scene::draw(Mf::Scalar alpha) const
+void Scene::draw(moof::scalar alpha) const
{
- std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
- std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;
+ std::list< boost::shared_ptr<impl::Quad> >& objects = impl_->mObjects;
+ std::list< boost::shared_ptr<impl::Quad> >::const_iterator it;
for (it = objects.begin(); it != objects.end(); ++it)
{
(*it)->draw(alpha);
}
- mImpl->mBounds.draw();
+ impl_->mBounds.draw();
}
-void Scene::drawIfVisible(Mf::Scalar alpha,
- const Mf::Frustum& frustum) const
+void Scene::draw_if_visible(moof::scalar alpha,
+ const moof::frustum& frustum) const
{
- std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
- std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;
+ std::list< boost::shared_ptr<impl::Quad> >& objects = impl_->mObjects;
+ std::list< boost::shared_ptr<impl::Quad> >::const_iterator it;
for (it = objects.begin(); it != objects.end(); ++it)
{
- (*it)->drawIfVisible(alpha, frustum);
+ (*it)->draw_if_visible(alpha, frustum);
}
- std::list< Mf::Line<2> >& lines = mImpl->mLines;
- std::list< Mf::Line<2> >::const_iterator lit;
+ std::list< moof::line<2> >& lines = impl_->mLines;
+ std::list< moof::line<2> >::const_iterator lit;
for (lit = lines.begin(); lit != lines.end(); ++lit)
{
(*lit).draw(alpha);
}
- mImpl->mBounds.draw();
+ impl_->mBounds.draw();
}
-bool Scene::castRay(const Mf::Ray<2>& ray,
- std::list<Mf::Ray<2>::Contact>& hits) const
+bool Scene::castRay(const moof::ray<2>& ray,
+ std::list<moof::ray<2>::contact>& hits) const
{
- std::list< Mf::Line<2> >& lines = mImpl->mLines;
- std::list< Mf::Line<2> >::const_iterator it;
+ std::list< moof::line<2> >& lines = impl_->mLines;
+ std::list< moof::line<2> >::const_iterator it;
for (it = lines.begin(); it != lines.end(); ++it)
{
- Mf::Ray<2>::Contact hit;
- Mf::Scalar d = (*it).intersectRay(ray, hit);
+ moof::ray<2>::contact hit;
+ moof::scalar d = (*it).intersect_ray(ray, hit);
if (d > 0.0)
{
hits.push_back(hit);
bool Scene::checkForCollision(Character& character)
{
return false;
- //std::list< boost::shared_ptr<Impl::Quad> > objects;
- //std::list<Mf::Octree<Impl::Quad>::InsertableP> objects;
- //mImpl->mOctree->getNearbyObjects(objects, character);
- std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
- std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;
+ std::list< boost::shared_ptr<impl::Quad> >& objects = impl_->mObjects;
+ std::list< boost::shared_ptr<impl::Quad> >::const_iterator it;
int collisions = 0;
- Mf::Sphere<3> sphere = character.getSphere();
+ moof::sphere<3> sphere = character.sphere();
for (it = objects.begin(); it != objects.end(); ++it)
{
- Impl::Quad::Surface type = (*it)->getSurface();
- if (type == Impl::Quad::NONE) continue;
+ impl::Quad::Surface type = (*it)->getSurface();
+ if (type == impl::Quad::NONE) continue;
- if (Mf::checkCollision(sphere, (*it)->getSphere()))
+ if (moof::checkCollision(sphere, (*it)->sphere()))
{
++collisions;
- Mf::Vector2 impulse(0.0, 0.0);
- Mf::Vector2 p = character.getState().momentum;
+ moof::vector2 impulse(0.0, 0.0);
+ moof::vector2 p = character.state().momentum;
- Mf::State2 state = character.getState(1.0);
- sphere = character.getSphere();
- Mf::Scalar alpha = 1.0;
- while (Mf::checkCollision(sphere, (*it)->getSphere()))
+ moof::state2 state = character.state(1.0);
+ sphere = character.sphere();
+ moof::scalar alpha = 1.0;
+ while (moof::checkCollision(sphere, (*it)->sphere()))
{
alpha -= 0.05;
- state = character.getState(alpha);
+ state = character.state(alpha);
}
character.setPosition(state.position);
//switch (type)
//{
- //case Impl::Quad::TOP:
+ //case impl::Quad::TOP:
//if (p[1] < 0.0) impulse[1] = -p[1];
//break;
- //case Impl::Quad::LEFT:
+ //case impl::Quad::LEFT:
//if (p[0] > 0.0) impulse[0] = 1.5*-p[0];
//break;
- //case Impl::Quad::RIGHT:
+ //case impl::Quad::RIGHT:
//if (p[0] < 0.0) impulse[0] = 1.5*-p[0];
//break;
//}
if (collisions > 0)
{
- Mf::logInfo << "collisions: " << collisions << std::endl;
+ moof::log_info << "collisions: " << collisions << std::endl;
}
return false;
}
-bool Scene::getPath(std::string& name)
+bool Scene::find_path(std::string& name)
{
- return Mf::Resource::getPath(name, "scenes/", "lua");
+ return moof::resource::find_path(name, "scenes/", "lua");
}
projects / chaz / yoink / blobdiff