### An OSL wood knot shader

Back in january I presented a wood shader that produces decent results but one of things that was missing was a way to add realistic knots to planks. In this article a present a shader that is meant as a first step in producing knots. It is not a finished shader yet, but it is fully functional as a texture warping tool and in a future article I might detail how to combine it with a wood shader and a shader to texture the inside of the knot properly. Because that will take some time so I thought it better to present it as a WIP as I am currently unable to spend more than a few minutes behind my desk (and there's no Blender for Android alas).

## Warping space

The idea is quite simple and might be adaptable to more than just producing knots: we distribute points randomly and warp the position coordinates around these points. These warped coordinates are then used as the basis for a texture. In the example image we use the warped coordinates as the input to a bands texture:

As you can see the bands of the texture seem to flow around the knots as if they were repelled by them and in fact that is pretty much how the algorithm works.

## Implementation

`int bend(vector p, vector k, float r, float a, float m, output vector B){  vector D = k - p;  float L = length(D);  if( L < r ){    float c = L/r; float d = m * pow( 1 - c , a); if( d < L ){  B = d * normalize(D);  return 1; }else{     B = D;  return 2; }  }  return 0;}shader knot(  vector Pos = P,  float Scale = 5,  float R = 0.8,  float Falloff = 1,  float Strength = 0.9,  float Knots=0.5,  output vector Vec = P,  output float Fac = 0){  vector p = Scale * Pos;  vector sdp = 0;  float TR = ceil(R);  for(float dx=-TR; dx <= TR; dx++){    for(float dy=-TR; dy <= TR; dy++){      for(float dz=-TR; dz <= TR; dz++){        vector ip = floor(p)+vector(dx,dy,dz);        for(int ik=0; ik < (int)Knots; ik++){          vector k = noise("cell",ip,ik);          vector dp= 0;    int ret = bend(p,ip+k,R,Falloff,Strength,dp);          if(ret != 0){            Fac=max(Fac,ret==2);            sdp+=dp;          }        }        if( noise("cell",ip,-1) < mod(Knots,1.0) ){          vector k = noise("cell",ip,-2);          vector dp= 0;    int ret = bend(p,ip+k,R,Falloff,Strength,dp);          if(ret != 0){            Fac=max(Fac,ret==2);            sdp+=dp;          }        }      }    }  }  if( Fac < 1 ){ Vec = p + sdp;  }else{    Vec = sdp;  }}`
The magic is in the bend() function. It calculates the difference vector from the point being shaded to the center of the repulsion. If the distance is short enough, a translation vector is returned that is a distance dependent fraction of the difference vector. It takes some thinking to see that in order to create the illusion of repulsion we actually have to replace the point being shaded towards the center of repulsion: remember that at the point we are shading we want to see the lines closer to the center.

When we calculate the translation towards the center and we are close enough to it, we might overshoot the center point. In which case we return a value of 2, signalling we are inside the knot and return not the translated shading point but the vector pointing to the center (which might be useful to render some concentric pattern in the knot).

The shader itself is nothing more than checking if we might be in range of one of the randomly distributed points and calling the bend() function to do the actual work. We do allow for a fractional number of knots per unit cell, in which case the fraction acts as the probability that a knot might occur.

## Room for improvement

Obviously knots are not spherical marbles embedded randomly in some wood but as the remnants of branches they are more reminiscent of stubby cylinders which might be better modeled by determining the distance to a randomly oriented line segment instead, something I intend to implement in the near future.

Another area that needs attention is to way the inside of the knot appears. In the example setup we produced some concentric circles but a real knot is a bit more complex than that.