k3d/share/shaders/k3d_altitude_fog.sl:7:	point PP = transform("world", P);
k3d/share/shaders/k3d_antialiasedchecks.sl:9: *   Ka, Kd	    	work just like the matte shader
k3d/share/shaders/k3d_antialiasedchecks.sl:10: *   color1, color2     these are the colors which make the pattern
k3d/share/shaders/k3d_antialiasedchecks.sl:14: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_antialiasedchecks.sl:17: *      27 Jan 1994 -- written by lg
k3d/share/shaders/k3d_antialiasedchecks.sl:30:  point Nf;             /* Forward facing surface normal */
k3d/share/shaders/k3d_antialiasedchecks.sl:31:  float smod, tmod;     /* Texture position within the pattern */
k3d/share/shaders/k3d_antialiasedchecks.sl:34:  float swidth, twidth, sfuzz, tfuzz;  /* Antialiasing */
k3d/share/shaders/k3d_antialiasedchecks.sl:38:  Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_antialiasedchecks.sl:40:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_antialiasedchecks.sl:41:  swidth = abs(Du(s)*du) + abs(Dv(s)*dv);
k3d/share/shaders/k3d_antialiasedchecks.sl:42:  twidth = abs(Du(t)*du) + abs(Dv(t)*dv);
k3d/share/shaders/k3d_antialiasedchecks.sl:46:  sfuzz = .5 * swidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:47:  tfuzz = .5 * twidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:50:  /* Get the place in the pattern where we're sampling */
k3d/share/shaders/k3d_antialiasedchecks.sl:54:  /* If the filter width is small enough, compute the pattern color */
k3d/share/shaders/k3d_antialiasedchecks.sl:59:      /* Gradually fade in the average color when we get close to the limit */
k3d/share/shaders/k3d_antialiasedchecks.sl:62:  else { /* otherwise, only use the average color */
k3d/share/shaders/k3d_arealight.sl:5: *   Makes light with cosine falloff from the normal of the light source
k3d/share/shaders/k3d_arealight.sl:6: *   surface.  This is perfect for using with area light sources.
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:25:   * approximately work for a flat light source whose normal points
k3d/share/shaders/k3d_arealight.sl:26:   * toward local +z.
k3d/share/shaders/k3d_background.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_background.sl:8:// License as published by the Free Software Foundation; either
k3d/share/shaders/k3d_background.sl:11:// This program is distributed in the hope that it will be useful,
k3d/share/shaders/k3d_background.sl:12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
k3d/share/shaders/k3d_background.sl:17:// License along with this program; if not, write to the Free Software
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_bluemarble.sl:49:    NN = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brick.sl:5: *   Makes a wall of bricks.  Need more be said?  OK.  It makes a good
k3d/share/shaders/k3d_brick.sl:6: *   looking staggered brick masonry.  It is especially convincing when
k3d/share/shaders/k3d_brick.sl:7: *   used in conjunction with the "brickbump" displacement shader (and
k3d/share/shaders/k3d_brick.sl:8: *   identical parameters).  Every other row of bricks is staggered.
k3d/share/shaders/k3d_brick.sl:9: *   The staggering isn't exact, however, and this variance is controlled
k3d/share/shaders/k3d_brick.sl:10: *   by the "rowvary" parameter.
k3d/share/shaders/k3d_brick.sl:15: *    brickvary                 How much does the brick color vary from
k3d/share/shaders/k3d_brick.sl:17: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brick.sl:20: *    rowvary                   How much does each row shift?
k3d/share/shaders/k3d_brick.sl:21: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brick.sl:23: * AUTHOR: written by Larry Gritz, gritzl@acm.org
k3d/share/shaders/k3d_brick.sl:35:		  float brickwidth = .28, brickheight = .07;
k3d/share/shaders/k3d_brick.sl:37:		  float rowvary = .5;
k3d/share/shaders/k3d_brick.sl:45:  float sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brick.sl:47:  float swidth, twidth;
k3d/share/shaders/k3d_brick.sl:48:  uniform float BMWIDTH = (brickwidth + mortarthickness);
k3d/share/shaders/k3d_brick.sl:52:  float whichbrick;
k3d/share/shaders/k3d_brick.sl:55:  /* Determine how wide in s-t space one pixel projects to, relative
k3d/share/shaders/k3d_brick.sl:56:   * the the width and height of a brick.  Overestimate the filter
k3d/share/shaders/k3d_brick.sl:57:   * size by a bit -- it makes the transitions between brick and mortar
k3d/share/shaders/k3d_brick.sl:60:  swidth = 1.5 * max(filterwidth(s), MINFILTWIDTH) / BMWIDTH;
k3d/share/shaders/k3d_brick.sl:61:  twidth = 1.5 * max(filterwidth(t), MINFILTWIDTH) / BMHEIGHT;
k3d/share/shaders/k3d_brick.sl:67:  whichbrick = 103 * sbrick + tbrick;
k3d/share/shaders/k3d_brick.sl:82:  if(swidth >= 1)
k3d/share/shaders/k3d_brick.sl:83:    w = 1 - 2 * MWF;
k3d/share/shaders/k3d_brick.sl:85:    w =
k3d/share/shaders/k3d_brick.sl:86:      clamp(filteredpulse(MWF, 1 - MWF, ss, swidth), max(1 - MWF / swidth, 0),
k3d/share/shaders/k3d_brick.sl:88:  if(twidth >= 1)
k3d/share/shaders/k3d_brick.sl:92:      clamp(filteredpulse(MHF, 1 - MHF, tt, twidth), max(1 - MHF / twidth, 0),
k3d/share/shaders/k3d_brick.sl:121:    pow(noise
k3d/share/shaders/k3d_brick.sl:127:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_brick.sl:131:  bcolor = brickcolor * (1 + (brickvary * snoise(whichbrick + 0.5)));
k3d/share/shaders/k3d_brick.sl:133:  Ct = mix(mortarcolor, bcolor, w * h);
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brick2.sl:35:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brick2.sl:39:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brick2.sl:45:        ss += 0.5;  /* shift alternate rows */
k3d/share/shaders/k3d_brick2.sl:46:    sbrick = floor(ss); /* which brick? */
k3d/share/shaders/k3d_brick2.sl:47:    tbrick = floor(tt); /* which brick? */
k3d/share/shaders/k3d_brick2.sl:50:    w = step(MWF,ss) - step(1-MWF,ss);
k3d/share/shaders/k3d_brick2.sl:53:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brick3.sl:5: *   Makes a wall of bricks.  Need more be said?  OK.  It makes a good
k3d/share/shaders/k3d_brick3.sl:6: *   looking staggered brick masonry.  It is especially convincing when
k3d/share/shaders/k3d_brick3.sl:7: *   used in conjunction with the "brickbump" displacement shader (and
k3d/share/shaders/k3d_brick3.sl:8: *   identical parameters).  Every other row of bricks is staggered.
k3d/share/shaders/k3d_brick3.sl:9: *   The staggering isn't exact, however, and this variance is controlled
k3d/share/shaders/k3d_brick3.sl:10: *   by the "rowvary" parameter.
k3d/share/shaders/k3d_brick3.sl:15: *    brickvary                 How much does the brick color vary from
k3d/share/shaders/k3d_brick3.sl:17: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brick3.sl:20: *    rowvary                   How much does each row shift?
k3d/share/shaders/k3d_brick3.sl:21: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brick3.sl:23: * AUTHOR: written by Larry Gritz, 1992
k3d/share/shaders/k3d_brick3.sl:25: *	by Darwyn Peachey.
k3d/share/shaders/k3d_brick3.sl:29: *      28 May 1992 -- written by lg for the "Timbre Trees" video (saucer)
k3d/share/shaders/k3d_brick3.sl:43:        float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brick3.sl:45:        float rowvary = .25; 
k3d/share/shaders/k3d_brick3.sl:48:#define BMWIDTH (brickwidth+mortarthickness)
k3d/share/shaders/k3d_brick3.sl:57:  float sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brick3.sl:59:  float swidth, twidth;
k3d/share/shaders/k3d_brick3.sl:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_brick3.sl:63:  swidth = max (abs(Du(s)*du) + abs(Dv(s)*dv), MINFILTERWIDTH);
k3d/share/shaders/k3d_brick3.sl:64:  twidth = max (abs(Du(t)*du) + abs(Dv(t)*dv), MINFILTERWIDTH);
k3d/share/shaders/k3d_brick3.sl:66:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_brick3.sl:73:  ss = scoord / BMWIDTH;   /* Determine which brick the point is in */
k3d/share/shaders/k3d_brick3.sl:75:  swidth /= BMWIDTH;
k3d/share/shaders/k3d_brick3.sl:76:  twidth /= BMHEIGHT;
k3d/share/shaders/k3d_brick3.sl:78:  /* shift alternate rows */
k3d/share/shaders/k3d_brick3.sl:82:  tbrick = floor (tt);   /* which brick row? */
k3d/share/shaders/k3d_brick3.sl:83:  /* Shift the columns randomly by row */
k3d/share/shaders/k3d_brick3.sl:84:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brick3.sl:86:  sbrick = floor (ss);   /* which brick column? */
k3d/share/shaders/k3d_brick3.sl:87:  ss -= sbrick;          /* Now ss and tt are coords within the brick */
k3d/share/shaders/k3d_brick3.sl:91:  if (swidth >= 1)
k3d/share/shaders/k3d_brick3.sl:92:      w = 1 - 2*MWF;
k3d/share/shaders/k3d_brick3.sl:93:  else w = clamp (boxstep(MWF-swidth,MWF,ss), max(1-MWF/swidth,0), 1)
k3d/share/shaders/k3d_brick3.sl:94:	 - clamp (boxstep(1-MWF-swidth,1-MWF,ss), 0, 2*MWF/swidth);
k3d/share/shaders/k3d_brick3.sl:96:  if (twidth >= 1)
k3d/share/shaders/k3d_brick3.sl:98:  else h = clamp (boxstep(MHF-twidth,MHF,tt), max(1-MHF/twidth,0),1)
k3d/share/shaders/k3d_brick3.sl:99:	 - clamp (boxstep(1-MHF-twidth,1-MHF,tt), 0, 2*MHF/twidth);
k3d/share/shaders/k3d_brick3.sl:104:  Ct = mix (mortarcolor, bcolor, w*h);
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickanti.sl:36:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickanti.sl:39:    float swidth, twidth;
k3d/share/shaders/k3d_brickanti.sl:41:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brickanti.sl:47:        ss += 0.5;  /* shift alternate rows */
k3d/share/shaders/k3d_brickanti.sl:49:    swidth = abs(Du(ss)*du) + abs(Dv(ss)*dv);
k3d/share/shaders/k3d_brickanti.sl:50:    twidth = abs(Du(tt)*du) + abs(Dv(tt)*dv);
k3d/share/shaders/k3d_brickanti.sl:51:    tbrick = floor(tt); /* which brick? */
k3d/share/shaders/k3d_brickanti.sl:52:    sbrick = floor(ss); /* which brick? */
k3d/share/shaders/k3d_brickanti.sl:55:    /* This is the simple antialiasing with "boxstep" */
k3d/share/shaders/k3d_brickanti.sl:59:    w = boxstep(MWF-swidth,MWF,ss)
k3d/share/shaders/k3d_brickanti.sl:60:      - boxstep(1-MWF-swidth,1-MWF,ss);
k3d/share/shaders/k3d_brickanti.sl:61:    h = boxstep(MHF-twidth,MHF,tt)
k3d/share/shaders/k3d_brickanti.sl:62:      - boxstep(1-MHF-twidth,1-MHF,tt);
k3d/share/shaders/k3d_brickanti.sl:72:    w = (sintegral(ss+swidth) - sintegral(ss))/swidth;
k3d/share/shaders/k3d_brickanti.sl:73:    h = (tintegral(tt+twidth) - tintegral(tt))/twidth;
k3d/share/shaders/k3d_brickanti.sl:76:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brickbump.sl:5: *   Makes displacements for a wall of bricks.  This is the companion
k3d/share/shaders/k3d_brickbump.sl:6: *   shader to the surface "brick" shader.  The parameters work exactly
k3d/share/shaders/k3d_brickbump.sl:7: *   the same.  Of course, you can use it with any surface shader, and
k3d/share/shaders/k3d_brickbump.sl:8: *   in fact matte or plastic gives those nice white cinder block walls.
k3d/share/shaders/k3d_brickbump.sl:9: *   However, if you do use it with "brick", the parameters MUST match,
k3d/share/shaders/k3d_brickbump.sl:10: *   or your bricks will look very strange.
k3d/share/shaders/k3d_brickbump.sl:13: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brickbump.sl:16: *    rowvary                   How much does each row shift?
k3d/share/shaders/k3d_brickbump.sl:17: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brickbump.sl:21: *    groovedepth               The depth of the grooves between bricks.
k3d/share/shaders/k3d_brickbump.sl:23: * AUTHOR: written by Larry Gritz, 1992 (and subsequently modified)
k3d/share/shaders/k3d_brickbump.sl:31:			   float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brickbump.sl:33:			   float rowvary = .25, pitting = 0.01;
k3d/share/shaders/k3d_brickbump.sl:41:  uniform float BMWIDTH = (brickwidth + mortarthickness);
k3d/share/shaders/k3d_brickbump.sl:75:    pow(noise
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickbump2.sl:35:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickbump2.sl:40:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brickbump2.sl:46:        ss += 0.5;  /* shift alternate rows */
k3d/share/shaders/k3d_brickbump2.sl:47:    sbrick = floor(ss); /* which brick? */
k3d/share/shaders/k3d_brickbump2.sl:48:    tbrick = floor(tt); /* which brick? */
k3d/share/shaders/k3d_brickbump2.sl:51:    w = step(MWF,ss) - step(1-MWF,ss);
k3d/share/shaders/k3d_brickbump2.sl:54:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brickbump2.sl:63:    Nf = normalize(faceforward(Nf, I));
k3d/share/shaders/k3d_brickbump3.sl:5: *   Makes displacements for a wall of bricks.  This is the companion
k3d/share/shaders/k3d_brickbump3.sl:6: *   shader to the surface "brick" shader.  The parameters work exactly
k3d/share/shaders/k3d_brickbump3.sl:7: *   the same.  Of course, you can use it with any surface shader, and
k3d/share/shaders/k3d_brickbump3.sl:8: *   in fact matte or plastic gives those nice white cinder block walls.
k3d/share/shaders/k3d_brickbump3.sl:9: *   However, if you do use it with "brick", the parameters MUST match,
k3d/share/shaders/k3d_brickbump3.sl:10: *   or your bricks will look very strange.
k3d/share/shaders/k3d_brickbump3.sl:13: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brickbump3.sl:16: *    rowvary                   How much does each row shift?
k3d/share/shaders/k3d_brickbump3.sl:17: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brickbump3.sl:21: *    groovedepth               The depth of the grooves between bricks.
k3d/share/shaders/k3d_brickbump3.sl:23: * AUTHOR: written by Larry Gritz, 1992
k3d/share/shaders/k3d_brickbump3.sl:26: *      28 May 1992 -- written by lg for the "Timbre Trees" video (saucer)
k3d/share/shaders/k3d_brickbump3.sl:37:  displacement shader with the matte surface shader.  With appropriate
k3d/share/shaders/k3d_brickbump3.sl:38:  parameters, it looks *exactly* like those painted cinderblock walls
k3d/share/shaders/k3d_brickbump3.sl:39:  (we have a wall in our lab like this).  
k3d/share/shaders/k3d_brickbump3.sl:44:  Displacement "brickbump" "brickwidth" 0.5 "brickheight" 0.25 
k3d/share/shaders/k3d_brickbump3.sl:52:            float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brickbump3.sl:54:	    float rowvary = .25, pitting = 0.01;
k3d/share/shaders/k3d_brickbump3.sl:58:#define BMWIDTH (brickwidth+mortarthickness)
k3d/share/shaders/k3d_brickbump3.sl:66:  float sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickbump3.sl:80:  /* shift alternate rows */
k3d/share/shaders/k3d_brickbump3.sl:84:  tbrick = floor (tt);   /* which brick row? */
k3d/share/shaders/k3d_brickbump3.sl:85:  /* Shift the columns randomly by row */
k3d/share/shaders/k3d_brickbump3.sl:86:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brickbump3.sl:88:  sbrick = floor (ss);   /* which brick column? */
k3d/share/shaders/k3d_brickbump3.sl:89:  ss -= sbrick;          /* Now ss and tt are coords within the brick */
k3d/share/shaders/k3d_brickbump3.sl:112:  disp -= fact * pow(noise ((ss+sbrick)*pockfrequency/BMHEIGHT,
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickperturb.sl:35:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickperturb.sl:39:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brickperturb.sl:45:        ss += 0.5;  /* shift alternate rows */
k3d/share/shaders/k3d_brickperturb.sl:46:    tbrick = floor(tt); /* which brick? */
k3d/share/shaders/k3d_brickperturb.sl:48:    sbrick = floor(ss); /* which brick? */
k3d/share/shaders/k3d_brickperturb.sl:51:    w = step(MWF,ss) - step(1-MWF,ss);
k3d/share/shaders/k3d_brickperturb.sl:54:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brushedmetal.sl:25:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_brushedmetal2.sl:1:/*  IDbrushedmetal.sl written 9/99 by Ivan DeWolf
k3d/share/shaders/k3d_brushedmetal2.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_brushedmetal2.sl:9: *  based somewhat on LGbrushedmetal.sl
k3d/share/shaders/k3d_brushedmetal2.sl:11: *  if you set Kr = 0 and specwidth = 10
k3d/share/shaders/k3d_brushedmetal2.sl:20: *  specwidth		- the width of the specular stripe
k3d/share/shaders/k3d_brushedmetal2.sl:26: *  twist		- allows you to twist the direction of anisotropy
k3d/share/shaders/k3d_brushedmetal2.sl:33:anisospecular (vector VA; float specspread; float specwidth)
k3d/share/shaders/k3d_brushedmetal2.sl:43:    normal Nf = faceforward(NN,-V);
k3d/share/shaders/k3d_brushedmetal2.sl:58:            C += Cl * pixbrdf * pow( 1-abs(VA.H), 1/specwidth );
k3d/share/shaders/k3d_brushedmetal2.sl:70:		specwidth	= .5,
k3d/share/shaders/k3d_brushedmetal2.sl:73:		twist		=  0;
k3d/share/shaders/k3d_brushedmetal2.sl:85:	vector VA = rotate(normalize(dPdu), twist, zro, normalize(N));
k3d/share/shaders/k3d_brushedmetal2.sl:88:	Nf = faceforward(normalize(N), -I);
k3d/share/shaders/k3d_brushedmetal2.sl:97:	      D = vtransform("world", D);
k3d/share/shaders/k3d_brushedmetal2.sl:105:	specularcolor * Ks * anisospecular(VA, specspread*2, specwidth*.1)) +
k3d/share/shaders/k3d_brushedmetal3.sl:10: *   V - unit viewing direction (from P toward the camera)
k3d/share/shaders/k3d_brushedmetal3.sl:11: *   xdir - a unit tangent of the surface which defines the reference
k3d/share/shaders/k3d_brushedmetal3.sl:15: *          tangent which is perpendicular to xdir.
k3d/share/shaders/k3d_brushedmetal3.sl:30:        /* Must declare because extern L & Cl because we're in a function */
k3d/share/shaders/k3d_brushedmetal3.sl:57:    normal Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_bubbles.sl:10:	float radius = 0.5;   /* values between -0.5 and 0.5          */
k3d/share/shaders/k3d_bubbly.sl:1:/*  bubbly.sl written a while ago by Ivan DeWolf
k3d/share/shaders/k3d_bubbly.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_bubbly.sl:10: *  not as elegant, but hey, it works.
k3d/share/shaders/k3d_bubbly.sl:13: *  try lowering bubsize for pimples.
k3d/share/shaders/k3d_bubbly.sl:21: *	      dont go higher than two with this.
k3d/share/shaders/k3d_bubbly.sl:47:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_bubbly.sl:60:  P+= Nn*(pow(bub,2)-1)*Kd;
k3d/share/shaders/k3d_castucco.sl:5: *   I call this "castucco" because it's the stuff on the walls *everywhere*
k3d/share/shaders/k3d_castucco.sl:6: *   in Northern California.  I never really saw it on the East Coast,
k3d/share/shaders/k3d_castucco.sl:12: *   octaves - how many octaves of fBm to sum
k3d/share/shaders/k3d_castucco.sl:30:  float fwidth;			/* Estimated change in P between image samples */
k3d/share/shaders/k3d_castucco.sl:35:  fwidth = filterwidthp(Pshad);
k3d/share/shaders/k3d_castucco.sl:37:  /* Compute some fractional Brownian motion */
k3d/share/shaders/k3d_castucco.sl:38:  disp = fBm(Pshad, fwidth, 3, 2, 0.6);
k3d/share/shaders/k3d_causticlight.sl:9:	       string shadowname = "";
k3d/share/shaders/k3d_causticlight.sl:14:	       float  noiseamp = 0, noisefreq = 1, noisepow = 1;
k3d/share/shaders/k3d_causticlight.sl:21:	float atten = pow (cosangle, beamdistribution) / (L . L);
k3d/share/shaders/k3d_causticlight.sl:25:        if (shadowname != "") {
k3d/share/shaders/k3d_causticlight.sl:26:            float caustic = shadow (shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_causticlight.sl:31:		caustic *= noiseamp * pow (noise(PL*noisefreq), noisepow);
k3d/share/shaders/k3d_celld.sl:20:				   between f2 and f1 is less then this value
k3d/share/shaders/k3d_celld.sl:25:	float usePref = 0;   /* type switch */
k3d/share/shaders/k3d_ceramic.sl:1:/* Author & copyright unknown */
k3d/share/shaders/k3d_ceramic.sl:10:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ceramictiles.sl:11: *   groovewidth, grooveheight - width of the spacing between tiles,
k3d/share/shaders/k3d_ceramictiles.sl:19: *   mottlefreq - frequency of the mottling between Cbase & Cmottle
k3d/share/shaders/k3d_ceramictiles.sl:23: *      edge variation, mottling, and speckles.  Setting any to zero will
k3d/share/shaders/k3d_ceramictiles.sl:26: *      color variation (0 means don't vary in that way, larger values
k3d/share/shaders/k3d_ceramictiles.sl:31: *   Kdmortar - Kd for the mortar between tiles
k3d/share/shaders/k3d_ceramictiles.sl:33: *   Kdtile - diffuse component weighting of the tile
k3d/share/shaders/k3d_ceramictiles.sl:49:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_ceramictiles.sl:60:/* Given 2-D texture coordinates ss,tt and their filter widths ds, dt,
k3d/share/shaders/k3d_ceramictiles.sl:61: * and the width and height of the grooves between tiles (assuming that
k3d/share/shaders/k3d_ceramictiles.sl:62: * tile spacing is 1.0), figure out which (integer indexed) tile we are
k3d/share/shaders/k3d_ceramictiles.sl:63: * on and what coordinates (on [0,1]) within our individual tile we are
k3d/share/shaders/k3d_ceramictiles.sl:67:		  float groovewidth, grooveheight;
k3d/share/shaders/k3d_ceramictiles.sl:68:		  output float swhichtile, twhichtile;
k3d/share/shaders/k3d_ceramictiles.sl:71:  swhichtile = floor(ss);
k3d/share/shaders/k3d_ceramictiles.sl:72:  twhichtile = floor(tt);
k3d/share/shaders/k3d_ceramictiles.sl:73:  stile = ss - swhichtile;
k3d/share/shaders/k3d_ceramictiles.sl:74:  ttile = tt - twhichtile;
k3d/share/shaders/k3d_ceramictiles.sl:76:  return filteredpulsetrain(groovewidth, 1, ss + groovewidth / 2,
k3d/share/shaders/k3d_ceramictiles.sl:84:/* Given coordinates (stile,ttile) and derivatives (ds,dt) *within* a
k3d/share/shaders/k3d_ceramictiles.sl:87: * to a different color near the border of the tile (with a ragged edge
k3d/share/shaders/k3d_ceramictiles.sl:134: * "glossy" specular term.  We're actually blending between a purely
k3d/share/shaders/k3d_ceramictiles.sl:136: * depending on the variable intile.  When in the mortar area, we turn
k3d/share/shaders/k3d_ceramictiles.sl:173:			 float groovewidth = 0.06, grooveheight = 0.06;
k3d/share/shaders/k3d_ceramictiles.sl:200:   * Find out where in the pattern we are: which tile we're on, and
k3d/share/shaders/k3d_ceramictiles.sl:201:   * the (stile,ttile) coordinates (both on [0,1]) within our tile.
k3d/share/shaders/k3d_ceramictiles.sl:203:  float swhichtile, twhichtile, stile, ttile;
k3d/share/shaders/k3d_ceramictiles.sl:205:			     groovewidth, grooveheight,
k3d/share/shaders/k3d_ceramictiles.sl:206:			     swhichtile, twhichtile, stile, ttile);
k3d/share/shaders/k3d_ceramictiles.sl:207:  float tileindex = swhichtile + 13 * twhichtile;
k3d/share/shaders/k3d_ceramictiles.sl:210:   * Displacement: the edges of the tile displace down a bit, as do
k3d/share/shaders/k3d_ceramictiles.sl:211:   * the grooves between tiles.  Also, add just a little bit of
k3d/share/shaders/k3d_ceramictiles.sl:216:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ceramictiles.sl:224:   * Here's the exciting part -- calculate the color of the spot we're
k3d/share/shaders/k3d_ceramictiles.sl:225:   * in within the tile.  Then use the tile index to vary its color
k3d/share/shaders/k3d_ceramictiles.sl:235:   * Set the color of the mortar between tiles, make it look good by
k3d/share/shaders/k3d_ceramictiles.sl:240:  float dQ = filterwidthp(Q);
k3d/share/shaders/k3d_checkerboard.sl:13:  float filterwidths, filterwidtht;
k3d/share/shaders/k3d_checkerboard.sl:22:	filterwidths = SFILTERWIDTH * TileS;
k3d/share/shaders/k3d_checkerboard.sl:23:	filterwidtht = TFILTERWIDTH * TileT;
k3d/share/shaders/k3d_checkerboard.sl:25:	filters = filteredpulse(1.0 - filterwidths, 1.0 + filterwidths, filters, filterwidths);
k3d/share/shaders/k3d_checkerboard.sl:26:	filtert = filteredpulse(1.0 - filterwidtht, 1.0 + filterwidtht, filtert, filterwidtht);
k3d/share/shaders/k3d_checkerboard.sl:31:  // Calculate which tile we're in ...
k3d/share/shaders/k3d_checkerboard.sl:47:  Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_checkerboard_solid.sl:36:	Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_clamptoalpha.sl:3: *    and with each component to greater than the alpha value of the
k3d/share/shaders/k3d_clay.sl:15:  normal Nf = faceforward(normalize(N), I);
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_contacshadow.sl:1:/* renamed shader to SIG2k_srf_contact to be consistent with RMR 
k3d/share/shaders/k3d_contacshadow.sl:7:** Render a contact shadow based on depth data derived from a light  
k3d/share/shaders/k3d_contacshadow.sl:8:** placed onto the surface which catches the contact shadow  
k3d/share/shaders/k3d_contacshadow.sl:14:k3d_contactshadow (  
k3d/share/shaders/k3d_contacshadow.sl:15:    string shadowname = "";     /* the name of the texture file */  
k3d/share/shaders/k3d_contacshadow.sl:16:    float samples = 10;         /* how many samples to take per Z lookup */  
k3d/share/shaders/k3d_contacshadow.sl:17:    float influence = 1.0;      /* world space distance in which effect is visible */  
k3d/share/shaders/k3d_contacshadow.sl:19:    float maxdist = 10000;      /* how far is considered infinity */  
k3d/share/shaders/k3d_contacshadow.sl:22:    /* get a matrix which transforms from current space to the  
k3d/share/shaders/k3d_contacshadow.sl:23:       camera space used when rendering the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:25:    textureinfo(shadowname, "viewingmatrix", matNl);  
k3d/share/shaders/k3d_contacshadow.sl:27:    /* get a matrix which transforms from current space to the  
k3d/share/shaders/k3d_contacshadow.sl:28:       screen space (-1..1) used when rendering the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:30:    textureinfo(shadowname, "projectionmatrix", matNP);  
k3d/share/shaders/k3d_contacshadow.sl:33:       needed to look up the point in the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:43:	/* get the distance from the shadow camera to the closest
k3d/share/shaders/k3d_contacshadow.sl:44:	   object as recorded in the shadow map */
k3d/share/shaders/k3d_contacshadow.sl:45:	float mapdist = float texture(shadowname, ss, tt, "samples", samples);
k3d/share/shaders/k3d_contacshadow.sl:47:	/* transform the point on the ground plane into the shadow
k3d/share/shaders/k3d_contacshadow.sl:48:	   camera space in order to get the distance from the shadow
k3d/share/shaders/k3d_contacshadow.sl:52:	/* the difference between the two distances is used to calculate the  
k3d/share/shaders/k3d_contacshadow.sl:53:	   contact shadow effect */  
k3d/share/shaders/k3d_contacshadow.sl:57:	distance = pow(distance, gamma);  
k3d/share/shaders/k3d_contacshadow.sl:59:	/* convert into a color (white=shadow) */  
k3d/share/shaders/k3d_corktile.sl:16: * gap - the size of the gap or groove between tiles, measured as a proportion of the tile,
k3d/share/shaders/k3d_corktile.sl:17: *	 thus a gap of .05 will mean that 2.5% of the tile around each edge will be taken up with
k3d/share/shaders/k3d_corktile.sl:21: * tileheight - the proportion of the bumpheight that is taken up with the rise of the tile from
k3d/share/shaders/k3d_corktile.sl:22: * 	 the gap between the tiles, the remainder of bumpheight is taken up with the bumps on the 
k3d/share/shaders/k3d_corktile.sl:25: *   in height between the gap and the tile itself
k3d/share/shaders/k3d_corktile.sl:33:#define fnoise(p,width) (noise(p) * (1-smoothstep (0.2,0.75,width)))
k3d/share/shaders/k3d_corktile.sl:40:	return pow(x, log(b)/log(0.5));
k3d/share/shaders/k3d_corktile.sl:44:							float txtscale, filtwidth)
k3d/share/shaders/k3d_corktile.sl:46:		/* 	the pattern is built up of the sum of two offset noise functions, perturbed slightly
k3d/share/shaders/k3d_corktile.sl:47:		and used to select a color from a spline, combined with an overlay of the dark 
k3d/share/shaders/k3d_corktile.sl:53:		float fw = filtwidth * 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:94:	uniform float tilewidth = 1 / (tiles * txtscale); 
k3d/share/shaders/k3d_corktile.sl:97:	float filtwidth = filterwidthp(PP),
k3d/share/shaders/k3d_corktile.sl:98:			swidth = abs(Du(s)*du) + abs(Dv(s)*dv),
k3d/share/shaders/k3d_corktile.sl:99:			twidth = abs(Du(t)*du) + abs(Dv(t)*dv),
k3d/share/shaders/k3d_corktile.sl:100:			stfiltwidth = max(swidth, twidth) / tilewidth,
k3d/share/shaders/k3d_corktile.sl:101:			sw, tw, so, to;
k3d/share/shaders/k3d_corktile.sl:104:	float ingap = tile(s, t, tilewidth, tilewidth, swidth, twidth, gap, gap, sw, tw, so, to);
k3d/share/shaders/k3d_corktile.sl:106:	Ct = cork( P, txtscale, filtwidth);	
k3d/share/shaders/k3d_corktile.sl:107:	/* Calculate color of gap between tiles */
k3d/share/shaders/k3d_corktile.sl:108:	Cg = color( .20, 0, 0) + filteredsnoise(PP * txtscale, filtwidth * txtscale) * .2;
k3d/share/shaders/k3d_corktile.sl:112:		(1  - smoothstep(.2 * gap, gap * .8, stfiltwidth));  
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:5: * Similar tricks can be used to make cork, swiss-cheese, bread, etc.
k3d/share/shaders/k3d_craters.sl:17:   float swidth=.6;      /* Size of largest crater relative to s/t mapping */
k3d/share/shaders/k3d_craters.sl:19:   float octaves=9;      /* number of scales used - use lower numbers for cartoony effects */
k3d/share/shaders/k3d_craters.sl:20:   float lac=1.91341;    /* diameter spacing between successive octaves */
k3d/share/shaders/k3d_craters.sl:21:   float amp=1.91341;    /* amplitude reduction between successive octaves */
k3d/share/shaders/k3d_craters.sl:35:    float rmax = swidth/2; /* was /2 */
k3d/share/shaders/k3d_craters.sl:44:	sc = pow(lac, lev);
k3d/share/shaders/k3d_craters.sl:45:	asc = 1 / pow(amp, lev);
k3d/share/shaders/k3d_craters.sl:46:	scellctr = floor(s*sc/swidth);
k3d/share/shaders/k3d_craters.sl:47:	tcellctr = floor(t*sc/swidth);
k3d/share/shaders/k3d_craters.sl:48:	cellsizescale = swidth/sc;
k3d/share/shaders/k3d_craters.sl:98:	    r = r*(2*r-pow(r,3))+(1-r)*pow(r,3);
k3d/share/shaders/k3d_craters.sl:104:	    r = r*(2*r-pow(r,3))+(1-r)*pow(r,3);			
k3d/share/shaders/k3d_craters.sl:111:    Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_crayon.sl:7:	This shader makes the surface look as if it had been shaded with a pastel crayon.
k3d/share/shaders/k3d_crayon.sl:12:	Ka, Kd, Ks, roughness, specularcolor - work as in the plastic shader
k3d/share/shaders/k3d_crayon.sl:14:	width - the width of the crayon strokes - this is scaled by txtscale
k3d/share/shaders/k3d_crayon.sl:17:	stretch - the length of the stroke relative to its width;
k3d/share/shaders/k3d_crayon.sl:19:		this should vary between 0 (no topcolor) to 1, .3 would give 30% topcolor;
k3d/share/shaders/k3d_crayon.sl:20:	density1 - if different density0 this is the density when t = 1, with a smooth
k3d/share/shaders/k3d_crayon.sl:21:		interpolation of values for density0 when t = 0, thus allowing a 
k3d/share/shaders/k3d_crayon.sl:35:aanoise(float sp, tp, width)
k3d/share/shaders/k3d_crayon.sl:37:	/* an antaliased noise function, which returns noise of a wavelenth always greater than
k3d/share/shaders/k3d_crayon.sl:38:	   twice the micropolygon width */
k3d/share/shaders/k3d_crayon.sl:40:	/* calculate smallest integer f for which width / f < .5 */
k3d/share/shaders/k3d_crayon.sl:41:	f = ceil(width /.5);
k3d/share/shaders/k3d_crayon.sl:42:	mag = max(pow(0.85, f - 1),.1);
k3d/share/shaders/k3d_crayon.sl:44:	ns  = mag * snoise(sp / f, tp / f) * (1 - smoothstep(0, .5, width / f))
k3d/share/shaders/k3d_crayon.sl:45:		+ snoise(sp / (f * 1.33), tp / (f * 1.33)) * mag * .25 * smoothstep(0, .5, width / f);
k3d/share/shaders/k3d_crayon.sl:51:#define filterwidth(x)  max (abs(Du(x)*du) + abs(Dv(x)*dv), MINFILTWIDTH)
k3d/share/shaders/k3d_crayon.sl:61:			float width = .05;
k3d/share/shaders/k3d_crayon.sl:72:	/* work out the density for the current t */
k3d/share/shaders/k3d_crayon.sl:78:	normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_crayon.sl:80:	float fw = max(filterwidth(s), filterwidth(t)); /* the size of the micropolygon */
k3d/share/shaders/k3d_crayon.sl:81:	float smks = aanoise(txtscale * s * micro / width, txtscale * t * micro / width,
k3d/share/shaders/k3d_crayon.sl:82:	 		txtscale * fw * micro / width);
k3d/share/shaders/k3d_crayon.sl:83:	float lmks = (aanoise(txtscale * s / width, txtscale * t / (width * stretch), 
k3d/share/shaders/k3d_crayon.sl:84:		txtscale * fw / width) + 1) / 2;
k3d/share/shaders/k3d_crayontoon.sl:9: * This shader is a constant with little diffusion, 

k3d/share/shaders/k3d_crayontoon.sl:10: * choose wisely both colors to obtain the crayon look. My

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

k3d/share/shaders/k3d_crayontoon.sl:22:  fresnel(normalize(I), faceforward(Nf, I, Nf), 1/eta, Kr1, Kt1);

k3d/share/shaders/k3d_cyclone.sl:11:		    float twist = 0.5; float scale = .7, offset = .5;
k3d/share/shaders/k3d_cyclone.sl:15:  float radius, dist, angle, sine, cosine, eye_weight, value;
k3d/share/shaders/k3d_cyclone.sl:31:      dist = pow(max_radius - radius, 3);
k3d/share/shaders/k3d_cyclone.sl:32:      angle = PI + twist * TWOPI * (max_radius - dist) / max_radius;
k3d/share/shaders/k3d_cyclone.sl:41:	  eye_weight = (.1 * max_radius - radius) * 10;	/* normalize */
k3d/share/shaders/k3d_cyclone.sl:43:	  eye_weight = pow(1 - eye_weight, 4);
k3d/share/shaders/k3d_cyclone.sl:46:	eye_weight = 1;
k3d/share/shaders/k3d_cyclone.sl:51:  if(eye_weight > 0)
k3d/share/shaders/k3d_cyclone.sl:63:      value = abs(eye_weight * (offset + scale * a));
k3d/share/shaders/k3d_cyclone.sl:71:  /* Shade like matte, but with color scaled by cloud opacity */
k3d/share/shaders/k3d_cyclone.sl:73:    Oi * Cs * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_decalplastic.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_decalplastic.sl:8:// License as published by the Free Software Foundation; either
k3d/share/shaders/k3d_decalplastic.sl:11:// This program is distributed in the hope that it will be useful,
k3d/share/shaders/k3d_decalplastic.sl:12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
k3d/share/shaders/k3d_decalplastic.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_decalplastic.sl:46:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_dented.sl:5: *   Makes a surface appear worn and dented.
k3d/share/shaders/k3d_dented.sl:9: *   power	   	controls the fractal dimension of the dents (1 looks
k3d/share/shaders/k3d_dented.sl:11: *                         like worn metal).
k3d/share/shaders/k3d_dented.sl:15: * AUTHOR: written by Larry Gritz, based on the "dented" shader in
k3d/share/shaders/k3d_dented.sl:16: *         RenderMan Companion, but with more control parameters.
k3d/share/shaders/k3d_dented.sl:19: *      Dec 1992 -- written by lg for "Timbre Trees Examples" (jingle)
k3d/share/shaders/k3d_dented.sl:30:displacement k3d_dented( float Km = 1; float power = 3; float frequency = 1; float maxoctaves = 6; )
k3d/share/shaders/k3d_dented.sl:44:	P = P - (Km * pow(magnitude, power)) * normalize(N);
k3d/share/shaders/k3d_depthcue_surf.sl:3: *  Author: Daniel S. Matthews dan@3-e.net
k3d/share/shaders/k3d_distant_shadow.sl:1:light k3d_distant_shadow(
k3d/share/shaders/k3d_distant_shadow.sl:6:	string shadowname="";
k3d/share/shaders/k3d_distant_shadow.sl:15:			if (shadowname != "") {
k3d/share/shaders/k3d_distant_shadow.sl:16:				Cl *= 1 - shadow(shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_droop.sl:3:/* Listing 16.27  Displacement shader with catenary droop in y*/
k3d/share/shaders/k3d_dturb.sl:12:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_dturb.sl:18:  width = filterwidth_point(PP);
k3d/share/shaders/k3d_dturb.sl:19:  cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_dturb.sl:27:  /* raise to power to create flat areas */
k3d/share/shaders/k3d_dturb.sl:29:  magnitude = pow(turb, flatness);
k3d/share/shaders/k3d_easysurface.sl:3:/* Listing 16.22  Surface shader for use without a light source*/
k3d/share/shaders/k3d_easysurface.sl:6: * easysurface(): orientation-sensitive surface shading without a light source
k3d/share/shaders/k3d_easysurface.sl:19:	diffuse = pow(diffuse, falloff);
k3d/share/shaders/k3d_ember.sl:1:/* Glowing ember shader 2002 Graeme Nattress & NOITAMINANIMATION Inc.
k3d/share/shaders/k3d_ember.sl:5: * It is designed for use with particle systems where the particle is scaled
k3d/share/shaders/k3d_ember.sl:6: * to represent it's life. The desired effect is that of glowing particles that
k3d/share/shaders/k3d_ember.sl:20:	point PP = transform ("world", P);
k3d/share/shaders/k3d_ember.sl:21:	point QQ = transform ("world", point "object" (0, 0, 0));
k3d/share/shaders/k3d_ember.sl:25:	//size now represents the size of the sphere particle normalised into 0,1.
k3d/share/shaders/k3d_ember.sl:33:	Nf = faceforward(NN,I);
k3d/share/shaders/k3d_ember.sl:39:	float spcol = pow (max (0, Nf.NI * -1), 1/roughness);
k3d/share/shaders/k3d_ember.sl:41:	// always in the centre of the particle sphere.
k3d/share/shaders/k3d_ember.sl:66:		angle = pow(angle, attenuation);
k3d/share/shaders/k3d_emboss.sl:6: * emboss(): emboss a pencil with lettering.  It uses the same texture
k3d/share/shaders/k3d_envsurf.sl:1:surface k3d_envsurf (string envname = "", envspace = "world")
k3d/share/shaders/k3d_eroded.sl:6: * eroded(): Simulate a metallic surface eaten away with acid
k3d/share/shaders/k3d_eroded.sl:34:	Nf = faceforward (normalize (N), I);
k3d/share/shaders/k3d_eyeball.sl:5: *   Makes a plastic-like surface which looks like an eyeball.  It's meant
k3d/share/shaders/k3d_eyeball.sl:7: *   i.e. where the t parameter is 1.  The colors of the pupil, iris, white
k3d/share/shaders/k3d_eyeball.sl:12: *   Ka, Kd, Ks, roughness, specularcolor - work just like the plastic shader
k3d/share/shaders/k3d_eyeball.sl:14: *   eyeballcolor - color of the white part of the eyeball
k3d/share/shaders/k3d_eyeball.sl:19: *   bloodshot - controls how bloodshot the eye is (0=no blood, 1=very ugly)
k3d/share/shaders/k3d_eyeball.sl:21: *   index - set between 0 and 1, lets you use this shader to generate
k3d/share/shaders/k3d_eyeball.sl:24: * ANTIALIASING: basic antialiasing of the boundaries between tissue types
k3d/share/shaders/k3d_eyeball.sl:27: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_eyeball.sl:30: *      Nov 1991 - crude written of "eye" by lg for Herman's eyes for
k3d/share/shaders/k3d_eyeball.sl:36: *       7 Jan 95 (wave) - changed name to LGEyeBall for namespace reasons...
k3d/share/shaders/k3d_eyeball.sl:37: *       8 Jan 95 (wave) - changed Ciris line to fix bug Larry figured out and changed defaults
k3d/share/shaders/k3d_eyeball.sl:38: *       27 Feb 95 (wave) - changed PO line to fix bug Larry figured out to actually *use* index
k3d/share/shaders/k3d_eyeball.sl:40: * last modified  8 Jan 95 by Michael B. Johnson (wave)
k3d/share/shaders/k3d_eyeball.sl:65:  float i, turb, newturb, freq, f2;
k3d/share/shaders/k3d_eyeball.sl:66:  float displayed, newdisp;
k3d/share/shaders/k3d_eyeball.sl:71:  float twidth, cutoff;
k3d/share/shaders/k3d_eyeball.sl:73:  /* Calculate an appropriate filter width for antialiasing */
k3d/share/shaders/k3d_eyeball.sl:74:  twidth = max (abs(Du(t)*du) + abs(Dv(t)*dv), MINFILTERWIDTH);
k3d/share/shaders/k3d_eyeball.sl:77:  /* Figure out where we are in the eyeball.  Use the following variables:
k3d/share/shaders/k3d_eyeball.sl:78:   * irisstat: 0 inside the iris/white boundary, 1 outside
k3d/share/shaders/k3d_eyeball.sl:80:   * bloody: how potentially bloody it is (fade as we get away from iris)
k3d/share/shaders/k3d_eyeball.sl:83:  irisstat = smoothstep (irissize, irissize+twidth, tt);
k3d/share/shaders/k3d_eyeball.sl:84:  pupilstat = smoothstep (pupilsize, pupilsize+twidth, tt);
k3d/share/shaders/k3d_eyeball.sl:87:  /* If we're somewhere in the white part and it's potentially bloody,
k3d/share/shaders/k3d_eyeball.sl:88:   * then calculate the veining pattern.  Otherwise, just use the color
k3d/share/shaders/k3d_eyeball.sl:89:   * of the whites.  The veining pattern is essentially summed zero sets
k3d/share/shaders/k3d_eyeball.sl:97:	  newturb = 1 - abs (snoise(PO*freq + point(0,0,20*freq)));
k3d/share/shaders/k3d_eyeball.sl:98:	  newdisp = pow (smoothstep (.85, 1, newturb), 10);
k3d/share/shaders/k3d_eyeball.sl:99:	  displayed += (1-displayed) * newdisp * smoothstep (.1, .85, turb * turb);
k3d/share/shaders/k3d_eyeball.sl:100:	  turb *= newturb;
k3d/share/shaders/k3d_eyeball.sl:108:  /* If we're somewhere in the iris, calculate the iris pattern, which is
k3d/share/shaders/k3d_eyeball.sl:120:  /* OK, now calculate a surface texture color (Ct) based on where we are
k3d/share/shaders/k3d_eyeball.sl:121:   * and what patterns we calculated.
k3d/share/shaders/k3d_eyeball.sl:130:  /* Now shade like plastic, but using our calculated surface color and
k3d/share/shaders/k3d_eyeball.sl:134:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_fakesky.sl:5: * sphere, with color varying a bit by altitude, in an attempt to mimic the

k3d/share/shaders/k3d_filament.sl:12:		width		= 0.3 )
k3d/share/shaders/k3d_filament.sl:17:	/* Threshold the fraction against the fractional filament width */
k3d/share/shaders/k3d_filament.sl:18:	if (offset < width) {
k3d/share/shaders/k3d_fill.sl:1:/*IDfill written by Ivan DeWolf
k3d/share/shaders/k3d_fill.sl:2: *simple toon fill shader with shadows
k3d/share/shaders/k3d_fill.sl:12:	normal Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_fire.sl:13:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_fire.sl:18:  color yellow = color (.95, .95, .1);
k3d/share/shaders/k3d_fire.sl:31:  width = max(filterwidth(ss), filterwidth(tt));
k3d/share/shaders/k3d_fire.sl:32:  cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_fire.sl:45:  layer_color = spline(flame, red, red, red, red, orange, yellow, hot, hot);
k3d/share/shaders/k3d_flame.sl:22: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_fractal.sl:8: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

k3d/share/shaders/k3d_fractal.sl:17:	float result, signal, weight, i, exponent;

k3d/share/shaders/k3d_fractal.sl:27:          		signal = pow( signal, sharpness );

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

k3d/share/shaders/k3d_fractal.sl:32:          		weight = 1.0;

k3d/share/shaders/k3d_fractal.sl:35:          		exponent = pow( lacunarity, (-i*H) );

k3d/share/shaders/k3d_fractal.sl:42:          		/* weigh successive contributions by previous signal */

k3d/share/shaders/k3d_fractal.sl:43:          		weight = signal * threshold;

k3d/share/shaders/k3d_fractal.sl:44:          		weight = clamp(weight,0,1)    ;    		

k3d/share/shaders/k3d_fractal.sl:54:          		signal = pow( signal, sharpness ); /* Or signal *= signal;*/

k3d/share/shaders/k3d_fractal.sl:56:          		/* weight the contribution*/

k3d/share/shaders/k3d_fractal.sl:57:          		signal *= weight;

k3d/share/shaders/k3d_fresnelplastic.sl:28:			 not over-written by "colorMap } */
k3d/share/shaders/k3d_fresnelplastic.sl:46:   string reflectSpace = "world";  /* cat Reflection 
k3d/share/shaders/k3d_fresnelplastic.sl:52:   float flipS = 0; /* cat ST type switch desc {Flip S on texture lookups.} */
k3d/share/shaders/k3d_fresnelplastic.sl:53:   float flipT = 0; /* cat ST type switch desc {Flip S on texture lookups.} */
k3d/share/shaders/k3d_fresnelplastic.sl:54:   float MtorFlip = 0; /* cat ST type switch def 1
k3d/share/shaders/k3d_fresnelplastic.sl:55:			  desc {Swap S/T access to overcome Maya/MtoR
k3d/share/shaders/k3d_fresnelplastic.sl:63:    normal Nf = normalize (faceforward( normalize(N), I ));
k3d/share/shaders/k3d_funkyglass.sl:19:  Nf = faceforward(normalize(N), V);
k3d/share/shaders/k3d_fur1.sl:5: *     by Lawrence D. Chin, cs184-bo

k3d/share/shaders/k3d_fur2.sl:1:/* Renamed to SIG2k_srf_fur to be consistent with the RMR 
k3d/share/shaders/k3d_fur2.sl:7:   with clumping and specular model
k3d/share/shaders/k3d_fur2.sl:50:	 float illum_width  = 180;
k3d/share/shaders/k3d_fur2.sl:71:    vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_fur2.sl:77:    vector N_hair = (T^S); /* N_hair is a normal for the hair oriented "away" from the surface */
k3d/share/shaders/k3d_fur2.sl:94:       surface normal, when the hair is exactly tangent to the
k3d/share/shaders/k3d_fur2.sl:95:       surface, use the hair normal Otherwise, blend between the two
k3d/share/shaders/k3d_fur2.sl:108:    /* Loop over lights, catch highlights as if this was a thin cylinder,
k3d/share/shaders/k3d_fur2.sl:111:       James T. Kajiya and Timothy L.  Kay (1989) "Rendering Fur with Three 
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:11: *    blur - how blurry are the reflections? (0 = perfectly sharp)
k3d/share/shaders/k3d_glass.sl:16: *    refrblur - how blurry are the refractions? (0 = perfectly sharp)
k3d/share/shaders/k3d_glass.sl:43:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_gloop.sl:1:/*  IDGloop.sl written 8/99 by Ivan DeWolf
k3d/share/shaders/k3d_gloop.sl:11: * freq - the frequency of the noise. Lower values
k3d/share/shaders/k3d_gloop.sl:12: *        will cause a larger displacement so you will 
k3d/share/shaders/k3d_gloop.sl:14: *        rhymes with freak.
k3d/share/shaders/k3d_gloop.sl:16: * magnitude - how far to displace. probably fine set where it is.
k3d/share/shaders/k3d_gloop.sl:18: * displacement bounds can be computed with the following 
k3d/share/shaders/k3d_gloop.sl:19: * wildly complex formula:
k3d/share/shaders/k3d_gloop.sl:54:  /*where it all happens*/
k3d/share/shaders/k3d_gloop.sl:62:  /* wash your hands after displacing P*/
k3d/share/shaders/k3d_glow.sl:1:surface k3d_glow(float attenuation = 2.0;
k3d/share/shaders/k3d_glow.sl:15:      strength = pow(incidence, attenuation);
k3d/share/shaders/k3d_glow.sl:19:      // Calculate final color and opacity - we set Oi near zero
k3d/share/shaders/k3d_gmarbtile_polish.sl:5: *   Makes the same marble texture as greenmarble, but polished (with ray
k3d/share/shaders/k3d_gmarbtile_polish.sl:9: *   Ka, Kd, Ks, roughness, specularcolor - work just like the plastic
k3d/share/shaders/k3d_gmarbtile_polish.sl:15: *   sharpness - how sharp the veins appear
k3d/share/shaders/k3d_gmarbtile_polish.sl:16: *   groovecolor - the color of the grooves between the tiles.
k3d/share/shaders/k3d_gmarbtile_polish.sl:17: *   groovewidth - the width of the grooves
k3d/share/shaders/k3d_gmarbtile_polish.sl:18: *   tilesize - how big each tile is
k3d/share/shaders/k3d_gmarbtile_polish.sl:20: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_gmarbtile_polish.sl:39:			     float groovewidth = 0.015;
k3d/share/shaders/k3d_gmarbtile_polish.sl:51:  float whichs, whicht;
k3d/share/shaders/k3d_gmarbtile_polish.sl:54:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_gmarbtile_polish.sl:57:  float dss = filterwidth(ss);
k3d/share/shaders/k3d_gmarbtile_polish.sl:59:  float dtt = filterwidth(tt);
k3d/share/shaders/k3d_gmarbtile_polish.sl:61:  float groovy = tilepattern(ss, tt, dss, dtt, groovewidth, groovewidth,
k3d/share/shaders/k3d_gmarbtile_polish.sl:62:			     whichs, whicht, ss, tt);
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:74:   * Now we layer on the veins
k3d/share/shaders/k3d_gmarbtile_polish.sl:80:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_gmarbtile_polish.sl:88:      turb = pow(smoothstep(0.8, 1, 1 - turb), sharpness) / freq;
k3d/share/shaders/k3d_gmarbtile_polish.sl:100:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_gooch.sl:9: *                 http://www.cs.utah.edu/~gooch/SIG98/abstract.html
k3d/share/shaders/k3d_gooch.sl:16: *  beta         : Gooch warm color factor
k3d/share/shaders/k3d_gooch.sl:18: *  y            : used to construct the warm color
k3d/share/shaders/k3d_gooch.sl:22: * AUTHOR: written by Mike King
k3d/share/shaders/k3d_gooch.sl:37:    normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_gooch.sl:39:    color yellow = color(y,y,0);
k3d/share/shaders/k3d_gooch.sl:43:    color kcool,kwarm;
k3d/share/shaders/k3d_gooch.sl:46:    kwarm = yellow + (Cs * beta);
k3d/share/shaders/k3d_gooch.sl:50:        Cgooch += mix(kcool,kwarm,blendval); 
k3d/share/shaders/k3d_gouge.sl:3:/* Listing 16.32  Displacement shader for beating up a surface with a texture  */
k3d/share/shaders/k3d_gouge.sl:19:    *  displace the surface point inwards by that amount. 
k3d/share/shaders/k3d_granite.sl:20:	Ci = Cs * sum * (Ka + Kd * diffuse(faceforward( normalize(N), I )) ) ;
k3d/share/shaders/k3d_graphic_lines.sl:110:	Nf_highlight=faceforward(normalize(N_highlight),I);
k3d/share/shaders/k3d_graphic_lines.sl:113:/** setup tt_highlight with chosen axis **/
k3d/share/shaders/k3d_graphic_lines.sl:188:	Nf_paint=faceforward(normalize(N_paint),I);
k3d/share/shaders/k3d_graphic_lines.sl:260:	Nf_ink=faceforward(normalize(N_ink),I);
k3d/share/shaders/k3d_graphic_lines.sl:321:			C += pow(N.H, 1/roughness);
k3d/share/shaders/k3d_graphic_lines.sl:334:	Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_grass_displace.sl:10: *   by Lawrence D. Chin, cs184-bo

k3d/share/shaders/k3d_grass_displace.sl:42:      z = sqrt(pow(x,2) + pow(y,2));

k3d/share/shaders/k3d_grass_displace.sl:54:      z = sqrt(pow(x,2) + pow(y,2));

k3d/share/shaders/k3d_grass_surface.sl:4: *  by Lawrence D. Chin, cs184-bo

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

k3d/share/shaders/k3d_greenmarble.sl:8: *   Ka, Kd, Ks, roughness, specularcolor - work just like the plastic
k3d/share/shaders/k3d_greenmarble.sl:13: *   sharpness - how sharp the veins appear
k3d/share/shaders/k3d_greenmarble.sl:39:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_greenmarble.sl:49:   * Now we layer on the veins
k3d/share/shaders/k3d_greenmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_greenmarble.sl:62:      turb = pow(smoothstep(0.8, 1, 1 - turb), sharpness) / freq;
k3d/share/shaders/k3d_greenmarble.sl:74:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_grids.sl:1:/** Grid shader copyright 2005 Daniel Scott Matthews dan@3-e.net **/
k3d/share/shaders/k3d_grids.sl:15:float G1L1_linewidth=0.579; 
k3d/share/shaders/k3d_grids.sl:23:float G1L2_linewidth=0.209; 
k3d/share/shaders/k3d_grids.sl:31:float G2L1_linewidth=0.281; 
k3d/share/shaders/k3d_grids.sl:39:float G2L2_linewidth=0.149; 
k3d/share/shaders/k3d_grids.sl:65:color G1L1_layer_opac = pulse(G1L1_linewidth, 1-G1L1_linewidth, G1L1_fuzz, G1L1_tt);
k3d/share/shaders/k3d_grids.sl:73:color G1L2_layer_opac = pulse(G1L2_linewidth, 1-G1L2_linewidth, G1L2_fuzz, G1L2_tt);
k3d/share/shaders/k3d_grids.sl:75:normal G1_Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_grids.sl:84:color G2L1_layer_opac = pulse(G2L1_linewidth, 1-G2L1_linewidth, G2L1_fuzz, G2L1_tt);
k3d/share/shaders/k3d_grids.sl:92:color G2L2_layer_opac = pulse(G2L2_linewidth, 1-G2L2_linewidth, G2L2_fuzz, G2L2_tt);
k3d/share/shaders/k3d_grids_disp.sl:17:float linewidth0=0.368; 
k3d/share/shaders/k3d_grids_disp.sl:23:float linewidth1=0.122; )
k3d/share/shaders/k3d_grids_disp.sl:37:color layer_opac0 = pulse(linewidth0, 1-linewidth0, fuzz0, tt0);
k3d/share/shaders/k3d_grids_disp.sl:50:color layer_opac1 = pulse(linewidth1, 1-linewidth1, fuzz1, tt1);
k3d/share/shaders/k3d_hair.sl:14:	vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_hair.sl:18:	/* Loop over lights, catch highlights as if this was a thin cylinder */
k3d/share/shaders/k3d_hair.sl:22:			Cspec += Cl * v * pow (cosang, 1/roughness);
k3d/share/shaders/k3d_hdr_light.sl:2:* to work with 32 bit floating point TIFF environment maps to give a higher

k3d/share/shaders/k3d_hdr_light.sl:6:*simon@rendermania.com http://www.rendermania.com/HDRI/

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:20:	vector D = normalize(vtransform("world",R));

k3d/share/shaders/k3d_hdr_light.sl:48:	float shadowmapping = 0.0;

k3d/share/shaders/k3d_hdr_light.sl:49:	string shadowname = "";

k3d/share/shaders/k3d_hdr_light.sl:50:	float shadowsamples = 16.0;

k3d/share/shaders/k3d_hdr_light.sl:51:	float shadowblur = 0.0;

k3d/share/shaders/k3d_hdr_light.sl:52:	float shadowbias = 0.0;

k3d/share/shaders/k3d_hdr_light.sl:69:		/*Else bright red colour warns if light is not picking up texture*/

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

k3d/share/shaders/k3d_hdr_light.sl:93:		if (shadowmapping == 1){

k3d/share/shaders/k3d_hdr_light.sl:94:		        if (shadowname != "") {

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:2:* to work with 32 bit floating point TIFF environment maps to give a higher 

k3d/share/shaders/k3d_hdr_surface.sl:6:*simon@rendermania.com http://www.rendermania.com/HDRI/

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:19:	vector D = normalize(vtransform("world",R));

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

k3d/share/shaders/k3d_hdri2.sl:5:       string envspace = "world";
k3d/share/shaders/k3d_hdri2.sl:7:       string shadowname = "";
k3d/share/shaders/k3d_hdri2.sl:8:       float shadowblur = 0.001;
k3d/share/shaders/k3d_hdri2.sl:9:       float shadowbias = 0.01;
k3d/share/shaders/k3d_hdri2.sl:10:       float shadowsamples = 1;)
k3d/share/shaders/k3d_hdri2.sl:17:        if (shadowname != "")
k3d/share/shaders/k3d_hdri2.sl:18:            Cl *= 1 - color shadow (shadowname, Ps, "samples", shadowsamples,
k3d/share/shaders/k3d_hdri2.sl:19:				    "blur", shadowblur, "bias", shadowbias);
k3d/share/shaders/k3d_hextile.sl:8: *       The basic pattern is a hexagonal tiling, with a little bit of
k3d/share/shaders/k3d_hextile.sl:10: *    (presumably due to water or something), which darkens the tile or
k3d/share/shaders/k3d_hextile.sl:12: *    shoes, which really only affects the tile part not the mortar part.
k3d/share/shaders/k3d_hextile.sl:16: *    Ka, Kd, Ks, roughness, specularcolor - work just like plastic
k3d/share/shaders/k3d_hextile.sl:18: *    mortarcolor - the color of the mortar (space between the tiles)
k3d/share/shaders/k3d_hextile.sl:20: *    mortarwidth - the width of the mortar (in s-t units)
k3d/share/shaders/k3d_hextile.sl:24: *    Some rudimentary antialiasing is performed on the borders between
k3d/share/shaders/k3d_hextile.sl:29: *    the floors in the public areas of the Washington DC subway system.
k3d/share/shaders/k3d_hextile.sl:31: * AUTHOR: written by Larry Gritz, 1994
k3d/share/shaders/k3d_hextile.sl:34: *    15 Feb 1994 -- written by lg
k3d/share/shaders/k3d_hextile.sl:53:	 float mortarwidth = 0.02;
k3d/share/shaders/k3d_hextile.sl:63:  float tilewidth;
k3d/share/shaders/k3d_hextile.sl:68:  float swidth, twidth, sfuzz, tfuzz, fuzzmax;
k3d/share/shaders/k3d_hextile.sl:69:  float mw2;
k3d/share/shaders/k3d_hextile.sl:74:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_hextile.sl:75:  swidth = abs(Du(s)*du) + abs(Dv(s)*dv);
k3d/share/shaders/k3d_hextile.sl:76:  twidth = abs(Du(t)*du) + abs(Dv(t)*dv);
k3d/share/shaders/k3d_hextile.sl:77:  sfuzz = 0.5 * swidth;
k3d/share/shaders/k3d_hextile.sl:78:  tfuzz = 0.5 * twidth;
k3d/share/shaders/k3d_hextile.sl:81:  tilewidth = tileradius * 1.7320508;  /* sqrt(3) */
k3d/share/shaders/k3d_hextile.sl:85:       ss = s + tilewidth/2;
k3d/share/shaders/k3d_hextile.sl:87:  stile = floor (ss / tilewidth);
k3d/share/shaders/k3d_hextile.sl:88:  ss = mod (ss, tilewidth);
k3d/share/shaders/k3d_hextile.sl:90:  mw2 = mortarwidth/2;
k3d/share/shaders/k3d_hextile.sl:92:      mortar =  1 - (smoothstep(mw2,mw2+sfuzz,ss) *
k3d/share/shaders/k3d_hextile.sl:93:		     (1 - smoothstep(tilewidth-mw2-sfuzz,tilewidth-mw2,ss)));
k3d/share/shaders/k3d_hextile.sl:96:      x = tilewidth/2 - abs (ss - tilewidth/2);
k3d/share/shaders/k3d_hextile.sl:102:	  if (ss > tilewidth/2)
k3d/share/shaders/k3d_hextile.sl:105:      mortar = (smoothstep (x-1.73*mw2-tfuzz, x-1.73*mw2, y) *
k3d/share/shaders/k3d_hextile.sl:106:		(1 - smoothstep (x+1.73*mw2, x+1.73*mw2+tfuzz, y)));
k3d/share/shaders/k3d_hextile.sl:120:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_imagelayerclouds.sl:19:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_incandplastic.sl:23:  Nf = faceforward(normalize(N), I, normalize(N));

k3d/share/shaders/k3d_leather.sl:8: *and offer you this shader, it was done (JMredapple.sl) by Jonathan Merritt

k3d/share/shaders/k3d_leather.sl:9: *without hes shader i wouldnt be able to do mine so send him flowers :)

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

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

k3d/share/shaders/k3d_leather.sl:27:	color brown = color(0.5,0.3,0.10);

k3d/share/shaders/k3d_leather.sl:46:	point PP, newP;

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

k3d/share/shaders/k3d_leather.sl:87:	base_turb = pow(base_turb, (1/redness));

k3d/share/shaders/k3d_leather.sl:119:	blotch = pow(blotch_turb, 1.3) * BLOTCH_TCF * 

k3d/share/shaders/k3d_leather.sl:120:	         pow(base_turb, 2);

k3d/share/shaders/k3d_leather.sl:127:	 * Set the brown specking.

k3d/share/shaders/k3d_leather.sl:129:	 * The apple has brown speckles on it, set by mixing

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

k3d/share/shaders/k3d_leather.sl:141:	 * Determine where the apple goes black at the poles.

k3d/share/shaders/k3d_leather.sl:142:	 * This simulates the spots where the stalk would be

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

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

k3d/share/shaders/k3d_leather.sl:157:	cs = mix(cs, brown, speck);

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

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

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:187:	 * Here, we raytrace for the slight mirrored reflections

k3d/share/shaders/k3d_lensflare.sl:4: * Description: This shader, when placed on a piece of geometry 
k3d/share/shaders/k3d_lensflare.sl:6: *   These effects happen in real cameras when the camera points toward
k3d/share/shaders/k3d_lensflare.sl:7: *   a bright light source, resulting in interreflections within the
k3d/share/shaders/k3d_lensflare.sl:22: *   rainbowintensity - intensity of rainbow effect (0=none)
k3d/share/shaders/k3d_lensflare.sl:23: *   rainbowradius, rainbowwidth - size of the rainbow
k3d/share/shaders/k3d_lensflare.sl:25: *          image center with the light position
k3d/share/shaders/k3d_lensflare.sl:33: *   graphics.  Use this effect with extreme care!  
k3d/share/shaders/k3d_lensflare.sl:59:/* Helper function: compute the camera's diagonal field of view */
k3d/share/shaders/k3d_lensflare.sl:70:rainbow(float x, dx)
k3d/share/shaders/k3d_lensflare.sl:94:		      float rainbowintensity = 0.03;
k3d/share/shaders/k3d_lensflare.sl:95:		      float rainbowradius = 0.5; float rainbowwidth = 0.2;
k3d/share/shaders/k3d_lensflare.sl:119:  float dPndc = filterwidthp(Pndc);
k3d/share/shaders/k3d_lensflare.sl:150:	bloom = pow(1 - smoothstep(0.0, radius * bloom, dist), bloomfalloff);
k3d/share/shaders/k3d_lensflare.sl:162:	  pow(1 - smoothstep(0.0, radius * star, dist), starburstfalloff);
k3d/share/shaders/k3d_lensflare.sl:166:    /* Rainbow */
k3d/share/shaders/k3d_lensflare.sl:167:    if(rainbowintensity > 0)
k3d/share/shaders/k3d_lensflare.sl:170:	  brightness * (rainbowintensity / intensity) *
k3d/share/shaders/k3d_lensflare.sl:171:	  rainbow((dist / rainbowradius - 1) / rainbowwidth,
k3d/share/shaders/k3d_lensflare.sl:172:		  (dPndc / rainbowradius) / rainbowwidth);
k3d/share/shaders/k3d_lensflare.sl:176:     * Now emit the random rings themselves
k3d/share/shaders/k3d_lensflare.sl:187:			   pow(urand(), 2)) * distance(cntr, Plight);
k3d/share/shaders/k3d_lensflare.sl:213:	  {			/* Spot with soft hole in middle */
k3d/share/shaders/k3d_luna.sl:7: *    the scale for human naked-eye viewing from earth.
k3d/share/shaders/k3d_luna.sl:15: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_luna.sl:65:  omega = pow(lacunarity, (-.5) - H);
k3d/share/shaders/k3d_luna.sl:147:/*	  ht = wrinkled (vv, 2, .833, 4); */
k3d/share/shaders/k3d_luna.sl:162:/*	  ht = wrinkled (vv, 2, .833, 4); */
k3d/share/shaders/k3d_luna.sl:182:  /* Recalc normal since we changed P a whole bunch. */
k3d/share/shaders/k3d_luna.sl:187:  Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_lunette.sl:8: *   surfaces placed beneath your scene which act as the ground.  The default
k3d/share/shaders/k3d_lunette.sl:9: *   colors are a bland pastel blue and yellow, which should complement many
k3d/share/shaders/k3d_lunette.sl:10: *   hero objects that you might wish to show off.  The shader is a copy of a
k3d/share/shaders/k3d_lunette.sl:11: *   pattern I saw in the background of another image entitled "Lunettes",
k3d/share/shaders/k3d_lunette.sl:12: *   which I believe has something to do with spectacles in French.  Hence the
k3d/share/shaders/k3d_lunette.sl:13: *   name, anyway.  The pattern is calculated in 2D u,v coordinates.
k3d/share/shaders/k3d_lunette.sl:16: *   Ka, Kd, Ks, roughness, specularcolor - work like the plastic shader
k3d/share/shaders/k3d_lunette.sl:18: *   ulinewidth, vlinewidth - proportional width of the grid lines
k3d/share/shaders/k3d_lunette.sl:25: *   maxOctaves, lunacrity, gain - work as in the fBm function
k3d/share/shaders/k3d_lunette.sl:28: *   The shader should antialias itself quite well, since it uses antialiased
k3d/share/shaders/k3d_lunette.sl:31: * Author: written by Jonathan Merritt (jmerritt@warpax.com), 5th October 2002
k3d/share/shaders/k3d_lunette.sl:42: * Base color for the "lunette" pattern.  The pattern is calculated in a two-
k3d/share/shaders/k3d_lunette.sl:51: *   sslinewidth, ttlinewidth - Width of the grid lines in ss and tt
k3d/share/shaders/k3d_lunette.sl:53: *                              cell over which the grid repeat occurs.
k3d/share/shaders/k3d_lunette.sl:54: *   colorA, colorB - Two colors for the background pattern.
k3d/share/shaders/k3d_lunette.sl:76:	float sslinewidth;	/* proportional width of lines in ss */
k3d/share/shaders/k3d_lunette.sl:77:	float ttlinewidth;	/* proportional width of lines in tt */
k3d/share/shaders/k3d_lunette.sl:91:	 * Calculate pulsegrid, which is a variable indicating the value of
k3d/share/shaders/k3d_lunette.sl:93:	 * whereas pulsegrid = 1 means that there IS a grid at the point.
k3d/share/shaders/k3d_lunette.sl:94:	 * pulsegrid varies smoothly between the two values to cope with
k3d/share/shaders/k3d_lunette.sl:98:		1/ssrepeats, sslinewidth, ss, filterwidth(ss)
k3d/share/shaders/k3d_lunette.sl:101:		1/ttrepeats, ttlinewidth, tt, filterwidth(tt)
k3d/share/shaders/k3d_lunette.sl:107:	 * between colorA and colorB, created using noise and other mixing
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:116:	noiseamt = pow(noiseamt, colorBenhance);
k3d/share/shaders/k3d_lunette.sl:125:	 * return the mix between the base grid and the colorful noise
k3d/share/shaders/k3d_lunette.sl:140:	float ulinewidth = 0.125;	/* Relative width of grid lines in u */
k3d/share/shaders/k3d_lunette.sl:142:	float vlinewidth = 0.12;	/* Relative width of grid lines in v */
k3d/share/shaders/k3d_lunette.sl:160:		u, v, urepeats, vrepeats, ulinewidth, vlinewidth,
k3d/share/shaders/k3d_lunette.sl:168:	normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_map_pattern_1.sl:4:float swidth1=1; 
k3d/share/shaders/k3d_map_pattern_1.sl:5:float twidth1=1; 
k3d/share/shaders/k3d_map_pattern_1.sl:10:color lightwood=color(0.69,0.44,0.25); 
k3d/share/shaders/k3d_map_pattern_1.sl:11:color darkwood=color(0.35,0.22,0.08); 
k3d/share/shaders/k3d_map_pattern_1.sl:36:temt_c1=texture(map1,temp_ss1,temp_tt1,"swidth",swidth1,"twidth",twidth1,"samples",samples1);
k3d/share/shaders/k3d_map_pattern_1.sl:40:temt_c1=texture(map1[channel1],temp_ss1,temp_tt1,"swidth",swidth1,"twidth",twidth1,"samples",samples1);
k3d/share/shaders/k3d_map_pattern_1.sl:65:Ct = mix (lightwood, darkwood, r*r2*r2);
k3d/share/shaders/k3d_map_pattern_1.sl:68:normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_matte.sl:12:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_metal.sl:13:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_mondometal.sl:4: * Layered shader with mondo as a base and a metal modulated with a matte file.

k3d/share/shaders/k3d_mondometal.sl:74:                            "swidth", abColorMapBlur,

k3d/share/shaders/k3d_mondometal.sl:75:                            "twidth", abColorMapBlur );

k3d/share/shaders/k3d_mondometal.sl:79:                            "swidth", abColorMapBlur,

k3d/share/shaders/k3d_mondometal.sl:80:                            "twidth", abColorMapBlur );

k3d/share/shaders/k3d_mondometal.sl:99:                            "swidth", abDiffuseMapBlur,

k3d/share/shaders/k3d_mondometal.sl:100:                            "twidth", abDiffuseMapBlur );

k3d/share/shaders/k3d_mondometal.sl:111:                            "swidth", abSpecularMapBlur,

k3d/share/shaders/k3d_mondometal.sl:112:                            "twidth", abSpecularMapBlur );

k3d/share/shaders/k3d_mondometal.sl:124:                      "swidth", abSpecularColorMapBlur, 

k3d/share/shaders/k3d_mondometal.sl:125:                      "twidth", abSpecularColorMapBlur );

k3d/share/shaders/k3d_mondometal.sl:135:                            "swidth", abRoughnessMapBlur, 

k3d/share/shaders/k3d_mondometal.sl:136:                            "twidth", abRoughnessMapBlur );

k3d/share/shaders/k3d_mondometal.sl:149:                            "swidth", abTransparencyMapBlur, 

k3d/share/shaders/k3d_mondometal.sl:150:                            "twidth", abTransparencyMapBlur );

k3d/share/shaders/k3d_mondometal.sl:155:                            "swidth", abTransparencyMapBlur, 

k3d/share/shaders/k3d_mondometal.sl:156:                            "twidth", abTransparencyMapBlur ));

k3d/share/shaders/k3d_mondometal.sl:164:                            "swidth", abIncandescenseMapBlur, 

k3d/share/shaders/k3d_mondometal.sl:165:                            "twidth", abIncandescenseMapBlur );

k3d/share/shaders/k3d_mondometal.sl:177:                            "swidth", abBumpMapBlur,

k3d/share/shaders/k3d_mondometal.sl:178:                            "twidth", abBumpMapBlur );

