### Creating unique snowflakes with OSL

Falling snowflakes are easy enough to dimulate in Blender with a particle system but if quite a few of them might be seen fairly close up, the real challenge is in making sure each one is unique.

The shader presented in this article will create a unique snowflake for each value of its `Seed`. Using the object info node we may obtain a unique random number for each object that we may use for this purpose as we will see when we examine the node setup.

## Snowflakes

The code below defines the following utility functions;
hex
this function will produce the x and y coordinates of a point as it is rotated through the six segments of a hexagon
in_hexagon
this function will return a non zero value if a point lies within a hexagon
pattern
this function does the real work. It returns non zero if a point is positioned within a number of hexagons that are randomly positioned along the x-axis. It also draws a connecting rod that extends as far as the farthest hexagon.
The body of the shader itself just copies the position being shaded along a hexagon and then calls `pattern()`. Note that because we expect uv-coordinates for a simple square (I.e in de range [0,1], we transform these coordinates so that the center is at (0.5, 0.5) [line 68].
```#define SLOPE 1/sqrt(3)
#define SIDE sqrt(.75)

void hex(float x, float y, output float hx, output float hy){
hx=x;
hy=y;
hx=x*D60c-y*D60s;
hy=y*D60c+x*D60s;
hx=x*D60c+y*D60s;;
hy=y*D60c-x*D60s;
hx=-hx;
hy=-hy;
hx=-hx;
hy=-hy;
hx=-hx;
hy=-hy;
}

int in_hexagon(
float px, float py,
float cx, float cy, float r,
output float d
){
d=hypot(px-cx,py-cy);
if(d>r){ return 0; }
float hx,hy;
hex(px-cx, py-cy, hx, hy);
for(int h=0; h < 6; h++){
if((abs(hy[h]) < SLOPE*hx[h]) && (hx[h]< r*SIDE)){
d=abs(hx[h]);
return 1;
}
}
return 0;
}

#define CELL noise("cell",seed++)

float pattern(float x, float y, int Seed, int Kernels){
int seed=Seed;
int n=(int)(1+Kernels*CELL);
float hx=0, maxx=0;
for(int f=0; f < n; f++){
float hy=0;
float r=0.2*CELL;
float d;
if(in_hexagon(x,y, hx,hy,r, d)){
return d;
}
hx=SIDE*CELL;
if(hx>maxx){maxx=hx;}
}
if(x < maxx && abs(y) < 0.01){ return 1; }
}

point Pos=P,

int Seed=0,
int Kernels=15,

output float Fac=0
){
float hx,hy;

hex(2*(Pos-0.5), 2*(Pos-0.5), hx, hy);

for(int h=0; h<6 br="" fac="=0;" h="">    if(abs(hy[h]) < SLOPE*hx[h]){
Fac=pattern(hx[h],hy[h],Seed, Kernels);
}
}
}```

## Example node setup

The node setup used to shade the particles in the image at the start of this article looks like this: The random value from the object info node lies in the range [0,1], so we multiply it by a large value to get a unique integer.The output of the shader node is checked to see if it is non-zero. if so we use a group of shaders to mimic ice, otherwise a transparent shader. The `Fac` output may vary smoothly so we use a color ramp node with constant interpolation the create stepped values that we can use to drive an ice-like bump pattern. The `Kernels` input determines how many random hexagons are within each snow flake, so this essentially controles how dense the flakes look.

## Code availability

You can copy the code from the listing above but you may also dowload it from GitHub.
If you would like to know more about programming OSL you might be interested in my book "Open Shading Language for Blender". More on the availability of this book and a sample can be found on this page.