EDIT Oct 15 2020

Hey, it's been a while. Version 2.1 free here: https://gum.co/tuftMaker [gum.co]



So, I think I got totally carried away adding parameters and functionality. Good exercise, but I'm lost in it and probably you will be, too. Anyway, feel free to dissect the HDA and I hope there are bits and pieces that could be useful. That's not to say it doesn't work or anything, it does but it takes a moment to understand how, haha!

Cheers!

PAST EDITS

Debugging

- Fixed scaling for anything outside the unit circle.

- Fixed curve framing with extreme angles by using dihedral to minimize rotation (thanks to Entagma for the theoretical insight on this one)

- Addressing tiny falloff value differences with a statistical variance check and a threshold parameter. (e.g. when the sample points are in a circle).

- Floating-point precision fix.

- Post carve ‘curveu’ recalculation takes care of the vertex colors ramp now.



Features

- Added point sampling mode switch (cone cap or cone volume)

- Added twist control

- (Obsolete since H18) Added per connected mesh UVs using Toraku's “Get correct uvs with a sweep sop” fix - http://www.tokeru.com/cgwiki/index.php?title=Houdini#Get_correct_uvs_with_a_sweep_sop [www.tokeru.com]

- “Listening” for N and iteration attributes.

- Using the new sweep sop now.

———————————————————————————————————
Hi folks,

How would you go about adding points in a propagating manner in VEX. Here's what I mean:

- Start with several incoming base points, each with an up vector.

- For each one, add a new point somewhere along its up vector.

- Calculate a new up vector by subtracting base positions from new point positions and setting the new point up vector to the result

- Add the next new point somewhere along the previous point's up vector



So, I called it propagating, because every next point in part defines the following.

I think I'm on the right track here, but my gut's telling me I'm missing something.

vector up = point(0, "up", @ptnum);
vector currentPos = point(0, "P", @ptnum);
vector newPos = {0,0,0};


int pts[];

for(int i=0; i<@numelem; i++) {
    append(pts,i);
}


int iteration = chi("iteration");

for(int j=0; j<=iteration-1; j++){
    
    newPos = currentPos+up;
    int newPoint = addpoint(0, newPos);
    
    setpointattrib(0, "up", len(pts)+j, normalize(newPos), "set");
    currentPos = point(0, "P", len(pts)+j);
    up = normalize(newPos-currentPos);
    currentPos = newPos;
}

Where do you think I'm wrong here. What would you do? Cheers!

Attachments:
propagating_points.gif (336.7 KB)
tuft_cover.png (552.4 KB)

Some corrections here:

vector up = @up;
vector current_pos = @P;
vector new_pos = 0;

int samples = chi("samples");
float offset = chf("offset");


for(int i = 0; i < samples; i++){


    new_pos += current_pos + up * offset;
    int new_point = addpoint(0, new_pos);
    
    up = normalize(new_pos-current_pos);
    setpointattrib(0, "up", new_point, up, "set");
    
    current_pos = point(0, "P", new_point);
    }

I didn't write in the post above, that I intended to later randomize the up vector direction for every new point and thus get a non-linear propagating pattern. I want to achieve a sort of (and I suspect that's not the right term here) parent-child behavior between every point and the next in line (something like tentacles constructed by points propagating in random directions). That's the reason why (in my head at least), calculating a new up by subtracting current_pos from new_pos and setting that at every sample is important.

Except, and this is probably going to seem totally dumb… at sample 2 it falls apart. Up is no longer pointing where I'd expect it to. I bet this has something to do with the last line current_pos = point(0, “P”, new_point);

It appears at sample 2, the up direction is pointing away from the world origin, and not away from the points at sample 1. I feel like I'm missing something so basic…



Edit:
Ok, getting somewhere with random vectors:

Attachments:
propagating_points_with_rand_dir.jpg (499.3 KB)
rand_dir_propagating_points.hiplc (571.6 KB)
drawing_board_time.jpg (42.2 KB)
propagating_points_with_rand_dir_draw.jpg (269.2 KB)

Cheers, @demoncase

Ta-da! I got the point arrays exactly in the correct order for the point number pattern I was getting.



Alright, it's going to be smooth sailing from here on… (doing a little dance) Wait, what!? Addprim didn't do what you imagined? Documentation, here I come.

(Edit)
What's the correct way to pass those point number arrays to the addprim function to get a polyline for each one?

Attachments:
propagating_points_with_rand_dir_prim.jpg (667.3 KB)

Eureka! (No need for point arrays after all…)



So, from what I originally intended to be a grass generator… it will be a multi-purpose generator (including the effect on hair that electrocution has according to popular cartoon depictions)

Still to figure out a way to control the up angle at every sample… and to orient the points correctly based on the starting points (polyframe the prims I guess…)

Edit- With some finetuning below:

Image Not Found

Attachments:
propagating_points_with_rand_dir_prim_eureka.jpg (521.2 KB)
rand_dir_propagating_points_2.hiplc (585.7 KB)

Attachments:
rand_dir_propagating_points_3.hiplc (609.9 KB)

Attachments:
grass_n_stuff_gen_18_4b.hiplc (1.8 MB)

Here's the beta. Give it a try (it's free). https://gum.co/SOpPT [gum.co]

Attachments:
stipules_gen_gumroad_poster.png (220.3 KB)