Cycles API: encapsulate Node socket members

This encapsulates Node socket members behind a set of specific methods;
as such it is no longer possible to directly access Node class members
from exporters and parts of Cycles.

The methods are defined via the NODE_SOCKET_API macros in `graph/
node.h`, and are for getting or setting a specific socket's value, as
well as querying or modifying the state of its update flag.

The setters will check whether the value has changed and tag the socket
as modified appropriately. This will let us know how a Node has changed
and what to update, which is the first concrete step toward a more
granular scene update system.

Since the setters will tag the Node sockets as modified when passed
different data, this patch also removes the various `modified` methods
on Nodes in favor of `Node::is_modified` which checks the sockets'
update flags status.

Reviewed By: brecht

Maniphest Tasks: T79174

Differential Revision: https://developer.blender.org/D8544

1 files changed, 77 insertions, 65 deletions

diff --git a/intern/cycles/render/geometry.cpp b/intern/cycles/render/geometry.cpp
index 455959512fd..910148a9d3b 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;
@@ -97,9 +97,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;
 }
@@ -109,9 +111,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;
 }
@@ -159,8 +163,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;
     }
   }
@@ -186,7 +191,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);
@@ -220,7 +225,7 @@ void Geometry::compute_bvh(
     }
   }
 
-  need_update = false;
+  clear_modified();
   need_update_rebuild = false;
 }
 
@@ -242,16 +247,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;
@@ -308,7 +315,7 @@ void GeometryManager::update_osl_attributes(Device *device,
     size_t j;
 
     for (j = 0; j < scene->geometry.size(); j++)
-      if (scene->geometry[j] == object->geometry)
+      if (scene->geometry[j] == object->get_geometry())
         break;
 
     AttributeRequestSet &attributes = geom_attributes[j];
@@ -433,9 +440,9 @@ void GeometryManager::update_svm_attributes(Device *,
 
       index++;
 
-      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()) {
           attr_map[index].x = id;
           attr_map[index].y = req.subd_desc.element;
           attr_map[index].z = as_uint(req.subd_desc.offset);
@@ -505,19 +512,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 */
@@ -589,7 +596,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) {
@@ -613,7 +620,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;
@@ -647,7 +654,8 @@ void GeometryManager::device_update_attributes(Device *device,
 
     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);
     }
   }
@@ -677,7 +685,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);
 
@@ -725,7 +733,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);
 
@@ -797,7 +805,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;
@@ -810,8 +818,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 */
@@ -821,19 +829,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;
@@ -855,14 +863,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 */
@@ -872,10 +880,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();
     }
   }
@@ -889,7 +897,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);
@@ -917,7 +925,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]);
@@ -949,7 +957,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],
@@ -970,7 +978,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,
@@ -993,7 +1001,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);
@@ -1120,7 +1128,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;
       }
@@ -1129,7 +1138,7 @@ void GeometryManager::device_update_preprocess(Device *device, Scene *scene, Pro
       }
     }
 
-    if (geom->need_update_rebuild && geom->type == Geometry::VOLUME) {
+    if (geom->need_update_rebuild && geom->geometry_type == Geometry::VOLUME) {
       /* Create volume meshes if there is voxel data. */
       if (!volume_images_updated) {
         progress.set_status("Updating Meshes Volume Bounds");
@@ -1141,7 +1150,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;
@@ -1160,9 +1169,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) {
@@ -1196,7 +1206,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;
     }
 
@@ -1245,12 +1255,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. */
@@ -1262,8 +1274,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++;
         }
 
@@ -1288,17 +1299,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);
@@ -1375,8 +1387,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;
@@ -1418,7 +1430,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)) {