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, 38 insertions, 33 deletions

diff --git a/intern/cycles/blender/blender_curves.cpp b/intern/cycles/blender/blender_curves.cpp
index 6288c370567..1af592fc8ab 100644
--- a/intern/cycles/blender/blender_curves.cpp
+++ b/intern/cycles/blender/blender_curves.cpp
@@ -77,7 +77,7 @@ static bool ObtainCacheParticleData(
 
       if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) &&
           (b_part.type() == BL::ParticleSettings::type_HAIR)) {
-        int shader = clamp(b_part.material() - 1, 0, hair->used_shaders.size() - 1);
+        int shader = clamp(b_part.material() - 1, 0, hair->get_used_shaders().size() - 1);
         int display_step = background ? b_part.render_step() : b_part.display_step();
         int totparts = b_psys.particles.length();
         int totchild = background ? b_psys.child_particles.length() :
@@ -307,7 +307,7 @@ static void ExportCurveSegments(Scene *scene, Hair *hair, ParticleCurveData *CDa
     VLOG(1) << "Exporting curve segments for mesh " << hair->name;
   }
 
-  hair->reserve_curves(hair->num_curves() + num_curves, hair->curve_keys.size() + num_keys);
+  hair->reserve_curves(hair->num_curves() + num_curves, hair->get_curve_keys().size() + num_keys);
 
   num_keys = 0;
   num_curves = 0;
@@ -350,7 +350,7 @@ static void ExportCurveSegments(Scene *scene, Hair *hair, ParticleCurveData *CDa
   }
 
   /* check allocation */
-  if ((hair->curve_keys.size() != num_keys) || (hair->num_curves() != num_curves)) {
+  if ((hair->get_curve_keys().size() != num_keys) || (hair->num_curves() != num_curves)) {
     VLOG(1) << "Allocation failed, clearing data";
     hair->clear();
   }
@@ -402,7 +402,7 @@ static void export_hair_motion_validate_attribute(Hair *hair,
                                                   bool have_motion)
 {
   Attribute *attr_mP = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
-  const int num_keys = hair->curve_keys.size();
+  const int num_keys = hair->get_curve_keys().size();
 
   if (num_motion_keys != num_keys || !have_motion) {
     /* No motion or hair "topology" changed, remove attributes again. */
@@ -423,8 +423,8 @@ static void export_hair_motion_validate_attribute(Hair *hair,
       float4 *mP = attr_mP->data_float4() + step * num_keys;
 
       for (int key = 0; key < num_keys; key++) {
-        mP[key] = float3_to_float4(hair->curve_keys[key]);
-        mP[key].w = hair->curve_radius[key];
+        mP[key] = float3_to_float4(hair->get_curve_keys()[key]);
+        mP[key].w = hair->get_curve_radius()[key];
       }
     }
   }
@@ -447,7 +447,7 @@ static void ExportCurveSegmentsMotion(Hair *hair, ParticleCurveData *CData, int
   }
 
   /* export motion vectors for curve keys */
-  size_t numkeys = hair->curve_keys.size();
+  size_t numkeys = hair->get_curve_keys().size();
   float4 *mP = attr_mP->data_float4() + motion_step * numkeys;
   bool have_motion = false;
   int i = 0;
@@ -458,24 +458,24 @@ static void ExportCurveSegmentsMotion(Hair *hair, ParticleCurveData *CData, int
          curve < CData->psys_firstcurve[sys] + CData->psys_curvenum[sys];
          curve++) {
       /* Curve lengths may not match! Curves can be clipped. */
-      int curve_key_end = (num_curves + 1 < (int)hair->curve_first_key.size() ?
-                               hair->curve_first_key[num_curves + 1] :
-                               (int)hair->curve_keys.size());
-      const int num_center_curve_keys = curve_key_end - hair->curve_first_key[num_curves];
+      int curve_key_end = (num_curves + 1 < (int)hair->get_curve_first_key().size() ?
+                               hair->get_curve_first_key()[num_curves + 1] :
+                               (int)hair->get_curve_keys().size());
+      const int num_center_curve_keys = curve_key_end - hair->get_curve_first_key()[num_curves];
       const int is_num_keys_different = CData->curve_keynum[curve] - num_center_curve_keys;
 
       if (!is_num_keys_different) {
         for (int curvekey = CData->curve_firstkey[curve];
              curvekey < CData->curve_firstkey[curve] + CData->curve_keynum[curve];
              curvekey++) {
-          if (i < hair->curve_keys.size()) {
+          if (i < hair->get_curve_keys().size()) {
             mP[i] = CurveSegmentMotionCV(CData, sys, curve, curvekey);
             if (!have_motion) {
               /* unlike mesh coordinates, these tend to be slightly different
                * between frames due to particle transforms into/out of object
                * space, so we use an epsilon to detect actual changes */
-              float4 curve_key = float3_to_float4(hair->curve_keys[i]);
-              curve_key.w = hair->curve_radius[i];
+              float4 curve_key = float3_to_float4(hair->get_curve_keys()[i]);
+              curve_key.w = hair->get_curve_radius()[i];
               if (len_squared(mP[i] - curve_key) > 1e-5f * 1e-5f)
                 have_motion = true;
             }
@@ -560,7 +560,7 @@ void BlenderSync::sync_particle_hair(
       float3 *generated = attr_generated->data_float3();
 
       for (size_t i = 0; i < hair->num_curves(); i++) {
-        float3 co = hair->curve_keys[hair->get_curve(i).first_key];
+        float3 co = hair->get_curve_keys()[hair->get_curve(i).first_key];
         generated[i] = co * size - loc;
       }
     }
@@ -742,7 +742,7 @@ static void export_hair_curves_motion(Hair *hair, BL::Hair b_hair, int motion_st
   }
 
   /* Export motion keys. */
-  const int num_keys = hair->curve_keys.size();
+  const int num_keys = hair->get_curve_keys().size();
   float4 *mP = attr_mP->data_float4() + motion_step * num_keys;
   bool have_motion = false;
   int num_motion_keys = 0;
@@ -769,8 +769,8 @@ static void export_hair_curves_motion(Hair *hair, BL::Hair b_hair, int motion_st
           if (!have_motion) {
             /* TODO: use epsilon for comparison? Was needed for particles due to
              * transform, but ideally should not happen anymore. */
-            float4 curve_key = float3_to_float4(hair->curve_keys[i]);
-            curve_key.w = hair->curve_radius[i];
+            float4 curve_key = float3_to_float4(hair->get_curve_keys()[i]);
+            curve_key.w = hair->get_curve_radius()[i];
             have_motion = !(mP[i] == curve_key);
           }
         }
@@ -820,39 +820,44 @@ void BlenderSync::sync_hair(Hair *hair, BL::Object &b_ob, bool motion, int motio
 void BlenderSync::sync_hair(BL::Depsgraph b_depsgraph,
                             BL::Object b_ob,
                             Hair *hair,
-                            const vector<Shader *> &used_shaders)
+                            array<Node *> &used_shaders)
 {
-  /* Compares curve_keys rather than strands in order to handle quick hair
-   * adjustments in dynamic BVH - other methods could probably do this better. */
-  array<float3> oldcurve_keys;
-  array<float> oldcurve_radius;
-  oldcurve_keys.steal_data(hair->curve_keys);
-  oldcurve_radius.steal_data(hair->curve_radius);
-
-  hair->clear();
-  hair->used_shaders = used_shaders;
+  Hair new_hair;
+  new_hair.set_used_shaders(used_shaders);
 
   if (view_layer.use_hair) {
     if (b_ob.type() == BL::Object::type_HAIR) {
       /* Hair object. */
-      sync_hair(hair, b_ob, false);
+      sync_hair(&new_hair, b_ob, false);
     }
     else {
       /* Particle hair. */
-      bool need_undeformed = hair->need_attribute(scene, ATTR_STD_GENERATED);
+      bool need_undeformed = new_hair.need_attribute(scene, ATTR_STD_GENERATED);
       BL::Mesh b_mesh = object_to_mesh(
           b_data, b_ob, b_depsgraph, need_undeformed, Mesh::SUBDIVISION_NONE);
 
       if (b_mesh) {
-        sync_particle_hair(hair, b_mesh, b_ob, false);
+        sync_particle_hair(&new_hair, b_mesh, b_ob, false);
         free_object_to_mesh(b_data, b_ob, b_mesh);
       }
     }
   }
 
+  /* update original sockets */
+
+  for (const SocketType &socket : new_hair.type->inputs) {
+    hair->set_value(socket, new_hair, socket);
+  }
+
+  foreach (Attribute &attr, new_hair.attributes.attributes) {
+    hair->attributes.attributes.push_back(std::move(attr));
+  }
+
   /* tag update */
-  const bool rebuild = ((oldcurve_keys != hair->curve_keys) ||
-                        (oldcurve_radius != hair->curve_radius));
+
+  /* Compares curve_keys rather than strands in order to handle quick hair
+   * adjustments in dynamic BVH - other methods could probably do this better. */
+  const bool rebuild = (hair->curve_keys_is_modified() || hair->curve_radius_is_modified());
 
   hair->tag_update(scene, rebuild);
 }