-/*******************************************************************************
-
- 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-2011, Charles McGarvey [*****************************
+**] All rights reserved.
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+*****************************************************************************/
#include <map>
-#include <vector>
-
-#include <Moof/Aabb.hh>
-#include <Moof/Camera.hh>
-#include <Moof/Entity.hh>
-#include <Moof/Log.hh>
-#include <Moof/Math.hh>
-#include <Moof/Mippleton.hh>
-#include <Moof/Octree.hh>
-#include <Moof/Script.hh>
-#include <Moof/Settings.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/resource.hh>
+#include <moof/script.hh>
+#include <moof/settings.hh>
+#include <moof/sprite.hh>
+
+#include "Character.hh"
#include "Scene.hh"
-#include "Tilemap.hh"
-struct Scene::Impl : public Mf::Mippleton<Impl>
+struct Scene::impl : public moof::manager<impl>
{
- class Quad : public Mf::Entity, public Mf::OctreeInsertable
+ struct Quad : public moof::entity
{
- Mf::Scalar vertices_[12];
- Mf::Scalar texCoords_[8];
-
- Tilemap tilemap_;
-
- bool blending_;
- bool fog_;
-
- Mf::Aabb aabb_;
- Mf::Sphere sphere_;
-
- public:
-
- enum SURFACE_TYPE
+ enum Surface
{
+ NONE = 0,
LEFT = 1,
RIGHT = 2,
- TOP = 3
+ TOP = 3
};
- Quad(const Mf::Vector3 vertices[4], const std::string& texture,
- Tilemap::Index tileIndex) :
- tilemap_(texture),
- blending_(false),
- fog_(false)
+ Quad(const moof::vector3* vertices[4],
+ const moof::image_handle& texture,
+ int tileIndex) :
+ mTilemap(texture, tileIndex),
+ mBlending(false),
+ mFog(false),
+ mSurface(NONE)
{
- for (int i = 0, num = 0; i < 4; ++i)
+ for (int i = 0; i < 4; ++i)
{
- for (int j = 0; j < 3; ++j, ++num)
- {
- vertices_[num] = vertices[i][j];
- }
- }
-
- if (!tilemap_.getTileCoords(tileIndex, texCoords_))
- {
- Mf::logWarning("no index %d in texture %s", tileIndex,
- texture.c_str());
-
- texCoords_[0] = texCoords_[1] =
- texCoords_[3] = texCoords_[6] = 0.0;
- texCoords_[2] = texCoords_[4] =
- texCoords_[5] = texCoords_[7] = 1.0;
+ mVertices[i] = *vertices[i];
+ //for (int j = 0; j < 3; ++j, ++num)
+ //{
+ //mVertices[num] = (*vertices[i])[j];
+ //}
}
- aabb_.encloseVertices(vertices, 4);
- sphere_.point = aabb_.getCenter();
+ aabb_.enclose_vertices(mVertices, 4);
+ sphere_.point = aabb_.center();
sphere_.radius = (aabb_.min - sphere_.point).length();
}
void setBlending(bool blending)
{
- blending_ = blending;
+ mBlending = blending;
}
void setFog(bool fog)
{
- fog_ = fog;
+ mFog = fog;
}
- void draw(Mf::Scalar alpha = 0.0) const
+ void setSurface(Surface type)
{
- if (blending_)
+ mSurface = type;
+ }
+
+ Surface getSurface() const
+ {
+ return mSurface;
+ }
+
+ void draw(moof::scalar alpha = 0.0) const
+ {
+ if (mBlending)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
- if (fog_)
+ if (mFog)
{
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
}
//glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- tilemap_.bind();
-
- glVertexPointer(3, GL_SCALAR, 0, vertices_);
- glTexCoordPointer(2, GL_SCALAR, 0, texCoords_);
-
- 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 sphere_.isVisible(frustum);
+ return sphere_.is_visible(frustum);
}
- bool isInsideAabb(const Mf::Aabb& aabb) const
- {
- // make sure the entity is fully inside the volume
- if (!(aabb_.max[0] < aabb.max[0] &&
- aabb_.min[0] > aabb.min[0] &&
- aabb_.max[1] < aabb.max[1] &&
- aabb_.min[1] > aabb.min[1] &&
- aabb_.max[2] < aabb.max[2] &&
- aabb_.min[2] > aabb.min[2]))
- {
- return false;
- }
-
- return true;
- }
-
- int getOctant(const Mf::Aabb& aabb) const
- {
- int octantNum = -1;
-
- Mf::Plane::Halfspace halfspace;
-
- Mf::Plane xy = aabb.getPlaneXY();
- halfspace = xy.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = xy.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- Mf::Plane xz = aabb.getPlaneXZ();
- halfspace = xz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = xz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- Mf::Plane yz = aabb.getPlaneYZ();
- halfspace = yz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = yz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- octantNum = 2;
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- octantNum = 3;
- }
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- Mf::Plane yz = aabb.getPlaneYZ();
- halfspace = yz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = yz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- octantNum = 1;
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- octantNum = 0;
- }
- }
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- Mf::Plane xz = aabb.getPlaneXZ();
- halfspace = xz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = xz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- Mf::Plane yz = aabb.getPlaneYZ();
- halfspace = yz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = yz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- octantNum = 6;
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- octantNum = 7;
- }
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- Mf::Plane yz = aabb.getPlaneYZ();
- halfspace = yz.intersects(sphere_);
- if (halfspace == Mf::Plane::INTERSECT)
- {
- halfspace = yz.intersects(aabb_);
- }
-
- if (halfspace == Mf::Plane::POSITIVE)
- {
- octantNum = 5;
- }
- else if (halfspace == Mf::Plane::NEGATIVE)
- {
- octantNum = 4;
- }
- }
- }
+ moof::vector3 mVertices[4];
+
+ moof::sprite mTilemap;
- return octantNum;
- }
+ bool mBlending;
+ bool mFog;
+ Surface mSurface;
};
- Mf::Matrix4 transform;
- std::string texture;
+ moof::matrix4 mTransform;
+ moof::image_handle mTexture;
+
+ std::list< boost::shared_ptr<impl::Quad> > mObjects;
+ std::list<moof::line2> mLines;
- Mf::Octree<Quad>::Ptr octree;
+ moof::aabb<3> mBounds;
enum AXIS
};
+ void init(const std::string& name) {}
- explicit Impl(const std::string& name) :
- Mf::Mippleton<Impl>(name)
- {
- loadFromFile();
- }
- void importSceneBindings(Mf::Script& script)
+ void importSceneBindings(moof::settings& settings, moof::script& script)
{
- script.importFunction("SetPlayfieldBounds",
- boost::bind(&Impl::setPlayfieldBounds, this, _1));
- script.importFunction("SetMaximumBounds",
- boost::bind(&Impl::setMaximumBounds, 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("MakeTilemap",
- boost::bind(&Impl::makeTilemap, this, _1));
- script.importFunction("MakeBillboard",
- boost::bind(&Impl::makeBillboard, this, _1));
-
- long detail = 3;
- Mf::Settings::getInstance().get("detail", detail);
- script.push(detail); script.set("detail");
-
- script.push(Quad::LEFT); script.set("LEFT");
- script.push(Quad::RIGHT); script.set("RIGHT");
- script.push(Quad::TOP); script.set("TOP");
-
- script.push(X); script.set("X");
- script.push(Y); script.set("Y");
- script.push(Z); script.set("Z");
+ 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().set_field("detail", detail);
+
+ script.globals().set_field("LOW", 1);
+ script.globals().set_field("MEDIUM", 2);
+ script.globals().set_field("HIGH", 3);
+
+ script.globals().set_field("X", X);
+ script.globals().set_field("Y", Y);
+ script.globals().set_field("Z", Z);
+
+ script.globals().set_field("LEFT", Quad::LEFT);
+ script.globals().set_field("RIGHT", Quad::RIGHT);
+ script.globals().set_field("TOP", Quad::TOP);
}
- void loadFromFile()
+ moof::script::status load(moof::settings& settings, moof::script& script)
{
- Mf::Script script;
- std::string filePath = Scene::getPath(getName());
-
- script.importStandardLibraries();
- importLogScript(script);
- importSceneBindings(script);
-
- if (script.doFile(filePath) != Mf::Script::SUCCESS)
+ std::string path = moof::resource::find_file("scenes/"+name(), "lua");
+ if (path.empty())
{
- std::string str;
- script[-1].get(str);
- Mf::logScript("%s", str.c_str());
+ script.push("the scene file could not be found");
+ return moof::script::file_error;
}
+
+ importSceneBindings(settings, script);
+ return script.do_file(path);
}
- static int loadBox(Mf::Script& script, Mf::Aabb& aabb)
+ static int loadBox(moof::script& script, moof::aabb3& aabb)
{
- Mf::Script::Value table[] =
- {
- script[1].requireTable(),
- script[2].requireTable()
- };
-
- if (!table[0].isTable() || !table[1].isTable())
- {
- Mf::logWarning("wrong arguments to setPlayfieldBounds; ignoring...");
- return 0;
- }
+ script[1].require_table("point");
+ script[2].require_table("point");
- for (int i = 0; i <= 1; ++i)
- {
- for (int j = 1; j <= 3; ++j)
- {
- script.push((long)j);
- table[i].pushField();
- }
- }
-
- 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 setPlayfieldBounds(Mf::Script& script)
- {
- Mf::Aabb bounds;
- return loadBox(script, bounds);
- }
-
- int setMaximumBounds(Mf::Script& script)
+ int setBounds(moof::script& script)
{
- Mf::Aabb bounds;
- int ret = loadBox(script, bounds);
- octree = Mf::Octree<Quad>::alloc(bounds);
- return ret;
+ return loadBox(script, mBounds);
}
- int resetTransform(Mf::Script& script)
+ int resetTransform(moof::script& script)
{
- transform.identity();
+ mTransform.identity();
return 0;
}
- int translate(Mf::Script& script)
+ int translate(moof::script& script)
{
- Mf::Script::Value x = script[1].requireNumber();
- Mf::Script::Value y = script[2].requireNumber();
- Mf::Script::Value z = script[3].requireNumber();
+ 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::Vector3 vec;
- x.get(vec[0]);
- y.get(vec[1]);
- z.get(vec[2]);
-
- Mf::Matrix4 translation;
- cml::matrix_translation(translation, vec);
- transform = translation * transform;
+ 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]);
-
- Mf::Matrix4 scaling;
- cml::matrix_scale(scaling, vec);
- transform = scaling * transform;
+ moof::scalar value = 1.0;
+ script[1].require_number().get(value);
+
+ 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);
-
- Mf::Matrix4 scaling;
- cml::matrix_uniform_scale(scaling, value);
- transform = scaling * transform;
+ moof::vector3 vec;
+ script[1].require_number().get(vec[0]);
+ script[2].require_number().get(vec[1]);
+ script[3].require_number().get(vec[2]);
+
+ 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)
{
- Mf::Script::Value axis = script[1].requireString();
- Mf::Script::Value angle = script[2].requireNumber();
+ size_t index = 0;
+ moof::scalar value;
- size_t index = 0;
- axis.get(index);
+ script[1].require_number().get(index);
+ script[2].require_number().get(value);
- Mf::Scalar value;
- angle.get(value);
-
- cml::matrix_rotate_about_world_axis(transform, 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)
{
- Mf::Script::Value name = script[1].requireString();
-
- name.get(texture);
-
+ std::string texture_name;
+ script[1].require_string().get(texture_name);
+ mTexture = moof::resource::load(texture_name, "png");
return 0;
}
- int makeTilemap(Mf::Script& script)
+ int drawTilemap(moof::script& script)
{
- Mf::Script::Value table = script[1].requireTable();
- Mf::Script::Value top = script[-1];
-
- long width = 1;
- long height = 1;
+ moof::script::slot table = script[1].require_table();
- table.pushField("width");
- top.get(width);
+ int width = 1;
+ table.get(width, "width");
- long nTiles = 0;
-
- table.pushField("tiles");
- Mf::Script::Value tiles = script.getTop();
- nTiles = tiles.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");
+ }
- std::vector< std::vector<Tilemap::Index> > indices;
+ if (width == 0) table.raise("width field must not be zero");
+ int height = nTiles / width;
- int i, w, h;
+ moof::vector3 vertices[height+1][width+1];
- height = nTiles / width;
- indices.resize(height);
+ // 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
- i = 1;
- for (h = height - 1; h >= 0; --h)
+ for (int w = 0; w <= width; ++w)
{
- std::vector<Tilemap::Index> row;
+ vertices[height][w] = moof::demote(mTransform *
+ moof::vector4(w, height, 0.0, 1.0));
+ }
+ for (int h = 0; h < height; ++h)
+ {
+ vertices[h][0] = moof::demote(mTransform *
+ moof::vector4(0.0, h, 0.0, 1.0));
+ }
- for (w = 0; w < width; ++w, ++i)
+ size_t i = 1;
+ for (int h = height - 1; h >= 0; --h)
+ {
+ for (int w = 0; w < width; ++w, ++i)
{
- script.checkStack(2);
- script.push(long(i));
- tiles.pushField();
+ int wPlus1 = w + 1;
+ int hPlus1 = h + 1;
- Tilemap::Index index;
- top.get(index);
+ int index;
+ table.get(index, i);
- row.push_back(index);
- }
+ vertices[h][wPlus1] = moof::demote(mTransform *
+ moof::vector4(wPlus1, h, 0.0, 1.0));
- indices[h] = row;
- }
+ if (index == moof::image::no_tile) continue;
- Mf::Vector4 vertices[height+1][width+1];
+ const moof::vector3* corners[4] = {
+ &vertices[h][w],
+ &vertices[h][wPlus1],
+ &vertices[hPlus1][wPlus1],
+ &vertices[hPlus1][w]
+ };
- Mf::Matrix4 transposedTransform = transform;
- transposedTransform.transpose();
+ Quad* quad = new Quad(corners, mTexture, index);
+ //quad->setSurface(surface);
- for (int h = 0; h <= height; ++h)
- {
- for (int w = 0; w <= width; ++w)
- {
- vertices[h][w] = Mf::Vector4(w, h, 0.0, 1.0) * transposedTransform;
+ boost::shared_ptr<Quad> quadPtr(quad);
+ mObjects.push_back(quadPtr);
}
}
- for (int h = 0; h < height; ++h)
- {
- for (int w = 0; w < width; ++w)
- {
- if (indices[h][w] == Tilemap::NO_TILE) continue;
-
- Mf::Vector3 quadVertices[4];
+ Quad::Surface surface = Quad::NONE;
+ table.get(surface, "surface");
- quadVertices[0] = Mf::demote(vertices[h][w]);
- quadVertices[1] = Mf::demote(vertices[h][w+1]);
- quadVertices[2] = Mf::demote(vertices[h+1][w+1]);
- quadVertices[3] = Mf::demote(vertices[h+1][w]);
+ if (surface != Quad::NONE)
+ {
+ // need a 2d line for collisions
+ // assuming the camera always looks directly to -z when the
+ // scene is built, simply demoting the vector again should
+ // project the points to the xy-plane
- Quad* quad = new Quad(quadVertices, texture, indices[h][w]);
- boost::shared_ptr<Quad> quadPtr(quad);
+ moof::vector2 bl = moof::demote(vertices[0][0]);
+ moof::vector2 tr = moof::demote(vertices[height][width]);
- octree->insert(quadPtr);
- }
+ mLines.push_back(moof::line<2>(bl, tr));
}
-
return 0;
}
- int makeBillboard(Mf::Script& script)
+ int drawTile(moof::script& script)
{
- Mf::Script::Value table = script[1];
- Mf::Script::Value top = script[-1];
+ moof::script::slot param = script[1];
+ moof::script::slot top = script[-1];
- long index = 0;
- long width = 1;
+ int index = 0;
+ int width = 1;
bool blending = false;
bool fog = false;
- if (table.isTable())
+ if (param.is_table())
{
- table.pushField("tile");
- top.get(index);
-
- table.pushField("u_scale");
- top.get(width);
-
- table.pushField("blend");
- top.get(blending);
-
- table.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.is_number())
+ {
+ param.get(index);
}
- Mf::Vector4 vertices[2][width+1];
-
- Mf::Matrix4 transposedTransform = transform;
- transposedTransform.transpose();
+ 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::Vector4(xf, Mf::Scalar(h), 0.0, 1.0) *
- transposedTransform;
+ vertices[h][w] = moof::demote(mTransform *
+ moof::vector4(xf, moof::scalar(h), 0.0, 1.0));
}
}
for (int w = 0; w < width; ++w)
{
- Mf::Vector3 quadVertices[4];
+ int wPlus1 = w + 1;
- quadVertices[0] = Mf::demote(vertices[0][w]);
- quadVertices[1] = Mf::demote(vertices[0][w+1]);
- quadVertices[2] = Mf::demote(vertices[1][w+1]);
- quadVertices[3] = Mf::demote(vertices[1][w]);
+ const moof::vector3* corners[4] = {
+ &vertices[0][w],
+ &vertices[0][wPlus1],
+ &vertices[1][wPlus1],
+ &vertices[1][w]
+ };
- Quad* quad = new Quad(quadVertices, texture, Tilemap::Index(index));
+ Quad* quad = new Quad(corners, mTexture, index);
quad->setBlending(blending);
quad->setFog(fog);
boost::shared_ptr<Quad> quadPtr(quad);
-
- octree->insert(quadPtr);
+ mObjects.push_back(quadPtr);
}
return 0;
Scene::Scene(const std::string& name) :
// pass through
- impl_(Scene::Impl::getInstance(name)) {}
+ impl_(Scene::impl::instance(name)) {}
-void Scene::draw(Mf::Scalar alpha) const
+moof::script::status Scene::load(moof::settings& settings, moof::script& script)
{
- impl_->octree->draw(alpha);
+ // pass through
+ return impl_->load(settings, script);
+}
+
+
+void Scene::draw(moof::scalar alpha) const
+{
+ 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);
+ }
+
+ 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
{
- impl_->octree->drawIfVisible(alpha, frustum);
+ 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_if_visible(alpha, frustum);
+ }
+
+ 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);
+ }
+
+ impl_->mBounds.draw();
}
-std::string Scene::getPath(const std::string& name)
+bool Scene::castRay(const moof::ray<2>& ray,
+ std::list<moof::ray<2>::contact>& hits) const
{
- return Mf::Resource::getPath("scenes/" + name + ".lua");
+ std::list< moof::line<2> >& lines = impl_->mLines;
+ std::list< moof::line<2> >::const_iterator it;
+
+ for (it = lines.begin(); it != lines.end(); ++it)
+ {
+ moof::ray<2>::contact hit;
+ moof::scalar d = (*it).intersect_ray(ray, hit);
+ if (d > 0.0)
+ {
+ hits.push_back(hit);
+ //return true;
+ }
+ }
+
+ hits.sort();
+ return !hits.empty();
+ //return false;
}
+bool Scene::checkForCollision(Character& character)
+{
+ return false;
+
+ std::list< boost::shared_ptr<impl::Quad> >& objects = impl_->mObjects;
+ std::list< boost::shared_ptr<impl::Quad> >::const_iterator it;
-/** vim: set ts=4 sw=4 tw=80: *************************************************/
+ int collisions = 0;
+ 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;
+
+ if (moof::checkCollision(sphere, (*it)->sphere()))
+ {
+ ++collisions;
+
+ moof::vector2 impulse(0.0, 0.0);
+ moof::vector2 p = character.state().momentum;
+
+ 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.state(alpha);
+ }
+
+ character.setPosition(state.position);
+
+ //switch (type)
+ //{
+ //case impl::Quad::TOP:
+ //if (p[1] < 0.0) impulse[1] = -p[1];
+ //break;
+ //case impl::Quad::LEFT:
+ //if (p[0] > 0.0) impulse[0] = 1.5*-p[0];
+ //break;
+ //case impl::Quad::RIGHT:
+ //if (p[0] < 0.0) impulse[0] = 1.5*-p[0];
+ //break;
+ //}
+
+ //character.addImpulse(impulse);
+ }
+ }
+
+ if (collisions > 0)
+ {
+ moof::log_info << "collisions: " << collisions << std::endl;
+ }
+
+ return false;
+}