nodes.py

        row = layout.row()
        row.label(text='Value')
        row.label(text='Height')
        row.label(text='Slope')

    def draw_label(self):
        return "Slope Map"

######################################## Texture nodes ###############################
class TextureOutputNode(Node, TextureNodeTree):
    '''Output'''
    bl_idname = 'TextureOutputNode'
    bl_label = 'Color Map'

    def init(self, context):
        tex = bpy.context.object.active_material.active_texture
        num_sockets = int(tex.pov.density_lines/32)
        for i in range(num_sockets):
            color = self.inputs.new('NodeSocketColor', "%s"%i)
            color.hide_value = True

    def draw_buttons(self, context, layout):

        layout.label(text="Color Ramps:")

    def draw_label(self):
        return "Color Map"


##################################################################################
#################################Operators########################################
##################################################################################


class NODE_OT_iso_add(Operator):
    bl_idname = "pov.nodeisoadd"
    bl_label = "Create iso props"

    def execute(self, context):
        ob = bpy.context.object
        if bpy.context.scene.use_nodes == False:
            bpy.context.scene.use_nodes = True
        tree = bpy.context.scene.node_tree
        for node in tree.nodes:
            if node.bl_idname == "IsoPropsNode" and node.label == ob.name:
                tree.nodes.remove(node)
        isonode = tree.nodes.new('IsoPropsNode')
        isonode.location = (0,0)
        isonode.label = ob.name
        return {'FINISHED'}

class NODE_OT_map_create(Operator):
    bl_idname = "node.map_create"
    bl_label = "Create map"

    def execute(self, context):
        x = y = 0
        space = context.space_data
        tree = space.edit_tree
        for node in tree.nodes:
            if node.select == True:
                x,y = node.location
            node.select=False
        tmap = tree.nodes.new('ShaderTextureMapNode')
        tmap.location = (x - 200,y)
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = context.window_manager
        return wm.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout
        mat = context.object.active_material
        layout.prop(mat.pov,"inputs_number")

class NODE_OT_povray_node_texture_map_add(Operator):
    bl_idname = "pov.nodetexmapadd"
    bl_label = "Texture map"

    def execute(self, context):
        tree=bpy.context.object.active_material.node_tree
        tmap = tree.nodes.active
        bpy.context.object.active_material.node_tree.nodes.active=tmap
        el=tmap.color_ramp.elements.new(0.5)
        for el in tmap.color_ramp.elements:
            el.color=(0,0,0,1)
        for inp in tmap.inputs:
            tmap.inputs.remove(inp)
        for outp in tmap.outputs:
            tmap.outputs.remove(outp)
        pattern=tmap.inputs.new('NodeSocketVector', "Pattern")
        pattern.hide_value=True
        for i in range(0,3):
            tmap.inputs.new('NodeSocketColor', "Shader")
        tmap.outputs.new('NodeSocketShader', "BSDF")
        tmap.label="Texture Map"
        return {'FINISHED'}


class NODE_OT_povray_node_output_add(Operator):
    bl_idname = "pov.nodeoutputadd"
    bl_label = "Output"

    def execute(self, context):
        tree=bpy.context.object.active_material.node_tree
        tmap = tree.nodes.new('ShaderNodeOutputMaterial')
        bpy.context.object.active_material.node_tree.nodes.active=tmap
        for inp in tmap.inputs:
            tmap.inputs.remove(inp)
        tmap.inputs.new('NodeSocketShader', "Surface")
        tmap.label="Output"
        return {'FINISHED'}

class NODE_OT_povray_node_layered_add(Operator):
    bl_idname = "pov.nodelayeredadd"
    bl_label = "Layered material"

    def execute(self, context):
        tree=bpy.context.object.active_material.node_tree
        tmap = tree.nodes.new('ShaderNodeAddShader')
        bpy.context.object.active_material.node_tree.nodes.active=tmap
        tmap.label="Layered material"
        return {'FINISHED'}

class NODE_OT_povray_input_add(Operator):
    bl_idname = "pov.nodeinputadd"
    bl_label = "Add entry"

    def execute(self, context):
        node=bpy.context.object.active_material.node_tree.nodes.active
        if node.type in {'VALTORGB'}:
            number=1
            for inp in node.inputs:
                if inp.type=='SHADER':
                    number+=1
            node.inputs.new('NodeSocketShader', "%s"%number)
            els=node.color_ramp.elements
            pos1=els[len(els)-1].position
            pos2=els[len(els)-2].position
            pos=(pos1-pos2)/2+pos2
            el=els.new(pos)

        if node.bl_idname == 'PovraySlopeNode':
            number=len(node.inputs)
            node.inputs.new('PovraySocketSlope', "%s"%number)


        return {'FINISHED'}

class NODE_OT_povray_input_remove(Operator):
    bl_idname = "pov.nodeinputremove"
    bl_label = "Remove input"

    def execute(self, context):
        node=bpy.context.object.active_material.node_tree.nodes.active
        if node.type in {'VALTORGB','ADD_SHADER'}:
            number=len(node.inputs)-1
            if number > 5:
                inp=node.inputs[number]
                node.inputs.remove(inp)
                if node.type in {'VALTORGB'}:
                    els=node.color_ramp.elements
                    number=len(els)-2
                    el=els[number]
                    els.remove(el)
        return {'FINISHED'}

