[Bf-blender-cvs] [db26c6f66c] blender-v2.78b-release: Cycles: Cleanup, split one gigantic function into two smaller ones

Sergey Sharybin noreply at git.blender.org
Thu Jan 26 13:46:56 CET 2017


Commit: db26c6f66cf8241838c0d1c3bf8d5372985b9841
Author: Sergey Sharybin
Date:   Fri Jan 20 17:52:48 2017 +0100
Branches: blender-v2.78b-release
https://developer.blender.org/rBdb26c6f66cf8241838c0d1c3bf8d5372985b9841

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. @@




More information about the Bf-blender-cvs mailing list