Commit: a1c21e0b5049ebe342707497021ce7e1f2e624e7
Author: Sergey Sharybin
Date: Fri Jan 20 17:52:48 2017 +0100
Branches: master
https://developer.blender.org/rBa1c21e0b5049ebe342707497021ce7e1f2e624e7
Cycles: Cleanup, split one gigantic function into two smaller ones
===================================================================
M intern/cycles/bvh/bvh_build.cpp
M intern/cycles/bvh/bvh_build.h
===================================================================
diff --git a/intern/cycles/bvh/bvh_build.cpp b/intern/cycles/bvh/bvh_build.cpp
index 4abd686cc6..9ff68333c8 100644
--- a/intern/cycles/bvh/bvh_build.cpp
+++ b/intern/cycles/bvh/bvh_build.cpp
@@ -112,104 +112,214 @@ BVHBuild::~BVHBuild()
/* Adding References */
-void BVHBuild::add_reference_mesh(BoundBox& root, BoundBox& center, Mesh
*mesh, int i)
+void BVHBuild::add_reference_triangles(BoundBox& root, BoundBox& center, Mesh
*mesh, int i)
{
- if(params.primitive_mask & PRIMITIVE_ALL_TRIANGLE) {
- Attribute *attr_mP = NULL;
-
- if(mesh->has_motion_blur())
- attr_mP =
mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+ Attribute *attr_mP = NULL;
+ if(mesh->has_motion_blur()) {
+ attr_mP =
mesh->attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+ }
+ const size_t num_triangles = mesh->num_triangles();
+ for(uint j = 0; j < num_triangles; j++) {
+ Mesh::Triangle t = mesh->get_triangle(j);
+ const float3 *verts = &mesh->verts[0];
+ if(attr_mP == NULL) {
+ BoundBox bounds = BoundBox::empty;
+ t.bounds_grow(verts, bounds);
+ if(bounds.valid()) {
+ references.push_back(BVHReference(bounds,
+ j,
+ i,
+
PRIMITIVE_TRIANGLE));
+ root.grow(bounds);
+ center.grow(bounds.center2());
+ }
+ }
+ else if(params.num_motion_triangle_steps == 0 ||
params.use_spatial_split) {
+ /* Motion triangles, simple case: single node for the
whole
+ * primitive. Lowest memory footprint and faster BVH
build but
+ * least optimal ray-tracing.
+ */
+ /* TODO(sergey): Support motion steps for spatially
split BVH. */
+ const size_t num_verts = mesh->verts.size();
+ const size_t num_steps = mesh->motion_steps;
+ const float3 *vert_steps = attr_mP->data_float3();
+ BoundBox bounds = BoundBox::empty;
+ t.bounds_grow(verts, bounds);
+ for(size_t step = 0; step < num_steps - 1; step++) {
+ t.bounds_grow(vert_steps + step*num_verts,
bounds);
+ }
+ if(bounds.valid()) {
+ references.push_back(
+ BVHReference(bounds,
+ j,
+ i,
+
PRIMITIVE_MOTION_TRIANGLE));
+ root.grow(bounds);
+ center.grow(bounds.center2());
+ }
+ }
+ else {
+ /* Motion triangles, trace optimized case: we split
triangle
+ * primitives into separate nodes for each of the time
steps.
+ * This way we minimize overlap of neighbor curve
primitives.
+ */
+ const int num_bvh_steps = params.num_motion_curve_steps
* 2 + 1;
+ const float num_bvh_steps_inv_1 = 1.0f / (num_bvh_steps
- 1);
+ const size_t num_verts = mesh->verts.size();
+ const size_t num_steps = mesh->motion_steps;
+ const float3 *vert_steps = attr_mP->data_float3();
+ /* Calculate bounding box of the previous time step.
+ * Will be reused later to avoid duplicated work on
+ * calculating BVH time step boundbox.
+ */
+ float3 prev_verts[3];
+ t.motion_verts(verts,
+ vert_steps,
+ num_verts,
+ num_steps,
+ 0.0f,
+ prev_verts);
+ BoundBox prev_bounds = BoundBox::empty;
+ prev_bounds.grow(prev_verts[0]);
+ prev_bounds.grow(prev_verts[1]);
+ prev_bounds.grow(prev_verts[2]);
+ /* Create all primitive time steps, */
+ for(int bvh_step = 1; bvh_step < num_bvh_steps;
++bvh_step) {
+ const float curr_time = (float)(bvh_step) *
num_bvh_steps_inv_1;
+ float3 curr_verts[3];
+ t.motion_verts(verts,
+ vert_steps,
+ num_verts,
+ num_steps,
+ curr_time,
+ curr_verts);
+ BoundBox curr_bounds = BoundBox::empty;
+ curr_bounds.grow(curr_verts[0]);
+ curr_bounds.grow(curr_verts[1]);
+ curr_bounds.grow(curr_verts[2]);
+ BoundBox bounds = prev_bounds;
+ bounds.grow(curr_bounds);
+ if(bounds.valid()) {
+ const float prev_time =
(float)(bvh_step - 1) * num_bvh_steps_inv_1;
+ references.push_back(
+ BVHReference(bounds,
+ j,
+ i,
+
PRIMITIVE_MOTION_TRIANGLE,
+ prev_time,
+ curr_time));
+ root.grow(bounds);
+ center.grow(bounds.center2());
+ }
+ /* Current time boundbox becomes previous one
for the
+ * next time step.
+ */
+ prev_bounds = curr_bounds;
+ }
+ }
+ }
+}
- const size_t num_triangles = mesh->num_triangles();
- for(uint j = 0; j < num_triangles; j++) {
- Mesh::Triangle t = mesh->get_triangle(j);
- const float3 *verts = &mesh->verts[0];
- if(attr_mP == NULL) {
+void BVHBuild::add_reference_curves(BoundBox& root, BoundBox& center, Mesh
*mesh, int i)
+{
+ Attribute *curve_attr_mP = NULL;
+ if(mesh->has_motion_blur()) {
+ curve_attr_mP =
mesh->curve_attributes.find(ATTR_STD_MOTION_VERTEX_POSITION);
+ }
+ size_t num_curves = mesh->num_curves();
+ for(uint j = 0; j < num_curves; j++) {
+ const Mesh::Curve curve = mesh->get_curve(j);
+ const float *curve_radius = &mesh->curve_radius[0];
+ for(int k = 0; k < curve.num_keys - 1; k++) {
+ if(curve_attr_mP == NULL) {
+ /* Really simple logic for static hair. */
BoundBox bounds = BoundBox::empty;
- t.bounds_grow(verts, bounds);
+ curve.bounds_grow(k, &mesh->curve_keys[0],
curve_radius, bounds);
if(bounds.valid()) {
-
references.push_back(BVHReference(bounds,
- j,
- i,
-
PRIMITIVE_TRIANGLE));
+ int packed_type =
PRIMITIVE_PACK_SEGMENT(PRIMITIVE_CURVE, k);
+
references.push_back(BVHReference(bounds, j, i, packed_type));
root.grow(bounds);
center.grow(bounds.center2());
}
}
- else if(params.num_motion_triangle_steps == 0 ||
params.use_spatial_split) {
- /* Motion triangles, simple case: single node
for the whole
- * primitive. Lowest memory footprint and
faster BVH build but
- * least optimal ray-tracing.
+ else if(params.num_motion_curve_steps == 0 ||
params.use_spatial_split) {
+ /* Simple case of motion curves: single node
for the while
+ * shutter time. Lowest memory usage but less
optimal
+ * rendering.
*/
/* TODO(sergey): Support motion steps for
spatially split BVH. */
- const size_t num_verts = mesh->verts.size();
- const size_t num_steps = mesh->motion_steps;
- const float3 *vert_steps =
attr_mP->data_float3();
BoundBox bounds = BoundBox::empty;
- t.bounds_grow(verts, bounds);
+ curve.bounds_grow(k, &mesh->curve_keys[0],
curve_radius, bounds);
+ const size_t num_keys = mesh->curve_keys.size();
+ const size_t num_steps = mesh->motion_steps;
+ const float3 *key_steps =
curve_attr_mP->data_float3();
for(size_t step = 0; step < num_steps - 1;
step++) {
- t.bounds_grow(vert_steps +
step*num_verts, bounds);
+ curve.bounds_grow(k,
+ key_steps +
step*num_keys,
+ curve_radius,
+ bounds);
}
if(bounds.valid()) {
- references.push_back(
- BVHReference(bounds,
- j,
- i,
-
PRIMITIVE_MOTION_TRIANGLE));
+ int packed_type =
PRIMITIVE_PACK_SEGMENT(PRIMITIVE_MOTION_CURVE, k);
+
references.push_back(BVHReference(bounds,
+ j,
+ i,
+
packed_type));
root.grow(bounds);
center.grow(bounds.center2());
}
}
else {
- /* Motion triangles, trace optimized case: we
split triangle
+ /* Motion curves, trace optimized case: we
split curve keys
* primitives into separate nodes for each of
the time steps.
* This way we minimize overlap of neighbor
curve primitives.
*/
const int num_bvh_steps =
params.num_motion_curve_steps * 2 + 1;
const float num_bvh_steps_inv_1 = 1.0f /
(num_bvh_steps - 1);
- const size_t num_verts = mesh->verts.size();
const size_t num_steps = mesh->motion_steps;
- const float3 *vert_steps =
attr_mP->data_float3();
+ const float3 *curve_keys = &mesh->curve_keys[0];
+ const float3 *key_steps =
curve_attr_mP->data_float3();
+ const size_t num_keys = mesh->curve_keys.size();
/* Calculate bounding box of the previous time
step.
* Will be reused later to avoid duplicated
work on
* calculating BVH time step boundbox.
*/
- float3 prev_verts[3];
- t.motion_verts(verts,
- vert_steps,
- num_verts,
- num_steps,
- 0.0f,
- prev_verts);
+ float4 prev_keys[4];
+ curve.cardinal_motion_keys(curve_keys,
+ curve_radius,
+ key_steps,
+ num_keys,
+ num_steps,
+ 0.0f,
+ k - 1, k, k + 1, k +
2,
+ prev_keys);
BoundBox prev_bounds = BoundBox::empty;
- prev_bounds.grow(prev_verts[0]);
- prev_bounds.grow(prev_verts[1]);
- prev_bounds.grow(prev_verts[2]);
+ curve.bounds_grow(prev_keys, prev_bounds);
/* Create all primitive time steps, */
for(int bvh_step = 1; bvh_step < num_bvh_steps;
++bvh_step) {
const float curr_time =
(float)(bvh_step) * num_bvh_steps_inv_1;
- float3 curr_verts[3];
- t.motion_verts(verts,
- vert_steps,
- num_verts,
- num_steps,
- curr_time,
- curr_verts);
+ float4 curr_keys[4];
+ curve.cardinal_motion_keys(curve_keys,
+ curve_radius,
+ key_steps,
+ num_keys,
+ num_steps,
+ curr_time,
+ k - 1, k, k
+ 1, k + 2,
+ curr_keys);
BoundBox curr_bounds = BoundBox::empty;
-
@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs
