k3d/share/shaders/k3d_altitude_fog.sl:7:	point PP = transform("world", P);
k3d/share/shaders/k3d_altitude_fog.sl:8:	float fog = 1 - smoothstep(min_height, max_height, ycomp(PP));
k3d/share/shaders/k3d_ambientlight.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_ambientlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_ambientlight.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_ambientlight.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_antialiasedchecks.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_antialiasedchecks.sl:8: * PARAMETERS:
k3d/share/shaders/k3d_arealight.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_arealight.sl:8: * PARAMETERS
k3d/share/shaders/k3d_arealight.sl:19:  illuminate(P, N, 1.5707963 /* PI/2 */ )
k3d/share/shaders/k3d_arealight.sl:24:  /* This is so if we use one of these lights in PRMan, it will
k3d/share/shaders/k3d_arealight.sl:29:  illuminate(point "shader"(0, 0, 0), Nl, PI / 2)
k3d/share/shaders/k3d_background.sl:7:// modify it under the terms of the GNU General Public
k3d/share/shaders/k3d_background.sl:13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
k3d/share/shaders/k3d_background.sl:14:// General Public License for more details.
k3d/share/shaders/k3d_background.sl:16:// You should have received a copy of the GNU General Public
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_bluemarble.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_bluemarble.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_bluemarble.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_bluemarble.sl:16:#define PALE_BLUE        color (0.25, 0.25, 0.35)
k3d/share/shaders/k3d_bluemarble.sl:27:        PALE_BLUE, PALE_BLUE,
k3d/share/shaders/k3d_bluemarble.sl:29:        PALE_BLUE, PALE_BLUE,
k3d/share/shaders/k3d_bluemarble.sl:32:        PALE_BLUE, DARKER_BLUE);
k3d/share/shaders/k3d_bluemarble.sl:46:    point PP;
k3d/share/shaders/k3d_bluemarble.sl:50:    PP = transform("shader", P) * texturescale;
k3d/share/shaders/k3d_bluemarble.sl:54:        marble += snoise(PP * f)/f;
k3d/share/shaders/k3d_bluescreen.sl:5: * PARAMETERS:
k3d/share/shaders/k3d_bluescreen.sl:20:       lenx = xcomp(P)/ resolution[0];
k3d/share/shaders/k3d_bluescreen.sl:21:       leny = ycomp(P)/ resolution[1];
k3d/share/shaders/k3d_brick.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_brick.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_brick.sl:14: *    brickcolor, mortarcolor	Pretty obvious (default is red bricks)
k3d/share/shaders/k3d_brick.sl:125:  P += disp * normalize(N);
k3d/share/shaders/k3d_brick.sl:126:  N = calculatenormal(P);
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_brick2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brick2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brick2.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_brick3.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_brick3.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_brick3.sl:14: *    brickcolor, mortarcolor	Pretty obvious (default is red bricks)
k3d/share/shaders/k3d_brick3.sl:25: *	by Darwyn Peachey.
k3d/share/shaders/k3d_brick3.sl:56:  point PP2, Nf;
k3d/share/shaders/k3d_brick3.sl:69:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brick3.sl:70:  scoord = s + jagged * xcomp (PP2);
k3d/share/shaders/k3d_brick3.sl:71:  tcoord = t + jagged * ycomp (PP2);
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_brickanti.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickanti.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickanti.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_brickbump.sl:12: * Parameters:
k3d/share/shaders/k3d_brickbump.sl:79:  P += disp * normalize(N);
k3d/share/shaders/k3d_brickbump.sl:80:  N = calculatenormal(P);
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_brickbump2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickbump2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickbump2.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_brickbump2.sl:62:    Nf = calculatenormal(P + normalize(N) * stbump);
k3d/share/shaders/k3d_brickbump3.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_brickbump3.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_brickbump3.sl:65:  point PP2;
k3d/share/shaders/k3d_brickbump3.sl:73:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brickbump3.sl:74:  scoord = s + jagged * xcomp (PP2);
k3d/share/shaders/k3d_brickbump3.sl:75:  tcoord = t + jagged * ycomp (PP2);
k3d/share/shaders/k3d_brickbump3.sl:115:  P += disp * normalize(N);
k3d/share/shaders/k3d_brickbump3.sl:116:  N = calculatenormal (P);
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_brickperturb.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickperturb.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickperturb.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_brushedmetal.sl:7: * Parameters:
k3d/share/shaders/k3d_brushedmetal.sl:14: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_brushedmetal.sl:27:    MaterialBrushedMetal(Nf, Cs, Ka, Kd, Ks, normalize(dPdu), uroughness,
k3d/share/shaders/k3d_brushedmetal2.sl:15: *  PARAMETERS:
k3d/share/shaders/k3d_brushedmetal2.sl:27: *			  angle in radians (i.e. PI*.5 = 90 degrees)
k3d/share/shaders/k3d_brushedmetal2.sl:38:    extern point P;
k3d/share/shaders/k3d_brushedmetal2.sl:47:    illuminance (P, Nf, PI*.5) {
k3d/share/shaders/k3d_brushedmetal2.sl:77:	point Po = transform("object",P);
k3d/share/shaders/k3d_brushedmetal2.sl:84:	float Jspread = PI*(1/numsamples)*mapspread;
k3d/share/shaders/k3d_brushedmetal2.sl:85:	vector VA = rotate(normalize(dPdu), twist, zro, normalize(N));
k3d/share/shaders/k3d_brushedmetal2.sl:94:	      angle = PI*((i/numsamples)-.5)*mapspread;
k3d/share/shaders/k3d_brushedmetal3.sl:7: * Graphics 26(2) (Proceedings of Siggraph '92), pp. 265-272, July, 1992.
k3d/share/shaders/k3d_brushedmetal3.sl:10: *   V - unit viewing direction (from P toward the camera)
k3d/share/shaders/k3d_brushedmetal3.sl:28:    extern point P;
k3d/share/shaders/k3d_brushedmetal3.sl:29:    illuminance (P, N, PI/2) {
k3d/share/shaders/k3d_brushedmetal3.sl:58:    vector xdir = normalize (dPdu);
k3d/share/shaders/k3d_bubbles.sl:21: point myPoint = (smod, 0, tmod);
k3d/share/shaders/k3d_bubbles.sl:22: distance2point = distance(myPoint, myCenter);
k3d/share/shaders/k3d_bubbles.sl:26: P += Kmag * magnitud * normalize(N);
k3d/share/shaders/k3d_bubbles.sl:27: N = calculatenormal(P);
k3d/share/shaders/k3d_bubbly.sl:17: *  PARAMETERS:
k3d/share/shaders/k3d_bubbly.sl:37:  point Po = transform("object",P)*mult;
k3d/share/shaders/k3d_bubbly.sl:43:  setxcomp(trucell,floor(xcomp(Po))+.5);
k3d/share/shaders/k3d_bubbly.sl:44:  setycomp(trucell,floor(ycomp(Po))+.5);
k3d/share/shaders/k3d_bubbly.sl:45:  setzcomp(trucell,floor(zcomp(Po))+.5);
k3d/share/shaders/k3d_bubbly.sl:54:	dist = distance(Po,nzcell);
k3d/share/shaders/k3d_bubbly.sl:60:  P+= Nn*(pow(bub,2)-1)*Kd;
k3d/share/shaders/k3d_bubbly.sl:61:  N = calculatenormal(P);
k3d/share/shaders/k3d_castucco.sl:9: * Parameters:
k3d/share/shaders/k3d_castucco.sl:29:  point Pshad;			/* Point to be shaded, in shader space */
k3d/share/shaders/k3d_castucco.sl:30:  float fwidth;			/* Estimated change in P between image samples */
k3d/share/shaders/k3d_castucco.sl:34:  Pshad = freq * transform("shader", P);
k3d/share/shaders/k3d_castucco.sl:35:  fwidth = filterwidthp(Pshad);
k3d/share/shaders/k3d_castucco.sl:38:  disp = fBm(Pshad, fwidth, 3, 2, 0.6);
k3d/share/shaders/k3d_causticlight.sl:26:            float caustic = shadow (shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_causticlight.sl:30:		point PL = transform ("shader", Ps);
k3d/share/shaders/k3d_causticlight.sl:31:		caustic *= noiseamp * pow (noise(PL*noisefreq), noisepow);
k3d/share/shaders/k3d_celld.sl:24:	string PSpace = "shader";  /* desc {Space to transform P for shading calculations } */
k3d/share/shaders/k3d_celld.sl:25:	float usePref = 0;   /* type switch */
k3d/share/shaders/k3d_celld.sl:26:	varying point __Pref = point (1000, 0, -1000); /* vis hidden */
k3d/share/shaders/k3d_celld.sl:30:	point objP = transform (PSpace, P);
k3d/share/shaders/k3d_celld.sl:31:	point noiseP = (usePref != 0)? transform (PSpace, __Pref): objP;
k3d/share/shaders/k3d_celld.sl:32:	normal Nn = ntransform (PSpace, N);
k3d/share/shaders/k3d_celld.sl:38:	voronoi_f1f2_3d (noiseP*voro_freq, voro_jitter, 
k3d/share/shaders/k3d_celld.sl:48:	objP += Kvoro * voro_dist * Nn;
k3d/share/shaders/k3d_celld.sl:51:	P = transform (PSpace, "current", objP);
k3d/share/shaders/k3d_celld.sl:52:	N = calculatenormal (P);
k3d/share/shaders/k3d_ceramic.sl:8:		    DECLARE_DEFAULTED_ENVPARAMS;)
k3d/share/shaders/k3d_ceramictiles.sl:6: * Parameters for pattern placement and size:
k3d/share/shaders/k3d_ceramictiles.sl:17: * Parameters for tile color and pattern:
k3d/share/shaders/k3d_ceramictiles.sl:29: * Parameters for illumination model:
k3d/share/shaders/k3d_ceramictiles.sl:50: * PRMan together.
k3d/share/shaders/k3d_ceramictiles.sl:144:			   DECLARE_ENVPARAMS)
k3d/share/shaders/k3d_ceramictiles.sl:147:  extern point P;
k3d/share/shaders/k3d_ceramictiles.sl:159:			specsharpness) + SampleEnvironment(P, R, kr, blur,
k3d/share/shaders/k3d_ceramictiles.sl:160:							   ENVPARAMS);
k3d/share/shaders/k3d_ceramictiles.sl:171:			 DECLARE_DEFAULTED_ENVPARAMS;
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:249:			 roughness, specsharpness, Kr, blur, eta, ENVPARAMS);
k3d/share/shaders/k3d_checkerboard_solid.sl:19:	point Pshad = transform(shadingspace, P);
k3d/share/shaders/k3d_checkerboard_solid.sl:21:	x = mod(floor(xcomp(Pshad) / TileX), 2.0);
k3d/share/shaders/k3d_checkerboard_solid.sl:22:	y = mod(floor(ycomp(Pshad) / TileY), 2.0);
k3d/share/shaders/k3d_checkerboard_solid.sl:23:	z = mod(floor(zcomp(Pshad) / TileZ), 2.0);
k3d/share/shaders/k3d_clay.sl:7: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_cloudplane.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_cloudplane.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_cloudplane.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_cloudplane.sl:24:    point Psh;
k3d/share/shaders/k3d_cloudplane.sl:32:    Psh = transform("shader", P);
k3d/share/shaders/k3d_cloudplane.sl:33:    x = xcomp(Psh) + xoffset;
k3d/share/shaders/k3d_cloudplane.sl:34:    y = ycomp(Psh) + yoffset;
k3d/share/shaders/k3d_cloudplane.sl:38:    xfreq = 2 * PI * 0.023;
k3d/share/shaders/k3d_cloudplane.sl:39:    yfreq = 2 * PI * 0.021;
k3d/share/shaders/k3d_cloudplane.sl:48:        xphase = PI/2 * 0.9 * cos(yfreq * y);
k3d/share/shaders/k3d_cloudplane.sl:49:        yphase = PI/2 * 1.1 * cos(xfreq * x);
k3d/share/shaders/k3d_constant.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_constant.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_constant.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_constant.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_contacshadow.sl:29:    uniform matrix matNP;  
k3d/share/shaders/k3d_contacshadow.sl:30:    textureinfo(shadowname, "projectionmatrix", matNP);  
k3d/share/shaders/k3d_contacshadow.sl:34:    point screenP = transform(matNP, P);  
k3d/share/shaders/k3d_contacshadow.sl:35:    float ss = (xcomp(screenP) + 1) * 0.5;  
k3d/share/shaders/k3d_contacshadow.sl:36:    float tt = (1 - ycomp(screenP)) * 0.5;  
k3d/share/shaders/k3d_contacshadow.sl:50:	point cameraP = transform(matNl, P);  
k3d/share/shaders/k3d_contacshadow.sl:54:	float distance = mapdist - zcomp(cameraP);  
k3d/share/shaders/k3d_corktile.sl:1:/* Renamed to PQcorktile.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_corktile.sl:5: * Author: Peter Quint
k3d/share/shaders/k3d_corktile.sl:35:/* Bias function - Perlin and Hoffert 1989 */
k3d/share/shaders/k3d_corktile.sl:43:color cork(		point PP;
k3d/share/shaders/k3d_corktile.sl:51:		point P2 = transform("shader",PP);
k3d/share/shaders/k3d_corktile.sl:52:		point PT = P2 * txtscale;
k3d/share/shaders/k3d_corktile.sl:55:		float f = fnoise(PT, fw) + fnoise((P2 + 0.553) * txtscale, fw); 
k3d/share/shaders/k3d_corktile.sl:56:		f = f * fnoise(PT * .854, fw);
k3d/share/shaders/k3d_corktile.sl:57:		f = f + (fnoise(PT * 5.342, fw) - .5) * .5;  
k3d/share/shaders/k3d_corktile.sl:59:		g = fBm((P2 + 8.654) * txtscale, fw, 4, 2, .5);
k3d/share/shaders/k3d_corktile.sl:96:	point PP = transform("shader",P);
k3d/share/shaders/k3d_corktile.sl:97:	float filtwidth = filterwidthp(PP),
k3d/share/shaders/k3d_corktile.sl:106:	Ct = cork( P, txtscale, filtwidth);	
k3d/share/shaders/k3d_corktile.sl:108:	Cg = color( .20, 0, 0) + filteredsnoise(PP * txtscale, filtwidth * txtscale) * .2;
k3d/share/shaders/k3d_corktile.sl:113:	disp = (tileheight + fnoise(PP * txtscale * bumpfreq + 3, filtwidth * txtscale) * (1 - tileheight)) 
k3d/share/shaders/k3d_corktile.sl:115:	Nf = faceforward(calculatenormal(P + disp *	normalize(N)), I);
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_craters.sl:99:	    pert += sin(r*PI/2)*asc-asc;
k3d/share/shaders/k3d_craters.sl:105:	    pert += sin(r*PI/2)*asc-asc;
k3d/share/shaders/k3d_craters.sl:109:    P += Km*pert*normalize(N);
k3d/share/shaders/k3d_craters.sl:110:    N = calculatenormal(P);	
k3d/share/shaders/k3d_crayon.sl:1:/* Renamed shader to PQCrayon for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_crayon.sl:5:	DESCRIPTION
k3d/share/shaders/k3d_crayon.sl:10:	PARAMETERS
k3d/share/shaders/k3d_crayon.sl:26:	Peter Quint - Revised Monday, January 10, 2000 
k3d/share/shaders/k3d_cyclone.sl:1:#define TWOPI (2*PI)
k3d/share/shaders/k3d_cyclone.sl:3:/* Use signed Perlin noise */
k3d/share/shaders/k3d_cyclone.sl:6:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_cyclone.sl:16:  point Pt;			/* Point in texture space */
k3d/share/shaders/k3d_cyclone.sl:17:  point PN;			/* Normalized vector in texture space */
k3d/share/shaders/k3d_cyclone.sl:18:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_cyclone.sl:22:  Pt = transform("shader", P);
k3d/share/shaders/k3d_cyclone.sl:25:  PN = normalize(Pt);
k3d/share/shaders/k3d_cyclone.sl:26:  radius = sqrt(xcomp(PN) * xcomp(PN) + ycomp(PN) * ycomp(PN));
k3d/share/shaders/k3d_cyclone.sl:32:      angle = PI + twist * TWOPI * (max_radius - dist) / max_radius;
k3d/share/shaders/k3d_cyclone.sl:35:      PP =
k3d/share/shaders/k3d_cyclone.sl:36:	point(xcomp(Pt) * cosine - ycomp(Pt) * sine,
k3d/share/shaders/k3d_cyclone.sl:37:	      xcomp(Pt) * sine + ycomp(Pt) * cosine, zcomp(Pt));
k3d/share/shaders/k3d_cyclone.sl:49:    PP = Pt;
k3d/share/shaders/k3d_cyclone.sl:59:	  a += o * VLNoise(PP * l, 1);
k3d/share/shaders/k3d_decalplastic.sl:7:// modify it under the terms of the GNU General Public
k3d/share/shaders/k3d_decalplastic.sl:13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
k3d/share/shaders/k3d_decalplastic.sl:14:// General Public License for more details.
k3d/share/shaders/k3d_decalplastic.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_decalplastic.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_defaultsurface.sl:3: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_defaultsurface.sl:4: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_defaultsurface.sl:5: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_dented.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_dented.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_dented.sl:23: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_dented.sl:24: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_dented.sl:25: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_dented.sl:35:	point PP;
k3d/share/shaders/k3d_dented.sl:37:	PP = transform ("shader", P);
k3d/share/shaders/k3d_dented.sl:41:			magnitude += abs(0.5 - noise(PP*size)) / size;
k3d/share/shaders/k3d_dented.sl:44:	P = P - (Km * pow(magnitude, power)) * normalize(N);
k3d/share/shaders/k3d_dented.sl:45:	N = calculatenormal(P);
k3d/share/shaders/k3d_depthcue.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_depthcue.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_depthcue.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_depthcue.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_depthcue.sl:14:  d = clamp((depth(P) - mindistance) / (maxdistance - mindistance), 0, 1);
k3d/share/shaders/k3d_depthcue_surf.sl:1:/* k3d_depthcue_surf inspired by depthcue_surf.sl by Pixar
k3d/share/shaders/k3d_depthcue_surf.sl:13:  d = clamp((depth(P) - mindistance) / (maxdistance - mindistance), 0, 1);
k3d/share/shaders/k3d_depthcue_surf.sl:18:			printf("<debug shadername='k3d_depthcue_surf' shadertype='surface'>%p\t%f\t%f\t%c</debug>\n", P, depth(P), d, Ci);
k3d/share/shaders/k3d_displacementmap.sl:2:				 float ZeroPoint = 0.0;
k3d/share/shaders/k3d_displacementmap.sl:5:  point PP;
k3d/share/shaders/k3d_displacementmap.sl:11:  N1 = calculatenormal(P);
k3d/share/shaders/k3d_displacementmap.sl:12:  P = P - (Km * (Ct - ZeroPoint)) * normalize(N);
k3d/share/shaders/k3d_displacementmap.sl:13:  N2 = calculatenormal(P);
k3d/share/shaders/k3d_distant_shadow.sl:16:				Cl *= 1 - shadow(shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_distantlight.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_distantlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_distantlight.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_distantlight.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_droop.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_droop.sl:19:	setycomp(P, ycomp(P) + yDel);
k3d/share/shaders/k3d_droop.sl:20:	N = calculatenormal(P);
k3d/share/shaders/k3d_dturb.sl:11:  point PP;
k3d/share/shaders/k3d_dturb.sl:16:  PP = transform("shader", P) * freq;
k3d/share/shaders/k3d_dturb.sl:18:  width = filterwidth_point(PP);
k3d/share/shaders/k3d_dturb.sl:23:    turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:25:  turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:33:  P += Km * magnitude * normalize(N);
k3d/share/shaders/k3d_dturb.sl:34:  N = calculatenormal(P);
k3d/share/shaders/k3d_easysurface.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_ember.sl:20:	point PP = transform ("world", P);
k3d/share/shaders/k3d_ember.sl:23:	float size = distance (PP, QQ) / baseSize;
k3d/share/shaders/k3d_emboss.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_emboss.sl:15:		P -= Km * texture(texturename, s, t) * normalize(N);
k3d/share/shaders/k3d_emboss.sl:16:		N = calculatenormal(P);
k3d/share/shaders/k3d_eroded.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_eroded.sl:19:	      W = transform ("object", P);
k3d/share/shaders/k3d_eroded.sl:32:	N = calculatenormal (P - magnitude * normalize(N));
k3d/share/shaders/k3d_eyeball.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_eyeball.sl:11: * PARAMETERS:
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:60:#define snoise(P) (2*noise(P)-1)
k3d/share/shaders/k3d_eyeball.sl:64:  point PP, PO;
k3d/share/shaders/k3d_eyeball.sl:75:  PO = transform ("object", P) + index;
k3d/share/shaders/k3d_eyeball.sl:97:	  newturb = 1 - abs (snoise(PO*freq + point(0,0,20*freq)));
k3d/share/shaders/k3d_eyeball.sl:114:	  turb += snoise (PO*f2 + point(0,0,20*f2)) / freq;
k3d/share/shaders/k3d_filament.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_fire.sl:3: * animated fire -- adpated from shader by Flip Phillips
k3d/share/shaders/k3d_flame.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_flame.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_flame.sl:21: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_flame.sl:22: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_flame.sl:23: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_flame.sl:41:  point PP, PQ;
k3d/share/shaders/k3d_flame.sl:45:  PP = point(s, t, phase);
k3d/share/shaders/k3d_flame.sl:46:  PQ = PP;
k3d/share/shaders/k3d_flame.sl:47:  PQ *= point(1, 1, exp(-ycomp(PP)));
k3d/share/shaders/k3d_flame.sl:52:      chaos += VLNoise(freq * PQ, distortion) / freq;
k3d/share/shaders/k3d_flame.sl:57:  cmap = 0.85 * chaos + flameoffset + (flameamplitude * ycomp(PP));
k3d/share/shaders/k3d_fog.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_fog.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_fog.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_fog.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_fractal.sl:7: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,

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

k3d/share/shaders/k3d_fractal.sl:9: *    Academic Press, 1998.  ISBN 0-12-228730-4.

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

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

k3d/share/shaders/k3d_fractal.sl:37:          		PP.x *= lacunarity;

k3d/share/shaders/k3d_fractal.sl:38:          		PP.y *= lacunarity;

k3d/share/shaders/k3d_fractal.sl:39:          		PP.z *= lacunarity;

k3d/share/shaders/k3d_fractal.sl:41:			PP = PP * lacunarity;

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

k3d/share/shaders/k3d_fractal.sl:62:	P+= Nn*result*Kt;

k3d/share/shaders/k3d_fractal.sl:63:  	N = calculatenormal(P);	

k3d/share/shaders/k3d_fresnelplastic.sl:2: * TLFresnelPlastic.sl -- simple shader illustrating fresnel().
k3d/share/shaders/k3d_fresnelplastic.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_fresnelplastic.sl:7: * PARAMETERS
k3d/share/shaders/k3d_fresnelplastic.sl:18:#ifdef PRMAN  /* as of prman10 */
k3d/share/shaders/k3d_fresnelplastic.sl:45:   /* cat Reflection desc {Percentage amount to blur map} */
k3d/share/shaders/k3d_fresnelplastic.sl:67:    /* Parametric space adjustments */
k3d/share/shaders/k3d_fresnelplastic.sl:105:			P, R, reflectBlur, reflOpacity);
k3d/share/shaders/k3d_funkyglass.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_funkyglass.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_funkyglass.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_funkyglass.sl:13:  point PP;
k3d/share/shaders/k3d_funkyglass.sl:20:  PP = transform("shader", P);
k3d/share/shaders/k3d_funkyglass.sl:21:  Ct = 2 * (color noise(PP) - .5) + .5;
k3d/share/shaders/k3d_fur1.sl:21:      P += 0.5;

