k3d/share/shaders/k3d_brick.sl:126:  N = calculatenormal(P);
k3d/share/shaders/k3d_brickbump.sl:80:  N = calculatenormal(P);
k3d/share/shaders/k3d_brickbump2.sl:62:    Nf = calculatenormal(P + normalize(N) * stbump);
k3d/share/shaders/k3d_brickbump3.sl:116:  N = calculatenormal (P);
k3d/share/shaders/k3d_bubbles.sl:27: N = calculatenormal(P);
k3d/share/shaders/k3d_bubbly.sl:61:  N = calculatenormal(P);
k3d/share/shaders/k3d_castucco.sl:33:  /* Do texture calcs in "shader" space, get approximate filter size */
k3d/share/shaders/k3d_celld.sl:24:	string PSpace = "shader";  /* desc {Space to transform P for shading calculations } */
k3d/share/shaders/k3d_celld.sl:52:	N = calculatenormal (P);
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:224:   * Here's the exciting part -- calculate the color of the spot we're
k3d/share/shaders/k3d_checkerboard.sl:18:	// Calculate our "filter zone" around the edges of each tile ...
k3d/share/shaders/k3d_checkerboard.sl:31:  // Calculate which tile we're in ...
k3d/share/shaders/k3d_contacshadow.sl:52:	/* the difference between the two distances is used to calculate the  
k3d/share/shaders/k3d_corktile.sl:107:	/* Calculate color of gap between tiles */
k3d/share/shaders/k3d_corktile.sl:115:	Nf = faceforward(calculatenormal(P + disp *	normalize(N)), I);
k3d/share/shaders/k3d_craters.sl:33:    float sctr, tctr, scell, tcell,scellctr,tcellctr;
k3d/share/shaders/k3d_craters.sl:46:	scellctr = floor(s*sc/swidth);
k3d/share/shaders/k3d_craters.sl:47:	tcellctr = floor(t*sc/swidth);
k3d/share/shaders/k3d_craters.sl:53:	    scell = scellctr + i;
k3d/share/shaders/k3d_craters.sl:56:		tcell = tcellctr + j;
k3d/share/shaders/k3d_craters.sl:110:    N = calculatenormal(P);	
k3d/share/shaders/k3d_crayon.sl:40:	/* calculate smallest integer f for which width / f < .5 */
k3d/share/shaders/k3d_dented.sl:45:	N = calculatenormal(P);
k3d/share/shaders/k3d_displacementmap.sl:11:  N1 = calculatenormal(P);
k3d/share/shaders/k3d_displacementmap.sl:13:  N2 = calculatenormal(P);
k3d/share/shaders/k3d_droop.sl:20:	N = calculatenormal(P);
k3d/share/shaders/k3d_dturb.sl:34:  N = calculatenormal(P);
k3d/share/shaders/k3d_emboss.sl:16:		N = calculatenormal(P);
k3d/share/shaders/k3d_eroded.sl:24:		/* Calculate a simple fractal 1/f noise function */
k3d/share/shaders/k3d_eroded.sl:32:	N = calculatenormal (P - magnitude * normalize(N));
k3d/share/shaders/k3d_eyeball.sl:14: *   eyeballcolor - color of the white part of the eyeball
k3d/share/shaders/k3d_eyeball.sl:16: *   pupilcolor - color of the pupil (opening)
k3d/share/shaders/k3d_eyeball.sl:51:	 color eyeballcolor = color(1,1,1);
k3d/share/shaders/k3d_eyeball.sl:53:	 color pupilcolor = 0;
k3d/share/shaders/k3d_eyeball.sl:73:  /* Calculate an appropriate filter width for antialiasing */
k3d/share/shaders/k3d_eyeball.sl:88:   * then calculate the veining pattern.  Otherwise, just use the color
k3d/share/shaders/k3d_eyeball.sl:103:      Cball = mix (eyeballcolor, bloodcolor, smoothstep(0,.75,displayed));
k3d/share/shaders/k3d_eyeball.sl:105:  else Cball = eyeballcolor;
k3d/share/shaders/k3d_eyeball.sl:108:  /* If we're somewhere in the iris, calculate the iris pattern, which is
k3d/share/shaders/k3d_eyeball.sl:120:  /* OK, now calculate a surface texture color (Ct) based on where we are
k3d/share/shaders/k3d_eyeball.sl:121:   * and what patterns we calculated.
k3d/share/shaders/k3d_eyeball.sl:124:  Ct = mix (pupilcolor, Ct, pupilstat);
k3d/share/shaders/k3d_eyeball.sl:130:  /* Now shade like plastic, but using our calculated surface color and
k3d/share/shaders/k3d_filament.sl:14:	/* Calculate the distance of (s,t) from a spiral as a fraction [0,1] */
k3d/share/shaders/k3d_fractal.sl:63:  	N = calculatenormal(P);	

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_fur1.sl:31:  N = calculatenormal(P);

