On Growth and Form

[Librarian]

A new beginning of fun yupppiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
 

INDIANAC.hiplc

[cg10]

On 7/4/2020 at 1:41 PM, Librarian said:

Fun

 

Hi I just wanna say that I read all the thread and I think all your work is awesome and very inspiring, Can I ask you what is the logic, more or less, behind this one?

[Librarian]

@cg10 Thank you .
Logic Hm,,, Just was trying to do some experimentos with gradient and Platonic shapes ..Have same crazy ideas that everything from nature can be build from those Shapes Platonic/ and with Notch of right freq ..that I'm still trying to do in CHOPS..
me and LOGIC

[vinyvince]

At first, before the animation was loaded, i thought it was a capture of your node graph

It will be not hurt if Sidefx gives some attention to Chops for next version...

 

 

________________________________________________________________

Vincent Thomas   (VFX and Art since 1998)
Senior Env and Lighting  artist & Houdini generalist & Creative Concepts
 http://fr.linkedin.com/in/vincentthomas

[Librarian]

Have Fun 3
 

Novi2Lilly14.hipnc

[Librarian]

Figuring out Sop Cop ..thanks for file (13 months old) by Zhongkai Lau
 

SOPtoCOPod.hipnc

[vinyvince]

Wow funky examples, Love it !

Love to make my life more complex, before i used only one line wrangle

@P = vertex(@OpInput1, "uv", pointvertex(@OpInput1, @ptnum));

 

Not sure what the purpose of the first example you found, but i think there is a mistake in the "voxel" wrangle. It doesnùt do anything to the pscale so the cube keep same size.

I guess you want to modify the first line by int near[] = nearpoints(1,@P,10,10);

and plug the isolate hitpoint from the ray in the second input?

 

There are some good ones from Houdini Jeff too, you know our "old school" wise master , some really interesting ideas

 

________________________________________________________________

Vincent Thomas   (VFX and Art since 1998)
Senior Env and Lighting  artist & Houdini generalist & Creative Concepts
 http://fr.linkedin.com/in/vincentthomas

 

[Librarian]

