home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Raytrace & Morphing / SOS-RAYTRACE.ISO / programm / raytrace / polyray / dat / texture.inc < prev   
Encoding:
Text File  |  1994-03-12  |  10.8 KB  |  344 lines
  1. // Various textures
  2. //
  3. // This file requires that "colors.inc" already be parsed
  4. //
  5. if (frame == start_frame) {
  6. //
  7. // Names of the various shading flags
  8. static define shadow_check       1
  9. static define reflect_check      2
  10. static define transmit_check     4
  11. static define two_sided_surface  8
  12. static define check_uv          16
  13. static define cast_shadows      32
  14.  
  15. // Default shading flags during raytracing - everything gets checked.
  16. static define all_shading_flags
  17.    shadow_check + reflect_check + transmit_check + cast_shadows +
  18.    two_sided_surface + check_uv
  19.  
  20. //
  21. // Define a set of shading flags for surfaces that shouldn't have their
  22. // backsided illuminated
  23. static define one_sided_surface
  24.    all_shading_flags - two_sided_surface
  25.  
  26. // Useful definitions to use with noise surfaces.  These
  27. // will come in handy below when we declare marble and
  28. // wood textures.
  29. static define position_plain       0
  30. static define position_objectx     1
  31. static define position_worldx      2
  32. static define position_cylindrical 3
  33. static define position_spherical   4
  34. static define position_radial      5
  35.  
  36. static define lookup_plain    0
  37. static define lookup_sawtooth 1
  38. static define lookup_cos      2
  39. static define lookup_ramp     3
  40.  
  41. static define plain_normal  0
  42. static define bump_normal   1
  43. static define ripple_normal 2
  44. static define dented_normal 3
  45.  
  46. // The standard sort of marble texture
  47. static define white_marble
  48. texture { special shiny { color white_marble_map[marble_fn] } }
  49.  
  50. // Nice blue agate texture
  51. static define blue_agate_map
  52.       color_map([0.0, 0.3, <0, 0, 0.9>, <0, 0, 0.8>]
  53.             [0.3, 1,   <0, 0, 0.8>, <0, 0, 0.4>])
  54. static define sapphire_agate
  55. texture { special shiny { color blue_agate_map[agate_fn] } }
  56.  
  57. // Simple color map texture
  58. static define whorl_texture
  59. texture {
  60.    special shiny {
  61.       color color_map([0.0, 0.3, green,   blue]
  62.               [0.3, 0.6, blue,    skyblue]
  63.               [0.6, 0.8, skyblue, orange]
  64.               [0.8, 1.0, orange,  red])[noise(P)]
  65.       }
  66.    scale <0.5, 0.5, 0.5>
  67.    }
  68.  
  69. // Create a wood texture.  Concentric rings of color
  70. // are wrapped around the z-axis.  There is some turbulence
  71. // in order to keep the rings from looking too perfect.
  72. static define wooden
  73.    texture {
  74.       special shiny {
  75.      color wood_map1[wood_fn]
  76.      position P + 0.5 * dnoise(P, 3)
  77.      }
  78.       }
  79.  
  80. // Define a texture using a color wheel
  81. static define xz_wheel_texture
  82. texture {
  83.    special surface {
  84.       color color_wheel(x, y, z)
  85.       ambient 0.2
  86.       diffuse 0.8
  87.       specular white, 0.2
  88.       microfacet Reitz 10
  89.       }
  90.    }
  91.  
  92. // This is an example of a gradient texture.
  93. static define mountain_color_map
  94.       color_map(
  95.          [-128,   0, blue,  blue]
  96.          [   0,  20, green, green]
  97.          [  20,  40, green, tan]
  98.          [  40,  90, tan,   tan]
  99.          [  90, 128, white, white])
  100. static define mountain_colors
  101. texture { special shiny { color mountain_color_map[y] } }
  102.  
  103. // This makes a nice texture to use on leaves
  104. static define bumpy_green
  105. texture {
  106.    special shiny {
  107.       color green normal N + (dnoise(3*W) - <0.5, 0.5, 0.5>)
  108.       }
  109.    scale <0.02, 0.02, 0.02>
  110.    }
  111.  
  112. // Red dented/wrinkled appearance
  113. static define dented_red
  114. texture {
  115.    special shiny {
  116.       color <1, 0.2, 0.2>
  117.       normal N + (dnoise(2*W) - <0.5,0.5,0.5>)
  118.       }
  119.    }
  120.  
  121. // When used on a big sphere, this makes a nice cloudy sky.  You will
  122. // probably need to scale to make it look good.
  123. static define cloudy_sky_map
  124.       color_map(
  125.      [0.0, 0.6, <0.4, 0.4, 0.4>, <1, 1, 1>]
  126.      [0.6, 0.8, <1, 1, 1>, <0.196078, 0.6, 0.8>]
  127.      [0.8, 1.0, <0.196078, 0.6, 0.8>, <0.196078, 0.6, 0.8>])
  128. static define cloudy_sky
  129. texture {
  130.    special surface {
  131.       color cloudy_sky_map[noise(P)]
  132.       ambient 0.9
  133.       diffuse 0
  134.       specular 0
  135.       }
  136.    }
  137.  
  138. //
  139. // Definitions to make a ripple texture.  Adjust the values of ripple_freq
  140. // and ripple_phase below for the desired effect
  141. //
  142. static define ripple_freq 10
  143. static define ripple_phase 0
  144.  
  145. // Centers of the ripple effect
  146. static define ripple_center1 brownian(black, 2*white)
  147. static define ripple_center2 brownian(black, 2*white)
  148. static define ripple_center3 brownian(black, 2*white)
  149. static define ripple_center4 brownian(black, 2*white)
  150. static define ripple_center5 brownian(black, 2*white)
  151.  
  152. // Direction of travel of the ripples
  153. static define ripple_axis1 (P - ripple_center1)
  154. static define ripple_axis2 (P - ripple_center2)
  155. static define ripple_axis3 (P - ripple_center3)
  156. static define ripple_axis4 (P - ripple_center4)
  157. static define ripple_axis5 (P - ripple_center5)
  158.  
  159. // Piece together the centers to make an overall ripple
  160. static define ripple_val1 cos(|ripple_axis1| * ripple_freq + ripple_phase)
  161. static define ripple_val2 cos(|ripple_axis2| * ripple_freq + ripple_phase)
  162. static define ripple_val3 cos(|ripple_axis3| * ripple_freq + ripple_phase)
  163. static define ripple_val4 cos(|ripple_axis4| * ripple_freq + ripple_phase)
  164. static define ripple_val5 cos(|ripple_axis5| * ripple_freq + ripple_phase)
  165. static define ripple_val ripple_axis1 * ripple_val1 / (5 * |ripple_axis1|) +
  166.           ripple_axis2 * ripple_val2 / (5 * |ripple_axis2|) +
  167.           ripple_axis3 * ripple_val3 / (5 * |ripple_axis3|) +
  168.           ripple_axis4 * ripple_val4 / (5 * |ripple_axis4|) +
  169.           ripple_axis5 * ripple_val5 / (5 * |ripple_axis5|)
  170.  
  171. /* Adjust the color, reflectivity, and scale of this texture for a
  172.    nice ripple effect */
  173. static define basic_ripple_texture
  174. texture {
  175.    special matte {
  176.       color 0.8*white
  177.       normal N + ripple_val
  178.       }
  179.    }
  180.  
  181. static define blue_ripple
  182. texture {
  183.    special shiny {
  184.       color <0.4, 0.4, 1.0>
  185.       normal N + ripple_val
  186.       reflection 0.5
  187.       }
  188.    }
  189.  
  190. /* Bumpy_Silver - */
  191. static define bumpy_silver
  192. texture {
  193.    special surface {
  194.       color 0.9*white
  195.       normal N + 0.2 * (dnoise(5*W) - <0.5,0.5,0.5>)
  196.       ambient 0.05
  197.       diffuse 0.1
  198.       specular 0.9*white, 0.3
  199.       reflection 0.8
  200.       microfacet Cook 5
  201.       }
  202.    }
  203.  
  204. static define dark_wooden wooden
  205.  
  206. /* A fairly diffuse white texture */
  207. static define milky_white
  208. texture { shiny {
  209.    color white
  210.    ambient 0.2
  211.    diffuse 0.1
  212.    transmission white, 0.4, 1.0
  213.    specular white, 0.1
  214.    microfacet Cook 5
  215.    } }
  216.  
  217. /* Tigers eye colors */
  218. static define tigers_eye_colors2 color_map(
  219.    [0.000, 0.115, <0.698, 0.533, 0.122>, 0.000, <0.529, 0.173, 0.071>, 0.000]
  220.    [0.115, 0.230, <0.529, 0.173, 0.071>, 0.000, <0.698, 0.533, 0.122>, 0.000]
  221.    [0.230, 0.336, <0.698, 0.533, 0.122>, 0.000, <0.424, 0.325, 0.075>, 0.000]
  222.    [0.336, 0.460, <0.424, 0.325, 0.075>, 0.000, <0.698, 0.533, 0.122>, 0.000]
  223.    [0.460, 0.628, <0.698, 0.533, 0.122>, 0.000, <0.306, 0.235, 0.055>, 0.000]
  224.    [0.628, 0.708, <0.306, 0.235, 0.055>, 0.000, <0.698, 0.341, 0.122>, 0.000]
  225.    [0.708, 0.796, <0.698, 0.341, 0.122>, 0.000, <0.000, 0.000, 0.000>, 0.000]
  226.    [0.796, 0.858, <0.000, 0.000, 0.000>, 0.000, <0.596, 0.373, 0.106>, 0.000]
  227.    [0.858, 0.982, <0.596, 0.373, 0.106>, 0.000, <0.494, 0.376, 0.086>, 0.000]
  228.    [0.982, 1.000, <0.494, 0.376, 0.086>, 0.000, <0.698, 0.533, 0.122>, 0.000])
  229.  
  230. /* Tigers_Eye1 - A noisy tigers eye texture */
  231. static define Tigers_Eye1
  232. texture {
  233.    special shiny {
  234.       color tigers_eye_colors2[marble_fn]
  235.       }
  236.    }
  237.  
  238. /* Tigers_Eye2 - A fractured tigers eye matrix */
  239. static define noisy_x x + 1.5 * dnoise(P)[0]
  240. static define noisy_y y + 1.5 * dnoise(P)[1]
  241. static define noisy_z y + 1.5 * dnoise(P)[2]
  242. static define noisy_x1 noisy_x - floor(noisy_x)
  243. static define noisy_y1 noisy_y - floor(noisy_y)
  244. static define noisy_z1 noisy_z - floor(noisy_z)
  245. static define noisy_checker3_fn fmod((noisy_x1+noisy_y1+noisy_z1)/3, 1)
  246. static define Tigers_Eye2 texture {
  247.    special shiny { color tigers_eye_colors2[noisy_checker3_fn] }
  248.    scale <0.5, 0.5, 0.5>
  249.    }
  250.  
  251. /* splash1 - A collection of primary colors in a splattered pattern */
  252.  
  253. static define dens1 0.6
  254. static define dens2 (dens1 + 1) / 2
  255. static define splash1_layer1_map color_map(
  256.    [0, dens1, black, 1, black, 1]
  257.    [dens1, dens2, red/3, 0.5, red, 0]
  258.    [dens2, 1, red, red])
  259. static define splash1_layer2_map color_map(
  260.    [0, dens1, black, 1, black, 1]
  261.    [dens1, dens2, blue/3, 0.5, blue, 0]
  262.    [dens2, 1, blue, blue])
  263. static define splash1_layer3_map color_map(
  264.    [0, dens1, black, 1, black, 1]
  265.    [dens1, dens2, green/3, 0.5, green, 0]
  266.    [dens2, 1, green, green])
  267. static define splash1_layer4_map color_map(
  268.    [0, dens1, black, 1, black, 1]
  269.    [dens1, dens2, yellow/3, 0.5, yellow, 0]
  270.    [dens2, 1, yellow, yellow])
  271.  
  272. static define noisy_x3 x + 5 * dnoise(4*P)[0]
  273. static define noisy_y3 y + 5 * dnoise(4*P)[1]
  274. static define noisy_z3 y + 5 * dnoise(4*P)[2]
  275. static define noisy_x4 noisy_x3 - floor(noisy_x3)
  276. static define noisy_y4 noisy_y3 - floor(noisy_y3)
  277. static define noisy_z4 noisy_z3 - floor(noisy_z3)
  278. static define noisy_checker3_fn fmod((noisy_x4+noisy_y4+noisy_z4)/3, 1)
  279.  
  280. static define splash1_layer1
  281. texture { special shiny { color splash1_layer1_map[noisy_checker3_fn] } }
  282.  
  283. static define splash1_layer2
  284. texture {
  285.    special shiny { color splash1_layer2_map[noisy_checker3_fn] }
  286.    scale <0.75, 1.7, 0.9>
  287.    rotate <60,-30, 0>
  288.    }
  289.  
  290. static define splash1_layer3
  291. texture {
  292.    special shiny { color splash1_layer3_map[noisy_checker3_fn] }
  293.    scale <1.5, 0.7, 1.2>
  294.    rotate <0, 30, 20>
  295.    }
  296.  
  297. static define splash1_layer4
  298. texture {
  299.    special shiny { color splash1_layer4_map[noisy_checker3_fn] }
  300.    scale <1.5, 0.7, 1.2>
  301.    rotate <10,-80, 0>
  302.    }
  303.  
  304. static define splash1
  305. texture {
  306.    layered splash1_layer1, splash1_layer2, splash1_layer3,
  307.        splash1_layer4, matte_white
  308.    }
  309.  
  310. /* Lapis_Lazuli -
  311.    Adapted from the Persistence of Vision Raytracer
  312.    Lapis Lazuli texture by Chad Eby */
  313.  
  314. static define lapis_layer1
  315. color_map([0.0, 0.1, blue, midnight_blue]
  316.           [0.1, 0.2, blue, midnight_blue]
  317.           [0.2, 0.3, blue, midnight_blue]
  318.           [0.3, 0.4, blue, midnight_blue]
  319.           [0.4, 0.5, blue, midnight_blue]
  320.           [0.5, 0.75, midnight_blue, slate_blue]
  321.           [0.75, 0.9, slate_blue, gold]
  322.       [0.9, 0.97, midnight_blue, midnight_blue]
  323.           [0.97, 1.0, slate_blue, gold])
  324.  
  325. static define lapis_layer2
  326. color_map([0.0, 0.4, black, 1.0, black, 1.0]
  327.       [0.4, 0.5, black, 1.0, white, 0.6]
  328.       [0.5, 0.7, white, 0.6, white, 0.6]
  329.       [0.7, 0.8, white, 0.6, black, 1.0]
  330.       [0.8, 0.97, black, 1.0, white/2, 0.5]
  331.       [0.97, 0.98, <0.2,0.2,1.0>, 0.5, blue, 0]
  332.       [0.98, 0.99, white, 0.5, white/2, 0.5]
  333.       [0.99, 1.0, white/2, 0.5, blue, 0])
  334.  
  335. static define lapis_layer2_fn sawtooth(x + 2*noise(P, 4))
  336. static define lapis_layer1_fn noise(15*P, 5)
  337. static define Lapis_Lazuli
  338. texture {
  339.    layered
  340.       texture { special shiny { color lapis_layer2[lapis_layer2_fn] } },
  341.       texture { special shiny { color lapis_layer1[lapis_layer1_fn] } }
  342.    }
  343. } // End of definitions
  344.