Merged trunk up to rev41928
[blender-staging.git] / intern / cycles / blender / blender_util.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __BLENDER_UTIL_H__
20 #define __BLENDER_UTIL_H__
21
22 #include "util_map.h"
23 #include "util_path.h"
24 #include "util_set.h"
25 #include "util_transform.h"
26 #include "util_types.h"
27 #include "util_vector.h"
28
29 /* Hacks to hook into Blender API
30    todo: clean this up ... */
31
32 extern "C" {
33
34 struct RenderEngine;
35 struct RenderResult;
36
37 ID *rna_Object_to_mesh(void *_self, void *reports, void *scene, int apply_modifiers, int settings);
38 void rna_Main_meshes_remove(void *bmain, void *reports, void *mesh);
39 void rna_Object_create_duplilist(void *ob, void *reports, void *sce);
40 void rna_Object_free_duplilist(void *ob, void *reports);
41 void rna_RenderLayer_rect_set(PointerRNA *ptr, const float *values);
42 void rna_RenderPass_rect_set(PointerRNA *ptr, const float *values);
43 struct RenderResult *RE_engine_begin_result(struct RenderEngine *engine, int x, int y, int w, int h);
44 void RE_engine_update_result(struct RenderEngine *engine, struct RenderResult *result);
45 void RE_engine_end_result(struct RenderEngine *engine, struct RenderResult *result);
46 int RE_engine_test_break(struct RenderEngine *engine);
47 void RE_engine_update_stats(struct RenderEngine *engine, const char *stats, const char *info);
48 void RE_engine_update_progress(struct RenderEngine *engine, float progress);
49 void engine_tag_redraw(void *engine);
50 void engine_tag_update(void *engine);
51 int rna_Object_is_modified(void *ob, void *scene, int settings);
52 void BLI_timestr(double _time, char *str);
53
54 }
55
56 CCL_NAMESPACE_BEGIN
57
58 static inline BL::Mesh object_to_mesh(BL::Object self, BL::Scene scene, bool apply_modifiers, bool render)
59 {
60         ID *data = rna_Object_to_mesh(self.ptr.data, NULL, scene.ptr.data, apply_modifiers, (render)? 2: 1);
61         PointerRNA ptr;
62         RNA_id_pointer_create(data, &ptr);
63         return BL::Mesh(ptr);
64 }
65
66 static inline void object_remove_mesh(BL::BlendData data, BL::Mesh mesh)
67 {
68         rna_Main_meshes_remove(data.ptr.data, NULL, mesh.ptr.data);
69 }
70
71 static inline void object_create_duplilist(BL::Object self, BL::Scene scene)
72 {
73         rna_Object_create_duplilist(self.ptr.data, NULL, scene.ptr.data);
74 }
75
76 static inline void object_free_duplilist(BL::Object self)
77 {
78         rna_Object_free_duplilist(self.ptr.data, NULL);
79 }
80
81 static inline bool object_is_modified(BL::Object self, BL::Scene scene, bool preview)
82 {
83         return rna_Object_is_modified(self.ptr.data, scene.ptr.data, (preview)? (1<<0): (1<<1))? true: false;
84 }
85
86 /* Utilities */
87
88 static inline Transform get_transform(BL::Array<float, 16> array)
89 {
90         Transform tfm;
91
92         /* we assume both types to be just 16 floats, and transpose because blender
93            use column major matrix order while we use row major */
94         memcpy(&tfm, &array, sizeof(float)*16);
95         tfm = transform_transpose(tfm);
96
97         return tfm;
98 }
99
100 static inline float2 get_float2(BL::Array<float, 2> array)
101 {
102         return make_float2(array[0], array[1]);
103 }
104
105 static inline float3 get_float3(BL::Array<float, 2> array)
106 {
107         return make_float3(array[0], array[1], 0.0f);
108 }
109
110 static inline float3 get_float3(BL::Array<float, 3> array)
111 {
112         return make_float3(array[0], array[1], array[2]);
113 }
114
115 static inline float3 get_float3(BL::Array<float, 4> array)
116 {
117         return make_float3(array[0], array[1], array[2]);
118 }
119
120 static inline int4 get_int4(BL::Array<int, 4> array)
121 {
122         return make_int4(array[0], array[1], array[2], array[3]);
123 }
124
125 static inline uint get_layer(BL::Array<int, 20> array)
126 {
127         uint layer = 0;
128
129         for(uint i = 0; i < 20; i++)
130                 if(array[i])
131                         layer |= (1 << i);
132         
133         return layer;
134 }
135
136 /*static inline float3 get_float3(PointerRNA& ptr, const char *name)
137 {
138         float3 f;
139         RNA_float_get_array(&ptr, name, &f.x);
140         return f;
141 }*/
142
143 static inline bool get_boolean(PointerRNA& ptr, const char *name)
144 {
145         return RNA_boolean_get(&ptr, name)? true: false;
146 }
147
148 static inline float get_float(PointerRNA& ptr, const char *name)
149 {
150         return RNA_float_get(&ptr, name);
151 }
152
153 static inline int get_int(PointerRNA& ptr, const char *name)
154 {
155         return RNA_int_get(&ptr, name);
156 }
157
158 static inline int get_enum(PointerRNA& ptr, const char *name)
159 {
160         return RNA_enum_get(&ptr, name);
161 }
162
163 static inline string get_enum_identifier(PointerRNA& ptr, const char *name)
164 {
165         PropertyRNA *prop = RNA_struct_find_property(&ptr, name);
166         const char *identifier = "";
167         int value = RNA_property_enum_get(&ptr, prop);
168
169         RNA_property_enum_identifier(NULL, &ptr, prop, value, &identifier);
170
171         return string(identifier);
172 }
173
174 /* Relative Paths */
175
176 static inline string blender_absolute_path(BL::BlendData b_data, BL::ID b_id, const string& path)
177 {
178         if(path.size() >= 2 && path[0] == '/' && path[1] == '/') {
179                 string dirname = (b_id.library())? b_id.library().filepath(): b_data.filepath();
180                 return path_join(path_dirname(dirname), path.substr(2));
181         }
182
183         return path;
184 }
185
186 /* ID Map
187  *
188  * Utility class to keep in sync with blender data.
189  * Used for objects, meshes, lights and shaders. */
190
191 template<typename K, typename T>
192 class id_map {
193 public:
194         id_map(vector<T*> *scene_data_)
195         {
196                 scene_data = scene_data_;
197         }
198
199         T *find(BL::ID id)
200         {
201                 return find(id.ptr.id.data);
202         }
203
204         T *find(const K& key)
205         {
206                 if(b_map.find(key) != b_map.end()) {
207                         T *data = b_map[key];
208                         return data;
209                 }
210
211                 return NULL;
212         }
213
214         void set_recalc(BL::ID id)
215         {
216                 b_recalc.insert(id.ptr.data);
217         }
218
219         bool has_recalc()
220         {
221                 return !(b_recalc.empty());
222         }
223
224         void pre_sync()
225         {
226                 used_set.clear();
227         }
228
229         bool sync(T **r_data, BL::ID id)
230         {
231                 return sync(r_data, id, id, id.ptr.id.data);
232         }
233
234         bool sync(T **r_data, BL::ID id, BL::ID parent, const K& key)
235         {
236                 T *data = find(key);
237                 bool recalc;
238
239                 if(!data) {
240                         /* add data if it didn't exist yet */
241                         data = new T();
242                         scene_data->push_back(data);
243                         b_map[key] = data;
244                         recalc = true;
245                 }
246                 else {
247                         recalc = (b_recalc.find(id.ptr.data) != b_recalc.end());
248                         if(parent.ptr.data)
249                                 recalc = recalc || (b_recalc.find(parent.ptr.data) != b_recalc.end());
250                 }
251
252                 used(data);
253
254                 *r_data = data;
255                 return recalc;
256         }
257
258         void used(T *data)
259         {
260                 /* tag data as still in use */
261                 used_set.insert(data);
262         }
263
264         void set_default(T *data)
265         {
266                 b_map[NULL] = data;
267         }
268
269         bool post_sync(bool do_delete = true)
270         {
271                 /* remove unused data */
272                 vector<T*> new_scene_data;
273                 typename vector<T*>::iterator it;
274                 bool deleted = false;
275
276                 for(it = scene_data->begin(); it != scene_data->end(); it++) {
277                         T *data = *it;
278
279                         if(do_delete && used_set.find(data) == used_set.end()) {
280                                 delete data;
281                                 deleted = true;
282                         }
283                         else
284                                 new_scene_data.push_back(data);
285                 }
286
287                 *scene_data = new_scene_data;
288
289                 /* update mapping */
290                 map<K, T*> new_map;
291                 typedef pair<const K, T*> TMapPair;
292                 typename map<K, T*>::iterator jt;
293
294                 for(jt = b_map.begin(); jt != b_map.end(); jt++) {
295                         TMapPair& pair = *jt;
296
297                         if(used_set.find(pair.second) != used_set.end())
298                                 new_map[pair.first] = pair.second;
299                 }
300
301                 used_set.clear();
302                 b_recalc.clear();
303                 b_map = new_map;
304
305                 return deleted;
306         }
307
308 protected:
309         vector<T*> *scene_data;
310         map<K, T*> b_map;
311         set<T*> used_set;
312         set<void*> b_recalc;
313 };
314
315 /* Object Key */
316
317 struct ObjectKey {
318         void *parent;
319         int index;
320         void *ob;
321
322         ObjectKey(void *parent_, int index_, void *ob_)
323         : parent(parent_), index(index_), ob(ob_) {}
324
325         bool operator<(const ObjectKey& k) const
326         { return (parent < k.parent || (parent == k.parent && (index < k.index || (index == k.index && ob < k.ob)))); }
327 };
328
329 CCL_NAMESPACE_END
330
331 #endif /* __BLENDER_UTIL_H__ */
332