intern/cycles/blender/blender_sync.h

   1 /*
   2  * Copyright 2011-2013 Blender Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __BLENDER_SYNC_H__
  18 #define __BLENDER_SYNC_H__
  19
  20 #include "MEM_guardedalloc.h"
  21 #include "RNA_types.h"
  22 #include "RNA_access.h"
  23 #include "RNA_blender_cpp.h"
  24
  25 #include "blender_util.h"
  26
  27 #include "scene.h"
  28 #include "session.h"
  29
  30 #include "util_map.h"
  31 #include "util_set.h"
  32 #include "util_transform.h"
  33 #include "util_vector.h"
  34
  35 CCL_NAMESPACE_BEGIN
  36
  37 class Background;
  38 class Camera;
  39 class Film;
  40 class Light;
  41 class Mesh;
  42 class Object;
  43 class ParticleSystem;
  44 class Scene;
  45 class Shader;
  46 class ShaderGraph;
  47 class ShaderNode;
  48
  49 class BlenderSync {
  50 public:
  51         BlenderSync(BL::RenderEngine& b_engine,
  52                     BL::BlendData& b_data,
  53                     BL::Scene& b_scene,
  54                     Scene *scene,
  55                     bool preview,
  56                     Progress &progress,
  57                     bool is_cpu);
  58         ~BlenderSync();
  59
  60         /* sync */
  61         bool sync_recalc();
  62         void sync_data(BL::RenderSettings& b_render,
  63                        BL::SpaceView3D& b_v3d,
  64                        BL::Object& b_override,
  65                        int width, int height,
  66                        void **python_thread_state,
  67                        const char *layer = 0);
  68         void sync_render_layers(BL::SpaceView3D& b_v3d, const char *layer);
  69         void sync_integrator();
  70         void sync_camera(BL::RenderSettings& b_render,
  71                          BL::Object& b_override,
  72                          int width, int height,
  73                          const char *viewname);
  74         void sync_view(BL::SpaceView3D& b_v3d,
  75                        BL::RegionView3D& b_rv3d,
  76                        int width, int height);
  77         inline int get_layer_samples() { return render_layer.samples; }
  78         inline int get_layer_bound_samples() { return render_layer.bound_samples; }
  79
  80         /* get parameters */
  81         static SceneParams get_scene_params(BL::Scene& b_scene,
  82                                             bool background,
  83                                             bool is_cpu);
  84         static SessionParams get_session_params(BL::RenderEngine& b_engine,
  85                                                 BL::UserPreferences& b_userpref,
  86                                                 BL::Scene& b_scene,
  87                                                 bool background);
  88         static bool get_session_pause(BL::Scene& b_scene, bool background);
  89         static BufferParams get_buffer_params(BL::RenderSettings& b_render,
  90                                               BL::SpaceView3D& b_v3d,
  91                                               BL::RegionView3D& b_rv3d,
  92                                               Camera *cam,
  93                                               int width, int height);
  94
  95 private:
  96         /* sync */
  97         void sync_lamps(bool update_all);
  98         void sync_materials(bool update_all);
  99         void sync_objects(BL::SpaceView3D& b_v3d, float motion_time = 0.0f);
 100         void sync_motion(BL::RenderSettings& b_render,
 101                          BL::SpaceView3D& b_v3d,
 102                          BL::Object& b_override,
 103                          int width, int height,
 104                          void **python_thread_state);
 105         void sync_film();
 106         void sync_view();
 107         void sync_world(bool update_all);
 108         void sync_shaders();
 109         void sync_curve_settings();
 110
 111         void sync_nodes(Shader *shader, BL::ShaderNodeTree& b_ntree);
 112         Mesh *sync_mesh(BL::Object& b_ob, bool object_updated, bool hide_tris);
 113         void sync_curves(Mesh *mesh,
 114                          BL::Mesh& b_mesh,
 115                          BL::Object& b_ob,
 116                          bool motion,
 117                          int time_index = 0);
 118         Object *sync_object(BL::Object& b_parent,
 119                             int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
 120                             BL::DupliObject& b_dupli_ob,
 121                             Transform& tfm,
 122                             uint layer_flag,
 123                             float motion_time,
 124                             bool hide_tris,
 125                             bool use_camera_cull,
 126                             float camera_cull_margin,
 127                             bool *use_portal);
 128         void sync_light(BL::Object& b_parent,
 129                         int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
 130                         BL::Object& b_ob,
 131                         Transform& tfm,
 132                         bool *use_portal);
 133         void sync_background_light(bool use_portal);
 134         void sync_mesh_motion(BL::Object& b_ob,
 135                               Object *object,
 136                               float motion_time);
 137         void sync_camera_motion(BL::RenderSettings& b_render,
 138                                 BL::Object& b_ob,
 139                                 int width, int height,
 140                                 float motion_time);
 141
 142         /* Images. */
 143         void sync_images();
 144
 145         /* util */
 146         void find_shader(BL::ID& id, vector<Shader*>& used_shaders, Shader *default_shader);
 147         bool BKE_object_is_modified(BL::Object& b_ob);
 148         bool object_is_mesh(BL::Object& b_ob);
 149         bool object_is_light(BL::Object& b_ob);
 150
 151         /* variables */
 152         BL::RenderEngine b_engine;
 153         BL::BlendData b_data;
 154         BL::Scene b_scene;
 155
 156         id_map<void*, Shader> shader_map;
 157         id_map<ObjectKey, Object> object_map;
 158         id_map<void*, Mesh> mesh_map;
 159         id_map<ObjectKey, Light> light_map;
 160         set<Mesh*> mesh_synced;
 161         set<Mesh*> mesh_motion_synced;
 162         set<float> motion_times;
 163         void *world_map;
 164         bool world_recalc;
 165
 166         Scene *scene;
 167         bool preview;
 168         bool experimental;
 169         bool is_cpu;
 170
 171         float dicing_rate;
 172         int max_subdivisions;
 173
 174         struct RenderLayerInfo {
 175                 RenderLayerInfo()
 176                 : scene_layer(0), layer(0),
 177                   holdout_layer(0), exclude_layer(0),
 178                   material_override(PointerRNA_NULL),
 179                   use_background_shader(true),
 180                   use_background_ao(true),
 181                   use_surfaces(true),
 182                   use_hair(true),
 183                   use_viewport_visibility(false),
 184                   samples(0), bound_samples(false)
 185                 {}
 186
 187                 string name;
 188                 uint scene_layer;
 189                 uint layer;
 190                 uint holdout_layer;
 191                 uint exclude_layer;
 192                 BL::Material material_override;
 193                 bool use_background_shader;
 194                 bool use_background_ao;
 195                 bool use_surfaces;
 196                 bool use_hair;
 197                 bool use_viewport_visibility;
 198                 int samples;
 199                 bool bound_samples;
 200         } render_layer;
 201
 202         Progress &progress;
 203 };
 204
 205 CCL_NAMESPACE_END
 206
 207 #endif /* __BLENDER_SYNC_H__ */
 208