1 files changed, 79 insertions, 65 deletions

diff --git a/intern/cycles/render/geometry.cpp b/intern/cycles/render/geometry.cpp
index 7b410a0c5ea..a63fc620c69 100644
--- a/intern/cycles/render/geometry.cpp
+++ b/intern/cycles/render/geometry.cpp
@@ -52,14 +52,14 @@ NODE_ABSTRACT_DEFINE(Geometry)
 
   SOCKET_UINT(motion_steps, "Motion Steps", 3);
   SOCKET_BOOLEAN(use_motion_blur, "Use Motion Blur", false);
+  SOCKET_NODE_ARRAY(used_shaders, "Shaders", &Shader::node_type);
 
   return type;
 }
 
 Geometry::Geometry(const NodeType *node_type, const Type type)
-    : Node(node_type), type(type), attributes(this, ATTR_PRIM_GEOMETRY)
+    : Node(node_type), geometry_type(type), attributes(this, ATTR_PRIM_GEOMETRY)
 {
-  need_update = true;
   need_update_rebuild = false;
 
   transform_applied = false;
@@ -99,9 +99,11 @@ bool Geometry::need_attribute(Scene *scene, AttributeStandard std)
   if (scene->need_global_attribute(std))
     return true;
 
-  foreach (Shader *shader, used_shaders)
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
     if (shader->attributes.find(std))
       return true;
+  }
 
   return false;
 }
@@ -111,9 +113,11 @@ bool Geometry::need_attribute(Scene * /*scene*/, ustring name)
   if (name == ustring())
     return false;
 
-  foreach (Shader *shader, used_shaders)
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
     if (shader->attributes.find(name))
       return true;
+  }
 
   return false;
 }
@@ -122,8 +126,10 @@ AttributeRequestSet Geometry::needed_attributes()
 {
   AttributeRequestSet result;
 
-  foreach (Shader *shader, used_shaders)
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
     result.add(shader->attributes);
+  }
 
   return result;
 }
