Cycles: Pass Blender's C++ RNA structures by reference
authorSergey Sharybin <sergey.vfx@gmail.com>
Sat, 30 Jan 2016 13:18:29 +0000 (14:18 +0100)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sat, 30 Jan 2016 14:08:57 +0000 (15:08 +0100)
This way we avoid passing structures which could be up to
few hundred bytes by value to the utility functions.

Ideally we'll also have to add `const` qualifier in majority
of the calls, but C++ RNA does not allow us to do that because
it does not know if some function modifies contents or not.

14 files changed:
intern/cycles/blender/blender_camera.cpp
intern/cycles/blender/blender_curves.cpp
intern/cycles/blender/blender_mesh.cpp
intern/cycles/blender/blender_object.cpp
intern/cycles/blender/blender_particles.cpp
intern/cycles/blender/blender_session.cpp
intern/cycles/blender/blender_session.h
intern/cycles/blender/blender_shader.cpp
intern/cycles/blender/blender_sync.cpp
intern/cycles/blender/blender_sync.h
intern/cycles/blender/blender_texture.cpp
intern/cycles/blender/blender_texture.h
intern/cycles/blender/blender_util.h
source/blender/makesrna/intern/makesrna.c

index 5f2e0762964967f09833d46bea78f5bf8eb67cc7..18e3431812d30af4955edec6397f789f97bf6fb2 100644 (file)
@@ -77,7 +77,8 @@ struct BlenderCamera {
        Transform matrix;
 };
 
