k3d/share/shaders/k3d_bluemarble.sl:54:        marble += snoise(PP * f)/f;
k3d/share/shaders/k3d_brick.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brick.sl:69:    raggedamp * snoisexy((s + tbrick * 5.15) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:72:    raggedamp * snoisexy((s + tbrick * 11.4) * raggedfreq,
k3d/share/shaders/k3d_brick.sl:75:    raggedamp / 2 * snoisexy((s + tbrick * 5.15) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:78:    raggedamp / 2 * snoisexy((s + tbrick * 11.4) * raggedfreq * 2,
k3d/share/shaders/k3d_brick.sl:121:    pow(noise
k3d/share/shaders/k3d_brick.sl:131:  bcolor = brickcolor * (1 + (brickvary * snoise(whichbrick + 0.5)));
k3d/share/shaders/k3d_brick3.sl:52:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_brick3.sl:69:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brick3.sl:84:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brick3.sl:102:  bcolor = brickcolor * (1 + (brickvary * snoise (tbrick+(100*sbrick)+0.5)));
k3d/share/shaders/k3d_brickbump.sl:26:#include "k3d_noises.h"
k3d/share/shaders/k3d_brickbump.sl:75:    pow(noise
k3d/share/shaders/k3d_brickbump3.sl:62:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_brickbump3.sl:73:  PP2 = point noise (s/BMWIDTH, t/BMHEIGHT);
k3d/share/shaders/k3d_brickbump3.sl:86:  ss += rowvary * (noise (tbrick+0.5) - 0.5);
k3d/share/shaders/k3d_brickbump3.sl:112:  disp -= fact * pow(noise ((ss+sbrick)*pockfrequency/BMHEIGHT,
k3d/share/shaders/k3d_brickperturb.sl:47:    ss += 0.1 * snoise(tbrick+0.5);
k3d/share/shaders/k3d_bubbly.sl:8: *  siggraph proceedings from 1996, except this uses a noised grid of cells
k3d/share/shaders/k3d_bubbly.sl:19: *  Nzscale - scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_bubbly.sl:39:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_bubbly.sl:47:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_bubbly.sl:53:	nzcell = surrcell + ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_castucco.sl:19:#include "k3d_noises.h"
k3d/share/shaders/k3d_causticlight.sl:14:	       float  noiseamp = 0, noisefreq = 1, noisepow = 1;
k3d/share/shaders/k3d_causticlight.sl:29:	    if (noiseamp != 0) {
k3d/share/shaders/k3d_causticlight.sl:31:		caustic *= noiseamp * pow (noise(PL*noisefreq), noisepow);
k3d/share/shaders/k3d_celld.sl:4: * Simple displacement shader using Voronoi cell noise
k3d/share/shaders/k3d_celld.sl:5: * Uses noises.h from ARMAN
k3d/share/shaders/k3d_celld.sl:14:#include "k3d_noises.h"
k3d/share/shaders/k3d_celld.sl:31:	point noiseP = (usePref != 0)? transform (PSpace, __Pref): objP;
k3d/share/shaders/k3d_celld.sl:38:	voronoi_f1f2_3d (noiseP*voro_freq, voro_jitter, 
k3d/share/shaders/k3d_ceramictiles.sl:56:#include "k3d_noises.h"
k3d/share/shaders/k3d_ceramictiles.sl:99:      point noisep = mottlefreq * point(stile, ttile, tileindex);
k3d/share/shaders/k3d_ceramictiles.sl:101:	.2 + .6 * fBm(noisep, mottlefreq * max(ds, dt), 4, 2, 0.65);
k3d/share/shaders/k3d_ceramictiles.sl:121:      point noisep =
k3d/share/shaders/k3d_ceramictiles.sl:123:      float specky = filteredsnoise(noisep, speckfreq * dst);
k3d/share/shaders/k3d_ceramictiles.sl:220:  Ntile += 0.05 * (vector cellnoise(tileindex + 5) - 0.5);
k3d/share/shaders/k3d_corktile.sl:31:#include "k3d_noises.h" /* the standard BMRT include file */
k3d/share/shaders/k3d_corktile.sl:33:#define fnoise(p,width) (noise(p) * (1-smoothstep (0.2,0.75,width)))
k3d/share/shaders/k3d_corktile.sl:46:		/* 	the pattern is built up of the sum of two offset noise functions, perturbed slightly
k3d/share/shaders/k3d_corktile.sl:55:		float f = fnoise(PT, fw) + fnoise((P2 + 0.553) * txtscale, fw); 
k3d/share/shaders/k3d_corktile.sl:56:		f = f * fnoise(PT * .854, fw);
k3d/share/shaders/k3d_corktile.sl:57:		f = f + (fnoise(PT * 5.342, fw) - .5) * .5;  
k3d/share/shaders/k3d_corktile.sl:108:	Cg = color( .20, 0, 0) + filteredsnoise(PP * txtscale, filtwidth * txtscale) * .2;
k3d/share/shaders/k3d_corktile.sl:113:	disp = (tileheight + fnoise(PP * txtscale * bumpfreq + 3, filtwidth * txtscale) * (1 - tileheight)) 
k3d/share/shaders/k3d_craters.sl:4: * Voronoi/Worley noise is combined using 1/f scaling to put craters on a surface.
k3d/share/shaders/k3d_craters.sl:10:#include "k3d_noises.h"
k3d/share/shaders/k3d_craters.sl:57:		if ( cellnoise(7*scell-9.5, 7*tcell+7.5) < pitfactor)
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_crayon.sl:32:#define snoise(x,y) ((noise(x,y) - 0.5) * 2)
k3d/share/shaders/k3d_crayon.sl:35:aanoise(float sp, tp, width)
k3d/share/shaders/k3d_crayon.sl:37:	/* an antaliased noise function, which returns noise of a wavelenth always greater than
k3d/share/shaders/k3d_crayon.sl:44:	ns  = mag * snoise(sp / f, tp / f) * (1 - smoothstep(0, .5, width / f))
k3d/share/shaders/k3d_crayon.sl:45:		+ snoise(sp / (f * 1.33), tp / (f * 1.33)) * mag * .25 * smoothstep(0, .5, width / f);
k3d/share/shaders/k3d_crayon.sl:75:	/*  use a spline to read across to the appropriate noise value - this equalisation
k3d/share/shaders/k3d_crayon.sl:81:	float smks = aanoise(txtscale * s * micro / width, txtscale * t * micro / width,
k3d/share/shaders/k3d_crayon.sl:83:	float lmks = (aanoise(txtscale * s / width, txtscale * t / (width * stretch), 
k3d/share/shaders/k3d_cyclone.sl:3:/* Use signed Perlin noise */
k3d/share/shaders/k3d_cyclone.sl:4:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_cyclone.sl:5:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_cyclone.sl:6:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_dented.sl:41:			magnitude += abs(0.5 - noise(PP*size)) / size;
k3d/share/shaders/k3d_dturb.sl:23:    turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_dturb.sl:25:  turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_ember.sl:3: * email: graeme@noitaminanimation.com
k3d/share/shaders/k3d_eroded.sl:24:		/* Calculate a simple fractal 1/f noise function */
k3d/share/shaders/k3d_eroded.sl:25:		magnitude += 4.0 * abs (.5 - noise (W * size)) / size;
k3d/share/shaders/k3d_eyeball.sl:60:#define snoise(P) (2*noise(P)-1)
k3d/share/shaders/k3d_eyeball.sl:97:	  newturb = 1 - abs (snoise(PO*freq + point(0,0,20*freq)));
k3d/share/shaders/k3d_eyeball.sl:114:	  turb += snoise (PO*f2 + point(0,0,20*f2)) / freq;
k3d/share/shaders/k3d_fire.sl:36:    turb += abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_fire.sl:38:  turb += fade * abs(snoise2(ss * f, tt * f)) / f;
k3d/share/shaders/k3d_flame.sl:32:#define snoise(p) (2 * float noise(p) - 1)
k3d/share/shaders/k3d_flame.sl:33:#define DNoise(p) (2 * (point noise(p)) - point(1, 1, 1))
k3d/share/shaders/k3d_flame.sl:34:#define VLNoise(p, scale) (snoise(p + scale * DNoise(p)))
k3d/share/shaders/k3d_fractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

k3d/share/shaders/k3d_fractal.sl:24:          		signal = snoise( PP );

k3d/share/shaders/k3d_fractal.sl:45:          		signal = snoise( PP );

k3d/share/shaders/k3d_funkyglass.sl:21:  Ct = 2 * (color noise(PP) - .5) + .5;
k3d/share/shaders/k3d_gloop.sl:6: * generated from the gradient of a noise function.
k3d/share/shaders/k3d_gloop.sl:11: * freq - the frequency of the noise. Lower values
k3d/share/shaders/k3d_gloop.sl:40:  /*noise function at the point, over in u, and over in v*/
k3d/share/shaders/k3d_gloop.sl: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_gmarbtile_polish.sl:23:#include "k3d_noises.h"
k3d/share/shaders/k3d_gmarbtile_polish.sl:87:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_gmarbtile_polish.sl:94:	       filteredsnoise(2 * (PP + vector(-4.4, 8.34, 27.1)), 2 * dPP));
k3d/share/shaders/k3d_granite.sl:17:		sum = sum + abs(.5 - noise( 4 * freq * I))/freq ;
k3d/share/shaders/k3d_graphic_lines.sl:19:        float noise_size_highlight=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:42:        float noise_size_paint=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:65:        float noise_size_ink=1.0;
k3d/share/shaders/k3d_graphic_lines.sl:131:	ns_highlight=noise_size_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:134:		n_highlight+=(2*noise(Psh_highlight*ns_highlight)-1)/ns_highlight;
k3d/share/shaders/k3d_graphic_lines.sl:206:	ns_paint=noise_size_paint;
k3d/share/shaders/k3d_graphic_lines.sl:208:		n_paint+=(2*noise(Psh_paint*ns_paint)-1)/ns_paint;
k3d/share/shaders/k3d_graphic_lines.sl:278:	ns_ink=noise_size_ink;
k3d/share/shaders/k3d_graphic_lines.sl:280:		n_ink+=(2*noise(Psh_ink*ns_ink)-1)/ns_ink;
k3d/share/shaders/k3d_grass_displace.sl:7: * This is simply uses the noise function and a checkerboard

k3d/share/shaders/k3d_grass_displace.sl:22:  float noifreq = 5;

k3d/share/shaders/k3d_grass_displace.sl:23:  float noiscale = 0.4;

k3d/share/shaders/k3d_grass_displace.sl:26:  float noi = noise(s * noifreq, t * noifreq);

k3d/share/shaders/k3d_grass_displace.sl:27:  ss = s + snoise(noi + 912) * noiscale;

k3d/share/shaders/k3d_grass_displace.sl:28:  tt = t + snoise(noi + 333) * noiscale;

k3d/share/shaders/k3d_grass_surface.sl:19:  float noifreq = 5;

k3d/share/shaders/k3d_grass_surface.sl:20:  float noiscale = 0.4;

k3d/share/shaders/k3d_grass_surface.sl:23:  float noi = noise(s * noifreq, t * noifreq);

k3d/share/shaders/k3d_grass_surface.sl:24:  ss = s + snoise(noi + 912) * noiscale;

k3d/share/shaders/k3d_grass_surface.sl:25:  tt = t + snoise(noi + 333) * noiscale;

k3d/share/shaders/k3d_greenmarble.sl:20:#include "k3d_noises.h"
k3d/share/shaders/k3d_greenmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_greenmarble.sl:67:    smoothstep(-0.1, 0.05, snoise(2 * (PP + vector(-4.4, 8.34, 27.1))));
k3d/share/shaders/k3d_grids.sl:51:#define snoise(x) (2*noise(x)-1) 
k3d/share/shaders/k3d_hexatile_bump.sl:31:* Larry Gritz "noises.h", "project.h", "patterns.h"
k3d/share/shaders/k3d_hexatile_bump.sl:60:	float spos = stestcell + jitter * (float cellnoise(stestcell,seed+ttestcell) - 0.5);
k3d/share/shaders/k3d_hexatile_bump.sl:61:	float tpos = ttestcell + jitter * (float cellnoise(stestcell+23,seed+ttestcell-87) - 0.5);
k3d/share/shaders/k3d_hextile.sl:40:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_hextile.sl:41:#define snoise2(x,y) (2*noise((x),(y))-1)
k3d/share/shaders/k3d_hextile.sl:110:  Ctile = tilecolor * (1 + tilevary * snoise(tileindex+0.5));
k3d/share/shaders/k3d_hextile.sl:112:  stain = stains * smoothstep (.5,1, noise(s*stainfrequency,t*stainfrequency));
k3d/share/shaders/k3d_hextile.sl:114:  scuff = scuffing * smoothstep (.6,1, noise(t*scufffrequency-90.26,
k3d/share/shaders/k3d_imagelayerclouds.sl:1:// Use signed Perlin noise
k3d/share/shaders/k3d_imagelayerclouds.sl:2:#define snoise(x) ((2 * noise(x)) - 1)
k3d/share/shaders/k3d_imagelayerclouds.sl:27:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_leather.sl:48:	float small_noise, blotch, speck, disp = 0, blackness;

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

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

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

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

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

k3d/share/shaders/k3d_leather.sl:88:	small_noise = snoise(BASE_NF*PP*txtscale/TSCALE);

k3d/share/shaders/k3d_leather.sl:90:	                    (small_noise*BASE_NOISE_AMP));

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

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

k3d/share/shaders/k3d_leather.sl:121:	blotch = blotch * (1+small_noise) +

k3d/share/shaders/k3d_leather.sl:122:	         small_noise * BLOTCH_SPECK_COEFF;

k3d/share/shaders/k3d_leather.sl:138:	            noise(SPECK_NF*PP*txtscale/TSCALE)), 3);

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

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

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

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

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

k3d/share/shaders/k3d_leather.sl:177:	disp += small_noise * DISP_SMNOISE_AMP * txtscale / TSCALE;

k3d/share/shaders/k3d_lensflare.sl:107:    return cellnoise(nrand, seed);
k3d/share/shaders/k3d_lensflare.sl:147:	float bloom = pnoise(bloomnpoints * angle / (2 * PI), bloomnpoints);
k3d/share/shaders/k3d_lensflare.sl:159:	float star = float pnoise(starburstnpoints * angle / (2 * PI),
k3d/share/shaders/k3d_lensflare.sl:189:	clr *= 1 + spotvarycolor * (color cellnoise(i) - 0.5);
k3d/share/shaders/k3d_luna.sl:25:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_luna.sl:28:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_luna.sl:29:#define VLNoise(Pt,scale) (snoise(Pt + scale*DNoise(Pt)))
k3d/share/shaders/k3d_luna.sl:73:      a += o * snoise(l * PP);
k3d/share/shaders/k3d_luna.sl:132:  /* Add some noise */
k3d/share/shaders/k3d_luna.sl:143:	      ht += scale * snoise(freq * vv);
k3d/share/shaders/k3d_luna.sl:158:	      ht += scale * snoise(freq * vv);
k3d/share/shaders/k3d_luna.sl:174:      lighten = smoothstep(.15, .5, snoise(62 * u));
k3d/share/shaders/k3d_luna.sl:175:      raydist = 0.2 + 0.2 * snoise(20 * mod(u + 0.022, 1));
k3d/share/shaders/k3d_lunette.sl:7: *   A grid pattern overlaid upon an fBm noise.  This shader is good for
k3d/share/shaders/k3d_lunette.sl:19: *   colorA, colorB - colors used in the background fBm noise
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:29: *   noise functions and an box-filter antialiased grid function.
k3d/share/shaders/k3d_lunette.sl:38:#include "k3d_noises.h"
k3d/share/shaders/k3d_lunette.sl:49: *                           and tt directions.  Also scales the noise in both
k3d/share/shaders/k3d_lunette.sl:55: *   noiseScale - Scale of the background fBm noise (relative to the size of
k3d/share/shaders/k3d_lunette.sl:57: *                noise; decreasing it makes a broader noise.
k3d/share/shaders/k3d_lunette.sl:58: *   noiseRandom - Randomization value for the noise.
k3d/share/shaders/k3d_lunette.sl:59: *   maxOctaves - Maximum number of octaves for the fBm noise.
k3d/share/shaders/k3d_lunette.sl:60: *   lunacrity - Lunacrity of the fBm noise.
k3d/share/shaders/k3d_lunette.sl:61: *   gain - Gain of the fBm noise.
k3d/share/shaders/k3d_lunette.sl:62: *   colorBenhance - After the noise has been calculated, there exists the
k3d/share/shaders/k3d_lunette.sl:68: *                   noise.
k3d/share/shaders/k3d_lunette.sl:80:	float noiseScale;	/* scale of the noise relative to the grid */
k3d/share/shaders/k3d_lunette.sl:81:	float noiseRandom;	/* randomization for the noise */
k3d/share/shaders/k3d_lunette.sl:82:	uniform float maxOctaves;	/* maximum number of octives for the noise */
k3d/share/shaders/k3d_lunette.sl:83:	uniform float lunacrity;	/* lunacrity of the noise */
k3d/share/shaders/k3d_lunette.sl:84:	uniform float gain;		/* gain for the noise */
k3d/share/shaders/k3d_lunette.sl:107:	 * between colorA and colorB, created using noise and other mixing
k3d/share/shaders/k3d_lunette.sl:110:	point noisePt = noiseScale * 
k3d/share/shaders/k3d_lunette.sl:111:		point(ss*ssrepeats, tt*ttrepeats, noiseRandom);
k3d/share/shaders/k3d_lunette.sl:112:	float noisefilterwidth = filterwidthp(noisePt);
k3d/share/shaders/k3d_lunette.sl:113:	float noiseamt = (fBm(
k3d/share/shaders/k3d_lunette.sl:114:		noisePt, noisefilterwidth, maxOctaves, lunacrity, gain
k3d/share/shaders/k3d_lunette.sl:116:	noiseamt = pow(noiseamt, colorBenhance);
k3d/share/shaders/k3d_lunette.sl:117:	color basecolor = mix(colorB, colorA, noiseamt);
k3d/share/shaders/k3d_lunette.sl:125:	 * return the mix between the base grid and the colorful noise
k3d/share/shaders/k3d_lunette.sl:149:	/* fBm noise parameters */
k3d/share/shaders/k3d_lunette.sl:150:	float noiseScale = .3;
k3d/share/shaders/k3d_lunette.sl:151:	float noiseRandom = 0;
k3d/share/shaders/k3d_lunette.sl:161:		colorA, colorB, noiseScale, noiseRandom, maxOctaves,
k3d/share/shaders/k3d_map_pattern_1.sl:55:my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_map_pattern_1.sl:58:r = temp_f_3 * noise (PQ);
k3d/share/shaders/k3d_map_pattern_1.sl:63:r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_mysky.sl:46:/* Use signed Perlin noise */

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

k3d/share/shaders/k3d_mysky.sl:71:      a += o * snoise (PP*l);

k3d/share/shaders/k3d_noisysmoke.sl:1:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_noisysmoke.sl:10:         if (use_noise != 0) {                                              \
k3d/share/shaders/k3d_noisysmoke.sl:12:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_noisysmoke.sl:18:                      smoke += f*snoise(Psmoke);                            \
k3d/share/shaders/k3d_noisysmoke.sl:30:volume k3d_noisysmoke(float density = 60;
k3d/share/shaders/k3d_noisysmoke.sl:33:		      float use_lighting = 1; float use_noise = 1;
k3d/share/shaders/k3d_oak.sl:21: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oak.sl:22: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oak.sl:57:		float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oak.sl:73:    oaktexture(Pshad, dPshad, ringfreq, ringunevenness, grainfreq, ringnoise,
k3d/share/shaders/k3d_oak.sl:74:	       ringnoisefreq, trunkwobble, trunkwobblefreq, angularwobble,
k3d/share/shaders/k3d_oakplank.sl:28: *   ringnoise, ringnoisefreq - general warping of the domain
k3d/share/shaders/k3d_oakplank.sl:29: *   trunkwobble, trunkwobblefreq - controls noise which wobbles the
k3d/share/shaders/k3d_oakplank.sl:64:#include "k3d_noises.h"
k3d/share/shaders/k3d_oakplank.sl:86:  float newt = tt + planklength * cellnoise(swhichplank);
k3d/share/shaders/k3d_oakplank.sl:107:		     float ringnoise = 0.02, ringnoisefreq = 1;
k3d/share/shaders/k3d_oakplank.sl:139:    (vector cellnoise(swhichplank, twhichplank) - 0.5);
k3d/share/shaders/k3d_oakplank.sl:142:			  ringnoise, ringnoisefreq, trunkwobble,
k3d/share/shaders/k3d_oakplank.sl:160:    varnishlump * filteredsnoise(Pshad * varnishlumpfreq,
k3d/share/shaders/k3d_orange.sl:43:	turb = noise (BUMP_FREQUENCY * p2) * BUMP_AMPLITUDE;
k3d/share/shaders/k3d_parquet_plank.sl:43:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_plank.sl:123:      ttt = tt / 4 + whichplank / 28.38 + wavy * noise(8 * ss, tt / 4);
k3d/share/shaders/k3d_parquet_plank.sl:124:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank.sl:136:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale / 4));
k3d/share/shaders/k3d_parquet_plank.sl:152:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_parquet_plank2.sl:57:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_plank2.sl:123:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_plank2.sl:124:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_plank2.sl:134:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_plank2.sl:147:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_parquet_tile.sl:72:#define snoise(x) (2 * noise((x)) - 1)
k3d/share/shaders/k3d_parquet_tile.sl:138:      ttt = tt/4+whichplank/28.38 + wavy * noise (8*ss, tt/4);
k3d/share/shaders/k3d_parquet_tile.sl:139:      r = ringscale * noise (ss-whichplank, ttt);
k3d/share/shaders/k3d_parquet_tile.sl:149:	  r2 = 1.3 - noise (ss*grainscale, (tt*grainscale/4));
k3d/share/shaders/k3d_parquet_tile.sl:162:  woodcolor *= (1-plankvary/2 + plankvary * noise (whichplank+0.5));
k3d/share/shaders/k3d_planetclouds.sl:58:/* Use signed Perlin noise */
k3d/share/shaders/k3d_planetclouds.sl:59:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_planetclouds.sl:60:#define DNoise(p) (2*(point noise(p)) - point(1,1,1))
k3d/share/shaders/k3d_planetclouds.sl:61:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_plank.sl:40:#define snoise(x) (2 * (float noise((x))) - 1)
k3d/share/shaders/k3d_plank.sl:72:  tt = (txtscale * t / PGHEIGHT) + 10 * snoise(0.5 + whichrow);
k3d/share/shaders/k3d_plank.sl:109:      ttt = tt + whichplank / 28.38 + wavy * noise(8 * ss, tt);
k3d/share/shaders/k3d_plank.sl:110:      r = ringscale * noise(ss - whichplank, ttt);
k3d/share/shaders/k3d_plank.sl:122:	  r2 = 1.3 - noise(ss * grainscale, (tt * grainscale));
k3d/share/shaders/k3d_plank.sl:138:    (1 - plankvary / 2 + plankvary * (float noise(whichplank + 0.5)));
k3d/share/shaders/k3d_puffyclouds.sl:43:/* Use signed Perlin noise */
k3d/share/shaders/k3d_puffyclouds.sl:44:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_puffyclouds.sl:68:      a += o * snoise (PP*l);
k3d/share/shaders/k3d_redapple.sl:18: * Look out for the "txtscale" parameter: some noise calculations are
k3d/share/shaders/k3d_redapple.sl:38:#ifndef snoise
k3d/share/shaders/k3d_redapple.sl:39:#define snoise(x) (2*noise(x)-1)  /* 1-D signed noise */
k3d/share/shaders/k3d_redapple.sl:65:	float small_noise, blotch, speck, disp = 0, blackness;
k3d/share/shaders/k3d_redapple.sl:99:	#define BASE_SF          1.2    /* s-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:100:	#define BASE_TF          3      /* t-factor for big noise          */
k3d/share/shaders/k3d_redapple.sl:101:	#define BASE_NF          100    /* scaling factor for small noise  */
k3d/share/shaders/k3d_redapple.sl:102:	#define BASE_NOISE_AMP   0.2    /* small noise color mix amplitude */
k3d/share/shaders/k3d_redapple.sl:109:	base_turb = noise(BASE_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:112:	small_noise = snoise(BASE_NF*PP*txtscale/TSCALE);
k3d/share/shaders/k3d_redapple.sl:114:	                    (small_noise*BASE_NOISE_AMP));
k3d/share/shaders/k3d_redapple.sl:134:	 * really simple noise routine.
k3d/share/shaders/k3d_redapple.sl:141:	blotch_turb = noise(BLOTCH_SF*sin(2*PI*(s+.1234)) + PI + label,
k3d/share/shaders/k3d_redapple.sl:145:	blotch = blotch * (1+small_noise) +
k3d/share/shaders/k3d_redapple.sl:146:	         small_noise * BLOTCH_SPECK_COEFF;
k3d/share/shaders/k3d_redapple.sl:159:	#define SPECK_NF        50    /* A noise scaling factor      */
k3d/share/shaders/k3d_redapple.sl:162:	            noise(SPECK_NF*PP*txtscale/TSCALE)), 3);
k3d/share/shaders/k3d_redapple.sl:190:	 * noise, affected a little by the brown specks, and
k3d/share/shaders/k3d_redapple.sl:194:	#define DISP_SF     10             /* s-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:195:	#define DISP_TF     30             /* t-factor for dent noise */
k3d/share/shaders/k3d_redapple.sl:197:	#define DISP_SMNOISE_AMP  (1/1000) /* small noise amplitude   */
k3d/share/shaders/k3d_redapple.sl:199:	disp += noise(DISP_SF*sin(2*PI*s) + PI + label,
k3d/share/shaders/k3d_redapple.sl:201:	disp += small_noise * DISP_SMNOISE_AMP * txtscale / TSCALE;
k3d/share/shaders/k3d_ridged_multifractal.sl:12:#define snoise(x) (2.5*(noise(x)-0.5))

k3d/share/shaders/k3d_ridged_multifractal.sl:24:          		signal = snoise( PP );

k3d/share/shaders/k3d_ridged_multifractal.sl:45:          		signal = snoise( PP );

k3d/share/shaders/k3d_rubber.sl:20:	cout = mix(Cs, white, .05* (float noise(txtscale*Ploc)));
k3d/share/shaders/k3d_rustymetal.sl:6: *   is basically thresholded turbulence (summed abs(snoise)).  Where it's
k3d/share/shaders/k3d_rustymetal.sl:34:/* Signed noise varies from -1 to 1 (like Perlin uses) */
k3d/share/shaders/k3d_rustymetal.sl:35:#define snoise(x) (2*noise(x)-1)
k3d/share/shaders/k3d_rustymetal.sl:60:  /* Sum several octaves of abs(snoise), i.e. turbulence.  Limit the
k3d/share/shaders/k3d_rustymetal.sl:67:      sum += a * abs(snoise(PP));
k3d/share/shaders/k3d_rustymetal.sl:72:  Nrust = calculatenormal (P + rustbump * snoise(PP) * normalize(N));
k3d/share/shaders/k3d_rustymetal.sl:74:  /* Scale the rust appropriately, modulate it by another noise 
k3d/share/shaders/k3d_rustymetal.sl:78:  rustiness *= clamp (abs(snoise(PP)), 0, .08) / 0.08;
k3d/share/shaders/k3d_saturnring.sl:33:#define snoise(x) (2 * noise(x) - 1)	
k3d/share/shaders/k3d_saturnring.sl:35:/* prman noise has less range */
k3d/share/shaders/k3d_saturnring.sl:36:#define snoise(x) (2.5 * (noise(x) - 1))
k3d/share/shaders/k3d_saturnring.sl:70:		oi =  (relpos + snoise (40* relpos) - floor(relpos) );
k3d/share/shaders/k3d_scartissue.sl:2: *  an unremarkable recursive noise to make scartissue
k3d/share/shaders/k3d_scartissue.sl:25:		nz += abs(.5 - noise( (freq * Psh)+offset)) / freq;
k3d/share/shaders/k3d_skin1.sl:34: * #include "locilum.h" and #include "noises.h".
k3d/share/shaders/k3d_skin1.sl:164:#define snoise(p) (2 * (float noise(p)) - 1)
k3d/share/shaders/k3d_skin1.sl:214:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_skin1.sl:241:  turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_slateroof.sl:69:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroof.sl:76:   uniform 	float colorfactor = 3.276 * factor;	/* Used in noise calculations */	
k3d/share/shaders/k3d_slateroof.sl:99:	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroof.sl:109:		add = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroof.sl:112:	ocolorvary = (noise(cs * colorfactor, ct * colorfactor) - 1) * 2 * maxcolorvary;
k3d/share/shaders/k3d_slateroof.sl:147:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroof.sl:153:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroof.sl:154:			newcolorvary =  (noise(cs * colorfactor, ct * colorfactor) - 1) * 2 * maxcolorvary;
k3d/share/shaders/k3d_slateroof.sl:184:	ns = noise( s * txtscale * 59.8534 * sfreq, t * txtscale * 59.8534 * tfreq);
k3d/share/shaders/k3d_slateroofd.sl:61:			cs, ct; 									/* Coordinates set to the centre of the tile and fed into the noise function */
k3d/share/shaders/k3d_slateroofd.sl:91:   	/* the noise function is always taken at the same point in the tile 
k3d/share/shaders/k3d_slateroofd.sl:100:   		add = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_slateroofd.sl:139:			/* Now calculate cs, ct the reference point for the noise calculation */					
k3d/share/shaders/k3d_slateroofd.sl:145:			newadd = noise(cs * factor, ct * factor) * maxadd;
k3d/share/shaders/k3d_smoke.sl:16: *   smokefreq, smokeoctaves, smokevary - control the fBm of the noisy smoke
k3d/share/shaders/k3d_smoke.sl:17: *          If either smokeoctaves or smokevary is 0, there is no noise
k3d/share/shaders/k3d_smoke.sl:28:#include "k3d_noises.h"
k3d/share/shaders/k3d_smoke.sl:53:      smoke = snoise(Psmoke);
k3d/share/shaders/k3d_smoke2.sl:2: * TLSmoke.sl -- This is really Larry's noisysmoke.sl.  I only took out the
k3d/share/shaders/k3d_smoke2.sl:16: *   use_noise - makes the smoke noisy (nonuniform) when nonzero
k3d/share/shaders/k3d_smoke2.sl:17: *   freq, octaves, smokevary - control the fBm of the noisy smoke
k3d/share/shaders/k3d_smoke2.sl:39: * Compute only one octave of noise when not lit (big speedup)
k3d/share/shaders/k3d_smoke2.sl:47:#define snoise(p) (2*noise(p)-1)
k3d/share/shaders/k3d_smoke2.sl:56:         if (use_noise != 0) {                                              \
k3d/share/shaders/k3d_smoke2.sl:58:             smoke = snoise (Psmoke);                                       \
k3d/share/shaders/k3d_smoke2.sl:64:                      smoke += f*snoise(Psmoke);                            \
k3d/share/shaders/k3d_smoke2.sl:82:	    float use_noise = 1;
k3d/share/shaders/k3d_spacecloud.sl:29: *      I was never happy with the results.  So now am just using noise over
k3d/share/shaders/k3d_spacecloud.sl:36:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spacecloud.sl:37:#define snoise2(x, y) (2 * noise(x, y) - 1)
k3d/share/shaders/k3d_spacecloud.sl:40:	snoise2 (x,y) * ((maxVal)-(minVal)+(minVal))
k3d/share/shaders/k3d_spacecloud.sl:75:    value += abs(snoise (PP * f))/f;
k3d/share/shaders/k3d_spacecloud.sl:82:	fBm (P, noiseScale, octaves, PP, freq, i, size, adjust);
k3d/share/shaders/k3d_spaceshiphull1.sl:1:#define snoise(x) (2 * noise(x) - 1)
k3d/share/shaders/k3d_spaceshiphull1.sl:10:		value += snoise(Q * f) / f;
k3d/share/shaders/k3d_spaceshiphull1.sl:38:  ss += rowvary * noise(tplate + 0.3);
k3d/share/shaders/k3d_spaceshiphull1.sl:42:  platecolor = Cs - (lumavary * float noise(splate + 0.4, tplate + 0.5));
k3d/share/shaders/k3d_spaceshiphull1.sl:48:  platespecular = Ks * noise(splate + 0.6, tplate + 0.7);
k3d/share/shaders/k3d_starfield.sl:19:	star_center += irregularity * (point noise(star_center) - point(0.5, 0.5, 0.5));
k3d/share/shaders/k3d_starfield.sl:27:	float star_intensity = float cellnoise(star_center);
k3d/share/shaders/k3d_stones.sl:49:#define snoise(x)    (noise(x) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:50:#define snoise2(x,y) (noise(x,y) * 2 - 1)
k3d/share/shaders/k3d_stones.sl:54:#define udn(x,lo,hi) (smoothstep(.25, .75, noise(x)) * ((hi) - (lo)) + (lo))
k3d/share/shaders/k3d_stones.sl:69:    h += varyhue * (cellnoise(index+3)-0.5);
k3d/share/shaders/k3d_stones.sl:70:    s *= 1 - varysat * (cellnoise(index-14)-0.5);
k3d/share/shaders/k3d_stones.sl:71:    v *= 1 - varyval * (cellnoise(index+37)-0.5);
k3d/share/shaders/k3d_stones.sl:103: float noifreq = 10, noiscale = 0.3;
k3d/share/shaders/k3d_stones.sl:115:   angle = PI * snoise(freq * 16.31456);  /*randomize angle index*/
k3d/share/shaders/k3d_stones.sl:129:   bub = 0.5 + snoise2(10 * freq,10 * freq);
k3d/share/shaders/k3d_stones.sl:130:   ss += noiscale * snoise(snoise2(s * noifreq, t * noifreq) + 912);
k3d/share/shaders/k3d_stones.sl:131:   tt += noiscale * snoise(snoise2(s * noifreq, t * noifreq) + 333);
k3d/share/shaders/k3d_stones.sl:132:   /*cx = 0.5 + 0.1 * snoise2( 12.312,  21.773);
k3d/share/shaders/k3d_stones.sl:133:   cy = 0.5 + 0.1 * snoise2( 28.398, 62.112); */
k3d/share/shaders/k3d_stones.sl:134:   cx = 0.5 + 0.1 * snoise2( freq * 8.456, freq * 18.773);
k3d/share/shaders/k3d_stones.sl:135:   cy = 0.5 + 0.1 * snoise2( freq * 28.398, freq * 42.112);
k3d/share/shaders/k3d_stones.sl:166:        turb += abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_stones.sl:168:        turb += fade * abs(snoise(PP * f)) / f;
k3d/share/shaders/k3d_strata.sl:13: *    octaves - number of octaves of noise to sum for the turbulence
k3d/share/shaders/k3d_strata.sl:35:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_strata.sl:53:      turb += abs(snoise(PP * freq) / freq);
k3d/share/shaders/k3d_stucco.sl:23:  magnitude = Km * pow(noise(PP * frequency), power);
k3d/share/shaders/k3d_superplank.sl:46:#include "k3d_noises.h"
k3d/share/shaders/k3d_superplank.sl:154:      plank_t = tt / PGHEIGHT + 20 * plankstagger * cellnoise(whichrow);
k3d/share/shaders/k3d_superplank.sl:218:      ttt = ring_t + whichplank * 28.38 + wavy * noise(8 * ring_s, ring_t);
k3d/share/shaders/k3d_superplank.sl:219:      ring = ringscale * noise(ring_s - whichplank * 4.18, ttt / 20);
k3d/share/shaders/k3d_superplank.sl:233:	  r2 = 1.3 - noise(12 * grain_s, grain_t);
k3d/share/shaders/k3d_superplank.sl:251:    1 - plankvary / 2 + plankvary * float cellnoise(whichplank, whichrow);
k3d/share/shaders/k3d_superplank.sl:274:			    noise(varnishbumpfreq * ss,
k3d/share/shaders/k3d_terran.sl:8:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:10:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran.sl:11:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran.sl:14:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran.sl:15:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran.sl:60:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terran.sl:73:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terran.sl:78:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran.sl:80:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_terran.sl:149:	      purt += o * snoise(l * PP);
k3d/share/shaders/k3d_terran2.sl:24: *    multifractal - zero uses fBm noise, nonzero uses multifractal
k3d/share/shaders/k3d_terran2.sl:64:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:66:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terran2.sl:67:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terran2.sl:70:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terran2.sl:71:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terran2.sl:119:	  bumpy += o * snoise (l * Ptexture);
k3d/share/shaders/k3d_terran2.sl:130:      bumpy = weight * snoise (tp);
k3d/share/shaders/k3d_terran2.sl:134:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terran2.sl:136:	  bumpy += snoise(tp) * min (weight, spectral_exp);
k3d/share/shaders/k3d_terran2.sl:206:	     purt += o * snoise (l * PP);
k3d/share/shaders/k3d_terranbump.sl:4:#define snoise(x) (2*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:6:/* This is because PRMAN's noise has less range than BMRT's */
k3d/share/shaders/k3d_terranbump.sl:7:#define snoise(x) (2.5*(noise(x)-0.5))
k3d/share/shaders/k3d_terranbump.sl:10:#define DNoise(x) ((2*(point noise(x))) - point(1,1,1))
k3d/share/shaders/k3d_terranbump.sl:11:#define VLNoise(Pt,scale) (snoise(DNoise(Pt)+(scale*Pt)))
k3d/share/shaders/k3d_terranbump.sl:38:	  bumpy += o * snoise(l * Ptexture);
k3d/share/shaders/k3d_terranbump.sl:51:      bumpy = weight * snoise(tp);
k3d/share/shaders/k3d_terranbump.sl:56:	  weight *= o * (N_OFFSET + snoise(tp));
k3d/share/shaders/k3d_terranbump.sl:58:	  bumpy += snoise(tp) * min(weight, spectral_exp);
k3d/share/shaders/k3d_texblender.sl:9:#include "k3d_noises.h"
k3d/share/shaders/k3d_texblender.sl:65:		//val=val*(1-Karm)+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:66:		val=val+Karm*snoise(arm*P);
k3d/share/shaders/k3d_texblender.sl:79:    my_t += noise (PQ) / 16;
k3d/share/shaders/k3d_texblender.sl:82:    float r = ringscale * noise (PQ);
k3d/share/shaders/k3d_texblender.sl:86:    float r2 = grainy * (1.3 - noise (PQ)) + (1-grainy);
k3d/share/shaders/k3d_texblender.sl:101:	else if (mapname=="noise")
k3d/share/shaders/k3d_tooledsteel.sl:17: *  Nzscale 		- scale of the noise that randomizes the location of 
k3d/share/shaders/k3d_tooledsteel.sl:53:  /*true cell center, surrounding cell centers, noised cell center*/
k3d/share/shaders/k3d_tooledsteel.sl:66:  /*what is the shortest distance to a noised cell center?*/
k3d/share/shaders/k3d_tooledsteel.sl:71:	nzoff = ((vector cellnoise(surrcell)-.5)*Nzscale);
k3d/share/shaders/k3d_uberlight.sl:87: * Projected noise on the light:
k3d/share/shaders/k3d_uberlight.sl:88: *   noiseamp - amplitude of the noise.  A value of 0 (the default) 
k3d/share/shaders/k3d_uberlight.sl:89: *       means not to use noise.  Larger values increase the blotchiness
k3d/share/shaders/k3d_uberlight.sl:90: *       of the projected noise.
k3d/share/shaders/k3d_uberlight.sl:91: *   noisefreq - frequency of the noise.
k3d/share/shaders/k3d_uberlight.sl:92: *   noiseoffset - spatial offset of the noise.  This can be animated,
k3d/share/shaders/k3d_uberlight.sl:93: *       for example, you can use the noise to simulate the
k3d/share/shaders/k3d_uberlight.sl:168: *   __foglight - the "noisysmoke" shader distributed with BMRT will add
k3d/share/shaders/k3d_uberlight.sl:171: *       this light with noisysmoke, you can set this flag to 0 to
k3d/share/shaders/k3d_uberlight.sl:173: *       Note that the noisysmoke shader is distributed with BMRT but
k3d/share/shaders/k3d_uberlight.sl:177: * noise texture.  Some advanced users may want more than one of some or
k3d/share/shaders/k3d_uberlight.sl:386:		     float noiseamp = 0, noisefreq = 4;
k3d/share/shaders/k3d_uberlight.sl:387:		     vector noiseoffset = 0;
k3d/share/shaders/k3d_uberlight.sl:476:	/* Apply noise */
k3d/share/shaders/k3d_uberlight.sl:477:	if(noiseamp > 0)
k3d/share/shaders/k3d_uberlight.sl:480:	    float n = noise(noisefreq * (PL + noiseoffset) * point(1, 1, 0));
k3d/share/shaders/k3d_uberlight.sl:481:	    n = smoothstep(0, 1, 0.5 + noiseamp * (n - 0.5));
k3d/share/shaders/k3d_veinedmarble.sl:27:#include "k3d_noises.h"
k3d/share/shaders/k3d_veinedmarble.sl:61:      turb = abs(filteredsnoise(PP * freq, dPP * freq));
k3d/share/shaders/k3d_venus.sl:19: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus.sl:49:/* Use signed noise on [-1,1] */
k3d/share/shaders/k3d_venus.sl:50:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus.sl:87:      a += o * snoise(PP * l);
k3d/share/shaders/k3d_venus2.sl:21: *    octaves - the number of octaves of noise to sum for the clouds.
k3d/share/shaders/k3d_venus2.sl:47:/* Use signed noise on [-1,1] */
k3d/share/shaders/k3d_venus2.sl:48:#define snoise(x) ((2*noise(x))-1)
k3d/share/shaders/k3d_venus2.sl:86:      a += o * snoise (PP * l);
k3d/share/shaders/k3d_volcube.sl:106:    return (noise((Pos+30.445)*2)-.5+vol_offset)*vol_mult;
k3d/share/shaders/k3d_volcube.sl:121:    dens = pow(1-abs(noise(Pos*7)*2-1),3);
k3d/share/shaders/k3d_volcube.sl:122:    dens += pow(1-abs(noise((Pos+24.72)*7)*2-1),3);
k3d/share/shaders/k3d_wallpaper.sl:16:#define snoise(s,t)	(2*noise((s),(t))-1)
k3d/share/shaders/k3d_wallpaper.sl:48:	    if (float noise(3*scell-9.5,7*tcell+7.5) < 0.55) {
k3d/share/shaders/k3d_wallpaper.sl:50:                     + 0.6 * snoise(scell+0.5, tcell+0.5));
k3d/share/shaders/k3d_wallpaper.sl:52:                     + 0.6 * snoise(scell+3.5, tcell+8.5));
k3d/share/shaders/k3d_waterlight.sl:24:			Cl = mix(minimum_intensity, maximum_intensity, float noise(frequency * Ps)) * lightcolor;
k3d/share/shaders/k3d_windywave.sl:1:#define snoise(Pt) (2*noise(Pt) - 1)
k3d/share/shaders/k3d_windywave.sl:14:  offset = Km * (snoise(PP) + 0.5 * snoise(2 * PP));
k3d/share/shaders/k3d_windywave.sl:21:      turb += abs(a * snoise(PP));
k3d/share/shaders/k3d_wood2.sl:40:  my_t += noise(PQ) / 16;
k3d/share/shaders/k3d_wood2.sl:43:  r = ringscale * noise(PQ);
k3d/share/shaders/k3d_wood2.sl:49:  r2 = grainy * (1.3 - noise(PQ)) + (1 - grainy);
k3d/share/shaders/k3d_woodcut.sl:9:#define snoise(x) (2*noise(x)-1) 
k3d/share/shaders/k3d_woodcut.sl:52:n += snoise(Psh * ns) / ns;