@@ -171,8 +177,9 @@ bool Geometry::is_instanced() const
 
 bool Geometry::has_true_displacement() const
 {
-  foreach (Shader *shader, used_shaders) {
-    if (shader->has_displacement && shader->displacement_method != DISPLACE_BUMP) {
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
+    if (shader->has_displacement && shader->get_displacement_method() != DISPLACE_BUMP) {
       return true;
     }
   }
@@ -198,7 +205,7 @@ void Geometry::compute_bvh(
       msg += string_printf("%s %u/%u", name.c_str(), (uint)(n + 1), (uint)total);
 
     Object object;
-    object.geometry = this;
+    object.set_geometry(this);
 
     vector<Geometry *> geometry;
     geometry.push_back(this);
@@ -232,7 +239,7 @@ void Geometry::compute_bvh(
     }
   }
 
-  need_update = false;
+  clear_modified();
   need_update_rebuild = false;
 }
 
@@ -254,16 +261,18 @@ bool Geometry::has_voxel_attributes() const
 
 void Geometry::tag_update(Scene *scene, bool rebuild)
 {
-  need_update = true;
+  tag_modified();
 
   if (rebuild) {
     need_update_rebuild = true;
     scene->light_manager->need_update = true;
   }
   else {
-    foreach (Shader *shader, used_shaders)
+    foreach (Node *node, used_shaders) {
+      Shader *shader = static_cast<Shader *>(node);
       if (shader->has_surface_emission)
         scene->light_manager->need_update = true;
+    }
   }
 
   scene->geometry_manager->need_update = true;
@@ -433,9 +442,9 @@ static void emit_attribute_mapping(
 
   emit_attribute_map_entry(attr_map, index, id, req.type, req.desc);
 
-  if (geom->type == Geometry::MESH) {
+  if (geom->is_mesh()) {
     Mesh *mesh = static_cast<Mesh *>(geom);
-    if (mesh->subd_faces.size()) {
+    if (mesh->get_num_subd_faces()) {
       emit_attribute_map_entry(attr_map, index + 1, id, req.subd_type, req.subd_desc);
     }
   }
@@ -547,19 +556,19 @@ static void update_attribute_element_size(Geometry *geom,
   }
 }
 
-static void update_attribute_element_offset(Geometry *geom,
-                                            device_vector<float> &attr_float,
-                                            size_t &attr_float_offset,
-                                            device_vector<float2> &attr_float2,
-                                            size_t &attr_float2_offset,
-                                            device_vector<float4> &attr_float3,
-                                            size_t &attr_float3_offset,
-                                            device_vector<uchar4> &attr_uchar4,
-                                            size_t &attr_uchar4_offset,
-                                            Attribute *mattr,
-                                            AttributePrimitive prim,
-                                            TypeDesc &type,
-                                            AttributeDescriptor &desc)
+void GeometryManager::update_attribute_element_offset(Geometry *geom,
+                                                      device_vector<float> &attr_float,
+                                                      size_t &attr_float_offset,
+                                                      device_vector<float2> &attr_float2,
+                                                      size_t &attr_float2_offset,
+                                                      device_vector<float4> &attr_float3,
+                                                      size_t &attr_float3_offset,
+                                                      device_vector<uchar4> &attr_uchar4,
+                                                      size_t &attr_uchar4_offset,
+                                                      Attribute *mattr,
+                                                      AttributePrimitive prim,
+                                                      TypeDesc &type,
+                                                      AttributeDescriptor &desc)
 {
   if (mattr) {
     /* store element and type */
@@ -631,7 +640,7 @@ static void update_attribute_element_offset(Geometry *geom,
 
     /* mesh vertex/curve index is global, not per object, so we sneak
      * a correction for that in here */
-    if (geom->type == Geometry::MESH) {
+    if (geom->is_mesh()) {
       Mesh *mesh = static_cast<Mesh *>(geom);
       if (mesh->subdivision_type == Mesh::SUBDIVISION_CATMULL_CLARK &&
           desc.flags & ATTR_SUBDIVIDED) {
@@ -655,7 +664,7 @@ static void update_attribute_element_offset(Geometry *geom,
           offset -= mesh->corner_offset;
       }
     }
-    else if (geom->type == Geometry::HAIR) {
+    else if (geom->is_hair()) {
       Hair *hair = static_cast<Hair *>(geom);
       if (element == ATTR_ELEMENT_CURVE)
         offset -= hair->prim_offset;
@@ -690,7 +699,8 @@ void GeometryManager::device_update_attributes(Device *device,
     geom->index = i;
     scene->need_global_attributes(geom_attributes[i]);
 
-    foreach (Shader *shader, geom->used_shaders) {
+    foreach (Node *node, geom->get_used_shaders()) {
+      Shader *shader = static_cast<Shader *>(node);
       geom_attributes[i].add(shader->attributes);
     }
   }
@@ -754,7 +764,7 @@ void GeometryManager::device_update_attributes(Device *device,
                                     &attr_float3_size,
                                     &attr_uchar4_size);
 
-      if (geom->type == Geometry::MESH) {
+      if (geom->is_mesh()) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         Attribute *subd_attr = mesh->subd_attributes.find(req);
 
@@ -816,7 +826,7 @@ void GeometryManager::device_update_attributes(Device *device,
                                       req.type,
                                       req.desc);
 
-      if (geom->type == Geometry::MESH) {
+      if (geom->is_mesh()) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         Attribute *subd_attr = mesh->subd_attributes.find(req);
 
@@ -919,7 +929,7 @@ void GeometryManager::mesh_calc_offset(Scene *scene)
   size_t optix_prim_size = 0;
 
   foreach (Geometry *geom, scene->geometry) {
-    if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
+    if (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME) {
       Mesh *mesh = static_cast<Mesh *>(geom);
 
       mesh->vert_offset = vert_size;
@@ -932,8 +942,8 @@ void GeometryManager::mesh_calc_offset(Scene *scene)
       vert_size += mesh->verts.size();
       tri_size += mesh->num_triangles();
 
-      if (mesh->subd_faces.size()) {
-        Mesh::SubdFace &last = mesh->subd_faces[mesh->subd_faces.size() - 1];
+      if (mesh->get_num_subd_faces()) {
+        Mesh::SubdFace last = mesh->get_subd_face(mesh->get_num_subd_faces() - 1);
         patch_size += (last.ptex_offset + last.num_ptex_faces()) * 8;
 
         /* patch tables are stored in same array so include them in patch_size */
@@ -943,19 +953,19 @@ void GeometryManager::mesh_calc_offset(Scene *scene)
         }
       }
 
-      face_size += mesh->subd_faces.size();
+      face_size += mesh->get_num_subd_faces();
       corner_size += mesh->subd_face_corners.size();
 
       mesh->optix_prim_offset = optix_prim_size;
       optix_prim_size += mesh->num_triangles();
     }
-    else if (geom->type == Geometry::HAIR) {
+    else if (geom->is_hair()) {
       Hair *hair = static_cast<Hair *>(geom);
 
       hair->curvekey_offset = curve_key_size;
       hair->prim_offset = curve_size;
 
-      curve_key_size += hair->curve_keys.size();
+      curve_key_size += hair->get_curve_keys().size();
       curve_size += hair->num_curves();
 
       hair->optix_prim_offset = optix_prim_size;
@@ -977,14 +987,14 @@ void GeometryManager::device_update_mesh(
   size_t patch_size = 0;
 
   foreach (Geometry *geom, scene->geometry) {
-    if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
+    if (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME) {
       Mesh *mesh = static_cast<Mesh *>(geom);
 
       vert_size += mesh->verts.size();
       tri_size += mesh->num_triangles();
 
-      if (mesh->subd_faces.size()) {
-        Mesh::SubdFace &last = mesh->subd_faces[mesh->subd_faces.size() - 1];
+      if (mesh->get_num_subd_faces()) {
+        Mesh::SubdFace last = mesh->get_subd_face(mesh->get_num_subd_faces() - 1);
         patch_size += (last.ptex_offset + last.num_ptex_faces()) * 8;
 
         /* patch tables are stored in same array so include them in patch_size */
@@ -994,10 +1004,10 @@ void GeometryManager::device_update_mesh(
         }
       }
     }
-    else if (geom->type == Geometry::HAIR) {
+    else if (geom->is_hair()) {
       Hair *hair = static_cast<Hair *>(geom);
 
-      curve_key_size += hair->curve_keys.size();
+      curve_key_size += hair->get_curve_keys().size();
       curve_size += hair->num_curves();
     }
   }
@@ -1011,7 +1021,7 @@ void GeometryManager::device_update_mesh(
      * really use same semantic of arrays.
      */
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
+      if (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         for (size_t i = 0; i < mesh->num_triangles(); ++i) {
           tri_prim_index[i + mesh->prim_offset] = 3 * (i + mesh->prim_offset);
@@ -1039,7 +1049,7 @@ void GeometryManager::device_update_mesh(
     float2 *tri_patch_uv = dscene->tri_patch_uv.alloc(vert_size);
 
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
+      if (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         mesh->pack_shaders(scene, &tri_shader[mesh->prim_offset]);
         mesh->pack_normals(&vnormal[mesh->vert_offset]);
@@ -1071,7 +1081,7 @@ void GeometryManager::device_update_mesh(
     float4 *curves = dscene->curves.alloc(curve_size);
 
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->type == Geometry::HAIR) {
+      if (geom->is_hair()) {
         Hair *hair = static_cast<Hair *>(geom);
         hair->pack_curves(scene,
                           &curve_keys[hair->curvekey_offset],
@@ -1092,7 +1102,7 @@ void GeometryManager::device_update_mesh(
     uint *patch_data = dscene->patches.alloc(patch_size);
 
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->type == Geometry::MESH) {
+      if (geom->is_mesh()) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         mesh->pack_patches(&patch_data[mesh->patch_offset],
                            mesh->vert_offset,
@@ -1115,7 +1125,7 @@ void GeometryManager::device_update_mesh(
   if (for_displacement) {
     float4 *prim_tri_verts = dscene->prim_tri_verts.alloc(tri_size * 3);
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
+      if (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         for (size_t i = 0; i < mesh->num_triangles(); ++i) {
           Mesh::Triangle t = mesh->get_triangle(i);
@@ -1242,7 +1252,8 @@ void GeometryManager::device_update_preprocess(Device *device, Scene *scene, Pro
   foreach (Geometry *geom, scene->geometry) {
     geom->has_volume = false;
 
-    foreach (const Shader *shader, geom->used_shaders) {
+    foreach (Node *node, geom->get_used_shaders()) {
+      Shader *shader = static_cast<Shader *>(node);
       if (shader->has_volume) {
         geom->has_volume = true;
       }
@@ -1254,7 +1265,7 @@ void GeometryManager::device_update_preprocess(Device *device, Scene *scene, Pro
     /* Re-create volume mesh if we will rebuild or refit the BVH. Note we
      * should only do it in that case, otherwise the BVH and mesh can go
      * out of sync. */
-    if (geom->need_update && geom->type == Geometry::VOLUME) {
+    if (geom->is_modified() && geom->geometry_type == Geometry::VOLUME) {
       /* Create volume meshes if there is voxel data. */
       if (!volume_images_updated) {
         progress.set_status("Updating Meshes Volume Bounds");
@@ -1266,7 +1277,7 @@ void GeometryManager::device_update_preprocess(Device *device, Scene *scene, Pro
       create_volume_mesh(volume, progress);
     }
 
-    if (geom->type == Geometry::HAIR) {
+    if (geom->is_hair()) {
       /* Set curve shape, still a global scene setting for now. */
       Hair *hair = static_cast<Hair *>(geom);
       hair->curve_shape = scene->params.hair_shape;
@@ -1285,9 +1296,10 @@ void GeometryManager::device_update_displacement_images(Device *device,
   ImageManager *image_manager = scene->image_manager;
   set<int> bump_images;
   foreach (Geometry *geom, scene->geometry) {
-    if (geom->need_update) {
-      foreach (Shader *shader, geom->used_shaders) {
-        if (!shader->has_displacement || shader->displacement_method == DISPLACE_BUMP) {
+    if (geom->is_modified()) {
+      foreach (Node *node, geom->get_used_shaders()) {
+        Shader *shader = static_cast<Shader *>(node);
+        if (!shader->has_displacement || shader->get_displacement_method() == DISPLACE_BUMP) {
           continue;
         }
         foreach (ShaderNode *node, shader->graph->nodes) {
@@ -1321,7 +1333,7 @@ void GeometryManager::device_update_volume_images(Device *device, Scene *scene,
   set<int> volume_images;
 
   foreach (Geometry *geom, scene->geometry) {
-    if (!geom->need_update) {
+    if (!geom->is_modified()) {
       continue;
     }
 
@@ -1370,12 +1382,14 @@ void GeometryManager::device_update(Device *device,
     });
 
     foreach (Geometry *geom, scene->geometry) {
-      foreach (Shader *shader, geom->used_shaders) {
+      foreach (Node *node, geom->get_used_shaders()) {
+        Shader *shader = static_cast<Shader *>(node);
         if (shader->need_update_geometry)
-          geom->need_update = true;
+          geom->tag_modified();
       }
 
-      if (geom->need_update && (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME)) {
+      if (geom->is_modified() &&
+          (geom->geometry_type == Geometry::MESH || geom->geometry_type == Geometry::VOLUME)) {
         Mesh *mesh = static_cast<Mesh *>(geom);
 
         /* Update normals. */
@@ -1387,8 +1401,7 @@ void GeometryManager::device_update(Device *device,
         }
 
         /* Test if we need tessellation. */
-        if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE && mesh->num_subd_verts == 0 &&
-            mesh->subd_params) {
+        if (mesh->need_tesselation()) {
           total_tess_needed++;
         }
 
@@ -1413,17 +1426,18 @@ void GeometryManager::device_update(Device *device,
     });
 
     Camera *dicing_camera = scene->dicing_camera;
+    dicing_camera->set_screen_size_and_resolution(
+        dicing_camera->get_full_width(), dicing_camera->get_full_height(), 1);
     dicing_camera->update(scene);
 
     size_t i = 0;
     foreach (Geometry *geom, scene->geometry) {
-      if (!(geom->need_update && geom->type == Geometry::MESH)) {
+      if (!(geom->is_modified() && geom->is_mesh())) {
         continue;
       }
 
       Mesh *mesh = static_cast<Mesh *>(geom);
-      if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE && mesh->num_subd_verts == 0 &&
-          mesh->subd_params) {
+      if (mesh->need_tesselation()) {
         string msg = "Tessellating ";
         if (mesh->name == "")
           msg += string_printf("%u/%u", (uint)(i + 1), (uint)total_tess_needed);
@@ -1500,8 +1514,8 @@ void GeometryManager::device_update(Device *device,
     });
 
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->need_update) {
-        if (geom->type == Geometry::MESH) {
+      if (geom->is_modified()) {
+        if (geom->is_mesh()) {
           Mesh *mesh = static_cast<Mesh *>(geom);
           if (displace(device, dscene, scene, mesh, progress)) {
             displacement_done = true;
@@ -1543,7 +1557,7 @@ void GeometryManager::device_update(Device *device,
 
     size_t i = 0;
     foreach (Geometry *geom, scene->geometry) {
-      if (geom->need_update) {
+      if (geom->is_modified()) {
         pool.push(function_bind(
             &Geometry::compute_bvh, geom, device, dscene, &scene->params, &progress, i, num_bvh));
         if (geom->need_build_bvh(bvh_layout)) {