add_mesh_extra_objects/add_mesh_beam_builder.py

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