live_lattice_operator.py

bl_info = {
    "name": "New Lattice Object",
    "author": "Dealga McArdle",
    "version": (1, 0),
    "blender": (2, 76, 0),
    "location": "View3D > Add > Mesh > New Lattice Object",
    "description": "Adds a new Lattice Object",
    "category": "Add Mesh",
    }


import bpy
from bpy.types import Operator
from bpy.props import FloatVectorProperty, FloatProperty, IntProperty
from bpy_extras.object_utils import AddObjectHelper, object_data_add
from mathutils import Vector


import bmesh

def sv_main(self):
    
    grid_x = self.grid_x
    grid_y = self.grid_y
    grid_z = self.grid_z
    div_x = self.div_x
    div_y = self.div_y
    div_z = self.div_z
    grid_scale = self.grid_scale
    
    verts_out = []
    edges_out = []

    grid_x = abs(grid_x)
    grid_y = abs(grid_y)
    grid_z = abs(grid_z)

    div_x = max(2, div_x)
    div_y = max(2, div_y)
    div_z = max(2, div_z)

    start_x = -grid_x / 2
    start_y = -grid_y / 2
    start_z = -grid_z / 2

    seg_x = grid_x / (div_x - 1)
    seg_y = grid_y / (div_y - 1)
    seg_z = grid_z / (div_z - 1)

    for i in range(div_z):
        for j in range(div_x):
            for k in range(div_y):
                x = start_x + (seg_x * j)
                y = start_y + (seg_y * k)
                z = start_z + (seg_z * i)
                verts_out.append([x, y, z])

    if verts_out:
        xy = (div_x) * (div_y)
        limit = (xy * (div_z)) - xy
        x_limit = xy * div_z

        ''' make z axis '''
        for e in range(limit):
            edges_out.append([e, e+xy])

        ''' make x axis '''
        m = [((div_x * div_y) - div_y) + i for i in range(0, div_x*div_y*div_z, div_x*div_y)]
        x_excluder = []
        for i in m:
            x_excluder.extend(list(range(i, i+div_y, 1)))

        for e in range(x_limit):
            if not e in x_excluder:
                edges_out.append([e, e+div_y])

        ''' make y axis '''
        last_y = (xy * div_z) - 1
        y_excluder = set(range(div_y-1, last_y, div_y))
        for j in range(last_y):
            if not j in y_excluder:
                edges_out.append([j, j+1])

    return verts_out, edges_out



def add_object(self, context):

    verts, edges = sv_main(self)

    mesh = bpy.data.meshes.new(name='base_grid_mesh')
    mesh.from_pydata(verts, edges, [])

    object_data_add(context, mesh, operator=self)
    obj = context.active_object
    
    objects = bpy.data.objects
    meshes = bpy.data.meshes

    # if obj and mesh:
    #     grid_scale = self.grid_scale
    #     obj.modifiers.new('skin', 'SKIN')
    #     num_verts = len(obj.data.vertices)
    #     flat_list = list((grid_scale,) * (2 * num_verts))

    #     grid_scale = max(0.001, grid_scale)
    #     grid_scale = min(0.5, grid_scale)
    #     mesh.skin_vertices[0].data.foreach_set("radius", flat_list)
    #     mesh.update()



class OBJECT_OT_add_object(Operator, AddObjectHelper):
    """Create a new Lattice Object"""
    bl_idname = "mesh.add_lattice_object"
    bl_label = "Add Lattice Mesh Object"
    bl_options = {'REGISTER', 'UNDO'}

    # grid_x=3.0, grid_y=4.0, grid_z=5.0, div_x=4, div_y=6, div_z=2, grid_scale=0.1
    grid_x = FloatProperty(default=3.0, min=0.01)
    grid_y = FloatProperty(default=4.0, min=0.01)
    grid_z = FloatProperty(default=5.0, min=0.01)
    div_x = IntProperty(default=3, min=2)
    div_y = IntProperty(default=4, min=2)
    div_z = IntProperty(default=5, min=2)
    grid_scale = FloatProperty(default=0.01, min=0.001)

    def execute(self, context):
        add_object(self, context)
        return {'FINISHED'}


# Registration

def add_object_button(self, context):
    self.layout.operator(
        OBJECT_OT_add_object.bl_idname,
        text="Add Lattice Object",
        icon='PLUGIN')


def register():
    bpy.utils.register_class(OBJECT_OT_add_object)
    bpy.types.INFO_MT_mesh_add.append(add_object_button)


def unregister():
    bpy.utils.unregister_class(OBJECT_OT_add_object)
    bpy.types.INFO_MT_mesh_add.remove(add_object_button)


if __name__ == "__main__":
    register()