import MaterialX as mx
from mtlxutils.mxfile import *
from IPython.display import display_markdown

# Load the current standard libraries
currLibrary, currlibFiles, status = MtlxFile.createLibraryDocument()
print(status)

# Load in the old standard libraries
otherVersion = ''
libraryFolders = [ 'libraries1.38' ]
otherLibrary = mx.createDocument()
searchPath = mx.FileSearchPath('../resources/')
# Attempt to preserve the original version of the library
options = mx.XmlReadOptions()
options.upgradeVersion = False

libFiles = mx.loadLibraries(libraryFolders, searchPath, otherLibrary)
print('- Loaded %d old library definitions from %d files' % (len(otherLibrary.getNodeDefs()), len(libFiles)))

- Loaded 780 library definitions from 50 files
- Loaded 0 old library definitions from 0 files

otherLibrary2 = mx.createDocument()
otherVersion2 = ''
loadedLibraries = set()
readOptions = mx.XmlReadOptions()
readOptions.upgradeVersion = False
for libraryName in libraryFolders:
    libraryPath = searchPath.find(libraryName)
    for path in libraryPath.getSubDirectories():
          for filename in path.getFilesInDirectory('mtlx'):
                file = path / filename;
                if file.asString() not in loadedLibraries:
                    mx.loadLibrary(file, otherLibrary2, searchPath, readOptions)                    
                    loadedLibraries.add(file.asString())
                    otherVersion2 = otherLibrary2.getVersionString()  

print('Read in %d definitions from %d files. Version: %s' % 
      (len(otherLibrary2.getNodeDefs()), len(loadedLibraries), otherVersion2))

Read in 0 definitions from 0 files. Version:

print('- Current library / package version: %s' % mx.getVersionString())
print('- Old library version: %s' % otherLibrary.getVersionString())

- Current library / package version: 1.39.2
- Old library version: 1.39

# Compare number of nodedefs
currNodeDefs = currLibrary.getNodeDefs()
currNodeDefsCount = len(currNodeDefs)
otherNodeDefs = otherLibrary.getNodeDefs()
otherNodeDefsCount = len(otherNodeDefs) # There seems to be no way to get the previous version?
print('There are %d new definitions.' % (currNodeDefsCount - otherNodeDefsCount))
print('- Current library has %d nodedefs' % currNodeDefsCount)
print('- Other library has %d nodedefs' % otherNodeDefsCount)

There are 780 new definitions.
- Current library has 780 nodedefs
- Other library has 0 nodedefs

# Create dictionary of current node definitions
currNodeDefSet = {}
for nodeDef in currNodeDefs:
    currNodeDefSet[nodeDef.getName()] = nodeDef

# Create dictionary of old node definitions
otherNodeDefSet = {}
for nodeDef in otherNodeDefs:
    otherNodeDefSet[nodeDef.getName()] = nodeDef

    
# Find out if any definitions were removed
removedNodeDefs = []
for nodeDef in otherNodeDefs:
    if nodeDef.getName() not in currNodeDefSet:
        removedNodeDefs.append(nodeDef)

text = ''  
if removedNodeDefs:
    removedNodeDefs = sorted(removedNodeDefs, key=lambda x: x.getName())
    text = text + '| Name | Category |\n'
    text = text + '| :--- | :--- |\n'
    for nd in removedNodeDefs:
        text = text + '| %s | %s |\n' % (nd.getName(), nd.getNodeString())

    delta = '%d node definitions removed' % len(removedNodeDefs)
    text = '<details open><summary>' + delta + '</summary>\n\n' + text + '\n' + '</details>\n' 
    display_markdown(text, raw=True)

# Find out what new definitions have been added.
# Cache common definitions in `compareDetails` for further comparison.
compareDetails = []
newNodeDefs = []
for nodeDef in currNodeDefs:
    if nodeDef.getName() not in otherNodeDefSet:
        newNodeDefs.append(nodeDef)
    else:
        # Cache these two for more comparison
        otherNodeDef = otherNodeDefSet[nodeDef.getName()]
        compareDetails.append( [otherNodeDef, nodeDef] )

