git.mutantstargoat.com Git - ld37_one_room/blob - src/scene.cc

   1 #include <regex>
   2 #include "scene.h"
   3 #include "objmesh.h"
   4 #include "app.h"
   5
   6 static void destroy_node_tree(SceneNode *n);
   7
   8 Scene::Scene()
   9 {
  10         metascn = 0;
  11         nodes = 0;
  12
  13         walk_mesh = 0;
  14
  15         texset = 0;
  16         loader_data = 0;
  17 }
  18
  19 Scene::~Scene()
  20 {
  21         destroy();
  22 }
  23
  24 void Scene::destroy()
  25 {
  26         clear();
  27
  28         metascn = 0;
  29         texset = 0;
  30         loader_data = 0;
  31
  32         datamap.clear();
  33 }
  34
  35 void Scene::clear()
  36 {
  37         destroy_node_tree(nodes);
  38         nodes = 0;
  39
  40         for(int i=0; i<(int)meshes.size(); i++) {
  41                 delete meshes[i];
  42         }
  43         meshes.clear();
  44
  45         delete walk_mesh;
  46         walk_mesh = 0;
  47
  48         for(int i=0; i<(int)objects.size(); i++) {
  49                 delete objects[i];
  50         }
  51         objects.clear();
  52 }
  53
  54 static void destroy_node_tree(SceneNode *n)
  55 {
  56         if(!n) return;
  57
  58         int nsub = n->get_num_children();
  59         for(int i=0; i<nsub; i++) {
  60                 destroy_node_tree(n->get_child(i));
  61         }
  62         delete n;
  63 }
  64
  65 // Scene::load defined in sceneload.cc
  66
  67 bool Scene::merge(Scene *scn)
  68 {
  69         if(walk_mesh) {
  70                 if(scn->walk_mesh) {
  71                         walk_mesh->append(*scn->walk_mesh);
  72                         delete scn->walk_mesh;
  73                         scn->walk_mesh = 0;
  74                 }
  75         } else {
  76                 walk_mesh = scn->walk_mesh;
  77                 scn->walk_mesh = 0;
  78         }
  79
  80         int nmeshes = scn->meshes.size();
  81         for(int i=0; i<nmeshes; i++) {
  82                 meshes.push_back(scn->meshes[i]);
  83         }
  84         scn->meshes.clear();
  85
  86         int nobj = scn->objects.size();
  87         for(int i=0; i<nobj; i++) {
  88                 objects.push_back(scn->objects[i]);
  89         }
  90         scn->objects.clear();
  91
  92         if(nodes) {
  93                 int nchildren = scn->nodes ? scn->nodes->get_num_children() : 0;
  94                 for(int i=0; i<nchildren; i++) {
  95                         SceneNode *n = scn->nodes->get_child(i);
  96                         scn->nodes->remove_child(n);
  97                         nodes->add_child(n);
  98                 }
  99                 if(scn->nodes && scn->nodes->get_num_objects() > 0) {
 100                         warning_log("merging with scene which has objects in its root node. these objects will not be merged!\n");
 101                 }
 102                 delete scn->nodes;
 103         } else {
 104                 nodes = scn->nodes;
 105         }
 106         scn->nodes = 0;
 107
 108         return true;
 109 }
 110
 111 void Scene::add_object(Object *obj)
 112 {
 113         objects.push_back(obj);
 114 }
 115
 116 bool Scene::remove_object(Object *obj)
 117 {
 118         std::vector<Object*>::iterator it = std::find(objects.begin(), objects.end(), obj);
 119         if(it != objects.end()) {
 120                 objects.erase(it);
 121                 return true;
 122         }
 123         return false;
 124 }
 125
 126 bool Scene::have_object(Object *obj) const
 127 {
 128         return std::find(objects.begin(), objects.end(), obj) != objects.end();
 129 }
 130
 131 void Scene::add_mesh(Mesh *m)
 132 {
 133         meshes.push_back(m);
 134 }
 135
 136 bool Scene::remove_mesh(Mesh *m)
 137 {
 138         std::vector<Mesh*>::iterator it = std::find(meshes.begin(), meshes.end(), m);
 139         if(it != meshes.end()) {
 140                 meshes.erase(it);
 141                 return true;
 142         }
 143         return false;
 144 }
 145
 146 bool Scene::have_mesh(Mesh *m) const
 147 {
 148         return std::find(meshes.begin(), meshes.end(), m) != meshes.end();
 149 }
 150
 151 void Scene::add_node(SceneNode *n)
 152 {
 153         // we always want to have a dedicated root node
 154         if(!nodes) {
 155                 nodes = new SceneNode;
 156                 nodes->scene = this;
 157                 nodes->set_name("root");
 158         }
 159
 160         nodes->add_child(n);
 161 }
 162
 163 bool Scene::remove_node(SceneNode *n)
 164 {
 165         SceneNode *par;
 166         if(!n || !(par = n->get_parent())) {
 167                 return false;
 168         }
 169
 170         int nsub = n->get_num_children();
 171         for(int i=0; i<nsub; i++) {
 172                 SceneNode *c = n->get_child(i);
 173                 n->remove_child(c);
 174                 par->add_child(c);
 175         }
 176
 177         return par->remove_child(n);
 178 }
 179
 180 bool Scene::have_node(SceneNode *n) const
 181 {
 182         return n->scene == this;
 183 }
 184
 185 static void find_nodes_rec(std::list<SceneNode*> *res, SceneNode *tree, const std::regex &re)
 186 {
 187         if(std::regex_match(tree->get_name(), re)) {
 188                 res->push_back(tree);
 189         }
 190
 191         int num = tree->get_num_children();
 192         for(int i=0; i<num; i++) {
 193                 find_nodes_rec(res, tree->get_child(i), re);
 194         }
 195 }
 196
 197 Scene *Scene::extract_nodes(const char *qstr)
 198 {
 199         if(!nodes) return 0;
 200
 201         std::regex re{qstr};
 202
 203         std::list<SceneNode*> nodelist;
 204         find_nodes_rec(&nodelist, nodes, re);
 205         if(nodelist.empty()) {
 206                 return 0;
 207         }
 208
 209         Scene *res = new Scene;
 210
 211         for(SceneNode *n : nodelist) {
 212
 213                 int nobj = n->get_num_objects();
 214                 for(int i=0; i<nobj; i++) {
 215                         Object *obj = n->get_object(i);
 216                         if(obj->get_type() == OBJ_MESH) {
 217                                 // XXX this assumes that meshes aren't shared between objects.
 218                                 // maybe we'll have to refcount them at some point, and copy if nref>1
 219                                 ObjMesh *om = (ObjMesh*)obj;
 220                                 remove_mesh(om->mesh);
 221                                 res->add_mesh(om->mesh);
 222                         }
 223
 224                         remove_object(obj);
 225                         res->add_object(obj);
 226                 }
 227
 228                 remove_node(n);
 229                 res->add_node(n);
 230         }
 231         return res;
 232 }
 233
 234 void Scene::apply_xform()
 235 {
 236         nodes->apply_xform();
 237 }
 238
 239 void Scene::update(float dt)
 240 {
 241         if(nodes) {
 242                 nodes->update(dt);
 243         }
 244
 245         int nobj = objects.size();
 246         for(int i=0; i<nobj; i++) {
 247                 if(!objects[i]->node) {
 248                         // only update objects which don't belong to a scenegraph node
 249                         // to avoid updating objects twice
 250                         objects[i]->update(dt);
 251                 }
 252         }
 253 }
 254
 255 void Scene::draw() const
 256 {
 257         if(!objects.empty()) {
 258                 int nobj = objects.size();
 259                 for(int i=0; i<nobj; i++) {
 260                         objects[i]->draw();
 261                 }
 262         } else {
 263                 int nmesh = meshes.size();
 264                 for(int i=0; i<nmesh; i++) {
 265                         meshes[i]->draw();
 266                 }
 267         }
 268 }