k3d/share/shaders/k3d_altitude_fog.sl:4:	color background = 0;
k3d/share/shaders/k3d_altitude_fog.sl:10:	Ci = mix(Ci, background, fog);
k3d/share/shaders/k3d_ambientlight.sl:1:/* ambientlight.sl - Standard ambient light source for RenderMan Interface.
k3d/share/shaders/k3d_ambientlight.sl:9:light k3d_ambientlight(
k3d/share/shaders/k3d_antialiasedchecks.sl:2: * checks_aa.sl -- RenderMan compatible shader for checks.
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:19: * last modified 27 Jan 1994 by Larry Gritz
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:45:  Nfactor = abs (Nf . I) / (length(Nf) * length(I));
k3d/share/shaders/k3d_antialiasedchecks.sl:68:  Ci *= Os * (Ka*ambient() + Kd*diffuse(Nf));
k3d/share/shaders/k3d_background.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_background.sl:7:// modify it under the terms of the GNU General Public
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:14:// General Public License for more details.
k3d/share/shaders/k3d_background.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_background.sl:24:/// Simplified from the original by Larry Gritz
k3d/share/shaders/k3d_background.sl:26:imager k3d_background(
k3d/share/shaders/k3d_background.sl:27:color bgcolor = color(1, 1, 1)
k3d/share/shaders/k3d_background.sl:30:  Ci += (1 - alpha) * bgcolor;
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:4: * bluemarb.sl
k3d/share/shaders/k3d_bluemarble.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_bluemarble.sl:23:marble_color(float m)
k3d/share/shaders/k3d_bluemarble.sl:36:k3d_bluemarble(
k3d/share/shaders/k3d_bluemarble.sl:47:    float i, f, marble;
k3d/share/shaders/k3d_bluemarble.sl:52:    marble = 0; f = 1;
k3d/share/shaders/k3d_bluemarble.sl:54:        marble += snoise(PP * f)/f;
k3d/share/shaders/k3d_bluemarble.sl:57:    Ct = marble_color(marble);
k3d/share/shaders/k3d_bluemarble.sl:59:    Ci = Os * (Ct * (Ka * ambient() + Kd * diffuse(NN))
k3d/share/shaders/k3d_bluescreen.sl:2: * bluescreen.sl
k3d/share/shaders/k3d_bluescreen.sl:3: *   puts a background color behind an image.
k3d/share/shaders/k3d_bluescreen.sl:6: *   background - the color of the background
k3d/share/shaders/k3d_bluescreen.sl:9:imager k3d_bluescreen (
k3d/share/shaders/k3d_bluescreen.sl:11:color background = color(0.0, 0.0, 1.0); 
k3d/share/shaders/k3d_bluescreen.sl:29:       Ci+=(1-alpha)*background;
k3d/share/shaders/k3d_brick.sl:2: * brick.sl -- Surface shader for a bricks.
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:10: *   by the "rowvary" parameter.
k3d/share/shaders/k3d_brick.sl:14: *    brickcolor, mortarcolor	Pretty obvious (default is red bricks)
k3d/share/shaders/k3d_brick.sl:15: *    brickvary                 How much does the brick color vary from
k3d/share/shaders/k3d_brick.sl:16: *     				   brick to brick?
k3d/share/shaders/k3d_brick.sl:17: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brick.sl:18: *    brickheight               Height of a brick (in st space)
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:29:surface k3d_brick(
k3d/share/shaders/k3d_brick.sl:31:		  color brickcolor = color "rgb"(.6, .1, .1);
k3d/share/shaders/k3d_brick.sl:32:		  color mortarcolor = color "rgb"(.6, .6, .6);
k3d/share/shaders/k3d_brick.sl:34:		  float jagged = 0.006, brickvary = 0.3;
k3d/share/shaders/k3d_brick.sl:35:		  float brickwidth = .28, brickheight = .07;
k3d/share/shaders/k3d_brick.sl:43:  color bcolor, Ct;
k3d/share/shaders/k3d_brick.sl:45:  float sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brick.sl:48:  uniform float BMWIDTH = (brickwidth + mortarthickness);
k3d/share/shaders/k3d_brick.sl:49:  uniform float BMHEIGHT = (brickheight + mortarthickness);
k3d/share/shaders/k3d_brick.sl:52:  float whichbrick;
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:58:   * a bit smoother.
k3d/share/shaders/k3d_brick.sl:63:  basicbrick(s, t, BMWIDTH, BMHEIGHT, 0.5, 0.2, 1, jagged, sbrick, tbrick, ss,
k3d/share/shaders/k3d_brick.sl:66:  /* Make the edges ragged, but different for each brick */
k3d/share/shaders/k3d_brick.sl:67:  whichbrick = 103 * sbrick + tbrick;
k3d/share/shaders/k3d_brick.sl:69:    raggedamp * snoisexy((s + tbrick * 5.15) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:70:			 (t + sbrick * 23.8) * raggedfreq);
k3d/share/shaders/k3d_brick.sl:72:    raggedamp * snoisexy((s + tbrick * 11.4) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:73:			 (t + sbrick * 7.2) * raggedfreq);
k3d/share/shaders/k3d_brick.sl:75:    raggedamp / 2 * snoisexy((s + tbrick * 5.15) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:76:			     (t + sbrick * 23.8) * raggedfreq * 2);
k3d/share/shaders/k3d_brick.sl:78:    raggedamp / 2 * snoisexy((s + tbrick * 11.4) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:79:			     (t + sbrick * 7.2) * raggedfreq * 2);
k3d/share/shaders/k3d_brick.sl:122:	((ss + sbrick) * pockfrequency / BMHEIGHT,
k3d/share/shaders/k3d_brick.sl:123:	 (tt + tbrick) * pockfrequency / BMWIDTH), 0.25);
k3d/share/shaders/k3d_brick.sl:130:  /* Choose a brick color that varies from brick to brick */
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_brick.sl:136:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
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:4: * brick.sl
k3d/share/shaders/k3d_brick2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brick2.sl:26:k3d_brick2(
k3d/share/shaders/k3d_brick2.sl:29:    uniform color Cbrick = color (0.5, 0.15, 0.14);
k3d/share/shaders/k3d_brick2.sl:35:    float ss, tt, sbrick, tbrick, w, h;
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:48:    ss -= sbrick;
k3d/share/shaders/k3d_brick2.sl:49:    tt -= tbrick;
k3d/share/shaders/k3d_brick2.sl:53:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brick2.sl:57:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_brick3.sl:2: * brick.sl -- Surface shader for a bricks.
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:10: *   by the "rowvary" parameter.
k3d/share/shaders/k3d_brick3.sl:14: *    brickcolor, mortarcolor	Pretty obvious (default is red bricks)
k3d/share/shaders/k3d_brick3.sl:15: *    brickvary                 How much does the brick color vary from
k3d/share/shaders/k3d_brick3.sl:16: *     				   brick to brick?
k3d/share/shaders/k3d_brick3.sl:17: *    brickwidth                Width of a brick (in st space)
k3d/share/shaders/k3d_brick3.sl:18: *    brickheight               Height of a brick (in st space)
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:24: * 	This shader is very similar to (and based upon) brick shaders
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:30: *      12 Jan 1994 -- recoded by lg in correct shading language.
k3d/share/shaders/k3d_brick3.sl:32: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_brick3.sl:38:k3d_brick3 ( 
k3d/share/shaders/k3d_brick3.sl:40:	color brickcolor = color "rgb" (.6,.1,.1);
k3d/share/shaders/k3d_brick3.sl:41:	color mortarcolor = color "rgb" (.6,.6,.6);
k3d/share/shaders/k3d_brick3.sl:42:        float jagged = 0.006, brickvary = 0.3;
k3d/share/shaders/k3d_brick3.sl:43:        float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brick3.sl:48:#define BMWIDTH (brickwidth+mortarthickness)
k3d/share/shaders/k3d_brick3.sl:49:#define BMHEIGHT (brickheight+mortarthickness)
k3d/share/shaders/k3d_brick3.sl:53:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
k3d/share/shaders/k3d_brick3.sl:55:  color bcolor, Ct;
k3d/share/shaders/k3d_brick3.sl:57:  float sbrick, tbrick, w, h;
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:68:  /* Make the shapes of the bricks vary just a bit */
k3d/share/shaders/k3d_brick3.sl:73:  ss = scoord / BMWIDTH;   /* Determine which brick the point is in */
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:88:  tt -= tbrick;
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: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:101:  /* Choose a brick color that varies from brick to brick */
k3d/share/shaders/k3d_brick3.sl:102:  bcolor = brickcolor * (1 + (brickvary * snoise (tbrick+(100*sbrick)+0.5)));
k3d/share/shaders/k3d_brick3.sl:104:  Ct = mix (mortarcolor, bcolor, w*h);
k3d/share/shaders/k3d_brick3.sl:107:  Ci = Os * Ct * (Ka * ambient() + Kd*diffuse(Nf));
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:4: * brickant.sl
k3d/share/shaders/k3d_brickanti.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickanti.sl:27:k3d_brickanti(
k3d/share/shaders/k3d_brickanti.sl:30:    uniform color Cbrick = color (0.5, 0.15, 0.14);
k3d/share/shaders/k3d_brickanti.sl:36:    float ss, tt, sbrick, tbrick, w, h;
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:56:    ss -= sbrick;
k3d/share/shaders/k3d_brickanti.sl:57:    tt -= tbrick;
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:76:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brickanti.sl:80:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_brickbump.sl:2: * brickbump.sl -- displacement shader for bricks.
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: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:14: *    brickheight               Height of a brick (in st space)
k3d/share/shaders/k3d_brickbump.sl:17: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brickbump.sl:19: *                                 the bricks.
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:29:displacement k3d_brickbump(
k3d/share/shaders/k3d_brickbump.sl:31:			   float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brickbump.sl:38:  float sbrick, tbrick;
k3d/share/shaders/k3d_brickbump.sl:41:  uniform float BMWIDTH = (brickwidth + mortarthickness);
k3d/share/shaders/k3d_brickbump.sl:42:  uniform float BMHEIGHT = (brickheight + mortarthickness);
k3d/share/shaders/k3d_brickbump.sl:46:  basicbrick(s, t, BMWIDTH, BMHEIGHT, 0.5, 0.2, 1, jagged, sbrick, tbrick, ss,
k3d/share/shaders/k3d_brickbump.sl:76:	((ss + sbrick) * pockfrequency / BMHEIGHT,
k3d/share/shaders/k3d_brickbump.sl:77:	 (tt + tbrick) * pockfrequency / BMWIDTH), 0.25);
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:4: * brickbum.sl
k3d/share/shaders/k3d_brickbump2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickbump2.sl:26:k3d_brickbump2(
k3d/share/shaders/k3d_brickbump2.sl:29:    uniform color Cbrick = color (0.5, 0.15, 0.14);
k3d/share/shaders/k3d_brickbump2.sl:35:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickbump2.sl:38:    float sbump, tbump, stbump;
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:49:    ss -= sbrick;
k3d/share/shaders/k3d_brickbump2.sl:50:    tt -= tbrick;
k3d/share/shaders/k3d_brickbump2.sl:54:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brickbump2.sl:56:    /* compute bump-mapping function for mortar grooves */
k3d/share/shaders/k3d_brickbump2.sl:57:    sbump = smoothstep(0,MWF,ss) - smoothstep(1-MWF,1,ss);
k3d/share/shaders/k3d_brickbump2.sl:58:    tbump = smoothstep(0,MHF,tt) - smoothstep(1-MHF,1,tt);
k3d/share/shaders/k3d_brickbump2.sl:59:    stbump = sbump * tbump;
k3d/share/shaders/k3d_brickbump2.sl:62:    Nf = calculatenormal(P + normalize(N) * stbump);
k3d/share/shaders/k3d_brickbump2.sl:67:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_brickbump3.sl:2: * brickbump.sl -- displacement shader for bricks.
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: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:14: *    brickheight               Height of a brick (in st space)
k3d/share/shaders/k3d_brickbump3.sl:17: *    jagged                    How much do bricks deviate from squares?
k3d/share/shaders/k3d_brickbump3.sl:19: *                                 the bricks.
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:27: *      12 Jan 1994 -- recoded by lg in correct shading language.
k3d/share/shaders/k3d_brickbump3.sl:29: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_brickbump3.sl:34:  You may note the companion shaders "brick" and "brickbump".
k3d/share/shaders/k3d_brickbump3.sl:36:  They're meant to go together, but I like to use the brickbump
k3d/share/shaders/k3d_brickbump3.sl: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:40:  ~gritz/brick.tif.
k3d/share/shaders/k3d_brickbump3.sl:44:  Displacement "brickbump" "brickwidth" 0.5 "brickheight" 0.25 
k3d/share/shaders/k3d_brickbump3.sl:50:k3d_brickbump3 ( 
k3d/share/shaders/k3d_brickbump3.sl:52:            float brickwidth = .25, brickheight = .08;
k3d/share/shaders/k3d_brickbump3.sl:58:#define BMWIDTH (brickwidth+mortarthickness)
k3d/share/shaders/k3d_brickbump3.sl:59:#define BMHEIGHT (brickheight+mortarthickness)
k3d/share/shaders/k3d_brickbump3.sl:63:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
k3d/share/shaders/k3d_brickbump3.sl:66:  float sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickbump3.sl:72:  /* Make the shapes of the bricks vary just a bit */
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:90:  tt -= tbrick;
k3d/share/shaders/k3d_brickbump3.sl:112:  disp -= fact * pow(noise ((ss+sbrick)*pockfrequency/BMHEIGHT,
k3d/share/shaders/k3d_brickbump3.sl:113:		            (tt+tbrick)*pockfrequency/BMWIDTH), 0.25);
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:4: * brickper.sl
k3d/share/shaders/k3d_brickperturb.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickperturb.sl:26:k3d_brickperturb(
k3d/share/shaders/k3d_brickperturb.sl:29:    uniform color Cbrick = color (0.5, 0.15, 0.14);
k3d/share/shaders/k3d_brickperturb.sl:35:    float ss, tt, sbrick, tbrick, w, h;
k3d/share/shaders/k3d_brickperturb.sl:46:    tbrick = floor(tt); /* which brick? */
k3d/share/shaders/k3d_brickperturb.sl:47:    ss += 0.1 * snoise(tbrick+0.5);
k3d/share/shaders/k3d_brickperturb.sl:48:    sbrick = floor(ss); /* which brick? */
k3d/share/shaders/k3d_brickperturb.sl:49:    ss -= sbrick;
k3d/share/shaders/k3d_brickperturb.sl:50:    tt -= tbrick;
k3d/share/shaders/k3d_brickperturb.sl:54:    Ct = mix(Cmortar, Cbrick, w*h);
k3d/share/shaders/k3d_brickperturb.sl:58:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_brushedmetal.sl:2: * brushedmetal.sl
k3d/share/shaders/k3d_brushedmetal.sl:15: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_brushedmetal.sl:20:surface k3d_brushedmetal(
k3d/share/shaders/k3d_brushedmetal2.sl:1:/*  IDbrushedmetal.sl written 9/99 by Ivan DeWolf
k3d/share/shaders/k3d_brushedmetal2.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_brushedmetal2.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_brushedmetal2.sl:6: *  yet another brushedmetal. This one computes a specular 
k3d/share/shaders/k3d_brushedmetal2.sl:9: *  based somewhat on LGbrushedmetal.sl
k3d/share/shaders/k3d_brushedmetal2.sl:18: *  Ka			- coefficient of ambient
k3d/share/shaders/k3d_brushedmetal2.sl:44:    color pixbrdf, C = 0;
k3d/share/shaders/k3d_brushedmetal2.sl:57:	    pixbrdf  = specularbrdf(LN, Nf,V,specspread);
k3d/share/shaders/k3d_brushedmetal2.sl:58:            C += Cl * pixbrdf * pow( 1-abs(VA.H), 1/specwidth );
k3d/share/shaders/k3d_brushedmetal2.sl:65:k3d_brushedmetal2(
k3d/share/shaders/k3d_brushedmetal2.sl:77:	point Po = transform("object",P);
k3d/share/shaders/k3d_brushedmetal2.sl:98:	      ev += environment(mapname, D)*(.5-abs((i/numsamples)-.5))*.25;
k3d/share/shaders/k3d_brushedmetal2.sl:104:	Ci = Oi * (Cs * (Ka * ambient() + Kd * diffuse(-Nf)) + 
k3d/share/shaders/k3d_brushedmetal3.sl:1:/* Renamed to LGbrushedmetal for RMR -- tal@SpamSucks_cs.caltech.edu */
k3d/share/shaders/k3d_brushedmetal3.sl:5: * The derivation and formulae can be found in:  Ward, Gregory J.
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:51:k3d_brushedmetal3 ( 
k3d/share/shaders/k3d_brushedmetal3.sl:54:		color basecolor = color (.5, .5, .5);
k3d/share/shaders/k3d_brushedmetal3.sl:62:    Ci = basecolor * (Ka*ambient() + Kd*diffuse(Nf) + Ks*spec);
k3d/share/shaders/k3d_bubbles.sl:2: * FEbubbles.sl
k3d/share/shaders/k3d_bubbles.sl:9:displacement k3d_bubbles(
k3d/share/shaders/k3d_bubbles.sl:10:	float radius = 0.5;   /* values between -0.5 and 0.5          */
k3d/share/shaders/k3d_bubbles.sl:12:	float frequency = 1; /* number of bubbles per linear surface */
k3d/share/shaders/k3d_bubbly.sl:1:/*  bubbly.sl written a while ago by Ivan DeWolf
k3d/share/shaders/k3d_bubbly.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_bubbly.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_bubbly.sl:6: *  basicly it's F1 squared as described in 
k3d/share/shaders/k3d_bubbly.sl:7: *  "a cellular texture basis function" by Steven Worley in the 
k3d/share/shaders/k3d_bubbly.sl:10: *  not as elegant, but hey, it works.
k3d/share/shaders/k3d_bubbly.sl:12: *  the "bubbles" are paraboloids diplaced along the normal. 
k3d/share/shaders/k3d_bubbly.sl:13: *  try lowering bubsize for pimples.
k3d/share/shaders/k3d_bubbly.sl:18: *  mult    - multiples of bubbles per unit
k3d/share/shaders/k3d_bubbly.sl:20: *            the bubbles. set this to zero for a perfect grid of bubbles.
k3d/share/shaders/k3d_bubbly.sl:23: *	      Displacement bounds and this value should be equal.
k3d/share/shaders/k3d_bubbly.sl:24: *  bubsize - basicly the radius of the bubbles. distance in rVu's.
k3d/share/shaders/k3d_bubbly.sl:28:k3d_bubbly(
k3d/share/shaders/k3d_bubbly.sl:32:         bubsize = 1)
k3d/share/shaders/k3d_bubbly.sl:35:  float a,b,c,bub;
k3d/share/shaders/k3d_bubbly.sl:37:  point Po = transform("object",P)*mult;
k3d/share/shaders/k3d_bubbly.sl:49:    for(b = -1; b<=1; b += 1){
k3d/share/shaders/k3d_bubbly.sl:51:	offset = vector(a,b,c);
k3d/share/shaders/k3d_bubbly.sl:59:  bub = clamp(shortest,0,bubsize)/bubsize; 
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:7: *   but in CA it's truly ubiquitous.
k3d/share/shaders/k3d_castucco.sl:10: *   freq - basic frequency of the texture
k3d/share/shaders/k3d_castucco.sl:29:  point Pshad;			/* Point to be shaded, in shader space */
k3d/share/shaders/k3d_castucco.sl:30:  float fwidth;			/* Estimated change in P between image samples */
k3d/share/shaders/k3d_causticlight.sl:8:	       float beamdistribution = 2;
k3d/share/shaders/k3d_causticlight.sl:11:	       float  blur = 0.01;
k3d/share/shaders/k3d_causticlight.sl:12:	       float  bias = 0.01;
k3d/share/shaders/k3d_causticlight.sl:21:	float atten = pow (cosangle, beamdistribution) / (L . L);
k3d/share/shaders/k3d_causticlight.sl:27:				    "blur", blur, "bias", bias);
k3d/share/shaders/k3d_celld.sl:20:				   between f2 and f1 is less then this value
k3d/share/shaders/k3d_celld.sl:22:	float voro_jitter = 0;  /* desc { Amount to perturb the voroni 
k3d/share/shaders/k3d_celld.sl:30:	point objP = transform (PSpace, P);
k3d/share/shaders/k3d_celld.sl:31:	point noiseP = (usePref != 0)? transform (PSpace, __Pref): objP;
k3d/share/shaders/k3d_celld.sl:48:	objP += Kvoro * voro_dist * Nn;
k3d/share/shaders/k3d_celld.sl:51:	P = transform (PSpace, "current", objP);
k3d/share/shaders/k3d_ceramic.sl:6:		    float Kr = 1, blur = 0, eta = 1.5;
k3d/share/shaders/k3d_ceramictiles.sl:4: * Description: Ceramic tiles (like you'd find in a bathroom)
k3d/share/shaders/k3d_ceramictiles.sl:8: *     establish a basic 2-D coordinate system for the pattern.
k3d/share/shaders/k3d_ceramictiles.sl:11: *   groovewidth, grooveheight - width of the spacing between tiles,
k3d/share/shaders/k3d_ceramictiles.sl:15: *   truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_ceramictiles.sl:18: *   Cbase, Cmottle - base color and mottle color of the tile
k3d/share/shaders/k3d_ceramictiles.sl:19: *   mottlefreq - frequency of the mottling between Cbase & Cmottle
k3d/share/shaders/k3d_ceramictiles.sl:31: *   Kdmortar - Kd for the mortar between tiles
k3d/share/shaders/k3d_ceramictiles.sl:32: *   mortarcolor - base color of the mortar
k3d/share/shaders/k3d_ceramictiles.sl:35: *   Kr, blur, eta - reflection parameters for the tile
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:87: * to a different color near the border of the tile (with a ragged edge
k3d/share/shaders/k3d_ceramictiles.sl:93:		  color Cbase, Cedge, Cmottle, Cspeck)
k3d/share/shaders/k3d_ceramictiles.sl:95:  color C = Cbase;
k3d/share/shaders/k3d_ceramictiles.sl:133:/* Compute the color of a ceramic object.  Like plastic, but use a
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:143:			   float roughness, specsharpness, Kr, blur, eta;
k3d/share/shaders/k3d_ceramictiles.sl:148:  color basecolor = mix(Cmortar, Ctile, intile);
k3d/share/shaders/k3d_ceramictiles.sl:157:  return fkt * basecolor * (Ka * ambient() + kd * diffuse(Nf)) +
k3d/share/shaders/k3d_ceramictiles.sl:159:			specsharpness) + SampleEnvironment(P, R, kr, blur,
k3d/share/shaders/k3d_ceramictiles.sl:167:			 float Kr = 1, blur = 0, eta = 1.5;
k3d/share/shaders/k3d_ceramictiles.sl:182:			 color Cbase = color(.05, .075, .6);
k3d/share/shaders/k3d_ceramictiles.sl:201:   * the (stile,ttile) coordinates (both on [0,1]) within our tile.
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:212:   * per-tile normal variation to break up reflections.
k3d/share/shaders/k3d_ceramictiles.sl:231:			    Cbase, Cedge, Cmottle, Cspeck);
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:236:   * scaling it by some high frequency fBm.
k3d/share/shaders/k3d_ceramictiles.sl:249:			 roughness, specsharpness, Kr, blur, eta, ENVPARAMS);
k3d/share/shaders/k3d_checkerboard.sl:3:surface k3d_checkerboard(float Ka = 1.0;
k3d/share/shaders/k3d_checkerboard.sl:50:    Os * (checkcolor * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_checkerboard_solid.sl:2:surface k3d_checkerboard_solid(
k3d/share/shaders/k3d_checkerboard_solid.sl:38:	Ci = Os * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_clamptoalpha.sl:2: * clamptoalpha.sl -- imager shader that forces Ci to be non-negative
k3d/share/shaders/k3d_clay.sl:8: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_cloudplane.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_cloudplane.sl:36:    xphase = 0.9; /* arbitrary */
k3d/share/shaders/k3d_cloudplane.sl:37:    yphase = 0.7; /* arbitrary */
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:10:** by Rob Engle and Jim Berney  
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:39:	/* point being shaded is outside the region of the depth map */  
k3d/share/shaders/k3d_contacshadow.sl:44:	   object as recorded in the shadow map */
k3d/share/shaders/k3d_contacshadow.sl:52:	/* the difference between the two distances is used to calculate the  
k3d/share/shaders/k3d_corktile.sl:1:/* Renamed to PQcorktile.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_corktile.sl:6: * Last Update: 16 October 2000
k3d/share/shaders/k3d_corktile.sl:11: * Ksgap - the specular component for tile gaps : by default 0.3 * Ks
k3d/share/shaders/k3d_corktile.sl:13: *   (if tiles=1) the number of tiles fitted into the texture as s and t vary from 0 to 1
k3d/share/shaders/k3d_corktile.sl:14: * tiles - the number of tiles in a unit square of texture before txtscale is applied
k3d/share/shaders/k3d_corktile.sl:15: *	 (this means the number of tiles actually seen is the square of txtscale * tiles)
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:19: * bumpheight - the total height for bump mapped bumps - irregularities on the surface plus
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:23: *   surface of the tile. So if tileheight = 1 there are no bumps on the tile surface, if
k3d/share/shaders/k3d_corktile.sl:24: *   tileheight = 0 there are bumps on the tile surface of height tileheight, but no difference
k3d/share/shaders/k3d_corktile.sl:25: *   in height between the gap and the tile itself
k3d/share/shaders/k3d_corktile.sl:27: * The shader makes an attempt at being self antaliasing
k3d/share/shaders/k3d_corktile.sl:38:bias (float b, x)
k3d/share/shaders/k3d_corktile.sl:40:	return pow(x, log(b)/log(0.5));
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:72:				g = bias(0.8,(g - .2) / .8);
k3d/share/shaders/k3d_corktile.sl:88:						float bumpheight = 0.3;
k3d/share/shaders/k3d_corktile.sl:90:						float bumpfreq = 0.8;)
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:107:	/* Calculate color of gap between tiles */
k3d/share/shaders/k3d_corktile.sl:113:	disp = (tileheight + fnoise(PP * txtscale * bumpfreq + 3, filtwidth * txtscale) * (1 - tileheight)) 
k3d/share/shaders/k3d_corktile.sl:114:		* bumpheight * (1 - adjust);
k3d/share/shaders/k3d_corktile.sl:119:	Ci = Os * (mix( Ct, Cg, ingap) * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_craters.sl:2: * JBUMcraters.sl -- Lunar-like surface - Jim Bumgardner jbum@jbum.com
k3d/share/shaders/k3d_craters.sl:4: * Voronoi/Worley noise is combined using 1/f scaling to put craters on a surface.
k3d/share/shaders/k3d_craters.sl:5: * Similar tricks can be used to make cork, swiss-cheese, bread, etc.
k3d/share/shaders/k3d_craters.sl: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:25:   /* but this can be avoided by looping i,j from -2 to 2 instead of -1 to 1 */
k3d/share/shaders/k3d_craters.sl:59:		  /* if ( fBm_default(xp) < pitfactor)  *//* I like this distribution better - pitf = -1 -> 1 */
k3d/share/shaders/k3d_craters.sl:94:	/* Seem crater perturbations for each scale */
k3d/share/shaders/k3d_crayon.sl:1:/* Renamed shader to PQCrayon for RMR -- talrmr@SpamSucks_pacbell.net */
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:14:	width - the width of the crayon strokes - this is scaled by txtscale
k3d/share/shaders/k3d_crayon.sl:16:		the stroke. By default they are about 15 times smaller
k3d/share/shaders/k3d_crayon.sl:19:		this should vary between 0 (no topcolor) to 1, .3 would give 30% topcolor;
k3d/share/shaders/k3d_crayon.sl:22:		graduation of shading from top to bottom of the object
k3d/share/shaders/k3d_crayon.sl:23:	color topcolor, basecolor - the color of the crayon strokes and the color of the ground
k3d/share/shaders/k3d_crayon.sl:51:#define filterwidth(x)  max (abs(Du(x)*du) + abs(Dv(x)*dv), MINFILTWIDTH)
k3d/share/shaders/k3d_crayon.sl:67:			color basecolor = 0;
k3d/share/shaders/k3d_crayon.sl:76:		process is described by Steven Worley in Ch 3 of "Texturing and Modelling a
k3d/share/shaders/k3d_crayon.sl:89:	Csurf = mix(basecolor, topcolor, m);
k3d/share/shaders/k3d_crayon.sl:91:    Ci = Os * ( Csurf * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_crayontoon.sl:2: * Abril 2002    <felipe@siggraph.org.mx>

k3d/share/shaders/k3d_crayontoon.sl:5: * hay que escoger con cuidado ambos colores para obtener

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

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

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

k3d/share/shaders/k3d_crayontoon.sl:15:                         colorSombra = color(1, .81, .37);

k3d/share/shaders/k3d_crayontoon.sl:25:  Ci = Os * (mix(colorBase, colorSombra, Kt1) + Kd * Kt1 * diffuse(Nf) * colorBase);

k3d/share/shaders/k3d_cyclone.sl:38:      /* Subtract out "eye" of storm */
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:7:// modify it under the terms of the GNU General Public
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:14:// General Public License for more details.
k3d/share/shaders/k3d_decalplastic.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_decalplastic.sl:49:	Ci = Oi * Ct * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, V, roughness);
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:21: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_dented.sl:41:			magnitude += abs(0.5 - noise(PP*size)) / size;
k3d/share/shaders/k3d_depthcue.sl:10:		    color background = 0;)
k3d/share/shaders/k3d_depthcue.sl:15:  Ci = mix(Ci, background, d);
k3d/share/shaders/k3d_depthcue_surf.sl:1:/* k3d_depthcue_surf inspired by depthcue_surf.sl by Pixar
k3d/share/shaders/k3d_depthcue_surf.sl:9:string debug="y";
k3d/share/shaders/k3d_depthcue_surf.sl:16:	if (debug=="y")
k3d/share/shaders/k3d_depthcue_surf.sl:18:			printf("<debug shadername='k3d_depthcue_surf' shadertype='surface'>%p\t%f\t%f\t%c</debug>\n", P, depth(P), d, Ci);
k3d/share/shaders/k3d_distant_shadow.sl:8:	float  blur=.01;
k3d/share/shaders/k3d_distant_shadow.sl:9:	float  bias=.01;
k3d/share/shaders/k3d_distant_shadow.sl:17:					"blur", blur, "bias", bias);
k3d/share/shaders/k3d_dturb.sl:1:/* dturb.sl
k3d/share/shaders/k3d_dturb.sl:3: * turbulence displacement
k3d/share/shaders/k3d_dturb.sl:8:displacement k3d_dturb(float Km = 0.1, freq = 10, flatness = 1)
k3d/share/shaders/k3d_dturb.sl:12:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_dturb.sl:14:  /* compute turbulence */
k3d/share/shaders/k3d_dturb.sl:21:  turb = 0;
k3d/share/shaders/k3d_dturb.sl:23:    turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:25:  turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:29:  magnitude = pow(turb, flatness);
k3d/share/shaders/k3d_ember.sl:1:/* Glowing ember shader 2002 Graeme Nattress & NOITAMINANIMATION Inc.
k3d/share/shaders/k3d_ember.sl:9: * baseSize = the basic diameter of the particle sphere before scaling
k3d/share/shaders/k3d_ember.sl:15:k3d_ember (	float baseSize = 2;
k3d/share/shaders/k3d_ember.sl:21:	point QQ = transform ("world", point "object" (0, 0, 0));
k3d/share/shaders/k3d_ember.sl:23:	float size = distance (PP, QQ) / baseSize;
k3d/share/shaders/k3d_ember.sl:40:	// basically, the standard specular function, but so that the highlight is
k3d/share/shaders/k3d_ember.sl:63:	//only back face shade...
k3d/share/shaders/k3d_emboss.sl:3:/* Listing 16.36  Displacement shader embossing a surface using a texture */
k3d/share/shaders/k3d_emboss.sl:6: * emboss(): emboss a pencil with lettering.  It uses the same texture
k3d/share/shaders/k3d_emboss.sl:10:k3d_emboss(	
k3d/share/shaders/k3d_eroded.sl:3:/* Listing 16.17  Surface shader eroding the surface of an object */
k3d/share/shaders/k3d_eroded.sl:19:	      W = transform ("object", P);
k3d/share/shaders/k3d_eroded.sl:25:		magnitude += 4.0 * abs (.5 - noise (W * size)) / size;
k3d/share/shaders/k3d_eroded.sl:36:	Ci = Oi * Cs * (Ka * ambient() + Ks * specular (Nf, V, roughness) );
k3d/share/shaders/k3d_eyeball.sl:2: * eyeball.sl -- RenderMan compatible shader for an eyeball.
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:8: *   part (eyeball), and blood vessels can be set individually.  Fractal
k3d/share/shaders/k3d_eyeball.sl:14: *   eyeballcolor - color of the white part of the eyeball
k3d/share/shaders/k3d_eyeball.sl:15: *   bloodcolor - color of the blood vessels
k3d/share/shaders/k3d_eyeball.sl:18: *   irissize - size of iris (in "t" space), must be larger than pupilsize
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:20: *   veinfreq, veinlevel - control the formation of the blood vessels
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:22: *           non-identical eyeballs.
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:32: *      Dec 1993 - "eye" modified by lg to clean up a bit.
k3d/share/shaders/k3d_eyeball.sl:33: *      10 Jan 1994 - recoded by lg in correct shading language.
k3d/share/shaders/k3d_eyeball.sl:35: *                       "eyeball"
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:46:k3d_eyeball (float Ka = .75, Kd = 0.75, Ks = 0.4, roughness = 0.1;
k3d/share/shaders/k3d_eyeball.sl:51:	 color eyeballcolor = color(1,1,1);
k3d/share/shaders/k3d_eyeball.sl:52:	 color bloodcolor = color(.8,.05,.05);
k3d/share/shaders/k3d_eyeball.sl:55:	 float bloodshot = 1.0;
k3d/share/shaders/k3d_eyeball.sl:65:  float i, turb, newturb, freq, f2;
k3d/share/shaders/k3d_eyeball.sl:67:  color Cball, Ciris;
k3d/share/shaders/k3d_eyeball.sl:69:  float bloody, tt;
k3d/share/shaders/k3d_eyeball.sl:74:  twidth = max (abs(Du(t)*du) + abs(Dv(t)*dv), MINFILTERWIDTH);
k3d/share/shaders/k3d_eyeball.sl:75:  PO = transform ("object", P) + index;
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:79:   * pupilstat: 0 inside the pupil/iris 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:85:  bloody = bloodshot * (smoothstep (-irissize, 2.5*irissize, 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:90:   * of turbulence functions.  Some stretching is done to get it to look
k3d/share/shaders/k3d_eyeball.sl:93:  if (irisstat * bloody > 0.001) {
k3d/share/shaders/k3d_eyeball.sl:94:      turb = bloody;  freq = veinfreq;
k3d/share/shaders/k3d_eyeball.sl:96:      for (i = 1;  (i <= veinlevel) && (turb > 0.1);  i += 1) {
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:103:      Cball = mix (eyeballcolor, bloodcolor, smoothstep(0,.75,displayed));
k3d/share/shaders/k3d_eyeball.sl:105:  else Cball = eyeballcolor;
k3d/share/shaders/k3d_eyeball.sl:109:   * just a stretched turbulence function.
k3d/share/shaders/k3d_eyeball.sl:112:      turb = 0;  freq = 1;  f2 = 30;
k3d/share/shaders/k3d_eyeball.sl:114:	  turb += snoise (PO*f2 + point(0,0,20*f2)) / freq;
k3d/share/shaders/k3d_eyeball.sl:117:      Ciris *= (1-clamp(turb/2,0,1));
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:123:  Ct = mix (Ciris, Cball, irisstat);
k3d/share/shaders/k3d_eyeball.sl:130:  /* Now shade like plastic, but using our calculated surface color and
k3d/share/shaders/k3d_eyeball.sl:135:  Ci = Os * ( Ct * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_ez.sl:3:Ci = abs(normalize(N).normalize(I));
k3d/share/shaders/k3d_fakesky.sl:4: * Shader a la const that slaps a fixed blue color up on the top half of a

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

k3d/share/shaders/k3d_fill.sl:1:/*IDfill written by Ivan DeWolf
k3d/share/shaders/k3d_fill.sl:13:	Ci = Cs * (Ka*ambient() + Kd*(smoothstep(min,max,comp(diffuse(Nf),0))));
k3d/share/shaders/k3d_fire.sl:3: * animated fire -- adpated from shader by Flip Phillips
k3d/share/shaders/k3d_fire.sl:13:  float width, cutoff, fade, f, turb, maxfreq = 16;
k3d/share/shaders/k3d_fire.sl:24:  /* compress ss & offset both by factor of current frame */
k3d/share/shaders/k3d_fire.sl:29:  /* compute turbulence */
k3d/share/shaders/k3d_fire.sl:34:  turb = 0;
k3d/share/shaders/k3d_fire.sl:36:    turb += abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_fire.sl:38:  turb += fade * abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_fire.sl:39:  turb *= 0.5;
k3d/share/shaders/k3d_fire.sl:41:  /* index into color spline using turbulence */
k3d/share/shaders/k3d_fire.sl:43:  flame = clamp(t - turb, 0, 1);
k3d/share/shaders/k3d_fire.sl:46:  surface_color = blend(surface_color, layer_color, layer_opac);
k3d/share/shaders/k3d_flame.sl:2: * flame.sl -- RenderMan compatible surface shader for a flame-like texture.
k3d/share/shaders/k3d_flame.sl:13: *    None, but should be easy to add antialiasing simply by adaptively
k3d/share/shaders/k3d_flame.sl:14: *    setting the "octaves" parameter based on distance from eye point.
k3d/share/shaders/k3d_flame.sl:17: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_flame.sl:18: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_flame.sl:21: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_flame.sl:26: *    ??? - original C language version by Ken Musgrave
k3d/share/shaders/k3d_flame.sl:27: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_flame.sl:56:  chaos = abs(chaosscale * chaos + chaosoffset);
k3d/share/shaders/k3d_fog.sl:9:volume k3d_fog(float distance = 1; color background = 0;)
k3d/share/shaders/k3d_fog.sl:12:  Ci = mix(Ci, background, d);
k3d/share/shaders/k3d_fractal.sl:3: *    Conversion to Shading Language and minor modifications by Fredrik Brnnbacka.

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

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

k3d/share/shaders/k3d_fractal.sl:47:          		/* get absolute value of signal*/

k3d/share/shaders/k3d_fractal.sl:48:          		signal = abs(signal);

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

k3d/share/shaders/k3d_fresnelplastic.sl:28:			 not over-written by "colorMap } */
k3d/share/shaders/k3d_fresnelplastic.sl:45:   /* cat Reflection desc {Percentage amount to blur map} */
k3d/share/shaders/k3d_fresnelplastic.sl:49:   /* cat Reflection desc {The size of the room to base the reflection
k3d/share/shaders/k3d_fresnelplastic.sl:93:    /* base color */
k3d/share/shaders/k3d_fresnelplastic.sl:109:    Ci = Os * ( fKt * Ct * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_funkyglass.sl:1:/* funkyglass.sl - randomly colored "glass" (transparent, but no refl/refr).
k3d/share/shaders/k3d_funkyglass.sl:24:  Oi = Ot * (0.75 - 0.5 * abs(V.Nf));
k3d/share/shaders/k3d_funkyglass.sl:26:    (Ct * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_fur1.sl:3: *   - Simple algorithm: checkerboard

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:9:   by Clint Hanson and Armin Bruderlin
k3d/share/shaders/k3d_fur2.sl:59:	 color static_ambient  = color (0.057,0.057,0.057);
k3d/share/shaders/k3d_fur2.sl:61:	 /* Variables Passed from the rib... */
k3d/share/shaders/k3d_fur2.sl:79:    float  l = clamp(nSN.T,0,1);  /* Dot of surface_normal and T, used for blending */
k3d/share/shaders/k3d_fur2.sl:95:       surface, use the hair normal Otherwise, blend between the two
k3d/share/shaders/k3d_fur2.sl:128:                                    abs(clamp(nL.normalize(-1*clump_vect), -1, 0)));
k3d/share/shaders/k3d_fur2.sl:149:				  abs(luminance(Kd*Cdiff))) * darkening));
k3d/share/shaders/k3d_fur2.sl:153:    Ci =  ((Ka*ambient() + Kd*Cdiff + static_ambient) * final_c
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:22: * Author: Larry Gritz, 1999  (lg@bmrt.org)
k3d/share/shaders/k3d_glass.sl:26: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_glass.sl:37:		  float Kr = 1, reflblur = 0;
k3d/share/shaders/k3d_glass.sl:39:		  float Kt = 1, refrblur = 0, eta = 1.5;
k3d/share/shaders/k3d_glass.sl:45:    MaterialGlass(Nf, Cs, Ka, Kd, Ks, roughness, Kr, reflblur, Kt, refrblur,
k3d/share/shaders/k3d_gloop.sl:1:/*  IDGloop.sl written 8/99 by Ivan DeWolf
k3d/share/shaders/k3d_gloop.sl:3: *  ivan@SpamSucks_martian-labs.com
k3d/share/shaders/k3d_gloop.sl:13: *        have to change your displacement bounds to fit
k3d/share/shaders/k3d_gloop.sl:16: * magnitude - how far to displace. probably fine set where it is.
k3d/share/shaders/k3d_gloop.sl:18: * displacement bounds can be computed with the following 
k3d/share/shaders/k3d_gloop.sl:31:  point  Psh = transform("object",P)*freq;
k3d/share/shaders/k3d_gloop.sl:34:  vector dPduN = normalize(vtransform("object",dPdu));
k3d/share/shaders/k3d_gloop.sl:35:  vector dPdvN = normalize(vtransform("object",dPdv));
k3d/share/shaders/k3d_gloop.sl:56:    P -= vtransform("object","current",step)*nz*stepsize;
k3d/share/shaders/k3d_glow.sl:14:      // Calculate a "strength" function based on incidence
k3d/share/shaders/k3d_gmarbtile_polish.sl:2: * gmarbtile_polish.sl -- polished green marble tiles
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:12: *   darkcolor, lightcolor - colors of the underlying substrate
k3d/share/shaders/k3d_gmarbtile_polish.sl:13: *   veincolor - color of the bright veins
k3d/share/shaders/k3d_gmarbtile_polish.sl:16: *   groovecolor - the color of the grooves between the tiles.
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:28:surface k3d_gmarbtile_polish(float Ka = 0.5, Kd = 0.4, Ks = 0.2;
k3d/share/shaders/k3d_gmarbtile_polish.sl:43:			     float blur = 0;
k3d/share/shaders/k3d_gmarbtile_polish.sl:49:  float turbsum, turb;
k3d/share/shaders/k3d_gmarbtile_polish.sl:68:   * First calculate the underlying color of the substrate
k3d/share/shaders/k3d_gmarbtile_polish.sl:70:  turb = 0.5 * turbulence(PP, dPP, 5, 2, 0.5);
k3d/share/shaders/k3d_gmarbtile_polish.sl:71:  Ct = mix(darkcolor, lightcolor, smoothstep(0.1, .35, turb));
k3d/share/shaders/k3d_gmarbtile_polish.sl:77:  /* perturb the lookup */
k3d/share/shaders/k3d_gmarbtile_polish.sl:81:  turbsum = 0;
k3d/share/shaders/k3d_gmarbtile_polish.sl:87:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
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:89:      turbsum += (1 - turbsum) * turb;
k3d/share/shaders/k3d_gmarbtile_polish.sl:92:  turbsum *=
k3d/share/shaders/k3d_gmarbtile_polish.sl:96:  Ct = mix(Ct, veincolor, turbsum);
k3d/share/shaders/k3d_gmarbtile_polish.sl:104:  env += SampleEnvironment(P, reflect(V, Nf), Kr, blur, ENVPARAMS);
k3d/share/shaders/k3d_gmarbtile_polish.sl:108:  Ci = Oi * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) + env);
k3d/share/shaders/k3d_gooch.sl:6: * DESCRIPTION   : This model is described in "A Non-Photorealistc
k3d/share/shaders/k3d_gooch.sl:9: *                 http://www.cs.utah.edu/~gooch/SIG98/abstract.html
k3d/share/shaders/k3d_gooch.sl:12: *  Ka           : ambient factor
k3d/share/shaders/k3d_gooch.sl:16: *  beta         : Gooch warm color factor
k3d/share/shaders/k3d_gooch.sl:17: *  b            : used to construct the cool color
k3d/share/shaders/k3d_gooch.sl:22: * AUTHOR: written by Mike King
k3d/share/shaders/k3d_gooch.sl:31:         float beta = .5;
k3d/share/shaders/k3d_gooch.sl:32:         float b = .55;
k3d/share/shaders/k3d_gooch.sl:38:    color blue = color(0,0,b);
k3d/share/shaders/k3d_gooch.sl:42:    float ldotn, blendval;
k3d/share/shaders/k3d_gooch.sl:45:    kcool = blue + ( Cs * alpha);
k3d/share/shaders/k3d_gooch.sl:46:    kwarm = yellow + (Cs * beta);
k3d/share/shaders/k3d_gooch.sl:49:        blendval = 0.5*(1+ldotn);
k3d/share/shaders/k3d_gooch.sl:50:        Cgooch += mix(kcool,kwarm,blendval); 
k3d/share/shaders/k3d_gooch.sl:54:    Ci = Os * ((Ka*ambient() + 
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:14:	float	y = ycomp(transform("object",P));	/* convert to object space	 */
k3d/share/shaders/k3d_gouge.sl:18:    *  determines the size of the gouge. Multiply by the Km factor, then 
k3d/share/shaders/k3d_gouge.sl:19:    *  displace the surface point inwards by that amount. 
k3d/share/shaders/k3d_granite.sl:17:		sum = sum + abs(.5 - noise( 4 * freq * I))/freq ;
k3d/share/shaders/k3d_graphic_lines.sl:17:        float brightness_highlight=0.5;
k3d/share/shaders/k3d_graphic_lines.sl:40:        float brightness_paint=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:63:        float brightness_ink=0.5;
k3d/share/shaders/k3d_graphic_lines.sl:128:	illumcolor_highlight=(Ka_highlight*ambient()+Kd_highlight*diffuse(Nf_highlight)+Ks_highlight*specular(Nf_highlight,V_highlight,roughness_highlight));
k3d/share/shaders/k3d_graphic_lines.sl:137:	illumination_highlight=(illumination_highlight*contrast_highlight)+(1.0-contrast_highlight)/2.0+(brightness_highlight-1.0)+n_highlight*randomness_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:203:	}illumcolor_paint=(Ka_paint*ambient()+Kd_paint*diffuse(Nf_paint)+Ks_paint*specular(Nf_paint,V_paint,roughness_paint));
k3d/share/shaders/k3d_graphic_lines.sl:211:	illumination_paint=(illumination_paint*contrast_paint)+(1.0-contrast_paint)/2.0+(brightness_paint-1.0)+n_paint*randomness_paint;
k3d/share/shaders/k3d_graphic_lines.sl:275:	}illumcolor_ink=(Ka_ink*ambient()+Kd_ink*diffuse(Nf_ink)+Ks_ink*specular(Nf_ink,V_ink,roughness_ink));
k3d/share/shaders/k3d_graphic_lines.sl:283:	illumination_ink=(illumination_ink*contrast_ink)+(1.0-contrast_ink)/2.0+(brightness_ink-1.0)+n_ink*randomness_ink;
k3d/share/shaders/k3d_graphic_lines.sl:308:	/** blend 3 layers **/
k3d/share/shaders/k3d_graphic_lines.sl:310:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_graphic_lines.sl:311:#define union(a,b) ((a) + (b) - (a) * (b))
k3d/share/shaders/k3d_graphic_lines.sl:337:	/* background layer  */
k3d/share/shaders/k3d_graphic_lines.sl:343:	/* only care about percentage illumination */
k3d/share/shaders/k3d_graphic_lines.sl:355:	layer_color = Cs*(Kd*diff*Ci_paint + Ka*ambient()) + Ci_highlight*Ks*spec;
k3d/share/shaders/k3d_graphic_lines.sl:358:	gline_color = blend(gline_color, layer_color, layer_opac);
k3d/share/shaders/k3d_graphic_lines.sl:366:	layer_opac = 1 - smoothstep(ink_thresh - ink_fuzz/2, ink_thresh + ink_fuzz/2, abs(cos_here));
k3d/share/shaders/k3d_graphic_lines.sl:368:	if (abs(cos_here) < ink_thresh)
k3d/share/shaders/k3d_graphic_lines.sl:373:	gline_color = blend(gline_color, layer_color, layer_opac);
k3d/share/shaders/k3d_grass_displace.sl:7: * This is simply uses the noise function and a checkerboard

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

k3d/share/shaders/k3d_grass_displace.sl:40:      x = abs(x - 2.5);

k3d/share/shaders/k3d_grass_displace.sl:41:      y = abs(y - 2.5);

k3d/share/shaders/k3d_grass_displace.sl:52:      x = abs(x - 2.5);

k3d/share/shaders/k3d_grass_displace.sl:53:      y = abs(y - 2.5);

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

k3d/share/shaders/k3d_grass_surface.sl:37:      Ci = blend(color1, color2, layer_opac);

k3d/share/shaders/k3d_grass_surface.sl:46:  Ci = Ci * (Ka *ambient() + Kd * diffuse(Nf) + Ks* specular(Nf,-I,roughness));

k3d/share/shaders/k3d_greenmarble.sl:2: * greenmarble.sl -- RenderMan compatible shader for green veined marble.
k3d/share/shaders/k3d_greenmarble.sl:5: *   Makes a marble-like surface using a turbulence function.
k3d/share/shaders/k3d_greenmarble.sl:10: *   darkcolor, lightcolor - colors of the underlying substrate
k3d/share/shaders/k3d_greenmarble.sl:11: *   veincolor - color of the bright veins
k3d/share/shaders/k3d_greenmarble.sl:25:surface k3d_greenmarble(float Ka = 0.1, Kd = 0.6, Ks = 0.4, roughness = 0.1;
k3d/share/shaders/k3d_greenmarble.sl:36:  float turbsum, turb, i;
k3d/share/shaders/k3d_greenmarble.sl:42:   * First calculate the underlying color of the substrate
k3d/share/shaders/k3d_greenmarble.sl:43:   *    Use turbulence - use frequency clamping
k3d/share/shaders/k3d_greenmarble.sl:45:  turb = 0.5 * turbulence(PP, dPP, 5, 2, 0.5);
k3d/share/shaders/k3d_greenmarble.sl:46:  Ct = mix(darkcolor, lightcolor, smoothstep(0.1, .35, turb));
k3d/share/shaders/k3d_greenmarble.sl:52:  /* perturb the lookup */
k3d/share/shaders/k3d_greenmarble.sl:56:  turbsum = 0;
k3d/share/shaders/k3d_greenmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_greenmarble.sl:62:      turb = pow(smoothstep(0.8, 1, 1 - turb), sharpness) / freq;
k3d/share/shaders/k3d_greenmarble.sl:63:      turbsum += (1 - turbsum) * turb;
k3d/share/shaders/k3d_greenmarble.sl:66:  turbsum *=
k3d/share/shaders/k3d_greenmarble.sl:69:  Ct = mix(Ct, veincolor, turbsum);
k3d/share/shaders/k3d_grids.sl:5:float K_ambient=0.993; 
k3d/share/shaders/k3d_grids.sl:10:color ambientcolor=color(0.5,0.5,0.5); 
k3d/share/shaders/k3d_grids.sl:48:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_grids.sl:50:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_grids.sl:57:float blend_val=0.5; 
k3d/share/shaders/k3d_grids.sl:66:color G1L1_Ct = blend(G1L1_SurfaceColor, G1L1_GridColor, G1L1_layer_opac);
k3d/share/shaders/k3d_grids.sl:74:color G1L2_Ct = blend(G1L2_SurfaceColor, G1L2_GridColor, G1L2_layer_opac);
k3d/share/shaders/k3d_grids.sl:85:color G2L1_Ct = blend(G2L1_SurfaceColor, G2L1_GridColor, G2L1_layer_opac);
k3d/share/shaders/k3d_grids.sl:93:color G2L2_Ct = blend(G2L2_SurfaceColor, G2L2_GridColor, G2L2_layer_opac);
k3d/share/shaders/k3d_grids.sl:97:Ci = (blend_val*G1L1_Ct+(1-blend_val)*G1L2_Ct) * (ambientcolor * K_ambient * ambient() + K_diffuse * diffuse(G1_Nf)) + 
k3d/share/shaders/k3d_grids.sl:99:Oi = (blend_val*G2L1_Ct+(1-blend_val)*G2L2_Ct);
k3d/share/shaders/k3d_grids_disp.sl:27:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_grids_disp.sl:29:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_grids_disp.sl:38:color Ct0 = blend(SurfaceColor, GridColor, layer_opac0);
k3d/share/shaders/k3d_grids_disp.sl:40:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_grids_disp.sl:42:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_grids_disp.sl:51:color Ct1 = blend(SurfaceColor, GridColor, layer_opac1);
k3d/share/shaders/k3d_hair.sl:21:			cosang = cos (abs (acos (T.normalize(L)) - acos (-T.V)));
k3d/share/shaders/k3d_hair.sl:25:			/* We multipled by v to make it darker at the roots.  This assumes v=0 at the root, v=1 at the tip.  */
k3d/share/shaders/k3d_hair.sl:29:	Ci = Oi * (mix(rootcolor, tipcolor, v) * (Ka*ambient() + Kd * Cdiff) + (Ks * Cspec * specularcolor));
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:5:*Created by Simon Bunker 27th September 2001

k3d/share/shaders/k3d_hdr_light.sl:8:*This shader is made freely available under the proviso that this copyright

k3d/share/shaders/k3d_hdr_light.sl:10:*post links back to the above address*or get in contact if you have any queries

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

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

k3d/share/shaders/k3d_hdr_light.sl:33:		hdrtex = texture(envname,ss,tt,"blur",blur);

k3d/share/shaders/k3d_hdr_light.sl:45:	string mappingtype = "probe";

k3d/share/shaders/k3d_hdr_light.sl:47:	float blur = 0.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:56:/* Code based off of Larry Gritz's Uberlight Shader */

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:72:			printf("Please select mapping type probe,environment or planar");

k3d/share/shaders/k3d_hdr_light.sl:75:		if (mappingtype == "probe"){

k3d/share/shaders/k3d_hdr_light.sl:77:				Ct = hdrenv(envname,R,blur);

k3d/share/shaders/k3d_hdr_light.sl:82:				Ct = environment(envname,R,"blur",blur);

k3d/share/shaders/k3d_hdr_light.sl:87:				Ct = texture(envname,s,t,"blur",blur);

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:5:*Created by Simon Bunker 27th September 2001

k3d/share/shaders/k3d_hdr_surface.sl:8:*This shader is made freely available under the proviso that this copyright

k3d/share/shaders/k3d_hdr_surface.sl:10:*post links back to the above address*or get in contact if you have any queries

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

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

k3d/share/shaders/k3d_hdr_surface.sl:32:		hdrtex = texture(envname,ss,tt,"blur",blur);

k3d/share/shaders/k3d_hdr_surface.sl:44:	string mappingtype = "probe";

k3d/share/shaders/k3d_hdr_surface.sl:46:	float blur = 0.0;

k3d/share/shaders/k3d_hdr_surface.sl:54:	if (mappingtype == "probe"){

k3d/share/shaders/k3d_hdr_surface.sl:56:			Ct = hdrenv(envname,R,blur);

k3d/share/shaders/k3d_hdr_surface.sl:61:			Ct = environment(envname,R,"blur",blur);

k3d/share/shaders/k3d_hdr_surface.sl:66:			Ct = texture(envname,s,t,"blur",blur);

k3d/share/shaders/k3d_hdri1.sl:5:	    Cl = environment (envname, -L, "blur", 0.5);
k3d/share/shaders/k3d_hdri2.sl:6:       float envblur = 0.5;
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:15:	    Cl = environment (envname, Lenv, "blur", envblur);
k3d/share/shaders/k3d_hdri2.sl:19:				    "blur", shadowblur, "bias", shadowbias);
k3d/share/shaders/k3d_hexatile_bump.sl:2:* FGHexaTile_bump.sl -- "Simple shader to do "Hexagon" displacement"
k3d/share/shaders/k3d_hexatile_bump.sl:5:* A simple bump shader that tile a "Hexagon" pattern
k3d/share/shaders/k3d_hexatile_bump.sl:9:* 	string Name 	= "FGHexaTile_bump"	---	Name of the shader "do nothing".
k3d/share/shaders/k3d_hexatile_bump.sl:57:if ((hexagon != 0) && abs(mod(stestcell, 2)) < 1)
k3d/share/shaders/k3d_hexatile_bump.sl:78:displacement k3d_hexatile_bump (
k3d/share/shaders/k3d_hexatile_bump.sl:79:	string Name 	= "FGHexaTile_bump";
k3d/share/shaders/k3d_hexatile_bump.sl:120:/*** ----- True Displacement and bump ----- ***/
k3d/share/shaders/k3d_hextile.sl:6: *    hexagonal tiles, similar to that found as floor patterns in public
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:18: *    mortarcolor - the color of the mortar (space between the tiles)
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:36: * last modified 15 Feb 94 by Larry Gritz
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:96:      x = tilewidth/2 - abs (ss - tilewidth/2);
k3d/share/shaders/k3d_hextile.sl:121:  Ci = Os * ( Ct * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_imagelayerclouds.sl:8:			     float octaves = 8, omega = 0.5, lambda = 2;
k3d/share/shaders/k3d_imagelayerclouds.sl:20:/*  value = fBm (PP, omega, lambda, octaves); */
k3d/share/shaders/k3d_imagelayerclouds.sl:35:  /* Shade like matte, but use color Ct */
k3d/share/shaders/k3d_incandplastic.sl:8: * incandescence value like the blinn shader.

k3d/share/shaders/k3d_incandplastic.sl:25:  Ci = SurfaceOpacity * (SurfaceColor * (Ka * ambient() + Kd * diffuse(Nf)) +

k3d/share/shaders/k3d_indirect.sl:4: * is built into the renderer.
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:21:	float Ka = 1;             /* Ambient light coeff.          */

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

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

k3d/share/shaders/k3d_leather.sl:30:	/*BLOTCH sont les zebrure*/

k3d/share/shaders/k3d_leather.sl:32:	float BLOTCH_TCF = 5;		/*zebrure sur la peau*/

k3d/share/shaders/k3d_leather.sl:36:	float txtscale = .05;     	/* Ugly kludge (see above...)    */

k3d/share/shaders/k3d_leather.sl:43:	 * Shader variables

k3d/share/shaders/k3d_leather.sl:47:	float base_turb, blotch_turb, disp_turb;

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

k3d/share/shaders/k3d_leather.sl:49:	color cs, small_speckle, base_color, reflect;

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

k3d/share/shaders/k3d_leather.sl:65:	 * The base color consists of patches of pure green,

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

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

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

k3d/share/shaders/k3d_leather.sl:86:	                  BASE_TF*t + label);

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

k3d/share/shaders/k3d_leather.sl:92:		base_turb = 0;

k3d/share/shaders/k3d_leather.sl:94:		base_turb *= (t-T1)/(T2-T1);

k3d/share/shaders/k3d_leather.sl:96:		base_turb *= (T4-t)/(T4-T3);

k3d/share/shaders/k3d_leather.sl:98:		base_turb = 0;

k3d/share/shaders/k3d_leather.sl:99:	base_color = spline(base_turb, green, green,

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

k3d/share/shaders/k3d_leather.sl:107:	 * The blotch color is finally determined by mixing,

k3d/share/shaders/k3d_leather.sl:108:	 * using the blotching coefficient "blotch". This

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

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

k3d/share/shaders/k3d_leather.sl:114:	/*#define BLOTCH_TCF         0     zebrure                */

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

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

k3d/share/shaders/k3d_leather.sl:118:	                    BLOTCH_TF*t + label) + BLOTCH_DELTA;

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:121:	blotch = blotch * (1+small_noise) +

k3d/share/shaders/k3d_leather.sl:123:	if (blotch > 1) blotch = 1;

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: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:148:	blackness = 1-(smoothstep(BEDGE, BEDGE+BWIDTH, t)*

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

k3d/share/shaders/k3d_leather.sl:156:	cs = mix(base_color, dred, blotch);

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

k3d/share/shaders/k3d_leather.sl:158:	cs = mix(cs, black, blackness);

k3d/share/shaders/k3d_leather.sl:165:	 * highlights. We'd like them perturbed by the small

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

k3d/share/shaders/k3d_leather.sl:167:	 * also dented a bit (alas, no real apples are perfectly

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

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

k3d/share/shaders/k3d_leather.sl:188:	 * in the surface of an apple. They don't add much, but

k3d/share/shaders/k3d_leather.sl:189:	 * may be needed for the 'perfect' apple :-).

k3d/share/shaders/k3d_leather.sl:192:	 * for this bit!

k3d/share/shaders/k3d_leather.sl:207:	 * Combine everything to get Ci, in the standard form.

k3d/share/shaders/k3d_leather.sl:210:	Ci = Os * (cs * (Ka*ambient() + Kd*diffuse(Nf)) +

k3d/share/shaders/k3d_lensflare.sl:7: *   a bright light source, resulting in interreflections within the
k3d/share/shaders/k3d_lensflare.sl:10: *   liberties but looks pretty good.
k3d/share/shaders/k3d_lensflare.sl:14: *   bloomintensity - overall intensity of the "bloom" effect.  Setting
k3d/share/shaders/k3d_lensflare.sl:15: *          this to 0 removes the bloom effect altogether.
k3d/share/shaders/k3d_lensflare.sl:16: *   bloomradius, bloomfalloff - control the size & shape of the bloom
k3d/share/shaders/k3d_lensflare.sl:17: *   bloomstarry, bloomnpoints - control the "starry" appearance of the 
k3d/share/shaders/k3d_lensflare.sl:18: *          bloom effect (bloomstarry=0 means perfectly round bloom)
k3d/share/shaders/k3d_lensflare.sl:19: *   starburstintensity - overall intensity of starburst effect (0=none)
k3d/share/shaders/k3d_lensflare.sl:20: *   starburstradius, starburstnpoints, starburstfalloff - control the
k3d/share/shaders/k3d_lensflare.sl:21: *          size and shape of the starburst effect
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:24: *   nspots - number of "spots" splayed out on the axis joining the
k3d/share/shaders/k3d_lensflare.sl:26: *   disky, ringy, blotty, bloony - give the relative proportions of
k3d/share/shaders/k3d_lensflare.sl:30: *   seed - random number seed for many of the computations
k3d/share/shaders/k3d_lensflare.sl:70:rainbow(float x, dx)
k3d/share/shaders/k3d_lensflare.sl:85:		      float bloomintensity = 1;
k3d/share/shaders/k3d_lensflare.sl:86:		      float bloomradius = 0.5;
k3d/share/shaders/k3d_lensflare.sl:87:		      float bloomstarry = 0.75;
k3d/share/shaders/k3d_lensflare.sl:88:		      float bloomnpoints = 25;
k3d/share/shaders/k3d_lensflare.sl:89:		      float bloomfalloff = 8;
k3d/share/shaders/k3d_lensflare.sl:90:		      float starburstintensity = 0.075;
k3d/share/shaders/k3d_lensflare.sl:91:		      float starburstradius = 0.5;
k3d/share/shaders/k3d_lensflare.sl:92:		      float starburstnpoints = 100;
k3d/share/shaders/k3d_lensflare.sl:93:		      float starburstfalloff = 3;
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:97:		      float blotty = 1;
k3d/share/shaders/k3d_lensflare.sl:98:		      float bloony = 1; float spotintensity = 0.08;
k3d/share/shaders/k3d_lensflare.sl:114:  uniform float aspect = abs(aspectratio());
k3d/share/shaders/k3d_lensflare.sl:124:    atten = 1 - smoothstep(1, 2, abs(atten) / (lensfov / 2));
k3d/share/shaders/k3d_lensflare.sl:126:    float brightness =
k3d/share/shaders/k3d_lensflare.sl:140:     * the bloom, a small red ring flare, and the triple starburst.
k3d/share/shaders/k3d_lensflare.sl:144:    if(bloomintensity > 0)
k3d/share/shaders/k3d_lensflare.sl:146:	float radius = sqrt(brightness) * 5 * mix(.2, bloomradius, urand());
k3d/share/shaders/k3d_lensflare.sl:147:	float bloom = pnoise(bloomnpoints * angle / (2 * PI), bloomnpoints);
k3d/share/shaders/k3d_lensflare.sl:148:	bloom = mix(0.5, bloom, bloomstarry);
k3d/share/shaders/k3d_lensflare.sl:149:	bloom = mix(1, bloom, smoothstep(0, 0.5, dist / radius));
k3d/share/shaders/k3d_lensflare.sl:150:	bloom = pow(1 - smoothstep(0.0, radius * bloom, dist), bloomfalloff);
k3d/share/shaders/k3d_lensflare.sl:151:	Cflare += bloom * (bloomintensity / intensity) / brightness;
k3d/share/shaders/k3d_lensflare.sl:154:    /* Starburst */
k3d/share/shaders/k3d_lensflare.sl:155:    if(starburstintensity > 0)
k3d/share/shaders/k3d_lensflare.sl:158:	  sqrt(brightness) * 5 * mix(.2, starburstradius, urand());
k3d/share/shaders/k3d_lensflare.sl:159:	float star = float pnoise(starburstnpoints * angle / (2 * PI),
k3d/share/shaders/k3d_lensflare.sl:160:				  starburstnpoints);
k3d/share/shaders/k3d_lensflare.sl:162:	  pow(1 - smoothstep(0.0, radius * star, dist), starburstfalloff);
k3d/share/shaders/k3d_lensflare.sl:163:	Cflare += star * (starburstintensity / intensity) / brightness;
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:190:	float bright = 1 - (2 * radius);
k3d/share/shaders/k3d_lensflare.sl:191:	bright *= bright;
k3d/share/shaders/k3d_lensflare.sl:193:	uniform float alltypes = (disky + ringy + blotty + bloony);
k3d/share/shaders/k3d_lensflare.sl:208:	else if(type < (disky + ringy + blotty))
k3d/share/shaders/k3d_lensflare.sl:220:	Cflare += spotintensity * bright * clr * Cs * int;
k3d/share/shaders/k3d_luna.sl:6: *    have craters, so it isn't good for closeups.  But it's pretty good at about
k3d/share/shaders/k3d_luna.sl:10: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_luna.sl:11: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_luna.sl:14: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_luna.sl:19: *    ??? - original C language version by Ken Musgrave
k3d/share/shaders/k3d_luna.sl:20: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_luna.sl:38:		 float maria_basecolor = .7, maria_color = .1;
k3d/share/shaders/k3d_luna.sl:67:  /* bumpy = fBm (PP, omega, lacunarity, octaves); */
k3d/share/shaders/k3d_luna.sl:94:      Ct *= maria_basecolor + maria_color * chaos;
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:17: *   urepeats, vrepeats - number of repeats of the grid pattern in u and v
k3d/share/shaders/k3d_lunette.sl:19: *   colorA, colorB - colors used in the background fBm noise
k3d/share/shaders/k3d_lunette.sl:20: *   baselinecolor - base color of the grid lines
k3d/share/shaders/k3d_lunette.sl:29: *   noise functions and an box-filter antialiased grid function.
k3d/share/shaders/k3d_lunette.sl:31: * Author: written by Jonathan Merritt (jmerritt@warpax.com), 5th October 2002
k3d/share/shaders/k3d_lunette.sl:33: * License: This shader is distributed under the GNU General Public License.
k3d/share/shaders/k3d_lunette.sl:48: *   ssrepeats, ttrepeats - Number of repeats of the grid pattern in both ss
k3d/share/shaders/k3d_lunette.sl:49: *                           and tt directions.  Also scales the noise in both
k3d/share/shaders/k3d_lunette.sl:54: *   colorA, colorB - Two colors for the background pattern.
k3d/share/shaders/k3d_lunette.sl:55: *   noiseScale - Scale of the background fBm noise (relative to the size of
k3d/share/shaders/k3d_lunette.sl:57: *                noise; decreasing it makes a broader noise.
k3d/share/shaders/k3d_lunette.sl:59: *   maxOctaves - Maximum number of octaves for the fBm noise.
k3d/share/shaders/k3d_lunette.sl:62: *   colorBenhance - After the noise has been calculated, there exists the
k3d/share/shaders/k3d_lunette.sl:63: *                   possibility to increase the amount of colorB present in
k3d/share/shaders/k3d_lunette.sl:69: *   baselinecolor - Base color of the grid lines.
k3d/share/shaders/k3d_lunette.sl:74:	float ssrepeats;	/* number of repeats in the ss direction */
k3d/share/shaders/k3d_lunette.sl:75:	float ttrepeats;	/* number of repeats in the tt direction */
k3d/share/shaders/k3d_lunette.sl:82:	uniform float maxOctaves;	/* maximum number of octives for the noise */
k3d/share/shaders/k3d_lunette.sl:87:	color baselinecolor;	/* base color for the lines */
k3d/share/shaders/k3d_lunette.sl:91:	 * Calculate pulsegrid, which is a variable indicating the value of
k3d/share/shaders/k3d_lunette.sl:94:	 * pulsegrid varies smoothly between the two values to cope with
k3d/share/shaders/k3d_lunette.sl:106:	 * Find the base color for the pattern.  The base color is a mix
k3d/share/shaders/k3d_lunette.sl:107:	 * between colorA and colorB, created using noise and other mixing
k3d/share/shaders/k3d_lunette.sl:117:	color basecolor = mix(colorB, colorA, noiseamt);
k3d/share/shaders/k3d_lunette.sl:120:	 * find the base line color for the grid pattern
k3d/share/shaders/k3d_lunette.sl:122:	color linecolor = mix(basecolor, baselinecolor, gridDensity);
k3d/share/shaders/k3d_lunette.sl:125:	 * return the mix between the base grid and the colorful noise
k3d/share/shaders/k3d_lunette.sl:127:	return mix(basecolor, linecolor, pulsegrid);
k3d/share/shaders/k3d_lunette.sl:139:	float urepeats = 30;		/* Number of repeats in u */
k3d/share/shaders/k3d_lunette.sl:141:	float vrepeats = 30;		/* Number of repeats in v */
k3d/share/shaders/k3d_lunette.sl:146:	color baselinecolor = color(.51, .48, .52);
k3d/share/shaders/k3d_lunette.sl:162:		lunacrity, gain, colorBenhance, gridDensity, baselinecolor
k3d/share/shaders/k3d_lunette.sl:171:	Ci = Os * ( cc * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_map_pattern_1.sl:69:C_temp1 = Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_matte.sl:14:  Ci = Os * Cs * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_metal.sl:16:  Ci = Os * Cs * (Ka * ambient() + Ks * specular(Nf, V, roughness));
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:6: * Version ampliada de Mondo.sl. Recibe un archivo B/N como mate, donde

k3d/share/shaders/k3d_mondometal.sl:7: * las partes blancas producen un efecto metalico y donde lo oscuro 

k3d/share/shaders/k3d_mondometal.sl:13:    string abColorMap = "";

k3d/share/shaders/k3d_mondometal.sl:14:    float abColorMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:15:    float abUseColorMapAlpha = 0;

k3d/share/shaders/k3d_mondometal.sl:16:    float abDiffuse = .8;

k3d/share/shaders/k3d_mondometal.sl:17:    string abDiffuseMap = "";

k3d/share/shaders/k3d_mondometal.sl:18:    float abDiffuseMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:19:    float abSpecular = .3;

k3d/share/shaders/k3d_mondometal.sl:20:    string abSpecularMap = "";

k3d/share/shaders/k3d_mondometal.sl:21:    float abSpecularMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:22:    color abSpecularColor = color(1,1,1);

k3d/share/shaders/k3d_mondometal.sl:23:    string abSpecularColorMap = "";

k3d/share/shaders/k3d_mondometal.sl:24:    float abSpecularColorMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:25:    float abRoughness = .3;

k3d/share/shaders/k3d_mondometal.sl:26:    string abRoughnessMap = "";

k3d/share/shaders/k3d_mondometal.sl:27:    float abRoughnessMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:28:    string abTransparencyMap = "";

k3d/share/shaders/k3d_mondometal.sl:29:    float abInvertTransparencyMap = 0;

k3d/share/shaders/k3d_mondometal.sl:30:    float abTransparencyMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:31:    color abIncandescence = color(0,0,0);

k3d/share/shaders/k3d_mondometal.sl:32:    string abIncandescenseMap = "";

k3d/share/shaders/k3d_mondometal.sl:33:    float abIncandescenseMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:34:    string abReflectionMap = "";

k3d/share/shaders/k3d_mondometal.sl:35:    float abReflectionUp = 0;

k3d/share/shaders/k3d_mondometal.sl:36:    float abReflectivity = .1;

k3d/share/shaders/k3d_mondometal.sl:37:    float abReflectionMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:38:    string abBumpMap = "";

k3d/share/shaders/k3d_mondometal.sl:39:    float abBumpMapBlur = 1;

k3d/share/shaders/k3d_mondometal.sl:40:    float abBumpScale = 1.0;

k3d/share/shaders/k3d_mondometal.sl:41:    float abDoDisplacement = 0.0;

k3d/share/shaders/k3d_mondometal.sl:42:    float abUseNormals = 0;

k3d/share/shaders/k3d_mondometal.sl:64:    float ss, tt, roughness, diff, spec, bmp;

k3d/share/shaders/k3d_mondometal.sl:71:    if(abColorMap != "")

k3d/share/shaders/k3d_mondometal.sl:73:        Csurf = Cs * color texture(abColorMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:76:        if(abUseColorMapAlpha != 0)

k3d/share/shaders/k3d_mondometal.sl:78:            Copac = float texture(abColorMap[3], ss, tt, 

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

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

k3d/share/shaders/k3d_mondometal.sl:96:    if(abDiffuseMap != "")

k3d/share/shaders/k3d_mondometal.sl:98:        diff = abDiffuse * float texture(abDiffuseMap, ss, tt, 

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

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

k3d/share/shaders/k3d_mondometal.sl:104:        diff = abDiffuse;

k3d/share/shaders/k3d_mondometal.sl:108:    if(abSpecularMap != "")

k3d/share/shaders/k3d_mondometal.sl:110:        spec = abSpecular * float texture(abSpecularMap, ss, tt, 

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

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

k3d/share/shaders/k3d_mondometal.sl:117:        spec = abSpecular;

k3d/share/shaders/k3d_mondometal.sl:121:    if(abSpecularColorMap != "")

k3d/share/shaders/k3d_mondometal.sl:123:        Cspec = abSpecularColor * color texture(abSpecularColorMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:129:        Cspec = abSpecularColor;

k3d/share/shaders/k3d_mondometal.sl:132:    if(abRoughnessMap != "")

k3d/share/shaders/k3d_mondometal.sl:134:        roughness = abRoughness * float texture(abRoughnessMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:140:        roughness = abRoughness;

k3d/share/shaders/k3d_mondometal.sl:144:    if(abTransparencyMap != "")

k3d/share/shaders/k3d_mondometal.sl:146:        if(abInvertTransparencyMap != 0)

k3d/share/shaders/k3d_mondometal.sl:148:            Copac = Copac * color texture(abTransparencyMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:154:            Copac = Copac * (color(1) - color texture(abTransparencyMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:161:    if(abIncandescenseMap != "")

k3d/share/shaders/k3d_mondometal.sl:163:        Cincand = abIncandescence * color texture(abIncandescenseMap, ss, tt,

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

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

k3d/share/shaders/k3d_mondometal.sl:169:        Cincand = abIncandescence;

k3d/share/shaders/k3d_mondometal.sl:173:    /* do the bump */

k3d/share/shaders/k3d_mondometal.sl:174:    if( abBumpMap != "" )

k3d/share/shaders/k3d_mondometal.sl:176:        bmp = abBumpScale * float texture( abBumpMap, ss, tt,

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

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

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

k3d/share/shaders/k3d_mondometal.sl:185:	if (abUseNormals == 1) {

k3d/share/shaders/k3d_mondometal.sl:190:        if( abDoDisplacement == 1.0 )

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

k3d/share/shaders/k3d_mondometal.sl:198:    /* compute shading variables **/

k3d/share/shaders/k3d_mondometal.sl:203:    if( abReflectionMap != "" )

k3d/share/shaders/k3d_mondometal.sl:207:        if( abReflectionUp != 0 )

k3d/share/shaders/k3d_mondometal.sl:211:        Crefl = abReflectivity * 

k3d/share/shaders/k3d_mondometal.sl:212:                color environment(abReflectionMap, 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:234:      Ci = Os * Copac * (Csurf * (Cincand + ambient() + diff * diffuse(Nf)) + 

k3d/share/shaders/k3d_mondometal.sl:239:      Ci = Cmetal * Oi * (Ka * ambient() + Kd * diffuse(Nf) +

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

k3d/share/shaders/k3d_mysky.sl:6: * puffyclouds.sl -- RenderMan compatible surface shader for puffy

k3d/share/shaders/k3d_mysky.sl:11: *    on a bright sunny day.  Works as a basic thresholded fBm.  Since

k3d/share/shaders/k3d_mysky.sl:12: *    this texture is generally used as a backdrop, it does not take

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:19: *    skycolor, cloudcolor - the obvious meanings

k3d/share/shaders/k3d_mysky.sl:20: *    octaves, omega, lambda - control the fractal appearance of the clouds

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

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

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

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

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

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

k3d/share/shaders/k3d_mysky.sl:37: *    ??? - original C language version by Ken Musgrave

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

k3d/share/shaders/k3d_mysky.sl:55:	     float octaves = 8, omega = 0.5, lambda = 2;

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

k3d/share/shaders/k3d_mysky.sl:78:  /* Shade like matte, but use color Ct */

k3d/share/shaders/k3d_noisysmoke.sl:32:		      float stepsize = 0.1; float debug = 0;
k3d/share/shaders/k3d_noisysmoke.sl:54:  float nsteps = 0;		/* record number of integration steps */
k3d/share/shaders/k3d_noisysmoke.sl:83:	     * of the portion of the volume covered by this step.
k3d/share/shaders/k3d_noisysmoke.sl:104:  /* Ci & Oi are the color (premultiplied by opacity) and opacity of 
k3d/share/shaders/k3d_noisysmoke.sl:105:   * the background element.
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:107:   * opacity of the volume, i.e. (1-Ov)*Ci is the light from the background
k3d/share/shaders/k3d_noisysmoke.sl:113:  if(debug > 0)
k3d/share/shaders/k3d_oak.sl:16: *   Clightwood - the light, "background" wood color
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:30: *   truedisp - 1 for true displacement, 0 for bump mapping
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:74:	       ringnoisefreq, trunkwobble, trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oak.sl:75:	       angularwobblefreq, ringy, grainy);
k3d/share/shaders/k3d_oakplank.sl:6: *    the y axis.  The subpattern within each individual plank is just
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:19: *   edgewidth - how close to the plank border does the wood start to curl?
k3d/share/shaders/k3d_oakplank.sl:23: *   Clightwood - the light, "background" wood color
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:37: *   truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_oakplank.sl:41: *   Kr, blur, eta - reflection parameters for the tile
k3d/share/shaders/k3d_oakplank.sl:72: * width and height of the grooves between tiles, figure out which
k3d/share/shaders/k3d_oakplank.sl:90:  /* Calculate our "in-plank" value by multiplying two perpendicular
k3d/share/shaders/k3d_oakplank.sl:103:		     float Kr = 1, blur = 0, eta = 1.5;
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:129:   * the (splank,tplank) coordinates (both on [0,1]) within our tile.
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: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:170:			 specadjusted * Kr, blur, eta, 1, ENVPARAMS);
k3d/share/shaders/k3d_orange.sl:34:	point turb, p2;
k3d/share/shaders/k3d_orange.sl:43:	turb = noise (BUMP_FREQUENCY * p2) * BUMP_AMPLITUDE;
k3d/share/shaders/k3d_orange.sl:44:	newP = calculatenormal (P + turb * normalize (N));
k3d/share/shaders/k3d_orange.sl:49:	Ci = Cs * (Ka * ambient() + Kd * diffuse (Nf)) + Ks * specular (Nf, V, roughness);
k3d/share/shaders/k3d_orennayar.sl:9: *   Lambert.  Based on Oren & Nayar's model (see Proc. SIGGRAPH 94).
k3d/share/shaders/k3d_orennayar.sl:11: *   Lambertian (isotropic) BRDF is a simple approximation, but not
k3d/share/shaders/k3d_orennayar.sl:17: *   sigma - roughness (0 is lambertian, larger values are rougher)
k3d/share/shaders/k3d_orennayar.sl:22: *   Oren, Michael and Shree K. Nayar.  "Generalization of Lambert's
k3d/share/shaders/k3d_orennayar.sl:29: *      model to the result.  It could easily be packaged up as a macro
k3d/share/shaders/k3d_orennayar.sl:31: *   2. Examination of why rough surfaces are not Lambertian will lead
k3d/share/shaders/k3d_orennayar.sl:32: *      you to the solution to the famous "flat full moon" problem.
k3d/share/shaders/k3d_orennayar.sl:35: *   14 June 1994 -- written by Larry Gritz
k3d/share/shaders/k3d_orennayar.sl:50:    float alpha, beta, sigma2, cos_phi_diff;
k3d/share/shaders/k3d_orennayar.sl:64:	beta = min (theta_i, theta_r);
k3d/share/shaders/k3d_orennayar.sl:69:	else C2 *= (sin(alpha) - pow(2*beta/PI,3));
k3d/share/shaders/k3d_orennayar.sl:70:	C3 = 0.125 * sigma2 / (sigma2+0.09) * pow ((4*alpha*beta)/(PI*PI),2);
k3d/share/shaders/k3d_orennayar.sl:71:	L1 = Cs * (cos_theta_i * (C1 + cos_phi_diff * C2 * tan(beta) +
k3d/share/shaders/k3d_orennayar.sl:72:				  (1 - abs(cos_phi_diff)) * C3 * tan((alpha+beta)/2)));
k3d/share/shaders/k3d_orennayar.sl:74:			  (1 - cos_phi_diff*(4*beta*beta)/(PI*PI)));
k3d/share/shaders/k3d_orennayar.sl:79:    Ci = Os * (Cs * (Ka*ambient()) + Kd*lightC);
k3d/share/shaders/k3d_outlet.sl:5: *   Makes an electrical outlet.  Perfect for slapping on a bilinear
k3d/share/shaders/k3d_outlet.sl:6: *   patch to make a wall more interesting.  The patch should be
k3d/share/shaders/k3d_outlet.sl:8: *   up close, but from across the room, it's a nice touch of detail.
k3d/share/shaders/k3d_outlet.sl:9: *   I should probably add some bump mapping or other variation, but
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:21: *      17 Jan 1994 -- recoded by lg in correct shading language.
k3d/share/shaders/k3d_outlet.sl:23: * last modified  17 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_outlet.sl:43:  x = abs (u - 0.5);
k3d/share/shaders/k3d_outlet.sl:70:  Ci = Os * ( Ct * (Ka*ambient() + kd*diffuse(Nf)) +
k3d/share/shaders/k3d_outline.sl:1:/* IDoutline written by Ivan DeWolf
k3d/share/shaders/k3d_paintedplastic.sl:10: *    by the s,t parameters of the surface.
k3d/share/shaders/k3d_paintedplastic.sl:46:	Ci = Oi * Cs * Ct * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, V, roughness);
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:14: *   plankspertile - number of planks in each parquet tile
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:19: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_plank.sl:24: * ANTIALIASING: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_parquet_plank.sl:27: * AUTHOR: Larry Gritz, email: lg@bmrt.org
k3d/share/shaders/k3d_parquet_plank.sl:44:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
k3d/share/shaders/k3d_parquet_plank.sl:64:    (max(abs(Du(s) * du) + abs(Dv(s) * dv), MINFILTERWIDTH) / PGWIDTH) *
k3d/share/shaders/k3d_parquet_plank.sl:67:    (max(abs(Du(t) * du) + abs(Dv(t) * dv), MINFILTERWIDTH) / PGHEIGHT) *
k3d/share/shaders/k3d_parquet_plank.sl:93:   * are grooves, 1 where the wood grain is visible.  Do some simple
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: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:110:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_parquet_plank.sl:131:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_plank.sl:159:    Os * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) +
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:15: *   plankspertile - number of planks in each parquet tile
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:20: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_plank2.sl:25: * ANTIALIASING: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_parquet_plank2.sl:28: * AUTHOR: written by Larry Gritz, the George Washington University
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:58:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
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:100:   * are grooves, 1 where the wood grain is visible.  Do some simple
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: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:130:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_plank2.sl:153:  Ci = Os * ( Ct * (Ka*ambient() + Kd*diffuse(Nf)) +
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:16: *   plankspertile - number of planks in each parquet tile
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:21: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_parquet_tile.sl:26: * ANTIALIASING: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_parquet_tile.sl:29: * AUTHOR: written by Larry Gritz, the George Washington University
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:42: * modified again by Dan Weeks <dan@SpamSucks_mango.sfasu.edu> on 08 Dec 1996
k3d/share/shaders/k3d_parquet_tile.sl:43: *   - made one plank per tile like the flooring in our lab
k3d/share/shaders/k3d_parquet_tile.sl:73:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
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:115:   * are grooves, 1 where the wood grain is visible.  Do some simple
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: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:145:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_tile.sl:168:  Ci = Os * ( Ct * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_planetclouds.sl:2: * planetclouds.sl - surface for a semi-opaque cloud layer to be put on
k3d/share/shaders/k3d_planetclouds.sl:8: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_planetclouds.sl:9: *   the surface, then modulating the opacity based on this function in
k3d/share/shaders/k3d_planetclouds.sl:16: *    omega,lambda,octaves - the fractal characteristics of the clouds
k3d/share/shaders/k3d_planetclouds.sl:17: *    p4 - beats me
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:30: *           AttributeBegin
k3d/share/shaders/k3d_planetclouds.sl:31: *             Attribute "render" "casts_shadows" "shade"
k3d/share/shaders/k3d_planetclouds.sl:34: *           AttributeEnd
k3d/share/shaders/k3d_planetclouds.sl:36: *      represented by a unit sphere.  The texture space and/or parameters
k3d/share/shaders/k3d_planetclouds.sl:37: *      to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_planetclouds.sl:42: *    Conversion to Shading Language and other minor changes by Larry Gritz.
k3d/share/shaders/k3d_planetclouds.sl:45: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_planetclouds.sl:50: *    ???? - original texture developed by Ken Musgrave.
k3d/share/shaders/k3d_planetclouds.sl:51: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_planetclouds.sl:53: * last modified 1 March 1994 by lg
k3d/share/shaders/k3d_planetclouds.sl:68:			 float lambda = 2; float octaves = 9;
k3d/share/shaders/k3d_planetclouds.sl:91:      l *= lambda;
k3d/share/shaders/k3d_planetclouds.sl:105:  /* Modulate surface opacity by the cloud value */
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:15: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:17: *   groovecolor - the color of the "grooves" between the planks
k3d/share/shaders/k3d_plank.sl:22: * ANTIALIASING: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_plank.sl:25: * AUTHOR: Larry Gritz, lg@bmrt.org
k3d/share/shaders/k3d_plank.sl:41:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
k3d/share/shaders/k3d_plank.sl:59:    max(abs(Du(s) * du) + abs(Dv(s) * dv),
k3d/share/shaders/k3d_plank.sl:62:    max(abs(Du(t) * du) + abs(Dv(t) * dv),
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: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: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:96:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_plank.sl:117:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_plank.sl:147:    Os * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_plastic.sl:16:  Ci = Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_plastic2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_plastic2.sl:23:    Ci = Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf))
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:7:// modify it under the terms of the GNU General Public
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:14:// General Public License for more details.
k3d/share/shaders/k3d_projectionmap_plastic.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_projectionmap_plastic.sl:62:	Ci = Oi * Cs * Ct * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, V, roughness);
k3d/share/shaders/k3d_puffyclouds.sl:4: * puffyclouds.sl -- RenderMan compatible surface shader for puffy
k3d/share/shaders/k3d_puffyclouds.sl:9: *    on a bright sunny day.  Works as a basic thresholded fBm.  Since
k3d/share/shaders/k3d_puffyclouds.sl:10: *    this texture is generally used as a backdrop, it does not take
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:17: *    skycolor, cloudcolor - the obvious meanings
k3d/share/shaders/k3d_puffyclouds.sl:18: *    octaves, omega, lambda - control the fractal appearance of the clouds
k3d/share/shaders/k3d_puffyclouds.sl:19: *    threshold - fBm sum below this level is just blue sky
k3d/share/shaders/k3d_puffyclouds.sl:22: *    None, but should be easy to add antialiasing simply by adaptively
k3d/share/shaders/k3d_puffyclouds.sl:23: *    setting the "octaves" parameter based on distance from eye point.
k3d/share/shaders/k3d_puffyclouds.sl:26: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_puffyclouds.sl:27: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_puffyclouds.sl:30: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_puffyclouds.sl:35: *    ??? - original C language version by Ken Musgrave
k3d/share/shaders/k3d_puffyclouds.sl:36: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_puffyclouds.sl:52:	     float octaves = 8, omega = 0.5, lambda = 2;
k3d/share/shaders/k3d_puffyclouds.sl:64:/*  value = fBm (PP, omega, lambda, octaves); */
k3d/share/shaders/k3d_puffyclouds.sl:75:  /* Shade like matte, but use color Ct */
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:2: * Renamed to JMredapple.sl for RMR -- talrmr@SpamSucks_pacbell.net  7/18/99
k3d/share/shaders/k3d_redapple.sl:11: * for specific geometry, but can very easily be adjusted to fit any
k3d/share/shaders/k3d_redapple.sl:15: * look best from the side, but work ok from the top, so long as you
k3d/share/shaders/k3d_redapple.sl:20: * my apple's parameters are stretched a bit?), so if you use
k3d/share/shaders/k3d_redapple.sl:24: * email me your praises, notification of my credits in big motion
k3d/share/shaders/k3d_redapple.sl:25: * pictures, job offers at Pixar, etc... to:  jmerritt@SpamSucks_warpax.com   :-)
k3d/share/shaders/k3d_redapple.sl:48:	float Ka = 1;             /* Ambient light coeff.          */
k3d/share/shaders/k3d_redapple.sl:51:	float label = 0;          /* Non-uniformity param.         */
k3d/share/shaders/k3d_redapple.sl:55:	float txtscale = .05;     /* Ugly kludge (see above...)    */
k3d/share/shaders/k3d_redapple.sl:60:	 * Shader variables
k3d/share/shaders/k3d_redapple.sl:64:	float base_turb, blotch_turb, disp_turb;
k3d/share/shaders/k3d_redapple.sl:65:	float small_noise, blotch, speck, disp = 0, blackness;
k3d/share/shaders/k3d_redapple.sl:66:	color cs, small_speckle, base_color, reflect;
k3d/share/shaders/k3d_redapple.sl:75:	color brown = color(0.70,0.78,0.34);
k3d/share/shaders/k3d_redapple.sl:76:	color black = color(0.00,0.00,0.00);
k3d/share/shaders/k3d_redapple.sl:87:	 * Pick the base color for the apple.
k3d/share/shaders/k3d_redapple.sl:89:	 * The base color consists of patches of pure green,
k3d/share/shaders/k3d_redapple.sl:99:	#define BASE_SF          1.2    /* s-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:100:	#define BASE_TF          3      /* t-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:109:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:110:	                  BASE_TF*t + label);
k3d/share/shaders/k3d_redapple.sl:111:	base_turb = pow(base_turb, (1/redness));
k3d/share/shaders/k3d_redapple.sl:116:		base_turb = 0;
k3d/share/shaders/k3d_redapple.sl:118:		base_turb *= (t-T1)/(T2-T1);
k3d/share/shaders/k3d_redapple.sl:120:		base_turb *= (T4-t)/(T4-T3);
k3d/share/shaders/k3d_redapple.sl:122:		base_turb = 0;
k3d/share/shaders/k3d_redapple.sl:123:	base_color = spline(base_turb, green, green,
k3d/share/shaders/k3d_redapple.sl:129:	 * Pick the blotch color.
k3d/share/shaders/k3d_redapple.sl:131:	 * The blotch color is finally determined by mixing,
k3d/share/shaders/k3d_redapple.sl:132:	 * using the blotching coefficient "blotch". This
k3d/share/shaders/k3d_redapple.sl:136:	#define BLOTCH_SF          20   /* s-factor for blotches  */
k3d/share/shaders/k3d_redapple.sl:137:	#define BLOTCH_TF          15   /* t-factor for blotches  */
k3d/share/shaders/k3d_redapple.sl:140:	#define BLOTCH_SPECK_COEFF 0.3  /* blotch specking coeff  */
k3d/share/shaders/k3d_redapple.sl:141:	blotch_turb = noise(BLOTCH_SF*sin(2*PI*(s+.1234)) + PI + label,
k3d/share/shaders/k3d_redapple.sl:142:	                    BLOTCH_TF*t + label) + BLOTCH_DELTA;
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:145:	blotch = blotch * (1+small_noise) +
k3d/share/shaders/k3d_redapple.sl:147:	if (blotch > 1) blotch = 1;
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: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:172:	blackness = 1-(smoothstep(BEDGE, BEDGE+BWIDTH, t)*
k3d/share/shaders/k3d_redapple.sl:177:	 * Combine what we have so far to set the surface
k3d/share/shaders/k3d_redapple.sl:180:	cs = mix(base_color, dred, blotch);
k3d/share/shaders/k3d_redapple.sl:181:	cs = mix(cs, brown, speck);
k3d/share/shaders/k3d_redapple.sl:182:	cs = mix(cs, black, blackness);
k3d/share/shaders/k3d_redapple.sl:189:	 * highlights. We'd like them perturbed by the small
k3d/share/shaders/k3d_redapple.sl:190:	 * noise, affected a little by the brown specks, and
k3d/share/shaders/k3d_redapple.sl:191:	 * also dented a bit (alas, no real apples are perfectly
k3d/share/shaders/k3d_redapple.sl:199:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:200:	              DISP_TF*t + label) * DISP_DENT_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_redapple.sl:211:	 * in the surface of an apple. They don't add much, but
k3d/share/shaders/k3d_redapple.sl:212:	 * may be needed for the 'perfect' apple :-).
k3d/share/shaders/k3d_redapple.sl:215:	 * for this bit!
k3d/share/shaders/k3d_redapple.sl:230:	 * Combine everything to get Ci, in the standard form.
k3d/share/shaders/k3d_redapple.sl:233:	Ci = Os * (cs * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_ridged_multifractal.sl:3: *    Conversion to Shading Language and minor modifications by Fredrik Brnnbacka.

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

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

k3d/share/shaders/k3d_ridged_multifractal.sl:47:          		/* get absolute value of signal*/

k3d/share/shaders/k3d_ridged_multifractal.sl:48:          		signal = abs(signal);

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

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

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

k3d/share/shaders/k3d_roughmetal.sl:8: *   Ka, Kd, Ks - ambient, diffuse, specular weights
k3d/share/shaders/k3d_round.sl:3:/* Listing 16.23  Displacement shader for bevelling perpendicular bilinear patches*/
k3d/share/shaders/k3d_round.sl:6: * round(): displace the edge of a bilinear patch so that, if it is placed 
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:44:	 * Find the point towards which the surface  point will be 
k3d/share/shaders/k3d_round.sl:57:		/* Make P be distance 'radius' along the line 
k3d/share/shaders/k3d_rubber.sl:3:/* Listing 16.38  Rubber surface shader*/
k3d/share/shaders/k3d_rubber.sl:6: * rubber(): This shader generates a rubber surface. It is a matte shader that
k3d/share/shaders/k3d_rubber.sl:10:k3d_rubber( 
k3d/share/shaders/k3d_rubber.sl:24:	Ci = Os * cout * ( Ka*ambient() + Kd*diffuse(Nf) ) ;
k3d/share/shaders/k3d_ruledpaper.sl:6: *   the margin, binder holes and writing (as an image texture).
k3d/share/shaders/k3d_ruledpaper.sl:14: * ANTIALIASING: no antialiasing. This can be a real problem because of the
k3d/share/shaders/k3d_ruledpaper.sl:17: * AUTHOR: written by Emil Mikulic
k3d/share/shaders/k3d_ruledpaper.sl:22: *    9 Nov 1997 - added binder holes and finished shader
k3d/share/shaders/k3d_ruledpaper.sl:25: * last modified 15 Nov 1997 by Emil Mikulic
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:29: *   the paper(...) block so that they get calculated on initialisation
k3d/share/shaders/k3d_ruledpaper.sl:30: *   (initcode) instead of being re-calced for every sample.
k3d/share/shaders/k3d_ruledpaper.sl:33: *   but in my day there's 7. I actually got a piece of loose-leaf paper
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:55:	// Spacing between lines
k3d/share/shaders/k3d_ruledpaper.sl:61:	// Top and bottom margins for lines
k3d/share/shaders/k3d_ruledpaper.sl:63:		margb = 1 - (1.35 / ph),
k3d/share/shaders/k3d_ruledpaper.sl:67:	// Settings for binder holes (circles)
k3d/share/shaders/k3d_ruledpaper.sl:72:	// Bounding box for circles
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:77:// Fancy macro checks ss/tt coords against bounding box and [if inside]
k3d/share/shaders/k3d_ruledpaper.sl:79:// becomes black and the opacity becomes 0.
k3d/share/shaders/k3d_ruledpaper.sl:105:	// If we're inside the borders/margins
k3d/share/shaders/k3d_ruledpaper.sl:106:	if ( (s>linef) && (t>margt) && (t<margb) )
k3d/share/shaders/k3d_ruledpaper.sl:113:	// Bounding box for circle calcs
k3d/share/shaders/k3d_ruledpaper.sl:114:	if ((s>boundl) && (s<boundr)) 
k3d/share/shaders/k3d_ruledpaper.sl:121:		// Find bounding boxes first to speed up calcs
k3d/share/shaders/k3d_ruledpaper.sl:137:			Ci = Oi * (tex * (Ka * ambient() + Kd * diffuse(Nf)) + 
k3d/share/shaders/k3d_ruledpaper.sl:141:			Ci = Oi * tex * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_rustymetal.sl:5: *   A rough metal surface with controllable rust spots.  The rust pattern
k3d/share/shaders/k3d_rustymetal.sl:6: *   is basically thresholded turbulence (summed abs(snoise)).  Where it's
k3d/share/shaders/k3d_rustymetal.sl:7: *   rusty, shade like rust colored matte, and also make it bumpy (like
k3d/share/shaders/k3d_rustymetal.sl:16: *   rustbump - controls the "bumpiness" of the rusty areas.
k3d/share/shaders/k3d_rustymetal.sl:19: *   The fractal sum used to determine the rust pattern chooses a number of
k3d/share/shaders/k3d_rustymetal.sl:20: *   octaves to sum based on the shader sampling rate.  This helps to keep
k3d/share/shaders/k3d_rustymetal.sl:37:/* Maximum number of octaves */
k3d/share/shaders/k3d_rustymetal.sl:49:	    float rustbump = 0.035;
k3d/share/shaders/k3d_rustymetal.sl:53:  point Nrust;                 /* perturbed normal for the rusty areas */
k3d/share/shaders/k3d_rustymetal.sl:60:  /* Sum several octaves of abs(snoise), i.e. turbulence.  Limit the
k3d/share/shaders/k3d_rustymetal.sl:61:   * number of octaves by the estimated change in PP between adjacent
k3d/share/shaders/k3d_rustymetal.sl:67:      sum += a * abs(snoise(PP));
k3d/share/shaders/k3d_rustymetal.sl:71:  /* If it's rusty, also add a high frequency bumpiness to the normal */
k3d/share/shaders/k3d_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
k3d/share/shaders/k3d_rustymetal.sl:74:  /* Scale the rust appropriately, modulate it by another noise 
k3d/share/shaders/k3d_rustymetal.sl:75:   * computation, then sharpen it by squaring its value.
k3d/share/shaders/k3d_rustymetal.sl:78:  rustiness *= clamp (abs(snoise(PP)), 0, .08) / 0.08;
k3d/share/shaders/k3d_rustymetal.sl:82:   * account the perturbed normal and shading like matte.
k3d/share/shaders/k3d_rustymetal.sl:86:      Crust = rustcolor * (rustKa*ambient() + rustKd*diffuse(Nf));
k3d/share/shaders/k3d_rustymetal.sl:94:      Cmetal = Cs * (metalKa*ambient() + metalKs*specular(Nf,V,metalroughness));
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:10: *   Saturn-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_saturn.sl:11: *   turbulence techniques.
k3d/share/shaders/k3d_saturn.sl:18: *               terrain type by latitude
k3d/share/shaders/k3d_saturn.sl:22: *   Assumes being used on a sphere.  Haven't really tried it by using other
k3d/share/shaders/k3d_saturn.sl:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_saturn.sl:33: *    This started out as L. Gritz's terran.sl shader.  But I think he may be
k3d/share/shaders/k3d_saturn.sl:36: *        Did major hacking to make it a Saturn-like shader by Tal Lancaster 
k3d/share/shaders/k3d_saturn.sl:39: * last modified 23 May 1995 by Tal
k3d/share/shaders/k3d_saturn.sl:60:   * Step 2: Assign a climite type, roughly by latitude.
k3d/share/shaders/k3d_saturn.sl:63:  /* make climate symmetric about equator */
k3d/share/shaders/k3d_saturn.sl:64:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_saturn.sl:86:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_saturnring.sl:2: * TLRing.sl -- surface for a saturn like ring to be used on a disk
k3d/share/shaders/k3d_saturnring.sl:12: *	opacity - the opacity of the rings (may not be used anymore)
k3d/share/shaders/k3d_saturnring.sl:16: *  otherwise then they will neeb to be changed.
k3d/share/shaders/k3d_saturnring.sl:31:/* Grabbed from one of Larry Gritz's many shaders */
k3d/share/shaders/k3d_saturnring.sl:107:			Ci = Oi * (cs * (Ka*ambient() + Kd*diffuse(Nf) ));
k3d/share/shaders/k3d_scartissue.sl:1:/*  IDscartissue.sl written by Ivan DeWolf
k3d/share/shaders/k3d_scartissue.sl:2: *  an unremarkable recursive noise to make scartissue
k3d/share/shaders/k3d_scartissue.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_scartissue.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_scartissue.sl:14:	point Psh = transform("object",P);
k3d/share/shaders/k3d_scartissue.sl:19:	color base;
k3d/share/shaders/k3d_scartissue.sl:25:		nz += abs(.5 - noise( (freq * Psh)+offset)) / freq;
k3d/share/shaders/k3d_scartissue.sl:29:	base = mix(dark,light,nz);
k3d/share/shaders/k3d_scartissue.sl:34:	Ci = ( base * (Ka + Kd*diffuse(Nf)) + 
k3d/share/shaders/k3d_screen.sl:1:/* screen.sl - RenderMan compatible shader for a metalic screen.
k3d/share/shaders/k3d_screen.sl:35:	Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_screen_aa.sl:2: * screen_aa.sl -- RenderMan compatible shader for a metalic screen.
k3d/share/shaders/k3d_screen_aa.sl:15: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_screen_aa.sl:17: * last modified  31 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_screen_aa.sl:25:#define boxstep(a,b,x) (clamp(((x)-(a))/((b)-(a)),0,1))
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: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: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:68:  /* This would be the non-antialiased version:
k3d/share/shaders/k3d_screen_aa.sl:78:	Oi * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_sdixon.sl:3:/* Listing 16.37  Pencil-labeling surface shader*/
k3d/share/shaders/k3d_sdixon.sl:6: * sdixon(): Paint the body of a pencil.
k3d/share/shaders/k3d_sdixon.sl:24:	 *   metallic-green ink to a matte-yellow background. */
k3d/share/shaders/k3d_sdixon.sl:37:	Ci = Os * cout * ( Ka*ambient() + (1-ink)*Kd*diffuse(Nf) +
k3d/share/shaders/k3d_shadowspot.sl:15:	float beamdistribution = 2;
k3d/share/shaders/k3d_shadowspot.sl:18:	float blur = 0.01;
k3d/share/shaders/k3d_shadowspot.sl:19:	float bias = 0.01; )
k3d/share/shaders/k3d_shadowspot.sl:29:		attenuation = pow(cosangle, beamdistribution) / (L.L);
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:11: *	fuzz -       Amount to blur edge
k3d/share/shaders/k3d_shifteddrtile.sl:20: *	The center varible should really be placed in the parameter list 
k3d/share/shaders/k3d_shifteddrtile.sl:21: *      (remember to set the right space)
k3d/share/shaders/k3d_shifteddrtile.sl:22: *  Also, it would be better to set the width of the ring rather than
k3d/share/shaders/k3d_shifteddrtile.sl:24: *  Another thing that might be useful is to add a parameter to 
k3d/share/shaders/k3d_shifteddrtile.sl:33:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shifteddrtile.sl:35:	smoothstep (b-fuzz, b+fuzz, loc) )
k3d/share/shaders/k3d_shifteddrtile.sl:52:	uniform float fuzz = .025;          /* amount to blur edge */
k3d/share/shaders/k3d_shifteddrtile.sl:63:	float mix_opacity; /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shifteddrtile.sl:72:	center = (0.5, 0.5, 0);  /* This should really be */
k3d/share/shaders/k3d_shifteddrtile.sl:100:	Ci = Os * (surfColor * (Ka*ambient() + Kd*diffuse(Nf)) +
k3d/share/shaders/k3d_shiftedmoontile.sl:10: *	fuzz -      Amount to blur edge
k3d/share/shaders/k3d_shiftedmoontile.sl:14: *	eclipseCenter - Center of obscuring disk
k3d/share/shaders/k3d_shiftedmoontile.sl:19: *	Really should move center to the paramter list so both centers 
k3d/share/shaders/k3d_shiftedmoontile.sl:20: *	 can be controled.
k3d/share/shaders/k3d_shiftedmoontile.sl:28:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shiftedmoontile.sl:30:	smoothstep (b-fuzz, b+fuzz, loc) )
k3d/share/shaders/k3d_shiftedmoontile.sl:41:#define difference(a, b) ((a) - (a) * b)
k3d/share/shaders/k3d_shiftedmoontile.sl:60:	float mix_opacity;       /* How much to mix between the surfaces */
k3d/share/shaders/k3d_shiftedmoontile.sl:68:	center = (0.5, 0.5, 0);  /* This should really be moved */
k3d/share/shaders/k3d_shiftedmoontile.sl:88:	Ci = Os * (surfColor * (Ka*ambient() + Kd*diffuse(Nf)) +
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:12: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shiny.sl:21: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_shiny.sl:34:		  float Kr = 0.8, blur = 0; DECLARE_DEFAULTED_ENVPARAMS;
k3d/share/shaders/k3d_shiny.sl:39:    MaterialShinyMetal(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, twosided,
k3d/share/shaders/k3d_shinymetal.sl:29:  Ci = Os * Cs * (Ka * ambient() + Ks * specular(Nf, -V, roughness) + env);
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:13: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shinyplastic.sl:18: * Author: Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_shinyplastic.sl:28:			 float Kr = 1, blur = 0, ior = 1.5;
k3d/share/shaders/k3d_shinyplastic.sl:35:    MaterialShinyPlastic(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, ior,
k3d/share/shaders/k3d_skin1.sl:4: * Copyright (C) 2002, Rudy Cortes   rcortes@hntb.com
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:22: * blemishfreq, blemishthresh,blemhishopac = control the freqency, threshold and opacity
k3d/share/shaders/k3d_skin1.sl:23: * of blemishes on the skin. Use to give skin a little variation.
k3d/share/shaders/k3d_skin1.sl:24: * blemishmap = Use a grayscale map to control where the belmishes will be more visible
k3d/share/shaders/k3d_skin1.sl:33: * You can replace the header functions by using
k3d/share/shaders/k3d_skin1.sl:35: * NOTE- you must copy the entire subsurface skin function to your
k3d/share/shaders/k3d_skin1.sl:55: * The derivation and formulae can be found in:  Ward, Gregory J.
k3d/share/shaders/k3d_skin1.sl:73:  /* Must declare extern L & Cl because we're in a function */
k3d/share/shaders/k3d_skin1.sl:93: * --- subsurfaceSkin------
k3d/share/shaders/k3d_skin1.sl:96: * information about skin reflectance from Hanrahan and Krueger, 
k3d/share/shaders/k3d_skin1.sl:97: * "Reflection from layered surfaces due to subsurface scattering", 
k3d/share/shaders/k3d_skin1.sl:101:   an asymmetry value g.  v1 and v2 should be normalized and g should 
k3d/share/shaders/k3d_skin1.sl:102:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin1.sl:103:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin1.sl: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:133:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin1.sl:134:   surface normal information, the base color of the skin, a
k3d/share/shaders/k3d_skin1.sl:137:color subsurfaceSkin(vector Vf; normal Nn; color skinColor, sheenColor;
k3d/share/shaders/k3d_skin1.sl:160:}    /* subsurfaceSkin --ends */
k3d/share/shaders/k3d_skin1.sl:167: *shader beggins here.
k3d/share/shaders/k3d_skin1.sl:176:  float blemishfreq  = 12,
k3d/share/shaders/k3d_skin1.sl:177:        belmishthresh = 4,
k3d/share/shaders/k3d_skin1.sl:178:        blemishopac = 1;
k3d/share/shaders/k3d_skin1.sl:179:  string blemishmap = "";
k3d/share/shaders/k3d_skin1.sl:194:  /* initialize local variables*/
k3d/share/shaders/k3d_skin1.sl:201:  float turb, f;
k3d/share/shaders/k3d_skin1.sl:212:  turb = 0;
k3d/share/shaders/k3d_skin1.sl:214:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:216:  turb = pow(turb,poresthresh) * poresdepth;
k3d/share/shaders/k3d_skin1.sl:220:  NN = calculatenormal(P + turb * normalize(N));
k3d/share/shaders/k3d_skin1.sl:223:  /* layer 1 .- apply a subsurface scattered BRDF to the surface.
k3d/share/shaders/k3d_skin1.sl:235:  /* layer 2 - create small skin blemishes over the skin. Use a map to control
k3d/share/shaders/k3d_skin1.sl:236:   * where the blemishes are visible */
k3d/share/shaders/k3d_skin1.sl:238:  PP = transform ("shader",P) * blemishfreq;
k3d/share/shaders/k3d_skin1.sl:239:  turb = 0;
k3d/share/shaders/k3d_skin1.sl:241:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:243:  turb = pow(turb, belmishthresh );
k3d/share/shaders/k3d_skin1.sl:251:  color blemishcol = color spline ( turb,
k3d/share/shaders/k3d_skin1.sl:264:  lc =  subsurfaceSkin(Vf, Nf, blemishcol, Csheen, 1/eta, thickness);
k3d/share/shaders/k3d_skin1.sl:265:  lo = 1 * (blemishopac) ;
k3d/share/shaders/k3d_skin1.sl:267:  if (blemishmap != "")
k3d/share/shaders/k3d_skin1.sl:268:      lo *= float texture (blemishmap);
k3d/share/shaders/k3d_skin1.sl:273:  * outside the skin. Oilyness is controlled by the oily, xrougness and yroughness.
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:11: * information about skin reflectance from Hanrahan and Krueger, 
k3d/share/shaders/k3d_skin2.sl:12: * "Reflection from layered surfaces due to subsurface scattering", 
k3d/share/shaders/k3d_skin2.sl:16: * for notes and background information.
k3d/share/shaders/k3d_skin2.sl:20:   an asymmetry value g.  v1 and v2 should be normalized and g should 
k3d/share/shaders/k3d_skin2.sl:21:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin2.sl:22:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin2.sl: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:54:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin2.sl:55:   surface normal information, the base color of the skin, a
k3d/share/shaders/k3d_skin2.sl:63:color subsurfaceSkin(vector Vf; normal Nn; color skinColor, sheenColor;
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:98:	Ci = Os * subsurfaceSkin(Vf, Nn, Cs, sheenColor, eta, thickness);
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:19:             /* actually should be vector and vtransform if using 3.5 or 
k3d/share/shaders/k3d_skymetal.sl:43:	Ci = Os * Cs * (Kr*refl + (1-Kr) * (Ka * ambient () +
k3d/share/shaders/k3d_slateroof.sl:1:/* Renamed to PQslateroof.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroof.sl:6:	transparent (and black) so that the edge of the roof looks irregular.
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:12:   Ka: Coefficient of ambient light;
k3d/share/shaders/k3d_slateroof.sl:14:   sfreq: number of tiles on the s direction
k3d/share/shaders/k3d_slateroof.sl:15:   tfreq: number of tiles in the t direction
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: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:41:	message passing, so to produce the test image the code has been
k3d/share/shaders/k3d_slateroof.sl:58:	/* sfreq and tfreq must not be below 3 */				   
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:70:   float add, 										/* Add, between 0 and 1, hold the amount the current tile overlaps the next */
k3d/share/shaders/k3d_slateroof.sl:77:   color 	Ct = 0;								/* A temporary color variable */
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:137:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroof.sl:140:			 * the row below */
k3d/share/shaders/k3d_slateroof.sl:199:	Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward( normalize(N), I )));
k3d/share/shaders/k3d_slateroofd.sl:1:/* Renamed to PQslateroofd.sl for RMR -- talrmr@SpamSucks_pacbell.net */
k3d/share/shaders/k3d_slateroofd.sl:10:    	sfreq: number of tiles on the s direction
k3d/share/shaders/k3d_slateroofd.sl:11:    	tfreq: number of tiles in the t direction
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: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:31:		the bottom of the tile, gaps to either side and the whole tile gently
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: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:62:   float add,	 									/* Add, between 0 and 1, hold the amount the current tile overlaps the next */
k3d/share/shaders/k3d_slateroofd.sl:103: 		/* the very bottom row cannot expand */
k3d/share/shaders/k3d_slateroofd.sl:107:	/* the above adjusts t_offset so that it runs from 0 to 1 within the expanded tile */
k3d/share/shaders/k3d_slateroofd.sl:129:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroofd.sl:132:		 			the row below */
k3d/share/shaders/k3d_slideprojector.sl:6:			 float conedeltaangle = 5; float beamdistribution = 2;
k3d/share/shaders/k3d_slideprojector.sl:36:    attenuation = pow(cosangle, beamdistribution) / (L.L);
k3d/share/shaders/k3d_smoke.sl:9: *   opacdensity - overall smoke density control as it affects its ability
k3d/share/shaders/k3d_smoke.sl:10: *          to block light from behind it.
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:68:/* Return a component-by-component exp() of a color */
k3d/share/shaders/k3d_smoke.sl:93:  /* Calculate a reasonable step size */
k3d/share/shaders/k3d_smoke.sl:97:   * beginning of the ray 
k3d/share/shaders/k3d_smoke.sl:111:      /* Find the blocking and light scattering contribution of 
k3d/share/shaders/k3d_smoke.sl:112:       * the portion of the volume covered by this step.
k3d/share/shaders/k3d_smoke.sl:118:      /* Composite with exponential extinction of background light */
k3d/share/shaders/k3d_smoke.sl:125:  /* Ci & Oi are the color and opacity of the background element.
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:127:   * opacity of the volume, i.e. (1-Ov)*Ci is the light from the background
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:19: *   debug - if nonzero, copious output will be sent to stderr.
k3d/share/shaders/k3d_smoke2.sl:32: * Revision 1.1  2003/02/11 14:32:43  blackburst
k3d/share/shaders/k3d_smoke2.sl:36: * Eliminated duplicate local variable declarations
k3d/share/shaders/k3d_smoke2.sl:39: * Compute only one octave of noise when not lit (big speedup)
k3d/share/shaders/k3d_smoke2.sl:80:	    float debug = 0;
k3d/share/shaders/k3d_smoke2.sl:101:  float nsteps = 0;          /* record number of integration steps */
k3d/share/shaders/k3d_smoke2.sl:128:	   * of the portion of the volume covered by this step.
k3d/share/shaders/k3d_smoke2.sl:147:  /* Ci & Oi are the color (premultiplied by opacity) and opacity of 
k3d/share/shaders/k3d_smoke2.sl:148:   * the background element.
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:150:   * opacity of the volume, i.e. (1-Ov)*Ci is the light from the background
k3d/share/shaders/k3d_smoke2.sl:156:  if (debug > 0) {
k3d/share/shaders/k3d_softboxes.sl:14:** $Id: k3d_softboxes.sl,v 1.1 2004/05/19 18:15:20 tshead Exp $
k3d/share/shaders/k3d_softboxes.sl:16:** Derived from softbox3 v1.2 - Author Bjorke for all
k3d/share/shaders/k3d_softboxes.sl:47:/* Superellipse soft clipping - straight out of "uberlight"		***/
k3d/share/shaders/k3d_softboxes.sl:51:/*      by  a,b and A,B for the inner and outer ellipses, respectively)	***/
k3d/share/shaders/k3d_softboxes.sl:55:/*   - smoothly varying from 0 to 1 in between				***/
k3d/share/shaders/k3d_softboxes.sl:58:/* this is the identical function used by sqLight etc */
k3d/share/shaders/k3d_softboxes.sl:62:    uniform float a, b;       /* Inner superellipse */
k3d/share/shaders/k3d_softboxes.sl:64:    uniform float roundness;  /* Same roundness for both ellipses */
k3d/share/shaders/k3d_softboxes.sl:67:    varying float x = abs(xcomp(Q)), y = abs(ycomp(Q));
k3d/share/shaders/k3d_softboxes.sl:70:	result = 1 - (1-smoothstep(a,A,x)) * (1-smoothstep(b,B,y));
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:82:/*** Given info on a softbox, ************************************/
k3d/share/shaders/k3d_softboxes.sl:85:void softbox_contrib2(
k3d/share/shaders/k3d_softboxes.sl:88:    uniform string	boxCoords;
k3d/share/shaders/k3d_softboxes.sl:89:    uniform string	boxTexture;
k3d/share/shaders/k3d_softboxes.sl:90:    uniform float	boxTexStr,
k3d/share/shaders/k3d_softboxes.sl:91:			boxTexBlur,
k3d/share/shaders/k3d_softboxes.sl:92:			boxFilter,
k3d/share/shaders/k3d_softboxes.sl:93:			boxWidth,
k3d/share/shaders/k3d_softboxes.sl:94:			boxHeight,
k3d/share/shaders/k3d_softboxes.sl:95:			boxWEdge,
k3d/share/shaders/k3d_softboxes.sl:96:			boxHEdge,
k3d/share/shaders/k3d_softboxes.sl:97:			boxRoundness;
k3d/share/shaders/k3d_softboxes.sl:98:    uniform color	boxColor,
k3d/share/shaders/k3d_softboxes.sl:99:    			boxOpac; 
k3d/share/shaders/k3d_softboxes.sl:105:    uniform string filtTypes[4] = {"gaussian","box","radial-bspline","disk"};
k3d/share/shaders/k3d_softboxes.sl:106:    uniform string theFilterName = filtTypes[clamp(boxFilter,0,3)];
k3d/share/shaders/k3d_softboxes.sl:107:    varying float contrib;
k3d/share/shaders/k3d_softboxes.sl:111:    varying point Pb1 = transform (boxCoords, surfPt);
k3d/share/shaders/k3d_softboxes.sl:112:    varying vector Vlight = vtransform (boxCoords, reflVect);
k3d/share/shaders/k3d_softboxes.sl:114:    varying point Pplane = Pb1 - Vlight*(zcomp(Pb1)/zcomp(Vlight));
k3d/share/shaders/k3d_softboxes.sl:116:    uniform float bw2 = boxWidth/2;
k3d/share/shaders/k3d_softboxes.sl:117:    uniform float bh2 = boxHeight/2;
k3d/share/shaders/k3d_softboxes.sl:119:#define bw2 boxWidth
k3d/share/shaders/k3d_softboxes.sl:120:#define bh2 boxHeight
k3d/share/shaders/k3d_softboxes.sl:122:    uniform float we = max(boxWEdge,-bw2);
k3d/share/shaders/k3d_softboxes.sl:123:    uniform float he = max(boxHEdge,-bh2);
k3d/share/shaders/k3d_softboxes.sl:124:    uniform float bW = bw2+we;
k3d/share/shaders/k3d_softboxes.sl:125:    uniform float bH = bh2+he;
k3d/share/shaders/k3d_softboxes.sl:126:    uniform float iW = min(bW,bw2);
k3d/share/shaders/k3d_softboxes.sl:127:    uniform float iH = min(bH,bh2);
k3d/share/shaders/k3d_softboxes.sl:128:    uniform float oW = max(bW,bw2);
k3d/share/shaders/k3d_softboxes.sl:129:    uniform float oH = max(bH,bh2);
k3d/share/shaders/k3d_softboxes.sl:130:    if (sign(zcomp(Pb1)) == sign(zcomp(Vlight))) {
k3d/share/shaders/k3d_softboxes.sl:131:	contrib = 0;
k3d/share/shaders/k3d_softboxes.sl:132:    } else if (abs(zv) < 0.0001) {
k3d/share/shaders/k3d_softboxes.sl:133:	contrib = 0;
k3d/share/shaders/k3d_softboxes.sl:135:	contrib = 1 - clipSuperellipse (Pplane, iW, iH, oW,oH, boxRoundness);
k3d/share/shaders/k3d_softboxes.sl:136:	if (boxTexture != "") {
k3d/share/shaders/k3d_softboxes.sl:138:	    textureinfo(boxTexture,"channels",nChans);
k3d/share/shaders/k3d_softboxes.sl:144:		ct = texture(boxTexture,theS,theT,
k3d/share/shaders/k3d_softboxes.sl:146:			    "blur",	boxTexBlur);
k3d/share/shaders/k3d_softboxes.sl:147:		if (boxTexStr != 1) {
k3d/share/shaders/k3d_softboxes.sl:148:		    ct = (ct*boxTexStr)+(1-boxTexStr);
k3d/share/shaders/k3d_softboxes.sl:158:		ot = float texture(boxTexture[alphaChan],theS,theT,
k3d/share/shaders/k3d_softboxes.sl:160:			    "blur",	boxTexBlur);
k3d/share/shaders/k3d_softboxes.sl:165:    varying point ppC = transform(boxCoords,"world",Pplane);
k3d/share/shaders/k3d_softboxes.sl:169:    theOpac = contrib * boxOpac * ot;
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:185:    uniform string filtTypes[2] = {"box", "gaussian"};
k3d/share/shaders/k3d_softboxes.sl:190:			    "blur",	theBlur,
k3d/share/shaders/k3d_softboxes.sl:192:			    "bias",	theBias);
k3d/share/shaders/k3d_softboxes.sl:200:light k3d_softboxes(
k3d/share/shaders/k3d_softboxes.sl:217:    string	boxCoord1	= "";
k3d/share/shaders/k3d_softboxes.sl:218:    color	boxColor1	= color (1,1,1),	/* multiplied by lightcolor&intensity */
k3d/share/shaders/k3d_softboxes.sl:219:		boxOpacity1	= color (1,1,1);
k3d/share/shaders/k3d_softboxes.sl:220:    float	boxWidth1	= 1,
k3d/share/shaders/k3d_softboxes.sl:221:		boxWEdge1	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:222:		boxHeight1	= 1,
k3d/share/shaders/k3d_softboxes.sl:223:		boxHEdge1	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:224:		boxRoundness1	= 0;
k3d/share/shaders/k3d_softboxes.sl:225:    string	boxTex1	= "";
k3d/share/shaders/k3d_softboxes.sl:226:    float	boxFilter1	= TEX_GAUSSIAN_FILT,
k3d/share/shaders/k3d_softboxes.sl:227:		boxTexStr1	= 1,
k3d/share/shaders/k3d_softboxes.sl:228:		boxTexBlur1	= 0;
k3d/share/shaders/k3d_softboxes.sl:229:    string	boxCoord2	= "";
k3d/share/shaders/k3d_softboxes.sl:230:    color	boxColor2	= color (1,1,1),	/* multiplied by lightcolor&intensity */
k3d/share/shaders/k3d_softboxes.sl:231:		boxOpacity2	= color (1,1,1);
k3d/share/shaders/k3d_softboxes.sl:232:    float	boxWidth2	= 1,
k3d/share/shaders/k3d_softboxes.sl:233:		boxWEdge2	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:234:		boxHeight2	= 1,
k3d/share/shaders/k3d_softboxes.sl:235:		boxHEdge2	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:236:		boxRoundness2	= 0;
k3d/share/shaders/k3d_softboxes.sl:237:    string	boxTex2	= "";
k3d/share/shaders/k3d_softboxes.sl:238:    float	boxFilter2	= TEX_GAUSSIAN_FILT,
k3d/share/shaders/k3d_softboxes.sl:239:		boxTexStr2	= 1,
k3d/share/shaders/k3d_softboxes.sl:240:		boxTexBlur2	= 0;
k3d/share/shaders/k3d_softboxes.sl:241:    string	boxCoord3	= "";
k3d/share/shaders/k3d_softboxes.sl:242:    color	boxColor3	= color (1,1,1),	/* multiplied by lightcolor&intensity */
k3d/share/shaders/k3d_softboxes.sl:243:		boxOpacity3	= color (1,1,1);
k3d/share/shaders/k3d_softboxes.sl:244:    float	boxWidth3	= 1,
k3d/share/shaders/k3d_softboxes.sl:245:		boxWEdge3	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:246:		boxHeight3	= 1,
k3d/share/shaders/k3d_softboxes.sl:247:		boxHEdge3	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:248:		boxRoundness3	= 0;
k3d/share/shaders/k3d_softboxes.sl:249:    string	boxTex3	= "";
k3d/share/shaders/k3d_softboxes.sl:250:    float	boxFilter3	= TEX_GAUSSIAN_FILT,
k3d/share/shaders/k3d_softboxes.sl:251:		boxTexStr3	= 1,
k3d/share/shaders/k3d_softboxes.sl:252:		boxTexBlur3	= 0;
k3d/share/shaders/k3d_softboxes.sl:253:    string	boxCoord4	= "";
k3d/share/shaders/k3d_softboxes.sl:254:    color	boxColor4	= color (1,1,1),	/* multiplied by lightcolor&intensity */
k3d/share/shaders/k3d_softboxes.sl:255:		boxOpacity4	= color (1,1,1);
k3d/share/shaders/k3d_softboxes.sl:256:    float	boxWidth4	= 1,
k3d/share/shaders/k3d_softboxes.sl:257:		boxWEdge4	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:258:		boxHeight4	= 1,
k3d/share/shaders/k3d_softboxes.sl:259:		boxHEdge4	= -0.1,
k3d/share/shaders/k3d_softboxes.sl:260:		boxRoundness4	= 0;
k3d/share/shaders/k3d_softboxes.sl:261:    string	boxTex4	= "";
k3d/share/shaders/k3d_softboxes.sl:262:    float	boxFilter4	= TEX_GAUSSIAN_FILT,
k3d/share/shaders/k3d_softboxes.sl:263:		boxTexStr4	= 1,
k3d/share/shaders/k3d_softboxes.sl:264:		boxTexBlur4	= 0;
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: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:287:    float   shadowblurc = 0.01,
k3d/share/shaders/k3d_softboxes.sl:288:	    shadowbiasc = 0,
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:297:    BOOL	ObeyMateria	= 0;
k3d/share/shaders/k3d_softboxes.sl:304:    uniform string rcsInfo = "$Id: k3d_softboxes.sl,v 1.1 2004/05/19 18:15:20 tshead Exp $";
k3d/share/shaders/k3d_softboxes.sl:305:    uniform string filtTypes[4] = {"gaussian","box","radial-bspline","disk"};
k3d/share/shaders/k3d_softboxes.sl:331:    if (ObeyMateria > 0) {
k3d/share/shaders/k3d_softboxes.sl:333:	    if (surface("abReflectivity",materiaRefl) == 0) {
k3d/share/shaders/k3d_softboxes.sl:344:	    if (surface("abReflectionMapBlur",materiaBlur) == 0) {
k3d/share/shaders/k3d_softboxes.sl:353:	    uniform float boxCt=0;
k3d/share/shaders/k3d_softboxes.sl:360:	    if (boxCoord1 != "") {
k3d/share/shaders/k3d_softboxes.sl:361:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:362:boxCoord1,boxTex1,boxTexStr1,
k3d/share/shaders/k3d_softboxes.sl:363:(boxTexBlur1+materiaBlur),boxFilter1,
k3d/share/shaders/k3d_softboxes.sl:364:		    boxWidth1,boxHeight1,boxWEdge1,boxHEdge1,
k3d/share/shaders/k3d_softboxes.sl:365:		    boxRoundness1,boxColor1,boxOpacity1,decayRate,
k3d/share/shaders/k3d_softboxes.sl:367:	    sortedDist[boxCt]  = thisDist;
k3d/share/shaders/k3d_softboxes.sl:368:	    sortedColor[boxCt] = thisColor;
k3d/share/shaders/k3d_softboxes.sl:369:	    sortedOpac[boxCt]  = thisOpac;
k3d/share/shaders/k3d_softboxes.sl:370:	    boxCt += 1;
k3d/share/shaders/k3d_softboxes.sl:372:	    if (boxCoord2 != "") {
k3d/share/shaders/k3d_softboxes.sl:373:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:374:boxCoord2,boxTex2,boxTexStr2,
k3d/share/shaders/k3d_softboxes.sl:375:(boxTexBlur2+materiaBlur),boxFilter2,
k3d/share/shaders/k3d_softboxes.sl:376:		    boxWidth2,boxHeight2,boxWEdge2,boxHEdge2,
k3d/share/shaders/k3d_softboxes.sl:377:		    boxRoundness2,boxColor2,boxOpacity2,decayRate,
k3d/share/shaders/k3d_softboxes.sl:379:	    sortedDist[boxCt]  = thisDist;
k3d/share/shaders/k3d_softboxes.sl:380:	    sortedColor[boxCt] = thisColor;
k3d/share/shaders/k3d_softboxes.sl:381:	    sortedOpac[boxCt]  = thisOpac;
k3d/share/shaders/k3d_softboxes.sl:382:	    boxCt += 1;
k3d/share/shaders/k3d_softboxes.sl:384:	    if (boxCoord3 != "") {
k3d/share/shaders/k3d_softboxes.sl:385:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:386:boxCoord3,boxTex3,boxTexStr3,
k3d/share/shaders/k3d_softboxes.sl:387:(boxTexBlur3+materiaBlur),boxFilter3,
k3d/share/shaders/k3d_softboxes.sl:388:		    boxWidth3,boxHeight3,boxWEdge3,boxHEdge3,
k3d/share/shaders/k3d_softboxes.sl:389:		    boxRoundness3,boxColor3,boxOpacity3,decayRate,
k3d/share/shaders/k3d_softboxes.sl:391:	    sortedDist[boxCt]  = thisDist;
k3d/share/shaders/k3d_softboxes.sl:392:	    sortedColor[boxCt] = thisColor;
k3d/share/shaders/k3d_softboxes.sl:393:	    sortedOpac[boxCt]  = thisOpac;
k3d/share/shaders/k3d_softboxes.sl:394:	    boxCt += 1;
k3d/share/shaders/k3d_softboxes.sl:396:	    if (boxCoord4 != "") {
k3d/share/shaders/k3d_softboxes.sl:397:	    softbox_contrib2(Ps,rv,
k3d/share/shaders/k3d_softboxes.sl:398:boxCoord4,boxTex4,boxTexStr4,
k3d/share/shaders/k3d_softboxes.sl:399:(boxTexBlur4+materiaBlur),boxFilter4,
k3d/share/shaders/k3d_softboxes.sl:400:		    boxWidth4,boxHeight4,boxWEdge4,boxHEdge4,
k3d/share/shaders/k3d_softboxes.sl:401:		    boxRoundness4,boxColor4,boxOpacity4,decayRate,
k3d/share/shaders/k3d_softboxes.sl:403:	    sortedDist[boxCt]  = thisDist;
k3d/share/shaders/k3d_softboxes.sl:404:	    sortedColor[boxCt] = thisColor;
k3d/share/shaders/k3d_softboxes.sl:405:	    sortedOpac[boxCt]  = thisOpac;
k3d/share/shaders/k3d_softboxes.sl:406:	    boxCt += 1;
k3d/share/shaders/k3d_softboxes.sl:416:		    Rs = vector( PShd + (pdotv + sqrt (abs (1 - pl + ((pdotv)*(pdotv)))))*Rs );
k3d/share/shaders/k3d_softboxes.sl:423:					    "blur", (envTexBlur+materiaBlur));
k3d/share/shaders/k3d_softboxes.sl:429:	    if (boxCt > 0) {
k3d/share/shaders/k3d_softboxes.sl:431:		for(k=0; k<(boxCt-1); k+=1) {
k3d/share/shaders/k3d_softboxes.sl:433:		    for(i=1; i<boxCt; i+=1) {
k3d/share/shaders/k3d_softboxes.sl:449:		for(k=0; k<boxCt; k+=1) {
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:467:	    shadowed = sbShadow(shadowname,Ps,shadowfilt,
k3d/share/shaders/k3d_softboxes.sl:468:			shadowblur,shadowsamples,shadowbias);
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:477:	    shadowed = sbShadow(shadownamec,Ps,shadowfiltc,
k3d/share/shaders/k3d_softboxes.sl:478:			shadowblurc,shadowsamplesc,shadowbiasc);
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_spacecloud.sl:2: * TLSpaceCloud.sl - perform turbulence function to add more dimension to
k3d/share/shaders/k3d_spacecloud.sl:3: *    texture-map and try to make it not so obvious that it is a texture-map.
k3d/share/shaders/k3d_spacecloud.sl:13: *   fuzz -- amount to blur the edges of the pulse
k3d/share/shaders/k3d_spacecloud.sl:14: *   minAdjust -- amount that can be subtracted from value
k3d/share/shaders/k3d_spacecloud.sl:15: *   maxAdjust -- amount that can be added to the value
k3d/share/shaders/k3d_spacecloud.sl:28: *  tal 2/23/97 -- Originally tried using fBm to create turbulence.  But
k3d/share/shaders/k3d_spacecloud.sl:43:#define smoothPulse2Fuzz(a, b, afuzz, bfuzz, loc) \
k3d/share/shaders/k3d_spacecloud.sl:45:   smoothstep (b, b+bfuzz, loc) )
k3d/share/shaders/k3d_spacecloud.sl:52:  float bfuzz = .2;
k3d/share/shaders/k3d_spacecloud.sl:72:	PP = transform ("object", P);
k3d/share/shaders/k3d_spacecloud.sl:75:    value += abs(snoise (PP * f))/f;
k3d/share/shaders/k3d_spacecloud.sl:93:		smoothPulse2Fuzz (startPulse, endPulse, bfuzz, afuzz, tt);
k3d/share/shaders/k3d_spaceshiphull1.sl:47:  // Add specular contribution
k3d/share/shaders/k3d_spaceshiphull1.sl:53:  Ci = Os * platecolor * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * platespecular * specular(Nf, V, roughness);
k3d/share/shaders/k3d_spotlight.sl:15:		    float beamdistribution = 2;)
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:7:// modify it under the terms of the GNU General Public
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:14:// General Public License for more details.
k3d/share/shaders/k3d_square_ridges.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_square_ridges.sl: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_srfdeformation.sl:1:/* renamed shader to SIG2k_srf_deformation to be consistent with RMR 
k3d/share/shaders/k3d_srfdeformation.sl:10:   object and deforms it to the P position
k3d/share/shaders/k3d_srfdeformation.sl:13:   measured by the change in diffuse lighting from the Pref to P.
k3d/share/shaders/k3d_srfdeformation.sl:18:   by Rob Bredow and Scott Stokdyk 
k3d/share/shaders/k3d_srfdeformation.sl:49:    float debug = 0;            /* 0 = deformed lit image
k3d/share/shaders/k3d_srfdeformation.sl:51:				   2 = output lighting of the P object
k3d/share/shaders/k3d_srfdeformation.sl:52:				   3 = output lighting of the Pref object
k3d/share/shaders/k3d_srfdeformation.sl:73:    /* Calculate shading difference between P and Porig*/
k3d/share/shaders/k3d_srfdeformation.sl:82:    /* These lighting loops can be enhanced to calculate
k3d/share/shaders/k3d_srfdeformation.sl:93:    /* Difference in lighting acts as brightness control*/
k3d/share/shaders/k3d_srfdeformation.sl:98:    if (debug == 1) {  /* output the texture - no lighting */
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:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_star.sl:50:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
k3d/share/shaders/k3d_starfield.sl:8:	AUTHOR: written by Timothy M. Shead
k3d/share/shaders/k3d_starfield.sl:13:	// Work in object coordinates ...
k3d/share/shaders/k3d_starfield.sl:14:	point PP = transform("object", frequency * P);
k3d/share/shaders/k3d_stones.sl:5: * Copyright (C) 2002, Rudy Cortes   rcortes@hntb.com
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:23: * displace = should the surface be bumped(0) or displaced (1)?
k3d/share/shaders/k3d_stones.sl:26: * stonecolor, groundcolor = this is obvious, isn't it?
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:46:#define fuzzpulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - \
k3d/share/shaders/k3d_stones.sl:47:         smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_stones.sl:59: * are all independently controlled.  Hue adds, but saturation and
k3d/share/shaders/k3d_stones.sl:61: * Original by Larry Gritz. Modified to "hsv" by Rudy Cortes
k3d/share/shaders/k3d_stones.sl:68:    /* Modify Chsv by adding Cvary scaled by our separate h,s,v controls */
k3d/share/shaders/k3d_stones.sl:73:    /* Clamp hsl and transform back to rgb space */
k3d/share/shaders/k3d_stones.sl:74:    return ctransform ("hsv", "rgb", clamp(Chsv,color 0, color 1));
k3d/share/shaders/k3d_stones.sl:104: float bub;
k3d/share/shaders/k3d_stones.sl:125:   /*tile index to be use in vary each*/
k3d/share/shaders/k3d_stones.sl:128:   /*create buble shapes*/
k3d/share/shaders/k3d_stones.sl:129:   bub = 0.5 + snoise2(10 * freq,10 * freq);
k3d/share/shaders/k3d_stones.sl:139:   /*mag= ((0.5 * .8 - abs(bub - 0.5)) / .8) * 60 *(.09 - d * d) *
k3d/share/shaders/k3d_stones.sl:141:   mag= (0.5 - abs(bub - 0.5)) * 90 *(.09 - d * d)*((maxfreq - freq)/maxfreq);
k3d/share/shaders/k3d_stones.sl:159:      /* compute turbulence  for grunge*/
k3d/share/shaders/k3d_stones.sl:164:        float turb = 0, f;
k3d/share/shaders/k3d_stones.sl:166:        turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:168:        turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:170:        grunge = pow(turb, grunge_Pow);
k3d/share/shaders/k3d_stones.sl:190:Ci = surface_color * Oi * (Ka * ambient() + Kd * diffuse(Nf))+
k3d/share/shaders/k3d_strata.sl:11: *    turbscale - how turbulent the layers are
k3d/share/shaders/k3d_strata.sl:13: *    octaves - number of octaves of noise to sum for the turbulence
k3d/share/shaders/k3d_strata.sl:20: *    C language version by F. Kenton Musgrave
k3d/share/shaders/k3d_strata.sl:21: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_strata.sl:24: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_strata.sl:29: *    ??? - original C language version by Ken Musgrave
k3d/share/shaders/k3d_strata.sl:30: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_strata.sl:38:		   float yscale = 2; float turbscale = 0.1; float offset = 0;
k3d/share/shaders/k3d_strata.sl:45:  float turb, i, freq;
k3d/share/shaders/k3d_strata.sl:49:  turb = 0;
k3d/share/shaders/k3d_strata.sl:53:      turb += abs(snoise(PP * freq) / freq);
k3d/share/shaders/k3d_strata.sl:57:  cmap = yscale * ycomp(PP) + turbscale * turb - offset;
k3d/share/shaders/k3d_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:13: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_superkagee.sl:21:    uniform string filtTypes[2] = {"box", "gaussian"};
k3d/share/shaders/k3d_superkagee.sl:28:                            "blur",     theBlur,
k3d/share/shaders/k3d_superkagee.sl:30:                            "bias",     theBias);
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: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:57:            float       shadowblurc = 0,
k3d/share/shaders/k3d_superkagee.sl:58:                        shadowbiasc = 0,
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:78:                    shadowfilta,shadowblura,shadowsamplesa,shadowbiasa
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:92:                    shadowfiltc,shadowblurc,shadowsamplesc,shadowbiasc
k3d/share/shaders/k3d_superkagee.sl:99:                    shadowfiltd,shadowblurd,shadowsamplesd,shadowbiasd
k3d/share/shaders/k3d_superplank.sl:7: *   reflections (either traced or via reflection map), and bumps.
k3d/share/shaders/k3d_superplank.sl:16: *   Km - overall scaling factor for bumpiness.
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:24: *   plankspertile - for parquet, number of sub-planks
k3d/share/shaders/k3d_superplank.sl:33: *   varnishbumpfreq - frequency of bumps in the varnish coating
k3d/share/shaders/k3d_superplank.sl:34: *   varnishbumpamp - height of bumps in the varnish coating
k3d/share/shaders/k3d_superplank.sl:36: * Antialiasing: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_superplank.sl:39: * Author: written by Larry Gritz
k3d/share/shaders/k3d_superplank.sl:54:			float Ka = 1, Kd = 1;	/* Overall ambient & diffuse response */
k3d/share/shaders/k3d_superplank.sl:62:			float Km = 1;	/* Overall bumpiness factor */
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:81:			float varnishbumpfreq = 30;	/* Bump freq of the varnish */
k3d/share/shaders/k3d_superplank.sl:82:			float varnishbumpamp = 0.0003;	/* How big are the varnish bumps? */
k3d/share/shaders/k3d_superplank.sl:101:  float grain;			/* 1 inside a grain bit, 0 elsewhere */
k3d/share/shaders/k3d_superplank.sl:120:   * Determine the basic mapping, filter sizes for antialiasing, other
k3d/share/shaders/k3d_superplank.sl:124:  /* First, determine the basic mapping */
k3d/share/shaders/k3d_superplank.sl:127:  /* Compute the basic filter size for antialiasing */
k3d/share/shaders/k3d_superplank.sl:134:   * the bumps scale relative to the overall pattern, rather than being
k3d/share/shaders/k3d_superplank.sl:135:   * strictly tied to the scale of the object.
k3d/share/shaders/k3d_superplank.sl:183:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_superplank.sl:184:   * antialiasing by trying to box filter the edges of the grooves.
k3d/share/shaders/k3d_superplank.sl:206:   * interact subtly.
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:254:  /* Combine the rings, grain, plank variation into one surface color */
k3d/share/shaders/k3d_superplank.sl:263:   * We do some bump mapping to make the grooves and grain depressed,
k3d/share/shaders/k3d_superplank.sl:270:      /* Random bumps on the varnish */
k3d/share/shaders/k3d_superplank.sl:271:      if(varnishbumpamp > 0)
k3d/share/shaders/k3d_superplank.sl:273:	  varnishbumpamp * (2 *
k3d/share/shaders/k3d_superplank.sl:274:			    noise(varnishbumpfreq * ss,
k3d/share/shaders/k3d_superplank.sl:275:				  varnishbumpfreq * tt) - 1);
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:313:    (1 - fresnelKr) * (Ct * (Ka * ambient() + Kd * diffuse(Nf))) +
k3d/share/shaders/k3d_superplank.sl:330:  /* Scale by opacity */
k3d/share/shaders/k3d_superpplastic.sl:10: *    by the s,t parameters of the surface.
k3d/share/shaders/k3d_superpplastic.sl:18:/* Modified to support filter type and aize, amount of image blur, nuber samples
k3d/share/shaders/k3d_superpplastic.sl:19:along S and T, fidelty and number of samples by Giueppe Zompatori joesunny@tiscalinet.it*/
k3d/share/shaders/k3d_superpplastic.sl:23:			  float filtertype = 1; float blur = 0.0;
k3d/share/shaders/k3d_superpplastic.sl:33:    filter = "box";
k3d/share/shaders/k3d_superpplastic.sl:43:    filter = "box";
k3d/share/shaders/k3d_superpplastic.sl:49:		    "blur", blur);
k3d/share/shaders/k3d_superpplastic.sl:57:    Os * (Cs * Ct * (Ka * ambient() + Kd * diffuse(Nf)) +
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:19: *                projected point before texture coordinates are extracted.
k3d/share/shaders/k3d_supertexmap.sl:20: *    truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_supertexmap.sl:26: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_supertexmap.sl:37:			/* base color */
k3d/share/shaders/k3d_supertexmap.sl:43:			float Csblur = 0;
k3d/share/shaders/k3d_supertexmap.sl:50:			float Osblur = 0;
k3d/share/shaders/k3d_supertexmap.sl:57:			float Ksblur = 0;
k3d/share/shaders/k3d_supertexmap.sl:64:			float dispblur = 0;
k3d/share/shaders/k3d_supertexmap.sl:69:   * by maps.
k3d/share/shaders/k3d_supertexmap.sl:79:			    array_to_mx(Csmx), Csblur);
k3d/share/shaders/k3d_supertexmap.sl:85:			    array_to_mx(Osmx), Osblur);
k3d/share/shaders/k3d_supertexmap.sl:91:			    array_to_mx(Ksmx), Ksblur);
k3d/share/shaders/k3d_supertexmap.sl:98:			      array_to_mx(dispmx), dispblur);
k3d/share/shaders/k3d_supertoon.sl:2: * <felipe@siggraph.org.mx>, abril 2002

k3d/share/shaders/k3d_supertoon.sl:5: * no se tenga un degradado en el cambio de color. En su lugar el cambio se

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_terran.sl:10:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran.sl:40:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terran.sl:41:  float bumpy;
k3d/share/shaders/k3d_terran.sl:49:   * Note: this section of code must be identical to "terranbump" if you
k3d/share/shaders/k3d_terran.sl:54:    {				/* use a "standard" fBm bump function */
k3d/share/shaders/k3d_terran.sl:57:      bumpy = 0;
k3d/share/shaders/k3d_terran.sl:60:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terran.sl:66:    {				/* use a "multifractal" fBm bump function */
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:77:	  /* get subsequent values, weighted by previous value */
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:85:  /* get the "height" of the bump, displacing by offset */
k3d/share/shaders/k3d_terran.sl:86:  chaos = bumpy + offset;
k3d/share/shaders/k3d_terran.sl:87:  /* set bump for land masses (i.e., areas above "sea level") */
k3d/share/shaders/k3d_terran.sl:96:   * Step 2: Assign a climite type, roughly by latitude.
k3d/share/shaders/k3d_terran.sl:99:  /* make climate symmetric about equator -- use the "v" parameter */
k3d/share/shaders/k3d_terran.sl:100:  latitude = abs(ycomp(PtN));
k3d/share/shaders/k3d_terran.sl:102:  /* fractally purturb color map offset using "chaos" */
k3d/share/shaders/k3d_terran.sl:103:  /*  "nonlinear" scales purturbation-by-z */
k3d/share/shaders/k3d_terran.sl:104:  /*  "purt_scale" scales overall purturbation */
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:117:       * suitable colors.  -- lg
k3d/share/shaders/k3d_terran.sl:175:    Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_terran2.sl:10: *   Earth-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_terran2.sl:11: *   turbulence and mottling techniques.
k3d/share/shaders/k3d_terran2.sl:12: *      Note that there is a companion displacement shader "terranbump"
k3d/share/shaders/k3d_terran2.sl:13: *   which is necessary to get the best effect.  If you do this, it is
k3d/share/shaders/k3d_terran2.sl:14: *   important that the parameters common to "terran" and "terranbump"
k3d/share/shaders/k3d_terran2.sl:15: *   both be set to the same values.  Otherwise you get bumpy mountains
k3d/share/shaders/k3d_terran2.sl:22: *                of the bump pattern.
k3d/share/shaders/k3d_terran2.sl:23: *    bump_scale - scaling of the mountains
k3d/share/shaders/k3d_terran2.sl:27: *    sea_level - obvious
k3d/share/shaders/k3d_terran2.sl:30: *               terrain type by latitude
k3d/share/shaders/k3d_terran2.sl:39: *    represented by a unit sphere.  The texture space and/or parameters
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:47: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_terran2.sl:54: *    ???? - original texture developed by F. Ken Musgrave.
k3d/share/shaders/k3d_terran2.sl:55: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_terran2.sl:56: *    1 March 1994 by lg
k3d/share/shaders/k3d_terran2.sl:66:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran2.sl:80:	  float bump_scale = 0.07;
k3d/share/shaders/k3d_terran2.sl:103:  float l, o, a, i, weight;      /* Loop variables for fBm calc */
k3d/share/shaders/k3d_terran2.sl:104:  float bumpy;
k3d/share/shaders/k3d_terran2.sl:112:   * Note: this section of code must be identical to "terranbump" if you
k3d/share/shaders/k3d_terran2.sl:116:  if (multifractal == 0) {	/* use a "standard" fBm bump function */
k3d/share/shaders/k3d_terran2.sl:117:      o = 1;  l = 1;  bumpy = 0;
k3d/share/shaders/k3d_terran2.sl:119:	  bumpy += o * snoise (l * Ptexture);
k3d/share/shaders/k3d_terran2.sl:124:  else {			/* use a "multifractal" fBm bump function */
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:133:	  /* get subsequent values, weighted by previous value */
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:141:  /* get the "height" of the bump, displacing by offset */
k3d/share/shaders/k3d_terran2.sl:142:  chaos = bumpy + offset;
k3d/share/shaders/k3d_terran2.sl:143:  /* set bump for land masses (i.e., areas above "sea level") */
k3d/share/shaders/k3d_terran2.sl:151:   * Step 2: Assign a climite type, roughly by latitude.
k3d/share/shaders/k3d_terran2.sl:154:  /* make climate symmetric about equator -- use the "v" parameter */
k3d/share/shaders/k3d_terran2.sl:155:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_terran2.sl:157:  /* fractally purturb color map offset using "chaos" */
k3d/share/shaders/k3d_terran2.sl:158:  /*  "nonlinear" scales purturbation-by-z */
k3d/share/shaders/k3d_terran2.sl:159:  /*  "purt_scale" scales overall purturbation */
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:170:       * suitable colors.  -- lg
k3d/share/shaders/k3d_terran2.sl:229:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_terranbump.sl:6:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terranbump.sl:17:displacement k3d_terranbump(float spectral_exp = 0.5;
k3d/share/shaders/k3d_terranbump.sl:19:			    float bump_scale = 0.04; float multifractal = 0;
k3d/share/shaders/k3d_terranbump.sl:25:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terranbump.sl:26:  float bumpy;
k3d/share/shaders/k3d_terranbump.sl:32:    {				/* use a "standard" fBm bump function */
k3d/share/shaders/k3d_terranbump.sl:35:      bumpy = 0;
k3d/share/shaders/k3d_terranbump.sl:38:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terranbump.sl:44:    {				/* use a "multifractal" fBm bump function */
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:55:	  /* get subsequent values, weighted by previous value */
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:63:  /* get the "height" of the bump, displacing by offset */
k3d/share/shaders/k3d_terranbump.sl:64:  chaos = bumpy + offset;
k3d/share/shaders/k3d_terranbump.sl:66:  /* set bump for land masses (i.e., areas above "sea level") */
k3d/share/shaders/k3d_terranbump.sl:68:    P += (bump_scale * bumpy) * normalize(Ng);
k3d/share/shaders/k3d_texblender.sl:11:color altMaterialPlastic (normal Nf;  color basecolor,selftcolor,Rcolor,RFcolor;
k3d/share/shaders/k3d_texblender.sl:15:    return (basecolor * ( Ka*ambient() + Kd*diffuse(Nf)+selft*selftcolor ) )
k3d/share/shaders/k3d_texblender.sl:21:myEnvironment (point P;  vector R;  float Kr, blur;  DECLARE_ENVPARAMS;)
k3d/share/shaders/k3d_texblender.sl:27:            C = ReflMap (envname, P, blur, alpha);
k3d/share/shaders/k3d_texblender.sl:29:            C = Environment (envname, envspace, envrad, P, R, blur, alpha);
k3d/share/shaders/k3d_texblender.sl:34:    color Cray = RayTrace (P, R, Kr, sqrt(blur), rayjitter, raysamples, alpha);
k3d/share/shaders/k3d_texblender.sl:44:	x=abs(xcomp(p));
k3d/share/shaders/k3d_texblender.sl:45:	x+=abs(ycomp(p));
k3d/share/shaders/k3d_texblender.sl:46:	x+=abs(zcomp(p));
k3d/share/shaders/k3d_texblender.sl:92:		float scalex, scaley, scalez, octaves, blur;)
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:132:k3d_texblender (float Ka = 1, Kd = .5, Ks = .2, roughness = .3, Kr=0,selft=0;
k3d/share/shaders/k3d_texblender.sl:133:		float Rblur=0.1,RFblur=0.1;
k3d/share/shaders/k3d_texblender.sl:140:		float bKmap[5]={0,0,0,0,0};
k3d/share/shaders/k3d_texblender.sl:148:		float Gblur[5]={0,0,0,0,0};
k3d/share/shaders/k3d_texblender.sl:150:		string Gspace[5]={"object","object","object","object","object"};
k3d/share/shaders/k3d_texblender.sl:159:    vector V ,D,badN,corr,dispDir,ndir;
k3d/share/shaders/k3d_texblender.sl:169:											Depth[i],Gblur[i]);
k3d/share/shaders/k3d_texblender.sl:181:		if((Alpha*bKmap[i])!=0) disp=BlendFloat(mode,Alpha*bKmap[i],MF,disp);
k3d/share/shaders/k3d_texblender.sl:193:	color env=0,benv=0;
k3d/share/shaders/k3d_texblender.sl:199:		if(Rblur==0) raysamples=1;
k3d/share/shaders/k3d_texblender.sl:200:		env=myEnvironment(P,normalize(reflect(V,Nf)),1,Rblur,ENVPARAMS);
k3d/share/shaders/k3d_texblender.sl:204:		if(RFblur==0) raysamples=1;
k3d/share/shaders/k3d_texblender.sl:206:		benv=myEnvironment(P,refract(V,Nf,(V.Nf > 0) ? 1.0/eta : eta),1,RFblur,ENVPARAMS);
k3d/share/shaders/k3d_texblender.sl:208:    Ci = altMaterialPlastic (Nf,Ct,Cselft,env,benv,
k3d/share/shaders/k3d_threads.sl:3:/* Listing 16.24  Displacement shader providing light-bulb threads to cylinder */
k3d/share/shaders/k3d_tooledsteel.sl:1:/*  tooledsteel.sl written 9/99 by Ivan DeWolf
k3d/share/shaders/k3d_tooledsteel.sl:3: *  feel free to copy, distribute, hack and/or abuse this code 
k3d/share/shaders/k3d_tooledsteel.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_tooledsteel.sl:6: *  a combination of IDbrushedmetal.sl and the Worley-esque
k3d/share/shaders/k3d_tooledsteel.sl:7: *  F1 from bubbly.sl adapted to happen in parameter space.
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:21: *  Ka			- coefficient of ambient
k3d/share/shaders/k3d_tooledsteel.sl:46:  float a,b,c;
k3d/share/shaders/k3d_tooledsteel.sl:68:    for(b = -1; b<=1; b += 1){
k3d/share/shaders/k3d_tooledsteel.sl:69:	offset = vector(a,b,c);
k3d/share/shaders/k3d_tooledsteel.sl:100:    color pixbrdf, C = 0;
k3d/share/shaders/k3d_tooledsteel.sl:113:	    pixbrdf  = specularbrdf(LN, Nf,V,specspread);
k3d/share/shaders/k3d_tooledsteel.sl:114:            C += Cl * pixbrdf * pow( 1-abs(VA.H), 1/specwidth );
k3d/share/shaders/k3d_tooledsteel.sl:137:	point Po = transform("object",P);
k3d/share/shaders/k3d_tooledsteel.sl:159:	      ev += environment(mapname, D)*(.5-abs((i/numsamples)-.5))*.25;
k3d/share/shaders/k3d_tooledsteel.sl:165:	Ci = Oi * (Cs * (Ka * ambient() + Kd * diffuse(-Nf)) + 
k3d/share/shaders/k3d_toonmap.sl:104:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_toonmap.sl:105:#define union(a,b) ((a) + (b) - (a) * (b))
k3d/share/shaders/k3d_toonmap.sl:131:/* background layer (layer 0) */
k3d/share/shaders/k3d_toonmap.sl:137:/* only care about percentage illumination */
k3d/share/shaders/k3d_toonmap.sl:149:layer_color = Cs*(Kd*diff*temt_c3 + Ka*ambient()) + temt_c4*Ks*spec;
k3d/share/shaders/k3d_toonmap.sl:152:toon_color = blend(toon_color, layer_color, layer_opac);
k3d/share/shaders/k3d_toonmap.sl:160:layer_opac = 1 - smoothstep(ink_thresh - ink_fuzz/2, ink_thresh + ink_fuzz/2, abs(cos_here));
k3d/share/shaders/k3d_toonmap.sl:162:if (abs(cos_here) < ink_thresh)
k3d/share/shaders/k3d_toonmap.sl:167:toon_color = blend(toon_color, layer_color, layer_opac);
k3d/share/shaders/k3d_translucency.sl:4:* Shader: Double side translucency shader
k3d/share/shaders/k3d_translucency.sl:11:* Description:  It's possible to use one different color and
k3d/share/shaders/k3d_translucency.sl:12:*		translucency texture for each side of a flat object
k3d/share/shaders/k3d_translucency.sl:17:* Tips & Tricks: The transTx and TransTx2 values can be used,
k3d/share/shaders/k3d_translucency.sl:20:*		 It burns out the surface color.
k3d/share/shaders/k3d_translucency.sl:22:* Notes: Please send me any kind of suggestions or bugs.
k3d/share/shaders/k3d_translucency.sl:26:* Shader birthdate: 31-08-2000
k3d/share/shaders/k3d_translucency.sl:39:			float blurcolorTx = 0;
k3d/share/shaders/k3d_translucency.sl:41:			float blurcolorTx2 = 0;
k3d/share/shaders/k3d_translucency.sl:48:			float transblurTx = 0;
k3d/share/shaders/k3d_translucency.sl:51:			float transblurTx2 = 0;
k3d/share/shaders/k3d_translucency.sl:60:	/*Velvet illuminance loop variable*/
k3d/share/shaders/k3d_translucency.sl:82:			Ct = color texture(colorTx, ss, tt, "blur", blurcolorTx) + (1-opac)*Cs;
k3d/share/shaders/k3d_translucency.sl:88:			Ct = color texture(colorTx2, ss, tt, "blur", blurcolorTx2) + (1-opac)*Cs;
k3d/share/shaders/k3d_translucency.sl:99:			 Kt = float texture(transTex[0], ss, tt, "blur", transblurTx);
k3d/share/shaders/k3d_translucency.sl:105:			 Kt = float texture(transTex2[0], ss, tt, "blur", transblurTx2);
k3d/share/shaders/k3d_translucency.sl:127:	Ci = Ct * (Ka*ambient() + Kd*diffuse(Nf) + Kt*diffuse(-Nf)) + Ks*specular(Nf,V,roughness) + shiny;
k3d/share/shaders/k3d_uberlight.sl:2: * uberlight.sl - a light with many fun controls.
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:17: * Basic color/brightness controls:
k3d/share/shaders/k3d_uberlight.sl:26: *       BMRT area lights for the time being).
k3d/share/shaders/k3d_uberlight.sl:33: *       for the cuton and cutoff.  The transitions will be smooth.
k3d/share/shaders/k3d_uberlight.sl:35: *       default) indicates that the light is the same brightness
k3d/share/shaders/k3d_uberlight.sl:38: *       (which is physically correct for point-like sources, but
k3d/share/shaders/k3d_uberlight.sl:42: *       is actually given by:   I = (falloffdist / distance) ^ falloff
k3d/share/shaders/k3d_uberlight.sl:43: *   maxintensity - to prevent the light from becoming unboundedly
k3d/share/shaders/k3d_uberlight.sl:52: * is actually described by a superellipse with the following
k3d/share/shaders/k3d_uberlight.sl:57: *   width, height - define the dimensions of the "barn door" opening.
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:69: *   beamdistribution - controls intensity falloff due to angle.
k3d/share/shaders/k3d_uberlight.sl:75: *       make the spot more bright in the center than the outskirts.
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:82: *       make a texture map that simply blocks light, just make it
k3d/share/shaders/k3d_uberlight.sl:83: *       black-and-white, but store it as an RGB texture.  For
k3d/share/shaders/k3d_uberlight.sl:89: *       means not to use noise.  Larger values increase the blotchiness
k3d/share/shaders/k3d_uberlight.sl:92: *   noiseoffset - spatial offset of the noise.  This can be animated,
k3d/share/shaders/k3d_uberlight.sl:98: * shadows are mainly computed by shadow maps.  Please consult the
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: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:111: *   nshadowrays - The number of rays to trace to determine shadowing.
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:120: * superellipse.  The blocker is defined to lie on the x-y plane of
k3d/share/shaders/k3d_uberlight.sl:121: * its own coordinate system (which obviously needs to be defined in
k3d/share/shaders/k3d_uberlight.sl:123: *   blockercoords - the name of the coordinate system that defines the
k3d/share/shaders/k3d_uberlight.sl:124: *       local coordinates of the blocker.  If this is "", it indicates 
k3d/share/shaders/k3d_uberlight.sl:125: *       that the shader should not use a blocker at all.
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:135: *       defined by any or all of the shadow map, ray cast, or
k3d/share/shaders/k3d_uberlight.sl:136: *       blocker) don't actually have to block light.  In fact, in
k3d/share/shaders/k3d_uberlight.sl:139: *       (0,0,0), it effectively blocks all light.  But if you set it
k3d/share/shaders/k3d_uberlight.sl:141: *       their full brightness but not go completely dark.  Another
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:152: *       explained above).  This is very handy for lights that are
k3d/share/shaders/k3d_uberlight.sl:153: *       meant to be fill lights, rather than key lights.
k3d/share/shaders/k3d_uberlight.sl:155: *       correctly acting upon, this parameter.  The built-in functions
k3d/share/shaders/k3d_uberlight.sl:162: *       1, this light will only cast specular highlights but not
k3d/share/shaders/k3d_uberlight.sl:166: *       respect to the surface shader, as described above for
k3d/share/shaders/k3d_uberlight.sl:168: *   __foglight - the "noisysmoke" shader distributed with BMRT will add
k3d/share/shaders/k3d_uberlight.sl:173: *       Note that the noisysmoke shader is distributed with BMRT but
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:185: * (co-chaired by Tony Apodaca and Larry Gritz).  Feel free to use and
k3d/share/shaders/k3d_uberlight.sl:186: * distribute the source code of this shader, but please leave the
k3d/share/shaders/k3d_uberlight.sl:187: * original attribution and all comments.
k3d/share/shaders/k3d_uberlight.sl:192: * older versions of these renderers, but I do make liberal use of the
k3d/share/shaders/k3d_uberlight.sl:193: * "vector" type and I often declare variables where they are used,
k3d/share/shaders/k3d_uberlight.sl:194: * rather than only at the beginning of blocks.  If you are using a
k3d/share/shaders/k3d_uberlight.sl:196: * substitute "point" for all occurrances of "vector", and move the
k3d/share/shaders/k3d_uberlight.sl:197: * variable declarations to the top of the shader.
k3d/share/shaders/k3d_uberlight.sl:199: * Author: coded by Larry Gritz, 1998
k3d/share/shaders/k3d_uberlight.sl:200: *         based on paper by Ronen Barzel, 1997
k3d/share/shaders/k3d_uberlight.sl:219: *   - the equations of two superellipses (with major/minor axes given by
k3d/share/shaders/k3d_uberlight.sl:220: *        a,b and A,B for the inner and outer ellipses, respectively)
k3d/share/shaders/k3d_uberlight.sl:224: *   - smoothly varying from 0 to 1 in between
k3d/share/shaders/k3d_uberlight.sl:227:		       float a, b;	/* Inner superellipse */
k3d/share/shaders/k3d_uberlight.sl:229:		       float roundness;	/* Same roundness for both ellipses */
k3d/share/shaders/k3d_uberlight.sl:233:  float x = abs(xcomp(Q)), y = abs(ycomp(Q));
k3d/share/shaders/k3d_uberlight.sl:239:	  result = 1 - (1 - smoothstep(a, A, x)) * (1 - smoothstep(b, B, y));
k3d/share/shaders/k3d_uberlight.sl:248:	  float q = a * b / sqrt(sqr(b * x) + sqr(a * y));
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:270: *   - the point being shaded, in the local light space
k3d/share/shaders/k3d_uberlight.sl:271: *   - all information about the light shaping, including z smooth depth
k3d/share/shaders/k3d_uberlight.sl:274: *   - attenuation factor based on the falloff and shaping
k3d/share/shaders/k3d_uberlight.sl:286:		       float beamdistribution;	/* angle falloff */
k3d/share/shaders/k3d_uberlight.sl:289:  /* Examine the z depth of PL to apply the (possibly smooth) cuton and
k3d/share/shaders/k3d_uberlight.sl:317:	  float beta = -falloff / s;
k3d/share/shaders/k3d_uberlight.sl:318:	  atten *= (maxintensity * exp(s * pow(PLlen / falloffdist, beta)));
k3d/share/shaders/k3d_uberlight.sl:323:  if(lighttype != "omni" && beamdistribution > 0)
k3d/share/shaders/k3d_uberlight.sl:324:    atten *= pow(zcomp(normalize(vector PL)), beamdistribution);
k3d/share/shaders/k3d_uberlight.sl:338:/* Evaluate the occlusion between two points, P1 and P2, due to a fake
k3d/share/shaders/k3d_uberlight.sl:339: * blocker.  Return 0 if the light is totally blocked, 1 if it totally
k3d/share/shaders/k3d_uberlight.sl:342:float BlockerContribution(point P1, P2;
k3d/share/shaders/k3d_uberlight.sl:343:			  string blockercoords;
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:346:			  float blockerround;
k3d/share/shaders/k3d_uberlight.sl:350:  /* Get the surface and light positions in blocker coords */
k3d/share/shaders/k3d_uberlight.sl:351:  point Pb1 = transform(blockercoords, P1);
k3d/share/shaders/k3d_uberlight.sl:352:  point Pb2 = transform(blockercoords, P2);
k3d/share/shaders/k3d_uberlight.sl:353:  /* Blocker works only if it's straddled by ray endpoints. */
k3d/share/shaders/k3d_uberlight.sl:354:  if(zcomp(Pb2) * zcomp(Pb1) < 0)
k3d/share/shaders/k3d_uberlight.sl:356:      vector Vlight = (Pb1 - Pb2);
k3d/share/shaders/k3d_uberlight.sl:357:      point Pplane = Pb1 - Vlight * (zcomp(Pb1) / zcomp(Vlight));
k3d/share/shaders/k3d_uberlight.sl:359:	clipSuperellipse(Pplane, blockerwidth, blockerheight,
k3d/share/shaders/k3d_uberlight.sl:360:			 blockerwidth + blockerwedge,
k3d/share/shaders/k3d_uberlight.sl:361:			 blockerheight + blockerhedge, blockerround);
k3d/share/shaders/k3d_uberlight.sl:369:light k3d_uberlight(
k3d/share/shaders/k3d_uberlight.sl:382:		     float beamdistribution = 0;
k3d/share/shaders/k3d_uberlight.sl:390:		     float shadowblur = 0.01, shadowbias = .01, shadownsamps =
k3d/share/shaders/k3d_uberlight.sl:396:		     /* Fake blocker shadow */
k3d/share/shaders/k3d_uberlight.sl:397:		     string blockercoords = "";
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:400:		     .1, blockerround = 1;
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:418:   * geometry.  If not an area light, BMRT guarantees P,N will be the
k3d/share/shaders/k3d_uberlight.sl:431:      uniform float maxradius = 1.4142136 * max(height + hedge + abs(sheary),
k3d/share/shaders/k3d_uberlight.sl:432:						width + wedge + abs(shearx));
k3d/share/shaders/k3d_uberlight.sl:447:    /* Accumulate attenuation of the light as it is affected by various
k3d/share/shaders/k3d_uberlight.sl:448:     * blockers and whatnot.  Start with no attenuation (i.e., a 
k3d/share/shaders/k3d_uberlight.sl:461:		       beamdistribution);
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:489:	    1 - shadow(shadowmap, Ps, "blur", shadowblur, "samples",
k3d/share/shaders/k3d_uberlight.sl:490:		       shadownsamps, "bias", shadowbias);
k3d/share/shaders/k3d_uberlight.sl:505:	      vis += visibility(Ps, shadoworigin + shadowcheat);
k3d/share/shaders/k3d_uberlight.sl:510:	/* Apply blocker fake shadows */
k3d/share/shaders/k3d_uberlight.sl:511:	if(blockercoords != "")
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:516:				  blockerhedge, blockerround);
k3d/share/shaders/k3d_urbermap.sl:3:surface k3d_urbermap (
k3d/share/shaders/k3d_urbermap.sl:5:string abColorMap="I:/ArtWorks/Textures/Batik_1.4.tif"; 
k3d/share/shaders/k3d_urbermap.sl:6:float abColorMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:7:float abUseColorMapAlpha=0; 
k3d/share/shaders/k3d_urbermap.sl:8:float abDiffuse=0.8; 
k3d/share/shaders/k3d_urbermap.sl:9:string abDiffuseMap="I:/ArtWorks/Textures/BubbaWeb_1.1.3.tif"; 
k3d/share/shaders/k3d_urbermap.sl:10:float abDiffuseMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:11:float abSpecular=0.3; 
k3d/share/shaders/k3d_urbermap.sl:12:string abSpecularMap="I:/ArtWorks/Textures/Curlitron_1.1.tif"; 
k3d/share/shaders/k3d_urbermap.sl:13:float abSpecularMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:14:color abSpecularColor=color(1.00,1.00,1.00); 
k3d/share/shaders/k3d_urbermap.sl:15:string abSpecularColorMap="I:/ArtWorks/Textures/Native_1.2.highlight.tif"; 
k3d/share/shaders/k3d_urbermap.sl:16:float abSpecularColorMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:17:float abRoughness=0.3; 
k3d/share/shaders/k3d_urbermap.sl:18:string abRoughnessMap="I:/ArtWorks/Textures/Native_1.2.shadow.tif"; 
k3d/share/shaders/k3d_urbermap.sl:19:float abRoughnessMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:20:string abTransparencyMap="I:/ArtWorks/Textures/Native_1.2.tif"; 
k3d/share/shaders/k3d_urbermap.sl:21:float abInvertTransparencyMap=0; 
k3d/share/shaders/k3d_urbermap.sl:22:float abTransparencyMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:23:color abIncandescence=color(0.00,0.00,0.00); 
k3d/share/shaders/k3d_urbermap.sl:24:string abIncandescenseMap="I:/ArtWorks/Textures/BubbaWeb_1.1.3.tif"; 
k3d/share/shaders/k3d_urbermap.sl:25:float abIncandescenseMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:26:string abReflectionMap="I:/ArtWorks/Textures/Batik_1.4.tif"; 
k3d/share/shaders/k3d_urbermap.sl:27:float abReflectionUp=0; 
k3d/share/shaders/k3d_urbermap.sl:28:float abReflectivity=0.1; 
k3d/share/shaders/k3d_urbermap.sl:29:float abReflectionMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:30:string abBumpMap="I:/ArtWorks/Textures/Curlitron_1.1.tif"; 
k3d/share/shaders/k3d_urbermap.sl:31:float abBumpMapBlur=1; 
k3d/share/shaders/k3d_urbermap.sl:32:float abBumpScale=1; 
k3d/share/shaders/k3d_urbermap.sl:33:float abDoDisplacement=0; 
k3d/share/shaders/k3d_urbermap.sl:34:float abUseNormals=0; 
k3d/share/shaders/k3d_urbermap.sl:44:float ss, tt, roughness, diff, spec, bmp;
k3d/share/shaders/k3d_urbermap.sl:51:if(abColorMap != "")
k3d/share/shaders/k3d_urbermap.sl:53:Csurf = Cs * color texture(abColorMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:54:"swidth", abColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:55:"twidth", abColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:56:if(abUseColorMapAlpha != 0)
k3d/share/shaders/k3d_urbermap.sl:58:Copac = float texture(abColorMap[3], ss, tt,
k3d/share/shaders/k3d_urbermap.sl:59:"swidth", abColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:60:"twidth", abColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:76:if(abDiffuseMap != "")
k3d/share/shaders/k3d_urbermap.sl:78:diff = abDiffuse * float texture(abDiffuseMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:79:"swidth", abDiffuseMapBlur,
k3d/share/shaders/k3d_urbermap.sl:80:"twidth", abDiffuseMapBlur );
k3d/share/shaders/k3d_urbermap.sl:84:diff = abDiffuse;
k3d/share/shaders/k3d_urbermap.sl:88:if(abSpecularMap != "")
k3d/share/shaders/k3d_urbermap.sl:90:spec = abSpecular * float texture(abSpecularMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:91:"swidth", abSpecularMapBlur,
k3d/share/shaders/k3d_urbermap.sl:92:"twidth", abSpecularMapBlur );
k3d/share/shaders/k3d_urbermap.sl:96:spec = abSpecular;
k3d/share/shaders/k3d_urbermap.sl:100:if(abSpecularColorMap != "")
k3d/share/shaders/k3d_urbermap.sl:102:Cspec = abSpecularColor * color texture(abSpecularColorMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:103:"swidth", abSpecularColorMapBlur,
k3d/share/shaders/k3d_urbermap.sl:104:"twidth", abSpecularColorMapBlur );
k3d/share/shaders/k3d_urbermap.sl:108:Cspec = abSpecularColor;
k3d/share/shaders/k3d_urbermap.sl:112:if(abRoughnessMap != "")
k3d/share/shaders/k3d_urbermap.sl:114:roughness = abRoughness * float texture(abRoughnessMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:115:"swidth", abRoughnessMapBlur,
k3d/share/shaders/k3d_urbermap.sl:116:"twidth", abRoughnessMapBlur );
k3d/share/shaders/k3d_urbermap.sl:120:roughness = abRoughness;
k3d/share/shaders/k3d_urbermap.sl:124:if(abTransparencyMap != "")
k3d/share/shaders/k3d_urbermap.sl:126:if(abInvertTransparencyMap != 0)
k3d/share/shaders/k3d_urbermap.sl:128:Copac = Copac * color texture(abTransparencyMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:129:"swidth", abTransparencyMapBlur,
k3d/share/shaders/k3d_urbermap.sl:130:"twidth", abTransparencyMapBlur );
k3d/share/shaders/k3d_urbermap.sl:134:Copac = Copac * (color(1) - color texture(abTransparencyMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:135:"swidth", abTransparencyMapBlur,
k3d/share/shaders/k3d_urbermap.sl:136:"twidth", abTransparencyMapBlur ));
k3d/share/shaders/k3d_urbermap.sl:141:if(abIncandescenseMap != "")
k3d/share/shaders/k3d_urbermap.sl:143:Cincand = abIncandescence * color texture(abIncandescenseMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:144:"swidth", abIncandescenseMapBlur,
k3d/share/shaders/k3d_urbermap.sl:145:"twidth", abIncandescenseMapBlur );
k3d/share/shaders/k3d_urbermap.sl:149:Cincand = abIncandescence;
k3d/share/shaders/k3d_urbermap.sl:154:if( abBumpMap != "" )
k3d/share/shaders/k3d_urbermap.sl:156:bmp = abBumpScale * float texture( abBumpMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:157:"swidth", abBumpMapBlur,
k3d/share/shaders/k3d_urbermap.sl:158:"twidth", abBumpMapBlur );
k3d/share/shaders/k3d_urbermap.sl:161:PP += bmp * Nf;
k3d/share/shaders/k3d_urbermap.sl:165:if (abUseNormals == 1) {
k3d/share/shaders/k3d_urbermap.sl:170:if( abDoDisplacement == 1.0 )
k3d/share/shaders/k3d_urbermap.sl:183:if( abReflectionMap != "" )
k3d/share/shaders/k3d_urbermap.sl:187:if( abReflectionUp != 0 )
k3d/share/shaders/k3d_urbermap.sl:191:Crefl = abReflectivity *
k3d/share/shaders/k3d_urbermap.sl:192:color environment(abReflectionMap, D,
k3d/share/shaders/k3d_urbermap.sl:193:"swidth", abReflectionMapBlur,
k3d/share/shaders/k3d_urbermap.sl:194:"twidth", abReflectionMapBlur );
k3d/share/shaders/k3d_urbermap.sl:201:Ci = Csurf * (Cincand + ambient() + diff * diffuse(Nf)) + (spec * Cspec * (specular(Nf, V, roughness) + Crefl));
k3d/share/shaders/k3d_veinedmarble.sl:2: * veinedmarble.sl -- surface shader for a nice veined marble.
k3d/share/shaders/k3d_veinedmarble.sl:5: *   Makes solid marble texture with strong veins.  The "veincolor" parameter
k3d/share/shaders/k3d_veinedmarble.sl:6: *   controls the color of the veins.  The background color is given by the
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:24: * last modified  29 Jun 1994 by Larry Gritz
k3d/share/shaders/k3d_veinedmarble.sl:32:surface k3d_veinedmarble(float Ka = .5;
k3d/share/shaders/k3d_veinedmarble.sl:47:  float i, turb, freq;
k3d/share/shaders/k3d_veinedmarble.sl:48:  float turbsum;
k3d/share/shaders/k3d_veinedmarble.sl:56:  turbsum = 0;
k3d/share/shaders/k3d_veinedmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_veinedmarble.sl:62:      turb = pow(smoothstep(0.8, 1, 1 - turb), sharpness) / freq;
k3d/share/shaders/k3d_veinedmarble.sl:63:      turbsum += (1 - turbsum) * turb;
k3d/share/shaders/k3d_veinedmarble.sl:68:  Ct = mix(Cs, veincolor, turbsum);
k3d/share/shaders/k3d_velvet.sl:9: *   - A retroreflective lobe (back toward the light source)
k3d/share/shaders/k3d_velvet.sl:14: *   Ks:	controls retroreflective lobe
k3d/share/shaders/k3d_velvet.sl:16: *   Ka:	ambient component (affects diffuse color only)
k3d/share/shaders/k3d_velvet.sl:17: *   sheen:	color of retroreflective lobe and horizon scattering
k3d/share/shaders/k3d_velvet.sl:18: *   roughness: shininess of fabric (controls retroreflection only)
k3d/share/shaders/k3d_velvet.sl:22: * AUTHOR: written by Stephen H. Westin, Ford Motor Company
k3d/share/shaders/k3d_velvet.sl:26: *			Fixed retroreflection lobe (sign error); added
k3d/share/shaders/k3d_velvet.sl:27: *			"backscatter" parameter to control it; added
k3d/share/shaders/k3d_velvet.sl:40:	    float backscatter = 0.1,
k3d/share/shaders/k3d_velvet.sl:59:    /* Retroreflective lobe */
k3d/share/shaders/k3d_velvet.sl:61:    shiny += pow ( cosine, 1.0/roughness ) * backscatter
k3d/share/shaders/k3d_velvet.sl:71:  Ci = Os * (Ka*ambient() + Kd*diffuse(Nf)) * Cs + shiny;
k3d/share/shaders/k3d_venus.sl:8: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus.sl:19: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus.sl:24: *    represented by a unit sphere.  The texture space and/or parameters
k3d/share/shaders/k3d_venus.sl:25: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_venus.sl:30: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus.sl:34: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_venus.sl:40: *    ???? - Venus texture developed by F. Ken Musgrave.
k3d/share/shaders/k3d_venus.sl:41: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus.sl:43: * last modified 1 March 1994 by lg
k3d/share/shaders/k3d_venus.sl:61:  point PP;			/* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus.sl:92:  value = abs(offset + scale * a);
k3d/share/shaders/k3d_venus.sl:94:  /* Shade like matte, but with color scaled by cloud color */
k3d/share/shaders/k3d_venus.sl:97:    Os * (value * Cs) * (Ka * ambient() +
k3d/share/shaders/k3d_venus2.sl:10: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus2.sl:21: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus2.sl:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus2.sl:27: *    Planet radius param added by Mark Beckwith.
k3d/share/shaders/k3d_venus2.sl:30: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_venus2.sl:36: *    ???? - Venus texture developed by F. Ken Musgrave.
k3d/share/shaders/k3d_venus2.sl:37: *    Feb 1994 - Conversion to Shading Language by L. Gritz
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:63:  point PP;                 /* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus2.sl:91:  value = abs (offset + scale * a);
k3d/share/shaders/k3d_venus2.sl:93:  /* Shade like matte, but with color scaled by cloud color */
k3d/share/shaders/k3d_venus2.sl:95:  Ci = Os * (value * Cs) * (Ka * ambient() +
k3d/share/shaders/k3d_volcube.sl:1:/* srf_vol_cube - Brian Steiner - Sony Pictures Imageworks
k3d/share/shaders/k3d_volcube.sl:3:   This shader raytraces a box that is one unit in size,
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:21:/* fnc_traceBox returns an intersection point on a box */
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:138:    Nd = ntransform("object","current",Nd);
k3d/share/shaders/k3d_volcube.sl:160:	spec += Cl * specularbrdf(L, Nf, V, Roughness);
k3d/share/shaders/k3d_volcube.sl:187:k3d_volcube(float  StepSize       = 1;
k3d/share/shaders/k3d_volcube.sl:200:    point  inPoint_obj  = transform("object",P);
k3d/share/shaders/k3d_volcube.sl:201:    point  outPoint_obj = fnc_traceBox(-.501,.501,-.501,.501,-.501,.501,1,"object");
k3d/share/shaders/k3d_volcube.sl:207:    float  vol_length   = length(outPoint_obj-inPoint_obj);
k3d/share/shaders/k3d_volcube.sl:209:    vector step_obj     = (outPoint_obj-inPoint_obj)/numOfSteps;
k3d/share/shaders/k3d_volcube.sl:210:    vector step_cur     = vtransform("object","current",step_obj);
k3d/share/shaders/k3d_volcube.sl:221:    point  Pcur_obj     = inPoint_obj + jitter * step_obj;
k3d/share/shaders/k3d_volcube.sl:235:	    cur_density = active_volume(Pcur_obj,Vol_Mult,Vol_Offset);
k3d/share/shaders/k3d_volcube.sl:237:	    cur_density = get_density(Pcur_obj,Vol_Mult,Vol_Offset);
k3d/share/shaders/k3d_volcube.sl:245:		    normal Vol_Nf = calcGradeNorm(Pcur_obj,Vol_Mult,Vol_Offset,
k3d/share/shaders/k3d_volcube.sl:296:	Pcur_obj += step_obj;
k3d/share/shaders/k3d_wallpaper.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_wallpaper.sl:72:    Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(Nf));
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:7: *   equal s.  The background color is given by the surface color.
k3d/share/shaders/k3d_wallpaper_2stripe.sl:13: *   bgcolor, stripecolor       color of background and stripes
k3d/share/shaders/k3d_wallpaper_2stripe.sl:15: *   stripespacing              dist between sets of stripes, in s coordinates
k3d/share/shaders/k3d_wallpaper_2stripe.sl:20: * AUTHOR: written by Larry Gritz (email: lg@bmrt.org)
k3d/share/shaders/k3d_wallpaper_2stripe.sl:31:			      color stripecolor = color "rgb"(1, 0.5, 0.5);
k3d/share/shaders/k3d_warningstripes.sl:6:// This program is free software; you can redistribute it and/or
k3d/share/shaders/k3d_warningstripes.sl:7:// modify it under the terms of the GNU General Public
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:14:// General Public License for more details.
k3d/share/shaders/k3d_warningstripes.sl:16:// You should have received a copy of the GNU General Public
k3d/share/shaders/k3d_warningstripes.sl: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:57:	Ci = (Os * Ct * (ambient() + diffuse(Nf)));
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: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:20: *    samples - set to higher than 1 for oversampling of blur

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

k3d/share/shaders/k3d_water.sl:25: *      25 Jan 1994 -- recoded by lg in correct shading language.

k3d/share/shaders/k3d_water.sl:27: * last modified 25 Jan 1994 by Larry Gritz

k3d/share/shaders/k3d_water.sl:30:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - \

k3d/share/shaders/k3d_water.sl:31:                           smoothstep((b)-(fuzz),(b),(x)))

k3d/share/shaders/k3d_water.sl:33:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))

k3d/share/shaders/k3d_water.sl:37:	float Kr = 1, roughness = 0, blur = 0;

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

k3d/share/shaders/k3d_water.sl:63:	if (blur > 0) {

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

k3d/share/shaders/k3d_water.sl:80:	    /* No blur, just do a simple trace */

k3d/share/shaders/k3d_water.sl:85:    surface_color = Os * ( Cs * (Ka*ambient() + Kd*diffuse(Nf)) +

k3d/share/shaders/k3d_water.sl:100:    surface_color = blend(surface_color, layer_color, layer_opac);

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

k3d/share/shaders/k3d_watercolor.sl:22:	float costhetai = abs(nI . nN);

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

k3d/share/shaders/k3d_waterdisplacement.sl:22:	if (bumpmap != "")

k3d/share/shaders/k3d_waterdisplacement.sl:23:		hump = texture(bumpmap, s, t);	

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:18:	float  blur=.01;
k3d/share/shaders/k3d_waterlight.sl:19:	float  bias=.01;
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:14: *   hpanes, vpanes - number of horizontal and vertical panes
k3d/share/shaders/k3d_windowlight.sl:17: *   framewidth, frameheight - how thick are the window frame "bars",
k3d/share/shaders/k3d_windywave.sl:10:  float turb, a, i;
k3d/share/shaders/k3d_windywave.sl:16:  turb = 0;
k3d/share/shaders/k3d_windywave.sl:21:      turb += abs(a * snoise(PP));
k3d/share/shaders/k3d_windywave.sl:25:  wind = minwind + windamp * turb;
k3d/share/shaders/k3d_wood2.sl:14: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_wood2.sl:29:  point PP, PQ;			/* shading space point to be computed */
k3d/share/shaders/k3d_wood2.sl:60:    Os * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) +
k3d/share/shaders/k3d_woodcut.sl:6:float brightness=0.75; 
k3d/share/shaders/k3d_woodcut.sl:10:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_woodcut.sl:11:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_woodcut.sl:45:illumcolor = (Ka*ambient() + Kd*diffuse(Nf) + Ks*specular(Nf,V,roughness));
k3d/share/shaders/k3d_woodcut.sl:57:(brightness - 1.0) + n*random;
k3d/share/shaders/k3d_woodcut.sl:78:surface_color = blend(surface_color, layer_color, layer_opac);
