An OSL wood shader with knots for Blender Cycles

In a previous article I presented a shader that could be used to create the impression of knots in wood. This was accomplished by warping the texture coordinates around randomly distributed points in space.

Knots however do not resemble spheres but are more like cylinders that are cut under a slight angle. This distinction is not that important but for completeness sake we present this new implementation here together with a node setup that combines these knots with the wood shader we presented a while ago. An example result is shown below.

Code and example node setup

The implementation differs from the previous one in generating random lines (represented by a random point plus a random direction) instead of points. The texture coordinates are bent proportional to the distance to the closest point on this random line, so the bend() is a little bit more complicated than before.

vector random_sphere(point p, int n, float zdistribution){  
  float t = M_2PI*noise("cell",p,n*2+0);  
  float u = 2*noise("cell",p,n*2+1)-1;  
  float s,c,a;  
  sincos(t,s,c);  
  a = sqrt(1-u*u);  
  float x = a*c;  
  float y = a*s;  
  float z = u*zdistribution;  
  return vector(x,y,z);    
}

int bend(vector p, vector k, vector kv, float r, float a, float m, output vector B){
  vector pk = k - p;
  vector t = dot(pk,kv)/dot(kv,kv);
  vector D = k + t * kv - 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 = 1.5,

  float R = 2.9,
  float Falloff = 2,
  float Strength = 1,
  float Knots=0.1,
  float Z=1,
  
  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 kv= random_sphere(ip,ik+1000,Z);
          vector dp= 0;
    int ret = bend(p,ip+k,kv,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 kv= random_sphere(ip,998,Z);
          vector dp= 0;
    int ret = bend(p,ip+k,kv,R,Falloff,Strength,dp);
          if(ret != 0){
            Fac=max(Fac,ret==2);
            sdp+=dp;
          }
        }
      }
    }
  }
  if( Fac < 1 ){
 Vec = p + sdp;
  }else{
    Vec = sdp;
  }
}

Note that the function random_sphere() is modified from the one presented in a previous article to bias the vectors that are returned. This allows us to tweak the orientation of the generated knots, which might give more realisted results because branches (the source of the knots) are not pointing in all directions from the stem.

The node setup used to create the material in the example image is shown below (click to enlarge).

Room for improvement

The distribution of the knots might be convincing enough for our purposes but the material is now just another (darker) wood mzterial, rings and all. Quits a number of wood knots do look like that but a significant fraction shows characteristic radial cracks. This is caused when the wood is dried because the material properties of the knot are different from the surrounding wood. It would be nice if we could implement this in some way as well.

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.