k3d/share/shaders/k3d_antialiasedchecks.sl:14: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_antialiasedchecks.sl:19: * last modified 27 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_antialiasedchecks.sl:34:  float swidth, twidth, sfuzz, tfuzz;  /* Antialiasing */
k3d/share/shaders/k3d_antialiasedchecks.sl:36:  float fuzzmax;        /* max of (sfuzz, tfuzz) */
k3d/share/shaders/k3d_antialiasedchecks.sl:38:  Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_antialiasedchecks.sl:44:  /* Figure out amount of fuzziness, taking normal into account */
k3d/share/shaders/k3d_antialiasedchecks.sl:46:  sfuzz = .5 * swidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:47:  tfuzz = .5 * twidth * frequency / Nfactor;
k3d/share/shaders/k3d_antialiasedchecks.sl:48:  fuzzmax = max (sfuzz, tfuzz);
k3d/share/shaders/k3d_antialiasedchecks.sl:55:  if (fuzzmax <= 0.5) {
k3d/share/shaders/k3d_antialiasedchecks.sl:56:      x = ((smoothstep (.5,.5+sfuzz,smod)) + (1 - smoothstep (0,sfuzz,smod)));
k3d/share/shaders/k3d_antialiasedchecks.sl:57:      y = ((smoothstep (.5,.5+tfuzz,tmod)) + (1 - smoothstep (0,tfuzz,tmod)));
k3d/share/shaders/k3d_antialiasedchecks.sl:60:      Ci = mix (checkcolor, (color1+color2)/2, smoothstep (.125, .5, fuzzmax));
k3d/share/shaders/k3d_arealight.sl:26:   * toward local +z.
k3d/share/shaders/k3d_arealight.sl:28:  vector Nl = normalize(vector "shader"(0, 0, 1));
k3d/share/shaders/k3d_arealight.sl:31:    Cl = (intensity * (Nl.normalize(L) / (L.L)) * lightcolor);
k3d/share/shaders/k3d_background.sl:24:/// Simplified from the original by Larry Gritz
k3d/share/shaders/k3d_bluemarble.sl:49:    NN = normalize(faceforward(N, I));
k3d/share/shaders/k3d_bluemarble.sl:60:        + Ks * specular(NN, normalize(-I), roughness));
k3d/share/shaders/k3d_brick.sl:23: * AUTHOR: written by Larry Gritz, gritzl@acm.org
k3d/share/shaders/k3d_brick.sl:57:   * size by a bit -- it makes the transitions between brick and mortar
k3d/share/shaders/k3d_brick.sl:99:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brick.sl:104:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brick.sl:125:  P += disp * normalize(N);
k3d/share/shaders/k3d_brick.sl:127:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_brick2.sl:39:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brick3.sl:23: * AUTHOR: written by Larry Gritz, 1992
k3d/share/shaders/k3d_brick3.sl:32: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_brick3.sl:66:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_brickanti.sl:41:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brickbump.sl:23: * AUTHOR: written by Larry Gritz, 1992 (and subsequently modified)
k3d/share/shaders/k3d_brickbump.sl:53:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump.sl:58:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brickbump.sl:79:  P += disp * normalize(N);
k3d/share/shaders/k3d_brickbump2.sl:40:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brickbump2.sl:62:    Nf = calculatenormal(P + normalize(N) * stbump);
k3d/share/shaders/k3d_brickbump2.sl:63:    Nf = normalize(faceforward(Nf, I));
k3d/share/shaders/k3d_brickbump3.sl:23: * AUTHOR: written by Larry Gritz, 1992
k3d/share/shaders/k3d_brickbump3.sl:29: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_brickbump3.sl:40:  ~gritz/brick.tif.
k3d/share/shaders/k3d_brickbump3.sl:95:      /* We're in the top horizontal groove */
k3d/share/shaders/k3d_brickbump3.sl:99:      /* Bottom horizontal groove */
k3d/share/shaders/k3d_brickbump3.sl:115:  P += disp * normalize(N);
k3d/share/shaders/k3d_brickperturb.sl:39:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_brushedmetal.sl:11: * Author: Larry Gritz (gritzl@acm.org)
k3d/share/shaders/k3d_brushedmetal.sl:15: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_brushedmetal.sl:25:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_brushedmetal.sl:27:    MaterialBrushedMetal(Nf, Cs, Ka, Kd, Ks, normalize(dPdu), uroughness,
k3d/share/shaders/k3d_brushedmetal2.sl:41:    vector V = normalize(-I);
k3d/share/shaders/k3d_brushedmetal2.sl:42:    normal NN = normalize(N);
k3d/share/shaders/k3d_brushedmetal2.sl:45:    point zro = 0;
k3d/share/shaders/k3d_brushedmetal2.sl:54:            vector LN = normalize (L);
k3d/share/shaders/k3d_brushedmetal2.sl:55:	    vector H = normalize (V + LN);
k3d/share/shaders/k3d_brushedmetal2.sl:79:	vector D, V= normalize(-I);
k3d/share/shaders/k3d_brushedmetal2.sl:81:        point zro = 0;
k3d/share/shaders/k3d_brushedmetal2.sl:85:	vector VA = rotate(normalize(dPdu), twist, zro, normalize(N));
k3d/share/shaders/k3d_brushedmetal2.sl:88:	Nf = faceforward(normalize(N), -I);
k3d/share/shaders/k3d_brushedmetal2.sl:95:	      Ntmp = rotate(Nf,angle+jitter,zro,VA);
k3d/share/shaders/k3d_brushedmetal3.sl:35:            vector LN = normalize (L);
k3d/share/shaders/k3d_brushedmetal3.sl:38:                vector H = normalize (V + LN);
k3d/share/shaders/k3d_brushedmetal3.sl:57:    normal Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_brushedmetal3.sl:58:    vector xdir = normalize (dPdu);
k3d/share/shaders/k3d_brushedmetal3.sl:60:    color spec = LocIllumWardAnisotropic (Nf, -normalize(I),
k3d/share/shaders/k3d_bubbles.sl:26: P += Kmag * magnitud * normalize(N);
k3d/share/shaders/k3d_bubbly.sl:13: *  try lowering bubsize for pimples.
k3d/share/shaders/k3d_bubbly.sl:19: *  Nzscale - scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_bubbly.sl:20: *            the bubbles. set this to zero for a perfect grid of bubbles.
k3d/share/shaders/k3d_bubbly.sl:24: *  bubsize - basicly the radius of the bubbles. distance in rVu's.
k3d/share/shaders/k3d_bubbly.sl:30:         Nzscale = 1,
k3d/share/shaders/k3d_bubbly.sl:32:         bubsize = 1)
k3d/share/shaders/k3d_bubbly.sl:34:  normal Nn = normalize(N);
k3d/share/shaders/k3d_bubbly.sl:40:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_bubbly.sl:45:  setzcomp(trucell,floor(zcomp(Po))+.5);
k3d/share/shaders/k3d_bubbly.sl:53:	nzcell = surrcell + ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_bubbly.sl:54:	dist = distance(Po,nzcell);
k3d/share/shaders/k3d_bubbly.sl:59:  bub = clamp(shortest,0,bubsize)/bubsize; 
k3d/share/shaders/k3d_castucco.sl:33:  /* Do texture calcs in "shader" space, get approximate filter size */
k3d/share/shaders/k3d_castucco.sl:44:  N = Displace(normalize(N), "shader", disp, 1);
k3d/share/shaders/k3d_causticlight.sl:17:    uniform vector axis = normalize(to-from);
k3d/share/shaders/k3d_celld.sl:18:	float voro_freq = 1;    /* desc {Feature size } */
k3d/share/shaders/k3d_celld.sl:19:	float voro_step = 0.05; /* desc {Step value size.  If the difference
k3d/share/shaders/k3d_celld.sl:33:	Nn = normalize (Nn);
k3d/share/shaders/k3d_ceramic.sl:10:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ceramictiles.sl:6: * Parameters for pattern placement and size:
k3d/share/shaders/k3d_ceramictiles.sl:23: *      edge variation, mottling, and speckles.  Setting any to zero will
k3d/share/shaders/k3d_ceramictiles.sl:41: * Author: Larry Gritz, 1999
k3d/share/shaders/k3d_ceramictiles.sl:151:  vector IN = normalize(I), V = -IN;
k3d/share/shaders/k3d_ceramictiles.sl:190:   * Normalize everything so that the tiles are 1x1 units
k3d/share/shaders/k3d_ceramictiles.sl:216:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ceramictiles.sl:221:  Nf = normalize(mix(Nf, Ntile, intile));
k3d/share/shaders/k3d_checkerboard.sl:18:	// Calculate our "filter zone" around the edges of each tile ...
k3d/share/shaders/k3d_checkerboard.sl:47:  Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_checkerboard.sl:51:	  specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_checkerboard_solid.sl:17:	float x, y, z, sum;
k3d/share/shaders/k3d_checkerboard_solid.sl:23:	z = mod(floor(zcomp(Pshad) / TileZ), 2.0);
k3d/share/shaders/k3d_checkerboard_solid.sl:25:	sum = mod(x + y + z, 2.0);
k3d/share/shaders/k3d_checkerboard_solid.sl:36:	Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_checkerboard_solid.sl:38:	Ci = Os * (Ct * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_clay.sl:4: * Author: Larry Gritz (gritzl@acm.org)
k3d/share/shaders/k3d_clay.sl:8: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_clay.sl:15:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_contacshadow.sl:54:	float distance = mapdist - zcomp(cameraP);  
k3d/share/shaders/k3d_corktile.sl:16: * gap - the size of the gap or groove between tiles, measured as a proportion of the tile,
k3d/share/shaders/k3d_corktile.sl:115:	Nf = faceforward(calculatenormal(P + disp *	normalize(N)), I);
k3d/share/shaders/k3d_corktile.sl:116:	Nf = normalize(Nf);
k3d/share/shaders/k3d_corktile.sl:120:		specularcolor * Ks*specular(Nf,-normalize(I),roughness)); 
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:36:    float	rmax1=1000000,rmax2=1000000,rrad1=0,rrad2=0,cellsizescale,ilac;
k3d/share/shaders/k3d_craters.sl:48:	cellsizescale = swidth/sc;
k3d/share/shaders/k3d_craters.sl:61:		    sctr = cellsizescale * (scell + 0.5 + jitter * cellnoise(scell+0.5, tcell+0.5));
k3d/share/shaders/k3d_craters.sl:62:		    tctr = cellsizescale * (tcell + 0.5 + jitter * cellnoise(scell+3.5, tcell+8.5));
k3d/share/shaders/k3d_craters.sl:67:		      /* rad is size of crater squared */
k3d/share/shaders/k3d_craters.sl:77:		      /* rad is size of crater squared */
k3d/share/shaders/k3d_craters.sl:109:    P += Km*pert*normalize(N);
k3d/share/shaders/k3d_craters.sl:111:    Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_crayon.sl:15:	micro - the size of the dots that make up a crayon stroke, relative to the size of
k3d/share/shaders/k3d_crayon.sl:78:	normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_crayon.sl:80:	float fw = max(filterwidth(s), filterwidth(t)); /* the size of the micropolygon */
k3d/share/shaders/k3d_crayon.sl:92:		specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_crayontoon.sl:20:  vector Nf = normalize(N);

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

k3d/share/shaders/k3d_cyclone.sl:17:  point PN;			/* Normalized vector in texture space */
k3d/share/shaders/k3d_cyclone.sl:25:  PN = normalize(Pt);
k3d/share/shaders/k3d_cyclone.sl:37:	      xcomp(Pt) * sine + ycomp(Pt) * cosine, zcomp(Pt));
k3d/share/shaders/k3d_cyclone.sl:41:	  eye_weight = (.1 * max_radius - radius) * 10;	/* normalize */
k3d/share/shaders/k3d_cyclone.sl:73:    Oi * Cs * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_decalplastic.sl:46:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_decalplastic.sl:47:	vector V = -normalize(I);
k3d/share/shaders/k3d_defaultsurface.sl:11:  float d = normalize(I).normalize(N);
k3d/share/shaders/k3d_dented.sl:15: * AUTHOR: written by Larry Gritz, based on the "dented" shader in
k3d/share/shaders/k3d_dented.sl:21: * last modified  12 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_dented.sl:32:	float size;
k3d/share/shaders/k3d_dented.sl:38:	size = frequency;
k3d/share/shaders/k3d_dented.sl:41:			magnitude += abs(0.5 - noise(PP*size)) / size;
k3d/share/shaders/k3d_dented.sl:42:			size *= 2;
k3d/share/shaders/k3d_dented.sl:44:	P = P - (Km * pow(magnitude, power)) * normalize(N);
k3d/share/shaders/k3d_displacementmap.sl:12:  P = P - (Km * (Ct - ZeroPoint)) * normalize(N);
k3d/share/shaders/k3d_displacementmap.sl:14:  N = normalize(N) + normalize(N2) - normalize(N1);
k3d/share/shaders/k3d_dturb.sl:33:  P += Km * magnitude * normalize(N);
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:9: * baseSize = the basic diameter of the particle sphere before scaling
k3d/share/shaders/k3d_ember.sl:15:k3d_ember (	float baseSize = 2;
k3d/share/shaders/k3d_ember.sl:23:	float size = distance (PP, QQ) / baseSize;
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:31:	NN = normalize(N);
k3d/share/shaders/k3d_ember.sl:32:	NI = normalize(I);
k3d/share/shaders/k3d_ember.sl:43:	Ci = color spline (spcol * size, 
k3d/share/shaders/k3d_ember.sl:69:		Oi = angle * size;
k3d/share/shaders/k3d_emboss.sl:15:		P -= Km * texture(texturename, s, t) * normalize(N);
k3d/share/shaders/k3d_envsurf.sl:4:	Ci = environment (envname, normalize(vtransform(envspace, I)));
k3d/share/shaders/k3d_eroded.sl:15:	float size = 4.0,
k3d/share/shaders/k3d_eroded.sl:21:	point V = normalize(-I);
k3d/share/shaders/k3d_eroded.sl:25:		magnitude += 4.0 * abs (.5 - noise (W * size)) / size;
k3d/share/shaders/k3d_eroded.sl:26:		size *= 2.0;
k3d/share/shaders/k3d_eroded.sl:32:	N = calculatenormal (P - magnitude * normalize(N));
k3d/share/shaders/k3d_eroded.sl:34:	Nf = faceforward (normalize (N), I);
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:27: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_eyeball.sl:54:	 float pupilsize = 0.05, irissize = 0.12;
k3d/share/shaders/k3d_eyeball.sl:83:  irisstat = smoothstep (irissize, irissize+twidth, tt);
k3d/share/shaders/k3d_eyeball.sl:84:  pupilstat = smoothstep (pupilsize, pupilsize+twidth, tt);
k3d/share/shaders/k3d_eyeball.sl:85:  bloody = bloodshot * (smoothstep (-irissize, 2.5*irissize, tt));
k3d/share/shaders/k3d_eyeball.sl:89:   * of the whites.  The veining pattern is essentially summed zero sets
k3d/share/shaders/k3d_eyeball.sl:107:  Ciris = mix (iriscolor, irisoutercolor, smoothstep (irissize*.8, irissize, tt));
k3d/share/shaders/k3d_eyeball.sl:134:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_eyeball.sl:136:	      specularcolor * ks*specular(Nf,-normalize(I),rough));
k3d/share/shaders/k3d_ez.sl:2:k3d_ez(){
k3d/share/shaders/k3d_ez.sl:3:Ci = abs(normalize(N).normalize(I));
k3d/share/shaders/k3d_fakesky.sl:11:    Ci = Os * (.5 + .5 * max(0., (up . normalize(N)))) * 1.8 * skycolor;

k3d/share/shaders/k3d_fill.sl:12:	normal Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_flame.sl:18: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_flame.sl:27: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_fractal.sl:19:	normal Nn = normalize(N);	

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

k3d/share/shaders/k3d_fresnelplastic.sl:49:   /* cat Reflection desc {The size of the room to base the reflection
k3d/share/shaders/k3d_fresnelplastic.sl:63:    normal Nf = normalize (faceforward( normalize(N), I ));
k3d/share/shaders/k3d_fresnelplastic.sl:64:    vector V = -normalize(I);
k3d/share/shaders/k3d_fresnelplastic.sl:65:    vector R = normalize (reflect (I, Nf));
k3d/share/shaders/k3d_fresnelplastic.sl:83:      fresnel (normalize (I), Nf, (I.Nf > 0)? ior: 1/ior,
k3d/share/shaders/k3d_funkyglass.sl:2: * (c) Copyright 1994, Larry Gritz
k3d/share/shaders/k3d_funkyglass.sl:18:  V = normalize(I);
k3d/share/shaders/k3d_funkyglass.sl:19:  Nf = faceforward(normalize(N), V);
k3d/share/shaders/k3d_fur2.sl:22:    /* normalize the stuff */
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:49:	 float spec_size_fade  = 0.1;
k3d/share/shaders/k3d_fur2.sl:70:    vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_fur2.sl:71:    vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_fur2.sl:75:    varying normal nSN = normalize( surface_normal );
k3d/share/shaders/k3d_fur2.sl:99:    norm_hair = normalize(norm_hair);
k3d/share/shaders/k3d_fur2.sl:104:    Kspec *= min( smoothstep( start_spec, start_spec + spec_size_fade, v),  
k3d/share/shaders/k3d_fur2.sl:105:		  1 - smoothstep( end_spec, end_spec - spec_size_fade, v ) );
k3d/share/shaders/k3d_fur2.sl:116:	nL = normalize(L);
k3d/share/shaders/k3d_fur2.sl:128:                                    abs(clamp(nL.normalize(-1*clump_vect), -1, 0)));
k3d/share/shaders/k3d_glass.sl:22: * Author: Larry Gritz, 1999  (lg@bmrt.org)
k3d/share/shaders/k3d_glass.sl:26: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_glass.sl:43:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_gloop.sl:29:  vector stepsize = magnitude/freq;
k3d/share/shaders/k3d_gloop.sl:34:  vector dPduN = normalize(vtransform("object",dPdu));
k3d/share/shaders/k3d_gloop.sl:35:  vector dPdvN = normalize(vtransform("object",dPdv));
k3d/share/shaders/k3d_gloop.sl:41:  float  nz = noise(Psh)-.5;
k3d/share/shaders/k3d_gloop.sl:42:  float  nzou = noise(Pou)-.5;
k3d/share/shaders/k3d_gloop.sl:43:  float  nzov = noise(Pov)-.5;
k3d/share/shaders/k3d_gloop.sl:45:  float  chu = (nz - nzou);/*change in noise value in u*/
k3d/share/shaders/k3d_gloop.sl:46:  float  chv = (nz - nzov); 
k3d/share/shaders/k3d_gloop.sl:56:    P -= vtransform("object","current",step)*nz*stepsize;
k3d/share/shaders/k3d_gloop.sl:57:    DdPdu = normalize(DdPdu+(step*chu));
k3d/share/shaders/k3d_gloop.sl:58:    DdPdv = normalize(DdPdv+(step*chv));
k3d/share/shaders/k3d_gloop.sl:63:  N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_glow.sl:11:      // Normalize incidence
k3d/share/shaders/k3d_glow.sl:19:      // Calculate final color and opacity - we set Oi near zero
k3d/share/shaders/k3d_gmarbtile_polish.sl:18: *   tilesize - how big each tile is
k3d/share/shaders/k3d_gmarbtile_polish.sl:20: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_gmarbtile_polish.sl:38:			     float tilesize = 1;
k3d/share/shaders/k3d_gmarbtile_polish.sl:56:  float ss = xcomp(PP) / tilesize;
k3d/share/shaders/k3d_gmarbtile_polish.sl:58:  float tt = ycomp(PP) / tilesize;
k3d/share/shaders/k3d_gmarbtile_polish.sl:64:  offset = vector(7 * whichs, 15 * whicht, 0 /*-23*floor(zcomp(PQ))*/ );
k3d/share/shaders/k3d_gmarbtile_polish.sl:100:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_gmarbtile_polish.sl:101:  vector V = normalize(I);
k3d/share/shaders/k3d_gooch.sl:37:    normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_gooch.sl:48:        ldotn = (normalize(L)).Nf;
k3d/share/shaders/k3d_gooch.sl:56:                specularcolor*Ks*specular(Nf,-normalize(I),roughness)));
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:23:   {  P += (-Km * texture(texturename,s+spin,y/15.0)) * normalize(N);
k3d/share/shaders/k3d_granite.sl:20:	Ci = Cs * sum * (Ka + Kd * diffuse(faceforward( normalize(N), I )) ) ;
k3d/share/shaders/k3d_graphic_lines.sl:9:        float paint_fuzz=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:11:        float ink_fuzz=0.0;
k3d/share/shaders/k3d_graphic_lines.sl:14:        string up_highlight="z";
k3d/share/shaders/k3d_graphic_lines.sl:19:        float noise_size_highlight=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:28:        float fuzz_highlight=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:42:        float noise_size_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:51:				float fuzz_paint=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:65:        float noise_size_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:74:				float fuzz_ink=0.3;
k3d/share/shaders/k3d_graphic_lines.sl:102:	float z_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:110:	Nf_highlight=faceforward(normalize(N_highlight),I);
k3d/share/shaders/k3d_graphic_lines.sl:111:	V_highlight=-normalize(I);
k3d/share/shaders/k3d_graphic_lines.sl:114:	if (up_highlight == "z")
k3d/share/shaders/k3d_graphic_lines.sl:115:	{z_highlight=zcomp(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:117:		tt_highlight=mod(z_highlight,1);
k3d/share/shaders/k3d_graphic_lines.sl:131:	ns_highlight=noise_size_highlight;
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:156:	float spacescale_highlight=length(vtransform("shader",normalize(N_highlight)));
k3d/share/shaders/k3d_graphic_lines.sl:157:	vector Ndisp_highlight=normalize(N_highlight)*(0/max(spacescale_highlight,1e-6));
k3d/share/shaders/k3d_graphic_lines.sl:160:	N_highlight=normalize(calculatenormal(P_highlight+(1-0)*Ndisp_highlight));
k3d/share/shaders/k3d_graphic_lines.sl:180:	float z_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:206:	ns_paint=noise_size_paint;
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: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:232:	N_paint=normalize(calculatenormal(P_paint+(1-0)*Ndisp1));
k3d/share/shaders/k3d_graphic_lines.sl:252:	float z_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:278:	ns_ink=noise_size_ink;
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: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:304:	N_ink=normalize(calculatenormal(P_ink+(1-0)*Ndisp2));
k3d/share/shaders/k3d_graphic_lines.sl:320:			H = normalize(normalize(L)+V);
k3d/share/shaders/k3d_graphic_lines.sl:334:	Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_graphic_lines.sl:335:	normI = normalize(I);
k3d/share/shaders/k3d_graphic_lines.sl:346:	diff += normalize(L).Nf;
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:363:	cos_here = normalize(Nf).normI;
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_grass_displace.sl:18:              size = 1.0,

k3d/share/shaders/k3d_grass_displace.sl:19:	      size2 = 0.75; )

k3d/share/shaders/k3d_grass_displace.sl:32:        x,y,z;

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

k3d/share/shaders/k3d_grass_displace.sl:43:      if (z <= size2 )

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

k3d/share/shaders/k3d_grass_displace.sl:55:      if (z <= size )

k3d/share/shaders/k3d_grass_surface.sl:12:              size = 1.0,

k3d/share/shaders/k3d_grass_surface.sl:13:	      size2 = 0.75; )

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

k3d/share/shaders/k3d_grass_surface.sl:32:      float d, fuzz = 0.025;

k3d/share/shaders/k3d_grass_surface.sl:36:      color layer_opac = 1 - smoothstep(radius - fuzz, radius, d);

k3d/share/shaders/k3d_greenmarble.sl:16: * AUTHOR: Larry Gritz, 1994
k3d/share/shaders/k3d_greenmarble.sl:74:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_grids.sl:14:float G1L1_fuzz=0.453; 
k3d/share/shaders/k3d_grids.sl:22:float G1L2_fuzz=0.363; 
k3d/share/shaders/k3d_grids.sl:30:float G2L1_fuzz=0.0655; 
k3d/share/shaders/k3d_grids.sl:38:float G2L2_fuzz=0.306; 
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:65:color G1L1_layer_opac = pulse(G1L1_linewidth, 1-G1L1_linewidth, G1L1_fuzz, G1L1_tt);
k3d/share/shaders/k3d_grids.sl:73:color G1L2_layer_opac = pulse(G1L2_linewidth, 1-G1L2_linewidth, G1L2_fuzz, G1L2_tt);
k3d/share/shaders/k3d_grids.sl:75:normal G1_Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_grids.sl:76:vector G1_V = -normalize(I);
k3d/share/shaders/k3d_grids.sl:84:color G2L1_layer_opac = pulse(G2L1_linewidth, 1-G2L1_linewidth, G2L1_fuzz, G2L1_tt);
k3d/share/shaders/k3d_grids.sl:92:color G2L2_layer_opac = pulse(G2L2_linewidth, 1-G2L2_linewidth, G2L2_fuzz, G2L2_tt);
k3d/share/shaders/k3d_grids_disp.sl:10: return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_grids_disp.sl:16:float fuzz0=0.136; 
k3d/share/shaders/k3d_grids_disp.sl:22:float fuzz1=0.269; 
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:37:color layer_opac0 = pulse(linewidth0, 1-linewidth0, fuzz0, tt0);
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:50:color layer_opac1 = pulse(linewidth1, 1-linewidth1, fuzz1, tt1);
k3d/share/shaders/k3d_grids_disp.sl:55: N = Displace(normalize(N),0.05*temp_f_2,0);
k3d/share/shaders/k3d_hair.sl:13:	vector T = normalize (dPdv); /* tangent along length of hair */
k3d/share/shaders/k3d_hair.sl:14:	vector V = -normalize(I);    /* V is the view vector */
k3d/share/shaders/k3d_hair.sl:21:			cosang = cos (abs (acos (T.normalize(L)) - acos (-T.V)));
k3d/share/shaders/k3d_hdr_light.sl:20:	vector D = normalize(vtransform("world",R));

k3d/share/shaders/k3d_hdr_light.sl:24:	float Dz = zcomp(D);

k3d/share/shaders/k3d_hdr_light.sl:26:	float r = 0.159154943 * acos(Dz) / sqrt((Dx * Dx) + (Dy * Dy));

k3d/share/shaders/k3d_hdr_light.sl:56:/* Code based off of Larry Gritz's Uberlight Shader */

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

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

k3d/share/shaders/k3d_hdr_light.sl:67:		vector R = normalize(vtransform(envspace,L));

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

k3d/share/shaders/k3d_hdr_surface.sl:23:	float Dz = zcomp(D);

k3d/share/shaders/k3d_hdr_surface.sl:25:	float r = 0.159154943 * acos(Dz) / sqrt((Dx * Dx) + (Dy * Dy));

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

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:31:* Larry Gritz "noises.h", "project.h", "patterns.h"
k3d/share/shaders/k3d_hexatile_bump.sl:128:return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_hexatile_bump.sl:131:vector VShd = vtransform("shader", vector(normalize(N)));
k3d/share/shaders/k3d_hexatile_bump.sl:135:N = Displace(normalize(N),VShd,Km*disp,Truedisp); 
k3d/share/shaders/k3d_hextile.sl:31: * AUTHOR: written by Larry Gritz, 1994
k3d/share/shaders/k3d_hextile.sl:36: * last modified 15 Feb 94 by Larry Gritz
k3d/share/shaders/k3d_hextile.sl:68:  float swidth, twidth, sfuzz, tfuzz, fuzzmax;
k3d/share/shaders/k3d_hextile.sl:77:  sfuzz = 0.5 * swidth;
k3d/share/shaders/k3d_hextile.sl:78:  tfuzz = 0.5 * twidth;
k3d/share/shaders/k3d_hextile.sl:79:  fuzzmax = max (sfuzz, tfuzz);
k3d/share/shaders/k3d_hextile.sl:92:      mortar =  1 - (smoothstep(mw2,mw2+sfuzz,ss) *
k3d/share/shaders/k3d_hextile.sl:93:		     (1 - smoothstep(tilewidth-mw2-sfuzz,tilewidth-mw2,ss)));
k3d/share/shaders/k3d_hextile.sl:105:      mortar = (smoothstep (x-1.73*mw2-tfuzz, x-1.73*mw2, y) *
k3d/share/shaders/k3d_hextile.sl:106:		(1 - smoothstep (x+1.73*mw2, x+1.73*mw2+tfuzz, y)));
k3d/share/shaders/k3d_hextile.sl:120:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_hextile.sl:122:	      specularcolor * ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_imagelayergradient.sl:1:surface k3d_imagelayergradient(color zenith = color(0, 0, 1);
k3d/share/shaders/k3d_imagelayergradient.sl:10:      Ci = Cs * mix(zenith, sky, v * 2.0);
k3d/share/shaders/k3d_incandplastic.sl:23:  Nf = faceforward(normalize(N), I, normalize(N));

k3d/share/shaders/k3d_incandplastic.sl:24:  NI = -normalize(I);

k3d/share/shaders/k3d_indirect.sl:25:  vector axis = normalize(N);
k3d/share/shaders/k3d_leather.sl:30:	/*BLOTCH sont les zebrure*/

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

k3d/share/shaders/k3d_leather.sl:59:	V = normalize(-I);

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

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:180:	newP = calculatenormal(P + disp * normalize(N));

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

k3d/share/shaders/k3d_leather.sl:191:	 * Note: You'll need Larry Gritz's raytrace helper files

k3d/share/shaders/k3d_leather.sl:196:		Rdir = normalize(reflect(normalize(I), Nf));

k3d/share/shaders/k3d_lensflare.sl:16: *   bloomradius, bloomfalloff - control the size & shape of the bloom
k3d/share/shaders/k3d_lensflare.sl:21: *          size and shape of the starburst effect
k3d/share/shaders/k3d_lensflare.sl:23: *   rainbowradius, rainbowwidth - size of the rainbow
k3d/share/shaders/k3d_lensflare.sl:37: * Author: Larry Gritz & Tony Apodaca, 1999
k3d/share/shaders/k3d_lensflare.sl:64:  uniform float halfangle = acos(normalize(corner).vector(0, 0, 1));
k3d/share/shaders/k3d_lensflare.sl:123:    float atten = acos(zcomp(normalize(vector transform("camera", P + L))));
k3d/share/shaders/k3d_lensflare.sl:178:    vector axis = normalize(vector Plight);
k3d/share/shaders/k3d_luna.sl:11: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_luna.sl:20: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_luna.sl:63:  NN = normalize(N);
k3d/share/shaders/k3d_luna.sl:100:  /* get normalized vector "v" */
k3d/share/shaders/k3d_luna.sl:102:  vv = point(xcomp(PP) / radial_dist, 0, zcomp(PP) / radial_dist);
k3d/share/shaders/k3d_luna.sl:183:/*  N = normalize (calculatenormal (PQ)); */
k3d/share/shaders/k3d_luna.sl:187:  Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_lunette.sl:23: *   noiseScale - scale factor for the fBm noise relative to the grid size
k3d/share/shaders/k3d_lunette.sl:24: *   noiseRandom - randomization factor for the fBm noise
k3d/share/shaders/k3d_lunette.sl:55: *   noiseScale - Scale of the background fBm noise (relative to the size of
k3d/share/shaders/k3d_lunette.sl:58: *   noiseRandom - Randomization value for the noise.
k3d/share/shaders/k3d_lunette.sl:81:	float noiseRandom;	/* randomization for the noise */
k3d/share/shaders/k3d_lunette.sl:168:	normal Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_lunette.sl:172:		specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_map_pattern_1.sl:53:my_t = zcomp(PP) / temp_f_3;
k3d/share/shaders/k3d_map_pattern_1.sl:54:PQ = point (xcomp(PP)*8, ycomp(PP)*8, zcomp(PP));
k3d/share/shaders/k3d_map_pattern_1.sl:62:PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_map_pattern_1.sl:68:normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_map_pattern_1.sl:69:C_temp1 = Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_matte.sl:12:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_metal.sl:13:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_metal.sl:14:  vector V = -normalize(I);
k3d/share/shaders/k3d_mondometal.sl:180:        Nf = normalize( ntransform("shader", N) );

k3d/share/shaders/k3d_mondometal.sl:186:	    normal deltaN = normalize(N) - normalize(Ng);

k3d/share/shaders/k3d_mondometal.sl:187:	    Nf = normalize(Nf) + deltaN;

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

k3d/share/shaders/k3d_mondometal.sl:200:    V = -normalize(I);

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

k3d/share/shaders/k3d_mondometal.sl:240:            Ks * specular(Nf,-normalize(I),roughness));

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

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

k3d/share/shaders/k3d_noisysmoke.sl:13:             /* Optimize: one octave only if not lit */                     \
k3d/share/shaders/k3d_noisysmoke.sl:32:		      float stepsize = 0.1; float debug = 0;
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:71:      GADD(PP, PW, li, dtau) ss = min(stepsize, end - d);
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:23: *       axis of the trunk so that it's not perfectly on the z axis.
k3d/share/shaders/k3d_oak.sl:25: *       the z axis.
k3d/share/shaders/k3d_oak.sl:37: * Author: Larry Gritz, 1999
k3d/share/shaders/k3d_oak.sl:69:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_oakplank.sl:15: *   plankwidth, planklength - size of the planks
k3d/share/shaders/k3d_oakplank.sl:30: *       axis of the trunk so that it's not perfectly on the z axis.
k3d/share/shaders/k3d_oakplank.sl:32: *       the z axis.
k3d/share/shaders/k3d_oakplank.sl:48: * Author: Larry Gritz, 1999
k3d/share/shaders/k3d_oakplank.sl:124:  float ss = xcomp(Pshad), tt = ycomp(Pshad), height = zcomp(Pshad);
k3d/share/shaders/k3d_oakplank.sl:157:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_orange.sl:40:	setzcomp (p2, cos (2 * PI * s));
k3d/share/shaders/k3d_orange.sl:44:	newP = calculatenormal (P + turb * normalize (N));
k3d/share/shaders/k3d_orange.sl:45:	Nf = faceforward (normalize (newP), I);
k3d/share/shaders/k3d_orange.sl:46:	V = -normalize (I);
k3d/share/shaders/k3d_orennayar.sl:19: * AUTHOR:  Larry Gritz
k3d/share/shaders/k3d_orennayar.sl:22: *   Oren, Michael and Shree K. Nayar.  "Generalization of Lambert's
k3d/share/shaders/k3d_orennayar.sl:35: *   14 June 1994 -- written by Larry Gritz
k3d/share/shaders/k3d_orennayar.sl:52:    Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_orennayar.sl:53:    IN = normalize (I);
k3d/share/shaders/k3d_orennayar.sl:59:	LN = normalize(L);
k3d/share/shaders/k3d_orennayar.sl:61:	cos_phi_diff = normalize(Eye-Nf*(Eye.Nf)) . normalize(LN - Nf*(LN.Nf));
k3d/share/shaders/k3d_outlet.sl:10: *   I'm lazy, okay?
k3d/share/shaders/k3d_outlet.sl:17: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_outlet.sl:23: * last modified  17 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_outlet.sl:68:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_outlet.sl:71:	      ks * specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_outline.sl:2: * it's the valdez algorithm. short and sweet.
k3d/share/shaders/k3d_outline.sl:9:  normal Nn = normalize (-N);
k3d/share/shaders/k3d_outline.sl:10:  float dot = Nn . normalize(I);
k3d/share/shaders/k3d_paintedplastic.sl:43:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_paintedplastic.sl:44:	vector V = -normalize(I);
k3d/share/shaders/k3d_parquet_plank.sl:8: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank.sl:27: * AUTHOR: Larry Gritz, email: lg@bmrt.org
k3d/share/shaders/k3d_parquet_plank.sl:71:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_parquet_plank.sl:160:	  specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_parquet_plank2.sl:9: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_plank2.sl:28: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_plank2.sl:29: *         email: gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_parquet_plank2.sl:35: *    10 Feb 1995 - written by Larry Gritz, based on my "plank" shader.
k3d/share/shaders/k3d_parquet_plank2.sl:81:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_parquet_plank2.sl:154:	      specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_parquet_tile.sl:10: *   units are both the same size in world space.
k3d/share/shaders/k3d_parquet_tile.sl:29: * AUTHOR: written by Larry Gritz, the George Washington University
k3d/share/shaders/k3d_parquet_tile.sl:30: *         email: gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_parquet_tile.sl:36: *    10 Feb 1995 - written by Larry Gritz, based on my "plank" shader.
k3d/share/shaders/k3d_parquet_tile.sl:45: *   - many thanks to Larry Gritz and wave for creating the original
k3d/share/shaders/k3d_parquet_tile.sl:96:  Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_parquet_tile.sl:169:	      specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_planetclouds.sl:18: *    offset - controls the zero crossings (where the clouds disappear)
k3d/share/shaders/k3d_planetclouds.sl:37: *      to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_planetclouds.sl:42: *    Conversion to Shading Language and other minor changes by Larry Gritz.
k3d/share/shaders/k3d_planetclouds.sl:51: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_planetclouds.sl:96:  /* Adjust zero crossing (where the clouds disappear) */
k3d/share/shaders/k3d_planetclouds.sl:109:  Ci = Oi * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_plank.sl:25: * AUTHOR: Larry Gritz, lg@bmrt.org
k3d/share/shaders/k3d_plank.sl:66:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plank.sl:148:	  specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_plastic.sl:14:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plastic.sl:16:  Ci = Os * (Cs * (Ka * ambient() + Kd * diffuse(Nf)) + specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_plastic2.sl:19:    point Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_plastic2.sl:20:    point V = normalize(-I);
k3d/share/shaders/k3d_projectionmap_plastic.sl:59:	normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_projectionmap_plastic.sl:60:	vector V = -normalize(I);
k3d/share/shaders/k3d_puffyclouds.sl:27: *    Translation to RenderMan Shading Language by Larry Gritz.
k3d/share/shaders/k3d_puffyclouds.sl:36: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_redapple.sl:21: * different size apples, make sure to change txtscale appropriately.
k3d/share/shaders/k3d_redapple.sl:83:	V = normalize(-I);
k3d/share/shaders/k3d_redapple.sl:203:	newP = calculatenormal(P + disp * normalize(N));
k3d/share/shaders/k3d_redapple.sl:204:	Nf = faceforward(normalize(newP), I);
k3d/share/shaders/k3d_redapple.sl:214:	 * Note: You'll need Larry Gritz's raytrace helper files
k3d/share/shaders/k3d_redapple.sl:219:		Rdir = normalize(reflect(normalize(I), Nf));
k3d/share/shaders/k3d_ridged_multifractal.sl:19:	normal Nn = normalize(N);	

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

k3d/share/shaders/k3d_ripple.sl:16:	       size = 5; )

k3d/share/shaders/k3d_roughmetal.sl:21:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_round.sl:13:		 vv,	/* distance in v to the nearest "horizontal" edge */
k3d/share/shaders/k3d_round.sl:15:		 lv;	/* "real" distance to the nearest "horizontal" edge */
k3d/share/shaders/k3d_round.sl:52:			center = (radius-lu) * normalize(dpdu);
k3d/share/shaders/k3d_round.sl:54:			center += (radius-lv) * normalize(dpdv);
k3d/share/shaders/k3d_round.sl:56:		center += P - radius*normalize(N);
k3d/share/shaders/k3d_round.sl:59:		P = center + radius*normalize( P-center );
k3d/share/shaders/k3d_rubber.sl:15:	point	Nf = faceforward(normalize(N),I), 
k3d/share/shaders/k3d_ruledpaper.sl:94:    Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_ruledpaper.sl:95:    V = normalize(-I);
k3d/share/shaders/k3d_rustymetal.sl:23: * AUTHOR: Larry Gritz, gritz@SpamSucks_seas.gwu.edu
k3d/share/shaders/k3d_rustymetal.sl:27: *   19 Jan 1995 - gritz - created
k3d/share/shaders/k3d_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
k3d/share/shaders/k3d_rustymetal.sl:85:      Nf = faceforward (normalize(Nrust),I);
k3d/share/shaders/k3d_rustymetal.sl:92:      Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_rustymetal.sl:93:      V = -normalize(I);
k3d/share/shaders/k3d_saturn.sl:1:/* This was terran.sl from Larry Gritz and Ken Musgrave.  But there isn't much of it left.
k3d/share/shaders/k3d_saturn.sl: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:34: *        the only one that would recognize that it was.
k3d/share/shaders/k3d_saturn.sl:57:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_saturn.sl:64:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_saturn.sl:86:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_saturnring.sl:31:/* Grabbed from one of Larry Gritz's many shaders */
k3d/share/shaders/k3d_saturnring.sl:43:	point Nf;       /* Forward facing Normalized vector of incident light */
k3d/share/shaders/k3d_saturnring.sl:106:			Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_scartissue.sl:16:	float nz = 0;
k3d/share/shaders/k3d_scartissue.sl:20:	normal Nn = normalize(N);
k3d/share/shaders/k3d_scartissue.sl:21:	normal Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_scartissue.sl:22:	vector V = normalize(-I);
k3d/share/shaders/k3d_scartissue.sl:25:		nz += abs(.5 - noise( (freq * Psh)+offset)) / freq;
k3d/share/shaders/k3d_scartissue.sl:29:	base = mix(dark,light,nz);
k3d/share/shaders/k3d_scartissue.sl:30:	P += Nn*nz*.3;
k3d/share/shaders/k3d_scartissue.sl:32:	Nf = faceforward(normalize(N), I );
k3d/share/shaders/k3d_scartissue.sl:35:	 	(1-nz)*Ks * specular(Nf,V,roughness) );
k3d/share/shaders/k3d_screen.sl:33:      Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_screen.sl:36:	      specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_screen_aa.sl:15: * AUTHOR: written by Larry Gritz
k3d/share/shaders/k3d_screen_aa.sl:17: * last modified  31 Jan 1994 by Larry Gritz
k3d/share/shaders/k3d_screen_aa.sl:35:  vector IN;			/* normalized incident vector */
k3d/share/shaders/k3d_screen_aa.sl:41:  IN = normalize(I);
k3d/share/shaders/k3d_screen_aa.sl:42:  Nf = faceforward(normalize(N), I);
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:32:	/* Compute the output color. Notice that as ink goes from zero to
k3d/share/shaders/k3d_sdixon.sl:33:	   one, the diffuse component goes to zero and the specular 
k3d/share/shaders/k3d_shadowspot.sl:28:		cosangle = L.A / length(L);	/* A is already normalized */
k3d/share/shaders/k3d_shifteddrtile.sl:11: *	fuzz -       Amount to blur edge
k3d/share/shaders/k3d_shifteddrtile.sl:33:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shifteddrtile.sl:34:	(smoothstep (a-fuzz, a+fuzz, loc) - \
k3d/share/shaders/k3d_shifteddrtile.sl:35:	smoothstep (b-fuzz, b+fuzz, loc) )
k3d/share/shaders/k3d_shifteddrtile.sl:52:	uniform float fuzz = .025;          /* amount to blur edge */
k3d/share/shaders/k3d_shifteddrtile.sl:69:	Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_shifteddrtile.sl:91:		mix_opacity = smoothPulse (innerRadius, outerRadius, fuzz, d);
k3d/share/shaders/k3d_shifteddrtile.sl:94:		mix_opacity = 1 - smoothstep (outerRadius-fuzz, outerRadius+fuzz, d);
k3d/share/shaders/k3d_shifteddrtile.sl:101:	      specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_shiftedmoontile.sl:10: *	fuzz -      Amount to blur edge
k3d/share/shaders/k3d_shiftedmoontile.sl:28:#define smoothPulse(a, b, fuzz, loc) \
k3d/share/shaders/k3d_shiftedmoontile.sl:29:	(smoothstep (a-fuzz, a+fuzz, loc) - \
k3d/share/shaders/k3d_shiftedmoontile.sl:30:	smoothstep (b-fuzz, b+fuzz, loc) )
k3d/share/shaders/k3d_shiftedmoontile.sl:49:	uniform float fuzz = .02;
k3d/share/shaders/k3d_shiftedmoontile.sl:66:	Nf = faceforward (normalize(N),I);
k3d/share/shaders/k3d_shiftedmoontile.sl:82:	circle1 = 1 - smoothstep (radius - fuzz, radius + fuzz, d);
k3d/share/shaders/k3d_shiftedmoontile.sl:83:	circle2 = 1 - smoothstep (radius - fuzz, radius + fuzz, d2);
k3d/share/shaders/k3d_shiftedmoontile.sl:89:	      specularcolor * Ks*specular(Nf,-normalize(I),roughness));
k3d/share/shaders/k3d_shiny.sl:10: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shiny.sl:12: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shiny.sl:17: * Author: Larry Gritz (gritzl@acm.org).
k3d/share/shaders/k3d_shiny.sl:21: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_shiny.sl:37:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_shinymetal.sl:18:  V = normalize(I);
k3d/share/shaders/k3d_shinymetal.sl:19:  Nf = faceforward(normalize(N), V);
k3d/share/shaders/k3d_shinyplastic.sl:11: *    twosided - if nonzero both sides of the surface are shiny, otherwise
k3d/share/shaders/k3d_shinyplastic.sl:13: *        spawn rays.  This can be an important optimization, especially
k3d/share/shaders/k3d_shinyplastic.sl:18: * Author: Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_shinyplastic.sl:33:  normal Nf = faceforward(normalize(N), I);
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:78:      vector LN = normalize (L);
k3d/share/shaders/k3d_skin1.sl:81:    vector H = normalize (V + LN);
k3d/share/shaders/k3d_skin1.sl:101:   an asymmetry value g.  v1 and v2 should be normalized and g should 
k3d/share/shaders/k3d_skin1.sl:130:    return normalize(T);
k3d/share/shaders/k3d_skin1.sl:146:      vector Ln = normalize(L);
k3d/share/shaders/k3d_skin1.sl:148:      vector H = normalize(Ln + Vf);
k3d/share/shaders/k3d_skin1.sl:194:  /* initialize local variables*/
k3d/share/shaders/k3d_skin1.sl:197:  vector Vf = -normalize(I);
k3d/share/shaders/k3d_skin1.sl:220:  NN = calculatenormal(P + turb * normalize(N));
k3d/share/shaders/k3d_skin1.sl:221:  Nf = faceforward(normalize(NN),I);
k3d/share/shaders/k3d_skin2.sl:20:   an asymmetry value g.  v1 and v2 should be normalized and g should 
k3d/share/shaders/k3d_skin2.sl:50:    return normalize(T);
k3d/share/shaders/k3d_skin2.sl:72:	    vector Ln = normalize(L);
k3d/share/shaders/k3d_skin2.sl:74:	    vector H = normalize(Ln + Vf);
k3d/share/shaders/k3d_skin2.sl:94:	normal Nn = faceforward(normalize(N), I);
k3d/share/shaders/k3d_skin2.sl:95:	vector Vf = -normalize(I);
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:28:	color sky_zenith = color (0.125, 0.162, 0.5);
k3d/share/shaders/k3d_skymetal.sl:29:	color sky_horiz = color (.4, .45, .8);
k3d/share/shaders/k3d_skymetal.sl:30:	color land_horiz = color (.0281, 0.0287, 0.0220);
k3d/share/shaders/k3d_skymetal.sl:31:	color land_zenith = color (0, 0, 0);
k3d/share/shaders/k3d_skymetal.sl:33:	Nf = normalize (faceforward (N, I));
k3d/share/shaders/k3d_skymetal.sl:35:	costheta = normalize (reflect (I, Nf)) . up;
k3d/share/shaders/k3d_skymetal.sl:38:		refl = mix (sky_horiz, sky_zenith, costheta);
k3d/share/shaders/k3d_skymetal.sl:40:		refl = mix (land_horiz, land_zenith, -costheta);
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:82:	normal Nf = normalize(faceforward(N,I));
k3d/share/shaders/k3d_slateroof.sl:199:	Ci = Ct * (Ka * ambient() + Kd * diffuse(faceforward( normalize(N), I )));
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: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:69:	normal Nf = normalize(N);
k3d/share/shaders/k3d_slideprojector.sl:9:  uniform vector Z = normalize(to - from);
k3d/share/shaders/k3d_slideprojector.sl:11:  uniform vector Y = normalize(X ^ Z);
k3d/share/shaders/k3d_slideprojector.sl:12:  X = normalize(Y ^ Z);
k3d/share/shaders/k3d_smoke.sl:5: *    This is a volume shader for smoke.  Trapezoidal integration is
k3d/share/shaders/k3d_smoke.sl:15: *   stepsize - step size for integration
k3d/share/shaders/k3d_smoke.sl:22: * Author: Larry Gritz
k3d/share/shaders/k3d_smoke.sl:37:		  float stepsize;
k3d/share/shaders/k3d_smoke.sl:54:      /* Optimize: one octave only if not lit */
k3d/share/shaders/k3d_smoke.sl:57:	  0.5 * fBm(Psmoke * 2, stepsize * 2, smokeoctaves - 1, 2, 0.5);
k3d/share/shaders/k3d_smoke.sl:79:		 float stepsize = 0.1, maxsteps = 100;
k3d/share/shaders/k3d_smoke.sl:89:  float d = integstart + random() * stepsize;
k3d/share/shaders/k3d_smoke.sl:90:  vector IN = normalize(vtransform("shader", I));
k3d/share/shaders/k3d_smoke.sl:93:  /* Calculate a reasonable step size */
k3d/share/shaders/k3d_smoke.sl:95:  float ss = min(stepsize, end - d);
k3d/share/shaders/k3d_smoke2.sl:6: *    This is a volume shader for smoke.  Trapezoidal integration is
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:16: *   use_noise - makes the smoke noisy (nonuniform) when nonzero
k3d/share/shaders/k3d_smoke2.sl:19: *   debug - if nonzero, copious output will be sent to stderr.
k3d/share/shaders/k3d_smoke2.sl:21: * Author: Larry Gritz
k3d/share/shaders/k3d_smoke2.sl:59:             /* Optimize: one octave only if not lit */                     \
k3d/share/shaders/k3d_smoke2.sl:79:	    float stepsize = 0.1;
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:117:      ss = min (stepsize, end-d);
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:130:    if (sign(zcomp(Pb1)) == sign(zcomp(Vlight))) {
k3d/share/shaders/k3d_softboxes.sl:132:    } else if (abs(zv) < 0.0001) {
k3d/share/shaders/k3d_softboxes.sl:307:    normal Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_softboxes.sl:410:		varying vector Rs = normalize (vtransform (theEnvSpace, normalize(-L)));
k3d/share/shaders/k3d_softboxes.sl:419:		    Rs = vector (-zcomp (Rs), xcomp (Rs), ycomp (Rs));
k3d/share/shaders/k3d_softboxes.sl:455:	    varying vector Ln = normalize(L);
k3d/share/shaders/k3d_softboxes.sl:456:	    varying vector Nn = normalize(N);
k3d/share/shaders/k3d_softboxes.sl:457:	    varying vector In = normalize(I);
k3d/share/shaders/k3d_spacecloud.sl:13: *   fuzz -- amount to blur the edges of the pulse
k3d/share/shaders/k3d_spacecloud.sl:42:/* separate fuzzes */
k3d/share/shaders/k3d_spacecloud.sl:43:#define smoothPulse2Fuzz(a, b, afuzz, bfuzz, loc) \
k3d/share/shaders/k3d_spacecloud.sl:44:  (smoothstep (a-afuzz, a, loc) - \
k3d/share/shaders/k3d_spacecloud.sl:45:   smoothstep (b, b+bfuzz, loc) )
k3d/share/shaders/k3d_spacecloud.sl:51:  float afuzz = .1;
k3d/share/shaders/k3d_spacecloud.sl:52:  float bfuzz = .2;
k3d/share/shaders/k3d_spacecloud.sl:62:  float freq, i, size;
k3d/share/shaders/k3d_spacecloud.sl:82:	fBm (P, noiseScale, octaves, PP, freq, i, size, adjust);
k3d/share/shaders/k3d_spacecloud.sl:92:	Oi = value * smoothPulse2Fuzz (startPulse, endPulse, afuzz, afuzz, ss) * 
k3d/share/shaders/k3d_spacecloud.sl:93:		smoothPulse2Fuzz (startPulse, endPulse, bfuzz, afuzz, tt);
k3d/share/shaders/k3d_spaceshiphull1.sl:50:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_spaceshiphull1.sl:51:  V = normalize(-I);
k3d/share/shaders/k3d_spotlight.sl:18:  uniform vector A = normalize(to - from);
k3d/share/shaders/k3d_square_ridges.sl:66:	vector Nn = normalize(N);
k3d/share/shaders/k3d_srfdeformation.sl:15:   additional contrast and color controls are left as an exersize
k3d/share/shaders/k3d_srfdeformation.sl:29:    Nn = normalize(N);
k3d/share/shaders/k3d_srfdeformation.sl:30:    Ln = normalize(L);
k3d/share/shaders/k3d_srfdeformation.sl:75:    N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_srfdeformation.sl:76:    N1 = faceforward(normalize(N),I);
k3d/share/shaders/k3d_srfdeformation.sl:77:    N = normalize(calculatenormal(Porig));
k3d/share/shaders/k3d_srfdeformation.sl:78:    N2 = faceforward(normalize(N),I);
k3d/share/shaders/k3d_star.sl:26:    point Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_star.sl:45:    in_out = step(0, zcomp(d0^d1));
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: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:24:	float inside_star = 1 - smoothstep(0.0, size, star_distance);
k3d/share/shaders/k3d_stones.sl:11: * Shader that creates a surface covered with stones of different sizes,
k3d/share/shaders/k3d_stones.sl:46:#define fuzzpulse(a,b,fuzz,x) (smoothstep((a)-(fuzz),(a),(x)) - \
k3d/share/shaders/k3d_stones.sl:47:         smoothstep((b)-(fuzz),(b),(x)))
k3d/share/shaders/k3d_stones.sl:61: * Original by Larry Gritz. Modified to "hsv" by Rudy Cortes
k3d/share/shaders/k3d_stones.sl:115:   angle = PI * snoise(freq * 16.31456);  /*randomize angle index*/
k3d/share/shaders/k3d_stones.sl:117:   rotate2d(s,t,angle,0.5,0.5,cx,cy);    /*randomize rotations*/
k3d/share/shaders/k3d_stones.sl:177:  P += Km * surface_mag * normalize(N);
k3d/share/shaders/k3d_stones.sl:178:  N = normalize(calculatenormal(P)); 
k3d/share/shaders/k3d_stones.sl:181:  N = normalize(calculatenormal(P + Km * surface_mag * normalize(N)));
k3d/share/shaders/k3d_stones.sl:184:  Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_stones.sl:185:  V = - normalize(I);
k3d/share/shaders/k3d_strata.sl:10: *    zscale - scaling for the thickness of the layers
k3d/share/shaders/k3d_strata.sl:12: *    offset - z offset for the pattern
k3d/share/shaders/k3d_strata.sl:21: *    Translation to Shading Language by Larry Gritz.
k3d/share/shaders/k3d_strata.sl:30: *    Apr 94 - translation to Shading Language by L. Gritz
k3d/share/shaders/k3d_strata.sl:85:    Cs * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_stucco.sl:13: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
k3d/share/shaders/k3d_stucco.sl:24:  P += magnitude * normalize(N);
k3d/share/shaders/k3d_superplank.sl:39: * Author: written by Larry Gritz
k3d/share/shaders/k3d_superplank.sl:40: *          current contact address: gritzl@acm.org
k3d/share/shaders/k3d_superplank.sl:104:  vector IN;			/* normalized I vector */
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:120:   * Determine the basic mapping, filter sizes for antialiasing, other
k3d/share/shaders/k3d_superplank.sl:127:  /* Compute the basic filter size for antialiasing */
k3d/share/shaders/k3d_superplank.sl:187:  /* compute half width & length of groove as fraction of plank size */
k3d/share/shaders/k3d_superplank.sl:279:      NN = normalize(N);
k3d/share/shaders/k3d_superplank.sl:290:   * using the fresnel formula (grazing angles reflect like mirrors).
k3d/share/shaders/k3d_superplank.sl:294:  IN = normalize(I);
k3d/share/shaders/k3d_superplank.sl:296:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_superplank.sl:306:	vector H = normalize(normalize(L) + V);
k3d/share/shaders/k3d_superpplastic.sl:18:/* Modified to support filter type and aize, amount of image blur, nuber samples
k3d/share/shaders/k3d_superpplastic.sl:53:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_superpplastic.sl:54:  V = -normalize(I);
k3d/share/shaders/k3d_supertexmap.sl:22: * Author: Larry Gritz (gritzl@acm.org)
k3d/share/shaders/k3d_supertexmap.sl:26: *   by Anthony A. Apodaca and Larry Gritz, Morgan Kaufmann, 1999.
k3d/share/shaders/k3d_supertexmap.sl:99:      N = Displace(normalize(N), dispspace, disp, truedisp);
k3d/share/shaders/k3d_supertexmap.sl:103:  normal Nf = faceforward(normalize(N), I);
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:39:    normal Nf = normalize(N);

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

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

k3d/share/shaders/k3d_terran.sl:45:  PtN = normalize(Ptexture);	/* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran.sl:103:  /*  "nonlinear" scales purturbation-by-z */
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:175:    Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_terran2.sl:24: *    multifractal - zero uses fBm noise, nonzero uses multifractal
k3d/share/shaders/k3d_terran2.sl:40: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_terran2.sl:47: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_terran2.sl:55: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_terran2.sl:108:  PtN = normalize (Ptexture);      /* Version of Ptexture with radius 1 */
k3d/share/shaders/k3d_terran2.sl:155:  latitude = abs (zcomp (PtN));
k3d/share/shaders/k3d_terran2.sl:158:  /*  "nonlinear" scales purturbation-by-z */
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:229:  Ci = Os * Ct * (Ka * ambient() + Kd * diffuse(faceforward(normalize(N),I)));
k3d/share/shaders/k3d_terranbump.sl:68:    P += (bump_scale * bumpy) * normalize(Ng);
k3d/share/shaders/k3d_texblender.sl:17:     + Ks*specular(Nf,-normalize(I),roughness);
k3d/share/shaders/k3d_texblender.sl:46:	x+=abs(zcomp(p));
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:85:    PQ = point (xcomp(PP)*128+5, zcomp(PP)*8-3, ycomp(PP)*128+1);
k3d/share/shaders/k3d_texblender.sl:92:		float scalex, scaley, scalez, octaves, blur;)
k3d/share/shaders/k3d_texblender.sl:97:	transp=transform(space,P)*vector (scalex, scaley, scalez);
k3d/share/shaders/k3d_texblender.sl:146:		float Sgmx[5]={1,1,1,1,1},Sgmy[5]={1,1,1,1,1},Sgmz[5]={1,1,1,1,1};
k3d/share/shaders/k3d_texblender.sl:161:    normal Nf =normalize( faceforward(normalize(N),I));
k3d/share/shaders/k3d_texblender.sl:162:    dispDir=normalize( faceforward(normalize(Ng),I));
k3d/share/shaders/k3d_texblender.sl:168:		color MC=colorMap(Gmapname[i],Gspace[i],Sgmx[i],Sgmy[i],Sgmz[i],
k3d/share/shaders/k3d_texblender.sl:185:			ndir=normalize(corr+Displace(dispDir,"shader",disp,0));
k3d/share/shaders/k3d_texblender.sl:186:			ndir=normalize(ndir-(Nf*(ndir.Nf)));
k3d/share/shaders/k3d_texblender.sl:187:			ndir=normalize(Nf+ndir);
k3d/share/shaders/k3d_texblender.sl:188:			ndir=normalize(ndir-(Nf*(ndir.Nf)));
k3d/share/shaders/k3d_texblender.sl:189:			Nf+=disp*(normalize(ndir));
k3d/share/shaders/k3d_texblender.sl:190:			Nf=normalize(Nf);
k3d/share/shaders/k3d_texblender.sl:195:	V = normalize(I);
k3d/share/shaders/k3d_texblender.sl:200:		env=myEnvironment(P,normalize(reflect(V,Nf)),1,Rblur,ENVPARAMS);
k3d/share/shaders/k3d_threads.sl:14:		dampzone	=  .05 )
k3d/share/shaders/k3d_threads.sl:22:	if( t > (1-dampzone)) 
k3d/share/shaders/k3d_threads.sl:23:		magnitude *= (1.0-t) / dampzone;
k3d/share/shaders/k3d_threads.sl:24:	else if( t < dampzone )
k3d/share/shaders/k3d_threads.sl:25:		magnitude *= t / dampzone;
k3d/share/shaders/k3d_threads.sl:28:	P += normalize(N) * magnitude;
k3d/share/shaders/k3d_tooledsteel.sl:17: *  Nzscale 		- scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_tooledsteel.sl:18: *          		  the swirls. set this to zero for a perfect grid.
k3d/share/shaders/k3d_tooledsteel.sl:36:getvec(float  mult; float Nzscale)
k3d/share/shaders/k3d_tooledsteel.sl:54:  point trucell, surrcell, nzcell;
k3d/share/shaders/k3d_tooledsteel.sl:55:  vector offset, nzoff, out;
k3d/share/shaders/k3d_tooledsteel.sl:59:  float cellsize = 1/ncells;
k3d/share/shaders/k3d_tooledsteel.sl:63:  setzcomp(trucell,0);
k3d/share/shaders/k3d_tooledsteel.sl:71:	nzoff = ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_tooledsteel.sl:72:	setzcomp(nzoff,0);
k3d/share/shaders/k3d_tooledsteel.sl:73:	nzcell = surrcell + nzoff;
k3d/share/shaders/k3d_tooledsteel.sl:74:	dist = distance(Po,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:77:	  valu = distance(Pou,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:78:	  valv = distance(Pov,nzcell);
k3d/share/shaders/k3d_tooledsteel.sl:84:  out  = normalize((udir*chu)+(vdir*chv));
k3d/share/shaders/k3d_tooledsteel.sl:97:    vector V = normalize(-I);
k3d/share/shaders/k3d_tooledsteel.sl:98:    normal NN = normalize(N);
k3d/share/shaders/k3d_tooledsteel.sl:101:    point zro = 0;
k3d/share/shaders/k3d_tooledsteel.sl:110:            vector LN = normalize (L);
k3d/share/shaders/k3d_tooledsteel.sl:111:	    vector H = normalize (V + LN);
k3d/share/shaders/k3d_tooledsteel.sl:124:		Nzscale		=  1.5,
k3d/share/shaders/k3d_tooledsteel.sl:136:        vector VA = getvec(mult,Nzscale);
k3d/share/shaders/k3d_tooledsteel.sl:139:	vector D, V= normalize(-I);
k3d/share/shaders/k3d_tooledsteel.sl:141:        point zro = 0;
k3d/share/shaders/k3d_tooledsteel.sl:146:	VA = rotate(VA, twist, zro, normalize(N));
k3d/share/shaders/k3d_tooledsteel.sl:149:	Nf = faceforward(normalize(N), -I);
k3d/share/shaders/k3d_tooledsteel.sl:156:	      Ntmp = rotate(Nf,angle+jitter,zro,VA);
k3d/share/shaders/k3d_toonmap.sl:27:float paint_fuzz=0.274; 
k3d/share/shaders/k3d_toonmap.sl:29:float ink_fuzz=0.765; 
k3d/share/shaders/k3d_toonmap.sl:114:H = normalize(normalize(L)+V);
k3d/share/shaders/k3d_toonmap.sl:128:Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_toonmap.sl:129:normI = normalize(I);
k3d/share/shaders/k3d_toonmap.sl:140:diff += normalize(L).Nf; 
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:146:spec = toonspec(Nf, -normalize(I), roughness);
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:157:cos_here = normalize(Nf).normI;
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_translucency.sl:71:	normal Nf = faceforward(normalize(N),I);
k3d/share/shaders/k3d_translucency.sl:72:	vector V = -normalize(I);
k3d/share/shaders/k3d_translucency.sl:118:		ln = normalize(L);
k3d/share/shaders/k3d_uberlight.sl:5: *   Based on Ronen Barzel's paper "Lighting Controls for Computer
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:23: *       those that point in a particular direction (+z in local light
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:47: *       from a single point (i.e., the rays diverge).  When nonzero, 
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:61: *   wedge, hedge - the amount of width and height edge fuzz,
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:128: *   blockerwedge, blockerhedge - define the fuzzyness of the edges.
k3d/share/shaders/k3d_uberlight.sl:185: * (co-chaired by Tony Apodaca and Larry Gritz).  Feel free to use and
k3d/share/shaders/k3d_uberlight.sl:199: * Author: coded by Larry Gritz, 1998
k3d/share/shaders/k3d_uberlight.sl:200: *         based on paper by Ronen Barzel, 1997
k3d/share/shaders/k3d_uberlight.sl:271: *   - all information about the light shaping, including z smooth depth
k3d/share/shaders/k3d_uberlight.sl:279:		       float znear, zfar;	/* z clipping */
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:294:  float Pz;
k3d/share/shaders/k3d_uberlight.sl:297:      Pz = zcomp(PL);
k3d/share/shaders/k3d_uberlight.sl:302:      Pz = PLlen;
k3d/share/shaders/k3d_uberlight.sl:304:  atten *= smoothstep(znear - nearedge, znear, Pz);
k3d/share/shaders/k3d_uberlight.sl:305:  atten *= 1 - smoothstep(zfar, zfar + faredge, Pz);
k3d/share/shaders/k3d_uberlight.sl:324:    atten *= pow(zcomp(normalize(vector PL)), beamdistribution);
k3d/share/shaders/k3d_uberlight.sl:328:	1 - clipSuperellipse(PL / Pz - point(shearx, sheary, 0), width,
k3d/share/shaders/k3d_uberlight.sl:354:  if(zcomp(Pb2) * zcomp(Pb1) < 0)
k3d/share/shaders/k3d_uberlight.sl:357:      point Pplane = Pb1 - Vlight * (zcomp(Pb1) / zcomp(Vlight));
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:419:   * origin and z-axis of shader space.
k3d/share/shaders/k3d_uberlight.sl:422:  vector axis = normalize(N);
k3d/share/shaders/k3d_uberlight.sl:426:  vector axis = normalize(vector "shader"(0, 0, 1));
k3d/share/shaders/k3d_uberlight.sl:467:	float zslide = zcomp(Pslide);
k3d/share/shaders/k3d_uberlight.sl:468:	float xslide = 0.5 + 0.5 * xcomp(Pslide) / zslide;
k3d/share/shaders/k3d_uberlight.sl:469:	float yslide = 0.5 - 0.5 * ycomp(Pslide) / zslide;
k3d/share/shaders/k3d_urbermap.sl:160:Nf = normalize( ntransform("shader", N) );
k3d/share/shaders/k3d_urbermap.sl:166:normal deltaN = normalize(N) - normalize(Ng);
k3d/share/shaders/k3d_urbermap.sl:167:Nf = normalize(Nf) + deltaN;
k3d/share/shaders/k3d_urbermap.sl:179:Nf = faceforward( normalize(Nf), I );
k3d/share/shaders/k3d_urbermap.sl:180:V = -normalize(I);
k3d/share/shaders/k3d_urbermap.sl:189:D = vector(-zcomp(D), xcomp(D), ycomp(D));
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:20: *         email: gritz@seas.gwu.edu
k3d/share/shaders/k3d_veinedmarble.sl:24: * last modified  29 Jun 1994 by Larry Gritz
k3d/share/shaders/k3d_veinedmarble.sl:70:  normal Nf = faceforward(normalize(N), I);
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:28: *			"edginess" parameter to control horizon scatter;
k3d/share/shaders/k3d_velvet.sl:46:  normal Nf;                     /* Normalized normal vector */
k3d/share/shaders/k3d_velvet.sl:47:  vector V;                      /* Normalized eye vector */
k3d/share/shaders/k3d_velvet.sl:49:  vector Ln;                     /* Normalized vector to light */
k3d/share/shaders/k3d_velvet.sl:51:  float cosine, sine;            /* Components for horizon scatter */
k3d/share/shaders/k3d_velvet.sl:53:  Nf = faceforward (normalize(N), I);
k3d/share/shaders/k3d_velvet.sl:54:  V = -normalize (I);
k3d/share/shaders/k3d_velvet.sl:58:    Ln = normalize ( L );
k3d/share/shaders/k3d_velvet.sl:63:    /* Horizon scattering */
k3d/share/shaders/k3d_venus.sl:25: *    to this shader will need to be altered if the size of your planet
k3d/share/shaders/k3d_venus.sl:30: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus.sl:41: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus.sl:60:  point PtN;			/* normalized version of Ptexture */
k3d/share/shaders/k3d_venus.sl:72:  PtN = normalize(Ptexture);
k3d/share/shaders/k3d_venus.sl:79:	  xcomp(Ptexture) * sine + ycomp(Ptexture) * cosine, zcomp(Ptexture));
k3d/share/shaders/k3d_venus.sl:98:			 Kd * diffuse(faceforward(normalize(N), I)));
k3d/share/shaders/k3d_venus2.sl:26: *    Conversion to Shading Language and minor modifications by Larry Gritz.
k3d/share/shaders/k3d_venus2.sl:37: *    Feb 1994 - Conversion to Shading Language by L. Gritz
k3d/share/shaders/k3d_venus2.sl:62:  point PtN;                /* normalized version of Ptexture */
k3d/share/shaders/k3d_venus2.sl:74:  PtN = normalize (Ptexture);
k3d/share/shaders/k3d_venus2.sl:81:	      zcomp(Ptexture));
k3d/share/shaders/k3d_venus2.sl:96:			    Kd * diffuse(faceforward(normalize(N),I)));
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:43:    IN = normalize(I);
k3d/share/shaders/k3d_volcube.sl:44:    NN = normalize(N);
k3d/share/shaders/k3d_volcube.sl:48:    /*plane_z_min*/
k3d/share/shaders/k3d_volcube.sl:56:    /*plane_z_max*/
k3d/share/shaders/k3d_volcube.sl:133:				    zcomp(Pos)),vol_mult,vol_offset) - dens,
k3d/share/shaders/k3d_volcube.sl:135:				    ycomp(Pos) - epsilon, zcomp(Pos)),vol_mult,vol_offset) - dens,
k3d/share/shaders/k3d_volcube.sl:137:				    ycomp(Pos), zcomp(Pos) - epsilon),vol_mult,vol_offset) - dens);
k3d/share/shaders/k3d_volcube.sl:159:	diff += Cl * max(0,normalize(L).Nf);
k3d/share/shaders/k3d_volcube.sl:173:    normal NN1 = normalize(N1);
k3d/share/shaders/k3d_volcube.sl:174:    normal NN2 = normalize(N2);
k3d/share/shaders/k3d_volcube.sl:178:    result = normalize(NN1 * N1_mag + NN2 * N2_mag);
k3d/share/shaders/k3d_volcube.sl:187:k3d_volcube(float  StepSize       = 1;
k3d/share/shaders/k3d_volcube.sl:202:    vector V  = normalize(-I);
k3d/share/shaders/k3d_volcube.sl:203:    normal Nf = normalize(N);
k3d/share/shaders/k3d_volcube.sl:208:    float  numOfSteps   = vol_length/StepSize;
k3d/share/shaders/k3d_volcube.sl:218:    float  density      = StepSize * Density;
k3d/share/shaders/k3d_volcube.sl:247:		    Vol_Nf = normalize(Vol_Nf);
k3d/share/shaders/k3d_volcube.sl:298:	cur_depth += StepSize;
k3d/share/shaders/k3d_wallpaper.sl:63:                in_out += step(0, zcomp(d0^d1));
k3d/share/shaders/k3d_wallpaper.sl:70:    Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_wallpaper_2stripe.sl:20: * AUTHOR: written by Larry Gritz (email: lg@bmrt.org)
k3d/share/shaders/k3d_wallpaper_2stripe.sl:45:  normal Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_warningstripes.sl:54:	vector Nf = normalize(faceforward(N, I));
k3d/share/shaders/k3d_water.sl:27: * last modified 25 Jan 1994 by Larry Gritz

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

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

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

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

k3d/share/shaders/k3d_water.sl:56:    IN = normalize (I);

k3d/share/shaders/k3d_water.sl:62:	Rdir = normalize (reflect (IN, Nf));

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

k3d/share/shaders/k3d_water.sl:66:					        xcomp(Rdir) - zcomp(Rdir),

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

k3d/share/shaders/k3d_water.sl:88:    /* I added some current.  Note, it doesn't apppear horizontally. */

k3d/share/shaders/k3d_water.sl:93:    float fuzz = 0.025;

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

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

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

k3d/share/shaders/k3d_waterdisplacement.sl:19:	norm = normalize (N);

k3d/share/shaders/k3d_windowlight.sl:14: *   hpanes, vpanes - number of horizontal and vertical panes
k3d/share/shaders/k3d_windowlight.sl:16: *   fuzz - controls the fading out near the edges
k3d/share/shaders/k3d_windowlight.sl:20: * Author:  Larry Gritz, with inspiration from [Upstill]
k3d/share/shaders/k3d_windowlight.sl:39:		      float fuzz = 0.25;
k3d/share/shaders/k3d_windowlight.sl:48:  path = normalize(from - to);
k3d/share/shaders/k3d_windowlight.sl:49:  inv = normalize(in);
k3d/share/shaders/k3d_windowlight.sl:51:  upv = normalize(inv ^ right);
k3d/share/shaders/k3d_windowlight.sl:66:			modulus, fuzz);
k3d/share/shaders/k3d_windowlight.sl:77:			fuzz);
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:14: * AUTHOR: written by Larry Gritz (lg@bmrt.org)
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:48:  PQ = point(xcomp(PP) * 128 + 5, zcomp(PP) * 8 - 3, ycomp(PP) * 128 + 1);
k3d/share/shaders/k3d_wood2.sl:57:  Nf = faceforward(normalize(N), I);
k3d/share/shaders/k3d_wood2.sl:61:	  specularcolor * Ks * specular(Nf, -normalize(I), roughness));
k3d/share/shaders/k3d_woodcut.sl:8:float nsize=5; ) { 
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:15:float fuzz = 0.3;
k3d/share/shaders/k3d_woodcut.sl:17:float y, z, i, n, ns;
k3d/share/shaders/k3d_woodcut.sl:31:Nf = faceforward( normalize(N), I );
k3d/share/shaders/k3d_woodcut.sl:32:V = -normalize(I); 
k3d/share/shaders/k3d_woodcut.sl:34:if (up == "z") { 
k3d/share/shaders/k3d_woodcut.sl:35:z = zcomp(Psh);
k3d/share/shaders/k3d_woodcut.sl:36:z *= ringscale;
k3d/share/shaders/k3d_woodcut.sl:37:tt = mod(z,1);
k3d/share/shaders/k3d_woodcut.sl:49:ns = nsize;
k3d/share/shaders/k3d_woodcut.sl:76:float val = pulse(stripemin, stripemax, fuzz, tt);
k3d/share/shaders/k3d_woodcut.sl:87: float spacescale = length(vtransform("shader", normalize(N)));
k3d/share/shaders/k3d_woodcut.sl:88: vector Ndisp = normalize(N) * (0 / max(spacescale,1e-6));
k3d/share/shaders/k3d_woodcut.sl:90: N = normalize (calculatenormal (P + (1-0)*Ndisp)); 
