test

node_Lathe.py

import bpy
import bmesh
import mathutils
from mathutils import Vector, Matrix
from bpy.props import BoolProperty, FloatProperty, FloatVectorProperty

from node_s import *
from util import *

import sv_bmesh_utils
from sv_bmesh_utils import bmesh_from_pydata


def get_lathed_geometry(node, verts, edges, cent, axis, dvec, space, angle, steps):

    steps = max(steps, 0)
    bm = bmesh_from_pydata(verts, edges, [])
    geom = bm.verts[:] + bm.edges[:]

    bmesh.ops.spin(bm,
                   geom=geom, cent=cent, axis=axis, dvec=dvec, angle=angle,
                   space=space, steps=steps, use_duplicate=use_duplicate)

    if node.remove_doubles:
        bmesh.ops.remove_doubles(bm, verts=bm.verts[:], dist=node.dist)

    v = [v.co[:] for v in bm.verts]
    p = [[i.index for i in p.verts] for p in bm.faces[:]]
    bm.free()
    return v, p


class SvLatheNode(Node, SverchCustomTreeNode):

    bl_idname = 'SvLatheNode'
    bl_label = 'Sv Lathe Node'
    bl_icon = 'OUTLINER_OB_EMPTY'

    remove_doubles = BoolProperty(
        name='merge', description='Remove doubles, merge',
        default=False,
        update=updateNode)

    dist = FloatProperty(name="merge distance", default=0.0001, update=updateNode)
    angle = FloatProperty(name="angle", default=1.0, update=updateNode)
    steps = IntProperty(name="steps", default=20, update=updateNode)
    cent = FloatVectorProperty(name='cent', subtype='XYZ', size=3, update=updateNode)
    dvec = FloatVectorProperty(name='dvec', subtype='XYZ', size=3, update=updateNode)
    axis = FloatVectorProperty(
        name='axis', subtype='XYZ', size=3, update=updateNode, default=(0, 0, 1))

    def init(self, context):

        # so many inputs!!
        self.inputs.new('VerticesSocket', 'Verts', 'Verts')
        self.inputs.new('StringsSocket', 'Edges', 'Edges')
        self.inputs.new('MatrixSocket', 'Matrix', 'Matrix')

        # these have default props
        self.inputs.new('VerticesSocket', 'cent', 'cent').prop_name = 'cent'
        self.inputs.new('VerticesSocket', 'axis', 'axis').prop_name = 'axis'
        self.inputs.new('VerticesSocket', 'dvec', 'dvecs').prop_name = 'dvec'
        self.inputs.new('StringsSocket', 'Angle', 'Angle').prop_name = 'angle'
        self.inputs.new('StringsSocket', 'Steps', 'Steps').prop_name = 'steps'

        # outputs, sparse!
        self.outputs.new('VerticesSocket', 'Verts', 'Verts')
        self.outputs.new('StringsSocket', 'Poly', 'Poly')

    def draw_buttons(self, context, layout):
        row = layout.row(align=True)
        split = row.split()
        col1 = split.column()
        col1.prop(self, "remove_doubles", text="merge")

    def get_corrected_data(self, socket_name, socket_type):
        inputs = self.inputs
        socket = inputs[socket_name].links[0].from_socket
        if isinstance(socket, socket_type):
            socket_in = SvGetSocketAnyType(self, inputs[socket_name])
            return dataCorrect(socket_in)
        else:
            return []

    def get_geometry_from_sockets(self):
        inputs = self.inputs
        mverts, medges, mmatrix = [], [], []

        mverts = self.get_corrected_data('vertices', VerticesSocket)

        # could be looped, yielded..
        if 'matrix' in inputs and inputs['matrix'].links:
            mmatrix = self.get_corrected_data('matrix', MatrixSocket)

        if 'edges' in inputs and inputs['edges'].links:
            medges = self.get_corrected_data('edges', StringsSocket)

        if 'faces' in inputs and inputs['faces'].links:
            mfaces = self.get_corrected_data('faces', StringsSocket)

        return mverts, medges, mmatrix

    def get_structure(self, stype, sindex):
        if not stype:
            return []

        try:
            j = stype[sindex]
        except IndexError:
            j = []
        finally:
            return j

    def update(self):

        if ('vertices' in self.inputs):
            if not self.inputs['vertices'].links:
                return
        else:
            return
        
        mverts, *mrest = self.get_geometry_from_sockets()

        def get_edges_faces_matrices(obj_index):
            for geom in mrest:
                yield self.get_structure(geom, obj_index)

        # # matrices need to define count of objects. paradigma
        # maxlen = max(len(mverts), len(mrest[0]), len(mrest[1]), len(mrest[2]))
        # fullList(mverts, maxlen)
        # if mrest[0]:
        #     fullList(mrest[0], maxlen)
        # if mrest[1]:
        #     fullList(mrest[1], maxlen)
        # if mrest[2]:
        #     fullList(mrest[2], maxlen)


        '''
        defaults:
            verts: (never none),
            edges: []
            cent: Vector()
            axis: Vector((0, 0, 1))
            dvec: Vector()
            space: Matrix()
            angle: 2.0
            steps: 20
        '''

        # verts_out, edges_out = [], []

        # for idx, Verts in enumerate(mverts):
        #     if not Verts:
        #         continue

        #     data = get_edges_faces_matrices(idx)
        #     Verts, *data)

        #     operator_data = verts, edges, cent, axis, dvec, space, angle, steps
        #     v, p = get_lathed_geometry(self, *operator_data):



    def update_socket(self, context):
        self.update()


def register():
    bpy.utils.register_class(SvLatheNode)


def unregister():
    bpy.utils.unregister_class(SvLatheNode)