Note: the images on this site are converted to .png from the original outputted .bmp

 Beer Lambert Law


Procedural Textures

  • Started with 2D noise implementation.
  • Expanded to 3D to create solid textures.
  • Implemented by adding a texture class to the renderer and adding a texture field to objects and the scene.
  • on intersecting an object the object’s texture pointer is added to a hit intersection
  • raytrace() checks to see if the texture is null.
  • The texture is displayed by scaling the material’s color with the texture’s noise function’s result.
  • The textures use one of two noise functions, Perlin and Worley
  • I use perlin for textures that need more randomness and worley for ones that follow a pattern

Perlin Noise

    • Based on java version found here:
    • selects noise value based on a permutation table of values from 0 to 255
    • permutation table defaults to the table in the java implementation
    • the permutation table can also be randomly seeded in my implementation with PerlinNoise.seed(unsigned int)
    • Perlin Noise takes a Vector3 position and returns the noise value at that position in the range 0-1
    • Perlin Noise can be generated two ways.  The first is using the PerlinNoise.getNoise(Vector3) function
    • The second is PerlinNoise.turbulence(Vector3, float size), which returns smoothed noise.
      • Size is the initial amplitude, which is halved in a loop.
      • turbulence uses the getNoise function scaled by size and returns the added result


    • Wood Texture
      • to create a wood texture, I use the following formula:
      • n = 20*PerlinNoise(position)
      • texture = n – floor(n);

wood texture mapped to the ground

    • Marble Texture
      • to create a marble texture, I use the following formula:
      • scale = position*period
      • noise = scale.x + scale.y + scale.z + power*turbulence(scale, size)
      • texture = abs ( sin(noise*PI) );

marble texture mapped to the ground

    • Cloud Texture
      • for the cloud texture, I simply return the result of the turbulence function.
      • texture = turbulence(pos, turbSize)
      • I use the cloud texture for the background skyColor by adding a texture field to the Scene() class

Scene skyColor background texture

Worley Noise

  • My implementation is based on the java version here:
  • it has a function WorleyNoise.Noise(Vector3, int, int, std::vector<float>,int)
  • the parameters are the position of the noise to be evaluated, the seed for the random number generator, an int representing which distance function to use, a vector of the distances of features points from the position, and an int representing which combination of closest feature selection to use.
  • it uses a cube representation of the texture
  • generates a LCG random number (Linear congruential generator)
  • Determine a number of feature points
  • use Poisson distribution to randomly place the points in the cube
  • pick the closest point to the position inputed
  • Distances:
    • There are 3 choices for distance and combination functions
    • The Euclidian, Manhattan, and Chebyshev distance functions
    • the choice of:
    • D1 – return closest,
    • D2 – return 2nd_closest – closest,
    • and D3 – return 3rd_closest – closest

Texture on the left Omanyte

Final image with 10 by 10 sampling and depth of 10

  •  Left Omanyte: Worley Noise(Manhattan distance, D3 combining), Ashikhmin material
  • Center Omastar: Perlin Noise(Marble texture), Ashikhmin material
  • Right: Perline Noise(Wood texture), Ashikhmin material
  • Front Helix Fossil: Fresnel Material
  • Sky: Perlin Noise(cloud texture)
  • ground: Worley noise(Euclidian distance, D1 combining), Lambert Material