k3d/share/shaders/k3d_altitude_fog.sl:3:	float min_height = 0;
k3d/share/shaders/k3d_altitude_fog.sl:7:	point PP = transform("world", P);
k3d/share/shaders/k3d_altitude_fog.sl:8:	float fog = 1 - smoothstep(min_height, max_height, ycomp(PP));
k3d/share/shaders/k3d_ambientlight.sl:10:float intensity = 1;
k3d/share/shaders/k3d_ambientlight.sl:14:  Cl = intensity * lightcolor;
k3d/share/shaders/k3d_antialiasedchecks.sl:11: *   frequency		determines the frequency (in s-t space) of the checks
k3d/share/shaders/k3d_antialiasedchecks.sl:30:  point Nf;             /* Forward facing surface normal */
k3d/share/shaders/k3d_antialiasedchecks.sl:31:  float smod, tmod;     /* Texture position within the pattern */
k3d/share/shaders/k3d_antialiasedchecks.sl:33:  float x, y;           /* Used to determine pattern */
k3d/share/shaders/k3d_antialiasedchecks.sl:34:  float swidth, twidth, sfuzz, tfuzz;  /* Antialiasing */
k3d/share/shaders/k3d_antialiasedchecks.sl:40:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_antialiasedchecks.sl:44:  /* Figure out amount of fuzziness, taking normal into account */
k3d/share/shaders/k3d_antialiasedchecks.sl:50:  /* Get the place in the pattern where we're sampling */
k3d/share/shaders/k3d_antialiasedchecks.sl:59:      /* Gradually fade in the average color when we get close to the limit */
k3d/share/shaders/k3d_arealight.sl:5: *   Makes light with cosine falloff from the normal of the light source
k3d/share/shaders/k3d_arealight.sl:6: *   surface.  This is perfect for using with area light sources.
k3d/share/shaders/k3d_arealight.sl:9: *   intensity, lightcolor - same meanings as pointlight
k3d/share/shaders/k3d_arealight.sl:14:float intensity = 1; 
k3d/share/shaders/k3d_arealight.sl:19:  illuminate(P, N, 1.5707963 /* PI/2 */ )
k3d/share/shaders/k3d_arealight.sl:21:    Cl = (intensity / (L.L)) * lightcolor;
k3d/share/shaders/k3d_arealight.sl:24:  /* This is so if we use one of these lights in PRMan, it will
k3d/share/shaders/k3d_arealight.sl:25:   * approximately work for a flat light source whose normal points
k3d/share/shaders/k3d_arealight.sl:29:  illuminate(point "shader"(0, 0, 0), Nl, PI / 2)
k3d/share/shaders/k3d_arealight.sl:31:    Cl = (intensity * (Nl.normalize(L) / (L.L)) * lightcolor);
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:24:/// Simplified from the original by Larry Gritz
k3d/share/shaders/k3d_bluemarble.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_bluemarble.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_bluemarble.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_bluemarble.sl:16:#define PALE_BLUE        color (0.25, 0.25, 0.35)
k3d/share/shaders/k3d_bluemarble.sl:17:#define MEDIUM_BLUE      color (0.10, 0.10, 0.30)
k3d/share/shaders/k3d_bluemarble.sl:18:#define DARK_BLUE        color (0.05, 0.05, 0.26)
k3d/share/shaders/k3d_bluemarble.sl:19:#define DARKER_BLUE      color (0.03, 0.03, 0.20)
k3d/share/shaders/k3d_bluemarble.sl:20:#define NNOISE           4
k3d/share/shaders/k3d_bluemarble.sl:25:    return color spline(
k3d/share/shaders/k3d_bluemarble.sl:45:    point NN;
k3d/share/shaders/k3d_bluemarble.sl:46:    point PP;
k3d/share/shaders/k3d_bluescreen.sl:3: *   puts a background color behind an image.
k3d/share/shaders/k3d_bluescreen.sl:12:string texturename = ""
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:9: *   The staggering isn't exact, however, and this variance is controlled
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:19: *    mortarthickness           Thickness of the mortar (in st space)
k3d/share/shaders/k3d_brick.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brick.sl:27:#include "k3d_patterns.h"
k3d/share/shaders/k3d_brick.sl:38:		  float pitting = 0.01;
k3d/share/shaders/k3d_brick.sl:42:#define sqr(x) ((x)*(x))
k3d/share/shaders/k3d_brick.sl:55:  /* Determine how wide in s-t space one pixel projects to, relative
k3d/share/shaders/k3d_brick.sl:99:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brick.sl:109:      disp = min(disp, 0.85 * groovedepth * (sqr(ss / MWF) - 1));
k3d/share/shaders/k3d_brick.sl:113:      disp = min(disp, 0.85 * groovedepth * (sqr((1 - ss) / MWF) - 1));
k3d/share/shaders/k3d_brick.sl:118:  fact = pitting * (0.5 * fact + 0.5);
k3d/share/shaders/k3d_brick2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brick2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brick2.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_brick2.sl:16:#define BRICKWIDTH      0.25
k3d/share/shaders/k3d_brick2.sl:17:#define BRICKHEIGHT     0.08
k3d/share/shaders/k3d_brick2.sl:18:#define MORTARTHICKNESS 0.01
k3d/share/shaders/k3d_brick2.sl:20:#define BMWIDTH         (BRICKWIDTH+MORTARTHICKNESS)
k3d/share/shaders/k3d_brick2.sl:21:#define BMHEIGHT        (BRICKHEIGHT+MORTARTHICKNESS)
k3d/share/shaders/k3d_brick2.sl:22:#define MWF             (MORTARTHICKNESS*0.5/BMWIDTH)
k3d/share/shaders/k3d_brick2.sl:23:#define MHF             (MORTARTHICKNESS*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brick2.sl:34:    point Nf;
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:9: *   The staggering isn't exact, however, and this variance is controlled
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:19: *    mortarthickness           Thickness of the mortar (in st space)
k3d/share/shaders/k3d_brick3.sl:30: *      12 Jan 1994 -- recoded by lg in correct shading language.
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:50:#define MWF (mortarthickness*0.5/BMWIDTH)
k3d/share/shaders/k3d_brick3.sl:51:#define MHF (mortarthickness*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brick3.sl:52:#define snoise(x) (2 * noise((x)) - 1)
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:54:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_brick3.sl:56:  point PP2, Nf;
k3d/share/shaders/k3d_brick3.sl:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_brick3.sl:69:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brick3.sl:73:  ss = scoord / BMWIDTH;   /* Determine which brick the point is in */
k3d/share/shaders/k3d_brick3.sl:87:  ss -= sbrick;          /* Now ss and tt are coords within the brick */
k3d/share/shaders/k3d_brickanti.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickanti.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickanti.sl:15:#include "k3d_proctext.h"
k3d/share/shaders/k3d_brickanti.sl:17:#define BRICKWIDTH      0.25
k3d/share/shaders/k3d_brickanti.sl:18:#define BRICKHEIGHT     0.08
k3d/share/shaders/k3d_brickanti.sl:19:#define MORTARTHICKNESS 0.02
k3d/share/shaders/k3d_brickanti.sl:21:#define BMWIDTH         (BRICKWIDTH+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickanti.sl:22:#define BMHEIGHT        (BRICKHEIGHT+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickanti.sl:23:#define MWF             (MORTARTHICKNESS*0.5/BMWIDTH)
k3d/share/shaders/k3d_brickanti.sl:24:#define MHF             (MORTARTHICKNESS*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brickanti.sl:35:    point Nf;
k3d/share/shaders/k3d_brickanti.sl:55:    /* This is the simple antialiasing with "boxstep" */
k3d/share/shaders/k3d_brickanti.sl:65:    /* This is the preferred antialiasing using integrals. */
k3d/share/shaders/k3d_brickanti.sl:66:#define frac(x)        mod((x),1)
k3d/share/shaders/k3d_brickanti.sl:67:#define sintegral(ss)  (floor(ss)*(1-2*MWF) + \
k3d/share/shaders/k3d_brickanti.sl:69:#define tintegral(tt)  (floor(tt)*(1-2*MHF) + \
k3d/share/shaders/k3d_brickanti.sl:72:    w = (sintegral(ss+swidth) - sintegral(ss))/swidth;
k3d/share/shaders/k3d_brickanti.sl:73:    h = (tintegral(tt+twidth) - tintegral(tt))/twidth;
k3d/share/shaders/k3d_brickbump.sl:8: *   in fact matte or plastic gives those nice white cinder block walls.
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:15: *    mortarthickness           Thickness of the mortar (in st space)
k3d/share/shaders/k3d_brickbump.sl:18: *    pitting                   The amplitude of the "pits" on the face of
k3d/share/shaders/k3d_brickbump.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brickbump.sl:27:#include "k3d_patterns.h"
k3d/share/shaders/k3d_brickbump.sl:33:			   float rowvary = .25, pitting = 0.01;
k3d/share/shaders/k3d_brickbump.sl:37:#define sqr(x) ((x)*(x))
k3d/share/shaders/k3d_brickbump.sl:53:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump.sl:63:      disp = min(disp, 0.85 * groovedepth * (sqr(ss / MWF) - 1));
k3d/share/shaders/k3d_brickbump.sl:67:      disp = min(disp, 0.85 * groovedepth * (sqr((1 - ss) / MWF) - 1));
k3d/share/shaders/k3d_brickbump.sl:72:  fact = pitting * (0.75 * fact + 0.25);
k3d/share/shaders/k3d_brickbump2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickbump2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickbump2.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_brickbump2.sl:16:#define BRICKWIDTH      0.25
k3d/share/shaders/k3d_brickbump2.sl:17:#define BRICKHEIGHT     0.08
k3d/share/shaders/k3d_brickbump2.sl:18:#define MORTARTHICKNESS 0.01
k3d/share/shaders/k3d_brickbump2.sl:20:#define BMWIDTH         (BRICKWIDTH+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickbump2.sl:21:#define BMHEIGHT        (BRICKHEIGHT+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickbump2.sl:22:#define MWF             (MORTARTHICKNESS*0.5/BMWIDTH)
k3d/share/shaders/k3d_brickbump2.sl:23:#define MHF             (MORTARTHICKNESS*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brickbump2.sl:34:    point Nf;
k3d/share/shaders/k3d_brickbump2.sl:56:    /* compute bump-mapping function for mortar grooves */
k3d/share/shaders/k3d_brickbump2.sl:61:    /* compute shading normal */
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: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:15: *    mortarthickness           Thickness of the mortar (in st space)
k3d/share/shaders/k3d_brickbump3.sl:18: *    pitting                   The amplitude of the "pits" on the face of
k3d/share/shaders/k3d_brickbump3.sl:27: *      12 Jan 1994 -- recoded by lg in correct shading language.
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:42:  I think good parameters for this look are:
k3d/share/shaders/k3d_brickbump3.sl:45:	       "mortarthickness" 0.02 "pitting" 0.015 "pockfrequency" 12
k3d/share/shaders/k3d_brickbump3.sl:54:	    float rowvary = .25, pitting = 0.01;
k3d/share/shaders/k3d_brickbump3.sl:58:#define BMWIDTH (brickwidth+mortarthickness)
k3d/share/shaders/k3d_brickbump3.sl:59:#define BMHEIGHT (brickheight+mortarthickness)
k3d/share/shaders/k3d_brickbump3.sl:60:#define MWF (mortarthickness*0.5/BMWIDTH)
k3d/share/shaders/k3d_brickbump3.sl:61:#define MHF (mortarthickness*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brickbump3.sl:62:#define snoise(x) (2 * noise((x)) - 1)
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:64:#define sqr(x) ((x)*(x))
k3d/share/shaders/k3d_brickbump3.sl:65:  point PP2;
k3d/share/shaders/k3d_brickbump3.sl:73:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brickbump3.sl:89:  ss -= sbrick;          /* Now ss and tt are coords within the brick */
k3d/share/shaders/k3d_brickbump3.sl:95:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump3.sl:111:  fact = pitting * (0.75 * fact + 0.25);
k3d/share/shaders/k3d_brickperturb.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_brickperturb.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_brickperturb.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_brickperturb.sl:16:#define BRICKWIDTH      0.25
k3d/share/shaders/k3d_brickperturb.sl:17:#define BRICKHEIGHT     0.08
k3d/share/shaders/k3d_brickperturb.sl:18:#define MORTARTHICKNESS 0.01
k3d/share/shaders/k3d_brickperturb.sl:20:#define BMWIDTH         (BRICKWIDTH+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickperturb.sl:21:#define BMHEIGHT        (BRICKHEIGHT+MORTARTHICKNESS)
k3d/share/shaders/k3d_brickperturb.sl:22:#define MWF             (MORTARTHICKNESS*0.5/BMWIDTH)
k3d/share/shaders/k3d_brickperturb.sl:23:#define MHF             (MORTARTHICKNESS*0.5/BMHEIGHT)
k3d/share/shaders/k3d_brickperturb.sl:34:    point Nf;
k3d/share/shaders/k3d_brushedmetal.sl:8: *   Ka, Kd, Ks - the usual meaning
k3d/share/shaders/k3d_brushedmetal.sl:14: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_brushedmetal.sl:18:#include "k3d_material.h"
k3d/share/shaders/k3d_brushedmetal2.sl:4: *  in any way you see fit, but please leave my name near the top
k3d/share/shaders/k3d_brushedmetal2.sl:8: *  stochasticly spreads the map, so it looks a little grainy.
k3d/share/shaders/k3d_brushedmetal2.sl:12: *  then assume specspread is roughness, then you have something 
k3d/share/shaders/k3d_brushedmetal2.sl:24: *  mapspread		- the spread of the image streaking
k3d/share/shaders/k3d_brushedmetal2.sl:27: *			  angle in radians (i.e. PI*.5 = 90 degrees)
k3d/share/shaders/k3d_brushedmetal2.sl:38:    extern point P;
k3d/share/shaders/k3d_brushedmetal2.sl:45:    point zro = 0;
k3d/share/shaders/k3d_brushedmetal2.sl:47:    illuminance (P, Nf, PI*.5) {
k3d/share/shaders/k3d_brushedmetal2.sl:74:	string	mapname 	= "";
k3d/share/shaders/k3d_brushedmetal2.sl:77:	point Po = transform("object",P);
k3d/share/shaders/k3d_brushedmetal2.sl:81:        point zro = 0;
k3d/share/shaders/k3d_brushedmetal3.sl:4: * Greg Ward Larson's anisotropic specular local illumination model.
k3d/share/shaders/k3d_brushedmetal3.sl:5: * The derivation and formulae can be found in:  Ward, Gregory J.
k3d/share/shaders/k3d_brushedmetal3.sl:6: * "Measuring and Modeling Anisotropic Reflection," ACM Computer
k3d/share/shaders/k3d_brushedmetal3.sl:7: * Graphics 26(2) (Proceedings of Siggraph '92), pp. 265-272, July, 1992.
k3d/share/shaders/k3d_brushedmetal3.sl:10: *   V - unit viewing direction (from P toward the camera)
k3d/share/shaders/k3d_brushedmetal3.sl:11: *   xdir - a unit tangent of the surface which defines the reference
k3d/share/shaders/k3d_brushedmetal3.sl:13: *   xroughness - the apparent roughness of the surface in xdir.
k3d/share/shaders/k3d_brushedmetal3.sl:28:    extern point P;
k3d/share/shaders/k3d_brushedmetal3.sl:29:    illuminance (P, N, PI/2) {
k3d/share/shaders/k3d_brushedmetal3.sl:30:        /* Must declare because extern L & Cl because we're in a function */
k3d/share/shaders/k3d_bubbles.sl:12:	float frequency = 1; /* number of bubbles per linear surface */
k3d/share/shaders/k3d_bubbles.sl:15: float distance2point;
k3d/share/shaders/k3d_bubbles.sl:16: point myCenter = (0, 0, 0);
k3d/share/shaders/k3d_bubbles.sl:21: point myPoint = (smod, 0, tmod);
k3d/share/shaders/k3d_bubbles.sl:22: distance2point = distance(myPoint, myCenter);
k3d/share/shaders/k3d_bubbles.sl:23: if (distance2point <= radius) 
k3d/share/shaders/k3d_bubbles.sl:24:    magnitud = sqrt((radius * radius) - (distance2point * distance2point));
k3d/share/shaders/k3d_bubbly.sl: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:8: *  siggraph proceedings from 1996, except this uses a noised grid of cells
k3d/share/shaders/k3d_bubbly.sl:9: *  instead of the sparse convolution in the paper.
k3d/share/shaders/k3d_bubbly.sl:13: *  try lowering bubsize for pimples.
k3d/share/shaders/k3d_bubbly.sl:15: *  try anything you feel like.
k3d/share/shaders/k3d_bubbly.sl:24: *  bubsize - basicly the radius of the bubbles. distance in rVu's.
k3d/share/shaders/k3d_bubbly.sl:37:  point Po = transform("object",P)*mult;
k3d/share/shaders/k3d_bubbly.sl:39:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_bubbly.sl:40:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_castucco.sl:6: *   in Northern California.  I never really saw it on the East Coast,
k3d/share/shaders/k3d_castucco.sl:7: *   but in CA it's truly ubiquitous.
k3d/share/shaders/k3d_castucco.sl:13: *   trough, peak - define the shape of the valleys and mesas of the stucco.
k3d/share/shaders/k3d_castucco.sl:19:#include "k3d_noises.h"
k3d/share/shaders/k3d_castucco.sl:20:#include "k3d_displace.h"
k3d/share/shaders/k3d_castucco.sl:29:  point Pshad;			/* Point to be shaded, in shader space */
k3d/share/shaders/k3d_castucco.sl:30:  float fwidth;			/* Estimated change in P between image samples */
k3d/share/shaders/k3d_castucco.sl:33:  /* Do texture calcs in "shader" space, get approximate filter size */
k3d/share/shaders/k3d_castucco.sl:43:  /* displace in shader space units */
k3d/share/shaders/k3d_causticlight.sl:2:k3d_causticlight ( float intensity = 1;
k3d/share/shaders/k3d_causticlight.sl:4:	       point from = point "shader" (0,0,0);
k3d/share/shaders/k3d_causticlight.sl:5:	       point to = point "shader" (0,0,1);
k3d/share/shaders/k3d_causticlight.sl:9:	       string shadowname = "";
k3d/share/shaders/k3d_causticlight.sl:19:    illuminate (from, axis, coneangle) {
k3d/share/shaders/k3d_causticlight.sl:24:	Cl = atten * intensity * lightcolor;
k3d/share/shaders/k3d_causticlight.sl:30:		point PL = transform ("shader", Ps);
k3d/share/shaders/k3d_celld.sl:4: * Simple displacement shader using Voronoi cell noise
k3d/share/shaders/k3d_celld.sl:14:#include "k3d_noises.h"
k3d/share/shaders/k3d_celld.sl:24:	string PSpace = "shader";  /* desc {Space to transform P for shading calculations } */
k3d/share/shaders/k3d_celld.sl:26:	varying point __Pref = point (1000, 0, -1000); /* vis hidden */
k3d/share/shaders/k3d_celld.sl:27:   	output varying float VoroVal = 0; /* vis hidden */
k3d/share/shaders/k3d_celld.sl:30:	point objP = transform (PSpace, P);
k3d/share/shaders/k3d_celld.sl:31:	point noiseP = (usePref != 0)? transform (PSpace, __Pref): objP;
k3d/share/shaders/k3d_celld.sl:36:	point voro_pos1 = 0, voro_pos2 = 0;
k3d/share/shaders/k3d_celld.sl:50:#pragma nolint 1
k3d/share/shaders/k3d_ceramic.sl:3:#include "k3d_material.h"
k3d/share/shaders/k3d_ceramictiles.sl:4: * Description: Ceramic tiles (like you'd find in a bathroom)
k3d/share/shaders/k3d_ceramictiles.sl:7: *   projection, textureprojspace, mx -  define the projection used to
k3d/share/shaders/k3d_ceramictiles.sl:8: *     establish a basic 2-D coordinate system for the pattern.
k3d/share/shaders/k3d_ceramictiles.sl:9: *   stilespacing, ttilespacing - tile-to-tile spacing (separate controls
k3d/share/shaders/k3d_ceramictiles.sl:11: *   groovewidth, grooveheight - width of the spacing between tiles,
k3d/share/shaders/k3d_ceramictiles.sl:12: *     expressed as a fraction of the tile-to-tile spacing.
k3d/share/shaders/k3d_ceramictiles.sl:13: *   groovedepth - displacement amount for the grooves (expressed in
k3d/share/shaders/k3d_ceramictiles.sl:15: *   truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_ceramictiles.sl:19: *   mottlefreq - frequency of the mottling between Cbase & Cmottle
k3d/share/shaders/k3d_ceramictiles.sl:21: *   Cspeck - color of the occasional specks in the tiles
k3d/share/shaders/k3d_ceramictiles.sl:22: *   edgevary, mottling, speckly - individual scalar controls over
k3d/share/shaders/k3d_ceramictiles.sl:23: *      edge variation, mottling, and speckles.  Setting any to zero will
k3d/share/shaders/k3d_ceramictiles.sl:25: *   varyhue, varysat, varylum - individual controls for the per-tile
k3d/share/shaders/k3d_ceramictiles.sl:26: *      color variation (0 means don't vary in that way, larger values
k3d/share/shaders/k3d_ceramictiles.sl:29: * Parameters for illumination model:
k3d/share/shaders/k3d_ceramictiles.sl:30: *   Ka - the usual meaning
k3d/share/shaders/k3d_ceramictiles.sl:33: *   Kdtile - diffuse component weighting of the tile
k3d/share/shaders/k3d_ceramictiles.sl:36: *   envname, envspace, envrad - environment mapping controls
k3d/share/shaders/k3d_ceramictiles.sl:37: *   rayjitter, raysamples - ray tracing controls
k3d/share/shaders/k3d_ceramictiles.sl:49:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_ceramictiles.sl:52:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_ceramictiles.sl:54:#include "k3d_project.h"
k3d/share/shaders/k3d_ceramictiles.sl:55:#include "k3d_material.h"
k3d/share/shaders/k3d_ceramictiles.sl:56:#include "k3d_noises.h"
k3d/share/shaders/k3d_ceramictiles.sl:57:#include "k3d_displace.h"
k3d/share/shaders/k3d_ceramictiles.sl:58:#include "k3d_patterns.h"
k3d/share/shaders/k3d_ceramictiles.sl:60:/* Given 2-D texture coordinates ss,tt and their filter widths ds, dt,
k3d/share/shaders/k3d_ceramictiles.sl:61: * and the width and height of the grooves between tiles (assuming that
k3d/share/shaders/k3d_ceramictiles.sl:62: * tile spacing is 1.0), figure out which (integer indexed) tile we are
k3d/share/shaders/k3d_ceramictiles.sl:63: * on and what coordinates (on [0,1]) within our individual tile we are
k3d/share/shaders/k3d_ceramictiles.sl:64: * shading.
k3d/share/shaders/k3d_ceramictiles.sl:76:  return filteredpulsetrain(groovewidth, 1, ss + groovewidth / 2,
k3d/share/shaders/k3d_ceramictiles.sl:77:			    ds) * filteredpulsetrain(grooveheight, 1,
k3d/share/shaders/k3d_ceramictiles.sl:84:/* Given coordinates (stile,ttile) and derivatives (ds,dt) *within* a
k3d/share/shaders/k3d_ceramictiles.sl:85: * single tile, calculate the color of the tile at that point.  Major
k3d/share/shaders/k3d_ceramictiles.sl:86: * features include: (1) mottling of the color; (2) darkening or shifting
k3d/share/shaders/k3d_ceramictiles.sl:90:color tiletexture(float tileindex;
k3d/share/shaders/k3d_ceramictiles.sl:92:		  float edgevary, mottling, speckly; float mottlefreq;
k3d/share/shaders/k3d_ceramictiles.sl:97:  if(mottling > 0)
k3d/share/shaders/k3d_ceramictiles.sl:99:      point noisep = mottlefreq * point(stile, ttile, tileindex);
k3d/share/shaders/k3d_ceramictiles.sl:102:      C = mix(C, Cmottle, clamp(mottling * mottle, 0, 1));
k3d/share/shaders/k3d_ceramictiles.sl:107:	.05 * fBm(point(stile * 10, ttile * 10, tileindex + 10),
k3d/share/shaders/k3d_ceramictiles.sl:110:	.05 * fBm(point(stile * 10, ttile * 10, tileindex - 3),
k3d/share/shaders/k3d_ceramictiles.sl:121:      point noisep =
k3d/share/shaders/k3d_ceramictiles.sl:122:	point(stile * speckfreq, ttile * speckfreq, tileindex + 8);
k3d/share/shaders/k3d_ceramictiles.sl: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:141:			   float intile;
k3d/share/shaders/k3d_ceramictiles.sl:147:  extern point P;
k3d/share/shaders/k3d_ceramictiles.sl:148:  color basecolor = mix(Cmortar, Ctile, intile);
k3d/share/shaders/k3d_ceramictiles.sl:149:  float ks = Ks * intile;
k3d/share/shaders/k3d_ceramictiles.sl:150:  float kd = mix(Kdmortar, Kdtile, intile);
k3d/share/shaders/k3d_ceramictiles.sl:156:  float kr = fkr * Kr * intile;
k3d/share/shaders/k3d_ceramictiles.sl:172:			 float stilespacing = 10, ttilespacing = 10;
k3d/share/shaders/k3d_ceramictiles.sl:175:			 string projection = "st";
k3d/share/shaders/k3d_ceramictiles.sl:176:			 string textureprojspace = "shader";
k3d/share/shaders/k3d_ceramictiles.sl:180:			 float edgevary = 1, mottling = 1, speckly = 1;
k3d/share/shaders/k3d_ceramictiles.sl:189:   * Get a 2-D texture coordinates for the texturing, then
k3d/share/shaders/k3d_ceramictiles.sl:190:   * Normalize everything so that the tiles are 1x1 units
k3d/share/shaders/k3d_ceramictiles.sl:194:  ss /= stilespacing;
k3d/share/shaders/k3d_ceramictiles.sl:195:  dss /= stilespacing;
k3d/share/shaders/k3d_ceramictiles.sl:196:  tt /= ttilespacing;
k3d/share/shaders/k3d_ceramictiles.sl:197:  dtt /= ttilespacing;
k3d/share/shaders/k3d_ceramictiles.sl:200:   * Find out where in the pattern we are: which tile we're on, and
k3d/share/shaders/k3d_ceramictiles.sl:201:   * the (stile,ttile) coordinates (both on [0,1]) within our tile.
k3d/share/shaders/k3d_ceramictiles.sl:204:  float intile = tilepattern(ss, tt, dss, dtt,
k3d/share/shaders/k3d_ceramictiles.sl:207:  float tileindex = swhichtile + 13 * twhichtile;
k3d/share/shaders/k3d_ceramictiles.sl:220:  Ntile += 0.05 * (vector cellnoise(tileindex + 5) - 0.5);
k3d/share/shaders/k3d_ceramictiles.sl:221:  Nf = normalize(mix(Nf, Ntile, intile));
k3d/share/shaders/k3d_ceramictiles.sl:224:   * Here's the exciting part -- calculate the color of the spot we're
k3d/share/shaders/k3d_ceramictiles.sl:225:   * in within the tile.  Then use the tile index to vary its color
k3d/share/shaders/k3d_ceramictiles.sl:228:  color Ctile = tiletexture(tileindex, stile, ttile, dss, dtt,
k3d/share/shaders/k3d_ceramictiles.sl:229:			    edgevary, mottling, speckly,
k3d/share/shaders/k3d_ceramictiles.sl:232:  Ctile = varyEach(Ctile, tileindex, varyhue, varysat, varylum);
k3d/share/shaders/k3d_ceramictiles.sl:236:   * scaling it by some high frequency fBm.
k3d/share/shaders/k3d_ceramictiles.sl:239:  point Q = 20 * point(ss, tt, 0);
k3d/share/shaders/k3d_ceramictiles.sl:241:  if(intile < 1.0)
k3d/share/shaders/k3d_ceramictiles.sl:245:   * Illumination model
k3d/share/shaders/k3d_ceramictiles.sl:248:    MaterialCeramicTiles(Nf, Cmortar, Ctile, intile, Ka, Kdmortar, Kdtile, Ks,
k3d/share/shaders/k3d_checkerboard.sl:1:#include "k3d_patterns.h"
k3d/share/shaders/k3d_checkerboard.sl:10:  point Nf;
k3d/share/shaders/k3d_checkerboard.sl:31:  // Calculate which tile we're in ...
k3d/share/shaders/k3d_checkerboard_solid.sl:12:	string shadingspace = "shader";
k3d/share/shaders/k3d_checkerboard_solid.sl:16:	point Nf;
k3d/share/shaders/k3d_checkerboard_solid.sl:19:	point Pshad = transform(shadingspace, P);
k3d/share/shaders/k3d_clay.sl:2: * clay.sl -- simple clay surface using MaterialClay
k3d/share/shaders/k3d_clay.sl:7: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_clay.sl:11:#include "k3d_material.h"
k3d/share/shaders/k3d_cloudplane.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_cloudplane.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_cloudplane.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_cloudplane.sl:16:#define NTERMS 5
k3d/share/shaders/k3d_cloudplane.sl:24:    point Psh;
k3d/share/shaders/k3d_constant.sl:9:surface k3d_constant(float intensity = 1.0)
k3d/share/shaders/k3d_constant.sl:12:  Ci = Os * Cs * intensity;
k3d/share/shaders/k3d_contacshadow.sl:15:    string shadowname = "";     /* the name of the texture file */  
k3d/share/shaders/k3d_contacshadow.sl:17:    float influence = 1.0;      /* world space distance in which effect is visible */  
k3d/share/shaders/k3d_contacshadow.sl:19:    float maxdist = 10000;      /* how far is considered infinity */  
k3d/share/shaders/k3d_contacshadow.sl:23:       camera space used when rendering the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:25:    textureinfo(shadowname, "viewingmatrix", matNl);  
k3d/share/shaders/k3d_contacshadow.sl:28:       screen space (-1..1) used when rendering the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:30:    textureinfo(shadowname, "projectionmatrix", matNP);  
k3d/share/shaders/k3d_contacshadow.sl:32:    /* transform the ground plane point into texture coordinates  
k3d/share/shaders/k3d_contacshadow.sl:33:       needed to look up the point in the shadow map */  
k3d/share/shaders/k3d_contacshadow.sl:34:    point screenP = transform(matNP, P);  
k3d/share/shaders/k3d_contacshadow.sl:39:	/* point being shaded is outside the region of the depth map */  
k3d/share/shaders/k3d_contacshadow.sl:44:	   object as recorded in the shadow map */
k3d/share/shaders/k3d_contacshadow.sl:47:	/* transform the point on the ground plane into the shadow
k3d/share/shaders/k3d_contacshadow.sl:48:	   camera space in order to get the distance from the shadow
k3d/share/shaders/k3d_contacshadow.sl:50:	point cameraP = transform(matNl, P);  
k3d/share/shaders/k3d_contacshadow.sl:56:	distance = smoothstep(0, 1, distance/influence);  
k3d/share/shaders/k3d_contacshadow.sl:59:	/* convert into a color (white=shadow) */  
k3d/share/shaders/k3d_corktile.sl:3:/* corktile.sl - a surface shader imitating cork tiling
k3d/share/shaders/k3d_corktile.sl:5: * Author: Peter Quint
k3d/share/shaders/k3d_corktile.sl:10: * Ka, Kd, Ks, roughness, specularcolor - take their usual meanings
k3d/share/shaders/k3d_corktile.sl:12: * txtscale - the amount of detail / magnification of the image, this also determines
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:18: *   the groove (2.5% either side = 5% in total = 0.05)
k3d/share/shaders/k3d_corktile.sl:22: * 	 the gap between the tiles, the remainder of bumpheight is taken up with the bumps on the 
k3d/share/shaders/k3d_corktile.sl:25: *   in height between the gap and the tile itself
k3d/share/shaders/k3d_corktile.sl:27: * The shader makes an attempt at being self antaliasing
k3d/share/shaders/k3d_corktile.sl:31:#include "k3d_noises.h" /* the standard BMRT include file */
k3d/share/shaders/k3d_corktile.sl:32:#include "k3d_tile.h"
k3d/share/shaders/k3d_corktile.sl:33:#define fnoise(p,width) (noise(p) * (1-smoothstep (0.2,0.75,width)))
k3d/share/shaders/k3d_corktile.sl:35:/* Bias function - Perlin and Hoffert 1989 */
k3d/share/shaders/k3d_corktile.sl:43:color cork(		point PP;
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:48:		markings that characterise cork
k3d/share/shaders/k3d_corktile.sl:51:		point P2 = transform("shader",PP);
k3d/share/shaders/k3d_corktile.sl:52:		point PT = P2 * txtscale;
k3d/share/shaders/k3d_corktile.sl:60:		Ct = color spline( 	f,
k3d/share/shaders/k3d_corktile.sl:69:		/* Overlay the dark markings */
k3d/share/shaders/k3d_corktile.sl:96:	point PP = transform("shader",P);
k3d/share/shaders/k3d_corktile.sl:104:	float ingap = tile(s, t, tilewidth, tilewidth, swidth, twidth, gap, gap, sw, tw, so, to);
k3d/share/shaders/k3d_corktile.sl:111:	adjust = (1 - min(smoothstep(gap * .3, gap * .7, so), smoothstep(gap * .3, gap * .7, to))) * 
k3d/share/shaders/k3d_corktile.sl:117:	/* printf("Nf = %p\n", Nf);	 */
k3d/share/shaders/k3d_corktile.sl:119:	Ci = Os * (mix( Ct, Cg, ingap) * (Ka*ambient() + Kd*diffuse(Nf)) +
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:9:#include "k3d_material.h"
k3d/share/shaders/k3d_craters.sl:10:#include "k3d_noises.h"
k3d/share/shaders/k3d_craters.sl:11:#include "k3d_patterns.h"
k3d/share/shaders/k3d_craters.sl:17:   float swidth=.6;      /* Size of largest crater relative to s/t mapping */
k3d/share/shaders/k3d_craters.sl:18:   float pitfactor = .7; /* chance of crater occuring in a cell */
k3d/share/shaders/k3d_craters.sl:20:   float lac=1.91341;    /* diameter spacing between successive octaves */
k3d/share/shaders/k3d_craters.sl:22:   float jitter=1.0;     /* irregularity of crater spacing */
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:99:	    pert += sin(r*PI/2)*asc-asc;
k3d/share/shaders/k3d_craters.sl:105:	    pert += sin(r*PI/2)*asc-asc;
k3d/share/shaders/k3d_crayon.sl:3:/* crayon.sl - a surface shader making crayon like marks
k3d/share/shaders/k3d_crayon.sl:8:	It makes an attempt at antaliasing.
k3d/share/shaders/k3d_crayon.sl:12:	Ka, Kd, Ks, roughness, specularcolor - work as in the plastic shader
k3d/share/shaders/k3d_crayon.sl:13:	txtscale  - an overall scaling factor
k3d/share/shaders/k3d_crayon.sl:21:		interpolation of values for density0 when t = 0, thus allowing a 
k3d/share/shaders/k3d_crayon.sl:22:		graduation of shading from top to bottom of the object
k3d/share/shaders/k3d_crayon.sl:26:	Peter Quint - Revised Monday, January 10, 2000 
k3d/share/shaders/k3d_crayon.sl:32:#define snoise(x,y) ((noise(x,y) - 0.5) * 2)
k3d/share/shaders/k3d_crayon.sl:40:	/* calculate smallest integer f for which width / f < .5 */
k3d/share/shaders/k3d_crayon.sl:43:	/*(printf("f = %f, mag = %f\n",f,mag)*/;
k3d/share/shaders/k3d_crayon.sl:50:#define MINFILTWIDTH 1.0e-6
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:73:	float trs = spline(1 - density, 0 , -0.195997, -0.128361, -0.0738346,	-0.0316483,
k3d/share/shaders/k3d_crayon.sl:75:	/*  use a spline to read across to the appropriate noise value - this equalisation
k3d/share/shaders/k3d_crayon.sl:76:		process is described by Steven Worley in Ch 3 of "Texturing and Modelling a
k3d/share/shaders/k3d_crayontoon.sl:6: * el estilo deseado. Mi intencion fue hacer un color dependiente

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

k3d/share/shaders/k3d_cyclone.sl:1:#define TWOPI (2*PI)
k3d/share/shaders/k3d_cyclone.sl:3:/* Use signed Perlin noise */
k3d/share/shaders/k3d_cyclone.sl:4:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_cyclone.sl:5:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_cyclone.sl:6:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_cyclone.sl:7:#define VERY_SMALL 0.001
k3d/share/shaders/k3d_cyclone.sl:15:  float radius, dist, angle, sine, cosine, eye_weight, value;
k3d/share/shaders/k3d_cyclone.sl:16:  point Pt;			/* Point in texture space */
k3d/share/shaders/k3d_cyclone.sl:17:  point PN;			/* Normalized vector in texture space */
k3d/share/shaders/k3d_cyclone.sl:18:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_cyclone.sl:21:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_cyclone.sl:24:  /* Rotate hit point to "cyclone space" */
k3d/share/shaders/k3d_cyclone.sl:29:    {				/* inside of cyclone */
k3d/share/shaders/k3d_cyclone.sl:30:      /* invert distance from center */
k3d/share/shaders/k3d_cyclone.sl:33:      sine = sin(angle);
k3d/share/shaders/k3d_cyclone.sl:34:      cosine = cos(angle);
k3d/share/shaders/k3d_cyclone.sl:36:	point(xcomp(Pt) * cosine - ycomp(Pt) * sine,
k3d/share/shaders/k3d_cyclone.sl:37:	      xcomp(Pt) * sine + ycomp(Pt) * cosine, zcomp(Pt));
k3d/share/shaders/k3d_cyclone.sl:40:	{			/* if in "eye" */
k3d/share/shaders/k3d_cyclone.sl:42:	  /* invert and make nonlinear */
k3d/share/shaders/k3d_cyclone.sl:52:    {				/* if in "storm" area */
k3d/share/shaders/k3d_cyclone.sl:68:  /* Thin the density of the clouds */
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:30:	string texturename = "";
k3d/share/shaders/k3d_dented.sl:15: * AUTHOR: written by Larry Gritz, based on the "dented" shader in
k3d/share/shaders/k3d_dented.sl:19: *      Dec 1992 -- written by lg for "Timbre Trees Examples" (jingle)
k3d/share/shaders/k3d_dented.sl:35:	point PP;
k3d/share/shaders/k3d_depthcue.sl:9:volume k3d_depthcue(float mindistance = 0, maxdistance = 1;
k3d/share/shaders/k3d_depthcue.sl:14:  d = clamp((depth(P) - mindistance) / (maxdistance - mindistance), 0, 1);
k3d/share/shaders/k3d_depthcue_surf.sl:1:/* k3d_depthcue_surf inspired by depthcue_surf.sl by Pixar
k3d/share/shaders/k3d_depthcue_surf.sl:8:float mindistance = 0, maxdistance = 1, CScale=1000;
k3d/share/shaders/k3d_depthcue_surf.sl:9:string debug="y";
k3d/share/shaders/k3d_depthcue_surf.sl:13:  d = clamp((depth(P) - mindistance) / (maxdistance - mindistance), 0, 1);
k3d/share/shaders/k3d_depthcue_surf.sl:18:			printf("<debug shadername='k3d_depthcue_surf' shadertype='surface'>%p\t%f\t%f\t%c</debug>\n", P, depth(P), d, Ci);
k3d/share/shaders/k3d_displacementmap.sl:2:				 float ZeroPoint = 0.0;
k3d/share/shaders/k3d_displacementmap.sl:3:				 string texturename = "";)
k3d/share/shaders/k3d_displacementmap.sl:5:  point PP;
k3d/share/shaders/k3d_displacementmap.sl:6:  point N1, N2;
k3d/share/shaders/k3d_displacementmap.sl:12:  P = P - (Km * (Ct - ZeroPoint)) * normalize(N);
k3d/share/shaders/k3d_distant_shadow.sl:2:	float  intensity=1 ;
k3d/share/shaders/k3d_distant_shadow.sl:4:	point from = point "shader" (0,0,0) ;
k3d/share/shaders/k3d_distant_shadow.sl:5:	point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_distant_shadow.sl:6:	string shadowname="";
k3d/share/shaders/k3d_distant_shadow.sl:13:			Cl = intensity * lightcolor;
k3d/share/shaders/k3d_distantlight.sl:9:light k3d_distantlight(float intensity = 1;
k3d/share/shaders/k3d_distantlight.sl:11:		       point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_distantlight.sl:12:		       point to = point "shader"(0, 0, 1);)
k3d/share/shaders/k3d_distantlight.sl:14:  solar(to - from, 0) Cl = intensity * lightcolor;
k3d/share/shaders/k3d_droop.sl:3:/* Listing 16.27  Displacement shader with catenary droop in y*/
k3d/share/shaders/k3d_droop.sl:6: * droop(): a displacement shader for making a surface "sag" along t.
k3d/share/shaders/k3d_droop.sl:8:#define M_E 2.7182818284590452354	/* e */
k3d/share/shaders/k3d_droop.sl:16:	droop = (t-.5)*2;	/* t in [0,1] goes to droop in [-1,1] */
k3d/share/shaders/k3d_dturb.sl:6:#include "k3d_rmannotes.h"
k3d/share/shaders/k3d_dturb.sl:11:  point PP;
k3d/share/shaders/k3d_dturb.sl:18:  width = filterwidth_point(PP);
k3d/share/shaders/k3d_easysurface.sl:3:/* Listing 16.22  Surface shader for use without a light source*/
k3d/share/shaders/k3d_easysurface.sl:6: * easysurface(): orientation-sensitive surface shading without a light source
k3d/share/shaders/k3d_easysurface.sl:15:	point II = normalize(I);
k3d/share/shaders/k3d_easysurface.sl:16:	point NN = normalize(N);
k3d/share/shaders/k3d_ember.sl:1:/* Glowing ember shader 2002 Graeme Nattress & NOITAMINANIMATION Inc.
k3d/share/shaders/k3d_ember.sl:3: * email: graeme@noitaminanimation.com
k3d/share/shaders/k3d_ember.sl:6: * to represent it's life. The desired effect is that of glowing particles that
k3d/share/shaders/k3d_ember.sl:9: * baseSize = the basic diameter of the particle sphere before scaling
k3d/share/shaders/k3d_ember.sl:20:	point PP = transform ("world", P);
k3d/share/shaders/k3d_ember.sl:21:	point QQ = transform ("world", point "object" (0, 0, 0));
k3d/share/shaders/k3d_ember.sl:25:	//size now represents the size of the sphere particle normalised into 0,1.
k3d/share/shaders/k3d_ember.sl:41:	// always in the centre of the particle sphere.
k3d/share/shaders/k3d_ember.sl:43:	Ci = color spline (spcol * size, 
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:7: * 	map as sdixon() to define the lettering.
k3d/share/shaders/k3d_emboss.sl:12:	string	texturename	= "")
k3d/share/shaders/k3d_envsurf.sl:1:surface k3d_envsurf (string envname = "", envspace = "world")
k3d/share/shaders/k3d_eroded.sl:3:/* Listing 16.17  Surface shader eroding the surface of an object */
k3d/share/shaders/k3d_eroded.sl:18:	point Nf,
k3d/share/shaders/k3d_eroded.sl:20:    point x = (1, 0, 0);
k3d/share/shaders/k3d_eroded.sl:21:	point V = normalize(-I);
k3d/share/shaders/k3d_eyeball.sl:8: *   part (eyeball), and blood vessels can be set individually.  Fractal
k3d/share/shaders/k3d_eyeball.sl:9: *   functions are used for the veining and the iris mottling.
k3d/share/shaders/k3d_eyeball.sl:16: *   pupilcolor - color of the pupil (opening)
k3d/share/shaders/k3d_eyeball.sl:17: *   pupilsize - size of pupil (in "t" space)
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: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:24: * ANTIALIASING: basic antialiasing of the boundaries between tissue types
k3d/share/shaders/k3d_eyeball.sl:31: *                 "Graphic Violence".  Original version hard coded in C.
k3d/share/shaders/k3d_eyeball.sl:33: *      10 Jan 1994 - recoded by lg in correct shading language.
k3d/share/shaders/k3d_eyeball.sl:34: *      28 Jun 94 (lg) - revamped to add veins and iris mottling, renamed
k3d/share/shaders/k3d_eyeball.sl: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:50:	 color irisinnercolor = color (.065142, .040605, .179311);
k3d/share/shaders/k3d_eyeball.sl:56:	 float veinfreq = 8, veinlevel = 4;
k3d/share/shaders/k3d_eyeball.sl:57:	 float index = 0;
k3d/share/shaders/k3d_eyeball.sl:60:#define snoise(P) (2*noise(P)-1)
k3d/share/shaders/k3d_eyeball.sl:61:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_eyeball.sl:63:  point Nf;
k3d/share/shaders/k3d_eyeball.sl:64:  point PP, PO;
k3d/share/shaders/k3d_eyeball.sl:73:  /* Calculate an appropriate filter width for antialiasing */
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:87:  /* If we're somewhere in the white part and it's potentially bloody,
k3d/share/shaders/k3d_eyeball.sl:88:   * then calculate the veining pattern.  Otherwise, just use the color
k3d/share/shaders/k3d_eyeball.sl:89:   * of the whites.  The veining pattern is essentially summed zero sets
k3d/share/shaders/k3d_eyeball.sl:90:   * of turbulence functions.  Some stretching is done to get it to look
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:108:  /* If we're somewhere in the iris, calculate the iris pattern, which is
k3d/share/shaders/k3d_eyeball.sl:114:	  turb += snoise (PO*f2 + point(0,0,20*f2)) / freq;
k3d/share/shaders/k3d_eyeball.sl:130:  /* Now shade like plastic, but using our calculated surface color and
k3d/share/shaders/k3d_fakesky.sl:5: * sphere, with color varying a bit by altitude, in an attempt to mimic the

k3d/share/shaders/k3d_filament.sl:3:/* Listing 16.25  Surface shader to make a cylinder look like a filament */
k3d/share/shaders/k3d_filament.sl:6: * filament(): map a filament-like spiral onto the surface of a cylinder.
k3d/share/shaders/k3d_filament.sl:17:	/* Threshold the fraction against the fractional filament width */
k3d/share/shaders/k3d_fill.sl:9:		min			=   0.05,
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:7:#include "k3d_rmannotes.h"
k3d/share/shaders/k3d_fire.sl:41:  /* index into color spline using turbulence */
k3d/share/shaders/k3d_fire.sl:45:  layer_color = spline(flame, red, red, red, red, orange, yellow, hot, hot);
k3d/share/shaders/k3d_flame.sl:5: *    Makes something that looks like fire.
k3d/share/shaders/k3d_flame.sl:10: *    flameheight, flameamplitude - scaling factors
k3d/share/shaders/k3d_flame.sl:13: *    None, but should be easy to add antialiasing simply by adaptively
k3d/share/shaders/k3d_flame.sl:14: *    setting the "octaves" parameter based on distance from eye point.
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:22: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
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:32:#define snoise(p) (2 * float noise(p) - 1)
k3d/share/shaders/k3d_flame.sl:33:#define DNoise(p) (2 * (point noise(p)) - point(1, 1, 1))
k3d/share/shaders/k3d_flame.sl:34:#define VLNoise(p, scale) (snoise(p + scale * DNoise(p)))
k3d/share/shaders/k3d_flame.sl:41:  point PP, PQ;
k3d/share/shaders/k3d_flame.sl:45:  PP = point(s, t, phase);
k3d/share/shaders/k3d_flame.sl:47:  PQ *= point(1, 1, exp(-ycomp(PP)));
k3d/share/shaders/k3d_flame.sl:59:    Cs * color spline(cmap, color(0, 0, 0), color(0, 0, 0), color(27, 0, 0),
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:8: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

k3d/share/shaders/k3d_fractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

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

k3d/share/shaders/k3d_fractal.sl:30:                             original one -- signal *= signal;*/

k3d/share/shaders/k3d_fractal.sl:50:          		/* invert and translate*/

k3d/share/shaders/k3d_fresnelplastic.sl:2: * TLFresnelPlastic.sl -- simple shader illustrating fresnel().
k3d/share/shaders/k3d_fresnelplastic.sl:5: *    Simple Fresnel shader using plastic illuminance.
k3d/share/shaders/k3d_fresnelplastic.sl:16:#include "k3d_reflections.h"
k3d/share/shaders/k3d_fresnelplastic.sl:19:#define CHKTX(tx) ((tx != "" && textureinfo (tx, "exists", 0) != 0)? 1: 0)
k3d/share/shaders/k3d_fresnelplastic.sl:21:#define CHKTX(tx) \
k3d/share/shaders/k3d_fresnelplastic.sl:29:   string colorMap = ""; /* cat Color
k3d/share/shaders/k3d_fresnelplastic.sl:42:   string reflectMap = ""; 
k3d/share/shaders/k3d_fresnelplastic.sl:46:   string reflectSpace = "world";  /* cat Reflection 
k3d/share/shaders/k3d_fresnelplastic.sl:47:   desc {Space the reflection calculations are performed in. } */
k3d/share/shaders/k3d_fresnelplastic.sl:81:    /* Calculate fresnel index of refraction */
k3d/share/shaders/k3d_fresnelplastic.sl:107:    /* lighting */
k3d/share/shaders/k3d_funkyglass.sl:13:  point PP;
k3d/share/shaders/k3d_fur1.sl:5: *     by Lawrence D. Chin, cs184-bo

k3d/share/shaders/k3d_fur2.sl:7:   with clumping and specular model
k3d/share/shaders/k3d_fur2.sl:9:   by Clint Hanson and Armin Bruderlin
k3d/share/shaders/k3d_fur2.sl:13:fnc_diffuselgt (color Cin;       /* Light Colour */
k3d/share/shaders/k3d_fur2.sl:14:                point Lin;       /* Light Position */
k3d/share/shaders/k3d_fur2.sl:15:                point Nin;       /* Surface Normal */
k3d/share/shaders/k3d_fur2.sl:18:    color Cout = Cin;
k3d/share/shaders/k3d_fur2.sl:23:    LN = normalize(vector(Lin));
k3d/share/shaders/k3d_fur2.sl:24:    NN = normalize(vector(Nin));
k3d/share/shaders/k3d_fur2.sl:35:#define luminance(c) comp(c,0)*0.299 + comp(c,1)*0.587 + comp(c,2)*0.114
k3d/share/shaders/k3d_fur2.sl:39:k3d_fur2( /* Hair Shading... */
k3d/share/shaders/k3d_fur2.sl:65:	 varying vector clump_vect  = vector 0;
k3d/share/shaders/k3d_fur2.sl:75:    varying normal nSN = normalize( surface_normal );
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:80:    float clump_darkening = 1.0;
k3d/share/shaders/k3d_fur2.sl:86:    float darkening = 1.0;
k3d/share/shaders/k3d_fur2.sl:87:    varying color final_c;
k3d/share/shaders/k3d_fur2.sl:96:       normals in a linear fashion 
k3d/share/shaders/k3d_fur2.sl:101:    /* Make the specular only hit in certain parts of the hair--v is
k3d/share/shaders/k3d_fur2.sl:104:    Kspec *= min( smoothstep( start_spec, start_spec + spec_size_fade, v),  
k3d/share/shaders/k3d_fur2.sl:108:    /* Loop over lights, catch highlights as if this was a thin cylinder,
k3d/share/shaders/k3d_fur2.sl:110:       Specular illumination model from:
k3d/share/shaders/k3d_fur2.sl:111:       James T. Kajiya and Timothy L.  Kay (1989) "Rendering Fur with Three 
k3d/share/shaders/k3d_fur2.sl:115:    illuminance (P, norm_hair, radians(illum_width)) {
k3d/share/shaders/k3d_fur2.sl:123:	Kajiya = T_Dot_nL * T_Dot_e + sin(Alpha) * sin(Beta);
k3d/share/shaders/k3d_fur2.sl:127:	    clump_darkening = 1 - ( clump_dark_strength * 
k3d/share/shaders/k3d_fur2.sl:130:	    clump_darkening = 1.0;
k3d/share/shaders/k3d_fur2.sl:139:	Cspec += (1-nonspecular) * SpecularColor * clump_darkening * 
k3d/share/shaders/k3d_fur2.sl:143:	Cdiff += clump_darkening * fnc_diffuselgt(Cl, L, norm_hair);
k3d/share/shaders/k3d_fur2.sl:146:    darkening = clamp(hair_col_var, 0, 1);
k3d/share/shaders/k3d_fur2.sl:148:    darkening = (1 - (smoothstep( var_fade_end, var_fade_start, 
k3d/share/shaders/k3d_fur2.sl:149:				  abs(luminance(Kd*Cdiff))) * darkening));
k3d/share/shaders/k3d_fur2.sl:151:    final_c = mix( rootcolor, tipcolor, v ) * darkening;
k3d/share/shaders/k3d_fur2.sl:153:    Ci =  ((Ka*ambient() + Kd*Cdiff + static_ambient) * final_c
k3d/share/shaders/k3d_glass.sl:2: * glass.sl -- Shiny reflective & refractive glass, using ray tracing.
k3d/share/shaders/k3d_glass.sl:5: *   Makes semi-transparent glass, using ray tracing to calculate
k3d/share/shaders/k3d_glass.sl:9: *    Ka, Kd, Ks, roughness, specularcolor - The usual meaning
k3d/share/shaders/k3d_glass.sl:12: *    envname, envspace, envrad - controls for using environment maps
k3d/share/shaders/k3d_glass.sl:13: *    rayjitter, raysamples - ray tracing controls for reflection
k3d/share/shaders/k3d_glass.sl:18: *    reflrayjitter, refrraysamples - ray tracing controls for refraction
k3d/share/shaders/k3d_glass.sl:25: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_glass.sl:32:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_glass.sl:33:#include "k3d_material.h"
k3d/share/shaders/k3d_gloop.sl:5: * an example of nonlinear displacements 
k3d/share/shaders/k3d_gloop.sl:9: * Renderman Users Group meeting at siggraph.
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:37:  point  Pou = Psh + (dPduN*overdist);/*P Over a distance in U*/
k3d/share/shaders/k3d_gloop.sl:38:  point  Pov = Psh + (dPdvN*overdist);
k3d/share/shaders/k3d_gloop.sl:40:  /*noise function at the point, over in u, and over in v*/
k3d/share/shaders/k3d_gloop.sl:45:  float  chu = (nz - nzou);/*change in noise value in u*/
k3d/share/shaders/k3d_gloop.sl:48:  /*init deflected derivatives*/
k3d/share/shaders/k3d_gloop.sl:62:  /* wash your hands after displacing P*/
k3d/share/shaders/k3d_glow.sl:5:  float incidence, strength;
k3d/share/shaders/k3d_glow.sl:8:  incidence = I.N;
k3d/share/shaders/k3d_glow.sl:9:  if(incidence < 0)		// If this point is on the front face of the sphere
k3d/share/shaders/k3d_glow.sl:11:      // Normalize incidence
k3d/share/shaders/k3d_glow.sl:12:      incidence = incidence * incidence / (I.I * N.N);
k3d/share/shaders/k3d_glow.sl:14:      // Calculate a "strength" function based on incidence
k3d/share/shaders/k3d_glow.sl:15:      strength = pow(incidence, attenuation);
k3d/share/shaders/k3d_glow.sl:19:      // Calculate final color and opacity - we set Oi near zero
k3d/share/shaders/k3d_gmarbtile_polish.sl:6: *   traced reflections) and cut into tiles (divided in xy texture space).
k3d/share/shaders/k3d_gmarbtile_polish.sl:10: *   Kr - reflectivity (shininess) of the surface
k3d/share/shaders/k3d_gmarbtile_polish.sl:11: *   txtscale - overall scaling for the texture
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:14: *   veinfreq - controls the frequency of the veining effects
k3d/share/shaders/k3d_gmarbtile_polish.sl:15: *   sharpness - how sharp the veins appear
k3d/share/shaders/k3d_gmarbtile_polish.sl:23:#include "k3d_noises.h"
k3d/share/shaders/k3d_gmarbtile_polish.sl:24:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_gmarbtile_polish.sl:25:#include "k3d_reflections.h"
k3d/share/shaders/k3d_gmarbtile_polish.sl:34:			     color veincolor = color(0.47, 0.57, 0.03);
k3d/share/shaders/k3d_gmarbtile_polish.sl:36:			     float veinfreq = 1;
k3d/share/shaders/k3d_gmarbtile_polish.sl:40:			     string envname = "", envspace = "NDC";
k3d/share/shaders/k3d_gmarbtile_polish.sl:53:  point PP = txtscale * transform("shader", P);
k3d/share/shaders/k3d_gmarbtile_polish.sl:68:   * First calculate the underlying color of the substrate
k3d/share/shaders/k3d_gmarbtile_polish.sl:74:   * Now we layer on the veins
k3d/share/shaders/k3d_gmarbtile_polish.sl:80:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_gmarbtile_polish.sl:83:  PP *= veinfreq;
k3d/share/shaders/k3d_gmarbtile_polish.sl:84:  dPP *= veinfreq;
k3d/share/shaders/k3d_gmarbtile_polish.sl:96:  Ct = mix(Ct, veincolor, turbsum);
k3d/share/shaders/k3d_gooch.sl:4: *              non-photorealistic lighting model
k3d/share/shaders/k3d_gooch.sl:6: * DESCRIPTION   : This model is described in "A Non-Photorealistc
k3d/share/shaders/k3d_gooch.sl:7: *                 Lighting Model For Automatic Technical 
k3d/share/shaders/k3d_gooch.sl:8: *                 Illustration" in the Siggraph 1998 Proceedings.
k3d/share/shaders/k3d_gooch.sl:22: * AUTHOR: written by Mike King
k3d/share/shaders/k3d_gooch.sl:47:    illuminance(P,Nf,PI) {
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:11:		spin	= 0.0;		/* each pin gets its texture spun */
k3d/share/shaders/k3d_gouge.sl:12:	string	texturename = "")
k3d/share/shaders/k3d_gouge.sl:16:   /* Use the same texture map that the surface shader uses. Spin it a different
k3d/share/shaders/k3d_gouge.sl:17:    *  amount for each pin so that similarity is not detected.  The texture 
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_gouge.sl:23:   {  P += (-Km * texture(texturename,s+spin,y/15.0)) * normalize(N);
k3d/share/shaders/k3d_granite.sl:3:/* Listing 16.18  Surface shader for granite-like surface*/
k3d/share/shaders/k3d_graphic_lines.sl:1:surface k3d_graphic_lines (
k3d/share/shaders/k3d_graphic_lines.sl:7:        float paint_spec=0.6;
k3d/share/shaders/k3d_graphic_lines.sl:8:        float paint_trans=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:9:        float paint_fuzz=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:10:        float ink_thresh=0.10;
k3d/share/shaders/k3d_graphic_lines.sl:11:        float ink_fuzz=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:12:				float line_scale_master=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:14:        string up_highlight="z";
k3d/share/shaders/k3d_graphic_lines.sl:15:        float line_scale_highlight=16.0;
k3d/share/shaders/k3d_graphic_lines.sl:31:				float illumination_highlight=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:37:        string up_paint="y";
k3d/share/shaders/k3d_graphic_lines.sl:38:        float line_scale_paint=16.0;
k3d/share/shaders/k3d_graphic_lines.sl:39:        float contrast_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:40:        float brightness_paint=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:41:        float randomness_paint=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:42:        float noise_size_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:43:        color color_curve_paint_color1=(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:44:        color color_curve_paint_color2=(0.1,0.05,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:45:        color color_curve_paint_color3=(0.8,0.6,0.4);
k3d/share/shaders/k3d_graphic_lines.sl:46:        color color_curve_paint_color4=(1.0,1.0,0.8);
k3d/share/shaders/k3d_graphic_lines.sl:47:        color color_curve_paint_color5=(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:48:        color color_curve_paint_color6=(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:49:        float surface_opac_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:50:        float surface_trans_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:51:				float fuzz_paint=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:52:				float tfreq_paint=50;
k3d/share/shaders/k3d_graphic_lines.sl:53:				color illumcolor_paint=(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:54:				float illumination_paint=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:55:				float Ka_paint=0.10;
k3d/share/shaders/k3d_graphic_lines.sl:56:				float Kd_paint=0.70;
k3d/share/shaders/k3d_graphic_lines.sl:57:				float Ks_paint=0.20;
k3d/share/shaders/k3d_graphic_lines.sl:58:				float roughness_paint=0.2;
k3d/share/shaders/k3d_graphic_lines.sl:60:        string up_ink="x";
k3d/share/shaders/k3d_graphic_lines.sl:61:        float line_scale_ink=16.0;
k3d/share/shaders/k3d_graphic_lines.sl:62:        float contrast_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:63:        float brightness_ink=0.5;
k3d/share/shaders/k3d_graphic_lines.sl:64:        float randomness_ink=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:65:        float noise_size_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:66:        color color_curve_ink_color1=(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:67:        color color_curve_ink_color2=(0.1,0.05,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:68:        color color_curve_ink_color3=(0.8,0.6,0.4);
k3d/share/shaders/k3d_graphic_lines.sl:69:        color color_curve_ink_color4=(1.0,1.0,0.8);
k3d/share/shaders/k3d_graphic_lines.sl:70:        color color_curve_ink_color5=(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:71:        color color_curve_ink_color6=(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:72:        float surface_opac_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:73:        float surface_trans_ink=1.0; 
k3d/share/shaders/k3d_graphic_lines.sl:74:				float fuzz_ink=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:75:				float tfreq_ink=50;
k3d/share/shaders/k3d_graphic_lines.sl:76:				color illumcolor_ink=(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:77:				float illumination_ink=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:78:				float Ka_ink=0.10;
k3d/share/shaders/k3d_graphic_lines.sl:79:				float Kd_ink=0.70;
k3d/share/shaders/k3d_graphic_lines.sl:80:				float Ks_ink=0.20;
k3d/share/shaders/k3d_graphic_lines.sl:81:				float roughness_ink=0.2;
k3d/share/shaders/k3d_graphic_lines.sl:84:	/** Surface main-code start **/
k3d/share/shaders/k3d_graphic_lines.sl:88:	point P_highlight = P;
k3d/share/shaders/k3d_graphic_lines.sl:97:	float stripemin_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:108:	point Psh_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:116:		z_highlight*=line_scale_highlight*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:121:		y_highlight*=line_scale_highlight*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:125:		x_highlight*=line_scale_highlight*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:129:	illumination_highlight=max(max(comp(illumcolor_highlight,0),comp(illumcolor_highlight,1)),comp(illumcolor_highlight,2));
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:138:	if (illumination_highlight<0.01)
k3d/share/shaders/k3d_graphic_lines.sl:142:	else if (illumination_highlight>0.99)
k3d/share/shaders/k3d_graphic_lines.sl:149:	stripemin_highlight=0.5-smoothstep(0.0,1.0,illumination_highlight)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:150:	stripemax_highlight=0.5+smoothstep(0.0,1.0,illumination_highlight)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:151:	float val_highlight=(smoothstep((stripemin_highlight)-(fuzz_highlight),(stripemin_highlight),(tt_highlight))-smoothstep((stripemax_highlight)-(fuzz_highlight),(stripemax_highlight),(tt_highlight)));
k3d/share/shaders/k3d_graphic_lines.sl:155:	color_curve_highlight=spline(color_val_highlight,color_curve_highlight_color1,color_curve_highlight_color2,color_curve_highlight_color3,color_curve_highlight_color4,color_curve_highlight_color5,color_curve_highlight_color6);
k3d/share/shaders/k3d_graphic_lines.sl:164:	/** paint **/
k3d/share/shaders/k3d_graphic_lines.sl:166:	point P_paint = P;
k3d/share/shaders/k3d_graphic_lines.sl:167:	normal N_paint = N;
k3d/share/shaders/k3d_graphic_lines.sl:168:	color Ci_paint = Ci;
k3d/share/shaders/k3d_graphic_lines.sl:169:	color Oi_paint = Oi;
k3d/share/shaders/k3d_graphic_lines.sl:171:	color surface_color_paint;
k3d/share/shaders/k3d_graphic_lines.sl:172:	color layer_color_paint;
k3d/share/shaders/k3d_graphic_lines.sl:173:	color color_curve_paint;
k3d/share/shaders/k3d_graphic_lines.sl:174:	color layer_opac_paint;
k3d/share/shaders/k3d_graphic_lines.sl:175:	float stripemin_paint;
k3d/share/shaders/k3d_graphic_lines.sl:176:	float stripemax_paint;
k3d/share/shaders/k3d_graphic_lines.sl:177:	float tt_paint;
k3d/share/shaders/k3d_graphic_lines.sl:178:	float x_paint;
k3d/share/shaders/k3d_graphic_lines.sl:179:	float y_paint;
k3d/share/shaders/k3d_graphic_lines.sl:180:	float z_paint;
k3d/share/shaders/k3d_graphic_lines.sl:181:	float i_paint;
k3d/share/shaders/k3d_graphic_lines.sl:182:	float n_paint;
k3d/share/shaders/k3d_graphic_lines.sl:183:	float ns_paint;
k3d/share/shaders/k3d_graphic_lines.sl:184:	vector Nf_paint;
k3d/share/shaders/k3d_graphic_lines.sl:185:	vector V_paint;
k3d/share/shaders/k3d_graphic_lines.sl:186:	point Psh_paint;
k3d/share/shaders/k3d_graphic_lines.sl:187:	Psh_paint=transform("shader",P_paint);
k3d/share/shaders/k3d_graphic_lines.sl:188:	Nf_paint=faceforward(normalize(N_paint),I);
k3d/share/shaders/k3d_graphic_lines.sl:189:	V_paint=-normalize(I);
k3d/share/shaders/k3d_graphic_lines.sl:190:	if (up_paint == "z")
k3d/share/shaders/k3d_graphic_lines.sl:191:	{z_paint=zcomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:192:		z_paint*=line_scale_paint*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:193:		tt_paint=mod(z_paint,1);
k3d/share/shaders/k3d_graphic_lines.sl:195:	else if (up_paint == "y")
k3d/share/shaders/k3d_graphic_lines.sl:196:	{y_paint=ycomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:197:		y_paint*=line_scale_paint*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:198:		tt_paint=mod(y_paint,1);
k3d/share/shaders/k3d_graphic_lines.sl:200:	else {x_paint=xcomp(Psh_paint);
k3d/share/shaders/k3d_graphic_lines.sl:201:		x_paint*=line_scale_paint*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:202:		tt_paint=mod(x_paint,1);
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:204:	illumination_paint=max(max(comp(illumcolor_paint,0),comp(illumcolor_paint,1)),comp(illumcolor_paint,2));
k3d/share/shaders/k3d_graphic_lines.sl:205:	n_paint=0;
k3d/share/shaders/k3d_graphic_lines.sl:206:	ns_paint=noise_size_paint;
k3d/share/shaders/k3d_graphic_lines.sl:207:	for ( i_paint=0; i_paint<6.0 ; i_paint+=1.0 ){
k3d/share/shaders/k3d_graphic_lines.sl:208:		n_paint+=(2*noise(Psh_paint*ns_paint)-1)/ns_paint;
k3d/share/shaders/k3d_graphic_lines.sl:209:		ns_paint*=2.17;
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:212:	if (illumination_paint<0.01)
k3d/share/shaders/k3d_graphic_lines.sl:213:	{surface_color_paint=color(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:214:		layer_color_paint=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:216:	else if (illumination_paint>0.99)
k3d/share/shaders/k3d_graphic_lines.sl:217:	{surface_color_paint=color(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:218:		layer_color_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:220:	else {surface_color_paint=color(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:221:		layer_color_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:222:	}stripemin_paint=0.5-smoothstep(0.0,1.0,illumination_paint)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:223:	stripemax_paint=0.5+smoothstep(0.0,1.0,illumination_paint)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:224:	float val1=(smoothstep((stripemin_paint)-(fuzz_paint),(stripemin_paint),(tt_paint))-smoothstep((stripemax_paint)-(fuzz_paint),(stripemax_paint),(tt_paint)));
k3d/share/shaders/k3d_graphic_lines.sl:225:	layer_opac_paint=color(val1);
k3d/share/shaders/k3d_graphic_lines.sl:226:	surface_color_paint=((surface_color_paint)*(1-(layer_opac_paint))+(layer_color_paint)*(layer_opac_paint));
k3d/share/shaders/k3d_graphic_lines.sl:228:	color_curve_paint=spline(color_val1,color_curve_paint_color1,color_curve_paint_color2,color_curve_paint_color3,color_curve_paint_color4,color_curve_paint_color5,color_curve_paint_color6);
k3d/share/shaders/k3d_graphic_lines.sl:229:	float spacescale1=length(vtransform("shader",normalize(N_paint)));
k3d/share/shaders/k3d_graphic_lines.sl:230:	vector Ndisp1=normalize(N_paint)*(0/max(spacescale1,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:231:	P_paint+=0*Ndisp1;
k3d/share/shaders/k3d_graphic_lines.sl:232:	N_paint=normalize(calculatenormal(P_paint+(1-0)*Ndisp1));
k3d/share/shaders/k3d_graphic_lines.sl:233:	Ci_paint=surface_opac_paint*color_curve_paint;
k3d/share/shaders/k3d_graphic_lines.sl:234:	Oi_paint=surface_trans_paint;
k3d/share/shaders/k3d_graphic_lines.sl:236:	/** ink **/
k3d/share/shaders/k3d_graphic_lines.sl:238:	point P_ink = P;
k3d/share/shaders/k3d_graphic_lines.sl:239:	normal N_ink = N;
k3d/share/shaders/k3d_graphic_lines.sl:240:	color Ci_ink = Ci;
k3d/share/shaders/k3d_graphic_lines.sl:241:	color Oi_ink = Oi;
k3d/share/shaders/k3d_graphic_lines.sl:243:	color surface_color_ink;
k3d/share/shaders/k3d_graphic_lines.sl:244:	color layer_color_ink;
k3d/share/shaders/k3d_graphic_lines.sl:245:	color color_curve_ink;
k3d/share/shaders/k3d_graphic_lines.sl:246:	color layer_opac_ink;
k3d/share/shaders/k3d_graphic_lines.sl:247:	float stripemin_ink;
k3d/share/shaders/k3d_graphic_lines.sl:248:	float stripemax_ink;
k3d/share/shaders/k3d_graphic_lines.sl:249:	float tt_ink;
k3d/share/shaders/k3d_graphic_lines.sl:250:	float x_ink;
k3d/share/shaders/k3d_graphic_lines.sl:251:	float y_ink;
k3d/share/shaders/k3d_graphic_lines.sl:252:	float z_ink;
k3d/share/shaders/k3d_graphic_lines.sl:253:	float i_ink;
k3d/share/shaders/k3d_graphic_lines.sl:254:	float n_ink;
k3d/share/shaders/k3d_graphic_lines.sl:255:	float ns_ink;
k3d/share/shaders/k3d_graphic_lines.sl:256:	vector Nf_ink;
k3d/share/shaders/k3d_graphic_lines.sl:257:	vector V_ink;
k3d/share/shaders/k3d_graphic_lines.sl:258:	point Psh_ink;
k3d/share/shaders/k3d_graphic_lines.sl:259:	Psh_ink=transform("shader",P_ink);
k3d/share/shaders/k3d_graphic_lines.sl:260:	Nf_ink=faceforward(normalize(N_ink),I);
k3d/share/shaders/k3d_graphic_lines.sl:261:	V_ink=-normalize(I);
k3d/share/shaders/k3d_graphic_lines.sl:262:	if (up_ink == "z")
k3d/share/shaders/k3d_graphic_lines.sl:263:	{z_ink=zcomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:264:		z_ink*=line_scale_ink*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:265:		tt_ink=mod(z_ink,1);
k3d/share/shaders/k3d_graphic_lines.sl:267:	else if (up_ink == "y")
k3d/share/shaders/k3d_graphic_lines.sl:268:	{y_ink=ycomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:269:		y_ink*=line_scale_ink*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:270:		tt_ink=mod(y_ink,1);
k3d/share/shaders/k3d_graphic_lines.sl:272:	else {x_ink=xcomp(Psh_ink);
k3d/share/shaders/k3d_graphic_lines.sl:273:		x_ink*=line_scale_ink*line_scale_master;
k3d/share/shaders/k3d_graphic_lines.sl:274:		tt_ink=mod(x_ink,1);
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:276:	illumination_ink=max(max(comp(illumcolor_ink,0),comp(illumcolor_ink,1)),comp(illumcolor_ink,2));
k3d/share/shaders/k3d_graphic_lines.sl:277:	n_ink=0;
k3d/share/shaders/k3d_graphic_lines.sl:278:	ns_ink=noise_size_ink;
k3d/share/shaders/k3d_graphic_lines.sl:279:	for ( i_ink=0; i_ink<6.0; i_ink+=1.0 ){
k3d/share/shaders/k3d_graphic_lines.sl:280:		n_ink+=(2*noise(Psh_ink*ns_ink)-1)/ns_ink;
k3d/share/shaders/k3d_graphic_lines.sl:281:		ns_ink*=2.17;
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:284:	if (illumination_ink<0.01)
k3d/share/shaders/k3d_graphic_lines.sl:285:	{surface_color_ink=color(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:286:		layer_color_ink=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:288:	else if (illumination_ink>0.99)
k3d/share/shaders/k3d_graphic_lines.sl:289:	{surface_color_ink=color(1.0,1.0,1.0);
k3d/share/shaders/k3d_graphic_lines.sl:290:		layer_color_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:292:	else {surface_color_ink=color(0.0,0.0,0.0);
k3d/share/shaders/k3d_graphic_lines.sl:293:		layer_color_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:294:	}stripemin_ink=0.5-smoothstep(0.0,1.0,illumination_ink)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:295:	stripemax_ink=0.5+smoothstep(0.0,1.0,illumination_ink)/2.0;
k3d/share/shaders/k3d_graphic_lines.sl:296:	float val2=(smoothstep((stripemin_ink)-(fuzz_ink),(stripemin_ink),(tt_ink))-smoothstep((stripemax_ink)-(fuzz_ink),(stripemax_ink),(tt_ink)));
k3d/share/shaders/k3d_graphic_lines.sl:297:	layer_opac_ink=color(val2);
k3d/share/shaders/k3d_graphic_lines.sl:298:	surface_color_ink=((surface_color_ink)*(1-(layer_opac_ink))+(layer_color_ink)*(layer_opac_ink));
k3d/share/shaders/k3d_graphic_lines.sl:300:	color_curve_ink=spline(color_val2,color_curve_ink_color1,color_curve_ink_color2,color_curve_ink_color3,color_curve_ink_color4,color_curve_ink_color5,color_curve_ink_color6);
k3d/share/shaders/k3d_graphic_lines.sl:301:	float spacescale2=length(vtransform("shader",normalize(N_ink)));
k3d/share/shaders/k3d_graphic_lines.sl:302:	vector Ndisp2=normalize(N_ink)*(0/max(spacescale2,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:303:	P_ink+=0*Ndisp2;
k3d/share/shaders/k3d_graphic_lines.sl:304:	N_ink=normalize(calculatenormal(P_ink+(1-0)*Ndisp2));
k3d/share/shaders/k3d_graphic_lines.sl:305:	Ci_ink=surface_opac_ink*color_curve_ink;
k3d/share/shaders/k3d_graphic_lines.sl:306:	Oi_ink=surface_trans_ink;
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:314:	glinespec(vector N, V; float roughness)
k3d/share/shaders/k3d_graphic_lines.sl:319:		illuminance(P, N, PI/2) {
k3d/share/shaders/k3d_graphic_lines.sl:331:	color gline_color, layer_color;
k3d/share/shaders/k3d_graphic_lines.sl:332:	color gline_opac, layer_opac;
k3d/share/shaders/k3d_graphic_lines.sl:338:	gline_color = color (0, 0, 0);
k3d/share/shaders/k3d_graphic_lines.sl:339:	gline_opac = Os;
k3d/share/shaders/k3d_graphic_lines.sl:341:	/* gline paint layer ) */
k3d/share/shaders/k3d_graphic_lines.sl:343:	/* only care about percentage illumination */
k3d/share/shaders/k3d_graphic_lines.sl:345:	illuminance(P, Nf, PI/2)
k3d/share/shaders/k3d_graphic_lines.sl:349:	diff = smoothstep(paint_trans - paint_fuzz/2, paint_trans + paint_fuzz/2, diff);
k3d/share/shaders/k3d_graphic_lines.sl:352:	spec = glinespec(Nf, -normalize(I), roughness);
k3d/share/shaders/k3d_graphic_lines.sl:353:	spec = smoothstep(paint_spec - paint_fuzz/2, paint_spec + paint_fuzz/2, spec);
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:356:	layer_opac = Oi_paint;
k3d/share/shaders/k3d_graphic_lines.sl:358:	gline_color = blend(gline_color, layer_color, layer_opac);
k3d/share/shaders/k3d_graphic_lines.sl:359:	gline_opac = union(gline_opac, layer_opac);
k3d/share/shaders/k3d_graphic_lines.sl:361:	/* gline ink layer ) */
k3d/share/shaders/k3d_graphic_lines.sl:365:	/* antialias ink lines */
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:369:		layer_color = Ci_ink;
k3d/share/shaders/k3d_graphic_lines.sl:373:	gline_color = blend(gline_color, layer_color, layer_opac);
k3d/share/shaders/k3d_graphic_lines.sl:374:	gline_opac = union(gline_opac, layer_opac);
k3d/share/shaders/k3d_graphic_lines.sl:376:	color glineOi = gline_opac;
k3d/share/shaders/k3d_graphic_lines.sl:377:	color glineCi = gline_opac * gline_color;
k3d/share/shaders/k3d_graphic_lines.sl:379:	/** Surface main-code end **/
k3d/share/shaders/k3d_graphic_lines.sl:381:	Ci = glineCi;
k3d/share/shaders/k3d_graphic_lines.sl:382:	Oi = gline_opac;
k3d/share/shaders/k3d_grass_displace.sl:4: * I took used some of RManNotes function to assist in

k3d/share/shaders/k3d_grass_displace.sl:5: * creating a random look on the grass texture.

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

k3d/share/shaders/k3d_grass_displace.sl:13:#include "k3d_rmannotes.h"

k3d/share/shaders/k3d_grass_surface.sl:2: * Again, similar structure of grass.sl

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

k3d/share/shaders/k3d_grass_surface.sl:7:#include "k3d_rmannotes.h"

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

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

k3d/share/shaders/k3d_greenmarble.sl: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:9: *   txtscale - overall scaling for the texture
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:12: *   veinfreq - controls the frequency of the veining effects
k3d/share/shaders/k3d_greenmarble.sl:13: *   sharpness - how sharp the veins appear
k3d/share/shaders/k3d_greenmarble.sl:20:#include "k3d_noises.h"
k3d/share/shaders/k3d_greenmarble.sl:21:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_greenmarble.sl:22:#include "k3d_material.h"
k3d/share/shaders/k3d_greenmarble.sl:29:			color veincolor = color(0.47, 0.57, 0.03);
k3d/share/shaders/k3d_greenmarble.sl:30:			float veinfreq = 1;
k3d/share/shaders/k3d_greenmarble.sl:38:  point PP = txtscale * transform("shader", P);
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:49:   * Now we layer on the veins
k3d/share/shaders/k3d_greenmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_greenmarble.sl:58:  PP *= veinfreq;
k3d/share/shaders/k3d_greenmarble.sl:69:  Ct = mix(Ct, veincolor, turbsum);
k3d/share/shaders/k3d_grids.sl:15:float G1L1_linewidth=0.579; 
k3d/share/shaders/k3d_grids.sl:23:float G1L2_linewidth=0.209; 
k3d/share/shaders/k3d_grids.sl:31:float G2L1_linewidth=0.281; 
k3d/share/shaders/k3d_grids.sl:39:float G2L2_linewidth=0.149; 
k3d/share/shaders/k3d_grids.sl:45:/** Surface main-code start **/
k3d/share/shaders/k3d_grids.sl:47:#define repeat(x,freq) (mod((x) * (freq), 1.0))
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:49:#define rotate2d(x,y,rad,ox,oy,rx,ry) rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox); ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy)
k3d/share/shaders/k3d_grids.sl:50:#define blend(a,b,x) ((a) * (1 - (x)) + (b) * (x))
k3d/share/shaders/k3d_grids.sl:51:#define snoise(x) (2*noise(x)-1) 
k3d/share/shaders/k3d_grids.sl:60:/** line set 1 **/
k3d/share/shaders/k3d_grids.sl:65:color G1L1_layer_opac = pulse(G1L1_linewidth, 1-G1L1_linewidth, G1L1_fuzz, G1L1_tt);
k3d/share/shaders/k3d_grids.sl:68:/** line set 2 **/
k3d/share/shaders/k3d_grids.sl:73:color G1L2_layer_opac = pulse(G1L2_linewidth, 1-G1L2_linewidth, G1L2_fuzz, G1L2_tt);
k3d/share/shaders/k3d_grids.sl:79:/** line set 3 **/
k3d/share/shaders/k3d_grids.sl:84:color G2L1_layer_opac = pulse(G2L1_linewidth, 1-G2L1_linewidth, G2L1_fuzz, G2L1_tt);
k3d/share/shaders/k3d_grids.sl:87:/** line set 4 **/
k3d/share/shaders/k3d_grids.sl:92:color G2L2_layer_opac = pulse(G2L2_linewidth, 1-G2L2_linewidth, G2L2_fuzz, G2L2_tt);
k3d/share/shaders/k3d_grids.sl:95:/** Surface main-code end **/
k3d/share/shaders/k3d_grids_disp.sl:6: extern point P;
k3d/share/shaders/k3d_grids_disp.sl:17:float linewidth0=0.368; 
k3d/share/shaders/k3d_grids_disp.sl:23:float linewidth1=0.122; )
k3d/share/shaders/k3d_grids_disp.sl:26:#define repeat(x,freq) (mod((x) * (freq), 1.0))
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:28:#define rotate2d(x,y,rad,ox,oy,rx,ry) rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox); ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy)
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:37:color layer_opac0 = pulse(linewidth0, 1-linewidth0, fuzz0, tt0);
k3d/share/shaders/k3d_grids_disp.sl:39:#define repeat(x,freq) (mod((x) * (freq), 1.0))
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:41:#define rotate2d(x,y,rad,ox,oy,rx,ry) rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox); ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy)
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:50:color layer_opac1 = pulse(linewidth1, 1-linewidth1, fuzz1, tt1);
k3d/share/shaders/k3d_hair.sl:18:	/* Loop over lights, catch highlights as if this was a thin cylinder */
k3d/share/shaders/k3d_hair.sl:19:	illuminance (P)
k3d/share/shaders/k3d_hdr_light.sl:2:* to work with 32 bit floating point TIFF environment maps to give a higher

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

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:16:color hdrenv(string envname;vector R;float blur)

k3d/share/shaders/k3d_hdr_light.sl:41:	float intensity =1.0;

k3d/share/shaders/k3d_hdr_light.sl:43:	string envname = "";

k3d/share/shaders/k3d_hdr_light.sl:44:	string envspace = "shader";

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

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

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

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

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

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:70:		if (mappingtype == ""){

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:80:		else if (mappingtype == "environment"){

k3d/share/shaders/k3d_hdr_light.sl:85:		else if (mappingtype == "planar"){

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

k3d/share/shaders/k3d_hdr_light.sl:99:		Cl = Ct * intensity * exposure;

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:9:*notice remain intact and that I am acknowledged as the original author. Please

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:15:color hdrenv(string envname;vector R;float blur)

k3d/share/shaders/k3d_hdr_surface.sl:40:	float intensity =1.0;

k3d/share/shaders/k3d_hdr_surface.sl:42:	string envname = "";

k3d/share/shaders/k3d_hdr_surface.sl:43:	string envspace = "shader";

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

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

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

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

k3d/share/shaders/k3d_hdr_surface.sl:59:	else if (mappingtype == "environment"){

k3d/share/shaders/k3d_hdr_surface.sl:64:	else if (mappingtype == "planar"){

k3d/share/shaders/k3d_hdr_surface.sl:73:	Ci = Cs * Oi * Ct * intensity * exposure;

k3d/share/shaders/k3d_hdri1.sl:1:light k3d_hdri1 (string envname = "")
k3d/share/shaders/k3d_hdri2.sl:2:k3d_hdri2 (float intensity = 1;
k3d/share/shaders/k3d_hdri2.sl:4:       string envname = "";
k3d/share/shaders/k3d_hdri2.sl:5:       string envspace = "world";
k3d/share/shaders/k3d_hdri2.sl:7:       string shadowname = "";
k3d/share/shaders/k3d_hdri2.sl:13:    illuminate (P) {
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:10:*	float Edge1	=.2 			---	Minvalue of Edge.
k3d/share/shaders/k3d_hexatile_bump.sl:15:*	point P1	= point(0,0,0) 		---	Center point for Rotation.
k3d/share/shaders/k3d_hexatile_bump.sl:16:*	point P2	= point(0,0,1) 		---	The x,y,z direction for Rotate.
k3d/share/shaders/k3d_hexatile_bump.sl:17:*	string Projection = "planar" 		---	Projection "preoject.h"
k3d/share/shaders/k3d_hexatile_bump.sl:18:*	string Space	  = "shader" 		---	Space for projection.
k3d/share/shaders/k3d_hexatile_bump.sl:20:*	float C1	= 1 			---	Multiply of f1 the closes future point.
k3d/share/shaders/k3d_hexatile_bump.sl:21:*	float C2	= 2 			---	Multiply of f2 the second closes future point.
k3d/share/shaders/k3d_hexatile_bump.sl:32:* Arman "Advanced Renderman-"Creating CGI for Motion Picture.
k3d/share/shaders/k3d_hexatile_bump.sl:38:#include "k3d_project.h"
k3d/share/shaders/k3d_hexatile_bump.sl:39:#include "k3d_patterns.h"
k3d/share/shaders/k3d_hexatile_bump.sl:79:	string Name 	= "FGHexaTile_bump";
k3d/share/shaders/k3d_hexatile_bump.sl:85:	point P1	= point(0,0,0); 
k3d/share/shaders/k3d_hexatile_bump.sl:86:	point P2	= point(0,0,1); 
k3d/share/shaders/k3d_hexatile_bump.sl:87:	string Projection = "planar"; 
k3d/share/shaders/k3d_hexatile_bump.sl:88:	string Space	  = "shader"; 
k3d/share/shaders/k3d_hexatile_bump.sl:124:	extern point P;
k3d/share/shaders/k3d_hextile.sl:2: * hextile.sl -- surface shader for hexagonal tiles in st space
k3d/share/shaders/k3d_hextile.sl:5: *       This surface shader operates in s-t space and gives a pattern of
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:9: *    color variation from tile to tile.  On top of that is some staining
k3d/share/shaders/k3d_hextile.sl:10: *    (presumably due to water or something), which darkens the tile or
k3d/share/shaders/k3d_hextile.sl:11: *    mortar underneath it.  Finally, there is scuffing due to people's
k3d/share/shaders/k3d_hextile.sl:19: *    tileradius - the "radius" (in s-t units) of a single tile
k3d/share/shaders/k3d_hextile.sl:20: *    mortarwidth - the width of the mortar (in s-t units)
k3d/share/shaders/k3d_hextile.sl:24: *    Some rudimentary antialiasing is performed on the borders between
k3d/share/shaders/k3d_hextile.sl:29: *    the floors in the public areas of the Washington DC subway system.
k3d/share/shaders/k3d_hextile.sl:40:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_hextile.sl:41:#define snoise2(x,y) (2*noise((x),(y))-1)
k3d/share/shaders/k3d_hextile.sl:55:	 float scuffing = 0.5;
k3d/share/shaders/k3d_hextile.sl:56:	 float stains = 0.4;
k3d/share/shaders/k3d_hextile.sl:57:         float stainfrequency = 2;
k3d/share/shaders/k3d_hextile.sl:61:  point Nf;
k3d/share/shaders/k3d_hextile.sl:70:  float tileindex;
k3d/share/shaders/k3d_hextile.sl:71:  float stain, scuff;
k3d/share/shaders/k3d_hextile.sl:74:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_hextile.sl:109:  tileindex = stile+41*ttile;
k3d/share/shaders/k3d_hextile.sl:110:  Ctile = tilecolor * (1 + tilevary * snoise(tileindex+0.5));
k3d/share/shaders/k3d_hextile.sl:112:  stain = stains * smoothstep (.5,1, noise(s*stainfrequency,t*stainfrequency));
k3d/share/shaders/k3d_hextile.sl:114:  scuff = scuffing * smoothstep (.6,1, noise(t*scufffrequency-90.26,
k3d/share/shaders/k3d_hextile.sl:118:  Ct = (1-stain) * mix (mix (Ctile, scuffcolor, scuff), mortarcolor, mortar);
k3d/share/shaders/k3d_imagelayerclouds.sl:1:// Use signed Perlin noise
k3d/share/shaders/k3d_imagelayerclouds.sl:2:#define snoise(x) ((2 * noise(x)) - 1)
k3d/share/shaders/k3d_imagelayerclouds.sl:13:  point PP;			/* Surface point in shader space */
k3d/share/shaders/k3d_imagelayerclouds.sl:17:  PP = txtscale * point(s, t, s);
k3d/share/shaders/k3d_imagelayerclouds.sl:19:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_imagelayerclouds.sl:37:  Ci = Ct;			/* This makes the color disregard the lighting */
k3d/share/shaders/k3d_incandplastic.sl:1:/* incandPlastic.sl   version 1.0, Jan. 2002

k3d/share/shaders/k3d_incandplastic.sl:5: * incandescencia como el contenido en un Blinn. 

k3d/share/shaders/k3d_incandplastic.sl:7: * This is a normal plastic shader and includes an

k3d/share/shaders/k3d_incandplastic.sl:8: * incandescence value like the blinn shader.

k3d/share/shaders/k3d_incandplastic.sl:11:k3d_incandplastic(color SurfaceColor = color(0, 0.25, 1);

k3d/share/shaders/k3d_indirect.sl:1:/* indirect.sl - retrieve radiosity data from the "ray server"
k3d/share/shaders/k3d_indirect.sl:3: * This shader is never called from BMRT -- the "indirect" light source
k3d/share/shaders/k3d_indirect.sl:4: * is built into the renderer.
k3d/share/shaders/k3d_indirect.sl:11:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_indirect.sl:14:light k3d_indirect(output float __nonspecular = 1;)
k3d/share/shaders/k3d_indirect.sl:17:  /* Just in case this is ever compiled for BMRT, make it do nothing. */
k3d/share/shaders/k3d_indirect.sl:22:  /* Exploit the fact that PRMan (incorrectly) leaves the surface normal
k3d/share/shaders/k3d_indirect.sl:23:   * in N.
k3d/share/shaders/k3d_indirect.sl:28:    Cl = rs_indirect(Ps, axis);
k3d/share/shaders/k3d_leather.sl:2: * JexSkin.sl

k3d/share/shaders/k3d_leather.sl:6: * add some parameter, change many thing

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:33:	float BLOTCH_SF = 5;		/*definis le s */

k3d/share/shaders/k3d_leather.sl:34:	float BLOTCH_TF = 5;		/*definis le s */

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

k3d/share/shaders/k3d_leather.sl:56:	 * Standard settings

k3d/share/shaders/k3d_leather.sl:66:	 * and patches of finely speckled red and green. These

k3d/share/shaders/k3d_leather.sl:70:	 * The apple geometry is such that lines of constant

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

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

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

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

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

k3d/share/shaders/k3d_leather.sl:79:	#define BASE_GRC         0.4    /* shift factor for more red       */

k3d/share/shaders/k3d_leather.sl:80:	#define T1               0.0    /* t < T1 is pure green            */

k3d/share/shaders/k3d_leather.sl:81:	#define T2               0.18   /* lerp s.t. T1->T2 => green->red  */

k3d/share/shaders/k3d_leather.sl:82:	#define T3               0.8    /* T2->T3 => red can exist here    */

k3d/share/shaders/k3d_leather.sl:83:	#define T4               1.0    /* lerp s.t. T3->T4 => red->green  */

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

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

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:109:	 * section sets that coefficient, using a funky yet

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

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:115:	#define BLOTCH_DELTA       0.1  /* 'nother scaling kludge */

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: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:130:	 * using the speckling coefficient "speck". These

k3d/share/shaders/k3d_leather.sl:131:	 * specks are very dot-like in nature, and this

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

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

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

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

k3d/share/shaders/k3d_leather.sl:146:	#define BEDGE  .0

k3d/share/shaders/k3d_leather.sl:147:	#define BWIDTH .0

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

k3d/share/shaders/k3d_leather.sl:162:	 * Set the shading surface normal.

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

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

k3d/share/shaders/k3d_leather.sl:172:	#define DISP_DENT_AMP     (1/15)   /* dent amplitude          */

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

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

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

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

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

k3d/share/shaders/k3d_lensflare.sl:5: *   immediately in front of the camera, simulates lens flare.
k3d/share/shaders/k3d_lensflare.sl:6: *   These effects happen in real cameras when the camera points toward
k3d/share/shaders/k3d_lensflare.sl:7: *   a bright light source, resulting in interreflections within the
k3d/share/shaders/k3d_lensflare.sl:9: *   pretty plain looking and uninteresting; this shader takes some
k3d/share/shaders/k3d_lensflare.sl:13: *   intensity - overall scale of intensity of all lens flare effects
k3d/share/shaders/k3d_lensflare.sl:14: *   bloomintensity - overall intensity of the "bloom" effect.  Setting
k3d/share/shaders/k3d_lensflare.sl:17: *   bloomstarry, bloomnpoints - control the "starry" appearance of the 
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: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:27: *          the 4 different kinds of spots.
k3d/share/shaders/k3d_lensflare.sl:28: *   spotintensity - overall intensity scale for the spots
k3d/share/shaders/k3d_lensflare.sl:45:#include "k3d_patterns.h"
k3d/share/shaders/k3d_lensflare.sl:52:  uniform point Pcorner0 = transform("NDC", "screen", point(0, 0, 0));
k3d/share/shaders/k3d_lensflare.sl:53:  uniform point Pcorner1 = transform("NDC", "screen", point(1, 1, 0));
k3d/share/shaders/k3d_lensflare.sl:63:  uniform vector corner = vector(transform("NDC", "camera", point(1, 1, 0)));
k3d/share/shaders/k3d_lensflare.sl:70:rainbow(float x, dx)
k3d/share/shaders/k3d_lensflare.sl:72:#define R	color(1,0,0)
k3d/share/shaders/k3d_lensflare.sl:73:#define O	color(1,.5,0)
k3d/share/shaders/k3d_lensflare.sl:74:#define Y	color(1,1,0)
k3d/share/shaders/k3d_lensflare.sl:75:#define G	color(0,1,0)
k3d/share/shaders/k3d_lensflare.sl:76:#define B	color(0,0,1)
k3d/share/shaders/k3d_lensflare.sl:77:#define Ii	color(.375,0,0.75)
k3d/share/shaders/k3d_lensflare.sl:78:#define V	color(0.5,0,0.5)
k3d/share/shaders/k3d_lensflare.sl:79:  return filteredpulse(0, 1, x, dx) * spline(x, V, V, Ii, B, G, Y, O, R, R);
k3d/share/shaders/k3d_lensflare.sl:84:surface k3d_lensflare(float intensity = 1.0;
k3d/share/shaders/k3d_lensflare.sl:85:		      float bloomintensity = 1;
k3d/share/shaders/k3d_lensflare.sl:88:		      float bloomnpoints = 25;
k3d/share/shaders/k3d_lensflare.sl:90:		      float starburstintensity = 0.075;
k3d/share/shaders/k3d_lensflare.sl:92:		      float starburstnpoints = 100;
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:96:		      float nspots = 50; float disky = 3; float ringy = 1;
k3d/share/shaders/k3d_lensflare.sl:98:		      float bloony = 1; float spotintensity = 0.08;
k3d/share/shaders/k3d_lensflare.sl:117:  point Pndc = (transform("NDC", P) - vector(.5, .5, 0)) * 2;
k3d/share/shaders/k3d_lensflare.sl:121:  illuminance(P, vector "camera"(0, 0, 1), PI / 2)
k3d/share/shaders/k3d_lensflare.sl:127:      atten * intensity * (comp(Cl, 0) + comp(Cl, 1) + comp(Cl, 2)) / 3;
k3d/share/shaders/k3d_lensflare.sl:132:    point Plight = (transform("NDC", P + L) - vector(.5, .5, 0)) * 2;
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:147:	float bloom = pnoise(bloomnpoints * angle / (2 * PI), bloomnpoints);
k3d/share/shaders/k3d_lensflare.sl:151:	Cflare += bloom * (bloomintensity / intensity) / brightness;
k3d/share/shaders/k3d_lensflare.sl:155:    if(starburstintensity > 0)
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: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:176:     * Now emit the random rings themselves
k3d/share/shaders/k3d_lensflare.sl:184:	point cntr = point(mix(-1.7, 1.7, alongaxis) * axis);
k3d/share/shaders/k3d_lensflare.sl:193:	uniform float alltypes = (disky + ringy + blotty + bloony);
k3d/share/shaders/k3d_lensflare.sl:197:	float int = 0;
k3d/share/shaders/k3d_lensflare.sl:200:	    int = 1 - filterstep(radius, axisdist - dPndc / 2,
k3d/share/shaders/k3d_lensflare.sl:203:	else if(type < (disky + ringy))
k3d/share/shaders/k3d_lensflare.sl:204:	  {			/* Ring */
k3d/share/shaders/k3d_lensflare.sl:205:	    int = filteredpulse(radius, radius + 0.05 * axisdist,
k3d/share/shaders/k3d_lensflare.sl:208:	else if(type < (disky + ringy + blotty))
k3d/share/shaders/k3d_lensflare.sl:210:	    int = 1 - smoothstep(0, radius, axisdist);
k3d/share/shaders/k3d_lensflare.sl:213:	  {			/* Spot with soft hole in middle */
k3d/share/shaders/k3d_lensflare.sl:214:	    int = smoothstep(0, radius, axisdist) - filterstep(radius,
k3d/share/shaders/k3d_lensflare.sl:220:	Cflare += spotintensity * bright * clr * Cs * int;
k3d/share/shaders/k3d_lensflare.sl:226:  Ci *= intensity;
k3d/share/shaders/k3d_luna.sl:7: *    the scale for human naked-eye viewing from earth.
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:15: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
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:25:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_luna.sl:28:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_luna.sl:29:#define VLNoise(Pt,scale) (snoise(Pt + scale*DNoise(Pt)))
k3d/share/shaders/k3d_luna.sl:30:#define TWOPI (6.28)
k3d/share/shaders/k3d_luna.sl:42:		 float peak_rad = .0075, inner_rad = .01, rim_rad =
k3d/share/shaders/k3d_luna.sl:49:  point PP, PQ;
k3d/share/shaders/k3d_luna.sl:54:  point vv;
k3d/share/shaders/k3d_luna.sl:57:  point NN;
k3d/share/shaders/k3d_luna.sl:81:  /* Insure that the crater is in one of the maria */
k3d/share/shaders/k3d_luna.sl:102:  vv = point(xcomp(PP) / radial_dist, 0, zcomp(PP) / radial_dist);
k3d/share/shaders/k3d_luna.sl:110:  else if(pd < inner_rad)
k3d/share/shaders/k3d_luna.sl:115:    {				/* inner rim */
k3d/share/shaders/k3d_luna.sl:116:      uu = (pd - inner_rad) / (rim_rad - inner_rad);
k3d/share/shaders/k3d_luna.sl:147:/*	  ht = wrinkled (vv, 2, .833, 4); */
k3d/share/shaders/k3d_luna.sl:162:/*	  ht = wrinkled (vv, 2, .833, 4); */
k3d/share/shaders/k3d_luna.sl:170:  /* Make crater rays (PP, arg10, arg11, arg12, arg15, arg24, arg25, radial_dist);, yielding temp1 */
k3d/share/shaders/k3d_luna.sl:182:  /* Recalc normal since we changed P a whole bunch. */
k3d/share/shaders/k3d_lunette.sl:1:/* renamed JMlinette.sl for RMR.  -- tal */
k3d/share/shaders/k3d_lunette.sl:11: *   pattern I saw in the background of another image entitled "Lunettes",
k3d/share/shaders/k3d_lunette.sl:12: *   which I believe has something to do with spectacles in French.  Hence the
k3d/share/shaders/k3d_lunette.sl:13: *   name, anyway.  The pattern is calculated in 2D u,v coordinates.
k3d/share/shaders/k3d_lunette.sl:17: *   urepeats, vrepeats - number of repeats of the grid pattern in u and v
k3d/share/shaders/k3d_lunette.sl:18: *   ulinewidth, vlinewidth - proportional width of the grid lines
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:22: *   gridDensity - effective opacity of the grid lines
k3d/share/shaders/k3d_lunette.sl:25: *   maxOctaves, lunacrity, gain - work as in the fBm function
k3d/share/shaders/k3d_lunette.sl:27: * Antialiasing:
k3d/share/shaders/k3d_lunette.sl:28: *   The shader should antialias itself quite well, since it uses antialiased
k3d/share/shaders/k3d_lunette.sl:37:#include "k3d_patterns.h"
k3d/share/shaders/k3d_lunette.sl:38:#include "k3d_noises.h"
k3d/share/shaders/k3d_lunette.sl:42: * Base color for the "lunette" pattern.  The pattern is calculated in a two-
k3d/share/shaders/k3d_lunette.sl:43: * dimensional fashion using the coordinates ss and tt as texture / pattern
k3d/share/shaders/k3d_lunette.sl:44: * coordinates.
k3d/share/shaders/k3d_lunette.sl:47: *   ss, tt - 2D pattern coordinates.
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:51: *   sslinewidth, ttlinewidth - Width of the grid lines in ss and tt
k3d/share/shaders/k3d_lunette.sl:56: *                a grid cell).  Increasing this value makes a finer, smaller
k3d/share/shaders/k3d_lunette.sl:57: *                noise; decreasing it makes a broader noise.
k3d/share/shaders/k3d_lunette.sl:61: *   gain - Gain of the fBm noise.
k3d/share/shaders/k3d_lunette.sl:63: *                   possibility to increase the amount of colorB present in
k3d/share/shaders/k3d_lunette.sl:65: *                   colorA and colorB are present in equal amounts.
k3d/share/shaders/k3d_lunette.sl:66: *                   Increasing this value puts more colorB in the output.
k3d/share/shaders/k3d_lunette.sl:67: *   gridDensity - Effective opacity of the grid pattern over the underlying
k3d/share/shaders/k3d_lunette.sl:69: *   baselinecolor - Base color of the grid lines.
k3d/share/shaders/k3d_lunette.sl:72:	float ss;		/* ss coordinate for the lunette pattern */
k3d/share/shaders/k3d_lunette.sl:73:	float tt;		/* tt coordinate for the lunette pattern */
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:76:	float sslinewidth;	/* proportional width of lines in ss */
k3d/share/shaders/k3d_lunette.sl:77:	float ttlinewidth;	/* proportional width of lines in tt */
k3d/share/shaders/k3d_lunette.sl:78:	color colorA;		/* first color in the pattern */
k3d/share/shaders/k3d_lunette.sl:79:	color colorB;		/* second color in the pattern */
k3d/share/shaders/k3d_lunette.sl:84:	uniform float gain;		/* gain 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:92:	 * the grid.  pulsegrid = 0 means that there is no grid at the point
k3d/share/shaders/k3d_lunette.sl:93:	 * whereas pulsegrid = 1 means that there IS a grid at the point.
k3d/share/shaders/k3d_lunette.sl:95:	 * antialising at the edges of the grid.
k3d/share/shaders/k3d_lunette.sl:97:	float pulsess = filteredpulsetrain(
k3d/share/shaders/k3d_lunette.sl:98:		1/ssrepeats, sslinewidth, ss, filterwidth(ss)
k3d/share/shaders/k3d_lunette.sl:100:	float pulsett = filteredpulsetrain(
k3d/share/shaders/k3d_lunette.sl:101:		1/ttrepeats, ttlinewidth, tt, filterwidth(tt)
k3d/share/shaders/k3d_lunette.sl:103:	float pulsegrid = 1 - min(pulsess, pulsett); 
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:110:	point noisePt = noiseScale * 
k3d/share/shaders/k3d_lunette.sl:111:		point(ss*ssrepeats, tt*ttrepeats, noiseRandom);
k3d/share/shaders/k3d_lunette.sl:114:		noisePt, noisefilterwidth, maxOctaves, lunacrity, gain
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:127:	return mix(basecolor, linecolor, pulsegrid);
k3d/share/shaders/k3d_lunette.sl:132:	/* Plastic illumination model parameters. */
k3d/share/shaders/k3d_lunette.sl:139:	float urepeats = 30;		/* Number of repeats in u */
k3d/share/shaders/k3d_lunette.sl:140:	float ulinewidth = 0.125;	/* Relative width of grid lines in u */
k3d/share/shaders/k3d_lunette.sl:141:	float vrepeats = 30;		/* Number of repeats in v */
k3d/share/shaders/k3d_lunette.sl:142:	float vlinewidth = 0.12;	/* Relative width of grid lines in v */
k3d/share/shaders/k3d_lunette.sl:146:	color baselinecolor = color(.51, .48, .52);
k3d/share/shaders/k3d_lunette.sl:147:	float colorBenhance = 1.6;	/* Enhancement of colorB in output */
k3d/share/shaders/k3d_lunette.sl:154:	float gain = .7;
k3d/share/shaders/k3d_lunette.sl:160:		u, v, urepeats, vrepeats, ulinewidth, vlinewidth,
k3d/share/shaders/k3d_lunette.sl:162:		lunacrity, gain, colorBenhance, gridDensity, baselinecolor
k3d/share/shaders/k3d_lunette.sl:166:	 * apply a plastic illumination model
k3d/share/shaders/k3d_map_pattern_1.sl:2:string map1=""; 
k3d/share/shaders/k3d_map_pattern_1.sl:12:float grainy=1; 
k3d/share/shaders/k3d_map_pattern_1.sl:20:/** Surface main-code start **/
k3d/share/shaders/k3d_map_pattern_1.sl:45:point PP, PQ;
k3d/share/shaders/k3d_map_pattern_1.sl:54:PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_map_pattern_1.sl:57:PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_map_pattern_1.sl:62:PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_map_pattern_1.sl:63:r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_map_pattern_1.sl:67:/** Surface main-code end **/
k3d/share/shaders/k3d_mondometal.sl:13:    string abColorMap = "";

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

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

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

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

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

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

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

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

k3d/share/shaders/k3d_mondometal.sl:48:    string metalMatte = "";

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

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

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

k3d/share/shaders/k3d_mondometal.sl:62:    color Csurf, Cspec, Copac, Cincand, Crefl;

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

k3d/share/shaders/k3d_mondometal.sl:70:    /* determine color **/

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

k3d/share/shaders/k3d_mondometal.sl:95:    /* determine diffuse **/

k3d/share/shaders/k3d_mondometal.sl:107:    /* determine specular */

k3d/share/shaders/k3d_mondometal.sl:120:    /* determine specular color */

k3d/share/shaders/k3d_mondometal.sl:131:    /* determine roughness */

k3d/share/shaders/k3d_mondometal.sl:143:    /* determine opacity */

k3d/share/shaders/k3d_mondometal.sl:160:    /* determine incandescence */

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

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

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:234:      Ci = Os * Copac * (Csurf * (Cincand + ambient() + diff * diffuse(Nf)) + 

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

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

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

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

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

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

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

k3d/share/shaders/k3d_mysky.sl:19: *    skycolor, cloudcolor - the obvious meanings

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: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:33: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.

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:46:/* Use signed Perlin noise */

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

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

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

k3d/share/shaders/k3d_noisysmoke.sl:1:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_noisysmoke.sl:4:/* Here is where we define the GADD. */
k3d/share/shaders/k3d_noisysmoke.sl:5:#define GADD(PP,PW,li,g)                                                    \
k3d/share/shaders/k3d_noisysmoke.sl:6:         if (use_lighting > 0) {                                            \
k3d/share/shaders/k3d_noisysmoke.sl:8:	     illuminance (PW) { li += Cl; }                                 \
k3d/share/shaders/k3d_noisysmoke.sl:31:		      float integstart = 0, integend = 100;
k3d/share/shaders/k3d_noisysmoke.sl:33:		      float use_lighting = 1; float use_noise = 1;
k3d/share/shaders/k3d_noisysmoke.sl:40:  /* PRMan and BMRT used to have I reverse of each other, conflict in spec */
k3d/share/shaders/k3d_noisysmoke.sl:41:  point Worigin = P + I;
k3d/share/shaders/k3d_noisysmoke.sl:42:  vector incident = vtransform("shader", -I);
k3d/share/shaders/k3d_noisysmoke.sl:45:  point Worigin = P - I;
k3d/share/shaders/k3d_noisysmoke.sl:46:  vector incident = vtransform("shader", I);
k3d/share/shaders/k3d_noisysmoke.sl:48:  point origin = transform("shader", Worigin);
k3d/share/shaders/k3d_noisysmoke.sl:54:  float nsteps = 0;		/* record number of integration steps */
k3d/share/shaders/k3d_noisysmoke.sl:56:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_noisysmoke.sl:61:  end = min(length(incident), integend) - 0.0001;
k3d/share/shaders/k3d_noisysmoke.sl:63:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_noisysmoke.sl:64:  d = integstart + random() * stepsize;
k3d/share/shaders/k3d_noisysmoke.sl:67:      IN = normalize(incident);
k3d/share/shaders/k3d_noisysmoke.sl:69:      PP = origin + d * IN;
k3d/share/shaders/k3d_noisysmoke.sl:70:      PW = Worigin + d * WIN;
k3d/share/shaders/k3d_noisysmoke.sl:71:      GADD(PP, PW, li, dtau) ss = min(stepsize, end - d);
k3d/share/shaders/k3d_noisysmoke.sl:79:	  PP = origin + d * IN;
k3d/share/shaders/k3d_noisysmoke.sl:80:	  PW = Worigin + d * WIN;
k3d/share/shaders/k3d_noisysmoke.sl:82:	    /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_noisysmoke.sl:98:	  ss = max(min(ss, end - d), 0.005);
k3d/share/shaders/k3d_noisysmoke.sl:115:      printf("nsteps = %f, t1 = %f, end = %f\n", nsteps, integstart, end);
k3d/share/shaders/k3d_noisysmoke.sl:116:      printf("   Cv = %c, Ov = %c\n", Cv, Ov);
k3d/share/shaders/k3d_null.sl:2: * Null shader - does nothing to a surface
k3d/share/shaders/k3d_null.sl:4: * Note: we include dummy Ka and Kd arguments to appease the radiosity
k3d/share/shaders/k3d_null.sl:5: * engine.
k3d/share/shaders/k3d_oak.sl:5: *    wood grain.  The rings surround the z axis, so to position the
k3d/share/shaders/k3d_oak.sl:6: *    pattern, one should translate the shadingspace (which defaults to
k3d/share/shaders/k3d_oak.sl:7: *    "shader").  This makes a fairly plain, unfinished wood, that looks
k3d/share/shaders/k3d_oak.sl:10: * Parameters for the coordinate mapping: 
k3d/share/shaders/k3d_oak.sl:11: *   shadingspace - space in which the pattern is laid out
k3d/share/shaders/k3d_oak.sl:12: *   shadingfreq - overall scaling factor for the pattern
k3d/share/shaders/k3d_oak.sl:17: *   Cdarkwood - the darker color in the ring/grain
k3d/share/shaders/k3d_oak.sl:18: *   ringfreq - mean frequency of ring spacing
k3d/share/shaders/k3d_oak.sl:19: *   ringunevenness - 0=equally spaced rings, larger is unequally spaced
k3d/share/shaders/k3d_oak.sl:20: *   grainfreq - frequency of the fine grain
k3d/share/shaders/k3d_oak.sl:21: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oak.sl:24: *   angularwobble, angularwobblefreq - warping indexed by angle about
k3d/share/shaders/k3d_oak.sl:26: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oak.sl:27: *       grain are weighted.  0 turns one off, 1 makes full effect.
k3d/share/shaders/k3d_oak.sl:28: *   divotdepth - depth (in shader units) of the displacement due to
k3d/share/shaders/k3d_oak.sl:29: *       ring or grain.
k3d/share/shaders/k3d_oak.sl:30: *   truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_oak.sl:32: * Parameters for illumination model:
k3d/share/shaders/k3d_oak.sl:33: *   Ka, Kd, Ks, roughness - the usual meaning
k3d/share/shaders/k3d_oak.sl:45:#include "k3d_project.h"
k3d/share/shaders/k3d_oak.sl:46:#include "k3d_pshad.h"
k3d/share/shaders/k3d_oak.sl:47:#include "k3d_material.h"
k3d/share/shaders/k3d_oak.sl:48:#include "k3d_displace.h"
k3d/share/shaders/k3d_oak.sl:50:#include "k3d_oak.h"
k3d/share/shaders/k3d_oak.sl:56:		float ringfreq = 8, ringunevenness = 0.5;
k3d/share/shaders/k3d_oak.sl:57:		float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oak.sl:58:		float grainfreq = 25;
k3d/share/shaders/k3d_oak.sl:64:		float ringy = 1, grainy = 1;
k3d/share/shaders/k3d_oak.sl:73:    oaktexture(Pshad, dPshad, ringfreq, ringunevenness, grainfreq, ringnoise,
k3d/share/shaders/k3d_oak.sl:74:	       ringnoisefreq, trunkwobble, trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oak.sl:75:	       angularwobblefreq, ringy, grainy);
k3d/share/shaders/k3d_oak.sl:79:  /* Illumination model - just use plastic */
k3d/share/shaders/k3d_oakplank.sl:6: *    the y axis.  The subpattern within each individual plank is just
k3d/share/shaders/k3d_oakplank.sl:9: * Parameters for the coordinate mapping: 
k3d/share/shaders/k3d_oakplank.sl:10: *   shadingspace - space in which the pattern is laid out
k3d/share/shaders/k3d_oakplank.sl:11: *   shadingfreq - overall scaling factor for the pattern
k3d/share/shaders/k3d_oakplank.sl:22: * Parameters for the color and pattern of the wood grain: 
k3d/share/shaders/k3d_oakplank.sl:24: *   Cdarkwood - the darker color in the ring/grain
k3d/share/shaders/k3d_oakplank.sl:25: *   ringfreq - mean frequency of ring spacing
k3d/share/shaders/k3d_oakplank.sl:26: *   ringunevenness - 0=equally spaced rings, larger is unequally spaced
k3d/share/shaders/k3d_oakplank.sl:27: *   grainfreq - frequency of the fine grain
k3d/share/shaders/k3d_oakplank.sl:28: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oakplank.sl:31: *   angularwobble, angularwobblefreq - warping indexed by angle about
k3d/share/shaders/k3d_oakplank.sl:33: *   ringy, grainy - overall scale on the degree to which rings and
k3d/share/shaders/k3d_oakplank.sl:34: *       grain are weighted.  0 turns one off, 1 makes full effect.
k3d/share/shaders/k3d_oakplank.sl:35: *   divotdepth - depth (in shader units) of the displacement due to
k3d/share/shaders/k3d_oakplank.sl:36: *       ring or grain.
k3d/share/shaders/k3d_oakplank.sl:37: *   truedisp - 1 for true displacement, 0 for bump mapping
k3d/share/shaders/k3d_oakplank.sl:39: * Parameters for illumination model:
k3d/share/shaders/k3d_oakplank.sl:40: *   Ka, Kd, Ks, roughness - the usual meaning
k3d/share/shaders/k3d_oakplank.sl:42: *   envname, envspace, envrad - environment mapping controls
k3d/share/shaders/k3d_oakplank.sl:43: *   rayjitter, raysamples - ray tracing controls
k3d/share/shaders/k3d_oakplank.sl:44: *   varnishlump, arnishlumpfreq - amp & freq of lumpiness in the varnish
k3d/share/shaders/k3d_oakplank.sl:56:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_oakplank.sl:59:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_oakplank.sl:61:#include "k3d_project.h"
k3d/share/shaders/k3d_oakplank.sl:62:#include "k3d_pshad.h"
k3d/share/shaders/k3d_oakplank.sl:63:#include "k3d_material.h"
k3d/share/shaders/k3d_oakplank.sl:64:#include "k3d_noises.h"
k3d/share/shaders/k3d_oakplank.sl:65:#include "k3d_displace.h"
k3d/share/shaders/k3d_oakplank.sl:66:#include "k3d_patterns.h"
k3d/share/shaders/k3d_oakplank.sl:68:#include "k3d_oak.h"
k3d/share/shaders/k3d_oakplank.sl:71:/* Given 2-D texture coordinates ss,tt, filter widths ds, dt, and the
k3d/share/shaders/k3d_oakplank.sl:73: * (integer indexed) plank we are on and what coordinates within our
k3d/share/shaders/k3d_oakplank.sl:74: * individual plank we are shading.
k3d/share/shaders/k3d_oakplank.sl:82:  /* Find which s plank we're on and our s coordinate within it */
k3d/share/shaders/k3d_oakplank.sl:85:  /* Shift in t a random amount for each plank column */
k3d/share/shaders/k3d_oakplank.sl:87:  /* Find which t plank we're on and our t coordinate within it */
k3d/share/shaders/k3d_oakplank.sl:90:  /* Calculate our "in-plank" value by multiplying two perpendicular
k3d/share/shaders/k3d_oakplank.sl:91:   * filtered pulsetrain functions.
k3d/share/shaders/k3d_oakplank.sl:93:  return filteredpulsetrain(groovewidth, plankwidth, ss + groovewidth / 2,
k3d/share/shaders/k3d_oakplank.sl:94:			    ds) * filteredpulsetrain(grooveheight,
k3d/share/shaders/k3d_oakplank.sl:106:		     float ringfreq = 8, ringunevenness = 0.5;
k3d/share/shaders/k3d_oakplank.sl:107:		     float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oakplank.sl:108:		     float grainfreq = 25;
k3d/share/shaders/k3d_oakplank.sl:115:		     float ringy = 1, grainy = 1;
k3d/share/shaders/k3d_oakplank.sl:128:   * Find out where in the pattern we are: which plank we're on, and
k3d/share/shaders/k3d_oakplank.sl:129:   * the (splank,tplank) coordinates (both on [0,1]) within our tile.
k3d/share/shaders/k3d_oakplank.sl:132:  float inplank = plankpattern(ss, tt, dss, dtt, plankwidth, planklength,
k3d/share/shaders/k3d_oakplank.sl:135:  float plankindex = swhichplank + 13 * twhichplank;
k3d/share/shaders/k3d_oakplank.sl:136:  point Ppat =
k3d/share/shaders/k3d_oakplank.sl:137:    point(splank - 0.5, height - 0.01 * tplank, tplank) + vector(1, 5,
k3d/share/shaders/k3d_oakplank.sl:141:  float wood = oaktexture(Ppat, dPshad, ringfreq, ringunevenness, grainfreq,
k3d/share/shaders/k3d_oakplank.sl:142:			  ringnoise, ringnoisefreq, trunkwobble,
k3d/share/shaders/k3d_oakplank.sl:144:			  angularwobblefreq, ringy, grainy);
k3d/share/shaders/k3d_oakplank.sl:147:  Cwood = varyEach(Cwood, plankindex, varyhue, varysat, varylum);
k3d/share/shaders/k3d_oakplank.sl:148:  Cwood = mix(Cgroove, Cwood, inplank);
k3d/share/shaders/k3d_oakplank.sl:164:  /* Illumination model
k3d/share/shaders/k3d_oakplank.sl:165:   * Less specular in the grooves, more specular in the dark wood. 
k3d/share/shaders/k3d_oakplank.sl:167:  float specadjusted = 1 + .3 * wood - 0.8 * (1 - inplank);
k3d/share/shaders/k3d_oakplank.sl:169:    MaterialShinyPlastic(Nf, Cwood, Ka, Kd, specadjusted * Ks, roughness,
k3d/share/shaders/k3d_orange.sl:2: * Actually it is a condensed version of the mango shader from Sig '92 "Writing RenderMan Shaders"
k3d/share/shaders/k3d_orange.sl:23:#define BUMP_AMPLITUDE (1/30)
k3d/share/shaders/k3d_orange.sl:24:#define BUMP_FREQUENCY (35)
k3d/share/shaders/k3d_orange.sl:33:	point Nf, V;
k3d/share/shaders/k3d_orange.sl:34:	point turb, p2;
k3d/share/shaders/k3d_orange.sl:35:	point newP;
k3d/share/shaders/k3d_orange.sl:38:	setxcomp (p2, sin (2 * PI * s));
k3d/share/shaders/k3d_orennayar.sl:8: *   Makes a rough surface using a BRDF which is more accurate than
k3d/share/shaders/k3d_orennayar.sl:24: *         Series 1994 (Proceedings of SIGGRAPH '94), pp. 239-246.
k3d/share/shaders/k3d_orennayar.sl:27: *   1. Note that this is really just an illuminance loop that gathers
k3d/share/shaders/k3d_orennayar.sl:30: *      or a function and used in any other shader, in place of diffuse().
k3d/share/shaders/k3d_orennayar.sl:31: *   2. Examination of why rough surfaces are not Lambertian will lead
k3d/share/shaders/k3d_orennayar.sl:45:    point Nf, IN, Eye, LN;
k3d/share/shaders/k3d_orennayar.sl:58:    illuminance (P, Nf, PI/2) {
k3d/share/shaders/k3d_orennayar.sl:64:	beta = min (theta_i, theta_r);
k3d/share/shaders/k3d_orennayar.sl:68:	    C2 *= sin(alpha);
k3d/share/shaders/k3d_orennayar.sl:69:	else C2 *= (sin(alpha) - pow(2*beta/PI,3));
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:9: *   I should probably add some bump mapping or other variation, but
k3d/share/shaders/k3d_outlet.sl:21: *      17 Jan 1994 -- recoded by lg in correct shading language.
k3d/share/shaders/k3d_outlet.sl:35:  point Nf;
k3d/share/shaders/k3d_outlet.sl:67:  /* Use the plastic illumination model */
k3d/share/shaders/k3d_outline.sl:1:/* IDoutline written by Ivan DeWolf
k3d/share/shaders/k3d_outline.sl:3: * width sets the line width.
k3d/share/shaders/k3d_outline.sl:6:k3d_outline(float width = .05)
k3d/share/shaders/k3d_painted_constant.sl:1:surface k3d_painted_constant(
k3d/share/shaders/k3d_painted_constant.sl:2:	string texturename = "";
k3d/share/shaders/k3d_paintedplastic.sl:1:/* paintedplastic.sl - Standard texture map surface for RenderMan Interface.
k3d/share/shaders/k3d_paintedplastic.sl:9: *    Apply a texture map to a plastic surface, indexing the texture
k3d/share/shaders/k3d_paintedplastic.sl:13: *    Ka, Kd, Ks, roughness, specularcolor - the usual meaning.
k3d/share/shaders/k3d_paintedplastic.sl:18:surface k3d_paintedplastic(
k3d/share/shaders/k3d_paintedplastic.sl:24:	string texturename = "";
k3d/share/shaders/k3d_parquet_plank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_plank.sl:8: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank.sl:12: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_plank.sl:13: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank.sl:14: *   plankspertile - number of planks in each parquet tile
k3d/share/shaders/k3d_parquet_plank.sl:15: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_parquet_plank.sl:16: *   grainscale - scaling for the fine grain
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:21: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_parquet_plank.sl:22: *   wavy - relative wavyness of the ring pattern
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:25: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_plank.sl:33:			  float ringscale = 15, grainscale = 60;
k3d/share/shaders/k3d_parquet_plank.sl:41:			  float grainy = 1, wavy = 0.08;)
k3d/share/shaders/k3d_parquet_plank.sl:43:#define snoise(x) (2 * noise((x)) - 1)
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:45:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_parquet_plank.sl:62:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_plank.sl:93:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_plank.sl:94:   * antialiasing.
k3d/share/shaders/k3d_parquet_plank.sl:118:   * Add the ring patterns
k3d/share/shaders/k3d_parquet_plank.sl:120:  fade = smoothstep(1 / ringscale, 8 / ringscale, fwidth);
k3d/share/shaders/k3d_parquet_plank.sl:124:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank.sl:131:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_plank.sl:133:      fade = smoothstep(2 / grainscale, 8 / grainscale, fwidth);
k3d/share/shaders/k3d_parquet_plank.sl:136:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale / 4));
k3d/share/shaders/k3d_parquet_plank.sl:137:	  r2 = grainy * r2 * r2 + (1 - grainy);
k3d/share/shaders/k3d_parquet_plank.sl:147:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank.sl:150:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_parquet_plank.sl:156:  /* Use the plastic illumination model */
k3d/share/shaders/k3d_parquet_plank2.sl:6: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_plank2.sl:9: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank2.sl:13: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_plank2.sl:14: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_plank2.sl:15: *   plankspertile - number of planks in each parquet tile
k3d/share/shaders/k3d_parquet_plank2.sl:16: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_parquet_plank2.sl:17: *   grainscale - scaling for the fine grain
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:22: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_parquet_plank2.sl:23: *   wavy - relative wavyness of the ring pattern
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:26: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_plank2.sl:28: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_plank2.sl:32: *                Washington, DC 20052
k3d/share/shaders/k3d_parquet_plank2.sl:47:	       float ringscale = 15, grainscale = 60;
k3d/share/shaders/k3d_parquet_plank2.sl:55:	       float grainy = 1, wavy = 0.08; )
k3d/share/shaders/k3d_parquet_plank2.sl:57:#define snoise(x) (2 * noise((x)) - 1)
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:59:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_parquet_plank2.sl:62:  point Nf;
k3d/share/shaders/k3d_parquet_plank2.sl:76:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_plank2.sl:100:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_plank2.sl:101:   * antialiasing.
k3d/share/shaders/k3d_parquet_plank2.sl:119:   * Add the ring patterns
k3d/share/shaders/k3d_parquet_plank2.sl:121:  fade = smoothstep (1/ringscale, 8/ringscale, fwidth);
k3d/share/shaders/k3d_parquet_plank2.sl:124:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank2.sl:130:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_plank2.sl:132:      fade = smoothstep (2/grainscale, 8/grainscale, fwidth);
k3d/share/shaders/k3d_parquet_plank2.sl:134:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_plank2.sl:135:	  r2 = grainy * r2*r2 + (1-grainy);
k3d/share/shaders/k3d_parquet_plank2.sl:143:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_plank2.sl:146:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_parquet_plank2.sl:151:  /* Use the plastic illumination model */
k3d/share/shaders/k3d_parquet_tile.sl:7: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_parquet_tile.sl:10: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_tile.sl:14: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_parquet_tile.sl:15: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_parquet_tile.sl:16: *   plankspertile - number of planks in each parquet tile
k3d/share/shaders/k3d_parquet_tile.sl:17: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_parquet_tile.sl:18: *   grainscale - scaling for the fine grain
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:23: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_parquet_tile.sl:24: *   wavy - relative wavyness of the ring pattern
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:27: *   even with low sampling densities.
k3d/share/shaders/k3d_parquet_tile.sl:29: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_tile.sl:33: *                Washington, DC 20052
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:45: *   - many thanks to Larry Gritz and wave for creating the original
k3d/share/shaders/k3d_parquet_tile.sl:54: *   - ringscale from 15 to 25
k3d/share/shaders/k3d_parquet_tile.sl:55: *   - grainscale from 60 to 55
k3d/share/shaders/k3d_parquet_tile.sl:62:	       float ringscale = 25, grainscale = 55;
k3d/share/shaders/k3d_parquet_tile.sl:70:	       float grainy = 1, wavy = 0.08; )
k3d/share/shaders/k3d_parquet_tile.sl:72:#define snoise(x) (2 * noise((x)) - 1)
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:74:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_parquet_tile.sl:77:  point Nf;
k3d/share/shaders/k3d_parquet_tile.sl:91:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_parquet_tile.sl:115:   * are grooves, 1 where the wood grain is visible.  Do some simple
k3d/share/shaders/k3d_parquet_tile.sl:116:   * antialiasing.
k3d/share/shaders/k3d_parquet_tile.sl:134:   * Add the ring patterns
k3d/share/shaders/k3d_parquet_tile.sl:136:  fade = smoothstep (1/ringscale, 8/ringscale, fwidth);
k3d/share/shaders/k3d_parquet_tile.sl:139:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_tile.sl:145:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_parquet_tile.sl:147:      fade = smoothstep (2/grainscale, 8/grainscale, fwidth);
k3d/share/shaders/k3d_parquet_tile.sl:149:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_tile.sl:150:	  r2 = grainy * r2*r2 + (1-grainy);
k3d/share/shaders/k3d_parquet_tile.sl:158:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_parquet_tile.sl:161:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_parquet_tile.sl:166:  /* Use the plastic illumination model */
k3d/share/shaders/k3d_planetclouds.sl:7: *   make it look like the clouds surrounding an Earth-like planet.
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:14: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_planetclouds.sl:18: *    offset - controls the zero crossings (where the clouds disappear)
k3d/share/shaders/k3d_planetclouds.sl:23: *      spheres represent a planet.  The inner one is colored like the
k3d/share/shaders/k3d_planetclouds.sl:24: *      surface of a planet (perhaps using the "terran" shader), and the
k3d/share/shaders/k3d_planetclouds.sl:30: *           AttributeBegin
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:46: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
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:56:#define TWOPI (2*PI)
k3d/share/shaders/k3d_planetclouds.sl:58:/* Use signed Perlin noise */
k3d/share/shaders/k3d_planetclouds.sl:59:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_planetclouds.sl:60:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_planetclouds.sl:61:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_planetclouds.sl:62:#define VERY_SMALL 0.001
k3d/share/shaders/k3d_planetclouds.sl:71:  point Pdistortion;		/* "distortion" vector */
k3d/share/shaders/k3d_planetclouds.sl:72:  point PP;			/* Point after distortion */
k3d/share/shaders/k3d_planetclouds.sl:76:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_planetclouds.sl:79:  /* Add in "distortion" vector */
k3d/share/shaders/k3d_planetclouds.sl:96:  /* Adjust zero crossing (where the clouds disappear) */
k3d/share/shaders/k3d_plank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_plank.sl:10: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_plank.sl:11: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_plank.sl:12: *   grainscale - scaling for the fine grain
k3d/share/shaders/k3d_plank.sl:13: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:14: *   planklength - length of each plank (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:15: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_plank.sl:19: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_plank.sl:20: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_plank.sl:22: * ANTIALIASING: this shader does a pretty good job of antialiasing itself,
k3d/share/shaders/k3d_plank.sl:23: *   even with low sampling densities.
k3d/share/shaders/k3d_plank.sl:31:		  float ringscale = 15, grainscale = 60;
k3d/share/shaders/k3d_plank.sl:38:		  float grainy = 1, wavy = 0.08;)
k3d/share/shaders/k3d_plank.sl:40:#define snoise(x) (2 * (float noise((x))) - 1)
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:42:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_plank.sl:57:  /* Determine how wide in s-t space one pixel projects to */
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:80:   * antialiasing.
k3d/share/shaders/k3d_plank.sl:104:   * Add the ring patterns
k3d/share/shaders/k3d_plank.sl:106:  fade = smoothstep(1 / ringscale, 8 / ringscale, fwidth);
k3d/share/shaders/k3d_plank.sl:110:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_plank.sl:117:       * Multiply the ring pattern by the fine grain
k3d/share/shaders/k3d_plank.sl:119:      fade = smoothstep(2 / grainscale, 8 / grainscale, fwidth);
k3d/share/shaders/k3d_plank.sl:122:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale));
k3d/share/shaders/k3d_plank.sl:123:	  r2 = grainy * r2 * r2 + (1 - grainy);
k3d/share/shaders/k3d_plank.sl:133:  /* Mix the light and dark wood according to the grain pattern */
k3d/share/shaders/k3d_plank.sl:136:  /* Add plank-to-plank variation in overall color */
k3d/share/shaders/k3d_plank.sl:143:   * Use the plastic illumination model
k3d/share/shaders/k3d_plastic2.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_plastic2.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_plastic2.sl:19:    point Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plastic2.sl:20:    point V = normalize(-I);
k3d/share/shaders/k3d_pointlight.sl:1:/* pointlight.sl - Standard point light source for RenderMan Interface.
k3d/share/shaders/k3d_pointlight.sl:9:light k3d_pointlight(float intensity = 3000;
k3d/share/shaders/k3d_pointlight.sl:11:		     point from = point "shader"(0, 0, 0);)
k3d/share/shaders/k3d_pointlight.sl:13:  illuminate(from) Cl = intensity * lightcolor / (L.L);
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:30:	string texturename = "";
k3d/share/shaders/k3d_projectionmap_plastic.sl:47:			point Pshad = transform("shader", P);
k3d/share/shaders/k3d_puffyclouds.sl:8: *    Makes nice looking cumulous clouds like you would see in the sky
k3d/share/shaders/k3d_puffyclouds.sl:9: *    on a bright sunny day.  Works as a basic thresholded fBm.  Since
k3d/share/shaders/k3d_puffyclouds.sl:11: *    lighting into account.  If you wanted a lit surface that looked like
k3d/share/shaders/k3d_puffyclouds.sl:12: *    puffy clouds (like painted clouds on a wall), then it would be pretty
k3d/share/shaders/k3d_puffyclouds.sl:13: *    easy to add the lighting.
k3d/share/shaders/k3d_puffyclouds.sl:16: *    txtscale - overall scaling factor
k3d/share/shaders/k3d_puffyclouds.sl:17: *    skycolor, cloudcolor - the obvious meanings
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: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:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
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:43:/* Use signed Perlin noise */
k3d/share/shaders/k3d_puffyclouds.sl:44:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_puffyclouds.sl:58:  point PP;      /* Surface point in shader space */
k3d/share/shaders/k3d_puffyclouds.sl:63:  /* Use fractional Brownian motion to compute a value for this point */
k3d/share/shaders/k3d_puffyclouds.sl:77:  Ci = Ct;   /* This makes the color disregard the lighting */
k3d/share/shaders/k3d_puffyclouds.sl:78:  /* Uncomment the next line if you want the surface to actually be lit */
k3d/share/shaders/k3d_redapple.sl:10: * This shader creates a nice skin for red-green apples. It _is_ tuned
k3d/share/shaders/k3d_redapple.sl:13: * texture parameter running equatorialy around them (like latitude
k3d/share/shaders/k3d_redapple.sl:14: * lines), and "t" running from pole to pole (like longditude). Apples
k3d/share/shaders/k3d_redapple.sl:16: * don't mind the simple lerping I used to fade to green at the poles.
k3d/share/shaders/k3d_redapple.sl:19: * done using shader space, instead of "s" and "t" parameters (I think
k3d/share/shaders/k3d_redapple.sl:23: * I think this shader is really cool. If you think so too, you can
k3d/share/shaders/k3d_redapple.sl:24: * email me your praises, notification of my credits in big motion
k3d/share/shaders/k3d_redapple.sl:31:/*#define USE_LG_RAYTRACE */
k3d/share/shaders/k3d_redapple.sl:34:#include "rayserver.h"
k3d/share/shaders/k3d_redapple.sl:35:#include "raytrace.h"
k3d/share/shaders/k3d_redapple.sl:39:#define snoise(x) (2*noise(x)-1)  /* 1-D signed noise */
k3d/share/shaders/k3d_redapple.sl:42:#define TSCALE .05
k3d/share/shaders/k3d_redapple.sl:63:	point PP, newP;
k3d/share/shaders/k3d_redapple.sl:80:	 * Standard settings
k3d/share/shaders/k3d_redapple.sl:90:	 * and patches of finely speckled red and green. These
k3d/share/shaders/k3d_redapple.sl:94:	 * The apple geometry is such that lines of constant
k3d/share/shaders/k3d_redapple.sl:95:	 * "t" are lines of longditude (from pole to pole).
k3d/share/shaders/k3d_redapple.sl:99:	#define BASE_SF          1.2    /* s-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:100:	#define BASE_TF          3      /* t-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:101:	#define BASE_NF          100    /* scaling factor for small noise  */
k3d/share/shaders/k3d_redapple.sl:102:	#define BASE_NOISE_AMP   0.2    /* small noise color mix amplitude */
k3d/share/shaders/k3d_redapple.sl:103:	#define BASE_GRC         0.4    /* shift factor for more red       */
k3d/share/shaders/k3d_redapple.sl:104:	#define T1               0.0    /* t < T1 is pure green            */
k3d/share/shaders/k3d_redapple.sl:105:	#define T2               0.18   /* lerp s.t. T1->T2 => green->red  */
k3d/share/shaders/k3d_redapple.sl:106:	#define T3               0.8    /* T2->T3 => red can exist here    */
k3d/share/shaders/k3d_redapple.sl:107:	#define T4               1.0    /* lerp s.t. T3->T4 => red->green  */
k3d/share/shaders/k3d_redapple.sl:109:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:123:	base_color = spline(base_turb, green, green,
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:133:	 * section sets that coefficient, using a funky yet
k3d/share/shaders/k3d_redapple.sl:134:	 * really simple noise routine.
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:138:	#define BLOTCH_TCF         2.5  /* scaling kludge         */
k3d/share/shaders/k3d_redapple.sl:139:	#define BLOTCH_DELTA       0.1  /* 'nother scaling kludge */
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: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:154:	 * using the speckling coefficient "speck". These
k3d/share/shaders/k3d_redapple.sl:155:	 * specks are very dot-like in nature, and this
k3d/share/shaders/k3d_redapple.sl:156:	 * dottiness technique is stolen from LG's starfield 
k3d/share/shaders/k3d_redapple.sl:159:	#define SPECK_NF        50    /* A noise scaling factor      */
k3d/share/shaders/k3d_redapple.sl:160:	#define SPECK_CUTOFF    .45   /* Cutoff for 'tops' of specks */
k3d/share/shaders/k3d_redapple.sl:165:	 * Determine where the apple goes black at the poles.
k3d/share/shaders/k3d_redapple.sl:170:	#define BEDGE  .01
k3d/share/shaders/k3d_redapple.sl:171:	#define BWIDTH .01
k3d/share/shaders/k3d_redapple.sl:177:	 * Combine what we have so far to set the surface
k3d/share/shaders/k3d_redapple.sl:186:	 * Set the shading surface normal.
k3d/share/shaders/k3d_redapple.sl:194:	#define DISP_SF     10             /* s-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:195:	#define DISP_TF     30             /* t-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:196:	#define DISP_DENT_AMP     (1/15)   /* dent amplitude          */
k3d/share/shaders/k3d_redapple.sl:197:	#define DISP_SMNOISE_AMP  (1/1000) /* small noise amplitude   */
k3d/share/shaders/k3d_redapple.sl:198:	#define DISP_SPECK_AMP    (1/40)   /* speckle disp. amplitude */
k3d/share/shaders/k3d_redapple.sl:199:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:211:	 * in the surface of an apple. They don't add much, but
k3d/share/shaders/k3d_redapple.sl:230:	 * Combine everything to get Ci, in the standard form.
k3d/share/shaders/k3d_ridged_multifractal.sl:3: *    Conversion to Shading Language and minor modifications by Fredrik Brnnbacka.

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

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

k3d/share/shaders/k3d_ridged_multifractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

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

k3d/share/shaders/k3d_ridged_multifractal.sl:30:                             original one -- signal *= signal;*/

k3d/share/shaders/k3d_ridged_multifractal.sl:50:          		/* invert and translate*/

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:16:#include "k3d_material.h"
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:12:	float	 uu,	/* distance in u to the nearest "vertical" edge */
k3d/share/shaders/k3d_round.sl:13:		 vv,	/* distance in v to the nearest "horizontal" edge */
k3d/share/shaders/k3d_round.sl:16:	point	 center,/* point toward which the surface is displaced 	*/
k3d/share/shaders/k3d_round.sl:17:		 dpdu,	/* dPdu pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:18:		 dpdv;	/* dPdv pointed toward patch center line 	*/
k3d/share/shaders/k3d_round.sl:20:	/* Find the distance in parameter space from the nearest edge in
k3d/share/shaders/k3d_round.sl:21:	   u and in v, and the directions away from those edges. */
k3d/share/shaders/k3d_round.sl:37:	/* Find the distances from the edges in the current space. */
k3d/share/shaders/k3d_round.sl:41:	if (lu < radius || lv < radius) {	/* only if within radius of 
k3d/share/shaders/k3d_round.sl:44:	 * Find the point towards which the surface  point will be 
k3d/share/shaders/k3d_round.sl:45:	 *  moved. This center is on the center line of a cylinder, if we 
k3d/share/shaders/k3d_round.sl:47:	 *  sphere, if we are. We move `center' to the nearest inflection 
k3d/share/shaders/k3d_round.sl:50:		center = point(0,0,0);
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:7: * adds in a little white dust to mimic the dust on a new eraser.
k3d/share/shaders/k3d_rubber.sl:15:	point	Nf = faceforward(normalize(N),I), 
k3d/share/shaders/k3d_rubber.sl:19:	/* Mix in some white dust. */
k3d/share/shaders/k3d_ruledpaper.sl:5: *   Makes a patch look like a piece of loose-leaf paper with lines,
k3d/share/shaders/k3d_ruledpaper.sl:6: *   the margin, binder holes and writing (as an image texture).
k3d/share/shaders/k3d_ruledpaper.sl:7: *   Works in s/t space.
k3d/share/shaders/k3d_ruledpaper.sl:11: *   linestr - how strongly do the lines show up (0.0 to 1.0)
k3d/share/shaders/k3d_ruledpaper.sl:14: * ANTIALIASING: no antialiasing. This can be a real problem because of the
k3d/share/shaders/k3d_ruledpaper.sl:15: *               thin lines on the paper.
k3d/share/shaders/k3d_ruledpaper.sl:21: *    8 Nov 1997 - started writing shader for RDC under MS VC++
k3d/share/shaders/k3d_ruledpaper.sl:22: *    9 Nov 1997 - added binder holes and finished shader
k3d/share/shaders/k3d_ruledpaper.sl:23: *   15 Nov 1997 - translated to Renderman SL in Linux
k3d/share/shaders/k3d_ruledpaper.sl:28: *   Don't worry about the paper anatomy settings. I moved them to
k3d/share/shaders/k3d_ruledpaper.sl: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:32: *   I don't know how many holes there were in paper when _YOU_ were a kid
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:34: *   and got all the measurements with a ruler. This is the real thing!!
k3d/share/shaders/k3d_ruledpaper.sl:45:	float linestr = 1;
k3d/share/shaders/k3d_ruledpaper.sl:46:	string texturename = "";
k3d/share/shaders/k3d_ruledpaper.sl:48:	/* Paper anatomy settings */
k3d/share/shaders/k3d_ruledpaper.sl:54: 		shiny=1.25/pw,
k3d/share/shaders/k3d_ruledpaper.sl:55:	// Spacing between lines
k3d/share/shaders/k3d_ruledpaper.sl:56:		lines = 0.7 / ph,
k3d/share/shaders/k3d_ruledpaper.sl:57:	// Thickness of lines
k3d/share/shaders/k3d_ruledpaper.sl:58:		linet = 0.05 / ph,
k3d/share/shaders/k3d_ruledpaper.sl:59:	// How far into the page do the lines start
k3d/share/shaders/k3d_ruledpaper.sl:60:		linef = 0.5 / pw,
k3d/share/shaders/k3d_ruledpaper.sl:61:	// Top and bottom margins for lines
k3d/share/shaders/k3d_ruledpaper.sl:64:	// Where does the vertical line (margin) start and end?
k3d/share/shaders/k3d_ruledpaper.sl:67:	// Settings for binder holes (circles)
k3d/share/shaders/k3d_ruledpaper.sl:68:	// Circle center along page (ss coordinate system)
k3d/share/shaders/k3d_ruledpaper.sl:70:	// Circle radius in ss/tt coord. system
k3d/share/shaders/k3d_ruledpaper.sl:72:	// Bounding box for circles
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:78:// calculates if it's inside the circle. If it is, the colour
k3d/share/shaders/k3d_ruledpaper.sl:81:#define circle(sm,tm) { \
k3d/share/shaders/k3d_ruledpaper.sl:84:		if (distance( point(ss,tt,0), point(sm,tm,0) ) <= circr)	\
k3d/share/shaders/k3d_ruledpaper.sl:89:    point Nf, V;
k3d/share/shaders/k3d_ruledpaper.sl:93:    // For plastic and diffuse shading
k3d/share/shaders/k3d_ruledpaper.sl:99:	// there's writing on the paper.
k3d/share/shaders/k3d_ruledpaper.sl:105:	// If we're inside the borders/margins
k3d/share/shaders/k3d_ruledpaper.sl:106:	if ( (s>linef) && (t>margt) && (t<margb) )
k3d/share/shaders/k3d_ruledpaper.sl:107:	// Figure out where in the lining we are and draw accordingly
k3d/share/shaders/k3d_ruledpaper.sl:108:	if ( (mod(t, lines)<=linet) || ((s>=verts) && (s<=verte)) )
k3d/share/shaders/k3d_ruledpaper.sl:109:		tex = (tex*(1-linestr)) + (color(0.2,0.8,0.8) * linestr);
k3d/share/shaders/k3d_ruledpaper.sl:113:	// Bounding box for circle calcs
k3d/share/shaders/k3d_ruledpaper.sl:121:		// Find bounding boxes first to speed up calcs
k3d/share/shaders/k3d_ruledpaper.sl:132:	// Check if it actually needs shading
k3d/share/shaders/k3d_ruledpaper.sl:134:		if (s<=shiny) {
k3d/share/shaders/k3d_ruledpaper.sl:135:			// If inside plasticky reinforcement strip then
k3d/share/shaders/k3d_ruledpaper.sl:136:			// use plastic shading model.
k3d/share/shaders/k3d_rustymetal.sl:8: *   the corrosion is kind of grainy).  Where there is no rust, shade like
k3d/share/shaders/k3d_rustymetal.sl:9: *   regular metal.  All computations are done in shader space.
k3d/share/shaders/k3d_rustymetal.sl:14: *   txtscale - overall scaling factor of the rust pattern.
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:21: *   aliasing under control.
k3d/share/shaders/k3d_rustymetal.sl:24: *         The George Washington University
k3d/share/shaders/k3d_rustymetal.sl:34:/* Signed noise varies from -1 to 1 (like Perlin uses) */
k3d/share/shaders/k3d_rustymetal.sl:35:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_rustymetal.sl:38:#define MAXOCTAVES 8
k3d/share/shaders/k3d_rustymetal.sl:52:  point Nf, V;                 /* normal and view vector used for shading */
k3d/share/shaders/k3d_rustymetal.sl:53:  point Nrust;                 /* perturbed normal for the rusty areas */
k3d/share/shaders/k3d_rustymetal.sl:54:  point PP;                    /* shade space point */
k3d/share/shaders/k3d_rustymetal.sl:56:  float alimit;                /* Limit sum to do simple antialiasing */
k3d/share/shaders/k3d_rustymetal.sl:57:  float rustiness;             /* Result: how rusty is this point? */
k3d/share/shaders/k3d_rustymetal.sl:61:   * number of octaves by the estimated change in PP between adjacent
k3d/share/shaders/k3d_rustymetal.sl:62:   * shading samples.
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:75:   * computation, then sharpen it by squaring its value.
k3d/share/shaders/k3d_rustymetal.sl:77:  rustiness = step (1-rusty, clamp (sum,0,1));
k3d/share/shaders/k3d_rustymetal.sl:78:  rustiness *= clamp (abs(snoise(PP)), 0, .08) / 0.08;
k3d/share/shaders/k3d_rustymetal.sl:79:  rustiness *= rustiness;
k3d/share/shaders/k3d_rustymetal.sl:81:  /* If we have any rust, calculate the color of the rust, taking into
k3d/share/shaders/k3d_rustymetal.sl:82:   * account the perturbed normal and shading like matte.
k3d/share/shaders/k3d_rustymetal.sl:84:  if (rustiness > 0) {
k3d/share/shaders/k3d_rustymetal.sl:88:  /* If we have any metal, calculate the color of the metal, using the
k3d/share/shaders/k3d_rustymetal.sl:89:   * original (smooth) normal and the usual metal illumination model.
k3d/share/shaders/k3d_rustymetal.sl:91:  if (rustiness < 1) {
k3d/share/shaders/k3d_rustymetal.sl:97:  /* Now blend the metal and rust colors depending on the computed value
k3d/share/shaders/k3d_rustymetal.sl:98:   * of the rustiness.
k3d/share/shaders/k3d_rustymetal.sl:101:  Ci = Oi * mix (Cmetal, Crust, rustiness);
k3d/share/shaders/k3d_saturn.sl:10: *   Saturn-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_saturn.sl:15: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_saturn.sl:16: *    dist_scale - scaling for multifractal distortion
k3d/share/shaders/k3d_saturn.sl:17: *    lat_scale,  map_exp - control scaling of 
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:49:  point PP;
k3d/share/shaders/k3d_saturn.sl:50:  point PtN;
k3d/share/shaders/k3d_saturn.sl:53:  point Ptexture;
k3d/share/shaders/k3d_saturn.sl:55:  /* Do all shading in shader space */
k3d/share/shaders/k3d_saturn.sl:71:      Ct = spline (latitude,
k3d/share/shaders/k3d_saturn.sl:84:  /* Shade using matte model */
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:5: *	When put on a disk will give a "saturn-like ringed" apearence with
k3d/share/shaders/k3d_saturnring.sl:6: * varing colors and transparency.
k3d/share/shaders/k3d_saturnring.sl:10: *	cutoff - what point to start rings (radius of transparency)
k3d/share/shaders/k3d_saturnring.sl:11: *	ringrad - radius of ring
k3d/share/shaders/k3d_saturnring.sl:12: *	opacity - the opacity of the rings (may not be used anymore)
k3d/share/shaders/k3d_saturnring.sl:25:#define RING1 0.83    /* Relative spacing for outermost ring */
k3d/share/shaders/k3d_saturnring.sl:26:#define RING2 0.77    /* Relative spacing for next outermost ring */    
k3d/share/shaders/k3d_saturnring.sl:27:#define RING3 0.62    /* Relative spacing for   "  outermost ring */
k3d/share/shaders/k3d_saturnring.sl:28:#define RING4 0.58    /* Relative spacing for   "  outermost ring */
k3d/share/shaders/k3d_saturnring.sl:29:#define RING5 0.55    /* Relative spacing for   "  outermost ring */
k3d/share/shaders/k3d_saturnring.sl:33:#define snoise(x) (2 * noise(x) - 1)	
k3d/share/shaders/k3d_saturnring.sl:36:#define snoise(x) (2.5 * (noise(x) - 1))
k3d/share/shaders/k3d_saturnring.sl:39:surface k3d_saturnring (float Ka = 1.0, Kd = 1.0,
k3d/share/shaders/k3d_saturnring.sl:40:	cutoff = 0.55, ringrad = 1.0, opacity = 0.5;)
k3d/share/shaders/k3d_saturnring.sl:42:	point PP;       /* Transformed point */
k3d/share/shaders/k3d_saturnring.sl:43:	point Nf;       /* Forward facing Normalized vector of incident light */
k3d/share/shaders/k3d_saturnring.sl:51:	color dpink = color (.664, .465,  .465);     /* A shade of dark pink */
k3d/share/shaders/k3d_saturnring.sl:57:#define DEBUG 0
k3d/share/shaders/k3d_saturnring.sl:59:	printf ("val %f ringrad %f \n",
k3d/share/shaders/k3d_saturnring.sl:60:	 val,  ringrad);
k3d/share/shaders/k3d_saturnring.sl:63:	if (val < cutoff * ringrad) {
k3d/share/shaders/k3d_saturnring.sl:64:		/* Creating an inner disk that is transparent to place the planet */
k3d/share/shaders/k3d_saturnring.sl:68:		/* Create rings of varing transparency */
k3d/share/shaders/k3d_saturnring.sl:69:		relpos =  val / ringrad;
k3d/share/shaders/k3d_saturnring.sl:72:#define DEBUG2 0
k3d/share/shaders/k3d_saturnring.sl:74:		printf ("oi = %f\n", oi);
k3d/share/shaders/k3d_saturnring.sl:77:		/* Create some gaps of completely transparent rings */
k3d/share/shaders/k3d_saturnring.sl:99:			cs = dpink;	
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_screen.sl:2: * (c) Pixar (appears in _RenderMan Companion_)
k3d/share/shaders/k3d_screen.sl:7: *   parallel to lines of s and t.  You can adjust the Ka, Kd, Ks, etc.
k3d/share/shaders/k3d_screen.sl:12: *   frequency - how many cycles of screen in st space
k3d/share/shaders/k3d_screen.sl:16: *   No antialiasing is performed here.
k3d/share/shaders/k3d_screen_aa.sl:6: *   parallel to lines of s and t.  You can adjust the Ka, Kd, Ks, etc.
k3d/share/shaders/k3d_screen_aa.sl:12: *   frequency - how many cycles of screen in st space
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:26:#define MINFILTERWIDTH 1.0e-7
k3d/share/shaders/k3d_screen_aa.sl:34:  normal Nf;			/* Forward facing Normal vector */
k3d/share/shaders/k3d_screen_aa.sl:35:  vector IN;			/* normalized incident vector */
k3d/share/shaders/k3d_screen_aa.sl:36:  float d;			/* Density at the sample point */
k3d/share/shaders/k3d_screen_aa.sl:37:  float ss, tt;			/* s,t, parameters in phase */
k3d/share/shaders/k3d_screen_aa.sl:40:  /* Compute a forward facing normal */
k3d/share/shaders/k3d_screen_aa.sl:44:  /* Determine how wide in s-t space one pixel projects to */
k3d/share/shaders/k3d_screen_aa.sl:48:  /* Figure out where in the pattern we are */
k3d/share/shaders/k3d_screen_aa.sl:52:  /* Figure out where the strips are. Do some simple antialiasing. */
k3d/share/shaders/k3d_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:16:	string	texturename	= "")
k3d/share/shaders/k3d_sdixon.sl:18:	point Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_sdixon.sl:19:	point V = normalize(-I);
k3d/share/shaders/k3d_sdixon.sl:20:	float ink;
k3d/share/shaders/k3d_sdixon.sl:23:	/* This shader uses a single-channel texture map to apply a 
k3d/share/shaders/k3d_sdixon.sl:24:	 *   metallic-green ink to a matte-yellow background. */
k3d/share/shaders/k3d_sdixon.sl:26:	/* Get the amount of ink from texture file. */
k3d/share/shaders/k3d_sdixon.sl:27:	ink = texture(texturename, s, t);
k3d/share/shaders/k3d_sdixon.sl:29: 	/* Use ink to mix yellow and green */
k3d/share/shaders/k3d_sdixon.sl:30:	cout = mix(yellow, green, ink); 					 
k3d/share/shaders/k3d_sdixon.sl:32:	/* Compute the output color. Notice that as ink goes from zero to
k3d/share/shaders/k3d_sdixon.sl:34:	   component is increased. This has the effect of transitioning
k3d/share/shaders/k3d_sdixon.sl:35:	   from a matte surface to a metallic one as ink is added. */
k3d/share/shaders/k3d_sdixon.sl:37:	Ci = Os * cout * ( Ka*ambient() + (1-ink)*Kd*diffuse(Nf) +
k3d/share/shaders/k3d_sdixon.sl:38:					ink*Ks*specular(Nf,V,roughness) ) ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:5:    float  intensity=1 ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:7:    point from = point "shader" (0,0,0) ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:8:    point to   = point "shader" (0,0,1) ;
k3d/share/shaders/k3d_shadowdistant_rim.sl:9:    string shadowname="";
k3d/share/shaders/k3d_shadowdistant_rim.sl:18:        Cl = intensity * lightcolor;
k3d/share/shaders/k3d_shadowspot.sl:3:/* Listing 16.33  Spotlight using shadow map*/
k3d/share/shaders/k3d_shadowspot.sl:9:	float intensity	= 1;
k3d/share/shaders/k3d_shadowspot.sl:11:	point from = point "shader" (0, 0, 0);
k3d/share/shaders/k3d_shadowspot.sl:12:	point to = point "shader" (0, 0, 1);
k3d/share/shaders/k3d_shadowspot.sl:16:	string shadowfile = "";
k3d/share/shaders/k3d_shadowspot.sl:21:	point A = (to - from) / length(to - from); /* direction */
k3d/share/shaders/k3d_shadowspot.sl:23:			cosinside = cos(coneangle-conedeltaangle);
k3d/share/shaders/k3d_shadowspot.sl:24:	float	attenuation, 	/* falloff from center of illumination cone */
k3d/share/shaders/k3d_shadowspot.sl:25:		cosangle;	/* cosine of angle wrt center of cone */
k3d/share/shaders/k3d_shadowspot.sl:27:	illuminate( from, A, coneangle ) {
k3d/share/shaders/k3d_shadowspot.sl:30:		attenuation *= smoothstep( cosoutside, cosinside, cosangle );
k3d/share/shaders/k3d_shadowspot.sl:33:		Cl = attenuation * intensity * lightcolor;
k3d/share/shaders/k3d_shifteddrtile.sl:2: * TLShiftedD_RTile.sl -- generates a surface of alternating disks and rings
k3d/share/shaders/k3d_shifteddrtile.sl:5: *	Will generate alternating and shifted rows of disks and rings
k3d/share/shaders/k3d_shifteddrtile.sl:12: *	innerRadius - inner ring
k3d/share/shaders/k3d_shifteddrtile.sl:13: *	outerRadius - outer ring
k3d/share/shaders/k3d_shifteddrtile.sl:14: *	sfreq - # of tiles in s
k3d/share/shaders/k3d_shifteddrtile.sl:15: *	tfreq - # of tiles in t 
k3d/share/shaders/k3d_shifteddrtile.sl:20: *	The center varible should really be placed in the parameter list 
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:23: *      specifing the inner and outer ring.
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:37:#define repeat(pos, freq) \
k3d/share/shaders/k3d_shifteddrtile.sl:40:#define whichtile(pos, freq) \
k3d/share/shaders/k3d_shifteddrtile.sl:43:#define isOdd(x) \
k3d/share/shaders/k3d_shifteddrtile.sl:53:	uniform float innerRadius = 0.3;    /* inner ring */
k3d/share/shaders/k3d_shifteddrtile.sl:54:	uniform float outerRadius = 0.45;   /* outer ring */
k3d/share/shaders/k3d_shifteddrtile.sl:55:	uniform float sfreq = 4.0;          /* # of tiles in s */
k3d/share/shaders/k3d_shifteddrtile.sl:56:	uniform float tfreq = 4.0;          /* # of tiles in t */
k3d/share/shaders/k3d_shifteddrtile.sl:60:	point Nf;
k3d/share/shaders/k3d_shifteddrtile.sl:61:	uniform point center;      /* Center of disk */
k3d/share/shaders/k3d_shifteddrtile.sl:65:	float row, col;    /* used to determine which tile we are in */
k3d/share/shaders/k3d_shifteddrtile.sl:73:	                         /* put in the paramter list */
k3d/share/shaders/k3d_shifteddrtile.sl:90:		/* Do ring */
k3d/share/shaders/k3d_shifteddrtile.sl:91:		mix_opacity = smoothPulse (innerRadius, outerRadius, fuzz, d);
k3d/share/shaders/k3d_shiftedmoontile.sl:12: *	sfreq - # of tiles in s
k3d/share/shaders/k3d_shiftedmoontile.sl:13: *	tfreq - # of tiles in t
k3d/share/shaders/k3d_shiftedmoontile.sl:14: *	eclipseCenter - Center of obscuring disk
k3d/share/shaders/k3d_shiftedmoontile.sl:28:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shiftedmoontile.sl:32:#define repeat(pos, freq) \
k3d/share/shaders/k3d_shiftedmoontile.sl:35:#define whichtile(pos, freq) \
k3d/share/shaders/k3d_shiftedmoontile.sl:38:#define isOdd(x) \
k3d/share/shaders/k3d_shiftedmoontile.sl:41:#define difference(a, b) ((a) - (a) * b)
k3d/share/shaders/k3d_shiftedmoontile.sl:53:	uniform point eclipseCenter = point "current" (0.6, 0.5, 0);
k3d/share/shaders/k3d_shiftedmoontile.sl:57:	point Nf;
k3d/share/shaders/k3d_shiftedmoontile.sl:58:	uniform point center;            /* Center of disk */
k3d/share/shaders/k3d_shiftedmoontile.sl:61:	float circle1, circle2;  /* True if in circle1, circle2 */
k3d/share/shaders/k3d_shiftedmoontile.sl:62:	float ss, tt;            /* Tile coordinates */
k3d/share/shaders/k3d_shiftedmoontile.sl:63:	float row, col;          /* Location in tiles */
k3d/share/shaders/k3d_shiftedmoontile.sl:64:	float d, d2;             /* Point distance from circle1, circle2 */
k3d/share/shaders/k3d_shiny.sl:2: * shiny.sl -- Shiny metal surface
k3d/share/shaders/k3d_shiny.sl:5: *    Ka, Kd, Ks, roughness - The usual meaning
k3d/share/shaders/k3d_shiny.sl:8: *    envname, envspace, envrad - controls for using environment maps
k3d/share/shaders/k3d_shiny.sl:9: *    rayjitter, raysamples - ray tracing controls for reflection
k3d/share/shaders/k3d_shiny.sl:10: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shiny.sl:11: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_shiny.sl:13: *        when using the "ray server."
k3d/share/shaders/k3d_shiny.sl:20: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_shiny.sl:28:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_shiny.sl:29:#include "k3d_material.h"
k3d/share/shaders/k3d_shiny.sl:33:surface k3d_shiny(float Ka = 1, Kd = 0.1, Ks = 1, roughness = 0.2;
k3d/share/shaders/k3d_shiny.sl:39:    MaterialShinyMetal(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, twosided,
k3d/share/shaders/k3d_shinymetal.sl:1:/* shinymetal.sl - Standard metal with environment mapping for
k3d/share/shaders/k3d_shinymetal.sl:10:surface k3d_shinymetal(float Ka = 1;
k3d/share/shaders/k3d_shinymetal.sl:12:		       string texturename = "";)
k3d/share/shaders/k3d_shinyplastic.sl:2: * shinyplastic.sl -- Shiny plastic surface
k3d/share/shaders/k3d_shinyplastic.sl:5: *    Ka, Kd, Ks, roughness - The usual meaning
k3d/share/shaders/k3d_shinyplastic.sl:8: *    ior - index of refraction (1.5 is a good estimate for most plastics)
k3d/share/shaders/k3d_shinyplastic.sl:9: *    envname, envspace, envrad - controls for using environment maps
k3d/share/shaders/k3d_shinyplastic.sl:10: *    rayjitter, raysamples - ray tracing controls for reflection
k3d/share/shaders/k3d_shinyplastic.sl:11: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shinyplastic.sl:12: *        only the "outside" (where the surface normal points) will
k3d/share/shaders/k3d_shinyplastic.sl:14: *        when using the "ray server."
k3d/share/shaders/k3d_shinyplastic.sl:24:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_shinyplastic.sl:25:#include "k3d_material.h"
k3d/share/shaders/k3d_shinyplastic.sl:27:surface k3d_shinyplastic(float Ka = 1, Kd = 0.5, Ks = .5, roughness = 0.1;
k3d/share/shaders/k3d_shinyplastic.sl:35:    MaterialShinyPlastic(Nf, Cs, Ka, Kd, Ks, roughness, Kr, blur, ior,
k3d/share/shaders/k3d_show_st.sl:3:/* Listing 16.11  Shader mapping texture-space coordinates to colors */
k3d/share/shaders/k3d_show_st.sl:6: * show_st(): color surface point according to its s,t coordinates.
k3d/share/shaders/k3d_skin1.sl:2: * RCskin.sl
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:10: * Surface shader that implements a shading model that should have a visual 
k3d/share/shaders/k3d_skin1.sl:11: * appearence generall similar to that of skin. 
k3d/share/shaders/k3d_skin1.sl:13: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_skin1.sl:14: * everywhere, Just list me on the credits under "Shading Team"
k3d/share/shaders/k3d_skin1.sl:17: * Kd = the amount of uniform diffusion applyied to the skin
k3d/share/shaders/k3d_skin1.sl:18: * skincolor, skinmap = the color of the skin. Using a map overrides original skincolor
k3d/share/shaders/k3d_skin1.sl:20: * sheencolor, shinmap = the color of the skin at grazing angles. Using a map overrides
k3d/share/shaders/k3d_skin1.sl:21: * original sheencolor color value.
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:26: * Oily,oilmap = controls how oily the skin looks. Use a grayscale map to contol
k3d/share/shaders/k3d_skin1.sl:27: * oiliness.---Note--- teh oiliy parameter is multiplied with the map.
k3d/share/shaders/k3d_skin1.sl:33: * You can replace the header functions by using
k3d/share/shaders/k3d_skin1.sl:34: * #include "locilum.h" and #include "noises.h".
k3d/share/shaders/k3d_skin1.sl:35: * NOTE- you must copy the entire subsurface skin function to your
k3d/share/shaders/k3d_skin1.sl:42: *     Renamed RudyCSkin for RMR.
k3d/share/shaders/k3d_skin1.sl:54: * Greg Ward Larson's anisotropic specular local illumination model.
k3d/share/shaders/k3d_skin1.sl:55: * The derivation and formulae can be found in:  Ward, Gregory J.
k3d/share/shaders/k3d_skin1.sl:56: * "Measuring and Modeling Anisotropic Reflection," ACM Computer 
k3d/share/shaders/k3d_skin1.sl:57: * Graphics 26(2) (Proceedings of Siggraph '92), pp. 265-272, July, 1992.
k3d/share/shaders/k3d_skin1.sl:71:    extern point P;
k3d/share/shaders/k3d_skin1.sl:72:    illuminance (P, N, PI/2) {
k3d/share/shaders/k3d_skin1.sl:73:  /* Must declare extern L & Cl because we're in a function */
k3d/share/shaders/k3d_skin1.sl:92:/* ------ ADAPTED FROM Mat Pahr's Skin.sl------
k3d/share/shaders/k3d_skin1.sl:93: * --- subsurfaceSkin------
k3d/share/shaders/k3d_skin1.sl:94: * Surface shader that implements a shading model that should have a visual 
k3d/share/shaders/k3d_skin1.sl:95: * appearence generall similar to that of skin.  Based on phenomenological 
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:98: * proceedings of Siggraph 1993.
k3d/share/shaders/k3d_skin1.sl:100:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin1.sl:102:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin1.sl:103:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin1.sl:110:/* Compute a the single-scattering approximation to scattering from
k3d/share/shaders/k3d_skin1.sl:111:   a one-dimensional volumetric surface.  Given incident and outgoing
k3d/share/shaders/k3d_skin1.sl:113:   scattering albedo (between 0 and 1 for physically-valid volumes),
k3d/share/shaders/k3d_skin1.sl:114:   and the thickness of the volume, use the closed-form single-scattering
k3d/share/shaders/k3d_skin1.sl:115:   equation to approximate overall scattering.
k3d/share/shaders/k3d_skin1.sl:117:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin1.sl:118:    float win = abs(wi . n);
k3d/share/shaders/k3d_skin1.sl:121:    return albedo * phase(wo, wi, g) / (win + won) *
k3d/share/shaders/k3d_skin1.sl:122:    (1. - exp(-(1/win + 1/won) * thickness));
k3d/share/shaders/k3d_skin1.sl:133:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin1.sl: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:139:  extern point P;
k3d/share/shaders/k3d_skin1.sl:145:  illuminance(P, Nn, PI/2) {
k3d/share/shaders/k3d_skin1.sl:154:      C += skinColor * Cl * (Ln . Nn) * Kt * Kt2 * 
k3d/share/shaders/k3d_skin1.sl:155:    (singleScatter(T, T2, Nn, .8, .8, thickness) +
k3d/share/shaders/k3d_skin1.sl:156:     singleScatter(T, T2, Nn, .3, .5, thickness) +
k3d/share/shaders/k3d_skin1.sl:157:     singleScatter(T, T2, Nn, 0., .4, thickness));
k3d/share/shaders/k3d_skin1.sl:160:}    /* subsurfaceSkin --ends */
k3d/share/shaders/k3d_skin1.sl:164:#define snoise(p) (2 * (float noise(p)) - 1)
k3d/share/shaders/k3d_skin1.sl:167: *shader beggins here.
k3d/share/shaders/k3d_skin1.sl:170:surface k3d_skin1(
k3d/share/shaders/k3d_skin1.sl:172:  color skincolor = color (0.7, 0.56, 0.52);
k3d/share/shaders/k3d_skin1.sl:173:  string skinmap = "";
k3d/share/shaders/k3d_skin1.sl:175:  string sheenmap = "";
k3d/share/shaders/k3d_skin1.sl:179:  string blemishmap = "";
k3d/share/shaders/k3d_skin1.sl:182:  varying vector xdir = dPdu;
k3d/share/shaders/k3d_skin1.sl:185:  string oilmap = "";
k3d/share/shaders/k3d_skin1.sl:194:  /* initialize local variables*/
k3d/share/shaders/k3d_skin1.sl:200:  point PP;
k3d/share/shaders/k3d_skin1.sl:204:  color Cskin = skincolor;
k3d/share/shaders/k3d_skin1.sl:209:  /*--- layer 1 - add pores to the skin*/
k3d/share/shaders/k3d_skin1.sl:224:   * you can use an image map for the color of the skin and the sheen.
k3d/share/shaders/k3d_skin1.sl:225:   * If the map is not provided use defined colors*/
k3d/share/shaders/k3d_skin1.sl:227:  if (skinmap != "")
k3d/share/shaders/k3d_skin1.sl:228:      Cskin = color texture(skinmap);
k3d/share/shaders/k3d_skin1.sl:233:  sc = Cskin;
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:245:  color red01 = Cskin + 0.05,
k3d/share/shaders/k3d_skin1.sl:247:        darkred01 = Cskin - 0.05,
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:273:  * outside the skin. Oilyness is controlled by the oily, xrougness and yroughness.
k3d/share/shaders/k3d_skin2.sl:2: * skin.sl 
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:9: * Surface shader that implements a shading model that should have a visual 
k3d/share/shaders/k3d_skin2.sl:10: * appearence generall similar to that of skin.  Based on phenomenological 
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:13: * proceedings of Siggraph 1993. 
k3d/share/shaders/k3d_skin2.sl:16: * for notes and background information.
k3d/share/shaders/k3d_skin2.sl:19:/* Evaluate the Henyey-Greenstein phase function for two vectors with
k3d/share/shaders/k3d_skin2.sl:21:   be in the range (-1, 1).  Negative values of g correspond to more
k3d/share/shaders/k3d_skin2.sl:22:   back-scattering and positive values correspond to more forward scattering.
k3d/share/shaders/k3d_skin2.sl:29:/* Compute a the single-scattering approximation to scattering from
k3d/share/shaders/k3d_skin2.sl:30:   a one-dimensional volumetric surface.  Given incident and outgoing
k3d/share/shaders/k3d_skin2.sl:32:   scattering albedo (between 0 and 1 for physically-valid volumes),
k3d/share/shaders/k3d_skin2.sl:33:   and the thickness of the volume, use the closed-form single-scattering
k3d/share/shaders/k3d_skin2.sl:34:   equation to approximate overall scattering.
k3d/share/shaders/k3d_skin2.sl:36:float singleScatter(vector wi, wo; normal n; float g, albedo, thickness) {
k3d/share/shaders/k3d_skin2.sl:37:    float win = abs(wi . n);
k3d/share/shaders/k3d_skin2.sl:40:    return albedo * phase(wo, wi, g) / (win + won) *
k3d/share/shaders/k3d_skin2.sl:41:		(1. - exp(-(1/win + 1/won) * thickness));
k3d/share/shaders/k3d_skin2.sl:54:/* Implements overall skin subsurface shading model.  Takes viewing and
k3d/share/shaders/k3d_skin2.sl:55:   surface normal information, the base color of the skin, a
k3d/share/shaders/k3d_skin2.sl:56:   color for an oily surface sheen, the ratio of the indices of 
k3d/share/shaders/k3d_skin2.sl:57:   refraction of the incoming ray (typically ~1 for air) to the index
k3d/share/shaders/k3d_skin2.sl:58:   of refraction for the transmitted ray (say something like 1.4 for
k3d/share/shaders/k3d_skin2.sl:59:   skin), and the overall thickness of the skin layer.  Then loops
k3d/share/shaders/k3d_skin2.sl:60:   over light sources with illuminance() and computes the reflected
k3d/share/shaders/k3d_skin2.sl:61:   skin color.
k3d/share/shaders/k3d_skin2.sl:63:color subsurfaceSkin(vector Vf; normal Nn; color skinColor, sheenColor;
k3d/share/shaders/k3d_skin2.sl:65:	extern point P;
k3d/share/shaders/k3d_skin2.sl:71:	illuminance(P, Nn, PI/2) {
k3d/share/shaders/k3d_skin2.sl:80:	    C += skinColor * Cl * (Ln . Nn) * Kt * Kt2 * 
k3d/share/shaders/k3d_skin2.sl:81:		(singleScatter(T, T2, Nn, .8, .8, thickness) +
k3d/share/shaders/k3d_skin2.sl:82:		 singleScatter(T, T2, Nn, .3, .5, thickness) +
k3d/share/shaders/k3d_skin2.sl:83:		 singleScatter(T, T2, Nn, 0., .4, thickness));
k3d/share/shaders/k3d_skin2.sl:88:/* Basic surface shader that uses the skin reflection model implemented
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:92:surface k3d_skin2(color Ka = .5; color sheenColor = 1.;
k3d/share/shaders/k3d_skin2.sl:98:	Ci = Os * subsurfaceSkin(Vf, Nn, Cs, sheenColor, eta, thickness);
k3d/share/shaders/k3d_skymetal.sl:3: * The RenderMan Interface and Shading Language
k3d/share/shaders/k3d_skymetal.sl:5: * NOTE: This shader was created at a time when the shading lanuage
k3d/share/shaders/k3d_skymetal.sl:8: * A more general version with some explainations can be found in my
k3d/share/shaders/k3d_skymetal.sl:18:    point up = normalize (point "world" (0, 1, 0) - point "world"  (0, 0, 0)); 
k3d/share/shaders/k3d_skymetal.sl:19:             /* actually should be vector and vtransform if using 3.5 or 
k3d/share/shaders/k3d_skymetal.sl:24:	point Nf;
k3d/share/shaders/k3d_slateroof.sl:4:	slateroof.sl - a surface shader working with slateroofd.sl, to
k3d/share/shaders/k3d_slateroof.sl:5:	introduce a slate color onto roof tiles, making the last row of tiles
k3d/share/shaders/k3d_slateroof.sl:7:	You must bear this in mind when modelling - to avoid the roof ending
k3d/share/shaders/k3d_slateroof.sl:9:	introduces a random color variation so that one tile will be lighter or
k3d/share/shaders/k3d_slateroof.sl:15:   tfreq: number of tiles in the t direction
k3d/share/shaders/k3d_slateroof.sl:17: 	ramp: the amount of a tile used for the initial rise to the maximum height
k3d/share/shaders/k3d_slateroof.sl:19: 	gap: the size of the gap between one tile and the next in the s direction,
k3d/share/shaders/k3d_slateroof.sl:24: 	txtscale: a scaling factor for the slate coloration - the larger txtscale the
k3d/share/shaders/k3d_slateroof.sl:26: 	factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroof.sl:28: 		different random patterning. A value > 20 works best
k3d/share/shaders/k3d_slateroof.sl:34: 	Peter Quint 17/11/2000
k3d/share/shaders/k3d_slateroof.sl:38:	produce an appropriate displacement and message passing from the
k3d/share/shaders/k3d_slateroof.sl:39:	displacement shader would eliminate the need for a lot of the
k3d/share/shaders/k3d_slateroof.sl:40:	calculations in this shader. Renderdc, however, does not yet support
k3d/share/shaders/k3d_slateroof.sl:41:	message passing, so to produce the test image the code has been
k3d/share/shaders/k3d_slateroof.sl:61:   uniform float swidth = 1 / sfreq, 		/* Tile width in the s directio */
k3d/share/shaders/k3d_slateroof.sl:65:   float scoord = s, tcoord = 1 - t; 		/* re map the t coord so that the coving is at the top */
k3d/share/shaders/k3d_slateroof.sl:66:	float stile, ttile, 							/* An integer identifying the current tile */
k3d/share/shaders/k3d_slateroof.sl:67:			s_offset, t_offset, 					/* Offsets withing the current tile, between 0, 1 */
k3d/share/shaders/k3d_slateroof.sl:68:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:69:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroof.sl:72:			disps, dispt, disp, dispo,      	/* Displacements - s direction, t direction, final displacement, and 
k3d/share/shaders/k3d_slateroof.sl:73:										  					displacement for the non-overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:76:   uniform 	float colorfactor = 3.276 * factor;	/* Used in noise calculations */	
k3d/share/shaders/k3d_slateroof.sl:85:	/* Work out which tile we are in, and the offset within that tile */
k3d/share/shaders/k3d_slateroof.sl:95:	/* Work out the displacement assuming the point is in the 
k3d/share/shaders/k3d_slateroof.sl:99:	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroof.sl:100:	 * normally the center, except in the short tiles which lie at the
k3d/share/shaders/k3d_slateroof.sl:128:	dispo = min(disps, dispt);
k3d/share/shaders/k3d_slateroof.sl:132:	/* Work out whether the point is in fact in another tile 
k3d/share/shaders/k3d_slateroof.sl:133:	 * storing the new tile in stile, ttile and new offset
k3d/share/shaders/k3d_slateroof.sl:134:	 * in s_offset, t_offset */
k3d/share/shaders/k3d_slateroof.sl:137:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroof.sl:139:			/* We are in an offset tile row adjust the scoord appropriately for
k3d/share/shaders/k3d_slateroof.sl:147:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroof.sl:156:				/* if t_offset <= newadd we are actually in the overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:158:					/* set parameters to overlapping tile */
k3d/share/shaders/k3d_slateroof.sl:167:	/* calculate the displacement again */
k3d/share/shaders/k3d_slateroof.sl:179:	disp = min(disps, dispt);
k3d/share/shaders/k3d_slateroof.sl:182:	/*printf("#dispo = %f, disp = %f, colorvary = %f\n",dispo,disp,colorvary); */
k3d/share/shaders/k3d_slateroof.sl:185:	Ct = color spline( 	ns, 
k3d/share/shaders/k3d_slateroofd.sl:11:    	tfreq: number of tiles in the t direction
k3d/share/shaders/k3d_slateroofd.sl:13: 		ramp: the amount of a tile used for the initial rise to the maximum height
k3d/share/shaders/k3d_slateroofd.sl:15: 		gap: the size of the gap between one tile and the next in the s direction,
k3d/share/shaders/k3d_slateroofd.sl:18: 		factor: a seed used for adjusting the randomness - if you have two roofs with
k3d/share/shaders/k3d_slateroofd.sl:20: 			different random patterning. A value > 20 works best
k3d/share/shaders/k3d_slateroofd.sl:24:		This routine produces a random tiled effect. In the s direction the
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:28:		is incorporated in the s direction, which remains regular. The routine
k3d/share/shaders/k3d_slateroofd.sl:29:		first determines the dimensions of the current tile, and then works out
k3d/share/shaders/k3d_slateroofd.sl:30:		the surface displacement according to a simple formula: a sharp ridge at
k3d/share/shaders/k3d_slateroofd.sl:32:		sloping towards zero at the top of the tile. It then looks to see if the
k3d/share/shaders/k3d_slateroofd.sl:33:		point we are considering is actually in the zone of overlap with the
k3d/share/shaders/k3d_slateroofd.sl:35:		considering with one calculated for the tile above, being a little
k3d/share/shaders/k3d_slateroofd.sl:36:		careful to ensure there are no sudden jumps in displacement.
k3d/share/shaders/k3d_slateroofd.sl:38:		Peter Quint 17/11/2000
k3d/share/shaders/k3d_slateroofd.sl:54:   uniform float swidth = 1 / sfreq, 		/* Tile width in the s directio */
k3d/share/shaders/k3d_slateroofd.sl:57:   float scoord = s, tcoord = 1 - t; 		/* re map the t coord so that the coving is at the top */
k3d/share/shaders/k3d_slateroofd.sl:58:   float stile, ttile, 							/* An integer identifying the current tile */
k3d/share/shaders/k3d_slateroofd.sl:59:			s_offset, t_offset, 					/* Offsets withing the current tile, between 0, 1 */
k3d/share/shaders/k3d_slateroofd.sl:60:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:61:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroofd.sl:64:			disps, dispt, disp, dispo,      	/* Displacements - s direction, t direction, final displacement, and 
k3d/share/shaders/k3d_slateroofd.sl:65:										 				 	displacement for the non-overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:76:	/* Work out which tile we are in, and the offset within that tile */
k3d/share/shaders/k3d_slateroofd.sl:86:	/* Work out the displacement assuming the point is in the 
k3d/share/shaders/k3d_slateroofd.sl:91:   	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroofd.sl:92:   		normally the center, except in the short tiles which lie at the
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:120:	dispo = min(disps, dispt);
k3d/share/shaders/k3d_slateroofd.sl:124:	/* Work out whether the point is in fact in another tile 	
k3d/share/shaders/k3d_slateroofd.sl:125:		storing the new tile in stile, ttile and new offset
k3d/share/shaders/k3d_slateroofd.sl:126:		in s_offset, t_offset */
k3d/share/shaders/k3d_slateroofd.sl:129:			/* the point might be in another tile */
k3d/share/shaders/k3d_slateroofd.sl:131:				/* We are in an offset tile row adjust the scoord appropriately for
k3d/share/shaders/k3d_slateroofd.sl:139:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroofd.sl:147:			/* if t_offset <= newadd we are actually in the overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:149:					/* set parameters to overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:156:			/* calculate the displacement again */
k3d/share/shaders/k3d_slateroofd.sl:170:			disp = min(disps, dispt);
k3d/share/shaders/k3d_slateroofd.sl:172:			/* taking the maximum of dispo, disp ensures that there
k3d/share/shaders/k3d_slateroofd.sl:173:   			are no discontinuities */
k3d/share/shaders/k3d_slateroofd.sl:177:	/*printf("disp = %f\n",disp);*/
k3d/share/shaders/k3d_slideprojector.sl:1:light k3d_slideprojector(float intensity = 2000;
k3d/share/shaders/k3d_slideprojector.sl:3:			 point from = point(0, 0, 0);
k3d/share/shaders/k3d_slideprojector.sl:4:			 point to = point(0, 0, 1);
k3d/share/shaders/k3d_slideprojector.sl:5:			 point up = point(0, 1, 0); float coneangle = 45;
k3d/share/shaders/k3d_slideprojector.sl:7:			 string slidename = "")
k3d/share/shaders/k3d_slideprojector.sl:23:  illuminate(from, Z, rconeangle)
k3d/share/shaders/k3d_slideprojector.sl:50:    Cl = attenuation * intensity * lightcolor * Ct;
k3d/share/shaders/k3d_smoke.sl:5: *    This is a volume shader for smoke.  Trapezoidal integration is
k3d/share/shaders/k3d_smoke.sl:6: *    used to find scattering and extinction.
k3d/share/shaders/k3d_smoke.sl:10: *          to block light from behind it.
k3d/share/shaders/k3d_smoke.sl:11: *   lightdensity - smoke density control as it affects light scattering
k3d/share/shaders/k3d_smoke.sl:13: *   integstart, integend - bounds along the viewing ray direction of the
k3d/share/shaders/k3d_smoke.sl:14: *          integration of atmospheric effects.
k3d/share/shaders/k3d_smoke.sl:15: *   stepsize - step size for integration
k3d/share/shaders/k3d_smoke.sl:20: *          extinction coefficients.
k3d/share/shaders/k3d_smoke.sl:28:#include "k3d_noises.h"
k3d/share/shaders/k3d_smoke.sl:30:/* For point P (we are passed both the current and shader space
k3d/share/shaders/k3d_smoke.sl:31: * coordinates), gather illumination from the light sources and
k3d/share/shaders/k3d_smoke.sl:32: * compute the smoke density at that point.  Only count lights tagged
k3d/share/shaders/k3d_smoke.sl:35:void smokedensity(point Pcur, Pshad;
k3d/share/shaders/k3d_smoke.sl:41:  illuminance(Pcur)
k3d/share/shaders/k3d_smoke.sl:51:      point Psmoke = Pshad * smokefreq;
k3d/share/shaders/k3d_smoke.sl:52:#pragma nolint
k3d/share/shaders/k3d_smoke.sl:78:		 float integstart = 0, integend = 100;
k3d/share/shaders/k3d_smoke.sl:83:  point Worigin = P - I;	/* Origin of volume ray */
k3d/share/shaders/k3d_smoke.sl:84:  point origin = transform("shader", Worigin);
k3d/share/shaders/k3d_smoke.sl:88:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_smoke.sl:89:  float d = integstart + random() * stepsize;
k3d/share/shaders/k3d_smoke.sl:94:  float end = min(length(I), integend) - 0.0001;
k3d/share/shaders/k3d_smoke.sl:95:  float ss = min(stepsize, end - d);
k3d/share/shaders/k3d_smoke.sl:96:  /* Get the in-scattered light and the local smoke density for the
k3d/share/shaders/k3d_smoke.sl:97:   * beginning of the ray 
k3d/share/shaders/k3d_smoke.sl:99:  smokedensity(Worigin + d * WIN, origin + d * IN, smokevary, smokefreq,
k3d/share/shaders/k3d_smoke.sl:108:      smokedensity(Worigin + d * WIN, origin + d * IN, smokevary, smokefreq,
k3d/share/shaders/k3d_smoke.sl:111:      /* Find the blocking and light scattering contribution of 
k3d/share/shaders/k3d_smoke.sl:118:      /* Composite with exponential extinction of background light */
k3d/share/shaders/k3d_smoke2.sl:6: *    This is a volume shader for smoke.  Trapezoidal integration is
k3d/share/shaders/k3d_smoke2.sl:7: *    used to integrate the GADD to find scattering and extinction.
k3d/share/shaders/k3d_smoke2.sl:11: *   integstart, integend - bounds along the viewing ray direction of the
k3d/share/shaders/k3d_smoke2.sl:12: *          integration of atmospheric effects.
k3d/share/shaders/k3d_smoke2.sl:13: *   stepsize - step size for integration
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:15: *          into account.
k3d/share/shaders/k3d_smoke2.sl:18: *   lightscale - multiplier for light scattered toward viewer in volume
k3d/share/shaders/k3d_smoke2.sl:33: * * Initial checkin
k3d/share/shaders/k3d_smoke2.sl:36: * Eliminated duplicate local variable declarations
k3d/share/shaders/k3d_smoke2.sl:47:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_smoke2.sl:50:/* Here is where we define the GADD. */
k3d/share/shaders/k3d_smoke2.sl:51:#define GADD(PP,PW,li,g)                                                    \
k3d/share/shaders/k3d_smoke2.sl:52:         if (use_lighting > 0) {                                            \
k3d/share/shaders/k3d_smoke2.sl:54:	     illuminance (PW, point(0,0,1), PI) { li += Cl; }               \
k3d/share/shaders/k3d_smoke2.sl:78:	    float integstart = 0, integend = 100;
k3d/share/shaders/k3d_smoke2.sl:81:	    float use_lighting = 1;
k3d/share/shaders/k3d_smoke2.sl:89:  point Worigin = P + I;
k3d/share/shaders/k3d_smoke2.sl:90:  point incident = vtransform ("shader", -I);
k3d/share/shaders/k3d_smoke2.sl:91:#else  /* PRMan and BMRT have I reverse of each other, conflict in spec */
k3d/share/shaders/k3d_smoke2.sl:92:  point Worigin = P - I;
k3d/share/shaders/k3d_smoke2.sl:93:  point incident = vtransform ("shader", I);
k3d/share/shaders/k3d_smoke2.sl:95:  point origin = transform ("shader", Worigin);
k3d/share/shaders/k3d_smoke2.sl:96:  point IN, WIN;
k3d/share/shaders/k3d_smoke2.sl:101:  float nsteps = 0;          /* record number of integration steps */
k3d/share/shaders/k3d_smoke2.sl:103:  point PP, PW, Psmoke;
k3d/share/shaders/k3d_smoke2.sl:107:  end = min (length (incident), integend) - 0.0001;
k3d/share/shaders/k3d_smoke2.sl:109:  /* Integrate forwards from the start point */
k3d/share/shaders/k3d_smoke2.sl:110:  d = integstart + /*random()* */ stepsize;
k3d/share/shaders/k3d_smoke2.sl:112:      IN = normalize (incident);
k3d/share/shaders/k3d_smoke2.sl:114:      PP = origin + d * IN;
k3d/share/shaders/k3d_smoke2.sl:115:      PW = Worigin + d * WIN;
k3d/share/shaders/k3d_smoke2.sl:117:      ss = min (stepsize, end-d);
k3d/share/shaders/k3d_smoke2.sl:124:	  PP = origin + d*IN;
k3d/share/shaders/k3d_smoke2.sl:125:	  PW = Worigin + d*WIN;
k3d/share/shaders/k3d_smoke2.sl:127:	  /* Our goal now is to find dC and dO, the color and opacity
k3d/share/shaders/k3d_smoke2.sl:141:	  ss = max (min (ss, end-d), 0.005);
k3d/share/shaders/k3d_smoke2.sl:157:      printf ("nsteps = %f, t1 = %f, end = %f\n", nsteps, integstart, end);
k3d/share/shaders/k3d_smoke2.sl:158:      printf ("   Cv = %c, Ov = %c\n", Cv, Ov);
k3d/share/shaders/k3d_softboxes.sl:18:** Full RCS log in .slm4 file
k3d/share/shaders/k3d_softboxes.sl:23:#define BOOL float
k3d/share/shaders/k3d_softboxes.sl:24:#define ENUM float
k3d/share/shaders/k3d_softboxes.sl:26:#define SHAD_BOX_FILT 0
k3d/share/shaders/k3d_softboxes.sl:27:#define SHAD_GAUSSIAN_FILT 1
k3d/share/shaders/k3d_softboxes.sl:29:#define TEX_GAUSSIAN_FILT 0
k3d/share/shaders/k3d_softboxes.sl:30:#define TEX_BOX_FILT 1
k3d/share/shaders/k3d_softboxes.sl:31:#define TEX_RADIAL_FILT 2
k3d/share/shaders/k3d_softboxes.sl:32:#define TEX_DISK_FILT 3
k3d/share/shaders/k3d_softboxes.sl:34:#define HALFSIZE
k3d/share/shaders/k3d_softboxes.sl:36:#define OBEY_THIS "Reflectivity"
k3d/share/shaders/k3d_softboxes.sl:38:#define CLASSIC 0
k3d/share/shaders/k3d_softboxes.sl:39:#define SPHERICAL 1
k3d/share/shaders/k3d_softboxes.sl:41:#define CUBEFACE 0
k3d/share/shaders/k3d_softboxes.sl:42:#define LATLONG 1
k3d/share/shaders/k3d_softboxes.sl:47:/* Superellipse soft clipping - straight out of "uberlight"		***/
k3d/share/shaders/k3d_softboxes.sl:49:/*   - point Q on the x-y plane						***/
k3d/share/shaders/k3d_softboxes.sl:50:/*   - the equations of two superellipses (with major/minor axes given	***/
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:53:/*   - 0 if Q was inside the inner ellipse				***/
k3d/share/shaders/k3d_softboxes.sl:55:/*   - smoothly varying from 0 to 1 in between				***/
k3d/share/shaders/k3d_softboxes.sl:61:    point Q;          /* Test point on the x-y plane */
k3d/share/shaders/k3d_softboxes.sl:66:    varying float result;
k3d/share/shaders/k3d_softboxes.sl:67:    varying float x = abs(xcomp(Q)), y = abs(ycomp(Q));
k3d/share/shaders/k3d_softboxes.sl:73:	varying float re = 2/roundness;		/* roundness exponent */
k3d/share/shaders/k3d_softboxes.sl:74:	varying float q = a * b * pow (pow(b*x, re) + pow(a*y, re), -1/re);
k3d/share/shaders/k3d_softboxes.sl:75:	varying float r = A * B * pow (pow(B*x, re) + pow(A*y, re), -1/re);
k3d/share/shaders/k3d_softboxes.sl:82:/*** Given info on a softbox, ************************************/
k3d/share/shaders/k3d_softboxes.sl:86:    varying point	surfPt;
k3d/share/shaders/k3d_softboxes.sl:87:    varying vector	reflVect;
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: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:108:    varying color ct = 1;
k3d/share/shaders/k3d_softboxes.sl:109:    varying float ot = 1; 
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:113:    varying float zv = zcomp(Vlight);
k3d/share/shaders/k3d_softboxes.sl:114:    varying point Pplane = Pb1 - Vlight*(zcomp(Pb1)/zcomp(Vlight));
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: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:138:	    textureinfo(boxTexture,"channels",nChans);
k3d/share/shaders/k3d_softboxes.sl:139:	    varying float theS = (oW+xcomp(Pplane))/(oW*2);
k3d/share/shaders/k3d_softboxes.sl:140:	    varying float theT = (oH-ycomp(Pplane))/(oH*2);
k3d/share/shaders/k3d_softboxes.sl:141:	    theS = min(2,max(-1,theS));
k3d/share/shaders/k3d_softboxes.sl:142:	    theT = min(2,max(-1,theT));
k3d/share/shaders/k3d_softboxes.sl:164:#pragma nolint
k3d/share/shaders/k3d_softboxes.sl:165:    varying point ppC = transform(boxCoords,"world",Pplane);
k3d/share/shaders/k3d_softboxes.sl:166:    varying point spw = transform("world",surfPt);
k3d/share/shaders/k3d_softboxes.sl:167:    varying float pDist = length(ppC - spw); /* in "world" coords */
k3d/share/shaders/k3d_softboxes.sl:178:    uniform string	theName;
k3d/share/shaders/k3d_softboxes.sl:179:    varying point	thePoint;
k3d/share/shaders/k3d_softboxes.sl:185:    uniform string filtTypes[2] = {"box", "gaussian"};
k3d/share/shaders/k3d_softboxes.sl:186:    uniform string theFilterName = filtTypes[clamp(theFilt,0,1)];
k3d/share/shaders/k3d_softboxes.sl:187:    varying float inShadow = shadow (theName,
k3d/share/shaders/k3d_softboxes.sl:188:			    thePoint,
k3d/share/shaders/k3d_softboxes.sl:193:    return(inShadow);
k3d/share/shaders/k3d_softboxes.sl:201:    string	Comment = "";
k3d/share/shaders/k3d_softboxes.sl:203:    string	Tcl = "";
k3d/share/shaders/k3d_softboxes.sl:204:    string	NodeName = "";
k3d/share/shaders/k3d_softboxes.sl:205:#else /* !BMRT -- slc compiler doesn't like these definitions */
k3d/share/shaders/k3d_softboxes.sl:206:    string	Tcl = "[addL]";	
k3d/share/shaders/k3d_softboxes.sl:207:    string	NodeName = "$OBJNAME";
k3d/share/shaders/k3d_softboxes.sl:209:    float	intensity	= 1;
k3d/share/shaders/k3d_softboxes.sl:213:    string	meterSpace = "";
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:225:    string	boxTex1	= "";
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:237:    string	boxTex2	= "";
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:249:    string	boxTex3	= "";
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:261:    string	boxTex4	= "";
k3d/share/shaders/k3d_softboxes.sl:265:    uniform string	envTexName = "";
k3d/share/shaders/k3d_softboxes.sl:272:    uniform string envReflSpace	= "";
k3d/share/shaders/k3d_softboxes.sl:274:    float shadowintensity = 1;
k3d/share/shaders/k3d_softboxes.sl:275:    string shadowname = "";
k3d/share/shaders/k3d_softboxes.sl:280:    string shadownameb = "";
k3d/share/shaders/k3d_softboxes.sl:285:    string shadownamec = "";
k3d/share/shaders/k3d_softboxes.sl:290:    string shadownamed = "";
k3d/share/shaders/k3d_softboxes.sl:299:    output varying float __nondiffuse = 1;
k3d/share/shaders/k3d_softboxes.sl:300:    output varying float __nonspecular = 0;
k3d/share/shaders/k3d_softboxes.sl:301:    string	__category = "reflection";
k3d/share/shaders/k3d_softboxes.sl:302:    output varying float __inShadow = 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:306:    uniform string theFilterName = filtTypes[clamp(envTexFilter,0,3)];
k3d/share/shaders/k3d_softboxes.sl:310:    uniform string theEnvSpace;
k3d/share/shaders/k3d_softboxes.sl:320:	uniform point metP = transform(meterSpace,"shader",point (0,0,0));
k3d/share/shaders/k3d_softboxes.sl:323:    uniform float adjIntensity = pow(adjMeterDistance,decayRate)*intensity;
k3d/share/shaders/k3d_softboxes.sl:324:    varying float fullShad = 0;
k3d/share/shaders/k3d_softboxes.sl:354:	    varying float thisDist;
k3d/share/shaders/k3d_softboxes.sl:355:	    varying color thisOpac;
k3d/share/shaders/k3d_softboxes.sl:356:	    varying color thisColor;
k3d/share/shaders/k3d_softboxes.sl:357:	    varying float sortedDist[4];
k3d/share/shaders/k3d_softboxes.sl:358:	    varying color sortedOpac[4];
k3d/share/shaders/k3d_softboxes.sl:359:	    varying color sortedColor[4];
k3d/share/shaders/k3d_softboxes.sl:409:#pragma nolint
k3d/share/shaders/k3d_softboxes.sl:410:		varying vector Rs = normalize (vtransform (theEnvSpace, normalize(-L)));
k3d/share/shaders/k3d_softboxes.sl:412:#pragma nolint
k3d/share/shaders/k3d_softboxes.sl:413:		    varying point PShd = transform (theEnvSpace, Ps);
k3d/share/shaders/k3d_softboxes.sl:414:		    varying float pl = vector(PShd).vector(PShd);
k3d/share/shaders/k3d_softboxes.sl:415:		    varying float pdotv = -vector(PShd).Rs;
k3d/share/shaders/k3d_softboxes.sl:455:	    varying vector Ln = normalize(L);
k3d/share/shaders/k3d_softboxes.sl:456:	    varying vector Nn = normalize(N);
k3d/share/shaders/k3d_softboxes.sl:457:	    varying vector In = normalize(I);
k3d/share/shaders/k3d_softboxes.sl:465:	    varying float shadowed;
k3d/share/shaders/k3d_softboxes.sl:486:	    __inShadow = fullShad; 
k3d/share/shaders/k3d_softboxes.sl:491:	Cl = mix(Cl, (shadowcolor*shadowintensity*adjIntensity), fullShad);
k3d/share/shaders/k3d_spacecloud.sl:14: *   minAdjust -- amount that can be subtracted from value
k3d/share/shaders/k3d_spacecloud.sl:16: *   maxOpacity -- maximin opacity for the surface
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:29: *      I was never happy with the results.  So now am just using noise over
k3d/share/shaders/k3d_spacecloud.sl:33:#define  MINFREQ 1.1
k3d/share/shaders/k3d_spacecloud.sl:34:#define MAXFREQ 6
k3d/share/shaders/k3d_spacecloud.sl:36:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spacecloud.sl:37:#define snoise2(x, y) (2 * noise(x, y) - 1)
k3d/share/shaders/k3d_spacecloud.sl:39:#define adjustNoise2(x, y, minVal, maxVal) \
k3d/share/shaders/k3d_spacecloud.sl:40:	snoise2 (x,y) * ((maxVal)-(minVal)+(minVal))
k3d/share/shaders/k3d_spacecloud.sl:43:#define smoothPulse2Fuzz(a, b, afuzz, bfuzz, loc) \
k3d/share/shaders/k3d_spacecloud.sl:48:  string txtFile = "";
k3d/share/shaders/k3d_spacecloud.sl:53:  float minAdjust = -.4;
k3d/share/shaders/k3d_spacecloud.sl:61:  point PP;
k3d/share/shaders/k3d_spacecloud.sl:78:#define  MINFREQ 1.1
k3d/share/shaders/k3d_spacecloud.sl:79:#define MAXFREQ 6
k3d/share/shaders/k3d_spacecloud.sl:83:	/*printf ("%.3f %.3f: adjust %.3f\n", s, t, adjust);*/
k3d/share/shaders/k3d_spacecloud.sl:86:	adjust = adjustNoise2 (u, v, minAdjust, maxAdjust);
k3d/share/shaders/k3d_spacecloud.sl:89:	/* printf ("%.3f %.3f: %.3f %.3f\n", s, t, ss-s, tt-t); */
k3d/share/shaders/k3d_spaceshiphull1.sl:1:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spaceshiphull1.sl:4:float fractalsum(point Q)
k3d/share/shaders/k3d_spaceshiphull1.sl:29:  point Nf;
k3d/share/shaders/k3d_spaceshiphull1.sl:30:  point V;
k3d/share/shaders/k3d_spaceshiphull1.sl:32:  // Figure out which row we're in  
k3d/share/shaders/k3d_spotlight.sl:9:light k3d_spotlight(float intensity = 1;
k3d/share/shaders/k3d_spotlight.sl:11:		    point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_spotlight.sl:12:		    point to = point "shader"(0, 0, 1);
k3d/share/shaders/k3d_spotlight.sl:20:  illuminate(from, A, coneangle)
k3d/share/shaders/k3d_spotlight.sl:26:    Cl = atten * intensity * lightcolor;
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:24:/// Filtering code courtesy of the Advanced RenderMan book ... where else?
k3d/share/shaders/k3d_square_ridges.sl:26:#define MIN_FILTER_WIDTH 1.0e-6
k3d/share/shaders/k3d_square_ridges.sl:27:#define filter_width(x) max(abs(Du(x)*du) + abs(Dv(x)*dv), MIN_FILTER_WIDTH)
k3d/share/shaders/k3d_square_ridges.sl:35:float pulse_train(float edge, period, x)
k3d/share/shaders/k3d_square_ridges.sl:41:float filtered_pulse_train(float edge, period, x, dx)
k3d/share/shaders/k3d_square_ridges.sl:48:	float integral(float t)
k3d/share/shaders/k3d_square_ridges.sl:54:	return (integral(x1) - integral(x0)) / w;
k3d/share/shaders/k3d_square_ridges.sl:63:	float ridge_position = filtered_pulse_train(0.5 / Frequency, 1.0 / Frequency, t + (Offset / Frequency), filter_width(t));
k3d/share/shaders/k3d_square_ridges.sl:64://	float ridge_position = pulse_train(0.5 / Frequency, 1.0 / Frequency, u, filter_width(u));
k3d/share/shaders/k3d_srfdeformation.sl:12:   additionally, calculates the changes to shading on the surface 
k3d/share/shaders/k3d_srfdeformation.sl:13:   measured by the change in diffuse lighting from the Pref to P.
k3d/share/shaders/k3d_srfdeformation.sl:36:fnc_projectCurrentCamera(point P;
k3d/share/shaders/k3d_srfdeformation.sl:39:    point Pndc = transform("NDC", P);
k3d/share/shaders/k3d_srfdeformation.sl:48:    string texname = "";        /* Texture to project */
k3d/share/shaders/k3d_srfdeformation.sl:50:				   1 = texture deformed with no lighting
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:54:    float Kd=1;                 /* Surface Kd for lighting calculations */
k3d/share/shaders/k3d_srfdeformation.sl:56:    varying point Pref = point "shader" (0,0,0);
k3d/share/shaders/k3d_srfdeformation.sl:64:    point Porig = Pref;
k3d/share/shaders/k3d_srfdeformation.sl: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:85:    illuminance(P, N1, radians(illum_width)) {
k3d/share/shaders/k3d_srfdeformation.sl:89:    illuminance(Porig, N2, radians(illum_width)) {
k3d/share/shaders/k3d_srfdeformation.sl: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:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_star.sl:14:#include "k3d_proctext.h"
k3d/share/shaders/k3d_star.sl:21:    uniform float npoints = 5;
k3d/share/shaders/k3d_star.sl:26:    point Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_star.sl:28:    float ss, tt, angle, r, a, in_out;
k3d/share/shaders/k3d_star.sl:29:    uniform float rmin = 0.07, rmax = 0.2;
k3d/share/shaders/k3d_star.sl:30:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_star.sl:31:    uniform point p0 = rmax*(cos(0),sin(0),0);
k3d/share/shaders/k3d_star.sl:32:    uniform point p1 = rmin*
k3d/share/shaders/k3d_star.sl:33:        (cos(starangle/2),sin(starangle/2),0);
k3d/share/shaders/k3d_star.sl:34:    uniform point d0 = p1 - p0;
k3d/share/shaders/k3d_star.sl:35:    point d1;
k3d/share/shaders/k3d_star.sl:44:    d1 = r*(cos(a), sin(a),0) - p0;
k3d/share/shaders/k3d_star.sl:45:    in_out = step(0, zcomp(d0^d1));
k3d/share/shaders/k3d_star.sl:46:    Ct = mix(Cs, starcolor, in_out);
k3d/share/shaders/k3d_star.sl:48:    /* diffuse ("matte") shading model */
k3d/share/shaders/k3d_starfield.sl:2:	Makes a star field.  Best when used as a surface shader for the inside	of a large sphere.
k3d/share/shaders/k3d_starfield.sl:4:	We partition space into a 1x1x1 grid, rendering one solid spherical "star" per cell.
k3d/share/shaders/k3d_starfield.sl:11:surface k3d_starfield(float intensity = 2.0; float frequency = 0.1; float size = 0.3; float irregularity = 2.0)
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_starfield.sl:17:	point star_center = point(0.5 * (floor(xcomp(PP)) + ceil(xcomp(PP))), 0.5 * (floor(ycomp(PP)) + ceil(ycomp(PP))), 0.5 * (floor(zcomp(PP)) + ceil(zcomp(PP))));
k3d/share/shaders/k3d_starfield.sl:19:	star_center += irregularity * (point noise(star_center) - point(0.5, 0.5, 0.5));
k3d/share/shaders/k3d_starfield.sl:24:	float inside_star = 1 - smoothstep(0.0, size, star_distance);
k3d/share/shaders/k3d_starfield.sl:26:	// Give stars relative intensities ...
k3d/share/shaders/k3d_starfield.sl:27:	float star_intensity = float cellnoise(star_center);
k3d/share/shaders/k3d_starfield.sl:29:	Ci = intensity * star_intensity * inside_star * inside_star;
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:12: * trying to replicate the shader usr for the ground in "A BUGS LIFE".
k3d/share/shaders/k3d_stones.sl:15: * Feel free to use this shader to create skin for any character, anywhere and
k3d/share/shaders/k3d_stones.sl:16: * everywhere, Just list me on the credits under "Shading Team" if you use the
k3d/share/shaders/k3d_stones.sl:17: *  hader as is, or under "shader info" if you do any minor modifications to
k3d/share/shaders/k3d_stones.sl:24: * minfreq & maxfreq = limits to the rock loop excecution
k3d/share/shaders/k3d_stones.sl:25: * grungefreq, grunge_Pow, grunginess = freqeuncy, power and depth of grunge
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:39:#define repeat(x,freq)    (mod((x) * (freq), 1.0))
k3d/share/shaders/k3d_stones.sl:41:#define rotate2d(x,y,rad,ox,oy,rx,ry) \
k3d/share/shaders/k3d_stones.sl:42:  rx = ((x) - (ox)) * cos(rad) - ((y) - (oy)) * sin(rad) + (ox); \
k3d/share/shaders/k3d_stones.sl:43:  ry = ((x) - (ox)) * sin(rad) + ((y) - (oy)) * cos(rad) + (oy)
k3d/share/shaders/k3d_stones.sl:46:#define fuzzpulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - \
k3d/share/shaders/k3d_stones.sl:49:#define snoise(x)    (noise(x) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:50:#define snoise2(x,y) (noise(x,y) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:51:#define whichtile(x,freq) (floor((x) * (freq)))
k3d/share/shaders/k3d_stones.sl:52:#define MINFILTERWIDTH  1e-7
k3d/share/shaders/k3d_stones.sl:53:#define filterwidth_point(p) (max(sqrt(area(p)), MINFILTERWIDTH))
k3d/share/shaders/k3d_stones.sl:54:#define udn(x,lo,hi) (smoothstep(.25, .75, noise(x)) * ((hi) - (lo)) + (lo))
k3d/share/shaders/k3d_stones.sl:57:/* varyEach takes a computed color, then tweaks each indexed item
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:63:color varyEach (color Cin; float index, varyhue, varysat, varyval;)
k3d/share/shaders/k3d_stones.sl:66:    color Chsv = ctransform ("hsv", Cin);
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:69:    h += varyhue * (cellnoise(index+3)-0.5);
k3d/share/shaders/k3d_stones.sl:70:    s *= 1 - varysat * (cellnoise(index-14)-0.5);
k3d/share/shaders/k3d_stones.sl:71:    v *= 1 - varyval * (cellnoise(index+37)-0.5);
k3d/share/shaders/k3d_stones.sl:87:    float minfreq = 1,
k3d/share/shaders/k3d_stones.sl:90:          grungefreq = 30, grunge_Pow = 3, grunginess = - 0.8;
k3d/share/shaders/k3d_stones.sl:112: /*loop for creating color layers of rocks*/
k3d/share/shaders/k3d_stones.sl:113: for (freq = maxfreq ; freq>minfreq;freq -=0.5)
k3d/share/shaders/k3d_stones.sl:115:   angle = PI * snoise(freq * 16.31456);  /*randomize angle index*/
k3d/share/shaders/k3d_stones.sl:119:   /*repeat tiles and find out in which tile we are at?*/
k3d/share/shaders/k3d_stones.sl:125:   /*tile index to be use in vary each*/
k3d/share/shaders/k3d_stones.sl:126:   float stoneindex = stile + 13 * ttile;
k3d/share/shaders/k3d_stones.sl:136:   point p1 =(cx,cy,0);
k3d/share/shaders/k3d_stones.sl:137:   point p2 = (ss,tt,0);
k3d/share/shaders/k3d_stones.sl:145:   layer_color = varyEach(stonecolor, stoneindex,varyhue,varysat,varylum);
k3d/share/shaders/k3d_stones.sl:156:   /*apply if grunginess != 0 */
k3d/share/shaders/k3d_stones.sl:157:   if(grunginess != 0)
k3d/share/shaders/k3d_stones.sl:160:       point PP = transform("shader", P) * grungefreq;
k3d/share/shaders/k3d_stones.sl:161:       float width = filterwidth_point(PP);
k3d/share/shaders/k3d_stones.sl:171:        surface_mag += grunge * grunginess;
k3d/share/shaders/k3d_stones.sl:183: /*compute normals and vectors for shading*/
k3d/share/shaders/k3d_strata.sl:5: *    Makes sedimentary rock strata, useful for rendering landscapes.
k3d/share/shaders/k3d_strata.sl:8: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_strata.sl:9: *    txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_strata.sl:10: *    zscale - scaling for the thickness of the layers
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:25: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
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:35:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_strata.sl:43:  point PP;
k3d/share/shaders/k3d_strata.sl:59:    color spline(mod(cmap, 1), color(166, 131, 70), color(166, 131, 70),
k3d/share/shaders/k3d_stucco.sl:20:  point PP;
k3d/share/shaders/k3d_superkagee.sl:3:#define BOOL    float
k3d/share/shaders/k3d_superkagee.sl:4:#define ENUM    float
k3d/share/shaders/k3d_superkagee.sl:6:#define FILT_BOX 0
k3d/share/shaders/k3d_superkagee.sl:7:#define FILT_GAUSS 1
k3d/share/shaders/k3d_superkagee.sl:14:    uniform string      theName;
k3d/share/shaders/k3d_superkagee.sl:15:    varying point       thePoint;
k3d/share/shaders/k3d_superkagee.sl:21:    uniform string filtTypes[2] = {"box", "gaussian"};
k3d/share/shaders/k3d_superkagee.sl:22:    uniform string theFilterName = filtTypes[clamp(theFilt,0,1)];
k3d/share/shaders/k3d_superkagee.sl:23:    float inShadow;
k3d/share/shaders/k3d_superkagee.sl:24:#define SHADPOINT thePoint
k3d/share/shaders/k3d_superkagee.sl:25:    inShadow = shadow (theName,
k3d/share/shaders/k3d_superkagee.sl:31:return(inShadow);
k3d/share/shaders/k3d_superkagee.sl:41:    string     shadownamea = "";
k3d/share/shaders/k3d_superkagee.sl:48:    string     shadownameb = "";
k3d/share/shaders/k3d_superkagee.sl:55:    string     shadownamec = "";
k3d/share/shaders/k3d_superkagee.sl:62:    string     shadownamed = "";
k3d/share/shaders/k3d_superkagee.sl:71:    uniform string rcsInfo =
k3d/share/shaders/k3d_superkagee.sl:73:    varying float fullShad = 0;
k3d/share/shaders/k3d_superkagee.sl:74:    varying float shadowed;
k3d/share/shaders/k3d_superplank.sl:5: *   Makes texture of wooden planks in s-t space.  This wood looks rather
k3d/share/shaders/k3d_superplank.sl:6: *   like varnished oak planks, with staggered planks, rings and grain,
k3d/share/shaders/k3d_superplank.sl:9: *   or in a parquet pattern.
k3d/share/shaders/k3d_superplank.sl:13: *   Kr, eta - reflection amount and index of refraction (for fresnel)
k3d/share/shaders/k3d_superplank.sl:15: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_superplank.sl:16: *   Km - overall scaling factor for bumpiness.
k3d/share/shaders/k3d_superplank.sl:18: *   plankwidth - width of each plank (in terms of s/t)
k3d/share/shaders/k3d_superplank.sl:19: *   planklength - length of each plank (in terms of s/t)
k3d/share/shaders/k3d_superplank.sl:20: *   groovewidth - width of the grooves between the planks (in terms of s/t)
k3d/share/shaders/k3d_superplank.sl:21: *   groovedepth - depth of the groove indentations (in shader space units)
k3d/share/shaders/k3d_superplank.sl:27: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_superplank.sl:28: *   ringwidth - relative width of the dark ring parts
k3d/share/shaders/k3d_superplank.sl:29: *   wavy - relative wavyness of the ring pattern
k3d/share/shaders/k3d_superplank.sl:30: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_superplank.sl:31: *   grainscale - scaling for the fine grain
k3d/share/shaders/k3d_superplank.sl:32: *   graindepth - depth of grain and ring grooves
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:37: *   even with low sampling densities.
k3d/share/shaders/k3d_superplank.sl:46:#include "k3d_noises.h"
k3d/share/shaders/k3d_superplank.sl:47:#include "k3d_patterns.h"
k3d/share/shaders/k3d_superplank.sl:57:			float Kr = 1, eta = 1.5;	/* Mirror refl & index of refr */
k3d/share/shaders/k3d_superplank.sl:59:			string reflmap = "";
k3d/share/shaders/k3d_superplank.sl:60:			/* Overall texturing control */
k3d/share/shaders/k3d_superplank.sl:61:			float txtscale = 1;	/* Overall scaling factor */
k3d/share/shaders/k3d_superplank.sl:62:			float Km = 1;	/* Overall bumpiness factor */
k3d/share/shaders/k3d_superplank.sl:75:			float ringscale = 25;	/* Larger makes more, thinner rings */
k3d/share/shaders/k3d_superplank.sl:76:			float ringwidth = 1;	/* Relative ring width */
k3d/share/shaders/k3d_superplank.sl:77:			float wavy = 0.08;	/* Larger makes rings more wavy */
k3d/share/shaders/k3d_superplank.sl:78:			float grainy = 1;	/* Relative graininess */
k3d/share/shaders/k3d_superplank.sl:79:			float grainscale = 60;	/* Larger makes smaller "grains" */
k3d/share/shaders/k3d_superplank.sl:80:			float graindepth = 0.0001;	/* Depth of divots where grains are */
k3d/share/shaders/k3d_superplank.sl:85:  /* mapping coordinates */
k3d/share/shaders/k3d_superplank.sl:87:  float grain_s, grain_t, ring_s, ring_t, plank_s, plank_t;
k3d/share/shaders/k3d_superplank.sl:88:  /* antialiasing */
k3d/share/shaders/k3d_superplank.sl:93:  float whichrow, whichplank;	/* Index for each row & plank within row */
k3d/share/shaders/k3d_superplank.sl:95:  float groovy;			/* 0 in groove, 1 in woody part */
k3d/share/shaders/k3d_superplank.sl:100:  float ring;			/* 1 in a ring darkening, 0 where not */
k3d/share/shaders/k3d_superplank.sl:101:  float grain;			/* 1 inside a grain bit, 0 elsewhere */
k3d/share/shaders/k3d_superplank.sl:102:  /* Illumination model */
k3d/share/shaders/k3d_superplank.sl:105:  normal NN;			/* normalized N for displacing */
k3d/share/shaders/k3d_superplank.sl:106:  normal Nf;			/* forward facing, normalized normal */
k3d/share/shaders/k3d_superplank.sl:111:  point Pndc;			/* NDC coordinate of P */
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:133:   * We will use this later to help scale the displacement, this making
k3d/share/shaders/k3d_superplank.sl:134:   * the bumps scale relative to the overall pattern, rather than being
k3d/share/shaders/k3d_superplank.sl:143:   * Determine which row and plank we're on, and come up with an
k3d/share/shaders/k3d_superplank.sl:144:   * antialiased term for whether we're in or out of a groove.
k3d/share/shaders/k3d_superplank.sl:180:  /* Now whichplank is a unique integer index for each plank */
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:203:   * 3. Ring and grain patterns, color and specularity adjustment.
k3d/share/shaders/k3d_superplank.sl:205:   * The wood has rings at one scale, grain at a finer scale.  They
k3d/share/shaders/k3d_superplank.sl:206:   * interact subtly.
k3d/share/shaders/k3d_superplank.sl:210:   * the rings are too small to see.
k3d/share/shaders/k3d_superplank.sl:212:  fwidth = max(swidth * ringscale, twidth * ringscale);
k3d/share/shaders/k3d_superplank.sl:216:      ring_s = ss * ringscale;
k3d/share/shaders/k3d_superplank.sl:217:      ring_t = tt * ringscale;
k3d/share/shaders/k3d_superplank.sl:218:      ttt = ring_t + whichplank * 28.38 + wavy * noise(8 * ring_s, ring_t);
k3d/share/shaders/k3d_superplank.sl:219:      ring = ringscale * noise(ring_s - whichplank * 4.18, ttt / 20);
k3d/share/shaders/k3d_superplank.sl:220:      ring -= floor(ring);
k3d/share/shaders/k3d_superplank.sl:221:      ring =
k3d/share/shaders/k3d_superplank.sl:222:	0.3 + 0.7 * smoothstep(.55 - .35 * ringwidth, 0.55,
k3d/share/shaders/k3d_superplank.sl:223:			       ring) * (1 - smoothstep(0.75, 0.8, ring));
k3d/share/shaders/k3d_superplank.sl:224:      ring = (1 - fade) * ring + 0.65 * fade;
k3d/share/shaders/k3d_superplank.sl:226:      /* Grain pattern */
k3d/share/shaders/k3d_superplank.sl:227:      fwidth = max(swidth * grainscale, twidth * grainscale);
k3d/share/shaders/k3d_superplank.sl:231:	  grain_s = ss * grainscale;
k3d/share/shaders/k3d_superplank.sl:232:	  grain_t = tt * grainscale;
k3d/share/shaders/k3d_superplank.sl:233:	  r2 = 1.3 - noise(12 * grain_s, grain_t);
k3d/share/shaders/k3d_superplank.sl:234:	  r2 = grainy * r2 * r2 + (1 - grainy);
k3d/share/shaders/k3d_superplank.sl:235:	  grain = (1 - fade) * r2 + (0.75 * fade);
k3d/share/shaders/k3d_superplank.sl:238:	grain = 0.75;
k3d/share/shaders/k3d_superplank.sl:242:      ring = 0.4875;
k3d/share/shaders/k3d_superplank.sl:243:      grain = 0.75;
k3d/share/shaders/k3d_superplank.sl:245:  grain *= (.85 + .15 * ring);
k3d/share/shaders/k3d_superplank.sl:249:  /* Add some plank-to-plank variation in overall color */
k3d/share/shaders/k3d_superplank.sl:252:  /* Darken the wood according to the ring and grain patterns */
k3d/share/shaders/k3d_superplank.sl:253:  woodcolor *= (1 - 0.25 * ring) * (1 - .5 * grain);
k3d/share/shaders/k3d_superplank.sl:254:  /* Combine the rings, grain, plank variation into one surface color */
k3d/share/shaders/k3d_superplank.sl:256:  /* Less specular in the grooves, more specular in the dark wood. */
k3d/share/shaders/k3d_superplank.sl:257:  adjustedKs = Ks * (1 + .2 * ring) * (1 + .3 * grain) * groovy;
k3d/share/shaders/k3d_superplank.sl:263:   * We do some bump mapping to make the grooves and grain depressed,
k3d/share/shaders/k3d_superplank.sl:264:   * and add some general lumpiness to the varnish layer.
k3d/share/shaders/k3d_superplank.sl:276:      /* Depressions due to grain & rings */
k3d/share/shaders/k3d_superplank.sl:277:      disp -= graindepth * (.75 * grain + ring);
k3d/share/shaders/k3d_superplank.sl:278:      /* Find out how long a unit of shader space is, in current units */
k3d/share/shaders/k3d_superplank.sl:290:   * using the fresnel formula (grazing angles reflect like mirrors).
k3d/share/shaders/k3d_superplank.sl:291:   * Have some subtle interaction between grain and specularity.
k3d/share/shaders/k3d_superplank.sl:300:  illuminance(P, Nf, PI / 2)
k3d/share/shaders/k3d_superpplastic.sl:1:/* paintedplastic.sl - Standard texture map surface for RenderMan Interface.
k3d/share/shaders/k3d_superpplastic.sl:9: *    Apply a texture map to a plastic surface, indexing the texture
k3d/share/shaders/k3d_superpplastic.sl:13: *    Ka, Kd, Ks, roughness, specularcolor - the usual meaning.
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:22:			  color specularcolor = 1; string texturename = "";
k3d/share/shaders/k3d_superpplastic.sl:30:  string filter;
k3d/share/shaders/k3d_superpplastic.sl:39:    filter = "sinc";
k3d/share/shaders/k3d_supertexmap.sl:7: *    standard "paintedplastic", but with much more flexibility in the
k3d/share/shaders/k3d_supertexmap.sl:8: *    coordinate mapping of the texture.
k3d/share/shaders/k3d_supertexmap.sl:11: *    Ka, Kd, Ks, roughness, specularcolor - the usual meaning.
k3d/share/shaders/k3d_supertexmap.sl:14: *                 "perspective", "cylindrical", "spherical".
k3d/share/shaders/k3d_supertexmap.sl:15: *    textureprojspace - the space in which the texture projection is
k3d/share/shaders/k3d_supertexmap.sl:17: *                named coordinate system.
k3d/share/shaders/k3d_supertexmap.sl:18: *    mx - 16 floats giving an 3-D affine transformation to apply to the
k3d/share/shaders/k3d_supertexmap.sl: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:25: *   _Advanced RenderMan: Creating CGI for Motion Picture_, 
k3d/share/shaders/k3d_supertexmap.sl:30:#include "k3d_filterwidth.h"
k3d/share/shaders/k3d_supertexmap.sl:31:#include "k3d_project.h"
k3d/share/shaders/k3d_supertexmap.sl:32:#include "k3d_displace.h"
k3d/share/shaders/k3d_supertexmap.sl:33:#include "k3d_material.h"
k3d/share/shaders/k3d_supertexmap.sl:38:			string Csmapname = "", Csproj = "st", Csspace =
k3d/share/shaders/k3d_supertexmap.sl:45:			string Osmapname = "", Osproj = "st", Osspace =
k3d/share/shaders/k3d_supertexmap.sl:52:			string Ksmapname = "", Ksproj = "st", Ksspace =
k3d/share/shaders/k3d_supertexmap.sl:59:			string dispmapname = "", dispproj = "st", dispspace =
k3d/share/shaders/k3d_supertexmap.sl:75:  /* Color mapping */
k3d/share/shaders/k3d_supertexmap.sl:81:  /* Opacity mapping */
k3d/share/shaders/k3d_supertexmap.sl:87:  /* specularity mapping */
k3d/share/shaders/k3d_supertexmap.sl:93:  /* displacement mapping */
k3d/share/shaders/k3d_supertexmap.sl:102:  /* Illumination model - just use plastic */
k3d/share/shaders/k3d_supertoon.sl:4: * Toon shader con antialiasing. Modula diffuse mediante escaloneo de modo que

k3d/share/shaders/k3d_supertoon.sl:6: * hace en tres puntos definidos por lim2, lim3 y lim4. A falta de antialiasing

k3d/share/shaders/k3d_supertoon.sl:7: * analitico se utiliza delta para determinar el nivel de antialiasing del shader.

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:10: * clamping, the inflection points are lim2, lim3 and lim4. This shader is very cheap, 

k3d/share/shaders/k3d_supertoon.sl:33:                        delta = 0.015,   /* antialiasing level */

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

k3d/share/shaders/k3d_terran.sl:3:           mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran.sl:8:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:11:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:14:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran.sl:15:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran.sl:16:#define N_OFFSET 0.7
k3d/share/shaders/k3d_terran.sl:17:#define VERY_SMALL 0.0001
k3d/share/shaders/k3d_terran.sl:28:		   float nonlinear = 0;
k3d/share/shaders/k3d_terran.sl:35:  point PP;
k3d/share/shaders/k3d_terran.sl:36:  point PtN;
k3d/share/shaders/k3d_terran.sl:39:  point Ptexture, tp;
k3d/share/shaders/k3d_terran.sl:43:  /* Do all shading in shader space */
k3d/share/shaders/k3d_terran.sl:48:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran.sl:69:      /* compute bump vector using MfBm with displaced point */
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: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:105:  latitude += chaos * (nonlinear * (1 - latitude) + purt_scale);
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:120:      Ct = spline (latitude,
k3d/share/shaders/k3d_terran.sl:135:	spline(latitude, color(.5, .39, .2), color(.5, .39, .2),
k3d/share/shaders/k3d_terran.sl:172:  /* Shade using matte model */
k3d/share/shaders/k3d_terran2.sl:1:/* Was terran.sl -- changed color spline to not use white 
k3d/share/shaders/k3d_terran2.sl:10: *   Earth-like.  The shader works by using a variety of fractal 
k3d/share/shaders/k3d_terran2.sl:11: *   turbulence and mottling techniques.
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:16: *   in the middle of the ocean.
k3d/share/shaders/k3d_terran2.sl:20: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_terran2.sl:23: *    bump_scale - scaling of the mountains
k3d/share/shaders/k3d_terran2.sl:25: *    dist_scale - scaling for multifractal distortion
k3d/share/shaders/k3d_terran2.sl:28: *    mtn_scale - scaling factor for mountains
k3d/share/shaders/k3d_terran2.sl:29: *    lat_scale, nonlinear, purt_scale, map_exp - control scaling of 
k3d/share/shaders/k3d_terran2.sl:30: *               terrain type by latitude
k3d/share/shaders/k3d_terran2.sl:32: *    depth_scale, depth_max - scaling factor and max depth of oceans
k3d/share/shaders/k3d_terran2.sl:34: *               mottling that adds detail to lower latitude regions.
k3d/share/shaders/k3d_terran2.sl:43: *    and add a cloud layer using either "planetclouds" or "venusclouds".
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:57: *    May 28 1995 Didn't want polar caps so removed white from color spline --
k3d/share/shaders/k3d_terran2.sl:64:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:67:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:70:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran2.sl:71:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran2.sl:72:#define N_OFFSET 0.7
k3d/share/shaders/k3d_terran2.sl:73:#define VERY_SMALL 0.0001
k3d/share/shaders/k3d_terran2.sl:87:	  float nonlinear = 0;
k3d/share/shaders/k3d_terran2.sl:98:  point PP;
k3d/share/shaders/k3d_terran2.sl:99:  point PtN;
k3d/share/shaders/k3d_terran2.sl:102:  point Ptexture, tp;
k3d/share/shaders/k3d_terran2.sl:106:  /* Do all shading in shader space */
k3d/share/shaders/k3d_terran2.sl:111:   * First, figure out where we are in relation to the oceans/mountains.
k3d/share/shaders/k3d_terran2.sl:127:      /* compute bump vector using MfBm with displaced point */
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: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:160:  latitude += chaos*(nonlinear*(1-latitude) + purt_scale);
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:173:      Ct = spline (latitude,
k3d/share/shaders/k3d_terran2.sl:187:      Ct = spline (latitude,
k3d/share/shaders/k3d_terran2.sl:227:  /* Shade using matte model */
k3d/share/shaders/k3d_terranbump.sl:4:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:7:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:10:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terranbump.sl:11:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terranbump.sl:12:#define N_OFFSET 0.7
k3d/share/shaders/k3d_terranbump.sl:13:#define VERY_SMALL 0.0001
k3d/share/shaders/k3d_terranbump.sl:24:  point Ptexture, tp;
k3d/share/shaders/k3d_terranbump.sl:28:  /* Do all shading in shader space */
k3d/share/shaders/k3d_terranbump.sl:47:      /* compute bump vector using MfBm with displaced point */
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_texblender.sl:3:#include "k3d_filterwidth.h"
k3d/share/shaders/k3d_texblender.sl:4:#include "k3d_project.h"
k3d/share/shaders/k3d_texblender.sl:5:#include "k3d_displace.h"
k3d/share/shaders/k3d_texblender.sl:6:#include "k3d_material.h"
k3d/share/shaders/k3d_texblender.sl:7:#include "k3d_reflections.h"
k3d/share/shaders/k3d_texblender.sl:8:#include "k3d_locillum.h"
k3d/share/shaders/k3d_texblender.sl:9:#include "k3d_noises.h"
k3d/share/shaders/k3d_texblender.sl:21:myEnvironment (point P;  vector R;  float Kr, blur;  DECLARE_ENVPARAMS;)
k3d/share/shaders/k3d_texblender.sl:33:#if (defined(BMRT) || defined(RAYSERVER_H))
k3d/share/shaders/k3d_texblender.sl:41:float myrand(point p;)
k3d/share/shaders/k3d_texblender.sl:57:float tex_clouds(point P;float depth)
k3d/share/shaders/k3d_texblender.sl:73:float tex_wood(point PP; float ringscale)
k3d/share/shaders/k3d_texblender.sl:75:	float grainy = 1;
k3d/share/shaders/k3d_texblender.sl:77:    float my_t = zcomp(PP) / ringscale;
k3d/share/shaders/k3d_texblender.sl:78:    point PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_texblender.sl:81:    PQ = point (xcomp(PP), my_t, ycomp(PP)+12.93);
k3d/share/shaders/k3d_texblender.sl:82:    float r = ringscale * noise (PQ);
k3d/share/shaders/k3d_texblender.sl:85:    PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_texblender.sl:86:    float r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_texblender.sl:91:color colorMap(string mapname, space; 
k3d/share/shaders/k3d_texblender.sl:94:	point transp;
k3d/share/shaders/k3d_texblender.sl:113:color BlendColor(string mode; float K; color newc, oldc)
k3d/share/shaders/k3d_texblender.sl:121:float BlendFloat(string mode; float K, newf, oldf)
k3d/share/shaders/k3d_texblender.sl:149:		string Gmapname[5]={"","","","",""};
k3d/share/shaders/k3d_texblender.sl:150:		string Gspace[5]={"object","object","object","object","object"};
k3d/share/shaders/k3d_texblender.sl:151:		string Gmode[5]={"m","m","m","m","m"};
k3d/share/shaders/k3d_texblender.sl:171:		string mode=Gmode[i];
k3d/share/shaders/k3d_threads.sl:3:/* Listing 16.24  Displacement shader providing light-bulb threads to cylinder */
k3d/share/shaders/k3d_threads.sl:6: * threads(): wrap threads around a cylinder 
k3d/share/shaders/k3d_threads.sl:19:	magnitude = (sin( PI*2*(t*frequency + s + phase))+offset) * Km;
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:12: *  thanks to Jos Stam whose animated cube motivated this thing.
k3d/share/shaders/k3d_tooledsteel.sl:27: *  mapspread		- the spread of the reflection map streaking
k3d/share/shaders/k3d_tooledsteel.sl:30: *			  angle in radians (i.e. PI*.5 = 90 degrees)
k3d/share/shaders/k3d_tooledsteel.sl:38:  extern point P;
k3d/share/shaders/k3d_tooledsteel.sl:49:  point Po = point(s*mult,t*mult,0);
k3d/share/shaders/k3d_tooledsteel.sl:50:  point Pou = Po +(udir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:51:  point Pov = Po +(vdir*.01);
k3d/share/shaders/k3d_tooledsteel.sl:53:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_tooledsteel.sl:54:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_tooledsteel.sl:94:    extern point P;
k3d/share/shaders/k3d_tooledsteel.sl:101:    point zro = 0;
k3d/share/shaders/k3d_tooledsteel.sl:103:    illuminance (P, Nf, PI*.5) {
k3d/share/shaders/k3d_tooledsteel.sl:133:	string	mapname 	= "";
k3d/share/shaders/k3d_tooledsteel.sl:137:	point Po = transform("object",P);
k3d/share/shaders/k3d_tooledsteel.sl:141:        point zro = 0;
k3d/share/shaders/k3d_toonmap.sl:9:string Highlight_Map="";
k3d/share/shaders/k3d_toonmap.sl:17:string Paint_Map="";
k3d/share/shaders/k3d_toonmap.sl:18:color Paint_Color=(0.5, 0.5, 0.5); 
k3d/share/shaders/k3d_toonmap.sl:25:float paint_spec=0.0888; 
k3d/share/shaders/k3d_toonmap.sl:26:float paint_trans=0.539; 
k3d/share/shaders/k3d_toonmap.sl:27:float paint_fuzz=0.274; 
k3d/share/shaders/k3d_toonmap.sl:28:float ink_thresh=0.389; 
k3d/share/shaders/k3d_toonmap.sl:29:float ink_fuzz=0.765; 
k3d/share/shaders/k3d_toonmap.sl:30:string Ink_Map=""; 
k3d/share/shaders/k3d_toonmap.sl:39:/** Surface main-code start **/
k3d/share/shaders/k3d_toonmap.sl:62:/** Texture_Paint_Map **/
k3d/share/shaders/k3d_toonmap.sl:68:if ( Paint_Map=="" ) 
k3d/share/shaders/k3d_toonmap.sl:70:temt_c3=Paint_Color;
k3d/share/shaders/k3d_toonmap.sl:76:temt_c3=texture(Paint_Map,temp_ss3,temp_tt3,"swidth",swidth3,"twidth",twidth3,"samples",samples3);
k3d/share/shaders/k3d_toonmap.sl:80:temt_c3=texture(Paint_Map[channel3],temp_ss3,temp_tt3,"swidth",swidth3,"twidth",twidth3,"samples",samples3);
k3d/share/shaders/k3d_toonmap.sl: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:113:illuminance(P, N, PI/2) {
k3d/share/shaders/k3d_toonmap.sl:135:/* toon paint (layer 1) */
k3d/share/shaders/k3d_toonmap.sl:137:/* only care about percentage illumination */
k3d/share/shaders/k3d_toonmap.sl:139:illuminance(P, Nf, PI/2)
k3d/share/shaders/k3d_toonmap.sl:143:diff = smoothstep(paint_trans - paint_fuzz/2, paint_trans + paint_fuzz/2, diff);
k3d/share/shaders/k3d_toonmap.sl:147:spec = smoothstep(paint_spec - paint_fuzz/2, paint_spec + paint_fuzz/2, spec);
k3d/share/shaders/k3d_toonmap.sl:155:/* toon ink (layer 3) */
k3d/share/shaders/k3d_toonmap.sl:159:/* antialias ink lines */
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:173:/** Surface main-code end **/
k3d/share/shaders/k3d_translucency.sl:13:*		It also implement the Stephen H. Westin velvet
k3d/share/shaders/k3d_translucency.sl:14:*		illuminance loop.	
k3d/share/shaders/k3d_translucency.sl:22:* Notes: Please send me any kind of suggestions or bugs.
k3d/share/shaders/k3d_translucency.sl:23:*	 If you use it in some production please email me the result.
k3d/share/shaders/k3d_translucency.sl:31:#define SQR(A) ((A)*(A))
k3d/share/shaders/k3d_translucency.sl:40:			string colorTx = "";
k3d/share/shaders/k3d_translucency.sl:42:			string colorTx2 = "";
k3d/share/shaders/k3d_translucency.sl:49:			string transTex = "";
k3d/share/shaders/k3d_translucency.sl:52:			string transTex2 = "";
k3d/share/shaders/k3d_translucency.sl:60:	/*Velvet illuminance loop variable*/
k3d/share/shaders/k3d_translucency.sl:64:	color shiny;
k3d/share/shaders/k3d_translucency.sl:65:	float cosine, sine;
k3d/share/shaders/k3d_translucency.sl:74:	/*Color texturing of different side*/
k3d/share/shaders/k3d_translucency.sl:94:	/*Translucency texturing of different side*/
k3d/share/shaders/k3d_translucency.sl:113:	/*Velvet illuminance loop*/
k3d/share/shaders/k3d_translucency.sl:115:	shiny = 0;
k3d/share/shaders/k3d_translucency.sl:117:	illuminance (P, Nf, 1.57079632679489661923){
k3d/share/shaders/k3d_translucency.sl:119:		cosine = max (-Nf.V,0);
k3d/share/shaders/k3d_translucency.sl:120:		shiny += pow (cosine, 1.0/roughness) / (ln.Nf) * Cl * sheen;
k3d/share/shaders/k3d_translucency.sl:121:		cosine = max (Nf.V, 0);
k3d/share/shaders/k3d_translucency.sl:122:		sine = sqrt (1.0-SQR(cosine));
k3d/share/shaders/k3d_translucency.sl:123:		shiny += pow(sine, 10.0)*ln.Nf * Cl*sheen;
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:5: *   Based on Ronen Barzel's paper "Lighting Controls for Computer
k3d/share/shaders/k3d_uberlight.sl:6: *   Cinematography" (in Journal of Graphics Tools, vol. 2, no. 1: 1-20).
k3d/share/shaders/k3d_uberlight.sl:8: * Rather than explicitly pass "from" and "to" points to indicate the
k3d/share/shaders/k3d_uberlight.sl:10: * emits from the origin of the local light shader space and points
k3d/share/shaders/k3d_uberlight.sl:11: * toward the +z axis (also in shader space).  Thus, to position and
k3d/share/shaders/k3d_uberlight.sl:13: * coordinate system in effect when the light source is declared.
k3d/share/shaders/k3d_uberlight.sl:15: * hard, and it vastly simplifies the math in the shader.
k3d/share/shaders/k3d_uberlight.sl:18: *   intensity - overall intensity scaling of the light
k3d/share/shaders/k3d_uberlight.sl:19: *   lightcolor - overall color filtering for the light
k3d/share/shaders/k3d_uberlight.sl:23: *       those that point in a particular direction (+z in local light
k3d/share/shaders/k3d_uberlight.sl:24: *       space, for this light).  Omni lights throw light in all directions.
k3d/share/shaders/k3d_uberlight.sl:26: *       BMRT area lights for the time being).
k3d/share/shaders/k3d_uberlight.sl:28: * Distance shaping and falloff controls:
k3d/share/shaders/k3d_uberlight.sl:29: *   cuton, cutoff - define the depth range (z range from the origin, in
k3d/share/shaders/k3d_uberlight.sl:30: *       light coordinates) over which the light is active.  Outside
k3d/share/shaders/k3d_uberlight.sl:32: *   nearedge, faredge - define the width of the transition regions
k3d/share/shaders/k3d_uberlight.sl:34: *   falloff - defines the exponent for falloff.  A falloff of 0 (the
k3d/share/shaders/k3d_uberlight.sl:35: *       default) indicates that the light is the same brightness
k3d/share/shaders/k3d_uberlight.sl:36: *       regardless of distance from the source.  Falloff==1 indicates
k3d/share/shaders/k3d_uberlight.sl:37: *       linear (1/r) falloff, falloff==2 indicates 1/r^2 falloff
k3d/share/shaders/k3d_uberlight.sl:38: *       (which is physically correct for point-like sources, but
k3d/share/shaders/k3d_uberlight.sl:40: *   falloffdist - the distance at which the incident energy is actually
k3d/share/shaders/k3d_uberlight.sl:41: *       equal to intensity*lightcolor.  In other words, the intensity
k3d/share/shaders/k3d_uberlight.sl:43: *   maxintensity - to prevent the light from becoming unboundedly
k3d/share/shaders/k3d_uberlight.sl:44: *       large when the distance < falloffdist, the intensity is
k3d/share/shaders/k3d_uberlight.sl:47: *       from a single point (i.e., the rays diverge).  When nonzero, 
k3d/share/shaders/k3d_uberlight.sl:48: *       the light rays are parallel, as if from an infinitely distant
k3d/share/shaders/k3d_uberlight.sl:51: * Shaping of the cross-section.  The cross-section of the light cone
k3d/share/shaders/k3d_uberlight.sl:52: * is actually described by a superellipse with the following
k3d/share/shaders/k3d_uberlight.sl:54: *   shearx, sheary - define the amount of shear applied to the light
k3d/share/shaders/k3d_uberlight.sl:55: *       cone direction.  Default is 0, meaning that the center of the
k3d/share/shaders/k3d_uberlight.sl:56: *       light cone is aligned with the z-axis in local light space.
k3d/share/shaders/k3d_uberlight.sl:57: *   width, height - define the dimensions of the "barn door" opening.
k3d/share/shaders/k3d_uberlight.sl:59: *       from the light.  In other words, width==height==1 indicates a
k3d/share/shaders/k3d_uberlight.sl: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:72: *       corresponds to a cosine falloff.  For a BMRT area light, the
k3d/share/shaders/k3d_uberlight.sl:73: *       cosine falloff happens automatically, so 0 is the right physical
k3d/share/shaders/k3d_uberlight.sl:75: *       make the spot more bright in the center than the outskirts.
k3d/share/shaders/k3d_uberlight.sl:89: *       means not to use noise.  Larger values increase the blotchiness
k3d/share/shaders/k3d_uberlight.sl:94: *       attenuation of light as it passes through a window with 
k3d/share/shaders/k3d_uberlight.sl:95: *       water drops dripping down it.
k3d/share/shaders/k3d_uberlight.sl:98: * shadows are mainly computed by shadow maps.  Please consult the
k3d/share/shaders/k3d_uberlight.sl:99: * PRMan documentation for more information on the meanings of these
k3d/share/shaders/k3d_uberlight.sl:101: *   shadowmap - the name of the texture containing the shadow map.  If
k3d/share/shaders/k3d_uberlight.sl:109: *   raytraceshadow - if nonzero, cast rays to see if we are in shadow.
k3d/share/shaders/k3d_uberlight.sl:110: *       The default is zero, i.e., not to try raytracing.
k3d/share/shaders/k3d_uberlight.sl:111: *   nshadowrays - The number of rays to trace to determine shadowing.
k3d/share/shaders/k3d_uberlight.sl:114: *       were someplace else, but without changing the area
k3d/share/shaders/k3d_uberlight.sl:115: *       illuminated or the appearance of highlights, etc.
k3d/share/shaders/k3d_uberlight.sl:118: * in 3-space which effectively blocks light.  But it's not really
k3d/share/shaders/k3d_uberlight.sl:119: * geometry, the shader just does the intersection with the
k3d/share/shaders/k3d_uberlight.sl: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:122: * the RIB file using the CoordinateSystem command).
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: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:133: * Joint shadow controls:
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:142: *       use is if you are simulating sunlight: set the lightcolor to
k3d/share/shaders/k3d_uberlight.sl:143: *       something yellowish and make the shadowcolor dark but
k3d/share/shaders/k3d_uberlight.sl:151: *       highlights just fine (except for regions in shadows, as
k3d/share/shaders/k3d_uberlight.sl:152: *       explained above).  This is very handy for lights that are
k3d/share/shaders/k3d_uberlight.sl:154: *       NOTE: This depends on the surface shader looking for, and
k3d/share/shaders/k3d_uberlight.sl:155: *       correctly acting upon, this parameter.  The built-in functions
k3d/share/shaders/k3d_uberlight.sl:158: *       your own illuminance loops in your surface shader, you've got
k3d/share/shaders/k3d_uberlight.sl:159: *       to account for it yourself.  The PRMan user manual explains how
k3d/share/shaders/k3d_uberlight.sl:163: *       diffuse light.  This is useful for making a light that only
k3d/share/shaders/k3d_uberlight.sl:164: *       makes specular highlights, without affecting the rest of the
k3d/share/shaders/k3d_uberlight.sl:165: *       illumination in the scene.  All the same caveats apply with
k3d/share/shaders/k3d_uberlight.sl:169: *       atmospheric scattering only for those lights that have this
k3d/share/shaders/k3d_uberlight.sl:172: *       make a particular light *not* cause illumination in the fog.
k3d/share/shaders/k3d_uberlight.sl:174: *       will also work just fine with PRMan (3.7 or later).
k3d/share/shaders/k3d_uberlight.sl:187: * original attribution and all comments.
k3d/share/shaders/k3d_uberlight.sl:189: * This shader was tested using Pixar's PhotoRealistic RenderMan 3.7
k3d/share/shaders/k3d_uberlight.sl:190: * and the Blue Moon Rendering Tools (BMRT) release 2.3.6.  I have
k3d/share/shaders/k3d_uberlight.sl:191: * tried to avoid Shading Language constructs which wouldn't work on
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:209:/* Comment out the following line if you do *not* wish to use BMRT and
k3d/share/shaders/k3d_uberlight.sl:212://#include "k3d_rayserver.h"
k3d/share/shaders/k3d_uberlight.sl:216:/* Superellipse soft clipping
k3d/share/shaders/k3d_uberlight.sl:218: *   - point Q on the x-y plane
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:222: *   - 0 if Q was inside the inner ellipse
k3d/share/shaders/k3d_uberlight.sl:224: *   - smoothly varying from 0 to 1 in between
k3d/share/shaders/k3d_uberlight.sl:226:float clipSuperellipse(point Q;	/* Test point on the x-y plane */
k3d/share/shaders/k3d_uberlight.sl:268:/* Volumetric light shaping
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:272: *     clipping, superellipse x-y shaping, and distance falloff.
k3d/share/shaders/k3d_uberlight.sl:274: *   - attenuation factor based on the falloff and shaping
k3d/share/shaders/k3d_uberlight.sl:276:float ShapeLightVolume(point PL;	/* Point in light space */
k3d/share/shaders/k3d_uberlight.sl:277:		       string lighttype;	/* what kind of light */
k3d/share/shaders/k3d_uberlight.sl:279:		       float znear, zfar;	/* z clipping */
k3d/share/shaders/k3d_uberlight.sl:282:		       float maxintensity;
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:316:	  float s = log(1 / maxintensity);
k3d/share/shaders/k3d_uberlight.sl:318:	  atten *= (maxintensity * exp(s * pow(PLlen / falloffdist, beta)));
k3d/share/shaders/k3d_uberlight.sl:328:	1 - clipSuperellipse(PL / Pz - point(shearx, sheary, 0), width,
k3d/share/shaders/k3d_uberlight.sl:338:/* Evaluate the occlusion between two points, P1 and P2, due to a fake
k3d/share/shaders/k3d_uberlight.sl:342:float BlockerContribution(point P1, P2;
k3d/share/shaders/k3d_uberlight.sl:343:			  string blockercoords;
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:357:      point Pplane = Pb1 - Vlight * (zcomp(Pb1) / zcomp(Vlight));
k3d/share/shaders/k3d_uberlight.sl:370:		     /* Basic intensity and color of the light */
k3d/share/shaders/k3d_uberlight.sl:371:		     string lighttype = "spot"; float intensity = 1;
k3d/share/shaders/k3d_uberlight.sl:373:		     /* Z shaping and distance falloff */
k3d/share/shaders/k3d_uberlight.sl:376:		     float falloff = 0, falloffdist = 1, maxintensity = 1;
k3d/share/shaders/k3d_uberlight.sl:378:		     /* xy shaping of the cross-section and angle falloff */
k3d/share/shaders/k3d_uberlight.sl:384:		     string slidename = "";
k3d/share/shaders/k3d_uberlight.sl:389:		     string shadowmap = "";
k3d/share/shaders/k3d_uberlight.sl:397:		     string blockercoords = "";
k3d/share/shaders/k3d_uberlight.sl:403:		     output varying float __nonspecular = 0;
k3d/share/shaders/k3d_uberlight.sl:407:  /* For simplicity, assume that the light is at the origin of shader
k3d/share/shaders/k3d_uberlight.sl:408:   * space and aimed in the +z direction.  So to move or orient the
k3d/share/shaders/k3d_uberlight.sl:409:   * light, you transform the coordinate system in the RIB stream, prior
k3d/share/shaders/k3d_uberlight.sl:410:   * to instancing the light shader.  But that sure simplifies the
k3d/share/shaders/k3d_uberlight.sl:411:   * internals of the light shader!  Anyway, let PL be the position of
k3d/share/shaders/k3d_uberlight.sl:412:   * the surface point we're shading, expressed in the local light
k3d/share/shaders/k3d_uberlight.sl:413:   * shader coordinates.
k3d/share/shaders/k3d_uberlight.sl:415:  point PL = transform("shader", Ps);
k3d/share/shaders/k3d_uberlight.sl:417:  /* If it's an area light, we want the point and normal of the light
k3d/share/shaders/k3d_uberlight.sl:419:   * origin and z-axis of shader space.
k3d/share/shaders/k3d_uberlight.sl:421:  point from = P;
k3d/share/shaders/k3d_uberlight.sl:425:  point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_uberlight.sl:445:  illuminate(from, axis, angle)
k3d/share/shaders/k3d_uberlight.sl:454:    /* Basic light shaping - the volumetric shaping is all encapsulated
k3d/share/shaders/k3d_uberlight.sl:455:     * in the ShapeLightVolume function.
k3d/share/shaders/k3d_uberlight.sl:459:		       falloff, falloffdist, maxintensity / intensity, shearx,
k3d/share/shaders/k3d_uberlight.sl:466:	point Pslide = PL / point(width + wedge, height + hedge, 1);
k3d/share/shaders/k3d_uberlight.sl:473:    /* If the volume says we aren't being lit, skip the remaining tests */
k3d/share/shaders/k3d_uberlight.sl:479:#pragma nolint
k3d/share/shaders/k3d_uberlight.sl:480:	    float n = noise(noisefreq * (PL + noiseoffset) * point(1, 1, 0));
k3d/share/shaders/k3d_uberlight.sl:491:	point shadoworigin;
k3d/share/shaders/k3d_uberlight.sl:493:	  shadoworigin = from;
k3d/share/shaders/k3d_uberlight.sl:495:	  shadoworigin = point "shader"(xcomp(PL), ycomp(PL), cuton);
k3d/share/shaders/k3d_uberlight.sl:496:#if (defined(BMRT) || defined(RAYSERVER_H))
k3d/share/shaders/k3d_uberlight.sl:498:	 * we're in BMRT and the user wanted a shadow map.
k3d/share/shaders/k3d_uberlight.sl:505:	      vis += visibility(Ps, shadoworigin + shadowcheat);
k3d/share/shaders/k3d_uberlight.sl:514:	      BlockerContribution(Ps, shadoworigin, blockercoords,
k3d/share/shaders/k3d_uberlight.sl:521:    Cl = (atten * intensity) * lcol;
k3d/share/shaders/k3d_urbermap.sl:5:string abColorMap="I:/ArtWorks/Textures/Batik_1.4.tif"; 
k3d/share/shaders/k3d_urbermap.sl:9:string abDiffuseMap="I:/ArtWorks/Textures/BubbaWeb_1.1.3.tif"; 
k3d/share/shaders/k3d_urbermap.sl:12:string abSpecularMap="I:/ArtWorks/Textures/Curlitron_1.1.tif"; 
k3d/share/shaders/k3d_urbermap.sl:15:string abSpecularColorMap="I:/ArtWorks/Textures/Native_1.2.highlight.tif"; 
k3d/share/shaders/k3d_urbermap.sl:18:string abRoughnessMap="I:/ArtWorks/Textures/Native_1.2.shadow.tif"; 
k3d/share/shaders/k3d_urbermap.sl:20:string abTransparencyMap="I:/ArtWorks/Textures/Native_1.2.tif"; 
k3d/share/shaders/k3d_urbermap.sl:24:string abIncandescenseMap="I:/ArtWorks/Textures/BubbaWeb_1.1.3.tif"; 
k3d/share/shaders/k3d_urbermap.sl:26:string abReflectionMap="I:/ArtWorks/Textures/Batik_1.4.tif"; 
k3d/share/shaders/k3d_urbermap.sl:30:string abBumpMap="I:/ArtWorks/Textures/Curlitron_1.1.tif"; 
k3d/share/shaders/k3d_urbermap.sl:35:point STMatrix0=point(1,0,0); 
k3d/share/shaders/k3d_urbermap.sl:36:point STMatrix1=point(0,1,0); ) 
k3d/share/shaders/k3d_urbermap.sl:38:/** Surface main-code start **/
k3d/share/shaders/k3d_urbermap.sl:42:point PP;
k3d/share/shaders/k3d_urbermap.sl:43:color Csurf, Cspec, Copac, Cincand, Crefl;
k3d/share/shaders/k3d_urbermap.sl:143:Cincand = abIncandescence * color texture(abIncandescenseMap, ss, tt,
k3d/share/shaders/k3d_urbermap.sl:149:Cincand = abIncandescence;
k3d/share/shaders/k3d_urbermap.sl:199:/** Surface main-code end **/
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:11: *   veinfreq - controls fhe lowest frequency of the color veins
k3d/share/shaders/k3d_veinedmarble.sl:12: *   veinlevels - how many "levels" of vein tendrills it has
k3d/share/shaders/k3d_veinedmarble.sl:13: *   warpfreq - lowest frequency of the turbulent warping in the marble
k3d/share/shaders/k3d_veinedmarble.sl:14: *   warping - controls how much turbulent warping there will be
k3d/share/shaders/k3d_veinedmarble.sl:15: *   veincolor - the color of the veins
k3d/share/shaders/k3d_veinedmarble.sl:16: *   sharpness - controls how sharp or fuzzy the veins are (higher = sharper)
k3d/share/shaders/k3d_veinedmarble.sl:19: * AUTHOR: Larry Gritz, the George Washington University
k3d/share/shaders/k3d_veinedmarble.sl:27:#include "k3d_noises.h"
k3d/share/shaders/k3d_veinedmarble.sl:28:#include "k3d_rayserver.h"
k3d/share/shaders/k3d_veinedmarble.sl:29:#include "k3d_material.h"
k3d/share/shaders/k3d_veinedmarble.sl:32:surface k3d_veinedmarble(float Ka = .5;
k3d/share/shaders/k3d_veinedmarble.sl:37:			 float veinfreq = 1;
k3d/share/shaders/k3d_veinedmarble.sl:38:			 float veinlevels = 2;
k3d/share/shaders/k3d_veinedmarble.sl:40:			 float warping = .5;
k3d/share/shaders/k3d_veinedmarble.sl:41:			 color veincolor = color(.6, .5, .1);
k3d/share/shaders/k3d_veinedmarble.sl:46:  point offset;
k3d/share/shaders/k3d_veinedmarble.sl:50:  point PP = transform("shader", P);
k3d/share/shaders/k3d_veinedmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_veinedmarble.sl:58:  PP *= veinfreq;
k3d/share/shaders/k3d_veinedmarble.sl:59:  for(i = 0; i < veinlevels; i += 1)
k3d/share/shaders/k3d_veinedmarble.sl:68:  Ct = mix(Cs, veincolor, turbsum);
k3d/share/shaders/k3d_velvet.sl:8: *   This phenomenological model contains three compnents:
k3d/share/shaders/k3d_velvet.sl:10: *   - Scattering near the horizon, regardless of incident direction
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:25: * 	2001.02.01	westin@SpamSucks_graphics.cornell.edu
k3d/share/shaders/k3d_velvet.sl:28: *			"edginess" parameter to control horizon scatter;
k3d/share/shaders/k3d_velvet.sl:29: *			defined SQR()
k3d/share/shaders/k3d_velvet.sl:31: * prev modified  28 January 1997 S. H. Westin
k3d/share/shaders/k3d_velvet.sl:34:#define SQR(A) ((A)*(A))
k3d/share/shaders/k3d_velvet.sl:41:	    edginess = 10;
k3d/share/shaders/k3d_velvet.sl:48:  vector H;                      /* Bisector vector for Phong/Blinn */
k3d/share/shaders/k3d_velvet.sl:50:  color shiny;                   /* Non-diffuse components */
k3d/share/shaders/k3d_velvet.sl:51:  float cosine, sine;            /* Components for horizon scatter */
k3d/share/shaders/k3d_velvet.sl:56:  shiny = 0;
k3d/share/shaders/k3d_velvet.sl:57:  illuminance ( P, Nf, 1.57079632679489661923 /* Hemisphere */ ) {
k3d/share/shaders/k3d_velvet.sl:60:    cosine = max ( Ln.V, 0 );
k3d/share/shaders/k3d_velvet.sl:61:    shiny += pow ( cosine, 1.0/roughness ) * backscatter
k3d/share/shaders/k3d_velvet.sl:63:    /* Horizon scattering */
k3d/share/shaders/k3d_velvet.sl:64:    cosine = max ( Nf.V, 0 );
k3d/share/shaders/k3d_velvet.sl:65:    sine = sqrt (1.0-SQR(cosine));
k3d/share/shaders/k3d_velvet.sl:66:    shiny += pow ( sine, edginess ) * Ln.Nf * Cl * sheen;
k3d/share/shaders/k3d_velvet.sl:70:  /* Add in diffuse color */
k3d/share/shaders/k3d_velvet.sl:71:  Ci = Os * (Ka*ambient() + Kd*diffuse(Nf)) * Cs + shiny;
k3d/share/shaders/k3d_venus.sl:7: *   clouded planet, very much like the real Venus appears in UV.
k3d/share/shaders/k3d_venus.sl:8: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus.sl:10: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus.sl:15: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_venus.sl:16: *    offset, scale - control the linear scaling of the cloud value.
k3d/share/shaders/k3d_venus.sl:17: *    twist - controls the twisting of the clouds due to Coriolis forces.
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:35: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus.sl:41: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus.sl:46:#define TWOPI (2*PI)
k3d/share/shaders/k3d_venus.sl:50:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus.sl:59:  point Ptexture;		/* the shade point in texture space */
k3d/share/shaders/k3d_venus.sl:60:  point PtN;			/* normalized version of Ptexture */
k3d/share/shaders/k3d_venus.sl:61:  point PP;			/* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus.sl:62:  float rsq;			/* Used in calculation of twist */
k3d/share/shaders/k3d_venus.sl:64:  float sine, cosine;		/* sin and cos of angle */
k3d/share/shaders/k3d_venus.sl:68:  /* Transform to texture coordinates */
k3d/share/shaders/k3d_venus.sl:71:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus.sl:75:  sine = sin(angle);
k3d/share/shaders/k3d_venus.sl:76:  cosine = cos(angle);
k3d/share/shaders/k3d_venus.sl:78:    point(xcomp(Ptexture) * cosine - ycomp(Ptexture) * sine,
k3d/share/shaders/k3d_venus.sl:79:	  xcomp(Ptexture) * sine + ycomp(Ptexture) * cosine, zcomp(Ptexture));
k3d/share/shaders/k3d_venus2.sl:9: *   clouded planet, very much like the real Venus appears in UV.
k3d/share/shaders/k3d_venus2.sl:10: *      The shader works by creating a fractal turbulence function over
k3d/share/shaders/k3d_venus2.sl:12: *   simulated to give the twisting of clouds that is typically seen
k3d/share/shaders/k3d_venus2.sl:17: *    Ka, Kd - the usual meaning
k3d/share/shaders/k3d_venus2.sl:18: *    offset, scale - control the linear scaling of the cloud value.
k3d/share/shaders/k3d_venus2.sl:19: *    twist - controls the twisting of the clouds due to Coriolis forces.
k3d/share/shaders/k3d_venus2.sl:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus2.sl:30: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_venus2.sl:31: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_venus2.sl:37: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus2.sl:39: *        (mark@SpamSucks_intrig.com)
k3d/share/shaders/k3d_venus2.sl:44:#define TWOPI (2*PI)
k3d/share/shaders/k3d_venus2.sl:48:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus2.sl:61:  point Ptexture;           /* the shade point in texture space */
k3d/share/shaders/k3d_venus2.sl:62:  point PtN;                /* normalized version of Ptexture */
k3d/share/shaders/k3d_venus2.sl:63:  point PP;                 /* Point after rotation by coriolis twist */
k3d/share/shaders/k3d_venus2.sl:64:  float rsq;                /* Used in calculation of twist */
k3d/share/shaders/k3d_venus2.sl:66:  float sine, cosine;       /* sin and cos of angle */
k3d/share/shaders/k3d_venus2.sl:70:  /* Transform to texture coordinates and map to nit sphere */
k3d/share/shaders/k3d_venus2.sl:73:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus2.sl:77:  sine = sin (angle);
k3d/share/shaders/k3d_venus2.sl:78:  cosine = cos (angle);
k3d/share/shaders/k3d_venus2.sl:79:  PP = point (xcomp(Ptexture)*cosine - ycomp(Ptexture)*sine,
k3d/share/shaders/k3d_venus2.sl:80:	      xcomp(Ptexture)*sine + ycomp(Ptexture)*cosine,
k3d/share/shaders/k3d_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:8:   Epsilon             - offset for calculating gradient normal. 
k3d/share/shaders/k3d_volcube.sl:10:   Do_Shading          - if 1, shading will be calculated.
k3d/share/shaders/k3d_volcube.sl:11:   SurfNormalDepth     - the mixing depth from surface
k3d/share/shaders/k3d_volcube.sl:14:   ShowActiveVol       - if 1 show the active volume instead of density.
k3d/share/shaders/k3d_volcube.sl:15:   RunShadowPass       - set to 1 if running a shadow pass.
k3d/share/shaders/k3d_volcube.sl:21:/* fnc_traceBox returns an intersection point on a box */
k3d/share/shaders/k3d_volcube.sl:22:point
k3d/share/shaders/k3d_volcube.sl:23:fnc_traceBox (float XMin;
k3d/share/shaders/k3d_volcube.sl:25:	      float YMin;
k3d/share/shaders/k3d_volcube.sl:27:	      float ZMin;
k3d/share/shaders/k3d_volcube.sl:30:	      string refractSpace;)
k3d/share/shaders/k3d_volcube.sl:32:    extern point P;
k3d/share/shaders/k3d_volcube.sl:36:    point Ri;
k3d/share/shaders/k3d_volcube.sl:39:    float TMin = 1000000;
k3d/share/shaders/k3d_volcube.sl:48:    /*plane_z_min*/
k3d/share/shaders/k3d_volcube.sl:50:    D = ZMin * -1;
k3d/share/shaders/k3d_volcube.sl:53:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:60:    if(T > 0 && T < TMin){
k3d/share/shaders/k3d_volcube.sl:61:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:64:    /*plane_x_min*/
k3d/share/shaders/k3d_volcube.sl:66:    D = XMin * -1;
k3d/share/shaders/k3d_volcube.sl:68:    if(T > 0 && T < TMin){
k3d/share/shaders/k3d_volcube.sl:69:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:76:    if(T > 0 && T < TMin){
k3d/share/shaders/k3d_volcube.sl:77:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:80:    /*plane_y_min*/
k3d/share/shaders/k3d_volcube.sl:82:    D = YMin *-1;
k3d/share/shaders/k3d_volcube.sl:84:    if(T > 0 && T < TMin){
k3d/share/shaders/k3d_volcube.sl:85:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:92:    if(T > 0 && T < TMin){
k3d/share/shaders/k3d_volcube.sl:93:	TMin = T;
k3d/share/shaders/k3d_volcube.sl:102:/* active_volume - controls animation in the volume */
k3d/share/shaders/k3d_volcube.sl:104:active_volume(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:112:/* density function will return the final volume density */
k3d/share/shaders/k3d_volcube.sl:114:get_density(point Pos; float vol_mult, vol_offset;)
k3d/share/shaders/k3d_volcube.sl:128:/* normal calculation inside the volume */
k3d/share/shaders/k3d_volcube.sl:129:normal calcGradeNorm(point Pos; float vol_mult, vol_offset, dens, epsilon;)
k3d/share/shaders/k3d_volcube.sl:132:    Nd = normal (get_density(point (xcomp(Pos) - epsilon, ycomp(Pos),
k3d/share/shaders/k3d_volcube.sl:134:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:136:		 get_density(point (xcomp(Pos),
k3d/share/shaders/k3d_volcube.sl:146:/* shading function returns diffuse ans specular */
k3d/share/shaders/k3d_volcube.sl:147:void get_shading (point Pos;
k3d/share/shaders/k3d_volcube.sl:158:    illuminance (Pos, Nf, radians(90)){
k3d/share/shaders/k3d_volcube.sl:185:/* main ray marching shader  */
k3d/share/shaders/k3d_volcube.sl:193:	     float  Do_Shading     = 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:215:    float  remainder    = 100;
k3d/share/shaders/k3d_volcube.sl:221:    point  Pcur_obj     = inPoint_obj + jitter * step_obj;
k3d/share/shaders/k3d_volcube.sl:222:    point  Pcur        = P  + jitter * step_cur;
k3d/share/shaders/k3d_volcube.sl:243:	    if(Do_Shading > 0){
k3d/share/shaders/k3d_volcube.sl:250:		get_shading(Pcur,Nf,V,Roughness,diff,spec);
k3d/share/shaders/k3d_volcube.sl:255:	    remainder = numOfSteps - curStep;
k3d/share/shaders/k3d_volcube.sl:256:	    if(remainder < 1){
k3d/share/shaders/k3d_volcube.sl:257:		cur_density *= remainder;
k3d/share/shaders/k3d_volcube.sl:291:            /* Displace Point To Current Sample */
k3d/share/shaders/k3d_volcube.sl:294:	/* jump to the next sample point */
k3d/share/shaders/k3d_wallpaper.sl:9: *    _Texturing and Modeling: A Procedural Approach_, by David S. Ebert, ed.,
k3d/share/shaders/k3d_wallpaper.sl:10: *    F. Kenton Musgrave, Darwyn Peachey, Ken Perlin, and Steven Worley.
k3d/share/shaders/k3d_wallpaper.sl:14:#define NCELLS 10
k3d/share/shaders/k3d_wallpaper.sl:15:#define CELLSIZE (1/NCELLS)
k3d/share/shaders/k3d_wallpaper.sl:16:#define snoise(s,t)	(2*noise((s),(t))-1)
k3d/share/shaders/k3d_wallpaper.sl:23:    uniform float npoints = 5;
k3d/share/shaders/k3d_wallpaper.sl:27:    point Nf;
k3d/share/shaders/k3d_wallpaper.sl:28:    float ss, tt, angle, r, a, in_out;
k3d/share/shaders/k3d_wallpaper.sl:32:    uniform float rmin = 0.01, rmax = 0.03;
k3d/share/shaders/k3d_wallpaper.sl:33:    uniform float starangle = 2*PI/npoints;
k3d/share/shaders/k3d_wallpaper.sl:34:    uniform point p0 = rmax*(cos(0),sin(0),0);
k3d/share/shaders/k3d_wallpaper.sl:35:    uniform point p1 = rmin*
k3d/share/shaders/k3d_wallpaper.sl:36:        (cos(starangle/2),sin(starangle/2),0);
k3d/share/shaders/k3d_wallpaper.sl:37:    uniform point d0 = p1 - p0;
k3d/share/shaders/k3d_wallpaper.sl:38:    point d1;
k3d/share/shaders/k3d_wallpaper.sl:42:    in_out = 0;
k3d/share/shaders/k3d_wallpaper.sl:62:                d1 = r*(cos(a), sin(a),0) - p0;
k3d/share/shaders/k3d_wallpaper.sl:63:                in_out += step(0, zcomp(d0^d1));
k3d/share/shaders/k3d_wallpaper.sl:67:    Ct = mix(Cs, starcolor, step(0.5,in_out));
k3d/share/shaders/k3d_wallpaper_2stripe.sl:6: *   are shaded in s-t space, and the stripes are parallel to lines of
k3d/share/shaders/k3d_wallpaper_2stripe.sl:14: *   stripewidth                width of stripes, in s coordinates
k3d/share/shaders/k3d_wallpaper_2stripe.sl:15: *   stripespacing              dist between sets of stripes, in s coordinates
k3d/share/shaders/k3d_wallpaper_2stripe.sl:26:#include "k3d_patterns.h"
k3d/share/shaders/k3d_wallpaper_2stripe.sl:27:#include "k3d_material.h"
k3d/share/shaders/k3d_wallpaper_2stripe.sl:33:			      float stripespacing = 0.5;)
k3d/share/shaders/k3d_wallpaper_2stripe.sl:35:  float ss = s / stripespacing - 0.5;
k3d/share/shaders/k3d_wallpaper_2stripe.sl:40:    (filteredpulsetrain(edge, 1, ss, ds) +
k3d/share/shaders/k3d_wallpaper_2stripe.sl:41:     filteredpulsetrain(edge, 1, ss + 2 * stripewidth, ds));
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:24:/// Filtering code courtesy of the Advanced RenderMan book ... where else?
k3d/share/shaders/k3d_warningstripes.sl:26:#define MIN_FILTER_WIDTH 1.0e-6
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:29:float filtered_pulse_train(float edge, period, x, dx)
k3d/share/shaders/k3d_warningstripes.sl:36:	float integral(float t)
k3d/share/shaders/k3d_warningstripes.sl:42:	return (integral(x1) - integral(x0)) / w;
k3d/share/shaders/k3d_warningstripes.sl:45:surface k3d_warningstripes(
k3d/share/shaders/k3d_warningstripes.sl:50:	float stripe_position = filtered_pulse_train(0.5 / Frequency, 1.0 / Frequency, u+v, filter_width(u+v));
k3d/share/shaders/k3d_water.sl:2: * water.sl -- water surface, using ray tracing.

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

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

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

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

k3d/share/shaders/k3d_water.sl:17: *    Ka, Kd, Ks, roughness, specularcolor - The usual meaning

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:30:#define pulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - \

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

k3d/share/shaders/k3d_water.sl:40:        radius = 8,           /* radius of ring */

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

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

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

k3d/share/shaders/k3d_water.sl:49:    color surface_color,     /* Resulting color */

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

k3d/share/shaders/k3d_water.sl:94:    point center;

k3d/share/shaders/k3d_water.sl:97:    center = (0.5, 0.5, 0);  /* position of ring */

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

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

k3d/share/shaders/k3d_watercolor.sl:4: *	R, T, ^nr, and ^nt using the surface normal, incident direction

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

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

k3d/share/shaders/k3d_watercolor.sl:16:	string envmap = "";

k3d/share/shaders/k3d_watercolor.sl:24:	float sinthetat = sin(thetai)/nSnell;

k3d/share/shaders/k3d_watercolor.sl:25:	float thetat = asin(sinthetat);

k3d/share/shaders/k3d_watercolor.sl:33:		float fs = sin(thetat - thetai) / sin(thetat + thetai);

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

k3d/share/shaders/k3d_waterdisplacement.sl:4: *	s, t		surface texture coordinates

k3d/share/shaders/k3d_waterdisplacement.sl:7: *	du, dv		change in u, v across the surface

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

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

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

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

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

k3d/share/shaders/k3d_waterlight.sl:11:	float minimum_intensity = 0.3;
k3d/share/shaders/k3d_waterlight.sl:12:	float maximum_intensity = 1.0;
k3d/share/shaders/k3d_waterlight.sl:16:	string shadowname="";
k3d/share/shaders/k3d_waterlight.sl:24:			Cl = mix(minimum_intensity, maximum_intensity, float noise(frequency * Ps)) * lightcolor;
k3d/share/shaders/k3d_windowlight.sl:2: * windowlight.sl - make a window light (with crossbars)
k3d/share/shaders/k3d_windowlight.sl:5: *   Simulates light coming through a window.  The light doesn't
k3d/share/shaders/k3d_windowlight.sl:9: *   intensity - overall intensity scaling of the light
k3d/share/shaders/k3d_windowlight.sl:10: *   lightcolor - overall color filtering for the light
k3d/share/shaders/k3d_windowlight.sl:11: *   center - the spatial position of the center of the window
k3d/share/shaders/k3d_windowlight.sl:12: *   up, in - vectors which define the orientation of the window
k3d/share/shaders/k3d_windowlight.sl:15: *   panewidth, paneheight - width/height of the individual panes
k3d/share/shaders/k3d_windowlight.sl:16: *   fuzz - controls the fading out near the edges
k3d/share/shaders/k3d_windowlight.sl:17: *   framewidth, frameheight - how thick are the window frame "bars",
k3d/share/shaders/k3d_windowlight.sl:20: * Author:  Larry Gritz, with inspiration from [Upstill]
k3d/share/shaders/k3d_windowlight.sl:26:#include "k3d_patterns.h"
k3d/share/shaders/k3d_windowlight.sl:28:light k3d_windowlight(float intensity = 1;
k3d/share/shaders/k3d_windowlight.sl:31:		      point from = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_windowlight.sl:32:		      point to = point "shader"(0, 1, 0);
k3d/share/shaders/k3d_windowlight.sl:33:		      point center = point "shader"(0, 0, 0);
k3d/share/shaders/k3d_windowlight.sl:35:		      vector in = vector "shader"(0, 1, 0);
k3d/share/shaders/k3d_windowlight.sl:42:  uniform vector inv, right, upv;
k3d/share/shaders/k3d_windowlight.sl:46:  point PL;			/* point on the light */
k3d/share/shaders/k3d_windowlight.sl:49:  inv = normalize(in);
k3d/share/shaders/k3d_windowlight.sl:50:  right = (up) ^ inv;
k3d/share/shaders/k3d_windowlight.sl:51:  upv = normalize(inv ^ right);
k3d/share/shaders/k3d_windowlight.sl:52:  right = upv ^ inv;
k3d/share/shaders/k3d_windowlight.sl:54:  /* d is the depth "into" the room perpendicular to the pane plane */
k3d/share/shaders/k3d_windowlight.sl:55:  d = inv.(Ps - center);
k3d/share/shaders/k3d_windowlight.sl:56:  PL = Ps - path * (d / (path.inv));
k3d/share/shaders/k3d_windowlight.sl:58:  illuminate(PL, -path, .01)
k3d/share/shaders/k3d_windowlight.sl:81:    Cl = intensity * mix(darkcolor, lightcolor, yfract * xfract);
k3d/share/shaders/k3d_windywave.sl:1:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_windywave.sl:3:displacement k3d_windywave(float Km = 0.1; float txtscale = 1;
k3d/share/shaders/k3d_windywave.sl:4:			   float windfreq = 0.5; float windamp = 1;
k3d/share/shaders/k3d_windywave.sl:5:			   float minwind = 0.3)
k3d/share/shaders/k3d_windywave.sl:8:  point PP;
k3d/share/shaders/k3d_windywave.sl:9:  float wind;
k3d/share/shaders/k3d_windywave.sl:12:  PP = txtscale * windfreq * transform("shader", P);
k3d/share/shaders/k3d_windywave.sl:25:  wind = minwind + windamp * turb;
k3d/share/shaders/k3d_windywave.sl:27:/*  P += wind * offset * normalize(N); */
k3d/share/shaders/k3d_windywave.sl:28:  N = calculatenormal(P + wind * offset * normalize(N));
k3d/share/shaders/k3d_wood2.sl:9: *   txtscale - overall scaling factor for the texture
k3d/share/shaders/k3d_wood2.sl:10: *   ringscale - scaling for the ring spacing
k3d/share/shaders/k3d_wood2.sl:12: *   grainy - relative graininess (0 = no fine grain)
k3d/share/shaders/k3d_wood2.sl:24:		  float ringscale = 15;
k3d/share/shaders/k3d_wood2.sl:27:		  color darkwood = color(0.35, 0.22, 0.08); float grainy = 1;)
k3d/share/shaders/k3d_wood2.sl:29:  point PP, PQ;			/* shading space point to be computed */
k3d/share/shaders/k3d_wood2.sl:30:  normal Nf;			/* forward facing normal */
k3d/share/shaders/k3d_wood2.sl:35:  /* Calculate in shader space */
k3d/share/shaders/k3d_wood2.sl:38:  my_t = zcomp(PP) / ringscale;
k3d/share/shaders/k3d_wood2.sl:39:  PQ = point(xcomp(PP) * 8, ycomp(PP) * 8, zcomp(PP));
k3d/share/shaders/k3d_wood2.sl:42:  PQ = point(xcomp(PP), my_t, ycomp(PP) + 12.93);
k3d/share/shaders/k3d_wood2.sl:43:  r = ringscale * noise(PQ);
k3d/share/shaders/k3d_wood2.sl:47:  /* \/--  extra line added for fine grain */
k3d/share/shaders/k3d_wood2.sl:48:  PQ = point(xcomp(PP) * 128 + 5, zcomp(PP) * 8 - 3, ycomp(PP) * 128 + 1);
k3d/share/shaders/k3d_wood2.sl:49:  r2 = grainy * (1.3 - noise(PQ)) + (1 - grainy);
k3d/share/shaders/k3d_wood2.sl:55:   * Use the plastic illumination model
k3d/share/shaders/k3d_woodcut.sl:3:string up="y"; 
k3d/share/shaders/k3d_woodcut.sl:4:float ringscale=5; 
k3d/share/shaders/k3d_woodcut.sl:9:#define snoise(x) (2*noise(x)-1) 
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:16:float stripemin, stripemax, tt;
k3d/share/shaders/k3d_woodcut.sl:21:float illumination = 0.0;
k3d/share/shaders/k3d_woodcut.sl:26:point Psh;
k3d/share/shaders/k3d_woodcut.sl:36:z *= ringscale;
k3d/share/shaders/k3d_woodcut.sl:41:y *= ringscale;
k3d/share/shaders/k3d_woodcut.sl:46:illumination = max(max(comp(illumcolor, 0), comp(illumcolor, 1)), comp(illumcolor, 2));
k3d/share/shaders/k3d_woodcut.sl:56:illumination = (illumination * contrast) + (1.0 - contrast)/2.0 + 
k3d/share/shaders/k3d_woodcut.sl:59:if (illumination < 0.01) {
k3d/share/shaders/k3d_woodcut.sl:63:else if (illumination > 0.99) {
k3d/share/shaders/k3d_woodcut.sl:74:stripemin = 0.5 - smoothstep(0.0, 1.0, illumination)/2.0;
k3d/share/shaders/k3d_woodcut.sl:75:stripemax = 0.5 + smoothstep(0.0, 1.0, illumination)/2.0;
k3d/share/shaders/k3d_woodcut.sl:76:float val = pulse(stripemin, stripemax, fuzz, tt);
k3d/share/shaders/k3d_woodcut.sl:80:Cr = spline (color_val,
