ImportLDraw/loadldraw/loadldraw.py

# -*- coding: utf-8 -*-
"""Load LDraw GPLv2 license.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

"""

"""
Import LDraw

This module loads LDraw compatible files into Blender. Set the
Options first, then call loadFromFile() function with the full
filepath of a file to load.

Accepts .io, .mpd, .ldr, .l3b, and .dat files.

Toby Nelson - [email protected]
"""

import os
import sys
import math
import mathutils
import traceback
import glob
import bpy
import datetime
import struct
import re
import bmesh
import copy
import platform
import itertools
import operator
import zipfile
import tempfile

from pprint import pprint

# **************************************************************************************
def linkToScene(ob):
    if bpy.context.collection.objects.find(ob.name) < 0:
        bpy.context.collection.objects.link(ob)

# **************************************************************************************
def linkToCollection(collectionName, ob):
    # Add object to the appropriate collection
    if hasCollections:
        if bpy.data.collections[collectionName].objects.find(ob.name) < 0:
            bpy.data.collections[collectionName].objects.link(ob)
    else:
        bpy.data.groups[collectionName].objects.link(ob)

# **************************************************************************************
def unlinkFromScene(ob):
    if bpy.context.collection.objects.find(ob.name) >= 0:
        bpy.context.collection.objects.unlink(ob)

# **************************************************************************************
def selectObject(ob):
    ob.select_set(state=True)
    bpy.context.view_layer.objects.active = ob

# **************************************************************************************
def deselectObject(ob):
    ob.select_set(state=False)
    bpy.context.view_layer.objects.active = None

# **************************************************************************************
def addPlane(location, size):
    bpy.ops.mesh.primitive_plane_add(size=size, enter_editmode=False, location=location)

# **************************************************************************************
def useDenoising(scene, useDenoising):
    if hasattr(getLayers(scene)[0], "cycles"):
        getLayers(scene)[0].cycles.use_denoising = useDenoising

# **************************************************************************************
def getLayerNames(scene):
    return list(map((lambda x: x.name), getLayers(scene)))

# **************************************************************************************
def deleteEdge(bm, edge):
    bmesh.ops.delete(bm, geom=edge, context='EDGES')

# **************************************************************************************
def getLayers(scene):
    # Get the render/view layers we are interested in:
    return scene.view_layers

# **************************************************************************************
def getDiffuseColor(color):
    return color + (1.0,)

# **************************************************************************************
def ShowMessageBox(message = "", title = "Message Box", icon = 'INFO'):
    def draw(self, context):
        self.layout.label(text=message)

    bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)


# **************************************************************************************
# **************************************************************************************
class Options:
    """User Options"""

    # Full filepath to ldraw folder. If empty, some standard locations are attempted
    ldrawDirectory     = r""            # Full filepath to the ldraw parts library (searches some standard locations if left blank)
    instructionsLook   = False          # Set up scene to look like Lego Instruction booklets
    #scale              = 0.01           # Size of the lego model to create. (0.04 is LeoCAD scale)
    realScale          = 1              # Scale of lego model to create (1 represents real Lego scale)
    useUnofficialParts = True           # Additionally searches <ldraw-dir>/unofficial/parts and /p for files
    resolution         = "Standard"     # Choose from "High", "Standard", or "Low"
    defaultColour      = "4"            # Default colour ("4" = red)
    createInstances    = True           # Multiple bricks share geometry (recommended)
    useColourScheme    = "lgeo"         # "ldraw", "alt", or "lgeo". LGEO gives the most true-to-life colours.
    numberNodes        = True           # Each node's name has a numerical prefix eg. 00001_car.dat (keeps nodes listed in a fixed order)
    removeDoubles      = True           # Remove duplicate vertices (recommended)
    smoothShading      = True           # Smooth the surface normals (recommended)
    edgeSplit          = True           # Edge split modifier (recommended if you use smoothShading)
    gaps               = True           # Introduces a tiny space between each brick
    realGapWidth       = 0.0002         # Width of gap between bricks (in metres)
    curvedWalls        = True           # Manipulate normals to make surfaces look slightly concave
    importCameras      = True           # LeoCAD can specify cameras within the ldraw file format. Choose to load them or ignore them.
    positionObjectOnGroundAtOrigin = True   # Centre the object at the origin, sitting on the z=0 plane
    flattenHierarchy   = False          # All parts are under the root object - no sub-models
    minifigHierarchy   = True           # Parts of minifigs are automatically parented to each other in a hierarchy
    flattenGroups      = False          # All LEOCad groups are ignored - no groups
    usePrincipledShaderWhenAvailable = True  # Use the new principled shader
    scriptDirectory    = os.path.dirname( os.path.realpath(__file__) )

    # We have the option of including the 'LEGO' logo on each stud
    useLogoStuds       = False          # Use the studs with the 'LEGO' logo on them
    logoStudVersion    = "4"            # Which version of the logo to use ("3" (flat), "4" (rounded) or "5" (subtle rounded))
    instanceStuds      = False          # Each stud is a new Blender object (slow)

    # LSynth (http://www.holly-wood.it/lsynth/tutorial-en.html) is a collection of parts used to render string, hoses, cables etc
    useLSynthParts     = True           # LSynth is used to render string, hoses etc.
    LSynthDirectory    = r""            # Full path to the lsynth parts (Defaults to <ldrawdir>/unofficial/lsynth if left blank)
    studLogoDirectory  = r""            # Optional full path to the stud logo parts (if not found in unofficial directory)

    # Ambiguous Normals
    # Older LDraw parts (parts not yet BFC certified) have ambiguous normals.
    # We resolve this by creating double sided faces ("double") or by taking a best guess ("guess")
    resolveAmbiguousNormals = "guess"   # How to resolve ambiguous normals

    overwriteExistingMaterials = True   # If there's an existing material with the same name, do we overwrite it, or use it?
    overwriteExistingMeshes = True      # If there's an existing mesh with the same name, do we overwrite it, or use it?
    verbose            = 1              # 1 = Show messages while working, 0 = Only show warnings/errors

    addBevelModifier   = True           # Adds a bevel modifier to each part (for rounded edges)
    bevelWidth         = 0.5            # Width of bevel

    addWorldEnvironmentTexture = True   # Add an environment texture
    addGroundPlane = True               # Add a ground plane
    setRenderSettings = True            # Set render percentage, denoising
    removeDefaultObjects = True         # Remove cube and lamp
    positionCamera = True               # Position the camera where so we get the whole object in shot
    cameraBorderPercent = 0.05          # Add a border gap around the positioned object (0.05 = 5%) for the rendered image

    def meshOptionsString():
        """These options change the mesh, so if they change, a new mesh needs to be cached"""

        return "_".join([str(Options.realScale),
                         str(Options.useUnofficialParts),
                         str(Options.instructionsLook),
                         str(Options.resolution),
                         str(Options.defaultColour),
                         str(Options.createInstances),
                         str(Options.useColourScheme),
                         str(Options.removeDoubles),
                         str(Options.smoothShading),
                         str(Options.gaps),
                         str(Options.realGapWidth),
                         str(Options.curvedWalls),
                         str(Options.flattenHierarchy),
                         str(Options.minifigHierarchy),
                         str(Options.useLogoStuds),
                         str(Options.logoStudVersion),
                         str(Options.instanceStuds),
                         str(Options.useLSynthParts),
                         str(Options.LSynthDirectory),
                         str(Options.studLogoDirectory),
                         str(Options.resolveAmbiguousNormals),
                         str(Options.addBevelModifier),
                         str(Options.bevelWidth)])

# **************************************************************************************
# Globals
globalBrickCount = 0
globalObjectsToAdd = []         # Blender objects to add to the scene
globalCamerasToAdd = []         # Camera data to add to the scene
globalContext = None
globalPoints = []
globalScaleFactor = 0.0004
globalWeldDistance = 0.0005

hasCollections = None
lightName = "Light"

# **************************************************************************************
# Dictionary with as keys the part numbers (without any extension for decorations)
# of pieces that have grainy slopes, and as values a set containing the angles (in
# degrees) of the face's normal to the horizontal plane. Use a tuple to represent a
# range within which the angle must lie.
globalSlopeBricks = {
    '962':{45},
    '2341':{-45},
    '2449':{-16},
    '2875':{45},
    '2876':{(40, 63)},
    '3037':{45},
    '3038':{45},
    '3039':{45},
    '3040':{45},
    '3041':{45},
    '3042':{45},
    '3043':{45},
    '3044':{45},
    '3045':{45},
    '3046':{45},
    '3048':{45},
    '3049':{45},
    '3135':{45},
    '3297':{63},
    '3298':{63},
    '3299':{63},
    '3300':{63},
    '3660':{-45},
    '3665':{-45},
    '3675':{63},
    '3676':{-45},
    '3678b':{24},
    '3684':{15},
    '3685':{16},
    '3688':{15},
    '3747':{-63},
    '4089':{-63},
    '4161':{63},
    '4286':{63},
    '4287':{-63},
    '4445':{45},
    '4460':{16},
    '4509':{63},
    '4854':{-45},
    '4856':{(-60, -70), -45},
    '4857':{45},
    '4858':{72},
    '4861':{45, 63},
    '4871':{-45},
    '4885':{72}, #blank
    '6069':{72, 45},
    '6153':{(60, 70), (26, 34)},
    '6227':{45},
    '6270':{45},
    '13269':{(40, 63)},
    '13548':{(45, 35)},
    '15571':{45},
    '18759':{-45},
    '22390':{(40, 55)}, #blank
    '22391':{(40, 55)},
    '22889':{-45},
    '28192':{45}, #blank
    '30180':{47},
    '30182':{45},
    '30183':{-45},
    '30249':{35},
    '30283':{-45},
    '30363':{72},
    '30373':{-24},
    '30382':{11, 45},
    '30390':{-45},
    '30499':{16},
    '32083':{45},
    '43708':{(64, 72)},
    '43710':{72, 45},
    '43711':{72, 45},
    '47759':{(40, 63)},
    '52501':{-45},
    '60219':{-45},
    '60477':{72},
    '60481':{24},
    '63341':{45},
    '72454':{-45},
    '92946':{45},
    '93348':{72},
    '95188':{65},
    '99301':{63},
    '303923':{45},
    '303926':{45},
    '304826':{45},
    '329826':{64},
    '374726':{-64},
    '428621':{64},
    '4162628':{17},
    '4195004':{45},
}

globalLightBricks = {
    '62930.dat':(1.0,0.373,0.059,1.0),
    '54869.dat':(1.0,0.052,0.017,1.0)
}

# Create a regular dictionary of parts with ranges of angles to check
margin = 5 # Allow 5 degrees either way to compensate for measuring inaccuracies
globalSlopeAngles = {}
for part, angles in globalSlopeBricks.items():
    globalSlopeAngles[part] = {(c-margin, c+margin) if type(c) is not tuple else (min(c)-margin,max(c)+margin) for c in angles}

# **************************************************************************************
def internalPrint(message):
    """Debug print with identification timestamp."""

    # Current timestamp (with milliseconds trimmed to two places)
    timestamp = datetime.datetime.now().strftime("%H:%M:%S.%f")[:-4]

    message = "{0} [importldraw] {1}".format(timestamp, message)
    print("{0}".format(message))

    global globalContext
    if globalContext is not None:
        globalContext.report({'INFO'}, message)

# **************************************************************************************
def debugPrint(message):
    """Debug print with identification timestamp."""

    if Options.verbose > 0:
        internalPrint(message)

# **************************************************************************************
def printWarningOnce(key, message=None):
    if message is None:
        message = key

    if key not in Configure.warningSuppression:
        internalPrint("WARNING: {0}".format(message))
        Configure.warningSuppression[key] = True

        global globalContext
        if globalContext is not None:
            globalContext.report({'WARNING'}, message)

# **************************************************************************************
def printError(message):
    internalPrint("ERROR: {0}".format(message))

    global globalContext
    if globalContext is not None:
        globalContext.report({'ERROR'}, message)


# **************************************************************************************
# **************************************************************************************
class Math:
    identityMatrix = mathutils.Matrix((
        (1.0, 0.0, 0.0, 0.0),
        (0.0, 1.0, 0.0, 0.0),
        (0.0, 0.0, 1.0, 0.0),
        (0.0, 0.0, 0.0, 1.0)
    ))
    rotationMatrix = mathutils.Matrix.Rotation(math.radians(-90), 4, 'X')
    reflectionMatrix = mathutils.Matrix((
        (1.0, 0.0, 0.0, 0.0),
        (0.0, 1.0, 0.0, 0.0),
        (0.0, 0.0, -1.0, 0.0),
        (0.0, 0.0, 0.0, 1.0)
    ))

    def clamp01(value):
        return max(min(value, 1.0), 0.0)

    def __init__(self):
        global globalScaleFactor

        # Rotation and scale matrices that convert LDraw coordinate space to Blender coordinate space
        Math.scaleMatrix = mathutils.Matrix((
                (globalScaleFactor, 0.0,               0.0,               0.0),
                (0.0,               globalScaleFactor, 0.0,               0.0),
                (0.0,               0.0,               globalScaleFactor, 0.0),
                (0.0,               0.0,               0.0,               1.0)
            ))


# **************************************************************************************
# **************************************************************************************
class Configure:
    """Configuration.
    Attempts to find the ldraw directory (platform specific directories are searched).
    Stores the list of paths to parts libraries that we search for individual parts.
    Stores warning messages we have already seen so we don't see them again.
    """

    searchPaths = []
    warningSuppression = {}
    tempDir = None

    def appendPath(path):
        if os.path.exists(path):
            Configure.searchPaths.append(path)

    def __setSearchPaths():
        Configure.searchPaths = []

        # Always search for parts in the 'models' folder
        Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "models"))

        # Search for stud logo parts
        if Options.useLogoStuds and Options.studLogoDirectory != "":
            if Options.resolution == "Low":
                Configure.appendPath(os.path.join(Options.studLogoDirectory, "8"))
            Configure.appendPath(Options.studLogoDirectory)

        # Search unofficial parts
        if Options.useUnofficialParts:
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "unofficial", "parts"))

            if Options.resolution == "High":
                Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "unofficial", "p", "48"))
            elif Options.resolution == "Low":
                Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "unofficial", "p", "8"))
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "unofficial", "p"))

            # Add 'Tente' parts too
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "tente", "parts"))

            if Options.resolution == "High":
                Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "tente", "p", "48"))
            elif Options.resolution == "Low":
                Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "tente", "p", "8"))
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "tente", "p"))

        # Search LSynth parts
        if Options.useLSynthParts:
            if Options.LSynthDirectory != "":
                Configure.appendPath(Options.LSynthDirectory)
            else:
                Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "unofficial", "lsynth"))
            debugPrint("Use LSynth Parts requested")

        # Search official parts
        Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "parts"))
        if Options.resolution == "High":
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "p", "48"))
            debugPrint("High-res primitives selected")
        elif Options.resolution == "Low":
            Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "p", "8"))
            debugPrint("Low-res primitives selected")
        else:
            debugPrint("Standard-res primitives selected")

        Configure.appendPath(os.path.join(Configure.ldrawInstallDirectory, "p"))

    def isWindows():
        return platform.system() == "Windows"

    def isMac():
        return platform.system() == "Darwin"

    def isLinux():
        return platform.system() == "Linux"

    def findDefaultLDrawDirectory():
        result = ""
        # Get list of possible ldraw installation directories for the platform
        if Configure.isWindows():
            ldrawPossibleDirectories = [
                                            "C:\\LDraw",
                                            "C:\\Program Files\\LDraw",
                                            "C:\\Program Files (x86)\\LDraw",
                                            "C:\\Program Files\\Studio 2.0\\ldraw",
                                       ]
        elif Configure.isMac():
            ldrawPossibleDirectories = [
                                            "~/ldraw/",
                                            "/Applications/LDraw/",
                                            "/Applications/ldraw/",
                                            "/usr/local/share/ldraw",
                                            "/Applications/Studio 2.0/ldraw",
                                       ]
        else:   # Default to Linux if not Windows or Mac
            ldrawPossibleDirectories = [
                                            "~/LDraw",
                                            "~/ldraw",
                                            "~/.LDraw",
                                            "~/.ldraw",
                                            "/usr/local/share/ldraw",
                                       ]

        # Search possible directories
        for dir in ldrawPossibleDirectories:
            dir = os.path.expanduser(dir)
            if os.path.isfile(os.path.join(dir, "LDConfig.ldr")):
                result = dir
                break

        return result

    def setLDrawDirectory():
        if Options.ldrawDirectory == "":
            Configure.ldrawInstallDirectory = Configure.findDefaultLDrawDirectory()
        else:
            Configure.ldrawInstallDirectory = os.path.expanduser(Options.ldrawDirectory)

        debugPrint("The LDraw Parts Library path to be used is: {0}".format(Configure.ldrawInstallDirectory))
        Configure.__setSearchPaths()

    def __init__(self):
        Configure.setLDrawDirectory()