text = ''
if newNodeDefs:
    newNodeDefs = sorted(newNodeDefs, key=lambda x: x.getNodeString())
    text = text + '| Name | Category | NodeGroup |\n'
    text = text + '| :--- | :--- | :---| \n'
    for nd in newNodeDefs:
        text = text + '| <a href="../documents/definitions/%s.html">%s</a> | %s | %s |\n' % (nd.getNodeString(), nd.getName(), nd.getNodeString(), nd.getNodeGroup())

    delta = '%d node definitions added. (Sorted by category)' % len(newNodeDefs)
    text = '<details open><summary>' + delta + '</summary>\n\n' + text + '\n' + '</details>\n' 
    display_markdown(text, raw=True)

oldCategories = set()
for nodeDef in otherNodeDefs:
    oldCategories.add(nodeDef.getNodeString())
# Sort old categories
oldCategories = sorted(oldCategories)

newCategories = {}
for nodeDef in currNodeDefs:
    newCategory = nodeDef.getNodeString()
    if newCategory not in oldCategories:
        newCategories[newCategory] = [ nodeDef.getNodeGroup(), nodeDef.getType() ]        

if newCategories:
    text = '| Node category | Node group | Type |\n'
    text = text + '| --- | --- | --- |\n' 
    sorted_keys = sorted(newCategories.keys())
    sortedNewCategories = {}
    for key in sorted_keys:
        sortedNewCategories[key] = newCategories[key]                                 
    for category in sortedNewCategories:
        text = text + '| [%s](../documents/definitions/%s.html) | %s | %s |\n' % (category, category, newCategories[category][0], newCategories[category][1])

    delta = '%d new node categories found' % len(newCategories)
    text = '<details open><summary>' + delta + '</summary>\n\n' + text + '\n' + '</details>\n' 
    display_markdown(text, raw=True)

def getActiveChild(element, name):
    '''
    Check if a child with a given name exists in the inheritance hierarchy for a given Element.
    '''
    for elem in element.traverseInheritance():
        child = elem.getChild(name)
        if child:
            return child
    return None

def getActiveChildren(element):
    '''
    Get all children (included inherited ones) for a given Element.
    '''
    children = []
    childset = set()
    for elem in element.traverseInheritance():
        for child in elem.getChildren():
            if child.getName() not in childset:
                children.append(child)
                childset.add(child.getName())
    return children    

def getActiveAttribute(element, name):
    ''' 
    Check if an attribute with a given name exists in the inheritance hierarchy for a given Element.
    '''
    for elem in element.traverseInheritance():
        child = elem.getAttribute(name)
        if child:
            return child
    return None

def getActiveAttributes(element):
    '''
    Get all attributes (included inherited ones) for a given Element.
    '''
    children = []
    childset = set()
    for elem in element.traverseInheritance():
        for child in elem.getAttributeNames():
            if child not in childset:
                children.append(child)
                childset.add(child)
    return children

def diffLists(list1, list2):
    '''
    Return items in either list1 or list2, and in both.
    '''
    if list1 != list2:
        # Find items in list1 not in list2
        onlyList1 = [item for item in list1 if item not in list2]
        # Find items in list2 not in list1
        onlyList2 = [item for item in list2 if item not in list1]
        # Find items in both lists
        common = [item for item in list1 if item in list2]
        return onlyList1, onlyList2, common
    return [], [], list1

