[Bf-blender-cvs] [e288e3d3680] hair_guides hair_guides_grooming: Replace callback for loop weights with a simple array, since these are cached anyway.

Lukas Tönne noreply at git.blender.org
Thu May 24 19:43:54 CEST 2018


Commit: e288e3d3680cd2640e7c37a282f7c3ad785bb7f3
Author: Lukas Tönne
Date:   Thu May 24 18:42:24 2018 +0100
Branches: hair_guides hair_guides_grooming
https://developer.blender.org/rBe288e3d3680cd2640e7c37a282f7c3ad785bb7f3

Replace callback for loop weights with a simple array, since these are cached anyway.

===================================================================

M	source/blender/blenkernel/BKE_hair.h
M	source/blender/blenkernel/BKE_mesh_sample.h
M	source/blender/blenkernel/intern/hair.c
M	source/blender/blenkernel/intern/mesh_sample.c

===================================================================

diff --git a/source/blender/blenkernel/BKE_hair.h b/source/blender/blenkernel/BKE_hair.h
index f10d3971153..1f74caa79e0 100644
--- a/source/blender/blenkernel/BKE_hair.h
+++ b/source/blender/blenkernel/BKE_hair.h
@@ -108,16 +108,14 @@ void BKE_hair_generate_follicles(
         int count);
 
 /* Distribute hair follicles on a scalp mesh.
- * Loop weight function controls follicle density on the scalp.
+ * Optional per-loop weights control follicle density on the scalp.
  */
-typedef float (*HairMeshLoopWeightFp)(struct Mesh *mesh, struct MLoop *loop, unsigned int index, void *userdata);
 void BKE_hair_generate_follicles_ex(
         struct HairSystem* hsys,
         struct Mesh *scalp,
         unsigned int seed,
         int count,
-        HairMeshLoopWeightFp loop_weight_cb,
-        void *userdata);
+        const float *loop_weights);
 
 void BKE_hair_bind_follicles(struct HairSystem *hsys, struct Mesh *scalp);
 
diff --git a/source/blender/blenkernel/BKE_mesh_sample.h b/source/blender/blenkernel/BKE_mesh_sample.h
index a99b3b1a8df..8f8b8939bae 100644
--- a/source/blender/blenkernel/BKE_mesh_sample.h
+++ b/source/blender/blenkernel/BKE_mesh_sample.h
@@ -38,14 +38,13 @@ struct MeshSampleGenerator;
 
 typedef struct MeshSampleGenerator MeshSampleGenerator;
 
-typedef float (*MeshSampleLoopWeightFp)(struct Mesh *mesh, struct MLoop *loop, unsigned int index, void *userdata);
 typedef void* (*MeshSampleThreadContextCreateFp)(void *userdata, int start);
 typedef void (*MeshSampleThreadContextFreeFp)(void *userdata, void *thread_ctx);
 typedef bool (*MeshSampleRayFp)(void *userdata, void *thread_ctx, float ray_start[3], float ray_end[3]);
 
 /* ==== Utility Functions ==== */
 
-float* BKE_mesh_sample_calc_triangle_weights(struct Mesh *mesh, MeshSampleLoopWeightFp loop_weight_cb, void *userdata, float *r_area);
+float* BKE_mesh_sample_calc_triangle_weights(struct Mesh *mesh, const float *loop_weights, float *r_area);
 
 void BKE_mesh_sample_weights_from_loc(struct MeshSample *sample, struct Mesh *mesh, int looptri_index, const float loc[3]);
 
@@ -69,8 +68,7 @@ void BKE_mesh_sample_clear(struct MeshSample *sample);
 struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_vertices(void);
 
 /* vertex_weight_cb is optional */
-struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_random(unsigned int seed, bool use_area_weight,
-                                                               MeshSampleLoopWeightFp loop_weight_cb, void *userdata);
+struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_random(unsigned int seed, bool use_area_weight, const float *loop_weights);
 
 struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_raycast(
         MeshSampleThreadContextCreateFp thread_context_create_cb,
@@ -78,8 +76,7 @@ struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_raycast(
         MeshSampleRayFp ray_cb,
         void *userdata);
 
-struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_poissondisk(unsigned int seed, float mindist, unsigned int max_samples,
-                                                                    MeshSampleLoopWeightFp loop_weight_cb, void *userdata);
+struct MeshSampleGenerator *BKE_mesh_sample_gen_surface_poissondisk(unsigned int seed, float mindist, unsigned int max_samples, const float *loop_weights);
 
 struct MeshSampleGenerator *BKE_mesh_sample_gen_volume_random_bbray(unsigned int seed, float density);
 
diff --git a/source/blender/blenkernel/intern/hair.c b/source/blender/blenkernel/intern/hair.c
index fd4bd499928..8786c957777 100644
--- a/source/blender/blenkernel/intern/hair.c
+++ b/source/blender/blenkernel/intern/hair.c
@@ -170,19 +170,18 @@ void BKE_hair_generate_follicles(
         unsigned int seed,
         int count)
 {
-	BKE_hair_generate_follicles_ex(hsys, scalp, seed, count, NULL, NULL);
+	BKE_hair_generate_follicles_ex(hsys, scalp, seed, count, NULL);
 }
 
 /* Distribute hair follicles on a scalp mesh.
- * Loop weight function controls follicle density on the scalp.
+ * Optional per-loop weights control follicle density on the scalp.
  */
 void BKE_hair_generate_follicles_ex(
         HairSystem* hsys,
         struct Mesh *scalp,
         unsigned int seed,
         int count,
-        HairMeshLoopWeightFp loop_weight_cb,
-        void *userdata)
+        const float *loop_weights)
 {
 	HairPattern *pattern = hsys->pattern;
 	
@@ -198,7 +197,7 @@ void BKE_hair_generate_follicles_ex(
 	pattern->follicles = MEM_callocN(sizeof(HairFollicle) * count, "hair follicles");
 	
 	{
-		MeshSampleGenerator *gen = BKE_mesh_sample_gen_surface_poissondisk(seed, min_distance, count, loop_weight_cb, userdata);
+		MeshSampleGenerator *gen = BKE_mesh_sample_gen_surface_poissondisk(seed, min_distance, count, loop_weights);
 		
 		BKE_mesh_sample_generator_bind(gen, scalp);
 		
diff --git a/source/blender/blenkernel/intern/mesh_sample.c b/source/blender/blenkernel/intern/mesh_sample.c
index 4fff3bf8a32..8c667799f1c 100644
--- a/source/blender/blenkernel/intern/mesh_sample.c
+++ b/source/blender/blenkernel/intern/mesh_sample.c
@@ -100,23 +100,11 @@ BLI_INLINE float triangle_weight(Mesh *mesh, const MLoopTri *tri, const float *l
 	return weight;
 }
 
-float* BKE_mesh_sample_calc_triangle_weights(Mesh *mesh, MeshSampleLoopWeightFp loop_weight_cb, void *userdata, float *r_area)
+float* BKE_mesh_sample_calc_triangle_weights(Mesh *mesh, const float *loop_weights, float *r_area)
 {
-	int numloops = mesh->totloop;
 	int numtris = BKE_mesh_runtime_looptri_len(mesh);
 	int numweights = numtris;
 	
-	float *loop_weights = NULL;
-	if (loop_weight_cb) {
-		loop_weights = MEM_mallocN(sizeof(float) * (size_t)numloops, "mesh sample loop weights");
-		{
-			MLoop *ml = mesh->mloop;
-			for (int i = 0; i < numloops; ++i, ++ml) {
-				loop_weights[i] = loop_weight_cb(mesh, ml, (unsigned int)i, userdata);
-			}
-		}
-	}
-	
 	float *tri_weights = MEM_mallocN(sizeof(float) * (size_t)numweights, "mesh sample triangle weights");
 	/* accumulate weights */
 	float totarea = 0.0;
@@ -133,10 +121,6 @@ float* BKE_mesh_sample_calc_triangle_weights(Mesh *mesh, MeshSampleLoopWeightFp
 		}
 	}
 	
-	if (loop_weights) {
-		MEM_freeN(loop_weights);
-	}
-	
 	/* normalize */
 	if (totweight > 0.0f) {
 		float norm = 1.0f / totweight;
@@ -502,8 +486,7 @@ typedef struct MSurfaceSampleGenerator_Random {
 	
 	unsigned int seed;
 	bool use_area_weight;
-	MeshSampleLoopWeightFp loop_weight_cb;
-	void *userdata;
+	const float *loop_weights;
 	
 	/* bind data */
 	float *tri_weights;
@@ -526,7 +509,7 @@ static void generator_random_bind(MSurfaceSampleGenerator_Random *gen)
 	BKE_mesh_ensure_normals(mesh);
 	
 	if (gen->use_area_weight) {
-		gen->tri_weights = BKE_mesh_sample_calc_triangle_weights(mesh, gen->loop_weight_cb, gen->userdata, NULL);
+		gen->tri_weights = BKE_mesh_sample_calc_triangle_weights(mesh, gen->loop_weights, NULL);
 		
 #ifdef USE_DEBUG_COUNT
 		gen->debug_count = MEM_callocN(sizeof(int) * (size_t)dm->getNumLoopTri(dm), "surface sample debug counts");
@@ -641,8 +624,7 @@ static bool generator_random_make_sample(const MSurfaceSampleGenerator_Random *g
 	return true;
 }
 
-MeshSampleGenerator *BKE_mesh_sample_gen_surface_random(unsigned int seed, bool use_area_weight,
-                                                        MeshSampleLoopWeightFp loop_weight_cb, void *userdata)
+MeshSampleGenerator *BKE_mesh_sample_gen_surface_random(unsigned int seed, bool use_area_weight, const float *loop_weights)
 {
 	MSurfaceSampleGenerator_Random *gen;
 	
@@ -658,8 +640,7 @@ MeshSampleGenerator *BKE_mesh_sample_gen_surface_random(unsigned int seed, bool
 	
 	gen->seed = seed;
 	gen->use_area_weight = use_area_weight;
-	gen->loop_weight_cb = loop_weight_cb;
-	gen->userdata = userdata;
+	gen->loop_weights = loop_weights;
 	
 	return &gen->base;
 }
@@ -1147,8 +1128,7 @@ static bool generator_poissondisk_make_sample(const MSurfaceSampleGenerator_Pois
 	return found_sample;
 }
 
-MeshSampleGenerator *BKE_mesh_sample_gen_surface_poissondisk(unsigned int seed, float mindist, unsigned int max_samples,
-                                                             MeshSampleLoopWeightFp loop_weight_cb, void *userdata)
+MeshSampleGenerator *BKE_mesh_sample_gen_surface_poissondisk(unsigned int seed, float mindist, unsigned int max_samples, const float *loop_weights)
 {
 	MSurfaceSampleGenerator_PoissonDisk *gen;
 	
@@ -1162,7 +1142,7 @@ MeshSampleGenerator *BKE_mesh_sample_gen_surface_poissondisk(unsigned int seed,
 	                      (GeneratorMakeSampleFp)generator_poissondisk_make_sample,
 	                      (GeneratorGetMaxSamplesFp)generator_poissondisk_get_max_samples);
 	
-	gen->uniform_gen = BKE_mesh_sample_gen_surface_random(seed, true, loop_weight_cb, userdata);
+	gen->uniform_gen = BKE_mesh_sample_gen_surface_random(seed, true, loop_weights);
 	gen->max_samples = max_samples;
 	gen->mindist_squared = mindist * mindist;
 	gen->cellsize = mindist / SQRT_3;



More information about the Bf-blender-cvs mailing list