k3d/share/shaders/k3d_fur2.sl:26:    /* diffuse calculation */
k3d/share/shaders/k3d_fur2.sl:125:	/* calculate diffuse component */
k3d/share/shaders/k3d_glass.sl:5: *   Makes semi-transparent glass, using ray tracing to calculate
k3d/share/shaders/k3d_gloop.sl:63:  N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_glow.sl:14:      // Calculate a "strength" function based on 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:68:   * First calculate the underlying color of the substrate
k3d/share/shaders/k3d_gmarbtile_polish.sl:80:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_gouge.sl:24:      N = calculatenormal(P);
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:232:	N_paint=normalize(calculatenormal(P_paint+(1-0)*Ndisp1));
k3d/share/shaders/k3d_graphic_lines.sl:304:	N_ink=normalize(calculatenormal(P_ink+(1-0)*Ndisp2));
k3d/share/shaders/k3d_grass_displace.sl:63:  N = calculatenormal(P);

k3d/share/shaders/k3d_greenmarble.sl:42:   * First calculate the underlying color of the substrate
k3d/share/shaders/k3d_greenmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_grids_disp.sl:10: return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_hexatile_bump.sl:128:return normalize (calculatenormal (P + (1-truedisp)*Ndisp));
k3d/share/shaders/k3d_leather.sl:180:	newP = calculatenormal(P + disp * normalize(N));

k3d/share/shaders/k3d_luna.sl:182:  /* Recalc normal since we changed P a whole bunch. */
k3d/share/shaders/k3d_luna.sl:183:/*  N = normalize (calculatenormal (PQ)); */
k3d/share/shaders/k3d_lunette.sl:13: *   name, anyway.  The pattern is calculated in 2D u,v coordinates.
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:62: *   colorBenhance - After the noise has been calculated, there exists the
k3d/share/shaders/k3d_lunette.sl:91:	 * Calculate pulsegrid, which is a variable indicating the value of
k3d/share/shaders/k3d_mondometal.sl:183:        Nf = calculatenormal(PP);

