object_carver/carver_utils.py

   1
   2 import bpy
   3 import bgl
   4 import gpu
   5 from gpu_extras.batch import batch_for_shader
   6 import math
   7 import sys
   8 import random
   9 import bmesh
  10 from mathutils import (
  11         Euler,
  12         Matrix,
  13         Vector,
  14         Quaternion,
  15 )
  16 from mathutils.geometry import (
  17         intersect_line_plane,
  18 )
  19
  20 from math import (
  21         sin,
  22         cos,
  23         pi,
  24         )
  25
  26 import bpy_extras
  27
  28 from bpy_extras import view3d_utils
  29 from bpy_extras.view3d_utils import (
  30         region_2d_to_vector_3d,
  31         region_2d_to_location_3d,
  32         location_3d_to_region_2d,
  33 )
  34
  35 # Cut Square
  36 def CreateCutSquare(self, context):
  37         """ Create a rectangle mesh """
  38         far_limit = 10000.0
  39         faces=[]
  40
  41         # Get the mouse coordinates
  42         coord = self.mouse_path[0][0], self.mouse_path[0][1]
  43
  44         # New mesh
  45         me = bpy.data.meshes.new('CMT_Square')
  46         bm = bmesh.new()
  47         bm.from_mesh(me)
  48
  49         # New object and link it to the scene
  50         ob = bpy.data.objects.new('CMT_Square', me)
  51         self.CurrentObj = ob
  52         context.collection.objects.link(ob)
  53
  54         # Scene information
  55         region = context.region
  56         rv3d = context.region_data
  57         depth_location = region_2d_to_vector_3d(region, rv3d, coord)
  58         self.ViewVector = depth_location
  59
  60         # Get a point on a infinite plane and its direction
  61         plane_normal = depth_location
  62         plane_direction = plane_normal.normalized()
  63
  64         if self.snapCursor:
  65                 plane_point = context.scene.cursor.location
  66         else:
  67                 plane_point = self.OpsObj.location if self.OpsObj is not None else Vector((0.0, 0.0, 0.0))
  68
  69         # Find the intersection of a line going thru each vertex and the infinite plane
  70         for v_co in self.rectangle_coord:
  71                 vec = region_2d_to_vector_3d(region, rv3d, v_co)
  72                 p0 = region_2d_to_location_3d(region, rv3d,v_co, vec)
  73                 p1 = region_2d_to_location_3d(region, rv3d,v_co, vec) + plane_direction * far_limit
  74                 faces.append(bm.verts.new(intersect_line_plane(p0, p1, plane_point, plane_direction)))
  75
  76         # Update vertices index
  77         bm.verts.index_update()
  78         # New faces
  79         t_face = bm.faces.new(faces)
  80         # Set mesh
  81         bm.to_mesh(me)
  82
  83
  84 # Cut Line
  85 def CreateCutLine(self, context):
  86         """ Create a polygon mesh """
  87         far_limit = 10000.0
  88         vertices = []
  89         faces = []
  90         loc = []
  91
  92         # Get the mouse coordinates
  93         coord = self.mouse_path[0][0], self.mouse_path[0][1]
  94
  95         # New mesh
  96         me = bpy.data.meshes.new('CMT_Line')
  97         bm = bmesh.new()
  98         bm.from_mesh(me)
  99
 100         # New object and link it to the scene
 101         ob = bpy.data.objects.new('CMT_Line', me)
 102         self.CurrentObj = ob
 103         context.collection.objects.link(ob)
 104
 105         # Scene information
 106         region = context.region
 107         rv3d = context.region_data
 108         depth_location = region_2d_to_vector_3d(region, rv3d, coord)
 109         self.ViewVector = depth_location
 110
 111         # Get a point on a infinite plane and its direction
 112         plane_normal = depth_location
 113         plane_direction = plane_normal.normalized()
 114
 115         if self.snapCursor:
 116                 plane_point = context.scene.cursor.location
 117         else:
 118                 plane_point = self.OpsObj.location if self.OpsObj is not None else Vector((0.0, 0.0, 0.0))
 119
 120         # Use dict to remove doubles
 121         # Find the intersection of a line going thru each vertex and the infinite plane
 122         for idx, v_co in enumerate(list(dict.fromkeys(self.mouse_path))):
 123                 vec = region_2d_to_vector_3d(region, rv3d, v_co)
 124                 p0 = region_2d_to_location_3d(region, rv3d,v_co, vec)
 125                 p1 = region_2d_to_location_3d(region, rv3d,v_co, vec) + plane_direction * far_limit
 126                 loc.append(intersect_line_plane(p0, p1, plane_point, plane_direction))
 127                 vertices.append(bm.verts.new(loc[idx]))
 128
 129                 if idx > 0:
 130                         bm.edges.new([vertices[idx-1],vertices[idx]])
 131
 132                 faces.append(vertices[idx])
 133
 134         # Update vertices index
 135         bm.verts.index_update()
 136
 137         # Nothing is selected, create close geometry
 138         if self.CreateMode:
 139                 if self.Closed and len(vertices) > 1:
 140                         bm.edges.new([vertices[-1], vertices[0]])
 141                         bm.faces.new(faces)
 142         else:
 143                 # Create faces if more than 2 vertices
 144                 if len(vertices) > 1 :
 145                         bm.edges.new([vertices[-1], vertices[0]])
 146                         bm.faces.new(faces)
 147
 148         bm.to_mesh(me)
 149
 150 # Cut Circle
 151 def CreateCutCircle(self, context):
 152         """ Create a circle mesh """
 153         far_limit = 10000.0
 154         FacesList = []
 155
 156         # Get the mouse coordinates
 157         mouse_pos_x = self.mouse_path[0][0]
 158         mouse_pos_y = self.mouse_path[0][1]
 159         coord = self.mouse_path[0][0], self.mouse_path[0][1]
 160
 161         # Scene information
 162         region = context.region
 163         rv3d = context.region_data
 164         depth_location = region_2d_to_vector_3d(region, rv3d, coord)
 165         self.ViewVector = depth_location
 166
 167         # Get a point on a infinite plane and its direction
 168         plane_point = context.scene.cursor.location if self.snapCursor else Vector((0.0, 0.0, 0.0))
 169         plane_normal = depth_location
 170         plane_direction = plane_normal.normalized()
 171
 172         # New mesh
 173         me = bpy.data.meshes.new('CMT_Circle')
 174         bm = bmesh.new()
 175         bm.from_mesh(me)
 176
 177         # New object and link it to the scene
 178         ob = bpy.data.objects.new('CMT_Circle', me)
 179         self.CurrentObj = ob
 180         context.collection.objects.link(ob)
 181
 182         # Create a circle using a tri fan
 183         tris_fan, indices = draw_circle(self, mouse_pos_x, mouse_pos_y)
 184
 185         # Remove the vertex in the center to get the outer line of the circle
 186         verts = tris_fan[1:]
 187
 188         # Find the intersection of a line going thru each vertex and the infinite plane
 189         for vert in verts:
 190                 vec = region_2d_to_vector_3d(region, rv3d, vert)
 191                 p0 = region_2d_to_location_3d(region, rv3d, vert, vec)
 192                 p1 = p0 + plane_direction * far_limit
 193                 loc0 = intersect_line_plane(p0, p1, plane_point, plane_direction)
 194                 t_v0 = bm.verts.new(loc0)
 195                 FacesList.append(t_v0)
 196
 197         bm.verts.index_update()
 198         bm.faces.new(FacesList)
 199         bm.to_mesh(me)
 200
 201
 202 def create_2d_circle(self, step, radius, rotation = 0):
 203         """ Create the vertices of a 2d circle at (0,0) """
 204         verts = []
 205         for angle in range(0, 360, step):
 206                 verts.append(math.cos(math.radians(angle + rotation)) * radius)
 207                 verts.append(math.sin(math.radians(angle + rotation)) * radius)
 208                 verts.append(0.0)
 209         verts.append(math.cos(math.radians(0.0 + rotation)) * radius)
 210         verts.append(math.sin(math.radians(0.0 + rotation)) * radius)
 211         verts.append(0.0)
 212         return(verts)
 213
 214
 215 def draw_circle(self, mouse_pos_x, mouse_pos_y):
 216         """ Return the coordinates + indices of a circle using a triangle fan """
 217         tris_verts = []
 218         indices = []
 219         segments = int(360 / self.stepAngle[self.step])
 220         radius = self.mouse_path[1][0] - self.mouse_path[0][0]
 221         rotation = (self.mouse_path[1][1] - self.mouse_path[0][1]) / 2
 222
 223         # Get the vertices of a 2d circle
 224         verts = create_2d_circle(self, self.stepAngle[self.step], radius, rotation)
 225
 226         # Create the first vertex at mouse position for the center of the circle
 227         tris_verts.append(Vector((mouse_pos_x + self.xpos , mouse_pos_y + self.ypos)))
 228
 229         # For each vertex of the circle, add the mouse position and the translation
 230         for idx in range(int(len(verts) / 3) - 1):
 231                 tris_verts.append(Vector((verts[idx * 3] + mouse_pos_x + self.xpos, \
 232                                                                   verts[idx * 3 + 1] + mouse_pos_y + self.ypos)))
 233                 i1 = idx+1
 234                 i2 = idx+2 if idx+2 <= segments else 1
 235                 indices.append((0,i1,i2))
 236
 237         return(tris_verts, indices)
 238
 239 # Object dimensions (SCULPT Tools tips)
 240 def objDiagonal(obj):
 241         return ((obj.dimensions[0]**2) + (obj.dimensions[1]**2) + (obj.dimensions[2]**2))**0.5
 242
 243
 244 # Bevel Update
 245 def update_bevel(context):
 246         selection = context.selected_objects.copy()
 247         active = context.active_object
 248
 249         if len(selection) > 0:
 250                 for obj in selection:
 251                         bpy.ops.object.select_all(action='DESELECT')
 252                         obj.select_set(True)
 253                         context.view_layer.objects.active = obj
 254
 255                         # Test object name
 256                         # Subdive mode : Only bevel weight
 257                         if obj.data.name.startswith("S_") or obj.data.name.startswith("S "):
 258                                 bpy.ops.object.mode_set(mode='EDIT')
 259                                 bpy.ops.mesh.region_to_loop()
 260                                 bpy.ops.transform.edge_bevelweight(value=1)
 261                                 bpy.ops.object.mode_set(mode='OBJECT')
 262
 263                         else:
 264                                 # No subdiv mode : bevel weight + Crease + Sharp
 265                                 CreateBevel(context, obj)
 266
 267         bpy.ops.object.select_all(action='DESELECT')
 268
 269         for obj in selection:
 270                 obj.select_set(True)
 271         context.view_layer.objects.active = active
 272
 273 # Create bevel
 274 def CreateBevel(context, CurrentObject):
 275         # Save active object
 276         SavActive = context.active_object
 277
 278         # Test if initial object has bevel
 279         bevel_modifier = False
 280         for modifier in SavActive.modifiers:
 281                 if modifier.name == 'Bevel':
 282                         bevel_modifier = True
 283
 284         if bevel_modifier:
 285                 # Active "CurrentObject"
 286                 context.view_layer.objects.active = CurrentObject
 287
 288                 bpy.ops.object.mode_set(mode='EDIT')
 289
 290                 # Edge mode
 291                 bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='EDGE')
 292                 # Clear all
 293                 bpy.ops.mesh.select_all(action='SELECT')
 294                 bpy.ops.mesh.mark_sharp(clear=True)
 295                 bpy.ops.transform.edge_crease(value=-1)
 296                 bpy.ops.transform.edge_bevelweight(value=-1)
 297
 298                 bpy.ops.mesh.select_all(action='DESELECT')
 299
 300                 # Select (in radians) all 30° sharp edges
 301                 bpy.ops.mesh.edges_select_sharp(sharpness=0.523599)
 302                 # Apply bevel weight + Crease + Sharp to the selected edges
 303                 bpy.ops.mesh.mark_sharp()
 304                 bpy.ops.transform.edge_crease(value=1)
 305                 bpy.ops.transform.edge_bevelweight(value=1)
 306
 307                 bpy.ops.mesh.select_all(action='DESELECT')
 308
 309                 bpy.ops.object.mode_set(mode='OBJECT')
 310
 311                 CurrentObject.data.use_customdata_edge_bevel = True
 312
 313                 for i in range(len(CurrentObject.data.edges)):
 314                         if CurrentObject.data.edges[i].select is True:
 315                                 CurrentObject.data.edges[i].bevel_weight = 1.0
 316                                 CurrentObject.data.edges[i].use_edge_sharp = True
 317
 318                 bevel_modifier = False
 319                 for m in CurrentObject.modifiers:
 320                         if m.name == 'Bevel':
 321                                 bevel_modifier = True
 322
 323                 if bevel_modifier is False:
 324                         bpy.ops.object.modifier_add(type='BEVEL')
 325                         mod = context.object.modifiers[-1]
 326                         mod.limit_method = 'WEIGHT'
 327                         mod.width = 0.01
 328                         mod.profile = 0.699099
 329                         mod.use_clight_overlap = False
 330                         mod.segments = 3
 331                         mod.loop_slide = False
 332
 333                 bpy.ops.object.shade_smooth()
 334
 335                 context.object.data.use_auto_smooth = True
 336                 context.object.data.auto_smooth_angle = 1.0471975
 337
 338                 # Restore the active object
 339                 context.view_layer.objects.active = SavActive
 340
 341
 342 def MoveCursor(qRot, location, self):
 343         """ In brush mode : Draw a circle around the brush """
 344         if qRot is not None:
 345                 verts = create_2d_circle(self, 10, 1)
 346                 self.CLR_C.clear()
 347                 vc = Vector()
 348                 for idx in range(int(len(verts) / 3)):
 349                         vc.x = verts[idx * 3]
 350                         vc.y = verts[idx * 3 + 1]
 351                         vc.z = verts[idx * 3 + 2]
 352                         vc = qRot @ vc
 353                         self.CLR_C.append(vc.x)
 354                         self.CLR_C.append(vc.y)
 355                         self.CLR_C.append(vc.z)
 356
 357
 358 def rot_axis_quat(vector1, vector2):
 359         """ Find the rotation (quaternion) from vector 1 to vector 2"""
 360         vector1 = vector1.normalized()
 361         vector2 = vector2.normalized()
 362         cosTheta = vector1.dot(vector2)
 363         rotationAxis = Vector((0.0, 0.0, 0.0))
 364         if (cosTheta < -1 + 0.001):
 365                 v = Vector((0.0, 1.0, 0.0))
 366                 #Get the vector at the right angles to both
 367                 rotationAxis = vector1.cross(v)
 368                 rotationAxis = rotationAxis.normalized()
 369                 q = Quaternion()
 370                 q.w = 0.0
 371                 q.x = rotationAxis.x
 372                 q.y = rotationAxis.y
 373                 q.z = rotationAxis.z
 374         else:
 375                 rotationAxis = vector1.cross(vector2)
 376                 s = math.sqrt((1.0 + cosTheta) * 2.0)
 377                 invs = 1 / s
 378                 q = Quaternion()
 379                 q.w = s * 0.5
 380                 q.x = rotationAxis.x * invs
 381                 q.y = rotationAxis.y * invs
 382                 q.z = rotationAxis.z * invs
 383         return q
 384
 385
 386 # Picking (template)
 387 def Picking(context, event):
 388         """ Put the 3d cursor on the closest object"""
 389
 390         # get the context arguments
 391         scene = context.scene
 392         region = context.region
 393         rv3d = context.region_data
 394         coord = event.mouse_region_x, event.mouse_region_y
 395
 396         # get the ray from the viewport and mouse
 397         view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
 398         ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)
 399         ray_target = ray_origin + view_vector
 400
 401         def visible_objects_and_duplis():
 402                 depsgraph = context.evaluated_depsgraph_get()
 403                 for dup in depsgraph.object_instances:
 404                         if dup.is_instance:  # Real dupli instance
 405                                 obj = dup.instance_object.original
 406                                 yield (obj, dup.matrix.copy())
 407                         else:  # Usual object
 408                                 obj = dup.object.original
 409                                 yield (obj, obj.matrix_world.copy())
 410
 411         def obj_ray_cast(obj, matrix):
 412                 # get the ray relative to the object
 413                 matrix_inv = matrix.inverted()
 414                 ray_origin_obj = matrix_inv @ ray_origin
 415                 ray_target_obj = matrix_inv @ ray_target
 416                 ray_direction_obj = ray_target_obj - ray_origin_obj
 417                 # cast the ray
 418                 success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)
 419                 if success:
 420                         return location, normal, face_index
 421                 return None, None, None
 422
 423         # cast rays and find the closest object
 424         best_length_squared = -1.0
 425         best_obj = None
 426
 427         # cast rays and find the closest object
 428         for obj, matrix in visible_objects_and_duplis():
 429                 if obj.type == 'MESH':
 430                         hit, normal, face_index = obj_ray_cast(obj, matrix)
 431                         if hit is not None:
 432                                 hit_world = matrix @ hit
 433                                 length_squared = (hit_world - ray_origin).length_squared
 434                                 if best_obj is None or length_squared < best_length_squared:
 435                                         scene.cursor.location = hit_world
 436                                         best_length_squared = length_squared
 437                                         best_obj = obj
 438                         else:
 439                                 if best_obj is None:
 440                                         depth_location = region_2d_to_vector_3d(region, rv3d, coord)
 441                                         loc = region_2d_to_location_3d(region, rv3d, coord, depth_location)
 442                                         scene.cursor.location = loc
 443
 444
 445 def Pick(context, event, self, ray_max=10000.0):
 446         region = context.region
 447         rv3d = context.region_data
 448         coord = event.mouse_region_x, event.mouse_region_y
 449         view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
 450         ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)
 451         ray_target = ray_origin + (view_vector * ray_max)
 452
 453         def obj_ray_cast(obj, matrix):
 454                 matrix_inv = matrix.inverted()
 455                 ray_origin_obj = matrix_inv @ ray_origin
 456                 ray_target_obj = matrix_inv @ ray_target
 457                 success, hit, normal, face_index = obj.ray_cast(ray_origin_obj, ray_target_obj)
 458                 if success:
 459                         return hit, normal, face_index
 460                 return None, None, None
 461
 462         best_length_squared = ray_max * ray_max
 463         best_obj = None
 464         for obj in self.CList:
 465                 matrix = obj.matrix_world
 466                 hit, normal, face_index = obj_ray_cast(obj, matrix)
 467                 rotation = obj.rotation_euler.to_quaternion()
 468                 if hit is not None:
 469                         hit_world = matrix @ hit
 470                         length_squared = (hit_world - ray_origin).length_squared
 471                         if length_squared < best_length_squared:
 472                                 best_length_squared = length_squared
 473                                 best_obj = obj
 474                                 hits = hit_world
 475                                 ns = normal
 476                                 fs = face_index
 477
 478         if best_obj is not None:
 479                 return hits, ns, rotation
 480
 481         return None, None, None
 482
 483 def SelectObject(self, copyobj):
 484         copyobj.select_set(True)
 485
 486         for child in copyobj.children:
 487                 SelectObject(self, child)
 488
 489         if copyobj.parent is None:
 490                 bpy.context.view_layer.objects.active = copyobj
 491
 492 # Undo
 493 def printUndo(self):
 494         for l in self.UList:
 495                 print(l)
 496
 497
 498 def UndoAdd(self, type, obj):
 499         """ Create a backup mesh before apply the action to the object """
 500         if obj is None:
 501                 return
 502
 503         if type != "DUPLICATE":
 504                 bm = bmesh.new()
 505                 bm.from_mesh(obj.data)
 506                 self.UndoOps.append((obj, type, bm))
 507         else:
 508                 self.UndoOps.append((obj, type, None))
 509
 510
 511 def UndoListUpdate(self):
 512         self.UList.append((self.UndoOps.copy()))
 513         self.UList_Index += 1
 514         self.UndoOps.clear()
 515
 516
 517 def Undo(self):
 518         if self.UList_Index < 0:
 519                 return
 520         # get previous mesh
 521         for o in self.UList[self.UList_Index]:
 522                 if o[1] == "MESH":
 523                         bm = o[2]
 524                         bm.to_mesh(o[0].data)
 525
 526         SelectObjList = bpy.context.selected_objects.copy()
 527         Active_Obj = bpy.context.active_object
 528         bpy.ops.object.select_all(action='TOGGLE')
 529
 530         for o in self.UList[self.UList_Index]:
 531                 if o[1] == "REBOOL":
 532                         o[0].select_set(True)
 533                         o[0].hide_viewport = False
 534
 535                 if o[1] == "DUPLICATE":
 536                         o[0].select_set(True)
 537                         o[0].hide_viewport = False
 538
 539         bpy.ops.object.delete(use_global=False)
 540
 541         for so in SelectObjList:
 542                 bpy.data.objects[so.name].select_set(True)
 543         bpy.context.view_layer.objects.active = Active_Obj
 544
 545         self.UList_Index -= 1
 546         self.UList[self.UList_Index + 1:] = []
 547
 548
 549 def duplicateObject(self):
 550         if self.Instantiate:
 551                 bpy.ops.object.duplicate_move_linked(
 552                         OBJECT_OT_duplicate={
 553                                 "linked": True,
 554                                 "mode": 'TRANSLATION',
 555                         },
 556                         TRANSFORM_OT_translate={
 557                                 "value": (0, 0, 0),
 558                         },
 559                 )
 560         else:
 561                 bpy.ops.object.duplicate_move(
 562                         OBJECT_OT_duplicate={
 563                                 "linked": False,
 564                                 "mode": 'TRANSLATION',
 565                         },
 566                         TRANSFORM_OT_translate={
 567                                 "value": (0, 0, 0),
 568                         },
 569                 )
 570
 571         ob_new = bpy.context.active_object
 572
 573         ob_new.location = self.CurLoc
 574         v = Vector()
 575         v.x = v.y = 0.0
 576         v.z = self.BrushDepthOffset
 577         ob_new.location += self.qRot * v
 578
 579         if self.ObjectMode:
 580                 ob_new.scale = self.ObjectBrush.scale
 581         if self.ProfileMode:
 582                 ob_new.scale = self.ProfileBrush.scale
 583
 584         e = Euler()
 585         e.x = e.y = 0.0
 586         e.z = self.aRotZ / 25.0
 587
 588         # If duplicate with a grid, no random rotation (each mesh in the grid is already rotated randomly)
 589         if (self.alt is True) and ((self.nbcol + self.nbrow) < 3):
 590                 if self.RandomRotation:
 591                         e.z += random.random()
 592
 593         qe = e.to_quaternion()
 594         qRot = self.qRot * qe
 595         ob_new.rotation_mode = 'QUATERNION'
 596         ob_new.rotation_quaternion = qRot
 597         ob_new.rotation_mode = 'XYZ'
 598
 599         if (ob_new.display_type == "WIRE") and (self.BrushSolidify is False):
 600                 ob_new.hide_viewport = True
 601
 602         if self.BrushSolidify:
 603                 ob_new.display_type = "SOLID"
 604                 ob_new.show_in_front = False
 605
 606         for o in bpy.context.selected_objects:
 607                 UndoAdd(self, "DUPLICATE", o)
 608
 609         if len(bpy.context.selected_objects) > 0:
 610                 bpy.ops.object.select_all(action='TOGGLE')
 611         for o in self.all_sel_obj_list:
 612                 o.select_set(True)
 613
 614         bpy.context.view_layer.objects.active = self.OpsObj
 615
 616
 617 def update_grid(self, context):
 618         """
 619         Thanks to batFINGER for his help :
 620         source : http://blender.stackexchange.com/questions/55864/multiple-meshes-not-welded-with-pydata
 621         """
 622         verts = []
 623         edges = []
 624         faces = []
 625         numface = 0
 626
 627         if self.nbcol < 1:
 628                 self.nbcol = 1
 629         if self.nbrow < 1:
 630                 self.nbrow = 1
 631         if self.gapx < 0:
 632                 self.gapx = 0
 633         if self.gapy < 0:
 634                 self.gapy = 0
 635
 636         # Get the data from the profils or the object
 637         if self.ProfileMode:
 638                 brush = bpy.data.objects.new(
 639                                         self.Profils[self.nProfil][0],
 640                                         bpy.data.meshes[self.Profils[self.nProfil][0]]
 641                                         )
 642                 obj = bpy.data.objects["CT_Profil"]
 643                 obfaces = brush.data.polygons
 644                 obverts = brush.data.vertices
 645                 lenverts = len(obverts)
 646         else:
 647                 brush = bpy.data.objects["CarverBrushCopy"]
 648                 obj = context.selected_objects[0]
 649                 obverts = brush.data.vertices
 650                 obfaces = brush.data.polygons
 651                 lenverts = len(brush.data.vertices)
 652
 653         # Gap between each row / column
 654         gapx = self.gapx
 655         gapy = self.gapy
 656
 657         # Width of each row / column
 658         widthx = brush.dimensions.x * self.scale_x
 659         widthy = brush.dimensions.y * self.scale_y
 660
 661         # Compute the corners so the new object will be always at the center
 662         left = -((self.nbcol - 1) * (widthx + gapx)) / 2
 663         start = -((self.nbrow - 1) * (widthy + gapy)) / 2
 664
 665         for i in range(self.nbrow * self.nbcol):
 666                 row = i % self.nbrow
 667                 col = i // self.nbrow
 668                 startx = left + ((widthx + gapx) * col)
 669                 starty = start + ((widthy + gapy) * row)
 670
 671                 # Add random rotation
 672                 if (self.RandomRotation) and not (self.GridScaleX or self.GridScaleY):
 673                         rotmat = Matrix.Rotation(math.radians(360 * random.random()), 4, 'Z')
 674                         for v in obverts:
 675                                 v.co = v.co @ rotmat
 676
 677                 verts.extend([((v.co.x - startx, v.co.y - starty, v.co.z)) for v in obverts])
 678                 faces.extend([[v + numface * lenverts for v in p.vertices] for p in obfaces])
 679                 numface += 1
 680
 681         # Update the mesh
 682         # Create mesh data
 683         mymesh = bpy.data.meshes.new("CT_Profil")
 684         # Generate mesh data
 685         mymesh.from_pydata(verts, edges, faces)
 686         # Calculate the edges
 687         mymesh.update(calc_edges=True)
 688         # Update data
 689         obj.data = mymesh
 690         # Make the object active to remove doubles
 691         context.view_layer.objects.active = obj
 692
 693
 694 def boolean_operation(bool_type="DIFFERENCE"):
 695         ActiveObj = bpy.context.active_object
 696         sel_index = 0 if bpy.context.selected_objects[0] != bpy.context.active_object else 1
 697
 698         # bpy.ops.object.modifier_apply(apply_as='DATA', modifier="CT_SOLIDIFY")
 699         bool_name = "CT_" + bpy.context.selected_objects[sel_index].name
 700         BoolMod = ActiveObj.modifiers.new(bool_name, "BOOLEAN")
 701         BoolMod.object = bpy.context.selected_objects[sel_index]
 702         BoolMod.operation = bool_type
 703         bpy.context.selected_objects[sel_index].display_type = 'WIRE'
 704         while ActiveObj.modifiers.find(bool_name) > 0:
 705                 bpy.ops.object.modifier_move_up(modifier=bool_name)
 706
 707
 708 def Rebool(context, self):
 709
 710         target_obj = context.active_object
 711
 712         Brush = context.selected_objects[1]
 713         Brush.display_type = "WIRE"
 714
 715         #Deselect all
 716         bpy.ops.object.select_all(action='TOGGLE')
 717
 718         target_obj.display_type = "SOLID"
 719         target_obj.select_set(True)
 720         bpy.ops.object.duplicate()
 721
 722         rebool_obj = context.active_object
 723
 724         m = rebool_obj.modifiers.new("CT_INTERSECT", "BOOLEAN")
 725         m.operation = "INTERSECT"
 726         m.object = Brush
 727
 728         m = target_obj.modifiers.new("CT_DIFFERENCE", "BOOLEAN")
 729         m.operation = "DIFFERENCE"
 730         m.object = Brush
 731
 732         for mb in target_obj.modifiers:
 733                 if mb.type == 'BEVEL':
 734                         mb.show_viewport = False
 735
 736         if self.ObjectBrush or self.ProfileBrush:
 737                 rebool_obj.show_in_front = False
 738                 try:
 739                         bpy.ops.object.modifier_apply(apply_as='DATA', modifier="CT_SOLIDIFY")
 740                 except:
 741                         exc_type, exc_value, exc_traceback = sys.exc_info()
 742                         self.report({'ERROR'}, str(exc_value))
 743
 744         if self.dont_apply_boolean is False:
 745                 try:
 746                         bpy.ops.object.modifier_apply(apply_as='DATA', modifier="CT_INTERSECT")
 747                 except:
 748                         exc_type, exc_value, exc_traceback = sys.exc_info()
 749                         self.report({'ERROR'}, str(exc_value))
 750
 751         bpy.ops.object.select_all(action='TOGGLE')
 752
 753         for mb in target_obj.modifiers:
 754                 if mb.type == 'BEVEL':
 755                         mb.show_viewport = True
 756
 757         context.view_layer.objects.active = target_obj
 758         target_obj.select_set(True)
 759         if self.dont_apply_boolean is False:
 760                 try:
 761                         bpy.ops.object.modifier_apply(apply_as='DATA', modifier="CT_DIFFERENCE")
 762                 except:
 763                         exc_type, exc_value, exc_traceback = sys.exc_info()
 764                         self.report({'ERROR'}, str(exc_value))
 765
 766         bpy.ops.object.select_all(action='TOGGLE')
 767
 768         rebool_obj.select_set(True)
 769
 770 def createMeshFromData(self):
 771         if self.Profils[self.nProfil][0] not in bpy.data.meshes:
 772                 # Create mesh and object
 773                 me = bpy.data.meshes.new(self.Profils[self.nProfil][0])
 774                 # Create mesh from given verts, faces.
 775                 me.from_pydata(self.Profils[self.nProfil][2], [], self.Profils[self.nProfil][3])
 776                 me.validate(verbose=True, clean_customdata=True)
 777                 # Update mesh with new data
 778                 me.update()
 779
 780         if "CT_Profil" not in bpy.data.objects:
 781                 ob = bpy.data.objects.new("CT_Profil", bpy.data.meshes[self.Profils[self.nProfil][0]])
 782                 ob.location = Vector((0.0, 0.0, 0.0))
 783
 784                 # Link object to scene and make active
 785                 bpy.context.collection.objects.link(ob)
 786                 bpy.context.view_layer.update()
 787                 bpy.context.view_layer.objects.active = ob
 788                 ob.select_set(True)
 789                 ob.location = Vector((10000.0, 0.0, 0.0))
 790                 ob.display_type = "WIRE"
 791
 792                 self.SolidifyPossible = True
 793         else:
 794                 bpy.data.objects["CT_Profil"].data = bpy.data.meshes[self.Profils[self.nProfil][0]]
 795
 796 def Selection_Save_Restore(self):
 797         if "CT_Profil" in bpy.data.objects:
 798                 Selection_Save(self)
 799                 bpy.ops.object.select_all(action='DESELECT')
 800                 bpy.data.objects["CT_Profil"].select_set(True)
 801                 bpy.context.view_layer.objects.active = bpy.data.objects["CT_Profil"]
 802                 if bpy.data.objects["CT_Profil"] in self.all_sel_obj_list:
 803                         self.all_sel_obj_list.remove(bpy.data.objects["CT_Profil"])
 804                 bpy.ops.object.delete(use_global=False)
 805                 Selection_Restore(self)
 806
 807 def Selection_Save(self):
 808         obj_name = getattr(bpy.context.active_object, "name", None)
 809         self.all_sel_obj_list = bpy.context.selected_objects.copy()
 810         self.save_active_obj = obj_name
 811
 812
 813 def Selection_Restore(self):
 814         for o in self.all_sel_obj_list:
 815                 o.select_set(True)
 816         if self.save_active_obj:
 817                 bpy.context.view_layer.objects.active = bpy.data.objects.get(self.save_active_obj, None)
 818
 819 def Snap_Cursor(self, context, event, mouse_pos):
 820         """ Find the closest position on the overlay grid and snap the mouse on it """
 821         # Get the context arguments
 822         region = context.region
 823         rv3d = context.region_data
 824
 825         # Get the VIEW3D area
 826         for i, a in enumerate(context.screen.areas):
 827                 if a.type == 'VIEW_3D':
 828                         space = context.screen.areas[i].spaces.active
 829
 830         # Get the grid overlay for the VIEW_3D
 831         grid_scale = space.overlay.grid_scale
 832         grid_subdivisions = space.overlay.grid_subdivisions
 833
 834         # Use the grid scale and subdivision to get the increment
 835         increment = (grid_scale / grid_subdivisions)
 836         half_increment = increment / 2
 837
 838         # Convert the 2d location of the mouse in 3d
 839         for index, loc in enumerate(reversed(mouse_pos)):
 840                 mouse_loc_3d = region_2d_to_location_3d(region, rv3d, loc, (0, 0, 0))
 841
 842                 # Get the remainder from the mouse location and the ratio
 843                 # Test if the remainder > to the half of the increment
 844                 for i in range(3):
 845                         modulo = mouse_loc_3d[i] % increment
 846                         if modulo < half_increment:
 847                                 modulo = - modulo
 848                         else:
 849                                 modulo = increment - modulo
 850
 851                         # Add the remainder to get the closest location on the grid
 852                         mouse_loc_3d[i] = mouse_loc_3d[i] + modulo
 853
 854                 # Get the snapped 2d location
 855                 snap_loc_2d = location_3d_to_region_2d(region, rv3d, mouse_loc_3d)
 856
 857                 # Replace the last mouse location by the snapped location
 858                 if len(self.mouse_path) > 0:
 859                         self.mouse_path[len(self.mouse_path) - (index + 1) ] = tuple(snap_loc_2d)
 860
 861 def mini_grid(self, context, color):
 862         """ Draw a snap mini grid around the cursor based on the overlay grid"""
 863         # Get the context arguments
 864         region = context.region
 865         rv3d = context.region_data
 866
 867         # Get the VIEW3D area
 868         for i, a in enumerate(context.screen.areas):
 869                 if a.type == 'VIEW_3D':
 870                         space = context.screen.areas[i].spaces.active
 871                         screen_height = context.screen.areas[i].height
 872                         screen_width = context.screen.areas[i].width
 873
 874         #Draw the snap grid, only in ortho view
 875         if not space.region_3d.is_perspective :
 876                 grid_scale = space.overlay.grid_scale
 877                 grid_subdivisions = space.overlay.grid_subdivisions
 878                 increment = (grid_scale / grid_subdivisions)
 879
 880                 # Get the 3d location of the mouse forced to a snap value in the operator
 881                 mouse_coord = self.mouse_path[len(self.mouse_path) - 1]
 882
 883                 snap_loc = region_2d_to_location_3d(region, rv3d, mouse_coord, (0, 0, 0))
 884
 885                 # Add the increment to get the closest location on the grid
 886                 snap_loc[0] += increment
 887                 snap_loc[1] += increment
 888
 889                 # Get the 2d location of the snap location
 890                 snap_loc = location_3d_to_region_2d(region, rv3d, snap_loc)
 891                 origin = location_3d_to_region_2d(region, rv3d, (0,0,0))
 892
 893                 # Get the increment value
 894                 snap_value = snap_loc[0] - mouse_coord[0]
 895
 896                 grid_coords = []
 897
 898                 # Draw lines on X and Z axis from the cursor through the screen
 899                 grid_coords = [
 900                 (0, mouse_coord[1]), (screen_width, mouse_coord[1]),
 901                 (mouse_coord[0], 0), (mouse_coord[0], screen_height)
 902                 ]
 903
 904                 # Draw a mlini grid around the cursor to show the snap options
 905                 grid_coords += [
 906                 (mouse_coord[0] + snap_value, mouse_coord[1] + 25 + snap_value),
 907                 (mouse_coord[0] + snap_value, mouse_coord[1] - 25 - snap_value),
 908                 (mouse_coord[0] + 25 + snap_value, mouse_coord[1] + snap_value),
 909                 (mouse_coord[0] - 25 - snap_value, mouse_coord[1] + snap_value),
 910                 (mouse_coord[0] - snap_value, mouse_coord[1] + 25 + snap_value),
 911                 (mouse_coord[0] - snap_value, mouse_coord[1] - 25 - snap_value),
 912                 (mouse_coord[0] + 25 + snap_value, mouse_coord[1] - snap_value),
 913                 (mouse_coord[0] - 25 - snap_value, mouse_coord[1] - snap_value),
 914                 ]
 915                 draw_shader(self, color, 0.3, 'LINES', grid_coords, size=2)
 916
 917
 918 def draw_shader(self, color, alpha, type, coords, size=1, indices=None):
 919         """ Create a batch for a draw type """
 920         bgl.glEnable(bgl.GL_BLEND)
 921         bgl.glEnable(bgl.GL_LINE_SMOOTH)
 922         if type =='POINTS':
 923                 bgl.glPointSize(size)
 924         else:
 925                 bgl.glLineWidth(size)
 926         try:
 927                 if len(coords[0])>2:
 928                         shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
 929                 else:
 930                         shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
 931                 batch = batch_for_shader(shader, type, {"pos": coords}, indices=indices)
 932                 shader.bind()
 933                 shader.uniform_float("color", (color[0], color[1], color[2], alpha))
 934                 batch.draw(shader)
 935                 bgl.glLineWidth(1)
 936                 bgl.glPointSize(1)
 937                 bgl.glDisable(bgl.GL_LINE_SMOOTH)
 938                 bgl.glDisable(bgl.GL_BLEND)
 939         except:
 940                 exc_type, exc_value, exc_traceback = sys.exc_info()
 941                 self.report({'ERROR'}, str(exc_value))