#include "Entity.hh"
#include "Math.hh"
#include "Mippleton.hh"
-#include "Octree.hh"
#include "OpenGL.hh"
#include "Scene.hh"
#include "Serializable.hh"
namespace Mf {
-class Scene::SceneImpl : public Mippleton<SceneImpl>
+class Scene::Impl : public Mippleton<Impl>
{
class Quad : public Entity
{
{
std::cerr << "no coords for tile's texture" << std::endl;
}
+
+ aabb_.encloseVertices(vertices, 4);
+ sphere_.point = aabb_.getCenter();
+ sphere_.radius = (aabb_.min - sphere_.point).length();
}
void setDetail(long detail)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
+ if (fog_)
+ {
+ glEnable(GL_FOG);
+ glFogi(GL_FOG_MODE, GL_LINEAR);
+ }
+
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
tilemap_.bind();
- //glEnableClientState(GL_VERTEX_ARRAY);
- //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-
- //glVertexPointer(3, GL_SCALAR, 0, vertices_);
- //glTexCoordPointer(2, GL_SCALAR, 0, texCoords_);
-
- //glDrawArrays(GL_TRIANGLE_FAN, 0, sizeof(vertices_));
+ glVertexPointer(3, GL_SCALAR, 0, vertices_);
+ glTexCoordPointer(2, GL_SCALAR, 0, texCoords_);
- //glDisableClientState(GL_VERTEX_ARRAY);
- //glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
- glBegin(GL_TRIANGLE_FAN);
- glTexCoord2f(texCoords_[0], texCoords_[1]);
- glVertex3v(vertices_);
- glTexCoord2f(texCoords_[2], texCoords_[3]);
- glVertex3v(vertices_+3);
- glTexCoord2f(texCoords_[4], texCoords_[5]);
- glVertex3v(vertices_+6);
- glTexCoord2f(texCoords_[6], texCoords_[7]);
- glVertex3v(vertices_+9);
- glEnd();
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisable(GL_BLEND);
+ glDisable(GL_FOG);
}
bool isVisible(const Camera& cam) const
{
- return aabb_.isVisible(cam);
+ return sphere_.isVisible(cam);
}
private:
};
- static void loadBox(Aabb& theBox, SerializablePtr obj)
+ static void loadBox(Aabb& theBox, SerializableP obj)
{
- std::vector<SerializablePtr> numbers;
+ Serializable::Array numbers;
if (obj->get(numbers) && numbers.size() == 6)
{
- double num;
+ Serializable::Float num;
if (numbers[0]->getNumber(num)) theBox.min[0] = Scalar(num);
if (numbers[1]->getNumber(num)) theBox.min[1] = Scalar(num);
}
public:
- SceneImpl(const std::string& name) :
- Mippleton<SceneImpl>(name)
+ Impl(const std::string& name) :
+ Mippleton<Impl>(name)
{
loadFromFile();
}
- void loadInstructions(SerializablePtr root)
+ void loadInstructions(SerializableP root)
{
- std::vector<SerializablePtr> rootObj;
- std::vector<SerializablePtr>::iterator it;
+ Serializable::Array rootObj;
+ Serializable::Array::iterator it;
if (!root->get(rootObj))
{
}
else if (instruction == "translate")
{
- std::vector<SerializablePtr> values;
+ Serializable::Array values;
++it;
if ((*it)->get(values))
for (size_t i = 0; i < values.size(); ++i)
{
- double value;
+ Serializable::Float value;
if (values[i]->getNumber(value))
{
}
else if (instruction == "scale")
{
- std::vector<SerializablePtr> values;
+ Serializable::Array values;
++it;
if ((*it)->get(values))
{
if (values.size() == 1)
{
- double value = 1.0;
+ Serializable::Float value = 1.0;
values[0]->getNumber(value);
for (size_t i = 0; i < values.size(); ++i)
{
- double value;
+ Serializable::Float value;
if (values[i]->getNumber(value))
{
}
else if (instruction == "rotate")
{
- std::vector<SerializablePtr> values;
+ Serializable::Array values;
++it;
if ((*it)->get(values))
{
std::string axis;
size_t index = 0;
- double value = 0.0;
+ Serializable::Float value = 0.0;
if (values[0]->get(axis))
{
}
- void loadTilemap(SerializablePtr root, const Matrix4& transform,
+ void loadTilemap(SerializableP root, const Matrix4& transform,
const std::string& texture)
{
- std::map<std::string,SerializablePtr> rootObj;
- std::map<std::string,SerializablePtr>::iterator it;
+ Serializable::Map rootObj;
+ Serializable::Map::iterator it;
if (!root->get(rootObj))
{
return;
}
- std::vector<SerializablePtr> tiles;
+ Serializable::Array tiles;
if ((it = rootObj.find("tiles")) != rootObj.end() &&
(*it).second->get(tiles) &&
tiles.size() % width == 0)
{
- std::vector<SerializablePtr>::iterator jt;
+ Serializable::Array::iterator jt;
int w, h;
height = tiles.size() / width;
for (w = 0; w < width && jt != tiles.end(); ++w, ++jt)
{
- long index;
+ Serializable::Integer index;
if ((*jt)->get(index))
{
Quad* quad = new Quad(quadVertices, texture, indices[h][w]);
boost::shared_ptr<Quad> quadPtr(quad);
- objects.push_back(quadPtr);
+ octree->insert(quadPtr);
}
}
}
- void loadBillboard(SerializablePtr root, const Matrix4& transform,
+ void loadBillboard(SerializableP root, const Matrix4& transform,
const std::string& texture)
{
- std::map<std::string,SerializablePtr> rootObj;
- std::map<std::string,SerializablePtr>::iterator it;
-
- if (!root->get(rootObj))
- {
- std::cerr << "error loading scene billboard object" << std::endl;
- return;
- }
+ Serializable::Map rootObj;
+ Serializable::Map::iterator it;
Tilemap::Index index = 0;
long width = 1;
bool blending = false;
bool fog = false;
- if ((it = rootObj.find("tile")) != rootObj.end())
+ if (root->get(rootObj))
{
- long value;
- if ((*it).second->get(value))
+ if ((it = rootObj.find("tile")) != rootObj.end())
{
- index = Tilemap::Index(value);
+ Serializable::Integer value;
+ if ((*it).second->get(value))
+ {
+ index = Tilemap::Index(value);
+ }
}
- }
- if ((it = rootObj.find("u_scale")) != rootObj.end())
- {
- (*it).second->get(width);
- }
+ if ((it = rootObj.find("u_scale")) != rootObj.end())
+ {
+ (*it).second->get(width);
+ }
- if ((it = rootObj.find("blend")) != rootObj.end())
- {
- (*it).second->get(blending);
- }
+ if ((it = rootObj.find("blend")) != rootObj.end())
+ {
+ (*it).second->get(blending);
+ }
- if ((it = rootObj.find("fog")) != rootObj.end())
- {
- (*it).second->get(fog);
+ if ((it = rootObj.find("fog")) != rootObj.end())
+ {
+ (*it).second->get(fog);
+ }
}
boost::shared_ptr<Quad> quadPtr(quad);
- objects.push_back(quadPtr);
+ octree->insert(quadPtr);
}
}
void loadFromFile()
{
- std::string filePath = Scene::getPathToResource(getName());
+ std::string filePath = Scene::getPath(getName());
Deserializer deserializer(filePath, true);
- SerializablePtr root = deserializer.deserialize();
+ SerializableP root = deserializer.deserialize();
- std::map<std::string,SerializablePtr> rootObj;
- std::map<std::string,SerializablePtr>::iterator it;
+ Serializable::Map rootObj;
+ Serializable::Map::iterator it;
if (!root || !root->get(rootObj))
{
{
loadBox(maximumBounds, (*it).second);
}
+ else
+ {
+ std::cerr << "maximum bounds required in scene" << std::endl;
+ return;
+ }
+
+ // create the tree to store the quads
+ octree = Octree::alloc(maximumBounds);
+
if ((it = rootObj.find("instructions")) != rootObj.end())
{
loadInstructions((*it).second);
}
+
+ octree->sort();
}
- void draw(Scalar alpha)
+ void draw(Scalar alpha, const Camera& cam) const
{
- QuadVector::iterator it;
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- for (it = objects.begin(); it != objects.end(); ++it)
- {
- //std::cout << "draw object";
- (*it)->draw(alpha);
- }
+ octree->drawIfVisible(alpha, cam);
- glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+ //glDisableClientState(GL_VERTEX_ARRAY);
+ //glDisableClientState(GL_TEXTURE_COORD_ARRAY);
- glBindTexture(GL_TEXTURE_2D, 0);
- glColor3f(0.0f, 1.0f, 0.0f);
- playfieldBounds.draw();
- glColor3f(0.0f, 0.0f, 1.0f);
- maximumBounds.draw();
+ //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
- glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+ //Texture::resetBind();
+ //glColor3f(0.0f, 1.0f, 0.0f);
+ //playfieldBounds.draw();
+ //glColor3f(0.0f, 0.0f, 1.0f);
+ //maximumBounds.draw();
+
+ //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
Aabb playfieldBounds;
Aabb maximumBounds;
- typedef std::vector< boost::shared_ptr<Quad> > QuadVector;
- QuadVector objects;
+ OctreeP octree;
};
Scene::Scene(const std::string& name) :
// pass through
- impl_(Scene::SceneImpl::retain(name), &Scene::SceneImpl::release) {}
+ impl_(Scene::Impl::getInstance(name)) {}
-void Scene::draw(Scalar alpha) const
+void Scene::draw(Scalar alpha, const Camera& cam) const
{
// pass through
- impl_->draw(alpha);
+ impl_->draw(alpha, cam);
}
void Scene::refresh()
{
- impl_->objects.clear();
+ //impl_->objects.clear();
impl_->loadFromFile();
}
+OctreeP Scene::getOctree() const
+{
+ // pass through
+ return impl_->octree;
+}
+
/**
* 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)
+std::string Scene::getPath(const std::string& name)
{
- return Resource::getPathToResource("scenes/" + name + ".json");
+ return Resource::getPath("scenes/" + name + ".json");
}
projects / chaz / yoink / blobdiff