k3d/share/shaders/k3d_fur1.sl:23:      P += 0.5 + N * height;

k3d/share/shaders/k3d_fur1.sl:26:      P += 0.5 + N * height;

k3d/share/shaders/k3d_fur1.sl:28:      P += 0.5;

k3d/share/shaders/k3d_fur1.sl:31:  N = calculatenormal(P);

k3d/share/shaders/k3d_fur2.sl:14:                point Lin;       /* Light Position */
k3d/share/shaders/k3d_fur2.sl:44:	 float SPEC1  = 0.01;
k3d/share/shaders/k3d_fur2.sl:46:	 float SPEC2  = 0.003;
k3d/share/shaders/k3d_fur2.sl:61:	 /* Variables Passed from the rib... */
k3d/share/shaders/k3d_fur2.sl:66:	 uniform float hair_id   = 0.0; /* Watch Out... Across Patches */
k3d/share/shaders/k3d_fur2.sl:70:    vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_fur2.sl:115:    illuminance (P, norm_hair, radians(illum_width)) {
k3d/share/shaders/k3d_fur2.sl:140:	    ((SPEC1*Cl*pow(Kajiya, 1/roughness1)) + 
k3d/share/shaders/k3d_fur2.sl:141:	     (SPEC2*Cl*pow(Kajiya, 1/roughness2)));
k3d/share/shaders/k3d_glass.sl:8: * Parameters:
k3d/share/shaders/k3d_glass.sl:25: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_glass.sl:38:		  DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_glass.sl:47:		  ENVPARAMS);
k3d/share/shaders/k3d_gloop.sl:31:  point  Psh = transform("object",P)*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:37:  point  Pou = Psh + (dPduN*overdist);/*P Over a distance in U*/
k3d/share/shaders/k3d_gloop.sl:38:  point  Pov = Psh + (dPdvN*overdist);
k3d/share/shaders/k3d_gloop.sl:41:  float  nz = noise(Psh)-.5;
k3d/share/shaders/k3d_gloop.sl:42:  float  nzou = noise(Pou)-.5;
k3d/share/shaders/k3d_gloop.sl:43:  float  nzov = noise(Pov)-.5;
k3d/share/shaders/k3d_gloop.sl: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_gloop.sl:56:    P -= vtransform("object","current",step)*nz*stepsize;
k3d/share/shaders/k3d_gloop.sl:57:    DdPdu = normalize(DdPdu+(step*chu));
k3d/share/shaders/k3d_gloop.sl:58:    DdPdv = normalize(DdPdv+(step*chv));
k3d/share/shaders/k3d_gloop.sl:59:    step = DdPdu^DdPdv;
k3d/share/shaders/k3d_gloop.sl:62:  /* wash your hands after displacing P*/
k3d/share/shaders/k3d_gloop.sl:63:  N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_gmarbtile_polish.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_gmarbtile_polish.sl:8: * PARAMETERS:
k3d/share/shaders/k3d_gmarbtile_polish.sl:53:  point PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_gmarbtile_polish.sl:54:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_gmarbtile_polish.sl:56:  float ss = xcomp(PP) / tilesize;
k3d/share/shaders/k3d_gmarbtile_polish.sl:58:  float tt = ycomp(PP) / tilesize;
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:65:  PP += offset;
k3d/share/shaders/k3d_gmarbtile_polish.sl:70:  turb = 0.5 * turbulence(PP, dPP, 5, 2, 0.5);
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:83:  PP *= veinfreq;
k3d/share/shaders/k3d_gmarbtile_polish.sl:84:  dPP *= veinfreq;
k3d/share/shaders/k3d_gmarbtile_polish.sl:87:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_gmarbtile_polish.sl:94:	       filteredsnoise(2 * (PP + vector(-4.4, 8.34, 27.1)), 2 * dPP));
k3d/share/shaders/k3d_gmarbtile_polish.sl:104:  env += SampleEnvironment(P, reflect(V, Nf), Kr, blur, ENVPARAMS);
k3d/share/shaders/k3d_gooch.sl:6: * DESCRIPTION   : This model is described in "A Non-Photorealistc
k3d/share/shaders/k3d_gooch.sl:8: *                 Illustration" in the Siggraph 1998 Proceedings.
k3d/share/shaders/k3d_gooch.sl:11: * INPUTS        : 
k3d/share/shaders/k3d_gooch.sl:47:    illuminance(P,Nf,PI) {
k3d/share/shaders/k3d_gouge.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_gouge.sl:14:	float	y = ycomp(transform("object",P));	/* convert to object space	 */
k3d/share/shaders/k3d_gouge.sl:23:   {  P += (-Km * texture(texturename,s+spin,y/15.0)) * normalize(N);
k3d/share/shaders/k3d_gouge.sl:24:      N = calculatenormal(P);
k3d/share/shaders/k3d_granite.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_granite.sl:6: * granite(): Provide a diffuse granite-like surface texture. 
k3d/share/shaders/k3d_graphic_lines.sl:88:	point P_highlight = P;
k3d/share/shaders/k3d_graphic_lines.sl:108:	point Psh_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:109:	Psh_highlight=transform("shader",P_highlight);
k3d/share/shaders/k3d_graphic_lines.sl:115:	{z_highlight=zcomp(Psh_highlight);
k3d/share/shaders/k3d_graphic_lines.sl:120:	{y_highlight=ycomp(Psh_highlight);
k3d/share/shaders/k3d_graphic_lines.sl:124:	else {x_highlight=xcomp(Psh_highlight);
k3d/share/shaders/k3d_graphic_lines.sl:134:		n_highlight+=(2*noise(Psh_highlight*ns_highlight)-1)/ns_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:159:	P_highlight+=0*Ndisp_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:160:	N_highlight=normalize(calculatenormal(P_highlight+(1-0)*Ndisp_highlight));
k3d/share/shaders/k3d_graphic_lines.sl:166:	point P_paint = P;
k3d/share/shaders/k3d_graphic_lines.sl:186:	point Psh_paint;
k3d/share/shaders/k3d_graphic_lines.sl:187:	Psh_paint=transform("shader",P_paint);
k3d/share/shaders/k3d_graphic_lines.sl:191:	{z_paint=zcomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:196:	{y_paint=ycomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:200:	else {x_paint=xcomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:208:		n_paint+=(2*noise(Psh_paint*ns_paint)-1)/ns_paint;
k3d/share/shaders/k3d_graphic_lines.sl:231:	P_paint+=0*Ndisp1;
k3d/share/shaders/k3d_graphic_lines.sl:232:	N_paint=normalize(calculatenormal(P_paint+(1-0)*Ndisp1));
k3d/share/shaders/k3d_graphic_lines.sl:238:	point P_ink = P;
k3d/share/shaders/k3d_graphic_lines.sl:258:	point Psh_ink;
k3d/share/shaders/k3d_graphic_lines.sl:259:	Psh_ink=transform("shader",P_ink);
k3d/share/shaders/k3d_graphic_lines.sl:263:	{z_ink=zcomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:268:	{y_ink=ycomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:272:	else {x_ink=xcomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:280:		n_ink+=(2*noise(Psh_ink*ns_ink)-1)/ns_ink;
k3d/share/shaders/k3d_graphic_lines.sl:303:	P_ink+=0*Ndisp2;
k3d/share/shaders/k3d_graphic_lines.sl:304:	N_ink=normalize(calculatenormal(P_ink+(1-0)*Ndisp2));
k3d/share/shaders/k3d_graphic_lines.sl:319:		illuminance(P, N, PI/2) {
k3d/share/shaders/k3d_graphic_lines.sl:345:	illuminance(P, Nf, PI/2)
k3d/share/shaders/k3d_grass_displace.sl:36:      P += 0.5;

k3d/share/shaders/k3d_grass_displace.sl:44:	P += N * height;

k3d/share/shaders/k3d_grass_displace.sl:46:        P += 0.5;

k3d/share/shaders/k3d_grass_displace.sl:56:	P += N * height;

k3d/share/shaders/k3d_grass_displace.sl:58:        P += 0.5;

k3d/share/shaders/k3d_grass_displace.sl:61:      P += 0.5;

k3d/share/shaders/k3d_grass_displace.sl:63:  N = calculatenormal(P);

k3d/share/shaders/k3d_greenmarble.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_greenmarble.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_greenmarble.sl:38:  point PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_greenmarble.sl:39:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_greenmarble.sl:45:  turb = 0.5 * turbulence(PP, dPP, 5, 2, 0.5);
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:58:  PP *= veinfreq;
k3d/share/shaders/k3d_greenmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_greenmarble.sl:67:    smoothstep(-0.1, 0.05, snoise(2 * (PP + vector(-4.4, 8.34, 27.1))));
k3d/share/shaders/k3d_greenmarble.sl:75:  Ci = MaterialPlastic(Nf, Ct, Ka, Kd, Ks, roughness);
k3d/share/shaders/k3d_grids_disp.sl:6: extern point P;
k3d/share/shaders/k3d_grids_disp.sl:9: P += truedisp * Ndisp;
k3d/share/shaders/k3d_grids_disp.sl:10: return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_hair.sl:13:	vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_hair.sl:19:	illuminance (P)
k3d/share/shaders/k3d_hdr_light.sl:9:*notice remain intact and that I am acknowledged as the original author. Please

k3d/share/shaders/k3d_hdr_light.sl:72:			printf("Please select mapping type probe,environment or planar");

k3d/share/shaders/k3d_hdr_light.sl:95:		            Cl *= 1 - shadow(shadowname, Ps, "samples", shadowsamples, "blur", shadowblur, "bias", shadowbias);

k3d/share/shaders/k3d_hdr_surface.sl:9:*notice remain intact and that I am acknowledged as the original author. Please

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

k3d/share/shaders/k3d_hdri2.sl:12:    vector Lenv = vtransform (envspace, P-Ps);
k3d/share/shaders/k3d_hdri2.sl:13:    illuminate (P) {
k3d/share/shaders/k3d_hdri2.sl:18:            Cl *= 1 - color shadow (shadowname, Ps, "samples", shadowsamples,
k3d/share/shaders/k3d_hexatile_bump.sl:8:* Parameters:
k3d/share/shaders/k3d_hexatile_bump.sl:15:*	point P1	= point(0,0,0) 		---	Center point for Rotation.
k3d/share/shaders/k3d_hexatile_bump.sl:16:*	point P2	= point(0,0,1) 		---	The x,y,z direction for Rotate.
k3d/share/shaders/k3d_hexatile_bump.sl:17:*	string Projection = "planar" 		---	Projection "preoject.h"
k3d/share/shaders/k3d_hexatile_bump.sl:32:* Arman "Advanced Renderman-"Creating CGI for Motion Picture.
k3d/share/shaders/k3d_hexatile_bump.sl:85:	point P1	= point(0,0,0); 
k3d/share/shaders/k3d_hexatile_bump.sl:86:	point P2	= point(0,0,1); 
k3d/share/shaders/k3d_hexatile_bump.sl:87:	string Projection = "planar"; 
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:111:/*** ----- SmoothPulse macro ----- ***/
k3d/share/shaders/k3d_hexatile_bump.sl:117:/*** ----- SmoothPulse macro ----- ***/
k3d/share/shaders/k3d_hexatile_bump.sl:124:	extern point P;
k3d/share/shaders/k3d_hexatile_bump.sl:127:P += truedisp * Ndisp;
k3d/share/shaders/k3d_hexatile_bump.sl:128:return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_hextile.sl:4: * DESCRIPTION
k3d/share/shaders/k3d_hextile.sl:15: * PARAMTERS
k3d/share/shaders/k3d_hextile.sl:27: * HINTS & APPLICATIONS
k3d/share/shaders/k3d_imagelayerclouds.sl:1:// Use signed Perlin noise
k3d/share/shaders/k3d_imagelayerclouds.sl:13:  point PP;			/* Surface point in shader space */
k3d/share/shaders/k3d_imagelayerclouds.sl:16://  PP = txtscale * transform ("shader", P);
k3d/share/shaders/k3d_imagelayerclouds.sl:17:  PP = txtscale * point(s, t, s);
k3d/share/shaders/k3d_imagelayerclouds.sl:20:/*  value = fBm (PP, omega, lambda, octaves); */
k3d/share/shaders/k3d_imagelayerclouds.sl:27:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_incandplastic.sl:1:/* incandPlastic.sl   version 1.0, Jan. 2002

k3d/share/shaders/k3d_indirect.sl:6: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_indirect.sl:7: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_indirect.sl:8: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_indirect.sl:20:#else /* PRMan - make a light that looks up from the ray server */
k3d/share/shaders/k3d_indirect.sl:22:  /* Exploit the fact that PRMan (incorrectly) leaves the surface normal
k3d/share/shaders/k3d_indirect.sl:28:    Cl = rs_indirect(Ps, axis);
k3d/share/shaders/k3d_leather.sl:46:	point PP, newP;

k3d/share/shaders/k3d_leather.sl:58:	PP = transform("shader", P);

k3d/share/shaders/k3d_leather.sl:63:	 * Pick the base color for the apple.

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

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

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

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

k3d/share/shaders/k3d_leather.sl:105:	 * Pick the blotch color.

k3d/share/shaders/k3d_leather.sl:116:	#define BLOTCH_SPECK_COEFF 0.3  /* blotch specking coeff  */

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

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

k3d/share/shaders/k3d_leather.sl:135:	#define SPECK_NF        0     /* un dented dessus que je met a zero*/    

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

k3d/share/shaders/k3d_leather.sl:137:	speck = pow(smoothstep(SPECK_CUTOFF, 1,

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

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:172:	#define DISP_DENT_AMP     (1/15)   /* dent amplitude          */

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

k3d/share/shaders/k3d_leather.sl:174:	#define DISP_SPECK_AMP    (1/40)   /* speckle disp. amplitude */

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

k3d/share/shaders/k3d_leather.sl:176:	              DISP_TF*t + label) * DISP_DENT_AMP * txtscale / TSCALE;

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

k3d/share/shaders/k3d_leather.sl:178:	disp -= speck * DISP_SPECK_AMP * txtscale / TSCALE;

k3d/share/shaders/k3d_leather.sl:180:	newP = calculatenormal(P + disp * normalize(N));

k3d/share/shaders/k3d_leather.sl:181:	Nf = faceforward(normalize(newP), I);

k3d/share/shaders/k3d_leather.sl:197:		reflect = RayTrace(P, Rdir, 0, 1, 1);

k3d/share/shaders/k3d_lensflare.sl:12: * Parameters:
k3d/share/shaders/k3d_lensflare.sl:52:  uniform point Pcorner0 = transform("NDC", "screen", point(0, 0, 0));
k3d/share/shaders/k3d_lensflare.sl:53:  uniform point Pcorner1 = transform("NDC", "screen", point(1, 1, 0));
k3d/share/shaders/k3d_lensflare.sl:54:  return (xcomp(Pcorner1) - xcomp(Pcorner0)) / (ycomp(Pcorner1) -
k3d/share/shaders/k3d_lensflare.sl:55:						ycomp(Pcorner0));
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:119:  float dPndc = filterwidthp(Pndc);
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:136:    float angle = atan(ycomp(Lvec), xcomp(Lvec)) + PI;
k3d/share/shaders/k3d_lensflare.sl:147:	float bloom = pnoise(bloomnpoints * angle / (2 * PI), bloomnpoints);
k3d/share/shaders/k3d_lensflare.sl:159:	float star = float pnoise(starburstnpoints * angle / (2 * PI),
k3d/share/shaders/k3d_lensflare.sl:172:		  (dPndc / rainbowradius) / rainbowwidth);
k3d/share/shaders/k3d_lensflare.sl:178:    vector axis = normalize(vector Plight);
k3d/share/shaders/k3d_lensflare.sl:185:	float axisdist = distance(cntr, Pndc);
k3d/share/shaders/k3d_lensflare.sl:187:			   pow(urand(), 2)) * distance(cntr, Plight);
k3d/share/shaders/k3d_lensflare.sl:200:	    int = 1 - filterstep(radius, axisdist - dPndc / 2,
k3d/share/shaders/k3d_lensflare.sl:201:				 axisdist + dPndc / 2);
k3d/share/shaders/k3d_lensflare.sl:206:				axisdist, dPndc);
k3d/share/shaders/k3d_lensflare.sl:216:							       dPndc / 2,
k3d/share/shaders/k3d_lensflare.sl:218:							       dPndc / 2);
k3d/share/shaders/k3d_luna.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_luna.sl:14: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_luna.sl:15: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_luna.sl:16: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_luna.sl:25:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_luna.sl:29:#define VLNoise(Pt,scale) (snoise(Pt + scale*DNoise(Pt)))
k3d/share/shaders/k3d_luna.sl:30:#define TWOPI (6.28)
k3d/share/shaders/k3d_luna.sl:49:  point PP, PQ;
k3d/share/shaders/k3d_luna.sl:61:  PQ = P;
k3d/share/shaders/k3d_luna.sl:62:  PP = transform("shader", P);
k3d/share/shaders/k3d_luna.sl:64:  radial_dist = sqrt(xcomp(PP) * xcomp(PP) + ycomp(PP) * ycomp(PP));
k3d/share/shaders/k3d_luna.sl:67:  /* bumpy = fBm (PP, omega, lacunarity, octaves); */
k3d/share/shaders/k3d_luna.sl:73:      a += o * snoise(l * PP);
k3d/share/shaders/k3d_luna.sl:88:      PQ += chaos * highland_altitude * NN;
k3d/share/shaders/k3d_luna.sl:93:      PQ += chaos * maria_altitude * NN;
k3d/share/shaders/k3d_luna.sl:102:  vv = point(xcomp(PP) / radial_dist, 0, zcomp(PP) / radial_dist);
k3d/share/shaders/k3d_luna.sl:128:  PQ += ht * NN;
k3d/share/shaders/k3d_luna.sl:137:	  vv = 5 * PP + 3 * vv;
k3d/share/shaders/k3d_luna.sl:148:	  PQ += 0.0025 * uu * ht * NN;
k3d/share/shaders/k3d_luna.sl:152:	  vv = 6 * PP + 3 * vv;
k3d/share/shaders/k3d_luna.sl:165:	  PQ += 0.0025 * (0.5 * uu + 0.5 * ht) * NN;
k3d/share/shaders/k3d_luna.sl:170:  /* Make crater rays (PP, arg10, arg11, arg12, arg15, arg24, arg25, radial_dist);, yielding temp1 */
k3d/share/shaders/k3d_luna.sl:182:  /* Recalc normal since we changed P a whole bunch. */
k3d/share/shaders/k3d_luna.sl:183:/*  N = normalize (calculatenormal (PQ)); */
k3d/share/shaders/k3d_lunette.sl:15: * Parameters:
k3d/share/shaders/k3d_lunette.sl:33: * License: This shader is distributed under the GNU General Public License.
k3d/share/shaders/k3d_lunette.sl:46: * Parameters:
k3d/share/shaders/k3d_lunette.sl:110:	point noisePt = noiseScale * 
k3d/share/shaders/k3d_lunette.sl:112:	float noisefilterwidth = filterwidthp(noisePt);
k3d/share/shaders/k3d_lunette.sl:114:		noisePt, noisefilterwidth, maxOctaves, lunacrity, gain
k3d/share/shaders/k3d_lunette.sl:132:	/* Plastic illumination model parameters. */
k3d/share/shaders/k3d_map_pattern_1.sl:45:point PP, PQ;
k3d/share/shaders/k3d_map_pattern_1.sl:51:PP = txtscale * transform ("shader", P);
k3d/share/shaders/k3d_map_pattern_1.sl:53:my_t = zcomp(PP) / temp_f_3;
k3d/share/shaders/k3d_map_pattern_1.sl:54:PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_map_pattern_1.sl:55:my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_map_pattern_1.sl:57:PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_map_pattern_1.sl:58:r = temp_f_3 * noise (PQ);
k3d/share/shaders/k3d_map_pattern_1.sl:62:PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_map_pattern_1.sl:63:r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_matte.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_matte.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_matte.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_matte.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_metal.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_metal.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_metal.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_metal.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_mondometal.sl:61:    point PP;

k3d/share/shaders/k3d_mondometal.sl:179:        PP = transform("shader", P);

k3d/share/shaders/k3d_mondometal.sl:181:        PP += bmp * Nf;

k3d/share/shaders/k3d_mondometal.sl:182:        PP = transform("shader", "current", PP);

k3d/share/shaders/k3d_mondometal.sl:183:        Nf = calculatenormal(PP);

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

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:9: * DESCRIPTION:

k3d/share/shaders/k3d_mysky.sl:17: * PARAMETERS:

k3d/share/shaders/k3d_mysky.sl:32: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,

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

k3d/share/shaders/k3d_mysky.sl:34: *    Academic Press, 1994.  ISBN 0-12-228760-6.

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

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

k3d/share/shaders/k3d_mysky.sl:64:  PP = txtscale * transform ("shader", P);

k3d/share/shaders/k3d_mysky.sl:67:  /*  value = fBm (PP, omega, lambda, octaves); */

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

k3d/share/shaders/k3d_noisysmoke.sl:5:#define GADD(PP,PW,li,g)                                                    \
k3d/share/shaders/k3d_noisysmoke.sl:8:	     illuminance (PW) { li += Cl; }                                 \
k3d/share/shaders/k3d_noisysmoke.sl:11:             Psmoke = PP*freq;                                              \
k3d/share/shaders/k3d_noisysmoke.sl:12:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_noisysmoke.sl:17:                      f *= 0.5;  Psmoke *= 2;                               \
k3d/share/shaders/k3d_noisysmoke.sl:18:                      smoke += f*snoise(Psmoke);                            \
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:41:  point Worigin = P + I;
k3d/share/shaders/k3d_noisysmoke.sl:45:  point Worigin = P - I;
k3d/share/shaders/k3d_noisysmoke.sl:56:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_noisysmoke.sl:69:      PP = origin + d * IN;
k3d/share/shaders/k3d_noisysmoke.sl:70:      PW = Worigin + d * WIN;
k3d/share/shaders/k3d_noisysmoke.sl:71:      GADD(PP, PW, li, dtau) ss = min(stepsize, end - d);
k3d/share/shaders/k3d_noisysmoke.sl:79:	  PP = origin + d * IN;
k3d/share/shaders/k3d_noisysmoke.sl:80:	  PW = Worigin + d * WIN;
k3d/share/shaders/k3d_noisysmoke.sl:81:	  GADD(PP, PW, li, dtau)
k3d/share/shaders/k3d_oak.sl:10: * Parameters for the coordinate mapping: 
k3d/share/shaders/k3d_oak.sl:13: *   Pref - if supplied, gives the reference pose
k3d/share/shaders/k3d_oak.sl:15: * Parameters for the color and pattern: 
k3d/share/shaders/k3d_oak.sl:32: * Parameters for illumination model:
k3d/share/shaders/k3d_oak.sl:55:		DEFAULT_PSHAD_PARAMS;
k3d/share/shaders/k3d_oak.sl:68:  GET_PSHAD;
k3d/share/shaders/k3d_oak.sl:73:    oaktexture(Pshad, dPshad, ringfreq, ringunevenness, grainfreq, ringnoise,
k3d/share/shaders/k3d_oak.sl:80:  Ci = MaterialPlastic(Nf, Cwood, Ka, Kd, Ks * (1 - 0.5 * wood), roughness);
k3d/share/shaders/k3d_oakplank.sl:9: * Parameters for the coordinate mapping: 
k3d/share/shaders/k3d_oakplank.sl:12: *   Pref - if supplied, gives the reference pose
k3d/share/shaders/k3d_oakplank.sl:14: * Parameters for the pattern of the plank structure: 
k3d/share/shaders/k3d_oakplank.sl:22: * Parameters for the color and pattern of the wood grain: 
k3d/share/shaders/k3d_oakplank.sl:39: * Parameters for illumination model:
k3d/share/shaders/k3d_oakplank.sl:57: * PRMan together.
k3d/share/shaders/k3d_oakplank.sl:104:		     DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_oakplank.sl:105:		     DEFAULT_PSHAD_PARAMS;
k3d/share/shaders/k3d_oakplank.sl:123:  GET_PSHAD;
k3d/share/shaders/k3d_oakplank.sl:124:  float ss = xcomp(Pshad), tt = ycomp(Pshad), height = zcomp(Pshad);
k3d/share/shaders/k3d_oakplank.sl:136:  point Ppat =
k3d/share/shaders/k3d_oakplank.sl:141:  float wood = oaktexture(Ppat, dPshad, ringfreq, ringunevenness, grainfreq,
k3d/share/shaders/k3d_oakplank.sl:160:    varnishlump * filteredsnoise(Pshad * varnishlumpfreq,
k3d/share/shaders/k3d_oakplank.sl:161:				 dPshad * varnishlumpfreq);
k3d/share/shaders/k3d_oakplank.sl:169:    MaterialShinyPlastic(Nf, Cwood, Ka, Kd, specadjusted * Ks, roughness,
k3d/share/shaders/k3d_oakplank.sl:170:			 specadjusted * Kr, blur, eta, 1, ENVPARAMS);
k3d/share/shaders/k3d_orange.sl:8: * DESCRIPTION:
k3d/share/shaders/k3d_orange.sl:11: * PARAMETERS:
k3d/share/shaders/k3d_orange.sl:23:#define BUMP_AMPLITUDE (1/30)
k3d/share/shaders/k3d_orange.sl:24:#define BUMP_FREQUENCY (35)
k3d/share/shaders/k3d_orange.sl:35:	point newP;
k3d/share/shaders/k3d_orange.sl:38:	setxcomp (p2, sin (2 * PI * s));
k3d/share/shaders/k3d_orange.sl:40:	setzcomp (p2, cos (2 * PI * s));
k3d/share/shaders/k3d_orange.sl:43:	turb = noise (BUMP_FREQUENCY * p2) * BUMP_AMPLITUDE;
k3d/share/shaders/k3d_orange.sl:44:	newP = calculatenormal (P + turb * normalize (N));
k3d/share/shaders/k3d_orange.sl:45:	Nf = faceforward (normalize (newP), I);
k3d/share/shaders/k3d_orennayar.sl:7: * DESCRIPTION:
k3d/share/shaders/k3d_orennayar.sl:9: *   Lambert.  Based on Oren & Nayar's model (see Proc. SIGGRAPH 94).
k3d/share/shaders/k3d_orennayar.sl:15: * PARAMETERS:
k3d/share/shaders/k3d_orennayar.sl:24: *         Series 1994 (Proceedings of SIGGRAPH '94), pp. 239-246.
k3d/share/shaders/k3d_orennayar.sl:58:    illuminance (P, Nf, PI/2) {
k3d/share/shaders/k3d_orennayar.sl:69:	else C2 *= (sin(alpha) - pow(2*beta/PI,3));
k3d/share/shaders/k3d_orennayar.sl:70:	C3 = 0.125 * sigma2 / (sigma2+0.09) * pow ((4*alpha*beta)/(PI*PI),2);
k3d/share/shaders/k3d_orennayar.sl:74:			  (1 - cos_phi_diff*(4*beta*beta)/(PI*PI)));
k3d/share/shaders/k3d_outlet.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_outlet.sl:5: *   Makes an electrical outlet.  Perfect for slapping on a bilinear
k3d/share/shaders/k3d_outlet.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_outline.sl:12:  P += Nn*width;
k3d/share/shaders/k3d_paintedplastic.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_paintedplastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_paintedplastic.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_paintedplastic.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_paintedplastic.sl:8: * DESCRIPTION:
k3d/share/shaders/k3d_paintedplastic.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_parquet_plank.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_parquet_plank.sl:10: * PARAMETERS:
k3d/share/shaders/k3d_parquet_plank.sl:53:  float PGWIDTH, PGHEIGHT, GWF, GHF;
k3d/share/shaders/k3d_parquet_plank.sl:56:  PGWIDTH = plankwidth + groovewidth;
k3d/share/shaders/k3d_parquet_plank.sl:57:  planklength = PGWIDTH * plankspertile - groovewidth;
k3d/share/shaders/k3d_parquet_plank.sl:58:  PGHEIGHT = planklength + groovewidth;
k3d/share/shaders/k3d_parquet_plank.sl:59:  GWF = groovewidth * 0.5 / PGWIDTH;
k3d/share/shaders/k3d_parquet_plank.sl:60:  GHF = groovewidth * 0.5 / PGHEIGHT;
k3d/share/shaders/k3d_parquet_plank.sl:64:    (max(abs(Du(s) * du) + abs(Dv(s) * dv), MINFILTERWIDTH) / PGWIDTH) *
k3d/share/shaders/k3d_parquet_plank.sl:67:    (max(abs(Du(t) * du) + abs(Dv(t) * dv), MINFILTERWIDTH) / PGHEIGHT) *
k3d/share/shaders/k3d_parquet_plank.sl:73:  ss = (txtscale * s) / PGWIDTH;
k3d/share/shaders/k3d_parquet_plank.sl:75:  tt = (txtscale * t) / PGHEIGHT;
k3d/share/shaders/k3d_parquet_plank.sl:79:      ss = txtscale * t / PGWIDTH;
k3d/share/shaders/k3d_parquet_plank.sl:81:      tt = txtscale * s / PGHEIGHT;
k3d/share/shaders/k3d_parquet_plank2.sl:5: * DESCRIPTION:
k3d/share/shaders/k3d_parquet_plank2.sl:11: * PARAMETERS:
k3d/share/shaders/k3d_parquet_plank2.sl:67:  float PGWIDTH, PGHEIGHT, GWF, GHF;
k3d/share/shaders/k3d_parquet_plank2.sl:70:  PGWIDTH = plankwidth+groovewidth;
k3d/share/shaders/k3d_parquet_plank2.sl:71:  planklength = PGWIDTH * plankspertile - groovewidth;
k3d/share/shaders/k3d_parquet_plank2.sl:72:  PGHEIGHT = planklength+groovewidth;
k3d/share/shaders/k3d_parquet_plank2.sl:73:  GWF = groovewidth*0.5/PGWIDTH;
k3d/share/shaders/k3d_parquet_plank2.sl:74:  GHF = groovewidth*0.5/PGHEIGHT;
k3d/share/shaders/k3d_parquet_plank2.sl:77:  swidth = (max (abs(Du(s)*du) + abs(Dv(s)*dv), MINFILTERWIDTH) / PGWIDTH) * txtscale;
k3d/share/shaders/k3d_parquet_plank2.sl:78:  twidth = (max (abs(Du(t)*du) + abs(Dv(t)*dv), MINFILTERWIDTH) / PGHEIGHT) * txtscale;
k3d/share/shaders/k3d_parquet_plank2.sl:83:  ss = (txtscale * s) / PGWIDTH;
k3d/share/shaders/k3d_parquet_plank2.sl:85:  tt = (txtscale * t) / PGHEIGHT;
k3d/share/shaders/k3d_parquet_plank2.sl:88:      ss = txtscale * t / PGWIDTH;
k3d/share/shaders/k3d_parquet_plank2.sl:90:      tt = txtscale * s / PGHEIGHT;
k3d/share/shaders/k3d_parquet_tile.sl:2: * DWParquetTile.sl -- yet another surface shader for wood
k3d/share/shaders/k3d_parquet_tile.sl:6: * DESCRIPTION:
k3d/share/shaders/k3d_parquet_tile.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_parquet_tile.sl:53: *   - name from LGParquetPlank to DWParquetTile
k3d/share/shaders/k3d_parquet_tile.sl:82:  float PGWIDTH, PGHEIGHT, GWF, GHF;
k3d/share/shaders/k3d_parquet_tile.sl:85:  PGWIDTH = plankwidth+groovewidth;
k3d/share/shaders/k3d_parquet_tile.sl:86:  planklength = PGWIDTH * plankspertile - groovewidth;
k3d/share/shaders/k3d_parquet_tile.sl:87:  PGHEIGHT = planklength+groovewidth;
k3d/share/shaders/k3d_parquet_tile.sl:88:  GWF = groovewidth*0.5/PGWIDTH;
k3d/share/shaders/k3d_parquet_tile.sl:89:  GHF = groovewidth*0.5/PGHEIGHT;
k3d/share/shaders/k3d_parquet_tile.sl:92:  swidth = (max (abs(Du(s)*du) + abs(Dv(s)*dv), MINFILTERWIDTH) / PGWIDTH) * txtscale;
k3d/share/shaders/k3d_parquet_tile.sl:93:  twidth = (max (abs(Du(t)*du) + abs(Dv(t)*dv), MINFILTERWIDTH) / PGHEIGHT) * txtscale;
k3d/share/shaders/k3d_parquet_tile.sl:98:  ss = (txtscale * s) / PGWIDTH;
k3d/share/shaders/k3d_parquet_tile.sl:100:  tt = (txtscale * t) / PGHEIGHT;
k3d/share/shaders/k3d_parquet_tile.sl:103:      ss = txtscale * t / PGWIDTH;
k3d/share/shaders/k3d_parquet_tile.sl:105:      tt = txtscale * s / PGHEIGHT;
k3d/share/shaders/k3d_planetclouds.sl:5: * DESCRIPTION:
k3d/share/shaders/k3d_planetclouds.sl:13: * PARAMETERS:
k3d/share/shaders/k3d_planetclouds.sl:45: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_planetclouds.sl:46: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_planetclouds.sl:47: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_planetclouds.sl:56:#define TWOPI (2*PI)
k3d/share/shaders/k3d_planetclouds.sl:58:/* Use signed Perlin noise */
k3d/share/shaders/k3d_planetclouds.sl:61:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_planetclouds.sl:71:  point Pdistortion;		/* "distortion" vector */
k3d/share/shaders/k3d_planetclouds.sl:72:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_planetclouds.sl:77:  PP = transform("shader", P);
k3d/share/shaders/k3d_planetclouds.sl:80:  Pdistortion = distortionscale * DNoise(PP);
k3d/share/shaders/k3d_planetclouds.sl:82:  PP = PP + Pdistortion;
k3d/share/shaders/k3d_planetclouds.sl:90:      a += o * VLNoise(PP * l, 1);
k3d/share/shaders/k3d_plank.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_plank.sl:8: * PARAMETERS:
k3d/share/shaders/k3d_plank.sl:50:  float PGWIDTH, PGHEIGHT, GWF, GHF;
k3d/share/shaders/k3d_plank.sl:52:  PGWIDTH = plankwidth + groovewidth;
k3d/share/shaders/k3d_plank.sl:53:  PGHEIGHT = planklength + groovewidth;
k3d/share/shaders/k3d_plank.sl:54:  GWF = groovewidth * 0.5 / PGWIDTH;
k3d/share/shaders/k3d_plank.sl:55:  GHF = groovewidth * 0.5 / PGHEIGHT;
k3d/share/shaders/k3d_plank.sl:60:	MINFILTERWIDTH) / PGWIDTH * txtscale;
k3d/share/shaders/k3d_plank.sl:63:	MINFILTERWIDTH) / PGHEIGHT * txtscale;
k3d/share/shaders/k3d_plank.sl:68:  ss = txtscale * s / PGWIDTH;
k3d/share/shaders/k3d_plank.sl:72:  tt = (txtscale * t / PGHEIGHT) + 10 * snoise(0.5 + whichrow);
k3d/share/shaders/k3d_plastic.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_plastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_plastic.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_plastic.sl:6: * RenderMan (R) is a registered trademark of Pixar.
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_plastic2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_plastic2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_plastic2.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_pointlight.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_pointlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_pointlight.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_pointlight.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_projectionmap_plastic.sl:7:// modify it under the terms of the GNU General Public
k3d/share/shaders/k3d_projectionmap_plastic.sl:13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
k3d/share/shaders/k3d_projectionmap_plastic.sl:14:// General Public License for more details.
k3d/share/shaders/k3d_projectionmap_plastic.sl:16:// You should have received a copy of the GNU General Public
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:47:			point Pshad = transform("shader", P);
k3d/share/shaders/k3d_projectionmap_plastic.sl:49:			float x = xfreq * (xcomp(Pshad) - xoffset + 0.5);
k3d/share/shaders/k3d_projectionmap_plastic.sl:50:			float y = yfreq * (ycomp(Pshad) - yoffset + 0.5);
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:7: * DESCRIPTION:
k3d/share/shaders/k3d_puffyclouds.sl:15: * PARAMETERS:
k3d/share/shaders/k3d_puffyclouds.sl:30: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_puffyclouds.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_puffyclouds.sl:32: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_puffyclouds.sl:43:/* Use signed Perlin noise */
k3d/share/shaders/k3d_puffyclouds.sl:58:  point PP;      /* Surface point in shader space */
k3d/share/shaders/k3d_puffyclouds.sl:61:  PP = txtscale * transform ("shader", P);
k3d/share/shaders/k3d_puffyclouds.sl:64:/*  value = fBm (PP, omega, lambda, octaves); */
k3d/share/shaders/k3d_puffyclouds.sl:68:      a += o * snoise (PP*l);
k3d/share/shaders/k3d_redapple.sl:25: * pictures, job offers at Pixar, etc... to:  jmerritt@SpamSucks_warpax.com   :-)
k3d/share/shaders/k3d_redapple.sl:63:	point PP, newP;
k3d/share/shaders/k3d_redapple.sl:82:	PP = transform("shader", P);
k3d/share/shaders/k3d_redapple.sl:87:	 * Pick the base color for the apple.
k3d/share/shaders/k3d_redapple.sl:102:	#define BASE_NOISE_AMP   0.2    /* small noise color mix amplitude */
k3d/share/shaders/k3d_redapple.sl:109:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:112:	small_noise = snoise(BASE_NF*PP*txtscale/TSCALE);
k3d/share/shaders/k3d_redapple.sl:114:	                    (small_noise*BASE_NOISE_AMP));
k3d/share/shaders/k3d_redapple.sl:129:	 * Pick the blotch color.
k3d/share/shaders/k3d_redapple.sl:140:	#define BLOTCH_SPECK_COEFF 0.3  /* blotch specking coeff  */
k3d/share/shaders/k3d_redapple.sl:141:	blotch_turb = noise(BLOTCH_SF*sin(2*PI*(s+.1234)) + PI + label,
k3d/share/shaders/k3d_redapple.sl:146:	         small_noise * BLOTCH_SPECK_COEFF;
k3d/share/shaders/k3d_redapple.sl:159:	#define SPECK_NF        50    /* A noise scaling factor      */
k3d/share/shaders/k3d_redapple.sl:160:	#define SPECK_CUTOFF    .45   /* Cutoff for 'tops' of specks */
k3d/share/shaders/k3d_redapple.sl:161:	speck = pow(smoothstep(SPECK_CUTOFF, 1,
k3d/share/shaders/k3d_redapple.sl:162:	            noise(SPECK_NF*PP*txtscale/TSCALE)), 3);
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:196:	#define DISP_DENT_AMP     (1/15)   /* dent amplitude          */
k3d/share/shaders/k3d_redapple.sl:197:	#define DISP_SMNOISE_AMP  (1/1000) /* small noise amplitude   */
k3d/share/shaders/k3d_redapple.sl:198:	#define DISP_SPECK_AMP    (1/40)   /* speckle disp. amplitude */
k3d/share/shaders/k3d_redapple.sl:199:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:200:	              DISP_TF*t + label) * DISP_DENT_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_redapple.sl:201:	disp += small_noise * DISP_SMNOISE_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_redapple.sl:202:	disp -= speck * DISP_SPECK_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_redapple.sl:203:	newP = calculatenormal(P + disp * normalize(N));
k3d/share/shaders/k3d_redapple.sl:204:	Nf = faceforward(normalize(newP), I);
k3d/share/shaders/k3d_redapple.sl:220:		reflect = RayTrace(P, Rdir, 0, 1, 1);
k3d/share/shaders/k3d_ridged_multifractal.sl:7: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,

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:9: *    Academic Press, 1998.  ISBN 0-12-228730-4.

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

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

k3d/share/shaders/k3d_ridged_multifractal.sl:37:          		PP.x *= lacunarity;

k3d/share/shaders/k3d_ridged_multifractal.sl:38:          		PP.y *= lacunarity;

k3d/share/shaders/k3d_ridged_multifractal.sl:39:          		PP.z *= lacunarity;

k3d/share/shaders/k3d_ridged_multifractal.sl:41:			PP = PP * lacunarity;

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

k3d/share/shaders/k3d_ridged_multifractal.sl:62:	P+= Nn*result*Kt;

k3d/share/shaders/k3d_ridged_multifractal.sl:63:  	N = calculatenormal(P);	

k3d/share/shaders/k3d_ripple.sl:20:  P += 1 + N * amplitude * (2 - abs (sin(2*PI*(s/wavelength))));

k3d/share/shaders/k3d_ripple.sl:21:  N = calculatenormal(P);

k3d/share/shaders/k3d_roughmetal.sl:7: * Parameters:
k3d/share/shaders/k3d_roughmetal.sl:11: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_roughmetal.sl:12: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_roughmetal.sl:13: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_round.sl:1:/* Copyrighted Pixar 1989 */
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:24:		dpdu = dPdu;
k3d/share/shaders/k3d_round.sl:27:		dpdu = -dPdu;
k3d/share/shaders/k3d_round.sl:31:		dpdv = dPdv;
k3d/share/shaders/k3d_round.sl:34:		dpdv = -dPdv;
k3d/share/shaders/k3d_round.sl:38:	lu = length(dPdu*uu);
k3d/share/shaders/k3d_round.sl:39:	lv = length(dPdv*vv);
k3d/share/shaders/k3d_round.sl:56:		center += P - radius*normalize(N);
k3d/share/shaders/k3d_round.sl:57:		/* Make P be distance 'radius' along the line 
k3d/share/shaders/k3d_round.sl:58:                 * from 'center' to P */
k3d/share/shaders/k3d_round.sl:59:		P = center + radius*normalize( P-center );
k3d/share/shaders/k3d_round.sl:61:	N = calculatenormal(P);
k3d/share/shaders/k3d_rubber.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_rubber.sl:16:		Ploc = transform("shader", P);  /* Move to shader space */
k3d/share/shaders/k3d_rubber.sl:20:	cout = mix(Cs, white, .05* (float noise(txtscale*Ploc)));
k3d/share/shaders/k3d_ruledpaper.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_ruledpaper.sl:9: * PARAMETERS:
k3d/share/shaders/k3d_ruledpaper.sl:48:	/* Paper anatomy settings */
k3d/share/shaders/k3d_ruledpaper.sl:49:	// Paper width
k3d/share/shaders/k3d_ruledpaper.sl:51:	// Paper height 
k3d/share/shaders/k3d_rustymetal.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_rustymetal.sl:11: * PARAMETERS
k3d/share/shaders/k3d_rustymetal.sl:34:/* Signed noise varies from -1 to 1 (like Perlin uses) */
k3d/share/shaders/k3d_rustymetal.sl:54:  point PP;                    /* shade space point */
k3d/share/shaders/k3d_rustymetal.sl:61:   * number of octaves by the estimated change in PP between adjacent
k3d/share/shaders/k3d_rustymetal.sl:64:  PP = txtscale * transform ("shader", P);
k3d/share/shaders/k3d_rustymetal.sl:65:  alimit = sqrt (area(PP));
k3d/share/shaders/k3d_rustymetal.sl:67:      sum += a * abs(snoise(PP));
k3d/share/shaders/k3d_rustymetal.sl:68:      PP *= 2;
k3d/share/shaders/k3d_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
k3d/share/shaders/k3d_rustymetal.sl:78:  rustiness *= clamp (abs(snoise(PP)), 0, .08) / 0.08;
k3d/share/shaders/k3d_saturn.sl:8: * DESCRIPTION:
k3d/share/shaders/k3d_saturn.sl:14: * PARAMETERS:
k3d/share/shaders/k3d_saturn.sl:49:  point PP;
k3d/share/shaders/k3d_saturn.sl:50:  point PtN;
k3d/share/shaders/k3d_saturn.sl:53:  point Ptexture;
k3d/share/shaders/k3d_saturn.sl:56:  Ptexture = transform ("shader", P);
k3d/share/shaders/k3d_saturn.sl:57:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_saturn.sl:64:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_saturnring.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_saturnring.sl:8: * PARAMETERS:
k3d/share/shaders/k3d_saturnring.sl:42:	point PP;       /* Transformed point */
k3d/share/shaders/k3d_saturnring.sl:44:	float val;      /* length of PP */
k3d/share/shaders/k3d_saturnring.sl:45:	float relpos;   /* relative position of PP on disk 
k3d/share/shaders/k3d_saturnring.sl:54:	PP = transform ("shader", P);
k3d/share/shaders/k3d_saturnring.sl:55:	val= length (PP);
k3d/share/shaders/k3d_scartissue.sl:14:	point Psh = transform("object",P);
k3d/share/shaders/k3d_scartissue.sl:25:		nz += abs(.5 - noise( (freq * Psh)+offset)) / freq;
k3d/share/shaders/k3d_scartissue.sl:30:	P += Nn*nz*.3;
k3d/share/shaders/k3d_scartissue.sl:31:	N = calculatenormal(P);
k3d/share/shaders/k3d_screen.sl:2: * (c) Pixar (appears in _RenderMan Companion_)
k3d/share/shaders/k3d_screen.sl:5: * DESCRIPTION:
k3d/share/shaders/k3d_screen.sl:10: * PARAMETERS:
k3d/share/shaders/k3d_screen.sl:18: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_screen.sl:19: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_screen.sl:20: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_screen_aa.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_screen_aa.sl:10: * PARAMETERS:
k3d/share/shaders/k3d_screen_aa.sl:20: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_screen_aa.sl:21: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_screen_aa.sl:22: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_sdixon.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_sdixon.sl:3:/* Listing 16.37  Pencil-labeling surface shader*/
k3d/share/shaders/k3d_sdixon.sl:6: * sdixon(): Paint the body of a pencil.
k3d/share/shaders/k3d_shadowdistant_rim.sl:20:                Cl *= 1 - shadow(shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_shadowspot.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_shadowspot.sl:32:		    attenuation *= (1.0 - shadow( shadowfile, Ps, "samples", samples, "blur", blur, "bias", bias ));
k3d/share/shaders/k3d_shifteddrtile.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_shifteddrtile.sl:8: * PARAMETERS:
k3d/share/shaders/k3d_shifteddrtile.sl:33:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shifteddrtile.sl:91:		mix_opacity = smoothPulse (innerRadius, outerRadius, fuzz, d);
k3d/share/shaders/k3d_shiftedmoontile.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_shiftedmoontile.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_shiftedmoontile.sl:28:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shiftedmoontile.sl:64:	float d, d2;             /* Point distance from circle1, circle2 */
k3d/share/shaders/k3d_shiny.sl:4: * Parameters:
k3d/share/shaders/k3d_shiny.sl:20: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
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_shiny.sl:34:		  float Kr = 0.8, blur = 0; DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_shiny.sl:40:		       ENVPARAMS);
k3d/share/shaders/k3d_shinymetal.sl:3: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_shinymetal.sl:5: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_shinymetal.sl:6: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_shinymetal.sl:7: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_shinyplastic.sl:4: * Parameters:
k3d/share/shaders/k3d_shinyplastic.sl:29:			 DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_shinyplastic.sl:35:    MaterialShinyPlastic(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, ior,
k3d/share/shaders/k3d_shinyplastic.sl:36:			 twosided, ENVPARAMS);
k3d/share/shaders/k3d_show_st.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_skin1.sl:16: * PARAMETERS
k3d/share/shaders/k3d_skin1.sl:57: * Graphics 26(2) (Proceedings of Siggraph '92), pp. 265-272, July, 1992.
k3d/share/shaders/k3d_skin1.sl:71:    extern point P;
k3d/share/shaders/k3d_skin1.sl:72:    illuminance (P, N, PI/2) {
k3d/share/shaders/k3d_skin1.sl:92:/* ------ ADAPTED FROM Mat Pahr's Skin.sl------
k3d/share/shaders/k3d_skin1.sl:139:  extern point P;
k3d/share/shaders/k3d_skin1.sl:145:  illuminance(P, Nn, PI/2) {
k3d/share/shaders/k3d_skin1.sl:182:  varying vector xdir = dPdu;
k3d/share/shaders/k3d_skin1.sl:200:  point PP;
k3d/share/shaders/k3d_skin1.sl:211:  PP = transform ("shader",P) * poresfreq;
k3d/share/shaders/k3d_skin1.sl:214:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:220:  NN = calculatenormal(P + turb * normalize(N));
k3d/share/shaders/k3d_skin1.sl:238:  PP = transform ("shader",P) * blemishfreq;
k3d/share/shaders/k3d_skin1.sl:241:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin2.sl:4: * Copyright (C) 2000-2001, Matt Pharr <mmp@SpamSucks_Exluna.com> 
k3d/share/shaders/k3d_skin2.sl:15: * See SIGGRAPH 2001 course notes, "Advanced RenderMan 3: Render Harder,"
k3d/share/shaders/k3d_skin2.sl:65:	extern point P;
k3d/share/shaders/k3d_skin2.sl:71:	illuminance(P, Nn, PI/2) {
k3d/share/shaders/k3d_slateroof.sl:1:/* Renamed to PQslateroof.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroof.sl:10:	darker than the next Parameters:
k3d/share/shaders/k3d_slateroof.sl:34: 	Peter Quint 17/11/2000
k3d/share/shaders/k3d_slateroofd.sl:1:/* Renamed to PQslateroofd.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroofd.sl:7:    	Parameters:
k3d/share/shaders/k3d_slateroofd.sl:38:		Peter Quint 17/11/2000
k3d/share/shaders/k3d_slateroofd.sl:176:	P += Nf * (disp / max(spacescale, 1e-6));
k3d/share/shaders/k3d_slateroofd.sl:178:   N = calculatenormal(P);
k3d/share/shaders/k3d_slideprojector.sl:19:  float Pt, Pu, Pv, sloc, tloc;
k3d/share/shaders/k3d_slideprojector.sl:25:    L = Ps - from;
k3d/share/shaders/k3d_slideprojector.sl:26:    Pt = L.Z;
k3d/share/shaders/k3d_slideprojector.sl:27:    Pu = L.X;
k3d/share/shaders/k3d_slideprojector.sl:28:    Pv = L.Y;
k3d/share/shaders/k3d_slideprojector.sl:30:    sloc = spread * Pu / Pt;
k3d/share/shaders/k3d_slideprojector.sl:31:    tloc = spread * Pv / Pt;
k3d/share/shaders/k3d_smoke.sl:8: * Parameters:
k3d/share/shaders/k3d_smoke.sl:30:/* For point P (we are passed both the current and shader space
k3d/share/shaders/k3d_smoke.sl:35:void smokedensity(point Pcur, Pshad;
k3d/share/shaders/k3d_smoke.sl:41:  illuminance(Pcur)
k3d/share/shaders/k3d_smoke.sl:51:      point Psmoke = Pshad * smokefreq;
k3d/share/shaders/k3d_smoke.sl:53:      smoke = snoise(Psmoke);
k3d/share/shaders/k3d_smoke.sl:57:	  0.5 * fBm(Psmoke * 2, stepsize * 2, smokeoctaves - 1, 2, 0.5);
k3d/share/shaders/k3d_smoke.sl:83:  point Worigin = P - I;	/* Origin of volume ray */
k3d/share/shaders/k3d_smoke2.sl:9: * Parameters:
k3d/share/shaders/k3d_smoke2.sl:51:#define GADD(PP,PW,li,g)                                                    \
k3d/share/shaders/k3d_smoke2.sl:54:	     illuminance (PW, point(0,0,1), PI) { li += Cl; }               \
k3d/share/shaders/k3d_smoke2.sl:57:             Psmoke = PP*freq;                                              \
k3d/share/shaders/k3d_smoke2.sl:58:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_smoke2.sl:63:                      f *= 0.5;  Psmoke *= 2;                               \
k3d/share/shaders/k3d_smoke2.sl:64:                      smoke += f*snoise(Psmoke);                            \
k3d/share/shaders/k3d_smoke2.sl:89:  point Worigin = P + I;
k3d/share/shaders/k3d_smoke2.sl:91:#else  /* PRMan and BMRT have I reverse of each other, conflict in spec */
k3d/share/shaders/k3d_smoke2.sl:92:  point Worigin = P - I;
k3d/share/shaders/k3d_smoke2.sl:103:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_smoke2.sl:114:      PP = origin + d * IN;
k3d/share/shaders/k3d_smoke2.sl:115:      PW = Worigin + d * WIN;
k3d/share/shaders/k3d_smoke2.sl:116:      GADD (PP, PW, li, dtau)
k3d/share/shaders/k3d_smoke2.sl:124:	  PP = origin + d*IN;
k3d/share/shaders/k3d_smoke2.sl:125:	  PW = Worigin + d*WIN;
k3d/share/shaders/k3d_smoke2.sl:126:	  GADD (PP, PW, li, dtau)
k3d/share/shaders/k3d_softboxes.sl:39:#define SPHERICAL 1
k3d/share/shaders/k3d_softboxes.sl:86:    varying point	surfPt;
k3d/share/shaders/k3d_softboxes.sl:111:    varying point Pb1 = transform (boxCoords, surfPt);
k3d/share/shaders/k3d_softboxes.sl:114:    varying point Pplane = Pb1 - Vlight*(zcomp(Pb1)/zcomp(Vlight));
k3d/share/shaders/k3d_softboxes.sl:130:    if (sign(zcomp(Pb1)) == sign(zcomp(Vlight))) {
k3d/share/shaders/k3d_softboxes.sl:135:	contrib = 1 - clipSuperellipse (Pplane, iW, iH, oW,oH, boxRoundness);
k3d/share/shaders/k3d_softboxes.sl:139:	    varying float theS = (oW+xcomp(Pplane))/(oW*2);
k3d/share/shaders/k3d_softboxes.sl:140:	    varying float theT = (oH-ycomp(Pplane))/(oH*2);
k3d/share/shaders/k3d_softboxes.sl:165:    varying point ppC = transform(boxCoords,"world",Pplane);
k3d/share/shaders/k3d_softboxes.sl:166:    varying point spw = transform("world",surfPt);
k3d/share/shaders/k3d_softboxes.sl:179:    varying point	thePoint;
k3d/share/shaders/k3d_softboxes.sl:188:			    thePoint,
k3d/share/shaders/k3d_softboxes.sl:320:	uniform point metP = transform(meterSpace,"shader",point (0,0,0));
k3d/share/shaders/k3d_softboxes.sl:321:	adjMeterDistance = length(metP) + meterDistance;
k3d/share/shaders/k3d_softboxes.sl:361:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:373:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:385:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:397:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:411:		if (EnvType == SPHERICAL) {
k3d/share/shaders/k3d_softboxes.sl:413:		    varying point PShd = transform (theEnvSpace, Ps);
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:467:	    shadowed = sbShadow(shadowname,Ps,shadowfilt,
k3d/share/shaders/k3d_softboxes.sl:472:	    shadowed = sbShadow(shadownameb,Ps,shadowfiltb,
k3d/share/shaders/k3d_softboxes.sl:477:	    shadowed = sbShadow(shadownamec,Ps,shadowfiltc,
k3d/share/shaders/k3d_softboxes.sl:482:	    shadowed = sbShadow(shadownamed,Ps,shadowfiltd,
k3d/share/shaders/k3d_spacecloud.sl:6: * DESCRIPTION:
k3d/share/shaders/k3d_spacecloud.sl:9: * PARAMETERS:
k3d/share/shaders/k3d_spacecloud.sl:11: *   startPulse -- start of pulse function.
k3d/share/shaders/k3d_spacecloud.sl:12: *   endPulse -- end of pulse function
k3d/share/shaders/k3d_spacecloud.sl:43:#define smoothPulse2Fuzz(a, b, afuzz, bfuzz, loc) \
k3d/share/shaders/k3d_spacecloud.sl:49:  float startPulse = .2; /* .1 .2 .3 .01 */
k3d/share/shaders/k3d_spacecloud.sl:50:  float endPulse = .9; /* .9 .8 .7 .8 */
k3d/share/shaders/k3d_spacecloud.sl:61:  point PP;
k3d/share/shaders/k3d_spacecloud.sl:72:	PP = transform ("object", P);
k3d/share/shaders/k3d_spacecloud.sl:75:    value += abs(snoise (PP * f))/f;
k3d/share/shaders/k3d_spacecloud.sl:82:	fBm (P, noiseScale, octaves, PP, freq, i, size, adjust);
k3d/share/shaders/k3d_spacecloud.sl:92:	Oi = value * smoothPulse2Fuzz (startPulse, endPulse, afuzz, afuzz, ss) * 
k3d/share/shaders/k3d_spacecloud.sl:93:		smoothPulse2Fuzz (startPulse, endPulse, bfuzz, afuzz, tt);
k3d/share/shaders/k3d_spaceshiphull1.sl:45:  platecolor -= grime * fractalsum(P);
k3d/share/shaders/k3d_spotlight.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_spotlight.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_spotlight.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_spotlight.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_square_ridges.sl:7:// modify it under the terms of the GNU General Public
k3d/share/shaders/k3d_square_ridges.sl:13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
k3d/share/shaders/k3d_square_ridges.sl:14:// General Public License for more details.
k3d/share/shaders/k3d_square_ridges.sl:16:// You should have received a copy of the GNU General Public
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:67:	P += Nn * ((Km * ridge_position) / length(vtransform("shader", Nn)));
k3d/share/shaders/k3d_square_ridges.sl:68://	P += Km * ridge_position * N;
k3d/share/shaders/k3d_square_ridges.sl:69:	N = calculatenormal(P);
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:13:   measured by the change in diffuse lighting from the Pref to P.
k3d/share/shaders/k3d_srfdeformation.sl:36:fnc_projectCurrentCamera(point P;
k3d/share/shaders/k3d_srfdeformation.sl:39:    point Pndc = transform("NDC", P);
k3d/share/shaders/k3d_srfdeformation.sl:41:    X = xcomp(Pndc);
k3d/share/shaders/k3d_srfdeformation.sl:42:    Y = ycomp(Pndc);
k3d/share/shaders/k3d_srfdeformation.sl:51:				   2 = output lighting of the P object
k3d/share/shaders/k3d_srfdeformation.sl:52:				   3 = output lighting of the Pref object
k3d/share/shaders/k3d_srfdeformation.sl:56:    varying point Pref = point "shader" (0,0,0);
k3d/share/shaders/k3d_srfdeformation.sl:64:    point Porig = Pref;
k3d/share/shaders/k3d_srfdeformation.sl:66:    fnc_projectCurrentCamera(Pref, x, y);
k3d/share/shaders/k3d_srfdeformation.sl:73:    /* Calculate shading difference between P and Porig*/
k3d/share/shaders/k3d_srfdeformation.sl:75:    N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_srfdeformation.sl:77:    N = normalize(calculatenormal(Porig));
k3d/share/shaders/k3d_srfdeformation.sl:85:    illuminance(P, N1, radians(illum_width)) {
k3d/share/shaders/k3d_srfdeformation.sl:89:    illuminance(Porig, N2, radians(illum_width)) {
k3d/share/shaders/k3d_srfdeformation.sl:100:    } else if (debug == 2) { /* output texture with P's lighting */
k3d/share/shaders/k3d_srfdeformation.sl:102:    } else if (debug == 3) { /* output texture with Pref's lighting */
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_star.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_star.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_star.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_star.sl:30:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_star.sl:38:    angle = atan(ss, tt) + PI;
k3d/share/shaders/k3d_starfield.sl:1:/* DESCRIPTION:
k3d/share/shaders/k3d_starfield.sl:6:	PARAMETERS:
k3d/share/shaders/k3d_starfield.sl:14:	point PP = transform("object", frequency * P);
k3d/share/shaders/k3d_starfield.sl:17:	point star_center = point(0.5 * (floor(xcomp(PP)) + ceil(xcomp(PP))), 0.5 * (floor(ycomp(PP)) + ceil(ycomp(PP))), 0.5 * (floor(zcomp(PP)) + ceil(zcomp(PP))));
k3d/share/shaders/k3d_starfield.sl:22:	float star_distance = distance(PP, star_center);
k3d/share/shaders/k3d_stones.sl:25: * grungefreq, grunge_Pow, grunginess = freqeuncy, power and depth of grunge
k3d/share/shaders/k3d_stones.sl:90:          grungefreq = 30, grunge_Pow = 3, grunginess = - 0.8;
k3d/share/shaders/k3d_stones.sl:115:   angle = PI * snoise(freq * 16.31456);  /*randomize angle index*/
k3d/share/shaders/k3d_stones.sl:160:       point PP = transform("shader", P) * grungefreq;
k3d/share/shaders/k3d_stones.sl:161:       float width = filterwidth_point(PP);
k3d/share/shaders/k3d_stones.sl:166:        turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:168:        turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:170:        grunge = pow(turb, grunge_Pow);
k3d/share/shaders/k3d_stones.sl:177:  P += Km * surface_mag * normalize(N);
k3d/share/shaders/k3d_stones.sl:178:  N = normalize(calculatenormal(P)); 
k3d/share/shaders/k3d_stones.sl:181:  N = normalize(calculatenormal(P + Km * surface_mag * normalize(N)));
k3d/share/shaders/k3d_strata.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_strata.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_strata.sl:24: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_strata.sl:25: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_strata.sl:26: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_strata.sl:35:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_strata.sl:43:  point PP;
k3d/share/shaders/k3d_strata.sl:47:  PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_strata.sl:53:      turb += abs(snoise(PP * freq) / freq);
k3d/share/shaders/k3d_strata.sl:57:  cmap = yscale * ycomp(PP) + turbscale * turb - offset;
k3d/share/shaders/k3d_stucco.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_stucco.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_stucco.sl:20:  point PP;
k3d/share/shaders/k3d_stucco.sl:22:  PP = transform("shader", P);
k3d/share/shaders/k3d_stucco.sl:23:  magnitude = Km * pow(noise(PP * frequency), power);
k3d/share/shaders/k3d_stucco.sl:24:  P += magnitude * normalize(N);
k3d/share/shaders/k3d_stucco.sl:25:  N = calculatenormal(P);
k3d/share/shaders/k3d_superkagee.sl:15:    varying point       thePoint;
k3d/share/shaders/k3d_superkagee.sl:24:#define SHADPOINT thePoint
k3d/share/shaders/k3d_superkagee.sl:26:                            SHADPOINT,
k3d/share/shaders/k3d_superkagee.sl:77:        shadowed = clamp(shadowdensitya,0,1) * do_shadow6(shadownamea,P,
k3d/share/shaders/k3d_superkagee.sl:84:        shadowed = clamp(shadowdensityb,0,1) * do_shadow6(shadownameb,P,
k3d/share/shaders/k3d_superkagee.sl:91:        shadowed = clamp(shadowdensityc,0,1) * do_shadow6(shadownamec,P,
k3d/share/shaders/k3d_superkagee.sl:98:        shadowed = clamp(shadowdensityd,0,1) * do_shadow6(shadownamed,P,
k3d/share/shaders/k3d_superplank.sl:11: * Parameters:
k3d/share/shaders/k3d_superplank.sl:52:surface k3d_superplank(		/* Parameters: */
k3d/share/shaders/k3d_superplank.sl:64:			/* Plank layout */
k3d/share/shaders/k3d_superplank.sl:91:  /* Planks & grooves */
k3d/share/shaders/k3d_superplank.sl:92:  uniform float PGWIDTH, PGHEIGHT, GWF, GHF;
k3d/share/shaders/k3d_superplank.sl:111:  point Pndc;			/* NDC coordinate of P */
k3d/share/shaders/k3d_superplank.sl:137:  overallscale = (length(Deriv(P, ss)));
k3d/share/shaders/k3d_superplank.sl:141:   * 2. Plank pattern.
k3d/share/shaders/k3d_superplank.sl:149:      PGWIDTH = plankwidth + groovewidth;
k3d/share/shaders/k3d_superplank.sl:150:      PGHEIGHT = planklength + groovewidth;
k3d/share/shaders/k3d_superplank.sl:151:      plank_s = ss / PGWIDTH;
k3d/share/shaders/k3d_superplank.sl:154:      plank_t = tt / PGHEIGHT + 20 * plankstagger * cellnoise(whichrow);
k3d/share/shaders/k3d_superplank.sl:159:      /* Parquet pattern */
k3d/share/shaders/k3d_superplank.sl:160:      PGWIDTH = plankwidth + groovewidth;
k3d/share/shaders/k3d_superplank.sl:161:      PGHEIGHT = PGWIDTH * plankspertile;
k3d/share/shaders/k3d_superplank.sl:162:      plank_s = ss / PGWIDTH;
k3d/share/shaders/k3d_superplank.sl:164:      plank_t = tt / PGHEIGHT;
k3d/share/shaders/k3d_superplank.sl:168:	  plank_s = tt / PGWIDTH;
k3d/share/shaders/k3d_superplank.sl:169:	  plank_t = ss / PGHEIGHT;
k3d/share/shaders/k3d_superplank.sl:188:  GWF = groovewidth * 0.5 / PGWIDTH;
k3d/share/shaders/k3d_superplank.sl:189:  GHF = groovewidth * 0.5 / PGHEIGHT;
k3d/share/shaders/k3d_superplank.sl:190:  sw = swidth / PGWIDTH;
k3d/share/shaders/k3d_superplank.sl:191:  tw = twidth / PGHEIGHT;
k3d/share/shaders/k3d_superplank.sl:283:      N = calculatenormal(P + (Km * shadlen * disp) * NN);
k3d/share/shaders/k3d_superplank.sl:300:  illuminance(P, Nf, PI / 2)
k3d/share/shaders/k3d_superplank.sl:321:	  Pndc = transform("NDC", P);
k3d/share/shaders/k3d_superplank.sl:323:	    fresnelKr * specularcolor * texture(reflmap, xcomp(Pndc),
k3d/share/shaders/k3d_superplank.sl:324:						1 - ycomp(Pndc));
k3d/share/shaders/k3d_superplank.sl:327:	Ci += Ktrace * fresnelKr * specularcolor * trace(P, R);
k3d/share/shaders/k3d_superpplastic.sl:2: * (c) Copyright 1988, Pixar.
k3d/share/shaders/k3d_superpplastic.sl:4: * The RenderMan (R) Interface Procedures and RIB Protocol are:
k3d/share/shaders/k3d_superpplastic.sl:5: *     Copyright 1988, 1989, Pixar.  All rights reserved.
k3d/share/shaders/k3d_superpplastic.sl:6: * RenderMan (R) is a registered trademark of Pixar.
k3d/share/shaders/k3d_superpplastic.sl:8: * DESCRIPTION:
k3d/share/shaders/k3d_superpplastic.sl:12: * PARAMETERS:
k3d/share/shaders/k3d_supertexmap.sl:10: * Parameters:
k3d/share/shaders/k3d_supertexmap.sl:25: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_supertexmap.sl:78:      ApplyColorTextureOver(Ct, Csmapname, Csproj, P, Csspace,
k3d/share/shaders/k3d_supertexmap.sl:84:      ApplyColorTextureOver(Ct, Osmapname, Osproj, P, Osspace,
k3d/share/shaders/k3d_supertexmap.sl:90:      ApplyFloatTextureOver(Ks, Ksmapname, Ksproj, P, Ksspace,
k3d/share/shaders/k3d_supertexmap.sl:97:	ApplyFloatTextureOver(disp, dispmapname, dispproj, P, dispspace,
k3d/share/shaders/k3d_supertexmap.sl:104:  Ci = MaterialPlastic(Nf, Ct, Ka, Kd, ks, roughness);
k3d/share/shaders/k3d_terran.sl:10:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran.sl:15:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran.sl:35:  point PP;
k3d/share/shaders/k3d_terran.sl:36:  point PtN;
k3d/share/shaders/k3d_terran.sl:39:  point Ptexture, tp;
k3d/share/shaders/k3d_terran.sl:44:  Ptexture = transform("shader", P);
k3d/share/shaders/k3d_terran.sl:45:  PtN = normalize(Ptexture);	/* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran.sl:60:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terran.sl:68:      Ptexture += dist_scale * DNoise(Ptexture);
k3d/share/shaders/k3d_terran.sl:71:      tp = Ptexture;
k3d/share/shaders/k3d_terran.sl:100:  latitude = abs(ycomp(PtN));
k3d/share/shaders/k3d_terran.sl:144:	  PP = mottle_scale * Ptexture;
k3d/share/shaders/k3d_terran.sl:149:	      purt += o * snoise(l * PP);
k3d/share/shaders/k3d_terran2.sl:8: * DESCRIPTION:
k3d/share/shaders/k3d_terran2.sl:19: * PARAMETERS:
k3d/share/shaders/k3d_terran2.sl:66:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran2.sl:71:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran2.sl:98:  point PP;
k3d/share/shaders/k3d_terran2.sl:99:  point PtN;
k3d/share/shaders/k3d_terran2.sl:102:  point Ptexture, tp;
k3d/share/shaders/k3d_terran2.sl:107:  Ptexture = transform ("shader", P);
k3d/share/shaders/k3d_terran2.sl:108:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran2.sl:119:	  bumpy += o * snoise (l * Ptexture);
k3d/share/shaders/k3d_terran2.sl:126:      Ptexture += dist_scale * DNoise (Ptexture);
k3d/share/shaders/k3d_terran2.sl:128:      o = spectral_exp;  tp = Ptexture;
k3d/share/shaders/k3d_terran2.sl:155:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_terran2.sl:203:         PP = mottle_scale * Ptexture;
k3d/share/shaders/k3d_terran2.sl:206:	     purt += o * snoise (l * PP);
k3d/share/shaders/k3d_terranbump.sl:6:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terranbump.sl:11:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terranbump.sl:24:  point Ptexture, tp;
k3d/share/shaders/k3d_terranbump.sl:29:  Ptexture = transform("shader", P);
k3d/share/shaders/k3d_terranbump.sl:38:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terranbump.sl:46:      Ptexture += dist_scale * DNoise(Ptexture);
k3d/share/shaders/k3d_terranbump.sl:49:      tp = Ptexture;
k3d/share/shaders/k3d_terranbump.sl:68:    P += (bump_scale * bumpy) * normalize(Ng);
k3d/share/shaders/k3d_terranbump.sl:71:  N = calculatenormal(P);
k3d/share/shaders/k3d_texblender.sl:11:color altMaterialPlastic (normal Nf;  color basecolor,selftcolor,Rcolor,RFcolor;
k3d/share/shaders/k3d_texblender.sl:21:myEnvironment (point P;  vector R;  float Kr, blur;  DECLARE_ENVPARAMS;)
k3d/share/shaders/k3d_texblender.sl:27:            C = ReflMap (envname, P, blur, alpha);
k3d/share/shaders/k3d_texblender.sl:29:            C = Environment (envname, envspace, envrad, P, R, blur, alpha);
k3d/share/shaders/k3d_texblender.sl:34:    color Cray = RayTrace (P, R, Kr, sqrt(blur), rayjitter, raysamples, alpha);
k3d/share/shaders/k3d_texblender.sl:57:float tex_clouds(point P;float depth)
k3d/share/shaders/k3d_texblender.sl:65:		//val=val*(1-Karm)+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:66:		val=val+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:73:float tex_wood(point PP; float ringscale)
k3d/share/shaders/k3d_texblender.sl:77:    float my_t = zcomp(PP) / ringscale;
k3d/share/shaders/k3d_texblender.sl:78:    point PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_texblender.sl:79:    my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_texblender.sl:81:    PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_texblender.sl:82:    float r = ringscale * noise (PQ);
k3d/share/shaders/k3d_texblender.sl:85:    PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_texblender.sl:86:    float r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_texblender.sl:97:	transp=transform(space,P)*vector (scalex, scaley, scalez);
k3d/share/shaders/k3d_texblender.sl:153:		DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_texblender.sl:200:		env=myEnvironment(P,normalize(reflect(V,Nf)),1,Rblur,ENVPARAMS);
k3d/share/shaders/k3d_texblender.sl:206:		benv=myEnvironment(P,refract(V,Nf,(V.Nf > 0) ? 1.0/eta : eta),1,RFblur,ENVPARAMS);
k3d/share/shaders/k3d_texblender.sl:208:    Ci = altMaterialPlastic (Nf,Ct,Cselft,env,benv,
k3d/share/shaders/k3d_threads.sl:1:/* Copyrighted Pixar 1989 */
k3d/share/shaders/k3d_threads.sl:19:	magnitude = (sin( PI*2*(t*frequency + s + phase))+offset) * Km;
k3d/share/shaders/k3d_threads.sl:28:	P += normalize(N) * magnitude;
k3d/share/shaders/k3d_threads.sl:29:	N = calculatenormal(P);
k3d/share/shaders/k3d_tooledsteel.sl:15: *  PARAMETERS:
k3d/share/shaders/k3d_tooledsteel.sl:30: *			  angle in radians (i.e. PI*.5 = 90 degrees)
k3d/share/shaders/k3d_tooledsteel.sl:38:  extern point P;
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:49:  point Po = point(s*mult,t*mult,0);
k3d/share/shaders/k3d_tooledsteel.sl:50:  point Pou = Po +(udir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:51:  point Pov = Po +(vdir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:61:  setxcomp(trucell,floor(xcomp(Po))+.5);
k3d/share/shaders/k3d_tooledsteel.sl:62:  setycomp(trucell,floor(ycomp(Po))+.5);
k3d/share/shaders/k3d_tooledsteel.sl:74:	dist = distance(Po,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:77:	  valu = distance(Pou,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:78:	  valv = distance(Pov,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:94:    extern point P;
k3d/share/shaders/k3d_tooledsteel.sl:103:    illuminance (P, Nf, PI*.5) {
k3d/share/shaders/k3d_tooledsteel.sl:137:	point Po = transform("object",P);
k3d/share/shaders/k3d_tooledsteel.sl:144:	float Jspread = PI*(1/numsamples)*mapspread;
k3d/share/shaders/k3d_tooledsteel.sl:155:	      angle = PI*((i/numsamples)-.5)*mapspread;
k3d/share/shaders/k3d_toonmap.sl:17:string Paint_Map="";
k3d/share/shaders/k3d_toonmap.sl:18:color Paint_Color=(0.5, 0.5, 0.5); 
k3d/share/shaders/k3d_toonmap.sl:62:/** Texture_Paint_Map **/
k3d/share/shaders/k3d_toonmap.sl:68:if ( Paint_Map=="" ) 
k3d/share/shaders/k3d_toonmap.sl:70:temt_c3=Paint_Color;
k3d/share/shaders/k3d_toonmap.sl:76:temt_c3=texture(Paint_Map,temp_ss3,temp_tt3,"swidth",swidth3,"twidth",twidth3,"samples",samples3);
k3d/share/shaders/k3d_toonmap.sl:80:temt_c3=texture(Paint_Map[channel3],temp_ss3,temp_tt3,"swidth",swidth3,"twidth",twidth3,"samples",samples3);
k3d/share/shaders/k3d_toonmap.sl:113:illuminance(P, N, PI/2) {
k3d/share/shaders/k3d_toonmap.sl:139:illuminance(P, Nf, PI/2)
k3d/share/shaders/k3d_translucency.sl:6:* Author: Xavier Matia Bernasconi - The Chimney Pot -
k3d/share/shaders/k3d_translucency.sl:22:* Notes: Please send me any kind of suggestions or bugs.
k3d/share/shaders/k3d_translucency.sl:117:	illuminance (P, Nf, 1.57079632679489661923){
k3d/share/shaders/k3d_uberlight.sl:14: * Perhaps this is a new idea for some users, but it isn't really
k3d/share/shaders/k3d_uberlight.sl:87: * Projected noise on the light:
k3d/share/shaders/k3d_uberlight.sl:97: * Shadow mapped shadows.  For PRMan (and perhaps other renderers),
k3d/share/shaders/k3d_uberlight.sl:98: * shadows are mainly computed by shadow maps.  Please consult the
k3d/share/shaders/k3d_uberlight.sl:99: * PRMan documentation for more information on the meanings of these
k3d/share/shaders/k3d_uberlight.sl:156: *       diffuse(), specular() and phong() all do this, for PRMan 3.5
k3d/share/shaders/k3d_uberlight.sl:159: *       to account for it yourself.  The PRMan user manual explains how
k3d/share/shaders/k3d_uberlight.sl:174: *       will also work just fine with PRMan (3.7 or later).
k3d/share/shaders/k3d_uberlight.sl:184: * SIGGRAPH '98, course 11, "Advanced RenderMan: Beyond the Companion"
k3d/share/shaders/k3d_uberlight.sl:189: * This shader was tested using Pixar's PhotoRealistic RenderMan 3.7
k3d/share/shaders/k3d_uberlight.sl:210: * PRMan together.
k3d/share/shaders/k3d_uberlight.sl:276:float ShapeLightVolume(point PL;	/* Point in light space */
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:293:  float PLlen = length(PL);
k3d/share/shaders/k3d_uberlight.sl:294:  float Pz;
k3d/share/shaders/k3d_uberlight.sl:297:      Pz = zcomp(PL);
k3d/share/shaders/k3d_uberlight.sl:302:      Pz = PLlen;
k3d/share/shaders/k3d_uberlight.sl:304:  atten *= smoothstep(znear - nearedge, znear, Pz);
k3d/share/shaders/k3d_uberlight.sl:305:  atten *= 1 - smoothstep(zfar, zfar + faredge, Pz);
k3d/share/shaders/k3d_uberlight.sl:310:      if(PLlen > falloffdist)
k3d/share/shaders/k3d_uberlight.sl:312:	  atten *= pow(falloffdist / PLlen, falloff);
k3d/share/shaders/k3d_uberlight.sl:318:	  atten *= (maxintensity * exp(s * pow(PLlen / falloffdist, beta)));
k3d/share/shaders/k3d_uberlight.sl:324:    atten *= pow(zcomp(normalize(vector PL)), beamdistribution);
k3d/share/shaders/k3d_uberlight.sl:328:	1 - clipSuperellipse(PL / Pz - point(shearx, sheary, 0), width,
k3d/share/shaders/k3d_uberlight.sl:338:/* Evaluate the occlusion between two points, P1 and P2, due to a fake
k3d/share/shaders/k3d_uberlight.sl:342:float BlockerContribution(point P1, P2;
k3d/share/shaders/k3d_uberlight.sl:351:  point Pb1 = transform(blockercoords, P1);
k3d/share/shaders/k3d_uberlight.sl:352:  point Pb2 = transform(blockercoords, P2);
k3d/share/shaders/k3d_uberlight.sl:354:  if(zcomp(Pb2) * zcomp(Pb1) < 0)
k3d/share/shaders/k3d_uberlight.sl:356:      vector Vlight = (Pb1 - Pb2);
k3d/share/shaders/k3d_uberlight.sl:357:      point Pplane = Pb1 - Vlight * (zcomp(Pb1) / zcomp(Vlight));
k3d/share/shaders/k3d_uberlight.sl:359:	clipSuperellipse(Pplane, blockerwidth, blockerheight,
k3d/share/shaders/k3d_uberlight.sl:411:   * internals of the light shader!  Anyway, let PL be the position of
k3d/share/shaders/k3d_uberlight.sl:415:  point PL = transform("shader", Ps);
k3d/share/shaders/k3d_uberlight.sl:418:   * geometry.  If not an area light, BMRT guarantees P,N will be the
k3d/share/shaders/k3d_uberlight.sl:421:  point from = P;
k3d/share/shaders/k3d_uberlight.sl:424:  /* For PRMan, we've gotta do it the hard way */
k3d/share/shaders/k3d_uberlight.sl:437:      angle = PI / 2;
k3d/share/shaders/k3d_uberlight.sl:441:      angle = PI;
k3d/share/shaders/k3d_uberlight.sl:458:      ShapeLightVolume(PL, lighttype, axis, cuton, cutoff, nearedge, faredge,
k3d/share/shaders/k3d_uberlight.sl:463:    /* Project a slide or use a cookie */
k3d/share/shaders/k3d_uberlight.sl:466:	point Pslide = PL / point(width + wedge, height + hedge, 1);
k3d/share/shaders/k3d_uberlight.sl:467:	float zslide = zcomp(Pslide);
k3d/share/shaders/k3d_uberlight.sl:468:	float xslide = 0.5 + 0.5 * xcomp(Pslide) / zslide;
k3d/share/shaders/k3d_uberlight.sl:469:	float yslide = 0.5 - 0.5 * ycomp(Pslide) / zslide;
k3d/share/shaders/k3d_uberlight.sl:480:	    float n = noise(noisefreq * (PL + noiseoffset) * point(1, 1, 0));
k3d/share/shaders/k3d_uberlight.sl:489:	    1 - shadow(shadowmap, Ps, "blur", shadowblur, "samples",
k3d/share/shaders/k3d_uberlight.sl:495:	  shadoworigin = point "shader"(xcomp(PL), ycomp(PL), cuton);
k3d/share/shaders/k3d_uberlight.sl:505:	      vis += visibility(Ps, shadoworigin + shadowcheat);
k3d/share/shaders/k3d_uberlight.sl:514:	      BlockerContribution(Ps, shadoworigin, blockercoords,
k3d/share/shaders/k3d_uberlight.sl:523:      L = axis * length(Ps - from);
k3d/share/shaders/k3d_urbermap.sl:42:point PP;
k3d/share/shaders/k3d_urbermap.sl:159:PP = transform("shader", P);
k3d/share/shaders/k3d_urbermap.sl:161:PP += bmp * Nf;
k3d/share/shaders/k3d_urbermap.sl:162:PP = transform("shader", "current", PP);
k3d/share/shaders/k3d_urbermap.sl:163:Nf = calculatenormal(PP);
k3d/share/shaders/k3d_urbermap.sl:171:P = PP;
k3d/share/shaders/k3d_veinedmarble.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_veinedmarble.sl:9: * PARAMETERS:
k3d/share/shaders/k3d_veinedmarble.sl:50:  point PP = transform("shader", P);
k3d/share/shaders/k3d_veinedmarble.sl:51:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_veinedmarble.sl:53:  PP += 0.5 * vfBm(PP, dPP, 6, 2, 0.5);
k3d/share/shaders/k3d_veinedmarble.sl:58:  PP *= veinfreq;
k3d/share/shaders/k3d_veinedmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_veinedmarble.sl:65:      PP *= 3;
k3d/share/shaders/k3d_veinedmarble.sl:71:  Ci = MaterialPlastic(Nf, Ct, Ka, Kd, Ks, roughness);
k3d/share/shaders/k3d_velvet.sl:6: * DESCRIPTION:
k3d/share/shaders/k3d_velvet.sl:13: * PARAMETERS:
k3d/share/shaders/k3d_velvet.sl:48:  vector H;                      /* Bisector vector for Phong/Blinn */
k3d/share/shaders/k3d_velvet.sl:57:  illuminance ( P, Nf, 1.57079632679489661923 /* Hemisphere */ ) {
k3d/share/shaders/k3d_venus.sl:5: * DESCRIPTION:
k3d/share/shaders/k3d_venus.sl:14: * PARAMETERS:
k3d/share/shaders/k3d_venus.sl:34: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_venus.sl:35: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus.sl:36: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_venus.sl:46:#define TWOPI (2*PI)
k3d/share/shaders/k3d_venus.sl:59:  point Ptexture;		/* the shade point in texture space */
k3d/share/shaders/k3d_venus.sl:60:  point PtN;			/* normalized version of Ptexture */
k3d/share/shaders/k3d_venus.sl:61:  point PP;			/* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus.sl:69:  Ptexture = transform("shader", P);
k3d/share/shaders/k3d_venus.sl:71:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus.sl:72:  PtN = normalize(Ptexture);
k3d/share/shaders/k3d_venus.sl:73:  rsq = xcomp(PtN) * xcomp(PtN) + ycomp(PtN) * ycomp(PtN);
k3d/share/shaders/k3d_venus.sl:74:  angle = twist * TWOPI * rsq;
k3d/share/shaders/k3d_venus.sl:77:  PP =
k3d/share/shaders/k3d_venus.sl:78:    point(xcomp(Ptexture) * cosine - ycomp(Ptexture) * sine,
k3d/share/shaders/k3d_venus.sl:79:	  xcomp(Ptexture) * sine + ycomp(Ptexture) * cosine, zcomp(Ptexture));
k3d/share/shaders/k3d_venus.sl:87:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_venus2.sl:7: * DESCRIPTION:
k3d/share/shaders/k3d_venus2.sl:16: * PARAMETERS:
k3d/share/shaders/k3d_venus2.sl:27: *    Planet radius param added by Mark Beckwith.
k3d/share/shaders/k3d_venus2.sl:30: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_venus2.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus2.sl:32: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_venus2.sl:44:#define TWOPI (2*PI)
k3d/share/shaders/k3d_venus2.sl:61:  point Ptexture;           /* the shade point in texture space */
k3d/share/shaders/k3d_venus2.sl:62:  point PtN;                /* normalized version of Ptexture */
k3d/share/shaders/k3d_venus2.sl:63:  point PP;                 /* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus2.sl:71:  Ptexture = transform ("shader", P) / radius;
k3d/share/shaders/k3d_venus2.sl:73:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus2.sl:74:  PtN = normalize (Ptexture);
k3d/share/shaders/k3d_venus2.sl:75:  rsq = xcomp(PtN)*xcomp(PtN) + ycomp(PtN)*ycomp(PtN);
k3d/share/shaders/k3d_venus2.sl:76:  angle = twist * TWOPI * rsq;
k3d/share/shaders/k3d_venus2.sl:79:  PP = point (xcomp(Ptexture)*cosine - ycomp(Ptexture)*sine,
k3d/share/shaders/k3d_venus2.sl:80:	      xcomp(Ptexture)*sine + ycomp(Ptexture)*cosine,
k3d/share/shaders/k3d_venus2.sl:81:	      zcomp(Ptexture));
k3d/share/shaders/k3d_venus2.sl:86:      a += o * snoise (PP * l);
k3d/share/shaders/k3d_volcube.sl:1:/* srf_vol_cube - Brian Steiner - Sony Pictures Imageworks
k3d/share/shaders/k3d_volcube.sl:15:   RunShadowPass       - set to 1 if running a shadow pass.
k3d/share/shaders/k3d_volcube.sl:32:    extern point P;
k3d/share/shaders/k3d_volcube.sl:37:    vector Pn;
k3d/share/shaders/k3d_volcube.sl:46:    Ro = transform(refractSpace,P);
k3d/share/shaders/k3d_volcube.sl:49:    Pn = (0,0,1);
k3d/share/shaders/k3d_volcube.sl:51:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:57:    Pn = (0,0,-1);
k3d/share/shaders/k3d_volcube.sl:59:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:65:    Pn = (1,0,0);
k3d/share/shaders/k3d_volcube.sl:67:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:73:    Pn = (-1,0,0);
k3d/share/shaders/k3d_volcube.sl:75:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:81:    Pn = (0,1,0);
k3d/share/shaders/k3d_volcube.sl:83:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:89:    Pn = (0,-1,0);
k3d/share/shaders/k3d_volcube.sl:91:    T = -(Pn . Ro + D) / (Pn . Rd);
k3d/share/shaders/k3d_volcube.sl:104:active_volume(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:106:    return (noise((Pos+30.445)*2)-.5+vol_offset)*vol_mult;
k3d/share/shaders/k3d_volcube.sl:114:get_density(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:120:    activeVol = active_volume(Pos,vol_mult,vol_offset);
k3d/share/shaders/k3d_volcube.sl:121:    dens = pow(1-abs(noise(Pos*7)*2-1),3);
k3d/share/shaders/k3d_volcube.sl:122:    dens += pow(1-abs(noise((Pos+24.72)*7)*2-1),3);
k3d/share/shaders/k3d_volcube.sl:129:normal calcGradeNorm(point Pos; float vol_mult, vol_offset, dens, epsilon;)
k3d/share/shaders/k3d_volcube.sl:132:    Nd = normal (get_density(point (xcomp(Pos) - epsilon, ycomp(Pos),
k3d/share/shaders/k3d_volcube.sl:133:				    zcomp(Pos)),vol_mult,vol_offset) - dens,
k3d/share/shaders/k3d_volcube.sl:134:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:135:				    ycomp(Pos) - epsilon, zcomp(Pos)),vol_mult,vol_offset) - dens,
k3d/share/shaders/k3d_volcube.sl:136:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:137:				    ycomp(Pos), zcomp(Pos) - epsilon),vol_mult,vol_offset) - dens);
k3d/share/shaders/k3d_volcube.sl:147:void get_shading (point Pos;
k3d/share/shaders/k3d_volcube.sl:158:    illuminance (Pos, Nf, radians(90)){
k3d/share/shaders/k3d_volcube.sl:197:	     float  RunShadowPass  = 0;
k3d/share/shaders/k3d_volcube.sl:200:    point  inPoint_obj  = transform("object",P);
k3d/share/shaders/k3d_volcube.sl:201:    point  outPoint_obj = fnc_traceBox(-.501,.501,-.501,.501,-.501,.501,1,"object");
k3d/share/shaders/k3d_volcube.sl:207:    float  vol_length   = length(outPoint_obj-inPoint_obj);
k3d/share/shaders/k3d_volcube.sl:209:    vector step_obj     = (outPoint_obj-inPoint_obj)/numOfSteps;
k3d/share/shaders/k3d_volcube.sl:221:    point  Pcur_obj     = inPoint_obj + jitter * step_obj;
k3d/share/shaders/k3d_volcube.sl:222:    point  Pcur        = P  + jitter * step_cur;
k3d/share/shaders/k3d_volcube.sl:235:	    cur_density = active_volume(Pcur_obj,Vol_Mult,Vol_Offset);
k3d/share/shaders/k3d_volcube.sl:237:	    cur_density = get_density(Pcur_obj,Vol_Mult,Vol_Offset);
k3d/share/shaders/k3d_volcube.sl:240:	if(cur_density > 0 && RunShadowPass == 0){
k3d/share/shaders/k3d_volcube.sl:245:		    normal Vol_Nf = calcGradeNorm(Pcur_obj,Vol_Mult,Vol_Offset,
k3d/share/shaders/k3d_volcube.sl:250:		get_shading(Pcur,Nf,V,Roughness,diff,spec);
k3d/share/shaders/k3d_volcube.sl:278:            /* if Shadow Pass */
k3d/share/shaders/k3d_volcube.sl:290:	    P = Pcur;           
k3d/share/shaders/k3d_volcube.sl:291:            /* Displace Point To Current Sample */
k3d/share/shaders/k3d_volcube.sl:296:	Pcur_obj += step_obj;
k3d/share/shaders/k3d_volcube.sl:297:	Pcur += step_cur;
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:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_wallpaper.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_wallpaper.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_wallpaper.sl:11: *    Academic Press, 1994.  ISBN 0-12-228760-6.
k3d/share/shaders/k3d_wallpaper.sl:33:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_wallpaper.sl:56:                angle = atan(ss, tt) + PI;
k3d/share/shaders/k3d_wallpaper_2stripe.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_wallpaper_2stripe.sl:10: * PARAMETERS:
k3d/share/shaders/k3d_wallpaper_2stripe.sl:46:  Ci = MaterialPlastic(Nf, Ct, Ka, Kd, Ks, roughness);
k3d/share/shaders/k3d_warningstripes.sl:7:// modify it under the terms of the GNU General Public
k3d/share/shaders/k3d_warningstripes.sl:13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
k3d/share/shaders/k3d_warningstripes.sl:14:// General Public License for more details.
k3d/share/shaders/k3d_warningstripes.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_warningstripes.sl:18:// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
k3d/share/shaders/k3d_water.sl:12:/* DESCRIPTION:

k3d/share/shaders/k3d_water.sl:16: * PARAMETERS:

k3d/share/shaders/k3d_water.sl:75:		    ev += trace (P, normalize(R));

k3d/share/shaders/k3d_water.sl:81:	    ev = Kr * trace (P, Rdir);

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

k3d/share/shaders/k3d_watercolor.sl:38:	float dist = length(dPE) * Kdiffuse;

k3d/share/shaders/k3d_waterdisplacement.sl:2: *	P			surface position

k3d/share/shaders/k3d_waterdisplacement.sl:8: *	dPdu,dPdv	change in position with u and v

k3d/share/shaders/k3d_waterdisplacement.sl:18:	/* STEP 1 - Make a copy of the surface normal */

k3d/share/shaders/k3d_waterdisplacement.sl:21:	/* STEP 2 - Calculate an appropriate value for the displacement */

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

k3d/share/shaders/k3d_waterdisplacement.sl:26:	P = P - norm * hump * Km;

k3d/share/shaders/k3d_waterdisplacement.sl:28:	/* STEP 4 - Recalculate the surface normal */

k3d/share/shaders/k3d_waterdisplacement.sl:29:	N = calculatenormal (P);

k3d/share/shaders/k3d_waterlight.sl:24:			Cl = mix(minimum_intensity, maximum_intensity, float noise(frequency * Ps)) * lightcolor;
k3d/share/shaders/k3d_waterlight.sl:29:			Cl *= 1 - shadow(shadowname, Ps, "samples", samples, "blur", blur, "bias", bias);
k3d/share/shaders/k3d_windowlight.sl:8: * Parameters:
k3d/share/shaders/k3d_windowlight.sl:46:  point PL;			/* point on the light */
k3d/share/shaders/k3d_windowlight.sl:55:  d = inv.(Ps - center);
k3d/share/shaders/k3d_windowlight.sl:56:  PL = Ps - path * (d / (path.inv));
k3d/share/shaders/k3d_windowlight.sl:58:  illuminate(PL, -path, .01)
k3d/share/shaders/k3d_windowlight.sl:60:    offset = (PL - center).upv + paneheight * (vpanes / 2);
k3d/share/shaders/k3d_windowlight.sl:71:    offset = (PL - center).right + panewidth * (hpanes / 2);
k3d/share/shaders/k3d_windywave.sl:1:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_windywave.sl:8:  point PP;
k3d/share/shaders/k3d_windywave.sl:12:  PP = txtscale * windfreq * transform("shader", P);
k3d/share/shaders/k3d_windywave.sl:14:  offset = Km * (snoise(PP) + 0.5 * snoise(2 * PP));
k3d/share/shaders/k3d_windywave.sl:18:  PP *= 8;
k3d/share/shaders/k3d_windywave.sl:21:      turb += abs(a * snoise(PP));
k3d/share/shaders/k3d_windywave.sl:22:      PP *= 2;
k3d/share/shaders/k3d_windywave.sl:27:/*  P += wind * offset * normalize(N); */
k3d/share/shaders/k3d_windywave.sl:28:  N = calculatenormal(P + wind * offset * normalize(N));
k3d/share/shaders/k3d_wood2.sl:4: * DESCRIPTION:
k3d/share/shaders/k3d_wood2.sl:7: * PARAMETERS:
k3d/share/shaders/k3d_wood2.sl:29:  point PP, PQ;			/* shading space point to be computed */
k3d/share/shaders/k3d_wood2.sl:36:  PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_wood2.sl:38:  my_t = zcomp(PP) / ringscale;
k3d/share/shaders/k3d_wood2.sl:39:  PQ = point(xcomp(PP) * 8, ycomp(PP) * 8, zcomp(PP));
k3d/share/shaders/k3d_wood2.sl:40:  my_t += noise(PQ) / 16;
k3d/share/shaders/k3d_wood2.sl:42:  PQ = point(xcomp(PP), my_t, ycomp(PP) + 12.93);
k3d/share/shaders/k3d_wood2.sl:43:  r = ringscale * noise(PQ);
k3d/share/shaders/k3d_wood2.sl:48:  PQ = point(xcomp(PP) * 128 + 5, zcomp(PP) * 8 - 3, ycomp(PP) * 128 + 1);
k3d/share/shaders/k3d_wood2.sl:49:  r2 = grainy * (1.3 - noise(PQ)) + (1 - grainy);
k3d/share/shaders/k3d_woodcut.sl:26:point Psh;
k3d/share/shaders/k3d_woodcut.sl:29:Psh = transform("shader", P);
k3d/share/shaders/k3d_woodcut.sl:35:z = zcomp(Psh);
k3d/share/shaders/k3d_woodcut.sl:40:y = ycomp(Psh);
k3d/share/shaders/k3d_woodcut.sl:52:n += snoise(Psh * ns) / ns;
k3d/share/shaders/k3d_woodcut.sl:89: P += 0 * Ndisp;
k3d/share/shaders/k3d_woodcut.sl:90: N = normalize (calculatenormal (P + (1-0)*Ndisp)); 
