#ifndef(CR_SOLID_INC)
#declare CR_SOLID_INC = on;

#include "transforms.inc"

#ifndef (fn_FIX)
#declare fn_FIX = function {1}
#end

#macro _C(_TC) #local _RC = _TC; _RC #end

// CrSolid Macro: produce solid crackle of a given pigment
//
//   R      = average radius of each element
//   pig    = pigment to crackle
//   pMax   = maximum colour values of pigment

#macro CrSolid (R,pig,pMax)

  #local M = colour pMax;  
  #local M = <max(M.x,1),max(M.y,1),max(M.z,1),max(M.filter,1),max(M.transmit,1)>;
  
  // these are the functions to give local x and y values ...
  #local fn_crack  = function { pattern { crackle form <1,0,0> } }
  
  #local fn_x = function { fn_crack(x,y,z)*(fn_crack(x+0.0005,y,z)-fn_crack(x-0.0005,y,z))/0.001 }
  #local fn_y = function { fn_crack(x,y,z)*(fn_crack(x,y+0.0005,z)-fn_crack(x,y-0.0005,z))/0.001 }
  #local fn_z = function { fn_crack(x,y,z)*(fn_crack(x,y,z+0.0005)-fn_crack(x,y,z-0.0005))/0.001 }

  #local fn_pig = function { pigment { pig } }
  
  function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).transmit/_C(M.transmit) }
  pigment_map {
    [0
      function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).filter/_C(M.filter) }
      pigment_map {
        [0 
          average
          pigment_map {
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).x/_C(M.x) } colour_map {[0 rgb 0][1 rgb M.x*3*x]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).y/_C(M.y) } colour_map {[0 rgb 0][1 rgb M.y*3*y]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).z/_C(M.z) } colour_map {[0 rgb 0][1 rgb M.z*3*z]} ]
          }
        ]
        [1 
          average
          pigment_map {
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).x/_C(M.x) } colour_map {[0 filter M.filter][1 rgb M.x*3*x filter M.filter]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).y/_C(M.y) } colour_map {[0 filter M.filter][1 rgb M.y*3*y filter M.filter]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).z/_C(M.z) } colour_map {[0 filter M.filter][1 rgb M.z*3*z filter M.filter]} ]
          }
        ]
      }
    ]
    [1
      function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).filter/_C(M.filter) }
      pigment_map {
        [0 
          average
          pigment_map {
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).x/_C(M.x) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.x*3*x transmit M.transmit]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).y/_C(M.y) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.y*3*y transmit M.transmit]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).z/_C(M.z) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.z*3*z transmit M.transmit]} ]
          }
        ]
        [1 
          average
          pigment_map {
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).x/_C(M.x) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.x*3*x filter M.filter transmit M.transmit]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).y/_C(M.y) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.y*3*y filter M.filter transmit M.transmit]} ]
            [ function { fn_pig(x-R*fn_x(x/R,y/R,z/R),y-R*fn_y(x/R,y/R,z/R),z-R*fn_z(x/R,y/R,z/R)).z/_C(M.z) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.z*3*z filter M.filter transmit M.transmit]} ]
          }
        ]
      }
    ]
  }
  
#end // CrSolid()

// MapTest Macro: should map input exactly to output for a given pigment
//
//   R      = not used (kept for same syntax as CrSolid)
//   pig    = pigment to crackle
//   pMax   = maximum colour values of pigment

#macro MapTest (R,pig,pMax)

  #local M = rgbft 0 + pMax;  
  #local M = <max(M.x,1),max(M.y,1),max(M.z,1),max(M.filter,1),max(M.transmit,1)>;
  
  #local fn_pig = function { pigment { pig } }
  
  function { fn_pig(x,y,z).transmit/_C(M.transmit) }
  pigment_map {
    [0
      function { fn_pig(x,y,z).filter/_C(M.filter) }
      pigment_map {
        [0 
          average
          pigment_map {
            [ function { fn_pig(x,y,z).x/_C(M.x) } colour_map {[0 rgb 0][1 rgb M.x*3*x]} ]
            [ function { fn_pig(x,y,z).y/_C(M.y) } colour_map {[0 rgb 0][1 rgb M.y*3*y]} ]
            [ function { fn_pig(x,y,z).z/_C(M.z) } colour_map {[0 rgb 0][1 rgb M.z*3*z]} ]
          }
        ]
        [1 
          average
          pigment_map {
            [ function { fn_pig(x,y,z).x/_C(M.x) } colour_map {[0 filter M.filter][1 rgb M.x*3*x filter M.filter]} ]
            [ function { fn_pig(x,y,z).y/_C(M.y) } colour_map {[0 filter M.filter][1 rgb M.y*3*y filter M.filter]} ]
            [ function { fn_pig(x,y,z).z/_C(M.z) } colour_map {[0 filter M.filter][1 rgb M.z*3*z filter M.filter]} ]
          }
        ]
      }
    ]
    [1
      function { fn_pig(x,y,z).filter/_C(M.filter) }
      pigment_map {
        [0 
          average
          pigment_map {
            [ function { fn_pig(x,y,z).x/_C(M.x) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.x*3*x transmit M.transmit]} ]
            [ function { fn_pig(x,y,z).y/_C(M.y) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.y*3*y transmit M.transmit]} ]
            [ function { fn_pig(x,y,z).z/_C(M.z) } colour_map {[0 rgb 0 transmit M.transmit][1 rgb M.z*3*z transmit M.transmit]} ]
          }
        ]
        [1 
          average
          pigment_map {
            [ function { fn_pig(x,y,z).x/_C(M.x) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.x*3*x filter M.filter transmit M.transmit]} ]
            [ function { fn_pig(x,y,z).y/_C(M.y) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.y*3*y filter M.filter transmit M.transmit]} ]
            [ function { fn_pig(x,y,z).z/_C(M.z) } colour_map {[0 filter M.filter transmit M.transmit][1 rgb M.z*3*z filter M.filter transmit M.transmit]} ]
          }
        ]
      }
    ]
  }
  
#end // MapTest()

#end // ifndef(CR_SOLID_INC)