-static void blender_camera_init(BlenderCamera *bcam, BL::RenderSettings b_render)
+static void blender_camera_init(BlenderCamera *bcam,
+                                BL::RenderSettings& b_render)
 {
        memset(bcam, 0, sizeof(BlenderCamera));
 
@@ -107,7 +108,9 @@ static void blender_camera_init(BlenderCamera *bcam, BL::RenderSettings b_render
        bcam->pixelaspect.y = b_render.pixel_aspect_y();
 }
 
-static float blender_camera_focal_distance(BL::RenderEngine b_engine, BL::Object b_ob, BL::Camera b_camera)
+static float blender_camera_focal_distance(BL::RenderEngine& b_engine,
+                                           BL::Object& b_ob,
+                                           BL::Camera& b_camera)
 {
        BL::Object b_dof_object = b_camera.dof_object();
 
@@ -124,7 +127,10 @@ static float blender_camera_focal_distance(BL::RenderEngine b_engine, BL::Object
        return fabsf(dot(view_dir, dof_dir));
 }
 
-static void blender_camera_from_object(BlenderCamera *bcam, BL::RenderEngine b_engine, BL::Object b_ob, bool skip_panorama = false)
+static void blender_camera_from_object(BlenderCamera *bcam,
+                                       BL::RenderEngine& b_engine,
+                                       BL::Object& b_ob,
+                                       bool skip_panorama = false)
 {
        BL::ID b_ob_data = b_ob.data();
 
@@ -439,7 +445,9 @@ static void blender_camera_sync(Camera *cam, BlenderCamera *bcam, int width, int
 
 /* Sync Render Camera */
 
-void BlenderSync::sync_camera(BL::RenderSettings b_render, BL::Object b_override, int width, int height)
+void BlenderSync::sync_camera(BL::RenderSettings& b_render,
+                              BL::Object& b_override,
+                              int width, int height)
 {
        BlenderCamera bcam;
        blender_camera_init(&bcam, b_render);
@@ -448,9 +456,9 @@ void BlenderSync::sync_camera(BL::RenderSettings b_render, BL::Object b_override
        bcam.pixelaspect.x = b_render.pixel_aspect_x();
        bcam.pixelaspect.y = b_render.pixel_aspect_y();
        bcam.shuttertime = b_render.motion_blur_shutter();
-       curvemapping_to_array(b_render.motion_blur_shutter_curve(),
-                             bcam.shutter_curve,
-                             RAMP_TABLE_SIZE);
+
+       BL::CurveMapping b_shutter_curve(b_render.motion_blur_shutter_curve());
+       curvemapping_to_array(b_shutter_curve, bcam.shutter_curve, RAMP_TABLE_SIZE);
 
        PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
        switch(RNA_enum_get(&cscene, "motion_blur_position")) {
@@ -507,8 +515,8 @@ void BlenderSync::sync_camera(BL::RenderSettings b_render, BL::Object b_override
        blender_camera_sync(cam, &bcam, width, height);
 }
 
-void BlenderSync::sync_camera_motion(BL::RenderSettings b_render,
-                                     BL::Object b_ob,
+void BlenderSync::sync_camera_motion(BL::RenderSettings& b_render,
+                                     BL::Object& b_ob,
                                      int width, int height,
                                      float motion_time)
 {
@@ -562,19 +570,32 @@ void BlenderSync::sync_camera_motion(BL::RenderSettings b_render,
 
 /* Sync 3D View Camera */
 
-static void blender_camera_view_subset(BL::RenderEngine b_engine, BL::RenderSettings b_render, BL::Scene b_scene, BL::Object b_ob, BL::SpaceView3D b_v3d,
-       BL::RegionView3D b_rv3d, int width, int height, BoundBox2D *view_box, BoundBox2D *cam_box);
-
-static void blender_camera_from_view(BlenderCamera *bcam, BL::RenderEngine b_engine, BL::Scene b_scene, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height, bool skip_panorama = false)
+static void blender_camera_view_subset(BL::RenderEngine& b_engine,
+                                       BL::RenderSettings& b_render,
+                                       BL::Scene& b_scene,
+                                       BL::Object& b_ob,
+                                       BL::SpaceView3D& b_v3d,
+                                       BL::RegionView3D& b_rv3d,
+                                       int width, int height,
+                                       BoundBox2D *view_box,
+                                       BoundBox2D *cam_box);
+
+static void blender_camera_from_view(BlenderCamera *bcam,
+                                     BL::RenderEngine& b_engine,
+                                     BL::Scene& b_scene,
+                                     BL::SpaceView3D& b_v3d,
+                                     BL::RegionView3D& b_rv3d,
+                                     int width, int height,
+                                     bool skip_panorama = false)
 {
        /* 3d view parameters */
        bcam->nearclip = b_v3d.clip_start();
        bcam->farclip = b_v3d.clip_end();
        bcam->lens = b_v3d.lens();
        bcam->shuttertime = b_scene.render().motion_blur_shutter();
-       curvemapping_to_array(b_scene.render().motion_blur_shutter_curve(),
-                             bcam->shutter_curve,
-                             RAMP_TABLE_SIZE);
+
+       BL::CurveMapping b_shutter_curve(b_scene.render().motion_blur_shutter_curve());
+       curvemapping_to_array(b_shutter_curve, bcam->shutter_curve, RAMP_TABLE_SIZE);
 
        if(b_rv3d.view_perspective() == BL::RegionView3D::view_perspective_CAMERA) {
                /* camera view */
@@ -587,8 +608,16 @@ static void blender_camera_from_view(BlenderCamera *bcam, BL::RenderEngine b_eng
                                /* in panorama camera view, we map viewplane to camera border */
                                BoundBox2D view_box, cam_box;
 
-                               blender_camera_view_subset(b_engine, b_scene.render(), b_scene, b_ob, b_v3d, b_rv3d, width, height,
-                                       &view_box, &cam_box);
+                               BL::RenderSettings b_render_settings(b_scene.render());
+                               blender_camera_view_subset(b_engine,
+                                                          b_render_settings,
+                                                          b_scene,
+                                                          b_ob,
+                                                          b_v3d,
+                                                          b_rv3d,
+                                                          width, height,
+                                                          &view_box,
+                                                          &cam_box);
 
                                bcam->pano_viewplane = view_box.make_relative_to(cam_box);
                        }
@@ -625,8 +654,15 @@ static void blender_camera_from_view(BlenderCamera *bcam, BL::RenderEngine b_eng
        bcam->matrix = transform_inverse(get_transform(b_rv3d.view_matrix()));
 }
 
-static void blender_camera_view_subset(BL::RenderEngine b_engine, BL::RenderSettings b_render, BL::Scene b_scene, BL::Object b_ob, BL::SpaceView3D b_v3d,
-       BL::RegionView3D b_rv3d, int width, int height, BoundBox2D *view_box, BoundBox2D *cam_box)
+static void blender_camera_view_subset(BL::RenderEngine& b_engine,
+                                       BL::RenderSettings& b_render,
+                                       BL::Scene& b_scene,
+                                       BL::Object& b_ob,
+                                       BL::SpaceView3D& b_v3d,
+                                       BL::RegionView3D& b_rv3d,
+                                       int width, int height,
+                                       BoundBox2D *view_box,
+                                       BoundBox2D *cam_box)
 {
        BoundBox2D cam, view;
        float view_aspect, cam_aspect, sensor_size;
@@ -652,12 +688,12 @@ static void blender_camera_view_subset(BL::RenderEngine b_engine, BL::RenderSett
        *cam_box = cam * (1.0f/cam_aspect);
 }
 
-static void blender_camera_border_subset(BL::RenderEngine b_engine,
-                                         BL::RenderSettings b_render,
-                                         BL::Scene b_scene,
-                                         BL::SpaceView3D b_v3d,
-                                         BL::RegionView3D b_rv3d,
-                                         BL::Object b_ob,
+static void blender_camera_border_subset(BL::RenderEngine& b_engine,
+                                         BL::RenderSettings& b_render,
+                                         BL::Scene& b_scene,
+                                         BL::SpaceView3D& b_v3d,
+                                         BL::RegionView3D& b_rv3d,
+                                         BL::Object& b_ob,
                                          int width, int height,
                                          const BoundBox2D &border,
                                          BoundBox2D *result)
@@ -672,8 +708,13 @@ static void blender_camera_border_subset(BL::RenderEngine b_engine,
        *result = cam_box.subset(border);
 }
 
-static void blender_camera_border(BlenderCamera *bcam, BL::RenderEngine b_engine, BL::RenderSettings b_render, BL::Scene b_scene, BL::SpaceView3D b_v3d,
-       BL::RegionView3D b_rv3d, int width, int height)
+static void blender_camera_border(BlenderCamera *bcam,
+                                  BL::RenderEngine& b_engine,
+                                  BL::RenderSettings& b_render,
+                                  BL::Scene& b_scene,
+                                  BL::SpaceView3D& b_v3d,
+                                  BL::RegionView3D& b_rv3d,
+                                  int width, int height)
 {
        bool is_camera_view;
 
@@ -733,17 +774,34 @@ static void blender_camera_border(BlenderCamera *bcam, BL::RenderEngine b_engine
        bcam->border.clamp();
 }
 
-void BlenderSync::sync_view(BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height)
+void BlenderSync::sync_view(BL::SpaceView3D& b_v3d,
+                            BL::RegionView3D& b_rv3d,
+                            int width, int height)
 {
        BlenderCamera bcam;
-       blender_camera_init(&bcam, b_scene.render());
-       blender_camera_from_view(&bcam, b_engine, b_scene, b_v3d, b_rv3d, width, height);
-       blender_camera_border(&bcam, b_engine, b_scene.render(), b_scene, b_v3d, b_rv3d, width, height);
-
+       BL::RenderSettings b_render_settings(b_scene.render());
+       blender_camera_init(&bcam, b_render_settings);
+       blender_camera_from_view(&bcam,
+                                b_engine,
+                                b_scene,
+                                b_v3d,
+                                b_rv3d,
+                                width, height);
+       blender_camera_border(&bcam,
+                             b_engine,
+                             b_render_settings,
+                             b_scene,
+                             b_v3d,
+                             b_rv3d,
+                             width, height);
        blender_camera_sync(scene->camera, &bcam, width, height);
 }
 
-BufferParams BlenderSync::get_buffer_params(BL::RenderSettings b_render, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, Camera *cam, int width, int height)
+BufferParams BlenderSync::get_buffer_params(BL::RenderSettings& b_render,
+                                            BL::SpaceView3D& b_v3d,
+                                            BL::RegionView3D& b_rv3d,
+                                            Camera *cam,
+                                            int width, int height)
 {
        BufferParams params;
        bool use_border = false;
index 6a119081bfdfa078018893f6a7da3be3a60ef7b8..a5c0b22c4d0db97ed1d32dca1a36a06ed53d2787 100644 (file)
@@ -856,7 +856,11 @@ void BlenderSync::sync_curve_settings()
                curve_system_manager->tag_update(scene);
 }
 
-void BlenderSync::sync_curves(Mesh *mesh, BL::Mesh b_mesh, BL::Object b_ob, bool motion, int time_index)
+void BlenderSync::sync_curves(Mesh *mesh,
+                              BL::Mesh& b_mesh,
+                              BL::Object& b_ob,
+                              bool motion,
+                              int time_index)
 {
        if(!motion) {
                /* Clear stored curve data */
index 182d830e729f6946f96b1df1ef64a354841616a2..0c78510040c9011528048414bcfae303057bef39 100644 (file)
@@ -80,7 +80,9 @@ inline void face_split_tri_indices(const int num_verts,
 /* Tangent Space */
 
 struct MikkUserData {
-       MikkUserData(const BL::Mesh mesh_, BL::MeshTextureFaceLayer *layer_, int num_faces_)
+       MikkUserData(const BL::Mesh& mesh_,
+                    BL::MeshTextureFaceLayer *layer_,
+                    int num_faces_)
        : mesh(mesh_), layer(layer_), num_faces(num_faces_)
        {
                tangent.resize(num_faces*4);
@@ -182,7 +184,7 @@ static void mikk_set_tangent_space(const SMikkTSpaceContext *context, const floa
        userdata->tangent[face*4 + vert] = make_float4(T[0], T[1], T[2], sign);
 }
 
-static void mikk_compute_tangents(BL::Mesh b_mesh,
+static void mikk_compute_tangents(BL::Mesh& b_mesh,
                                   BL::MeshTextureFaceLayer *b_layer,
                                   Mesh *mesh,
                                   const vector<int>& nverts,
@@ -280,7 +282,11 @@ static void mikk_compute_tangents(BL::Mesh b_mesh,
 
 /* Create Volume Attribute */
 
-static void create_mesh_volume_attribute(BL::Object b_ob, Mesh *mesh, ImageManager *image_manager, AttributeStandard std, float frame)
+static void create_mesh_volume_attribute(BL::Object& b_ob,
+                                         Mesh *mesh,
+                                         ImageManager *image_manager,
+                                         AttributeStandard std,
+                                         float frame)
 {
        BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
 
@@ -305,7 +311,10 @@ static void create_mesh_volume_attribute(BL::Object b_ob, Mesh *mesh, ImageManag
                true);
 }
 
-static void create_mesh_volume_attributes(Scene *scene, BL::Object b_ob, Mesh *mesh, float frame)
+static void create_mesh_volume_attributes(Scene *scene,
+                                          BL::Object& b_ob,
+                                          Mesh *mesh,
+                                          float frame)
 {
        /* for smoke volume rendering */
        if(mesh->need_attribute(scene, ATTR_STD_VOLUME_DENSITY))
@@ -323,7 +332,7 @@ static void create_mesh_volume_attributes(Scene *scene, BL::Object b_ob, Mesh *m
 /* Create vertex color attributes. */
 static void attr_create_vertex_color(Scene *scene,
                                      Mesh *mesh,
-                                     BL::Mesh b_mesh,
+                                     BL::Mesh& b_mesh,
                                      const vector<int>& nverts,
                                      const vector<int>& face_flags)
 {
@@ -370,7 +379,7 @@ static void attr_create_vertex_color(Scene *scene,
 /* Create uv map attributes. */
 static void attr_create_uv_map(Scene *scene,
                                Mesh *mesh,
-                               BL::Mesh b_mesh,
+                               BL::Mesh& b_mesh,
                                const vector<int>& nverts,
                                const vector<int>& face_flags)
 {
@@ -455,7 +464,7 @@ static void attr_create_uv_map(Scene *scene,
 /* Create vertex pointiness attributes. */
 static void attr_create_pointiness(Scene *scene,
                                    Mesh *mesh,
-                                   BL::Mesh b_mesh)
+                                   BL::Mesh& b_mesh)
 {
        if(mesh->need_attribute(scene, ATTR_STD_POINTINESS)) {
                const int numverts = b_mesh.vertices.length();
@@ -519,7 +528,10 @@ static void attr_create_pointiness(Scene *scene,
 
 /* Create Mesh */
 
-static void create_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, const vector<uint>& used_shaders)
+static void create_mesh(Scene *scene,
+                        Mesh *mesh,
+                        BL::Mesh& b_mesh,
+                        const vector<uint>& used_shaders)
 {
        /* count vertices and faces */
        int numverts = b_mesh.vertices.length();
@@ -641,7 +653,11 @@ static void create_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, const vector<
        }
 }
 
-static void create_subd_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, PointerRNA *cmesh, const vector<uint>& used_shaders)
+static void create_subd_mesh(Scene *scene,
+                             Mesh *mesh,
+                             BL::Mesh& b_mesh,
+                             PointerRNA *cmesh,
+                             const vector<uint>& used_shaders)
 {
        /* create subd mesh */
        SubdMesh sdmesh;
@@ -685,7 +701,9 @@ static void create_subd_mesh(Scene *scene, Mesh *mesh, BL::Mesh b_mesh, PointerR
 
 /* Sync */
 
-Mesh *BlenderSync::sync_mesh(BL::Object b_ob, bool object_updated, bool hide_tris)
+Mesh *BlenderSync::sync_mesh(BL::Object& b_ob,
+                             bool object_updated,
+                             bool hide_tris)
 {
        /* When viewport display is not needed during render we can force some
         * caches to be releases from blender side in order to reduce peak memory
@@ -705,10 +723,13 @@ Mesh *BlenderSync::sync_mesh(BL::Object b_ob, bool object_updated, bool hide_tri
 
        BL::Object::material_slots_iterator slot;
        for(b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot) {
-               if(material_override)
+               if(material_override) {
                        find_shader(material_override, used_shaders, scene->default_surface);
-               else
-                       find_shader(slot->material(), used_shaders, scene->default_surface);
+               }
+               else {
+                       BL::ID b_material(slot->material());
+                       find_shader(b_material, used_shaders, scene->default_surface);
+               }
        }
 
        if(used_shaders.size() == 0) {
@@ -838,7 +859,9 @@ Mesh *BlenderSync::sync_mesh(BL::Object b_ob, bool object_updated, bool hide_tri
        return mesh;
 }
 
-void BlenderSync::sync_mesh_motion(BL::Object b_ob, Object *object, float motion_time)
+void BlenderSync::sync_mesh_motion(BL::Object& b_ob,
+                                   Object *object,
+                                   float motion_time)
 {
        /* ensure we only sync instanced meshes once */
        Mesh *mesh = object->mesh;
index 11593807a0071088c18b21cb38a15a15a0583363..1c5180a1ddc48464abe81a78dcc8570cb6bdb5b4 100644 (file)
@@ -36,7 +36,7 @@ CCL_NAMESPACE_BEGIN
 
 /* Utilities */
 
-bool BlenderSync::BKE_object_is_modified(BL::Object b_ob)
+bool BlenderSync::BKE_object_is_modified(BL::Object& b_ob)
 {
        /* test if we can instance or if the object is modified */
        if(b_ob.type() == BL::Object::type_META) {
@@ -58,7 +58,7 @@ bool BlenderSync::BKE_object_is_modified(BL::Object b_ob)
        return false;
 }
 
-bool BlenderSync::object_is_mesh(BL::Object b_ob)
+bool BlenderSync::object_is_mesh(BL::Object& b_ob)
 {
        BL::ID b_ob_data = b_ob.data();
 
@@ -66,14 +66,14 @@ bool BlenderSync::object_is_mesh(BL::Object b_ob)
                b_ob_data.is_a(&RNA_Curve) || b_ob_data.is_a(&RNA_MetaBall)));
 }
 
-bool BlenderSync::object_is_light(BL::Object b_ob)
+bool BlenderSync::object_is_light(BL::Object& b_ob)
 {
        BL::ID b_ob_data = b_ob.data();
 
        return (b_ob_data && b_ob_data.is_a(&RNA_Lamp));
 }
 
-static uint object_ray_visibility(BL::Object b_ob)
+static uint object_ray_visibility(BL::Object& b_ob)
 {
        PointerRNA cvisibility = RNA_pointer_get(&b_ob.ptr, "cycles_visibility");
        uint flag = 0;
@@ -90,7 +90,11 @@ static uint object_ray_visibility(BL::Object b_ob)
 
 /* Light */
 
-void BlenderSync::sync_light(BL::Object b_parent, int persistent_id[OBJECT_PERSISTENT_ID_SIZE], BL::Object b_ob, Transform& tfm, bool *use_portal)
+void BlenderSync::sync_light(BL::Object& b_parent,
+                             int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
+                             BL::Object& b_ob,
+                             Transform& tfm,
+                             bool *use_portal)
 {
        /* test if we need to sync */
        Light *light;
@@ -239,7 +243,7 @@ void BlenderSync::sync_background_light(bool use_portal)
  * to reduce number of objects which are wrongly considered visible.
  */
 static bool object_boundbox_clip(Scene *scene,
-                                 BL::Object b_ob,
+                                 BL::Object& b_ob,
                                  Transform& tfm,
                                  float margin)
 {
@@ -275,9 +279,9 @@ static bool object_boundbox_clip(Scene *scene,
        return true;
 }
 
-Object *BlenderSync::sync_object(BL::Object b_parent,
+Object *BlenderSync::sync_object(BL::Object& b_parent,
                                  int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
-                                 BL::DupliObject b_dupli_ob,
+                                 BL::DupliObject& b_dupli_ob,
                                  Transform& tfm,
                                  uint layer_flag,
                                  float motion_time,
@@ -439,7 +443,8 @@ Object *BlenderSync::sync_object(BL::Object b_parent,
        return object;
 }
 
-static bool object_render_hide_original(BL::Object::type_enum ob_type, BL::Object::dupli_type_enum dupli_type)
+static bool object_render_hide_original(BL::Object::type_enum ob_type,
+                                        BL::Object::dupli_type_enum dupli_type)
 {
        /* metaball exception, they duplicate self */
        if(ob_type == BL::Object::type_META)
@@ -450,7 +455,10 @@ static bool object_render_hide_original(BL::Object::type_enum ob_type, BL::Objec
                dupli_type == BL::Object::dupli_type_FRAMES);
 }
 
-static bool object_render_hide(BL::Object b_ob, bool top_level, bool parent_hide, bool& hide_triangles)
+static bool object_render_hide(BL::Object& b_ob,
+                               bool top_level,
+                               bool parent_hide,
+                               bool& hide_triangles)
 {
        /* check if we should render or hide particle emitter */
        BL::Object::particle_systems_iterator b_psys;
@@ -507,7 +515,7 @@ static bool object_render_hide(BL::Object b_ob, bool top_level, bool parent_hide
        }
 }
 
-static bool object_render_hide_duplis(BL::Object b_ob)
+static bool object_render_hide_duplis(BL::Object& b_ob)
 {
        BL::Object parent = b_ob.parent();
 
@@ -516,7 +524,7 @@ static bool object_render_hide_duplis(BL::Object b_ob)
 
 /* Object Loop */
 
-void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, float motion_time)
+void BlenderSync::sync_objects(BL::SpaceView3D& b_v3d, float motion_time)
 {
        /* layer data */
        uint scene_layer = render_layer.scene_layer;
@@ -631,9 +639,10 @@ void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, float motion_time)
                                if(!object_render_hide(b_ob, true, true, hide_tris)) {
                                        /* object itself */
                                        Transform tfm = get_transform(b_ob.matrix_world());
+                                       BL::DupliObject b_empty_dupli_ob(PointerRNA_NULL);
                                        sync_object(b_ob,
                                                    NULL,
-                                                   PointerRNA_NULL,
+                                                   b_empty_dupli_ob,
                                                    tfm,
                                                    ob_layer,
                                                    motion_time,
@@ -668,9 +677,9 @@ void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, float motion_time)
                mesh_motion_synced.clear();
 }
 
-void BlenderSync::sync_motion(BL::RenderSettings b_render,
-                              BL::SpaceView3D b_v3d,
-                              BL::Object b_override,
+void BlenderSync::sync_motion(BL::RenderSettings& b_render,
+                              BL::SpaceView3D& b_v3d,
+                              BL::Object& b_override,
                               int width, int height,
                               void **python_thread_state)
 {
index 6d799e6e10ecd26244ba2f4d1586bb38c2cdb122..d1e702cfdc22826e57ccce1ba685ab93c80b3a4c 100644 (file)
@@ -27,7 +27,9 @@ CCL_NAMESPACE_BEGIN
 
 /* Utilities */
 
-bool BlenderSync::sync_dupli_particle(BL::Object b_ob, BL::DupliObject b_dup, Object *object)
+bool BlenderSync::sync_dupli_particle(BL::Object& b_ob,
+                                      BL::DupliObject& b_dup,
+                                      Object *object)
 {
        /* test if this dupli was generated from a particle sytem */
        BL::ParticleSystem b_psys = b_dup.particle_system();
index a2a399e6152d94e94ba51a72edd030d78406616e..544ae97d93f62b7b65b418de7c94c3dd922e0714 100644 (file)
@@ -44,10 +44,18 @@ CCL_NAMESPACE_BEGIN
 
 bool BlenderSession::headless = false;
 
-BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_,
-       BL::BlendData b_data_, BL::Scene b_scene_)
-: b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_render(b_engine_.render()), b_scene(b_scene_),
-  b_v3d(PointerRNA_NULL), b_rv3d(PointerRNA_NULL), python_thread_state(NULL)
+BlenderSession::BlenderSession(BL::RenderEngine& b_engine,
+                               BL::UserPreferences& b_userpref,
+                               BL::BlendData& b_data,
+                               BL::Scene& b_scene)
+: b_engine(b_engine),
+  b_userpref(b_userpref),
+  b_data(b_data),
+  b_render(b_engine.render()),
+  b_scene(b_scene),
+  b_v3d(PointerRNA_NULL),
+  b_rv3d(PointerRNA_NULL),
+  python_thread_state(NULL)
 {
        /* offline render */
 
@@ -59,16 +67,26 @@ BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b
        start_resize_time = 0.0;
 }
 
-BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_,
-       BL::BlendData b_data_, BL::Scene b_scene_,
-       BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_)
-: b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_render(b_scene_.render()), b_scene(b_scene_),
-  b_v3d(b_v3d_), b_rv3d(b_rv3d_), python_thread_state(NULL)
+BlenderSession::BlenderSession(BL::RenderEngine& b_engine,
+                               BL::UserPreferences& b_userpref,
+                               BL::BlendData& b_data,
+                               BL::Scene& b_scene,
+                               BL::SpaceView3D& b_v3d,
+                               BL::RegionView3D& b_rv3d,
+                               int width, int height)
+: b_engine(b_engine),
+  b_userpref(b_userpref),
+  b_data(b_data),
+  b_render(b_scene.render()),
+  b_scene(b_scene),
+  b_v3d(b_v3d),
+  b_rv3d(b_rv3d),
+  width(width),
+  height(height),
+  python_thread_state(NULL)
 {
        /* 3d view render */
 
-       width = width_;
-       height = height_;
        background = false;
        last_redraw_time = 0.0;
        start_resize_time = 0.0;
@@ -117,14 +135,14 @@ void BlenderSession::create_session()
 
        /* create sync */
        sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress, is_cpu);
-
+       BL::Object b_camera_override(b_engine.camera_override());
        if(b_v3d) {
                if(session_pause == false) {
                        /* full data sync */
                        sync->sync_view(b_v3d, b_rv3d, width, height);
                        sync->sync_data(b_render,
                                        b_v3d,
-                                       b_engine.camera_override(),
+                                       b_camera_override,
                                        width, height,
                                        &python_thread_state,
                                        b_rlay_name.c_str());
@@ -135,7 +153,7 @@ void BlenderSession::create_session()
                 * do some basic syncing here, no objects or materials for speed */
                sync->sync_render_layers(b_v3d, NULL);
                sync->sync_integrator();
-               sync->sync_camera(b_render, b_engine.camera_override(), width, height);
+               sync->sync_camera(b_render, b_camera_override, width, height);
        }
 
        /* set buffer parameters */
@@ -145,7 +163,7 @@ void BlenderSession::create_session()
        b_engine.use_highlight_tiles(session_params.progressive_refine == false);
 }
 
-void BlenderSession::reset_session(BL::BlendData b_data_, BL::Scene b_scene_)
+void BlenderSession::reset_session(BL::BlendData& b_data_, BL::Scene& b_scene_)
 {
        b_data = b_data_;
        b_render = b_engine.render();
@@ -188,11 +206,18 @@ void BlenderSession::reset_session(BL::BlendData b_data_, BL::Scene b_scene_)
 
        /* for final render we will do full data sync per render layer, only
         * do some basic syncing here, no objects or materials for speed */
+       BL::Object b_camera_override(b_engine.camera_override());
        sync->sync_render_layers(b_v3d, NULL);
        sync->sync_integrator();
-       sync->sync_camera(b_render, b_engine.camera_override(), width, height);
-
-       BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, PointerRNA_NULL, PointerRNA_NULL, scene->camera, width, height);
+       sync->sync_camera(b_render, b_camera_override, width, height);
+
+       BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);
+       BL::RegionView3D b_null_region_view3d(PointerRNA_NULL);
+       BufferParams buffer_params = BlenderSync::get_buffer_params(b_render,
+                                                                   b_null_space_view3d,
+                                                                   b_null_region_view3d,
+                                                                   scene->camera,
+                                                                   width, height);
        session->reset(buffer_params, session_params.samples);
 
        b_engine.use_highlight_tiles(session_params.progressive_refine == false);
@@ -209,7 +234,7 @@ void BlenderSession::free_session()
        delete session;
 }
 
-static PassType get_pass_type(BL::RenderPass b_pass)
+static PassType get_pass_type(BL::RenderPass& b_pass)
 {
        switch(b_pass.type()) {
                case BL::RenderPass::type_COMBINED:
@@ -333,12 +358,19 @@ static ShaderEvalType get_shader_type(const string& pass_type)
                return SHADER_EVAL_BAKE;
 }
 
-static BL::RenderResult begin_render_result(BL::RenderEngine b_engine, int x, int y, int w, int h, const char *layername, const char *viewname)
+static BL::RenderResult begin_render_result(BL::RenderEngine& b_engine,
+                                            int x, int y,
+                                            int w, int h,
+                                            const char *layername,
+                                            const char *viewname)
 {
        return b_engine.begin_result(x, y, w, h, layername, viewname);
 }
 
-static void end_render_result(BL::RenderEngine b_engine, BL::RenderResult b_rr, bool cancel, bool do_merge_results)
+static void end_render_result(BL::RenderEngine& b_engine,
+                              BL::RenderResult& b_rr,
+                              bool cancel,
+                              bool do_merge_results)
 {
        b_engine.end_result(b_rr, (int)cancel, (int)do_merge_results);
 }
@@ -469,10 +501,11 @@ void BlenderSession::render()
                        b_engine.active_view_set(b_rview_name.c_str());
 
                        /* update scene */
-                       sync->sync_camera(b_render, b_engine.camera_override(), width, height);
+                       BL::Object b_camera_override(b_engine.camera_override());
+                       sync->sync_camera(b_render, b_camera_override, width, height);
                        sync->sync_data(b_render,
                                        b_v3d,
-                                       b_engine.camera_override(),
+                                       b_camera_override,
                                        width, height,
                                        &python_thread_state,
                                        b_rlay_name.c_str());
@@ -520,7 +553,10 @@ void BlenderSession::render()
        sync = NULL;
 }
 
-static void populate_bake_data(BakeData *data, const int object_id, BL::BakePixel pixel_array, const int num_pixels)
+static void populate_bake_data(BakeData *data, const
+                               int object_id,
+                               BL::BakePixel& pixel_array,
+                               const int num_pixels)
 {
        BL::BakePixel bp = pixel_array;
 
@@ -563,11 +599,11 @@ static int bake_pass_filter_get(const int pass_filter)
        return flag;
 }
 
-void BlenderSession::bake(BL::Object b_object,
+void BlenderSession::bake(BL::Object& b_object,
                           const string& pass_type,
                           const int pass_filter,
                           const int object_id,
-                          BL::BakePixel pixel_array,
+                          BL::BakePixel& pixel_array,
                           const size_t num_pixels,
                           const int /*depth*/,
                           float result[])
@@ -603,10 +639,11 @@ void BlenderSession::bake(BL::Object b_object,
        scene->integrator->tag_update(scene);
 
        /* update scene */
-       sync->sync_camera(b_render, b_engine.camera_override(), width, height);
+       BL::Object b_camera_override(b_engine.camera_override());
+       sync->sync_camera(b_render, b_camera_override, width, height);
        sync->sync_data(b_render,
                        b_v3d,
-                       b_engine.camera_override(),
+                       b_camera_override,
                        width, height,
                        &python_thread_state,
                        b_rlay_name.c_str());
@@ -657,7 +694,10 @@ void BlenderSession::bake(BL::Object b_object,
        sync = NULL;
 }
 
-void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile, bool do_update_only)
+void BlenderSession::do_write_update_render_result(BL::RenderResult& b_rr,
+                                                   BL::RenderLayer& b_rlay,
+                                                   RenderTile& rtile,
+                                                   bool do_update_only)
 {
        RenderBuffers *buffers = rtile.buffers;
 
@@ -699,12 +739,16 @@ void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::Re
        b_engine.update_result(b_rr);
 }
 
-void BlenderSession::write_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile)
+void BlenderSession::write_render_result(BL::RenderResult& b_rr,
+                                         BL::RenderLayer& b_rlay,
+                                         RenderTile& rtile)
 {
        do_write_update_render_result(b_rr, b_rlay, rtile, false);
 }
 
-void BlenderSession::update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile)
+void BlenderSession::update_render_result(BL::RenderResult& b_rr,
+                                          BL::RenderLayer& b_rlay,
+                                          RenderTile& rtile)
 {
        do_write_update_render_result(b_rr, b_rlay, rtile, true);
 }
@@ -751,9 +795,10 @@ void BlenderSession::synchronize()
        }
 
        /* data and camera synchronize */
+       BL::Object b_camera_override(b_engine.camera_override());
        sync->sync_data(b_render,
                        b_v3d,
-                       b_engine.camera_override(),
+                       b_camera_override,
                        width, height,
                        &python_thread_state,
                        b_rlay_name.c_str());
@@ -761,7 +806,7 @@ void BlenderSession::synchronize()
        if(b_rv3d)
                sync->sync_view(b_v3d, b_rv3d, width, height);
        else
-               sync->sync_camera(b_render, b_engine.camera_override(), width, height);
+               sync->sync_camera(b_render, b_camera_override, width, height);
 
        /* unlock */
        session->scene->mutex.unlock();
index 0d391cadc989c8399f55a3861f279711052ebeb2..8492d9f2c6bf091a5e93549b8a92e8121d28e874 100644 (file)
@@ -33,11 +33,18 @@ class RenderTile;
 
 class BlenderSession {
 public:
-       BlenderSession(BL::RenderEngine b_engine, BL::UserPreferences b_userpref,
-               BL::BlendData b_data, BL::Scene b_scene);
-       BlenderSession(BL::RenderEngine b_engine, BL::UserPreferences b_userpref,
-               BL::BlendData b_data, BL::Scene b_scene,
-               BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height);
+       BlenderSession(BL::RenderEngine& b_engine,
+                      BL::UserPreferences& b_userpref,
+                      BL::BlendData& b_data,
+                      BL::Scene& b_scene);
+
+       BlenderSession(BL::RenderEngine& b_engine,
+                      BL::UserPreferences& b_userpref,
+                      BL::BlendData& b_data,
+                      BL::Scene& b_scene,
+                      BL::SpaceView3D& b_v3d,
+                      BL::RegionView3D& b_rv3d,
+                      int width, int height);
 
        ~BlenderSession();
 
@@ -47,26 +54,31 @@ public:
        void create_session();
        void free_session();
 
-       void reset_session(BL::BlendData b_data, BL::Scene b_scene);
+       void reset_session(BL::BlendData& b_data,
+                          BL::Scene& b_scene);
 
        /* offline render */
        void render();
 
-       void bake(BL::Object b_object,
+       void bake(BL::Object& b_object,
                  const string& pass_type,
                  const int custom_flag,
                  const int object_id,
-                 BL::BakePixel pixel_array,
+                 BL::BakePixel& pixel_array,
                  const size_t num_pixels,
                  const int depth,
                  float pixels[]);
 
-       void write_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile);
+       void write_render_result(BL::RenderResult& b_rr,
+                                BL::RenderLayer& b_rlay,
+                                RenderTile& rtile);
        void write_render_tile(RenderTile& rtile);
 
        /* update functions are used to update display buffer only after sample was rendered
         * only needed for better visual feedback */
-       void update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile);
+       void update_render_result(BL::RenderResult& b_rr,
+                                 BL::RenderLayer& b_rlay,
+                                 RenderTile& rtile);
        void update_render_tile(RenderTile& rtile);
 
        /* interactive updates */
@@ -109,7 +121,10 @@ public:
        void *python_thread_state;
 
 protected:
-       void do_write_update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile, bool do_update_only);
+       void do_write_update_render_result(BL::RenderResult& b_rr,
+                                          BL::RenderLayer& b_rlay,
+                                          RenderTile& rtile,
+                                          bool do_update_only);
        void do_write_update_render_tile(RenderTile& rtile, bool do_update_only);
 
        int builtin_image_frame(const string &builtin_name);
index a06a6093c1c6839bacfe480342be7156ca075863..ffe99bda26206a0e6967587372dfc49165841d65 100644 (file)
@@ -36,7 +36,9 @@ typedef map<std::string, ProxyNode*> ProxyMap;
 
 /* Find */
 
-void BlenderSync::find_shader(BL::ID id, vector<uint>& used_shaders, int default_shader)
+void BlenderSync::find_shader(BL::ID& id,
+                              vector<uint>& used_shaders,
+                              int default_shader)
 {
        Shader *shader = (id)? shader_map.find(id): scene->shaders[default_shader];
 
@@ -51,7 +53,7 @@ void BlenderSync::find_shader(BL::ID id, vector<uint>& used_shaders, int default
 
 /* Graph */
 
-static BL::NodeSocket get_node_output(BL::Node b_node, const string& name)
+static BL::NodeSocket get_node_output(BL::Node& b_node, const string& name)
 {
        BL::Node::outputs_iterator b_out;
 
@@ -64,7 +66,7 @@ static BL::NodeSocket get_node_output(BL::Node b_node, const string& name)
        return *b_out;
 }
 
-static float3 get_node_output_rgba(BL::Node b_node, const string& name)
+static float3 get_node_output_rgba(BL::Node& b_node, const string& name)
 {
        BL::NodeSocket b_sock = get_node_output(b_node, name);
        float value[4];
@@ -72,13 +74,13 @@ static float3 get_node_output_rgba(BL::Node b_node, const string& name)
        return make_float3(value[0], value[1], value[2]);
 }
 
-static float get_node_output_value(BL::Node b_node, const string& name)
+static float get_node_output_value(BL::Node& b_node, const string& name)
 {
        BL::NodeSocket b_sock = get_node_output(b_node, name);
        return RNA_float_get(&b_sock.ptr, "default_value");
 }
 
-static float3 get_node_output_vector(BL::Node b_node, const string& name)
+static float3 get_node_output_vector(BL::Node& b_node, const string& name)
 {
        BL::NodeSocket b_sock = get_node_output(b_node, name);
        float value[3];
@@ -86,7 +88,7 @@ static float3 get_node_output_vector(BL::Node b_node, const string& name)
        return make_float3(value[0], value[1], value[2]);
 }
 
-static ShaderSocketType convert_socket_type(BL::NodeSocket b_socket)
+static ShaderSocketType convert_socket_type(BL::NodeSocket& b_socket)
 {
        switch(b_socket.type()) {
                case BL::NodeSocket::type_VALUE:
@@ -109,7 +111,7 @@ static ShaderSocketType convert_socket_type(BL::NodeSocket b_socket)
 
 #ifdef WITH_OSL
 static ShaderSocketType convert_osl_socket_type(OSL::OSLQuery& query,
-                                                BL::NodeSocket b_socket)
+                                                BL::NodeSocket& b_socket)
 {
        ShaderSocketType socket_type = convert_socket_type(b_socket);
 #if OSL_LIBRARY_VERSION_CODE < 10701
@@ -133,7 +135,10 @@ static ShaderSocketType convert_osl_socket_type(OSL::OSLQuery& query,
 }
 #endif  /* WITH_OSL */
 
-static void set_default_value(ShaderInput *input, BL::NodeSocket b_sock, BL::BlendData b_data, BL::ID b_id)
+static void set_default_value(ShaderInput *input,
+                              BL::NodeSocket& b_sock,
+                              BL::BlendData& b_data,
+                              BL::ID& b_id)
 {
        /* copy values for non linked inputs */
        switch(input->type) {
@@ -166,7 +171,7 @@ static void set_default_value(ShaderInput *input, BL::NodeSocket b_sock, BL::Ble
        }
 }
 
-static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
+static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping& b_mapping)
 {
        if(!b_mapping)
                return;
@@ -181,7 +186,8 @@ static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
        mapping->z_mapping = (TextureMapping::Mapping)b_mapping.mapping_z();
 }
 
-static void get_tex_mapping(TextureMapping *mapping, BL::ShaderNodeMapping b_mapping)
+static void get_tex_mapping(TextureMapping *mapping,
+                            BL::ShaderNodeMapping& b_mapping)
 {
        if(!b_mapping)
                return;
@@ -199,7 +205,7 @@ static void get_tex_mapping(TextureMapping *mapping, BL::ShaderNodeMapping b_map
                mapping->max = get_float3(b_mapping.max());
 }
 
-static bool is_output_node(BL::Node b_node)
+static bool is_output_node(BL::Node& b_node)
 {
        return (b_node.is_a(&RNA_ShaderNodeOutputMaterial)
                    || b_node.is_a(&RNA_ShaderNodeOutputWorld)
@@ -207,13 +213,13 @@ static bool is_output_node(BL::Node b_node)
 }
 
 static ShaderNode *add_node(Scene *scene,
-                            BL::RenderEngine b_engine,
-                            BL::BlendData b_data,
-                            BL::Scene b_scene,
+                            BL::RenderEngine& b_engine,
+                            BL::BlendData& b_data,
+                            BL::Scene& b_scene,
                             const bool background,
                             ShaderGraph *graph,
-                            BL::ShaderNodeTree b_ntree,
-                            BL::ShaderNode b_node)
+                            BL::ShaderNodeTree& b_ntree,
+                            BL::ShaderNode& b_node)
 {
        ShaderNode *node = NULL;
 
@@ -243,8 +249,9 @@ static ShaderNode *add_node(Scene *scene,
        else if(b_node.is_a(&RNA_ShaderNodeValToRGB)) {
                RGBRampNode *ramp = new RGBRampNode();
                BL::ShaderNodeValToRGB b_ramp_node(b_node);
-               colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE);
-               ramp->interpolate = b_ramp_node.color_ramp().interpolation() != BL::ColorRamp::interpolation_CONSTANT;
+               BL::ColorRamp b_color_ramp(b_ramp_node.color_ramp());
+               colorramp_to_array(b_color_ramp, ramp->ramp, RAMP_TABLE_SIZE);
+               ramp->interpolate = b_color_ramp.interpolation() != BL::ColorRamp::interpolation_CONSTANT;
                node = ramp;
        }
        else if(b_node.is_a(&RNA_ShaderNodeRGB)) {
@@ -608,6 +615,7 @@ static ShaderNode *add_node(Scene *scene,
        else if(b_node.is_a(&RNA_ShaderNodeTexImage)) {
                BL::ShaderNodeTexImage b_image_node(b_node);
                BL::Image b_image(b_image_node.image());
+               BL::ImageUser b_image_user(b_image_node.image_user());
                ImageTextureNode *image = new ImageTextureNode();
                if(b_image) {
                        /* builtin images will use callback-based reading because
@@ -626,12 +634,15 @@ static ShaderNode *add_node(Scene *scene,
                                 * builtin names for packed images and movies
                                 */
                                int scene_frame = b_scene.frame_current();
-                               int image_frame = image_user_frame_number(b_image_node.image_user(), scene_frame);
+                               int image_frame = image_user_frame_number(b_image_user,
+                                                                         scene_frame);
                                image->filename = b_image.name() + "@" + string_printf("%d", image_frame);
                                image->builtin_data = b_image.ptr.data;
                        }
                        else {
-                               image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current());
+                               image->filename = image_user_file_path(b_image_user,
+                                                                      b_image,
+                                                                      b_scene.frame_current());
                                image->builtin_data = NULL;
                        }
 
@@ -652,12 +663,14 @@ static ShaderNode *add_node(Scene *scene,
                image->interpolation = (InterpolationType)b_image_node.interpolation();
                image->extension = (ExtensionType)b_image_node.extension();
                image->projection_blend = b_image_node.projection_blend();
-               get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_image_node.texture_mapping());
+               get_tex_mapping(&image->tex_mapping, b_texture_mapping);
                node = image;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
                BL::ShaderNodeTexEnvironment b_env_node(b_node);
                BL::Image b_image(b_env_node.image());
+               BL::ImageUser b_image_user(b_env_node.image_user());
                EnvironmentTextureNode *env = new EnvironmentTextureNode();
                if(b_image) {
                        bool is_builtin = b_image.packed_file() ||
@@ -667,12 +680,15 @@ static ShaderNode *add_node(Scene *scene,
 
                        if(is_builtin) {
                                int scene_frame = b_scene.frame_current();
-                               int image_frame = image_user_frame_number(b_env_node.image_user(), scene_frame);
+                               int image_frame = image_user_frame_number(b_image_user,
+                                                                         scene_frame);
                                env->filename = b_image.name() + "@" + string_printf("%d", image_frame);
                                env->builtin_data = b_image.ptr.data;
                        }
                        else {
-                               env->filename = image_user_file_path(b_env_node.image_user(), b_image, b_scene.frame_current());
+                               env->filename = image_user_file_path(b_image_user,
+                                                                    b_image,
+                                                                    b_scene.frame_current());
                                env->animated = b_env_node.image_user().use_auto_refresh();
                                env->builtin_data = NULL;
                        }
@@ -690,28 +706,32 @@ static ShaderNode *add_node(Scene *scene,
                env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()];
                env->interpolation = (InterpolationType)b_env_node.interpolation();
                env->projection = EnvironmentTextureNode::projection_enum[(int)b_env_node.projection()];
-               get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_env_node.texture_mapping());
+               get_tex_mapping(&env->tex_mapping, b_texture_mapping);
                node = env;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexGradient)) {
                BL::ShaderNodeTexGradient b_gradient_node(b_node);
                GradientTextureNode *gradient = new GradientTextureNode();
                gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()];
-               get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_gradient_node.texture_mapping());
+               get_tex_mapping(&gradient->tex_mapping, b_texture_mapping);
                node = gradient;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
                BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
                VoronoiTextureNode *voronoi = new VoronoiTextureNode();
                voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()];
-               get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_voronoi_node.texture_mapping());
+               get_tex_mapping(&voronoi->tex_mapping, b_texture_mapping);
                node = voronoi;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexMagic)) {
                BL::ShaderNodeTexMagic b_magic_node(b_node);
                MagicTextureNode *magic = new MagicTextureNode();
                magic->depth = b_magic_node.turbulence_depth();
-               get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_magic_node.texture_mapping());
+               get_tex_mapping(&magic->tex_mapping, b_texture_mapping);
                node = magic;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexWave)) {
@@ -719,13 +739,15 @@ static ShaderNode *add_node(Scene *scene,
                WaveTextureNode *wave = new WaveTextureNode();
                wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()];
                wave->profile = WaveTextureNode::profile_enum[(int)b_wave_node.wave_profile()];
-               get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_wave_node.texture_mapping());
+               get_tex_mapping(&wave->tex_mapping, b_texture_mapping);
                node = wave;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexChecker)) {
                BL::ShaderNodeTexChecker b_checker_node(b_node);
                CheckerTextureNode *checker = new CheckerTextureNode();
-               get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_checker_node.texture_mapping());
+               get_tex_mapping(&checker->tex_mapping, b_texture_mapping);
                node = checker;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexBrick)) {
@@ -735,20 +757,23 @@ static ShaderNode *add_node(Scene *scene,
                brick->offset_frequency = b_brick_node.offset_frequency();
                brick->squash = b_brick_node.squash();
                brick->squash_frequency = b_brick_node.squash_frequency();
-               get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_brick_node.texture_mapping());
+               get_tex_mapping(&brick->tex_mapping, b_texture_mapping);
                node = brick;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexNoise)) {
                BL::ShaderNodeTexNoise b_noise_node(b_node);
                NoiseTextureNode *noise = new NoiseTextureNode();
-               get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_noise_node.texture_mapping());
+               get_tex_mapping(&noise->tex_mapping, b_texture_mapping);
                node = noise;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
                BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
                MusgraveTextureNode *musgrave = new MusgraveTextureNode();
                musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()];
-               get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
+               get_tex_mapping(&musgrave->tex_mapping, b_texture_mapping);
                node = musgrave;
        }
        else if(b_node.is_a(&RNA_ShaderNodeTexCoord)) {
@@ -768,7 +793,8 @@ static ShaderNode *add_node(Scene *scene,
                sky->sun_direction = normalize(get_float3(b_sky_node.sun_direction()));
                sky->turbidity = b_sky_node.turbidity();
                sky->ground_albedo = b_sky_node.ground_albedo();
-               get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping());
+               BL::TexMapping b_texture_mapping(b_sky_node.texture_mapping());
+               get_tex_mapping(&sky->tex_mapping, b_texture_mapping);
                node = sky;
        }
        else if(b_node.is_a(&RNA_ShaderNodeNormalMap)) {
@@ -850,7 +876,9 @@ static bool node_use_modified_socket_name(ShaderNode *node)
        return true;
 }
 
-static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket)
+static ShaderInput *node_find_input_by_name(ShaderNode *node,
+                                            BL::Node& b_node,
+                                            BL::NodeSocket& b_socket)
 {
        string name = b_socket.name();
        
@@ -881,7 +909,9 @@ static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, B
        return node->input(name.c_str());
 }
 
-static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket)
+static ShaderOutput *node_find_output_by_name(ShaderNode *node,
+                                              BL::Node& b_node,
+                                              BL::NodeSocket& b_socket)
 {
        string name = b_socket.name();
 
@@ -913,12 +943,12 @@ static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node,
 }
 
 static void add_nodes(Scene *scene,
-                      BL::RenderEngine b_engine,
-                      BL::BlendData b_data,
-                      BL::Scene b_scene,
+                      BL::RenderEngine& b_engine,
+                      BL::BlendData& b_data,
+                      BL::Scene& b_scene,
                       const bool background,
                       ShaderGraph *graph,
-                      BL::ShaderNodeTree b_ntree,
+                      BL::ShaderNodeTree& b_ntree,
                       const ProxyMap &proxy_input_map,
                       const ProxyMap &proxy_output_map)
 {
@@ -955,7 +985,8 @@ static void add_nodes(Scene *scene,
                        /* replace muted node with internal links */
                        BL::Node::internal_links_iterator b_link;
                        for(b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) {
-                               ProxyNode *proxy = new ProxyNode(convert_socket_type(b_link->to_socket()));
+                               BL::NodeSocket to_socket(b_link->to_socket());
+                               ProxyNode *proxy = new ProxyNode(convert_socket_type(to_socket));
 
                                input_map[b_link->from_socket().ptr.data] = proxy->inputs[0];
                                output_map[b_link->to_socket().ptr.data] = proxy->outputs[0];
@@ -1046,6 +1077,7 @@ static void add_nodes(Scene *scene,
                                }
                        }
                        else {
+                               BL::ShaderNode b_shader_node(*b_node);
                                node = add_node(scene,
                                                b_engine,
                                                b_data,
@@ -1053,7 +1085,7 @@ static void add_nodes(Scene *scene,
                                                background,
                                                graph,
                                                b_ntree,
-                                               BL::ShaderNode(*b_node));
+                                               b_shader_node);
                        }
 
                        if(node) {
@@ -1110,12 +1142,12 @@ static void add_nodes(Scene *scene,
 }
 
 static void add_nodes(Scene *scene,
-                      BL::RenderEngine b_engine,
-                      BL::BlendData b_data,
-                      BL::Scene b_scene,
+                      BL::RenderEngine& b_engine,
+                      BL::BlendData& b_data,
+                      BL::Scene& b_scene,
                       const bool background,
                       ShaderGraph *graph,
-                      BL::ShaderNodeTree b_ntree)
+                      BL::ShaderNodeTree& b_ntree)
 {
        static const ProxyMap empty_proxy_map;
        add_nodes(scene,
index 78882156ed110712d2f01df1f03670790775c4e2..65d1a6d09ba869750c32858580c48a022e517a89 100644 (file)
@@ -42,22 +42,29 @@ CCL_NAMESPACE_BEGIN
 
 /* Constructor */
 
-BlenderSync::BlenderSync(BL::RenderEngine b_engine_, BL::BlendData b_data_, BL::Scene b_scene_, Scene *scene_, bool preview_, Progress &progress_, bool is_cpu_)
-: b_engine(b_engine_),
-  b_data(b_data_), b_scene(b_scene_),
-  shader_map(&scene_->shaders),
-  object_map(&scene_->objects),
-  mesh_map(&scene_->meshes),
-  light_map(&scene_->lights),
-  particle_system_map(&scene_->particle_systems),
+BlenderSync::BlenderSync(BL::RenderEngine& b_engine,
+                         BL::BlendData& b_data,
+                         BL::Scene& b_scene,
+                         Scene *scene,
+                         bool preview,
+                         Progress &progress,
+                         bool is_cpu)
+: b_engine(b_engine),
+  b_data(b_data),
+  b_scene(b_scene),
+  shader_map(&scene->shaders),
+  object_map(&scene->objects),
+  mesh_map(&scene->meshes),
+  light_map(&scene->lights),
+  particle_system_map(&scene->particle_systems),
   world_map(NULL),
   world_recalc(false),
+  scene(scene),
+  preview(preview),
   experimental(false),
-  progress(progress_)
+  is_cpu(is_cpu),
+  progress(progress)
 {
-       scene = scene_;
-       preview = preview_;
-       is_cpu = is_cpu_;
 }
 
 BlenderSync::~BlenderSync()
@@ -145,9 +152,9 @@ bool BlenderSync::sync_recalc()
        return recalc;
 }
 
-void BlenderSync::sync_data(BL::RenderSettings b_render,
-                            BL::SpaceView3D b_v3d,
-                            BL::Object b_override,
+void BlenderSync::sync_data(BL::RenderSettings& b_render,
+                            BL::SpaceView3D& b_v3d,
+                            BL::Object& b_override,
                             int width, int height,
                             void **python_thread_state,
                             const char *layer)
@@ -308,7 +315,7 @@ void BlenderSync::sync_film()
 
 /* Render Layer */
 
-void BlenderSync::sync_render_layers(BL::SpaceView3D b_v3d, const char *layer)
+void BlenderSync::sync_render_layers(BL::SpaceView3D& b_v3d, const char *layer)
 {
        PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
        string layername;
@@ -416,7 +423,9 @@ void BlenderSync::sync_images()
 
 /* Scene Parameters */
 
-SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background, bool is_cpu)
+SceneParams BlenderSync::get_scene_params(BL::Scene& b_scene,
+                                          bool background,
+                                          bool is_cpu)
 {
        BL::RenderSettings r = b_scene.render();
        SceneParams params;
@@ -455,15 +464,15 @@ SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background, bo
 
 /* Session Parameters */
 
-bool BlenderSync::get_session_pause(BL::Scene b_scene, bool background)
+bool BlenderSync::get_session_pause(BL::Scene& b_scene, bool background)
 {
        PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
        return (background)? false: get_boolean(cscene, "preview_pause");
 }
 
-SessionParams BlenderSync::get_session_params(BL::RenderEngine b_engine,
-                                              BL::UserPreferences b_userpref,
-                                              BL::Scene b_scene,
+SessionParams BlenderSync::get_session_params(BL::RenderEngine& b_engine,
+                                              BL::UserPreferences& b_userpref,
+                                              BL::Scene& b_scene,
                                               bool background)
 {
        SessionParams params;
index 2eb153a6f74d1f1b30043aa4b2c38393811bf06d..d3edfcb657f792d59de4c823d8211f8127c6a6ae 100644 (file)
@@ -48,41 +48,57 @@ class ShaderNode;
 
 class BlenderSync {
 public:
-       BlenderSync(BL::RenderEngine b_engine_, BL::BlendData b_data, BL::Scene b_scene, Scene *scene_, bool preview_, Progress &progress_, bool is_cpu_);
+       BlenderSync(BL::RenderEngine& b_engine,
+                   BL::BlendData& b_data,
+                   BL::Scene& b_scene,
+                   Scene *scene,
+                   bool preview,
+                   Progress &progress,
+                   bool is_cpu);
        ~BlenderSync();
 
        /* sync */
        bool sync_recalc();
-       void sync_data(BL::RenderSettings b_render,
-                      BL::SpaceView3D b_v3d,
-                      BL::Object b_override,
+       void sync_data(BL::RenderSettings& b_render,
+                      BL::SpaceView3D& b_v3d,
+                      BL::Object& b_override,
                       int width, int height,
                       void **python_thread_state,
                       const char *layer = 0);
-       void sync_render_layers(BL::SpaceView3D b_v3d, const char *layer);
+       void sync_render_layers(BL::SpaceView3D& b_v3d, const char *layer);
        void sync_integrator();
-       void sync_camera(BL::RenderSettings b_render, BL::Object b_override, int width, int height);
-       void sync_view(BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height);
-       int get_layer_samples() { return render_layer.samples; }
-       int get_layer_bound_samples() { return render_layer.bound_samples; }
+       void sync_camera(BL::RenderSettings& b_render,
+                        BL::Object& b_override,
+                        int width, int height);
+       void sync_view(BL::SpaceView3D& b_v3d,
+                      BL::RegionView3D& b_rv3d,
+                      int width, int height);
+       inline int get_layer_samples() { return render_layer.samples; }
+       inline int get_layer_bound_samples() { return render_layer.bound_samples; }
 
        /* get parameters */
-       static SceneParams get_scene_params(BL::Scene b_scene, bool background, bool is_cpu);
-       static SessionParams get_session_params(BL::RenderEngine b_engine,
-                                               BL::UserPreferences b_userpref,
-                                               BL::Scene b_scene,
+       static SceneParams get_scene_params(BL::Scene& b_scene,
+                                           bool background,
+                                           bool is_cpu);
+       static SessionParams get_session_params(BL::RenderEngine& b_engine,
+                                               BL::UserPreferences& b_userpref,
+                                               BL::Scene& b_scene,
                                                bool background);
-       static bool get_session_pause(BL::Scene b_scene, bool background);
-       static BufferParams get_buffer_params(BL::RenderSettings b_render, BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, Camera *cam, int width, int height);
+       static bool get_session_pause(BL::Scene& b_scene, bool background);
+       static BufferParams get_buffer_params(BL::RenderSettings& b_render,
+                                             BL::SpaceView3D& b_v3d,
+                                             BL::RegionView3D& b_rv3d,
+                                             Camera *cam,
+                                             int width, int height);
 
 private:
        /* sync */
        void sync_lamps(bool update_all);
        void sync_materials(bool update_all);
-       void sync_objects(BL::SpaceView3D b_v3d, float motion_time = 0.0f);
-       void sync_motion(BL::RenderSettings b_render,
-                        BL::SpaceView3D b_v3d,
-                        BL::Object b_override,
+       void sync_objects(BL::SpaceView3D& b_v3d, float motion_time = 0.0f);
+       void sync_motion(BL::RenderSettings& b_render,
+                        BL::SpaceView3D& b_v3d,
+                        BL::Object& b_override,
                         int width, int height,
                         void **python_thread_state);
        void sync_film();
@@ -91,12 +107,16 @@ private:
        void sync_shaders();
        void sync_curve_settings();
 
-       void sync_nodes(Shader *shader, BL::ShaderNodeTree b_ntree);
-       Mesh *sync_mesh(BL::Object b_ob, bool object_updated, bool hide_tris);
-       void sync_curves(Mesh *mesh, BL::Mesh b_mesh, BL::Object b_ob, bool motion, int time_index = 0);
-       Object *sync_object(BL::Object b_parent,
+       void sync_nodes(Shader *shader, BL::ShaderNodeTree& b_ntree);
+       Mesh *sync_mesh(BL::Object& b_ob, bool object_updated, bool hide_tris);
+       void sync_curves(Mesh *mesh,
+                        BL::Mesh& b_mesh,
+                        BL::Object& b_ob,
+                        bool motion,
+                        int time_index = 0);
+       Object *sync_object(BL::Object& b_parent,
                            int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
-                           BL::DupliObject b_dupli_ob,
+                           BL::DupliObject& b_dupli_ob,
                            Transform& tfm,
                            uint layer_flag,
                            float motion_time,
@@ -104,25 +124,31 @@ private:
                            bool use_camera_cull,
                            float camera_cull_margin,
                            bool *use_portal);
-       void sync_light(BL::Object b_parent, int persistent_id[OBJECT_PERSISTENT_ID_SIZE], BL::Object b_ob, Transform& tfm, bool *use_portal);
+       void sync_light(BL::Object& b_parent,
+                       int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
+                       BL::Object& b_ob,
+                       Transform& tfm,
+                       bool *use_portal);
        void sync_background_light(bool use_portal);
-       void sync_mesh_motion(BL::Object b_ob, Object *object, float motion_time);
-       void sync_camera_motion(BL::RenderSettings b_render,
-                               BL::Object b_ob,
+       void sync_mesh_motion(BL::Object& b_ob, Object *object, float motion_time);
+       void sync_camera_motion(BL::RenderSettings& b_render,
+                               BL::Object& b_ob,
                                int width, int height,
                                float motion_time);
 
        /* particles */
-       bool sync_dupli_particle(BL::Object b_ob, BL::DupliObject b_dup, Object *object);
+       bool sync_dupli_particle(BL::Object& b_ob,
+                                BL::DupliObject& b_dup,
+                                Object *object);
 
        /* Images. */
        void sync_images();
 
        /* util */
-       void find_shader(BL::ID id, vector<uint>& used_shaders, int default_shader);
-       bool BKE_object_is_modified(BL::Object b_ob);
-       bool object_is_mesh(BL::Object b_ob);
-       bool object_is_light(BL::Object b_ob);
+       void find_shader(BL::ID& id, vector<uint>& used_shaders, int default_shader);
+       bool BKE_object_is_modified(BL::Object& b_ob);
+       bool object_is_mesh(BL::Object& b_ob);
+       bool object_is_light(BL::Object& b_ob);
 
        /* variables */
        BL::RenderEngine b_engine;
index 55fc5352e3f32ae6b87f605e67cb0aaa95802a85..3807e683c7c6ba3063243583caacefd471fc1520 100644 (file)
@@ -34,8 +34,8 @@ void density_texture_space_invert(float3& loc,
 
 }  /* namespace */
 
-void point_density_texture_space(BL::Scene b_scene,
-                                 BL::ShaderNodeTexPointDensity b_point_density_node,
+void point_density_texture_space(BL::Scene& b_scene,
+                                 BL::ShaderNodeTexPointDensity& b_point_density_node,
                                  int settings,
                                  float3& loc,
                                  float3& size)
index 017b78b67e3719723b37c783f80f63b370c3d137..ad96f9db8ed21f3a650597281e020a1cd7fb5538 100644 (file)
@@ -22,8 +22,8 @@
 
 CCL_NAMESPACE_BEGIN
 
-void point_density_texture_space(BL::Scene b_scene,
-                                 BL::ShaderNodeTexPointDensity b_point_density_node,
+void point_density_texture_space(BL::Scene& b_scene,
+                                 BL::ShaderNodeTexPointDensity& b_point_density_node,
                                  const int settings,
                                  float3& loc,
                                  float3& size);
index 56ac5d1c4bad9f4fc68a6ea1c3dce2168f9b07d3..06176b2d28994a5eecd16281097d127bde55ecb9 100644 (file)
@@ -40,7 +40,12 @@ CCL_NAMESPACE_BEGIN
 void python_thread_state_save(void **python_thread_state);
 void python_thread_state_restore(void **python_thread_state);
 
-static inline BL::Mesh object_to_mesh(BL::BlendData data, BL::Object object, BL::Scene scene, bool apply_modifiers, bool render, bool calc_undeformed)
+static inline BL::Mesh object_to_mesh(BL::BlendData& data,
+                                      BL::Object& object,
+                                      BL::Scene& scene,
+                                      bool apply_modifiers,
+                                      bool render,
+                                      bool calc_undeformed)
 {
        BL::Mesh me = data.meshes.new_from_object(scene, object, apply_modifiers, (render)? 2: 1, false, calc_undeformed);
        if((bool)me) {
@@ -52,7 +57,9 @@ static inline BL::Mesh object_to_mesh(BL::BlendData data, BL::Object object, BL:
        return me;
 }
 
-static inline void colorramp_to_array(BL::ColorRamp ramp, float4 *data, int size)
+static inline void colorramp_to_array(BL::ColorRamp& ramp,
+                                      float4 *data,
+                                      int size)
 {
        for(int i = 0; i < size; i++) {
                float color[4];
@@ -85,7 +92,9 @@ static inline void curvemapping_minmax(/*const*/ BL::CurveMapping& cumap,
        }
 }
 
-static inline void curvemapping_to_array(BL::CurveMapping cumap, float *data, int size)
+static inline void curvemapping_to_array(BL::CurveMapping& cumap,
+                                         float *data,
+                                         int size)
 {
        cumap.update();
        BL::CurveMap curve = cumap.curves[0];
@@ -95,7 +104,7 @@ static inline void curvemapping_to_array(BL::CurveMapping cumap, float *data, in
        }
 }
 
-static inline void curvemapping_color_to_array(BL::CurveMapping cumap,
+static inline void curvemapping_color_to_array(BL::CurveMapping& cumap,
                                                float4 *data,
                                                int size,
                                                bool rgb_curve)
@@ -145,27 +154,33 @@ static inline void curvemapping_color_to_array(BL::CurveMapping cumap,
        }
 }
 
-static inline bool BKE_object_is_modified(BL::Object self, BL::Scene scene, bool preview)
+static inline bool BKE_object_is_modified(BL::Object& self,
+                                          BL::Scene& scene,
+                                          bool preview)
 {
        return self.is_modified(scene, (preview)? (1<<0): (1<<1))? true: false;
 }
 
-static inline bool BKE_object_is_deform_modified(BL::Object self, BL::Scene scene, bool preview)
+static inline bool BKE_object_is_deform_modified(BL::Object& self,
+                                                 BL::Scene& scene,
+                                                 bool preview)
 {
        return self.is_deform_modified(scene, (preview)? (1<<0): (1<<1))? true: false;
 }
 
-static inline int render_resolution_x(BL::RenderSettings b_render)
+static inline int render_resolution_x(BL::RenderSettings& b_render)
 {
        return b_render.resolution_x()*b_render.resolution_percentage()/100;
 }
 
-static inline int render_resolution_y(BL::RenderSettings b_render)
+static inline int render_resolution_y(BL::RenderSettings& b_render)
 {
        return b_render.resolution_y()*b_render.resolution_percentage()/100;
 }
 
-static inline string image_user_file_path(BL::ImageUser iuser, BL::Image ima, int cfra)
+static inline string image_user_file_path(BL::ImageUser& iuser,
+                                          BL::Image& ima,
+                                          int cfra)
 {
        char filepath[1024];
        BKE_image_user_frame_calc(iuser.ptr.data, cfra, 0);
@@ -173,25 +188,27 @@ static inline string image_user_file_path(BL::ImageUser iuser, BL::Image ima, in
        return string(filepath);
 }
 
-static inline int image_user_frame_number(BL::ImageUser iuser, int cfra)
+static inline int image_user_frame_number(BL::ImageUser& iuser, int cfra)
 {
        BKE_image_user_frame_calc(iuser.ptr.data, cfra, 0);
        return iuser.frame_current();
 }
 
-static inline unsigned char *image_get_pixels_for_frame(BL::Image image, int frame)
+static inline unsigned char *image_get_pixels_for_frame(BL::Image& image,
+                                                        int frame)
 {
        return BKE_image_get_pixels_for_frame(image.ptr.data, frame);
 }
 
-static inline float *image_get_float_pixels_for_frame(BL::Image image, int frame)
+static inline float *image_get_float_pixels_for_frame(BL::Image& image,
+                                                      int frame)
 {
        return BKE_image_get_float_pixels_for_frame(image.ptr.data, frame);
 }
 
 /* Utilities */
 
-static inline Transform get_transform(BL::Array<float, 16> array)
+static inline Transform get_transform(const BL::Array<float, 16>& array)
 {
        Transform tfm;
 
@@ -203,42 +220,42 @@ static inline Transform get_transform(BL::Array<float, 16> array)
        return tfm;
 }
 
-static inline float2 get_float2(BL::Array<float, 2> array)
+static inline float2 get_float2(const BL::Array<float, 2>& array)
 {
        return make_float2(array[0], array[1]);
 }
 
-static inline float3 get_float3(BL::Array<float, 2> array)
+static inline float3 get_float3(const BL::Array<float, 2>& array)
 {
        return make_float3(array[0], array[1], 0.0f);
 }
 
-static inline float3 get_float3(BL::Array<float, 3> array)
+static inline float3 get_float3(const BL::Array<float, 3>& array)
 {
        return make_float3(array[0], array[1], array[2]);
 }
 
-static inline float3 get_float3(BL::Array<float, 4> array)
+static inline float3 get_float3(const BL::Array<float, 4>& array)
 {
        return make_float3(array[0], array[1], array[2]);
 }
 
-static inline float4 get_float4(BL::Array<float, 4> array)
+static inline float4 get_float4(const BL::Array<float, 4>& array)
 {
        return make_float4(array[0], array[1], array[2], array[3]);
 }
 
-static inline int3 get_int3(BL::Array<int, 3> array)
+static inline int3 get_int3(const BL::Array<int, 3>& array)
 {
        return make_int3(array[0], array[1], array[2]);
 }
 
-static inline int4 get_int4(BL::Array<int, 4> array)
+static inline int4 get_int4(const BL::Array<int, 4>& array)
 {
        return make_int4(array[0], array[1], array[2], array[3]);
 }
 
-static inline uint get_layer(BL::Array<int, 20> array)
+static inline uint get_layer(const BL::Array<int, 20>& array)
 {
        uint layer = 0;
 
@@ -249,8 +266,8 @@ static inline uint get_layer(BL::Array<int, 20> array)
        return layer;
 }
 
-static inline uint get_layer(BL::Array<int, 20> array,
-                             BL::Array<int, 8> local_array,
+static inline uint get_layer(const BL::Array<int, 20>& array,
+                             const BL::Array<int, 8>& local_array,
                              bool use_local,
                              bool is_light = false,
                              uint scene_layers = (1 << 20) - 1)
@@ -384,13 +401,19 @@ static inline void set_string(PointerRNA& ptr, const char *name, const string &v
 
 /* Relative Paths */
 
-static inline string blender_absolute_path(BL::BlendData b_data, BL::ID b_id, const string& path)
+static inline string blender_absolute_path(BL::BlendData& b_data,
+                                           BL::ID& b_id,
+                                           const string& path)
 {
        if(path.size() >= 2 && path[0] == '/' && path[1] == '/') {
                string dirname;
                
-               if(b_id.library())
-                       dirname = blender_absolute_path(b_data, b_id.library(), b_id.library().filepath());
+               if(b_id.library()) {
+                       BL::ID b_library_id(b_id.library());
+                       dirname = blender_absolute_path(b_data,
+                                                       b_library_id,
+                                                       b_id.library().filepath());
+               }
                else
                        dirname = b_data.filepath();
 
@@ -402,7 +425,9 @@ static inline string blender_absolute_path(BL::BlendData b_data, BL::ID b_id, co
 
 /* Texture Space */
 
-static inline void mesh_texture_space(BL::Mesh b_mesh, float3& loc, float3& size)
+static inline void mesh_texture_space(BL::Mesh& b_mesh,
+                                      float3& loc,
+                                      float3& size)
 {
        loc = get_float3(b_mesh.texspace_location());
        size = get_float3(b_mesh.texspace_size());
@@ -415,7 +440,7 @@ static inline void mesh_texture_space(BL::Mesh b_mesh, float3& loc, float3& size
 }
 
 /* object used for motion blur */
-static inline bool object_use_motion(BL::Object b_parent, BL::Object b_ob)
+static inline bool object_use_motion(BL::Object& b_parent, BL::Object& b_ob)
 {
        PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles");
        bool use_motion = get_boolean(cobject, "use_motion_blur");
@@ -433,7 +458,7 @@ static inline bool object_use_motion(BL::Object b_parent, BL::Object b_ob)
 }
 
 /* object motion steps */
-static inline uint object_motion_steps(BL::Object b_ob)
+static inline uint object_motion_steps(BL::Object& b_ob)
 {
        PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles");
        uint steps = get_int(cobject, "motion_steps");
@@ -445,7 +470,8 @@ static inline uint object_motion_steps(BL::Object b_ob)
 }
 
 /* object uses deformation motion blur */
-static inline bool object_use_deform_motion(BL::Object b_parent, BL::Object b_ob)
+static inline bool object_use_deform_motion(BL::Object& b_parent,
+                                            BL::Object& b_ob)
 {
        PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles");
        bool use_deform_motion = get_boolean(cobject, "use_deform_motion");
@@ -462,7 +488,7 @@ static inline bool object_use_deform_motion(BL::Object b_parent, BL::Object b_ob
        return use_deform_motion;
 }
 
-static inline BL::SmokeDomainSettings object_smoke_domain_find(BL::Object b_ob)
+static inline BL::SmokeDomainSettings object_smoke_domain_find(BL::Object& b_ob)
 {
        BL::Object::modifiers_iterator b_mod;
 
@@ -491,7 +517,7 @@ public:
                scene_data = scene_data_;
        }
 
-       T *find(BL::ID id)
+       T *find(const BL::ID& id)
        {
                return find(id.ptr.id.data);
        }
@@ -506,7 +532,7 @@ public:
                return NULL;
        }
 
-       void set_recalc(BL::ID id)
+       void set_recalc(const BL::ID& id)
        {
                b_recalc.insert(id.ptr.data);
        }
@@ -521,12 +547,12 @@ public:
                used_set.clear();
        }
 
-       bool sync(T **r_data, BL::ID id)
+       bool sync(T **r_data, const BL::ID& id)
        {
                return sync(r_data, id, id, id.ptr.id.data);
        }
 
-       bool sync(T **r_data, BL::ID id, BL::ID parent, const K& key)
+       bool sync(T **r_data, const BL::ID& id, const BL::ID& parent, const K& key)
        {
                T *data = find(key);
                bool recalc;
index ce977daf30a3863f1f5ab8f5290cbe8cab429e91..535847cfc78333fe147bc767dadcd3e02c57d4d2 100644 (file)
@@ -3692,6 +3692,7 @@ static const char *cpp_classes = ""
 "return *this; }\n"
 "\n"
 "      operator T*() { return data; }\n"
+"      operator const T*() const { return data; }\n"
 "};\n"
 "\n"
 "template<typename T>\n"