# **************************************************************************************
# **************************************************************************************
class LegoColours:
    """Parses and stores a table of colour / material definitions. Converts colour space."""

    colours = {}

    def __getValue(line, value):
        """Parses a colour value from the ldConfig.ldr file"""
        if value in line:
            n = line.index(value)
            return line[n + 1]

    def __sRGBtoRGBValue(value):
        # See https://en.wikipedia.org/wiki/SRGB#The_reverse_transformation
        if value < 0.04045:
            return value / 12.92
        return ((value + 0.055)/1.055)**2.4

    def isDark(colour):
        R = colour[0]
        G = colour[1]
        B = colour[2]

        # Measure the perceived brightness of colour
        brightness = math.sqrt( 0.299*R*R + 0.587*G*G + 0.114*B*B )

        # Dark colours have white lines
        if brightness < 0.03:
            return True
        return False

    def sRGBtoLinearRGB(sRGBColour):
        # See https://en.wikipedia.org/wiki/SRGB#The_reverse_transformation
        (sr, sg, sb) = sRGBColour
        r = LegoColours.__sRGBtoRGBValue(sr)
        g = LegoColours.__sRGBtoRGBValue(sg)
        b = LegoColours.__sRGBtoRGBValue(sb)
        return (r,g,b)

    def hexDigitsToLinearRGBA(hexDigits, alpha):
        # String is "RRGGBB" format
        int_tuple = struct.unpack('BBB', bytes.fromhex(hexDigits))
        sRGB = tuple([val / 255 for val in int_tuple])
        linearRGB = LegoColours.sRGBtoLinearRGB(sRGB)
        return (linearRGB[0], linearRGB[1], linearRGB[2], alpha)

    def hexStringToLinearRGBA(hexString):
        """Convert colour hex value to RGB value."""
        # Handle direct colours
        # Direct colours are documented here: http://www.hassings.dk/l3/l3p.html
        match = re.fullmatch(r"0x0*([0-9])((?:[A-F0-9]{2}){3})", hexString)
        if match is not None:
            digit = match.group(1)
            rgb_str = match.group(2)

            interleaved = False
            if digit == "2":        # Opaque
                alpha = 1.0
            elif digit == "3":      # Transparent
                alpha = 0.5
            elif digit == "4":      # Opaque
                alpha = 1.0
                interleaved = True
            elif digit == "5":      # More Transparent
                alpha = 0.333
                interleaved = True
            elif digit == "6":      # Less transparent
                alpha = 0.666
                interleaved = True
            elif digit == "7":      # Invisible
                alpha = 0.0
                interleaved = True
            else:
                alpha = 1.0

            if interleaved:
                # Input string is six hex digits of two colours "RGBRGB".
                # This was designed to be a dithered colour.
                # Take the average of those two colours (R+R,G+G,B+B) * 0.5
                r = float(int(rgb_str[0], 16)) / 15
                g = float(int(rgb_str[1], 16)) / 15
                b = float(int(rgb_str[2], 16)) / 15
                colour1 = LegoColours.sRGBtoLinearRGB((r,g,b))
                r = float(int(rgb_str[3], 16)) / 15
                g = float(int(rgb_str[4], 16)) / 15
                b = float(int(rgb_str[5], 16)) / 15
                colour2 = LegoColours.sRGBtoLinearRGB((r,g,b))
                return (0.5 * (colour1[0] + colour2[0]),
                        0.5 * (colour1[1] + colour2[1]),
                        0.5 * (colour1[2] + colour2[2]), alpha)

            # String is "RRGGBB" format
            return LegoColours.hexDigitsToLinearRGBA(rgb_str, alpha)
        return None

    def __overwriteColour(index, sRGBColour):
        if index in LegoColours.colours:
            # Colour Space Management: Convert sRGB colour values to Blender's linear RGB colour space
            LegoColours.colours[index]["colour"] = LegoColours.sRGBtoLinearRGB(sRGBColour)

    def __readColourTable():
        """Reads the colour values from the LDConfig.ldr file. For details of the
        Ldraw colour system see: http://www.ldraw.org/article/547"""
        if Options.useColourScheme == "alt":
            configFilename = "LDCfgalt.ldr"
        else:
            configFilename = "LDConfig.ldr"

        configFilepath = os.path.join(Configure.ldrawInstallDirectory, configFilename)

        ldconfig_lines = ""
        if os.path.exists(configFilepath):
            with open(configFilepath, "rt", encoding="utf_8") as ldconfig:
                ldconfig_lines = ldconfig.readlines()

        for line in ldconfig_lines:
            if len(line) > 3:
                if line[2:4].lower() == '!c':
                    line_split = line.split()

                    name = line_split[2]
                    code = int(line_split[4])
                    linearRGBA = LegoColours.hexDigitsToLinearRGBA(line_split[6][1:], 1.0)

                    colour = {
                        "name": name,
                        "colour": linearRGBA[0:3],
                        "alpha": linearRGBA[3],
                        "luminance": 0.0,
                        "material": "BASIC"
                    }

                    if "ALPHA" in line_split:
                        colour["alpha"] = int(LegoColours.__getValue(line_split, "ALPHA")) / 256.0

                    if "LUMINANCE" in line_split:
                        colour["luminance"] = int(LegoColours.__getValue(line_split, "LUMINANCE"))

                    if "CHROME" in line_split:
                        colour["material"] = "CHROME"

                    if "PEARLESCENT" in line_split:
                        colour["material"] = "PEARLESCENT"

                    if "RUBBER" in line_split:
                        colour["material"] = "RUBBER"

                    if "METAL" in line_split:
                        colour["material"] = "METAL"

                    if "MATERIAL" in line_split:
                        subline = line_split[line_split.index("MATERIAL"):]

                        colour["material"]         = LegoColours.__getValue(subline, "MATERIAL")

                        # current `FABRIC [VELVET | CANVAS | STRING | FUR]` is not yet supported.
                        if colour["material"] == "FABRIC":
                            debugPrint(f"Unsupported material finish: {colour['material']} for [colour: {name} code: {code}] in line: {subline}")

                        # Note, not all finishes have a secondary value
                        finishValue                    = LegoColours.__getValue(subline, "VALUE")
                        if finishValue is not None:
                            hexDigits                  = finishValue[1:]
                            colour["secondary_colour"] = LegoColours.hexDigitsToLinearRGBA(hexDigits, 1.0)

                        colour["fraction"]         = LegoColours.__getValue(subline, "FRACTION")
                        colour["vfraction"]        = LegoColours.__getValue(subline, "VFRACTION")
                        colour["size"]             = LegoColours.__getValue(subline, "SIZE")
                        colour["minsize"]          = LegoColours.__getValue(subline, "MINSIZE")
                        colour["maxsize"]          = LegoColours.__getValue(subline, "MAXSIZE")

                    LegoColours.colours[code] = colour

        if Options.useColourScheme == "lgeo":
            # LGEO is a parts library for rendering LEGO using the povray rendering software.
            # It has a list of LEGO colours suitable for realistic rendering.
            # I've extracted the following colours from the LGEO file: lg_color.inc
            # LGEO is downloadable from http://ldraw.org/downloads-2/downloads.html
            # We overwrite the standard LDraw colours if we have better LGEO colours.
            LegoColours.__overwriteColour(0,   ( 33/255,  33/255,  33/255))
            LegoColours.__overwriteColour(1,   ( 13/255, 105/255, 171/255))
            LegoColours.__overwriteColour(2,   ( 40/255, 127/255,  70/255))
            LegoColours.__overwriteColour(3,   (  0/255, 143/255, 155/255))
            LegoColours.__overwriteColour(4,   (196/255,  40/255,  27/255))
            LegoColours.__overwriteColour(5,   (205/255,  98/255, 152/255))
            LegoColours.__overwriteColour(6,   ( 98/255,  71/255,  50/255))
            LegoColours.__overwriteColour(7,   (161/255, 165/255, 162/255))
            LegoColours.__overwriteColour(8,   (109/255, 110/255, 108/255))
            LegoColours.__overwriteColour(9,   (180/255, 210/255, 227/255))
            LegoColours.__overwriteColour(10,  ( 75/255, 151/255,  74/255))
            LegoColours.__overwriteColour(11,  ( 85/255, 165/255, 175/255))
            LegoColours.__overwriteColour(12,  (242/255, 112/255,  94/255))
            LegoColours.__overwriteColour(13,  (252/255, 151/255, 172/255))
            LegoColours.__overwriteColour(14,  (245/255, 205/255,  47/255))
            LegoColours.__overwriteColour(15,  (242/255, 243/255, 242/255))
            LegoColours.__overwriteColour(17,  (194/255, 218/255, 184/255))
            LegoColours.__overwriteColour(18,  (249/255, 233/255, 153/255))
            LegoColours.__overwriteColour(19,  (215/255, 197/255, 153/255))
            LegoColours.__overwriteColour(20,  (193/255, 202/255, 222/255))
            LegoColours.__overwriteColour(21,  (224/255, 255/255, 176/255))
            LegoColours.__overwriteColour(22,  (107/255,  50/255, 123/255))
            LegoColours.__overwriteColour(23,  ( 35/255,  71/255, 139/255))
            LegoColours.__overwriteColour(25,  (218/255, 133/255,  64/255))
            LegoColours.__overwriteColour(26,  (146/255, 57/255,  120/255))
            LegoColours.__overwriteColour(27,  (164/255, 189/255,  70/255))
            LegoColours.__overwriteColour(28,  (149/255, 138/255, 115/255))
            LegoColours.__overwriteColour(29,  (228/255, 173/255, 200/255))
            LegoColours.__overwriteColour(30,  (172/255, 120/255, 186/255))
            LegoColours.__overwriteColour(31,  (225/255, 213/255, 237/255))
            LegoColours.__overwriteColour(32,  (  0/255,  20/255,  20/255))
            LegoColours.__overwriteColour(33,  (123/255, 182/255, 232/255))
            LegoColours.__overwriteColour(34,  (132/255, 182/255, 141/255))
            LegoColours.__overwriteColour(35,  (217/255, 228/255, 167/255))
            LegoColours.__overwriteColour(36,  (205/255,  84/255,  75/255))
            LegoColours.__overwriteColour(37,  (228/255, 173/255, 200/255))
            LegoColours.__overwriteColour(38,  (255/255,  43/255,   0/225))
            LegoColours.__overwriteColour(40,  (166/255, 145/255, 130/255))
            LegoColours.__overwriteColour(41,  (170/255, 229/255, 255/255))
            LegoColours.__overwriteColour(42,  (198/255, 255/255,   0/255))
            LegoColours.__overwriteColour(43,  (193/255, 223/255, 240/255))
            LegoColours.__overwriteColour(44,  (150/255, 112/255, 159/255))
            LegoColours.__overwriteColour(46,  (247/255, 241/255, 141/255))
            LegoColours.__overwriteColour(47,  (252/255, 252/255, 252/255))
            LegoColours.__overwriteColour(52,  (156/255, 149/255, 199/255))
            LegoColours.__overwriteColour(54,  (255/255, 246/255, 123/255))
            LegoColours.__overwriteColour(57,  (226/255, 176/255,  96/255))
            LegoColours.__overwriteColour(65,  (236/255, 201/255,  53/255))
            LegoColours.__overwriteColour(66,  (202/255, 176/255,   0/255))
            LegoColours.__overwriteColour(67,  (255/255, 255/255, 255/255))
            LegoColours.__overwriteColour(68,  (243/255, 207/255, 155/255))
            LegoColours.__overwriteColour(69,  (142/255,  66/255, 133/255))
            LegoColours.__overwriteColour(70,  (105/255,  64/255,  39/255))
            LegoColours.__overwriteColour(71,  (163/255, 162/255, 164/255))
            LegoColours.__overwriteColour(72,  ( 99/255,  95/255,  97/255))
            LegoColours.__overwriteColour(73,  (110/255, 153/255, 201/255))
            LegoColours.__overwriteColour(74,  (161/255, 196/255, 139/255))
            LegoColours.__overwriteColour(77,  (220/255, 144/255, 149/255))
            LegoColours.__overwriteColour(78,  (246/255, 215/255, 179/255))
            LegoColours.__overwriteColour(79,  (255/255, 255/255, 255/255))
            LegoColours.__overwriteColour(80,  (140/255, 140/255, 140/255))
            LegoColours.__overwriteColour(82,  (219/255, 172/255,  52/255))
            LegoColours.__overwriteColour(84,  (170/255, 125/255,  85/255))
            LegoColours.__overwriteColour(85,  ( 52/255,  43/255, 117/255))
            LegoColours.__overwriteColour(86,  (124/255,  92/255,  69/255))
            LegoColours.__overwriteColour(89,  (155/255, 178/255, 239/255))
            LegoColours.__overwriteColour(92,  (204/255, 142/255, 104/255))
            LegoColours.__overwriteColour(100, (238/255, 196/255, 182/255))
            LegoColours.__overwriteColour(115, (199/255, 210/255,  60/255))
            LegoColours.__overwriteColour(134, (174/255, 122/255,  89/255))
            LegoColours.__overwriteColour(135, (171/255, 173/255, 172/255))
            LegoColours.__overwriteColour(137, (106/255, 122/255, 150/255))
            LegoColours.__overwriteColour(142, (220/255, 188/255, 129/255))
            LegoColours.__overwriteColour(148, ( 62/255,  60/255,  57/255))
            LegoColours.__overwriteColour(151, ( 14/255,  94/255,  77/255))
            LegoColours.__overwriteColour(179, (160/255, 160/255, 160/255))
            LegoColours.__overwriteColour(183, (242/255, 243/255, 242/255))
            LegoColours.__overwriteColour(191, (248/255, 187/255,  61/255))
            LegoColours.__overwriteColour(212, (159/255, 195/255, 233/255))
            LegoColours.__overwriteColour(216, (143/255,  76/255,  42/255))
            LegoColours.__overwriteColour(226, (253/255, 234/255, 140/255))
            LegoColours.__overwriteColour(232, (125/255, 187/255, 221/255))
            LegoColours.__overwriteColour(256, ( 33/255,  33/255,  33/255))
            LegoColours.__overwriteColour(272, ( 32/255,  58/255,  86/255))
            LegoColours.__overwriteColour(273, ( 13/255, 105/255, 171/255))
            LegoColours.__overwriteColour(288, ( 39/255,  70/255,  44/255))
            LegoColours.__overwriteColour(294, (189/255, 198/255, 173/255))
            LegoColours.__overwriteColour(297, (170/255, 127/255,  46/255))
            LegoColours.__overwriteColour(308, ( 53/255,  33/255,   0/255))
            LegoColours.__overwriteColour(313, (171/255, 217/255, 255/255))
            LegoColours.__overwriteColour(320, (123/255,  46/255,  47/255))
            LegoColours.__overwriteColour(321, ( 70/255, 155/255, 195/255))
            LegoColours.__overwriteColour(322, (104/255, 195/255, 226/255))
            LegoColours.__overwriteColour(323, (211/255, 242/255, 234/255))
            LegoColours.__overwriteColour(324, (196/255,   0/255,  38/255))
            LegoColours.__overwriteColour(326, (226/255, 249/255, 154/255))
            LegoColours.__overwriteColour(330, (119/255, 119/255,  78/255))
            LegoColours.__overwriteColour(334, (187/255, 165/255,  61/255))
            LegoColours.__overwriteColour(335, (149/255, 121/255, 118/255))
            LegoColours.__overwriteColour(366, (209/255, 131/255,   4/255))
            LegoColours.__overwriteColour(373, (135/255, 124/255, 144/255))
            LegoColours.__overwriteColour(375, (193/255, 194/255, 193/255))
            LegoColours.__overwriteColour(378, (120/255, 144/255, 129/255))
            LegoColours.__overwriteColour(379, ( 94/255, 116/255, 140/255))
            LegoColours.__overwriteColour(383, (224/255, 224/255, 224/255))
            LegoColours.__overwriteColour(406, (  0/255,  29/255, 104/255))
            LegoColours.__overwriteColour(449, (129/255,   0/255, 123/255))
            LegoColours.__overwriteColour(450, (203/255, 132/255,  66/255))
            LegoColours.__overwriteColour(462, (226/255, 155/255,  63/255))
            LegoColours.__overwriteColour(484, (160/255,  95/255,  52/255))
            LegoColours.__overwriteColour(490, (215/255, 240/255,   0/255))
            LegoColours.__overwriteColour(493, (101/255, 103/255,  97/255))
            LegoColours.__overwriteColour(494, (208/255, 208/255, 208/255))
            LegoColours.__overwriteColour(496, (163/255, 162/255, 164/255))
            LegoColours.__overwriteColour(503, (199/255, 193/255, 183/255))
            LegoColours.__overwriteColour(504, (137/255, 135/255, 136/255))
            LegoColours.__overwriteColour(511, (250/255, 250/255, 250/255))

    def lightenRGBA(colour, scale):
        # Moves the linear RGB values closer to white
        # scale = 0 means full white
        # scale = 1 means color stays same
        colour = ((1.0 - colour[0]) * scale,
                  (1.0 - colour[1]) * scale,
                  (1.0 - colour[2]) * scale,
                  colour[3])
        return (Math.clamp01(1.0 - colour[0]),
                Math.clamp01(1.0 - colour[1]),
                Math.clamp01(1.0 - colour[2]),
                colour[3])

    def isFluorescentTransparent(colName):
        if (colName == "Trans_Neon_Orange"):
            return True
        if (colName == "Trans_Neon_Green"):
            return True
        if (colName == "Trans_Neon_Yellow"):
            return True
        if (colName == "Trans_Bright_Green"):
            return True
        return False

    def __init__(self):
        LegoColours.__readColourTable()


# **************************************************************************************
# **************************************************************************************
class FileSystem:
    """
    Reads text files in different encodings. Locates full filepath for a part.
    """

    # Takes a case-insensitive filepath and constructs a case sensitive version (based on an actual existing file)
    # See https://stackoverflow.com/questions/8462449/python-case-insensitive-file-name/8462613#8462613
    def pathInsensitive(path):
        """
        Get a case-insensitive path for use on a case sensitive system.

        >>> path_insensitive('/Home')
        '/home'
        >>> path_insensitive('/Home/chris')
        '/home/chris'
        >>> path_insensitive('/HoME/CHris/')
        '/home/chris/'
        >>> path_insensitive('/home/CHRIS')
        '/home/chris'
        >>> path_insensitive('/Home/CHRIS/.gtk-bookmarks')
        '/home/chris/.gtk-bookmarks'
        >>> path_insensitive('/home/chris/.GTK-bookmarks')
        '/home/chris/.gtk-bookmarks'
        >>> path_insensitive('/HOME/Chris/.GTK-bookmarks')
        '/home/chris/.gtk-bookmarks'
        >>> path_insensitive("/HOME/Chris/I HOPE this doesn't exist")
        "/HOME/Chris/I HOPE this doesn't exist"
        """

        return FileSystem.__pathInsensitive(path) or path

    def __pathInsensitive(path):
        """
        Recursive part of path_insensitive to do the work.
        """

        if path == '' or os.path.exists(path):
            return path

        base = os.path.basename(path)  # may be a directory or a file
        dirname = os.path.dirname(path)

        suffix = ''
        if not base:  # dir ends with a slash?
            if len(dirname) < len(path):
                suffix = path[:len(path) - len(dirname)]

            base = os.path.basename(dirname)
            dirname = os.path.dirname(dirname)

        if not os.path.exists(dirname):
            debug_dirname = dirname
            dirname = FileSystem.__pathInsensitive(dirname)
            if not dirname:
                return

        # at this point, the directory exists but not the file

        try:  # we are expecting dirname to be a directory, but it could be a file
            files = CachedDirectoryFilenames.getCached(dirname)
            if files is None:
                files = os.listdir(dirname)
                CachedDirectoryFilenames.addToCache(dirname, files)
        except OSError:
            return

        baselow = base.lower()
        try:
            basefinal = next(fl for fl in files if fl.lower() == baselow)
        except StopIteration:
            return

        if basefinal:
            return os.path.join(dirname, basefinal) + suffix
        else:
            return

    def __checkEncoding(filepath):
        """Check the encoding of a file for Endian encoding."""

        filepath = FileSystem.pathInsensitive(filepath)

        # Open it, read just the area containing a possible byte mark
        with open(filepath, "rb") as encode_check:
            encoding = encode_check.readline(3)

        # The file uses UCS-2 (UTF-16) Big Endian encoding
        if encoding == b"\xfe\xff\x00":
            return "utf_16_be"

        # The file uses UCS-2 (UTF-16) Little Endian
        elif encoding == b"\xff\xfe0":
            return "utf_16_le"

        # Use LDraw model standard UTF-8
        else:
            return "utf_8"

    def readTextFile(filepath):
        """Read a text file, with various checks for type of encoding"""

        filepath = FileSystem.pathInsensitive(filepath)

        lines = None
        if os.path.exists(filepath):
            # Try to read using the suspected encoding
            file_encoding = FileSystem.__checkEncoding(filepath)
            try:
                with open(filepath, "rt", encoding=file_encoding) as f_in:
                    lines = f_in.readlines()
            except:
                # If all else fails, read using Latin 1 encoding
                with open(filepath, "rt", encoding="latin_1") as f_in:
                    lines = f_in.readlines()

        return lines

    def locate(filename, rootPath = None):
        """Given a file name of an ldraw file, find the full path"""

        partName = filename.replace("\\", os.path.sep)
        partName = os.path.expanduser(partName)

        if rootPath is None:
            rootPath = os.path.dirname(filename)

        allSearchPaths = Configure.searchPaths[:]
        if rootPath not in allSearchPaths:
            allSearchPaths.append(rootPath)

        for path in allSearchPaths:
            fullPathName = os.path.join(path, partName)
            fullPathName = FileSystem.pathInsensitive(fullPathName)

            if os.path.exists(fullPathName):
                return fullPathName

        return None


# **************************************************************************************
# **************************************************************************************
class CachedDirectoryFilenames:
    """Cached dictionary of directory filenames keyed by directory path"""

    __cache = {}        # Dictionary

    def getCached(key):
        if key in CachedDirectoryFilenames.__cache:
            return CachedDirectoryFilenames.__cache[key]
        return None

    def addToCache(key, value):
        CachedDirectoryFilenames.__cache[key] = value

    def clearCache():
        CachedDirectoryFilenames.__cache = {}


# **************************************************************************************
# **************************************************************************************
class CachedFiles:
    """Cached dictionary of LDrawFile objects keyed by filename"""

    __cache = {}        # Dictionary of exact filenames as keys, and file contents as values
    __lowercache = {}   # Dictionary of lowercase filenames as keys, and file contents as values

    def getCached(key):
        # Look for an exact match in the cache first
        if key in CachedFiles.__cache:
            return CachedFiles.__cache[key]

        # Look for a case-insensitive match next
        if key.lower() in CachedFiles.__lowercache:
            return CachedFiles.__lowercache[key.lower()]
        return None

    def addToCache(key, value):
        CachedFiles.__cache[key] = value
        CachedFiles.__lowercache[key.lower()] = value

    def clearCache():
        CachedFiles.__cache = {}
        CachedFiles.__lowercache = {}


# **************************************************************************************
# **************************************************************************************
class CachedGeometry:
    """Cached dictionary of LDrawGeometry objects"""

    __cache = {}        # Dictionary

    def getCached(key):
        if key in CachedGeometry.__cache:
            return CachedGeometry.__cache[key]
        return None

    def addToCache(key, value):
        CachedGeometry.__cache[key] = value

    def clearCache():
        CachedGeometry.__cache = {}

# **************************************************************************************
# **************************************************************************************
class FaceInfo:
    def __init__(self, faceColour, culling, windingCCW, isGrainySlopeAllowed):
        self.faceColour = faceColour
        self.culling = culling
        self.windingCCW = windingCCW
        self.isGrainySlopeAllowed = isGrainySlopeAllowed


# **************************************************************************************
# **************************************************************************************
class LDrawGeometry:
    """Stores the geometry for an LDrawFile"""

    def __init__(self):
        self.points = []
        self.faces = []
        self.faceInfo = []
        self.edges = []
        self.edgeIndices = []

    def parseFace(self, parameters, cull, ccw, isGrainySlopeAllowed):
        """Parse a face from parameters"""

        num_points = int(parameters[0])
        colourName = parameters[1]

        newPoints = []
        for i in range(num_points):
            blenderPos = Math.scaleMatrix @ mathutils.Vector( (float(parameters[i * 3 + 2]),
                                                               float(parameters[i * 3 + 3]),
                                                               float(parameters[i * 3 + 4])) )
            newPoints.append(blenderPos)

        # Fix "bowtie" quadrilaterals (see http://wiki.ldraw.org/index.php?title=LDraw_technical_restrictions#Complex_quadrilaterals)
        if num_points == 4:
            nA = (newPoints[1] - newPoints[0]).cross(newPoints[2] - newPoints[0])
            nB = (newPoints[2] - newPoints[1]).cross(newPoints[3] - newPoints[1])
            nC = (newPoints[3] - newPoints[2]).cross(newPoints[0] - newPoints[2])
            if (nA.dot(nB) < 0):
                newPoints[2], newPoints[3] = newPoints[3], newPoints[2]
            elif (nB.dot(nC) < 0):
                newPoints[2], newPoints[1] = newPoints[1], newPoints[2]

        pointCount = len(self.points)
        newFace = list(range(pointCount, pointCount + num_points))
        self.points.extend(newPoints)
        self.faces.append(newFace)
        self.faceInfo.append(FaceInfo(colourName, cull, ccw, isGrainySlopeAllowed))

    def parseEdge(self, parameters):
        """Parse an edge from parameters"""

        colourName = parameters[1]
        if colourName == "24":
            blenderPos1 = Math.scaleMatrix @ mathutils.Vector( (float(parameters[2]),
                                                                float(parameters[3]),
                                                                float(parameters[4])) )
            blenderPos2 = Math.scaleMatrix @ mathutils.Vector( (float(parameters[5]),
                                                                float(parameters[6]),
                                                                float(parameters[7])) )
            self.edges.append((blenderPos1, blenderPos2))

    def verify(self, face, numPoints):
        for i in face:
            assert i < numPoints
            assert i >= 0

    def appendGeometry(self, geometry, matrix, isStud, isStudLogo, parentMatrix, cull, invert):
        combinedMatrix = parentMatrix @ matrix
        isReflected = combinedMatrix.determinant() < 0.0
        reflectStudLogo = isStudLogo and isReflected

        fixedMatrix = matrix.copy()
        if reflectStudLogo:
            fixedMatrix = matrix @ Math.reflectionMatrix
            invert = not invert

        # Append face information
        pointCount = len(self.points)
        newFaceInfo = []
        for index, face in enumerate(geometry.faces):
            # Gather points for this face (and transform points)
            newPoints = []
            for i in face:
                newPoints.append(fixedMatrix @ geometry.points[i])

            # Add clockwise and/or anticlockwise sets of points as appropriate
            newFace = face.copy()
            for i in range(len(newFace)):
                newFace[i] += pointCount

            faceInfo = geometry.faceInfo[index]
            faceCCW = faceInfo.windingCCW != invert
            faceCull = faceInfo.culling and cull

            # If we are going to resolve ambiguous normals by "best guess" we will let
            # Blender calculate that for us later. Just cull with arbitrary winding for now.
            if not faceCull:
                if Options.resolveAmbiguousNormals == "guess":
                    faceCull = True

            if faceCCW or not faceCull:
                self.points.extend(newPoints)
                self.faces.append(newFace)

                newFaceInfo.append(FaceInfo(faceInfo.faceColour, True, True, not isStud and faceInfo.isGrainySlopeAllowed))
                self.verify(newFace, len(self.points))

            if not faceCull:
                newFace = newFace.copy()
                pointCount += len(newPoints)
                for i in range(len(newFace)):
                    newFace[i] += len(newPoints)

            if not faceCCW or not faceCull:
                self.points.extend(newPoints[::-1])
                self.faces.append(newFace)

                newFaceInfo.append(FaceInfo(faceInfo.faceColour, True, True, not isStud and faceInfo.isGrainySlopeAllowed))
                self.verify(newFace, len(self.points))

        self.faceInfo.extend(newFaceInfo)
        assert len(self.faces) == len(self.faceInfo)

        # Append edge information
        newEdges = []
        for edge in geometry.edges:
            newEdges.append( (fixedMatrix @ edge[0], fixedMatrix @ edge[1]) )
        self.edges.extend(newEdges)


