X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FScene.cc;h=a1218f29b6f14eed579aa5bc0681f1fb35785705;hp=45fc3a0ac9bc6f70397206fc49646546c1006614;hb=ed04ddaaa59dcc42e375ec492dbda77f693530e9;hpb=e973a129b5b83b628ba3f09e8c95682fc74080cd diff --git a/src/Scene.cc b/src/Scene.cc index 45fc3a0..a1218f2 100644 --- a/src/Scene.cc +++ b/src/Scene.cc @@ -1,52 +1,34 @@ -/******************************************************************************* - - Copyright (c) 2009, Charles McGarvey - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*******************************************************************************/ +/*] Copyright (c) 2009-2010, Charles McGarvey [************************** +**] All rights reserved. +* +* vi:ts=4 sw=4 tw=75 +* +* Distributable under the terms and conditions of the 2-clause BSD license; +* see the file COPYING for a complete text of the license. +* +**************************************************************************/ #include -#include -#include -#include -#include -#include -#include -#include -//#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "Character.hh" #include "Scene.hh" -struct Scene::Impl : public Mf::Manager +struct Scene::impl : public moof::manager { - struct Quad : public Mf::Entity + struct Quad : public moof::entity { enum Surface { @@ -56,9 +38,10 @@ struct Scene::Impl : public Mf::Manager TOP = 3 }; - Quad(const Mf::Vector3* vertices[4], const std::string& texture, - Mf::Texture::TileIndex tileIndex) : - mTilemap(texture), + Quad(const moof::vector3* vertices[4], + const std::string& texture, + int tileIndex) : + mTilemap(texture, tileIndex), mBlending(false), mFog(false), mSurface(NONE) @@ -72,20 +55,9 @@ struct Scene::Impl : public Mf::Manager //} } - if (!mTilemap.getTileCoords(tileIndex, mTexCoords)) - { - Mf::logWarning << "no index " << tileIndex << - " in texture " << texture << std::endl; - - mTexCoords[0] = mTexCoords[1] = - mTexCoords[3] = mTexCoords[6] = 0.0; - mTexCoords[2] = mTexCoords[4] = - 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) @@ -108,7 +80,7 @@ struct Scene::Impl : public Mf::Manager return mSurface; } - void draw(Mf::Scalar alpha = 0.0) const + void draw(moof::scalar alpha = 0.0) const { if (mBlending) { @@ -123,27 +95,21 @@ struct Scene::Impl : public Mf::Manager } //glColor4f(1.0f, 1.0f, 1.0f, 1.0f); - mTilemap.bind(); - - glVertexPointer(3, GL_SCALAR, 0, mVertices[0].data()); - glTexCoordPointer(2, GL_SCALAR, 0, mTexCoords); - - glDrawArrays(GL_TRIANGLE_FAN, 0, 4); + mTilemap.draw(mVertices); glDisable(GL_BLEND); 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]; - Mf::Texture mTilemap; + moof::sprite mTilemap; bool mBlending; bool mFog; @@ -152,14 +118,13 @@ struct Scene::Impl : public Mf::Manager - Mf::Matrix4 mTransform; - std::string mTexture; + moof::matrix4 mTransform; + std::string mTexture; - //Mf::Octree::Ptr mOctree; - std::list< boost::shared_ptr > mObjects; - std::list< Mf::Line<2> > mLines; + std::list< boost::shared_ptr > mObjects; + std::list mLines; - Mf::Aabb<3> mBounds; + moof::aabb<3> mBounds; enum AXIS @@ -173,193 +138,183 @@ struct Scene::Impl : public Mf::Manager void init(const std::string& name) {} - void importSceneBindings(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; - Mf::settings.get("detail", detail); - script.push(detail); script.set("detail"); + settings.get("detail", detail); + script.globals().set_field("detail", detail); - script.push(1); script.set("LOW"); - script.push(2); script.set("MEDIUM"); - script.push(3); script.set("HIGH"); + script.globals().set_field("LOW", 1); + script.globals().set_field("MEDIUM", 2); + script.globals().set_field("HIGH", 3); - script.push(X); script.set("X"); - script.push(Y); script.set("Y"); - script.push(Z); script.set("Z"); + script.globals().set_field("X", X); + script.globals().set_field("Y", Y); + script.globals().set_field("Z", Z); - script.push(Quad::LEFT); script.set("LEFT"); - script.push(Quad::RIGHT); script.set("RIGHT"); - script.push(Quad::TOP); script.set("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::Script& script) + moof::script::status load(moof::settings& settings, moof::script& script) { - std::string filePath = Scene::getPath(getName()); - if (filePath == "") + std::string path = moof::resource::find_file("scenes/"+name(), "lua"); + if (path.empty()) { script.push("the scene file could not be found"); - return Mf::Script::FILE_ERROR; + return moof::script::file_error; } - importSceneBindings(script); - return script.doFile(filePath); + importSceneBindings(settings, script); + return script.do_file(path); } - static int loadBox(Mf::Script& script, Mf::Aabb<3>& aabb) + static int loadBox(moof::script& script, moof::aabb3& aabb) { - script[1].requireTable(); - script[2].requireTable(); - script.setSize(2); - - for (int i = 1; i <= 2; ++i) - { - for (int j = 1; j <= 3; ++j) - { - script[i].pushField(j); - } - } + script[1].require_table(); + script[2].require_table(); - script[3].get(aabb.min[0]); - script[4].get(aabb.min[1]); - script[5].get(aabb.min[2]); - script[6].get(aabb.max[0]); - script[7].get(aabb.max[1]); - script[8].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::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; + moof::vector3 vec; + script[1].require_number().get(vec[0]); + script[2].require_number().get(vec[1]); + script[3].require_number().get(vec[2]); - script[1].requireNumber().get(vec[0]); - script[2].requireNumber().get(vec[1]); - script[3].requireNumber().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) { - if (script.getSize() == 3) + int size = script.stack_size(); + + if (size == 1) { - Mf::Vector3 vec; - script[1].requireNumber().get(vec[0]); - script[2].requireNumber().get(vec[1]); - script[3].requireNumber().get(vec[2]); + moof::scalar value = 1.0; + script[1].require_number().get(value); - Mf::Matrix4 scaling; - cml::matrix_scale(scaling, vec); + moof::matrix4 scaling; + moof::matrix_uniform_scale(scaling, value); mTransform = scaling * mTransform; } - else if (script.getSize() == 1) + else if (size == 3) { - Mf::Scalar value = 1.0; - script[1].requireNumber().get(value); + 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_uniform_scale(scaling, value); + moof::matrix4 scaling; + moof::matrix_scale(scaling, vec); mTransform = scaling * mTransform; } else { - script.getTop().throwError("wrong number of arguments"); + script.top().raise("wrong number of arguments"); } 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(); - Mf::Script::Slot top = script[-1]; - - int width = 1; - int height = 1; - int nTiles = 0; + moof::script::slot table = script[1].require_table(); - table.pushField("width"); - top.get(width); - script.pop(); + int width = 1; + table.get(width, "width"); - nTiles = table.getLength(); - if (nTiles % width != 0) table.throwError("invalid number of tiles"); + int nTiles = table.length(); + if (nTiles % width != 0) + { + table.raise("invalid number of tiles"); + } - if (width == 0) table.throwError("width field must not be zero"); - height = nTiles / 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 row first + // 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 + // row first // do first row and first column of vertices 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; @@ -370,19 +325,15 @@ struct Scene::Impl : public Mf::Manager int wPlus1 = w + 1; int hPlus1 = h + 1; - table.pushField(i); - - Mf::Texture::TileIndex index; - top.get(index); - - script.pop(); + 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::image::no_tile) continue; - const Mf::Vector3* corners[4] = { + const moof::vector3* corners[4] = { &vertices[h][w], &vertices[h][wPlus1], &vertices[hPlus1][wPlus1], @@ -398,10 +349,7 @@ struct Scene::Impl : public Mf::Manager } Quad::Surface surface = Quad::NONE; - - table.pushField("surface"); - top.get(surface); - script.pop(); + table.get(surface, "surface"); if (surface != Quad::NONE) { @@ -410,58 +358,49 @@ struct Scene::Impl : public Mf::Manager // 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)); - Mf::logInfo("new line"); + 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()) { - script.push(1); - param.pushField(); - top.get(index); - - param.pushField("u_scale"); - top.get(width); - - param.pushField("blend"); - top.get(blending); - - param.pushField("fog"); - top.get(fog); + 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 = 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)); } } @@ -469,7 +408,7 @@ struct Scene::Impl : public Mf::Manager { int wPlus1 = w + 1; - const Mf::Vector3* corners[4] = { + const moof::vector3* corners[4] = { &vertices[0][w], &vertices[0][wPlus1], &vertices[1][wPlus1], @@ -491,61 +430,62 @@ struct Scene::Impl : public Mf::Manager Scene::Scene(const std::string& name) : // pass through - mImpl(Scene::Impl::getInstance(name)) {} + impl_(Scene::impl::instance(name)) {} -Mf::Script::Result Scene::load(Mf::Script& script) +moof::script::status Scene::load(moof::settings& settings, moof::script& script) { // pass through - return mImpl->load(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 >& objects = mImpl->mObjects; - std::list< boost::shared_ptr >::const_iterator it; + std::list< boost::shared_ptr >& objects = impl_->mObjects; + std::list< boost::shared_ptr >::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 >& objects = mImpl->mObjects; - std::list< boost::shared_ptr >::const_iterator it; + std::list< boost::shared_ptr >& objects = impl_->mObjects; + std::list< boost::shared_ptr >::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::Intersection>& hits) const +bool Scene::castRay(const moof::ray<2>& ray, + std::list::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>::Intersection 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); @@ -561,48 +501,45 @@ bool Scene::castRay(const Mf::Ray<2>& ray, bool Scene::checkForCollision(Character& character) { return false; - //std::list< boost::shared_ptr > objects; - //std::list::InsertableP> objects; - //mImpl->mOctree->getNearbyObjects(objects, character); - std::list< boost::shared_ptr >& objects = mImpl->mObjects; - std::list< boost::shared_ptr >::const_iterator it; + std::list< boost::shared_ptr >& objects = impl_->mObjects; + std::list< boost::shared_ptr >::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; //} @@ -613,18 +550,10 @@ bool Scene::checkForCollision(Character& character) if (collisions > 0) { - Mf::logInfo << "collisions: " << collisions << std::endl; + moof::log_info << "collisions: " << collisions << std::endl; } return false; } -std::string Scene::getPath(const std::string& name) -{ - return Mf::Resource::getPath("scenes/" + name + ".lua"); -} - - -/** vim: set ts=4 sw=4 tw=80: *************************************************/ -