X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FScene.cc;h=fe49ed276d8706edc8626b566db7db51dd108dd8;hp=5f4a440c4ce0d06655afe62ed06de1b9b1d456db;hb=ca0f7bdfba63140dca0bd20586d31980f3938eb2;hpb=16d1a05b0777e97a45c48e2874aa4e5cc791282e diff --git a/src/Moof/Scene.cc b/src/Moof/Scene.cc index 5f4a440..fe49ed2 100644 --- a/src/Moof/Scene.cc +++ b/src/Moof/Scene.cc @@ -26,481 +26,399 @@ *******************************************************************************/ -#include #include #include #include "Aabb.hh" #include "Camera.hh" -#include "Cullable.hh" -#include "Deserializer.hh" -#include "Drawable.hh" +#include "Entity.hh" +#include "Log.hh" #include "Math.hh" -#include "Mippleton.hh" -#include "OpenGL.hh" #include "Scene.hh" -#include "Serializable.hh" +#include "Script.hh" +#include "Settings.hh" #include "Tilemap.hh" namespace Mf { -class Scene::SceneImpl : public Mippleton +static std::string getPath(const std::string& name) { - class Scenery : public Drawable, public Cullable + return Resource::getPath("scenes/" + name + ".lua"); +} + + +struct Meh +{ + Matrix4 transform; + std::string texture; + + OctreeP octree; + + Meh() { - public: - Scenery(const Matrix4& transform, const std::string& textureName) : - transformation(transform), - image(textureName) {} - - protected: - Matrix4 transformation; - Tilemap image; - bool blending; - long detail; - bool fog; - }; - - class TilePanel : public Scenery + octree = Octree::alloc(Aabb()); + } + + static int loadBox(Script& script, Aabb& aabb) { - public: - TilePanel(const Matrix4& transform, const std::string& textureName, - SerializablePtr root) : - Scenery(transform, textureName), - width(1), - height(1) + Script::Value table[] = {script[1], script[2]}; + + if (!table[0].isTable() || !table[1].isTable()) { - std::map rootObj; + logWarning("wrong arguments to setPlayfieldBounds; ignoring..."); + return 0; + } - if (root->get(rootObj)) + for (int i = 0; i <= 1; ++i) + { + for (int j = 1; j <= 3; ++j) { - std::map::iterator it; - - if ((it = rootObj.find("width")) != rootObj.end()) - { - (*it).second->get(width); - } - if ((it = rootObj.find("tiles")) != rootObj.end()) - { - std::vector theTiles; - - if ((*it).second->get(theTiles)) - { - std::vector::iterator jt; + script.push((long)j); + table[i].pushField(); + } + } - height = theTiles.size() / width; - int w, h; + 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]); - indices.resize(height); + return 0; + } - for (h = height - 1, jt = theTiles.begin(); - jt != theTiles.end(); h--) - { - std::vector row; + int setPlayfieldBounds(Script& script) + { + Aabb bounds; + return loadBox(script, bounds); + } - for (w = 0; w < width && jt != theTiles.end(); - w++, jt++) - { - long index; + int setMaximumBounds(Script& script) + { + Aabb bounds; + int ret = loadBox(script, bounds); + octree = Octree::alloc(bounds); + return ret; + } - if ((*jt)->get(index)) - { - row.push_back(Tilemap::Index(index)); - } - } + int resetTransform(Script& script) + { + transform.identity(); + return 0; + } - indices[h] = row; - } - } - } - } - } + int translate(Script& script) + { + Script::Value x = script[1]; + Script::Value y = script[2]; + Script::Value z = script[3]; - void draw(Scalar alpha) + if (!x.isNumber() || !y.isNumber() || !z.isNumber()) { - glPushMatrix(); - //std::cout << "transforming..." << std::endl; - //std::cout << transformation << std::endl; - glMultMatrix(transformation.data()); + logWarning("wrong arguments to translate; ignoring..."); + return 0; + } - glColor4f(1.0f, 1.0f, 1.0f, 1.0f); - image.bind(); + Vector3 vec; + x.get(vec[0]); + y.get(vec[1]); + z.get(vec[2]); - long x, y; - Scalar xf, yf; + Matrix4 translation; + cml::matrix_translation(translation, vec); + transform = translation * transform; - for (y = 0, yf = 0.0; y < height; y++, yf += 1.0) - { - for (x = 0, xf = 0.0; x < width; x++, xf += 1.0) - { - Scalar texCoords[8]; - - Tilemap::Index index = indices[y][x]; - - if (image.getTileCoords(index, texCoords)) - { - glBegin(GL_TRIANGLE_FAN); - glTexCoord2f(texCoords[0], texCoords[1]); - glVertex2f(xf, yf); - glTexCoord2f(texCoords[2], texCoords[3]); - glVertex2f(xf+1.0, yf); - glTexCoord2f(texCoords[4], texCoords[5]); - glVertex2f(xf+1.0, yf+1.0); - glTexCoord2f(texCoords[6], texCoords[7]); - glVertex2f(xf, yf+1.0); - glEnd(); - } - } - } + return 0; + } - glPopMatrix(); + int scale(Script& script) + { + if (script.getSize() == 3) + { + Vector3 vec; + script[1].get(vec[0]); + script[2].get(vec[1]); + script[3].get(vec[2]); + + Matrix4 scaling; + cml::matrix_scale(scaling, vec); + transform = scaling * transform; } + else if (script.getSize() == 1) + { + Scalar value = 1.0; + script[1].get(value); - bool isVisible(const Camera& cam) + Matrix4 scaling; + cml::matrix_uniform_scale(scaling, + Scalar(value)); + transform = scaling * transform; + } + else { - return true; + logWarning("wrong arguments to scale; ignoring..."); } - private: - long width, height; - std::vector > indices; - }; + return 0; + } - class Billboard : public Scenery + int rotate(Script& script) { - public: - Billboard(const Matrix4& transform, const std::string& textureName, - SerializablePtr root) : - Scenery(transform, textureName), - index(0), - uScale(1) + Script::Value a = script[1]; + Script::Value d = script[2]; + + if (!a.isString() || !d.isNumber()) { - std::map rootObj; + logWarning("wrong arguments to rotate; ignoring..."); + return 0; + } - if (root->get(rootObj)) - { - std::map::iterator it; + std::string axis; + a.get(axis); - if ((it = rootObj.find("tile")) != rootObj.end()) - { - long value; - if ((*it).second->get(value)) - { - index = Tilemap::Index(value); - } - } - if ((it = rootObj.find("u_scale")) != rootObj.end()) - { - (*it).second->get(uScale); - } - } + size_t index = 0; + if (axis == "x") index = 0; + else if (axis == "y") index = 1; + else if (axis == "z") index = 2; - image.getTileCoords(index, texCoords); - } + Scalar value; + d.get(value); - void draw(Scalar alpha) - { - glPushMatrix(); - glMultMatrix(transformation.data()); + cml::matrix_rotate_about_world_axis(transform, + index, cml::rad(Scalar(value))); + + return 0; + } - glColor4f(1.0f, 1.0f, 1.0f, 1.0f); - image.bind(); + int setTexture(Script& script) + { + Script::Value t = script[1]; - float increment = 1.0f / float(uScale); - int x; - float xf; + if (t.isString()) t.get(texture); + else logWarning("wrong arguments to setTexture; ignoring..."); - for (x = 0, xf = 0.0f; x < uScale; x++, xf += increment) - { - glBegin(GL_TRIANGLE_FAN); - glTexCoord2f(texCoords[0], texCoords[1]); - glVertex2f(xf, 0.0f); - glTexCoord2f(texCoords[2], texCoords[3]); - glVertex2f(xf+increment, 0.0f); - glTexCoord2f(texCoords[4], texCoords[5]); - glVertex2f(xf+increment, 1.0f); - glTexCoord2f(texCoords[6], texCoords[7]); - glVertex2f(xf, 1.0f); - glEnd(); - } + return 0; + } - glPopMatrix(); - } + int makeTilemap(Script& script) + { + Script::Value table = script[1]; + Script::Value top = script[-1]; - bool isVisible(const Camera& cam) + if (!table.isTable()) { - return false; + logWarning("wrong arguments to makeTilemap; ignoring..."); + return 0; } - private: - Tilemap::Index index; - Scalar texCoords[8]; - long uScale; - }; + long width = 1; + long height = 1; + table.pushField("width"); + top.get(width); - static bool loadBox(Aabb& theBox, SerializablePtr obj) - { - std::vector numbers; + long nTiles = 0; + + table.pushField("tiles"); + Script::Value tiles = script.getTop(); + nTiles = tiles.getLength(); - if (obj->get(numbers)) + std::vector< std::vector > indices; + + if (nTiles % width == 0) { - if (numbers.size() == 6) + int i, w, h; + + 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 + + i = 1; + for (h = height - 1; h >= 0; --h) { - double num; + std::vector row; - if (numbers[0]->getNumber(num)) + for (w = 0; w < width; ++w, ++i) { + script.checkStack(2); + script.push(long(i)); + tiles.pushField(); + long index; + top.get(index); + + row.push_back(Tilemap::Index(index)); } + + indices[h] = row; } } + else + { + logError("invalid tiles in tilemap instruction"); + return 0; + } - return false; - } - -public: - SceneImpl(const std::string& name) : - Mippleton(name) - { - loadFromFile(); - } + Vector4 vertices[height+1][width+1]; + Matrix4 transposedTransform = transform; + transposedTransform.transpose(); - void loadInstructions(SerializablePtr root) - { - std::vector rootObj; + for (int h = 0; h <= height; ++h) + { + for (int w = 0; w <= width; ++w) + { + vertices[h][w] = Vector4(Scalar(w), Scalar(h), 0.0, 1.0) * + transposedTransform; + } + } - if (root->get(rootObj)) + for (int h = 0; h < height; ++h) { - std::vector::iterator it; + for (int w = 0; w < width; ++w) + { + if (indices[h][w] == Tilemap::NO_TILE) continue; - Matrix4 transform; - std::string texture; + Vector3 quadVertices[4]; - for (it = rootObj.begin(); it != rootObj.end(); it++) - { - std::string instruction; + demoteVector(quadVertices[0], vertices[h][w]); + demoteVector(quadVertices[1], vertices[h][w+1]); + demoteVector(quadVertices[2], vertices[h+1][w+1]); + demoteVector(quadVertices[3], vertices[h+1][w]); - if ((*it)->get(instruction)) - { - if (instruction == "reset_transform") - { - transform.identity(); - //std::cout << "===================RESET=====================" << std::endl; - } - else if (instruction == "translate") - { - std::vector values; - - it++; - if ((*it)->get(values)) - { - Vector3 vec; - - for (size_t i = 0; i < values.size(); i++) - { - double value; - - if (values[i]->getNumber(value)) - { - vec[i] = value; - } - } - - Matrix4 translation; - cml::matrix_translation(translation, vec); - transform = translation * transform; - //std::cout << "TRANSLATE\t" << vec << std::endl - //<< transform << std::endl; - } - } - else if (instruction == "scale") - { - std::vector values; - - it++; - if ((*it)->get(values)) - { - if (values.size() == 1) - { - double value = 1.0; - - values[0]->getNumber(value); - - Matrix4 scaling; - cml::matrix_uniform_scale(scaling, Scalar(value)); - transform = scaling * transform; - //std::cout << "SCALE\t\t" << value << std::endl - //<< transform << std::endl; - } - else if (values.size() == 3) - { - Vector3 vec; - - for (size_t i = 0; i < values.size(); i++) - { - double value; - - if (values[i]->getNumber(value)) - { - vec[i] = value; - } - } - - Matrix4 scaling; - cml::matrix_scale(scaling, vec); - transform = scaling * transform; - //std::cout << "SCALE\t\t" << vec << std::endl - //<< transform << std::endl; - } - } - } - else if (instruction == "rotate") - { - std::vector values; - - it++; - if ((*it)->get(values)) - { - if (values.size() == 2) - { - std::string axis; - size_t axisIndex = 0; - double value = 0.0; - - if (values[0]->get(axis)) - { - if (axis == "x") - { - axisIndex = 0; - } - else if (axis == "y") - { - axisIndex = 1; - } - else if (axis == "z") - { - axisIndex = 2; - } - values[1]->getNumber(value); - } - - cml::matrix_rotate_about_local_axis(transform, - axisIndex, Scalar(value * cml::constantsd::rad_per_deg())); - //std::cout << "ROTATE\t" << axis << " " << value << std::endl - //<< transform << std::endl; - } - } - } - else if (instruction == "texture") - { - it++; - (*it)->get(texture); - } - else if (instruction == "tilemap") - { - //std::cout << "TILEMAP\t" << texture<< std::endl; - //std::cout << transform << std::endl; - - it++; - TilePanel* tilePanel = new TilePanel(transform, texture, - *it); - boost::shared_ptr sceneItem(tilePanel); - objects.push_back(sceneItem); - } - else if (instruction == "billboard") - { - //std::cout << "BILLBOARD\t" << texture << std::endl; - //std::cout << transform << std::endl; - - it++; - Billboard* billboard = new Billboard(transform, texture, - *it); - boost::shared_ptr sceneItem(billboard); - objects.push_back(sceneItem); - } - } + Quad* quad = new Quad(quadVertices, texture, indices[h][w]); + boost::shared_ptr quadPtr(quad); + + octree->insert(quadPtr); } } - } + return 0; + } - void loadFromFile() + int makeBillboard(Script& script) { - std::string filePath = Scene::getPathToResource(getName()); + Script::Value table = script[1]; + Script::Value top = script[-1]; - Deserializer deserializer(filePath, true); + long index = 0; + long width = 1; + bool blending = false; + bool fog = false; - SerializablePtr root = deserializer.deserialize(); - - if (root) + if (table.isTable()) { - std::map rootObj; + table.pushField("tile"); + if (top.isNumber()) top.get(index); - if (root->get(rootObj)) - { - std::map::iterator it; + table.pushField("u_scale"); + if (top.isNumber()) top.get(width); - if ((it = rootObj.find("playfield_bounds")) != rootObj.end()) - { - loadBox(playfieldBounds, (*it).second); - } - if ((it = rootObj.find("maximum_bounds")) != rootObj.end()) - { - loadBox(maximumBounds, (*it).second); - } - if ((it = rootObj.find("instructions")) != rootObj.end()) - { - loadInstructions((*it).second); - } - } + table.pushField("blend"); + if (top.isBoolean()) top.get(blending); + + table.pushField("fog"); + if (top.isBoolean()) top.get(fog); } - } + Vector4 vertices[2][width+1]; - void draw(Scalar alpha) - { - SceneryVector::iterator it; + Matrix4 transposedTransform = transform; + transposedTransform.transpose(); - for (it = objects.begin(); it != objects.end(); it++) + Scalar xf; + Scalar increment = 1.0 / Scalar(width); + + for (int h = 0; h <= 1; ++h) { - //std::cout << "draw object"; - (*it)->draw(alpha); + xf = 0.0; + for (int w = 0; w <= width; ++w, xf += increment) + { + vertices[h][w] = Vector4(xf, Scalar(h), 0.0, 1.0) * + transposedTransform; + } } - } + for (int w = 0; w < width; ++w) + { + Vector3 quadVertices[4]; + + demoteVector(quadVertices[0], vertices[0][w]); + demoteVector(quadVertices[1], vertices[0][w+1]); + demoteVector(quadVertices[2], vertices[1][w+1]); + demoteVector(quadVertices[3], vertices[1][w]); - Aabb playfieldBounds; - Aabb maximumBounds; + Quad* quad = new Quad(quadVertices, texture, Tilemap::Index(index)); + quad->setBlending(blending); + quad->setFog(fog); - typedef std::vector > SceneryVector; - SceneryVector objects; -}; + boost::shared_ptr quadPtr(quad); + octree->insert(quadPtr); + } -Scene::Scene(const std::string& name) : - // pass through - impl_(Scene::SceneImpl::retain(name), &Scene::SceneImpl::release) {} + return 0; + } +}; -void Scene::draw(Scalar alpha) +static void importScriptBindings(Script& script, Meh& scene) { - // pass through - impl_->draw(alpha); + script.importFunction("SetPlayfieldBounds", + boost::bind(&Meh::setPlayfieldBounds, &scene, _1)); + script.importFunction("SetMaximumBounds", + boost::bind(&Meh::setMaximumBounds, &scene, _1)); + script.importFunction("ResetTransform", + boost::bind(&Meh::resetTransform, &scene, _1)); + script.importFunction("Translate", + boost::bind(&Meh::translate, &scene, _1)); + script.importFunction("Scale", + boost::bind(&Meh::scale, &scene, _1)); + script.importFunction("Rotate", + boost::bind(&Meh::rotate, &scene, _1)); + script.importFunction("SetTexture", + boost::bind(&Meh::setTexture, &scene, _1)); + script.importFunction("MakeTilemap", + boost::bind(&Meh::makeTilemap, &scene, _1)); + script.importFunction("MakeBillboard", + boost::bind(&Meh::makeBillboard, &scene, _1)); } -/** - * Specialized search location for scene files. They can be found in the - * "scenes" subdirectory of any of the searched directories. - */ - -std::string Scene::getPathToResource(const std::string& name) +OctreeP loadScene(const std::string& name) { - return Resource::getPathToResource("scenes/" + name + ".json"); + std::string filePath = getPath(name); + + Meh cool; + + Script script; + script.importStandardLibraries(); + importLogScript(script); + importScriptBindings(script, cool); + + long detail = 3; + Settings::getInstance().get("detail", detail); + + script.push(detail); + script.set("detail"); + + logInfo("doing file..."); + if (script.doFile(filePath) != 0) + { + std::string str; + script[-1].get(str); + logError("lua error: %s", str.c_str()); + } + logInfo("done"); + + cool.octree->sort(); + return cool.octree; }