@vinyvince thanks for tip..I only need to jump to Final result (Don't care about complex or simple Codes)
  Never seen Jeffs Cop Tutorials ..I know only COPs with Mike Lyndon.

[Librarian]

In One Place..Nice to have   I think
just One grid and Vex with 20 diff Shapes(easily Mult and you have 200 shapes) plus some IsoSurface ..learning
Have Fun

 

GridVEXSHAPES_IsoSurfaceNOrmalize.hiplc

[Librarian]

I think I found Render Engine @schwungsau please when you have time just explain how to render correct splines on Best way  ..or someone else who have Time .
Using Bug Asset and tutorial from Renderman ..learning

 

Edited September 8, 2020 by Librarian

[schwungsau]

best way is mess it out as tiny tubes, if you specular hights is important for you. but its atr 12 times more data and memory.  you need a renderer with great splines primitves/shaders, Arnold and Renderman are the best bt far.

[Librarian]

thank You @schwungsau getting nice  res from Renderman.
 

gt.mov

[Librarian]

Now when I have everything for better learning (Nice PC-config -first H18 indie version) just happy.
Having fun with solvers ..(must learn to combine somehow forces) trying to learn more about solvers ..(fishes- predators- ants -birds -etc--
https://www.red3d.com/cwr/boids/
https://nccastaff.bournemouth.ac.uk/jmacey/MastersProjects/MSc13/08/_assets/i7784427_TusharK_Thesis.pdf

 

[Librarian]

https://a124.borndigital.jp/houdini/houdini_tips/201703houdinivex.html

Learned Something NIce tricks and setups..(Morphing Filet VEx nice stuff) for Lazy peoples Snippets

Combining with this Cop setups Olalalalaal

//MOrph Blend

float A = prim(0,"perimeter",@primnum);
float B = prim(1,"perimeter",@primnum);
float C = prim(2,"perimeter",@primnum);
float T = A +B + C ;

float Au = A/T;
float Bu= B/T;
float Cu = C/T;

@Au =Au;
@Bu = Bu;
@Cu = Cu;

float offset = fit01(chf("offset"),0,Au+Bu);
int i, pt;
int pts[] = primpoints(0, @primnum);

foreach (i, pt; pts){
    float localu = 1.0/ (len(pts)-1)*i;
    float offsetu = localu *Au +offset ;
    if (offsetu > Au+Bu){
        float setu = ( offsetu- (Au+Bu)) / Cu;
        vector setp = primuv(2,"P",@primnum,setu);
        setpointattrib(0,"P",pt,setp,"set");
        }
        else if (offsetu> Au ){
            float setu = (offsetu -Au)/Bu;
            vector setp = primuv(1,"P",@primnum,setu);
            setpointattrib(0,"P",pt,setp,"set");
            }else{
                  float setu = offsetu /Au;
                  vector setp= primuv(0,"P",@primnum,setu);
                  setpointattrib(0,"P",pt,setp,"set");
                  }
                  
      }            

 

//Duplicate
int points[]= primpoints (0,@primnum);
int pcount = len(points);
int nmax = chi("duplicate");
for (int n = 0; n < nmax ; n++){
    int prim = addprim(0, "polyline");
    float primof= fit01(rand(prim+chf("rand")),1,pcount);
    for (int i = 0; i <= pcount;i++){
        int offset = int( i +primof ) % pcount;
        vector pos = point(0, "P", points[offset]);
        int point = addpoint(0,pos);
        addvertex(0,prim,point);
     }
     
  }   
  
removeprim(0,@primnum,1);  
    

//Offset tangents

int points[]= primpoints(0,@primnum);
for (int i = 0; i< len(points); i ++) {
    int ptnum = points[i];
    vector pos = point (0,"P", ptnum);
    vector tv = normalize(point(0,"tangentv",ptnum));
    vector posB = pos + tv * chf("scale");
    vector blend = pos + (posB -pos) *rand(@primnum);
    setpointattrib (0,"P",ptnum,blend,"set");
}   

Endless Control ..Have Fun

[Librarian]

different projection ....learning sharing

 

projectionLearn.hipnc

[Librarian]

@dyei nightmare i did some research on Flocky MOcky . HAve Fun
 

//variable set

v@v = (nrandom() - 0.5) * 2;//chv("InitVelocity");
float extent = 1;
v@v += normalize(@P);//normalize(fit01(rand(@ptnum), {1,1,1} * -extent, {1,1,1} * extent));
v@accel = {0,0,0};
v@N = normalize(v@v);
v@up = {0,1,0};
f@mass = 1;
i@id = @ptnum;

f@CohesionRadius = chf("CohesionRadius");
f@CohesionSpeed = chf("CohesionSpeed");

f@AlignmentRadius = chf("AlignmentRadius");
f@AlignmentWeight = chf("AlignmentWeight");

//Solver Set

--------------------------
//integr
@v += @accel * @TimeInc;
@P += @v * @TimeInc;
@accel = {0,0,0};
--------------------------
//cohesion
@v += @accel * @TimeInc;
@P += @v * @TimeInc;
@accel = (random(@ptnum)-10.5) * 0.3;//{0,0,0};

int Neighbours[] = nearpoints(0, @P, @CohesionRadius);
int NeighboursCount = len(Neighbours);
vector AvgPos = {0,4,0.5};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector pos;
                getattribute(@OpInput1, pos, "point", "P", i, 0);
                AvgPos += pos;
        }
}

AvgPos /= NeighboursCount;

v@accel += normalize(AvgPos - @P) * @CohesionSpeed;
-----------------------------------------------------------
//Align
int Neighbours[] = nearpoints(0, @P, @AlignmentRadius);
int NeighboursCount = len(Neighbours);
vector AvgVel = {0,1,0};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector vel;
                getattribute(@OpInput1, vel, "point", "v", i, 0);
                AvgVel += vel;
        }
}

AvgVel /= NeighboursCount;