def compareElements(nd1, nd2, indent, log):
    '''
    Compare two elements and print any differences.

    Tests performed:
    1. Element category
    2. Element attribute names
    3. Elememt attribute values
    4. Child Element count and what children are present in one but not the other.
    5. Recursing on child Elements.
    '''
    if not nd1 or not nd2:
        return True

    differs = False

    if nd1.getCategory() != nd2.getCategory():
        log.append(indent + '- Category changed on: `%s` from `%s` to `%s`' % (nd1.getName(), nd2.getCategory(), nd1.getCategory()))
        differs = True

    # Compare attributes.
    # Note: This does not work properly with inheritance yet.
    onlynd1, onlynd2, common = diffLists(getActiveAttributes(nd1), getActiveAttributes(nd2))
    if len(onlynd1) > 0 or len(onlynd2) > 0:
        for item in onlynd1:
            log.append(indent + '- attribute: `%s`=( `%s` ) removed from: `%s`' % 
                       ( item, getActiveAttribute(nd1, item), nd1.getName()))
        for item in onlynd2:
            log.append(indent + '- attribute: `%s`=( `%s` ) added to: `%s`' % 
                       ( item, getActiveAttribute(nd2, item), nd2.getName()))
        differs = True

    for attr in common:
        if nd2.getAttribute(attr) != nd1.getAttribute(attr):
            log.append(indent + '  - attribute: `%s` changed on `%s` from `( %s )` to `( %s )`' % 
                       (attr, nd1.getName(), nd1.getAttribute(attr), nd2.getAttribute(attr)))
            differs = True

    # Compare children. This also checks for children that inherited 
    c1 = [c.getName() for c in getActiveChildren(nd1)] 
    c2 = [c.getName() for c in getActiveChildren(nd2)]
    if len(c1) != len(c2):
        log.append(indent + '- Number of children on: `%s` changed from ( %s ) to ( %s )' % (nd1.getName(), len(c1), len(c2)))
        differs = True

    # Get list of added, removed, and common children.
    onlynd1, onlynd2, common = diffLists(c1, c2)

    # Log children that are removed. Emit value if is a value element.
    for childName in onlynd1:
        child = nd1.getChild(childName)
        childName = child.getNamePath().removeprefix(child.getParent().getNamePath())
        childType = child.getCategory()
        if child.isA(mx.ValueElement):
            log.append(indent + '- %s `%s` removed from `%s`. Value=( %s )' % (childType, childName, nd1.getNamePath(), child.getValueString()))
        else:
            log.append(indent + '- %s `%s` removed from `%s`' % (childType, childName, nd1.getNamePath()))
        differs = True

    # Log child that are added. Emit value if is a value element.
    for childName in onlynd2:
        child = nd2.getChild(childName)
        childName = child.getNamePath().removeprefix(child.getParent().getNamePath())
        childType = child.getCategory()
        if child.isA(mx.ValueElement):
            log.append(indent + '- %s `%s` added to `%s`. Value=( %s )' % (childType, childName, nd2.getNamePath(), child.getValueString()))
        else:
            log.append(indent + '- %s `%s` add to `%s`' % (childType, childName, nd2.getNamePath()))
        differs = True

    # Recurse on common children.
    for childName in common:
        c1child = getActiveChild(nd1, childName)
        c2child = getActiveChild(nd2, childName)
        if compareElements(c1child, c2child, indent, log):
            differs = True

    return differs

#text = '### Compare old and current definitions in detail\n'
text = '| Name | Change  |\n'
text = text + '| --- | --- |\n'

changed = 0
for item in compareDetails:
    nd1 = item[0]
    nd2 = item[1]
    # Use the built in comparitor first
    difference = (nd1 != nd2)
    if difference:
        # Perform details comparison
        text = text + '| <a href="../documents/definitions/%s.html">%s</a> | ' % (nd1.getNodeString(), nd1.getName())
        log = []
        difference = compareElements(nd1, nd2, '', log) 
        if difference:
            for line in log:
                text = text + line + '<br>'
            text = text + '|\n'
            changed = changed + 1

delta = '%d definitions modified' % changed
text = '<details open><summary>' + delta + '</summary>\n\n' + text + '\n' + '</details>\n' 
display_markdown(text, raw=True)

## Get old targets
oldTargets = []
for target in otherLibrary.getTargetDefs():
    oldTargets.append(target.getName())
print('Old targets:', oldTargets)

## Check for new targets
currTargets = []
for target in currLibrary.getTargetDefs():
    currTargets.append(target.getName())
print('Current targets:', currTargets)

newTargets = list(set(currTargets) - set(oldTargets))
if newTargets:
    print('New targets:', newTargets)

Old targets: []
Current targets: ['essl', 'genglsl', 'genmdl', 'genmsl', 'genosl']
New targets: ['genmsl', 'essl', 'genosl', 'genglsl', 'genmdl']

def get_implementations(nodedefs, target, allimpls):
    '''
    Build a dictionary of nodedefs and their corresponding implementations.
    
    The dictionary is keyed by the nodedef name and the value is a list of the implementation and 
    source file name.
    '''
    implementations = {}
    for nodedef in nodedefs:
        impl = nodedef.getImplementation(target)
        # This may be a nodegraph or an implementation
        if impl:
            # Skip if already used
            if impl.getName() in allimpls:
                continue
            # Skip if it's a nodegraph and target is not empty
            if len(target) > 0 and impl.isA(mx.NodeGraph):
                continue

            if target != 'essl':
                allimpls.add(impl.getName())
            implementations[nodedef.getName()] = [impl, mx.FilePath(impl.getSourceUri()).getBaseName()]
    return implementations

