intern/cycles/scene/CMakeLists.txt

@@ -18,9 +18,9 @@ set(SRC
   devicescene.cpp
   film.cpp
   geometry.cpp
-  geometry_mesh.cpp
-  geometry_bvh.cpp
   geometry_attributes.cpp
+  geometry_bvh.cpp
+  geometry_mesh.cpp
   hair.cpp
   image.cpp
   image_oiio.cpp

intern/cycles/scene/devicescene.cpp

@@ -1,6 +1,8 @@
 /* SPDX-License-Identifier: Apache-2.0
  * Copyright 2011-2022 Blender Foundation */
 
+#include "bvh/bvh2.h"
+
 #include "scene/devicescene.h"
 #include "scene/scene.h"
 

intern/cycles/scene/devicescene.h

@@ -4,13 +4,9 @@
 #ifndef __DEVICESCENE_H__
 #define __DEVICESCENE_H__
 
-#include "bvh/bvh.h"
-#include "bvh/bvh2.h"
-
+#include "device/device.h"
 #include "device/memory.h"
 
-#include "kernel/types.h"
-
 #include "util/progress.h"
 #include "util/types.h"
 #include "util/vector.h"

intern/cycles/scene/geometry.cpp

@@ -84,49 +84,6 @@ void Geometry::clear(bool preserve_shaders)
   tag_modified();
 }
 
-bool Geometry::need_attribute(Scene *scene, AttributeStandard std)
-{
-  if (std == ATTR_STD_NONE)
-    return false;
-
-  if (scene->need_global_attribute(std))
-    return true;
-
-  foreach (Node *node, used_shaders) {
-    Shader *shader = static_cast<Shader *>(node);
-    if (shader->attributes.find(std))
-      return true;
-  }
-
-  return false;
-}
-
-bool Geometry::need_attribute(Scene * /*scene*/, ustring name)
-{
-  if (name == ustring())
-    return false;
-
-  foreach (Node *node, used_shaders) {
-    Shader *shader = static_cast<Shader *>(node);
-    if (shader->attributes.find(name))
-      return true;
-  }
-
-  return false;
-}
-
-AttributeRequestSet Geometry::needed_attributes()
-{
-  AttributeRequestSet result;
-
-  foreach (Node *node, used_shaders) {
-    Shader *shader = static_cast<Shader *>(node);
-    result.add(shader->attributes);
-  }
-
-  return result;
-}
-
 float Geometry::motion_time(int step) const
 {
   return (motion_steps > 1) ? 2.0f * step / (motion_steps - 1) - 1.0f : 0.0f;
@@ -182,41 +139,11 @@ bool Geometry::has_true_displacement() const
   return false;
 }
 
-void Geometry::compute_bvh(Device *device,
-                           DeviceScene *dscene,
-                           SceneParams *params,
-                           Progress *progress,
-                           size_t n,
-                           size_t total)
-{
-  if (progress->get_cancel())
-     return;
-
-  const BVHLayout bvh_layout = BVHParams::best_bvh_layout(
-      params->bvh_layout, device->get_bvh_layout_mask(dscene->data.kernel_features));
-  if (need_build_bvh(bvh_layout)) {
-    BVH *sub_bvh = bvh->get_device_bvh(device);
-    GeometryManager::device_update_sub_bvh(
-        device, dscene, bvh, sub_bvh, !need_update_rebuild, n, total, progress);
-  }
-}
-
 bool Geometry::has_motion_blur() const
 {
   return (use_motion_blur && attributes.find(ATTR_STD_MOTION_VERTEX_POSITION));
 }
 