v@accel += (AvgVel - @v) * @AlignmentWeight;
--------------------------------------------------------------------
//Separation
float SeparationRadius = @CohesionRadius * chf("speed");
int Neighbours[] = nearpoints(0, @P, SeparationRadius);
int NeighboursCount = len(Neighbours);
vector DirectionToNeighbour = {0,0,0};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector pos;
                getattribute(@OpInput1, pos, "point", "P", i, 0);
                DirectionToNeighbour += normalize(@P - pos);
        }
}

DirectionToNeighbour *= 1.0 / SeparationRadius;

v@accel += DirectionToNeighbour;
------------------------------------------------------------------

tips --
animate only speed with constant
you can Combine with files from jhorikawa Dude..
for the momment working on predator and Ants (sim)

 

[vinyvince]

1 hour ago, Librarian said:

@dyei nightmare i did some research on Flocky MOcky . HAve Fun
 

//variable set

v@v = (nrandom() - 0.5) * 2;//chv("InitVelocity");
float extent = 1;
v@v += normalize(@P);//normalize(fit01(rand(@ptnum), {1,1,1} * -extent, {1,1,1} * extent));
v@accel = {0,0,0};
v@N = normalize(v@v);
v@up = {0,1,0};
f@mass = 1;
i@id = @ptnum;

f@CohesionRadius = chf("CohesionRadius");
f@CohesionSpeed = chf("CohesionSpeed");

f@AlignmentRadius = chf("AlignmentRadius");
f@AlignmentWeight = chf("AlignmentWeight");

//Solver Set

--------------------------
//integr
@v += @accel * @TimeInc;
@P += @v * @TimeInc;
@accel = {0,0,0};
--------------------------
//cohesion
@v += @accel * @TimeInc;
@P += @v * @TimeInc;
@accel = (random(@ptnum)-10.5) * 0.3;//{0,0,0};

int Neighbours[] = nearpoints(0, @P, @CohesionRadius);
int NeighboursCount = len(Neighbours);
vector AvgPos = {0,4,0.5};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector pos;
                getattribute(@OpInput1, pos, "point", "P", i, 0);
                AvgPos += pos;
        }
}

AvgPos /= NeighboursCount;

v@accel += normalize(AvgPos - @P) * @CohesionSpeed;
-----------------------------------------------------------
//Align
int Neighbours[] = nearpoints(0, @P, @AlignmentRadius);
int NeighboursCount = len(Neighbours);
vector AvgVel = {0,1,0};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector vel;
                getattribute(@OpInput1, vel, "point", "v", i, 0);
                AvgVel += vel;
        }
}

AvgVel /= NeighboursCount;

v@accel += (AvgVel - @v) * @AlignmentWeight;
--------------------------------------------------------------------
//Separation
float SeparationRadius = @CohesionRadius * chf("speed");
int Neighbours[] = nearpoints(0, @P, SeparationRadius);
int NeighboursCount = len(Neighbours);
vector DirectionToNeighbour = {0,0,0};

foreach (int i ; Neighbours) 
{
        if(@ptnum != i)
        {
                vector pos;
                getattribute(@OpInput1, pos, "point", "P", i, 0);
                DirectionToNeighbour += normalize(@P - pos);
        }
}

DirectionToNeighbour *= 1.0 / SeparationRadius;

v@accel += DirectionToNeighbour;
------------------------------------------------------------------

tips --
animate only speed with constant
you can Combine with files from jhorikawa Dude..
for the momment working on predator and Ants (sim)

 

 

I love your poetry

 

Here's some poetry from me to make your birds sing

Sorry for the watermark, i didn t notice this quick screencapture tool was about to add its own

 

________________________________________________________________

Vincent Thomas   (VFX and Art since 1998)
Senior Env and Lighting  artist & Houdini generalist & Creative Concepts
 http://fr.linkedin.com/in/vincentthomas

 

 

Edited September 20, 2020 by vinyvince

[Librarian]

Yessssssss @vinyvince Hm Like it

[Librarian]

Finito with this also ,,meanly because its Vop baserad .. I see somehow better in VOp..have Fun.
 

SrleForeachprimVop.hiplc

[Librarian]

Crossing and Winding Number Algorithm + wave Solver ..
Learning Sharing

 

 

 

CrosswINDsoLVERwAVEsRLE.hiplc