def print_implementations(nodedefs, targets, allimpls, title):
    '''
    Display all the implementations for the given nodedefs and targets.
    '''
    display_markdown(title, raw=True)
    for target in targets:
        impls = get_implementations(nodedefs, target, allimpls)

        if len(target) == 0:
            result = '| Definition | NodeGraph | File |\n'
        else:
            result = '| Definition | Implementation | File |\n'
        result = result + '| --- | --- | --- |\n'
        for impl in impls:
            result = result + '|' + impl + '|' + impls[impl][0].getName() + '|' + impls[impl][1] + '\n'
        text = '<details><summary>' + str(len(impls)) + (' shaders: ' + target if target else ' node graphs') + '</summary>\n\n' + result+ '\n</details>\n' 
        display_markdown(text, raw=True)

# Scan for all the current targets
title = '**Current Library Definitions / Implementations**\n'
alltargets = currTargets
alltargets.append('')
allimpls = set()
print_implementations(currNodeDefs, alltargets, allimpls, title)

# Scan for all the previous targets
title = '**Previous Library Definitions / Implementations**\n'
alltargets = oldTargets
alltargets.append('')
allimpls = set()
print_implementations(otherNodeDefs, alltargets, allimpls, title)

# Collect all Implementation and NodeGraph elements from two libraries
allImpls = set()
implsNoDef = set()
for i in currLibrary.getImplementations():
    if i.getNodeDef():
        allImpls.add(i.getName())
    else:
        implsNoDef.add(i.getName())
for i in currLibrary.getNodeGraphs():
    if i.getNodeDef():
        allImpls.add(i.getName())
    else:
        implsNoDef.add(i.getName())
print('Current implementation count:', len(allImpls))

allImpls2 = set()
for i in otherLibrary.getImplementations():
    if i.getNodeDef():
        allImpls2.add(i.getName())
        allImpls.add(i.getName())
    else:
        implsNoDef.add(i.getName())
for i in otherLibrary.getNodeGraphs():
    if i.getNodeDef():
        allImpls2.add(i.getName())
        allImpls.add(i.getName())
print('Previous implementation count:', len(allImpls2))

Current implementation count: 1878
Previous implementation count: 0

title = '| Name | Node Category | Node Type |\n'
title = title + '| --- | --- | --- |\n'

allImpls = sorted(allImpls)
added = 0
addedText = title
removed = 0
removedText = title

title = '| Name | Change |\n| --- | --- |\n'
changed = 0
changedText = title

for item in allImpls:
    
    # Check for new implementations. Note that we check for source implementations
    # as well as node graph implementations.
    impl = otherLibrary.getImplementation(item)
    if not impl:
        impl = otherLibrary.getNodeGraph(item)
    if not impl:
        ns = 'None'
        nt = 'None'
        curimpl = currLibrary.getChild(item)
        if curimpl:
            nd = curimpl.getNodeDef()
            if nd:
                ns = nd.getNodeString()
                nt = nd.getType()
        addedText = addedText + '| %s | <a href="../documents/definitions/%s.html">%s</a> | %s | \n' % (item, ns, ns, nt) 
        added = added + 1
        continue
    
    # Check for implementations which have been removed. Note that we check for source implementations
    # as well as node graph implementations.
    impl2 = currLibrary.getImplementation(item)
    if not impl2:
        impl2 = currLibrary.getNodeGraph(item)
    if not impl2:
        oldimpl = currLibrary.getChild(item)
        if oldimpl:
            nd = oldimpl.getNodeDef()
            if nd:
                ns = nd.getNodeString()
                nt = nd.getType()        
        removedText = removedText + '| %s | %s | %s | \n' % (item, ns, nt)
        removed = removed + 1
        continue
    
    # Check for implementations which have been modified.
    # Use the built in comparitor first before performing a detailed comparison.
    difference = (impl != impl2)
    if difference:
        ns = 'None'
        nt = 'None'
        if impl2:
            nd = impl2.getNodeDef()
            if nd:
                ns = nd.getNodeString()                
        changedText = changedText + '| <a href="../documents/definitions/%s.html">%s</a> | ' % (ns, item)
        # Perform detailed comparison
        log = []
        difference = compareElements(impl, impl2, '', log) 
        if difference:
            for line in log:
                changedText = changedText + line + '<br>'
            changedText = changedText + '|\n'
            changed = changed + 1