-bool Geometry::has_voxel_attributes() const
-{
-  foreach (const Attribute &attr, attributes.attributes) {
-    if (attr.element == ATTR_ELEMENT_VOXEL) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 void Geometry::tag_update(Scene *scene, bool rebuild)
 {
   if (rebuild) {
@@ -280,7 +207,6 @@ void GeometryManager::update_osl_globals(Device *device, Scene *scene)
 #endif
 }
 
-
 static void update_attribute_realloc_flags(uint32_t &device_update_flags,
                                            const AttributeSet &attributes)
 {

intern/cycles/scene/geometry_attributes.cpp

@@ -32,6 +32,60 @@
 
 CCL_NAMESPACE_BEGIN
 
+bool Geometry::need_attribute(Scene *scene, AttributeStandard std)
+{
+  if (std == ATTR_STD_NONE)
+    return false;
+
+  if (scene->need_global_attribute(std))
+    return true;
+
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
+    if (shader->attributes.find(std))
+      return true;
+  }
+
+  return false;
+}
+
+bool Geometry::need_attribute(Scene * /*scene*/, ustring name)
+{
+  if (name == ustring())
+    return false;
+
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
+    if (shader->attributes.find(name))
+      return true;
+  }
+
+  return false;
+}
+
+AttributeRequestSet Geometry::needed_attributes()
+{
+  AttributeRequestSet result;
+
+  foreach (Node *node, used_shaders) {
+    Shader *shader = static_cast<Shader *>(node);
+    result.add(shader->attributes);
+  }
+
+  return result;
+}
+
+bool Geometry::has_voxel_attributes() const
+{
+  foreach (const Attribute &attr, attributes.attributes) {
+    if (attr.element == ATTR_ELEMENT_VOXEL) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /* Generate a normal attribute map entry from an attribute descriptor. */
 static void emit_attribute_map_entry(AttributeMap *attr_map,
                                      size_t index,
@@ -375,6 +429,45 @@ void GeometryManager::update_attribute_element_offset(Geometry *geom,
   }
 }
 
+/*
+ * Records the sizes of the attribute buffers
+ */
+static void update_attribute_element_size(Geometry *geom,
+                                          Attribute *mattr,
+                                          AttributePrimitive prim,
+                                          size_t *attr_float_size,
+                                          size_t *attr_float2_size,
+                                          size_t *attr_float3_size,
+                                          size_t *attr_float4_size,
+                                          size_t *attr_uchar4_size)
+{
+  if (mattr) {
+    size_t size = mattr->element_size(geom, prim);
+
+    if (mattr->element == ATTR_ELEMENT_VOXEL) {
+      /* pass */
+    }
+    else if (mattr->element == ATTR_ELEMENT_CORNER_BYTE) {
+      *attr_uchar4_size += size;
+    }
+    else if (mattr->type == TypeDesc::TypeFloat) {
+      *attr_float_size += size;
+    }
+    else if (mattr->type == TypeFloat2) {
+      *attr_float2_size += size;
+    }
+    else if (mattr->type == TypeDesc::TypeMatrix) {
+      *attr_float4_size += size * 4;
+    }
+    else if (mattr->type == TypeFloat4 || mattr->type == TypeRGBA) {
+      *attr_float4_size += size;
+    }
+    else {
+      *attr_float3_size += size;
+    }
+  }
+}
+
 /*
  * Packs the attribute buffers and records the sizes and offsets using
  * the attribute sets
@@ -524,45 +617,6 @@ bool GeometryManager::device_update_attributes_preprocess(
   return update_obj_offsets;
 }
 
-/*
- * Records the sizes of the attribute buffers
- */
-static void update_attribute_element_size(Geometry *geom,
-                                          Attribute *mattr,
-                                          AttributePrimitive prim,
-                                          size_t *attr_float_size,
-                                          size_t *attr_float2_size,
-                                          size_t *attr_float3_size,
-                                          size_t *attr_float4_size,
-                                          size_t *attr_uchar4_size)
-{
-  if (mattr) {
-    size_t size = mattr->element_size(geom, prim);
-
-    if (mattr->element == ATTR_ELEMENT_VOXEL) {
-      /* pass */
-    }
-    else if (mattr->element == ATTR_ELEMENT_CORNER_BYTE) {
-      *attr_uchar4_size += size;
-    }
-    else if (mattr->type == TypeDesc::TypeFloat) {
-      *attr_float_size += size;
-    }
-    else if (mattr->type == TypeFloat2) {
-      *attr_float2_size += size;
-    }
-    else if (mattr->type == TypeDesc::TypeMatrix) {
-      *attr_float4_size += size * 4;
-    }
-    else if (mattr->type == TypeFloat4 || mattr->type == TypeRGBA) {
-      *attr_float4_size += size;
-    }
-    else {
-      *attr_float3_size += size;
-    }
-  }
-}
-
 /*
  * Records all the attribute buffer sizes for all the attribute buffers for later use
  */

intern/cycles/scene/geometry_bvh.cpp

@@ -32,6 +32,25 @@
 
 CCL_NAMESPACE_BEGIN
 
+void Geometry::compute_bvh(Device *device,
+                           DeviceScene *dscene,
+                           SceneParams *params,
+                           Progress *progress,
+                           size_t n,
+                           size_t total)
+{
+  if (progress->get_cancel())
+     return;
+
+  const BVHLayout bvh_layout = BVHParams::best_bvh_layout(
+      params->bvh_layout, device->get_bvh_layout_mask(dscene->data.kernel_features));
+  if (need_build_bvh(bvh_layout)) {
+    BVH *sub_bvh = bvh->get_device_bvh(device);
+    GeometryManager::device_update_sub_bvh(
+        device, dscene, bvh, sub_bvh, !need_update_rebuild, n, total, progress);
+  }
+}
+
 void GeometryManager::device_init_update_bvh(Scene *scene)
 {
   if (scene->bvh->params.bvh_layout == BVH_LAYOUT_BVH2) {