k3d/share/shaders/k3d_ambientlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_antialiasedchecks.sl:33:  float x, y;           /* Used to determine pattern */
k3d/share/shaders/k3d_antialiasedchecks.sl:35:  float Nfactor;        /* Multiplicative factor for AA due to normal */
k3d/share/shaders/k3d_antialiasedchecks.sl:40:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_antialiasedchecks.sl:44:  /* Figure out amount of fuzziness, taking normal into account */
k3d/share/shaders/k3d_antialiasedchecks.sl:45:  Nfactor = abs (Nf . I) / (length(Nf) * length(I));
k3d/share/shaders/k3d_antialiasedchecks.sl:46:  sfuzz = .5 * swidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:47:  tfuzz = .5 * twidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:59:      /* Gradually fade in the average color when we get close to the limit */
k3d/share/shaders/k3d_arealight.sl:26:   * toward local +z.
k3d/share/shaders/k3d_arealight.sl:28:  vector Nl = normalize(vector "shader"(0, 0, 1));
k3d/share/shaders/k3d_background.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_background.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_bluemarble.sl:1:/* I took wave's lead and renamed bluemarb to DPBlueMarble.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_bluemarble.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brick.sl:16: *     				   brick to brick?
k3d/share/shaders/k3d_brick.sl:55:  /* Determine how wide in s-t space one pixel projects to, relative
k3d/share/shaders/k3d_brick.sl:99:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brick.sl:104:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brick.sl:130:  /* Choose a brick color that varies from brick to brick */
k3d/share/shaders/k3d_brick2.sl:1:/* I took wave's lead and renamed brick to DPBrick.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brick2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brick3.sl:16: *     				   brick to brick?
k3d/share/shaders/k3d_brick3.sl:24: * 	This shader is very similar to (and based upon) brick shaders
k3d/share/shaders/k3d_brick3.sl:60:  float Nfactor;
k3d/share/shaders/k3d_brick3.sl:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_brick3.sl:101:  /* Choose a brick color that varies from brick to brick */
k3d/share/shaders/k3d_brickanti.sl:1:/* I took wave's lead and renamed brickant to DPBrickAnti.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brickanti.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickbump.sl:6: *   shader to the surface "brick" shader.  The parameters work exactly
k3d/share/shaders/k3d_brickbump.sl:53:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump.sl:58:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brickbump2.sl:1:/* I took wave's lead and renamed brickbum to DPBrickbump.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brickbump2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickbump3.sl:6: *   shader to the surface "brick" shader.  The parameters work exactly
k3d/share/shaders/k3d_brickbump3.sl:36:  They're meant to go together, but I like to use the brickbump
k3d/share/shaders/k3d_brickbump3.sl:95:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump3.sl:99:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brickperturb.sl:1:/* I took wave's lead and renamed brickper to DPBrickperturb.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brickperturb.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brushedmetal2.sl:2: *  ivan@SpamSucks_martian-tools.com
k3d/share/shaders/k3d_brushedmetal2.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_brushedmetal2.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_brushedmetal2.sl:8: *  stochasticly spreads the map, so it looks a little grainy.
k3d/share/shaders/k3d_brushedmetal2.sl:13: *  very similar to plastic.sl...
k3d/share/shaders/k3d_brushedmetal2.sl:26: *  twist		- allows you to twist the direction of anisotropy
k3d/share/shaders/k3d_brushedmetal2.sl:33:anisospecular (vector VA; float specspread; float specwidth)
k3d/share/shaders/k3d_brushedmetal2.sl:36:    extern vector I;
k3d/share/shaders/k3d_brushedmetal2.sl:41:    vector V = normalize(-I);
k3d/share/shaders/k3d_brushedmetal2.sl:48:        extern vector L;  
k3d/share/shaders/k3d_brushedmetal2.sl:54:            vector LN = normalize (L);
k3d/share/shaders/k3d_brushedmetal2.sl:55:	    vector H = normalize (V + LN);
k3d/share/shaders/k3d_brushedmetal2.sl:79:	vector D, V= normalize(-I);
k3d/share/shaders/k3d_brushedmetal2.sl:80:	vector Nf, Ntmp;
k3d/share/shaders/k3d_brushedmetal2.sl:85:	vector VA = rotate(normalize(dPdu), twist, zro, normalize(N));
k3d/share/shaders/k3d_brushedmetal3.sl:1:/* Renamed to LGbrushedmetal for RMR -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brushedmetal3.sl:10: *   V - unit viewing direction (from P toward the camera)
k3d/share/shaders/k3d_brushedmetal3.sl:15: *          tangent which is perpendicular to xdir.
k3d/share/shaders/k3d_brushedmetal3.sl:18:LocIllumWardAnisotropic (normal N;  vector V;
k3d/share/shaders/k3d_brushedmetal3.sl:19:                         vector xdir;  float xroughness, yroughness;)
k3d/share/shaders/k3d_brushedmetal3.sl:24:    vector X = xdir / xroughness;
k3d/share/shaders/k3d_brushedmetal3.sl:25:    vector Y = (N ^ xdir) / yroughness;
k3d/share/shaders/k3d_brushedmetal3.sl:31:        extern vector L;  extern color Cl;
k3d/share/shaders/k3d_brushedmetal3.sl:35:            vector LN = normalize (L);
k3d/share/shaders/k3d_brushedmetal3.sl:38:                vector H = normalize (V + LN);
k3d/share/shaders/k3d_brushedmetal3.sl:58:    vector xdir = normalize (dPdu);
k3d/share/shaders/k3d_bubbly.sl:2: *  ivan@SpamSucks_martian-tools.com
k3d/share/shaders/k3d_bubbly.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_bubbly.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_bubbly.sl:20: *            the bubbles. set this to zero for a perfect grid of bubbles.
k3d/share/shaders/k3d_bubbly.sl:41:  vector offset;
k3d/share/shaders/k3d_bubbly.sl:47:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_bubbly.sl:51:	offset = vector(a,b,c);
k3d/share/shaders/k3d_bubbly.sl:53:	nzcell = surrcell + ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_castucco.sl:7: *   but in CA it's truly ubiquitous.
k3d/share/shaders/k3d_castucco.sl:12: *   octaves - how many octaves of fBm to sum
k3d/share/shaders/k3d_castucco.sl:29:  point Pshad;			/* Point to be shaded, in shader space */
k3d/share/shaders/k3d_castucco.sl:31:  float disp;			/* Amount to displace */
k3d/share/shaders/k3d_causticlight.sl:5:	       point to = point "shader" (0,0,1);
k3d/share/shaders/k3d_causticlight.sl:17:    uniform vector axis = normalize(to-from);
k3d/share/shaders/k3d_celld.sl:9: * History
k3d/share/shaders/k3d_celld.sl:17:        float Kvoro = 0;        /* desc {amount to displace. } */
k3d/share/shaders/k3d_celld.sl:22:	float voro_jitter = 0;  /* desc { Amount to perturb the voroni 
k3d/share/shaders/k3d_celld.sl:24:	string PSpace = "shader";  /* desc {Space to transform P for shading calculations } */
k3d/share/shaders/k3d_ceramictiles.sl:7: *   projection, textureprojspace, mx -  define the projection used to
k3d/share/shaders/k3d_ceramictiles.sl:9: *   stilespacing, ttilespacing - tile-to-tile spacing (separate controls
k3d/share/shaders/k3d_ceramictiles.sl:12: *     expressed as a fraction of the tile-to-tile spacing.
k3d/share/shaders/k3d_ceramictiles.sl:23: *      edge variation, mottling, and speckles.  Setting any to zero will
k3d/share/shaders/k3d_ceramictiles.sl:27: *      cause more tile-to-tile variation).
k3d/share/shaders/k3d_ceramictiles.sl:49:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_ceramictiles.sl:50: * PRMan together.
k3d/share/shaders/k3d_ceramictiles.sl:87: * to a different color near the border of the tile (with a ragged edge
k3d/share/shaders/k3d_ceramictiles.sl:88: * to the color transition); (3) occasional dark specks.
k3d/share/shaders/k3d_ceramictiles.sl:146:  extern vector I;
k3d/share/shaders/k3d_ceramictiles.sl:151:  vector IN = normalize(I), V = -IN;
k3d/share/shaders/k3d_ceramictiles.sl:153:  vector R, T;
k3d/share/shaders/k3d_ceramictiles.sl:193:    ProjectTo2D (projection, P, textureprojspace, array_to_mx(mx),ss, tt, dss, dtt);
k3d/share/shaders/k3d_ceramictiles.sl:212:   * per-tile normal variation to break up reflections.
k3d/share/shaders/k3d_ceramictiles.sl:220:  Ntile += 0.05 * (vector cellnoise(tileindex + 5) - 0.5);
k3d/share/shaders/k3d_ceramictiles.sl:225:   * in within the tile.  Then use the tile index to vary its color
k3d/share/shaders/k3d_clamptoalpha.sl:2: * clamptoalpha.sl -- imager shader that forces Ci to be non-negative
k3d/share/shaders/k3d_clamptoalpha.sl:3: *    and with each component to greater than the alpha value of the
k3d/share/shaders/k3d_clamptoalpha.sl:8:k3d_clamptoalpha()
k3d/share/shaders/k3d_cloudplane.sl:1:/* I took wave's lead and renamed cloudplane to DPCloudplane.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_cloudplane.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_constant.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_contacshadow.sl:1:/* renamed shader to SIG2k_srf_contact to be consistent with RMR 
k3d/share/shaders/k3d_contacshadow.sl:8:** placed onto the surface which catches the contact shadow  
k3d/share/shaders/k3d_contacshadow.sl:16:    float samples = 10;         /* how many samples to take per Z lookup */  
k3d/share/shaders/k3d_contacshadow.sl:22:    /* get a matrix which transforms from current space to the  
k3d/share/shaders/k3d_contacshadow.sl:27:    /* get a matrix which transforms from current space to the  
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:43:	/* get the distance from the shadow camera to the closest
k3d/share/shaders/k3d_contacshadow.sl:47:	/* transform the point on the ground plane into the shadow
k3d/share/shaders/k3d_contacshadow.sl:48:	   camera space in order to get the distance from the shadow
k3d/share/shaders/k3d_contacshadow.sl:49:	   camera to the ground plane */
k3d/share/shaders/k3d_contacshadow.sl:52:	/* the difference between the two distances is used to calculate the  
k3d/share/shaders/k3d_contacshadow.sl:59:	/* convert into a color (white=shadow) */  
k3d/share/shaders/k3d_corktile.sl:1:/* Renamed to PQcorktile.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_corktile.sl:6: * Last Update: 16 October 2000
k3d/share/shaders/k3d_corktile.sl:13: *   (if tiles=1) the number of tiles fitted into the texture as s and t vary from 0 to 1
k3d/share/shaders/k3d_corktile.sl:18: *   the groove (2.5% either side = 5% in total = 0.05)
k3d/share/shaders/k3d_corktile.sl:19: * bumpheight - the total height for bump mapped bumps - irregularities on the surface plus
k3d/share/shaders/k3d_corktile.sl:47:		and used to select a color from a spline, combined with an overlay of the dark 
k3d/share/shaders/k3d_corktile.sl:101:			sw, tw, so, to;
k3d/share/shaders/k3d_corktile.sl:104:	float ingap = tile(s, t, tilewidth, tilewidth, swidth, twidth, gap, gap, sw, tw, so, to);
k3d/share/shaders/k3d_corktile.sl:110:	to = to > .5 ? 1 - to : to; 
k3d/share/shaders/k3d_corktile.sl:111:	adjust = (1 - min(smoothstep(gap * .3, gap * .7, so), smoothstep(gap * .3, gap * .7, to))) * 
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:5: * Similar tricks can be used to make cork, swiss-cheese, bread, etc.
k3d/share/shaders/k3d_craters.sl:17:   float swidth=.6;      /* Size of largest crater relative to s/t mapping */
k3d/share/shaders/k3d_craters.sl:18:   float pitfactor = .7; /* chance of crater occuring in a cell */
k3d/share/shaders/k3d_craters.sl:19:   float octaves=9;      /* number of scales used - use lower numbers for cartoony effects */
k3d/share/shaders/k3d_craters.sl:24:   /* you'll get artifacts if you go too much higher than 1 */
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:26:   float distortamp = 0.0005; /* Crater distortion.  You'll get artifacts if it goes too high. */
k3d/share/shaders/k3d_craters.sl:57:		if ( cellnoise(7*scell-9.5, 7*tcell+7.5) < pitfactor)
k3d/share/shaders/k3d_craters.sl:59:		  /* if ( fBm_default(xp) < pitfactor)  *//* I like this distribution better - pitf = -1 -> 1 */
k3d/share/shaders/k3d_craters.sl:87:	/* Optional Crater Distortion... */
k3d/share/shaders/k3d_craters.sl:88:	if (distortamp != 0)
k3d/share/shaders/k3d_craters.sl:90:	    rrad1 += fBm_default(P*sc)*asc*distortamp; /* add crater roughness */
k3d/share/shaders/k3d_craters.sl:91:	    rrad2 += fBm_default(P*sc)*asc*distortamp; 
k3d/share/shaders/k3d_crayon.sl:1:/* Renamed shader to PQCrayon for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_crayon.sl:13:	txtscale  - an overall scaling factor
k3d/share/shaders/k3d_crayon.sl:15:	micro - the size of the dots that make up a crayon stroke, relative to the size of
k3d/share/shaders/k3d_crayon.sl:17:	stretch - the length of the stroke relative to its width;
k3d/share/shaders/k3d_crayon.sl:18:	density0 - controls the amount of topcolor seen - measured as a proportion - 
k3d/share/shaders/k3d_crayon.sl:19:		this should vary between 0 (no topcolor) to 1, .3 would give 30% topcolor;
k3d/share/shaders/k3d_crayon.sl:22:		graduation of shading from top to bottom of the object
k3d/share/shaders/k3d_crayon.sl:23:	color topcolor, basecolor - the color of the crayon strokes and the color of the ground
k3d/share/shaders/k3d_crayon.sl:66:			color topcolor = 1;
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:89:	Csurf = mix(basecolor, topcolor, m);
k3d/share/shaders/k3d_crayontoon.sl:10: * choose wisely both colors to obtain the crayon look. My

k3d/share/shaders/k3d_crayontoon.sl:11: * idea was to make one color dependable of the other but is

k3d/share/shaders/k3d_crayontoon.sl:12: * better to let the user change this.

k3d/share/shaders/k3d_crayontoon.sl:14:surface k3d_crayontoon(color colorBase = color(1, .92, .44),

k3d/share/shaders/k3d_crayontoon.sl:20:  vector Nf = normalize(N);

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:21:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_cyclone.sl:24:  /* Rotate hit point to "cyclone space" */
k3d/share/shaders/k3d_cyclone.sl:38:      /* Subtract out "eye" of storm */
k3d/share/shaders/k3d_cyclone.sl:52:    {				/* if in "storm" area */
k3d/share/shaders/k3d_decalplastic.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_decalplastic.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_decalplastic.sl:47:	vector V = -normalize(I);
k3d/share/shaders/k3d_defaultsurface.sl:3: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_dented.sl:23: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_depthcue.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_distant_shadow.sl:5:	point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_distant_shadow.sl:12:		solar( to - from, 0.0 ) {
k3d/share/shaders/k3d_distantlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_distantlight.sl:12:		       point to = point "shader"(0, 0, 1);)
k3d/share/shaders/k3d_distantlight.sl:14:  solar(to - from, 0) Cl = intensity * lightcolor;
k3d/share/shaders/k3d_droop.sl:16:	droop = (t-.5)*2;	/* t in [0,1] goes to droop in [-1,1] */
k3d/share/shaders/k3d_dturb.sl:12:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_dturb.sl:19:  cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_dturb.sl:22:  for (f = 1; f < 0.5 * cutoff; f *= 2) 
k3d/share/shaders/k3d_dturb.sl:24:  fade = clamp(2 * (cutoff - f) / cutoff, 0, 1);
k3d/share/shaders/k3d_dturb.sl:27:  /* raise to power to create flat areas */
k3d/share/shaders/k3d_ember.sl:6: * to represent it's life. The desired effect is that of glowing particles that
k3d/share/shaders/k3d_ember.sl:25:	//size now represents the size of the sphere particle normalised into 0,1.
k3d/share/shaders/k3d_ember.sl:28:	vector V;
k3d/share/shaders/k3d_ember.sl:34:	V = vector -NI;
k3d/share/shaders/k3d_ember.sl:61:	// the colours for the fire effect from F. Kenton Musgrave's KMFlame.sl
k3d/share/shaders/k3d_emboss.sl:7: * 	map as sdixon() to define the lettering.
k3d/share/shaders/k3d_eyeball.sl:21: *   index - set between 0 and 1, lets you use this shader to generate
k3d/share/shaders/k3d_eyeball.sl:32: *      Dec 1993 - "eye" modified by lg to clean up a bit.
k3d/share/shaders/k3d_eyeball.sl:34: *      28 Jun 94 (lg) - revamped to add veins and iris mottling, renamed
k3d/share/shaders/k3d_eyeball.sl:36: *       7 Jan 95 (wave) - changed name to LGEyeBall for namespace reasons...
k3d/share/shaders/k3d_eyeball.sl:37: *       8 Jan 95 (wave) - changed Ciris line to fix bug Larry figured out and changed defaults
k3d/share/shaders/k3d_eyeball.sl:38: *       27 Feb 95 (wave) - changed PO line to fix bug Larry figured out to actually *use* index
k3d/share/shaders/k3d_eyeball.sl:71:  float twidth, cutoff;
k3d/share/shaders/k3d_eyeball.sl:90:   * of turbulence functions.  Some stretching is done to get it to look
k3d/share/shaders/k3d_fakesky.sl:4: * Shader a la const that slaps a fixed blue color up on the top half of a

k3d/share/shaders/k3d_fakesky.sl:5: * sphere, with color varying a bit by altitude, in an attempt to mimic the

k3d/share/shaders/k3d_fakesky.sl:9:surface k3d_fakesky(vector up = (0,0,1); color skycolor = (.5, .6, 1.)) {

k3d/share/shaders/k3d_filament.sl:3:/* Listing 16.25  Surface shader to make a cylinder look like a filament */
k3d/share/shaders/k3d_filament.sl:6: * filament(): map a filament-like spiral onto the surface of a cylinder.
k3d/share/shaders/k3d_fill.sl:2: *simple toon fill shader with shadows
k3d/share/shaders/k3d_fill.sl:3: *compare this to plastic.sl
k3d/share/shaders/k3d_fire.sl:13:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_fire.sl:24:  /* compress ss & offset both by factor of current frame */
k3d/share/shaders/k3d_fire.sl:32:  cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_fire.sl:35:  for (f = 1; f < 0.5 * cutoff; f *= 2) 
k3d/share/shaders/k3d_fire.sl:37:  fade = clamp(2 * (cutoff - f) / cutoff, 0, 1);
k3d/share/shaders/k3d_fire.sl:41:  /* index into color spline using turbulence */
k3d/share/shaders/k3d_flame.sl:8: *    distortion - 
k3d/share/shaders/k3d_flame.sl:10: *    flameheight, flameamplitude - scaling factors
k3d/share/shaders/k3d_flame.sl:13: *    None, but should be easy to add antialiasing simply by adaptively
k3d/share/shaders/k3d_flame.sl:17: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_flame.sl:18: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_flame.sl:22: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_flame.sl:27: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_flame.sl:36:surface k3d_flame(float distortion = 0;
k3d/share/shaders/k3d_flame.sl:52:      chaos += VLNoise(freq * PQ, distortion) / freq;
k3d/share/shaders/k3d_fog.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_fractal.sl:3: *    Conversion to Shading Language and minor modifications by Fredrik Brnnbacka.

k3d/share/shaders/k3d_fractal.sl:8: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

k3d/share/shaders/k3d_fractal.sl:28:                             /*This should give you a power function to control

k3d/share/shaders/k3d_fresnelplastic.sl:33:   /* desc { Index of Refraction.  Used to get Fresnel falloff.
k3d/share/shaders/k3d_fresnelplastic.sl:45:   /* cat Reflection desc {Percentage amount to blur map} */
k3d/share/shaders/k3d_fresnelplastic.sl:49:   /* cat Reflection desc {The size of the room to base the reflection
k3d/share/shaders/k3d_fresnelplastic.sl:54:   float MtorFlip = 0; /* cat ST type switch def 1
k3d/share/shaders/k3d_fresnelplastic.sl:55:			  desc {Swap S/T access to overcome Maya/MtoR
k3d/share/shaders/k3d_fresnelplastic.sl:64:    vector V = -normalize(I);
k3d/share/shaders/k3d_fresnelplastic.sl:65:    vector R = normalize (reflect (I, Nf));
k3d/share/shaders/k3d_fresnelplastic.sl:68:    if (MtorFlip == 1) {
k3d/share/shaders/k3d_funkyglass.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_funkyglass.sl:15:  vector V;
k3d/share/shaders/k3d_fur2.sl:1:/* Renamed to SIG2k_srf_fur to be consistent with the RMR 
k3d/share/shaders/k3d_fur2.sl:19:    vector LN, NN;
k3d/share/shaders/k3d_fur2.sl:23:    LN = normalize(vector(Lin));
k3d/share/shaders/k3d_fur2.sl:24:    NN = normalize(vector(Nin));
k3d/share/shaders/k3d_fur2.sl:65:	 varying vector clump_vect  = vector 0;
k3d/share/shaders/k3d_fur2.sl:70:    vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_fur2.sl:71:    vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_fur2.sl:74:    vector nL;
k3d/share/shaders/k3d_fur2.sl:76:    vector S = nSN^T;     /* Cross product of the tangent along the hair and surface normal */
k3d/share/shaders/k3d_fur2.sl:77:    vector N_hair = (T^S); /* N_hair is a normal for the hair oriented "away" from the surface */
k3d/share/shaders/k3d_fur2.sl:78:    vector norm_hair;
k3d/share/shaders/k3d_fur2.sl:93:    /* When the hair is exactly perpendicular to the surface, use the
k3d/share/shaders/k3d_fur2.sl:94:       surface normal, when the hair is exactly tangent to the
k3d/share/shaders/k3d_glass.sl:5: *   Makes semi-transparent glass, using ray tracing to calculate
k3d/share/shaders/k3d_gloop.sl:7: * Written as an explanation to the talk I gave at
k3d/share/shaders/k3d_gloop.sl:13: *        have to change your displacement bounds to fit
k3d/share/shaders/k3d_gloop.sl:16: * magnitude - how far to displace. probably fine set where it is.
k3d/share/shaders/k3d_gloop.sl:28:  vector overdist = .1;
k3d/share/shaders/k3d_gloop.sl:29:  vector stepsize = magnitude/freq;
k3d/share/shaders/k3d_gloop.sl:34:  vector dPduN = normalize(vtransform("object",dPdu));
k3d/share/shaders/k3d_gloop.sl:35:  vector dPdvN = normalize(vtransform("object",dPdv));
k3d/share/shaders/k3d_gloop.sl:49:  vector DdPdu = dPduN;
k3d/share/shaders/k3d_gloop.sl:50:  vector DdPdv = dPdvN;
k3d/share/shaders/k3d_gloop.sl:52:  vector step = DdPdu^DdPdv;
k3d/share/shaders/k3d_glow.sl:20:      // and skip pre-multiplication to get an "add" effect ...
k3d/share/shaders/k3d_gmarbtile_polish.sl:6: *   traced reflections) and cut into tiles (divided in xy texture space).
k3d/share/shaders/k3d_gmarbtile_polish.sl:46:  vector offset;
k3d/share/shaders/k3d_gmarbtile_polish.sl:47:  vector refldir;
k3d/share/shaders/k3d_gmarbtile_polish.sl:64:  offset = vector(7 * whichs, 15 * whicht, 0 /*-23*floor(zcomp(PQ))*/ );
k3d/share/shaders/k3d_gmarbtile_polish.sl:78:  PP += vector(35.2, -21.9, 6.25) + 0.5 * vfBm(PP, dPP, 6, 2, 0.5);
k3d/share/shaders/k3d_gmarbtile_polish.sl:94:	       filteredsnoise(2 * (PP + vector(-4.4, 8.34, 27.1)), 2 * dPP));
k3d/share/shaders/k3d_gmarbtile_polish.sl:101:  vector V = normalize(I);
k3d/share/shaders/k3d_gooch.sl:1:/* Renamed to MKgooch.sl for RMR -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_gooch.sl:4: *              non-photorealistic lighting model
k3d/share/shaders/k3d_gooch.sl:6: * DESCRIPTION   : This model is described in "A Non-Photorealistc
k3d/share/shaders/k3d_gooch.sl:7: *                 Lighting Model For Automatic Technical 
k3d/share/shaders/k3d_gooch.sl:12: *  Ka           : ambient factor
k3d/share/shaders/k3d_gooch.sl:13: *  Kd           : diffuse factor
k3d/share/shaders/k3d_gooch.sl:14: *  Ks           : specular factor
k3d/share/shaders/k3d_gooch.sl:15: *  alpha        : Gooch cool color factor
k3d/share/shaders/k3d_gooch.sl:16: *  beta         : Gooch warm color factor
k3d/share/shaders/k3d_gooch.sl:17: *  b            : used to construct the cool color
k3d/share/shaders/k3d_gooch.sl:18: *  y            : used to construct the warm color
k3d/share/shaders/k3d_gouge.sl:6: * gouge(): Use a texture map to displace a surface.
k3d/share/shaders/k3d_gouge.sl:14:	float	y = ycomp(transform("object",P));	/* convert to object space	 */
k3d/share/shaders/k3d_gouge.sl:18:    *  determines the size of the gouge. Multiply by the Km factor, then 
k3d/share/shaders/k3d_graphic_lines.sl:106:	vector Nf_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:107:	vector V_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:157:	vector Ndisp_highlight=normalize(N_highlight)*(0/max(spacescale_highlight,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:184:	vector Nf_paint;
k3d/share/shaders/k3d_graphic_lines.sl:185:	vector V_paint;
k3d/share/shaders/k3d_graphic_lines.sl:230:	vector Ndisp1=normalize(N_paint)*(0/max(spacescale1,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:256:	vector Nf_ink;
k3d/share/shaders/k3d_graphic_lines.sl:257:	vector V_ink;
k3d/share/shaders/k3d_graphic_lines.sl:302:	vector Ndisp2=normalize(N_ink)*(0/max(spacescale2,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:314:	glinespec(vector N, V; float roughness)
k3d/share/shaders/k3d_graphic_lines.sl:317:		vector H;
k3d/share/shaders/k3d_graphic_lines.sl:329:	vector normI, half;
k3d/share/shaders/k3d_grass_displace.sl:4: * I took used some of RManNotes function to assist in

k3d/share/shaders/k3d_greenmarble.sl:53:  PP += vector(35.2, -21.9, 6.25) + 0.5 * vfBm(PP, dPP, 6, 2, 0.5);
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:76:vector G1_V = -normalize(I);
k3d/share/shaders/k3d_grids_disp.sl:8: vector Ndisp = dir * (amp / max(spacescale,1e-6));
k3d/share/shaders/k3d_hair.sl:13:	vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_hair.sl:14:	vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_hair.sl:25:			/* We multipled by v to make it darker at the roots.  This assumes v=0 at the root, v=1 at the tip.  */
k3d/share/shaders/k3d_hdr_light.sl:1:/*Environment Light to project an environment map onto 3D geometry - designed

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:10:*post links back to the above address*or get in contact if you have any queries

k3d/share/shaders/k3d_hdr_light.sl:11:*or bug reports related to this shader 

k3d/share/shaders/k3d_hdr_light.sl:16:color hdrenv(string envname;vector R;float blur)

k3d/share/shaders/k3d_hdr_light.sl:20:	vector D = normalize(vtransform("world",R));

k3d/share/shaders/k3d_hdr_light.sl:42:	float exposure_compensation_stops = 0.0;

k3d/share/shaders/k3d_hdr_light.sl:58:vector axis = normalize(N);

k3d/share/shaders/k3d_hdr_light.sl:60:vector axis = normalize(vector "shader" (0,0,1));

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_light.sl:67:		vector R = normalize(vtransform(envspace,L));

k3d/share/shaders/k3d_hdr_light.sl:91:		float exposure = pow(2,exposure_compensation_stops);

k3d/share/shaders/k3d_hdr_surface.sl:1:/*Environment Light to project an environment map onto 3D geometry - designed

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:10:*post links back to the above address*or get in contact if you have any queries

k3d/share/shaders/k3d_hdr_surface.sl:11:*or bug reports related to this shader 

k3d/share/shaders/k3d_hdr_surface.sl:15:color hdrenv(string envname;vector R;float blur)

k3d/share/shaders/k3d_hdr_surface.sl:19:	vector D = normalize(vtransform("world",R));

k3d/share/shaders/k3d_hdr_surface.sl:41:	float exposure_compensation_stops = 0.0;

k3d/share/shaders/k3d_hdr_surface.sl:52:	vector R = normalize(vtransform(envspace,(origin - P)));

k3d/share/shaders/k3d_hdr_surface.sl:70:	float exposure = pow(2,exposure_compensation_stops);

k3d/share/shaders/k3d_hdri2.sl:12:    vector Lenv = vtransform (envspace, P-Ps);
k3d/share/shaders/k3d_hexatile_bump.sl:2:* FGHexaTile_bump.sl -- "Simple shader to do "Hexagon" displacement"
k3d/share/shaders/k3d_hexatile_bump.sl:63:	float toffset = (tpos - tt) * scale_tt;
k3d/share/shaders/k3d_hexatile_bump.sl:64:	float dist = soffset*soffset + toffset*toffset;
k3d/share/shaders/k3d_hexatile_bump.sl:97:ProjectTo2D (Projection,rotate(P,radians(Rotate),P1,P2),Space,array_to_mx(mx),SS,TT,Ds,Dt);
k3d/share/shaders/k3d_hexatile_bump.sl:122:Displace (normal dir; vector space; float amp; float truedisp;)
k3d/share/shaders/k3d_hexatile_bump.sl:126:	vector Ndisp = dir * (amp / max(spacescale,1e-6));
k3d/share/shaders/k3d_hexatile_bump.sl:131:vector VShd = vtransform("shader", vector(normalize(N)));
k3d/share/shaders/k3d_hextile.sl:6: *    hexagonal tiles, similar to that found as floor patterns in public
k3d/share/shaders/k3d_hextile.sl:9: *    color variation from tile to tile.  On top of that is some staining
k3d/share/shaders/k3d_hextile.sl:10: *    (presumably due to water or something), which darkens the tile or
k3d/share/shaders/k3d_hextile.sl:11: *    mortar underneath it.  Finally, there is scuffing due to people's
k3d/share/shaders/k3d_hextile.sl:21: *    tilevary - the color variance from tile to tile
k3d/share/shaders/k3d_hextile.sl:29: *    the floors in the public areas of the Washington DC subway system.
k3d/share/shaders/k3d_hextile.sl:74:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_imagelayerclouds.sl:19:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_incandplastic.sl:21:  vector NI;

k3d/share/shaders/k3d_indirect.sl:4: * is built into the renderer.
k3d/share/shaders/k3d_indirect.sl:6: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_indirect.sl:25:  vector axis = normalize(N);
k3d/share/shaders/k3d_leather.sl:9: *without hes shader i wouldnt be able to do mine so send him flowers :)

k3d/share/shaders/k3d_leather.sl:11: *	re-autor istarion@3dvf.net    web site http://istarion.3dvf.net

k3d/share/shaders/k3d_leather.sl:13: * 	old-autor jmerritt@warpax.com   :-)

k3d/share/shaders/k3d_leather.sl:45:	vector Nf, V, Rdir;

k3d/share/shaders/k3d_leather.sl:68:	 * goes to 1 or 0) are colored more and more green.

k3d/share/shaders/k3d_leather.sl:71:	 * "t" are lines of longditude (from pole to pole).

k3d/share/shaders/k3d_leather.sl:73:	 * start of 'greenness' toward the poles.

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:79:	#define BASE_GRC         0.4    /* shift factor for more red       */

k3d/share/shaders/k3d_leather.sl:112:	/*#define BLOTCH_SF          20   s-factor for blotches  */

k3d/share/shaders/k3d_leather.sl:113:	/*#define BLOTCH_TF          15   t-factor for blotches  */

k3d/share/shaders/k3d_leather.sl:132:	 * dottiness technique is stolen from LG's starfield 

k3d/share/shaders/k3d_leather.sl:136:	#define SPECK_CUTOFF    .45   /*Cutoff for 'tops' of specks*/ 

k3d/share/shaders/k3d_leather.sl:143:	 * attached, and where the wierd bit at the very bottom

k3d/share/shaders/k3d_leather.sl:153:	 * Combine what we have so far to set the surface

k3d/share/shaders/k3d_leather.sl:164:	 * Here we set the surface normal to fix up the specular

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:207:	 * Combine everything to get Ci, in the standard form.

k3d/share/shaders/k3d_lensflare.sl:6: *   These effects happen in real cameras when the camera points toward
k3d/share/shaders/k3d_lensflare.sl:15: *          this to 0 removes the bloom effect altogether.
k3d/share/shaders/k3d_lensflare.sl:32: * WARNING: lens flare is notorious as a sign of cheesy, cheap computer
k3d/share/shaders/k3d_lensflare.sl:63:  uniform vector corner = vector(transform("NDC", "camera", point(1, 1, 0)));
k3d/share/shaders/k3d_lensflare.sl:64:  uniform float halfangle = acos(normalize(corner).vector(0, 0, 1));
k3d/share/shaders/k3d_lensflare.sl:117:  point Pndc = (transform("NDC", P) - vector(.5, .5, 0)) * 2;
k3d/share/shaders/k3d_lensflare.sl:118:  Pndc *= vector(aspect, 1, 0);
k3d/share/shaders/k3d_lensflare.sl:121:  illuminance(P, vector "camera"(0, 0, 1), PI / 2)
k3d/share/shaders/k3d_lensflare.sl:123:    float atten = acos(zcomp(normalize(vector transform("camera", P + L))));
k3d/share/shaders/k3d_lensflare.sl:132:    point Plight = (transform("NDC", P + L) - vector(.5, .5, 0)) * 2;
k3d/share/shaders/k3d_lensflare.sl:133:    Plight *= vector(aspect, 1, 0);
k3d/share/shaders/k3d_lensflare.sl:135:    vector Lvec = Plight - Pndc;
k3d/share/shaders/k3d_lensflare.sl:178:    vector axis = normalize(vector Plight);
k3d/share/shaders/k3d_luna.sl:10: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_luna.sl:11: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_luna.sl:15: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_luna.sl:20: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_luna.sl:100:  /* get normalized vector "v" */
k3d/share/shaders/k3d_lunette.sl:10: *   hero objects that you might wish to show off.  The shader is a copy of a
k3d/share/shaders/k3d_lunette.sl:12: *   which I believe has something to do with spectacles in French.  Hence the
k3d/share/shaders/k3d_lunette.sl:21: *   colorBenhance - amount to enhance colorB's presence over colorA
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:31: * Author: written by Jonathan Merritt (jmerritt@warpax.com), 5th October 2002
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:63: *                   possibility to increase the amount of colorB present in
k3d/share/shaders/k3d_lunette.sl:80:	float noiseScale;	/* scale of the noise relative to the grid */
k3d/share/shaders/k3d_lunette.sl:85:	float colorBenhance;	/* amount to enhance color B */
k3d/share/shaders/k3d_lunette.sl:94:	 * pulsegrid varies smoothly between the two values to cope with
k3d/share/shaders/k3d_matte.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_metal.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_metal.sl:14:  vector V = -normalize(I);
k3d/share/shaders/k3d_mondometal.sl:7: * las partes blancas producen un efecto metalico y donde lo oscuro 

k3d/share/shaders/k3d_mondometal.sl:57:    extern vector I;

k3d/share/shaders/k3d_mondometal.sl:60:    vector V, D;

k3d/share/shaders/k3d_mondometal.sl:66:    /* apply STMatrix to texture coordinates **/

k3d/share/shaders/k3d_mondometal.sl:67:    ss = vector(s, t, 1) . vector(transform("shader", STMatrix0));

k3d/share/shaders/k3d_mondometal.sl:68:    tt = vector(s, t, 1) . vector(transform("shader", STMatrix1));

k3d/share/shaders/k3d_mondometal.sl:81:            /* need to un-premultiply the color in this case */

k3d/share/shaders/k3d_mondometal.sl:191:            P = PP; /* usually it's better to do displacments in displacement shader */

k3d/share/shaders/k3d_mondometal.sl:209:            D = vector(-zcomp(D), xcomp(D), ycomp(D));

k3d/share/shaders/k3d_mondometal.sl:229:    /* now add it all together */

k3d/share/shaders/k3d_mysky.sl:1:/* I took wave's lead and renamed starfield to KMPuffyclouds.sl -- tal@cs.caltech.edu */

k3d/share/shaders/k3d_mysky.sl:13: *    lighting into account.  If you wanted a lit surface that looked like

k3d/share/shaders/k3d_mysky.sl:15: *    easy to add the lighting.

k3d/share/shaders/k3d_mysky.sl:18: *    txtscale - overall scaling factor

k3d/share/shaders/k3d_mysky.sl:24: *    None, but should be easy to add antialiasing simply by adaptively

k3d/share/shaders/k3d_mysky.sl:28: *    C language version by F. Kenton Musgrave

k3d/share/shaders/k3d_mysky.sl:29: *    Translation to RenderMan Shading Language by Larry Gritz.

k3d/share/shaders/k3d_mysky.sl:33: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

k3d/share/shaders/k3d_mysky.sl:38: *    Apr 94 - translation to Shading Language by L. Gritz

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

k3d/share/shaders/k3d_noisysmoke.sl:40:  /* PRMan and BMRT used to have I reverse of each other, conflict in spec */
k3d/share/shaders/k3d_noisysmoke.sl:42:  vector incident = vtransform("shader", -I);
k3d/share/shaders/k3d_noisysmoke.sl:46:  vector incident = vtransform("shader", I);
k3d/share/shaders/k3d_noisysmoke.sl:49:  vector IN, WIN;
k3d/share/shaders/k3d_noisysmoke.sl:82:	    /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_noisysmoke.sl:94:	  /* Now we adjust Cv/Ov to account for dC and dO */
k3d/share/shaders/k3d_null.sl:2: * Null shader - does nothing to a surface
k3d/share/shaders/k3d_null.sl:4: * Note: we include dummy Ka and Kd arguments to appease the radiosity
k3d/share/shaders/k3d_oak.sl:5: *    wood grain.  The rings surround the z axis, so to position the
k3d/share/shaders/k3d_oak.sl:6: *    pattern, one should translate the shadingspace (which defaults to
k3d/share/shaders/k3d_oak.sl:12: *   shadingfreq - overall scaling factor for the pattern
k3d/share/shaders/k3d_oak.sl:26: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oak.sl:28: *   divotdepth - depth (in shader units) of the displacement due to
k3d/share/shaders/k3d_oakplank.sl:5: *    are projected onto the x-y plane, with the length aligned with
k3d/share/shaders/k3d_oakplank.sl:11: *   shadingfreq - overall scaling factor for the pattern
k3d/share/shaders/k3d_oakplank.sl:19: *   edgewidth - how close to the plank border does the wood start to curl?
k3d/share/shaders/k3d_oakplank.sl:20: *   varyhue, varysat, varylum - control plank-to-plank color variation
k3d/share/shaders/k3d_oakplank.sl:33: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oakplank.sl:35: *   divotdepth - depth (in shader units) of the displacement due to
k3d/share/shaders/k3d_oakplank.sl:56:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_oakplank.sl:57: * PRMan together.
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_orange.sl:19: * History:
k3d/share/shaders/k3d_orennayar.sl:13: *   tend to act more like retroreflectors than like isotropic scatterers.
k3d/share/shaders/k3d_orennayar.sl:29: *      model to the result.  It could easily be packaged up as a macro
k3d/share/shaders/k3d_orennayar.sl:32: *      you to the solution to the famous "flat full moon" problem.
k3d/share/shaders/k3d_outlet.sl:6: *   patch to make a wall more interesting.  The patch should be
k3d/share/shaders/k3d_outlet.sl:8: *   up close, but from across the room, it's a nice touch of detail.
k3d/share/shaders/k3d_paintedplastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_paintedplastic.sl:9: *    Apply a texture map to a plastic surface, indexing the texture
k3d/share/shaders/k3d_paintedplastic.sl:44:	vector V = -normalize(I);
k3d/share/shaders/k3d_parquet_plank.sl:12: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_plank.sl:20: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_plank.sl:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_plank.sl:147:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank.sl:150:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_parquet_plank2.sl:13: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_plank2.sl:21: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_plank2.sl:28: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_plank2.sl:32: *                Washington, DC 20052
k3d/share/shaders/k3d_parquet_plank2.sl:36: *    10 Feb 1995 - modified by wave to change the name
k3d/share/shaders/k3d_parquet_plank2.sl:76:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_plank2.sl:143:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank2.sl:146:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_parquet_tile.sl:14: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_tile.sl:22: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_tile.sl:29: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_tile.sl:33: *                Washington, DC 20052
k3d/share/shaders/k3d_parquet_tile.sl:37: *    10 Feb 1995 - modified by wave to change the name
k3d/share/shaders/k3d_parquet_tile.sl:45: *   - many thanks to Larry Gritz and wave for creating the original
k3d/share/shaders/k3d_parquet_tile.sl:53: *   - name from LGParquetPlank to DWParquetTile
k3d/share/shaders/k3d_parquet_tile.sl:54: *   - ringscale from 15 to 25
k3d/share/shaders/k3d_parquet_tile.sl:55: *   - grainscale from 60 to 55
k3d/share/shaders/k3d_parquet_tile.sl:56: *   - plankspertile from 4 to 1
k3d/share/shaders/k3d_parquet_tile.sl:57: *   - plankwidth from .05 to .2
k3d/share/shaders/k3d_parquet_tile.sl:91:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_tile.sl:158:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_tile.sl:161:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_planetclouds.sl:2: * planetclouds.sl - surface for a semi-opaque cloud layer to be put on
k3d/share/shaders/k3d_planetclouds.sl:6: *      When put on a sphere, sets the color & opacity of the sphere to
k3d/share/shaders/k3d_planetclouds.sl:15: *    distortionscale - controls the amount of texture distortion
k3d/share/shaders/k3d_planetclouds.sl:22: *   1. The way this shader is typically used is to have two concentric
k3d/share/shaders/k3d_planetclouds.sl:27: *      the view of the planet, but also shadow it.  The way to do this
k3d/share/shaders/k3d_planetclouds.sl:28: *      with the Blue Moon Renderer is to let the light cast shadows,
k3d/share/shaders/k3d_planetclouds.sl:37: *      to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_planetclouds.sl:42: *    Conversion to Shading Language and other minor changes by Larry Gritz.
k3d/share/shaders/k3d_planetclouds.sl:46: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_planetclouds.sl:51: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_planetclouds.sl:67:			 float distortionscale = 1; float omega = 0.7;
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:74:  float result;			/* Fractal sum is stored here */
k3d/share/shaders/k3d_planetclouds.sl:76:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_planetclouds.sl:79:  /* Add in "distortion" vector */
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:82:  PP = PP + Pdistortion;
k3d/share/shaders/k3d_plank.sl:10: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_plank.sl:18: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_plank.sl:57:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_plank.sl:133:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_plank.sl:136:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_plastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_plastic2.sl:1:/* I took wave's lead and renamed plastic to DPPlastic.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_plastic2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_pointlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_projectionmap_plastic.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_projectionmap_plastic.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_projectionmap_plastic.sl:35:	vector axis = vector(0, 0, 1);
k3d/share/shaders/k3d_projectionmap_plastic.sl:60:	vector V = -normalize(I);
k3d/share/shaders/k3d_puffyclouds.sl:1:/* I took wave's lead and renamed starfield to KMPuffyclouds.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_puffyclouds.sl:11: *    lighting into account.  If you wanted a lit surface that looked like
k3d/share/shaders/k3d_puffyclouds.sl:13: *    easy to add the lighting.
k3d/share/shaders/k3d_puffyclouds.sl:16: *    txtscale - overall scaling factor
k3d/share/shaders/k3d_puffyclouds.sl:22: *    None, but should be easy to add antialiasing simply by adaptively
k3d/share/shaders/k3d_puffyclouds.sl:26: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_puffyclouds.sl:27: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_puffyclouds.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_puffyclouds.sl:36: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_puffyclouds.sl:63:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_puffyclouds.sl:78:  /* Uncomment the next line if you want the surface to actually be lit */
k3d/share/shaders/k3d_redapple.sl:2: * Renamed to JMredapple.sl for RMR -- talrmr@SpamSucks_pacbell.net  7/18/99
k3d/share/shaders/k3d_redapple.sl:7: * Feel free to use this shader to create apples anywhere and
k3d/share/shaders/k3d_redapple.sl:11: * for specific geometry, but can very easily be adjusted to fit any
k3d/share/shaders/k3d_redapple.sl:12: * apple you care to lay it on. Apples are requred to have the "s"
k3d/share/shaders/k3d_redapple.sl:13: * texture parameter running equatorialy around them (like latitude
k3d/share/shaders/k3d_redapple.sl:14: * lines), and "t" running from pole to pole (like longditude). Apples
k3d/share/shaders/k3d_redapple.sl:15: * look best from the side, but work ok from the top, so long as you
k3d/share/shaders/k3d_redapple.sl:16: * don't mind the simple lerping I used to fade to green at the poles.
k3d/share/shaders/k3d_redapple.sl:21: * different size apples, make sure to change txtscale appropriately.
k3d/share/shaders/k3d_redapple.sl:23: * I think this shader is really cool. If you think so too, you can
k3d/share/shaders/k3d_redapple.sl:25: * pictures, job offers at Pixar, etc... to:  jmerritt@SpamSucks_warpax.com   :-)
k3d/share/shaders/k3d_redapple.sl:62:	vector Nf, V, Rdir;
k3d/share/shaders/k3d_redapple.sl:92:	 * goes to 1 or 0) are colored more and more green.
k3d/share/shaders/k3d_redapple.sl:95:	 * "t" are lines of longditude (from pole to pole).
k3d/share/shaders/k3d_redapple.sl:97:	 * start of 'greenness' toward the poles.
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:103:	#define BASE_GRC         0.4    /* shift factor for more red       */
k3d/share/shaders/k3d_redapple.sl:136:	#define BLOTCH_SF          20   /* s-factor for blotches  */
k3d/share/shaders/k3d_redapple.sl:137:	#define BLOTCH_TF          15   /* t-factor for blotches  */
k3d/share/shaders/k3d_redapple.sl:156:	 * dottiness technique is stolen from LG's starfield 
k3d/share/shaders/k3d_redapple.sl:159:	#define SPECK_NF        50    /* A noise scaling factor      */
k3d/share/shaders/k3d_redapple.sl:160:	#define SPECK_CUTOFF    .45   /* Cutoff for 'tops' of specks */
k3d/share/shaders/k3d_redapple.sl:167:	 * attached, and where the wierd bit at the very bottom
k3d/share/shaders/k3d_redapple.sl:177:	 * Combine what we have so far to set the surface
k3d/share/shaders/k3d_redapple.sl:188:	 * Here we set the surface normal to fix up the specular
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:230:	 * Combine everything to get Ci, in the standard form.
k3d/share/shaders/k3d_ridged_multifractal.sl:3: *    Conversion to Shading Language and minor modifications by Fredrik Brnnbacka.

k3d/share/shaders/k3d_ridged_multifractal.sl:8: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

k3d/share/shaders/k3d_ridged_multifractal.sl:28:                             /*This should give you a power function to control

k3d/share/shaders/k3d_roughmetal.sl:11: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_round.sl:7: * next to another patch at a right angle, the edge will be rounded.
k3d/share/shaders/k3d_round.sl:12:	float	 uu,	/* distance in u to the nearest "vertical" edge */
k3d/share/shaders/k3d_round.sl:13:		 vv,	/* distance in v to the nearest "horizontal" edge */
k3d/share/shaders/k3d_round.sl:14:		 lu,	/* "real" distance to the nearest "vertical" edge */
k3d/share/shaders/k3d_round.sl:15:		 lv;	/* "real" distance to the nearest "horizontal" edge */
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:47:	 *  sphere, if we are. We move `center' to the nearest inflection 
k3d/share/shaders/k3d_round.sl:55:		/* Move center perpendicular to the surface */
k3d/share/shaders/k3d_round.sl:58:                 * from 'center' to P */
k3d/share/shaders/k3d_rubber.sl:7: * adds in a little white dust to mimic the dust on a new eraser.
k3d/share/shaders/k3d_rubber.sl:16:		Ploc = transform("shader", P);  /* Move to shader space */
k3d/share/shaders/k3d_ruledpaper.sl:11: *   linestr - how strongly do the lines show up (0.0 to 1.0)
k3d/share/shaders/k3d_ruledpaper.sl:12: *   texturename - name of image to map onto paper (optional)
k3d/share/shaders/k3d_ruledpaper.sl:23: *   15 Nov 1997 - translated to Renderman SL in Linux
k3d/share/shaders/k3d_ruledpaper.sl:28: *   Don't worry about the paper anatomy settings. I moved them to
k3d/share/shaders/k3d_ruledpaper.sl:36: *   The paper shader works for A4 pieces of paper, so remeber to make your
k3d/share/shaders/k3d_ruledpaper.sl:48:	/* Paper anatomy settings */
k3d/share/shaders/k3d_ruledpaper.sl:59:	// How far into the page do the lines start
k3d/share/shaders/k3d_ruledpaper.sl:61:	// Top and bottom margins for lines
k3d/share/shaders/k3d_ruledpaper.sl:121:		// Find bounding boxes first to speed up calcs
k3d/share/shaders/k3d_ruledpaper.sl:122:		// I wrote this handy macro to automate it!
k3d/share/shaders/k3d_rustymetal.sl:14: *   txtscale - overall scaling factor of the rust pattern.
k3d/share/shaders/k3d_rustymetal.sl:19: *   The fractal sum used to determine the rust pattern chooses a number of
k3d/share/shaders/k3d_rustymetal.sl:20: *   octaves to sum based on the shader sampling rate.  This helps to keep
k3d/share/shaders/k3d_rustymetal.sl:24: *         The George Washington University
k3d/share/shaders/k3d_rustymetal.sl:34:/* Signed noise varies from -1 to 1 (like Perlin uses) */
k3d/share/shaders/k3d_rustymetal.sl:52:  point Nf, V;                 /* normal and view vector used for shading */
k3d/share/shaders/k3d_rustymetal.sl:56:  float alimit;                /* Limit sum to do simple antialiasing */
k3d/share/shaders/k3d_rustymetal.sl:71:  /* If it's rusty, also add a high frequency bumpiness to the normal */
k3d/share/shaders/k3d_rustymetal.sl:81:  /* If we have any rust, calculate the color of the rust, taking into
k3d/share/shaders/k3d_saturn.sl:9: *      When put on a sphere, sets the color to look like relatively
k3d/share/shaders/k3d_saturn.sl:16: *    dist_scale - scaling for multifractal distortion
k3d/share/shaders/k3d_saturn.sl:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_saturn.sl:35: *    23 May 1995 - Changed name from terran.sl to TLSaturn.sl and
k3d/share/shaders/k3d_saturn.sl:36: *        Did major hacking to make it a Saturn-like shader by Tal Lancaster 
k3d/share/shaders/k3d_saturn.sl:63:  /* make climate symmetric about equator */
k3d/share/shaders/k3d_saturnring.sl:2: * TLRing.sl -- surface for a saturn like ring to be used on a disk
k3d/share/shaders/k3d_saturnring.sl:10: *	cutoff - what point to start rings (radius of transparency)
k3d/share/shaders/k3d_saturnring.sl:16: *  otherwise then they will neeb to be changed.
k3d/share/shaders/k3d_saturnring.sl:21: * History:
k3d/share/shaders/k3d_saturnring.sl:40:	cutoff = 0.55, ringrad = 1.0, opacity = 0.5;)
k3d/share/shaders/k3d_saturnring.sl:43:	point Nf;       /* Forward facing Normalized vector of incident light */
k3d/share/shaders/k3d_saturnring.sl:63:	if (val < cutoff * ringrad) {
k3d/share/shaders/k3d_saturnring.sl:64:		/* Creating an inner disk that is transparent to place the planet */
k3d/share/shaders/k3d_scartissue.sl:2: *  an unremarkable recursive noise to make scartissue
k3d/share/shaders/k3d_scartissue.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_scartissue.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_scartissue.sl:22:	vector V = normalize(-I);
k3d/share/shaders/k3d_screen.sl:7: *   parallel to lines of s and t.  You can adjust the Ka, Kd, Ks, etc.
k3d/share/shaders/k3d_screen.sl:8: *   to change the material appearance.
k3d/share/shaders/k3d_screen.sl:18: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_screen_aa.sl:6: *   parallel to lines of s and t.  You can adjust the Ka, Kd, Ks, etc.
k3d/share/shaders/k3d_screen_aa.sl:7: *   to change the material appearance.  This texture antialiases pretty
k3d/share/shaders/k3d_screen_aa.sl:20: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_screen_aa.sl:34:  normal Nf;			/* Forward facing Normal vector */
k3d/share/shaders/k3d_screen_aa.sl:35:  vector IN;			/* normalized incident vector */
k3d/share/shaders/k3d_screen_aa.sl:44:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_sdixon.sl:23:	/* This shader uses a single-channel texture map to apply a 
k3d/share/shaders/k3d_sdixon.sl:24:	 *   metallic-green ink to a matte-yellow background. */
k3d/share/shaders/k3d_sdixon.sl:29: 	/* Use ink to mix yellow and green */
k3d/share/shaders/k3d_sdixon.sl:32:	/* Compute the output color. Notice that as ink goes from zero to
k3d/share/shaders/k3d_sdixon.sl:33:	   one, the diffuse component goes to zero and the specular 
k3d/share/shaders/k3d_sdixon.sl:35:	   from a matte surface to a metallic one as ink is added. */
k3d/share/shaders/k3d_shadowdistant_rim.sl:8:    point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:17:    solar( to - from, 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:10: *  roughness -  Contols the specular reflection
k3d/share/shaders/k3d_shifteddrtile.sl:11: *	fuzz -       Amount to blur edge
k3d/share/shaders/k3d_shifteddrtile.sl:21: *      (remember to set the right space)
k3d/share/shaders/k3d_shifteddrtile.sl:22: *  Also, it would be better to set the width of the ring rather than
k3d/share/shaders/k3d_shifteddrtile.sl:24: *  Another thing that might be useful is to add a parameter to 
k3d/share/shaders/k3d_shifteddrtile.sl:25: *      choose which row to do first.
k3d/share/shaders/k3d_shifteddrtile.sl:30: * History:
k3d/share/shaders/k3d_shifteddrtile.sl:52:	uniform float fuzz = .025;          /* amount to blur edge */
k3d/share/shaders/k3d_shifteddrtile.sl:63:	float mix_opacity; /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shifteddrtile.sl:65:	float row, col;    /* used to determine which tile we are in */
k3d/share/shaders/k3d_shiftedmoontile.sl:9: *  roughness - Contols the specular reflection
k3d/share/shaders/k3d_shiftedmoontile.sl:10: *	fuzz -      Amount to blur edge
k3d/share/shaders/k3d_shiftedmoontile.sl:19: *	Really should move center to the paramter list so both centers 
k3d/share/shaders/k3d_shiftedmoontile.sl:25: * History:
k3d/share/shaders/k3d_shiftedmoontile.sl:60:	float mix_opacity;       /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shiftedmoontile.sl:69:	                         /*  to the paramter list */
k3d/share/shaders/k3d_shiny.sl:27:/* Get rid of rayserver.h if you don't want PRMan and BMRT to work together */
k3d/share/shaders/k3d_shinymetal.sl:5: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_shinymetal.sl:15:  vector V, D;
k3d/share/shaders/k3d_show_st.sl:3:/* Listing 16.11  Shader mapping texture-space coordinates to colors */
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:11: * appearence generall similar to that of skin. 
k3d/share/shaders/k3d_skin1.sl:13: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_skin1.sl:17: * Kd = the amount of uniform diffusion applyied to the skin
k3d/share/shaders/k3d_skin1.sl:23: * of blemishes on the skin. Use to give skin a little variation.
k3d/share/shaders/k3d_skin1.sl:24: * blemishmap = Use a grayscale map to control where the belmishes will be more visible
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:35: * NOTE- you must copy the entire subsurface skin function to your
k3d/share/shaders/k3d_skin1.sl:40: * Modification history:
k3d/share/shaders/k3d_skin1.sl:61:LocIllumWardAnisotropic (normal N;  vector V;
k3d/share/shaders/k3d_skin1.sl:62:                         vector xdir;  float xroughness, yroughness;)
k3d/share/shaders/k3d_skin1.sl:67:    vector X = xdir / xroughness;
k3d/share/shaders/k3d_skin1.sl:68:    vector Y = (N ^ xdir) / yroughness;
k3d/share/shaders/k3d_skin1.sl:74:  extern vector L;  extern color Cl; 
k3d/share/shaders/k3d_skin1.sl:78:      vector LN = normalize (L);
k3d/share/shaders/k3d_skin1.sl:81:    vector H = normalize (V + LN);
k3d/share/shaders/k3d_skin1.sl:95: * appearence generall similar to that of skin.  Based on phenomenological 
k3d/share/shaders/k3d_skin1.sl:97: * "Reflection from layered surfaces due to subsurface scattering", 
k3d/share/shaders/k3d_skin1.sl:100:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin1.sl:102:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin1.sl:103:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin1.sl:105:float phase(vector v1, v2; float g) {
k3d/share/shaders/k3d_skin1.sl:110:/* Compute a the single-scattering approximation to scattering from
k3d/share/shaders/k3d_skin1.sl:115:   equation to approximate overall scattering.
k3d/share/shaders/k3d_skin1.sl:117:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin1.sl:125:vector efresnel(vector II; normal NN; float eta; output float Kr, Kt;) {
k3d/share/shaders/k3d_skin1.sl:126:    vector R, T;
k3d/share/shaders/k3d_skin1.sl:137:color subsurfaceSkin(vector Vf; normal Nn; color skinColor, sheenColor;
k3d/share/shaders/k3d_skin1.sl:143:  vector T = efresnel(-Vf, Nn, eta, Kr, Kt);
k3d/share/shaders/k3d_skin1.sl:146:      vector Ln = normalize(L);
k3d/share/shaders/k3d_skin1.sl:148:      vector H = normalize(Ln + Vf);
k3d/share/shaders/k3d_skin1.sl:153:      vector T2 = efresnel(-Ln, Nn, eta, Kr2, Kt2);
k3d/share/shaders/k3d_skin1.sl:182:  varying vector xdir = dPdu;
k3d/share/shaders/k3d_skin1.sl:197:  vector Vf = -normalize(I);
k3d/share/shaders/k3d_skin1.sl:209:  /*--- layer 1 - add pores to the skin*/
k3d/share/shaders/k3d_skin1.sl:223:  /* layer 1 .- apply a subsurface scattered BRDF to the surface.
k3d/share/shaders/k3d_skin1.sl:235:  /* layer 2 - create small skin blemishes over the skin. Use a map to control
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:277:  vector anisoDir = xdir;
k3d/share/shaders/k3d_skin2.sl:10: * appearence generall similar to that of skin.  Based on phenomenological 
k3d/share/shaders/k3d_skin2.sl:12: * "Reflection from layered surfaces due to subsurface scattering", 
k3d/share/shaders/k3d_skin2.sl:19:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin2.sl:21:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin2.sl:22:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin2.sl:24:float phase(vector v1, v2; float g) {
k3d/share/shaders/k3d_skin2.sl:29:/* Compute a the single-scattering approximation to scattering from
k3d/share/shaders/k3d_skin2.sl:34:   equation to approximate overall scattering.
k3d/share/shaders/k3d_skin2.sl:36:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin2.sl:45:vector efresnel(vector II; normal NN; float eta; output float Kr, Kt;) {
k3d/share/shaders/k3d_skin2.sl:46:    vector R, T;
k3d/share/shaders/k3d_skin2.sl:57:   refraction of the incoming ray (typically ~1 for air) to the index
k3d/share/shaders/k3d_skin2.sl:63:color subsurfaceSkin(vector Vf; normal Nn; color skinColor, sheenColor;
k3d/share/shaders/k3d_skin2.sl:69:	vector T = efresnel(-Vf, Nn, eta, Kr, Kt);
k3d/share/shaders/k3d_skin2.sl:72:	    vector Ln = normalize(L);
k3d/share/shaders/k3d_skin2.sl:74:	    vector H = normalize(Ln + Vf);
k3d/share/shaders/k3d_skin2.sl:79:	    vector T2 = efresnel(-Ln, Nn, eta, Kr2, Kt2);
k3d/share/shaders/k3d_skin2.sl:95:	vector Vf = -normalize(I);
k3d/share/shaders/k3d_skymetal.sl:6: *   didn't support vector the vector type.  
k3d/share/shaders/k3d_skymetal.sl:9: * TLSkymetal shader.  Actually, I never could get this oneto work right,
k3d/share/shaders/k3d_skymetal.sl:19:             /* actually should be vector and vtransform if using 3.5 or 
k3d/share/shaders/k3d_slateroof.sl:1:/* Renamed to PQslateroof.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroof.sl:4:	slateroof.sl - a surface shader working with slateroofd.sl, to
k3d/share/shaders/k3d_slateroof.sl:5:	introduce a slate color onto roof tiles, making the last row of tiles
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:17: 	ramp: the amount of a tile used for the initial rise to the maximum height
k3d/share/shaders/k3d_slateroof.sl:24: 	txtscale: a scaling factor for the slate coloration - the larger txtscale the
k3d/share/shaders/k3d_slateroof.sl:26: 	factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroof.sl:27: 		the same sfreq, tfreq change the value of factor to ensure they have a 
k3d/share/shaders/k3d_slateroof.sl:37:	Nb. This shader would normally be used with the slateroofd shader to
k3d/share/shaders/k3d_slateroof.sl:41:	message passing, so to produce the test image the code has been
k3d/share/shaders/k3d_slateroof.sl:56:							factor = 22.238,
k3d/share/shaders/k3d_slateroof.sl:62:                 twidth = 1 / tfreq, 		/* ditto for the t direction */
k3d/share/shaders/k3d_slateroof.sl:65:   float scoord = s, tcoord = 1 - t; 		/* re map the t coord so that the coving is at the top */
k3d/share/shaders/k3d_slateroof.sl:68:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
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: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:133:	 * storing the new tile in stile, ttile and new offset
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:158:					/* set parameters to overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:1:/* Renamed to PQslateroofd.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroofd.sl:4:  slateroofd.sl - a displacement shader to produce tiles on a roof
k3d/share/shaders/k3d_slateroofd.sl:13: 		ramp: the amount of a tile used for the initial rise to the maximum height
k3d/share/shaders/k3d_slateroofd.sl:18: 		factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroofd.sl:19: 			the same sfreq, tfreq change the value of factor to ensure they have a 
k3d/share/shaders/k3d_slateroofd.sl:30:		the surface displacement according to a simple formula: a sharp ridge at
k3d/share/shaders/k3d_slateroofd.sl:31:		the bottom of the tile, gaps to either side and the whole tile gently
k3d/share/shaders/k3d_slateroofd.sl:32:		sloping towards zero at the top of the tile. It then looks to see if the
k3d/share/shaders/k3d_slateroofd.sl:36:		careful to ensure there are no sudden jumps in displacement.
k3d/share/shaders/k3d_slateroofd.sl:50:							factor = 22.838)
k3d/share/shaders/k3d_slateroofd.sl:55:                 twidth = 1 / tfreq, 		/* ditto for the t direction */
k3d/share/shaders/k3d_slateroofd.sl:57:   float scoord = s, tcoord = 1 - t; 		/* re map the t coord so that the coving is at the top */
k3d/share/shaders/k3d_slateroofd.sl:60:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
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:71:   vector Ndisp = Nf * (1 / max(spacescale,1e-6));
k3d/share/shaders/k3d_slateroofd.sl:100:   		add = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroofd.sl:103: 		/* the very bottom row cannot expand */
k3d/share/shaders/k3d_slateroofd.sl:107:	/* the above adjusts t_offset so that it runs from 0 to 1 within the expanded tile */
k3d/share/shaders/k3d_slateroofd.sl:125:		storing the new tile in stile, ttile and new offset
k3d/share/shaders/k3d_slateroofd.sl:145:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroofd.sl:149:					/* set parameters to overlapping tile */
k3d/share/shaders/k3d_slideprojector.sl:1:light k3d_slideprojector(float intensity = 2000;
k3d/share/shaders/k3d_slideprojector.sl:4:			 point to = point(0, 0, 1);
k3d/share/shaders/k3d_slideprojector.sl:9:  uniform vector Z = normalize(to - from);
k3d/share/shaders/k3d_slideprojector.sl:10:  uniform vector X = Z ^ up;
k3d/share/shaders/k3d_slideprojector.sl:11:  uniform vector Y = normalize(X ^ Z);
k3d/share/shaders/k3d_smoke.sl:6: *    used to find scattering and extinction.
k3d/share/shaders/k3d_smoke.sl:10: *          to block light from behind it.
k3d/share/shaders/k3d_smoke.sl:12: *          toward the viewer.
k3d/share/shaders/k3d_smoke.sl:18: *          to the smoke.
k3d/share/shaders/k3d_smoke.sl:19: *   scatter - when non-1, can be used to give wavelength-dependent
k3d/share/shaders/k3d_smoke.sl:90:  vector IN = normalize(vtransform("shader", I));
k3d/share/shaders/k3d_smoke.sl:91:  vector WIN = vtransform("shader", "current", IN);
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:3: * random() as it made my animation look to funky -- tal 9/4/96
k3d/share/shaders/k3d_smoke2.sl:7: *    used to integrate the GADD to find scattering and extinction.
k3d/share/shaders/k3d_smoke2.sl:15: *          into account.
k3d/share/shaders/k3d_smoke2.sl:18: *   lightscale - multiplier for light scattered toward viewer in volume
k3d/share/shaders/k3d_smoke2.sl:19: *   debug - if nonzero, copious output will be sent to stderr.
k3d/share/shaders/k3d_smoke2.sl:23: * History:
k3d/share/shaders/k3d_smoke2.sl:24: *   9/4/96 tal -- took out random call and renamed to TLSmoke
k3d/share/shaders/k3d_smoke2.sl:30: * * Moved scripts & shaders to the share directory
k3d/share/shaders/k3d_smoke2.sl:127:	  /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_smoke2.sl:137:	  /* Now we adjust Cv/Ov to account for dC and dO */
k3d/share/shaders/k3d_softboxes.sl:55:/*   - smoothly varying from 0 to 1 in between				***/
k3d/share/shaders/k3d_softboxes.sl:87:    varying vector	reflVect;
k3d/share/shaders/k3d_softboxes.sl:112:    varying vector Vlight = vtransform (boxCoords, reflVect);
k3d/share/shaders/k3d_softboxes.sl:308:    vector rv = reflect(I,Nf);
k3d/share/shaders/k3d_softboxes.sl:410:		varying vector Rs = normalize (vtransform (theEnvSpace, normalize(-L)));
k3d/share/shaders/k3d_softboxes.sl:414:		    varying float pl = vector(PShd).vector(PShd);
k3d/share/shaders/k3d_softboxes.sl:415:		    varying float pdotv = -vector(PShd).Rs;
k3d/share/shaders/k3d_softboxes.sl:416:		    Rs = vector( PShd + (pdotv + sqrt (abs (1 - pl + ((pdotv)*(pdotv)))))*Rs );
k3d/share/shaders/k3d_softboxes.sl:419:		    Rs = vector (-zcomp (Rs), xcomp (Rs), ycomp (Rs));
k3d/share/shaders/k3d_softboxes.sl:455:	    varying vector Ln = normalize(L);
k3d/share/shaders/k3d_softboxes.sl:456:	    varying vector Nn = normalize(N);
k3d/share/shaders/k3d_softboxes.sl:457:	    varying vector In = normalize(I);
k3d/share/shaders/k3d_spacecloud.sl:2: * TLSpaceCloud.sl - perform turbulence function to add more dimension to
k3d/share/shaders/k3d_spacecloud.sl:3: *    texture-map and try to make it not so obvious that it is a texture-map.
k3d/share/shaders/k3d_spacecloud.sl:7: *   Uses a pulse function to tapper off the edges of the texture
k3d/share/shaders/k3d_spacecloud.sl:13: *   fuzz -- amount to blur the edges of the pulse
k3d/share/shaders/k3d_spacecloud.sl:15: *   maxAdjust -- amount that can be added to the value
k3d/share/shaders/k3d_spacecloud.sl:28: *  tal 2/23/97 -- Originally tried using fBm to create turbulence.  But
k3d/share/shaders/k3d_spotlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_spotlight.sl:12:		    point to = point "shader"(0, 0, 1);
k3d/share/shaders/k3d_spotlight.sl:18:  uniform vector A = normalize(to - from);
k3d/share/shaders/k3d_square_ridges.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_square_ridges.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_square_ridges.sl:66:	vector Nn = normalize(N);
k3d/share/shaders/k3d_srfdeformation.sl:1:/* renamed shader to SIG2k_srf_deformation to be consistent with RMR 
k3d/share/shaders/k3d_srfdeformation.sl:9:   projects a texture through the camera onto the Pref
k3d/share/shaders/k3d_srfdeformation.sl:10:   object and deforms it to the P position
k3d/share/shaders/k3d_srfdeformation.sl:12:   additionally, calculates the changes to shading on the surface 
k3d/share/shaders/k3d_srfdeformation.sl:13:   measured by the change in diffuse lighting from the Pref to P.
k3d/share/shaders/k3d_srfdeformation.sl:18:   by Rob Bredow and Scott Stokdyk 
k3d/share/shaders/k3d_srfdeformation.sl:23:	       vector L; 
k3d/share/shaders/k3d_srfdeformation.sl:27:    vector Ln;
k3d/share/shaders/k3d_srfdeformation.sl:48:    string texname = "";        /* Texture to project */
k3d/share/shaders/k3d_srfdeformation.sl:82:    /* These lighting loops can be enhanced to calculate
k3d/share/shaders/k3d_star.sl:1:/* I took wave's lead and renamed star to DPStar.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_star.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_starfield.sl:4:	We partition space into a 1x1x1 grid, rendering one solid spherical "star" per cell.
k3d/share/shaders/k3d_starfield.sl:21:	// Calculate the distance to the nearest star ...
k3d/share/shaders/k3d_stones.sl:3: * RudyCstones.sl
k3d/share/shaders/k3d_stones.sl:11: * Shader that creates a surface covered with stones of different sizes,
k3d/share/shaders/k3d_stones.sl:12: * trying to replicate the shader usr for the ground in "A BUGS LIFE".
k3d/share/shaders/k3d_stones.sl:13: * Uses st to create the rocks and "shader" space to create the grunge.
k3d/share/shaders/k3d_stones.sl:15: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_stones.sl:17: *  hader as is, or under "shader info" if you do any minor modifications to
k3d/share/shaders/k3d_stones.sl:24: * minfreq & maxfreq = limits to the rock loop excecution
k3d/share/shaders/k3d_stones.sl:26: * stonecolor, groundcolor = this is obvious, isn't it?
k3d/share/shaders/k3d_stones.sl:31: * modified 10/17/02 Changed algorithms arround to make it render a little faster.
k3d/share/shaders/k3d_stones.sl:58: * separately to add some variation.  Hue, saturation, and lightness
k3d/share/shaders/k3d_stones.sl:61: * Original by Larry Gritz. Modified to "hsv" by Rudy Cortes
k3d/share/shaders/k3d_stones.sl:65:    /* Convert to "hsv" space, it's more convenient */
k3d/share/shaders/k3d_stones.sl:73:    /* Clamp hsl and transform back to rgb space */
k3d/share/shaders/k3d_stones.sl:82:surface k3d_stones (
k3d/share/shaders/k3d_stones.sl:91:   color  stonecolor = color(.7,.6,.4);
k3d/share/shaders/k3d_stones.sl:105: vector V;
k3d/share/shaders/k3d_stones.sl:125:   /*tile index to be use in vary each*/
k3d/share/shaders/k3d_stones.sl:126:   float stoneindex = stile + 13 * ttile;
k3d/share/shaders/k3d_stones.sl:145:   layer_color = varyEach(stonecolor, stoneindex,varyhue,varysat,varylum);
k3d/share/shaders/k3d_stones.sl:162:       float cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_stones.sl:165:        for (f = 1; f < 0.5 * cutoff; f *= 2)
k3d/share/shaders/k3d_stones.sl:167:        float fade = clamp(2 * (cutoff - f) / cutoff, 0, 1);
k3d/share/shaders/k3d_stones.sl:183: /*compute normals and vectors for shading*/
k3d/share/shaders/k3d_strata.sl:9: *    txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_strata.sl:13: *    octaves - number of octaves of noise to sum for the turbulence
k3d/share/shaders/k3d_strata.sl:20: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_strata.sl:21: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_strata.sl:25: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_strata.sl:30: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_stucco.sl:5: *   Displacees a surface to make it look like stucco.
k3d/share/shaders/k3d_superplank.sl:15: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_superplank.sl:16: *   Km - overall scaling factor for bumpiness.
k3d/share/shaders/k3d_superplank.sl:26: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_superplank.sl:61:			float txtscale = 1;	/* Overall scaling factor */
k3d/share/shaders/k3d_superplank.sl:62:			float Km = 1;	/* Overall bumpiness factor */
k3d/share/shaders/k3d_superplank.sl:73:			float plankvary = 0.8;	/* Wood color variation plank-to-plank */
k3d/share/shaders/k3d_superplank.sl:104:  vector IN;			/* normalized I vector */
k3d/share/shaders/k3d_superplank.sl:107:  vector R, T_dummy;		/* Refl (and tummy transmit) from fresnel */
k3d/share/shaders/k3d_superplank.sl:112:  vector V;
k3d/share/shaders/k3d_superplank.sl:132:  /* How much current space corresponds to a unit of s or t?
k3d/share/shaders/k3d_superplank.sl:133:   * We will use this later to help scale the displacement, this making
k3d/share/shaders/k3d_superplank.sl:134:   * the bumps scale relative to the overall pattern, rather than being
k3d/share/shaders/k3d_superplank.sl:135:   * strictly tied to the scale of the object.
k3d/share/shaders/k3d_superplank.sl:184:   * antialiasing by trying to box filter the edges of the grooves.
k3d/share/shaders/k3d_superplank.sl:210:   * the rings are too small to see.
k3d/share/shaders/k3d_superplank.sl:249:  /* Add some plank-to-plank variation in overall color */
k3d/share/shaders/k3d_superplank.sl:252:  /* Darken the wood according to the ring and grain patterns */
k3d/share/shaders/k3d_superplank.sl:254:  /* Combine the rings, grain, plank variation into one surface color */
k3d/share/shaders/k3d_superplank.sl:263:   * We do some bump mapping to make the grooves and grain depressed,
k3d/share/shaders/k3d_superplank.sl:264:   * and add some general lumpiness to the varnish layer.
k3d/share/shaders/k3d_superplank.sl:276:      /* Depressions due to grain & rings */
k3d/share/shaders/k3d_superplank.sl:289:   * The wood itself behaves like plastic, the varnish overtop reflects
k3d/share/shaders/k3d_superplank.sl:306:	vector H = normalize(normalize(L) + V);
k3d/share/shaders/k3d_superpplastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_superpplastic.sl:9: *    Apply a texture map to a plastic surface, indexing the texture
k3d/share/shaders/k3d_superpplastic.sl:18:/* Modified to support filter type and aize, amount of image blur, nuber samples
k3d/share/shaders/k3d_superpplastic.sl:19:along S and T, fidelty and number of samples by Giueppe Zompatori joesunny@tiscalinet.it*/
k3d/share/shaders/k3d_superpplastic.sl:28:  vector V;
k3d/share/shaders/k3d_supertexmap.sl:6: *    to a plastic surface.  This is essentially a replacement for the
k3d/share/shaders/k3d_supertexmap.sl:18: *    mx - 16 floats giving an 3-D affine transformation to apply to the
k3d/share/shaders/k3d_supertexmap.sl:79:			    array_to_mx(Csmx), Csblur);
k3d/share/shaders/k3d_supertexmap.sl:85:			    array_to_mx(Osmx), Osblur);
k3d/share/shaders/k3d_supertexmap.sl:91:			    array_to_mx(Ksmx), Ksblur);
k3d/share/shaders/k3d_supertexmap.sl:98:			      array_to_mx(dispmx), dispblur);
k3d/share/shaders/k3d_supertoon.sl:6: * hace en tres puntos definidos por lim2, lim3 y lim4. A falta de antialiasing

k3d/share/shaders/k3d_supertoon.sl:30:surface k3d_supertoon(float Kd = 1,

k3d/share/shaders/k3d_supertoon.sl:40:    vector NI = normalize(I);

k3d/share/shaders/k3d_terran.sl:3:           mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran.sl:48:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran.sl:49:   * Note: this section of code must be identical to "terranbump" if you
k3d/share/shaders/k3d_terran.sl:50:   *       expect these two shaders to work well together.
k3d/share/shaders/k3d_terran.sl:67:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terran.sl:69:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran.sl:99:  /* make climate symmetric about equator -- use the "v" parameter */
k3d/share/shaders/k3d_terran.sl:115:       * Ken originally had a huge table.  I was too lazy to type it in,
k3d/share/shaders/k3d_terran.sl:116:       * so I used a scanned photo of the real Earth to select some
k3d/share/shaders/k3d_terran.sl:164:	  /* Adjust color of water to darken deeper seas */
k3d/share/shaders/k3d_terran2.sl:1:/* Was terran.sl -- changed color spline to not use white 
k3d/share/shaders/k3d_terran2.sl:9: *      When put on a sphere, sets the color to look like relatively
k3d/share/shaders/k3d_terran2.sl:13: *   which is necessary to get the best effect.  If you do this, it is
k3d/share/shaders/k3d_terran2.sl:14: *   important that the parameters common to "terran" and "terranbump"
k3d/share/shaders/k3d_terran2.sl:15: *   both be set to the same values.  Otherwise you get bumpy mountains
k3d/share/shaders/k3d_terran2.sl:25: *    dist_scale - scaling for multifractal distortion
k3d/share/shaders/k3d_terran2.sl:28: *    mtn_scale - scaling factor for mountains
k3d/share/shaders/k3d_terran2.sl:31: *    ice_caps - latitude at which ice caps tend to form on the oceans
k3d/share/shaders/k3d_terran2.sl:32: *    depth_scale, depth_max - scaling factor and max depth of oceans
k3d/share/shaders/k3d_terran2.sl:34: *               mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran2.sl:40: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_terran2.sl:47: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_terran2.sl:55: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_terran2.sl:111:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran2.sl:112:   * Note: this section of code must be identical to "terranbump" if you
k3d/share/shaders/k3d_terran2.sl:113:   *       expect these two shaders to work well together.
k3d/share/shaders/k3d_terran2.sl:125:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terran2.sl:127:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran2.sl:154:  /* make climate symmetric about equator -- use the "v" parameter */
k3d/share/shaders/k3d_terran2.sl:168:       * Ken originally had a huge table.  I was too lazy to type it in,
k3d/share/shaders/k3d_terran2.sl:169:       * so I used a scanned photo of the real Earth to select some
k3d/share/shaders/k3d_terran2.sl:219:	  /* Adjust color of water to darken deeper seas */
k3d/share/shaders/k3d_terranbump.sl:45:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terranbump.sl:47:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_texblender.sl:14:    extern vector I;
k3d/share/shaders/k3d_texblender.sl:21:myEnvironment (point P;  vector R;  float Kr, blur;  DECLARE_ENVPARAMS;)
k3d/share/shaders/k3d_texblender.sl:97:	transp=transform(space,P)*vector (scalex, scaley, scalez);
k3d/share/shaders/k3d_texblender.sl:159:    vector V ,D,badN,corr,dispDir,ndir;
k3d/share/shaders/k3d_threads.sl:3:/* Listing 16.24  Displacement shader providing light-bulb threads to cylinder */
k3d/share/shaders/k3d_threads.sl:21:	/* Damp the displacement to 0 at each end */
k3d/share/shaders/k3d_tooledsteel.sl:1:/*  tooledsteel.sl written 9/99 by Ivan DeWolf
k3d/share/shaders/k3d_tooledsteel.sl:2: *  ivan@SpamSucks_martian-tools.com
k3d/share/shaders/k3d_tooledsteel.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_tooledsteel.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_tooledsteel.sl:7: *  F1 from bubbly.sl adapted to happen in parameter space.
k3d/share/shaders/k3d_tooledsteel.sl:8: *  A vector is computed from the gradient of the distance function,
k3d/share/shaders/k3d_tooledsteel.sl:9: *  and then used as the vector of anisotropy. works best on parametric
k3d/share/shaders/k3d_tooledsteel.sl:12: *  thanks to Jos Stam whose animated cube motivated this thing.
k3d/share/shaders/k3d_tooledsteel.sl:18: *          		  the swirls. set this to zero for a perfect grid.
k3d/share/shaders/k3d_tooledsteel.sl:29: *  twist		- allows you to twist the direction of anisotropy
k3d/share/shaders/k3d_tooledsteel.sl:35:vector
k3d/share/shaders/k3d_tooledsteel.sl:39:  extern vector dPdu;
k3d/share/shaders/k3d_tooledsteel.sl:40:  extern vector dPdv;
k3d/share/shaders/k3d_tooledsteel.sl:43:  vector udir = vector(1,0,0);
k3d/share/shaders/k3d_tooledsteel.sl:44:  vector vdir = vector(0,1,0);
k3d/share/shaders/k3d_tooledsteel.sl:55:  vector offset, nzoff, out;
k3d/share/shaders/k3d_tooledsteel.sl:66:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_tooledsteel.sl:69:	offset = vector(a,b,c);
k3d/share/shaders/k3d_tooledsteel.sl:71:	nzoff = ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_tooledsteel.sl:89:anisospecular (vector VA; float specspread; float specwidth)
k3d/share/shaders/k3d_tooledsteel.sl:92:    extern vector I;
k3d/share/shaders/k3d_tooledsteel.sl:97:    vector V = normalize(-I);
k3d/share/shaders/k3d_tooledsteel.sl:104:        extern vector L;  
k3d/share/shaders/k3d_tooledsteel.sl:110:            vector LN = normalize (L);
k3d/share/shaders/k3d_tooledsteel.sl:111:	    vector H = normalize (V + LN);
k3d/share/shaders/k3d_tooledsteel.sl:122:k3d_tooledsteel(
k3d/share/shaders/k3d_tooledsteel.sl:136:        vector VA = getvec(mult,Nzscale);
k3d/share/shaders/k3d_tooledsteel.sl:139:	vector D, V= normalize(-I);
k3d/share/shaders/k3d_tooledsteel.sl:140:	vector Nf, Ntmp;
k3d/share/shaders/k3d_toonmap.sl:3:surface k3d_toonmap (
k3d/share/shaders/k3d_toonmap.sl:108:toonspec(vector N, V; float roughness)
k3d/share/shaders/k3d_toonmap.sl:111:vector H;
k3d/share/shaders/k3d_toonmap.sl:123:vector normI, half;
k3d/share/shaders/k3d_toonmap.sl:125:color toon_color, layer_color;
k3d/share/shaders/k3d_toonmap.sl:126:color toon_opac, layer_opac;
k3d/share/shaders/k3d_toonmap.sl:132:toon_color = color (0, 0, 0);
k3d/share/shaders/k3d_toonmap.sl:133:toon_opac = Os;
k3d/share/shaders/k3d_toonmap.sl:135:/* toon paint (layer 1) */
k3d/share/shaders/k3d_toonmap.sl:146:spec = toonspec(Nf, -normalize(I), roughness);
k3d/share/shaders/k3d_toonmap.sl:152:toon_color = blend(toon_color, layer_color, layer_opac);
k3d/share/shaders/k3d_toonmap.sl:153:toon_opac = union(toon_opac, layer_opac);
k3d/share/shaders/k3d_toonmap.sl:155:/* toon ink (layer 3) */
k3d/share/shaders/k3d_toonmap.sl:167:toon_color = blend(toon_color, layer_color, layer_opac);
k3d/share/shaders/k3d_toonmap.sl:168:toon_opac = union(toon_opac, layer_opac);
k3d/share/shaders/k3d_toonmap.sl:170:color toonOi = toon_opac;
k3d/share/shaders/k3d_toonmap.sl:171:color toonCi = toon_opac * toon_color;
k3d/share/shaders/k3d_toonmap.sl:175:Ci = toonCi;
k3d/share/shaders/k3d_toonmap.sl:176:Oi = toon_opac;
k3d/share/shaders/k3d_translucency.sl:11:* Description:  It's possible to use one different color and
k3d/share/shaders/k3d_translucency.sl:62:	vector H;
k3d/share/shaders/k3d_translucency.sl:63:	vector ln;
k3d/share/shaders/k3d_translucency.sl:69:	/*XMB vector assignment*/
k3d/share/shaders/k3d_translucency.sl:72:	vector V = -normalize(I);
k3d/share/shaders/k3d_uberlight.sl:6: *   Cinematography" (in Journal of Graphics Tools, vol. 2, no. 1: 1-20).
k3d/share/shaders/k3d_uberlight.sl:8: * Rather than explicitly pass "from" and "to" points to indicate the
k3d/share/shaders/k3d_uberlight.sl:11: * toward the +z axis (also in shader space).  Thus, to position and
k3d/share/shaders/k3d_uberlight.sl:29: *   cuton, cutoff - define the depth range (z range from the origin, in
k3d/share/shaders/k3d_uberlight.sl:33: *       for the cuton and cutoff.  The transitions will be smooth.
k3d/share/shaders/k3d_uberlight.sl:39: *       sometimes hard to use).
k3d/share/shaders/k3d_uberlight.sl:41: *       equal to intensity*lightcolor.  In other words, the intensity
k3d/share/shaders/k3d_uberlight.sl:43: *   maxintensity - to prevent the light from becoming unboundedly
k3d/share/shaders/k3d_uberlight.sl:45: *       smoothly clamped to this maximum value.
k3d/share/shaders/k3d_uberlight.sl:46: *   parallelrays - when 0 (the default), the light appears to emanate
k3d/share/shaders/k3d_uberlight.sl:54: *   shearx, sheary - define the amount of shear applied to the light
k3d/share/shaders/k3d_uberlight.sl:62: *       respectively.  Values of 0 will make a sharp cutoff, larger
k3d/share/shaders/k3d_uberlight.sl:63: *       values (up to 1) will make the edge softer.
k3d/share/shaders/k3d_uberlight.sl:69: *   beamdistribution - controls intensity falloff due to angle.
k3d/share/shaders/k3d_uberlight.sl:72: *       corresponds to a cosine falloff.  For a BMRT area light, the
k3d/share/shaders/k3d_uberlight.sl:73: *       cosine falloff happens automatically, so 0 is the right physical
k3d/share/shaders/k3d_uberlight.sl:74: *       value to use.  In either case, you may use larger values to
k3d/share/shaders/k3d_uberlight.sl:81: *       by that color, much like a slide projector.  If you want to
k3d/share/shaders/k3d_uberlight.sl:83: *       black-and-white, but store it as an RGB texture.  For
k3d/share/shaders/k3d_uberlight.sl:89: *       means not to use noise.  Larger values increase the blotchiness
k3d/share/shaders/k3d_uberlight.sl:93: *       for example, you can use the noise to simulate the
k3d/share/shaders/k3d_uberlight.sl:103: *   shadowblur - how soft to make the shadow edge, expressed as a
k3d/share/shaders/k3d_uberlight.sl:105: *   shadowbias - the amount of shadow bias to add to the lookup.
k3d/share/shaders/k3d_uberlight.sl:106: *   shadownsamps - the number of samples to use.
k3d/share/shaders/k3d_uberlight.sl:109: *   raytraceshadow - if nonzero, cast rays to see if we are in shadow.
k3d/share/shaders/k3d_uberlight.sl:110: *       The default is zero, i.e., not to try raytracing.
k3d/share/shaders/k3d_uberlight.sl:111: *   nshadowrays - The number of rays to trace to determine shadowing.
k3d/share/shaders/k3d_uberlight.sl:112: *   shadowcheat - add this offset to the light source position.  This
k3d/share/shaders/k3d_uberlight.sl:113: *       allows you to cause the shadows to emanate as if the light
k3d/share/shaders/k3d_uberlight.sl:120: * superellipse.  The blocker is defined to lie on the x-y plane of
k3d/share/shaders/k3d_uberlight.sl:121: * its own coordinate system (which obviously needs to be defined in
k3d/share/shaders/k3d_uberlight.sl:136: *       blocker) don't actually have to block light.  In fact, in
k3d/share/shaders/k3d_uberlight.sl:138: *       of the light to "shadowcolor".  If this color is set to
k3d/share/shaders/k3d_uberlight.sl:140: *       to, say (.25,.25,.25), it will make the shadowed regions lose
k3d/share/shaders/k3d_uberlight.sl:142: *       use is if you are simulating sunlight: set the lightcolor to
k3d/share/shaders/k3d_uberlight.sl:144: *       somewhat bluish.  Another effect of shadows is to set the
k3d/share/shaders/k3d_uberlight.sl:149: *   nonspecular - when set to 1, this light does not create
k3d/share/shaders/k3d_uberlight.sl:153: *       meant to be fill lights, rather than key lights.
k3d/share/shaders/k3d_uberlight.sl:159: *       to account for it yourself.  The PRMan user manual explains how
k3d/share/shaders/k3d_uberlight.sl:160: *       to do this.
k3d/share/shaders/k3d_uberlight.sl:161: *   __nondiffuse - the analog to nonspecular; if this flag is set to
k3d/share/shaders/k3d_uberlight.sl:166: *       respect to the surface shader, as described above for
k3d/share/shaders/k3d_uberlight.sl:170: *       parameter set to 1 (the default).  In other words, if you use
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:178: * all of these.  It is left as an exercise for the reader to make such
k3d/share/shaders/k3d_uberlight.sl:179: * extensions to the shader.
k3d/share/shaders/k3d_uberlight.sl:185: * (co-chaired by Tony Apodaca and Larry Gritz).  Feel free to use and
k3d/share/shaders/k3d_uberlight.sl:189: * This shader was tested using Pixar's PhotoRealistic RenderMan 3.7
k3d/share/shaders/k3d_uberlight.sl:191: * tried to avoid Shading Language constructs which wouldn't work on
k3d/share/shaders/k3d_uberlight.sl:193: * "vector" type and I often declare variables where they are used,
k3d/share/shaders/k3d_uberlight.sl:196: * substitute "point" for all occurrances of "vector", and move the
k3d/share/shaders/k3d_uberlight.sl:197: * variable declarations to the top of the shader.
k3d/share/shaders/k3d_uberlight.sl:209:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_uberlight.sl:210: * PRMan together.
k3d/share/shaders/k3d_uberlight.sl:224: *   - smoothly varying from 0 to 1 in between
k3d/share/shaders/k3d_uberlight.sl:274: *   - attenuation factor based on the falloff and shaping
k3d/share/shaders/k3d_uberlight.sl:278:		       vector axis;	/* light axis */
k3d/share/shaders/k3d_uberlight.sl:289:  /* Examine the z depth of PL to apply the (possibly smooth) cuton and
k3d/share/shaders/k3d_uberlight.sl:290:   * cutoff.
k3d/share/shaders/k3d_uberlight.sl:322:  /* Clip to superellipse */
k3d/share/shaders/k3d_uberlight.sl:324:    atten *= pow(zcomp(normalize(vector PL)), beamdistribution);
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:339: * blocker.  Return 0 if the light is totally blocked, 1 if it totally
k3d/share/shaders/k3d_uberlight.sl:356:      vector Vlight = (Pb1 - Pb2);
k3d/share/shaders/k3d_uberlight.sl:374:		     float cuton = 0.01, cutoff = 1.0e6, nearedge =
k3d/share/shaders/k3d_uberlight.sl:383:		     /* Cookie or slide to control light cross-sectional color */
k3d/share/shaders/k3d_uberlight.sl:387:		     vector noiseoffset = 0;
k3d/share/shaders/k3d_uberlight.sl:395:		     vector shadowcheat = vector "shader"(0, 0, 0);
k3d/share/shaders/k3d_uberlight.sl:408:   * space and aimed in the +z direction.  So to move or orient the
k3d/share/shaders/k3d_uberlight.sl:410:   * to instancing the light shader.  But that sure simplifies the
k3d/share/shaders/k3d_uberlight.sl:422:  vector axis = normalize(N);
k3d/share/shaders/k3d_uberlight.sl:426:  vector axis = normalize(vector "shader"(0, 0, 1));
k3d/share/shaders/k3d_uberlight.sl:458:      ShapeLightVolume(PL, lighttype, axis, cuton, cutoff, nearedge, faredge,
k3d/share/shaders/k3d_uberlight.sl:495:	  shadoworigin = point "shader"(xcomp(PL), ycomp(PL), cuton);
k3d/share/shaders/k3d_urbermap.sl:41:vector V, D;
k3d/share/shaders/k3d_urbermap.sl:47:ss = vector(s, t, 1) . vector(transform("shader", STMatrix0));
k3d/share/shaders/k3d_urbermap.sl:48:tt = vector(s, t, 1) . vector(transform("shader", STMatrix1));
k3d/share/shaders/k3d_urbermap.sl:189:D = vector(-zcomp(D), xcomp(D), ycomp(D));
k3d/share/shaders/k3d_veinedmarble.sl:19: * AUTHOR: Larry Gritz, the George Washington University
k3d/share/shaders/k3d_velvet.sl:1:/* Renamed to SHW_velvet.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_velvet.sl:9: *   - A retroreflective lobe (back toward the light source)
k3d/share/shaders/k3d_velvet.sl:22: * AUTHOR: written by Stephen H. Westin, Ford Motor Company
k3d/share/shaders/k3d_velvet.sl:27: *			"backscatter" parameter to control it; added
k3d/share/shaders/k3d_velvet.sl:28: *			"edginess" parameter to control horizon scatter;
k3d/share/shaders/k3d_velvet.sl:46:  normal Nf;                     /* Normalized normal vector */
k3d/share/shaders/k3d_velvet.sl:47:  vector V;                      /* Normalized eye vector */
k3d/share/shaders/k3d_velvet.sl:48:  vector H;                      /* Bisector vector for Phong/Blinn */
k3d/share/shaders/k3d_velvet.sl:49:  vector Ln;                     /* Normalized vector to light */
k3d/share/shaders/k3d_venus.sl:6: *      When put on a sphere, sets the color to look like a densely
k3d/share/shaders/k3d_venus.sl:9: *   the surface to simulate the clouds.  Strong Coriolis forces are
k3d/share/shaders/k3d_venus.sl:10: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus.sl:17: *    twist - controls the twisting of the clouds due to Coriolis forces.
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:25: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_venus.sl:30: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus.sl:35: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus.sl:41: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus.sl:66:  float value;			/* Fractal sum is stored here */
k3d/share/shaders/k3d_venus.sl:68:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_venus2.sl:1:/* I renamed the shader to MBVenus.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_venus2.sl:8: *      When put on a sphere, sets the color to look like a densely
k3d/share/shaders/k3d_venus2.sl:11: *   the surface to simulate the clouds.  Strong Coriolis forces are
k3d/share/shaders/k3d_venus2.sl:12: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus2.sl:19: *    twist - controls the twisting of the clouds due to Coriolis forces.
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:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus2.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus2.sl:37: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus2.sl:68:  float value;              /* Fractal sum is stored here */
k3d/share/shaders/k3d_venus2.sl:70:  /* Transform to texture coordinates and map to nit sphere */
k3d/share/shaders/k3d_volcube.sl:12:                         normal to volume normal.
k3d/share/shaders/k3d_volcube.sl:15:   RunShadowPass       - set to 1 if running a shadow pass.
k3d/share/shaders/k3d_volcube.sl:33:    extern vector I;
k3d/share/shaders/k3d_volcube.sl:35:    vector Rd,Ro;
k3d/share/shaders/k3d_volcube.sl:37:    vector Pn;
k3d/share/shaders/k3d_volcube.sl:40:    vector IN;
k3d/share/shaders/k3d_volcube.sl:149:		  vector V;
k3d/share/shaders/k3d_volcube.sl:154:    extern vector L;
k3d/share/shaders/k3d_volcube.sl:202:    vector V  = normalize(-I);
k3d/share/shaders/k3d_volcube.sl:209:    vector step_obj     = (outPoint_obj-inPoint_obj)/numOfSteps;
k3d/share/shaders/k3d_volcube.sl:210:    vector step_cur     = vtransform("object","current",step_obj);
k3d/share/shaders/k3d_volcube.sl:294:	/* jump to the next sample point */
k3d/share/shaders/k3d_wallpaper.sl:1:/* I took wave's lead and renamed wallpaper to DPWallpaper.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_wallpaper.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_wallpaper_2stripe.sl:6: *   are shaded in s-t space, and the stripes are parallel to lines of
k3d/share/shaders/k3d_warningstripes.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_warningstripes.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_warningstripes.sl:54:	vector Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_water.sl:3: * This was originally shiny.sl, but I change it to make it transparant.  The interesting part colors that

k3d/share/shaders/k3d_water.sl:6: * note : This is very similar to shiny.sl with a slight modification to give it a

k3d/share/shaders/k3d_water.sl:13: *   Makes a smoothly polished metal, using ray tracing to calculate

k3d/share/shaders/k3d_water.sl:20: *    samples - set to higher than 1 for oversampling of blur

k3d/share/shaders/k3d_water.sl:46:    normal Nf;               /* Forward facing normal vector */

k3d/share/shaders/k3d_water.sl:47:    vector IN;               /* normalized incident vector */

k3d/share/shaders/k3d_water.sl:48:    vector uoffset, voffset; /* Offsets for blur */

k3d/share/shaders/k3d_water.sl:51:    vector R, Rdir;          /* Direction to cast the ray */

k3d/share/shaders/k3d_water.sl:64:	    /* Construct orthogonal components to Rdir */

k3d/share/shaders/k3d_water.sl:65:	    uoffset = blur * normalize (vector (zcomp(Rdir) - ycomp(Rdir),

k3d/share/shaders/k3d_water.sl:71:		    /* Add a random offset to the smooth reflection vector */

k3d/share/shaders/k3d_watercolor.sl:3: *	provides a built-in Fresnel quantity calculator, which provides

k3d/share/shaders/k3d_watercolor.sl:5: *	vector, and index of refraction. The shader for the air-to-water 

k3d/share/shaders/k3d_watercolor.sl:20:	vector nI = normalize(I);

k3d/share/shaders/k3d_watercolor.sl:21:	vector nN = normalize(Ng);

k3d/share/shaders/k3d_watercolor.sl:37:	vector dPE = P-E;

k3d/share/shaders/k3d_waterlight.sl:5:A cheap trick to simulate underwater caustics - best used for deep-sea effects
k3d/share/shaders/k3d_waterlight.sl:22:	solar(vector "shader" (0, -1, 0), 0)
k3d/share/shaders/k3d_windowlight.sl:12: *   up, in - vectors which define the orientation of the window
k3d/share/shaders/k3d_windowlight.sl:13: *   from, to - the direction that the light falls
k3d/share/shaders/k3d_windowlight.sl:32:		      point to = point "shader"(0, 1, 0);
k3d/share/shaders/k3d_windowlight.sl:34:		      vector up = vector "shader"(0, 0, 1);
k3d/share/shaders/k3d_windowlight.sl:35:		      vector in = vector "shader"(0, 1, 0);
k3d/share/shaders/k3d_windowlight.sl:42:  uniform vector inv, right, upv;
k3d/share/shaders/k3d_windowlight.sl:43:  uniform vector path;
k3d/share/shaders/k3d_windowlight.sl:48:  path = normalize(from - to);
k3d/share/shaders/k3d_windowlight.sl:54:  /* d is the depth "into" the room perpendicular to the pane plane */
k3d/share/shaders/k3d_wood2.sl:9: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_wood2.sl:29:  point PP, PQ;			/* shading space point to be computed */
k3d/share/shaders/k3d_woodcut.sl:25:vector Nf, V; 
k3d/share/shaders/k3d_woodcut.sl:88: vector Ndisp = normalize(N) * (0 / max(spacescale,1e-6));