delta = '%d implementations added' % added
text = '<details><summary>' + delta + '</summary>\n\n' + addedText + '\n' + '</details>\n' 
display_markdown(text, raw=True)

delta = '%d implementations removed' % removed
text = '<details><summary>' + delta + '</summary>\n\n' +  removedText + '\n' + '</details>\n' 
display_markdown(text, raw=True)

delta = '%d implementations modified' % changed
text = '<details><summary>' + delta + '</summary>\n\n' + changedText + '\n' + '</details>\n' 
display_markdown(text, raw=True)

Library Comparison¶

Library Loading¶

Testing for Definition Additions and Removals¶

Detailed Element Comparison¶

Target and Implementation Comparison¶

Target Check¶

Implementation Check¶

Listing Implementations¶

Comparing Implementations¶

Higher Level Comparisons¶

Node category	Node group	Type
LamaAdd	pbr	EDF
LamaConductor	pbr	BSDF
LamaDielectric	pbr	BSDF
LamaDiffuse	pbr	BSDF
LamaEmission	pbr	EDF
LamaGeneralizedSchlick	pbr	BSDF
LamaIridescence	pbr	BSDF
LamaLayer	pbr	BSDF
LamaMix	pbr	EDF
LamaSSS	pbr	BSDF
LamaSheen	pbr	BSDF
LamaSurface	pbr	material
LamaTranslucent	pbr	BSDF
UsdPreviewSurface	pbr	surfaceshader
UsdPrimvarReader	geometric	vector4
UsdTransform2d	math	vector2
UsdUVTexture	texture2d	multioutput
absorption_vdf	pbr	VDF
absval	math	vector4
acescg_to_lin_rec709	colortransform	color4
acos	math	vector4
add	math	matrix44
adobergb_to_lin_rec709	colortransform	color4
and	conditional	boolean
anisotropic_vdf	pbr	VDF
artistic_ior	pbr	multioutput
asin	math	vector4
atan2	math	vector4
bitangent	geometric	vector3
blackbody	pbr	color3
blur	convolution2d	vector4
bump	geometric	vector3
burley_diffuse_bsdf	pbr	BSDF
burn	compositing	color4
ceil	math	integer
cellnoise2d	procedural2d	float
cellnoise3d	procedural3d	float
checkerboard	procedural2d	color3
chiang_hair_absorption_from_color	pbr	vector3
chiang_hair_bsdf	pbr	BSDF
chiang_hair_roughness	pbr	multioutput
circle	procedural2d	float
clamp	math	vector4
cloverleaf	procedural2d	float
colorcorrect	adjustment	color4
combine2	channel	vector4
combine3	channel	vector3
combine4	channel	vector4
conductor_bsdf	pbr	BSDF
conical_edf	pbr	EDF
constant	procedural	filename
contrast	adjustment	vector4
convert	shader	surfaceshader
cos	math	vector4
creatematrix	math	matrix44
crosshatch	procedural2d	color3
crossproduct	math	vector3
deon_hair_absorption_from_melanin	pbr	vector3
determinant	math	float
dielectric_bsdf	pbr	BSDF
difference	compositing	color4
directional_light	light	lightshader
disjointover	compositing	color4
disney_principled	pbr	surfaceshader
displacement	pbr	displacementshader
distance	math	float
divide	math	vector4
dodge	compositing	color4
dot	organization	lightshader
dotproduct	math	float
exp	math	vector4
extract	channel	float
facingratio	npr	float
floor	math	integer
fractal3d	procedural3d	vector4
frame	application	float
g18_rec709_to_lin_rec709	colortransform	color4
g22_ap1_to_lin_rec709	colortransform	color4
g22_rec709_to_lin_rec709	colortransform	color4
generalized_schlick_bsdf	pbr	BSDF
generalized_schlick_edf	pbr	EDF
geomcolor	geometric	color4
geompropvalue	geometric	vector4
geompropvalueuniform	geometric	filename
glossiness_anisotropy	pbr	vector2
gltf_colorimage	texture2d	multioutput
gltf_image	texture2d	vector3
gltf_iridescence_thickness	texture2d	float
gltf_normalmap	texture2d	vector3
gltf_pbr	pbr	surfaceshader
gooch_shade	npr	color3
grid	procedural2d	color3
heighttonormal	convolution2d	vector3
hexagon	procedural2d	float
hsvadjust	adjustment	color4
hsvtorgb	adjustment	color4
ifequal	conditional	boolean
ifgreater	conditional	boolean
ifgreatereq	conditional	boolean
image	texture2d	vector4
in	compositing	color4
inside	compositing	color4
invert	math	vector4
invertmatrix	math	matrix44
layer	pbr	BSDF
light	pbr	lightshader
lin_adobergb_to_lin_rec709	colortransform	color4
lin_displayp3_to_lin_rec709	colortransform	color4
line	procedural2d	float
ln	math	vector4
luminance	adjustment	color4
magnitude	math	float
mask	compositing	color4
matte	compositing	color4
max	math	vector4
measured_edf	pbr	EDF
min	math	vector4
minus	compositing	color4
mix	compositing	volumeshader
modulo	math	vector4
multiply	math	vector4
noise2d	procedural2d	vector4
noise3d	procedural3d	vector4
normal	geometric	vector3
normalize	math	vector4
normalmap	math	vector3
not	conditional	boolean
open_pbr_anisotropy	pbr	vector2
open_pbr_surface	pbr	surfaceshader
open_pbr_surface_to_standard_surface	translation	multioutput
or	conditional	boolean
oren_nayar_diffuse_bsdf	pbr	BSDF
out	compositing	color4
outside	compositing	color4
over	compositing	color4
overlay	compositing	color4
place2d	math	vector2
plus	compositing	color4
point_light	light	lightshader
position	geometric	vector3
power	math	vector4
premult	compositing	color4
ramp	procedural2d	color4
ramp4	procedural2d	vector4
ramp_gradient	procedural2d	color4
ramplr	procedural2d	vector4
ramptb	procedural2d	vector4
randomcolor	procedural3d	color3
randomfloat	procedural	float
range	adjustment	vector4
rec709_display_to_lin_rec709	colortransform	color4
reflect	math	vector3
refract	math	vector3
remap	adjustment	vector4
rgbtohsv	adjustment	color4
rotate2d	math	vector2
rotate3d	math	vector3
roughness_anisotropy	pbr	vector2
roughness_dual	pbr	vector2
round	math	integer
safepower	math	vector4
saturate	adjustment	color4
screen	compositing	color4
separate2	channel	multioutput
separate3	channel	multioutput
separate4	channel	multioutput
sheen_bsdf	pbr	BSDF
sign	math	vector4
sin	math	vector4
smoothstep	adjustment	vector4
splitlr	procedural2d	vector4
splittb	procedural2d	vector4
spot_light	light	lightshader
sqrt	math	vector4
srgb_displayp3_to_lin_rec709	colortransform	color4
srgb_texture_to_lin_rec709	colortransform	color4
standard_surface	pbr	surfaceshader
standard_surface_to_UsdPreviewSurface	translation	multioutput
standard_surface_to_gltf_pbr	translation	multioutput
standard_surface_to_open_pbr_surface	translation	multioutput
subsurface_bsdf	pbr	BSDF
subtract	math	matrix44
surface	pbr	surfaceshader
surface_unlit	shader	surfaceshader
surfacematerial	material	material
switch	conditional	matrix44
tan	math	vector4
tangent	geometric	vector3
texcoord	geometric	vector3
tiledcircles	procedural2d	color3
tiledcloverleafs	procedural2d	color3
tiledhexagons	procedural2d	color3
tiledimage	texture2d	vector4
time	application	float
transformmatrix	math	vector4
transformnormal	math	vector3
transformpoint	math	vector3
transformvector	math	vector3
translucent_bsdf	pbr	BSDF
transpose	math	matrix44
trianglewave	math	float
triplanarprojection	texture3d	vector4
unifiednoise2d	procedural2d	float
unifiednoise3d	procedural3d	float
uniform_edf	pbr	EDF
unpremult	compositing	color4
viewdirection	npr	vector3
volume	pbr	volumeshader
volumematerial	material	material
worleynoise2d	procedural2d	vector3
worleynoise3d	procedural3d	vector3
xor	conditional	boolean