k3d/share/shaders/k3d_altitude_fog.sl:7:	point PP = transform("world", P);
k3d/share/shaders/k3d_antialiasedchecks.sl:30:  point Nf;             /* Forward facing surface normal */
k3d/share/shaders/k3d_arealight.sl:9: *   intensity, lightcolor - same meanings as pointlight
k3d/share/shaders/k3d_arealight.sl:25:   * approximately work for a flat light source whose normal points
k3d/share/shaders/k3d_arealight.sl:29:  illuminate(point "shader"(0, 0, 0), Nl, PI / 2)
k3d/share/shaders/k3d_bluemarble.sl:45:    point NN;
k3d/share/shaders/k3d_bluemarble.sl:46:    point PP;
k3d/share/shaders/k3d_bluemarble.sl:54:        marble += snoise(PP * f)/f;
k3d/share/shaders/k3d_brick.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brick.sl:69:    raggedamp * snoisexy((s + tbrick * 5.15) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:72:    raggedamp * snoisexy((s + tbrick * 11.4) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:75:    raggedamp / 2 * snoisexy((s + tbrick * 5.15) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:78:    raggedamp / 2 * snoisexy((s + tbrick * 11.4) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:121:    pow(noise
k3d/share/shaders/k3d_brick.sl:131:  bcolor = brickcolor * (1 + (brickvary * snoise(whichbrick + 0.5)));
k3d/share/shaders/k3d_brick2.sl:34:    point Nf;
k3d/share/shaders/k3d_brick3.sl:52:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_brick3.sl:56:  point PP2, Nf;
k3d/share/shaders/k3d_brick3.sl:69:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brick3.sl:73:  ss = scoord / BMWIDTH;   /* Determine which brick the point is in */
k3d/share/shaders/k3d_brick3.sl:84:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brick3.sl:102:  bcolor = brickcolor * (1 + (brickvary * snoise (tbrick+(100*sbrick)+0.5)));
k3d/share/shaders/k3d_brickanti.sl:35:    point Nf;
k3d/share/shaders/k3d_brickbump.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brickbump.sl:75:    pow(noise
k3d/share/shaders/k3d_brickbump2.sl:34:    point Nf;
k3d/share/shaders/k3d_brickbump3.sl:62:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_brickbump3.sl:65:  point PP2;
k3d/share/shaders/k3d_brickbump3.sl:73:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brickbump3.sl:86:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brickbump3.sl:112:  disp -= fact * pow(noise ((ss+sbrick)*pockfrequency/BMHEIGHT,
k3d/share/shaders/k3d_brickperturb.sl:34:    point Nf;
k3d/share/shaders/k3d_brickperturb.sl:47:    ss += 0.1 * snoise(tbrick+0.5);
k3d/share/shaders/k3d_brushedmetal2.sl:38:    extern point P;
k3d/share/shaders/k3d_brushedmetal2.sl:45:    point zro = 0;
k3d/share/shaders/k3d_brushedmetal2.sl:77:	point Po = transform("object",P);
k3d/share/shaders/k3d_brushedmetal2.sl:81:        point zro = 0;
k3d/share/shaders/k3d_brushedmetal3.sl:28:    extern point P;
k3d/share/shaders/k3d_bubbles.sl:15: float distance2point;
k3d/share/shaders/k3d_bubbles.sl:16: point myCenter = (0, 0, 0);
k3d/share/shaders/k3d_bubbles.sl:21: point myPoint = (smod, 0, tmod);
k3d/share/shaders/k3d_bubbles.sl:22: distance2point = distance(myPoint, myCenter);
k3d/share/shaders/k3d_bubbles.sl:23: if (distance2point <= radius) 
k3d/share/shaders/k3d_bubbles.sl:24:    magnitud = sqrt((radius * radius) - (distance2point * distance2point));
k3d/share/shaders/k3d_bubbly.sl:8: *  siggraph proceedings from 1996, except this uses a noised grid of cells
k3d/share/shaders/k3d_bubbly.sl:12: *  the "bubbles" are paraboloids diplaced along the normal. 
k3d/share/shaders/k3d_bubbly.sl:19: *  Nzscale - scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_bubbly.sl:37:  point Po = transform("object",P)*mult;
k3d/share/shaders/k3d_bubbly.sl:39:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_bubbly.sl:40:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_bubbly.sl:47:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_bubbly.sl:53:	nzcell = surrcell + ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_castucco.sl:19:#include "k3d_noises.h"
k3d/share/shaders/k3d_castucco.sl:29:  point Pshad;			/* Point to be shaded, in shader space */
k3d/share/shaders/k3d_causticlight.sl:4:	       point from = point "shader" (0,0,0);
k3d/share/shaders/k3d_causticlight.sl:5:	       point to = point "shader" (0,0,1);
k3d/share/shaders/k3d_causticlight.sl:14:	       float  noiseamp = 0, noisefreq = 1, noisepow = 1;
k3d/share/shaders/k3d_causticlight.sl:29:	    if (noiseamp != 0) {
k3d/share/shaders/k3d_causticlight.sl:30:		point PL = transform ("shader", Ps);
k3d/share/shaders/k3d_causticlight.sl:31:		caustic *= noiseamp * pow (noise(PL*noisefreq), noisepow);
k3d/share/shaders/k3d_celld.sl:4: * Simple displacement shader using Voronoi cell noise
k3d/share/shaders/k3d_celld.sl:5: * Uses noises.h from ARMAN
k3d/share/shaders/k3d_celld.sl:14:#include "k3d_noises.h"
k3d/share/shaders/k3d_celld.sl:26:	varying point __Pref = point (1000, 0, -1000); /* vis hidden */
k3d/share/shaders/k3d_celld.sl:30:	point objP = transform (PSpace, P);
k3d/share/shaders/k3d_celld.sl:31:	point noiseP = (usePref != 0)? transform (PSpace, __Pref): objP;
k3d/share/shaders/k3d_celld.sl:36:	point voro_pos1 = 0, voro_pos2 = 0;
k3d/share/shaders/k3d_celld.sl:38:	voronoi_f1f2_3d (noiseP*voro_freq, voro_jitter, 
k3d/share/shaders/k3d_ceramictiles.sl:56:#include "k3d_noises.h"
k3d/share/shaders/k3d_ceramictiles.sl:85: * single tile, calculate the color of the tile at that point.  Major
k3d/share/shaders/k3d_ceramictiles.sl:99:      point noisep = mottlefreq * point(stile, ttile, tileindex);
k3d/share/shaders/k3d_ceramictiles.sl:101:	.2 + .6 * fBm(noisep, mottlefreq * max(ds, dt), 4, 2, 0.65);
k3d/share/shaders/k3d_ceramictiles.sl:107:	.05 * fBm(point(stile * 10, ttile * 10, tileindex + 10),
k3d/share/shaders/k3d_ceramictiles.sl:110:	.05 * fBm(point(stile * 10, ttile * 10, tileindex - 3),
k3d/share/shaders/k3d_ceramictiles.sl:121:      point noisep =
k3d/share/shaders/k3d_ceramictiles.sl:122:	point(stile * speckfreq, ttile * speckfreq, tileindex + 8);
k3d/share/shaders/k3d_ceramictiles.sl:123:      float specky = filteredsnoise(noisep, speckfreq * dst);
k3d/share/shaders/k3d_ceramictiles.sl:147:  extern point P;
k3d/share/shaders/k3d_ceramictiles.sl:220:  Ntile += 0.05 * (vector cellnoise(tileindex + 5) - 0.5);
k3d/share/shaders/k3d_ceramictiles.sl:239:  point Q = 20 * point(ss, tt, 0);
k3d/share/shaders/k3d_checkerboard.sl:10:  point Nf;
k3d/share/shaders/k3d_checkerboard_solid.sl:16:	point Nf;
k3d/share/shaders/k3d_checkerboard_solid.sl:19:	point Pshad = transform(shadingspace, P);
k3d/share/shaders/k3d_cloudplane.sl:24:    point Psh;
k3d/share/shaders/k3d_contacshadow.sl:32:    /* transform the ground plane point into texture coordinates  
k3d/share/shaders/k3d_contacshadow.sl:33:       needed to look up the point in the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:34:    point screenP = transform(matNP, P);  
k3d/share/shaders/k3d_contacshadow.sl:39:	/* point being shaded is outside the region of the depth map */  
k3d/share/shaders/k3d_contacshadow.sl:47:	/* transform the point on the ground plane into the shadow
k3d/share/shaders/k3d_contacshadow.sl:50:	point cameraP = transform(matNl, P);  
k3d/share/shaders/k3d_corktile.sl:31:#include "k3d_noises.h" /* the standard BMRT include file */
k3d/share/shaders/k3d_corktile.sl:33:#define fnoise(p,width) (noise(p) * (1-smoothstep (0.2,0.75,width)))
k3d/share/shaders/k3d_corktile.sl:43:color cork(		point PP;
k3d/share/shaders/k3d_corktile.sl:46:		/* 	the pattern is built up of the sum of two offset noise functions, perturbed slightly
k3d/share/shaders/k3d_corktile.sl:51:		point P2 = transform("shader",PP);
k3d/share/shaders/k3d_corktile.sl:52:		point PT = P2 * txtscale;
k3d/share/shaders/k3d_corktile.sl:55:		float f = fnoise(PT, fw) + fnoise((P2 + 0.553) * txtscale, fw); 
k3d/share/shaders/k3d_corktile.sl:56:		f = f * fnoise(PT * .854, fw);
k3d/share/shaders/k3d_corktile.sl:57:		f = f + (fnoise(PT * 5.342, fw) - .5) * .5;  
k3d/share/shaders/k3d_corktile.sl:96:	point PP = transform("shader",P);
k3d/share/shaders/k3d_corktile.sl:108:	Cg = color( .20, 0, 0) + filteredsnoise(PP * txtscale, filtwidth * txtscale) * .2;
k3d/share/shaders/k3d_corktile.sl:113:	disp = (tileheight + fnoise(PP * txtscale * bumpfreq + 3, filtwidth * txtscale) * (1 - tileheight)) 
k3d/share/shaders/k3d_craters.sl:4: * Voronoi/Worley noise is combined using 1/f scaling to put craters on a surface.
k3d/share/shaders/k3d_craters.sl:10:#include "k3d_noises.h"
k3d/share/shaders/k3d_craters.sl:25:   /* but this can be avoided by looping i,j from -2 to 2 instead of -1 to 1 */
k3d/share/shaders/k3d_craters.sl:57:		if ( cellnoise(7*scell-9.5, 7*tcell+7.5) < pitfactor)
k3d/share/shaders/k3d_craters.sl:61:		    sctr = cellsizescale * (scell + 0.5 + jitter * cellnoise(scell+0.5, tcell+0.5));
k3d/share/shaders/k3d_craters.sl:62:		    tctr = cellsizescale * (tcell + 0.5 + jitter * cellnoise(scell+3.5, tcell+8.5));
k3d/share/shaders/k3d_crayon.sl:32:#define snoise(x,y) ((noise(x,y) - 0.5) * 2)
k3d/share/shaders/k3d_crayon.sl:35:aanoise(float sp, tp, width)
k3d/share/shaders/k3d_crayon.sl:37:	/* an antaliased noise function, which returns noise of a wavelenth always greater than
k3d/share/shaders/k3d_crayon.sl:44:	ns  = mag * snoise(sp / f, tp / f) * (1 - smoothstep(0, .5, width / f))
k3d/share/shaders/k3d_crayon.sl:45:		+ snoise(sp / (f * 1.33), tp / (f * 1.33)) * mag * .25 * smoothstep(0, .5, width / f);
k3d/share/shaders/k3d_crayon.sl:75:	/*  use a spline to read across to the appropriate noise value - this equalisation
k3d/share/shaders/k3d_crayon.sl:81:	float smks = aanoise(txtscale * s * micro / width, txtscale * t * micro / width,
k3d/share/shaders/k3d_crayon.sl:83:	float lmks = (aanoise(txtscale * s / width, txtscale * t / (width * stretch), 
k3d/share/shaders/k3d_cyclone.sl:3:/* Use signed Perlin noise */
k3d/share/shaders/k3d_cyclone.sl:4:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_cyclone.sl:5:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_cyclone.sl:6:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_cyclone.sl:16:  point Pt;			/* Point in texture space */
k3d/share/shaders/k3d_cyclone.sl:17:  point PN;			/* Normalized vector in texture space */
k3d/share/shaders/k3d_cyclone.sl:18:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_cyclone.sl:24:  /* Rotate hit point to "cyclone space" */
k3d/share/shaders/k3d_cyclone.sl:36:	point(xcomp(Pt) * cosine - ycomp(Pt) * sine,
k3d/share/shaders/k3d_cyclone.sl:59:	  a += o * VLNoise(PP * l, 1);
k3d/share/shaders/k3d_dented.sl:35:	point PP;
k3d/share/shaders/k3d_dented.sl:41:			magnitude += abs(0.5 - noise(PP*size)) / size;
k3d/share/shaders/k3d_displacementmap.sl:2:				 float ZeroPoint = 0.0;
k3d/share/shaders/k3d_displacementmap.sl:5:  point PP;
k3d/share/shaders/k3d_displacementmap.sl:6:  point N1, N2;
k3d/share/shaders/k3d_displacementmap.sl:12:  P = P - (Km * (Ct - ZeroPoint)) * normalize(N);
k3d/share/shaders/k3d_distant_shadow.sl:4:	point from = point "shader" (0,0,0) ;
k3d/share/shaders/k3d_distant_shadow.sl:5:	point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_distantlight.sl:11:		       point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_distantlight.sl:12:		       point to = point "shader"(0, 0, 1);)
k3d/share/shaders/k3d_dturb.sl:11:  point PP;
k3d/share/shaders/k3d_dturb.sl:18:  width = filterwidth_point(PP);
k3d/share/shaders/k3d_dturb.sl:23:    turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:25:  turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_easysurface.sl:15:	point II = normalize(I);
k3d/share/shaders/k3d_easysurface.sl:16:	point NN = normalize(N);
k3d/share/shaders/k3d_ember.sl:3: * email: graeme@noitaminanimation.com
k3d/share/shaders/k3d_ember.sl:20:	point PP = transform ("world", P);
k3d/share/shaders/k3d_ember.sl:21:	point QQ = transform ("world", point "object" (0, 0, 0));
k3d/share/shaders/k3d_eroded.sl:18:	point Nf,
k3d/share/shaders/k3d_eroded.sl:20:    point x = (1, 0, 0);
k3d/share/shaders/k3d_eroded.sl:21:	point V = normalize(-I);
k3d/share/shaders/k3d_eroded.sl:24:		/* Calculate a simple fractal 1/f noise function */
k3d/share/shaders/k3d_eroded.sl:25:		magnitude += 4.0 * abs (.5 - noise (W * size)) / size;
k3d/share/shaders/k3d_eyeball.sl:60:#define snoise(P) (2*noise(P)-1)
k3d/share/shaders/k3d_eyeball.sl:63:  point Nf;
k3d/share/shaders/k3d_eyeball.sl:64:  point PP, PO;
k3d/share/shaders/k3d_eyeball.sl:97:	  newturb = 1 - abs (snoise(PO*freq + point(0,0,20*freq)));
k3d/share/shaders/k3d_eyeball.sl:114:	  turb += snoise (PO*f2 + point(0,0,20*f2)) / freq;
k3d/share/shaders/k3d_fire.sl:36:    turb += abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_fire.sl:38:  turb += fade * abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_flame.sl:14: *    setting the "octaves" parameter based on distance from eye point.
k3d/share/shaders/k3d_flame.sl:32:#define snoise(p) (2 * float noise(p) - 1)
k3d/share/shaders/k3d_flame.sl:33:#define DNoise(p) (2 * (point noise(p)) - point(1, 1, 1))
k3d/share/shaders/k3d_flame.sl:34:#define VLNoise(p, scale) (snoise(p + scale * DNoise(p)))
k3d/share/shaders/k3d_flame.sl:41:  point PP, PQ;
k3d/share/shaders/k3d_flame.sl:45:  PP = point(s, t, phase);
k3d/share/shaders/k3d_flame.sl:47:  PQ *= point(1, 1, exp(-ycomp(PP)));
k3d/share/shaders/k3d_flame.sl:52:      chaos += VLNoise(freq * PQ, distortion) / freq;
k3d/share/shaders/k3d_fractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

k3d/share/shaders/k3d_fractal.sl:18:	point PP =transform("shader",P);

k3d/share/shaders/k3d_fractal.sl:24:          		signal = snoise( PP );

k3d/share/shaders/k3d_fractal.sl:45:          		signal = snoise( PP );

k3d/share/shaders/k3d_funkyglass.sl:13:  point PP;
k3d/share/shaders/k3d_funkyglass.sl:21:  Ct = 2 * (color noise(PP) - .5) + .5;
k3d/share/shaders/k3d_fur2.sl:14:                point Lin;       /* Light Position */
k3d/share/shaders/k3d_fur2.sl:15:                point Nin;       /* Surface Normal */
k3d/share/shaders/k3d_gloop.sl:6: * generated from the gradient of a noise function.
k3d/share/shaders/k3d_gloop.sl:11: * freq - the frequency of the noise. Lower values
k3d/share/shaders/k3d_gloop.sl:31:  point  Psh = transform("object",P)*freq;
k3d/share/shaders/k3d_gloop.sl:37:  point  Pou = Psh + (dPduN*overdist);/*P Over a distance in U*/
k3d/share/shaders/k3d_gloop.sl:38:  point  Pov = Psh + (dPdvN*overdist);
k3d/share/shaders/k3d_gloop.sl:40:  /*noise function at the point, over in u, and over in v*/
k3d/share/shaders/k3d_gloop.sl:41:  float  nz = noise(Psh)-.5;
k3d/share/shaders/k3d_gloop.sl:42:  float  nzou = noise(Pou)-.5;
k3d/share/shaders/k3d_gloop.sl:43:  float  nzov = noise(Pov)-.5;
k3d/share/shaders/k3d_gloop.sl:45:  float  chu = (nz - nzou);/*change in noise value in u*/
k3d/share/shaders/k3d_glow.sl:9:  if(incidence < 0)		// If this point is on the front face of the sphere
k3d/share/shaders/k3d_gmarbtile_polish.sl:23:#include "k3d_noises.h"
k3d/share/shaders/k3d_gmarbtile_polish.sl:53:  point PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_gmarbtile_polish.sl:87:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_gmarbtile_polish.sl:94:	       filteredsnoise(2 * (PP + vector(-4.4, 8.34, 27.1)), 2 * dPP));
k3d/share/shaders/k3d_gouge.sl:19:    *  displace the surface point inwards by that amount. 
k3d/share/shaders/k3d_granite.sl:17:		sum = sum + abs(.5 - noise( 4 * freq * I))/freq ;
k3d/share/shaders/k3d_graphic_lines.sl:19:        float noise_size_highlight=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:42:        float noise_size_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:65:        float noise_size_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:88:	point P_highlight = P;
k3d/share/shaders/k3d_graphic_lines.sl:108:	point Psh_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:131:	ns_highlight=noise_size_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:134:		n_highlight+=(2*noise(Psh_highlight*ns_highlight)-1)/ns_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:166:	point P_paint = P;
k3d/share/shaders/k3d_graphic_lines.sl:186:	point Psh_paint;
k3d/share/shaders/k3d_graphic_lines.sl:206:	ns_paint=noise_size_paint;
k3d/share/shaders/k3d_graphic_lines.sl:208:		n_paint+=(2*noise(Psh_paint*ns_paint)-1)/ns_paint;
k3d/share/shaders/k3d_graphic_lines.sl:238:	point P_ink = P;
k3d/share/shaders/k3d_graphic_lines.sl:258:	point Psh_ink;
k3d/share/shaders/k3d_graphic_lines.sl:278:	ns_ink=noise_size_ink;
k3d/share/shaders/k3d_graphic_lines.sl:280:		n_ink+=(2*noise(Psh_ink*ns_ink)-1)/ns_ink;
k3d/share/shaders/k3d_grass_displace.sl:7: * This is simply uses the noise function and a checkerboard

k3d/share/shaders/k3d_grass_displace.sl:22:  float noifreq = 5;

k3d/share/shaders/k3d_grass_displace.sl:23:  float noiscale = 0.4;

k3d/share/shaders/k3d_grass_displace.sl:26:  float noi = noise(s * noifreq, t * noifreq);

k3d/share/shaders/k3d_grass_displace.sl:27:  ss = s + snoise(noi + 912) * noiscale;

k3d/share/shaders/k3d_grass_displace.sl:28:  tt = t + snoise(noi + 333) * noiscale;

k3d/share/shaders/k3d_grass_surface.sl:17:  point Nf = faceforward(normalize(N),I);

k3d/share/shaders/k3d_grass_surface.sl:19:  float noifreq = 5;

k3d/share/shaders/k3d_grass_surface.sl:20:  float noiscale = 0.4;

k3d/share/shaders/k3d_grass_surface.sl:23:  float noi = noise(s * noifreq, t * noifreq);

k3d/share/shaders/k3d_grass_surface.sl:24:  ss = s + snoise(noi + 912) * noiscale;

k3d/share/shaders/k3d_grass_surface.sl:25:  tt = t + snoise(noi + 333) * noiscale;

k3d/share/shaders/k3d_grass_surface.sl:33:      point center = (0.5, 0.5, 0);  /* location of center of disk */

k3d/share/shaders/k3d_greenmarble.sl:20:#include "k3d_noises.h"
k3d/share/shaders/k3d_greenmarble.sl:38:  point PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_greenmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_greenmarble.sl:67:    smoothstep(-0.1, 0.05, snoise(2 * (PP + vector(-4.4, 8.34, 27.1))));
k3d/share/shaders/k3d_grids.sl:51:#define snoise(x) (2*noise(x)-1) 
k3d/share/shaders/k3d_grids_disp.sl:6: extern point P;
k3d/share/shaders/k3d_hdr_light.sl:2:* to work with 32 bit floating point TIFF environment maps to give a higher

k3d/share/shaders/k3d_hdr_light.sl:46:	point origin = (0,0,0);

k3d/share/shaders/k3d_hdr_light.sl:66:		/*Use light ray direction as map lookup NB L points from surface to lightsource*/

k3d/share/shaders/k3d_hdr_surface.sl:2:* to work with 32 bit floating point TIFF environment maps to give a higher 

k3d/share/shaders/k3d_hdr_surface.sl:45:	point origin = (0,0,0);

k3d/share/shaders/k3d_hexatile_bump.sl:15:*	point P1	= point(0,0,0) 		---	Center point for Rotation.
k3d/share/shaders/k3d_hexatile_bump.sl:16:*	point P2	= point(0,0,1) 		---	The x,y,z direction for Rotate.
k3d/share/shaders/k3d_hexatile_bump.sl:20:*	float C1	= 1 			---	Multiply of f1 the closes future point.
k3d/share/shaders/k3d_hexatile_bump.sl:21:*	float C2	= 2 			---	Multiply of f2 the second closes future point.
k3d/share/shaders/k3d_hexatile_bump.sl:31:* Larry Gritz "noises.h", "project.h", "patterns.h"
k3d/share/shaders/k3d_hexatile_bump.sl:41:void
k3d/share/shaders/k3d_hexatile_bump.sl:60:	float spos = stestcell + jitter * (float cellnoise(stestcell,seed+ttestcell) - 0.5);
k3d/share/shaders/k3d_hexatile_bump.sl:61:	float tpos = ttestcell + jitter * (float cellnoise(stestcell+23,seed+ttestcell-87) - 0.5);
k3d/share/shaders/k3d_hexatile_bump.sl:85:	point P1	= point(0,0,0); 
k3d/share/shaders/k3d_hexatile_bump.sl:86:	point P2	= point(0,0,1); 
k3d/share/shaders/k3d_hexatile_bump.sl:124:	extern point P;
k3d/share/shaders/k3d_hextile.sl:40:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_hextile.sl:41:#define snoise2(x,y) (2*noise((x),(y))-1)
k3d/share/shaders/k3d_hextile.sl:61:  point Nf;
k3d/share/shaders/k3d_hextile.sl:110:  Ctile = tilecolor * (1 + tilevary * snoise(tileindex+0.5));
k3d/share/shaders/k3d_hextile.sl:112:  stain = stains * smoothstep (.5,1, noise(s*stainfrequency,t*stainfrequency));
k3d/share/shaders/k3d_hextile.sl:114:  scuff = scuffing * smoothstep (.6,1, noise(t*scufffrequency-90.26,
k3d/share/shaders/k3d_imagelayerclouds.sl:1:// Use signed Perlin noise
k3d/share/shaders/k3d_imagelayerclouds.sl:2:#define snoise(x) ((2 * noise(x)) - 1)
k3d/share/shaders/k3d_imagelayerclouds.sl:13:  point PP;			/* Surface point in shader space */
k3d/share/shaders/k3d_imagelayerclouds.sl:17:  PP = txtscale * point(s, t, s);
k3d/share/shaders/k3d_imagelayerclouds.sl:19:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_imagelayerclouds.sl:27:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_indirect.sl:22:  /* Exploit the fact that PRMan (incorrectly) leaves the surface normal
k3d/share/shaders/k3d_leather.sl:46:	point PP, newP;

k3d/share/shaders/k3d_leather.sl:48:	float small_noise, blotch, speck, disp = 0, blackness;

k3d/share/shaders/k3d_leather.sl:75:	#define BASE_SF          1      /* s-factor for big noise          */

k3d/share/shaders/k3d_leather.sl:76:	#define BASE_TF          1      /* t-factor for big noise          */

k3d/share/shaders/k3d_leather.sl:77:	#define BASE_NF          100    /* scaling factor for small noise  */

k3d/share/shaders/k3d_leather.sl:78:	#define BASE_NOISE_AMP   0.2    /* small noise color mix amplitude */

k3d/share/shaders/k3d_leather.sl:85:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,

k3d/share/shaders/k3d_leather.sl:88:	small_noise = snoise(BASE_NF*PP*txtscale/TSCALE);

k3d/share/shaders/k3d_leather.sl:90:	                    (small_noise*BASE_NOISE_AMP));

k3d/share/shaders/k3d_leather.sl:110:	 * really simple noise routine.

k3d/share/shaders/k3d_leather.sl:117:	blotch_turb = noise(BLOTCH_SF*sin(2*PI*(s+.1234)) + PI + label,

k3d/share/shaders/k3d_leather.sl:121:	blotch = blotch * (1+small_noise) +

k3d/share/shaders/k3d_leather.sl:122:	         small_noise * BLOTCH_SPECK_COEFF;

k3d/share/shaders/k3d_leather.sl:138:	            noise(SPECK_NF*PP*txtscale/TSCALE)), 3);

k3d/share/shaders/k3d_leather.sl:166:	 * noise, affected a little by the brown specks, and

k3d/share/shaders/k3d_leather.sl:170:	#define DISP_SF     10             /* s-factor for dent noise */

k3d/share/shaders/k3d_leather.sl:171:	#define DISP_TF     30             /* t-factor for dent noise */

k3d/share/shaders/k3d_leather.sl:173:	#define DISP_SMNOISE_AMP  (1/1000) /* small noise amplitude   */

k3d/share/shaders/k3d_leather.sl:175:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,

k3d/share/shaders/k3d_leather.sl:177:	disp += small_noise * DISP_SMNOISE_AMP * txtscale / TSCALE;

k3d/share/shaders/k3d_lensflare.sl:6: *   These effects happen in real cameras when the camera points toward
k3d/share/shaders/k3d_lensflare.sl:17: *   bloomstarry, bloomnpoints - control the "starry" appearance of the 
k3d/share/shaders/k3d_lensflare.sl:20: *   starburstradius, starburstnpoints, starburstfalloff - control the
k3d/share/shaders/k3d_lensflare.sl:24: *   nspots - number of "spots" splayed out on the axis joining the
k3d/share/shaders/k3d_lensflare.sl:52:  uniform point Pcorner0 = transform("NDC", "screen", point(0, 0, 0));
k3d/share/shaders/k3d_lensflare.sl:53:  uniform point Pcorner1 = transform("NDC", "screen", point(1, 1, 0));
k3d/share/shaders/k3d_lensflare.sl:63:  uniform vector corner = vector(transform("NDC", "camera", point(1, 1, 0)));
k3d/share/shaders/k3d_lensflare.sl:88:		      float bloomnpoints = 25;
k3d/share/shaders/k3d_lensflare.sl:92:		      float starburstnpoints = 100;
k3d/share/shaders/k3d_lensflare.sl:107:    return cellnoise(nrand, seed);
k3d/share/shaders/k3d_lensflare.sl:117:  point Pndc = (transform("NDC", P) - vector(.5, .5, 0)) * 2;
k3d/share/shaders/k3d_lensflare.sl:132:    point Plight = (transform("NDC", P + L) - vector(.5, .5, 0)) * 2;
k3d/share/shaders/k3d_lensflare.sl:147:	float bloom = pnoise(bloomnpoints * angle / (2 * PI), bloomnpoints);
k3d/share/shaders/k3d_lensflare.sl:159:	float star = float pnoise(starburstnpoints * angle / (2 * PI),
k3d/share/shaders/k3d_lensflare.sl:160:				  starburstnpoints);
k3d/share/shaders/k3d_lensflare.sl:184:	point cntr = point(mix(-1.7, 1.7, alongaxis) * axis);
k3d/share/shaders/k3d_lensflare.sl:189:	clr *= 1 + spotvarycolor * (color cellnoise(i) - 0.5);
k3d/share/shaders/k3d_luna.sl:25:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_luna.sl:28:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_luna.sl:29:#define VLNoise(Pt,scale) (snoise(Pt + scale*DNoise(Pt)))
k3d/share/shaders/k3d_luna.sl:49:  point PP, PQ;
k3d/share/shaders/k3d_luna.sl:54:  point vv;
k3d/share/shaders/k3d_luna.sl:57:  point NN;
k3d/share/shaders/k3d_luna.sl:73:      a += o * snoise(l * PP);
k3d/share/shaders/k3d_luna.sl:102:  vv = point(xcomp(PP) / radial_dist, 0, zcomp(PP) / radial_dist);
k3d/share/shaders/k3d_luna.sl:132:  /* Add some noise */
k3d/share/shaders/k3d_luna.sl:143:	      ht += scale * snoise(freq * vv);
k3d/share/shaders/k3d_luna.sl:158:	      ht += scale * snoise(freq * vv);
k3d/share/shaders/k3d_luna.sl:174:      lighten = smoothstep(.15, .5, snoise(62 * u));
k3d/share/shaders/k3d_luna.sl:175:      raydist = 0.2 + 0.2 * snoise(20 * mod(u + 0.022, 1));
k3d/share/shaders/k3d_lunette.sl:7: *   A grid pattern overlaid upon an fBm noise.  This shader is good for
k3d/share/shaders/k3d_lunette.sl:19: *   colorA, colorB - colors used in the background fBm noise
k3d/share/shaders/k3d_lunette.sl:23: *   noiseScale - scale factor for the fBm noise relative to the grid size
k3d/share/shaders/k3d_lunette.sl:24: *   noiseRandom - randomization factor for the fBm noise
k3d/share/shaders/k3d_lunette.sl:29: *   noise functions and an box-filter antialiased grid function.
k3d/share/shaders/k3d_lunette.sl:38:#include "k3d_noises.h"
k3d/share/shaders/k3d_lunette.sl:49: *                           and tt directions.  Also scales the noise in both
k3d/share/shaders/k3d_lunette.sl:55: *   noiseScale - Scale of the background fBm noise (relative to the size of
k3d/share/shaders/k3d_lunette.sl:57: *                noise; decreasing it makes a broader noise.
k3d/share/shaders/k3d_lunette.sl:58: *   noiseRandom - Randomization value for the noise.
k3d/share/shaders/k3d_lunette.sl:59: *   maxOctaves - Maximum number of octaves for the fBm noise.
k3d/share/shaders/k3d_lunette.sl:60: *   lunacrity - Lunacrity of the fBm noise.
k3d/share/shaders/k3d_lunette.sl:61: *   gain - Gain of the fBm noise.
k3d/share/shaders/k3d_lunette.sl:62: *   colorBenhance - After the noise has been calculated, there exists the
k3d/share/shaders/k3d_lunette.sl:68: *                   noise.
k3d/share/shaders/k3d_lunette.sl:80:	float noiseScale;	/* scale of the noise relative to the grid */
k3d/share/shaders/k3d_lunette.sl:81:	float noiseRandom;	/* randomization for the noise */
k3d/share/shaders/k3d_lunette.sl:82:	uniform float maxOctaves;	/* maximum number of octives for the noise */
k3d/share/shaders/k3d_lunette.sl:83:	uniform float lunacrity;	/* lunacrity of the noise */
k3d/share/shaders/k3d_lunette.sl:84:	uniform float gain;		/* gain for the noise */
k3d/share/shaders/k3d_lunette.sl:92:	 * the grid.  pulsegrid = 0 means that there is no grid at the point
k3d/share/shaders/k3d_lunette.sl:93:	 * whereas pulsegrid = 1 means that there IS a grid at the point.
k3d/share/shaders/k3d_lunette.sl:107:	 * between colorA and colorB, created using noise and other mixing
k3d/share/shaders/k3d_lunette.sl:110:	point noisePt = noiseScale * 
k3d/share/shaders/k3d_lunette.sl:111:		point(ss*ssrepeats, tt*ttrepeats, noiseRandom);
k3d/share/shaders/k3d_lunette.sl:112:	float noisefilterwidth = filterwidthp(noisePt);
k3d/share/shaders/k3d_lunette.sl:113:	float noiseamt = (fBm(
k3d/share/shaders/k3d_lunette.sl:114:		noisePt, noisefilterwidth, maxOctaves, lunacrity, gain
k3d/share/shaders/k3d_lunette.sl:116:	noiseamt = pow(noiseamt, colorBenhance);
k3d/share/shaders/k3d_lunette.sl:117:	color basecolor = mix(colorB, colorA, noiseamt);
k3d/share/shaders/k3d_lunette.sl:125:	 * return the mix between the base grid and the colorful noise
k3d/share/shaders/k3d_lunette.sl:149:	/* fBm noise parameters */
k3d/share/shaders/k3d_lunette.sl:150:	float noiseScale = .3;
k3d/share/shaders/k3d_lunette.sl:151:	float noiseRandom = 0;
k3d/share/shaders/k3d_lunette.sl:161:		colorA, colorB, noiseScale, noiseRandom, maxOctaves,
k3d/share/shaders/k3d_map_pattern_1.sl:45:point PP, PQ;
k3d/share/shaders/k3d_map_pattern_1.sl:54:PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_map_pattern_1.sl:55:my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_map_pattern_1.sl:57:PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_map_pattern_1.sl:58:r = temp_f_3 * noise (PQ);
k3d/share/shaders/k3d_map_pattern_1.sl:62:PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_map_pattern_1.sl:63:r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_mondometal.sl:49:    point STMatrix0 = point "shader" (1,0,0);

k3d/share/shaders/k3d_mondometal.sl:50:    point STMatrix1 = point "shader" (0,1,0);

k3d/share/shaders/k3d_mondometal.sl:61:    point PP;

k3d/share/shaders/k3d_mysky.sl:25: *    setting the "octaves" parameter based on distance from eye point.

k3d/share/shaders/k3d_mysky.sl:46:/* Use signed Perlin noise */

k3d/share/shaders/k3d_mysky.sl:47:#define snoise(x) ((2*noise(x))-1)

k3d/share/shaders/k3d_mysky.sl:61:  point PP;      /* Surface point in shader space */

k3d/share/shaders/k3d_mysky.sl:66:  /* Use fractional Brownian motion to compute a value for this point */

k3d/share/shaders/k3d_mysky.sl:71:      a += o * snoise (PP*l);

k3d/share/shaders/k3d_noisysmoke.sl:1:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_noisysmoke.sl:10:         if (use_noise != 0) {                                              \
k3d/share/shaders/k3d_noisysmoke.sl:12:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_noisysmoke.sl:18:                      smoke += f*snoise(Psmoke);                            \
k3d/share/shaders/k3d_noisysmoke.sl:30:volume k3d_noisysmoke(float density = 60;
k3d/share/shaders/k3d_noisysmoke.sl:33:		      float use_lighting = 1; float use_noise = 1;
k3d/share/shaders/k3d_noisysmoke.sl:41:  point Worigin = P + I;
k3d/share/shaders/k3d_noisysmoke.sl:45:  point Worigin = P - I;
k3d/share/shaders/k3d_noisysmoke.sl:48:  point origin = transform("shader", Worigin);
k3d/share/shaders/k3d_noisysmoke.sl:56:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_noisysmoke.sl:63:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_oak.sl:21: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oak.sl:22: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oak.sl:57:		float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oak.sl:73:    oaktexture(Pshad, dPshad, ringfreq, ringunevenness, grainfreq, ringnoise,
k3d/share/shaders/k3d_oak.sl:74:	       ringnoisefreq, trunkwobble, trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oakplank.sl:28: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oakplank.sl:29: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oakplank.sl:64:#include "k3d_noises.h"
k3d/share/shaders/k3d_oakplank.sl:86:  float newt = tt + planklength * cellnoise(swhichplank);
k3d/share/shaders/k3d_oakplank.sl:107:		     float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oakplank.sl:136:  point Ppat =
k3d/share/shaders/k3d_oakplank.sl:137:    point(splank - 0.5, height - 0.01 * tplank, tplank) + vector(1, 5,
k3d/share/shaders/k3d_oakplank.sl:139:    (vector cellnoise(swhichplank, twhichplank) - 0.5);
k3d/share/shaders/k3d_oakplank.sl:142:			  ringnoise, ringnoisefreq, trunkwobble,
k3d/share/shaders/k3d_oakplank.sl:160:    varnishlump * filteredsnoise(Pshad * varnishlumpfreq,
k3d/share/shaders/k3d_orange.sl:33:	point Nf, V;
k3d/share/shaders/k3d_orange.sl:34:	point turb, p2;
k3d/share/shaders/k3d_orange.sl:35:	point newP;
k3d/share/shaders/k3d_orange.sl:43:	turb = noise (BUMP_FREQUENCY * p2) * BUMP_AMPLITUDE;
k3d/share/shaders/k3d_orennayar.sl:45:    point Nf, IN, Eye, LN;
k3d/share/shaders/k3d_outlet.sl:35:  point Nf;
k3d/share/shaders/k3d_parquet_plank.sl:43:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_plank.sl:123:      ttt = tt / 4 + whichplank / 28.38 + wavy * noise(8 * ss, tt / 4);
k3d/share/shaders/k3d_parquet_plank.sl:124:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank.sl:136:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale / 4));
k3d/share/shaders/k3d_parquet_plank.sl:152:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_parquet_plank2.sl:57:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_plank2.sl:62:  point Nf;
k3d/share/shaders/k3d_parquet_plank2.sl:123:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_plank2.sl:124:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank2.sl:134:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_plank2.sl:147:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_parquet_tile.sl:72:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_tile.sl:77:  point Nf;
k3d/share/shaders/k3d_parquet_tile.sl:138:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_tile.sl:139:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_tile.sl:149:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_tile.sl:162:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_planetclouds.sl:58:/* Use signed Perlin noise */
k3d/share/shaders/k3d_planetclouds.sl:59:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_planetclouds.sl:60:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_planetclouds.sl:61:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_planetclouds.sl:71:  point Pdistortion;		/* "distortion" vector */
k3d/share/shaders/k3d_planetclouds.sl:72:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_planetclouds.sl:80:  Pdistortion = distortionscale * DNoise(PP);
k3d/share/shaders/k3d_planetclouds.sl:81:  /* Second cirrus: replace DNoise with vector fBm */
k3d/share/shaders/k3d_planetclouds.sl:90:      a += o * VLNoise(PP * l, 1);
k3d/share/shaders/k3d_plank.sl:40:#define snoise(x) (2 * (float noise((x))) - 1)
k3d/share/shaders/k3d_plank.sl:72:  tt = (txtscale * t / PGHEIGHT) + 10 * snoise(0.5 + whichrow);
k3d/share/shaders/k3d_plank.sl:109:      ttt = tt + whichplank / 28.38 + wavy * noise(8 * ss, tt);
k3d/share/shaders/k3d_plank.sl:110:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_plank.sl:122:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale));
k3d/share/shaders/k3d_plank.sl:138:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_plastic2.sl:19:    point Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plastic2.sl:20:    point V = normalize(-I);
k3d/share/shaders/k3d_pointlight.sl:1:/* pointlight.sl - Standard point light source for RenderMan Interface.
k3d/share/shaders/k3d_pointlight.sl:9:light k3d_pointlight(float intensity = 3000;
k3d/share/shaders/k3d_pointlight.sl:11:		     point from = point "shader"(0, 0, 0);)
k3d/share/shaders/k3d_projectionmap_plastic.sl:47:			point Pshad = transform("shader", P);
k3d/share/shaders/k3d_puffyclouds.sl:23: *    setting the "octaves" parameter based on distance from eye point.
k3d/share/shaders/k3d_puffyclouds.sl:43:/* Use signed Perlin noise */
k3d/share/shaders/k3d_puffyclouds.sl:44:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_puffyclouds.sl:58:  point PP;      /* Surface point in shader space */
k3d/share/shaders/k3d_puffyclouds.sl:63:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_puffyclouds.sl:68:      a += o * snoise (PP*l);
k3d/share/shaders/k3d_redapple.sl:18: * Look out for the "txtscale" parameter: some noise calculations are
k3d/share/shaders/k3d_redapple.sl:38:#ifndef snoise
k3d/share/shaders/k3d_redapple.sl:39:#define snoise(x) (2*noise(x)-1)  /* 1-D signed noise */
k3d/share/shaders/k3d_redapple.sl:63:	point PP, newP;
k3d/share/shaders/k3d_redapple.sl:65:	float small_noise, blotch, speck, disp = 0, blackness;
k3d/share/shaders/k3d_redapple.sl:99:	#define BASE_SF          1.2    /* s-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:100:	#define BASE_TF          3      /* t-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:101:	#define BASE_NF          100    /* scaling factor for small noise  */
k3d/share/shaders/k3d_redapple.sl:102:	#define BASE_NOISE_AMP   0.2    /* small noise color mix amplitude */
k3d/share/shaders/k3d_redapple.sl:109:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:112:	small_noise = snoise(BASE_NF*PP*txtscale/TSCALE);
k3d/share/shaders/k3d_redapple.sl:114:	                    (small_noise*BASE_NOISE_AMP));
k3d/share/shaders/k3d_redapple.sl:134:	 * really simple noise routine.
k3d/share/shaders/k3d_redapple.sl:141:	blotch_turb = noise(BLOTCH_SF*sin(2*PI*(s+.1234)) + PI + label,
k3d/share/shaders/k3d_redapple.sl:145:	blotch = blotch * (1+small_noise) +
k3d/share/shaders/k3d_redapple.sl:146:	         small_noise * BLOTCH_SPECK_COEFF;
k3d/share/shaders/k3d_redapple.sl:159:	#define SPECK_NF        50    /* A noise scaling factor      */
k3d/share/shaders/k3d_redapple.sl:162:	            noise(SPECK_NF*PP*txtscale/TSCALE)), 3);
k3d/share/shaders/k3d_redapple.sl:190:	 * noise, affected a little by the brown specks, and
k3d/share/shaders/k3d_redapple.sl:194:	#define DISP_SF     10             /* s-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:195:	#define DISP_TF     30             /* t-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:197:	#define DISP_SMNOISE_AMP  (1/1000) /* small noise amplitude   */
k3d/share/shaders/k3d_redapple.sl:199:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:201:	disp += small_noise * DISP_SMNOISE_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_ridged_multifractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

k3d/share/shaders/k3d_ridged_multifractal.sl:18:	point PP =transform("shader",P);

k3d/share/shaders/k3d_ridged_multifractal.sl:24:          		signal = snoise( PP );

k3d/share/shaders/k3d_ridged_multifractal.sl:45:          		signal = snoise( PP );

k3d/share/shaders/k3d_round.sl:16:	point	 center,/* point toward which the surface is displaced 	*/
k3d/share/shaders/k3d_round.sl:17:		 dpdu,	/* dPdu pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:18:		 dpdv;	/* dPdv pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:44:	 * Find the point towards which the surface  point will be 
k3d/share/shaders/k3d_round.sl:50:		center = point(0,0,0);
k3d/share/shaders/k3d_rubber.sl:15:	point	Nf = faceforward(normalize(N),I), 
k3d/share/shaders/k3d_rubber.sl:20:	cout = mix(Cs, white, .05* (float noise(txtscale*Ploc)));
k3d/share/shaders/k3d_ruledpaper.sl:84:		if (distance( point(ss,tt,0), point(sm,tm,0) ) <= circr)	\
k3d/share/shaders/k3d_ruledpaper.sl:89:    point Nf, V;
k3d/share/shaders/k3d_rustymetal.sl:6: *   is basically thresholded turbulence (summed abs(snoise)).  Where it's
k3d/share/shaders/k3d_rustymetal.sl:34:/* Signed noise varies from -1 to 1 (like Perlin uses) */
k3d/share/shaders/k3d_rustymetal.sl:35:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_rustymetal.sl:52:  point Nf, V;                 /* normal and view vector used for shading */
k3d/share/shaders/k3d_rustymetal.sl:53:  point Nrust;                 /* perturbed normal for the rusty areas */
k3d/share/shaders/k3d_rustymetal.sl:54:  point PP;                    /* shade space point */
k3d/share/shaders/k3d_rustymetal.sl:57:  float rustiness;             /* Result: how rusty is this point? */
k3d/share/shaders/k3d_rustymetal.sl:60:  /* Sum several octaves of abs(snoise), i.e. turbulence.  Limit the
k3d/share/shaders/k3d_rustymetal.sl:67:      sum += a * abs(snoise(PP));
k3d/share/shaders/k3d_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
k3d/share/shaders/k3d_rustymetal.sl:74:  /* Scale the rust appropriately, modulate it by another noise 
k3d/share/shaders/k3d_rustymetal.sl:78:  rustiness *= clamp (abs(snoise(PP)), 0, .08) / 0.08;
k3d/share/shaders/k3d_saturn.sl:49:  point PP;
k3d/share/shaders/k3d_saturn.sl:50:  point PtN;
k3d/share/shaders/k3d_saturn.sl:53:  point Ptexture;
k3d/share/shaders/k3d_saturnring.sl:10: *	cutoff - what point to start rings (radius of transparency)
k3d/share/shaders/k3d_saturnring.sl:33:#define snoise(x) (2 * noise(x) - 1)	
k3d/share/shaders/k3d_saturnring.sl:35:/* prman noise has less range */
k3d/share/shaders/k3d_saturnring.sl:36:#define snoise(x) (2.5 * (noise(x) - 1))
k3d/share/shaders/k3d_saturnring.sl:42:	point PP;       /* Transformed point */
k3d/share/shaders/k3d_saturnring.sl:43:	point Nf;       /* Forward facing Normalized vector of incident light */
k3d/share/shaders/k3d_saturnring.sl:47:	float oi = 0.0; /* Opacity holder */
k3d/share/shaders/k3d_saturnring.sl:70:		oi =  (relpos + snoise (40* relpos) - floor(relpos) );
k3d/share/shaders/k3d_saturnring.sl:74:		printf ("oi = %f\n", oi);
k3d/share/shaders/k3d_saturnring.sl:78:		if (oi > 1.0)
k3d/share/shaders/k3d_saturnring.sl:79:			oi = 0.0;
k3d/share/shaders/k3d_saturnring.sl:83:	if (oi == 0.0)
k3d/share/shaders/k3d_saturnring.sl:92:			oi = 0.0;
k3d/share/shaders/k3d_saturnring.sl:103:		if (oi != 0.0) {
k3d/share/shaders/k3d_saturnring.sl:104:			Oi = oi;
k3d/share/shaders/k3d_scartissue.sl:2: *  an unremarkable recursive noise to make scartissue
k3d/share/shaders/k3d_scartissue.sl:14:	point Psh = transform("object",P);
k3d/share/shaders/k3d_scartissue.sl:25:		nz += abs(.5 - noise( (freq * Psh)+offset)) / freq;
k3d/share/shaders/k3d_screen_aa.sl:36:  float d;			/* Density at the sample point */
k3d/share/shaders/k3d_sdixon.sl:18:	point Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_sdixon.sl:19:	point V = normalize(-I);
k3d/share/shaders/k3d_shadowdistant_rim.sl:7:    point from = point "shader" (0,0,0) ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:8:    point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_shadowspot.sl:11:	point from = point "shader" (0, 0, 0);
k3d/share/shaders/k3d_shadowspot.sl:12:	point to = point "shader" (0, 0, 1);
k3d/share/shaders/k3d_shadowspot.sl:21:	point A = (to - from) / length(to - from); /* direction */
k3d/share/shaders/k3d_shifteddrtile.sl:60:	point Nf;
k3d/share/shaders/k3d_shifteddrtile.sl:61:	uniform point center;      /* Center of disk */
k3d/share/shaders/k3d_shiftedmoontile.sl:53:	uniform point eclipseCenter = point "current" (0.6, 0.5, 0);
k3d/share/shaders/k3d_shiftedmoontile.sl:57:	point Nf;
k3d/share/shaders/k3d_shiftedmoontile.sl:58:	uniform point center;            /* Center of disk */
k3d/share/shaders/k3d_shiftedmoontile.sl:64:	float d, d2;             /* Point distance from circle1, circle2 */
k3d/share/shaders/k3d_shiny.sl:11: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_shinyplastic.sl:12: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_show_st.sl:6: * show_st(): color surface point according to its s,t coordinates.
k3d/share/shaders/k3d_skin1.sl:26: * Oily,oilmap = controls how oily the skin looks. Use a grayscale map to contol
k3d/share/shaders/k3d_skin1.sl:27: * oiliness.---Note--- teh oiliy parameter is multiplied with the map.
k3d/share/shaders/k3d_skin1.sl:34: * #include "locilum.h" and #include "noises.h".
k3d/share/shaders/k3d_skin1.sl:71:    extern point P;
k3d/share/shaders/k3d_skin1.sl:111:   a one-dimensional volumetric surface.  Given incident and outgoing
k3d/share/shaders/k3d_skin1.sl:135:   color for an oily surface sheen.
k3d/share/shaders/k3d_skin1.sl:139:  extern point P;
k3d/share/shaders/k3d_skin1.sl:164:#define snoise(p) (2 * (float noise(p)) - 1)
k3d/share/shaders/k3d_skin1.sl:184:  float oily = 1.5;
k3d/share/shaders/k3d_skin1.sl:185:  string oilmap = "";
k3d/share/shaders/k3d_skin1.sl:200:  point PP;
k3d/share/shaders/k3d_skin1.sl:206:  float oilVal = oily;
k3d/share/shaders/k3d_skin1.sl:214:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:241:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:272:  /* --Layer 3-- apply an Anisotropic BRDF to simulate the oil layer that lies
k3d/share/shaders/k3d_skin1.sl:273:  * outside the skin. Oilyness is controlled by the oily, xrougness and yroughness.
k3d/share/shaders/k3d_skin1.sl:276:  if (oily > 0.01){
k3d/share/shaders/k3d_skin1.sl:285:  if (oilmap != "")
k3d/share/shaders/k3d_skin1.sl:286:      oilVal *= float texture(oilmap);
k3d/share/shaders/k3d_skin1.sl:288:  sc += (lc * (oilVal * 0.1) );
k3d/share/shaders/k3d_skin2.sl:30:   a one-dimensional volumetric surface.  Given incident and outgoing
k3d/share/shaders/k3d_skin2.sl:56:   color for an oily surface sheen, the ratio of the indices of 
k3d/share/shaders/k3d_skin2.sl:65:	extern point P;
k3d/share/shaders/k3d_skymetal.sl:18:    point up = normalize (point "world" (0, 1, 0) - point "world"  (0, 0, 0)); 
k3d/share/shaders/k3d_skymetal.sl:24:	point Nf;
k3d/share/shaders/k3d_slateroof.sl:7:	You must bear this in mind when modelling - to avoid the roof ending
k3d/share/shaders/k3d_slateroof.sl:69:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroof.sl:76:   uniform 	float colorfactor = 3.276 * factor;	/* Used in noise calculations */	
k3d/share/shaders/k3d_slateroof.sl:95:	/* Work out the displacement assuming the point is in the 
k3d/share/shaders/k3d_slateroof.sl:99:	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroof.sl:109:		add = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroof.sl:112:	ocolorvary = (noise(cs * colorfactor, ct * colorfactor) - 1) * 2 * maxcolorvary;
k3d/share/shaders/k3d_slateroof.sl:132:	/* Work out whether the point is in fact in another tile 
k3d/share/shaders/k3d_slateroof.sl:137:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroof.sl:147:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroof.sl:153:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroof.sl:154:			newcolorvary =  (noise(cs * colorfactor, ct * colorfactor) - 1) * 2 * maxcolorvary;
k3d/share/shaders/k3d_slateroof.sl:184:	ns = noise( s * txtscale * 59.8534 * sfreq, t * txtscale * 59.8534 * tfreq);
k3d/share/shaders/k3d_slateroofd.sl:33:		point we are considering is actually in the zone of overlap with the
k3d/share/shaders/k3d_slateroofd.sl:61:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroofd.sl:86:	/* Work out the displacement assuming the point is in the 
k3d/share/shaders/k3d_slateroofd.sl:91:   	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroofd.sl:100:   		add = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroofd.sl:124:	/* Work out whether the point is in fact in another tile 	
k3d/share/shaders/k3d_slateroofd.sl:129:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroofd.sl:139:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroofd.sl:145:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slideprojector.sl:3:			 point from = point(0, 0, 0);
k3d/share/shaders/k3d_slideprojector.sl:4:			 point to = point(0, 0, 1);
k3d/share/shaders/k3d_slideprojector.sl:5:			 point up = point(0, 1, 0); float coneangle = 45;
k3d/share/shaders/k3d_smoke.sl:5: *    This is a volume shader for smoke.  Trapezoidal integration is
k3d/share/shaders/k3d_smoke.sl:16: *   smokefreq, smokeoctaves, smokevary - control the fBm of the noisy smoke
k3d/share/shaders/k3d_smoke.sl:17: *          If either smokeoctaves or smokevary is 0, there is no noise
k3d/share/shaders/k3d_smoke.sl:28:#include "k3d_noises.h"
k3d/share/shaders/k3d_smoke.sl:30:/* For point P (we are passed both the current and shader space
k3d/share/shaders/k3d_smoke.sl:32: * compute the smoke density at that point.  Only count lights tagged
k3d/share/shaders/k3d_smoke.sl:35:void smokedensity(point Pcur, Pshad;
k3d/share/shaders/k3d_smoke.sl:51:      point Psmoke = Pshad * smokefreq;
k3d/share/shaders/k3d_smoke.sl:53:      smoke = snoise(Psmoke);
k3d/share/shaders/k3d_smoke.sl:83:  point Worigin = P - I;	/* Origin of volume ray */
k3d/share/shaders/k3d_smoke.sl:84:  point origin = transform("shader", Worigin);
k3d/share/shaders/k3d_smoke.sl:88:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_smoke2.sl:2: * TLSmoke.sl -- This is really Larry's noisysmoke.sl.  I only took out the
k3d/share/shaders/k3d_smoke2.sl:6: *    This is a volume shader for smoke.  Trapezoidal integration is
k3d/share/shaders/k3d_smoke2.sl:16: *   use_noise - makes the smoke noisy (nonuniform) when nonzero
k3d/share/shaders/k3d_smoke2.sl:17: *   freq, octaves, smokevary - control the fBm of the noisy smoke
k3d/share/shaders/k3d_smoke2.sl:39: * Compute only one octave of noise when not lit (big speedup)
k3d/share/shaders/k3d_smoke2.sl:47:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_smoke2.sl:54:	     illuminance (PW, point(0,0,1), PI) { li += Cl; }               \
k3d/share/shaders/k3d_smoke2.sl:56:         if (use_noise != 0) {                                              \
k3d/share/shaders/k3d_smoke2.sl:58:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_smoke2.sl:64:                      smoke += f*snoise(Psmoke);                            \
k3d/share/shaders/k3d_smoke2.sl:82:	    float use_noise = 1;
k3d/share/shaders/k3d_smoke2.sl:89:  point Worigin = P + I;
k3d/share/shaders/k3d_smoke2.sl:90:  point incident = vtransform ("shader", -I);
k3d/share/shaders/k3d_smoke2.sl:92:  point Worigin = P - I;
k3d/share/shaders/k3d_smoke2.sl:93:  point incident = vtransform ("shader", I);
k3d/share/shaders/k3d_smoke2.sl:95:  point origin = transform ("shader", Worigin);
k3d/share/shaders/k3d_smoke2.sl:96:  point IN, WIN;
k3d/share/shaders/k3d_smoke2.sl:103:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_smoke2.sl:109:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_softboxes.sl:49:/*   - point Q on the x-y plane						***/
k3d/share/shaders/k3d_softboxes.sl:61:    point Q;          /* Test point on the x-y plane */
k3d/share/shaders/k3d_softboxes.sl:85:void softbox_contrib2(
k3d/share/shaders/k3d_softboxes.sl:86:    varying point	surfPt;
k3d/share/shaders/k3d_softboxes.sl:111:    varying point Pb1 = transform (boxCoords, surfPt);
k3d/share/shaders/k3d_softboxes.sl:114:    varying point Pplane = Pb1 - Vlight*(zcomp(Pb1)/zcomp(Vlight));
k3d/share/shaders/k3d_softboxes.sl:165:    varying point ppC = transform(boxCoords,"world",Pplane);
k3d/share/shaders/k3d_softboxes.sl:166:    varying point spw = transform("world",surfPt);
k3d/share/shaders/k3d_softboxes.sl:179:    varying point	thePoint;
k3d/share/shaders/k3d_softboxes.sl:188:			    thePoint,
k3d/share/shaders/k3d_softboxes.sl:320:	uniform point metP = transform(meterSpace,"shader",point (0,0,0));
k3d/share/shaders/k3d_softboxes.sl:413:		    varying point PShd = transform (theEnvSpace, Ps);
k3d/share/shaders/k3d_spacecloud.sl:29: *      I was never happy with the results.  So now am just using noise over
k3d/share/shaders/k3d_spacecloud.sl:36:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spacecloud.sl:37:#define snoise2(x, y) (2 * noise(x, y) - 1)
k3d/share/shaders/k3d_spacecloud.sl:39:#define adjustNoise2(x, y, minVal, maxVal) \
k3d/share/shaders/k3d_spacecloud.sl:40:	snoise2 (x,y) * ((maxVal)-(minVal)+(minVal))
k3d/share/shaders/k3d_spacecloud.sl:61:  point PP;
k3d/share/shaders/k3d_spacecloud.sl:75:    value += abs(snoise (PP * f))/f;
k3d/share/shaders/k3d_spacecloud.sl:82:	fBm (P, noiseScale, octaves, PP, freq, i, size, adjust);
k3d/share/shaders/k3d_spacecloud.sl:86:	adjust = adjustNoise2 (u, v, minAdjust, maxAdjust);
k3d/share/shaders/k3d_spaceshiphull1.sl:1:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spaceshiphull1.sl:4:float fractalsum(point Q)
k3d/share/shaders/k3d_spaceshiphull1.sl:10:		value += snoise(Q * f) / f;
k3d/share/shaders/k3d_spaceshiphull1.sl:29:  point Nf;
k3d/share/shaders/k3d_spaceshiphull1.sl:30:  point V;
k3d/share/shaders/k3d_spaceshiphull1.sl:38:  ss += rowvary * noise(tplate + 0.3);
k3d/share/shaders/k3d_spaceshiphull1.sl:42:  platecolor = Cs - (lumavary * float noise(splate + 0.4, tplate + 0.5));
k3d/share/shaders/k3d_spaceshiphull1.sl:48:  platespecular = Ks * noise(splate + 0.6, tplate + 0.7);
k3d/share/shaders/k3d_spotlight.sl:11:		    point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_spotlight.sl:12:		    point to = point "shader"(0, 0, 1);
k3d/share/shaders/k3d_srfdeformation.sl:35:void 
k3d/share/shaders/k3d_srfdeformation.sl:36:fnc_projectCurrentCamera(point P;
k3d/share/shaders/k3d_srfdeformation.sl:39:    point Pndc = transform("NDC", P);
k3d/share/shaders/k3d_srfdeformation.sl:56:    varying point Pref = point "shader" (0,0,0);
k3d/share/shaders/k3d_srfdeformation.sl:64:    point Porig = Pref;
k3d/share/shaders/k3d_star.sl:21:    uniform float npoints = 5;
k3d/share/shaders/k3d_star.sl:26:    point Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_star.sl:30:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_star.sl:31:    uniform point p0 = rmax*(cos(0),sin(0),0);
k3d/share/shaders/k3d_star.sl:32:    uniform point p1 = rmin*
k3d/share/shaders/k3d_star.sl:34:    uniform point d0 = p1 - p0;
k3d/share/shaders/k3d_star.sl:35:    point d1;
k3d/share/shaders/k3d_starfield.sl:14:	point PP = transform("object", frequency * P);
k3d/share/shaders/k3d_starfield.sl:17:	point star_center = point(0.5 * (floor(xcomp(PP)) + ceil(xcomp(PP))), 0.5 * (floor(ycomp(PP)) + ceil(ycomp(PP))), 0.5 * (floor(zcomp(PP)) + ceil(zcomp(PP))));
k3d/share/shaders/k3d_starfield.sl:19:	star_center += irregularity * (point noise(star_center) - point(0.5, 0.5, 0.5));
k3d/share/shaders/k3d_starfield.sl:27:	float star_intensity = float cellnoise(star_center);
k3d/share/shaders/k3d_stones.sl:49:#define snoise(x)    (noise(x) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:50:#define snoise2(x,y) (noise(x,y) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:53:#define filterwidth_point(p) (max(sqrt(area(p)), MINFILTERWIDTH))
k3d/share/shaders/k3d_stones.sl:54:#define udn(x,lo,hi) (smoothstep(.25, .75, noise(x)) * ((hi) - (lo)) + (lo))
k3d/share/shaders/k3d_stones.sl:69:    h += varyhue * (cellnoise(index+3)-0.5);
k3d/share/shaders/k3d_stones.sl:70:    s *= 1 - varysat * (cellnoise(index-14)-0.5);
k3d/share/shaders/k3d_stones.sl:71:    v *= 1 - varyval * (cellnoise(index+37)-0.5);
k3d/share/shaders/k3d_stones.sl:103: float noifreq = 10, noiscale = 0.3;
k3d/share/shaders/k3d_stones.sl:115:   angle = PI * snoise(freq * 16.31456);  /*randomize angle index*/
k3d/share/shaders/k3d_stones.sl:129:   bub = 0.5 + snoise2(10 * freq,10 * freq);
k3d/share/shaders/k3d_stones.sl:130:   ss += noiscale * snoise(snoise2(s * noifreq, t * noifreq) + 912);
k3d/share/shaders/k3d_stones.sl:131:   tt += noiscale * snoise(snoise2(s * noifreq, t * noifreq) + 333);
k3d/share/shaders/k3d_stones.sl:132:   /*cx = 0.5 + 0.1 * snoise2( 12.312,  21.773);
k3d/share/shaders/k3d_stones.sl:133:   cy = 0.5 + 0.1 * snoise2( 28.398, 62.112); */
k3d/share/shaders/k3d_stones.sl:134:   cx = 0.5 + 0.1 * snoise2( freq * 8.456, freq * 18.773);
k3d/share/shaders/k3d_stones.sl:135:   cy = 0.5 + 0.1 * snoise2( freq * 28.398, freq * 42.112);
k3d/share/shaders/k3d_stones.sl:136:   point p1 =(cx,cy,0);
k3d/share/shaders/k3d_stones.sl:137:   point p2 = (ss,tt,0);
k3d/share/shaders/k3d_stones.sl:160:       point PP = transform("shader", P) * grungefreq;
k3d/share/shaders/k3d_stones.sl:161:       float width = filterwidth_point(PP);
k3d/share/shaders/k3d_stones.sl:166:        turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:168:        turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_strata.sl:13: *    octaves - number of octaves of noise to sum for the turbulence
k3d/share/shaders/k3d_strata.sl:35:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_strata.sl:43:  point PP;
k3d/share/shaders/k3d_strata.sl:53:      turb += abs(snoise(PP * freq) / freq);
k3d/share/shaders/k3d_stucco.sl:20:  point PP;
k3d/share/shaders/k3d_stucco.sl:23:  magnitude = Km * pow(noise(PP * frequency), power);
k3d/share/shaders/k3d_superkagee.sl:15:    varying point       thePoint;
k3d/share/shaders/k3d_superkagee.sl:24:#define SHADPOINT thePoint
k3d/share/shaders/k3d_superplank.sl:46:#include "k3d_noises.h"
k3d/share/shaders/k3d_superplank.sl:111:  point Pndc;			/* NDC coordinate of P */
k3d/share/shaders/k3d_superplank.sl:154:      plank_t = tt / PGHEIGHT + 20 * plankstagger * cellnoise(whichrow);
k3d/share/shaders/k3d_superplank.sl:218:      ttt = ring_t + whichplank * 28.38 + wavy * noise(8 * ring_s, ring_t);
k3d/share/shaders/k3d_superplank.sl:219:      ring = ringscale * noise(ring_s - whichplank * 4.18, ttt / 20);
k3d/share/shaders/k3d_superplank.sl:233:	  r2 = 1.3 - noise(12 * grain_s, grain_t);
k3d/share/shaders/k3d_superplank.sl:251:    1 - plankvary / 2 + plankvary * float cellnoise(whichplank, whichrow);
k3d/share/shaders/k3d_superplank.sl:274:			    noise(varnishbumpfreq * ss,
k3d/share/shaders/k3d_supertexmap.sl:19: *                projected point before texture coordinates are extracted.
k3d/share/shaders/k3d_supertoon.sl:10: * clamping, the inflection points are lim2, lim3 and lim4. This shader is very cheap, 

k3d/share/shaders/k3d_supertoon.sl:34:                        lim2 = 0.3,      /* inflection points  */

k3d/share/shaders/k3d_terran.sl:8:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:10:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran.sl:11:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:14:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran.sl:15:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran.sl:35:  point PP;
k3d/share/shaders/k3d_terran.sl:36:  point PtN;
k3d/share/shaders/k3d_terran.sl:39:  point Ptexture, tp;
k3d/share/shaders/k3d_terran.sl:60:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terran.sl:68:      Ptexture += dist_scale * DNoise(Ptexture);
k3d/share/shaders/k3d_terran.sl:69:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran.sl:72:      weight = abs(VLNoise(tp, 1.5));
k3d/share/shaders/k3d_terran.sl:73:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terran.sl:78:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran.sl:80:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_terran.sl:149:	      purt += o * snoise(l * PP);
k3d/share/shaders/k3d_terran2.sl:24: *    multifractal - zero uses fBm noise, nonzero uses multifractal
k3d/share/shaders/k3d_terran2.sl:64:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:66:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran2.sl:67:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:70:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran2.sl:71:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran2.sl:98:  point PP;
k3d/share/shaders/k3d_terran2.sl:99:  point PtN;
k3d/share/shaders/k3d_terran2.sl:102:  point Ptexture, tp;
k3d/share/shaders/k3d_terran2.sl:119:	  bumpy += o * snoise (l * Ptexture);
k3d/share/shaders/k3d_terran2.sl:126:      Ptexture += dist_scale * DNoise (Ptexture);
k3d/share/shaders/k3d_terran2.sl:127:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran2.sl:129:      weight = abs (VLNoise (tp, 1.5));
k3d/share/shaders/k3d_terran2.sl:130:      bumpy = weight * snoise (tp);
k3d/share/shaders/k3d_terran2.sl:134:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran2.sl:136:	  bumpy += snoise(tp) * min (weight, spectral_exp);
k3d/share/shaders/k3d_terran2.sl:206:	     purt += o * snoise (l * PP);
k3d/share/shaders/k3d_terranbump.sl:4:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:6:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terranbump.sl:7:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:10:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terranbump.sl:11:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terranbump.sl:24:  point Ptexture, tp;
k3d/share/shaders/k3d_terranbump.sl:38:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terranbump.sl:46:      Ptexture += dist_scale * DNoise(Ptexture);
k3d/share/shaders/k3d_terranbump.sl:47:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terranbump.sl:50:      weight = abs(VLNoise(tp, 1.5));
k3d/share/shaders/k3d_terranbump.sl:51:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terranbump.sl:56:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terranbump.sl:58:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_texblender.sl:9:#include "k3d_noises.h"
k3d/share/shaders/k3d_texblender.sl:21:myEnvironment (point P;  vector R;  float Kr, blur;  DECLARE_ENVPARAMS;)
k3d/share/shaders/k3d_texblender.sl:41:float myrand(point p;)
k3d/share/shaders/k3d_texblender.sl:57:float tex_clouds(point P;float depth)
k3d/share/shaders/k3d_texblender.sl:65:		//val=val*(1-Karm)+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:66:		val=val+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:73:float tex_wood(point PP; float ringscale)
k3d/share/shaders/k3d_texblender.sl:78:    point PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_texblender.sl:79:    my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_texblender.sl:81:    PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_texblender.sl:82:    float r = ringscale * noise (PQ);
k3d/share/shaders/k3d_texblender.sl:85:    PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_texblender.sl:86:    float r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_texblender.sl:94:	point transp;
k3d/share/shaders/k3d_texblender.sl:101:	else if (mapname=="noise")
k3d/share/shaders/k3d_tooledsteel.sl:17: *  Nzscale 		- scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_tooledsteel.sl:38:  extern point P;
k3d/share/shaders/k3d_tooledsteel.sl:49:  point Po = point(s*mult,t*mult,0);
k3d/share/shaders/k3d_tooledsteel.sl:50:  point Pou = Po +(udir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:51:  point Pov = Po +(vdir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:53:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_tooledsteel.sl:54:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_tooledsteel.sl:66:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_tooledsteel.sl:71:	nzoff = ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_tooledsteel.sl:94:    extern point P;
k3d/share/shaders/k3d_tooledsteel.sl:101:    point zro = 0;
k3d/share/shaders/k3d_tooledsteel.sl:137:	point Po = transform("object",P);
k3d/share/shaders/k3d_tooledsteel.sl:141:        point zro = 0;
k3d/share/shaders/k3d_uberlight.sl:8: * Rather than explicitly pass "from" and "to" points to indicate the
k3d/share/shaders/k3d_uberlight.sl:10: * emits from the origin of the local light shader space and points
k3d/share/shaders/k3d_uberlight.sl:23: *       those that point in a particular direction (+z in local light
k3d/share/shaders/k3d_uberlight.sl:38: *       (which is physically correct for point-like sources, but
k3d/share/shaders/k3d_uberlight.sl:47: *       from a single point (i.e., the rays diverge).  When nonzero, 
k3d/share/shaders/k3d_uberlight.sl:87: * Projected noise on the light:
k3d/share/shaders/k3d_uberlight.sl:88: *   noiseamp - amplitude of the noise.  A value of 0 (the default) 
k3d/share/shaders/k3d_uberlight.sl:89: *       means not to use noise.  Larger values increase the blotchiness
k3d/share/shaders/k3d_uberlight.sl:90: *       of the projected noise.
k3d/share/shaders/k3d_uberlight.sl:91: *   noisefreq - frequency of the noise.
k3d/share/shaders/k3d_uberlight.sl:92: *   noiseoffset - spatial offset of the noise.  This can be animated,
k3d/share/shaders/k3d_uberlight.sl:93: *       for example, you can use the noise to simulate the
k3d/share/shaders/k3d_uberlight.sl:133: * Joint shadow controls:
k3d/share/shaders/k3d_uberlight.sl:168: *   __foglight - the "noisysmoke" shader distributed with BMRT will add
k3d/share/shaders/k3d_uberlight.sl:171: *       this light with noisysmoke, you can set this flag to 0 to
k3d/share/shaders/k3d_uberlight.sl:173: *       Note that the noisysmoke shader is distributed with BMRT but
k3d/share/shaders/k3d_uberlight.sl:177: * noise texture.  Some advanced users may want more than one of some or
k3d/share/shaders/k3d_uberlight.sl:191: * tried to avoid Shading Language constructs which wouldn't work on
k3d/share/shaders/k3d_uberlight.sl:196: * substitute "point" for all occurrances of "vector", and move the
k3d/share/shaders/k3d_uberlight.sl:218: *   - point Q on the x-y plane
k3d/share/shaders/k3d_uberlight.sl:226:float clipSuperellipse(point Q;	/* Test point on the x-y plane */
k3d/share/shaders/k3d_uberlight.sl:235:    {				/* avoid degenerate case */
k3d/share/shaders/k3d_uberlight.sl:270: *   - the point being shaded, in the local light space
k3d/share/shaders/k3d_uberlight.sl:276:float ShapeLightVolume(point PL;	/* Point in light space */
k3d/share/shaders/k3d_uberlight.sl:328:	1 - clipSuperellipse(PL / Pz - point(shearx, sheary, 0), width,
k3d/share/shaders/k3d_uberlight.sl:338:/* Evaluate the occlusion between two points, P1 and P2, due to a fake
k3d/share/shaders/k3d_uberlight.sl:342:float BlockerContribution(point P1, P2;
k3d/share/shaders/k3d_uberlight.sl:351:  point Pb1 = transform(blockercoords, P1);
k3d/share/shaders/k3d_uberlight.sl:352:  point Pb2 = transform(blockercoords, P2);
k3d/share/shaders/k3d_uberlight.sl:353:  /* Blocker works only if it's straddled by ray endpoints. */
k3d/share/shaders/k3d_uberlight.sl:357:      point Pplane = Pb1 - Vlight * (zcomp(Pb1) / zcomp(Vlight));
k3d/share/shaders/k3d_uberlight.sl:385:		     /* Noisy light */
k3d/share/shaders/k3d_uberlight.sl:386:		     float noiseamp = 0, noisefreq = 4;
k3d/share/shaders/k3d_uberlight.sl:387:		     vector noiseoffset = 0;
k3d/share/shaders/k3d_uberlight.sl:412:   * the surface point we're shading, expressed in the local light
k3d/share/shaders/k3d_uberlight.sl:415:  point PL = transform("shader", Ps);
k3d/share/shaders/k3d_uberlight.sl:417:  /* If it's an area light, we want the point and normal of the light
k3d/share/shaders/k3d_uberlight.sl:421:  point from = P;
k3d/share/shaders/k3d_uberlight.sl:425:  point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_uberlight.sl:466:	point Pslide = PL / point(width + wedge, height + hedge, 1);
k3d/share/shaders/k3d_uberlight.sl:476:	/* Apply noise */
k3d/share/shaders/k3d_uberlight.sl:477:	if(noiseamp > 0)
k3d/share/shaders/k3d_uberlight.sl:480:	    float n = noise(noisefreq * (PL + noiseoffset) * point(1, 1, 0));
k3d/share/shaders/k3d_uberlight.sl:481:	    n = smoothstep(0, 1, 0.5 + noiseamp * (n - 0.5));
k3d/share/shaders/k3d_uberlight.sl:491:	point shadoworigin;
k3d/share/shaders/k3d_uberlight.sl:495:	  shadoworigin = point "shader"(xcomp(PL), ycomp(PL), cuton);
k3d/share/shaders/k3d_urbermap.sl:35:point STMatrix0=point(1,0,0); 
k3d/share/shaders/k3d_urbermap.sl:36:point STMatrix1=point(0,1,0); ) 
k3d/share/shaders/k3d_urbermap.sl:42:point PP;
k3d/share/shaders/k3d_veinedmarble.sl:27:#include "k3d_noises.h"
k3d/share/shaders/k3d_veinedmarble.sl:46:  point offset;
k3d/share/shaders/k3d_veinedmarble.sl:50:  point PP = transform("shader", P);
k3d/share/shaders/k3d_veinedmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_venus.sl:19: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus.sl:49:/* Use signed noise on [-1,1] */
k3d/share/shaders/k3d_venus.sl:50:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus.sl:59:  point Ptexture;		/* the shade point in texture space */
k3d/share/shaders/k3d_venus.sl:60:  point PtN;			/* normalized version of Ptexture */
k3d/share/shaders/k3d_venus.sl:61:  point PP;			/* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus.sl:71:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus.sl:78:    point(xcomp(Ptexture) * cosine - ycomp(Ptexture) * sine,
k3d/share/shaders/k3d_venus.sl:87:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_venus2.sl:21: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus2.sl:47:/* Use signed noise on [-1,1] */
k3d/share/shaders/k3d_venus2.sl:48:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus2.sl:61:  point Ptexture;           /* the shade point in texture space */
k3d/share/shaders/k3d_venus2.sl:62:  point PtN;                /* normalized version of Ptexture */
k3d/share/shaders/k3d_venus2.sl:63:  point PP;                 /* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus2.sl:73:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus2.sl:79:  PP = point (xcomp(Ptexture)*cosine - ycomp(Ptexture)*sine,
k3d/share/shaders/k3d_venus2.sl:86:      a += o * snoise (PP * l);
k3d/share/shaders/k3d_volcube.sl:5:   StepSize            - distance between sample points.
k3d/share/shaders/k3d_volcube.sl:21:/* fnc_traceBox returns an intersection point on a box */
k3d/share/shaders/k3d_volcube.sl:22:point
k3d/share/shaders/k3d_volcube.sl:32:    extern point P;
k3d/share/shaders/k3d_volcube.sl:36:    point Ri;
k3d/share/shaders/k3d_volcube.sl:104:active_volume(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:106:    return (noise((Pos+30.445)*2)-.5+vol_offset)*vol_mult;
k3d/share/shaders/k3d_volcube.sl:114:get_density(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:121:    dens = pow(1-abs(noise(Pos*7)*2-1),3);
k3d/share/shaders/k3d_volcube.sl:122:    dens += pow(1-abs(noise((Pos+24.72)*7)*2-1),3);
k3d/share/shaders/k3d_volcube.sl:129:normal calcGradeNorm(point Pos; float vol_mult, vol_offset, dens, epsilon;)
k3d/share/shaders/k3d_volcube.sl:132:    Nd = normal (get_density(point (xcomp(Pos) - epsilon, ycomp(Pos),
k3d/share/shaders/k3d_volcube.sl:134:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:136:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:147:void get_shading (point Pos;
k3d/share/shaders/k3d_volcube.sl:200:    point  inPoint_obj  = transform("object",P);
k3d/share/shaders/k3d_volcube.sl:201:    point  outPoint_obj = fnc_traceBox(-.501,.501,-.501,.501,-.501,.501,1,"object");
k3d/share/shaders/k3d_volcube.sl:207:    float  vol_length   = length(outPoint_obj-inPoint_obj);
k3d/share/shaders/k3d_volcube.sl:209:    vector step_obj     = (outPoint_obj-inPoint_obj)/numOfSteps;
k3d/share/shaders/k3d_volcube.sl:221:    point  Pcur_obj     = inPoint_obj + jitter * step_obj;
k3d/share/shaders/k3d_volcube.sl:222:    point  Pcur        = P  + jitter * step_cur;
k3d/share/shaders/k3d_volcube.sl:291:            /* Displace Point To Current Sample */
k3d/share/shaders/k3d_volcube.sl:294:	/* jump to the next sample point */
k3d/share/shaders/k3d_wallpaper.sl:16:#define snoise(s,t)	(2*noise((s),(t))-1)
k3d/share/shaders/k3d_wallpaper.sl:23:    uniform float npoints = 5;
k3d/share/shaders/k3d_wallpaper.sl:27:    point Nf;
k3d/share/shaders/k3d_wallpaper.sl:33:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_wallpaper.sl:34:    uniform point p0 = rmax*(cos(0),sin(0),0);
k3d/share/shaders/k3d_wallpaper.sl:35:    uniform point p1 = rmin*
k3d/share/shaders/k3d_wallpaper.sl:37:    uniform point d0 = p1 - p0;
k3d/share/shaders/k3d_wallpaper.sl:38:    point d1;
k3d/share/shaders/k3d_wallpaper.sl:48:	    if (float noise(3*scell-9.5,7*tcell+7.5) < 0.55) {
k3d/share/shaders/k3d_wallpaper.sl:50:                     + 0.6 * snoise(scell+0.5, tcell+0.5));
k3d/share/shaders/k3d_wallpaper.sl:52:                     + 0.6 * snoise(scell+3.5, tcell+8.5));
k3d/share/shaders/k3d_water.sl:94:    point center;

k3d/share/shaders/k3d_watercolor.sl:2: *	The shader exploits that fact that the Renderman interface already

k3d/share/shaders/k3d_waterdisplacement.sl:9: *	I			direction of ray stricking a surface point (from the camera)

k3d/share/shaders/k3d_waterdisplacement.sl:16:	point	norm;

k3d/share/shaders/k3d_waterdisplacement.sl:25:	/* STEP 3 - Calculate a new position of the surface point, "P" */

k3d/share/shaders/k3d_waterlight.sl:24:			Cl = mix(minimum_intensity, maximum_intensity, float noise(frequency * Ps)) * lightcolor;
k3d/share/shaders/k3d_windowlight.sl:31:		      point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_windowlight.sl:32:		      point to = point "shader"(0, 1, 0);
k3d/share/shaders/k3d_windowlight.sl:33:		      point center = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_windowlight.sl:46:  point PL;			/* point on the light */
k3d/share/shaders/k3d_windywave.sl:1:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_windywave.sl:8:  point PP;
k3d/share/shaders/k3d_windywave.sl:14:  offset = Km * (snoise(PP) + 0.5 * snoise(2 * PP));
k3d/share/shaders/k3d_windywave.sl:21:      turb += abs(a * snoise(PP));
k3d/share/shaders/k3d_wood2.sl:29:  point PP, PQ;			/* shading space point to be computed */
k3d/share/shaders/k3d_wood2.sl:39:  PQ = point(xcomp(PP) * 8, ycomp(PP) * 8, zcomp(PP));
k3d/share/shaders/k3d_wood2.sl:40:  my_t += noise(PQ) / 16;
k3d/share/shaders/k3d_wood2.sl:42:  PQ = point(xcomp(PP), my_t, ycomp(PP) + 12.93);
k3d/share/shaders/k3d_wood2.sl:43:  r = ringscale * noise(PQ);
k3d/share/shaders/k3d_wood2.sl:48:  PQ = point(xcomp(PP) * 128 + 5, zcomp(PP) * 8 - 3, ycomp(PP) * 128 + 1);
k3d/share/shaders/k3d_wood2.sl:49:  r2 = grainy * (1.3 - noise(PQ)) + (1 - grainy);
k3d/share/shaders/k3d_woodcut.sl:9:#define snoise(x) (2*noise(x)-1) 
k3d/share/shaders/k3d_woodcut.sl:26:point Psh;
k3d/share/shaders/k3d_woodcut.sl:52:n += snoise(Psh * ns) / ns;