# **************************************************************************************
# **************************************************************************************
class LDrawNode:
    """A node in the hierarchy. References one LDrawFile"""

    def __init__(self, filename, isFullFilepath, parentFilepath, colourName=Options.defaultColour, matrix=Math.identityMatrix, bfcCull=True, bfcInverted=False, isLSynthPart=False, isSubPart=False, isRootNode=True, groupNames=[]):
        self.filename       = filename
        self.isFullFilepath = isFullFilepath
        self.parentFilepath = parentFilepath
        self.matrix         = matrix
        self.colourName     = colourName
        self.bfcInverted    = bfcInverted
        self.bfcCull        = bfcCull
        self.file           = None
        self.isLSynthPart   = isLSynthPart
        self.isSubPart      = isSubPart
        self.isRootNode     = isRootNode
        self.groupNames     = groupNames.copy()

    def look_at(obj_camera, target, up_vector):
        bpy.context.view_layer.update()

        loc_camera = obj_camera.matrix_world.to_translation()

        #print("CamLoc = " + str(loc_camera[0]) + "," + str(loc_camera[1]) + "," + str(loc_camera[2]))
        #print("TarLoc = " + str(target[0]) + "," + str(target[1]) + "," + str(target[2]))
        #print("UpVec  = " + str(up_vector[0]) + "," + str(up_vector[1]) + "," + str(up_vector[2]))

        # back vector is a vector pointing from the target to the camera
        back = loc_camera - target;
        back.normalize()

        # If our back and up vectors are very close to pointing the same way (or opposite), choose a different up_vector
        if (abs(back.dot(up_vector)) > 0.9999):
            up_vector=mathutils.Vector((0.0,0.0,1.0))
            if (abs(back.dot(up_vector)) > 0.9999):
                up_vector=mathutils.Vector((1.0,0.0,0.0))

        right = up_vector.cross(back)
        right.normalize()
        up = back.cross(right)
        up.normalize()

        row1 = [   right.x,   up.x,   back.x, loc_camera.x ]
        row2 = [   right.y,   up.y,   back.y, loc_camera.y ]
        row3 = [   right.z,   up.z,   back.z, loc_camera.z ]
        row4 = [       0.0,    0.0,      0.0,          1.0 ]

        #bpy.ops.mesh.primitive_ico_sphere_add(location=loc_camera+up,size=0.1)
        #bpy.ops.mesh.primitive_cylinder_add(location=loc_camera+back,radius = 0.1, depth=0.2)
        #bpy.ops.mesh.primitive_cone_add(location=loc_camera+right,radius1=0.1, radius2=0, depth=0.2)

        obj_camera.matrix_world = mathutils.Matrix((row1, row2, row3, row4))
        #print(obj_camera.matrix_world)

    def isBlenderObjectNode(self):
        """
        Calculates if this node should become a Blender object.
        Some nodes will become objects in Blender, some will not.
        Typically nodes that reference a model or a part become Blender Objects, but not nodes that reference subparts.
        """

        # The root node is always a Blender node
        if self.isRootNode:
            return True

        # General rule: We are a Blender object if we are a part or higher (ie. if we are not a subPart)
        isBON = not self.isSubPart

        # Exception #1 - If flattening the hierarchy, we only want parts (not models)
        if Options.flattenHierarchy:
            isBON = self.file.isPart and not self.isSubPart

        # Exception #2 - We are not a Blender Object if we are an LSynth part (so that all LSynth parts become a single mesh)
        if self.isLSynthPart:
            isBON = False

        # Exception #3 - We are a Blender Object if we are a stud to be instanced
        if Options.instanceStuds and self.file.isStud:
            isBON = True

        return isBON

    def load(self):
        # Is this file in the cache?
        self.file = CachedFiles.getCached(self.filename)
        if self.file is None:
            # Not in cache, so load file
            self.file = LDrawFile(self.filename, self.isFullFilepath, self.parentFilepath, None, self.isSubPart)
            assert self.file is not None

            # Add the new file to the cache
            CachedFiles.addToCache(self.filename, self.file)

        # Load any children
        for child in self.file.childNodes:
            child.load()

    def resolveColour(colourName, realColourName):
        if colourName == "16":
            return realColourName
        return colourName

    def printBFC(self, depth=0):
        # For debugging, displays BFC information

        debugPrint("{0}Node {1} has cull={2} and invert={3} det={4}".format(" "*(depth*4), self.filename, self.bfcCull, self.bfcInverted, self.matrix.determinant()))
        for child in self.file.childNodes:
            child.printBFC(depth + 1)

    def getBFCCode(accumCull, accumInvert, bfcCull, bfcInverted):
        index = (8 if accumCull else 0) +  (4 if accumInvert else 0) + (2 if bfcCull else 0) + (1 if bfcInverted else 0)
        # Normally meshes are culled and not inverted, so don't bother with a code in this case
        if index == 10:
            return ""
        # If this is out of the ordinary, add a code that makes it a unique name to cache the mesh properly
        return "_{0}".format(index)

    def getBlenderGeometry(self, realColourName, basename, parentMatrix=Math.identityMatrix, accumCull=True, accumInvert=False):
        """
        Returns the geometry for the Blender Object at this node.

        It accumulates the geometry of itself with all the geometry of it's children
        recursively (specifically - those children that are not Blender Object nodes).

        The result will become a single mesh in Blender.
        """

        assert self.file is not None

        accumCull = accumCull and self.bfcCull
        accumInvert = accumInvert != self.bfcInverted

        ourColourName = LDrawNode.resolveColour(self.colourName, realColourName)
        code = LDrawNode.getBFCCode(accumCull, accumInvert, self.bfcCull, self.bfcInverted)
        meshName = "Mesh_{0}_{1}{2}".format(basename, ourColourName, code)
        key = (self.filename, ourColourName, accumCull, accumInvert, self.bfcCull, self.bfcInverted)
        bakedGeometry = CachedGeometry.getCached(key)
        if bakedGeometry is None:
            combinedMatrix = parentMatrix @ self.matrix

            # Start with a copy of our file's geometry
            assert len(self.file.geometry.faces) == len(self.file.geometry.faceInfo)
            bakedGeometry = LDrawGeometry()
            bakedGeometry.appendGeometry(self.file.geometry, Math.identityMatrix, self.file.isStud, self.file.isStudLogo, combinedMatrix, self.bfcCull, self.bfcInverted)

            # Replaces the default colour 16 in our faceColours list with a specific colour
            for faceInfo in bakedGeometry.faceInfo:
                faceInfo.faceColour = LDrawNode.resolveColour(faceInfo.faceColour, ourColourName)

            # Append each child's geometry
            for child in self.file.childNodes:
                assert child.file is not None
                if not child.isBlenderObjectNode():
                    childColourName = LDrawNode.resolveColour(child.colourName, ourColourName)
                    childMeshName, bg = child.getBlenderGeometry(childColourName, basename, combinedMatrix, accumCull, accumInvert)

                    isStud = child.file.isStud
                    isStudLogo = child.file.isStudLogo
                    bakedGeometry.appendGeometry(bg, child.matrix, isStud, isStudLogo, combinedMatrix, self.bfcCull, self.bfcInverted)

            CachedGeometry.addToCache(key, bakedGeometry)
        assert len(bakedGeometry.faces) == len(bakedGeometry.faceInfo)
        return (meshName, bakedGeometry)


# **************************************************************************************
# **************************************************************************************
class LDrawCamera:
    """Data about a camera"""

    def __init__(self):
        self.vert_fov_degrees = 30.0
        self.near             = 0.01
        self.far              = 100.0
        self.position         = mathutils.Vector((0.0, 0.0, 0.0))
        self.target_position  = mathutils.Vector((1.0, 0.0, 0.0))
        self.up_vector        = mathutils.Vector((0.0, 1.0, 0.0))
        self.name             = "Camera"
        self.orthographic     = False
        self.hidden           = False

    def createCameraNode(self):
        camData = bpy.data.cameras.new(self.name)
        camera = bpy.data.objects.new(self.name, camData)

        # Add to scene
        camera.location = self.position
        camera.data.sensor_fit = 'VERTICAL'
        camera.data.angle = self.vert_fov_degrees * 3.1415926 / 180.0
        camera.data.clip_end = self.far
        camera.data.clip_start = self.near
        camera.hide_set(self.hidden)
        self.hidden = False

        if self.orthographic:
            dist_target_to_camera = (self.position - self.target_position).length
            camera.data.ortho_scale = dist_target_to_camera / 1.92
            camera.data.type = 'ORTHO'
            self.orthographic = False
        else:
            camera.data.type = 'PERSP'

        linkToScene(camera)
        LDrawNode.look_at(camera, self.target_position, self.up_vector)
        return camera


# **************************************************************************************
# **************************************************************************************
class LDrawFile:
    """Stores the contents of a single LDraw file.
    Specifically this represents an IO, LDR, L3B, DAT or one '0 FILE' section of an MPD.
    Splits up an MPD file into '0 FILE' sections and caches them."""

    def __loadLegoFile(self, filepath, isFullFilepath, parentFilepath):
        # Resolve full filepath if necessary
        if isFullFilepath is False:
            if parentFilepath == "":
                parentDir = os.path.dirname(filepath)
            else:
                parentDir = os.path.dirname(parentFilepath)
            result = FileSystem.locate(filepath, parentDir)
            if result is None:
                printWarningOnce("Missing file {0}".format(filepath))
                return False
            filepath = result

        if os.path.splitext(filepath)[1] == ".io":
            # Check if the file is encrypted (password protected)
            is_encrypted = False
            zf = zipfile.ZipFile(filepath)
            for zinfo in zf.infolist():
                is_encrypted |= zinfo.flag_bits & 0x1
            if is_encrypted:
                ShowMessageBox("Oops, this .io file is password protected", "Password protected files are not supported", 'ERROR')
                return False

            # Get a temporary directory. Store the TemporaryDirectory object in Configure so it's scope lasts long enough
            Configure.tempDir = tempfile.TemporaryDirectory()
            directory_to_extract_to = Configure.tempDir.name

            # Decompress to temporary directory
            with zipfile.ZipFile(filepath, 'r') as zip_ref:
                zip_ref.extractall(directory_to_extract_to)

            # It's the 'model.ldr' file we want to use
            filepath = os.path.join(directory_to_extract_to, "model.ldr")

            # Add the subdirectories of the directory to the search paths
            Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts"))
            Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "parts"))

            if Options.resolution == "High":
                Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "p", "48"))
            elif Options.resolution == "Low":
                Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "p", "8"))
            Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "p"))
            Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "s"))
            Configure.appendPath(os.path.join(directory_to_extract_to, "CustomParts", "s", "s"))

        self.fullFilepath = filepath

        # Load text into local lines variable
        lines = FileSystem.readTextFile(filepath)
        if lines is None:
            printWarningOnce("Could not read file {0}".format(filepath))
            lines = []

        # MPD files have separate sections between '0 FILE' and '0 NOFILE' lines.
        # Split into sections between "0 FILE" and "0 NOFILE" lines
        sections = []

        startLine = 0
        endLine = 0
        lineCount = 0
        sectionFilename = filepath
        foundEnd = False

        for line in lines:
            parameters = line.strip().split()
            if len(parameters) > 2:
                if parameters[0] == "0" and parameters[1] == "FILE":
                    if foundEnd == False:
                        endLine = lineCount
                        if endLine > startLine:
                            sections.append((sectionFilename, lines[startLine:endLine]))

                    startLine = lineCount
                    foundEnd = False
                    sectionFilename = " ".join(parameters[2:])

                if parameters[0] == "0" and parameters[1] == "NOFILE":
                    endLine = lineCount
                    foundEnd = True
                    sections.append((sectionFilename, lines[startLine:endLine]))
            lineCount += 1

        if foundEnd == False:
            endLine = lineCount
            if endLine > startLine:
                sections.append((sectionFilename, lines[startLine:endLine]))

        if len(sections) == 0:
            return False

        # First section is the main one
        self.filename = sections[0][0]
        self.lines = sections[0][1]

        # Remaining sections are loaded into the cached files
        for (sectionFilename, lines) in sections[1:]:
            # Load section
            file = LDrawFile(sectionFilename, False, filepath, lines, False)
            assert file is not None

            # Cache section
            CachedFiles.addToCache(sectionFilename, file)

        return True

    def __isStud(filename):
        """Is this file a stud?"""

        if LDrawFile.__isStudLogo(filename):
            return True

        # Extract just the filename, in lower case
        filename = filename.replace("\\", os.path.sep)
        name = os.path.basename(filename).lower()

        return name in (
            "stud2.dat",
            "stud6.dat",
            "stud6a.dat",
            "stud7.dat",
            "stud10.dat",
            "stud13.dat",
            "stud15.dat",
            "stud20.dat",
            "studa.dat",
            "teton.dat",        # TENTE
            "stud-logo3.dat",   "stud-logo4.dat",   "stud-logo5.dat",
            "stud2-logo3.dat",  "stud2-logo4.dat",  "stud2-logo5.dat",
            "stud6-logo3.dat",  "stud6-logo4.dat",  "stud6-logo5.dat",
            "stud6a-logo3.dat", "stud6a-logo4.dat", "stud6a-logo5.dat",
            "stud7-logo3.dat",  "stud7-logo4.dat",  "stud7-logo5.dat",
            "stud10-logo3.dat", "stud10-logo4.dat", "stud10-logo5.dat",
            "stud13-logo3.dat", "stud13-logo4.dat", "stud13-logo5.dat",
            "stud15-logo3.dat", "stud15-logo4.dat", "stud15-logo5.dat",
            "stud20-logo3.dat", "stud20-logo4.dat", "stud20-logo5.dat",
            "studa-logo3.dat",  "studa-logo4.dat",  "studa-logo5.dat",
            "studtente-logo.dat"    # TENTE
             )

    def __isStudLogo(filename):
        """Is this file a stud logo?"""

        # Extract just the filename, in lower case
        filename = filename.replace("\\", os.path.sep)
        name = os.path.basename(filename).lower()

        return name in ("logo3.dat", "logo4.dat", "logo5.dat", "logotente.dat")

    def __init__(self, filename, isFullFilepath, parentFilepath, lines = None, isSubPart=False):
        """Loads an LDraw file (IO, LDR, L3B, DAT or MPD)"""

        global globalCamerasToAdd
        global globalScaleFactor

        self.filename         = filename
        self.lines            = lines
        self.isPart           = False
        self.isSubPart        = isSubPart
        self.isStud           = LDrawFile.__isStud(filename)
        self.isStudLogo       = LDrawFile.__isStudLogo(filename)
        self.isLSynthPart     = False
        self.isDoubleSided    = False
        self.geometry         = LDrawGeometry()
        self.childNodes       = []
        self.bfcCertified     = None
        self.isModel          = False

        isGrainySlopeAllowed = not self.isStud

        if self.lines is None:
            # Load the file into self.lines
            if not self.__loadLegoFile(self.filename, isFullFilepath, parentFilepath):
                return
        else:
            # We are loading a section of our parent document, so full filepath is that of the parent
            self.fullFilepath = parentFilepath

        # BFC = Back face culling. The rules are arcane and complex, but at least
        #       it's kind of documented: http://www.ldraw.org/article/415.html
        bfcLocalCull          = True
        bfcWindingCCW         = True
        bfcInvertNext         = False
        processingLSynthParts = False
        camera = LDrawCamera()

        currentGroupNames = []

        #debugPrint("Processing file {0}, isSubPart = {1}, found {2} lines".format(self.filename, self.isSubPart, len(self.lines)))

        for line in self.lines:
            parameters = line.strip().split()

            # Skip empty lines
            if len(parameters) == 0:
                continue

            # Pad with empty values to simplify parsing code
            while len(parameters) < 9:
                parameters.append("")

            # Parse LDraw comments (some of which have special significance)
            if parameters[0] == "0":
                if parameters[1] == "!LDRAW_ORG":
                    partType = parameters[2].lower()
                    if 'part' in partType:
                        self.isPart = True
                    if 'subpart' in partType:
                        self.isSubPart = True
                    if 'primitive' in partType:
                        self.isSubPart = True
                    #if 'shortcut' in partType:
                    #    self.isPart = True

                if parameters[1] == "BFC":
                    # If unsure about being certified yet...
                    if self.bfcCertified is None:
                        if parameters[2] == "NOCERTIFY":
                            self.bfcCertified = False
                        else:
                            self.bfcCertified = True
                    if "CW" in parameters:
                        bfcWindingCCW = False
                    if "CCW" in parameters:
                        bfcWindingCCW = True
                    if "CLIP" in parameters:
                        bfcLocalCull = True
                    if "NOCLIP" in parameters:
                        bfcLocalCull = False
                    if "INVERTNEXT" in parameters:
                        bfcInvertNext = True
                if parameters[1] == "SYNTH":
                    if parameters[2] == "SYNTHESIZED":
                        if parameters[3] == "BEGIN":
                            processingLSynthParts = True
                        if parameters[3] == "END":
                            processingLSynthParts = False
                if parameters[1] == "!LDCAD":
                    if parameters[2] == "GENERATED":
                        processingLSynthParts = True
                if parameters[1] == "!LEOCAD":
                    if parameters[2] == "GROUP":
                        if parameters[3] == "BEGIN":
                            currentGroupNames.append(" ".join(parameters[4:]))
                        elif parameters[3] == "END":
                            currentGroupNames.pop(-1)
                    if parameters[2] == "CAMERA":
                        if Options.importCameras:
                            parameters = parameters[3:]
                            while( len(parameters) > 0):
                                if parameters[0] == "FOV":
                                    camera.vert_fov_degrees = float(parameters[1])
                                    parameters = parameters[2:]
                                elif parameters[0] == "ZNEAR":
                                    camera.near = globalScaleFactor * float(parameters[1])
                                    parameters = parameters[2:]
                                elif parameters[0] == "ZFAR":
                                    camera.far = globalScaleFactor * float(parameters[1])
                                    parameters = parameters[2:]
                                elif parameters[0] == "POSITION":
                                    camera.position = Math.scaleMatrix @ mathutils.Vector((float(parameters[1]), float(parameters[2]), float(parameters[3])))
                                    parameters = parameters[4:]
                                elif parameters[0] == "TARGET_POSITION":
                                    camera.target_position = Math.scaleMatrix @ mathutils.Vector((float(parameters[1]), float(parameters[2]), float(parameters[3])))
                                    parameters = parameters[4:]
                                elif parameters[0] == "UP_VECTOR":
                                    camera.up_vector = mathutils.Vector((float(parameters[1]), float(parameters[2]), float(parameters[3])))
                                    parameters = parameters[4:]
                                elif parameters[0] == "ORTHOGRAPHIC":
                                    camera.orthographic = True
                                    parameters = parameters[1:]
                                elif parameters[0] == "HIDDEN":
                                    camera.hidden = True
                                    parameters = parameters[1:]
                                elif parameters[0] == "NAME":
                                    camera.name = line.split(" NAME ",1)[1].strip()

                                    globalCamerasToAdd.append(camera)
                                    camera = LDrawCamera()

                                    # By definition this is the last of the parameters
                                    parameters = []
                                else:
                                    parameters = parameters[1:]


            else:
                if self.bfcCertified is None:
                    self.bfcCertified = False

                self.isModel = (not self.isPart) and (not self.isSubPart)

                # Parse a File reference
                if parameters[0] == "1":
                    (x, y, z, a, b, c, d, e, f, g, h, i) = map(float, parameters[2:14])
                    (x, y, z) = Math.scaleMatrix @ mathutils.Vector((x, y, z))
                    localMatrix = mathutils.Matrix( ((a, b, c, x), (d, e, f, y), (g, h, i, z), (0, 0, 0, 1)) )

                    new_filename = " ".join(parameters[14:])
                    new_colourName = parameters[1]

                    det = localMatrix.determinant()
                    if det < 0:
                        bfcInvertNext = not bfcInvertNext
                    canCullChildNode = (self.bfcCertified or self.isModel) and bfcLocalCull and (det != 0)

                    if new_filename != "":
                        newNode = LDrawNode(new_filename, False, self.fullFilepath, new_colourName, localMatrix, canCullChildNode, bfcInvertNext, processingLSynthParts, not self.isModel, False, currentGroupNames)
                        self.childNodes.append(newNode)
                    else:
                        printWarningOnce("In file '{0}', the line '{1}' is not formatted corectly (ignoring).".format(self.fullFilepath, line))

                # Parse an edge
                elif parameters[0] == "2":
                    self.geometry.parseEdge(parameters)

                # Parse a Face (either a triangle or a quadrilateral)
                elif parameters[0] == "3" or parameters[0] == "4":
                    if self.bfcCertified is None:
                        self.bfcCertified = False
                    if not self.bfcCertified or not bfcLocalCull:
                        printWarningOnce("Found double-sided polygons in file {0}".format(self.filename))
                        self.isDoubleSided = True

                    assert len(self.geometry.faces) == len(self.geometry.faceInfo)
                    self.geometry.parseFace(parameters, self.bfcCertified and bfcLocalCull, bfcWindingCCW, isGrainySlopeAllowed)
                    assert len(self.geometry.faces) == len(self.geometry.faceInfo)

                bfcInvertNext = False

        #debugPrint("File {0} is part = {1}, is subPart = {2}, isModel = {3}".format(filename, self.isPart, isSubPart, self.isModel))


