Cycles: remove prefix from source code file names

Remove prefix of filenames that is the same as the folder name. This used
to help when #includes were using individual files, but now they are always
relative to the cycles root directory and so the prefixes are redundant.

For patches and branches, git merge and rebase should be able to detect the
renames and move over code to the right file.

1 files changed, 915 insertions, 0 deletions

diff --git a/intern/cycles/blender/curves.cpp b/intern/cycles/blender/curves.cpp
new file mode 100644
index 00000000000..fb2b329e61d
--- /dev/null
+++ b/intern/cycles/blender/curves.cpp
@@ -0,0 +1,915 @@
+/*
+ * Copyright 2011-2013 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "blender/sync.h"
+#include "blender/util.h"
+
+#include "scene/attribute.h"
+#include "scene/camera.h"
+#include "scene/curves.h"
+#include "scene/hair.h"
+#include "scene/object.h"
+#include "scene/scene.h"
+
+#include "util/color.h"
+#include "util/foreach.h"
+#include "util/hash.h"
+#include "util/log.h"
+
+CCL_NAMESPACE_BEGIN
+
+ParticleCurveData::ParticleCurveData()
+{
+}
+
+ParticleCurveData::~ParticleCurveData()
+{
+}
+
+static float shaperadius(float shape, float root, float tip, float time)
+{
+  assert(time >= 0.0f);
+  assert(time <= 1.0f);
+  float radius = 1.0f - time;
+
+  if (shape != 0.0f) {
+    if (shape < 0.0f)
+      radius = powf(radius, 1.0f + shape);
+    else
+      radius = powf(radius, 1.0f / (1.0f - shape));
+  }
+  return (radius * (root - tip)) + tip;
+}
+
+/* curve functions */
+
+static bool ObtainCacheParticleData(
+    Hair *hair, BL::Mesh *b_mesh, BL::Object *b_ob, ParticleCurveData *CData, bool background)
+{
+  int curvenum = 0;
+  int keyno = 0;
+
+  if (!(hair && b_mesh && b_ob && CData))
+    return false;
+
+  Transform tfm = get_transform(b_ob->matrix_world());
+  Transform itfm = transform_quick_inverse(tfm);
+
+  for (BL::Modifier &b_mod : b_ob->modifiers) {
+    if ((b_mod.type() == b_mod.type_PARTICLE_SYSTEM) &&
+        (background ? b_mod.show_render() : b_mod.show_viewport())) {
+      BL::ParticleSystemModifier psmd((const PointerRNA)b_mod.ptr);
+      BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
+      BL::ParticleSettings b_part((const PointerRNA)b_psys.settings().ptr);
+
+      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->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() :
+                                    (int)((float)b_psys.child_particles.length() *
+                                          (float)b_part.display_percentage() / 100.0f);
+        int totcurves = totchild;
+
+        if (b_part.child_type() == 0 || totchild == 0)
+          totcurves += totparts;
+
+        if (totcurves == 0)
+          continue;
+
+        int ren_step = (1 << display_step) + 1;
+        if (b_part.kink() == BL::ParticleSettings::kink_SPIRAL)
+          ren_step += b_part.kink_extra_steps();
+
+        CData->psys_firstcurve.push_back_slow(curvenum);
+        CData->psys_curvenum.push_back_slow(totcurves);
+        CData->psys_shader.push_back_slow(shader);
+
+        float radius = b_part.radius_scale() * 0.5f;
+
+        CData->psys_rootradius.push_back_slow(radius * b_part.root_radius());
+        CData->psys_tipradius.push_back_slow(radius * b_part.tip_radius());
+        CData->psys_shape.push_back_slow(b_part.shape());
+        CData->psys_closetip.push_back_slow(b_part.use_close_tip());
+
+        int pa_no = 0;
+        if (!(b_part.child_type() == 0) && totchild != 0)
+          pa_no = totparts;
+
+        int num_add = (totparts + totchild - pa_no);
+        CData->curve_firstkey.reserve(CData->curve_firstkey.size() + num_add);
+        CData->curve_keynum.reserve(CData->curve_keynum.size() + num_add);
+        CData->curve_length.reserve(CData->curve_length.size() + num_add);
+        CData->curvekey_co.reserve(CData->curvekey_co.size() + num_add * ren_step);
+        CData->curvekey_time.reserve(CData->curvekey_time.size() + num_add * ren_step);
+
+        for (; pa_no < totparts + totchild; pa_no++) {
+          int keynum = 0;
+          CData->curve_firstkey.push_back_slow(keyno);
+
+          float curve_length = 0.0f;
+          float3 prev_co_world = zero_float3();
+          float3 prev_co_object = zero_float3();
+          for (int step_no = 0; step_no < ren_step; step_no++) {
+            float3 co_world = prev_co_world;
+            b_psys.co_hair(*b_ob, pa_no, step_no, &co_world.x);
+            float3 co_object = transform_point(&itfm, co_world);
+            if (step_no > 0) {
+              const float step_length = len(co_object - prev_co_object);
+              curve_length += step_length;
+            }
+            CData->curvekey_co.push_back_slow(co_object);
+            CData->curvekey_time.push_back_slow(curve_length);
+            prev_co_object = co_object;
+            prev_co_world = co_world;
+            keynum++;
+          }
+          keyno += keynum;
+
+          CData->curve_keynum.push_back_slow(keynum);
+          CData->curve_length.push_back_slow(curve_length);
+          curvenum++;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ObtainCacheParticleUV(Hair *hair,
+                                  BL::Mesh *b_mesh,
+                                  BL::Object *b_ob,
+                                  ParticleCurveData *CData,
+                                  bool background,
+                                  int uv_num)
+{
+  if (!(hair && b_mesh && b_ob && CData))
+    return false;
+
+  CData->curve_uv.clear();
+
+  for (BL::Modifier &b_mod : b_ob->modifiers) {
+    if ((b_mod.type() == b_mod.type_PARTICLE_SYSTEM) &&
+        (background ? b_mod.show_render() : b_mod.show_viewport())) {
+      BL::ParticleSystemModifier psmd((const PointerRNA)b_mod.ptr);
+      BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
+      BL::ParticleSettings b_part((const PointerRNA)b_psys.settings().ptr);
+
+      if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) &&
+          (b_part.type() == BL::ParticleSettings::type_HAIR)) {
+        int totparts = b_psys.particles.length();
+        int totchild = background ? b_psys.child_particles.length() :
+                                    (int)((float)b_psys.child_particles.length() *
+                                          (float)b_part.display_percentage() / 100.0f);
+        int totcurves = totchild;
+
+        if (b_part.child_type() == 0 || totchild == 0)
+          totcurves += totparts;
+
+        if (totcurves == 0)
+          continue;
+
+        int pa_no = 0;
+        if (!(b_part.child_type() == 0) && totchild != 0)
+          pa_no = totparts;
+
+        int num_add = (totparts + totchild - pa_no);
+        CData->curve_uv.reserve(CData->curve_uv.size() + num_add);
+
+        BL::ParticleSystem::particles_iterator b_pa;
+        b_psys.particles.begin(b_pa);
+        for (; pa_no < totparts + totchild; pa_no++) {
+          /* Add UVs */
+          BL::Mesh::uv_layers_iterator l;
+          b_mesh->uv_layers.begin(l);
+
+          float2 uv = zero_float2();
+          if (b_mesh->uv_layers.length())
+            b_psys.uv_on_emitter(psmd, *b_pa, pa_no, uv_num, &uv.x);
+          CData->curve_uv.push_back_slow(uv);
+
+          if (pa_no < totparts && b_pa != b_psys.particles.end())
+            ++b_pa;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ObtainCacheParticleVcol(Hair *hair,
+                                    BL::Mesh *b_mesh,
+                                    BL::Object *b_ob,
+                                    ParticleCurveData *CData,
+                                    bool background,
+                                    int vcol_num)
+{
+  if (!(hair && b_mesh && b_ob && CData))
+    return false;
+
+  CData->curve_vcol.clear();
+
+  for (BL::Modifier &b_mod : b_ob->modifiers) {
+    if ((b_mod.type() == b_mod.type_PARTICLE_SYSTEM) &&
+        (background ? b_mod.show_render() : b_mod.show_viewport())) {
+      BL::ParticleSystemModifier psmd((const PointerRNA)b_mod.ptr);
+      BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
+      BL::ParticleSettings b_part((const PointerRNA)b_psys.settings().ptr);
+
+      if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) &&
+          (b_part.type() == BL::ParticleSettings::type_HAIR)) {
+        int totparts = b_psys.particles.length();
+        int totchild = background ? b_psys.child_particles.length() :
+                                    (int)((float)b_psys.child_particles.length() *
+                                          (float)b_part.display_percentage() / 100.0f);
+        int totcurves = totchild;
+
+        if (b_part.child_type() == 0 || totchild == 0)
+          totcurves += totparts;
+
+        if (totcurves == 0)
+          continue;
+
+        int pa_no = 0;
+        if (!(b_part.child_type() == 0) && totchild != 0)
+          pa_no = totparts;
+
+        int num_add = (totparts + totchild - pa_no);
+        CData->curve_vcol.reserve(CData->curve_vcol.size() + num_add);
+
+        BL::ParticleSystem::particles_iterator b_pa;
+        b_psys.particles.begin(b_pa);
+        for (; pa_no < totparts + totchild; pa_no++) {
+          /* Add vertex colors */
+          BL::Mesh::vertex_colors_iterator l;
+          b_mesh->vertex_colors.begin(l);
+
+          float4 vcol = make_float4(0.0f, 0.0f, 0.0f, 1.0f);
+          if (b_mesh->vertex_colors.length())
+            b_psys.mcol_on_emitter(psmd, *b_pa, pa_no, vcol_num, &vcol.x);
+          CData->curve_vcol.push_back_slow(vcol);
+
+          if (pa_no < totparts && b_pa != b_psys.particles.end())
+            ++b_pa;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+static void ExportCurveSegments(Scene *scene, Hair *hair, ParticleCurveData *CData)
+{
+  int num_keys = 0;
+  int num_curves = 0;
+
+  if (hair->num_curves())
+    return;
+
+  Attribute *attr_intercept = NULL;
+  Attribute *attr_length = NULL;
+  Attribute *attr_random = NULL;
+
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_INTERCEPT))
+    attr_intercept = hair->attributes.add(ATTR_STD_CURVE_INTERCEPT);
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_LENGTH))
+    attr_length = hair->attributes.add(ATTR_STD_CURVE_LENGTH);
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_RANDOM))
+    attr_random = hair->attributes.add(ATTR_STD_CURVE_RANDOM);
+
+  /* compute and reserve size of arrays */
+  for (int sys = 0; sys < CData->psys_firstcurve.size(); sys++) {
+    for (int curve = CData->psys_firstcurve[sys];
+         curve < CData->psys_firstcurve[sys] + CData->psys_curvenum[sys];
+         curve++) {
+      num_keys += CData->curve_keynum[curve];
+      num_curves++;
+    }
+  }
+
+  if (num_curves > 0) {
+    VLOG(1) << "Exporting curve segments for mesh " << hair->name;
+  }
+
+  hair->reserve_curves(hair->num_curves() + num_curves, hair->get_curve_keys().size() + num_keys);
+
+  num_keys = 0;
+  num_curves = 0;
+
+  /* actually export */
+  for (int sys = 0; sys < CData->psys_firstcurve.size(); sys++) {
+    for (int curve = CData->psys_firstcurve[sys];
+         curve < CData->psys_firstcurve[sys] + CData->psys_curvenum[sys];
+         curve++) {
+      size_t num_curve_keys = 0;
+
+      for (int curvekey = CData->curve_firstkey[curve];
+           curvekey < CData->curve_firstkey[curve] + CData->curve_keynum[curve];
+           curvekey++) {
+        const float3 ickey_loc = CData->curvekey_co[curvekey];
+        const float curve_time = CData->curvekey_time[curvekey];
+        const float curve_length = CData->curve_length[curve];
+        const float time = (curve_length > 0.0f) ? curve_time / curve_length : 0.0f;
+        float radius = shaperadius(
+            CData->psys_shape[sys], CData->psys_rootradius[sys], CData->psys_tipradius[sys], time);
+        if (CData->psys_closetip[sys] &&
+            (curvekey == CData->curve_firstkey[curve] + CData->curve_keynum[curve] - 1)) {
+          radius = 0.0f;
+        }
+        hair->add_curve_key(ickey_loc, radius);
+        if (attr_intercept)
+          attr_intercept->add(time);
+
+        num_curve_keys++;
+      }
+
+      if (attr_length != NULL) {
+        attr_length->add(CData->curve_length[curve]);
+      }
+
+      if (attr_random != NULL) {
+        attr_random->add(hash_uint2_to_float(num_curves, 0));
+      }
+
+      hair->add_curve(num_keys, CData->psys_shader[sys]);
+      num_keys += num_curve_keys;
+      num_curves++;
+    }
+  }
+
+  /* check allocation */
+  if ((hair->get_curve_keys().size() != num_keys) || (hair->num_curves() != num_curves)) {
+    VLOG(1) << "Allocation failed, clearing data";
+    hair->clear(true);
+  }
+}
+
+static float4 CurveSegmentMotionCV(ParticleCurveData *CData, int sys, int curve, int curvekey)
+{
+  const float3 ickey_loc = CData->curvekey_co[curvekey];
+  const float curve_time = CData->curvekey_time[curvekey];
+  const float curve_length = CData->curve_length[curve];
+  float time = (curve_length > 0.0f) ? curve_time / curve_length : 0.0f;
+  float radius = shaperadius(
+      CData->psys_shape[sys], CData->psys_rootradius[sys], CData->psys_tipradius[sys], time);
+
+  if (CData->psys_closetip[sys] &&
+      (curvekey == CData->curve_firstkey[curve] + CData->curve_keynum[curve] - 1))
+    radius = 0.0f;
+
+  /* curve motion keys store both position and radius in float4 */
+  float4 mP = float3_to_float4(ickey_loc);
+  mP.w = radius;
+  return mP;
+}
+
+static float4 LerpCurveSegmentMotionCV(ParticleCurveData *CData, int sys, int curve, float step)
+{
+  assert(step >= 0.0f);
+  assert(step <= 1.0f);
+  const int first_curve_key = CData->curve_firstkey[curve];
+  const float curve_key_f = step * (CData->curve_keynum[curve] - 1);
+  int curvekey = (int)floorf(curve_key_f);
+  const float remainder = curve_key_f - curvekey;
+  if (remainder == 0.0f) {
+    return CurveSegmentMotionCV(CData, sys, curve, first_curve_key + curvekey);
+  }
+  int curvekey2 = curvekey + 1;
+  if (curvekey2 >= (CData->curve_keynum[curve] - 1)) {
+    curvekey2 = (CData->curve_keynum[curve] - 1);
+    curvekey = curvekey2 - 1;
+  }
+  const float4 mP = CurveSegmentMotionCV(CData, sys, curve, first_curve_key + curvekey);
+  const float4 mP2 = CurveSegmentMotionCV(CData, sys, curve, first_curve_key + curvekey2);
+  return lerp(mP, mP2, remainder);
+}
+
+static void export_hair_motion_validate_attribute(Hair *hair,
+                                                  int motion_step,
+                                                  int num_motion_keys,
+                                                  bool have_motion)
+{
+  Attribute *attr_mP = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+  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. */
+    if (num_motion_keys != num_keys) {
+      VLOG(1) << "Hair topology changed, removing attribute.";
+    }
+    else {
+      VLOG(1) << "No motion, removing attribute.";
+    }
+    hair->attributes.remove(ATTR_STD_MOTION_VERTEX_POSITION);
+  }
+  else if (motion_step > 0) {
+    VLOG(1) << "Filling in new motion vertex position for motion_step " << motion_step;
+
+    /* Motion, fill up previous steps that we might have skipped because
+     * they had no motion, but we need them anyway now. */
+    for (int step = 0; step < motion_step; step++) {
+      float4 *mP = attr_mP->data_float4() + step * num_keys;
+
+      for (int key = 0; key < num_keys; key++) {
+        mP[key] = float3_to_float4(hair->get_curve_keys()[key]);
+        mP[key].w = hair->get_curve_radius()[key];
+      }
+    }
+  }
+}
+
+static void ExportCurveSegmentsMotion(Hair *hair, ParticleCurveData *CData, int motion_step)
+{
+  VLOG(1) << "Exporting curve motion segments for hair " << hair->name << ", motion step "
+          << motion_step;
+
+  /* find attribute */
+  Attribute *attr_mP = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+  bool new_attribute = false;
+
+  /* add new attribute if it doesn't exist already */
+  if (!attr_mP) {
+    VLOG(1) << "Creating new motion vertex position attribute";
+    attr_mP = hair->attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
+    new_attribute = true;
+  }
+
+  /* export motion vectors for curve keys */
+  size_t numkeys = hair->get_curve_keys().size();
+  float4 *mP = attr_mP->data_float4() + motion_step * numkeys;
+  bool have_motion = false;
+  int i = 0;
+  int num_curves = 0;
+
+  for (int sys = 0; sys < CData->psys_firstcurve.size(); sys++) {
+    for (int curve = CData->psys_firstcurve[sys];
+         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->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->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->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;
+            }
+          }
+          i++;
+        }
+      }
+      else {
+        /* Number of keys has changed. Generate an interpolated version
+         * to preserve motion blur. */
+        const float step_size = num_center_curve_keys > 1 ? 1.0f / (num_center_curve_keys - 1) :
+                                                            0.0f;
+        for (int step_index = 0; step_index < num_center_curve_keys; ++step_index) {
+          const float step = step_index * step_size;
+          mP[i] = LerpCurveSegmentMotionCV(CData, sys, curve, step);
+          i++;
+        }
+        have_motion = true;
+      }
+      num_curves++;
+    }
+  }
+
+  /* In case of new attribute, we verify if there really was any motion. */
+  if (new_attribute) {
+    export_hair_motion_validate_attribute(hair, motion_step, i, have_motion);
+  }
+}
+
+/* Hair Curve Sync */
+
+bool BlenderSync::object_has_particle_hair(BL::Object b_ob)
+{
+  /* Test if the object has a particle modifier with hair. */
+  for (BL::Modifier &b_mod : b_ob.modifiers) {
+    if ((b_mod.type() == b_mod.type_PARTICLE_SYSTEM) &&
+        (preview ? b_mod.show_viewport() : b_mod.show_render())) {
+      BL::ParticleSystemModifier psmd((const PointerRNA)b_mod.ptr);
+      BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
+      BL::ParticleSettings b_part((const PointerRNA)b_psys.settings().ptr);
+
+      if ((b_part.render_type() == BL::ParticleSettings::render_type_PATH) &&
+          (b_part.type() == BL::ParticleSettings::type_HAIR)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/* Old particle hair. */
+void BlenderSync::sync_particle_hair(
+    Hair *hair, BL::Mesh &b_mesh, BObjectInfo &b_ob_info, bool motion, int motion_step)
+{
+  if (!b_ob_info.is_real_object_data()) {
+    return;
+  }
+  BL::Object b_ob = b_ob_info.real_object;
+
+  /* obtain general settings */
+  if (b_ob.mode() == b_ob.mode_PARTICLE_EDIT || b_ob.mode() == b_ob.mode_EDIT) {
+    return;
+  }
+
+  /* Extract particle hair data - should be combined with connecting to mesh later. */
+
+  ParticleCurveData CData;
+
+  ObtainCacheParticleData(hair, &b_mesh, &b_ob, &CData, !preview);
+
+  /* add hair geometry */
+  if (motion)
+    ExportCurveSegmentsMotion(hair, &CData, motion_step);
+  else
+    ExportCurveSegments(scene, hair, &CData);
+
+  /* generated coordinates from first key. we should ideally get this from
+   * blender to handle deforming objects */
+  if (!motion) {
+    if (hair->need_attribute(scene, ATTR_STD_GENERATED)) {
+      float3 loc, size;
+      mesh_texture_space(b_mesh, loc, size);
+
+      Attribute *attr_generated = hair->attributes.add(ATTR_STD_GENERATED);
+      float3 *generated = attr_generated->data_float3();
+
+      for (size_t i = 0; i < hair->num_curves(); i++) {
+        float3 co = hair->get_curve_keys()[hair->get_curve(i).first_key];
+        generated[i] = co * size - loc;
+      }
+    }
+  }
+
+  /* create vertex color attributes */
+  if (!motion) {
+    BL::Mesh::vertex_colors_iterator l;
+    int vcol_num = 0;
+
+    for (b_mesh.vertex_colors.begin(l); l != b_mesh.vertex_colors.end(); ++l, vcol_num++) {
+      if (!hair->need_attribute(scene, ustring(l->name().c_str())))
+        continue;
+
+      ObtainCacheParticleVcol(hair, &b_mesh, &b_ob, &CData, !preview, vcol_num);
+
+      Attribute *attr_vcol = hair->attributes.add(
+          ustring(l->name().c_str()), TypeRGBA, ATTR_ELEMENT_CURVE);
+
+      float4 *fdata = attr_vcol->data_float4();
+
+      if (fdata) {
+        size_t i = 0;
+
+        /* Encode vertex color using the sRGB curve. */
+        for (size_t curve = 0; curve < CData.curve_vcol.size(); curve++) {
+          fdata[i++] = color_srgb_to_linear_v4(CData.curve_vcol[curve]);
+        }
+      }
+    }
+  }
+
+  /* create UV attributes */
+  if (!motion) {
+    BL::Mesh::uv_layers_iterator l;
+    int uv_num = 0;
+
+    for (b_mesh.uv_layers.begin(l); l != b_mesh.uv_layers.end(); ++l, uv_num++) {
+      bool active_render = l->active_render();
+      AttributeStandard std = (active_render) ? ATTR_STD_UV : ATTR_STD_NONE;
+      ustring name = ustring(l->name().c_str());
+
+      /* UV map */
+      if (hair->need_attribute(scene, name) || hair->need_attribute(scene, std)) {
+        Attribute *attr_uv;
+
+        ObtainCacheParticleUV(hair, &b_mesh, &b_ob, &CData, !preview, uv_num);
+
+        if (active_render)
+          attr_uv = hair->attributes.add(std, name);
+        else
+          attr_uv = hair->attributes.add(name, TypeFloat2, ATTR_ELEMENT_CURVE);
+
+        float2 *uv = attr_uv->data_float2();
+
+        if (uv) {
+          size_t i = 0;
+
+          for (size_t curve = 0; curve < CData.curve_uv.size(); curve++) {
+            uv[i++] = CData.curve_uv[curve];
+          }
+        }
+      }
+    }
+  }
+}
+
+#ifdef WITH_HAIR_NODES
+static float4 hair_point_as_float4(BL::HairPoint b_point)
+{
+  float4 mP = float3_to_float4(get_float3(b_point.co()));
+  mP.w = b_point.radius();
+  return mP;
+}
+
+static float4 interpolate_hair_points(BL::Hair b_hair,
+                                      const int first_point_index,
+                                      const int num_points,
+                                      const float step)
+{
+  const float curve_t = step * (num_points - 1);
+  const int point_a = clamp((int)curve_t, 0, num_points - 1);
+  const int point_b = min(point_a + 1, num_points - 1);
+  const float t = curve_t - (float)point_a;
+  return lerp(hair_point_as_float4(b_hair.points[first_point_index + point_a]),
+              hair_point_as_float4(b_hair.points[first_point_index + point_b]),
+              t);
+}
+
+static void export_hair_curves(Scene *scene, Hair *hair, BL::Hair b_hair)
+{
+  /* TODO: optimize so we can straight memcpy arrays from Blender? */
+
+  /* Add requested attributes. */
+  Attribute *attr_intercept = NULL;
+  Attribute *attr_length = NULL;
+  Attribute *attr_random = NULL;
+
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_INTERCEPT)) {
+    attr_intercept = hair->attributes.add(ATTR_STD_CURVE_INTERCEPT);
+  }
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_LENGTH)) {
+    attr_length = hair->attributes.add(ATTR_STD_CURVE_LENGTH);
+  }
+  if (hair->need_attribute(scene, ATTR_STD_CURVE_RANDOM)) {
+    attr_random = hair->attributes.add(ATTR_STD_CURVE_RANDOM);
+  }
+
+  /* Reserve memory. */
+  const int num_keys = b_hair.points.length();
+  const int num_curves = b_hair.curves.length();
+
+  if (num_curves > 0) {
+    VLOG(1) << "Exporting curve segments for hair " << hair->name;
+  }
+
+  hair->reserve_curves(num_curves, num_keys);
+
+  /* Export curves and points. */
+  vector<float> points_length;
+
+  for (BL::HairCurve &b_curve : b_hair.curves) {
+    const int first_point_index = b_curve.first_point_index();
+    const int num_points = b_curve.num_points();
+
+    float3 prev_co = zero_float3();
+    float length = 0.0f;
+    if (attr_intercept) {
+      points_length.clear();
+      points_length.reserve(num_points);
+    }
+
+    /* Position and radius. */
+    for (int i = 0; i < num_points; i++) {
+      BL::HairPoint b_point = b_hair.points[first_point_index + i];
+
+      const float3 co = get_float3(b_point.co());
+      const float radius = b_point.radius();
+      hair->add_curve_key(co, radius);
+
+      if (attr_intercept) {
+        if (i > 0) {
+          length += len(co - prev_co);
+          points_length.push_back(length);
+        }
+        prev_co = co;
+      }
+    }
+
+    /* Normalized 0..1 attribute along curve. */
+    if (attr_intercept) {
+      for (int i = 0; i < num_points; i++) {
+        attr_intercept->add((length == 0.0f) ? 0.0f : points_length[i] / length);
+      }
+    }
+
+    if (attr_length) {
+      attr_length->add(length);
+    }
+
+    /* Random number per curve. */
+    if (attr_random != NULL) {
+      attr_random->add(hash_uint2_to_float(b_curve.index(), 0));
+    }
+
+    /* Curve. */
+    const int shader_index = 0;
+    hair->add_curve(first_point_index, shader_index);
+  }
+}
+
+static void export_hair_curves_motion(Hair *hair, BL::Hair b_hair, int motion_step)
+{
+  VLOG(1) << "Exporting curve motion segments for hair " << hair->name << ", motion step "
+          << motion_step;
+
+  /* Find or add attribute. */
+  Attribute *attr_mP = hair->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+  bool new_attribute = false;
+
+  if (!attr_mP) {
+    VLOG(1) << "Creating new motion vertex position attribute";
+    attr_mP = hair->attributes.add(ATTR_STD_MOTION_VERTEX_POSITION);
+    new_attribute = true;
+  }
+
+  /* Export motion keys. */
+  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;
+  int curve_index = 0;
+
+  for (BL::HairCurve &b_curve : b_hair.curves) {
+    const int first_point_index = b_curve.first_point_index();
+    const int num_points = b_curve.num_points();
+
+    Hair::Curve curve = hair->get_curve(curve_index);
+    curve_index++;
+
+    if (num_points == curve.num_keys) {
+      /* Number of keys matches. */
+      for (int i = 0; i < num_points; i++) {
+        int point_index = first_point_index + i;
+
+        if (point_index < num_keys) {
+          mP[num_motion_keys] = hair_point_as_float4(b_hair.points[point_index]);
+          num_motion_keys++;
+
+          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->get_curve_keys()[i]);
+            curve_key.w = hair->get_curve_radius()[i];
+            have_motion = !(mP[i] == curve_key);
+          }
+        }
+      }
+    }
+    else {
+      /* Number of keys has changed. Generate an interpolated version
+       * to preserve motion blur. */
+      const float step_size = curve.num_keys > 1 ? 1.0f / (curve.num_keys - 1) : 0.0f;
+      for (int i = 0; i < curve.num_keys; i++) {
+        const float step = i * step_size;
+        mP[num_motion_keys] = interpolate_hair_points(b_hair, first_point_index, num_points, step);
+        num_motion_keys++;
+      }
+      have_motion = true;
+    }
+  }
+
+  /* In case of new attribute, we verify if there really was any motion. */
+  if (new_attribute) {
+    export_hair_motion_validate_attribute(hair, motion_step, num_motion_keys, have_motion);
+  }
+}
+
+/* Hair object. */
+void BlenderSync::sync_hair(Hair *hair, BObjectInfo &b_ob_info, bool motion, int motion_step)
+{
+  /* Convert Blender hair to Cycles curves. */
+  BL::Hair b_hair(b_ob_info.object_data);
+  if (motion) {
+    export_hair_curves_motion(hair, b_hair, motion_step);
+  }
+  else {
+    export_hair_curves(scene, hair, b_hair);
+  }
+}
+#else
+void BlenderSync::sync_hair(Hair *hair, BObjectInfo &b_ob_info, bool motion, int motion_step)
+{
+  (void)hair;
+  (void)b_ob_info;
+  (void)motion;
+  (void)motion_step;
+}
+#endif
+
+void BlenderSync::sync_hair(BL::Depsgraph b_depsgraph, BObjectInfo &b_ob_info, Hair *hair)
+{
+  /* make a copy of the shaders as the caller in the main thread still need them for syncing the
+   * attributes */
+  array<Node *> used_shaders = hair->get_used_shaders();
+
+  Hair new_hair;
+  new_hair.set_used_shaders(used_shaders);
+
+  if (view_layer.use_hair) {
+    if (b_ob_info.object_data.is_a(&RNA_Hair)) {
+      /* Hair object. */
+      sync_hair(&new_hair, b_ob_info, false);
+    }
+    else {
+      /* Particle hair. */
+      bool need_undeformed = new_hair.need_attribute(scene, ATTR_STD_GENERATED);
+      BL::Mesh b_mesh = object_to_mesh(
+          b_data, b_ob_info, b_depsgraph, need_undeformed, Mesh::SUBDIVISION_NONE);
+
+      if (b_mesh) {
+        sync_particle_hair(&new_hair, b_mesh, b_ob_info, false);
+        free_object_to_mesh(b_data, b_ob_info, b_mesh);
+      }
+    }
+  }
+
+  /* update original sockets */
+
+  for (const SocketType &socket : new_hair.type->inputs) {
+    /* Those sockets are updated in sync_object, so do not modify them. */
+    if (socket.name == "use_motion_blur" || socket.name == "motion_steps" ||
+        socket.name == "used_shaders") {
+      continue;
+    }
+    hair->set_value(socket, new_hair, socket);
+  }
+
+  hair->attributes.update(std::move(new_hair.attributes));
+
+  /* tag update */
+
+  /* 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);
+}
+
+void BlenderSync::sync_hair_motion(BL::Depsgraph b_depsgraph,
+                                   BObjectInfo &b_ob_info,
+                                   Hair *hair,
+                                   int motion_step)
+{
+  /* Skip if nothing exported. */
+  if (hair->num_keys() == 0) {
+    return;
+  }
+
+  /* Export deformed coordinates. */
+  if (ccl::BKE_object_is_deform_modified(b_ob_info, b_scene, preview)) {
+    if (b_ob_info.object_data.is_a(&RNA_Hair)) {
+      /* Hair object. */
+      sync_hair(hair, b_ob_info, true, motion_step);
+      return;
+    }
+    else {
+      /* Particle hair. */
+      BL::Mesh b_mesh = object_to_mesh(
+          b_data, b_ob_info, b_depsgraph, false, Mesh::SUBDIVISION_NONE);
+      if (b_mesh) {
+        sync_particle_hair(hair, b_mesh, b_ob_info, true, motion_step);
+        free_object_to_mesh(b_data, b_ob_info, b_mesh);
+        return;
+      }
+    }
+  }
+
+  /* No deformation on this frame, copy coordinates if other frames did have it. */
+  hair->copy_center_to_motion_step(motion_step);
+}
+
+CCL_NAMESPACE_END