class NODE_OT_povray_image_open(Operator):
    bl_idname = "pov.imageopen"
    bl_label = "Open"

    filepath: StringProperty(
            name="File Path",
            description="Open image",
            maxlen=1024,
            subtype='FILE_PATH',
            )

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

    def execute(self, context):
        im=bpy.data.images.load(self.filepath)
        node=context.object.active_material.node_tree.nodes.active
        node.image = im.name
        return {'FINISHED'}


# class TEXTURE_OT_povray_open_image(Operator):
    # bl_idname = "pov.openimage"
    # bl_label = "Open Image"

    # filepath = StringProperty(
            # name="File Path",
            # description="Open image",
            # maxlen=1024,
            # subtype='FILE_PATH',
            # )

    # def invoke(self, context, event):
        # context.window_manager.fileselect_add(self)
        # return {'RUNNING_MODAL'}

    # def execute(self, context):
        # im=bpy.data.images.load(self.filepath)
        # tex = context.texture
        # tex.pov.image = im.name
        # view_layer = context.view_layer
        # view_layer.update()
        # return {'FINISHED'}

class PovrayPatternNode(Operator):
    bl_idname = "pov.patternnode"
    bl_label  = "Pattern"

    add=True

    def execute(self, context):
        space = context.space_data
        tree = space.edit_tree
        for node in tree.nodes:
            node.select=False
        if self.add==True:
            tmap = tree.nodes.new('ShaderNodeValToRGB')
            tmap.label="Pattern"
            for inp in tmap.inputs:
                tmap.inputs.remove(inp)
            for outp in tmap.outputs:
                tmap.outputs.remove(outp)
            pattern = tmap.inputs.new('PovraySocketPattern', "Pattern")
            pattern.hide_value = True
            mapping=tmap.inputs.new('NodeSocketVector', "Mapping")
            mapping.hide_value=True
            transform=tmap.inputs.new('NodeSocketVector', "Transform")
            transform.hide_value=True
            modifier=tmap.inputs.new('NodeSocketVector', "Modifier")
            modifier.hide_value=True
            for i in range(0,2):
                tmap.inputs.new('NodeSocketShader', "%s"%(i+1))
            tmap.outputs.new('NodeSocketShader', "Material")
            tmap.outputs.new('NodeSocketColor', "Color")
            tree.nodes.active=tmap
            self.add=False
        aNode=tree.nodes.active
        aNode.select=True
        v2d = context.region.view2d
        x, y = v2d.region_to_view(self.x, self.y)
        aNode.location = (x, y)

    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':
            self.x = event.mouse_region_x
            self.y = event.mouse_region_y
            self.execute(context)
            return {'RUNNING_MODAL'}
        elif event.type == 'LEFTMOUSE':
            return {'FINISHED'}
        elif event.type in ('RIGHTMOUSE', 'ESC'):
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

class UpdatePreviewMaterial(Operator):
    '''Operator update preview material'''
    bl_idname = "node.updatepreview"
    bl_label = "Update preview"

    def execute(self, context):
        scene=context.view_layer
        ob=context.object
        for obj in scene.objects:
            if obj != ob:
                scene.objects.active = ob
                break
        scene.objects.active = ob

    def modal(self, context, event):
        if event.type == 'RIGHTMOUSE':
            self.execute(context)
            return {'FINISHED'}
        return {'PASS_THROUGH'}

    def invoke(self, context, event):
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

class UpdatePreviewKey(Operator):
    '''Operator update preview keymap'''
    bl_idname = "wm.updatepreviewkey"
    bl_label = "Activate RMB"
    @classmethod
    def poll(cls, context):
        conf = context.window_manager.keyconfigs.active
        mapstr = "Node Editor"
        map = conf.keymaps[mapstr]
        try:
            map.keymap_items["node.updatepreview"]
            return False
        except:
            return True

    def execute(self, context):
        conf = context.window_manager.keyconfigs.active
        mapstr = "Node Editor"
        map = conf.keymaps[mapstr]
        map.keymap_items.new("node.updatepreview",type='RIGHTMOUSE',value="PRESS")
        return {'FINISHED'}

classes = (
    ObjectNodeTree,
    PovrayOutputNode,
    PovrayTextureNode,
    PovrayFinishNode,
    PovrayDiffuseNode,
    PovrayPhongNode,
    PovraySpecularNode,
    PovrayMirrorNode,
    PovrayAmbientNode,
    PovrayIridescenceNode,
    PovraySubsurfaceNode,
    PovrayMappingNode,
    PovrayMultiplyNode,
    PovrayTransformNode,
    PovrayValueNode,
    PovrayModifierNode,
    PovrayPigmentNode,
    PovrayColorImageNode,
    PovrayBumpMapNode,
    PovrayImagePatternNode,
    ShaderPatternNode,
    ShaderTextureMapNode,
    ShaderNormalMapNode,
    ShaderNormalMapEntryNode,
    IsoPropsNode,
    PovrayFogNode,
    PovraySlopeNode,
    TextureOutputNode,
    NODE_OT_iso_add,
    NODE_OT_map_create,
    NODE_OT_povray_node_texture_map_add,
    NODE_OT_povray_node_output_add,
    NODE_OT_povray_node_layered_add,
    NODE_OT_povray_input_add,
    NODE_OT_povray_input_remove,
    NODE_OT_povray_image_open,
    PovrayPatternNode,
    UpdatePreviewMaterial,
    UpdatePreviewKey,
)


def register():
    #from bpy.utils import register_class

    for cls in classes:
        register_class(cls)


def unregister():
    from bpy.utils import unregister_class

    for cls in classes:
        unregister_class(cls)