mesh_easy_lattice.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19
  20 bl_info = {
  21             "name": " Easy Lattice",
  22             "author": "Kursad Karatas / Mechanical Mustache Labs",
  23             "version": ( 1, 0, 1 ),
  24             "blender": ( 2, 80,0 ),
  25             "location": "View3D > EZ Lattice",
  26             "description": "Create a lattice for shape editing",
  27             "warning": "",
  28             "doc_url": "",
  29             "tracker_url": "",
  30             "category": "Mesh"}
  31
  32 import bpy
  33 import copy
  34
  35 import bmesh
  36 from bpy.app.handlers import persistent
  37 from bpy.props import (EnumProperty, FloatProperty, FloatVectorProperty,
  38                        IntProperty, StringProperty, BoolProperty)
  39 from bpy.types import Operator
  40 from bpy_extras.object_utils import AddObjectHelper, object_data_add
  41 from mathutils import Matrix, Vector
  42 import mathutils
  43 import numpy as np
  44
  45
  46 LAT_TYPES= ( ( 'KEY_LINEAR', 'KEY_LINEAR', '' ), ( 'KEY_CARDINAL', 'KEY_CARDINAL', '' ), ( 'KEY_BSPLINE', 'KEY_BSPLINE', '' ) )
  47
  48 OP_TYPES= ( ( 'NEW', 'NEW', '' ), ( 'APPLY', 'APPLY', '' ), ( 'CLEAR', 'CLEAR', '' ) )
  49
  50 def defineSceneProps():
  51     bpy.types.Scene.ezlattice_object = StringProperty(name="Object2Operate",
  52                                         description="Object to be operated on",
  53                                         default="")
  54
  55     bpy.types.Scene.ezlattice_objects = StringProperty(name="Objects2Operate",
  56                                         description="Objects to be operated on",
  57                                         default="")
  58
  59     bpy.types.Scene.ezlattice_mode = StringProperty(name="CurrentMode",
  60                                         default="")
  61
  62     bpy.types.Scene.ezlattice_lattice = StringProperty(name="LatticeObName",
  63                                         default="")
  64
  65     bpy.types.Scene.ezlattice_flag = BoolProperty(name="LatticeFlag", default=False)
  66
  67 def defineObjectProps():
  68
  69     bpy.types.Object.ezlattice_flag = BoolProperty(name="LatticeFlag", default=False)
  70
  71     bpy.types.Object.ezlattice_controller = StringProperty(name="LatticeController", default="")
  72
  73     bpy.types.Object.ezlattice_modifier = StringProperty(name="latticeModifier", default="")
  74
  75 def objectMode():
  76
  77     if isEditMode():
  78         bpy.ops.object.mode_set(mode="OBJECT")
  79
  80     else:
  81         return True
  82
  83     return
  84
  85 def isEditMode():
  86     """Check to see we are in edit  mode
  87     """
  88
  89     try:
  90         if bpy.context.object.mode == "EDIT":
  91             return True
  92
  93         else:
  94             return False
  95
  96     except:
  97         print("No active mesh object")
  98
  99
 100
 101 def isObjectMode():
 102
 103     if bpy.context.object.mode == "OBJECT":
 104         return True
 105
 106     else:
 107         return False
 108
 109
 110 def setMode(mode=None):
 111
 112     if mode:
 113         bpy.ops.object.mode_set(mode=mode)
 114
 115 def curMode():
 116
 117     return bpy.context.object.mode
 118
 119 def editMode():
 120
 121     if not isEditMode():
 122         bpy.ops.object.mode_set(mode="EDIT")
 123
 124     else:
 125         return True
 126
 127     return
 128
 129
 130 def setSelectActiveObject(context, obj):
 131
 132     if context.mode == 'OBJECT':
 133
 134         bpy.ops.object.select_all(action='DESELECT')
 135         context.view_layer.objects.active = obj
 136         obj.select_set(True)
 137
 138
 139 def getObject(name=None):
 140     try:
 141         ob=[o for o in bpy.data.objects if o.name == name][0]
 142         return ob
 143
 144     except:
 145         return None
 146
 147
 148
 149 def buildTrnScl_WorldMat( obj ):
 150     # This function builds a real world matrix that encodes translation and scale and it leaves out the rotation matrix
 151     # The rotation is applied at obejct level if there is any
 152     loc,rot,scl=obj.matrix_world.decompose()
 153     mat_trans = mathutils.Matrix.Translation( loc)
 154
 155     mat_scale = mathutils.Matrix.Scale( scl[0], 4, ( 1, 0, 0 ) )
 156     mat_scale @= mathutils.Matrix.Scale( scl[1], 4, ( 0, 1, 0 ) )
 157     mat_scale @= mathutils.Matrix.Scale( scl[2], 4, ( 0, 0, 1 ) )
 158
 159     mat_final = mat_trans @ mat_scale
 160
 161     return mat_final
 162
 163 def getSelectedVerts(context):
 164     """
 165     https://devtalk.blender.org/t/foreach-get-for-selected-vertex-indices/7712/6
 166
 167     v_sel = np.empty(len(me.vertices), dtype=bool)
 168     me.vertices.foreach_get('select', v_sel)
 169
 170     sel_idx, = np.where(v_sel)
 171     unsel_idx, = np.where(np.invert(v_sel))
 172
 173     """
 174
 175     obj = context.active_object
 176     m=obj.matrix_world
 177
 178     count=len(obj.data.vertices)
 179     shape = (count, 3)
 180
 181
 182     if obj.type=='MESH':
 183         me = obj.data
 184         bm = bmesh.from_edit_mesh(me)
 185
 186         verts=[m@v.co for v in bm.verts if v.select]
 187
 188     return np.array(verts, dtype=np.float32)
 189
 190
 191 def getSelectedVertsNumPy(context):
 192     obj = context.active_object
 193
 194     if obj.type=='MESH':
 195
 196         obj.update_from_editmode()
 197
 198         #BMESH
 199         me = obj.data
 200         bm = bmesh.from_edit_mesh(me)
 201
 202         verts_selected=np.array([v.select for v in bm.verts])
 203
 204         count=len(obj.data.vertices)
 205         shape = (count, 3)
 206
 207         co = np.empty(count*3, dtype=np.float32)
 208
 209         obj.data.vertices.foreach_get("co",co)
 210
 211
 212         co.shape=shape
 213
 214         return co[verts_selected]
 215
 216
 217 def findSelectedVertsBBoxNumPy(context):
 218
 219
 220     verts=getSelectedVerts(context)
 221
 222     x_min = verts[:,0].min()
 223     y_min = verts[:,1].min()
 224     z_min = verts[:,2].min()
 225
 226     x_max = verts[:,0].max()
 227     y_max = verts[:,1].max()
 228     z_max = verts[:,2].max()
 229
 230
 231     x_avg = verts[:,0].mean()
 232     y_avg = verts[:,1].mean()
 233     z_avg = verts[:,2].mean()
 234
 235     middle=Vector( ( (x_min+x_max)/2,
 236                     (y_min+y_max)/2,
 237                     (z_min+z_max)/2 )
 238                 )
 239
 240     bbox= [ np.array([x_max,y_max,z_max], dtype=np.float32),
 241             np.array([x_min, y_min, z_min],  dtype=np.float32),
 242             np.array([x_avg, y_avg, z_avg],  dtype=np.float32),
 243             np.array(middle)
 244             ]
 245
 246     return bbox
 247
 248
 249 def addSelected2VertGrp():
 250
 251     C=bpy.context
 252
 253     grp=C.active_object.vertex_groups.new(name=".templatticegrp")
 254     bpy.ops.object.vertex_group_assign()
 255     bpy.ops.object.vertex_group_set_active( group = grp.name )
 256
 257 def removetempVertGrp():
 258
 259     C=bpy.context
 260
 261     grp=[g for g in C.active_object.vertex_groups if ".templatticegrp" in g.name]
 262
 263     if grp:
 264         for g in grp:
 265             bpy.context.object.vertex_groups.active_index = g.index
 266             bpy.ops.object.vertex_group_remove(all=False, all_unlocked=False)
 267
 268
 269 def cleanupLatticeObjects(context):
 270
 271     cur_obj=context.active_object
 272
 273     try:
 274         lats=[l for l in bpy.data.objects if ".latticetemp" in l.name]
 275
 276         if lats:
 277             for l in lats:
 278                 setSelectActiveObject(context, l)
 279                 bpy.data.objects.remove(l)
 280
 281                 bpy.ops.ed.undo_push()
 282
 283         setSelectActiveObject(context, cur_obj)
 284
 285     except:
 286         print("no cleanup")
 287
 288
 289
 290
 291 def cleanupLatticeModifier(context):
 292
 293     scn=context.scene
 294
 295     obj_operated_name=scn.ezlattice_object
 296     obj_operated=getObject(obj_operated_name)
 297
 298     curmode=curMode()
 299
 300     temp_mod=None
 301
 302     obj=None
 303
 304     if obj_operated:
 305
 306         if context.active_object.type=='LATTICE':
 307             setMode('OBJECT')
 308             setSelectActiveObject(context, obj_operated )
 309
 310
 311         temp_mod=[m for m in obj_operated.modifiers if ".LatticeModTemp" in m.name]
 312
 313         obj=obj_operated
 314
 315     else:
 316         temp_mod=[m for m in context.object.modifiers if ".LatticeModTemp" in m.name]
 317         obj=context.object
 318
 319     if temp_mod:
 320         for m in temp_mod:
 321             bpy.ops.object.modifier_remove(modifier=m.name)
 322
 323         setMode(curmode)
 324
 325         return True
 326
 327     return False
 328
 329 def cleanupApplyPre(context):
 330
 331     scn=context.scene
 332
 333     obj_operated_name=scn.ezlattice_object
 334
 335     obj_operated=getObject(obj_operated_name)
 336
 337     cur_mode=curMode()
 338
 339
 340     if obj_operated:
 341
 342         if context.active_object.type=='LATTICE':
 343             setMode('OBJECT')
 344             setSelectActiveObject(context, obj_operated )
 345
 346
 347         temp_mod=[m for m in obj_operated.modifiers if ".LatticeModTemp" in m.name]
 348
 349
 350         lats=[l for l in bpy.data.objects if ".latticetemp" in l.name]
 351
 352         cur_obj=context.active_object
 353
 354         curmode=curMode()
 355
 356
 357         if isEditMode():
 358             objectMode()
 359
 360         if temp_mod:
 361             for m in temp_mod:
 362                 if m.object:
 363                     bpy.ops.object.modifier_apply(modifier=m.name)
 364
 365                 else:
 366                     bpy.ops.object.modifier_remove(modifier=m.name)
 367
 368         if lats:
 369             for l in lats:
 370
 371                 bpy.data.objects.remove(l)
 372
 373                 bpy.ops.ed.undo_push()
 374
 375         setSelectActiveObject(context, cur_obj)
 376
 377         setMode(curmode)
 378         bpy.ops.object.mode_set(mode=curmode)
 379
 380
 381
 382 def createLatticeObject(context, loc=Vector((0,0,0)), scale=Vector((1,1,1)),
 383                         name=".latticetemp", divisions=[], interp="KEY_BSPLINE"):
 384
 385     C=bpy.context
 386     lat_name=name+"_"+C.object.name
 387
 388     lat = bpy.data.lattices.new( lat_name )
 389     ob = bpy.data.objects.new( lat_name, lat )
 390     ob.data.use_outside=True
 391     ob.data.points_u=divisions[0]
 392     ob.data.points_v=divisions[1]
 393     ob.data.points_w=divisions[2]
 394
 395     ob.data.interpolation_type_u = interp
 396     ob.data.interpolation_type_v = interp
 397     ob.data.interpolation_type_w = interp
 398
 399     scene = context.scene
 400     scene.collection.objects.link(ob)
 401     ob.location=loc
 402     ob.scale = scale
 403
 404     return ob
 405
 406
 407 def applyLatticeModifier():
 408
 409     try:
 410         temp_mod=[m for m in bpy.context.object.modifiers if ".LatticeModTemp" in m.name]
 411
 412         if temp_mod:
 413             for m in temp_mod:
 414                 bpy.ops.object.modifier_apply(modifier=m.name)
 415
 416     except:
 417         print("no modifiers")
 418
 419
 420 def addLatticeModifier(context, lat,vrtgrp=""):
 421
 422     bpy.ops.object.modifier_add(type='LATTICE')
 423
 424     bpy.context.object.modifiers['Lattice'].name=".LatticeModTemp"
 425
 426     bpy.context.object.modifiers[".LatticeModTemp"].object=lat
 427     bpy.context.object.modifiers[".LatticeModTemp"].vertex_group=vrtgrp
 428
 429     bpy.context.object.modifiers[".LatticeModTemp"].show_in_editmode = True
 430     bpy.context.object.modifiers[".LatticeModTemp"].show_on_cage = True
 431
 432
 433
 434 def newLatticeOp(obj, context,self):
 435
 436     scn=context.scene
 437
 438
 439     if scn.ezlattice_flag:
 440
 441         applyLatticeOp(obj, context)
 442
 443         scn.ezlattice_flag=False
 444         scn.ezlattice_mode=""
 445
 446         return
 447
 448     cur_obj=obj
 449     scn.ezlattice_object=cur_obj.name
 450
 451     scn.ezlattice_mode=curMode()
 452
 453     cleanupApplyPre(context)
 454
 455     removetempVertGrp()
 456
 457     addSelected2VertGrp()
 458
 459     bbox=findSelectedVertsBBoxNumPy(context)
 460     scale=bbox[0]-bbox[1]
 461
 462     loc_crs=Vector((bbox[3][0],bbox[3][1],bbox[3][2]))
 463
 464     lat=createLatticeObject(context, loc=loc_crs, scale=scale,
 465                             divisions=[self.lat_u,self.lat_w,self.lat_m],
 466                             interp=self.lat_type )
 467
 468     scn.ezlattice_lattice=lat.name
 469
 470
 471     setSelectActiveObject(context, cur_obj)
 472
 473     addLatticeModifier(context, lat=lat, vrtgrp=".templatticegrp")
 474
 475     objectMode()
 476     setSelectActiveObject(context, lat)
 477
 478     editMode()
 479
 480     scn.ezlattice_flag=True
 481
 482
 483
 484
 485     return
 486
 487 def resetHelperAttrbs(context):
 488
 489     scn=context.scene
 490
 491     scn.ezlattice_mode=""
 492     scn.ezlattice_object=""
 493     scn.ezlattice_objects=""
 494     scn.ezlattice_lattice=""
 495
 496
 497 def applyLatticeOp(obj, context):
 498
 499     scn=context.scene
 500
 501     if scn.ezlattice_mode=="EDIT":
 502
 503
 504         obj_operated_name=scn.ezlattice_object
 505
 506         obj_operated=getObject(obj_operated_name)
 507
 508         cur_mode=curMode()
 509
 510         if obj_operated:
 511
 512             if context.active_object.type=='LATTICE':
 513                 setMode('OBJECT')
 514                 setSelectActiveObject(context, obj_operated )
 515
 516             temp_mod=[m for m in obj_operated.modifiers if ".LatticeModTemp" in m.name]
 517
 518
 519             lats=[l for l in bpy.data.objects if ".latticetemp" in l.name]
 520
 521             cur_obj=context.active_object
 522
 523             curmode=curMode()
 524
 525
 526             if isEditMode():
 527                 objectMode()
 528
 529             if temp_mod:
 530                 for m in temp_mod:
 531                     if m.object:
 532                         bpy.ops.object.modifier_apply(modifier=m.name)
 533
 534                     else:
 535                         bpy.ops.object.modifier_remove(modifier=m.name)
 536
 537             if lats:
 538                 for l in lats:
 539
 540                     bpy.data.objects.remove(l)
 541
 542                     bpy.ops.ed.undo_push()
 543
 544             setSelectActiveObject(context, cur_obj)
 545
 546             setMode(curmode)
 547             bpy.ops.object.mode_set(mode=curmode)
 548
 549
 550         removetempVertGrp()
 551
 552
 553     resetHelperAttrbs(context)
 554
 555     return
 556
 557 def clearLatticeOps(obj, context):
 558
 559     scn=context.scene
 560
 561     if scn.ezlattice_mode=="EDIT":
 562         cleanupLatticeModifier(context)
 563
 564
 565
 566     cleanupLatticeObjects(context)
 567
 568     resetHelperAttrbs(context)
 569     return
 570
 571
 572 def objectCheck(context):
 573
 574     if not [bool(o) for  o in context.selected_objects if o.type!="MESH"]:
 575         return True
 576
 577     else:
 578         return False
 579
 580
 581 class OBJECT_MT_EZLatticeOperator(bpy.types.Menu):
 582     bl_label = "Easy Lattice Menu"
 583     bl_idname = "LAT_MT_ezlattice"
 584
 585     def draw(self, context):
 586
 587         scn=context.scene
 588         layout = self.layout
 589
 590         layout.operator_context = 'INVOKE_REGION_WIN'
 591
 592         if scn.ezlattice_flag:
 593             op="Apply"
 594             layout.operator("object.ezlattice_new", text=op)
 595
 596         else:
 597             op="New"
 598             layout.operator("object.ezlattice_new", text=op)
 599
 600
 601
 602 class OBJECT_OT_EZLatticeCall(Operator):
 603     """UV Operator description"""
 604     bl_idname = "object.ezlatticecall"
 605     bl_label = "Easy Lattice"
 606     bl_options = {'REGISTER', 'UNDO'}
 607
 608
 609     @classmethod
 610     def poll(cls, context):
 611         return bool(context.active_object)
 612
 613     def execute(self, context):
 614         return {'FINISHED'}
 615
 616 class OBJECT_OT_EZLatticeOperatorNew(Operator):
 617
 618     """Tooltip"""
 619     bl_idname = "object.ezlattice_new"
 620     bl_label = "Easy Lattice Creator"
 621     bl_space_type = "VIEW_3D"
 622     bl_region_type = "TOOLS"
 623
 624     operation: StringProperty(options={'HIDDEN'})
 625     isnew: BoolProperty(default=False, options={'HIDDEN'})
 626     isobjectmode: BoolProperty(default=False, options={'HIDDEN'})
 627
 628     op_type: EnumProperty( name = "Operation Type", items = OP_TYPES)
 629
 630     lat_u: IntProperty( name = "Lattice u", default = 3 )
 631     lat_w: IntProperty( name = "Lattice w", default = 3 )
 632     lat_m: IntProperty( name = "Lattice m", default = 3 )
 633
 634
 635     lat_type: EnumProperty( name = "Lattice Type", items = LAT_TYPES)
 636
 637     @classmethod
 638     def poll(cls, context):
 639         return (context.mode == 'EDIT_MESH') or (context.mode == 'EDIT_LATTICE') or (context.object.type=='LATTICE')
 640
 641     def execute(self, context):
 642
 643         cur_obj=context.active_object
 644         objs=context.selected_objects
 645         scn=context.scene
 646
 647         if self.isnew and isEditMode():
 648
 649             self.isobjectmode=False
 650             scn.ezlattice_objects=""
 651             scn.ezlattice_mode="EDIT"
 652
 653             newLatticeOp(cur_obj,context,self)
 654             self.isnew=False
 655
 656         else:
 657             newLatticeOp(cur_obj,context,self)
 658
 659         return {'FINISHED'}
 660
 661     def invoke( self, context, event ):
 662         wm = context.window_manager
 663
 664         cur_obj=context.active_object
 665
 666         objs=context.selected_objects
 667
 668         scn=context.scene
 669
 670         if isEditMode() and cur_obj.type=='MESH':
 671
 672             self.isnew=True
 673             if not scn.ezlattice_flag:
 674                 return wm.invoke_props_dialog( self )
 675
 676         else:
 677             newLatticeOp(cur_obj,context,self)
 678
 679         return {'FINISHED'}
 680
 681
 682 def menu_draw(self, context):
 683     self.layout.separator()
 684     self.layout.operator_context = 'INVOKE_REGION_WIN'
 685
 686     self.layout.menu(OBJECT_MT_EZLatticeOperator.bl_idname)
 687
 688
 689 def draw_item(self, context):
 690     layout = self.layout
 691     layout.menu(OBJECT_MT_EZLatticeOperator.bl_idname)
 692
 693 classes = (
 694     OBJECT_OT_EZLatticeOperatorNew,
 695     OBJECT_MT_EZLatticeOperator,
 696 )
 697
 698
 699 @persistent
 700 def resetProps(dummy):
 701
 702     context=bpy.context
 703
 704     resetHelperAttrbs(context)
 705
 706     return
 707
 708 def register():
 709
 710     defineSceneProps()
 711
 712     bpy.app.handlers.load_post.append(resetProps)
 713
 714     for cls in classes:
 715         bpy.utils.register_class(cls)
 716
 717     bpy.types.VIEW3D_MT_edit_mesh_context_menu.prepend(menu_draw)
 718
 719     bpy.types.VIEW3D_MT_edit_lattice.prepend(menu_draw)
 720     bpy.types.VIEW3D_MT_edit_lattice_context_menu.prepend(menu_draw)
 721
 722
 723 def unregister():
 724
 725
 726     for cls in classes:
 727         bpy.utils.unregister_class(cls)
 728
 729     bpy.types.VIEW3D_MT_edit_mesh_context_menu.remove(menu_draw)
 730
 731     bpy.types.VIEW3D_MT_edit_lattice.remove(menu_draw)
 732     bpy.types.VIEW3D_MT_edit_lattice_context_menu.remove(menu_draw)
 733
 734 if __name__ == "__main__":
 735     register()