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;
 180
 181                 if(b_id.library())
 182                         dirname = blender_absolute_path(b_data, b_id.library(), b_id.library().filepath());
 183                 else
 184                         dirname = b_data.filepath();
 185
 186                 return path_join(path_dirname(dirname), path.substr(2));
 187         }
 188
 189         return path;
 190 }
 191
 192 /* ID Map
 193  *
 194  * Utility class to keep in sync with blender data.
 195  * Used for objects, meshes, lights and shaders. */
 196
 197 template<typename K, typename T>
 198 class id_map {
 199 public:
 200         id_map(vector<T*> *scene_data_)
 201         {
 202                 scene_data = scene_data_;
 203         }
 204
 205         T *find(BL::ID id)
 206         {
 207                 return find(id.ptr.id.data);
 208         }
 209
 210         T *find(const K& key)
 211         {
 212                 if(b_map.find(key) != b_map.end()) {
 213                         T *data = b_map[key];
 214                         return data;
 215                 }
 216
 217                 return NULL;
 218         }
 219
 220         void set_recalc(BL::ID id)
 221         {
 222                 b_recalc.insert(id.ptr.data);
 223         }
 224
 225         bool has_recalc()
 226         {
 227                 return !(b_recalc.empty());
 228         }
 229
 230         void pre_sync()
 231         {
 232                 used_set.clear();
 233         }
 234
 235         bool sync(T **r_data, BL::ID id)
 236         {
 237                 return sync(r_data, id, id, id.ptr.id.data);
 238         }
 239
 240         bool sync(T **r_data, BL::ID id, BL::ID parent, const K& key)
 241         {
 242                 T *data = find(key);
 243                 bool recalc;
 244
 245                 if(!data) {
 246                         /* add data if it didn't exist yet */
 247                         data = new T();
 248                         scene_data->push_back(data);
 249                         b_map[key] = data;
 250                         recalc = true;
 251                 }
 252                 else {
 253                         recalc = (b_recalc.find(id.ptr.data) != b_recalc.end());
 254                         if(parent.ptr.data)
 255                                 recalc = recalc || (b_recalc.find(parent.ptr.data) != b_recalc.end());
 256                 }
 257
 258                 used(data);
 259
 260                 *r_data = data;
 261                 return recalc;
 262         }
 263
 264         void used(T *data)
 265         {
 266                 /* tag data as still in use */
 267                 used_set.insert(data);
 268         }
 269
 270         void set_default(T *data)
 271         {
 272                 b_map[NULL] = data;
 273         }
 274
 275         bool post_sync(bool do_delete = true)
 276         {
 277                 /* remove unused data */
 278                 vector<T*> new_scene_data;
 279                 typename vector<T*>::iterator it;
 280                 bool deleted = false;
 281
 282                 for(it = scene_data->begin(); it != scene_data->end(); it++) {
 283                         T *data = *it;
 284
 285                         if(do_delete && used_set.find(data) == used_set.end()) {
 286                                 delete data;
 287                                 deleted = true;
 288                         }
 289                         else
 290                                 new_scene_data.push_back(data);
 291                 }
 292
 293                 *scene_data = new_scene_data;
 294
 295                 /* update mapping */
 296                 map<K, T*> new_map;
 297                 typedef pair<const K, T*> TMapPair;
 298                 typename map<K, T*>::iterator jt;
 299
 300                 for(jt = b_map.begin(); jt != b_map.end(); jt++) {
 301                         TMapPair& pair = *jt;
 302
 303                         if(used_set.find(pair.second) != used_set.end())
 304                                 new_map[pair.first] = pair.second;
 305                 }
 306
 307                 used_set.clear();
 308                 b_recalc.clear();
 309                 b_map = new_map;
 310
 311                 return deleted;
 312         }
 313
 314 protected:
 315         vector<T*> *scene_data;
 316         map<K, T*> b_map;
 317         set<T*> used_set;
 318         set<void*> b_recalc;
 319 };
 320
 321 /* Object Key */
 322
 323 struct ObjectKey {
 324         void *parent;
 325         int index;
 326         void *ob;
 327
 328         ObjectKey(void *parent_, int index_, void *ob_)
 329         : parent(parent_), index(index_), ob(ob_) {}
 330
 331         bool operator<(const ObjectKey& k) const
 332         { return (parent < k.parent || (parent == k.parent && (index < k.index || (index == k.index && ob < k.ob)))); }
 333 };
 334
 335 CCL_NAMESPACE_END
 336
 337 #endif /* __BLENDER_UTIL_H__ */
 338