add_mesh_extra_objects/add_mesh_beam_builder.py

   1 # GPL # "author": revolt_randy, Jambay
   2
   3 # Create "Beam" primitives. Based on original script by revolt_randy
   4
   5
   6 import bpy
   7 from bpy.types import Operator
   8 from bpy.props import (
   9         BoolProperty,
  10         EnumProperty,
  11         FloatProperty,
  12         IntProperty,
  13         StringProperty,
  14         )
  15 from bpy_extras import object_utils
  16
  17 # #####################
  18 # Create vertices for end of mesh
  19 #
  20 # y_off - verts y-axis origin
  21 #
  22 # returns:
  23 #  endVs - x,y,z list
  24
  25 def beamEndVs(sRef, y_off):
  26     thick = sRef.beamW * 2
  27
  28     if sRef.Type == '2':  # swap width and height for C shape
  29         bEndX2 = sRef.beamZ / 2
  30         bEndXInr = ((sRef.beamZ - thick) / 2)
  31         bEndZ2 = sRef.beamX / 2
  32         bEndZInr = ((sRef.beamX - thick) / 2)
  33     else:
  34         bEndX2 = sRef.beamX / 2
  35         bEndXInr = ((sRef.beamX - thick) / 2)
  36         bEndZ2 = sRef.beamZ / 2
  37         bEndZInr = ((sRef.beamZ - thick) / 2)
  38
  39     endVs = []
  40
  41     # outer ...
  42     endVs.append((bEndX2, y_off, bEndZ2))
  43     endVs.append((-bEndX2, y_off, bEndZ2))
  44     endVs.append((-bEndX2, y_off, -bEndZ2))
  45     endVs.append((bEndX2, y_off, -bEndZ2))
  46     # innner ...
  47     endVs.append((bEndXInr, y_off, bEndZInr))
  48     endVs.append((-bEndXInr, y_off, bEndZInr))
  49     endVs.append((-bEndXInr, y_off, -bEndZInr))
  50     endVs.append((bEndXInr, y_off, -bEndZInr))
  51
  52     return endVs
  53
  54
  55 # #####################
  56 # Create End Faces
  57 #
  58 # verts_list - list of vertices
  59 #
  60 # returns:
  61 #  beamFs, a list of tuples defining the end faces.
  62
  63 def beamEndFaces(verts_list):
  64
  65     beamFs = []
  66
  67     num_of_verts = int(len(verts_list) / 2)
  68
  69     # Create list of faces
  70     for index in range(num_of_verts):
  71         faces_temp = []
  72
  73         if index == (num_of_verts - 1):
  74             faces_temp.append(verts_list[index])
  75             faces_temp.append(verts_list[index - index])
  76             faces_temp.append(verts_list[index + 1])
  77             faces_temp.append(verts_list[index * 2 + 1])
  78         else:
  79             faces_temp.append(verts_list[index])
  80             faces_temp.append(verts_list[index + 1])
  81             faces_temp.append(verts_list[index + num_of_verts + 1])
  82             faces_temp.append(verts_list[index + num_of_verts])
  83
  84         beamFs.append(tuple(faces_temp))
  85
  86     return beamFs
  87
  88
  89 # #####################
  90 # Bridge vertices to create side faces.
  91 #
  92 # front_verts - front face vertices
  93 # back_verts - back face vertices
  94 #  front & back must be ordered in same direction
  95 #  with respect to y-axis
  96 #
  97 # returns:
  98 #  sideFaces, a list of the bridged faces
  99
 100 def beamSides(front_verts, back_verts):
 101     sideFaces = []
 102
 103     num_of_faces = (len(front_verts))
 104
 105     # add first value to end of lists for looping
 106     front_verts.append(front_verts[0])
 107     back_verts.append(back_verts[0])
 108
 109     # Build the faces
 110     for index in range(num_of_faces):
 111         facestemp = (front_verts[index], front_verts[index + 1], back_verts[index + 1], back_verts[index])
 112         sideFaces.append(facestemp)
 113
 114     return sideFaces
 115
 116
 117 # #####################
 118 # Creates a box beam
 119 #
 120 # returns:
 121 #  beamVs - x, y, z, location of each vertice
 122 #  beamFs - vertices that make up each face
 123
 124 def create_beam(sRef):
 125
 126     frontVs = []
 127     frontFs = []
 128     backVs = []
 129
 130     y_off = sRef.beamY / 2  # offset from center for vertices
 131
 132     frontVs = beamEndVs(sRef, y_off)
 133     backVs = beamEndVs(sRef, -y_off)
 134
 135     # Combine vertices
 136     beamVs = frontVs + backVs
 137
 138     # Create front face
 139     numofverts = len(frontVs)
 140     verts_front_list = []
 141     for index in range(numofverts):
 142         verts_front_list.append(index)
 143
 144     frontFs = beamEndFaces(verts_front_list)
 145
 146     # Create back face
 147     faces_back_temp = []
 148     verts_back_list = []
 149
 150     numofverts = len(backVs)
 151     for index in range(numofverts):
 152         verts_back_list.append(index + numofverts)
 153
 154     faces_back_temp = beamEndFaces(verts_back_list)
 155
 156     # Create side faces
 157     faces_side_temp = []
 158
 159     # Object has thickness, create list of outside vertices
 160     numofverts = len(verts_front_list)
 161     halfVerts = int(numofverts / 2)
 162     frontVs = verts_front_list[0:halfVerts]
 163     backVs = verts_back_list[0:halfVerts]
 164
 165     faces_side_temp = beamSides(frontVs, backVs)
 166
 167     # Create list of inside vertices
 168     frontVs = verts_front_list[halfVerts:numofverts]
 169     backVs = verts_back_list[halfVerts:numofverts]
 170
 171     faces_side_temp += beamSides(frontVs, backVs)
 172
 173     # Combine all faces
 174     beamFs = frontFs + faces_back_temp + faces_side_temp
 175
 176     return beamVs, beamFs
 177
 178
 179 # #####################
 180 # Taper/angle faces of beam.
 181 #  inner vert toward outer vert
 182 #  based on percentage of taper.
 183 #
 184 # returns:
 185 #  adVert - the calculated vertex
 186
 187 def beamSlant(sRef, outV, inV):
 188     bTaper = 100 - sRef.edgeA
 189
 190     # calculate variance & adjust vertex
 191     deltaV = ((inV - outV) / 100)
 192     adVert = outV + (deltaV * bTaper)
 193
 194     return adVert
 195
 196
 197 # #####################
 198 # Modify location to shape beam.
 199 #
 200 # verts - tuples for one end of beam
 201 #
 202 # returns:
 203 #  verts - modified tuples for beam shape.
 204
 205 def beamSquareEnds(sRef, verts):
 206
 207     # match 5th & 6th z locations to 1st & 2nd
 208
 209     vert_orig = verts[0]
 210     vert_temp = verts[4]
 211     vert_x = beamSlant(sRef, vert_orig[0], vert_temp[0])
 212     verts[4] = (vert_x, vert_temp[1], vert_orig[2])
 213
 214     vert_orig = verts[1]
 215     vert_temp = verts[5]
 216     vert_x = beamSlant(sRef, vert_orig[0], vert_temp[0])
 217     verts[5] = (vert_x, vert_temp[1], vert_orig[2])
 218
 219     return verts
 220
 221
 222 # #####################
 223 #
 224 # Create U shaped beam
 225 #  Shared with C shape - see beamEndVs
 226 #  for sizing and rotate in addBeamObj.
 227 #
 228 # returns:
 229 #  beamVs - vertice x, y, z, locations
 230 #  beamFs - face vertices
 231
 232 def create_u_beam(sRef):
 233
 234     # offset vertices from center
 235     y_off = sRef.beamY / 2
 236
 237     frontVtemp = []
 238     frontFtemp = []
 239     frontVlist = []
 240
 241     backVtemp = []
 242     backFtemp = []
 243     backVlist = []
 244
 245     sideFs = []
 246
 247     frontVtemp = beamEndVs(sRef, y_off)  # Box beam
 248     frontVtemp = beamSquareEnds(sRef, frontVtemp)  # U shape
 249
 250     backVtemp = beamEndVs(sRef, -y_off)
 251     backVtemp = beamSquareEnds(sRef, backVtemp)
 252
 253     beamVs = frontVtemp + backVtemp
 254
 255     # Create front face
 256     for index in range(len(frontVtemp)):  # Build vert list
 257         frontVlist.append(index)
 258
 259     frontFtemp = beamEndFaces(frontVlist)
 260     frontFtemp = frontFtemp[1:4]  # Remove 1st face
 261
 262     # Create back face
 263     numofverts = len(backVtemp)
 264     for index in range(numofverts):  # Build vertex list
 265         backVlist.append(index + numofverts)
 266
 267     backFtemp = beamEndFaces(backVlist)
 268     backFtemp = backFtemp[1:4]  # Remove face
 269
 270     # Create list vertices for outside faces
 271     numofverts = int(len(frontVlist))
 272     halfVerts = int(numofverts / 2)
 273     frontVtemp = frontVlist[0:halfVerts]
 274     backVtemp = backVlist[0:halfVerts]
 275
 276     sideFs = beamSides(frontVtemp, backVtemp)
 277     sideFs = sideFs[1:]  # Remove face
 278
 279     # Create inside verts
 280     frontVtemp = frontVlist[halfVerts:numofverts]
 281     backVtemp = backVlist[halfVerts:numofverts]
 282
 283     sideFs += beamSides(frontVtemp, backVtemp)
 284     sideFs = sideFs[0:3] + sideFs[4:]  # Remove face
 285
 286     # fill in faces
 287     sideFs.append((0, 4, 12, 8))
 288     sideFs.append((5, 1, 9, 13))
 289
 290     beamFs = frontFtemp + backFtemp + sideFs  # Combine faces
 291
 292     return beamVs, beamFs
 293
 294
 295 # #####################
 296 # returns:
 297 #  verts_final - x, y, z, location of each vertice
 298 #  faces_final - vertices that make up each face
 299
 300 def create_L_beam(sRef):
 301
 302     thick = sRef.beamW
 303
 304     # offset vertices from center
 305     x_off = sRef.beamX / 2
 306     y_off = sRef.beamY / 2
 307     z_off = sRef.beamZ / 2
 308
 309     # Create temporarylists to hold vertices locations
 310     verts_front_temp = []
 311     verts_back_temp = []
 312
 313     # Create front vertices by calculation
 314     verts_front_temp = [
 315             (-x_off, -y_off, z_off),
 316             (-(x_off - thick), -y_off, z_off),
 317             (-(x_off - thick), -y_off, -(z_off - thick)),
 318             (x_off, -y_off, -(z_off - thick)),
 319             (x_off, -y_off, -z_off),
 320             (-x_off, -y_off, -z_off)
 321             ]
 322
 323     # Adjust taper
 324     vert_outside = verts_front_temp[0]
 325     vert_inside = verts_front_temp[1]
 326     vert_taper = beamSlant(sRef, vert_outside[0], vert_inside[0])
 327     verts_front_temp[1] = [vert_taper, vert_inside[1], vert_inside[2]]
 328
 329     vert_outside = verts_front_temp[4]
 330     vert_inside = verts_front_temp[3]
 331     vert_taper = beamSlant(sRef, vert_outside[2], vert_inside[2])
 332     verts_front_temp[3] = [vert_inside[0], vert_inside[1], vert_taper]
 333
 334     # Create back vertices by calculation
 335     verts_back_temp = [
 336             (-x_off, y_off, z_off),
 337             (-(x_off - thick), y_off, z_off),
 338             (-(x_off - thick), y_off, -(z_off - thick)),
 339             (x_off, y_off, -(z_off - thick)),
 340             (x_off, y_off, -z_off),
 341             (-x_off, y_off, -z_off)
 342             ]
 343
 344     # Adjust taper
 345     vert_outside = verts_back_temp[0]
 346     vert_inside = verts_back_temp[1]
 347     vert_taper = beamSlant(sRef, vert_outside[0], vert_inside[0])
 348     verts_back_temp[1] = [vert_taper, vert_inside[1], vert_inside[2]]
 349
 350     vert_outside = verts_back_temp[4]
 351     vert_inside = verts_back_temp[3]
 352     vert_taper = beamSlant(sRef, vert_outside[2], vert_inside[2])
 353     verts_back_temp[3] = [vert_inside[0], vert_inside[1], vert_taper]
 354
 355     verts_final = verts_front_temp + verts_back_temp
 356
 357     # define end faces, only 4 so just coded
 358     faces_front_temp = []
 359     faces_back_temp = []
 360     faces_side_temp = []
 361
 362     faces_front_temp = [(0, 1, 2, 5), (2, 3, 4, 5)]
 363     faces_back_temp = [(6, 7, 8, 11), (8, 9, 10, 11)]
 364
 365     verts_front_list = []
 366     verts_back_list = []
 367     num_of_verts = len(verts_front_temp)
 368
 369     # build lists of back and front verts for beamSides function
 370     for index in range(num_of_verts):
 371         verts_front_list.append(index)
 372     for index in range(num_of_verts):
 373         verts_back_list.append(index + 6)
 374
 375     faces_side_temp = beamSides(verts_front_list, verts_back_list)
 376
 377     faces_final = faces_front_temp + faces_back_temp + faces_side_temp
 378
 379     return verts_final, faces_final
 380
 381
 382 # #####################
 383 # returns:
 384 #  verts_final - a list of tuples of the x, y, z, location of each vertice
 385 #  faces_final - a list of tuples of the vertices that make up each face
 386
 387 def create_T_beam(sRef):
 388
 389     thick = sRef.beamW
 390
 391     # Get offset of vertices from center
 392     x_off = sRef.beamX / 2
 393     y_off = sRef.beamY / 2
 394     z_off = sRef.beamZ / 2
 395     thick_off = thick / 2
 396
 397     # Create temporarylists to hold vertices locations
 398     verts_front_temp = []
 399     verts_back_temp = []
 400
 401     # Create front vertices
 402     verts_front_temp = [
 403             (-x_off, -y_off, z_off),
 404             (-thick_off, -y_off, z_off),
 405             (thick_off, -y_off, z_off),
 406             (x_off, -y_off, z_off),
 407             (x_off, -y_off, z_off - thick),
 408             (thick_off, -y_off, z_off - thick),
 409             (thick_off, -y_off, -z_off),
 410             (-thick_off, -y_off, -z_off),
 411             (-thick_off, -y_off, z_off - thick),
 412             (-x_off, -y_off, z_off - thick)
 413             ]
 414
 415     # Adjust taper
 416     vert_outside = verts_front_temp[0]
 417     vert_inside = verts_front_temp[9]
 418     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 419     verts_front_temp[9] = [vert_inside[0], vert_inside[1], vert_taper]
 420
 421     vert_outside = verts_front_temp[3]
 422     vert_inside = verts_front_temp[4]
 423     verts_front_temp[4] = [vert_inside[0], vert_inside[1], vert_taper]
 424
 425     # Adjust taper of bottom of beam, so 0 the center
 426     # now becomes vert_outside, and vert_inside is calculated
 427     # 1/2 way towards center
 428     vert_outside = (0, -y_off, -z_off)
 429     vert_inside = verts_front_temp[6]
 430     vert_taper = (beamSlant(sRef, vert_outside[0], vert_inside[0]))
 431     verts_front_temp[6] = [vert_taper, vert_inside[1], vert_inside[2]]
 432
 433     vert_outside = (0, -y_off, -z_off)
 434     vert_inside = verts_front_temp[7]
 435     vert_taper = beamSlant(sRef, vert_outside[0], vert_inside[0])
 436     verts_front_temp[7] = [vert_taper, vert_inside[1], vert_inside[2]]
 437
 438     # Create fack vertices by calculation
 439     verts_back_temp = [
 440             (-x_off, y_off, z_off),
 441             (-thick_off, y_off, z_off),
 442             (thick_off, y_off, z_off),
 443             (x_off, y_off, z_off),
 444             (x_off, y_off, z_off - thick),
 445             (thick_off, y_off, z_off - thick),
 446             (thick_off, y_off, -z_off),
 447             (-thick_off, y_off, -z_off),
 448             (-thick_off, y_off, z_off - thick),
 449             (-x_off, y_off, z_off - thick)
 450             ]
 451
 452     # Adjust taper
 453     vert_outside = verts_back_temp[0]
 454     vert_inside = verts_back_temp[9]
 455     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 456     verts_back_temp[9] = [vert_inside[0], vert_inside[1], vert_taper]
 457
 458     vert_outside = verts_back_temp[3]
 459     vert_inside = verts_back_temp[4]
 460     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 461     verts_back_temp[4] = [vert_inside[0], vert_inside[1], vert_taper]
 462
 463     # Adjust taper of bottom of beam, so 0 the center
 464     # now becomes vert_outside, and vert_inside is calculated
 465     # 1/2 way towards center
 466     vert_outside = (0, -y_off, -z_off)
 467     vert_inside = verts_back_temp[6]
 468     vert_taper = (beamSlant(sRef, vert_outside[0], vert_inside[0]))
 469     verts_back_temp[6] = [vert_taper, vert_inside[1], vert_inside[2]]
 470
 471     vert_outside = (0, -y_off, -z_off)
 472     vert_inside = verts_back_temp[7]
 473     vert_taper = (beamSlant(sRef, vert_outside[0], vert_inside[0]))
 474     verts_back_temp[7] = [vert_taper, vert_inside[1], vert_inside[2]]
 475
 476     verts_final = verts_front_temp + verts_back_temp
 477
 478     # define end faces, only 8 so just coded
 479     faces_front_temp = []
 480     faces_back_temp = []
 481     faces_side_temp = []
 482
 483     faces_front_temp = [(0, 1, 8, 9), (1, 2, 5, 8),
 484                         (2, 3, 4, 5), (5, 6, 7, 8)]
 485
 486     faces_back_temp = [(10, 11, 18, 19), (11, 12, 15, 18),
 487                        (12, 13, 14, 15), (15, 16, 17, 18)]
 488
 489     verts_front_list = []
 490     verts_back_list = []
 491     num_of_verts = len(verts_front_temp)
 492
 493     # build lists of back and front verts for beamSides function
 494     for index in range(num_of_verts):
 495         verts_front_list.append(index)
 496     for index in range(num_of_verts):
 497         verts_back_list.append(index + 10)
 498
 499     faces_side_temp = beamSides(verts_front_list, verts_back_list)
 500
 501     faces_final = faces_front_temp + faces_back_temp + faces_side_temp
 502
 503     return verts_final, faces_final
 504
 505
 506 # #####################
 507 # returns:
 508 #  verts_final - a list of tuples of the x, y, z, location of each vertice
 509 #  faces_final - a list of tuples of the vertices that make up each face
 510
 511 def create_I_beam(sRef):
 512
 513     thick = sRef.beamW
 514
 515     # Get offset of vertices from center
 516     x_off = sRef.beamX / 2
 517     y_off = sRef.beamY / 2
 518     z_off = sRef.beamZ / 2
 519     thick_off = thick / 2
 520
 521     # Create temporarylists to hold vertices locations
 522     verts_front_temp = []
 523     verts_back_temp = []
 524
 525     # Create front vertices by calculation
 526     verts_front_temp = [
 527             (-x_off, -y_off, z_off),
 528             (-thick_off, -y_off, z_off),
 529             (thick_off, -y_off, z_off),
 530             (x_off, -y_off, z_off),
 531             (x_off, -y_off, z_off - thick),
 532             (thick_off, -y_off, z_off - thick),
 533             (thick_off, -y_off, -z_off + thick),
 534             (x_off, -y_off, -z_off + thick),
 535             (x_off, -y_off, -z_off),
 536             (thick_off, -y_off, -z_off),
 537             (-thick_off, -y_off, -z_off),
 538             (-x_off, -y_off, -z_off),
 539             (-x_off, -y_off, -z_off + thick),
 540             (-thick_off, -y_off, -z_off + thick),
 541             (-thick_off, -y_off, z_off - thick),
 542             (-x_off, -y_off, z_off - thick)
 543             ]
 544
 545     # Adjust taper
 546     vert_outside = verts_front_temp[0]
 547     vert_inside = verts_front_temp[15]
 548     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 549     verts_front_temp[15] = [vert_inside[0], vert_inside[1], vert_taper]
 550
 551     vert_outside = verts_front_temp[3]
 552     vert_inside = verts_front_temp[4]
 553     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 554     verts_front_temp[4] = [vert_inside[0], vert_inside[1], vert_taper]
 555
 556     vert_outside = verts_front_temp[8]
 557     vert_inside = verts_front_temp[7]
 558     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 559     verts_front_temp[7] = [vert_inside[0], vert_inside[1], vert_taper]
 560
 561     vert_outside = verts_front_temp[11]
 562     vert_inside = verts_front_temp[12]
 563     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 564     verts_front_temp[12] = [vert_inside[0], vert_inside[1], vert_taper]
 565
 566     # Create back vertices by calculation
 567     verts_back_temp = [
 568             (-x_off, y_off, z_off),
 569             (-thick_off, y_off, z_off),
 570             (thick_off, y_off, z_off),
 571             (x_off, y_off, z_off),
 572             (x_off, y_off, z_off - thick),
 573             (thick_off, y_off, z_off - thick),
 574             (thick_off, y_off, -z_off + thick),
 575             (x_off, y_off, -z_off + thick),
 576             (x_off, y_off, -z_off),
 577             (thick_off, y_off, -z_off),
 578             (-thick_off, y_off, -z_off),
 579             (-x_off, y_off, -z_off),
 580             (-x_off, y_off, -z_off + thick),
 581             (-thick_off, y_off, -z_off + thick),
 582             (-thick_off, y_off, z_off - thick),
 583             (-x_off, y_off, z_off - thick)
 584             ]
 585
 586     # Adjust taper
 587     vert_outside = verts_back_temp[0]
 588     vert_inside = verts_back_temp[15]
 589     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 590     verts_back_temp[15] = [vert_inside[0], vert_inside[1], vert_taper]
 591
 592     vert_outside = verts_back_temp[3]
 593     vert_inside = verts_back_temp[4]
 594     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 595     verts_back_temp[4] = [vert_inside[0], vert_inside[1], vert_taper]
 596
 597     vert_outside = verts_back_temp[8]
 598     vert_inside = verts_back_temp[7]
 599     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 600     verts_back_temp[7] = [vert_inside[0], vert_inside[1], vert_taper]
 601
 602     vert_outside = verts_back_temp[11]
 603     vert_inside = verts_back_temp[12]
 604     vert_taper = (beamSlant(sRef, vert_outside[2], vert_inside[2]))
 605     verts_back_temp[12] = [vert_inside[0], vert_inside[1], vert_taper]
 606
 607     verts_final = verts_front_temp + verts_back_temp
 608
 609 # define end faces, only 7 per end, so just coded
 610     faces_front_temp = []
 611     faces_back_temp = []
 612     faces_side_temp = []
 613
 614     faces_front_temp = [(0, 1, 14, 15), (1, 2, 5, 14),
 615                         (2, 3, 4, 5), (6, 7, 8, 9),
 616                         (6, 9, 10, 13), (12, 13, 10, 11),
 617                         (5, 6, 13, 14)]
 618
 619     faces_back_temp = [(16, 17, 30, 31), (17, 18, 21, 30),
 620                        (18, 19, 20, 21), (22, 23, 24, 25),
 621                        (22, 25, 26, 29), (28, 29, 26, 27),
 622                        (21, 22, 29, 30)]
 623
 624     verts_front_list = []
 625     verts_back_list = []
 626     num_of_verts = len(verts_front_temp)
 627
 628     # build lists of back and front verts for beamSides function
 629     for index in range(num_of_verts):
 630         verts_front_list.append(index)
 631     for index in range(num_of_verts):
 632         verts_back_list.append(index + 16)
 633
 634     faces_side_temp = beamSides(verts_front_list, verts_back_list)
 635
 636     faces_final = faces_front_temp + faces_back_temp + faces_side_temp
 637
 638     return verts_final, faces_final
 639
 640
 641 # ######################
 642 #
 643 # Generate beam mesh.
 644
 645 def addBeamMesh(sRef, context):
 646     verts = []
 647     faces = []
 648
 649     # type of beam to add
 650     if sRef.Type == '0':
 651         verts, faces = create_beam(sRef)
 652     elif sRef.Type == '1':
 653         verts, faces = create_u_beam(sRef)
 654     elif sRef.Type == '2':
 655         verts, faces = create_u_beam(sRef)
 656     elif sRef.Type == '3':
 657         verts, faces = create_L_beam(sRef)
 658     elif sRef.Type == '4':
 659         verts, faces = create_I_beam(sRef)
 660     elif sRef.Type == '5':
 661         verts, faces = create_T_beam(sRef)
 662     else:  # unknown type, use default.
 663         verts, faces = create_beam(sRef)
 664
 665     beamMesh = bpy.data.meshes.new("Beam")
 666
 667     beamMesh.from_pydata(verts, [], faces)
 668     beamMesh.update(calc_edges=True)
 669
 670     return beamMesh
 671
 672
 673 # ######################
 674 # Create a beam primitive.
 675 #
 676 #  UI functions and object creation.
 677
 678 class addBeam(Operator, object_utils.AddObjectHelper):
 679     bl_idname = "mesh.add_beam"
 680     bl_label = "Beam Builder"
 681     bl_description = "Create beam meshes of various profiles"
 682     bl_options = {'REGISTER', 'UNDO', 'PRESET'}
 683
 684     Beam : BoolProperty(name = "Beam",
 685                 default = True,
 686                 description = "Beam")
 687     change : BoolProperty(name = "Change",
 688                 default = False,
 689                 description = "change Beam")
 690
 691     Type: EnumProperty(
 692             items=(
 693             ('0', "Box Profile", "Square Beam"),
 694             ("1", "U Profile", "U Profile Beam"),
 695             ("2", "C Profile", "C Profile Beam"),
 696             ("3", "L Profile", "L Profile Beam"),
 697             ("4", "I Profile", "I Profile Beam"),
 698             ("5", "T Profile", "T Profile Beam")
 699             ),
 700             description="Beam form"
 701             )
 702     beamZ: FloatProperty(
 703             name="Height",
 704             min=0.01,
 705             #max=100,
 706             default=1
 707             )
 708     beamX: FloatProperty(
 709             name="Width",
 710             min=0.01,
 711             #max=100,
 712             default=.5
 713             )
 714     beamY: FloatProperty(
 715             name="Depth",
 716             min=0.01,
 717             #max=100,
 718             default=2
 719             )
 720     beamW: FloatProperty(
 721             name="Thickness",
 722             min=0.01,
 723             #max=1,
 724             default=0.1
 725             )
 726     edgeA: IntProperty(
 727             name="Taper",
 728             min=0,
 729             #max=100,
 730             default=0,
 731             description="Angle beam edges"
 732             )
 733
 734     def draw(self, context):
 735         layout = self.layout
 736
 737         box = layout.box()
 738         split = box.split(factor=0.85, align=True)
 739         split.prop(self, "Type", text="")
 740
 741         box.prop(self, "beamZ")
 742         box.prop(self, "beamX")
 743         box.prop(self, "beamY")
 744         box.prop(self, "beamW")
 745
 746         if self.Type != '0':
 747             box.prop(self, "edgeA")
 748
 749         if self.change == False:
 750             # generic transform props
 751             box = layout.box()
 752             box.prop(self, 'align', expand=True)
 753             box.prop(self, 'location', expand=True)
 754             box.prop(self, 'rotation', expand=True)
 755
 756     def execute(self, context):
 757         # turn off 'Enter Edit Mode'
 758         use_enter_edit_mode = bpy.context.preferences.edit.use_enter_edit_mode
 759         bpy.context.preferences.edit.use_enter_edit_mode = False
 760
 761         if bpy.context.mode == "OBJECT":
 762
 763             if context.selected_objects != [] and context.active_object and \
 764                 (context.active_object.data is not None) and ('Beam' in context.active_object.data.keys()) and \
 765                 (self.change == True):
 766                 obj = context.active_object
 767                 oldmesh = obj.data
 768                 oldmeshname = obj.data.name
 769                 mesh = addBeamMesh(self, context)
 770                 obj.data = mesh
 771                 for material in oldmesh.materials:
 772                     obj.data.materials.append(material)
 773                 bpy.data.meshes.remove(oldmesh)
 774                 obj.data.name = oldmeshname
 775             else:
 776                 mesh = addBeamMesh(self, context)
 777                 obj = object_utils.object_data_add(context, mesh, operator=self)
 778
 779             if self.Type == '2':  # Rotate C shape
 780                 bpy.ops.transform.rotate(value=1.570796, constraint_axis=[False, True, False])
 781                 bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)
 782
 783             obj.data["Beam"] = True
 784             obj.data["change"] = False
 785             for prm in BeamParameters():
 786                 obj.data[prm] = getattr(self, prm)
 787
 788         if bpy.context.mode == "EDIT_MESH":
 789             active_object = context.active_object
 790             name_active_object = active_object.name
 791             bpy.ops.object.mode_set(mode='OBJECT')
 792             mesh = addBeamMesh(self, context)
 793             obj = object_utils.object_data_add(context, mesh, operator=self)
 794             obj.select_set(True)
 795             active_object.select_set(True)
 796             bpy.context.view_layer.objects.active = active_object
 797             bpy.ops.object.join()
 798             context.active_object.name = name_active_object
 799             bpy.ops.object.mode_set(mode='EDIT')
 800
 801         if use_enter_edit_mode:
 802             bpy.ops.object.mode_set(mode = 'EDIT')
 803
 804         # restore pre operator state
 805         bpy.context.preferences.edit.use_enter_edit_mode = use_enter_edit_mode
 806
 807         return {'FINISHED'}
 808
 809 def BeamParameters():
 810     BeamParameters = [
 811             "Type",
 812             "beamZ",
 813             "beamX",
 814             "beamY",
 815             "beamW",
 816             "edgeA",
 817             ]
 818     return BeamParameters