k3d/share/shaders/k3d_mondometal.sl:199:    Nf = faceforward(normalize(Nf), I , normalize(Nf));

k3d/share/shaders/k3d_mondometal.sl:206:        D = vtransform("worldspace", D);

k3d/share/shaders/k3d_mondometal.sl:213:                                    "swidth", abReflectionMapBlur,

k3d/share/shaders/k3d_mondometal.sl:214:                                    "twidth", abReflectionMapBlur );

k3d/share/shaders/k3d_mondometal.sl:223:                            "swidth", abColorMapBlur,

k3d/share/shaders/k3d_mondometal.sl:224:                            "twidth", abColorMapBlur);

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

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

k3d/share/shaders/k3d_mysky.sl:5: * Original name below 

k3d/share/shaders/k3d_mysky.sl:10: *    Makes nice looking cumulous clouds like you would see in the sky

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

k3d/share/shaders/k3d_mysky.sl:14: *    puffy clouds (like painted clouds on a wall), then it would be pretty

k3d/share/shaders/k3d_mysky.sl:21: *    threshold - fBm sum below this level is just blue sky

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

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

k3d/share/shaders/k3d_noisysmoke.sl:4:/* Here is where we define the GADD. */
k3d/share/shaders/k3d_noisysmoke.sl:44:  /* But with BMRT 2.3.6 and later, they're the same... */
k3d/share/shaders/k3d_noisysmoke.sl:63:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_noisysmoke.sl:75:      while(d <= end)
k3d/share/shaders/k3d_noisysmoke.sl:82:	    /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_noisysmoke.sl:94:	  /* Now we adjust Cv/Ov to account for dC and dO */
k3d/share/shaders/k3d_noisysmoke.sl:106:   * Now Cv is the light contributed by the volume itself, and Ov is the
k3d/share/shaders/k3d_noisysmoke.sl:108:   * which makes it through the volume.
k3d/share/shaders/k3d_null.sl:4: * Note: we include dummy Ka and Kd arguments to appease the radiosity
k3d/share/shaders/k3d_oak.sl:5: *    wood grain.  The rings surround the z axis, so to position the
k3d/share/shaders/k3d_oak.sl:6: *    pattern, one should translate the shadingspace (which defaults to
k3d/share/shaders/k3d_oak.sl:7: *    "shader").  This makes a fairly plain, unfinished wood, that looks
k3d/share/shaders/k3d_oak.sl:11: *   shadingspace - space in which the pattern is laid out
k3d/share/shaders/k3d_oak.sl:16: *   Clightwood - the light, "background" wood color
k3d/share/shaders/k3d_oak.sl:17: *   Cdarkwood - the darker color in the ring/grain
k3d/share/shaders/k3d_oak.sl:21: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oak.sl:22: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oak.sl:24: *   angularwobble, angularwobblefreq - warping indexed by angle about
k3d/share/shaders/k3d_oak.sl:26: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oak.sl:27: *       grain are weighted.  0 turns one off, 1 makes full effect.
k3d/share/shaders/k3d_oak.sl:59:		float trunkwobble = 0.15, trunkwobblefreq = 0.025;
k3d/share/shaders/k3d_oak.sl:60:		float angularwobble = 1, angularwobblefreq = 1.5;
k3d/share/shaders/k3d_oak.sl:62:		color Clightwood = color(.5, .2, .067);	/* light wood color */
k3d/share/shaders/k3d_oak.sl:63:		color Cdarkwood = color(0.15, 0.077, 0.028);
k3d/share/shaders/k3d_oak.sl:69:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_oak.sl:71:  float wood;
k3d/share/shaders/k3d_oak.sl:72:  wood =
k3d/share/shaders/k3d_oak.sl:74:	       ringnoisefreq, trunkwobble, trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oak.sl:75:	       angularwobblefreq, ringy, grainy);
k3d/share/shaders/k3d_oak.sl:76:  color Cwood = mix(Clightwood, Cdarkwood, wood);
k3d/share/shaders/k3d_oak.sl:77:  Nf = faceforward(Displace(Nf, "shader", -wood * divotdepth, truedisp), I);
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:4: * Description: makes procedural varnished wood planks.  The planks
k3d/share/shaders/k3d_oakplank.sl:5: *    are projected onto the x-y plane, with the length aligned with
k3d/share/shaders/k3d_oakplank.sl:6: *    the y axis.  The subpattern within each individual plank is just
k3d/share/shaders/k3d_oakplank.sl:10: *   shadingspace - space in which the pattern is laid out
k3d/share/shaders/k3d_oakplank.sl:15: *   plankwidth, planklength - size of the planks
k3d/share/shaders/k3d_oakplank.sl:16: *   groovewidth, grooveheight - width of the grooves between planks
k3d/share/shaders/k3d_oakplank.sl:17: *   Cgroove - color of the grooves between the planks
k3d/share/shaders/k3d_oakplank.sl:18: *   groovedepth - how far down do the grooves displace?
k3d/share/shaders/k3d_oakplank.sl:19: *   edgewidth - how close to the plank border does the wood start to curl?
k3d/share/shaders/k3d_oakplank.sl:22: * Parameters for the color and pattern of the wood grain: 
k3d/share/shaders/k3d_oakplank.sl:23: *   Clightwood - the light, "background" wood color
k3d/share/shaders/k3d_oakplank.sl:24: *   Cdarkwood - the darker color in the ring/grain
k3d/share/shaders/k3d_oakplank.sl:28: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oakplank.sl:29: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oakplank.sl:31: *   angularwobble, angularwobblefreq - warping indexed by angle about
k3d/share/shaders/k3d_oakplank.sl:33: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oakplank.sl:34: *       grain are weighted.  0 turns one off, 1 makes full effect.
k3d/share/shaders/k3d_oakplank.sl:56:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_oakplank.sl:71:/* Given 2-D texture coordinates ss,tt, filter widths ds, dt, and the
k3d/share/shaders/k3d_oakplank.sl:72: * width and height of the grooves between tiles, figure out which
k3d/share/shaders/k3d_oakplank.sl:73: * (integer indexed) plank we are on and what coordinates within our
k3d/share/shaders/k3d_oakplank.sl:74: * individual plank we are shading.
k3d/share/shaders/k3d_oakplank.sl:77:		   float plankwidth, planklength;
k3d/share/shaders/k3d_oakplank.sl:78:		   float groovewidth, grooveheight;
k3d/share/shaders/k3d_oakplank.sl:79:		   output float swhichplank, twhichplank;
k3d/share/shaders/k3d_oakplank.sl:82:  /* Find which s plank we're on and our s coordinate within it */
k3d/share/shaders/k3d_oakplank.sl:83:  swhichplank = floor(ss / plankwidth);
k3d/share/shaders/k3d_oakplank.sl:84:  splank = ss - swhichplank * plankwidth;
k3d/share/shaders/k3d_oakplank.sl:86:  float newt = tt + planklength * cellnoise(swhichplank);
k3d/share/shaders/k3d_oakplank.sl:87:  /* Find which t plank we're on and our t coordinate within it */
k3d/share/shaders/k3d_oakplank.sl:88:  twhichplank = floor(newt / planklength);
k3d/share/shaders/k3d_oakplank.sl:89:  tplank = newt - twhichplank * planklength;
k3d/share/shaders/k3d_oakplank.sl:90:  /* Calculate our "in-plank" value by multiplying two perpendicular
k3d/share/shaders/k3d_oakplank.sl:93:  return filteredpulsetrain(groovewidth, plankwidth, ss + groovewidth / 2,
k3d/share/shaders/k3d_oakplank.sl:96:						     newt + grooveheight / 2,
k3d/share/shaders/k3d_oakplank.sl:109:		     float trunkwobble = 0.15, trunkwobblefreq = 0.025;
k3d/share/shaders/k3d_oakplank.sl:110:		     float angularwobble = 1, angularwobblefreq = 1.5;
k3d/share/shaders/k3d_oakplank.sl:112:		     color Clightwood = color(.5, .2, .067);	/* light wood color */
k3d/share/shaders/k3d_oakplank.sl:113:		     color Cdarkwood = color(0.15, 0.077, 0.028);
k3d/share/shaders/k3d_oakplank.sl:116:		     float plankwidth = 2, planklength = 30;
k3d/share/shaders/k3d_oakplank.sl:117:		     float groovewidth = 0.05, grooveheight = 0.05;
k3d/share/shaders/k3d_oakplank.sl:119:		     float groovedepth = 0.03, edgewidth = 0.1;
k3d/share/shaders/k3d_oakplank.sl:125:  float dss = filterwidth(ss), dtt = filterwidth(tt);
k3d/share/shaders/k3d_oakplank.sl:128:   * Find out where in the pattern we are: which plank we're on, and
k3d/share/shaders/k3d_oakplank.sl:129:   * the (splank,tplank) coordinates (both on [0,1]) within our tile.
k3d/share/shaders/k3d_oakplank.sl:131:  float swhichplank, twhichplank, splank, tplank;
k3d/share/shaders/k3d_oakplank.sl:132:  float inplank = plankpattern(ss, tt, dss, dtt, plankwidth, planklength,
k3d/share/shaders/k3d_oakplank.sl:133:			       groovewidth, grooveheight,
k3d/share/shaders/k3d_oakplank.sl:134:			       swhichplank, twhichplank, splank, tplank);
k3d/share/shaders/k3d_oakplank.sl:135:  float plankindex = swhichplank + 13 * twhichplank;
k3d/share/shaders/k3d_oakplank.sl:139:    (vector cellnoise(swhichplank, twhichplank) - 0.5);
k3d/share/shaders/k3d_oakplank.sl:141:  float wood = oaktexture(Ppat, dPshad, ringfreq, ringunevenness, grainfreq,
k3d/share/shaders/k3d_oakplank.sl:142:			  ringnoise, ringnoisefreq, trunkwobble,
k3d/share/shaders/k3d_oakplank.sl:143:			  trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oakplank.sl:144:			  angularwobblefreq, ringy, grainy);
k3d/share/shaders/k3d_oakplank.sl:145:  color Cwood = mix(Clightwood, Cdarkwood, wood);
k3d/share/shaders/k3d_oakplank.sl:147:  Cwood = varyEach(Cwood, plankindex, varyhue, varysat, varylum);
k3d/share/shaders/k3d_oakplank.sl:148:  Cwood = mix(Cgroove, Cwood, inplank);
k3d/share/shaders/k3d_oakplank.sl:150:  /* Displacement: the edges of the planks displace down a bit, as do
k3d/share/shaders/k3d_oakplank.sl:151:   * the grooves between planks. 
k3d/share/shaders/k3d_oakplank.sl:153:  float edgedisp = smoothpulse(0, edgewidth, plankwidth - edgewidth,
k3d/share/shaders/k3d_oakplank.sl:154:			       plankwidth, splank);
k3d/share/shaders/k3d_oakplank.sl:156:    smoothpulse(0, edgewidth, planklength - edgewidth, planklength, tplank);
k3d/share/shaders/k3d_oakplank.sl:157:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_oakplank.sl:158:  float disp = -wood * divotdepth + groovedepth * (edgedisp - 1);
k3d/share/shaders/k3d_oakplank.sl:162:  Nf = faceforward(Displace(Nf, "shader", disp, truedisp), I);
k3d/share/shaders/k3d_oakplank.sl:165:   * Less specular in the grooves, more specular in the dark wood. 
k3d/share/shaders/k3d_oakplank.sl:167:  float specadjusted = 1 + .3 * wood - 0.8 * (1 - inplank);
k3d/share/shaders/k3d_oakplank.sl:169:    MaterialShinyPlastic(Nf, Cwood, Ka, Kd, specadjusted * Ks, roughness,
k3d/share/shaders/k3d_orange.sl:35:	point newP;
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:8: *   Makes a rough surface using a BRDF which is more accurate than
k3d/share/shaders/k3d_orennayar.sl:31: *   2. Examination of why rough surfaces are not Lambertian will lead
k3d/share/shaders/k3d_orennayar.sl:35: *   14 June 1994 -- written by Larry Gritz
k3d/share/shaders/k3d_orennayar.sl:52:    Nf = faceforward (normalize(N),I);
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_outlet.sl:6: *   patch to make a wall more interesting.  The patch should be
k3d/share/shaders/k3d_outlet.sl:7: *   twice as high as it is wide.  *Totally* cheesy if you see it from
k3d/share/shaders/k3d_outlet.sl:13: *   Ka, Kd 	   	work just like the matte shader
k3d/share/shaders/k3d_outlet.sl:14: *   screwKs            Ks parameter for the screw
k3d/share/shaders/k3d_outlet.sl:17: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_outlet.sl:20: *      June 1992 -- first written by lg for the Kitchen image
k3d/share/shaders/k3d_outlet.sl:30:	 float screwKs = 0.5; )
k3d/share/shaders/k3d_outlet.sl:48:      ks = screwKs;
k3d/share/shaders/k3d_outlet.sl:68:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_outline.sl:1:/* IDoutline written by Ivan DeWolf
k3d/share/shaders/k3d_outline.sl:2: * it's the valdez algorithm. short and sweet.
k3d/share/shaders/k3d_outline.sl:3: * width sets the line width.
k3d/share/shaders/k3d_outline.sl:6:k3d_outline(float width = .05)
k3d/share/shaders/k3d_outline.sl:12:  P += Nn*width;
k3d/share/shaders/k3d_paintedplastic.sl:43:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_parquet_plank.sl:2: * parquet_plank.sl -- another surface shader for wood.
k3d/share/shaders/k3d_parquet_plank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_plank.sl:6: *   like oak plank parquet floor tiles.  The actual wood and plank pattern
k3d/share/shaders/k3d_parquet_plank.sl:7: *   is based on my "planks" shader.  This shader works best if "s" and "t"
k3d/share/shaders/k3d_parquet_plank.sl:8: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank.sl:11: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_parquet_plank.sl:13: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank.sl:17: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank.sl:18: *   lightwood, darkwood - surface colors for the wood itself
k3d/share/shaders/k3d_parquet_plank.sl:19: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_plank.sl:20: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_plank.sl:22: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_parquet_plank.sl:25: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_plank.sl:36:			  color lightwood = color(0.57, 0.292, 0.125);
k3d/share/shaders/k3d_parquet_plank.sl:37:			  color darkwood = color(0.275, 0.15, 0.06);
k3d/share/shaders/k3d_parquet_plank.sl:39:			  float plankwidth = .05, groovewidth = 0.001;
k3d/share/shaders/k3d_parquet_plank.sl:41:			  float grainy = 1, wavy = 0.08;)
k3d/share/shaders/k3d_parquet_plank.sl:49:  float whichrow, whichplank;
k3d/share/shaders/k3d_parquet_plank.sl:50:  float swidth, twidth, fwidth, ss, tt, w, h, fade, ttt;
k3d/share/shaders/k3d_parquet_plank.sl:51:  color Ct, woodcolor;
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:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_plank.sl:63:  swidth =
k3d/share/shaders/k3d_parquet_plank.sl:66:  twidth =
k3d/share/shaders/k3d_parquet_plank.sl:69:  fwidth = max(swidth, twidth);
k3d/share/shaders/k3d_parquet_plank.sl:71:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_parquet_plank.sl:74:  whichrow = floor(ss);
k3d/share/shaders/k3d_parquet_plank.sl:76:  whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_plank.sl:77:  if(mod(whichrow / plankspertile + whichplank, 2) >= 1)
k3d/share/shaders/k3d_parquet_plank.sl:80:      whichrow = floor(ss);
k3d/share/shaders/k3d_parquet_plank.sl:82:      whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_plank.sl:83:      tmp = swidth;
k3d/share/shaders/k3d_parquet_plank.sl:84:      swidth = twidth;
k3d/share/shaders/k3d_parquet_plank.sl:85:      twidth = tmp;
k3d/share/shaders/k3d_parquet_plank.sl:87:  ss -= whichrow;
k3d/share/shaders/k3d_parquet_plank.sl:88:  tt -= whichplank;
k3d/share/shaders/k3d_parquet_plank.sl:89:  whichplank += 20 * (whichrow + 10);
k3d/share/shaders/k3d_parquet_plank.sl:92:   * Figure out where the grooves are.  The value groovy is 0 where there
k3d/share/shaders/k3d_parquet_plank.sl:93:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_plank.sl:96:  if(swidth >= 1)
k3d/share/shaders/k3d_parquet_plank.sl:97:    w = 1 - 2 * GWF;
k3d/share/shaders/k3d_parquet_plank.sl:99:    w =
k3d/share/shaders/k3d_parquet_plank.sl:100:      clamp(boxstep(GWF - swidth, GWF, ss), max(1 - GWF / swidth, 0),
k3d/share/shaders/k3d_parquet_plank.sl:101:	    1) - clamp(boxstep(1 - GWF - swidth, 1 - GWF, ss), 0,
k3d/share/shaders/k3d_parquet_plank.sl:102:		       2 * GWF / swidth);
k3d/share/shaders/k3d_parquet_plank.sl:103:  if(twidth >= 1)
k3d/share/shaders/k3d_parquet_plank.sl:107:      clamp(boxstep(GHF - twidth, GHF, tt), max(1 - GHF / twidth, 0),
k3d/share/shaders/k3d_parquet_plank.sl:108:	    1) - clamp(boxstep(1 - GHF - twidth, 1 - GHF, tt), 0,
k3d/share/shaders/k3d_parquet_plank.sl:109:		       2 * GHF / twidth);
k3d/share/shaders/k3d_parquet_plank.sl:110:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_parquet_plank.sl:111:   * w = step (GWF,ss) - step(1-GWF,ss);
k3d/share/shaders/k3d_parquet_plank.sl:114:  groovy = w * h;
k3d/share/shaders/k3d_parquet_plank.sl:120:  fade = smoothstep(1 / ringscale, 8 / ringscale, fwidth);
k3d/share/shaders/k3d_parquet_plank.sl:123:      ttt = tt / 4 + whichplank / 28.38 + wavy * noise(8 * ss, tt / 4);
k3d/share/shaders/k3d_parquet_plank.sl:124:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank.sl:133:      fade = smoothstep(2 / grainscale, 8 / grainscale, fwidth);
k3d/share/shaders/k3d_parquet_plank.sl:147:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank.sl:148:  woodcolor = mix(lightwood, darkwood, r);
k3d/share/shaders/k3d_parquet_plank.sl:151:  woodcolor *=
k3d/share/shaders/k3d_parquet_plank.sl:152:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_parquet_plank.sl:154:  Ct = mix(groovecolor, woodcolor, groovy);
k3d/share/shaders/k3d_parquet_plank2.sl:3: * parquet_plank.sl -- another surface shader for wood.
k3d/share/shaders/k3d_parquet_plank2.sl:6: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_plank2.sl:7: *   like oak plank parquet floor tiles.  The actual wood and plank pattern
k3d/share/shaders/k3d_parquet_plank2.sl:8: *   is based on my "planks" shader.  This shader works best if "s" and "t"
k3d/share/shaders/k3d_parquet_plank2.sl:9: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank2.sl:12: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_parquet_plank2.sl:14: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank2.sl:18: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank2.sl:19: *   lightwood, darkwood - surface colors for the wood itself
k3d/share/shaders/k3d_parquet_plank2.sl:20: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_plank2.sl:21: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_plank2.sl:23: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_parquet_plank2.sl:26: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_plank2.sl:28: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_plank2.sl:29: *         email: gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_parquet_plank2.sl:35: *    10 Feb 1995 - written by Larry Gritz, based on my "plank" shader.
k3d/share/shaders/k3d_parquet_plank2.sl:36: *    10 Feb 1995 - modified by wave to change the name
k3d/share/shaders/k3d_parquet_plank2.sl:38: * last modified 10 Feb 1995 by wave
k3d/share/shaders/k3d_parquet_plank2.sl:50:	       color lightwood = color (0.57, 0.292, 0.125);
k3d/share/shaders/k3d_parquet_plank2.sl:51:	       color darkwood  = color (0.275, 0.15, 0.06);
k3d/share/shaders/k3d_parquet_plank2.sl:53:	       float plankwidth = .05, groovewidth = 0.001;
k3d/share/shaders/k3d_parquet_plank2.sl:55:	       float grainy = 1, wavy = 0.08; )
k3d/share/shaders/k3d_parquet_plank2.sl:63:  float whichrow, whichplank;
k3d/share/shaders/k3d_parquet_plank2.sl:64:  float swidth, twidth, fwidth, ss, tt, w, h, fade, ttt;
k3d/share/shaders/k3d_parquet_plank2.sl:65:  color Ct, woodcolor;
k3d/share/shaders/k3d_parquet_plank2.sl:68:  float tilewidth, whichtile, tmp, planklength;
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:76:  /* Determine how wide in s-t space one pixel projects to */
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:79:  fwidth = max(swidth,twidth);
k3d/share/shaders/k3d_parquet_plank2.sl:81:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_parquet_plank2.sl:84:  whichrow = floor (ss);
k3d/share/shaders/k3d_parquet_plank2.sl:86:  whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_plank2.sl:87:  if (mod (whichrow/plankspertile + whichplank, 2) >= 1) {
k3d/share/shaders/k3d_parquet_plank2.sl:89:      whichrow = floor (ss);
k3d/share/shaders/k3d_parquet_plank2.sl:91:      whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_plank2.sl:92:      tmp = swidth;  swidth = twidth;  twidth = tmp;
k3d/share/shaders/k3d_parquet_plank2.sl:94:  ss -= whichrow;
k3d/share/shaders/k3d_parquet_plank2.sl:95:  tt -= whichplank;
k3d/share/shaders/k3d_parquet_plank2.sl:96:  whichplank += 20*(whichrow+10);
k3d/share/shaders/k3d_parquet_plank2.sl:99:   * Figure out where the grooves are.  The value groovy is 0 where there
k3d/share/shaders/k3d_parquet_plank2.sl:100:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_plank2.sl:103:  if (swidth >= 1)
k3d/share/shaders/k3d_parquet_plank2.sl:104:      w = 1 - 2*GWF;
k3d/share/shaders/k3d_parquet_plank2.sl:105:  else w = clamp (boxstep(GWF-swidth,GWF,ss), max(1-GWF/swidth,0), 1)
k3d/share/shaders/k3d_parquet_plank2.sl:106:	 - clamp (boxstep(1-GWF-swidth,1-GWF,ss), 0, 2*GWF/swidth);
k3d/share/shaders/k3d_parquet_plank2.sl:107:  if (twidth >= 1)
k3d/share/shaders/k3d_parquet_plank2.sl:109:  else h = clamp (boxstep(GHF-twidth,GHF,tt), max(1-GHF/twidth,0),1)
k3d/share/shaders/k3d_parquet_plank2.sl:110:	 - clamp (boxstep(1-GHF-twidth,1-GHF,tt), 0, 2*GHF/twidth);
k3d/share/shaders/k3d_parquet_plank2.sl:111:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_parquet_plank2.sl:112:   * w = step (GWF,ss) - step(1-GWF,ss);
k3d/share/shaders/k3d_parquet_plank2.sl:115:  groovy = w*h;
k3d/share/shaders/k3d_parquet_plank2.sl:121:  fade = smoothstep (1/ringscale, 8/ringscale, fwidth);
k3d/share/shaders/k3d_parquet_plank2.sl:123:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_plank2.sl:124:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank2.sl:132:      fade = smoothstep (2/grainscale, 8/grainscale, fwidth);
k3d/share/shaders/k3d_parquet_plank2.sl:143:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank2.sl:144:  woodcolor = mix (lightwood, darkwood, r);
k3d/share/shaders/k3d_parquet_plank2.sl:147:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_parquet_plank2.sl:149:  Ct = mix (groovecolor, woodcolor, groovy);
k3d/share/shaders/k3d_parquet_tile.sl:2: * DWParquetTile.sl -- yet another surface shader for wood
k3d/share/shaders/k3d_parquet_tile.sl:3: *-was:
k3d/share/shaders/k3d_parquet_tile.sl:4: * parquet_plank.sl -- another surface shader for wood.
k3d/share/shaders/k3d_parquet_tile.sl:7: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_tile.sl:8: *   like oak plank parquet floor tiles.  The actual wood and plank pattern
k3d/share/shaders/k3d_parquet_tile.sl:9: *   is based on my "planks" shader.  This shader works best if "s" and "t"
k3d/share/shaders/k3d_parquet_tile.sl:10: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_tile.sl:13: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_parquet_tile.sl:15: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_tile.sl:19: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_parquet_tile.sl:20: *   lightwood, darkwood - surface colors for the wood itself
k3d/share/shaders/k3d_parquet_tile.sl:21: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_tile.sl:22: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_parquet_tile.sl:24: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_parquet_tile.sl:27: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_tile.sl:29: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_tile.sl:30: *         email: gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_parquet_tile.sl:36: *    10 Feb 1995 - written by Larry Gritz, based on my "plank" shader.
k3d/share/shaders/k3d_parquet_tile.sl:37: *    10 Feb 1995 - modified by wave to change the name
k3d/share/shaders/k3d_parquet_tile.sl:39: * last modified 10 Feb 1995 by wave
k3d/share/shaders/k3d_parquet_tile.sl:44: *   - comments appear where changes are made
k3d/share/shaders/k3d_parquet_tile.sl:45: *   - many thanks to Larry Gritz and wave for creating the original
k3d/share/shaders/k3d_parquet_tile.sl:57: *   - plankwidth from .05 to .2
k3d/share/shaders/k3d_parquet_tile.sl:65:	       color lightwood = color (0.57, 0.292, 0.125);
k3d/share/shaders/k3d_parquet_tile.sl:66:	       color darkwood  = color (0.275, 0.15, 0.06);
k3d/share/shaders/k3d_parquet_tile.sl:68:	       float plankwidth = .2, groovewidth = 0.001;
k3d/share/shaders/k3d_parquet_tile.sl:70:	       float grainy = 1, wavy = 0.08; )
k3d/share/shaders/k3d_parquet_tile.sl:78:  float whichrow, whichplank;
k3d/share/shaders/k3d_parquet_tile.sl:79:  float swidth, twidth, fwidth, ss, tt, w, h, fade, ttt;
k3d/share/shaders/k3d_parquet_tile.sl:80:  color Ct, woodcolor;
k3d/share/shaders/k3d_parquet_tile.sl:83:  float tilewidth, whichtile, tmp, planklength;
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:91:  /* Determine how wide in s-t space one pixel projects to */
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:94:  fwidth = max(swidth,twidth);
k3d/share/shaders/k3d_parquet_tile.sl:96:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_parquet_tile.sl:99:  whichrow = floor (ss);
k3d/share/shaders/k3d_parquet_tile.sl:101:  whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_tile.sl:102:  if (mod (whichrow/plankspertile + whichplank, 2) >= 1) {
k3d/share/shaders/k3d_parquet_tile.sl:104:      whichrow = floor (ss);
k3d/share/shaders/k3d_parquet_tile.sl:106:      whichplank = floor(tt);
k3d/share/shaders/k3d_parquet_tile.sl:107:      tmp = swidth;  swidth = twidth;  twidth = tmp;
k3d/share/shaders/k3d_parquet_tile.sl:109:  ss -= whichrow;
k3d/share/shaders/k3d_parquet_tile.sl:110:  tt -= whichplank;
k3d/share/shaders/k3d_parquet_tile.sl:111:  whichplank += 20*(whichrow+10);
k3d/share/shaders/k3d_parquet_tile.sl:114:   * Figure out where the grooves are.  The value groovy is 0 where there
k3d/share/shaders/k3d_parquet_tile.sl:115:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_tile.sl:118:  if (swidth >= 1)
k3d/share/shaders/k3d_parquet_tile.sl:119:      w = 1 - 2*GWF;
k3d/share/shaders/k3d_parquet_tile.sl:120:  else w = clamp (boxstep(GWF-swidth,GWF,ss), max(1-GWF/swidth,0), 1)
k3d/share/shaders/k3d_parquet_tile.sl:121:	 - clamp (boxstep(1-GWF-swidth,1-GWF,ss), 0, 2*GWF/swidth);
k3d/share/shaders/k3d_parquet_tile.sl:122:  if (twidth >= 1)
k3d/share/shaders/k3d_parquet_tile.sl:124:  else h = clamp (boxstep(GHF-twidth,GHF,tt), max(1-GHF/twidth,0),1)
k3d/share/shaders/k3d_parquet_tile.sl:125:	 - clamp (boxstep(1-GHF-twidth,1-GHF,tt), 0, 2*GHF/twidth);
k3d/share/shaders/k3d_parquet_tile.sl:126:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_parquet_tile.sl:127:   * w = step (GWF,ss) - step(1-GWF,ss);
k3d/share/shaders/k3d_parquet_tile.sl:130:  groovy = w*h;
k3d/share/shaders/k3d_parquet_tile.sl:136:  fade = smoothstep (1/ringscale, 8/ringscale, fwidth);
k3d/share/shaders/k3d_parquet_tile.sl:138:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_tile.sl:139:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_tile.sl:147:      fade = smoothstep (2/grainscale, 8/grainscale, fwidth);
k3d/share/shaders/k3d_parquet_tile.sl:158:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_tile.sl:159:  woodcolor = mix (lightwood, darkwood, r);
k3d/share/shaders/k3d_parquet_tile.sl:162:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_parquet_tile.sl:164:  Ct = mix (groovecolor, woodcolor, groovy);
k3d/share/shaders/k3d_planetclouds.sl:8: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_planetclouds.sl:10: *   a way that looks like clouds on a planetary scale.
k3d/share/shaders/k3d_planetclouds.sl:18: *    offset - controls the zero crossings (where the clouds disappear)
k3d/share/shaders/k3d_planetclouds.sl:22: *   1. The way this shader is typically used is to have two concentric
k3d/share/shaders/k3d_planetclouds.sl:26: *   2. The best effects are achieved when the clouds not only occlude
k3d/share/shaders/k3d_planetclouds.sl:27: *      the view of the planet, but also shadow it.  The way to do this
k3d/share/shaders/k3d_planetclouds.sl:28: *      with the Blue Moon Renderer is to let the light cast shadows,
k3d/share/shaders/k3d_planetclouds.sl:29: *      then declare the cloud sphere as follows:
k3d/share/shaders/k3d_planetclouds.sl:31: *             Attribute "render" "casts_shadows" "shade"
k3d/share/shaders/k3d_planetclouds.sl:37: *      to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_planetclouds.sl:46: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_planetclouds.sl:81:  /* Second cirrus: replace DNoise with vector fBm */
k3d/share/shaders/k3d_planetclouds.sl:96:  /* Adjust zero crossing (where the clouds disappear) */
k3d/share/shaders/k3d_planetclouds.sl:108:  /* Shade like matte, but with color scaled by cloud opacity */
k3d/share/shaders/k3d_planetclouds.sl:109:  Ci = Oi * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_plank.sl:2: * plank.sl -- another surface shader for wood.
k3d/share/shaders/k3d_plank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_plank.sl:9: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_plank.sl:13: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:15: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:16: *   lightwood, darkwood - surface colors for the wood itself
k3d/share/shaders/k3d_plank.sl:17: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_plank.sl:18: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_plank.sl:20: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_plank.sl:23: *   even with low sampling densities.
k3d/share/shaders/k3d_plank.sl:33:		  color lightwood = color(0.57, 0.292, 0.125);
k3d/share/shaders/k3d_plank.sl:34:		  color darkwood = color(0.275, 0.15, 0.06);
k3d/share/shaders/k3d_plank.sl:36:		  float plankwidth = .05, planklength = .75, groovewidth =
k3d/share/shaders/k3d_plank.sl:38:		  float grainy = 1, wavy = 0.08;)
k3d/share/shaders/k3d_plank.sl:46:  float whichrow, whichplank;
k3d/share/shaders/k3d_plank.sl:47:  float swidth, twidth, fwidth, ss, tt, w, h, fade, ttt;
k3d/share/shaders/k3d_plank.sl:48:  color Ct, woodcolor;
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:57:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_plank.sl:58:  swidth =
k3d/share/shaders/k3d_plank.sl:61:  twidth =
k3d/share/shaders/k3d_plank.sl:64:  fwidth = max(swidth, twidth);
k3d/share/shaders/k3d_plank.sl:66:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plank.sl:69:  whichrow = floor(ss);
k3d/share/shaders/k3d_plank.sl:70:  ss -= whichrow;
k3d/share/shaders/k3d_plank.sl:71:  /* Jiggle each row */
k3d/share/shaders/k3d_plank.sl:72:  tt = (txtscale * t / PGHEIGHT) + 10 * snoise(0.5 + whichrow);
k3d/share/shaders/k3d_plank.sl:73:  whichplank = floor(tt);
k3d/share/shaders/k3d_plank.sl:74:  tt -= whichplank;
k3d/share/shaders/k3d_plank.sl:75:  whichplank += 20 * whichrow;
k3d/share/shaders/k3d_plank.sl:78:   * Figure out where the grooves are.  The value groovy is 0 where there
k3d/share/shaders/k3d_plank.sl:79:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_plank.sl:82:  if(swidth >= 1)
k3d/share/shaders/k3d_plank.sl:83:    w = 1 - 2 * GWF;
k3d/share/shaders/k3d_plank.sl:85:    w =
k3d/share/shaders/k3d_plank.sl:86:      clamp(boxstep(GWF - swidth, GWF, ss), max(1 - GWF / swidth, 0),
k3d/share/shaders/k3d_plank.sl:87:	    1) - clamp(boxstep(1 - GWF - swidth, 1 - GWF, ss), 0,
k3d/share/shaders/k3d_plank.sl:88:		       2 * GWF / swidth);
k3d/share/shaders/k3d_plank.sl:89:  if(twidth >= 1)
k3d/share/shaders/k3d_plank.sl:93:      clamp(boxstep(GHF - twidth, GHF, tt), max(1 - GHF / twidth, 0),
k3d/share/shaders/k3d_plank.sl:94:	    1) - clamp(boxstep(1 - GHF - twidth, 1 - GHF, tt), 0,
k3d/share/shaders/k3d_plank.sl:95:		       2 * GHF / twidth);
k3d/share/shaders/k3d_plank.sl:96:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_plank.sl:97:   * w = step (GWF,ss) - step(1-GWF,ss);
k3d/share/shaders/k3d_plank.sl:100:  groovy = w * h;
k3d/share/shaders/k3d_plank.sl:106:  fade = smoothstep(1 / ringscale, 8 / ringscale, fwidth);
k3d/share/shaders/k3d_plank.sl:109:      ttt = tt + whichplank / 28.38 + wavy * noise(8 * ss, tt);
k3d/share/shaders/k3d_plank.sl:110:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_plank.sl:119:      fade = smoothstep(2 / grainscale, 8 / grainscale, fwidth);
k3d/share/shaders/k3d_plank.sl:133:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_plank.sl:134:  woodcolor = mix(lightwood, darkwood, r);
k3d/share/shaders/k3d_plank.sl:137:  woodcolor *=
k3d/share/shaders/k3d_plank.sl:138:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_plank.sl:140:  Ct = mix(groovecolor, woodcolor, groovy);
k3d/share/shaders/k3d_plastic.sl:14:  normal Nf = faceforward(normalize(N), I);
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_plastic2.sl:19:    point Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_projectionmap_plastic.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_projectionmap_plastic.sl:8:// License as published by the Free Software Foundation; either
k3d/share/shaders/k3d_projectionmap_plastic.sl:11:// This program is distributed in the hope that it will be useful,
k3d/share/shaders/k3d_projectionmap_plastic.sl:12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
k3d/share/shaders/k3d_projectionmap_plastic.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_projectionmap_plastic.sl:59:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_puffyclouds.sl:1:/* I took wave's lead and renamed starfield to KMPuffyclouds.sl -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_puffyclouds.sl:8: *    Makes nice looking cumulous clouds like you would see in the sky
k3d/share/shaders/k3d_puffyclouds.sl:11: *    lighting into account.  If you wanted a lit surface that looked like
k3d/share/shaders/k3d_puffyclouds.sl:12: *    puffy clouds (like painted clouds on a wall), then it would be pretty
k3d/share/shaders/k3d_puffyclouds.sl:19: *    threshold - fBm sum below this level is just blue sky
k3d/share/shaders/k3d_puffyclouds.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_puffyclouds.sl:63:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_puffyclouds.sl:78:  /* Uncomment the next line if you want the surface to actually be lit */
k3d/share/shaders/k3d_puffyclouds.sl:79:/*  Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward(N,I))); */
k3d/share/shaders/k3d_redapple.sl:7: * Feel free to use this shader to create apples anywhere and
k3d/share/shaders/k3d_redapple.sl:8: * everywhere.
k3d/share/shaders/k3d_redapple.sl:15: * look best from the side, but work ok from the top, so long as you
k3d/share/shaders/k3d_redapple.sl: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:75:	color brown = color(0.70,0.78,0.34);
k3d/share/shaders/k3d_redapple.sl:97:	 * start of 'greenness' toward the poles.
k3d/share/shaders/k3d_redapple.sl:111:	base_turb = pow(base_turb, (1/redness));
k3d/share/shaders/k3d_redapple.sl:143:	blotch = pow(blotch_turb, 1.3) * BLOTCH_TCF * 
k3d/share/shaders/k3d_redapple.sl:144:	         pow(base_turb, 2);
k3d/share/shaders/k3d_redapple.sl:151:	 * Set the brown specking.
k3d/share/shaders/k3d_redapple.sl:153:	 * The apple has brown speckles on it, set by mixing
k3d/share/shaders/k3d_redapple.sl:161:	speck = pow(smoothstep(SPECK_CUTOFF, 1,
k3d/share/shaders/k3d_redapple.sl:165:	 * Determine where the apple goes black at the poles.
k3d/share/shaders/k3d_redapple.sl:166:	 * This simulates the spots where the stalk would be
k3d/share/shaders/k3d_redapple.sl:167:	 * attached, and where the wierd bit at the very bottom
k3d/share/shaders/k3d_redapple.sl:177:	 * Combine what we have so far to set the surface
k3d/share/shaders/k3d_redapple.sl:181:	cs = mix(cs, brown, speck);
k3d/share/shaders/k3d_redapple.sl:188:	 * Here we set the surface normal to fix up the specular
k3d/share/shaders/k3d_redapple.sl:190:	 * noise, affected a little by the brown specks, and
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:210:	 * Here, we raytrace for the slight mirrored reflections
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:17:	float result, signal, weight, i, exponent;

k3d/share/shaders/k3d_ridged_multifractal.sl:27:          		signal = pow( signal, sharpness );

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

k3d/share/shaders/k3d_ridged_multifractal.sl:32:          		weight = 1.0;

k3d/share/shaders/k3d_ridged_multifractal.sl:35:          		exponent = pow( lacunarity, (-i*H) );

k3d/share/shaders/k3d_ridged_multifractal.sl:42:          		/* weigh successive contributions by previous signal */

k3d/share/shaders/k3d_ridged_multifractal.sl:43:          		weight = signal * threshold;

k3d/share/shaders/k3d_ridged_multifractal.sl:44:          		weight = clamp(weight,0,1)    ;    		

k3d/share/shaders/k3d_ridged_multifractal.sl:54:          		signal = pow( signal, sharpness ); /* Or signal *= signal;*/

k3d/share/shaders/k3d_ridged_multifractal.sl:56:          		/* weight the contribution*/

k3d/share/shaders/k3d_ridged_multifractal.sl:57:          		signal *= weight;

k3d/share/shaders/k3d_ripple.sl:7: *    by Lawrence D. Chin, cs184-bo

k3d/share/shaders/k3d_ripple.sl:14:	       wavelength = 0.25,

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

k3d/share/shaders/k3d_roughmetal.sl:5: *   Rough metal without coherent reflections
k3d/share/shaders/k3d_roughmetal.sl:8: *   Ka, Kd, Ks - ambient, diffuse, specular weights
k3d/share/shaders/k3d_roughmetal.sl:9: *   roughness - highlight width
k3d/share/shaders/k3d_roughmetal.sl:21:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_round.sl:7: * next to another patch at a right angle, the edge will be rounded.
k3d/share/shaders/k3d_round.sl:16:	point	 center,/* point toward which the surface is displaced 	*/
k3d/share/shaders/k3d_round.sl:17:		 dpdu,	/* dPdu pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:18:		 dpdv;	/* dPdv pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:21:	   u and in v, and the directions away from those edges. */
k3d/share/shaders/k3d_round.sl:41:	if (lu < radius || lv < radius) {	/* only if within radius of 
k3d/share/shaders/k3d_round.sl:44:	 * Find the point towards which the surface  point will be 
k3d/share/shaders/k3d_round.sl:45:	 *  moved. This center is on the center line of a cylinder, if we 
k3d/share/shaders/k3d_round.sl:47:	 *  sphere, if we are. We move `center' to the nearest inflection 
k3d/share/shaders/k3d_rubber.sl:7: * adds in a little white dust to mimic the dust on a new eraser.
k3d/share/shaders/k3d_rubber.sl:15:	point	Nf = faceforward(normalize(N),I), 
k3d/share/shaders/k3d_rubber.sl:17:	color	cout, white=1;
k3d/share/shaders/k3d_rubber.sl:19:	/* Mix in some white dust. */
k3d/share/shaders/k3d_rubber.sl:20:	cout = mix(Cs, white, .05* (float noise(txtscale*Ploc)));
k3d/share/shaders/k3d_ruledpaper.sl:5: *   Makes a patch look like a piece of loose-leaf paper with lines,
k3d/share/shaders/k3d_ruledpaper.sl:6: *   the margin, binder holes and writing (as an image texture).
k3d/share/shaders/k3d_ruledpaper.sl:10: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_ruledpaper.sl:11: *   linestr - how strongly do the lines show up (0.0 to 1.0)
k3d/share/shaders/k3d_ruledpaper.sl:17: * AUTHOR: written by Emil Mikulic
k3d/share/shaders/k3d_ruledpaper.sl:21: *    8 Nov 1997 - started writing shader for RDC under MS VC++
k3d/share/shaders/k3d_ruledpaper.sl:28: *   Don't worry about the paper anatomy settings. I moved them to
k3d/share/shaders/k3d_ruledpaper.sl:32: *   I don't know how many holes there were in paper when _YOU_ were a kid
k3d/share/shaders/k3d_ruledpaper.sl:34: *   and got all the measurements with a ruler. This is the real thing!!
k3d/share/shaders/k3d_ruledpaper.sl:36: *   The paper shader works for A4 pieces of paper, so remeber to make your
k3d/share/shaders/k3d_ruledpaper.sl:37: *   patch 21x29.7 units or at least with an approximate aspect ratio. 
k3d/share/shaders/k3d_ruledpaper.sl:49:	// Paper width
k3d/share/shaders/k3d_ruledpaper.sl:50:	float 	pw=21,
k3d/share/shaders/k3d_ruledpaper.sl:54: 		shiny=1.25/pw,
k3d/share/shaders/k3d_ruledpaper.sl:55:	// Spacing between lines
k3d/share/shaders/k3d_ruledpaper.sl:59:	// How far into the page do the lines start
k3d/share/shaders/k3d_ruledpaper.sl:60:		linef = 0.5 / pw,
k3d/share/shaders/k3d_ruledpaper.sl:65:		verts = 2.75 / pw,
k3d/share/shaders/k3d_ruledpaper.sl:66:		verte = 2.85 / pw,
k3d/share/shaders/k3d_ruledpaper.sl:73:		boundl = (circms-circr)/pw,
k3d/share/shaders/k3d_ruledpaper.sl:74:		boundr = (circms+circr)/pw;	)
k3d/share/shaders/k3d_ruledpaper.sl:94:    Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ruledpaper.sl:98:	// Use a nice handwrititng font and you can make it look like
k3d/share/shaders/k3d_ruledpaper.sl:99:	// there's writing on the paper.
k3d/share/shaders/k3d_ruledpaper.sl:105:	// If we're inside the borders/margins
k3d/share/shaders/k3d_ruledpaper.sl:107:	// Figure out where in the lining we are and draw accordingly
k3d/share/shaders/k3d_ruledpaper.sl:116:		// Figure out where we are on the paper so that we can get
k3d/share/shaders/k3d_ruledpaper.sl:118:		ss = s * pw;
k3d/share/shaders/k3d_ruledpaper.sl:122:		// I wrote this handy macro to automate it!
k3d/share/shaders/k3d_rustymetal.sl:2: * rustymetal.sl -- metal with specks of rust
k3d/share/shaders/k3d_rustymetal.sl:5: *   A rough metal surface with controllable rust spots.  The rust pattern
k3d/share/shaders/k3d_rustymetal.sl:23: * AUTHOR: Larry Gritz, gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_rustymetal.sl:52:  point Nf, V;                 /* normal and view vector used for shading */
k3d/share/shaders/k3d_rustymetal.sl:57:  float rustiness;             /* Result: how rusty is this 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:81:  /* If we have any rust, calculate the color of the rust, taking into
k3d/share/shaders/k3d_rustymetal.sl:85:      Nf = faceforward (normalize(Nrust),I);
k3d/share/shaders/k3d_rustymetal.sl:88:  /* If we have any metal, calculate the color of the metal, using the
k3d/share/shaders/k3d_rustymetal.sl:92:      Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_rustymetal.sl:97:  /* Now blend the metal and rust colors depending on the computed value
k3d/share/shaders/k3d_saturn.sl:1:/* This was terran.sl from Larry Gritz and Ken Musgrave.  But there isn't much of it left.
k3d/share/shaders/k3d_saturn.sl:10: *   Saturn-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_saturn.sl:34: *        the only one that would recognize that it was.
k3d/share/shaders/k3d_saturn.sl:57:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_saturn.sl:67:       latitude = lat_scale * pow(latitude,map_exp);
k3d/share/shaders/k3d_saturn.sl:86:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_saturnring.sl:5: *	When put on a disk will give a "saturn-like ringed" apearence with
k3d/share/shaders/k3d_saturnring.sl:10: *	cutoff - what point to start rings (radius of transparency)
k3d/share/shaders/k3d_saturnring.sl:16: *  otherwise then they will neeb to be changed.
k3d/share/shaders/k3d_saturnring.sl:43:	point Nf;       /* Forward facing Normalized vector of incident light */
k3d/share/shaders/k3d_saturnring.sl:50:	color dyellow = color (.73, .664, .398);     /* A shade of dark yellow */
k3d/share/shaders/k3d_saturnring.sl:96:			cs = dyellow;	
k3d/share/shaders/k3d_saturnring.sl:106:			Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_scartissue.sl:1:/*  IDscartissue.sl written by Ivan DeWolf
k3d/share/shaders/k3d_scartissue.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_scartissue.sl:21:	normal Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_scartissue.sl:32:	Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_screen.sl:11: *   Ka, Kd, Ks, roughness, specularcolor - work just like the plastic shader
k3d/share/shaders/k3d_screen.sl:12: *   frequency - how many cycles of screen in st space
k3d/share/shaders/k3d_screen.sl:13: *   density - how much of each cycle is opaque?
k3d/share/shaders/k3d_screen.sl:33:      Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_screen_aa.sl:8: *   well, even with only one sample per pixel.
k3d/share/shaders/k3d_screen_aa.sl:11: *   Ka, Kd, Ks, roughness, specularcolor - work just like the plastic shader
k3d/share/shaders/k3d_screen_aa.sl:12: *   frequency - how many cycles of screen in st space
k3d/share/shaders/k3d_screen_aa.sl:13: *   density - how much of each cycle is opaque?
k3d/share/shaders/k3d_screen_aa.sl:15: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_screen_aa.sl:34:  normal Nf;			/* Forward facing Normal vector */
k3d/share/shaders/k3d_screen_aa.sl:38:  float swidth, twidth, GWF, w, h;
k3d/share/shaders/k3d_screen_aa.sl:40:  /* Compute a forward facing normal */
k3d/share/shaders/k3d_screen_aa.sl:42:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_screen_aa.sl:44:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_screen_aa.sl:45:  swidth = max(abs(Du(s) * du) + abs(Dv(s) * dv), MINFILTERWIDTH) * frequency;
k3d/share/shaders/k3d_screen_aa.sl:46:  twidth = max(abs(Du(t) * du) + abs(Dv(t) * dv), MINFILTERWIDTH) * frequency;
k3d/share/shaders/k3d_screen_aa.sl:48:  /* Figure out where in the pattern we are */
k3d/share/shaders/k3d_screen_aa.sl:52:  /* Figure out where the strips are. Do some simple antialiasing. */
k3d/share/shaders/k3d_screen_aa.sl:54:  if(swidth >= 1)
k3d/share/shaders/k3d_screen_aa.sl:55:    w = 1 - 2 * GWF;
k3d/share/shaders/k3d_screen_aa.sl:57:    w =
k3d/share/shaders/k3d_screen_aa.sl:58:      clamp(boxstep(GWF - swidth, GWF, ss), max(1 - GWF / swidth, 0),
k3d/share/shaders/k3d_screen_aa.sl:59:	    1) - clamp(boxstep(1 - GWF - swidth, 1 - GWF, ss), 0,
k3d/share/shaders/k3d_screen_aa.sl:60:		       2 * GWF / swidth);
k3d/share/shaders/k3d_screen_aa.sl:61:  if(twidth >= 1)
k3d/share/shaders/k3d_screen_aa.sl:65:      clamp(boxstep(GWF - twidth, GWF, tt), max(1 - GWF / twidth, 0),
k3d/share/shaders/k3d_screen_aa.sl:66:	    1) - clamp(boxstep(1 - GWF - twidth, 1 - GWF, tt), 0,
k3d/share/shaders/k3d_screen_aa.sl:67:		       2 * GWF / twidth);
k3d/share/shaders/k3d_screen_aa.sl:68:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_screen_aa.sl:69:   *    w = step (GWF,ss) - step(1-GWF,ss);
k3d/share/shaders/k3d_screen_aa.sl:72:  d = 1 - w * h;
k3d/share/shaders/k3d_sdixon.sl:15:		yellow 		= color(.56, .23, 0);
k3d/share/shaders/k3d_sdixon.sl:18:	point Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_sdixon.sl:24:	 *   metallic-green ink to a matte-yellow background. */
k3d/share/shaders/k3d_sdixon.sl:29: 	/* Use ink to mix yellow and green */
k3d/share/shaders/k3d_sdixon.sl:30:	cout = mix(yellow, green, ink); 					 
k3d/share/shaders/k3d_shadowdistant_rim.sl:1:/* renamed from MKshadowdistant_rim.sl */
k3d/share/shaders/k3d_shadowdistant_rim.sl:4:k3d_shadowdistant_rim( 
k3d/share/shaders/k3d_shadowdistant_rim.sl:9:    string shadowname="";
k3d/share/shaders/k3d_shadowdistant_rim.sl:11:    float width=1;
k3d/share/shaders/k3d_shadowdistant_rim.sl:19:        if (shadowname != "") {
k3d/share/shaders/k3d_shadowdistant_rim.sl:20:                Cl *= 1 - shadow(shadowname, Ps, "samples", samples,
k3d/share/shaders/k3d_shadowdistant_rim.sl:21:                        "swidth", width, "twidth", width);
k3d/share/shaders/k3d_shadowspot.sl:3:/* Listing 16.33  Spotlight using shadow map*/
k3d/share/shaders/k3d_shadowspot.sl:6: *  shadowspot(): spotlight with an optional shadow map
k3d/share/shaders/k3d_shadowspot.sl:8:light k3d_shadowspot( 
k3d/share/shaders/k3d_shadowspot.sl:16:	string shadowfile = "";
k3d/share/shaders/k3d_shadowspot.sl:25:		cosangle;	/* cosine of angle wrt center of cone */
k3d/share/shaders/k3d_shadowspot.sl:29:		attenuation = pow(cosangle, beamdistribution) / (L.L);
k3d/share/shaders/k3d_shadowspot.sl:31:		if( shadowfile != "" )
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:5: *	Will generate alternating and shifted rows of disks and rings
k3d/share/shaders/k3d_shifteddrtile.sl:22: *  Also, it would be better to set the width of the ring rather than
k3d/share/shaders/k3d_shifteddrtile.sl:25: *      choose which row to do first.
k3d/share/shaders/k3d_shifteddrtile.sl:40:#define whichtile(pos, freq) \
k3d/share/shaders/k3d_shifteddrtile.sl:63:	float mix_opacity; /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shifteddrtile.sl:65:	float row, col;    /* used to determine which tile we are in */
k3d/share/shaders/k3d_shifteddrtile.sl:67:	float wasOdd;      /* True if test was odd */
k3d/share/shaders/k3d_shifteddrtile.sl:69:	Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_shifteddrtile.sl:75: 	row = whichtile (t, tfreq);
k3d/share/shaders/k3d_shifteddrtile.sl:77:	if (isOdd(row) == 0) {
k3d/share/shaders/k3d_shifteddrtile.sl:79:		wasOdd = 0;
k3d/share/shaders/k3d_shifteddrtile.sl:83:		wasOdd = 1;
k3d/share/shaders/k3d_shifteddrtile.sl:89:	if (wasOdd == 1)
k3d/share/shaders/k3d_shiftedmoontile.sl:35:#define whichtile(pos, freq) \
k3d/share/shaders/k3d_shiftedmoontile.sl:60:	float mix_opacity;       /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shiftedmoontile.sl:63:	float row, col;          /* Location in tiles */
k3d/share/shaders/k3d_shiftedmoontile.sl:66:	Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_shiftedmoontile.sl:71: 	row = whichtile (t, tfreq);
k3d/share/shaders/k3d_shiftedmoontile.sl:72:	if (isOdd(row) == 0)
k3d/share/shaders/k3d_shiny.sl:7: *    blur - how blurry are the reflections? (0 = perfectly sharp)
k3d/share/shaders/k3d_shiny.sl:10: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shiny.sl:11: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_shiny.sl:12: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shiny.sl:13: *        when using the "ray server."
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:35:		  float twosided = 0;)
k3d/share/shaders/k3d_shiny.sl:37:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_shiny.sl:39:    MaterialShinyMetal(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, twosided,
k3d/share/shaders/k3d_shinymetal.sl:1:/* shinymetal.sl - Standard metal with environment mapping for
k3d/share/shaders/k3d_shinymetal.sl:19:  Nf = faceforward(normalize(N), V);
k3d/share/shaders/k3d_shinymetal.sl:21:  D = vtransform("world", D);
k3d/share/shaders/k3d_shinyplastic.sl:7: *    blur - how blurry are the reflections? (0 = perfectly sharp)
k3d/share/shaders/k3d_shinyplastic.sl:11: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shinyplastic.sl:12: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_shinyplastic.sl:13: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shinyplastic.sl:14: *        when using the "ray server."
k3d/share/shaders/k3d_shinyplastic.sl:30:			 float twosided = 0;
k3d/share/shaders/k3d_shinyplastic.sl:33:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_shinyplastic.sl:36:			 twosided, ENVPARAMS);
k3d/share/shaders/k3d_show_st.sl:6: * show_st(): color surface point according to its s,t coordinates.
k3d/share/shaders/k3d_show_st.sl:9:k3d_show_st()
k3d/share/shaders/k3d_skin1.sl:7: * This software is placed in the public domain and is provided as is 
k3d/share/shaders/k3d_skin1.sl:8: * without express or implied warranty. 
k3d/share/shaders/k3d_skin1.sl:13: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_skin1.sl:14: * everywhere, Just list me on the credits under "Shading Team"
k3d/share/shaders/k3d_skin1.sl:24: * blemishmap = Use a grayscale map to control where the belmishes will be more visible
k3d/share/shaders/k3d_skin1.sl:26: * Oily,oilmap = controls how oily the skin looks. Use a grayscale map to contol
k3d/share/shaders/k3d_skin1.sl:27: * oiliness.---Note--- teh oiliy parameter is multiplied with the map.
k3d/share/shaders/k3d_skin1.sl:28: * xroughness,yroughness = how rough is the specular highlight on x and Y?
k3d/share/shaders/k3d_skin1.sl:43: *     Made changes so would compile.
k3d/share/shaders/k3d_skin1.sl:73:  /* Must declare extern L & Cl because we're in a function */
k3d/share/shaders/k3d_skin1.sl:100:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin1.sl:103:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin1.sl:107:  return (1. - g*g) / pow(1. + g*g - 2.*g*costheta, 1.5);
k3d/share/shaders/k3d_skin1.sl:112:   directions wi and wo, surface normal n, asymmetry value g (see above),
k3d/share/shaders/k3d_skin1.sl:113:   scattering albedo (between 0 and 1 for physically-valid volumes),
k3d/share/shaders/k3d_skin1.sl:117:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin1.sl:118:    float win = abs(wi . n);
k3d/share/shaders/k3d_skin1.sl:119:    float won = abs(wo . n);
k3d/share/shaders/k3d_skin1.sl:121:    return albedo * phase(wo, wi, g) / (win + won) *
k3d/share/shaders/k3d_skin1.sl:122:    (1. - exp(-(1/win + 1/won) * thickness));
k3d/share/shaders/k3d_skin1.sl:133:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin1.sl:150:    C += Kr * sheenColor * Cl * (Ln . Nn) * pow(H . Nn, 4.);
k3d/share/shaders/k3d_skin1.sl:216:  turb = pow(turb,poresthresh) * poresdepth;
k3d/share/shaders/k3d_skin1.sl:221:  Nf = faceforward(normalize(NN),I);
k3d/share/shaders/k3d_skin1.sl:236:   * where the blemishes are visible */
k3d/share/shaders/k3d_skin1.sl:243:  turb = pow(turb, belmishthresh );
k3d/share/shaders/k3d_skin2.sl:6: * This software is placed in the public domain and is provided as is 
k3d/share/shaders/k3d_skin2.sl:7: * without express or implied warranty. 
k3d/share/shaders/k3d_skin2.sl:19:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin2.sl:22:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin2.sl:26:	return (1. - g*g) / pow(1. + g*g - 2.*g*costheta, 1.5);
k3d/share/shaders/k3d_skin2.sl:31:   directions wi and wo, surface normal n, asymmetry value g (see above),
k3d/share/shaders/k3d_skin2.sl:32:   scattering albedo (between 0 and 1 for physically-valid volumes),
k3d/share/shaders/k3d_skin2.sl:36:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin2.sl:37:    float win = abs(wi . n);
k3d/share/shaders/k3d_skin2.sl:38:    float won = abs(wo . n);
k3d/share/shaders/k3d_skin2.sl:40:    return albedo * phase(wo, wi, g) / (win + won) *
k3d/share/shaders/k3d_skin2.sl:41:		(1. - exp(-(1/win + 1/won) * thickness));
k3d/share/shaders/k3d_skin2.sl:54:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin2.sl:60:   over light sources with illuminance() and computes the reflected
k3d/share/shaders/k3d_skin2.sl:76:		C += Kr * sheenColor * Cl * (Ln . Nn) * pow(H . Nn, 4.);
k3d/share/shaders/k3d_skin2.sl:89:   above.  Uses Cs for the basic color of the skin (.8, .5, .5) works
k3d/share/shaders/k3d_skin2.sl:90:   reasonably well for Caucasian skin.
k3d/share/shaders/k3d_skin2.sl:94:	normal Nn = faceforward(normalize(N), I);
k3d/share/shaders/k3d_skymetal.sl:5: * NOTE: This shader was created at a time when the shading lanuage
k3d/share/shaders/k3d_skymetal.sl:8: * A more general version with some explainations can be found in my
k3d/share/shaders/k3d_skymetal.sl:9: * TLSkymetal shader.  Actually, I never could get this oneto work right,
k3d/share/shaders/k3d_skymetal.sl:10: * anyways.
k3d/share/shaders/k3d_skymetal.sl:18:    point up = normalize (point "world" (0, 1, 0) - point "world"  (0, 0, 0)); 
k3d/share/shaders/k3d_skymetal.sl:33:	Nf = normalize (faceforward (N, I));
k3d/share/shaders/k3d_slateroof.sl:4:	slateroof.sl - a surface shader working with slateroofd.sl, to
k3d/share/shaders/k3d_slateroof.sl:5:	introduce a slate color onto roof tiles, making the last row of tiles
k3d/share/shaders/k3d_slateroof.sl:7:	You must bear this in mind when modelling - to avoid the roof ending
k3d/share/shaders/k3d_slateroof.sl:8:	before it reaches the wall which supposedly supports it! The shader
k3d/share/shaders/k3d_slateroof.sl:9:	introduces a random color variation so that one tile will be lighter or
k3d/share/shaders/k3d_slateroof.sl:18: 		a value between 0 and 1
k3d/share/shaders/k3d_slateroof.sl:19: 	gap: the size of the gap between one tile and the next in the s direction,
k3d/share/shaders/k3d_slateroof.sl:20: 		measured as a proportion of the tile (so the value of gap must lie between 0 
k3d/share/shaders/k3d_slateroof.sl:22: 	maxcolorvary: the maximum amount by which the color of a slate can vary from the 
k3d/share/shaders/k3d_slateroof.sl:26: 	factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroof.sl:28: 		different random patterning. A value > 20 works best
k3d/share/shaders/k3d_slateroof.sl:37:	Nb. This shader would normally be used with the slateroofd shader to
k3d/share/shaders/k3d_slateroof.sl:39:	displacement shader would eliminate the need for a lot of the
k3d/share/shaders/k3d_slateroof.sl:40:	calculations in this shader. Renderdc, however, does not yet support
k3d/share/shaders/k3d_slateroof.sl:58:	/* sfreq and tfreq must not be below 3 */				   
k3d/share/shaders/k3d_slateroof.sl:61:   uniform float swidth = 1 / sfreq, 		/* Tile width in the s directio */
k3d/share/shaders/k3d_slateroof.sl:62:                 twidth = 1 / tfreq, 		/* ditto for the t direction */
k3d/share/shaders/k3d_slateroof.sl:63:                 offset = swidth / 2,		/* the amount by which alternate rows are offset */
k3d/share/shaders/k3d_slateroof.sl:67:			s_offset, t_offset, 					/* Offsets withing the current tile, between 0, 1 */
k3d/share/shaders/k3d_slateroof.sl:68:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:70:   float add, 										/* Add, between 0 and 1, hold the amount the current tile overlaps the next */
k3d/share/shaders/k3d_slateroof.sl:71:			news_offset, 
k3d/share/shaders/k3d_slateroof.sl:75:			temp_t_offset, newadd;			 
k3d/share/shaders/k3d_slateroof.sl:78:	float 	colorvary = 0,				    	/* the random amount by which a tile is lightened or darkened */
k3d/share/shaders/k3d_slateroof.sl:79:				newcolorvary, ocolorvary, ns;
k3d/share/shaders/k3d_slateroof.sl:82:	normal Nf = normalize(faceforward(N,I));
k3d/share/shaders/k3d_slateroof.sl:85:	/* Work out which tile we are in, and the offset within that tile */
k3d/share/shaders/k3d_slateroof.sl:86:   ttile = tcoord / twidth;
k3d/share/shaders/k3d_slateroof.sl:88:      scoord = scoord + offset; /* Displace alternate rows */
k3d/share/shaders/k3d_slateroof.sl:89:   stile = scoord / swidth;
k3d/share/shaders/k3d_slateroof.sl:99:	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroof.sl:100:	 * normally the center, except in the short tiles which lie at the
k3d/share/shaders/k3d_slateroof.sl:101:	 * start and end of an offset row, where the middle of the left side 
k3d/share/shaders/k3d_slateroof.sl:106:	/* An offset row, so we must deal with the half tiles */
k3d/share/shaders/k3d_slateroof.sl:114:	/* now calculate the displacement */
k3d/share/shaders/k3d_slateroof.sl:132:	/* Work out whether the point is in fact in another tile 
k3d/share/shaders/k3d_slateroof.sl:133:	 * storing the new tile in stile, ttile and new offset
k3d/share/shaders/k3d_slateroof.sl:139:			/* We are in an offset tile row adjust the scoord appropriately for
k3d/share/shaders/k3d_slateroof.sl:140:			 * the row below */
k3d/share/shaders/k3d_slateroof.sl:141:				newscoord = scoord - offset;
k3d/share/shaders/k3d_slateroof.sl:143:				newscoord = scoord + offset;
k3d/share/shaders/k3d_slateroof.sl:144:			newstile = newscoord / swidth;
k3d/share/shaders/k3d_slateroof.sl:145:			news_offset = newstile - floor(newstile);
k3d/share/shaders/k3d_slateroof.sl:146:			newstile = floor(newstile);
k3d/share/shaders/k3d_slateroof.sl:147:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroof.sl:149:			cs = newstile + .5;
k3d/share/shaders/k3d_slateroof.sl:150:			if ((mod(ct,2) >= 1) && ((newstile == 0) || (newstile == sfreq)))
k3d/share/shaders/k3d_slateroof.sl:151:			/* An offset row, so we must deal with the half tiles */
k3d/share/shaders/k3d_slateroof.sl:152:				cs = newstile;
k3d/share/shaders/k3d_slateroof.sl:153:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroof.sl:154:			newcolorvary =  (noise(cs * colorfactor, ct * colorfactor) - 1) * 2 * maxcolorvary;
k3d/share/shaders/k3d_slateroof.sl:155:			if (t_offset <= newadd)
k3d/share/shaders/k3d_slateroof.sl:156:				/* if t_offset <= newadd we are actually in the overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:160:					stile = newstile;
k3d/share/shaders/k3d_slateroof.sl:162:					s_offset = news_offset;
k3d/share/shaders/k3d_slateroof.sl:163:					add = newadd;
k3d/share/shaders/k3d_slateroof.sl:164:					colorvary = newcolorvary; 
k3d/share/shaders/k3d_slateroof.sl:199:	Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward( normalize(N), I )));
k3d/share/shaders/k3d_slateroofd.sl:14: 			a value between 0 and 1
k3d/share/shaders/k3d_slateroofd.sl:15: 		gap: the size of the gap between one tile and the next in the s direction,
k3d/share/shaders/k3d_slateroofd.sl:16: 			measured as a proportion of the tile (so the value of gap must lie between 0 
k3d/share/shaders/k3d_slateroofd.sl:18: 		factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroofd.sl:20: 			different random patterning. A value > 20 works best
k3d/share/shaders/k3d_slateroofd.sl:25:		tiles are regular, with every other row offset by half a tile width, as
k3d/share/shaders/k3d_slateroofd.sl:26:		normal roof tiles would be. Each tile is expanded by a random amount in
k3d/share/shaders/k3d_slateroofd.sl:27:		the t direction so that it overlaps the tile 'below' it. No randomness
k3d/share/shaders/k3d_slateroofd.sl:28:		is incorporated in the s direction, which remains regular. The routine
k3d/share/shaders/k3d_slateroofd.sl:29:		first determines the dimensions of the current tile, and then works out
k3d/share/shaders/k3d_slateroofd.sl:31:		the bottom of the tile, gaps to either side and the whole tile gently
k3d/share/shaders/k3d_slateroofd.sl:32:		sloping towards zero at the top of the tile. It then looks to see if the
k3d/share/shaders/k3d_slateroofd.sl:33:		point we are considering is actually in the zone of overlap with the
k3d/share/shaders/k3d_slateroofd.sl:34:		tile 'above' the current one. If it is we replace the displacement we are
k3d/share/shaders/k3d_slateroofd.sl:35:		considering with one calculated for the tile above, being a little
k3d/share/shaders/k3d_slateroofd.sl:51:/* sfreq and tfreq must not be below 3 */				   
k3d/share/shaders/k3d_slateroofd.sl:54:   uniform float swidth = 1 / sfreq, 		/* Tile width in the s directio */
k3d/share/shaders/k3d_slateroofd.sl:55:                 twidth = 1 / tfreq, 		/* ditto for the t direction */
k3d/share/shaders/k3d_slateroofd.sl:56:                 offset = swidth / 2;		/* the amount by which alternate rows are offset */
k3d/share/shaders/k3d_slateroofd.sl:59:			s_offset, t_offset, 					/* Offsets withing the current tile, between 0, 1 */
k3d/share/shaders/k3d_slateroofd.sl:60:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:62:   float add,	 									/* Add, between 0 and 1, hold the amount the current tile overlaps the next */
k3d/share/shaders/k3d_slateroofd.sl:63:			news_offset, 
k3d/share/shaders/k3d_slateroofd.sl:67:			temp_t_offset, newadd;			 
k3d/share/shaders/k3d_slateroofd.sl:76:	/* Work out which tile we are in, and the offset within that tile */
k3d/share/shaders/k3d_slateroofd.sl:77:   ttile = tcoord / twidth;
k3d/share/shaders/k3d_slateroofd.sl:79:      scoord = scoord + offset; /* Displace alternate rows */
k3d/share/shaders/k3d_slateroofd.sl:80:   stile = scoord / swidth;
k3d/share/shaders/k3d_slateroofd.sl:91:   	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroofd.sl:92:   		normally the center, except in the short tiles which lie at the
k3d/share/shaders/k3d_slateroofd.sl:93:			start and end of an offset row, where the middle of the left side 
k3d/share/shaders/k3d_slateroofd.sl:98:			/* An offset row, so we must deal with the half tiles */
k3d/share/shaders/k3d_slateroofd.sl:103: 		/* the very bottom row cannot expand */
k3d/share/shaders/k3d_slateroofd.sl:105:	/* now calculate the displacement */
k3d/share/shaders/k3d_slateroofd.sl:107:	/* the above adjusts t_offset so that it runs from 0 to 1 within the expanded tile */
k3d/share/shaders/k3d_slateroofd.sl:124:	/* Work out whether the point is in fact in another tile 	
k3d/share/shaders/k3d_slateroofd.sl:125:		storing the new tile in stile, ttile and new offset
k3d/share/shaders/k3d_slateroofd.sl:131:				/* We are in an offset tile row adjust the scoord appropriately for
k3d/share/shaders/k3d_slateroofd.sl:132:		 			the row below */
k3d/share/shaders/k3d_slateroofd.sl:133:				newscoord = scoord - offset;
k3d/share/shaders/k3d_slateroofd.sl:135:				newscoord = scoord + offset;
k3d/share/shaders/k3d_slateroofd.sl:136:			newstile = newscoord / swidth;
k3d/share/shaders/k3d_slateroofd.sl:137:			news_offset = newstile - floor(newstile);
k3d/share/shaders/k3d_slateroofd.sl:138:			newstile = floor(newstile);
k3d/share/shaders/k3d_slateroofd.sl:139:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroofd.sl:141:			cs = newstile + .5;
k3d/share/shaders/k3d_slateroofd.sl:142:			if ((mod(ct,2) >= 1) && ((newstile == 0) || (newstile == sfreq)))
k3d/share/shaders/k3d_slateroofd.sl:143:				/* An offset row, so we must deal with the half tiles */
k3d/share/shaders/k3d_slateroofd.sl:144:				cs = newstile;
k3d/share/shaders/k3d_slateroofd.sl:145:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroofd.sl:146:			if (t_offset <= newadd)
k3d/share/shaders/k3d_slateroofd.sl:147:			/* if t_offset <= newadd we are actually in the overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:151:					stile = newstile;
k3d/share/shaders/k3d_slateroofd.sl:153:					s_offset = news_offset;
k3d/share/shaders/k3d_slateroofd.sl:154:					add = newadd;
k3d/share/shaders/k3d_slideprojector.sl:36:    attenuation = pow(cosangle, beamdistribution) / (L.L);
k3d/share/shaders/k3d_smoke.sl:12: *          toward the viewer.
k3d/share/shaders/k3d_smoke.sl:13: *   integstart, integend - bounds along the viewing ray direction of the
k3d/share/shaders/k3d_smoke.sl:19: *   scatter - when non-1, can be used to give wavelength-dependent
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:33: * with the "__foglight" parameter.  
k3d/share/shaders/k3d_smoke.sl:88:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_smoke.sl:102:  color Cv = 0, Ov = 0;		/* color & opacity of volume that we accumulate */
k3d/share/shaders/k3d_smoke.sl:103:  while(d <= end)
k3d/share/shaders/k3d_smoke.sl:118:      /* Composite with exponential extinction of background light */
k3d/share/shaders/k3d_smoke.sl:126:   * Now Cv is the light contributed by the volume itself, and Ov is the
k3d/share/shaders/k3d_smoke.sl:128:   * which makes it through the volume.  So just composite!
k3d/share/shaders/k3d_smoke2.sl:11: *   integstart, integend - bounds along the viewing ray direction of the
k3d/share/shaders/k3d_smoke2.sl:14: *   use_lighting - if nonzero, light visibility along the ray will be taken
k3d/share/shaders/k3d_smoke2.sl:16: *   use_noise - makes the smoke noisy (nonuniform) when nonzero
k3d/share/shaders/k3d_smoke2.sl:18: *   lightscale - multiplier for light scattered toward viewer in volume
k3d/share/shaders/k3d_smoke2.sl:19: *   debug - if nonzero, copious output will be sent to stderr.
k3d/share/shaders/k3d_smoke2.sl:39: * Compute only one octave of noise when not lit (big speedup)
k3d/share/shaders/k3d_smoke2.sl:50:/* Here is where we define the GADD. */
k3d/share/shaders/k3d_smoke2.sl:109:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_smoke2.sl:121:      while (d <= end) {
k3d/share/shaders/k3d_smoke2.sl:127:	  /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_smoke2.sl:137:	  /* Now we adjust Cv/Ov to account for dC and dO */
k3d/share/shaders/k3d_smoke2.sl:149:   * Now Cv is the light contributed by the volume itself, and Ov is the
k3d/share/shaders/k3d_smoke2.sl:151:   * which makes it through the volume.
k3d/share/shaders/k3d_softboxes.sl:10:* To do: accomodate negative widths. twosided/onesided cards.
k3d/share/shaders/k3d_softboxes.sl:50:/*   - the equations of two superellipses (with major/minor axes given	***/
k3d/share/shaders/k3d_softboxes.sl:53:/*   - 0 if Q was inside the inner ellipse				***/
k3d/share/shaders/k3d_softboxes.sl:54:/*   - 1 if Q was outside the outer ellipse				***/
k3d/share/shaders/k3d_softboxes.sl:55:/*   - smoothly varying from 0 to 1 in between				***/
k3d/share/shaders/k3d_softboxes.sl:74:	varying float q = a * b * pow (pow(b*x, re) + pow(a*y, re), -1/re);
k3d/share/shaders/k3d_softboxes.sl:75:	varying float r = A * B * pow (pow(B*x, re) + pow(A*y, re), -1/re);
k3d/share/shaders/k3d_softboxes.sl:116:    uniform float bw2 = boxWidth/2;
k3d/share/shaders/k3d_softboxes.sl:119:#define bw2 boxWidth
k3d/share/shaders/k3d_softboxes.sl:122:    uniform float we = max(boxWEdge,-bw2);
k3d/share/shaders/k3d_softboxes.sl:124:    uniform float bW = bw2+we;
k3d/share/shaders/k3d_softboxes.sl:126:    uniform float iW = min(bW,bw2);
k3d/share/shaders/k3d_softboxes.sl:128:    uniform float oW = max(bW,bw2);
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:167:    varying float pDist = length(ppC - spw); /* in "world" coords */
k3d/share/shaders/k3d_softboxes.sl:170:    theColor = contrib * ct * boxColor / pow(pDist,decayExp);	/* premultiplied!!!!! */
k3d/share/shaders/k3d_softboxes.sl:177:float sbShadow(
k3d/share/shaders/k3d_softboxes.sl:187:    varying float inShadow = shadow (theName,
k3d/share/shaders/k3d_softboxes.sl:193:    return(inShadow);
k3d/share/shaders/k3d_softboxes.sl:273:    color shadowcolor = 0;
k3d/share/shaders/k3d_softboxes.sl:274:    float shadowintensity = 1;
k3d/share/shaders/k3d_softboxes.sl:275:    string shadowname = "";
k3d/share/shaders/k3d_softboxes.sl:276:    ENUM	shadowfilt = SHAD_BOX_FILT;
k3d/share/shaders/k3d_softboxes.sl:277:    float   shadowblur = 0.01,
k3d/share/shaders/k3d_softboxes.sl:278:	    shadowbias = 0,
k3d/share/shaders/k3d_softboxes.sl:279:	    shadowsamples = 16;
k3d/share/shaders/k3d_softboxes.sl:280:    string shadownameb = "";
k3d/share/shaders/k3d_softboxes.sl:281:    ENUM	shadowfiltb = SHAD_BOX_FILT;
k3d/share/shaders/k3d_softboxes.sl:282:    float   shadowblurb = 0.01,
k3d/share/shaders/k3d_softboxes.sl:283:	    shadowbiasb = 0,
k3d/share/shaders/k3d_softboxes.sl:284:	    shadowsamplesb = 16;
k3d/share/shaders/k3d_softboxes.sl:285:    string shadownamec = "";
k3d/share/shaders/k3d_softboxes.sl:286:    ENUM	shadowfiltc = SHAD_BOX_FILT;
k3d/share/shaders/k3d_softboxes.sl:287:    float   shadowblurc = 0.01,
k3d/share/shaders/k3d_softboxes.sl:288:	    shadowbiasc = 0,
k3d/share/shaders/k3d_softboxes.sl:289:	    shadowsamplesc = 16;
k3d/share/shaders/k3d_softboxes.sl:290:    string shadownamed = "";
k3d/share/shaders/k3d_softboxes.sl:291:    ENUM	shadowfiltd = SHAD_BOX_FILT;
k3d/share/shaders/k3d_softboxes.sl:292:    float   shadowblurd = 0.01,
k3d/share/shaders/k3d_softboxes.sl:293:	    shadowbiasd = 0,
k3d/share/shaders/k3d_softboxes.sl:294:	    shadowsamplesd = 16;
k3d/share/shaders/k3d_softboxes.sl:302:    output varying float __inShadow = 0;	   
k3d/share/shaders/k3d_softboxes.sl:307:    normal Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_softboxes.sl:323:    uniform float adjIntensity = pow(adjMeterDistance,decayRate)*intensity;
k3d/share/shaders/k3d_softboxes.sl:454:	    /* Apply shadow mapped shadows */
k3d/share/shaders/k3d_softboxes.sl:462:		q = 1 - clamp(edgeRolloff*pow(clamp(abs(q),0,1),1/max(edgeExp,0.001)),0,1);
k3d/share/shaders/k3d_softboxes.sl:465:	    varying float shadowed;
k3d/share/shaders/k3d_softboxes.sl:466:	    if (shadowname != "") {
k3d/share/shaders/k3d_softboxes.sl:467:	    shadowed = sbShadow(shadowname,Ps,shadowfilt,
k3d/share/shaders/k3d_softboxes.sl:468:			shadowblur,shadowsamples,shadowbias);
k3d/share/shaders/k3d_softboxes.sl:469:	    fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_softboxes.sl:471:	    if (shadownameb != "") {
k3d/share/shaders/k3d_softboxes.sl:472:	    shadowed = sbShadow(shadownameb,Ps,shadowfiltb,
k3d/share/shaders/k3d_softboxes.sl:473:			shadowblurb,shadowsamplesb,shadowbiasb);
k3d/share/shaders/k3d_softboxes.sl:474:	    fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_softboxes.sl:476:	    if (shadownamec != "") {
k3d/share/shaders/k3d_softboxes.sl:477:	    shadowed = sbShadow(shadownamec,Ps,shadowfiltc,
k3d/share/shaders/k3d_softboxes.sl:478:			shadowblurc,shadowsamplesc,shadowbiasc);
k3d/share/shaders/k3d_softboxes.sl:479:	    fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_softboxes.sl:481:	    if (shadownamed != "") {
k3d/share/shaders/k3d_softboxes.sl:482:	    shadowed = sbShadow(shadownamed,Ps,shadowfiltd,
k3d/share/shaders/k3d_softboxes.sl:483:			shadowblurd,shadowsamplesd,shadowbiasd);
k3d/share/shaders/k3d_softboxes.sl:484:	    fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_softboxes.sl:486:	    __inShadow = fullShad; 
k3d/share/shaders/k3d_softboxes.sl:491:	Cl = mix(Cl, (shadowcolor*shadowintensity*adjIntensity), fullShad);
k3d/share/shaders/k3d_spacecloud.sl:29: *      I was never happy with the results.  So now am just using noise over
k3d/share/shaders/k3d_spacecloud.sl:80:	/* Old way */
k3d/share/shaders/k3d_spaceshiphull1.sl:22:	float width = .1; float height = .06;
k3d/share/shaders/k3d_spaceshiphull1.sl:24:	float rowvary = 3.0;
k3d/share/shaders/k3d_spaceshiphull1.sl:32:  // Figure out which row we're in  
k3d/share/shaders/k3d_spaceshiphull1.sl:33:  ss = s / width;
k3d/share/shaders/k3d_spaceshiphull1.sl:38:  ss += rowvary * noise(tplate + 0.3);
k3d/share/shaders/k3d_spaceshiphull1.sl:50:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_spotlight.sl:23:    atten = pow(cosangle, beamdistribution) / (L.L);
k3d/share/shaders/k3d_square_ridges.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_square_ridges.sl:8:// License as published by the Free Software Foundation; either
k3d/share/shaders/k3d_square_ridges.sl:11:// This program is distributed in the hope that it will be useful,
k3d/share/shaders/k3d_square_ridges.sl:12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
k3d/share/shaders/k3d_square_ridges.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_square_ridges.sl:24:/// Filtering code courtesy of the Advanced RenderMan book ... where else?
k3d/share/shaders/k3d_square_ridges.sl:27:#define filter_width(x) max(abs(Du(x)*du) + abs(Dv(x)*dv), MIN_FILTER_WIDTH)
k3d/share/shaders/k3d_square_ridges.sl:43:	float w = dx / period;
k3d/share/shaders/k3d_square_ridges.sl:44:	float x0 = x/period - w/2;
k3d/share/shaders/k3d_square_ridges.sl:45:	float x1 = x0 + w;
k3d/share/shaders/k3d_square_ridges.sl:54:	return (integral(x1) - integral(x0)) / w;
k3d/share/shaders/k3d_square_ridges.sl:63:	float ridge_position = filtered_pulse_train(0.5 / Frequency, 1.0 / Frequency, t + (Offset / Frequency), filter_width(t));
k3d/share/shaders/k3d_square_ridges.sl:64://	float ridge_position = pulse_train(0.5 / Frequency, 1.0 / Frequency, u, filter_width(u));
k3d/share/shaders/k3d_srfdeformation.sl:1:/* renamed shader to SIG2k_srf_deformation to be consistent with RMR 
k3d/share/shaders/k3d_srfdeformation.sl:18:   by Rob Bredow and Scott Stokdyk 
k3d/share/shaders/k3d_srfdeformation.sl:50:				   1 = texture deformed with no lighting
k3d/share/shaders/k3d_srfdeformation.sl:62:    float illum_width = 180;
k3d/share/shaders/k3d_srfdeformation.sl:73:    /* Calculate shading difference between P and Porig*/
k3d/share/shaders/k3d_srfdeformation.sl:76:    N1 = faceforward(normalize(N),I);
k3d/share/shaders/k3d_srfdeformation.sl:78:    N2 = faceforward(normalize(N),I);
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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_star.sl:26:    point Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_starfield.sl:2:	Makes a star field.  Best when used as a surface shader for the inside	of a large sphere.
k3d/share/shaders/k3d_starfield.sl:8:	AUTHOR: written by Timothy M. Shead
k3d/share/shaders/k3d_stones.sl:8: * This software is placed in the public domain and is provided as is 
k3d/share/shaders/k3d_stones.sl:9: * without express or implied warranty.
k3d/share/shaders/k3d_stones.sl:11: * Shader that creates a surface covered with stones of different sizes,
k3d/share/shaders/k3d_stones.sl:15: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_stones.sl:16: * everywhere, Just list me on the credits under "Shading Team" if you use the
k3d/share/shaders/k3d_stones.sl:25: * grungefreq, grunge_Pow, grunginess = freqeuncy, power and depth of grunge
k3d/share/shaders/k3d_stones.sl:27: * varyhue, varysat,varylum  = how much will the color change?
k3d/share/shaders/k3d_stones.sl:33: * NOTE .- This shader is VERY SLOW when you enable bumping, even SLOWER with
k3d/share/shaders/k3d_stones.sl:51:#define whichtile(x,freq) (floor((x) * (freq)))
k3d/share/shaders/k3d_stones.sl:53:#define filterwidth_point(p) (max(sqrt(area(p)), MINFILTERWIDTH))
k3d/share/shaders/k3d_stones.sl:57:/* varyEach takes a computed color, then tweaks each indexed item
k3d/share/shaders/k3d_stones.sl:90:          grungefreq = 30, grunge_Pow = 3, grunginess = - 0.8;
k3d/share/shaders/k3d_stones.sl:119:   /*repeat tiles and find out in which tile we are at?*/
k3d/share/shaders/k3d_stones.sl:122:   stile = whichtile(cx,freq * tilefreq);
k3d/share/shaders/k3d_stones.sl:123:   ttile = whichtile(cy,freq * tilefreq);
k3d/share/shaders/k3d_stones.sl:161:       float width = filterwidth_point(PP);
k3d/share/shaders/k3d_stones.sl:162:       float cutoff = clamp(0.5 / width, 0, maxfreq);
k3d/share/shaders/k3d_stones.sl:170:        grunge = pow(turb, grunge_Pow);
k3d/share/shaders/k3d_stones.sl:184:  Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_strata.sl:11: *    turbscale - how turbulent the layers are
k3d/share/shaders/k3d_strata.sl:25: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_strata.sl:82:  /* Shade like matte, but with color scaled by cloudcolor and opacity */
k3d/share/shaders/k3d_strata.sl:85:    Cs * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_stucco.sl:9: *   power	   	controls the shape of the pimples
k3d/share/shaders/k3d_stucco.sl:13: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_stucco.sl:17:displacement k3d_stucco(float Km = 0.05, power = 5, frequency = 10;)
k3d/share/shaders/k3d_stucco.sl:23:  magnitude = Km * pow(noise(PP * frequency), power);
k3d/share/shaders/k3d_superkagee.sl:13:float do_shadow6(
k3d/share/shaders/k3d_superkagee.sl:23:    float inShadow;
k3d/share/shaders/k3d_superkagee.sl:25:    inShadow = shadow (theName,
k3d/share/shaders/k3d_superkagee.sl:31:return(inShadow);
k3d/share/shaders/k3d_superkagee.sl:41:    string     shadownamea = "";
k3d/share/shaders/k3d_superkagee.sl:42:            ENUM        shadowfilta = FILT_BOX;
k3d/share/shaders/k3d_superkagee.sl:43:            float       shadowblura = 0,
k3d/share/shaders/k3d_superkagee.sl:44:                        shadowbiasa = 0,
k3d/share/shaders/k3d_superkagee.sl:45:                        shadowsamplesa = 16,
k3d/share/shaders/k3d_superkagee.sl:46:                        shadowdensitya = 1;
k3d/share/shaders/k3d_superkagee.sl:48:    string     shadownameb = "";
k3d/share/shaders/k3d_superkagee.sl:49:            ENUM        shadowfiltb = FILT_BOX;
k3d/share/shaders/k3d_superkagee.sl:50:            float       shadowblurb = 0,
k3d/share/shaders/k3d_superkagee.sl:51:                        shadowbiasb = 0,
k3d/share/shaders/k3d_superkagee.sl:52:                        shadowsamplesb = 16,
k3d/share/shaders/k3d_superkagee.sl:53:                        shadowdensityb = 1;
k3d/share/shaders/k3d_superkagee.sl:55:    string     shadownamec = "";
k3d/share/shaders/k3d_superkagee.sl:56:            ENUM        shadowfiltc = FILT_BOX;
k3d/share/shaders/k3d_superkagee.sl:57:            float       shadowblurc = 0,
k3d/share/shaders/k3d_superkagee.sl:58:                        shadowbiasc = 0,
k3d/share/shaders/k3d_superkagee.sl:59:                        shadowsamplesc = 16,
k3d/share/shaders/k3d_superkagee.sl:60:                        shadowdensityc = 1;
k3d/share/shaders/k3d_superkagee.sl:62:    string     shadownamed = "";
k3d/share/shaders/k3d_superkagee.sl:63:            ENUM        shadowfiltd = FILT_BOX;
k3d/share/shaders/k3d_superkagee.sl:64:            float       shadowblurd = 0,
k3d/share/shaders/k3d_superkagee.sl:65:                        shadowbiasd = 0,
k3d/share/shaders/k3d_superkagee.sl:66:                        shadowsamplesd = 16,
k3d/share/shaders/k3d_superkagee.sl:67:                        shadowdensityd = 1;
k3d/share/shaders/k3d_superkagee.sl:74:    varying float shadowed;
k3d/share/shaders/k3d_superkagee.sl:75:    if (shadownamea != "") {
k3d/share/shaders/k3d_superkagee.sl:77:        shadowed = clamp(shadowdensitya,0,1) * do_shadow6(shadownamea,P,
k3d/share/shaders/k3d_superkagee.sl:78:                    shadowfilta,shadowblura,shadowsamplesa,shadowbiasa
k3d/share/shaders/k3d_superkagee.sl:81:        fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_superkagee.sl:82:    }if (shadownameb != "") {
k3d/share/shaders/k3d_superkagee.sl:84:        shadowed = clamp(shadowdensityb,0,1) * do_shadow6(shadownameb,P,
k3d/share/shaders/k3d_superkagee.sl:85:                    shadowfiltb,shadowblurb,shadowsamplesb,shadowbiasb
k3d/share/shaders/k3d_superkagee.sl:88:        fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_superkagee.sl:89:    }if (shadownamec != "") {
k3d/share/shaders/k3d_superkagee.sl:91:        shadowed = clamp(shadowdensityc,0,1) * do_shadow6(shadownamec,P,
k3d/share/shaders/k3d_superkagee.sl:92:                    shadowfiltc,shadowblurc,shadowsamplesc,shadowbiasc
k3d/share/shaders/k3d_superkagee.sl:95:        fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_superkagee.sl:96:    }if (shadownamed != "") {
k3d/share/shaders/k3d_superkagee.sl:98:        shadowed = clamp(shadowdensityd,0,1) * do_shadow6(shadownamed,P,
k3d/share/shaders/k3d_superkagee.sl:99:                    shadowfiltd,shadowblurd,shadowsamplesd,shadowbiasd
k3d/share/shaders/k3d_superkagee.sl:102:        fullShad = max(fullShad,shadowed);
k3d/share/shaders/k3d_superplank.sl:2: * superplank.sl -- another surface shader for wood planks.
k3d/share/shaders/k3d_superplank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_superplank.sl:6: *   like varnished oak planks, with staggered planks, rings and grain,
k3d/share/shaders/k3d_superplank.sl:12: *   Ka, Kd, Ks, specularcolor, roughness - work just like the plastic shader
k3d/share/shaders/k3d_superplank.sl:17: *   lightwood - wood-like color from which the various shades are derived.
k3d/share/shaders/k3d_superplank.sl:18: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_superplank.sl:20: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_superplank.sl:22: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_superplank.sl:25: *   plankstagger - for staggered, how much are the rows of planks staggered
k3d/share/shaders/k3d_superplank.sl:26: *   plankvary - controls how much wood color varies from plank to plank
k3d/share/shaders/k3d_superplank.sl:28: *   ringwidth - relative width of the dark ring parts
k3d/share/shaders/k3d_superplank.sl:29: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_superplank.sl:37: *   even with low sampling densities.
k3d/share/shaders/k3d_superplank.sl:39: * Author: written by Larry Gritz
k3d/share/shaders/k3d_superplank.sl:63:			color lightwood = color(.5, .2, .067);	/* light wood color */
k3d/share/shaders/k3d_superplank.sl:67:			float plankwidth = .05;	/* Width of a plank */
k3d/share/shaders/k3d_superplank.sl:69:			float groovewidth = 0.001;	/* Width of the grooves between planks */
k3d/share/shaders/k3d_superplank.sl:72:			float plankstagger = 1;	/* How much should rows be staggered */
k3d/share/shaders/k3d_superplank.sl:76:			float ringwidth = 1;	/* Relative ring width */
k3d/share/shaders/k3d_superplank.sl:77:			float wavy = 0.08;	/* Larger makes rings more wavy */
k3d/share/shaders/k3d_superplank.sl:80:			float graindepth = 0.0001;	/* Depth of divots where grains are */
k3d/share/shaders/k3d_superplank.sl:82:			float varnishbumpamp = 0.0003;	/* How big are the varnish bumps? */
k3d/share/shaders/k3d_superplank.sl:89:  float swidth, twidth, fwidth;
k3d/share/shaders/k3d_superplank.sl:90:  float sw, tw, overallscale;
k3d/share/shaders/k3d_superplank.sl:93:  float whichrow, whichplank;	/* Index for each row & plank within row */
k3d/share/shaders/k3d_superplank.sl:94:  float w, h;			/* temporaries */
k3d/share/shaders/k3d_superplank.sl:95:  float groovy;			/* 0 in groove, 1 in woody part */
k3d/share/shaders/k3d_superplank.sl:97:  color Ct, woodcolor;
k3d/share/shaders/k3d_superplank.sl:100:  float ring;			/* 1 in a ring darkening, 0 where not */
k3d/share/shaders/k3d_superplank.sl:101:  float grain;			/* 1 inside a grain bit, 0 elsewhere */
k3d/share/shaders/k3d_superplank.sl:106:  normal Nf;			/* forward facing, normalized normal */
k3d/share/shaders/k3d_superplank.sl:128:  swidth = filterwidth(ss);
k3d/share/shaders/k3d_superplank.sl:129:  twidth = filterwidth(tt);
k3d/share/shaders/k3d_superplank.sl:130:  fwidth = max(swidth, twidth);
k3d/share/shaders/k3d_superplank.sl:132:  /* How much current space corresponds to a unit of s or t?
k3d/share/shaders/k3d_superplank.sl:133:   * We will use this later to help scale the displacement, this making
k3d/share/shaders/k3d_superplank.sl:143:   * Determine which row and plank we're on, and come up with an
k3d/share/shaders/k3d_superplank.sl:144:   * antialiased term for whether we're in or out of a groove.
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:152:      whichrow = floor(plank_s);
k3d/share/shaders/k3d_superplank.sl:153:      /* Jiggle each row */
k3d/share/shaders/k3d_superplank.sl:154:      plank_t = tt / PGHEIGHT + 20 * plankstagger * cellnoise(whichrow);
k3d/share/shaders/k3d_superplank.sl:155:      whichplank = floor(plank_t);
k3d/share/shaders/k3d_superplank.sl:160:      PGWIDTH = plankwidth + groovewidth;
k3d/share/shaders/k3d_superplank.sl:163:      whichrow = floor(plank_s);
k3d/share/shaders/k3d_superplank.sl:165:      whichplank = floor(plank_t);
k3d/share/shaders/k3d_superplank.sl:166:      if(mod((whichrow / plankspertile) + whichplank, 2) >= 1)
k3d/share/shaders/k3d_superplank.sl:170:	  whichrow = floor(plank_s);
k3d/share/shaders/k3d_superplank.sl:171:	  whichplank = floor(plank_t);
k3d/share/shaders/k3d_superplank.sl:175:	  tmp = swidth;
k3d/share/shaders/k3d_superplank.sl:176:	  swidth = twidth;
k3d/share/shaders/k3d_superplank.sl:177:	  twidth = tmp;
k3d/share/shaders/k3d_superplank.sl:180:  /* Now whichplank is a unique integer index for each plank */
k3d/share/shaders/k3d_superplank.sl:182:  /* Figure out where the grooves are.  The value groovy is 0 where there
k3d/share/shaders/k3d_superplank.sl:183:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_superplank.sl:187:  /* compute half width & length of groove as fraction of plank size */
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:192:  if(sw >= 1)
k3d/share/shaders/k3d_superplank.sl:193:    w = 1 - 2 * GWF;		/* Filter width is wider than the plank itself */
k3d/share/shaders/k3d_superplank.sl:195:    w = filteredpulse(whichrow + GWF, whichrow + 1 - GWF, plank_s, sw);
k3d/share/shaders/k3d_superplank.sl:196:  if(tw >= 1)
k3d/share/shaders/k3d_superplank.sl:197:    h = 1 - 2 * GHF;		/* Filter width is longer than the plank itself */
k3d/share/shaders/k3d_superplank.sl:199:    h = filteredpulse(whichplank + GHF, whichplank + 1 - GHF, plank_t, tw);
k3d/share/shaders/k3d_superplank.sl:200:  groovy = w * h;
k3d/share/shaders/k3d_superplank.sl:205:   * The wood has rings at one scale, grain at a finer scale.  They
k3d/share/shaders/k3d_superplank.sl:209:  /* Compute the filter width first, so we don't bother with more if
k3d/share/shaders/k3d_superplank.sl:212:  fwidth = max(swidth * ringscale, twidth * ringscale);
k3d/share/shaders/k3d_superplank.sl:213:  fade = smoothstep(.75, 4, fwidth);
k3d/share/shaders/k3d_superplank.sl:218:      ttt = ring_t + whichplank * 28.38 + wavy * noise(8 * ring_s, ring_t);
k3d/share/shaders/k3d_superplank.sl:219:      ring = ringscale * noise(ring_s - whichplank * 4.18, ttt / 20);
k3d/share/shaders/k3d_superplank.sl:222:	0.3 + 0.7 * smoothstep(.55 - .35 * ringwidth, 0.55,
k3d/share/shaders/k3d_superplank.sl:227:      fwidth = max(swidth * grainscale, twidth * grainscale);
k3d/share/shaders/k3d_superplank.sl:228:      fade = smoothstep(.75, 4, fwidth);
k3d/share/shaders/k3d_superplank.sl:247:  /* Start with the light wood color */
k3d/share/shaders/k3d_superplank.sl:248:  woodcolor = lightwood;
k3d/share/shaders/k3d_superplank.sl:250:  woodcolor *=
k3d/share/shaders/k3d_superplank.sl:251:    1 - plankvary / 2 + plankvary * float cellnoise(whichplank, whichrow);
k3d/share/shaders/k3d_superplank.sl:252:  /* Darken the wood according to the ring and grain patterns */
k3d/share/shaders/k3d_superplank.sl:253:  woodcolor *= (1 - 0.25 * ring) * (1 - .5 * grain);
k3d/share/shaders/k3d_superplank.sl:255:  Ct = mix(groovecolor, woodcolor, groovy);
k3d/share/shaders/k3d_superplank.sl:256:  /* Less specular in the grooves, more specular in the dark wood. */
k3d/share/shaders/k3d_superplank.sl:278:      /* Find out how long a unit of shader space is, in current units */
k3d/share/shaders/k3d_superplank.sl:289:   * The wood itself behaves like plastic, the varnish overtop reflects
k3d/share/shaders/k3d_superplank.sl:291:   * Have some subtle interaction between grain and specularity.
k3d/share/shaders/k3d_superplank.sl:296:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_superplank.sl:309:		smoothstep(.6, .85, pow(max(0, Nf.H), 8 / roughness)));
k3d/share/shaders/k3d_superpplastic.sl:25:			  float Swidth = 1; float Twidth = 1;)
k3d/share/shaders/k3d_superpplastic.sl:48:		    "samples", samples, "swidth", Swidth, "twidth", Twidth,
k3d/share/shaders/k3d_superpplastic.sl:53:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_supertexmap.sl:5: *    Apply a texture map (possibly with associated alpha) 
k3d/share/shaders/k3d_supertexmap.sl:7: *    standard "paintedplastic", but with much more flexibility in the
k3d/share/shaders/k3d_supertexmap.sl:15: *    textureprojspace - the space in which the texture projection is
k3d/share/shaders/k3d_supertexmap.sl:30:#include "k3d_filterwidth.h"
k3d/share/shaders/k3d_supertexmap.sl:68:  /* Start out with the regular plastic parameters, unless overridden
k3d/share/shaders/k3d_supertexmap.sl:103:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_supertoon.sl:9: * Toon shader with non-analitic antialiasing (controlled by delta). Difusion is modulated with

k3d/share/shaders/k3d_supertoon.sl:11: * reason why no border detection is allowed. Now with specular.

k3d/share/shaders/k3d_supertoon.sl:44:    if(Ks != 0){ /* Some optimization. If the multiplier is zero, why call an expensive function? */

k3d/share/shaders/k3d_supertoon.sl:49:      difusion = diffuse(faceforward(Nf, NI, Nf));

k3d/share/shaders/k3d_terran.sl:3:           mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran.sl:40:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terran.sl:45:  PtN = normalize(Ptexture);	/* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran.sl:48:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran.sl:50:   *       expect these two shaders to work well together.
k3d/share/shaders/k3d_terran.sl:67:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terran.sl:69:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran.sl:72:      weight = abs(VLNoise(tp, 1.5));
k3d/share/shaders/k3d_terran.sl:73:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terran.sl:74:      for(i = 1; i < octaves && weight >= VERY_SMALL; i += 1)
k3d/share/shaders/k3d_terran.sl:77:	  /* get subsequent values, weighted by previous value */
k3d/share/shaders/k3d_terran.sl:78:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran.sl:79:	  weight = clamp(abs(weight), 0, 1);
k3d/share/shaders/k3d_terran.sl:80:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_terran.sl:107:    latitude = lat_scale * pow(latitude, map_exp);
k3d/share/shaders/k3d_terran.sl:114:      /* Choose color of land based on the following spline.
k3d/share/shaders/k3d_terran.sl:115:       * Ken originally had a huge table.  I was too lazy to type it in,
k3d/share/shaders/k3d_terran.sl:164:	  /* Adjust color of water to darken deeper seas */
k3d/share/shaders/k3d_terran.sl:175:    Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_terran2.sl:1:/* Was terran.sl -- changed color spline to not use white 
k3d/share/shaders/k3d_terran2.sl:10: *   Earth-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_terran2.sl:13: *   which is necessary to get the best effect.  If you do this, it is
k3d/share/shaders/k3d_terran2.sl:15: *   both be set to the same values.  Otherwise you get bumpy mountains
k3d/share/shaders/k3d_terran2.sl:31: *    ice_caps - latitude at which ice caps tend to form on the oceans
k3d/share/shaders/k3d_terran2.sl:34: *               mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran2.sl:40: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_terran2.sl:42: *       For best results, use with the "terranbump" displacement shader,
k3d/share/shaders/k3d_terran2.sl:57: *    May 28 1995 Didn't want polar caps so removed white from color spline --
k3d/share/shaders/k3d_terran2.sl:103:  float l, o, a, i, weight;      /* Loop variables for fBm calc */
k3d/share/shaders/k3d_terran2.sl:108:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran2.sl:111:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran2.sl:113:   *       expect these two shaders to work well together.
k3d/share/shaders/k3d_terran2.sl:125:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terran2.sl:127:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terran2.sl:129:      weight = abs (VLNoise (tp, 1.5));
k3d/share/shaders/k3d_terran2.sl:130:      bumpy = weight * snoise (tp);
k3d/share/shaders/k3d_terran2.sl:131:      for (i = 1;  i < octaves  &&  weight >= VERY_SMALL;  i += 1) {
k3d/share/shaders/k3d_terran2.sl:133:	  /* get subsequent values, weighted by previous value */
k3d/share/shaders/k3d_terran2.sl:134:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran2.sl:135:	  weight = clamp (abs(weight), 0, 1);
k3d/share/shaders/k3d_terran2.sl:136:	  bumpy += snoise(tp) * min (weight, spectral_exp);
k3d/share/shaders/k3d_terran2.sl:162:       latitude = lat_scale * pow(latitude,map_exp);
k3d/share/shaders/k3d_terran2.sl:167:      /* Choose color of land based on the following spline.
k3d/share/shaders/k3d_terran2.sl:168:       * Ken originally had a huge table.  I was too lazy to type it in,
k3d/share/shaders/k3d_terran2.sl:219:	  /* Adjust color of water to darken deeper seas */
k3d/share/shaders/k3d_terran2.sl:229:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_terranbump.sl:25:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terranbump.sl:45:      /* get "distortion" vector, as used with clouds */
k3d/share/shaders/k3d_terranbump.sl:47:      /* compute bump vector using MfBm with displaced point */
k3d/share/shaders/k3d_terranbump.sl:50:      weight = abs(VLNoise(tp, 1.5));
k3d/share/shaders/k3d_terranbump.sl:51:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terranbump.sl:52:      for(i = 1; i < octaves && weight >= VERY_SMALL; i += 1)
k3d/share/shaders/k3d_terranbump.sl:55:	  /* get subsequent values, weighted by previous value */
k3d/share/shaders/k3d_terranbump.sl:56:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terranbump.sl:57:	  weight = clamp(abs(weight), 0, 1);
k3d/share/shaders/k3d_terranbump.sl:58:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_terranbump.sl:70:  /* Recalculate the surface normal (this is where all the real magic is!) */
k3d/share/shaders/k3d_texblender.sl:3:#include "k3d_filterwidth.h"
k3d/share/shaders/k3d_texblender.sl:51:	x=x/pow(10,n);
k3d/share/shaders/k3d_texblender.sl:73:float tex_wood(point PP; float ringscale)
k3d/share/shaders/k3d_texblender.sl:95:	color newc;
k3d/share/shaders/k3d_texblender.sl:100:		newc=tex_clouds(transp,octaves);
k3d/share/shaders/k3d_texblender.sl:102:		newc=myrand(transp);
k3d/share/shaders/k3d_texblender.sl:103:	else if (mapname=="wood")
k3d/share/shaders/k3d_texblender.sl:104:		newc=tex_wood(transp,octaves);
k3d/share/shaders/k3d_texblender.sl:107:		newc=texture(mapname,s*scalex,t*scaley,"blur",blur,"fill",-1,"width",0);
k3d/share/shaders/k3d_texblender.sl:108:    if (comp(newc,1)==-1) newc=comp(newc,0); /* treat a 1-channel texture map as a greyscale */
k3d/share/shaders/k3d_texblender.sl:110:			  return newc;
k3d/share/shaders/k3d_texblender.sl:113:color BlendColor(string mode; float K; color newc, oldc)
k3d/share/shaders/k3d_texblender.sl:116:  if (mode=="m") res+=K*newc;
k3d/share/shaders/k3d_texblender.sl:117:  if (mode=="f") res*= (1-K)*(color 1)+K*newc;
k3d/share/shaders/k3d_texblender.sl:121:float BlendFloat(string mode; float K, newf, oldf)
k3d/share/shaders/k3d_texblender.sl:125: if (mode=="m") res=(res+K*newf)/(1+K);
k3d/share/shaders/k3d_texblender.sl:126: if (mode=="f") res*= ((1-K)+K*newf);
k3d/share/shaders/k3d_texblender.sl:161:    normal Nf =normalize( faceforward(normalize(N),I));
k3d/share/shaders/k3d_texblender.sl:162:    dispDir=normalize( faceforward(normalize(Ng),I));
k3d/share/shaders/k3d_texblender.sl:170:    float MF=(comp(MC,0)+comp(MC,1)+comp(MC,2))/3; // when we want a float
k3d/share/shaders/k3d_threads.sl:6: * threads(): wrap threads around a cylinder 
k3d/share/shaders/k3d_tooledsteel.sl:1:/*  tooledsteel.sl written 9/99 by Ivan DeWolf
k3d/share/shaders/k3d_tooledsteel.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_tooledsteel.sl:9: *  and then used as the vector of anisotropy. works best on parametric
k3d/share/shaders/k3d_tooledsteel.sl:10: *  surfaces where you don't care about the seams. 
k3d/share/shaders/k3d_tooledsteel.sl:12: *  thanks to Jos Stam whose animated cube motivated this thing.
k3d/share/shaders/k3d_tooledsteel.sl:16: *  mult    		- multiples of swirls per unit
k3d/share/shaders/k3d_tooledsteel.sl:18: *          		  the swirls. set this to zero for a perfect grid.
k3d/share/shaders/k3d_tooledsteel.sl:23: *  specwidth		- the width of the specular stripe
k3d/share/shaders/k3d_tooledsteel.sl:29: *  twist		- allows you to twist the direction of anisotropy
k3d/share/shaders/k3d_tooledsteel.sl:66:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_tooledsteel.sl:89:anisospecular (vector VA; float specspread; float specwidth)
k3d/share/shaders/k3d_tooledsteel.sl:99:    normal Nf = faceforward(NN,-V);
k3d/share/shaders/k3d_tooledsteel.sl:114:            C += Cl * pixbrdf * pow( 1-abs(VA.H), 1/specwidth );
k3d/share/shaders/k3d_tooledsteel.sl:129:		specwidth	= .5,
k3d/share/shaders/k3d_tooledsteel.sl:132:		twist		=  0;
k3d/share/shaders/k3d_tooledsteel.sl:146:	VA = rotate(VA, twist, zro, normalize(N));
k3d/share/shaders/k3d_tooledsteel.sl:149:	Nf = faceforward(normalize(N), -I);
k3d/share/shaders/k3d_tooledsteel.sl:158:	      D = vtransform("world", D);
k3d/share/shaders/k3d_tooledsteel.sl:166:	specularcolor * Ks * anisospecular(VA, specspread*2, specwidth*.1)) +
k3d/share/shaders/k3d_toonmap.sl:12:float swidth4=1; 
k3d/share/shaders/k3d_toonmap.sl:13:float twidth4=1; 
k3d/share/shaders/k3d_toonmap.sl:20:float swidth3=1; 
k3d/share/shaders/k3d_toonmap.sl:21:float twidth3=1; 
k3d/share/shaders/k3d_toonmap.sl:33:float swidth2=1; 
k3d/share/shaders/k3d_toonmap.sl:34:float twidth2=1; 
k3d/share/shaders/k3d_toonmap.sl:55:temt_c4=texture(Highlight_Map,temp_ss4,temp_tt4,"swidth",swidth4,"twidth",twidth4,"samples",samples4);
k3d/share/shaders/k3d_toonmap.sl:59:temt_c4=texture(Highlight_Map[channel4],temp_ss4,temp_tt4,"swidth",swidth4,"twidth",twidth4,"samples",samples4);
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:97:temt_c2=texture(Ink_Map,temp_ss2,temp_tt2,"swidth",swidth2,"twidth",twidth2,"samples",samples2);
k3d/share/shaders/k3d_toonmap.sl:101:temt_c2=texture(Ink_Map[channel2],temp_ss2,temp_tt2,"swidth",swidth2,"twidth",twidth2,"samples",samples2);
k3d/share/shaders/k3d_toonmap.sl:115:C += pow(N.H, 1/roughness);
k3d/share/shaders/k3d_toonmap.sl:128:Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_translucency.sl:18:*		 when a texture is present, as scale value for the texture.
k3d/share/shaders/k3d_translucency.sl:19:*		 Don't use white on the translucency texture.
k3d/share/shaders/k3d_translucency.sl:71:	normal Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_translucency.sl:120:		shiny += pow (cosine, 1.0/roughness) / (ln.Nf) * Cl * sheen;
k3d/share/shaders/k3d_translucency.sl:123:		shiny += pow(sine, 10.0)*ln.Nf * Cl*sheen;
k3d/share/shaders/k3d_uberlight.sl:2: * uberlight.sl - a light with many fun controls.
k3d/share/shaders/k3d_uberlight.sl:11: * toward the +z axis (also in shader space).  Thus, to position and
k3d/share/shaders/k3d_uberlight.sl:13: * coordinate system in effect when the light source is declared.
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:24: *       space, for this light).  Omni lights throw light in all directions.
k3d/share/shaders/k3d_uberlight.sl:25: *       Area lights are emitted from actual geometry (this only works on
k3d/share/shaders/k3d_uberlight.sl:30: *       light coordinates) over which the light is active.  Outside
k3d/share/shaders/k3d_uberlight.sl:32: *   nearedge, faredge - define the width of the transition regions
k3d/share/shaders/k3d_uberlight.sl:33: *       for the cuton and cutoff.  The transitions will be smooth.
k3d/share/shaders/k3d_uberlight.sl:38: *       (which is physically correct for point-like sources, but
k3d/share/shaders/k3d_uberlight.sl:40: *   falloffdist - the distance at which the incident energy is actually
k3d/share/shaders/k3d_uberlight.sl:41: *       equal to intensity*lightcolor.  In other words, the intensity
k3d/share/shaders/k3d_uberlight.sl:44: *       large when the distance < falloffdist, the intensity is
k3d/share/shaders/k3d_uberlight.sl:46: *   parallelrays - when 0 (the default), the light appears to emanate
k3d/share/shaders/k3d_uberlight.sl:52: * is actually described by a superellipse with the following
k3d/share/shaders/k3d_uberlight.sl:56: *       light cone is aligned with the z-axis in local light space.
k3d/share/shaders/k3d_uberlight.sl:57: *   width, height - define the dimensions of the "barn door" opening.
k3d/share/shaders/k3d_uberlight.sl:59: *       from the light.  In other words, width==height==1 indicates a
k3d/share/shaders/k3d_uberlight.sl:61: *   wedge, hedge - the amount of width and height edge fuzz,
k3d/share/shaders/k3d_uberlight.sl:62: *       respectively.  Values of 0 will make a sharp cutoff, larger
k3d/share/shaders/k3d_uberlight.sl:63: *       values (up to 1) will make the edge softer.
k3d/share/shaders/k3d_uberlight.sl:64: *   roundness - controls how rounded the corners of the superellipse
k3d/share/shaders/k3d_uberlight.sl:65: *       are.  If this value is 0, the cross-section will be a perfect
k3d/share/shaders/k3d_uberlight.sl:66: *       rectangle.  If the value is 1, the cross-section will be a
k3d/share/shaders/k3d_uberlight.sl:67: *       perfect ellipse.  In-between values control the roundness of
k3d/share/shaders/k3d_uberlight.sl:68: *       the corners in a fairly obvious way.
k3d/share/shaders/k3d_uberlight.sl:79: *   slidename - if a filename is supplied, a texture lookup will be
k3d/share/shaders/k3d_uberlight.sl:80: *       done and the light emitted from the source will be filtered
k3d/share/shaders/k3d_uberlight.sl:81: *       by that color, much like a slide projector.  If you want to
k3d/share/shaders/k3d_uberlight.sl:83: *       black-and-white, but store it as an RGB texture.  For
k3d/share/shaders/k3d_uberlight.sl:84: *       simplicity, the shader assumes that the texture file will
k3d/share/shaders/k3d_uberlight.sl:94: *       attenuation of light as it passes through a window with 
k3d/share/shaders/k3d_uberlight.sl:95: *       water drops dripping down it.
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:101: *   shadowmap - the name of the texture containing the shadow map.  If
k3d/share/shaders/k3d_uberlight.sl:102: *       this value is "" (the default), no shadow map will be used.
k3d/share/shaders/k3d_uberlight.sl:103: *   shadowblur - how soft to make the shadow edge, expressed as a
k3d/share/shaders/k3d_uberlight.sl:104: *       percentage of the width of the entire shadow map.
k3d/share/shaders/k3d_uberlight.sl:105: *   shadowbias - the amount of shadow bias to add to the lookup.
k3d/share/shaders/k3d_uberlight.sl:106: *   shadownsamps - the number of samples to use.
k3d/share/shaders/k3d_uberlight.sl:108: * Ray-traced shadows.  These options work only for BMRT:
k3d/share/shaders/k3d_uberlight.sl:109: *   raytraceshadow - if nonzero, cast rays to see if we are in shadow.
k3d/share/shaders/k3d_uberlight.sl:111: *   nshadowrays - The number of rays to trace to determine shadowing.
k3d/share/shaders/k3d_uberlight.sl:112: *   shadowcheat - add this offset to the light source position.  This
k3d/share/shaders/k3d_uberlight.sl:113: *       allows you to cause the shadows to emanate as if the light
k3d/share/shaders/k3d_uberlight.sl:114: *       were someplace else, but without changing the area
k3d/share/shaders/k3d_uberlight.sl:117: * "Fake" shadows from a blocker object.  A blocker is a superellipse
k3d/share/shaders/k3d_uberlight.sl:118: * in 3-space which effectively blocks light.  But it's not really
k3d/share/shaders/k3d_uberlight.sl:119: * geometry, the shader just does the intersection with the
k3d/share/shaders/k3d_uberlight.sl:121: * its own coordinate system (which obviously needs to be defined in
k3d/share/shaders/k3d_uberlight.sl:126: *   blockerwidth, blockerheight - define the dimensions of the blocker's
k3d/share/shaders/k3d_uberlight.sl:128: *   blockerwedge, blockerhedge - define the fuzzyness of the edges.
k3d/share/shaders/k3d_uberlight.sl:129: *   blockerround - how round the corners of the blocker are (same
k3d/share/shaders/k3d_uberlight.sl:133: * Joint shadow controls:
k3d/share/shaders/k3d_uberlight.sl:134: *   shadowcolor - Shadows (i.e., those regions with "occlusion" as
k3d/share/shaders/k3d_uberlight.sl:135: *       defined by any or all of the shadow map, ray cast, or
k3d/share/shaders/k3d_uberlight.sl:137: *       this shader, shadowed regions actually just change the color
k3d/share/shaders/k3d_uberlight.sl:138: *       of the light to "shadowcolor".  If this color is set to
k3d/share/shaders/k3d_uberlight.sl:140: *       to, say (.25,.25,.25), it will make the shadowed regions lose
k3d/share/shaders/k3d_uberlight.sl:143: *       something yellowish and make the shadowcolor dark but
k3d/share/shaders/k3d_uberlight.sl:144: *       somewhat bluish.  Another effect of shadows is to set the
k3d/share/shaders/k3d_uberlight.sl:145: *       __nonspecular flag so that the shadowed regions are lit only
k3d/share/shaders/k3d_uberlight.sl:146: *       diffusely, without highlights.
k3d/share/shaders/k3d_uberlight.sl:149: *   nonspecular - when set to 1, this light does not create
k3d/share/shaders/k3d_uberlight.sl:150: *       specular highlights!  The default is 0, which means it makes
k3d/share/shaders/k3d_uberlight.sl:151: *       highlights just fine (except for regions in shadows, as
k3d/share/shaders/k3d_uberlight.sl:157: *       and later, as well as BMRT 2.3.5 and later.  But if you write
k3d/share/shaders/k3d_uberlight.sl:158: *       your own illuminance loops in your surface shader, you've got
k3d/share/shaders/k3d_uberlight.sl:159: *       to account for it yourself.  The PRMan user manual explains how
k3d/share/shaders/k3d_uberlight.sl:162: *       1, this light will only cast specular highlights but not
k3d/share/shaders/k3d_uberlight.sl:164: *       makes specular highlights, without affecting the rest of the
k3d/share/shaders/k3d_uberlight.sl:165: *       illumination in the scene.  All the same caveats apply with
k3d/share/shaders/k3d_uberlight.sl:168: *   __foglight - the "noisysmoke" shader distributed with BMRT will add
k3d/share/shaders/k3d_uberlight.sl:170: *       parameter set to 1 (the default).  In other words, if you use
k3d/share/shaders/k3d_uberlight.sl:171: *       this light with noisysmoke, you can set this flag to 0 to
k3d/share/shaders/k3d_uberlight.sl:173: *       Note that the noisysmoke shader is distributed with BMRT but
k3d/share/shaders/k3d_uberlight.sl:174: *       will also work just fine with PRMan (3.7 or later).
k3d/share/shaders/k3d_uberlight.sl:176: * NOTE: this shader has one each of: blocker, shadow map, slide, and
k3d/share/shaders/k3d_uberlight.sl:177: * noise texture.  Some advanced users may want more than one of some or
k3d/share/shaders/k3d_uberlight.sl:183: * This shader was written as part of the course notes for ACM
k3d/share/shaders/k3d_uberlight.sl:189: * This shader was tested using Pixar's PhotoRealistic RenderMan 3.7
k3d/share/shaders/k3d_uberlight.sl:191: * tried to avoid Shading Language constructs which wouldn't work on
k3d/share/shaders/k3d_uberlight.sl:193: * "vector" type and I often declare variables where they are used,
k3d/share/shaders/k3d_uberlight.sl:195: * renderer which does not support these new language features, just
k3d/share/shaders/k3d_uberlight.sl:209:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_uberlight.sl:219: *   - the equations of two superellipses (with major/minor axes given by
k3d/share/shaders/k3d_uberlight.sl:222: *   - 0 if Q was inside the inner ellipse
k3d/share/shaders/k3d_uberlight.sl:223: *   - 1 if Q was outside the outer ellipse
k3d/share/shaders/k3d_uberlight.sl:224: *   - smoothly varying from 0 to 1 in between
k3d/share/shaders/k3d_uberlight.sl:256:	  float q = a * b * pow(pow(b * x, re) + pow(a * y, re), -1 / re);
k3d/share/shaders/k3d_uberlight.sl:257:	  float r = A * B * pow(pow(B * x, re) + pow(A * y, re), -1 / re);
k3d/share/shaders/k3d_uberlight.sl:277:		       string lighttype;	/* what kind of light */
k3d/share/shaders/k3d_uberlight.sl:284:		       float width, height;	/* xy superellipse */
k3d/share/shaders/k3d_uberlight.sl:285:		       float hedge, wedge, roundness;
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:329:			     height, width + wedge, height + hedge,
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:344:			  float blockerwidth, blockerheight;
k3d/share/shaders/k3d_uberlight.sl:345:			  float blockerwedge, blockerhedge;
k3d/share/shaders/k3d_uberlight.sl:353:  /* Blocker works only if it's straddled by ray endpoints. */
k3d/share/shaders/k3d_uberlight.sl:359:	clipSuperellipse(Pplane, blockerwidth, blockerheight,
k3d/share/shaders/k3d_uberlight.sl:360:			 blockerwidth + blockerwedge,
k3d/share/shaders/k3d_uberlight.sl:380:		     float width = 1, height = 1, wedge = .1, hedge = .1;
k3d/share/shaders/k3d_uberlight.sl:388:		     /* Shadow mapped shadows */
k3d/share/shaders/k3d_uberlight.sl:389:		     string shadowmap = "";
k3d/share/shaders/k3d_uberlight.sl:390:		     float shadowblur = 0.01, shadowbias = .01, shadownsamps =
k3d/share/shaders/k3d_uberlight.sl:392:		     color shadowcolor = 0;
k3d/share/shaders/k3d_uberlight.sl:393:		     /* Ray traced shadows */
k3d/share/shaders/k3d_uberlight.sl:394:		     float raytraceshadow = 0, nshadowrays = 1;
k3d/share/shaders/k3d_uberlight.sl:395:		     vector shadowcheat = vector "shader"(0, 0, 0);
k3d/share/shaders/k3d_uberlight.sl:396:		     /* Fake blocker shadow */
k3d/share/shaders/k3d_uberlight.sl:398:		     float blockerwidth = 1, blockerheight = 1;
k3d/share/shaders/k3d_uberlight.sl:399:		     float blockerwedge = .1, blockerhedge =
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:412:   * the surface point we're shading, expressed in the local light
k3d/share/shaders/k3d_uberlight.sl:417:  /* If it's an area light, we want the point and normal of the light
k3d/share/shaders/k3d_uberlight.sl:418:   * geometry.  If not an area light, BMRT guarantees P,N will be the
k3d/share/shaders/k3d_uberlight.sl:424:  /* For PRMan, we've gotta do it the hard way */
k3d/share/shaders/k3d_uberlight.sl:432:						width + wedge + abs(shearx));
k3d/share/shaders/k3d_uberlight.sl:448:     * blockers and whatnot.  Start with no attenuation (i.e., a 
k3d/share/shaders/k3d_uberlight.sl:460:		       sheary, width, height, hedge, wedge, roundness,
k3d/share/shaders/k3d_uberlight.sl:466:	point Pslide = PL / point(width + wedge, height + hedge, 1);
k3d/share/shaders/k3d_uberlight.sl:473:    /* If the volume says we aren't being lit, skip the remaining tests */
k3d/share/shaders/k3d_uberlight.sl:485:	/* Apply shadow mapped shadows */
k3d/share/shaders/k3d_uberlight.sl:487:	if(shadowmap != "")
k3d/share/shaders/k3d_uberlight.sl:489:	    1 - shadow(shadowmap, Ps, "blur", shadowblur, "samples",
k3d/share/shaders/k3d_uberlight.sl:490:		       shadownsamps, "bias", shadowbias);
k3d/share/shaders/k3d_uberlight.sl:491:	point shadoworigin;
k3d/share/shaders/k3d_uberlight.sl:493:	  shadoworigin = from;
k3d/share/shaders/k3d_uberlight.sl:495:	  shadoworigin = point "shader"(xcomp(PL), ycomp(PL), cuton);
k3d/share/shaders/k3d_uberlight.sl:497:	/* If we can, apply ray cast shadows.  Force a ray trace if
k3d/share/shaders/k3d_uberlight.sl:498:	 * we're in BMRT and the user wanted a shadow map.
k3d/share/shaders/k3d_uberlight.sl:500:	if(raytraceshadow != 0)
k3d/share/shaders/k3d_uberlight.sl:504:	    for(i = 0; i < nshadowrays; i += 1)
k3d/share/shaders/k3d_uberlight.sl:505:	      vis += visibility(Ps, shadoworigin + shadowcheat);
k3d/share/shaders/k3d_uberlight.sl:506:	    vis /= nshadowrays;
k3d/share/shaders/k3d_uberlight.sl:510:	/* Apply blocker fake shadows */
k3d/share/shaders/k3d_uberlight.sl:514:	      BlockerContribution(Ps, shadoworigin, blockercoords,
k3d/share/shaders/k3d_uberlight.sl:515:				  blockerwidth, blockerheight, blockerwedge,
k3d/share/shaders/k3d_uberlight.sl:518:	lcol = mix(shadowcolor, lcol, unoccluded);
k3d/share/shaders/k3d_urbermap.sl:18:string abRoughnessMap="I:/ArtWorks/Textures/Native_1.2.shadow.tif"; 
k3d/share/shaders/k3d_urbermap.sl:54:"swidth", abColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:55:"twidth", abColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:59:"swidth", abColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:60:"twidth", abColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:79:"swidth", abDiffuseMapBlur,
k3d/share/shaders/k3d_urbermap.sl:80:"twidth", abDiffuseMapBlur );
k3d/share/shaders/k3d_urbermap.sl:91:"swidth", abSpecularMapBlur,
k3d/share/shaders/k3d_urbermap.sl:92:"twidth", abSpecularMapBlur );
k3d/share/shaders/k3d_urbermap.sl:103:"swidth", abSpecularColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:104:"twidth", abSpecularColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:115:"swidth", abRoughnessMapBlur,
k3d/share/shaders/k3d_urbermap.sl:116:"twidth", abRoughnessMapBlur );
k3d/share/shaders/k3d_urbermap.sl:129:"swidth", abTransparencyMapBlur,
k3d/share/shaders/k3d_urbermap.sl:130:"twidth", abTransparencyMapBlur );
k3d/share/shaders/k3d_urbermap.sl:135:"swidth", abTransparencyMapBlur,
k3d/share/shaders/k3d_urbermap.sl:136:"twidth", abTransparencyMapBlur ));
k3d/share/shaders/k3d_urbermap.sl:144:"swidth", abIncandescenseMapBlur,
k3d/share/shaders/k3d_urbermap.sl:145:"twidth", abIncandescenseMapBlur );
k3d/share/shaders/k3d_urbermap.sl:157:"swidth", abBumpMapBlur,
k3d/share/shaders/k3d_urbermap.sl:158:"twidth", abBumpMapBlur );
k3d/share/shaders/k3d_urbermap.sl:179:Nf = faceforward( normalize(Nf), I );
k3d/share/shaders/k3d_urbermap.sl:186:D = vtransform("worldspace", D);
k3d/share/shaders/k3d_urbermap.sl:193:"swidth", abReflectionMapBlur,
k3d/share/shaders/k3d_urbermap.sl:194:"twidth", abReflectionMapBlur );
k3d/share/shaders/k3d_veinedmarble.sl:5: *   Makes solid marble texture with strong veins.  The "veincolor" parameter
k3d/share/shaders/k3d_veinedmarble.sl:11: *   veinfreq - controls fhe lowest frequency of the color veins
k3d/share/shaders/k3d_veinedmarble.sl:12: *   veinlevels - how many "levels" of vein tendrills it has
k3d/share/shaders/k3d_veinedmarble.sl:13: *   warpfreq - lowest frequency of the turbulent warping in the marble
k3d/share/shaders/k3d_veinedmarble.sl:14: *   warping - controls how much turbulent warping there will be
k3d/share/shaders/k3d_veinedmarble.sl:16: *   sharpness - controls how sharp or fuzzy the veins are (higher = sharper)
k3d/share/shaders/k3d_veinedmarble.sl:20: *         email: gritz@seas.gwu.edu
k3d/share/shaders/k3d_veinedmarble.sl:39:			 float warpfreq = 1;
k3d/share/shaders/k3d_veinedmarble.sl:40:			 float warping = .5;
k3d/share/shaders/k3d_veinedmarble.sl:51:  float dPP = filterwidthp(PP);
k3d/share/shaders/k3d_veinedmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_veinedmarble.sl:62:      turb = pow(smoothstep(0.8, 1, 1 - turb), sharpness) / freq;
k3d/share/shaders/k3d_veinedmarble.sl:70:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_velvet.sl:9: *   - A retroreflective lobe (back toward the light source)
k3d/share/shaders/k3d_velvet.sl:20: * ANTIALIASING: should antialias itself fairly well
k3d/share/shaders/k3d_velvet.sl:22: * AUTHOR: written by Stephen H. Westin, Ford Motor Company
k3d/share/shaders/k3d_velvet.sl:25: * 	2001.02.01	westin@SpamSucks_graphics.cornell.edu
k3d/share/shaders/k3d_velvet.sl:53:  Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_velvet.sl:61:    shiny += pow ( cosine, 1.0/roughness ) * backscatter
k3d/share/shaders/k3d_velvet.sl:66:    shiny += pow ( sine, edginess ) * Ln.Nf * Cl * sheen;
k3d/share/shaders/k3d_venus.sl:8: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus.sl:10: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus.sl:17: *    twist - controls the twisting of the clouds due to Coriolis forces.
k3d/share/shaders/k3d_venus.sl:25: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_venus.sl:35: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus.sl:55:		  float offset = 1; float scale = 0.6; float twist = 0.22;
k3d/share/shaders/k3d_venus.sl:61:  point PP;			/* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus.sl:62:  float rsq;			/* Used in calculation of twist */
k3d/share/shaders/k3d_venus.sl:63:  float angle;			/* Twist angle */
k3d/share/shaders/k3d_venus.sl:71:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus.sl:74:  angle = twist * TWOPI * rsq;
k3d/share/shaders/k3d_venus.sl:94:  /* Shade like matte, but with color scaled by cloud color */
k3d/share/shaders/k3d_venus.sl:98:			 Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_venus2.sl:10: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus2.sl:12: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus2.sl:19: *    twist - controls the twisting of the clouds due to Coriolis forces.
k3d/share/shaders/k3d_venus2.sl:27: *    Planet radius param added by Mark Beckwith.
k3d/share/shaders/k3d_venus2.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus2.sl:38: *    Dec 1996 - Added radius of planet as a parameter by Mark Beckwith
k3d/share/shaders/k3d_venus2.sl:56:       float twist = 0.22;
k3d/share/shaders/k3d_venus2.sl:63:  point PP;                 /* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus2.sl:64:  float rsq;                /* Used in calculation of twist */
k3d/share/shaders/k3d_venus2.sl:65:  float angle;              /* Twist angle */
k3d/share/shaders/k3d_venus2.sl:73:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus2.sl:76:  angle = twist * TWOPI * rsq;
k3d/share/shaders/k3d_venus2.sl:93:  /* Shade like matte, but with color scaled by cloud color */
k3d/share/shaders/k3d_venus2.sl:96:			    Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_volcube.sl:1:/* srf_vol_cube - Brian Steiner - Sony Pictures Imageworks
k3d/share/shaders/k3d_volcube.sl:5:   StepSize            - distance between sample points.
k3d/share/shaders/k3d_volcube.sl:10:   Do_Shading          - if 1, shading will be calculated.
k3d/share/shaders/k3d_volcube.sl:14:   ShowActiveVol       - if 1 show the active volume instead of density.
k3d/share/shaders/k3d_volcube.sl:15:   RunShadowPass       - set to 1 if running a shadow pass.
k3d/share/shaders/k3d_volcube.sl:112:/* density function will return the final volume density */
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:196:	     float  ShowActiveVol  = 0;
k3d/share/shaders/k3d_volcube.sl:197:	     float  RunShadowPass  = 0;
k3d/share/shaders/k3d_volcube.sl:229:    while(curStep < numOfSteps && density_sum < 1){
k3d/share/shaders/k3d_volcube.sl:234:	if(ShowActiveVol == 1)
k3d/share/shaders/k3d_volcube.sl:240:	if(cur_density > 0 && RunShadowPass == 0){
k3d/share/shaders/k3d_volcube.sl:278:            /* if Shadow Pass */
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:4: * wallpaper.sl
k3d/share/shaders/k3d_wallpaper.sl:6: * AUTHOR: Darwyn Peachy
k3d/share/shaders/k3d_wallpaper.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_wallpaper.sl:19:k3d_wallpaper(
k3d/share/shaders/k3d_wallpaper.sl:70:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_wallpaper_2stripe.sl:2: * wallpaper_2stripe.sl -- surface shader for double striped wall paper
k3d/share/shaders/k3d_wallpaper_2stripe.sl:5: *   Makes a double striped pattern appropriate for wall paper.  Stripes
k3d/share/shaders/k3d_wallpaper_2stripe.sl:14: *   stripewidth                width of stripes, in s coordinates
k3d/share/shaders/k3d_wallpaper_2stripe.sl:15: *   stripespacing              dist between sets of stripes, in s coordinates
k3d/share/shaders/k3d_wallpaper_2stripe.sl:18: * ANTIALIASING:  should analytically antialias itself quite well.
k3d/share/shaders/k3d_wallpaper_2stripe.sl:20: * AUTHOR: written by Larry Gritz (email: lg@bmrt.org)
k3d/share/shaders/k3d_wallpaper_2stripe.sl:29:surface k3d_wallpaper_2stripe(float Ka = 0.5, Kd = 0.75, Ks = 0.25;
k3d/share/shaders/k3d_wallpaper_2stripe.sl:32:			      float stripewidth = 0.05;
k3d/share/shaders/k3d_wallpaper_2stripe.sl:36:  float ds = filterwidth(ss);
k3d/share/shaders/k3d_wallpaper_2stripe.sl:37:  float edge = (1 - stripewidth);
k3d/share/shaders/k3d_wallpaper_2stripe.sl:41:     filteredpulsetrain(edge, 1, ss + 2 * stripewidth, ds));
k3d/share/shaders/k3d_wallpaper_2stripe.sl:45:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_warningstripes.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_warningstripes.sl:8:// License as published by the Free Software Foundation; either
k3d/share/shaders/k3d_warningstripes.sl:11:// This program is distributed in the hope that it will be useful,
k3d/share/shaders/k3d_warningstripes.sl:12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
k3d/share/shaders/k3d_warningstripes.sl:17:// License along with this program; if not, write to the Free Software
k3d/share/shaders/k3d_warningstripes.sl:24:/// Filtering code courtesy of the Advanced RenderMan book ... where else?
k3d/share/shaders/k3d_warningstripes.sl:27:#define filter_width(x) max(abs(Du(x)*du) + abs(Dv(x)*dv), MIN_FILTER_WIDTH)
k3d/share/shaders/k3d_warningstripes.sl:31:	float w = dx / period;
k3d/share/shaders/k3d_warningstripes.sl:32:	float x0 = x/period - w/2;
k3d/share/shaders/k3d_warningstripes.sl:33:	float x1 = x0 + w;
k3d/share/shaders/k3d_warningstripes.sl:42:	return (integral(x1) - integral(x0)) / w;
k3d/share/shaders/k3d_warningstripes.sl:45:surface k3d_warningstripes(
k3d/share/shaders/k3d_warningstripes.sl:50:	float stripe_position = filtered_pulse_train(0.5 / Frequency, 1.0 / Frequency, u+v, filter_width(u+v));
k3d/share/shaders/k3d_warningstripes.sl:54:	vector Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_water.sl:2: * water.sl -- water surface, using ray tracing.

k3d/share/shaders/k3d_water.sl:3: * This was originally shiny.sl, but I change it to make it transparant.  The interesting part colors that

k3d/share/shaders/k3d_water.sl:4: * are not blue will pass thru the water.

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

k3d/share/shaders/k3d_water.sl:7: *        water like look.

k3d/share/shaders/k3d_water.sl:9: * modified by Lawrence D. Chin, cs184-bo

k3d/share/shaders/k3d_water.sl:19: *    blur - how blurry are the reflections? (0 = perfectly sharp)

k3d/share/shaders/k3d_water.sl:24: *      Aug 1991 -- written by lg in C

k3d/share/shaders/k3d_water.sl:36:k3d_water ( float Ka = 0, Kd = 0, Ks = 1;

k3d/share/shaders/k3d_water.sl:41:        half_width = 0.1;      /* half width of ring */

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

k3d/share/shaders/k3d_water.sl:54:    /* Construct a forward facing surface normal */

k3d/share/shaders/k3d_water.sl:55:    Nf = faceforward (normalize(N), I);

k3d/share/shaders/k3d_water.sl:99:    layer_opac = pulse(radius - half_width, radius + half_width, fuzz, d);

k3d/share/shaders/k3d_water.sl:104:    /* This gives the water a somewhat transparant look. 

k3d/share/shaders/k3d_water.sl:105:     *   Note: This does works with radiosity.

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

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

k3d/share/shaders/k3d_watercolor.sl:6: * 	case is as follows:

k3d/share/shaders/k3d_watercolor.sl:10:surface k3d_watercolor(

k3d/share/shaders/k3d_watercolor.sl:11:	color upwelling = color(0, 0.2, 0.3);

k3d/share/shaders/k3d_watercolor.sl:45:	Ci = dist * ( reflectivity * sky + (1-reflectivity) * upwelling ) + (1-dist)* air;

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

k3d/share/shaders/k3d_waterdisplacement.sl:13:displacement k3d_waterdisplacement (float Km = 1.0; string bumpmap = "")

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

k3d/share/shaders/k3d_waterlight.sl:1:/** k3d_waterlight
k3d/share/shaders/k3d_waterlight.sl:5:A cheap trick to simulate underwater caustics - best used for deep-sea effects
k3d/share/shaders/k3d_waterlight.sl:10:light k3d_waterlight(
k3d/share/shaders/k3d_waterlight.sl:16:	string shadowname="";
k3d/share/shaders/k3d_waterlight.sl:27:	if(shadowname != "")
k3d/share/shaders/k3d_waterlight.sl:29:			Cl *= 1 - shadow(shadowname, Ps, "samples", samples, "blur", blur, "bias", bias);
k3d/share/shaders/k3d_windowlight.sl:2: * windowlight.sl - make a window light (with crossbars)
k3d/share/shaders/k3d_windowlight.sl:5: *   Simulates light coming through a window.  The light doesn't
k3d/share/shaders/k3d_windowlight.sl:11: *   center - the spatial position of the center of the window
k3d/share/shaders/k3d_windowlight.sl:12: *   up, in - vectors which define the orientation of the window
k3d/share/shaders/k3d_windowlight.sl:15: *   panewidth, paneheight - width/height of the individual panes
k3d/share/shaders/k3d_windowlight.sl:17: *   framewidth, frameheight - how thick are the window frame "bars",
k3d/share/shaders/k3d_windowlight.sl:18: *               as percentage of panewidth/paneheight
k3d/share/shaders/k3d_windowlight.sl:20: * Author:  Larry Gritz, with inspiration from [Upstill]
k3d/share/shaders/k3d_windowlight.sl:28:light k3d_windowlight(float intensity = 1;
k3d/share/shaders/k3d_windowlight.sl:37:		      float panewidth = 6, paneheight = 6;
k3d/share/shaders/k3d_windowlight.sl:38:		      float framewidth = .1, frameheight = .1;
k3d/share/shaders/k3d_windowlight.sl:71:    offset = (PL - center).right + panewidth * (hpanes / 2);
k3d/share/shaders/k3d_windowlight.sl:72:    if(offset > 0 && (offset / panewidth) < hpanes)
k3d/share/shaders/k3d_windowlight.sl:74:	modulus = mod(offset, panewidth);
k3d/share/shaders/k3d_windowlight.sl:76:	  filteredpulse(framewidth / 2, panewidth - framewidth / 2, modulus,
k3d/share/shaders/k3d_windywave.sl:3:displacement k3d_windywave(float Km = 0.1; float txtscale = 1;
k3d/share/shaders/k3d_windywave.sl:4:			   float windfreq = 0.5; float windamp = 1;
k3d/share/shaders/k3d_windywave.sl:5:			   float minwind = 0.3)
k3d/share/shaders/k3d_windywave.sl:9:  float wind;
k3d/share/shaders/k3d_windywave.sl:12:  PP = txtscale * windfreq * transform("shader", P);
k3d/share/shaders/k3d_windywave.sl:25:  wind = minwind + windamp * turb;
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:2: * wood2.sl -- another surface shader for wood.
k3d/share/shaders/k3d_wood2.sl:5: *   Makes wood solid texture.
k3d/share/shaders/k3d_wood2.sl:8: *   Ka, Kd, Ks, specular, roughness - work just like the plastic shader
k3d/share/shaders/k3d_wood2.sl:11: *   lightwood, darkwood - surface colors for the wood itself
k3d/share/shaders/k3d_wood2.sl:14: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_wood2.sl:21:surface k3d_wood2(float Ka = 1, Kd = .75, Ks = .4;
k3d/share/shaders/k3d_wood2.sl:26:		  color lightwood = color(0.69, 0.44, 0.25);
k3d/share/shaders/k3d_wood2.sl:27:		  color darkwood = color(0.35, 0.22, 0.08); float grainy = 1;)
k3d/share/shaders/k3d_wood2.sl:30:  normal Nf;			/* forward facing normal */
k3d/share/shaders/k3d_wood2.sl:31:  color Ct;			/* surface color of the wood */
k3d/share/shaders/k3d_wood2.sl:51:  Ct = mix(lightwood, darkwood, r * r2 * r2);
k3d/share/shaders/k3d_wood2.sl:57:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_woodcut.sl:2: surface k3d_woodcut (
k3d/share/shaders/k3d_woodcut.sl:31:Nf = faceforward( normalize(N), I );