# **************************************************************************************
# **************************************************************************************
class BlenderMaterials:
    """Creates and stores a cache of materials for Blender"""

    __material_list = {}
    if bpy.app.version >= (4, 0, 0):
        __hasPrincipledShader = True
    else:
        __hasPrincipledShader = "ShaderNodeBsdfPrincipled" in [node.nodetype for node in getattr(bpy.types, "NODE_MT_category_SH_NEW_SHADER").category.items(None)]

    def __getGroupName(name):
        if Options.instructionsLook:
            return name + " Instructions"
        return name

    def __createNodeBasedMaterial(blenderName, col, isSlopeMaterial=False):
        """Set Cycles Material Values."""

        # Reuse current material if it exists, otherwise create a new material
        if bpy.data.materials.get(blenderName) is None:
            material = bpy.data.materials.new(blenderName)
        else:
            material = bpy.data.materials[blenderName]

        # Use nodes
        material.use_nodes = True

        if col is not None:
            if len(col["colour"]) == 3:
                colour = col["colour"] + (1.0,)
            material.diffuse_color = getDiffuseColor(col["colour"][0:3])

        if Options.instructionsLook:
            material.blend_method = 'BLEND'
            material.show_transparent_back = False

            if col is not None:
                # Dark colours have white lines
                if LegoColours.isDark(colour):
                    material.line_color = (1.0, 1.0, 1.0, 1.0)

        nodes = material.node_tree.nodes
        links = material.node_tree.links

        # Remove any existing nodes
        for n in nodes:
            nodes.remove(n)

        if col is not None:
            isTransparent = col["alpha"] < 1.0

            if Options.instructionsLook:
                BlenderMaterials.__createCyclesBasic(nodes, links, colour, col["alpha"], "")
            elif col["name"] == "Milky_White":
                BlenderMaterials.__createCyclesMilkyWhite(nodes, links, colour)
            elif col["luminance"] > 0:
                BlenderMaterials.__createCyclesEmission(nodes, links, colour, col["alpha"], col["luminance"])
            elif col["material"] == "CHROME":
                BlenderMaterials.__createCyclesChrome(nodes, links, colour)
            elif col["material"] == "PEARLESCENT":
                BlenderMaterials.__createCyclesPearlescent(nodes, links, colour)
            elif col["material"] == "METAL":
                BlenderMaterials.__createCyclesMetal(nodes, links, colour)
            elif col["material"] == "GLITTER":
                BlenderMaterials.__createCyclesGlitter(nodes, links, colour, col["secondary_colour"])
            elif col["material"] == "SPECKLE":
                BlenderMaterials.__createCyclesSpeckle(nodes, links, colour, col["secondary_colour"])
            elif col["material"] == "RUBBER":
                BlenderMaterials.__createCyclesRubber(nodes, links, colour, col["alpha"])
            else:
                BlenderMaterials.__createCyclesBasic(nodes, links, colour, col["alpha"], col["name"])

            if isSlopeMaterial and not Options.instructionsLook:
                BlenderMaterials.__createCyclesSlopeTexture(nodes, links, 0.6)
            elif Options.curvedWalls and not Options.instructionsLook:
                BlenderMaterials.__createCyclesConcaveWalls(nodes, links, 20 * globalScaleFactor)

            material["Lego.isTransparent"] = isTransparent
            return material

        BlenderMaterials.__createCyclesBasic(nodes, links, (1.0, 1.0, 0.0, 1.0), 1.0, "")
        material["Lego.isTransparent"] = False
        return material

    def __nodeConcaveWalls(nodes, strength, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Concave Walls')]
        node.location = x, y
        node.inputs['Strength'].default_value = strength
        return node

    def __nodeSlopeTexture(nodes, strength, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Slope Texture')]
        node.location = x, y
        node.inputs['Strength'].default_value = strength
        return node

    def __nodeLegoStandard(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Standard')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoTransparentFluorescent(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Transparent Fluorescent')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoTransparent(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Transparent')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoRubberSolid(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Rubber Solid')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoRubberTranslucent(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Rubber Translucent')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoEmission(nodes, colour, luminance, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Emission')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        node.inputs['Luminance'].default_value = luminance
        return node

    def __nodeLegoChrome(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Chrome')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoPearlescent(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Pearlescent')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoMetal(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Metal')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeLegoGlitter(nodes, colour, glitterColour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Glitter')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        node.inputs['Glitter Color'].default_value = glitterColour
        return node

    def __nodeLegoSpeckle(nodes, colour, speckleColour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Speckle')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        node.inputs['Speckle Color'].default_value = speckleColour
        return node

    def __nodeLegoMilkyWhite(nodes, colour, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups[BlenderMaterials.__getGroupName('Lego Milky White')]
        node.location = x, y
        node.inputs['Color'].default_value = colour
        return node

    def __nodeMix(nodes, factor, x, y):
        node = nodes.new('ShaderNodeMixShader')
        node.location = x, y
        node.inputs['Fac'].default_value = factor
        return node

    def __nodeOutput(nodes, x, y):
        node = nodes.new('ShaderNodeOutputMaterial')
        node.location = x, y
        return node

    def __nodeDielectric(nodes, roughness, reflection, transparency, ior, x, y):
        node = nodes.new('ShaderNodeGroup')
        node.node_tree = bpy.data.node_groups['PBR-Dielectric']
        node.location = x, y
        node.inputs['Roughness'].default_value = roughness
        node.inputs['Reflection'].default_value = reflection
        node.inputs['Transparency'].default_value = transparency
        node.inputs['IOR'].default_value = ior
        return node

    def __nodePrincipled(nodes, subsurface, sub_rad, metallic, roughness, clearcoat, clearcoat_roughness, ior, transmission, x, y):
        node = nodes.new('ShaderNodeBsdfPrincipled')
        node.location = x, y

        # Some inputs are renamed in Blender 4
        if bpy.app.version >= (4, 0, 0):
            node.inputs['Subsurface Weight'].default_value = subsurface
            node.inputs['Coat Weight'].default_value = clearcoat
            node.inputs['Coat Roughness'].default_value = clearcoat_roughness
            node.inputs['Transmission Weight'].default_value = transmission
        else:
            # Blender 3.X or earlier
            node.inputs['Subsurface'].default_value = subsurface
            node.inputs['Clearcoat'].default_value = clearcoat
            node.inputs['Clearcoat Roughness'].default_value = clearcoat_roughness
            node.inputs['Transmission'].default_value = transmission

        node.inputs['Subsurface Radius'].default_value = mathutils.Vector( (sub_rad, sub_rad, sub_rad) )
        node.inputs['Metallic'].default_value = metallic
        node.inputs['Roughness'].default_value = roughness
        node.inputs['IOR'].default_value = ior
        return node

    def __nodeHSV(nodes, h, s, v, x, y):
        node = nodes.new('ShaderNodeHueSaturation')
        node.location = x, y
        node.inputs[0].default_value = h
        node.inputs[1].default_value = s
        node.inputs[2].default_value = v
        return node

    def __nodeSeparateHSV(nodes, x, y):
        node = nodes.new('ShaderNodeSeparateHSV')
        node.location = x, y
        return node

    def __nodeCombineHSV(nodes, x, y):
        node = nodes.new('ShaderNodeCombineHSV')
        node.location = x, y
        return node

    def __nodeTexCoord(nodes, x, y):
        node = nodes.new('ShaderNodeTexCoord')
        node.location = x, y
        return node

    def __nodeTexWave(nodes, wave_type, wave_profile, scale, distortion, detail, detailScale, x, y):
        node = nodes.new('ShaderNodeTexWave')
        node.wave_type = wave_type
        node.wave_profile = wave_profile
        node.inputs[1].default_value = scale
        node.inputs[2].default_value = distortion
        node.inputs[3].default_value = detail
        node.inputs[4].default_value = detailScale
        node.location = x, y
        return node

    def __nodeDiffuse(nodes, roughness, x, y):
        node = nodes.new('ShaderNodeBsdfDiffuse')
        node.location = x, y
        node.inputs['Color'].default_value = (1,1,1,1)
        node.inputs['Roughness'].default_value = roughness
        return node

    def __nodeGlass(nodes, roughness, ior, distribution, x, y):
        node = nodes.new('ShaderNodeBsdfGlass')
        node.location = x, y
        node.distribution = distribution
        node.inputs['Color'].default_value = (1,1,1,1)
        node.inputs['Roughness'].default_value = roughness
        node.inputs['IOR'].default_value = ior
        return node

    def __nodeFresnel(nodes, ior, x, y):
        node = nodes.new('ShaderNodeFresnel')
        node.location = x, y
        node.inputs['IOR'].default_value = ior
        return node

    def __nodeGlossy(nodes, colour, roughness, distribution, x, y):
        node = nodes.new('ShaderNodeBsdfGlossy')
        node.location = x, y
        node.distribution = distribution
        node.inputs['Color'].default_value = colour
        node.inputs['Roughness'].default_value = roughness
        return node

    def __nodeTranslucent(nodes, x, y):
        node = nodes.new('ShaderNodeBsdfTranslucent')
        node.location = x, y
        return node

    def __nodeTransparent(nodes, x, y):
        node = nodes.new('ShaderNodeBsdfTransparent')
        node.location = x, y
        return node

    def __nodeAddShader(nodes, x, y):
        node = nodes.new('ShaderNodeAddShader')
        node.location = x, y
        return node

    def __nodeVolume(nodes, density, x, y):
        node = nodes.new('ShaderNodeVolumeAbsorption')
        node.inputs['Density'].default_value = density
        node.location = x, y
        return node

    def __nodeLightPath(nodes, x, y):
        node = nodes.new('ShaderNodeLightPath')
        node.location = x, y
        return node

    def __nodeMath(nodes, operation, x, y):
        node = nodes.new('ShaderNodeMath')
        node.operation = operation
        node.location = x, y
        return node

    def __nodeVectorMath(nodes, operation, x, y):
        node = nodes.new('ShaderNodeVectorMath')
        node.operation = operation
        node.location = x, y
        return node

    def __nodeEmission(nodes, x, y):
        node = nodes.new('ShaderNodeEmission')
        node.location = x, y
        return node

    def __nodeVoronoi(nodes, scale, x, y):
        node = nodes.new('ShaderNodeTexVoronoi')
        node.location = x, y
        node.inputs['Scale'].default_value = scale
        return node

    def __nodeGamma(nodes, gamma, x, y):
        node = nodes.new('ShaderNodeGamma')
        node.location = x, y
        node.inputs['Gamma'].default_value = gamma
        return node

    def __nodeColorRamp(nodes, pos1, colour1, pos2, colour2, x, y):
        node = nodes.new('ShaderNodeValToRGB')
        node.location = x, y
        node.color_ramp.elements[0].position = pos1
        node.color_ramp.elements[0].color = colour1
        node.color_ramp.elements[1].position = pos2
        node.color_ramp.elements[1].color = colour2
        return node

    def __nodeNoiseTexture(nodes, scale, detail, distortion, x, y):
        node = nodes.new('ShaderNodeTexNoise')
        node.location = x, y
        node.inputs['Scale'].default_value = scale
        node.inputs['Detail'].default_value = detail
        node.inputs['Distortion'].default_value = distortion
        return node

    def __nodeBumpShader(nodes, strength, distance, x, y):
        node = nodes.new('ShaderNodeBump')
        node.location = x, y
        node.inputs[0].default_value = strength
        node.inputs[1].default_value = distance
        return node

    def __nodeRefraction(nodes, roughness, ior, x, y):
        node = nodes.new('ShaderNodeBsdfRefraction')
        node.inputs['Roughness'].default_value = roughness
        node.inputs['IOR'].default_value = ior
        node.location = x, y
        return node

    def __getGroup(nodes):
        out = None
        for x in nodes:
            if x.type == 'GROUP':
                return x
        return None

    def __createCyclesConcaveWalls(nodes, links, strength):
        """Concave wall normals for Cycles render engine"""
        node = BlenderMaterials.__nodeConcaveWalls(nodes, strength, -200, 5)
        out = BlenderMaterials.__getGroup(nodes)
        if out is not None:
            links.new(node.outputs['Normal'], out.inputs['Normal'])

    def __createCyclesSlopeTexture(nodes, links, strength):
        """Slope face normals for Cycles render engine"""
        node = BlenderMaterials.__nodeSlopeTexture(nodes, strength, -200, 5)
        out = BlenderMaterials.__getGroup(nodes)
        if out is not None:
            links.new(node.outputs['Normal'], out.inputs['Normal'])

    def __createCyclesBasic(nodes, links, diffColour, alpha, colName):
        """Basic Material for Cycles render engine."""

        if alpha < 1:
            if LegoColours.isFluorescentTransparent(colName):
                node = BlenderMaterials.__nodeLegoTransparentFluorescent(nodes, diffColour, 0, 5)
            else:
                node = BlenderMaterials.__nodeLegoTransparent(nodes, diffColour, 0, 5)
        else:
            node = BlenderMaterials.__nodeLegoStandard(nodes, diffColour, 0, 5)

        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesEmission(nodes, links, diffColour, alpha, luminance):
        """Emission material for Cycles render engine."""

        node = BlenderMaterials.__nodeLegoEmission(nodes, diffColour, luminance/100.0, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesChrome(nodes, links, diffColour):
        """Chrome material for Cycles render engine."""

        node = BlenderMaterials.__nodeLegoChrome(nodes, diffColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesPearlescent(nodes, links, diffColour):
        """Pearlescent material for Cycles render engine."""

        node = BlenderMaterials.__nodeLegoPearlescent(nodes, diffColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesMetal(nodes, links, diffColour):
        """Metal material for Cycles render engine."""

        node = BlenderMaterials.__nodeLegoMetal(nodes, diffColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesGlitter(nodes, links, diffColour, glitterColour):
        """Glitter material for Cycles render engine."""

        glitterColour = LegoColours.lightenRGBA(glitterColour, 0.5)
        node = BlenderMaterials.__nodeLegoGlitter(nodes, diffColour, glitterColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesSpeckle(nodes, links, diffColour, speckleColour):
        """Speckle material for Cycles render engine."""

        speckleColour = LegoColours.lightenRGBA(speckleColour, 0.5)
        node = BlenderMaterials.__nodeLegoSpeckle(nodes, diffColour, speckleColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __createCyclesRubber(nodes, links, diffColour, alpha):
        """Rubber material colours for Cycles render engine."""

        out    = BlenderMaterials.__nodeOutput(nodes, 200, 0)

        if alpha < 1.0:
            rubber = BlenderMaterials.__nodeLegoRubberTranslucent(nodes, diffColour, 0, 5)
        else:
            rubber = BlenderMaterials.__nodeLegoRubberSolid(nodes, diffColour, 0, 5)

        links.new(rubber.outputs[0], out.inputs[0])

    def __createCyclesMilkyWhite(nodes, links, diffColour):
        """Milky White material for Cycles render engine."""

        node = BlenderMaterials.__nodeLegoMilkyWhite(nodes, diffColour, 0, 5)
        out = BlenderMaterials.__nodeOutput(nodes, 200, 0)
        links.new(node.outputs['Shader'], out.inputs[0])

    def __is_int(s):
        try:
            int(s)
            return True
        except ValueError:
            return False

    def __getColourData(colourName):
        """Get the colour data associated with the colour name"""

        # Try the LDraw defined colours
        if BlenderMaterials.__is_int(colourName):
            colourInt = int(colourName)
            if colourInt in LegoColours.colours:
                return LegoColours.colours[colourInt]

        # Handle direct colours
        # Direct colours are documented here: http://www.hassings.dk/l3/l3p.html
        linearRGBA = LegoColours.hexStringToLinearRGBA(colourName)
        if linearRGBA is None:
            printWarningOnce("Could not decode {0} to a colour".format(colourName))
            return None
        return {
            "name":         colourName,
            "colour":       linearRGBA[0:3],
            "alpha":        linearRGBA[3],
            "luminance":    0.0,
            "material":     "BASIC"
        }

    # **********************************************************************************
    def getMaterial(colourName, isSlopeMaterial):
        pureColourName = colourName
        if isSlopeMaterial:
            colourName = colourName + "_s"

        # If it's already in the cache, use that
        if (colourName in BlenderMaterials.__material_list):
            result = BlenderMaterials.__material_list[colourName]
            return result

        # Create a name for the material based on the colour
        if Options.instructionsLook:
            blenderName = "MatInst_{0}".format(colourName)
        elif Options.curvedWalls and not isSlopeMaterial:
            blenderName = "Material_{0}_c".format(colourName)
        else:
            blenderName = "Material_{0}".format(colourName)

        # If the name already exists in Blender, use that
        if Options.overwriteExistingMaterials is False:
            if blenderName in bpy.data.materials:
                return bpy.data.materials[blenderName]

        # Create new material
        col = BlenderMaterials.__getColourData(pureColourName)
        material = BlenderMaterials.__createNodeBasedMaterial(blenderName, col, isSlopeMaterial)

        if material is None:
            printWarningOnce("Could not create material for blenderName {0}".format(blenderName))

        # Add material to cache
        BlenderMaterials.__material_list[colourName] = material
        return material

    # **********************************************************************************
    def clearCache():
        BlenderMaterials.__material_list = {}

    # **********************************************************************************
    def addInputSocket(group, my_socket_type, myname):
        if bpy.app.version >= (4, 0, 0):
            if my_socket_type.endswith("FloatFactor"):
                my_socket_type = my_socket_type[:-6]
            elif my_socket_type.endswith("VectorDirection"):
                my_socket_type = my_socket_type[:-9]
            group.interface.new_socket(name=myname, in_out="INPUT", socket_type=my_socket_type)
        else:
            if my_socket_type.endswith("Vector"):
                my_socket_type += "Direction"
            group.inputs.new(my_socket_type, myname)

    # **********************************************************************************
    def addOutputSocket(group, my_socket_type, myname):
        if bpy.app.version >= (4, 0, 0):
            if my_socket_type.endswith("FloatFactor"):
                my_socket_type = my_socket_type[:-6]
            elif my_socket_type.endswith("VectorDirection"):
                my_socket_type = my_socket_type[:-9]
            group.interface.new_socket(name=myname, in_out="OUTPUT", socket_type=my_socket_type)
        else:
            if my_socket_type.endswith("Vector"):
                my_socket_type += "Direction"
            group.outputs.new(my_socket_type, myname)

    # **********************************************************************************
    def setDefaults(group, name, default_value, min_value, max_value):
        if bpy.app.version >= (4, 0, 0):
            group_inputs = group.nodes["Group Input"].outputs
            group_inputs[name].default_value = default_value
            # TODO: How to set min_value and max_value?
        else:
            group_inputs = group.inputs
            group_inputs[name].default_value = default_value
            group_inputs[name].min_value = min_value
            group_inputs[name].max_value = max_value

    # **********************************************************************************
    def __createGroup(name, x1, y1, x2, y2, createShaderOutput):
        group = bpy.data.node_groups.new(name, 'ShaderNodeTree')

        # create input node
        node_input = group.nodes.new('NodeGroupInput')
        node_input.location = (x1,y1)

        # create output node
        node_output = group.nodes.new('NodeGroupOutput')
        node_output.location = (x2,y2)
        if createShaderOutput:
            BlenderMaterials.addOutputSocket(group, 'NodeSocketShader', 'Shader')
        return (group, node_input, node_output)

    # **********************************************************************************
    def __createBlenderDistanceToCenterNodeGroup():
        if bpy.data.node_groups.get('Distance-To-Center') is None:
            debugPrint("createBlenderDistanceToCenterNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('Distance-To-Center', -930, 0, 240, 0, False)
            BlenderMaterials.addOutputSocket(group, 'NodeSocketVectorDirection', 'Vector')

            # create nodes
            node_texture_coordinate = BlenderMaterials.__nodeTexCoord(group.nodes, -730, 0)

            node_vector_subtraction1 = BlenderMaterials.__nodeVectorMath(group.nodes, 'SUBTRACT', -535, 0)
            node_vector_subtraction1.inputs[1].default_value[0] = 0.5
            node_vector_subtraction1.inputs[1].default_value[1] = 0.5
            node_vector_subtraction1.inputs[1].default_value[2] = 0.5

            node_normalize = BlenderMaterials.__nodeVectorMath(group.nodes, 'NORMALIZE', -535, -245)
            node_dot_product = BlenderMaterials.__nodeVectorMath(group.nodes, 'DOT_PRODUCT', -340, -125)

            node_multiply = group.nodes.new('ShaderNodeMixRGB')
            node_multiply.blend_type = 'MULTIPLY'
            node_multiply.inputs['Fac'].default_value = 1.0
            node_multiply.location = -145, -125

            node_vector_subtraction2 = BlenderMaterials.__nodeVectorMath(group.nodes, 'SUBTRACT', 40, 0)

            # link nodes together
            group.links.new(node_texture_coordinate.outputs['Generated'], node_vector_subtraction1.inputs[0])
            group.links.new(node_texture_coordinate.outputs['Normal'], node_normalize.inputs[0])
            group.links.new(node_vector_subtraction1.outputs['Vector'], node_dot_product.inputs[0])
            group.links.new(node_normalize.outputs['Vector'], node_dot_product.inputs[1])
            group.links.new(node_dot_product.outputs['Value'], node_multiply.inputs['Color1'])
            group.links.new(node_normalize.outputs['Vector'], node_multiply.inputs['Color2'])
            group.links.new(node_vector_subtraction1.outputs['Vector'], node_vector_subtraction2.inputs[0])
            group.links.new(node_multiply.outputs['Color'], node_vector_subtraction2.inputs[1])
            group.links.new(node_vector_subtraction2.outputs['Vector'], node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderVectorElementPowerNodeGroup():
        if bpy.data.node_groups.get('Vector-Element-Power') is None:
            debugPrint("createBlenderVectorElementPowerNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('Vector-Element-Power', -580, 0, 400, 0, False)
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Exponent')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Vector')
            BlenderMaterials.addOutputSocket(group, 'NodeSocketVectorDirection', 'Vector')

            # create nodes
            node_separate_xyz = group.nodes.new('ShaderNodeSeparateXYZ')
            node_separate_xyz.location = -385, -140

            node_abs_x = BlenderMaterials.__nodeMath(group.nodes, 'ABSOLUTE', -180, 180)
            node_abs_y = BlenderMaterials.__nodeMath(group.nodes, 'ABSOLUTE', -180, 0)
            node_abs_z = BlenderMaterials.__nodeMath(group.nodes, 'ABSOLUTE', -180, -180)

            node_power_x = BlenderMaterials.__nodeMath(group.nodes, 'POWER', 20, 180)
            node_power_y = BlenderMaterials.__nodeMath(group.nodes, 'POWER', 20, 0)
            node_power_z = BlenderMaterials.__nodeMath(group.nodes, 'POWER', 20, -180)

            node_combine_xyz = group.nodes.new('ShaderNodeCombineXYZ')
            node_combine_xyz.location = 215, 0

            # link nodes together
            group.links.new(node_input.outputs['Vector'], node_separate_xyz.inputs[0])
            group.links.new(node_separate_xyz.outputs['X'], node_abs_x.inputs[0])
            group.links.new(node_separate_xyz.outputs['Y'], node_abs_y.inputs[0])
            group.links.new(node_separate_xyz.outputs['Z'], node_abs_z.inputs[0])
            group.links.new(node_abs_x.outputs['Value'], node_power_x.inputs[0])
            group.links.new(node_input.outputs['Exponent'], node_power_x.inputs[1])
            group.links.new(node_abs_y.outputs['Value'], node_power_y.inputs[0])
            group.links.new(node_input.outputs['Exponent'], node_power_y.inputs[1])
            group.links.new(node_abs_z.outputs['Value'], node_power_z.inputs[0])
            group.links.new(node_input.outputs['Exponent'], node_power_z.inputs[1])
            group.links.new(node_power_x.outputs['Value'], node_combine_xyz.inputs['X'])
            group.links.new(node_power_y.outputs['Value'], node_combine_xyz.inputs['Y'])
            group.links.new(node_power_z.outputs['Value'], node_combine_xyz.inputs['Z'])
            group.links.new(node_combine_xyz.outputs['Vector'], node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderConvertToNormalsNodeGroup():
        if bpy.data.node_groups.get('Convert-To-Normals') is None:
            debugPrint("createBlenderConvertToNormalsNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('Convert-To-Normals', -490, 0, 400, 0, False)
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Vector Length')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Smoothing')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Strength')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Normal')
            BlenderMaterials.addOutputSocket(group, 'NodeSocketVectorDirection', 'Normal')

            # create nodes
            node_power = BlenderMaterials.__nodeMath(group.nodes, 'POWER', -290, 150)

            node_colorramp = group.nodes.new('ShaderNodeValToRGB')
            node_colorramp.color_ramp.color_mode = 'RGB'
            node_colorramp.color_ramp.interpolation = 'EASE'
            node_colorramp.color_ramp.elements[0].color = (1, 1, 1, 1)
            node_colorramp.color_ramp.elements[1].color = (0, 0, 0, 1)
            node_colorramp.color_ramp.elements[1].position = 0.45
            node_colorramp.location = -95, 150

            node_bump = group.nodes.new('ShaderNodeBump')
            node_bump.inputs['Distance'].default_value = 0.02
            node_bump.location = 200, 0

            # link nodes together
            group.links.new(node_input.outputs['Vector Length'], node_power.inputs[0])
            group.links.new(node_input.outputs['Smoothing'], node_power.inputs[1])
            group.links.new(node_power.outputs['Value'], node_colorramp.inputs[0])
            group.links.new(node_input.outputs['Strength'], node_bump.inputs['Strength'])
            group.links.new(node_colorramp.outputs['Color'], node_bump.inputs['Height'])
            group.links.new(node_input.outputs['Normal'], node_bump.inputs['Normal'])
            group.links.new(node_bump.outputs['Normal'], node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderConcaveWallsNodeGroup():
        if bpy.data.node_groups.get('Concave Walls') is None:
            debugPrint("createBlenderConcaveWallsNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('Concave Walls', -530, 0, 300, 0, False)
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Strength')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Normal')
            BlenderMaterials.addOutputSocket(group, 'NodeSocketVectorDirection', 'Normal')

            # create nodes
            node_distance_to_center = group.nodes.new('ShaderNodeGroup')
            node_distance_to_center.node_tree = bpy.data.node_groups['Distance-To-Center']
            node_distance_to_center.location = (-340,105)

            node_vector_elements_power = group.nodes.new('ShaderNodeGroup')
            node_vector_elements_power.node_tree = bpy.data.node_groups['Vector-Element-Power']
            node_vector_elements_power.location = (-120,105)
            node_vector_elements_power.inputs['Exponent'].default_value = 4.0

            node_convert_to_normals = group.nodes.new('ShaderNodeGroup')
            node_convert_to_normals.node_tree = bpy.data.node_groups['Convert-To-Normals']
            node_convert_to_normals.location = (90,0)
            node_convert_to_normals.inputs['Strength'].default_value = 0.2
            node_convert_to_normals.inputs['Smoothing'].default_value = 0.3

            # link nodes together
            group.links.new(node_distance_to_center.outputs['Vector'], node_vector_elements_power.inputs['Vector'])
            group.links.new(node_vector_elements_power.outputs['Vector'], node_convert_to_normals.inputs['Vector Length'])
            group.links.new(node_input.outputs['Strength'], node_convert_to_normals.inputs['Strength'])
            group.links.new(node_input.outputs['Normal'], node_convert_to_normals.inputs['Normal'])
            group.links.new(node_convert_to_normals.outputs['Normal'], node_output.inputs['Normal'])

    # **********************************************************************************
    def __createBlenderSlopeTextureNodeGroup():
        global globalScaleFactor

        if bpy.data.node_groups.get('Slope Texture') is None:
            debugPrint("createBlenderSlopeTextureNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('Slope Texture', -530, 0, 300, 0, False)
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'Strength')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Normal')
            BlenderMaterials.addOutputSocket(group, 'NodeSocketVectorDirection', 'Normal')

            # create nodes
            node_texture_coordinate = BlenderMaterials.__nodeTexCoord(group.nodes, -300, 240)
            node_voronoi = BlenderMaterials.__nodeVoronoi(group.nodes, 3.0/globalScaleFactor, -100, 155)
            node_bump = BlenderMaterials.__nodeBumpShader(group.nodes, 0.3, 0.08, 90, 50)
            node_bump.invert = True

            # link nodes together
            group.links.new(node_texture_coordinate.outputs['Object'], node_voronoi.inputs['Vector'])
            group.links.new(node_voronoi.outputs['Distance'], node_bump.inputs['Height'])
            group.links.new(node_input.outputs['Strength'], node_bump.inputs['Strength'])
            group.links.new(node_input.outputs['Normal'], node_bump.inputs['Normal'])
            group.links.new(node_bump.outputs['Normal'], node_output.inputs['Normal'])

    # **********************************************************************************
    def __createBlenderFresnelNodeGroup():
        if bpy.data.node_groups.get('PBR-Fresnel-Roughness') is None:
            debugPrint("createBlenderFresnelNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('PBR-Fresnel-Roughness', -530, 0, 300, 0, False)
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor', 'Roughness')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'IOR')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Normal')
            BlenderMaterials.addOutputSocket(group, 'NodeSocketFloatFactor', 'Fresnel Factor')

            # create nodes
            node_fres = group.nodes.new('ShaderNodeFresnel')
            node_fres.location = (110,0)

            node_mix = group.nodes.new('ShaderNodeMixRGB')
            node_mix.location = (-80,-75)

            node_bump = group.nodes.new('ShaderNodeBump')
            node_bump.location = (-320,-172)
            # node_bump.hide = True

            node_geom = group.nodes.new('ShaderNodeNewGeometry')
            node_geom.location = (-320,-360)
            # node_geom.hide = True

            # link nodes together
            group.links.new(node_input.outputs['Roughness'],   node_mix.inputs['Fac'])       # Input Roughness -> Mix Fac
            group.links.new(node_input.outputs['IOR'],         node_fres.inputs['IOR'])      # Input IOR -> Fres IOR
            group.links.new(node_input.outputs['Normal'],      node_bump.inputs['Normal'])   # Input Normal -> Bump Normal
            group.links.new(node_bump.outputs['Normal'],       node_mix.inputs['Color1'])    # Bump Normal -> Mix Color1
            group.links.new(node_geom.outputs['Incoming'],     node_mix.inputs['Color2'])    # Geom Incoming -> Mix Colour2
            group.links.new(node_mix.outputs['Color'],         node_fres.inputs['Normal'])   # Mix Color -> Fres Normal
            group.links.new(node_fres.outputs['Fac'],          node_output.inputs['Fresnel Factor']) # Fres Fac -> Group Output Fresnel Factor

    # **********************************************************************************
    def __createBlenderReflectionNodeGroup():
        if bpy.data.node_groups.get('PBR-Reflection') is None:
            debugPrint("createBlenderReflectionNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('PBR-Reflection', -530, 0, 300, 0, True)
            BlenderMaterials.addInputSocket(group, 'NodeSocketShader', 'Shader')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor', 'Roughness')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor', 'Reflection')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat', 'IOR')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection', 'Normal')

            node_fresnel_roughness = group.nodes.new('ShaderNodeGroup')
            node_fresnel_roughness.node_tree = bpy.data.node_groups['PBR-Fresnel-Roughness']
            node_fresnel_roughness.location = (-290,145)

            node_mixrgb = group.nodes.new('ShaderNodeMixRGB')
            node_mixrgb.location = (-80,115)
            node_mixrgb.inputs['Color2'].default_value = (0.0, 0.0, 0.0, 1.0)

            node_mix_shader = group.nodes.new('ShaderNodeMixShader')
            node_mix_shader.location = (100,0)

            node_glossy = group.nodes.new('ShaderNodeBsdfGlossy')
            node_glossy.inputs['Color'].default_value = (1.0, 1.0, 1.0, 1.0)
            node_glossy.location = (-290,-95)

            # link nodes together
            group.links.new(node_input.outputs['Shader'],       node_mix_shader.inputs[1])
            group.links.new(node_input.outputs['Roughness'],    node_fresnel_roughness.inputs['Roughness'])
            group.links.new(node_input.outputs['Roughness'],    node_glossy.inputs['Roughness'])
            group.links.new(node_input.outputs['Reflection'],   node_mixrgb.inputs['Color1'])
            group.links.new(node_input.outputs['IOR'],          node_fresnel_roughness.inputs['IOR'])
            group.links.new(node_input.outputs['Normal'],       node_fresnel_roughness.inputs['Normal'])
            group.links.new(node_input.outputs['Normal'],       node_glossy.inputs['Normal'])
            group.links.new(node_fresnel_roughness.outputs[0],  node_mixrgb.inputs[0])
            group.links.new(node_mixrgb.outputs[0],             node_mix_shader.inputs[0])
            group.links.new(node_glossy.outputs[0],             node_mix_shader.inputs[2])
            group.links.new(node_mix_shader.outputs[0],         node_output.inputs['Shader'])

    # **********************************************************************************
    def __createBlenderDielectricNodeGroup():
        if bpy.data.node_groups.get('PBR-Dielectric') is None:
            debugPrint("createBlenderDielectricNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup('PBR-Dielectric', -530, 70, 500, 0, True)
            BlenderMaterials.addInputSocket(group, 'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor','Roughness')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor','Reflection')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloatFactor','Transparency')
            BlenderMaterials.addInputSocket(group, 'NodeSocketFloat','IOR')
            BlenderMaterials.addInputSocket(group, 'NodeSocketVectorDirection','Normal')

            BlenderMaterials.setDefaults(group, 'IOR',          1.46, 0.0, 100.0)
            BlenderMaterials.setDefaults(group, 'Roughness',    0.2,  0.0,   1.0)
            BlenderMaterials.setDefaults(group, 'Reflection',   0.1,  0.0,   1.0)
            BlenderMaterials.setDefaults(group, 'Transparency', 0.0,  0.0,   1.0)

            node_diffuse = group.nodes.new('ShaderNodeBsdfDiffuse')
            node_diffuse.location = (-110,145)

            node_reflection = group.nodes.new('ShaderNodeGroup')
            node_reflection.node_tree = bpy.data.node_groups['PBR-Reflection']
            node_reflection.location = (100,115)

            node_power = BlenderMaterials.__nodeMath(group.nodes, 'POWER', -330, -105)
            node_power.inputs[1].default_value = 2.0

            node_glass = group.nodes.new('ShaderNodeBsdfGlass')
            node_glass.location = (100,-105)

            node_mix_shader = group.nodes.new('ShaderNodeMixShader')
            node_mix_shader.location = (300,5)

            # link nodes together
            group.links.new(node_input.outputs['Color'],        node_diffuse.inputs['Color'])
            group.links.new(node_input.outputs['Roughness'],    node_power.inputs[0])
            group.links.new(node_input.outputs['Reflection'],   node_reflection.inputs['Reflection'])
            group.links.new(node_input.outputs['IOR'],          node_reflection.inputs['IOR'])
            group.links.new(node_input.outputs['Normal'],       node_diffuse.inputs['Normal'])
            group.links.new(node_input.outputs['Normal'],       node_reflection.inputs['Normal'])
            group.links.new(node_power.outputs[0],              node_diffuse.inputs['Roughness'])
            group.links.new(node_power.outputs[0],              node_reflection.inputs['Roughness'])
            group.links.new(node_diffuse.outputs[0],            node_reflection.inputs['Shader'])
            group.links.new(node_reflection.outputs['Shader'],  node_mix_shader.inputs['Shader'])
            group.links.new(node_input.outputs['Color'],        node_glass.inputs['Color'])
            group.links.new(node_input.outputs['IOR'],          node_glass.inputs['IOR'])
            group.links.new(node_input.outputs['Normal'],       node_glass.inputs['Normal'])
            group.links.new(node_power.outputs[0],              node_glass.inputs['Roughness'])
            group.links.new(node_input.outputs['Transparency'], node_mix_shader.inputs[0])
            group.links.new(node_glass.outputs[0],              node_mix_shader.inputs[2])
            group.links.new(node_mix_shader.outputs['Shader'],  node_output.inputs['Shader'])

    # **********************************************************************************
    def __getSubsurfaceColor(node):
        if 'Subsurface Color' in node.inputs:
            # Blender 3
            return node.inputs['Subsurface Color']

        # Blender 4 - Subsurface Colour has been removed, so just use the base colour instead
        return node.inputs['Base Color']

    # **********************************************************************************
    def __createBlenderLegoStandardNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Standard')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoStandardNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -250, 0, 300, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if Options.instructionsLook:
                node_emission = BlenderMaterials.__nodeEmission(group.nodes, 0, 0)
                group.links.new(node_input.outputs['Color'],       node_emission.inputs['Color'])
                group.links.new(node_emission.outputs['Emission'], node_output.inputs['Shader'])
            else:
                if BlenderMaterials.usePrincipledShader:
                    node_main = BlenderMaterials.__nodePrincipled(group.nodes, 5 * globalScaleFactor, 0.05, 0.0, 0.1, 0.0, 0.0, 1.45, 0.0, 0, 0)
                    output_name = 'BSDF'
                    color_name = 'Base Color'
                    group.links.new(node_input.outputs['Color'], BlenderMaterials.__getSubsurfaceColor(node_main))
                else:
                    node_main = BlenderMaterials.__nodeDielectric(group.nodes, 0.2, 0.1, 0.0, 1.46, 0, 0)
                    output_name = 'Shader'
                    color_name = 'Color'

                # link nodes together
                group.links.new(node_input.outputs['Color'],        node_main.inputs[color_name])
                group.links.new(node_input.outputs['Normal'],       node_main.inputs['Normal'])
                group.links.new(node_main.outputs[output_name],     node_output.inputs['Shader'])


    # **********************************************************************************
    def __createBlenderLegoTransparentNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Transparent')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoTransparentNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -250, 0, 300, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if Options.instructionsLook:
                node_emission    = BlenderMaterials.__nodeEmission(group.nodes, 0, 0)
                node_transparent = BlenderMaterials.__nodeTransparent(group.nodes, 0, 100)
                node_mix1        = BlenderMaterials.__nodeMix(group.nodes, 0.5, 400, 100)
                node_light       = BlenderMaterials.__nodeLightPath(group.nodes, 200, 400)
                node_less        = BlenderMaterials.__nodeMath(group.nodes, 'LESS_THAN', 400, 400)
                node_mix2        = BlenderMaterials.__nodeMix(group.nodes, 0.5, 600, 300)

                node_output.location = (800,0)

                group.links.new(node_input.outputs['Color'],                node_emission.inputs['Color'])
                group.links.new(node_transparent.outputs[0],                node_mix1.inputs[1])
                group.links.new(node_emission.outputs['Emission'],          node_mix1.inputs[2])
                group.links.new(node_transparent.outputs[0],                node_mix2.inputs[1])
                group.links.new(node_mix1.outputs[0],                       node_mix2.inputs[2])
                group.links.new(node_light.outputs['Transparent Depth'],    node_less.inputs[0])
                group.links.new(node_less.outputs[0],                       node_mix2.inputs['Fac'])
                group.links.new(node_mix2.outputs[0],                       node_output.inputs['Shader'])
            else:
                if BlenderMaterials.usePrincipledShader:
                    node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.05, 0.0, 0.0, 1.585, 1.0, 45, 340)

                    # link nodes together
                    group.links.new(node_input.outputs['Color'],       node_principled.inputs['Base Color'])
                    group.links.new(node_input.outputs['Normal'],      node_principled.inputs['Normal'])
                    group.links.new(node_principled.outputs['BSDF'],   node_output.inputs['Shader'])
                else:
                    node_main = BlenderMaterials.__nodeDielectric(group.nodes, 0.15, 0.1, 0.97, 1.46, 0, 0)

                    # link nodes together
                    group.links.new(node_input.outputs['Color'],       node_main.inputs['Color'])
                    group.links.new(node_input.outputs['Normal'],      node_main.inputs['Normal'])
                    group.links.new(node_main.outputs['Shader'],       node_output.inputs['Shader'])


    # **********************************************************************************
    def __createBlenderLegoTransparentFluorescentNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Transparent Fluorescent')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoTransparentFluorescentNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -250, 0, 300, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if Options.instructionsLook:
                node_emission    = BlenderMaterials.__nodeEmission(group.nodes, 0, 0)
                node_transparent = BlenderMaterials.__nodeTransparent(group.nodes, 0, 100)
                node_mix1        = BlenderMaterials.__nodeMix(group.nodes, 0.5, 400, 100)
                node_light       = BlenderMaterials.__nodeLightPath(group.nodes, 200, 400)
                node_less        = BlenderMaterials.__nodeMath(group.nodes, 'LESS_THAN', 400, 400)
                node_mix2        = BlenderMaterials.__nodeMix(group.nodes, 0.5, 600, 300)

                node_output.location = (800,0)

                group.links.new(node_input.outputs['Color'],                node_emission.inputs['Color'])
                group.links.new(node_transparent.outputs[0],                node_mix1.inputs[1])
                group.links.new(node_emission.outputs['Emission'],          node_mix1.inputs[2])
                group.links.new(node_transparent.outputs[0],                node_mix2.inputs[1])
                group.links.new(node_mix1.outputs[0],                       node_mix2.inputs[2])
                group.links.new(node_light.outputs['Transparent Depth'],    node_less.inputs[0])
                group.links.new(node_less.outputs[0],                       node_mix2.inputs['Fac'])
                group.links.new(node_mix2.outputs[0],                       node_output.inputs['Shader'])
            else:
                if BlenderMaterials.usePrincipledShader:
                    node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.05, 0.0, 0.0, 1.585, 1.0, 45, 340)
                    node_emission    = BlenderMaterials.__nodeEmission(group.nodes, 45, -160)
                    node_mix         = BlenderMaterials.__nodeMix(group.nodes, 0.03, 300, 290)

                    node_output.location = 500, 290

                    # link nodes together
                    group.links.new(node_input.outputs['Color'],       node_principled.inputs['Base Color'])
                    group.links.new(node_input.outputs['Color'],       node_emission.inputs['Color'])
                    group.links.new(node_input.outputs['Normal'],      node_principled.inputs['Normal'])
                    group.links.new(node_principled.outputs['BSDF'],   node_mix.inputs[1])
                    group.links.new(node_emission.outputs['Emission'], node_mix.inputs[2])
                    group.links.new(node_mix.outputs[0],               node_output.inputs['Shader'])

                else:
                    node_main = BlenderMaterials.__nodeDielectric(group.nodes, 0.15, 0.1, 0.97, 1.46, 0, 0)

                    # link nodes together
                    group.links.new(node_input.outputs['Color'],       node_main.inputs['Color'])
                    group.links.new(node_input.outputs['Normal'],      node_main.inputs['Normal'])
                    group.links.new(node_main.outputs['Shader'],       node_output.inputs['Shader'])


    # **********************************************************************************
    def __createBlenderLegoRubberNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Rubber Solid')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoRubberNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, 45-950, 340-50, 45+200, 340-5, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_noise = BlenderMaterials.__nodeNoiseTexture(group.nodes, 250, 2, 0.0, 45-770, 340-200)
                node_bump1 = BlenderMaterials.__nodeBumpShader(group.nodes, 1.0, 0.3, 45-366, 340-200)
                node_bump2 = BlenderMaterials.__nodeBumpShader(group.nodes, 1.0, 0.1, 45-184, 340-115)
                node_subtract = BlenderMaterials.__nodeMath(group.nodes, 'SUBTRACT', 45-570, 340-216)
                node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.4, 0.03, 0.0, 1.45, 0.0, 45, 340)

                node_subtract.inputs[1].default_value = 0.4

                group.links.new(node_input.outputs['Color'],       node_principled.inputs['Base Color'])
                group.links.new(node_principled.outputs['BSDF'],   node_output.inputs[0])
                group.links.new(node_noise.outputs['Color'],       node_subtract.inputs[0])
                group.links.new(node_subtract.outputs[0],          node_bump1.inputs['Height'])
                group.links.new(node_bump1.outputs['Normal'],      node_bump2.inputs['Normal'])
                group.links.new(node_bump2.outputs['Normal'],      node_principled.inputs['Normal'])
            else:
                node_dielectric = BlenderMaterials.__nodeDielectric(group.nodes, 0.5, 0.07, 0.0, 1.52, 0, 0)

                # link nodes together
                group.links.new(node_input.outputs['Color'],       node_dielectric.inputs['Color'])
                group.links.new(node_input.outputs['Normal'],      node_dielectric.inputs['Normal'])
                group.links.new(node_dielectric.outputs['Shader'], node_output.inputs['Shader'])


    # **********************************************************************************
    def __createBlenderLegoRubberTranslucentNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Rubber Translucent')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoRubberTranslucentNodeGroup #create")
            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -250, 0, 250, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_noise = BlenderMaterials.__nodeNoiseTexture(group.nodes, 250, 2, 0.0, 45-770, 340-200)
                node_bump1 = BlenderMaterials.__nodeBumpShader(group.nodes, 1.0, 0.3, 45-366, 340-200)
                node_bump2 = BlenderMaterials.__nodeBumpShader(group.nodes, 1.0, 0.1, 45-184, 340-115)
                node_subtract = BlenderMaterials.__nodeMath(group.nodes, 'SUBTRACT', 45-570, 340-216)
                node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.4, 0.03, 0.0, 1.45, 0.0, 45, 340)
                node_mix = BlenderMaterials.__nodeMix(group.nodes, 0.8, 300, 290)
                node_refraction = BlenderMaterials.__nodeRefraction(group.nodes, 0.0, 1.45, 290-242, 154-330)
                node_input.location = -320, 290
                node_output.location = 530, 285

                node_subtract.inputs[1].default_value = 0.4

                group.links.new(node_input.outputs['Normal'],      node_refraction.inputs['Normal'])
                group.links.new(node_refraction.outputs[0],        node_mix.inputs[2])
                group.links.new(node_principled.outputs[0],        node_mix.inputs[1])
                group.links.new(node_mix.outputs[0],               node_output.inputs[0])
                group.links.new(node_input.outputs['Color'],       node_principled.inputs['Base Color'])
                group.links.new(node_noise.outputs['Color'],       node_subtract.inputs[0])
                group.links.new(node_subtract.outputs[0],          node_bump1.inputs['Height'])
                group.links.new(node_bump1.outputs['Normal'],      node_bump2.inputs['Normal'])
                group.links.new(node_bump2.outputs['Normal'],      node_principled.inputs['Normal'])
                group.links.new(node_mix.outputs[0],               node_output.inputs[0])
            else:
                node_dielectric = BlenderMaterials.__nodeDielectric(group.nodes, 0.15, 0.1, 0.97, 1.46, 0, 0)

                # link nodes together
                group.links.new(node_input.outputs['Color'],       node_dielectric.inputs['Color'])
                group.links.new(node_input.outputs['Normal'],      node_dielectric.inputs['Normal'])
                group.links.new(node_dielectric.outputs['Shader'], node_output.inputs['Shader'])

    # **************************************************************************************
    def __createBlenderLegoEmissionNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Emission')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoEmissionNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 90, 250, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketFloatFactor','Luminance')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            node_emit  = BlenderMaterials.__nodeEmission(group.nodes, -242, -123)
            node_mix   = BlenderMaterials.__nodeMix(group.nodes, 0.5, 0, 90)

            if BlenderMaterials.usePrincipledShader:
                node_main = BlenderMaterials.__nodePrincipled(group.nodes, 1.0, 0.05, 0.0, 0.5, 0.0, 0.03, 1.45, 0.0, -242, 154+240)
                group.links.new(node_input.outputs['Color'],     BlenderMaterials.__getSubsurfaceColor(node_main))
                group.links.new(node_input.outputs['Color'],     node_emit.inputs['Color'])
                main_colour = 'Base Color'
            else:
                node_main = BlenderMaterials.__nodeTranslucent(group.nodes, -242, 154)
                main_colour = 'Color'

            # link nodes together
            group.links.new(node_input.outputs['Color'],     node_main.inputs[main_colour])
            group.links.new(node_input.outputs['Normal'],    node_main.inputs['Normal'])
            group.links.new(node_input.outputs['Luminance'], node_mix.inputs[0])
            group.links.new(node_main.outputs[0],            node_mix.inputs[1])
            group.links.new(node_emit.outputs[0],            node_mix.inputs[2])
            group.links.new(node_mix.outputs[0],             node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoChromeNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Chrome')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoChromeNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 90, 250, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_hsv         = BlenderMaterials.__nodeHSV(group.nodes, 0.5, 0.9, 2.0, -90, 0)
                node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 2.4, 0.0, 100, 0)

                node_output.location = (575, -140)

                # link nodes together
                group.links.new(node_input.outputs['Color'],       node_hsv.inputs['Color'])
                group.links.new(node_input.outputs['Normal'],      node_principled.inputs['Normal'])
                group.links.new(node_hsv.outputs['Color'],         node_principled.inputs['Base Color'])
                group.links.new(node_principled.outputs['BSDF'],   node_output.inputs[0])
            else:
                node_glossyOne = BlenderMaterials.__nodeGlossy(group.nodes, (1,1,1,1), 0.03, 'GGX', -242, 154)
                node_glossyTwo = BlenderMaterials.__nodeGlossy(group.nodes, (1.0, 1.0, 1.0, 1.0), 0.03, 'BECKMANN', -242, -23)
                node_mix       = BlenderMaterials.__nodeMix(group.nodes, 0.01, 0, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'],  node_glossyOne.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_glossyOne.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_glossyTwo.inputs['Normal'])
                group.links.new(node_glossyOne.outputs[0],    node_mix.inputs[1])
                group.links.new(node_glossyTwo.outputs[0],    node_mix.inputs[2])
                group.links.new(node_mix.outputs[0],          node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoPearlescentNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Pearlescent')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoPearlescentNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 90, 630, 95, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 1.0, 0.25, 0.5, 0.2, 1.0, 0.2, 1.6, 0.0, 310, 95)
                node_sep_hsv     = BlenderMaterials.__nodeSeparateHSV(group.nodes, -240, 75)
                node_multiply    = BlenderMaterials.__nodeMath(group.nodes, 'MULTIPLY', -60, 0)
                node_com_hsv     = BlenderMaterials.__nodeCombineHSV(group.nodes, 110, 95)
                node_tex_coord   = BlenderMaterials.__nodeTexCoord(group.nodes, -730, -223)
                node_tex_wave    = BlenderMaterials.__nodeTexWave(group.nodes, 'BANDS', 'SIN', 0.5, 40, 1, 1.5, -520, -190)
                node_color_ramp  = BlenderMaterials.__nodeColorRamp(group.nodes, 0.329, (0.89, 0.89, 0.89, 1), 0.820, (1, 1, 1, 1), -340, -70)
                element = node_color_ramp.color_ramp.elements.new(1.0)
                element.color = (1.118, 1.118, 1.118, 1)

                # link nodes together
                group.links.new(node_input.outputs['Color'], node_sep_hsv.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_principled.inputs['Normal'])
                group.links.new(node_sep_hsv.outputs['H'], node_com_hsv.inputs['H'])
                group.links.new(node_sep_hsv.outputs['S'], node_com_hsv.inputs['S'])
                group.links.new(node_sep_hsv.outputs['V'], node_multiply.inputs[0])
                group.links.new(node_com_hsv.outputs['Color'], node_principled.inputs['Base Color'])
                group.links.new(node_com_hsv.outputs['Color'], BlenderMaterials.__getSubsurfaceColor(node_principled))
                group.links.new(node_tex_coord.outputs['Object'], node_tex_wave.inputs['Vector'])
                group.links.new(node_tex_wave.outputs['Fac'], node_color_ramp.inputs['Fac'])
                group.links.new(node_color_ramp.outputs['Color'], node_multiply.inputs[1])
                group.links.new(node_multiply.outputs[0], node_com_hsv.inputs['V'])
                group.links.new(node_principled.outputs['BSDF'], node_output.inputs[0])
            else:
                node_diffuse = BlenderMaterials.__nodeDiffuse(group.nodes, 0.0, -242, -23)
                node_glossy  = BlenderMaterials.__nodeGlossy(group.nodes, (1,1,1,1), 0.05, 'BECKMANN', -242, 154)
                node_mix     = BlenderMaterials.__nodeMix(group.nodes, 0.4, 0, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'],  node_diffuse.inputs['Color'])
                group.links.new(node_input.outputs['Color'],  node_glossy.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_diffuse.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_glossy.inputs['Normal'])
                group.links.new(node_glossy.outputs[0],   node_mix.inputs[1])
                group.links.new(node_diffuse.outputs[0],  node_mix.inputs[2])
                group.links.new(node_mix.outputs[0],      node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoMetalNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Metal')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoMetalNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 90, 250, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_principled  = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.8, 0.2, 0.0, 0.03, 1.45, 0.0, 310, 95)

                group.links.new(node_input.outputs['Color'], node_principled.inputs['Base Color'])
                group.links.new(node_input.outputs['Normal'], node_principled.inputs['Normal'])
                group.links.new(node_principled.outputs[0], node_output.inputs['Shader'])
            else:
                node_dielectric = BlenderMaterials.__nodeDielectric(group.nodes, 0.05, 0.2, 0.0, 1.46, -242, 0)
                node_glossy = BlenderMaterials.__nodeGlossy(group.nodes, (1,1,1,1), 0.2, 'BECKMANN', -242, 154)
                node_mix = BlenderMaterials.__nodeMix(group.nodes, 0.4, 0, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'], node_glossy.inputs['Color'])
                group.links.new(node_input.outputs['Color'], node_dielectric.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_glossy.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_dielectric.inputs['Normal'])
                group.links.new(node_glossy.outputs[0],     node_mix.inputs[1])
                group.links.new(node_dielectric.outputs[0], node_mix.inputs[2])
                group.links.new(node_mix.outputs[0],        node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoGlitterNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Glitter')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoGlitterNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 0, 410, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Glitter Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_voronoi     = BlenderMaterials.__nodeVoronoi(group.nodes, 100, -222, 310)
                node_gamma       = BlenderMaterials.__nodeGamma(group.nodes, 50, 0, 200)
                node_mix         = BlenderMaterials.__nodeMix(group.nodes, 0.05, 210, 90+25)
                node_principled1 = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.2, 0.0, 0.03, 1.585, 1.0, 45-270, 340-210)
                node_principled2 = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.5, 0.0, 0.03, 1.45, 0.0, 45-270, 340-750)

                group.links.new(node_input.outputs['Color'], node_principled1.inputs['Base Color'])
                group.links.new(node_input.outputs['Glitter Color'], node_principled2.inputs['Base Color'])
                group.links.new(node_input.outputs['Normal'], node_principled1.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_principled2.inputs['Normal'])
                group.links.new(node_voronoi.outputs['Color'], node_gamma.inputs['Color'])
                group.links.new(node_gamma.outputs[0], node_mix.inputs[0])
                group.links.new(node_principled1.outputs['BSDF'], node_mix.inputs[1])
                group.links.new(node_principled2.outputs['BSDF'], node_mix.inputs[2])
                group.links.new(node_mix.outputs[0], node_output.inputs[0])
            else:
                node_glass   = BlenderMaterials.__nodeGlass(group.nodes, 0.05, 1.46, 'BECKMANN', -242, 154)
                node_glossy  = BlenderMaterials.__nodeGlossy(group.nodes, (1,1,1,1), 0.05, 'BECKMANN', -242, -23)
                node_diffuse = BlenderMaterials.__nodeDiffuse(group.nodes, 0.0, -12, -49)
                node_voronoi = BlenderMaterials.__nodeVoronoi(group.nodes, 100, -232, 310)
                node_gamma   = BlenderMaterials.__nodeGamma(group.nodes, 50, 0, 200)
                node_mixOne  = BlenderMaterials.__nodeMix(group.nodes, 0.05, 0, 90)
                node_mixTwo  = BlenderMaterials.__nodeMix(group.nodes, 0.5, 200, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'], node_glass.inputs['Color'])
                group.links.new(node_input.outputs['Glitter Color'], node_diffuse.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_glass.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_glossy.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_diffuse.inputs['Normal'])
                group.links.new(node_glass.outputs[0],     node_mixOne.inputs[1])
                group.links.new(node_glossy.outputs[0],    node_mixOne.inputs[2])
                group.links.new(node_voronoi.outputs[0],   node_gamma.inputs[0])
                group.links.new(node_gamma.outputs[0],     node_mixTwo.inputs[0])
                group.links.new(node_mixOne.outputs[0],    node_mixTwo.inputs[1])
                group.links.new(node_diffuse.outputs[0],   node_mixTwo.inputs[2])
                group.links.new(node_mixTwo.outputs[0],    node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoSpeckleNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Speckle')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoSpeckleNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 0, 410, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Speckle Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_voronoi     = BlenderMaterials.__nodeVoronoi(group.nodes, 50, -222, 310)
                node_gamma       = BlenderMaterials.__nodeGamma(group.nodes, 3.5, 0, 200)
                node_mix         = BlenderMaterials.__nodeMix(group.nodes, 0.05, 210, 90+25)
                node_principled1 = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 0.0, 0.1, 0.0, 0.03, 1.45, 0.0, 45-270, 340-210)
                node_principled2 = BlenderMaterials.__nodePrincipled(group.nodes, 0.0, 0.0, 1.0, 0.5, 0.0, 0.03, 1.45, 0.0, 45-270, 340-750)

                group.links.new(node_input.outputs['Color'], node_principled1.inputs['Base Color'])
                group.links.new(node_input.outputs['Speckle Color'], node_principled2.inputs['Base Color'])
                group.links.new(node_input.outputs['Normal'], node_principled1.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_principled2.inputs['Normal'])
                group.links.new(node_voronoi.outputs['Color'], node_gamma.inputs['Color'])
                group.links.new(node_gamma.outputs[0], node_mix.inputs[0])
                group.links.new(node_principled1.outputs['BSDF'], node_mix.inputs[1])
                group.links.new(node_principled2.outputs['BSDF'], node_mix.inputs[2])
                group.links.new(node_mix.outputs[0], node_output.inputs[0])
            else:
                node_diffuseOne = BlenderMaterials.__nodeDiffuse(group.nodes, 0.0, -242, 131)
                node_glossy     = BlenderMaterials.__nodeGlossy(group.nodes, (0.333, 0.333, 0.333, 1.0), 0.2, 'BECKMANN', -242, -23)
                node_diffuseTwo = BlenderMaterials.__nodeDiffuse(group.nodes, 0.0, -12, -49)
                node_voronoi    = BlenderMaterials.__nodeVoronoi(group.nodes, 100, -232, 310)
                node_gamma      = BlenderMaterials.__nodeGamma(group.nodes, 20, 0, 200)
                node_mixOne     = BlenderMaterials.__nodeMix(group.nodes, 0.2, 0, 90)
                node_mixTwo     = BlenderMaterials.__nodeMix(group.nodes, 0.5, 200, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'], node_diffuseOne.inputs['Color'])
                group.links.new(node_input.outputs['Speckle Color'], node_diffuseTwo.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_diffuseOne.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_glossy.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_diffuseTwo.inputs['Normal'])
                group.links.new(node_voronoi.outputs[0],       node_gamma.inputs[0])
                group.links.new(node_diffuseOne.outputs[0],    node_mixOne.inputs[1])
                group.links.new(node_glossy.outputs[0],        node_mixOne.inputs[2])
                group.links.new(node_gamma.outputs[0],         node_mixTwo.inputs[0])
                group.links.new(node_mixOne.outputs[0],        node_mixTwo.inputs[1])
                group.links.new(node_diffuseTwo.outputs[0],    node_mixTwo.inputs[2])
                group.links.new(node_mixTwo.outputs[0],        node_output.inputs[0])

    # **********************************************************************************
    def __createBlenderLegoMilkyWhiteNodeGroup():
        groupName = BlenderMaterials.__getGroupName('Lego Milky White')
        if bpy.data.node_groups.get(groupName) is None:
            debugPrint("createBlenderLegoMilkyWhiteNodeGroup #create")

            # create a group
            group, node_input, node_output = BlenderMaterials.__createGroup(groupName, -450, 0, 350, 0, True)
            BlenderMaterials.addInputSocket(group,'NodeSocketColor','Color')
            BlenderMaterials.addInputSocket(group,'NodeSocketVectorDirection','Normal')

            if BlenderMaterials.usePrincipledShader:
                node_principled = BlenderMaterials.__nodePrincipled(group.nodes, 1.0, 0.05, 0.0, 0.5, 0.0, 0.03, 1.45, 0.0, 45-270, 340-210)
                node_translucent = BlenderMaterials.__nodeTranslucent(group.nodes, -225, -382)
                node_mix = BlenderMaterials.__nodeMix(group.nodes, 0.5, 65, -40)

                group.links.new(node_input.outputs['Color'], node_principled.inputs['Base Color'])
                group.links.new(node_input.outputs['Color'], BlenderMaterials.__getSubsurfaceColor(node_principled))
                group.links.new(node_input.outputs['Normal'], node_principled.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_translucent.inputs['Normal'])
                group.links.new(node_principled.outputs[0], node_mix.inputs[1])
                group.links.new(node_translucent.outputs[0], node_mix.inputs[2])
                group.links.new(node_mix.outputs[0], node_output.inputs[0])
            else:
                node_diffuse = BlenderMaterials.__nodeDiffuse(group.nodes, 0.0, -242, 90)
                node_trans   = BlenderMaterials.__nodeTranslucent(group.nodes, -242, -46)
                node_glossy  = BlenderMaterials.__nodeGlossy(group.nodes, (1,1,1,1), 0.5, 'BECKMANN', -42, -54)
                node_mixOne  = BlenderMaterials.__nodeMix(group.nodes, 0.4, -35, 90)
                node_mixTwo  = BlenderMaterials.__nodeMix(group.nodes, 0.2, 175, 90)

                # link nodes together
                group.links.new(node_input.outputs['Color'],  node_diffuse.inputs['Color'])
                group.links.new(node_input.outputs['Color'],  node_trans.inputs['Color'])
                group.links.new(node_input.outputs['Color'],  node_glossy.inputs['Color'])
                group.links.new(node_input.outputs['Normal'], node_diffuse.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_trans.inputs['Normal'])
                group.links.new(node_input.outputs['Normal'], node_glossy.inputs['Normal'])
                group.links.new(node_diffuse.outputs[0],  node_mixOne.inputs[1])
                group.links.new(node_trans.outputs[0],    node_mixOne.inputs[2])
                group.links.new(node_mixOne.outputs[0],   node_mixTwo.inputs[1])
                group.links.new(node_glossy.outputs[0],   node_mixTwo.inputs[2])
                group.links.new(node_mixTwo.outputs[0],   node_output.inputs[0])

    # **********************************************************************************
    def createBlenderNodeGroups():
        BlenderMaterials.usePrincipledShader = BlenderMaterials.__hasPrincipledShader and Options.usePrincipledShaderWhenAvailable

        BlenderMaterials.__createBlenderDistanceToCenterNodeGroup()
        BlenderMaterials.__createBlenderVectorElementPowerNodeGroup()
        BlenderMaterials.__createBlenderConvertToNormalsNodeGroup()
        BlenderMaterials.__createBlenderConcaveWallsNodeGroup()
        BlenderMaterials.__createBlenderSlopeTextureNodeGroup()

        # Originally based on ideas from https://www.youtube.com/watch?v=V3wghbZ-Vh4
        # "Create your own PBR Material [Fixed!]" by BlenderGuru
        # Updated with Principled Shader, if available
        BlenderMaterials.__createBlenderFresnelNodeGroup()
        BlenderMaterials.__createBlenderReflectionNodeGroup()
        BlenderMaterials.__createBlenderDielectricNodeGroup()

        BlenderMaterials.__createBlenderLegoStandardNodeGroup()
        BlenderMaterials.__createBlenderLegoTransparentNodeGroup()
        BlenderMaterials.__createBlenderLegoTransparentFluorescentNodeGroup()
        BlenderMaterials.__createBlenderLegoRubberNodeGroup()
        BlenderMaterials.__createBlenderLegoRubberTranslucentNodeGroup()
        BlenderMaterials.__createBlenderLegoEmissionNodeGroup()
        BlenderMaterials.__createBlenderLegoChromeNodeGroup()
        BlenderMaterials.__createBlenderLegoPearlescentNodeGroup()
        BlenderMaterials.__createBlenderLegoMetalNodeGroup()
        BlenderMaterials.__createBlenderLegoGlitterNodeGroup()
        BlenderMaterials.__createBlenderLegoSpeckleNodeGroup()
        BlenderMaterials.__createBlenderLegoMilkyWhiteNodeGroup()


# **************************************************************************************
def addSharpEdges(bm, geometry, filename):
    if geometry.edges:
        global globalWeldDistance
        epsilon = globalWeldDistance

        bm.faces.ensure_lookup_table()
        bm.verts.ensure_lookup_table()
        bm.edges.ensure_lookup_table()

        # Create kd tree for fast "find nearest points" calculation
        kd = mathutils.kdtree.KDTree(len(bm.verts))
        for i, v in enumerate(bm.verts):
            kd.insert(v.co, i)
        kd.balance()

        # Create edgeIndices dictionary, which is the list of edges as pairs of indicies into our bm.verts array
        edgeIndices = {}
        for ind, geomEdge in enumerate(geometry.edges):
            # Find index of nearest points in bm.verts to geomEdge[0] and geomEdge[1]
            edges0 = [index for (co, index, dist) in kd.find_range(geomEdge[0], epsilon)]
            edges1 = [index for (co, index, dist) in kd.find_range(geomEdge[1], epsilon)]

            #if (len(edges0) > 2):
            #    printWarningOnce("Found {1} vertices near {0} in file {2}".format(geomEdge[0], len(edges0), filename))
            #if (len(edges1) > 2):
            #    printWarningOnce("Found {1} vertices near {0} in file {2}".format(geomEdge[1], len(edges1), filename))

            for e0 in edges0:
                for e1 in edges1:
                    edgeIndices[(e0, e1)] = True
                    edgeIndices[(e1, e0)] = True

        # Find the appropriate mesh edges and make them sharp (i.e. not smooth)
        for meshEdge in bm.edges:
            v0 = meshEdge.verts[0].index
            v1 = meshEdge.verts[1].index
            if (v0, v1) in edgeIndices:
                # Make edge sharp
                meshEdge.smooth = False

        # Set bevel weights
        if bpy.app.version < (4, 0, 0):
            # Blender 3
            # Find layer for bevel weights
            if 'BevelWeight' in bm.edges.layers.bevel_weight:
                bwLayer = bm.edges.layers.bevel_weight['BevelWeight']
            elif '' in bm.edges.layers.bevel_weight:
                bwLayer = bm.edges.layers.bevel_weight['']
            else:
                bwLayer = None

            for meshEdge in bm.edges:
                v0 = meshEdge.verts[0].index
                v1 = meshEdge.verts[1].index
                if (v0, v1) in edgeIndices:
                    # Add bevel weight
                    if bwLayer is not None:
                        meshEdge[bwLayer] = 1.0

        return edgeIndices

# Commented this next section out as it fails for certain pieces.

        # Look for any pair of colinear edges emanating from a single vertex, where each edge is connected to exactly one face.
        # Subdivide the longer edge to include the shorter edge's vertex.
        # Repeat until there's nothing left to subdivide.
        # This helps create better (more manifold) geometry in general, and in particular solves issues with technic pieces with holes.
#        verts = set(bm.verts)
#
#        while(verts):
#            v = verts.pop()
#            edges = [e for e in v.link_edges if len(e.link_faces) == 1]
#            for e1, e2 in itertools.combinations(edges, 2):
#
#                # ensure e1 is always the longer edge
#                if e1.calc_length() < e2.calc_length():
#                    e1, e2 = e2, e1
#
#                v1 = e1.other_vert(v)
#                v2 = e2.other_vert(v)
#                vec1 = v1.co - v.co
#                vec2 = v2.co - v.co
#
#                # test for colinear
#                if vec1.angle(vec2) < 0.02:
#                    old_face = e1.link_faces[0]
#                    new_verts = old_face.verts[:]
#
#                    e2.smooth &= e1.smooth
#                    if bwLayer is not None:
#                        e2[bwLayer] = max(e1[bwLayer], e2[bwLayer])
#
#                    # insert the shorter edge's vertex
#                    i = new_verts.index(v)
#                    i1 = new_verts.index(v1)
#                    if i1 - i in [1, -1]:
#                        new_verts.insert(max(i,i1), v2)
#                    else:
#                        new_verts.insert(0, v2)
#
#                    # create a new face that includes the newly inserted vertex
#                    new_face = bm.faces.new(new_verts)
#
#                    # copy material to new face
#                    new_face.material_index = old_face.material_index
#
#                    # copy metadata to the new edge
#                    for e in v2.link_edges:
#                        if e.other_vert(v2) is v1:
#                            e.smooth &= e1.smooth
#                            if bwLayer is not None:
#                                e[bwLayer] = max(e1[bwLayer], e[bwLayer])
#
#                    # delete the old edge
#                    deleteEdge(bm, [e1])
#
#                    # re-check the vertices we modified
#                    verts.add(v)
#                    verts.add(v2)
#                    break

        bm.faces.ensure_lookup_table()
        bm.verts.ensure_lookup_table()
        bm.edges.ensure_lookup_table()

# **************************************************************************************
def meshIsReusable(meshName, geometry):
    meshExists = meshName in bpy.data.meshes
    #debugPrint("meshIsReusable says {0} exists = {1}.".format(meshName, meshExists))
    if meshExists and not Options.overwriteExistingMeshes:
        mesh = bpy.data.meshes[meshName]

        #debugPrint("meshIsReusable testing")
        # A mesh loses it's materials information when it is no longer in use.
        # We must check the number of faces matches, otherwise we can't re-set the
        # materials.
        if mesh.users == 0 and (len(mesh.polygons) != len(geometry.faces)):
            #debugPrint("meshIsReusable says no users and num faces changed.")
            return False

        # If options have changed (e.g. scale) we should not reuse the same mesh.
        if 'customMeshOptions' in mesh.keys():
            #debugPrint("meshIsReusable found custom options.")
            #debugPrint("mesh['customMeshOptions'] = {0}".format(mesh['customMeshOptions']))
            #debugPrint("Options.meshOptionsString() = {0}".format(Options.meshOptionsString()))
            if mesh['customMeshOptions'] == Options.meshOptionsString():
                #debugPrint("meshIsReusable found custom options - match OK.")
                return True
            #debugPrint("meshIsReusable found custom options - DON'T match.")
    return False

# **************************************************************************************
def addNodeToParentWithGroups(parentObject, groupNames, newObject):

    if not Options.flattenGroups:
        # Create groups as needed
        for groupName in groupNames:
            # The max length of a Blender node name appears to be 63 bytes when encoded as UTF-8. We make sure it fits.
            while len(groupName.encode("utf8")) > 63:
                groupName = groupName[:-1]

            # Check if we already have this node name, or if we need to create a new node
            groupObj = None
            for obj in bpy.data.objects:
                if (obj.name == groupName):
                    groupObj = obj
            if (groupObj is None):
                groupObj = bpy.data.objects.new(groupName, None)
                groupObj.parent = parentObject
                globalObjectsToAdd.append(groupObj)
            parentObject = groupObj

    newObject.parent = parentObject
    globalObjectsToAdd.append(newObject)


# **************************************************************************************
parent = None
attach_points = []
children = []
partsHierarchy = {}
macro_name = None
macros = {}

# **************************************************************************************
def parseParentsFile(file):
    global parent
    global attach_points
    global children
    global partsHierarchy
    global macro_name
    global macros

    # See https://stackoverflow.com/a/53870514
    number_pattern = "[+-]?((\d+(\.\d*)?)|(\.\d+))"
    pattern = "(" + number_pattern + ")(.*)"
    compiled = re.compile(pattern)

    def number_split(s):
        match = compiled.match(s)
        if match is None:
            return None, s
        groups = match.groups()
        return groups[0], groups[-1].strip()

    parent = None
    attach_points = []
    children = []
    partsHierarchy = {}
    macro_name = None
    macros = {}

    def finishParent():
        global parent
        global attach_points
        global children
        global partsHierarchy
        global macro_name

        if macro_name:
            macros[macro_name] = children
            # print("Adding macro ", macro_name)
            parent = None
            attach_points = []
            children = []
            macro_name = None

        if parent:
            partsHierarchy[parent] = (attach_points, children)
            parent = None
            attach_points = []
            children = []
            macro_name = None

    with open(file) as f:
        lines = f.readlines() # list containing lines of file

        line_number = 0
        for line in lines:
            line_number += 1
            line = line.strip() # remove leading/trailing white spaces
            line = line.split("#")[0]
            if line:
                line = line.strip()
                original_line = line
                if line.startswith("Group "):
                    # Found group definition
                    finishParent()
                    macro_name = line[6:].strip().strip(":")
                    # print("Found group definition ", macro_name)
                    continue
                if line.startswith("Parent "):
                    # Found parent definition
                    finishParent()
                    parent = line[7:].strip().strip(":")
                    # print("Found parent definition ", parent)
                    continue
                if line in macros:
                    # found instance of a macro
                    # add children to definition
                    children += macros[line]
                    continue

                # check for three floating point numbers of an attach point
                number1, line = number_split(line)
                if number1:
                    number3 = None
                    number2, line = number_split(line)
                    if number2:
                        number3, line = number_split(line)
                    if number3:
                        # Got three numbers for an attach point
                        try:
                            attachPoint = (float(number1), float(number2), float(number3))
                        except:
                            attachPoint = None
                        if attachPoint:
                            # Attach point
                            attach_points.append(attachPoint)
                            continue
                        else:
                            debugPrint("ERROR: Bad attach point found on line %d" % (line_number,))
                            partsHierarchy = None
                            return

                # child part number?
                children.append(original_line)

    finishParent()
    # print("Macros:")
    # pprint(macros)
    # print("End of Macros")
    return


# **************************************************************************************
def setupImplicitParents():
    global globalScaleFactor

    if not Options.minifigHierarchy:
        return

    parseParentsFile(Options.scriptDirectory + '/parents.txt')
    # print(partsHierarchy)
    if not partsHierarchy:
        return

    bpy.context.view_layer.update()

    # create a set of the parent parts and a set of child parts from the partsHierarchy
    parentParts = set()
    childParts = set()
    for parent, childrenData in partsHierarchy.items():
        parentParts.add(parent)
        childParts.update(childrenData[1])

    # create a flat set of all interesting parts (parents and children together)
    interestingParts = set()
    interestingParts.update(parentParts)
    interestingParts.update(childParts)

    # print('Parent parts: %s' % (parentParts,))
    # print('Child parts: %s' % (childParts,))
    # print('Interesting parts: %s' % (interestingParts,))

    tolerance = globalScaleFactor * 5 # in LDraw units
    squaredTolerance = tolerance * tolerance
    # print(" Squared tolerance: %s" % (squaredTolerance,))

    # For each interesting mesh in the scene, remember the bare part number and the children
    parentMeshParts = {}        # bare part numbers of the parents
    childMeshParts = {}         # bare part numbers of the children
    parentableMeshes = {}       # interesting children
    lego_part_pattern = "([A-Za-z]?\d+)($|\D)"

    # for each object in the scene
    for obj in bpy.data.objects:
        if obj.type != 'MESH':
            continue

        name = obj.data.name
        if not name.startswith('Mesh_'):
            continue

        # skip 'Mesh_' and get part of name that is just digits (possibly with a letter in front)
        test_name = name[5:]
        if " - " in test_name:
            test_name = test_name.split(" - ",1)[1]

        partName = ''
        m = re.match(lego_part_pattern, test_name)
        if m:
            partName = m.group(1)

        # For each interesting parent mesh in the scene, remember the bare part number and the children
        if partName in parentParts:
            # remember the bare part number for each interesting mesh in the scene
            parentMeshParts[name] = partName

            # remember possible children of the mesh in the scene
            children = partsHierarchy.get(partName)
            if children:
                parentableMeshes[name] = children

        # For each interesting child mesh in the scene, remember the bare part number
        if partName in childParts:
            # remember the bare part number for each interesting mesh in the scene
            childMeshParts[name] = partName

    # Now, iterate through the objects in the scene and gather the interesting ones
    parentObjects = []
    childObjects = []
    for obj in bpy.data.objects:
        if obj.type != 'MESH':
            continue
        meshName = obj.data.name
        if meshName in parentMeshParts:
            parentObjects.append(obj)
            # print("Possible parent object %s has matrix %s" % (obj.name, obj.matrix_world))
        if meshName in childMeshParts:
            childObjects.append(obj)

    # for each interesting parent object
    for obj in parentObjects:
        meshName = obj.data.name
        childrenData = parentableMeshes.get(meshName)
        if not childrenData:
            continue
        # parentLocation = obj.matrix_world @ mathutils.Vector((0, 0, 0))
        # parentMatrixInverted = obj.matrix_world.inverted()
        # print("Looking for children of %s (at %s)" % (obj.name, parentLocation))

        slotLocations = []
        for slot in childrenData[0]:
            loc = obj.matrix_world @ (mathutils.Vector(slot) * globalScaleFactor)
            slotLocations.append(loc)
        # print(" Slot locations: %s" % (slotLocations,))

        # for each interesting child object
        for childObj in childObjects:
            childMeshName = childObj.data.name
            childPartName = childMeshParts[childMeshName]
            if childPartName not in childrenData[1]:
                continue
            childLocation = childObj.matrix_world.to_translation()
            # print("  Found possible child %s" % (childObj.name,))
            for slotLocation in slotLocations:
                # print("  Slot location:%s   Child Location:%s" % (slotLocation, childLocation))
                diff = slotLocation - childLocation
                squaredDistance = diff.length_squared
                # print("  location: %s (squared distance: %s)" % (childLocation, squaredDistance))
                if squaredDistance <= squaredTolerance:
                    temp = childObj.matrix_world
                    childObj.parent = obj
                    # childObj.matrix_parent_inverse = parentMatrixInverted
                    childObj.matrix_world = temp
                    # print("    Got it! Parent '%s' now has child '%s'" % (obj.name, childObj.name))

# **************************************************************************************
def slopeAnglesForPart(partName):
    """
    Gets the allowable slope angles for a given part.
    """
    global globalSlopeAngles

    # Check for a part number with or without a subsequent letter
    match = re.match(r'\D*(\d+)([A-Za-z]?)', partName)
    if match:
        partNumberWithoutLetter = match.group(1)
        partNumberWithLetter = partNumberWithoutLetter + match.group(2)

        if partNumberWithLetter in globalSlopeAngles:
            return globalSlopeAngles[partNumberWithLetter]

        if partNumberWithoutLetter in globalSlopeAngles:
            return globalSlopeAngles[partNumberWithoutLetter]

    return None

# **************************************************************************************
def isSlopeFace(slopeAngles, isGrainySlopeAllowed, faceVertices):
    """
    Checks whether a given face should receive a grainy slope material.
    """

    # Step 1: Ignore some faces (studs) when checking for a grainy face
    if not isGrainySlopeAllowed:
        return False

    # Step 2: Calculate angle of face normal to the ground
    faceNormal = (faceVertices[1] - faceVertices[0]).cross(faceVertices[2]-faceVertices[0])
    faceNormal.normalize()

    # Clamp value to range -1 to 1 (ensure we are in the strict range of the acos function, taking account of rounding errors)
    cosine = min(max(faceNormal.y, -1.0), 1.0)

    # Calculate angle of face normal to the ground (-90 to 90 degrees)
    angleToGroundDegrees = math.degrees(math.acos(cosine)) - 90

    # debugPrint("Angle to ground {0}".format(angleToGroundDegrees))

    # Step 3: Check angle of normal to ground is within one of the acceptable ranges for this part
    return any(c[0] <= angleToGroundDegrees <= c[1] for c in slopeAngles)

# **************************************************************************************
def createMesh(name, meshName, geometry):
    # Are there any points?
    if not geometry.points:
        return (None, False)

    newMeshCreated = False

    # Have we already cached this mesh?
    if Options.createInstances and hasattr(geometry, 'mesh'):
        mesh = geometry.mesh
    else:
        # Does this mesh already exist in Blender?
        if meshIsReusable(meshName, geometry):
            mesh = bpy.data.meshes[meshName]
        else:
            # Create new mesh
            # debugPrint("Creating Mesh for node {0}".format(node.filename))
            mesh = bpy.data.meshes.new(meshName)

            points = [p.to_tuple() for p in geometry.points]

            mesh.from_pydata(points, [], geometry.faces)

            mesh.validate()
            mesh.update()

            # Set a custom parameter to record the options used to create this mesh
            # Used for caching.
            mesh['customMeshOptions'] = Options.meshOptionsString()

            newMeshCreated = True

        # Create materials and assign material to each polygon
        if mesh.users == 0:
            assert len(mesh.polygons) == len(geometry.faces)
            assert len(geometry.faces) == len(geometry.faceInfo)

            slopeAngles = slopeAnglesForPart(name)
            isSloped = slopeAngles is not None
            for i, f in enumerate(mesh.polygons):
                faceInfo = geometry.faceInfo[i]
                isSlopeMaterial = isSloped and isSlopeFace(slopeAngles, faceInfo.isGrainySlopeAllowed, [geometry.points[j] for j in geometry.faces[i]])
                faceColour = faceInfo.faceColour
                # For debugging purposes, we can make sloped faces blue:
                # if isSlopeMaterial:
                #     faceColour = "1"
                material = BlenderMaterials.getMaterial(faceColour, isSlopeMaterial)

                if material is not None:
                    if mesh.materials.get(material.name) is None:
                        mesh.materials.append(material)
                    f.material_index = mesh.materials.find(material.name)
                else:
                    printWarningOnce("Could not find material '{0}' in mesh '{1}'.".format(faceColour, name))

    # Cache mesh
    if newMeshCreated:
        geometry.mesh = mesh

    return (mesh, newMeshCreated)

# **************************************************************************************
def addModifiers(ob):
    global globalScaleFactor

    # Add Bevel modifier to each instance
    if Options.addBevelModifier:
        bevelModifier = ob.modifiers.new("Bevel", type='BEVEL')
        bevelModifier.width = Options.bevelWidth * globalScaleFactor
        bevelModifier.segments = 4
        bevelModifier.profile = 0.5
        bevelModifier.limit_method = 'WEIGHT'
        bevelModifier.use_clamp_overlap = True

    # Add edge split modifier to each instance
    if Options.edgeSplit:
        edgeModifier = ob.modifiers.new("Edge Split", type='EDGE_SPLIT')
        edgeModifier.use_edge_sharp = True
        edgeModifier.split_angle = math.radians(30.0)

# **************************************************************************************
def smoothShadingAndFreestyleEdges(ob):
    # We would like to avoid using bpy.ops functions altogether since it
    # slows down progressively as more objects are added to the scene, but
    # we have no choice but to use it here (a) for smoothing and (b) for
    # marking freestyle edges (no bmesh options exist currently). To minimise
    # the performance drop, we add one object only to the scene, smooth it,
    # then remove it again. Only at the end of the import process are all the
    # objects properly added to the scene.

    # Temporarily add object to scene
    linkToScene(ob)

    # Select object
    selectObject(ob)

    # Smooth shading
    if Options.smoothShading:
        # Smooth the mesh
        bpy.ops.object.shade_smooth()

    if Options.instructionsLook:
        # Mark all sharp edges as freestyle edges
        me = bpy.context.object.data
        for e in me.edges:
            e.use_freestyle_mark = e.use_edge_sharp

    # Deselect object
    deselectObject(ob)

    # Remove object from scene
    unlinkFromScene(ob)


# **************************************************************************************
def createBlenderObjectsFromNode(node,
                                 localMatrix,
                                 name,
                                 realColourName=Options.defaultColour,
                                 blenderParentTransform=Math.identityMatrix,
                                 localToWorldSpaceMatrix=Math.identityMatrix,
                                 blenderNodeParent=None):
    """
    Creates a Blender Object for the node given and (recursively) for all it's children as required.
    Creates and optimises the mesh for each object too.
    """

    global globalBrickCount
    global globalObjectsToAdd
    global globalWeldDistance
    global globalPoints

    ob = None

    if node.isBlenderObjectNode():
        ourColourName = LDrawNode.resolveColour(node.colourName, realColourName)
        meshName, geometry = node.getBlenderGeometry(ourColourName, name)
        mesh, newMeshCreated = createMesh(name, meshName, geometry)

        # Format a name for the Blender Object
        if Options.numberNodes:
            blenderName = str(globalBrickCount).zfill(5) + "_" + name
        else:
            blenderName = name
        globalBrickCount = globalBrickCount + 1

        # Create Blender Object
        ob = bpy.data.objects.new(blenderName, mesh)
        ob.matrix_local = blenderParentTransform @ localMatrix

        if newMeshCreated:
            # For performance reasons we try to avoid using bpy.ops.* methods
            # (e.g. we use bmesh.* operations instead).
            # See discussion: http://blender.stackexchange.com/questions/7358/python-performance-with-blender-operators

            # Use bevel weights (added to sharp edges) - Only available for Blender version < 3.4
            if hasattr(ob.data, "use_customdata_edge_bevel"):
                ob.data.use_customdata_edge_bevel = True
            else:
                if bpy.app.version < (4, 0, 0):
                    # Add to scene
                    linkToScene(ob)

                    # Blender 3.4 removed 'ob.data.use_customdata_edge_bevel', so this seems to be the alternative:
                    # See https://blender.stackexchange.com/a/270716
                    area_type = 'VIEW_3D' # change this to use the correct Area Type context you want to process in
                    areas  = [area for area in bpy.context.window.screen.areas if area.type == area_type]

                    if len(areas) <= 0:
                        raise Exception(f"Make sure an Area of type {area_type} is open or visible on your screen!")
                    selectObject(ob)
                    bpy.ops.object.mode_set(mode='EDIT')

                    with bpy.context.temp_override(
                        window=bpy.context.window,
                        area=areas[0],
                        regions=[region for region in areas[0].regions if region.type == 'WINDOW'][0],
                        screen=bpy.context.window.screen):
                        bpy.ops.mesh.customdata_bevel_weight_edge_add()
                    bpy.ops.object.mode_set(mode='OBJECT')

                    unlinkFromScene(ob)

        # The lines out of an empty shown in the viewport are scaled to a reasonable size
        ob.empty_display_size = 250.0 * globalScaleFactor

        # Mark object as transparent if any polygon is transparent
        ob["Lego.isTransparent"] = False
        if mesh is not None:
            for faceInfo in geometry.faceInfo:
                material = BlenderMaterials.getMaterial(faceInfo.faceColour, False)
                if material is not None:
                    if "Lego.isTransparent" in material:
                        if material["Lego.isTransparent"]:
                            ob["Lego.isTransparent"] = True
                            break

        # Add any (LeoCAD) group nodes as parents of 'ob' (the new node), and as children of 'blenderNodeParent'.
        # Also add all objects to 'globalObjectsToAdd'.
        addNodeToParentWithGroups(blenderNodeParent, node.groupNames, ob)

        # Node to which our children will be attached
        blenderNodeParent = ob
        blenderParentTransform = Math.identityMatrix

        # debugPrint("NAME = {0}".format(name))

        # Add light to light bricks
        if (name in globalLightBricks):
            lights = bpy.data.lights
            lamp_data = lights.new(name="LightLamp", type='POINT')
            lamp_data.shadow_soft_size = 0.05
            lamp_data.use_nodes = True
            emission_node = lamp_data.node_tree.nodes.get('Emission')
            if emission_node:
                emission_node.inputs['Color'].default_value = globalLightBricks[name]
                emission_node.inputs['Strength'].default_value = 100.0
            lamp_object = bpy.data.objects.new(name="LightLamp", object_data=lamp_data)
            lamp_object.location = (-0.27, 0.0, -0.18)

            addNodeToParentWithGroups(blenderNodeParent, [], lamp_object)

        if newMeshCreated:
            # Calculate what we need to do next
            recalculateNormals = node.file.isDoubleSided and (Options.resolveAmbiguousNormals == "guess")
            keepDoubleSided    = node.file.isDoubleSided and (Options.resolveAmbiguousNormals == "double")
            removeDoubles      = Options.removeDoubles and not keepDoubleSided

            bm = bmesh.new()
            bm.from_mesh(ob.data)
            bm.faces.ensure_lookup_table()
            bm.verts.ensure_lookup_table()
            bm.edges.ensure_lookup_table()

            # Remove doubles
            # Note: This doesn't work properly with a low distance value
            # So we scale up the vertices beforehand and scale them down afterwards
            for v in bm.verts:
                v.co = v.co * 1000

            if removeDoubles:
                bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=globalWeldDistance)

            for v in bm.verts:
                v.co = v.co / 1000

            # Recalculate normals
            if recalculateNormals:
                bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])

            # Add sharp edges (and edge weights in Blender 3)
            edgeIndices = addSharpEdges(bm, geometry, name)

            bm.to_mesh(ob.data)

            # In Blender 4, set the edge weights (on ob.data rather than bm these days)
            if (bpy.app.version >= (4, 0, 0)) and edgeIndices:
                # Blender 4
                bevel_weight_attr = ob.data.attributes.new("bevel_weight_edge", "FLOAT", "EDGE")
                for idx, meshEdge in enumerate(bm.edges):
                    v0 = meshEdge.verts[0].index
                    v1 = meshEdge.verts[1].index
                    if (v0, v1) in edgeIndices:
                        bevel_weight_attr.data[idx].value = 1.0

            bm.clear()
            bm.free()

            # Show the sharp edges in Edit Mode
            for area in bpy.context.screen.areas:  # iterate through areas in current screen
                if area.type == 'VIEW_3D':
                    for space in area.spaces:  # iterate through spaces in current VIEW_3D area
                        if space.type == 'VIEW_3D':  # check if space is a 3D view
                            space.overlay.show_edge_sharp = True

            # Scale for Gaps
            if Options.gaps and node.file.isPart:
                # Distance between gaps is controlled by Options.realGapWidth
                # Gap height is set smaller than realGapWidth since empirically, stacked bricks tend
                # to be pressed more tightly together
                gapHeight = 0.33 * Options.realGapWidth
                objScale = ob.scale
                dim = ob.dimensions

                # Checks whether the object isn't flat in a certain direction
                # to avoid division by zero.
                # Else, the scale factor is set proportional to the inverse of
                # the dimension so that the mesh shrinks a fixed distance
                # (determined by the gap_width and the scale of the object)
                # in every direction, creating a uniform gap.
                scaleFac = mathutils.Vector( (1.0, 1.0, 1.0) )
                if dim.x != 0:
                    scaleFac.x = 1 - Options.realGapWidth * abs(objScale.x) / dim.x
                if dim.y != 0:
                    scaleFac.y = 1 - gapHeight            * abs(objScale.y) / dim.y
                if dim.z != 0:
                    scaleFac.z = 1 - Options.realGapWidth * abs(objScale.z) / dim.z

                # A safety net: Don't distort the part too much (e.g. -ve scale would not look good)
                if scaleFac.x < 0.95:
                    scaleFac.x = 0.95
                if scaleFac.y < 0.95:
                    scaleFac.y = 0.95
                if scaleFac.z < 0.95:
                    scaleFac.z = 0.95

                # Scale all vertices in the mesh
                gapsScaleMatrix = mathutils.Matrix((
                    (scaleFac.x, 0.0,        0.0,        0.0),
                    (0.0,        scaleFac.y, 0.0,        0.0),
                    (0.0,        0.0,        scaleFac.z, 0.0),
                    (0.0,        0.0,        0.0,        1.0)
                ))
                mesh.transform(gapsScaleMatrix)

            smoothShadingAndFreestyleEdges(ob)

        # Keep track of all vertices in global space, for positioning the camera and/or root object at the end
        # Notice that we do this after scaling for Options.gaps
        if Options.positionObjectOnGroundAtOrigin or Options.positionCamera:
            if mesh and mesh.vertices:
                localTransform = localToWorldSpaceMatrix @ localMatrix
                points = [localTransform @ p.co for p in mesh.vertices]

                # Remember all the points
                globalPoints.extend(points)

        # Hide selection of studs
        if node.file.isStud:
            ob.hide_select = True

        # Add bevel and edge split modifiers as needed
        if mesh:
            addModifiers(ob)

    else:
        blenderParentTransform = blenderParentTransform @ localMatrix

    # Create children and parent them
    for childNode in node.file.childNodes:
        # Create sub-objects recursively
        childColourName = LDrawNode.resolveColour(childNode.colourName, realColourName)
        createBlenderObjectsFromNode(childNode, childNode.matrix, childNode.filename, childColourName, blenderParentTransform, localToWorldSpaceMatrix @ localMatrix, blenderNodeParent)

    return ob

# **************************************************************************************
def addFileToCache(relativePath, name):
    """Loads and caches an LDraw file in the cache of files"""

    file = LDrawFile(relativePath, False, "", None, True)
    CachedFiles.addToCache(name, file)
    return True

# **************************************************************************************
def setupLineset(lineset, thickness, group):
    lineset.select_silhouette = True
    lineset.select_border = False
    lineset.select_contour = False
    lineset.select_suggestive_contour = False
    lineset.select_ridge_valley = False
    lineset.select_crease = False
    lineset.select_edge_mark = True
    lineset.select_external_contour = False
    lineset.select_material_boundary = False
    lineset.edge_type_combination = 'OR'
    lineset.edge_type_negation = 'INCLUSIVE'
    lineset.select_by_collection = True
    lineset.collection = bpy.data.collections[bpy.data.collections.find(group)]

    # Set line color
    lineset.linestyle.color = (0.0, 0.0, 0.0)

    # Set material to override color
    if 'LegoMaterial' not in lineset.linestyle.color_modifiers:
        lineset.linestyle.color_modifiers.new('LegoMaterial', 'MATERIAL')

    # Use square caps
    lineset.linestyle.caps = 'SQUARE'       # Can be 'ROUND', 'BUTT', or 'SQUARE'

    # Draw inside the edge of the object
    lineset.linestyle.thickness_position = 'INSIDE'

    # Set Thickness
    lineset.linestyle.thickness = thickness

# **************************************************************************************
def setupRealisticLook():
    scene = bpy.context.scene
    render = scene.render

    # Use cycles render
    scene.render.engine = 'CYCLES'

    # Add environment texture for world
    if Options.addWorldEnvironmentTexture:
        scene.world.use_nodes = True
        nodes = scene.world.node_tree.nodes
        links = scene.world.node_tree.links
        worldNodeNames = [node.name for node in scene.world.node_tree.nodes]

        if "LegoEnvMap" in worldNodeNames:
            env_tex = nodes["LegoEnvMap"]
        else:
            env_tex          = nodes.new('ShaderNodeTexEnvironment')
            env_tex.location = (-250, 300)
            env_tex.name     = "LegoEnvMap"
            env_tex.image    = bpy.data.images.load(Options.scriptDirectory + "/background.exr", check_existing=True)

        if "Background" in worldNodeNames:
            background = nodes["Background"]
            links.new(env_tex.outputs[0],background.inputs[0])
    else:
        scene.world.color = (1.0, 1.0, 1.0)

    if Options.setRenderSettings:
        useDenoising(scene, True)

        if (scene.cycles.samples < 400):
            scene.cycles.samples = 400
        if (scene.cycles.diffuse_bounces < 20):
            scene.cycles.diffuse_bounces = 20
        if (scene.cycles.glossy_bounces < 20):
            scene.cycles.glossy_bounces = 20

    # Check layer names to see if we were previously rendering instructions and change settings back.
    layerNames = getLayerNames(scene)
    if ("SolidBricks" in layerNames) or ("TransparentBricks" in layerNames):
        render.use_freestyle = False

        # Change camera back to Perspective
        if scene.camera is not None:
            scene.camera.data.type = 'PERSP'

        # For Blender Render, reset to opaque background (Not available in Blender 3.5.1 or higher.)
        if hasattr(render, "alpha_mode"):
            render.alpha_mode = 'SKY'

        # Turn off cycles transparency
        scene.cycles.film_transparent = False

        # Get the render/view layers we are interested in:
        layers = getLayers(scene)

        # If we have previously added render layers for instructions look, re-enable any disabled render layers
        for i in range(len(layers)):
            layers[i].use = True

        # Un-name SolidBricks and TransparentBricks layers
        if "SolidBricks" in layerNames:
            layers.remove(layers["SolidBricks"])

        if "TransparentBricks" in layerNames:
            layers.remove(layers["TransparentBricks"])

        # Re-enable all layers
        for i in range(len(layers)):
            layers[i].use = True

        # Create Compositing Nodes
        scene.use_nodes = True

        # If scene nodes exist for compositing instructions look, remove them
        nodeNames = [node.name for node in scene.node_tree.nodes]
        if "Solid" in nodeNames:
           scene.node_tree.nodes.remove(scene.node_tree.nodes["Solid"])

        if "Trans" in nodeNames:
           scene.node_tree.nodes.remove(scene.node_tree.nodes["Trans"])

        if "Z Combine" in nodeNames:
            scene.node_tree.nodes.remove(scene.node_tree.nodes["Z Combine"])

        # Set up standard link from Render Layers to Composite
        if "Render Layers" in nodeNames:
            if "Composite" in nodeNames:
                rl = scene.node_tree.nodes["Render Layers"]
                zCombine = scene.node_tree.nodes["Composite"]

                links = scene.node_tree.links
                links.new(rl.outputs[0], zCombine.inputs[0])

    removeCollection('Black Edged Bricks Collection')
    removeCollection('White Edged Bricks Collection')
    removeCollection('Solid Bricks Collection')
    removeCollection('Transparent Bricks Collection')

# **************************************************************************************
def removeCollection(name, remove_collection_objects=False):
    coll = bpy.data.collections.get(name)
    if coll:
        if remove_collection_objects:
            obs = [o for o in coll.objects if o.users == 1]
            while obs:
                bpy.data.objects.remove(obs.pop())

        bpy.data.collections.remove(coll)

# **************************************************************************************
def createCollection(scene, name):
    if bpy.data.collections.find(name) < 0:
        # Create collection
        bpy.data.collections.new(name)
        # Add collection to scene
        scene.collection.children.link(bpy.data.collections[name])

# **************************************************************************************
def setupInstructionsLook():
    scene = bpy.context.scene
    render = scene.render
    render.use_freestyle = True

    # Use Blender Eevee (or Eevee Next) for instructions look
    try:
        render.engine = 'BLENDER_EEVEE'
    except:
        render.engine = 'BLENDER_EEVEE_NEXT'

    # Change camera to Orthographic
    if scene.camera is not None:
        scene.camera.data.type = 'ORTHO'

    # For Blender Render, set transparent background. (Not available in Blender 3.5.1 or higher.)
    if hasattr(render, "alpha_mode"):
        render.alpha_mode = 'TRANSPARENT'

    # Turn on cycles transparency
    scene.cycles.film_transparent = True

    # Increase max number of transparency bounces to at least 80
    # This avoids artefacts when multiple transparent objects are behind each other
    if scene.cycles.transparent_max_bounces < 80:
        scene.cycles.transparent_max_bounces = 80

    # Add collections / groups, if not already present
    if hasCollections:
        createCollection(scene, 'Black Edged Bricks Collection')
        createCollection(scene, 'White Edged Bricks Collection')
        createCollection(scene, 'Solid Bricks Collection')
        createCollection(scene, 'Transparent Bricks Collection')
    else:
        if bpy.data.groups.find('Black Edged Bricks Collection') < 0:
            bpy.data.groups.new('Black Edged Bricks Collection')
        if bpy.data.groups.find('White Edged Bricks Collection') < 0:
            bpy.data.groups.new('White Edged Bricks Collection')

    # Find or create the render/view layers we are interested in:
    layers = getLayers(scene)

    # Remember current view layer
    current_view_layer = bpy.context.view_layer

    # Add layers as needed
    layerNames = list(map((lambda x: x.name), layers))
    if "SolidBricks" not in layerNames:
        bpy.ops.scene.view_layer_add()

        layers[-1].name = "SolidBricks"
        layers[-1].use = True
        layerNames.append("SolidBricks")
    solidLayer = layerNames.index("SolidBricks")

    if "TransparentBricks" not in layerNames:
        bpy.ops.scene.view_layer_add()

        layers[-1].name = "TransparentBricks"
        layers[-1].use = True
        layerNames.append("TransparentBricks")
    transLayer = layerNames.index("TransparentBricks")

    # Restore current view layer
    bpy.context.window.view_layer = current_view_layer

    # Use Z layer (defaults to off in Blender 3.5.1)
    if hasattr(layers[transLayer], "use_pass_z"):
        layers[transLayer].use_pass_z = True
    if hasattr(layers[solidLayer], "use_pass_z"):
        layers[solidLayer].use_pass_z = True

    # Disable any render/view layers that are not needed
    for i in range(len(layers)):
        if i not in [solidLayer, transLayer]:
            layers[i].use = False

    layers[solidLayer].use = True
    layers[transLayer].use = True

    # Include or exclude collections for each layer
    for collection in layers[solidLayer].layer_collection.children:
        collection.exclude = collection.name != 'Solid Bricks Collection'
    for collection in layers[transLayer].layer_collection.children:
        collection.exclude = collection.name != 'Transparent Bricks Collection'

    #layers[solidLayer].layer_collection.children['Black Edged Bricks Collection'].exclude = True
    #layers[solidLayer].layer_collection.children['White Edged Bricks Collection'].exclude = True
    #layers[solidLayer].layer_collection.children['Solid Bricks Collection'].exclude = False
    #layers[solidLayer].layer_collection.children['Transparent Bricks Collection'].exclude = True

    #layers[transLayer].layer_collection.children['Black Edged Bricks Collection'].exclude = True
    #layers[transLayer].layer_collection.children['White Edged Bricks Collection'].exclude = True
    #layers[transLayer].layer_collection.children['Solid Bricks Collection'].exclude = True
    #layers[transLayer].layer_collection.children['Transparent Bricks Collection'].exclude = False

    # Move each part to appropriate collection
    for object in scene.objects:
        isTransparent = False
        if "Lego.isTransparent" in object:
            isTransparent = object["Lego.isTransparent"]

            # Add objects to the appropriate layers
            if isTransparent:
                linkToCollection('Transparent Bricks Collection', object)
            else:
                linkToCollection('Solid Bricks Collection', object)

            # Add object to the appropriate group
            if object.data != None:
                colour = object.data.materials[0].diffuse_color

                # Dark colours have white lines
                if LegoColours.isDark(colour):
                    linkToCollection('White Edged Bricks Collection', object)
                else:
                    linkToCollection('Black Edged Bricks Collection', object)

    # Find or create linesets
    solidBlackLineset = None
    solidWhiteLineset = None
    transBlackLineset = None
    transWhiteLineset = None

    for lineset in layers[solidLayer].freestyle_settings.linesets:
        if lineset.name == "LegoSolidBlackLines":
            solidBlackLineset = lineset
        if lineset.name == "LegoSolidWhiteLines":
            solidWhiteLineset = lineset

    for lineset in layers[transLayer].freestyle_settings.linesets:
        if lineset.name == "LegoTransBlackLines":
            transBlackLineset = lineset
        if lineset.name == "LegoTransWhiteLines":
            transWhiteLineset = lineset

    if solidBlackLineset == None:
        layers[solidLayer].freestyle_settings.linesets.new("LegoSolidBlackLines")
        solidBlackLineset = layers[solidLayer].freestyle_settings.linesets[-1]
        setupLineset(solidBlackLineset, 2.25, 'Black Edged Bricks Collection')
    if solidWhiteLineset == None:
        layers[solidLayer].freestyle_settings.linesets.new("LegoSolidWhiteLines")
        solidWhiteLineset = layers[solidLayer].freestyle_settings.linesets[-1]
        setupLineset(solidWhiteLineset, 2, 'White Edged Bricks Collection')
    if transBlackLineset == None:
        layers[transLayer].freestyle_settings.linesets.new("LegoTransBlackLines")
        transBlackLineset = layers[transLayer].freestyle_settings.linesets[-1]
        setupLineset(transBlackLineset, 2.25, 'Black Edged Bricks Collection')
    if transWhiteLineset == None:
        layers[transLayer].freestyle_settings.linesets.new("LegoTransWhiteLines")
        transWhiteLineset = layers[transLayer].freestyle_settings.linesets[-1]
        setupLineset(transWhiteLineset, 2, 'White Edged Bricks Collection')

    # Create Compositing Nodes
    scene.use_nodes = True

    if "Solid" in scene.node_tree.nodes:
        solidLayer = scene.node_tree.nodes["Solid"]
    else:
        solidLayer = scene.node_tree.nodes.new('CompositorNodeRLayers')
        solidLayer.name = "Solid"
    solidLayer.layer = 'SolidBricks'

    if "Trans" in scene.node_tree.nodes:
        transLayer = scene.node_tree.nodes["Trans"]
    else:
        transLayer = scene.node_tree.nodes.new('CompositorNodeRLayers')
        transLayer.name = "Trans"
    transLayer.layer = 'TransparentBricks'

    if "Z Combine" in scene.node_tree.nodes:
        zCombine = scene.node_tree.nodes["Z Combine"]
    else:
        zCombine = scene.node_tree.nodes.new('CompositorNodeZcombine')
    zCombine.use_alpha = True
    zCombine.use_antialias_z = True

    if "Set Alpha" in scene.node_tree.nodes:
        setAlpha = scene.node_tree.nodes["Set Alpha"]
    else:
        setAlpha = scene.node_tree.nodes.new('CompositorNodeSetAlpha')
    setAlpha.inputs[1].default_value = 0.75

    composite = scene.node_tree.nodes["Composite"]
    composite.location = (950, 400)
    zCombine.location = (750, 500)
    transLayer.location = (300, 300)
    solidLayer.location = (300, 600)
    setAlpha.location = (580, 370)

    links = scene.node_tree.links
    links.new(solidLayer.outputs[0], zCombine.inputs[0])
    links.new(solidLayer.outputs[2], zCombine.inputs[1])
    links.new(transLayer.outputs[0], setAlpha.inputs[0])
    links.new(setAlpha.outputs[0], zCombine.inputs[2])
    links.new(transLayer.outputs[2], zCombine.inputs[3])
    links.new(zCombine.outputs[0], composite.inputs[0])

    # Blender 3 only: link the Z from the Z Combine to the composite. This is not present in Blender 4.
    if bpy.app.version < (4, 0, 0):
        links.new(zCombine.outputs[1], composite.inputs[2])


# **************************************************************************************
def iterateCameraPosition(camera, render, vcentre3d, moveCamera):

    global globalPoints

    bpy.context.view_layer.update()

    minX = sys.float_info.max
    maxX = -sys.float_info.max
    minY = sys.float_info.max
    maxY = -sys.float_info.max

    # Calculate matrix to take 3d points into normalised camera space
    modelview_matrix = camera.matrix_world.inverted()

    get_depsgraph_method = getattr(bpy.context, "evaluated_depsgraph_get", None)
    if callable(get_depsgraph_method):
        depsgraph = get_depsgraph_method()
    else:
        depsgraph = bpy.context.depsgraph
    projection_matrix = camera.calc_matrix_camera(
        depsgraph,
        x=render.resolution_x,
        y=render.resolution_y,
        scale_x=render.pixel_aspect_x,
        scale_y=render.pixel_aspect_y)

    mp_matrix = projection_matrix @ modelview_matrix
    mpinv_matrix = mp_matrix.copy()
    mpinv_matrix.invert()

    isOrtho = bpy.context.scene.camera.data.type == 'ORTHO'

    # Convert 3d points to camera space, calculating the min and max extents in 2d normalised camera space.
    minDistToCamera = sys.float_info.max
    for point in globalPoints:
        p1 = mp_matrix @ mathutils.Vector((point.x, point.y, point.z, 1))
        if isOrtho:
            point2d = (p1.x, p1.y)
        elif abs(p1.w)<1e-8:
            continue
        else:
            point2d = (p1.x/p1.w, p1.y/p1.w)
        minX = min(point2d[0], minX)
        minY = min(point2d[1], minY)
        maxX = max(point2d[0], maxX)
        maxY = max(point2d[1], maxY)
        disttocamera = (point - camera.location).length
        minDistToCamera = min(minDistToCamera, disttocamera)

    #debugPrint("minX,maxX: " + ('%.5f' % minX) + "," + ('%.5f' % maxX))
    #debugPrint("minY,maxY: " + ('%.5f' % minY) + "," + ('%.5f' % maxY))

    # Calculate distance d from camera to centre of the model
    d = (vcentre3d - camera.location).length

    # Which axis is filling most of the display?
    largestSpan = max(maxX-minX, maxY-minY)

    # Force option to be in range
    if Options.cameraBorderPercent > 0.99999:
        Options.cameraBorderPercent = 0.99999

    # How far should the camera be away from the object?
    # Zoom in or out to make the coverage close to 1 (or 1-border if theres a border amount specified)
    scale = largestSpan/(2 - 2 * Options.cameraBorderPercent)
    desiredMinDistToCamera = scale * minDistToCamera

    # Adjust d to be the change in distance from the centre of the object
    offsetD = minDistToCamera - desiredMinDistToCamera

    # Calculate centre of object on screen
    centre2d = mathutils.Vector(((minX + maxX)*0.5, (minY+maxY)*0.5))

    # Get the forward vector of the camera
    tempMatrix = camera.matrix_world.copy()
    tempMatrix.invert()
    forwards4d = -tempMatrix[2]
    forwards3d = mathutils.Vector((forwards4d.x, forwards4d.y, forwards4d.z))

    # Transform the 2d centre of object back into 3d space
    if isOrtho:
        centre3d = mpinv_matrix @ mathutils.Vector((centre2d.x, centre2d.y, 0, 1))
        centre3d = mathutils.Vector((centre3d.x, centre3d.y, centre3d.z))

        # Move centre3d a distance d from the camera plane
        v = centre3d - camera.location
        dist = v.dot(forwards3d)
        centre3d = centre3d + (d - dist) * forwards3d
    else:
        centre3d = mpinv_matrix @ mathutils.Vector((centre2d.x, centre2d.y, -1, 1))
        centre3d = mathutils.Vector((centre3d.x / centre3d.w, centre3d.y / centre3d.w, centre3d.z / centre3d.w))

        # Make sure the 3d centre of the object is distance d from the camera location
        forwards = centre3d - camera.location
        forwards.normalize()
        centre3d = camera.location + d * forwards

    # Get the centre of the viewing area in 3d space at distance d from the camera
    # This is where we want to move the object to
    origin3d = camera.location + d * forwards3d

    #debugPrint("d: " + ('%.5f' % d))
    #debugPrint("camloc: " + ('%.5f' % camera.location.x) + "," + ('%.5f' % camera.location.y) + "," + ('%.5f' % camera.location.z))
    #debugPrint("forwards3d: " + ('%.5f' % forwards3d.x) + "," + ('%.5f' % forwards3d.y) + "," + ('%.5f' % forwards3d.z))
    #debugPrint("Origin3d: " + ('%.5f' % origin3d.x) + "," + ('%.5f' % origin3d.y) + "," + ('%.5f' % origin3d.z))
    #debugPrint("Centre3d: " + ('%.5f' % centre3d.x) + "," + ('%.5f' % centre3d.y) + "," + ('%.5f' % centre3d.z))

    # bpy.context.scene.cursor_location = centre3d
    # bpy.context.scene.cursor_location = origin3d

    if moveCamera:
        if isOrtho:
            offset3d = (centre3d - origin3d)

            camera.data.ortho_scale *= scale
        else:
            # How much do we want to move the camera?
            # We want to move the camera by the same amount as if we moved the centre of the object to the centre of the viewing area.
            # In practice, this is not completely accurate, since the perspective projection changes the objects silhouette in 2d space
            # when we move the camera, but it's close in practice. We choose to move it conservatively by 93% of our calculated amount,
            # a figure obtained by some quick practical observations of the convergence on a few test models.
            offset3d = 0.93 * (centre3d - origin3d) + offsetD * forwards3d
        # debugPrint("offset3d: " + ('%.5f' % offset3d.x) + "," + ('%.5f' % offset3d.y) + "," + ('%.5f' % offset3d.z) + " length:" + ('%.5f' % offset3d.length))
        # debugPrint("move by: " + ('%.5f' % offset3d.length))
        camera.location += mathutils.Vector((offset3d.x, offset3d.y, offset3d.z))
        return offset3d.length
    return 0.0

# **************************************************************************************
def getConvexHull(minPoints = 3):
    global globalPoints

    if len(globalPoints) >= minPoints:
        bm = bmesh.new()
        [bm.verts.new(v) for v in globalPoints]
        bm.verts.ensure_lookup_table()

        ret = bmesh.ops.convex_hull(bm, input=bm.verts, use_existing_faces=False)
        globalPoints = [vert.co.copy() for vert in ret["geom"] if isinstance(vert, bmesh.types.BMVert)]
        del ret
        bm.clear()
        bm.free()

# **************************************************************************************
def loadFromFile(context, filename, isFullFilepath=True):
    global globalCamerasToAdd
    global globalContext
    global globalScaleFactor

    # Set global scale factor
    # -----------------------
    #
    # 1. The size of Lego pieces:
    #
    # Lego scale: https://www.lugnet.com/~330/FAQ/Build/dimensions
    #
    #   1 Lego draw unit = 0.4 mm, in an idealised world.
    #
    # In real life, actual Lego pieces have been measured as 0.3993 mm +/- 0.0002,
    # which makes 0.4mm accurate enough for all practical purposes (The difference
    # being just 7 microns).
    #
    # 2. Blender coordinates:
    #
    # Blender reports coordinates in metres by default. So the
    # scale factor to convert from Lego units to Blender coordinates
    # is 0.0004.
    #
    # This calculation does not adjust for any gap between the pieces.
    # This is (optionally) done later in the calculations, where we
    # reduce the size of each piece by 0.2mm (default amount) to allow
    # for a small gap between pieces. This matches real piece sizes.
    #
    # 3. Blender Scene Unit Scale:
    #
    # Blender has a 'Scene Unit Scale' value which by default is set
    # to 1.0. By changing the 'Unit Scale' after import the size of
    # everything in the scene can be adjusted.

    globalScaleFactor = 0.0004 * Options.realScale
    globalWeldDistance = 0.01 * globalScaleFactor

    globalCamerasToAdd = []
    globalContext = context

    # Make sure we have the latest configuration, including the latest ldraw directory
    # and the colours derived from that.
    Configure()
    LegoColours()
    Math()

    if Configure.ldrawInstallDirectory == "":
        printError("Could not find LDraw Part Library")
        return None

    # Clear caches
    CachedDirectoryFilenames.clearCache()
    CachedFiles.clearCache()
    CachedGeometry.clearCache()
    BlenderMaterials.clearCache()
    Configure.warningSuppression = {}

    if Options.useLogoStuds:
        debugPrint("Loading stud files")
        # Load stud logo files into cache
        addFileToCache("stud-logo"   + Options.logoStudVersion + ".dat", "stud.dat")
        addFileToCache("stud2-logo"  + Options.logoStudVersion + ".dat", "stud2.dat")
        addFileToCache("stud6-logo"  + Options.logoStudVersion + ".dat", "stud6.dat")
        addFileToCache("stud6a-logo" + Options.logoStudVersion + ".dat", "stud6a.dat")
        addFileToCache("stud7-logo"  + Options.logoStudVersion + ".dat", "stud7.dat")
        addFileToCache("stud10-logo" + Options.logoStudVersion + ".dat", "stud10.dat")
        addFileToCache("stud13-logo" + Options.logoStudVersion + ".dat", "stud13.dat")
        addFileToCache("stud15-logo" + Options.logoStudVersion + ".dat", "stud15.dat")
        addFileToCache("stud20-logo" + Options.logoStudVersion + ".dat", "stud20.dat")
        addFileToCache("studa-logo"  + Options.logoStudVersion + ".dat", "studa.dat")
        addFileToCache("studtente-logo.dat", "s\\teton.dat")     # TENTE

    # Load and parse file to create geometry
    filename = os.path.expanduser(filename)

    debugPrint("Loading files")
    node = LDrawNode(filename, isFullFilepath, os.path.dirname(filename))
    node.load()
    # node.printBFC()

    if node.file.isModel:
        # Fix top level rotation from LDraw coordinate space to Blender coordinate space
        node.file.geometry.points = [Math.rotationMatrix * p for p in node.file.geometry.points]
        node.file.geometry.edges  = [(Math.rotationMatrix @ e[0], Math.rotationMatrix @ e[1]) for e in node.file.geometry.edges]

        for childNode in node.file.childNodes:
            childNode.matrix = Math.rotationMatrix @ childNode.matrix

    # Switch to Object mode and deselect all
    if bpy.ops.object.mode_set.poll():
        bpy.ops.object.mode_set(mode='OBJECT')
    bpy.ops.object.select_all(action='DESELECT')

    name = os.path.basename(filename)

    global globalBrickCount
    global globalObjectsToAdd
    global globalPoints

    globalBrickCount = 0
    globalObjectsToAdd = []
    globalPoints = []

    debugPrint("Creating NodeGroups")
    BlenderMaterials.createBlenderNodeGroups()

    # Create Blender objects from the loaded file
    debugPrint("Creating Blender objects")
    rootOb = createBlenderObjectsFromNode(node, node.matrix, name)

    if not node.file.isModel:
        if rootOb.data:
            rootOb.data.transform(Math.rotationMatrix)

    scene  = bpy.context.scene
    camera = scene.camera
    render = scene.render

    debugPrint("Number of vertices: " + str(len(globalPoints)))

    # Take the convex hull of all the points in the scene (operation must have at least three vertices)
    # This results in far fewer points to consider when adjusting the object and/or camera position.
    getConvexHull()
    debugPrint("Number of convex hull vertices: " + str(len(globalPoints)))

    # Set camera type
    if scene.camera is not None:
        if Options.instructionsLook:
            scene.camera.data.type = 'ORTHO'
        else:
            scene.camera.data.type = 'PERSP'

    # Centre object only if root node is a model
    if node.file.isModel and globalPoints:
        # Calculate our bounding box in global coordinate space
        boundingBoxMin = mathutils.Vector((0, 0, 0))
        boundingBoxMax = mathutils.Vector((0, 0, 0))

        boundingBoxMin[0] = min(p[0] for p in globalPoints)
        boundingBoxMin[1] = min(p[1] for p in globalPoints)
        boundingBoxMin[2] = min(p[2] for p in globalPoints)
        boundingBoxMax[0] = max(p[0] for p in globalPoints)
        boundingBoxMax[1] = max(p[1] for p in globalPoints)
        boundingBoxMax[2] = max(p[2] for p in globalPoints)

        # Length of bounding box diagonal
        boundingBoxDistance = (boundingBoxMax - boundingBoxMin).length
        boundingBoxCentre = (boundingBoxMax + boundingBoxMin) * 0.5

        vcentre = (boundingBoxMin + boundingBoxMax) * 0.5
        offsetToCentreModel = mathutils.Vector((-vcentre.x, -vcentre.y, -boundingBoxMin.z))
        if Options.positionObjectOnGroundAtOrigin:
            debugPrint("Centre object")
            rootOb.location += offsetToCentreModel

            # Offset bounding box
            boundingBoxMin += offsetToCentreModel
            boundingBoxMax += offsetToCentreModel
            boundingBoxCentre += offsetToCentreModel

            # Offset all points
            globalPoints = [p + offsetToCentreModel for p in globalPoints]
            offsetToCentreModel = mathutils.Vector((0, 0, 0))

        if camera is not None:
            if Options.positionCamera:
                debugPrint("Positioning Camera")

                camera.data.clip_start = 25 * globalScaleFactor            # 0.01 at normal scale
                camera.data.clip_end   = 250000 * globalScaleFactor        # 100 at normal scale

                # Set up a default camera position and rotation
                camera.location = mathutils.Vector((6.5, -6.5, 4.75))
                camera.location.normalize()
                camera.location = camera.location * boundingBoxDistance
                camera.rotation_mode = 'XYZ'
                camera.rotation_euler = mathutils.Euler((1.0471975803375244, 0.0, 0.7853981852531433), 'XYZ')

                # Must have at least three vertices to move the camera
                if len(globalPoints) >= 3:
                    isOrtho = camera.data.type == 'ORTHO'
                    if isOrtho:
                        iterateCameraPosition(camera, render, vcentre, True)
                    else:
                        for i in range(20):
                            error = iterateCameraPosition(camera, render, vcentre, True)
                            if (error < 0.001):
                                break

        # Find the (first) 3D View, then set the view's 'look at' and 'distance'
        # Note: Not a camera object, but the point of view in the UI.
        areas = [area for area in bpy.context.window.screen.areas if area.type == 'VIEW_3D']
        if len(areas) > 0:
            area = areas[0]
            with bpy.context.temp_override(area=area):
                view3d = bpy.context.space_data
                view3d.region_3d.view_location = boundingBoxCentre      # Where to look at
                view3d.region_3d.view_distance = boundingBoxDistance    # How far from target

    # Get existing object names
    sceneObjectNames = [x.name for x in scene.objects]

    # Remove default objects
    if Options.removeDefaultObjects:
        if "Cube" in sceneObjectNames:
            cube = scene.objects['Cube']
            if (cube.location.length < 0.001):
                unlinkFromScene(cube)

        if lightName in sceneObjectNames:
            light = scene.objects[lightName]
            lampVector = light.location - mathutils.Vector((4.076245307922363, 1.0054539442062378, 5.903861999511719))
            if (lampVector.length < 0.001):
                unlinkFromScene(light)

    # Finally add each object to the scene
    debugPrint("Adding {0} objects to scene".format(len(globalObjectsToAdd)))
    for ob in globalObjectsToAdd:
        linkToScene(ob)

    # Parent only once everything has been added to the scene, otherwise the matrix_world's are
    # sometimes not updated properly - some are erroneously still the identity matrix.
    setupImplicitParents()

    # Add cameras to the scene
    for ob in globalCamerasToAdd:
        cam = ob.createCameraNode()
        cam.parent = rootOb

    globalObjectsToAdd = []
    globalCamerasToAdd = []

    # Select the newly created root object
    selectObject(rootOb)

    # Get existing object names
    sceneObjectNames = [x.name for x in scene.objects]

    # Add ground plane with white material
    if Options.addGroundPlane and not Options.instructionsLook:
        if "LegoGroundPlane" not in sceneObjectNames:
            addPlane((0,0,0), 100000 * globalScaleFactor)

            blenderName = "Mat_LegoGroundPlane"
            # Reuse current material if it exists, otherwise create a new material
            if bpy.data.materials.get(blenderName) is None:
                material = bpy.data.materials.new(blenderName)
            else:
                material = bpy.data.materials[blenderName]

            # Use nodes
            material.use_nodes = True

            nodes = material.node_tree.nodes
            links = material.node_tree.links

            # Remove any existing nodes
            for n in nodes:
                nodes.remove(n)

            node = nodes.new('ShaderNodeBsdfDiffuse')
            node.location = 0, 5
            node.inputs['Color'].default_value = (1,1,1,1)
            node.inputs['Roughness'].default_value = 1.0

            out = nodes.new('ShaderNodeOutputMaterial')
            out.location = 200, 0
            links.new(node.outputs[0], out.inputs[0])

            for obj in bpy.context.selected_objects:
                obj.name = "LegoGroundPlane"
                if obj.data.materials:
                    obj.data.materials[0] = material
                else:
                    obj.data.materials.append(material)

    # Set to render at full resolution
    if Options.setRenderSettings:
        scene.render.resolution_percentage = 100

    # Setup scene as appropriate
    if Options.instructionsLook:
        setupInstructionsLook()
    else:
        setupRealisticLook()

    # Delete the temporary directory if there was one
    if Configure.tempDir:
        Configure.tempDir.cleanup()

    debugPrint("Load Done")
    return rootOb