00001 #ifndef _H_vsl_pass
00002 #define _H_vsl_pass
00003
00004 #include "noises.h"
00005 #include "vsl_utils.h"
00006 #include "blinn.h"
00007
00008
00009
00010
00011
00012 color
00013 do_cracks( uniform color crack_colour; uniform float crack_veining;)
00014 {
00015 color final_output;
00016 color marble;
00017 float float_marble = 0;
00018 uniform float marble_var = -0.5;
00019 vlsMarble( crack_colour, crack_veining, marble_var, marble);
00020
00021
00022 varying color surf_colour;
00023 vslColourAdjust(
00024 marble,
00025 0.82,
00026 0.97,
00027 1.54,
00028 1.00,
00029 color (1.000,1.000,1.000),
00030 marble
00031 );
00032
00033
00034 vslColourInvert(
00035 marble,
00036 "rgb", 1,1,1, marble);
00037
00038 vslConvertColourToFloat(marble, float_marble);
00039
00040
00041 vslRemapF( float_marble,
00042 0.64102,
00043 1,
00044 0,
00045 1.00000000000,
00046 0,
00047 0.19,
00048 0.81,
00049 float_marble
00050 );
00051 vslConvertFloatToColour(float_marble, marble);
00052 return marble;
00053 }
00054
00055
00056
00057 do_fresnel( uniform float ior;
00058 output float fKt;
00059 output float fKr;
00060 output vector Rf;
00061 output vector Tf)
00062 {
00063 normal Nf = faceforward(normalize(N), I);
00064
00065 fresnel (normalize (I), Nf, (I.Nf > 0)? ior: 1/ior, fKr, fKt, Rf, Tf);
00066
00067 fKt = 1 - fKr;
00068
00069 }
00070
00071 color
00072 do_albedo( uniform color marble_tint, marble_gain;
00073 uniform float veining;
00074 uniform float vein_variation;
00075 uniform float cracks_flag;)
00076 {
00077 color final_output;
00078 color marble;
00079 uniform color marble_colour = (0.97, 0.99, 1.0);
00080 vlsMarble( marble_colour, veining,vein_variation, marble);
00081
00082
00083 color bias = (0.783,0.783,0.783);
00084 color gain = 1 - marble_gain;
00085 marble= vslColourBias(bias, marble);
00086 marble = vslColourGain(gain, marble);
00087
00088
00089 varying color surf_colour;
00090 vslColourAdjust (
00091 marble,
00092 1.24,
00093 1.07,
00094 2.34,
00095 1,
00096 marble_tint,
00097 surf_colour
00098 );
00099 final_output = surf_colour;
00100
00101
00102 if( cracks_flag != 0)
00103 {
00104
00105 uniform color crack_colour = color (1.000,1.000,1.000);
00106 uniform float crack_veining = 0.12;
00107
00108 color cracks = do_cracks(crack_colour, crack_veining);
00109 float method = 1.0;
00110 vslCombineColors(method, surf_colour, cracks, final_output);
00111 }
00112 return final_output;
00113 }
00114
00115 color
00116 do_sss( uniform string filename;
00117 color albedo;
00118 color dmfp;
00119 float ior;
00120 float unitlength;
00121 float smooth;
00122 float maxsolidangle;
00123 )
00124 {
00125 normal Nn = normalize(N);
00126 vector V = -normalize(I);
00127 color sss = 0;
00128
00129
00130
00131 sss = subsurface(P, N, "filename", filename,
00132 "albedo", albedo, "diffusemeanfreepath", dmfp,
00133 "ior", ior, "unitlength", unitlength,
00134 "smooth", smooth,
00135 "maxsolidangle", maxsolidangle);
00136
00137 return sss;
00138 }
00139
00140
00141 color
00142 do_indirect_diffuse( string coord_system;
00143 string diffuse_map;
00144 float indirectdiff_samples;
00145 float indirectdiff_maxvariation;)
00146
00147 {
00148 normal Nf = faceforward((normalize(N)), I);
00149 color output_indirect;
00150
00151 output_indirect = indirectdiffuse(P, Nf, indirectdiff_samples, "maxvariation", indirectdiff_maxvariation, "environmentmap", diffuse_map, "maxsolidangle", 0.5, "environmentspace", coord_system);
00152 return output_indirect;
00153 }
00154
00155
00156
00157 color
00158 do_reflection_occlusion( string coord_system;
00159 float reflectionocc_samples;
00160 float reflectionocc_blur;
00161 vector Rf;
00162 string env_map;
00163 )
00164 {
00165 float angle = radians(reflectionocc_blur);
00166
00167 vector R = Rf;
00168 vector rayDir = 0;
00169
00170 color hitcolour = 0;
00171 color output_rocc = 0;
00172
00173
00174 gather("illuminance", P, R, angle, reflectionocc_samples, "volume:Ci", hitcolour, "ray:direction", rayDir)
00175 {
00176 output_rocc += hitcolour;
00177 }
00178 else
00179 {
00180 vector rEnv=vtransform(coord_system, rayDir);
00181 output_rocc+= environment(env_map, rEnv);
00182 }
00183
00184 output_rocc = output_rocc / reflectionocc_samples;
00185 return output_rocc;
00186
00187 }
00188
00189
00190
00191 void do_diffuse_ibl( string coord_system;
00192 string diffuse_map;
00193 float maxvar;
00194 float samples;
00195 output color output_occ;
00196 output color output_diff;)
00197 {
00198 normal Nf = faceforward(normalize(N), I);
00199
00200
00201
00202 vector envdir = Nf;
00203 color envcolour = 0;
00204 float occ = occlusion(P, Nf, samples, "maxvariation", maxvar, "environmentmap", diffuse_map, "environmentcolor", envcolour, "environmentspace", coord_system);
00205
00206
00207 output_occ = (1-occ);
00208 output_diff = (1-occ) * envcolour;
00209
00210 }
00211
00212 color do_refraction( float kior )
00213 {
00214 normal Nf = faceforward(normalize(N), I);
00215 float ior = kior;
00216
00217 vector refract_ray = refract(I, Nf, ior);
00218 color output_colour;
00219 output_colour = trace(P, refract_ray);
00220 return output_colour;
00221 }
00222
00223
00224
00225 color do_specularity(float spec_roughness)
00226 {
00227 normal Nf = faceforward(normalize(N), I);
00228 vector V = -normalize(I);
00229 color output_colour;
00230 output_colour = specular(Nf, V, spec_roughness);
00231 return output_colour;
00232 }
00233
00234
00236 color do_specularity_blinn( uniform color spec_colour;
00237 uniform float eccentricity;
00238 uniform float spec_rolloff;
00239 uniform float spec_reflectivity;
00240 output color o_SpecularDirect;
00241 output color o_SpecularDirectShadow;
00242 )
00243 {
00244 normal Nf = faceforward(normalize(N), I);
00245 color output_colour;
00246 blinnSpecularAOV( spec_colour, Nf, eccentricity, spec_rolloff, spec_reflectivity, o_SpecularDirect, o_SpecularDirectShadow);
00247
00248 return o_SpecularDirect;
00249
00250 }
00251
00253 color do_specularity_cook( float roughness;
00254 float gaussConstant;
00255 float F;
00256 float Ktransmit;
00257 )
00258 {
00259
00260 normal Nn = normalize(N);
00261 vector Vn = normalize(-I);
00262 float m = roughness;
00263
00264 color cook = 0;
00265 float NdotV = Nn.Vn;
00266
00267 illuminance( P, Nn, PI/2 ){
00268
00269 vector Ln = normalize(L);
00270 vector H = normalize(Vn+Ln);
00271
00272 float NdotH = Nn.H;
00273 float NdotL = Nn.Ln;
00274 float VdotH = Vn.H;
00275
00276 float D;
00277 float alpha = acos(NdotH);
00278
00279
00280 D = gaussConstant*exp(-(alpha*alpha)/(m*m));
00281
00282
00283 float G = min(1, min((2*NdotH*NdotV/VdotH), (2*NdotH*NdotL/VdotH)));
00284
00285
00286 cook += Cl*(F*D*G)/(PI*NdotV);
00287 }
00288 cook = cook/PI;
00289 return cook;
00290 }
00291
00292
00293
00294
00295 color
00296 do_snow_spec( float eccentricity;
00297 float spec_rolloff;
00298 float spec_reflectivity;
00299 float spec_rythm;
00300 output color o_SpecularDirect;
00301 output color o_SpecularDirectShadow)
00302 {
00303
00304 uniform float br_f = 10.0;
00305 uniform float br_octaves = 8.0;
00306 uniform float br_lacunarity = 2.00;
00307 uniform float br_gain = 1.0;
00308 uniform float br_rescale = 1.0;
00309 varying float br_fourthdimension = (( xcomp(I) + ycomp(I) + zcomp(I) ))*spec_rythm;
00310 float br_result;
00311
00312 point pp=transform("object",P);
00313 vslBrownian(br_f, br_octaves, br_lacunarity, br_gain, br_rescale, br_fourthdimension, pp, br_result);
00314
00315
00316 uniform float re_inputmin = 0.65;
00317 uniform float re_inputmax = 1.00;
00318 uniform float re_outputmin = 0.00;
00319 uniform float re_outputmax = 1.0;
00320 uniform float re_disable = 0;
00321 uniform float re_bias = 1;
00322 uniform float re_gain = 0.0;
00323 float re_result = 0;
00324
00325 vslRemapF( br_result, re_inputmin, re_inputmax, re_outputmin, re_outputmax, re_disable, re_bias, re_gain, re_result);
00326 color sparks_colour = 1;
00327 vslConvertFloatToColour(re_result, sparks_colour);
00329
00330 normal Nf = faceforward(normalize(N), I);
00331 color output_colour;
00332 blinnSpecularAOV( sparks_colour, Nf, eccentricity, spec_rolloff, spec_reflectivity, o_SpecularDirect, o_SpecularDirectShadow);
00333
00334 output_colour = o_SpecularDirect;
00335
00336 }
00337
00338
00339 color
00340 do_snow_diffuse()
00341 {
00342 color output_c = 0;
00343 point pp=transform("object",P);
00344
00345
00346 uniform float fr_layers = 6.00;
00347 uniform float fr_f = 0.5;
00348 uniform float fr_lacunarity = 1.80;
00349 uniform float fr_dimension = 1.00;
00350 uniform float fr_erosion = 0.00;
00351 uniform float fr_variation = 0;
00352 float fr_result;
00353
00354 vsl_Fractal(fr_layers, fr_f, fr_lacunarity, fr_dimension, fr_erosion, fr_variation, pp, fr_result);
00355
00356
00357 uniform float re_inputmin = 0.0;
00358 uniform float re_inputmax = 1.00;
00359 uniform float re_outputmin = 0.500;
00360 uniform float re_outputmax = 1.0;
00361 uniform float re_disable = 0;
00362 uniform float re_bias = 0.44;
00363 uniform float re_gain = 0.26;
00364 float re_result = 0;
00365
00366 vslRemapF( fr_result, re_inputmin, re_inputmax, re_outputmin, re_outputmax, re_disable, re_bias, re_gain, re_result);
00367 vslConvertFloatToColour(re_result, output_c);
00368 return output_c;
00369 }
00370
00371 float
00372 find_upward( uniform float up_snow;
00373 )
00374 {
00375
00376
00377
00378 normal Nn = normalize(N);
00379 float vert = ycomp(Nn);
00380 float up_surface = 0;
00381
00382 up_surface = smoothstep(up_snow-0.15, 1, vert);
00383
00384 return up_surface;
00385 }
00386
00387
00388 float
00389 do_snow_mask( uniform float snow_height;
00390 uniform float up_snow;
00391 )
00392 {
00393 color final_output;
00394 color snow_mask;
00395 color marble=0;
00396 float float_marble = 0;
00397 uniform float marble_var = -0.5;
00398
00399 point PP=transform("object",P);
00400
00401
00402
00403 normal Nn = normalize(N);
00404 float vert = ycomp(Nn);
00405 snow_mask = 0;
00406
00407 snow_mask = smoothstep(up_snow-0.1, 1, vert);
00408
00409 snow_mask = find_upward(up_snow);
00410
00411 uniform float angle = 0;
00412 uniform float repeatS = 1;
00413 uniform float repeatT = 1;
00414 uniform float offsetS = 0;
00415 uniform float offsetT = 0;
00416 vector tmp2;
00417 point tmp0;
00418 vector tmp1;
00419 color tmp3 = (0, 0, 0);
00420 vslST(angle, repeatS, repeatT, offsetS, offsetT, PP, tmp1, tmp2);
00421
00422 varying float val1 = 1.0;
00423 varying float val2 = 0.0;
00424 varying float val3 = 5.0;
00425 varying float val4 = 0.46;
00426 varying color colour1 = (0,0,0);
00427 varying color colour2 = (1.0,1.0,1.0);
00428
00429 vslColorRamp( val2,
00430 val2,
00431 6,
00432 val2,
00433 colour1,
00434 val2,
00435 colour1,
00436 0.25,
00437 colour1,
00438 0.42,
00439 colour2,
00440 val1,
00441 colour2,
00442 val1,
00443 colour2,
00444 PP,
00445 tmp1,
00446 tmp2,
00447 tmp3
00448 );
00449
00450
00451 snow_mask *= tmp3;
00452
00453
00454
00455 vslConvertColourToFloat(snow_mask, float_marble);
00456
00457 return float_marble;
00458 }
00459
00460 color
00461 do_snow( uniform float snow_over; )
00462 {
00463 color crack_colour = 0;
00464 point pp = transform("object", P);
00465
00466
00467 uniform float turb_f = 0.4;
00468 uniform float octaves = 7;
00469 uniform float lacunarity = 1.58;
00470 uniform float gain = 1.3;
00471 uniform float invert = 1;
00472 uniform float fourthdimension = 0;
00473 float turb_result;
00474
00475 vslTurbulence(turb_f, octaves, lacunarity, gain, invert, fourthdimension, pp, turb_result );
00476 vslConvertFloatToColour(turb_result, crack_colour);
00477
00478 uniform float saturation = 0.03;
00479 uniform float midpoint = 0.77;
00480 uniform float contrast = 4.0;
00481 uniform float clamp = 1.0;
00482 uniform color tint = (0.956,0.972,1.000);
00483
00484 vslColourAdjust(crack_colour, saturation, midpoint, contrast, clamp, tint, crack_colour);
00485 vslConvertColourToFloat(crack_colour, turb_result);
00486
00487
00488 uniform float br_f = 0.2;
00489 uniform float br_octaves = 8;
00490 uniform float br_lacunarity = 4.00;
00491 uniform float br_gain = 0.70;
00492 uniform float br_rescale = 0;
00493 uniform float br_fourthdimension = 1;
00494 float br_result;
00495 vslBrownian(br_f, br_octaves, br_lacunarity, br_gain, br_rescale, br_fourthdimension, pp, br_result);
00496
00497
00498 uniform float fr_layers = 6.00;
00499 uniform float fr_f = 3.00;
00500 uniform float fr_lacunarity = 5.00;
00501 uniform float fr_dimension = 1.00;
00502 uniform float fr_erosion = 1.0;
00503 uniform float fr_variation = 0;
00504 float fr_result;
00505 vsl_Fractal(fr_layers, fr_f, fr_lacunarity, fr_dimension, fr_erosion, fr_variation, pp, fr_result);
00506
00507 vslRemapF( fr_result, 0.05, 1, 0, 1, 0, 0.74, 0.66, fr_result);
00508
00509
00510
00511 float combine_result = turb_result * br_result * fr_result;
00512
00513
00514 uniform float re_inputmin = 0.00;
00515 uniform float re_inputmax = 1.00;
00516 uniform float re_outputmin = 0.00;
00517 uniform float re_outputmax = 1.0;
00518 uniform float re_disable = 0;
00519 uniform float re_bias = 0.68;
00520 uniform float re_gain = 0.62;
00521 float re_result = 0;
00522
00523 vslRemapF( combine_result, re_inputmin, re_inputmax, re_outputmin, re_outputmax, re_disable, re_bias, re_gain, re_result);
00524
00525 vslConvertFloatToColour(re_result, crack_colour);
00526
00527 float snow_float = find_upward( snow_over );
00528 color snow_colour;
00529 vslConvertFloatToColour(snow_float, snow_colour);
00530 return crack_colour;
00531 }
00532
00533 float
00534 do_disp( float mask; color snow)
00535 {
00536
00537 float output_disp = 0;
00538 vslConvertColourToFloat(snow, output_disp);
00539
00540 output_disp *= mask;
00541 return output_disp;
00542
00543 }
00544
00545 #endif