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