k3d/share/shaders/k3d_oakplank.sl:90:  /* Calculate our "in-plank" value by multiplying two perpendicular
k3d/share/shaders/k3d_orange.sl:44:	newP = calculatenormal (P + turb * normalize (N));
k3d/share/shaders/k3d_redapple.sl:18: * Look out for the "txtscale" parameter: some noise calculations are
k3d/share/shaders/k3d_redapple.sl:203:	newP = calculatenormal(P + disp * normalize(N));
k3d/share/shaders/k3d_ridged_multifractal.sl:63:  	N = calculatenormal(P);	

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

k3d/share/shaders/k3d_round.sl:61:	N = calculatenormal(P);
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:78:// calculates if it's inside the circle. If it is, the colour
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_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
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:88:  /* If we have any metal, calculate the color of the metal, using the
k3d/share/shaders/k3d_scartissue.sl:31:	N = calculatenormal(P);
k3d/share/shaders/k3d_skin1.sl:198:  color sc , lc;
k3d/share/shaders/k3d_skin1.sl:220:  NN = calculatenormal(P + turb * normalize(N));
k3d/share/shaders/k3d_skin1.sl:264:  lc =  subsurfaceSkin(Vf, Nf, blemishcol, Csheen, 1/eta, thickness);
k3d/share/shaders/k3d_skin1.sl:270:  sc = mix (sc,lc,lo);
k3d/share/shaders/k3d_skin1.sl:283:  lc = LocIllumWardAnisotropic(Nf,Vf,anisoDir,xroughness,yroughness);
k3d/share/shaders/k3d_skin1.sl:288:  sc += (lc * (oilVal * 0.1) );
k3d/share/shaders/k3d_slateroof.sl:40:	calculations in this shader. Renderdc, however, does not yet support
k3d/share/shaders/k3d_slateroof.sl:68:			newstile, newscoord, 				/* Used in calculations to identify an 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:114:	/* now calculate the displacement */
k3d/share/shaders/k3d_slateroof.sl:147:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroof.sl:167:	/* calculate the displacement again */
k3d/share/shaders/k3d_slateroofd.sl:35:		considering with one calculated for the tile above, being a little
k3d/share/shaders/k3d_slateroofd.sl:60:			newstile, newscoord, 				/* Used in calculations to identify an overlapping tile */
k3d/share/shaders/k3d_slateroofd.sl:105:	/* now calculate the displacement */
k3d/share/shaders/k3d_slateroofd.sl:139:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroofd.sl:156:			/* calculate the displacement again */
k3d/share/shaders/k3d_slateroofd.sl:178:   N = calculatenormal(P);
k3d/share/shaders/k3d_smoke.sl:93:  /* Calculate a reasonable step size */
k3d/share/shaders/k3d_softboxes.sl:205:#else /* !BMRT -- slc compiler doesn't like these definitions */
k3d/share/shaders/k3d_spaceshiphull1.sl:41:  // Calculate plate color
k3d/share/shaders/k3d_square_ridges.sl:69:	N = calculatenormal(P);
k3d/share/shaders/k3d_srfdeformation.sl:12:   additionally, calculates the changes to shading on the surface 
k3d/share/shaders/k3d_srfdeformation.sl:54:    float Kd=1;                 /* Surface Kd for lighting calculations */
k3d/share/shaders/k3d_srfdeformation.sl:73:    /* Calculate shading difference between P and Porig*/
k3d/share/shaders/k3d_srfdeformation.sl:75:    N = normalize(calculatenormal(P));
k3d/share/shaders/k3d_srfdeformation.sl:77:    N = normalize(calculatenormal(Porig));
k3d/share/shaders/k3d_srfdeformation.sl:82:    /* These lighting loops can be enhanced to calculate
k3d/share/shaders/k3d_starfield.sl:21:	// Calculate the distance to the nearest star ...
k3d/share/shaders/k3d_stones.sl:149:   /*calculate displacement if Km > .01*/
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_stucco.sl:25:  N = calculatenormal(P);
k3d/share/shaders/k3d_superplank.sl:282:      /* Recalculate N */
k3d/share/shaders/k3d_superplank.sl:283:      N = calculatenormal(P + (Km * shadlen * disp) * NN);
k3d/share/shaders/k3d_terran.sl:40:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terran2.sl:103:  float l, o, a, i, weight;      /* Loop variables for fBm calc */
k3d/share/shaders/k3d_terranbump.sl:25:  float l, o, a, i, weight;	/* Loop variables for fBm calc */
k3d/share/shaders/k3d_terranbump.sl:70:  /* Recalculate the surface normal (this is where all the real magic is!) */
k3d/share/shaders/k3d_terranbump.sl:71:  N = calculatenormal(P);
k3d/share/shaders/k3d_threads.sl:18:	/* Calculate the undamped displacement */
k3d/share/shaders/k3d_threads.sl:29:	N = calculatenormal(P);
k3d/share/shaders/k3d_uberlight.sl:452:    color lcol = lightcolor;
k3d/share/shaders/k3d_uberlight.sl:470:	lcol *= color texture(slidename, xslide, yslide);
k3d/share/shaders/k3d_uberlight.sl:518:	lcol = mix(shadowcolor, lcol, unoccluded);
k3d/share/shaders/k3d_uberlight.sl:521:    Cl = (atten * intensity) * lcol;
k3d/share/shaders/k3d_urbermap.sl:163:Nf = calculatenormal(PP);
k3d/share/shaders/k3d_veinedmarble.sl:55:  /* Now calculate the veining function for the lookup area */
k3d/share/shaders/k3d_venus.sl:62:  float rsq;			/* Used in calculation of twist */
k3d/share/shaders/k3d_venus.sl:71:  /* Calculate Coriolis twist, yielding point PP */
k3d/share/shaders/k3d_venus2.sl:64:  float rsq;                /* Used in calculation of twist */
k3d/share/shaders/k3d_venus2.sl:73:  /* Calculate Coriolis twist, yielding point PP */
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: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:187:k3d_volcube(float  StepSize       = 1;
k3d/share/shaders/k3d_volcube.sl:245:		    normal Vol_Nf = calcGradeNorm(Pcur_obj,Vol_Mult,Vol_Offset,
k3d/share/shaders/k3d_wallpaper.sl:30:    float scellctr, tcellctr;
k3d/share/shaders/k3d_wallpaper.sl:40:    scellctr = floor(s*NCELLS);
k3d/share/shaders/k3d_wallpaper.sl:41:    tcellctr = floor(t*NCELLS);
k3d/share/shaders/k3d_wallpaper.sl:46:	    scell = scellctr + i;
k3d/share/shaders/k3d_wallpaper.sl:47:	    tcell = tcellctr + j;
k3d/share/shaders/k3d_water.sl:13: *   Makes a smoothly polished metal, using ray tracing to calculate

k3d/share/shaders/k3d_water.sl:59:    /* Calculate the reflection color */

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

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

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

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

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

k3d/share/shaders/k3d_windywave.sl:28:  N = calculatenormal(P + wind * offset * normalize(N));
k3d/share/shaders/k3d_wood2.sl:35:  /* Calculate in shader space */
k3d/share/shaders/k3d_woodcut.sl:90: N = normalize (calculatenormal (P + (1-0)*Ndisp)); 
