add_mesh_extra_objects/add_mesh_star.py

   1 # SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 # Original by Fourmadmen
   4
   5 import bpy
   6 from mathutils import (
   7         Vector,
   8         Quaternion,
   9         )
  10 from math import pi
  11 from bpy.props import (
  12         IntProperty,
  13         FloatProperty,
  14         StringProperty,
  15         BoolProperty,
  16         )
  17 from bpy_extras import object_utils
  18
  19 # Create a new mesh (object) from verts/edges/faces.
  20 # verts/edges/faces ... List of vertices/edges/faces for the
  21 #                       new mesh (as used in from_pydata)
  22 # name ... Name of the new mesh (& object)
  23
  24 def create_mesh_object(context, verts, edges, faces, name):
  25
  26     # Create new mesh
  27     mesh = bpy.data.meshes.new(name)
  28
  29     # Make a mesh from a list of verts/edges/faces.
  30     mesh.from_pydata(verts, edges, faces)
  31
  32     # Update mesh geometry after adding stuff.
  33     mesh.update()
  34
  35     from bpy_extras import object_utils
  36     return object_utils.object_data_add(context, mesh, operator=None)
  37
  38
  39 # A very simple "bridge" tool.
  40
  41 def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False):
  42     faces = []
  43
  44     if not vertIdx1 or not vertIdx2:
  45         return None
  46
  47     if len(vertIdx1) < 2 and len(vertIdx2) < 2:
  48         return None
  49
  50     fan = False
  51     if (len(vertIdx1) != len(vertIdx2)):
  52         if (len(vertIdx1) == 1 and len(vertIdx2) > 1):
  53             fan = True
  54         else:
  55             return None
  56
  57     total = len(vertIdx2)
  58
  59     if closed:
  60         # Bridge the start with the end.
  61         if flipped:
  62             face = [
  63                 vertIdx1[0],
  64                 vertIdx2[0],
  65                 vertIdx2[total - 1]]
  66             if not fan:
  67                 face.append(vertIdx1[total - 1])
  68             faces.append(face)
  69
  70         else:
  71             face = [vertIdx2[0], vertIdx1[0]]
  72             if not fan:
  73                 face.append(vertIdx1[total - 1])
  74             face.append(vertIdx2[total - 1])
  75             faces.append(face)
  76
  77     # Bridge the rest of the faces.
  78     for num in range(total - 1):
  79         if flipped:
  80             if fan:
  81                 face = [vertIdx2[num], vertIdx1[0], vertIdx2[num + 1]]
  82             else:
  83                 face = [vertIdx2[num], vertIdx1[num],
  84                         vertIdx1[num + 1], vertIdx2[num + 1]]
  85             faces.append(face)
  86         else:
  87             if fan:
  88                 face = [vertIdx1[0], vertIdx2[num], vertIdx2[num + 1]]
  89             else:
  90                 face = [vertIdx1[num], vertIdx2[num],
  91                         vertIdx2[num + 1], vertIdx1[num + 1]]
  92             faces.append(face)
  93
  94     return faces
  95
  96
  97 # @todo Clean up vertex&face creation process a bit.
  98
  99 def add_star(points, outer_radius, inner_radius, height):
 100     PI_2 = pi * 2
 101     z_axis = (0, 0, 1)
 102
 103     verts = []
 104     faces = []
 105
 106     segments = points * 2
 107
 108     half_height = height / 2.0
 109
 110     vert_idx_top = len(verts)
 111     verts.append(Vector((0.0, 0.0, half_height)))
 112
 113     vert_idx_bottom = len(verts)
 114     verts.append(Vector((0.0, 0.0, -half_height)))
 115
 116     edgeloop_top = []
 117     edgeloop_bottom = []
 118
 119     for index in range(segments):
 120         quat = Quaternion(z_axis, (index / segments) * PI_2)
 121
 122         if index % 2:
 123             # Uneven
 124             radius = outer_radius
 125         else:
 126             # Even
 127             radius = inner_radius
 128
 129         edgeloop_top.append(len(verts))
 130         vec = quat @ Vector((radius, 0, half_height))
 131         verts.append(vec)
 132
 133         edgeloop_bottom.append(len(verts))
 134         vec = quat @ Vector((radius, 0, -half_height))
 135         verts.append(vec)
 136
 137     faces_top = createFaces([vert_idx_top], edgeloop_top, closed=True)
 138     faces_outside = createFaces(edgeloop_top, edgeloop_bottom, closed=True)
 139     faces_bottom = createFaces([vert_idx_bottom], edgeloop_bottom,
 140         flipped=True, closed=True)
 141
 142     faces.extend(faces_top)
 143     faces.extend(faces_outside)
 144     faces.extend(faces_bottom)
 145
 146     return verts, faces
 147
 148
 149 class AddStar(bpy.types.Operator, object_utils.AddObjectHelper):
 150     bl_idname = "mesh.primitive_star_add"
 151     bl_label = "Simple Star"
 152     bl_description = "Construct a star mesh"
 153     bl_options = {'REGISTER', 'UNDO', 'PRESET'}
 154
 155     Star : BoolProperty(name = "Star",
 156                 default = True,
 157                 description = "Star")
 158     change : BoolProperty(name = "Change",
 159                 default = False,
 160                 description = "change Star")
 161
 162     points: IntProperty(
 163         name="Points",
 164         description="Number of points for the star",
 165         min=2,
 166         max=256,
 167         default=5
 168         )
 169     outer_radius: FloatProperty(
 170         name="Outer Radius",
 171         description="Outer radius of the star",
 172         min=0.01,
 173         max=9999.0,
 174         default=1.0
 175         )
 176     innter_radius: FloatProperty(
 177         name="Inner Radius",
 178         description="Inner radius of the star",
 179         min=0.01,
 180         max=9999.0,
 181         default=0.5
 182         )
 183     height: FloatProperty(name="Height",
 184         description="Height of the star",
 185         min=0.01,
 186         max=9999.0,
 187         default=0.5
 188         )
 189
 190     def draw(self, context):
 191         layout = self.layout
 192
 193         layout.prop(self, 'points', expand=True)
 194         layout.prop(self, 'outer_radius', expand=True)
 195         layout.prop(self, 'innter_radius', expand=True)
 196         layout.prop(self, 'height', expand=True)
 197
 198         if self.change == False:
 199             col = layout.column(align=True)
 200             col.prop(self, 'align', expand=True)
 201             col = layout.column(align=True)
 202             col.prop(self, 'location', expand=True)
 203             col = layout.column(align=True)
 204             col.prop(self, 'rotation', expand=True)
 205
 206     def execute(self, context):
 207         # turn off 'Enter Edit Mode'
 208         use_enter_edit_mode = bpy.context.preferences.edit.use_enter_edit_mode
 209         bpy.context.preferences.edit.use_enter_edit_mode = False
 210
 211         if bpy.context.mode == "OBJECT":
 212             if context.selected_objects != [] and context.active_object and \
 213                 (context.active_object.data is not None) and ('Star' in context.active_object.data.keys()) and \
 214                 (self.change == True):
 215                 obj = context.active_object
 216                 oldmesh = obj.data
 217                 oldmeshname = obj.data.name
 218                 verts, faces = add_star(
 219                         self.points,
 220                         self.outer_radius,
 221                         self.innter_radius,
 222                         self.height
 223                         )
 224                 mesh = bpy.data.meshes.new('Star')
 225                 mesh.from_pydata(verts, [], faces)
 226                 obj.data = mesh
 227                 for material in oldmesh.materials:
 228                     obj.data.materials.append(material)
 229                 bpy.data.meshes.remove(oldmesh)
 230                 obj.data.name = oldmeshname
 231             else:
 232                 verts, faces = add_star(
 233                         self.points,
 234                         self.outer_radius,
 235                         self.innter_radius,
 236                         self.height
 237                         )
 238                 mesh = bpy.data.meshes.new('Star')
 239                 mesh.from_pydata(verts, [], faces)
 240                 obj = object_utils.object_data_add(context, mesh, operator=self)
 241
 242             obj.data["Star"] = True
 243             obj.data["change"] = False
 244             for prm in StarParameters():
 245                 obj.data[prm] = getattr(self, prm)
 246
 247         if bpy.context.mode == "EDIT_MESH":
 248             active_object = context.active_object
 249             name_active_object = active_object.name
 250             bpy.ops.object.mode_set(mode='OBJECT')
 251             verts, faces = add_star(
 252                         self.points,
 253                         self.outer_radius,
 254                         self.innter_radius,
 255                         self.height
 256                         )
 257             mesh = bpy.data.meshes.new('Star')
 258             mesh.from_pydata(verts, [], faces)
 259             obj = object_utils.object_data_add(context, mesh, operator=self)
 260             obj.select_set(True)
 261             active_object.select_set(True)
 262             bpy.context.view_layer.objects.active = active_object
 263             bpy.ops.object.join()
 264             context.active_object.name = name_active_object
 265             bpy.ops.object.mode_set(mode='EDIT')
 266
 267         if use_enter_edit_mode:
 268             bpy.ops.object.mode_set(mode = 'EDIT')
 269
 270         # restore pre operator state
 271         bpy.context.preferences.edit.use_enter_edit_mode = use_enter_edit_mode
 272
 273         return {'FINISHED'}
 274
 275 def StarParameters():
 276     StarParameters = [
 277         "points",
 278         "outer_radius",
 279         "innter_radius",
 280         "height",
 281         ]
 282     return StarParameters