133 lines
5.9 KiB
Python
133 lines
5.9 KiB
Python
import bpy, mathutils
|
|
from bpy_extras import view3d_utils
|
|
from .draw import get_bounding_box_coords
|
|
from .poll import is_linked, is_instanced_data
|
|
|
|
|
|
#### ------------------------------ FUNCTIONS ------------------------------ ####
|
|
|
|
def cursor_snap(self, context, event, mouse_pos):
|
|
"""Find the closest position on the overlay grid and snap the mouse on it"""
|
|
|
|
region = context.region
|
|
rv3d = context.region_data
|
|
|
|
for i, a in enumerate(context.screen.areas):
|
|
if a.type == 'VIEW_3D':
|
|
space = context.screen.areas[i].spaces.active
|
|
|
|
# get_the_grid_overlay
|
|
grid_scale = space.overlay.grid_scale
|
|
grid_subdivisions = space.overlay.grid_subdivisions
|
|
|
|
# use_grid_scale_and_subdivision_to_get_the_increment
|
|
increment = (grid_scale / grid_subdivisions)
|
|
half_increment = increment / 2
|
|
|
|
# convert_2d_location_of_the_mouse_in_3d
|
|
for index, loc in enumerate(reversed(mouse_pos)):
|
|
mouse_loc_3d = view3d_utils.region_2d_to_location_3d(region, rv3d, loc, (0, 0, 0))
|
|
|
|
# get_the_remainder_from_the_mouse_location_and_the_ratio (test_if_the_remainder_>_to_the_half_of_the_increment)
|
|
for i in range(3):
|
|
modulo = mouse_loc_3d[i] % increment
|
|
if modulo < half_increment:
|
|
modulo = -modulo
|
|
else:
|
|
modulo = increment - modulo
|
|
|
|
# add_the_remainder_to_get_the_closest_location_on_the_grid
|
|
mouse_loc_3d[i] = mouse_loc_3d[i] + modulo
|
|
|
|
snap_loc_2d = view3d_utils.location_3d_to_region_2d(region, rv3d, mouse_loc_3d)
|
|
|
|
# replace_the_last_mouse_location_by_the_snapped_location
|
|
if len(self.mouse_path) > 0:
|
|
self.mouse_path[len(self.mouse_path) - (index + 1) ] = tuple(snap_loc_2d)
|
|
|
|
|
|
def is_inside_selection(context, obj, rect_min, rect_max):
|
|
"""Checks if the bounding box of an object intersects with the selection bounding box"""
|
|
|
|
region = context.region
|
|
rv3d = context.space_data.region_3d
|
|
|
|
bound_corners = [obj.matrix_world @ mathutils.Vector(corner) for corner in obj.bound_box]
|
|
bound_corners_2d = [view3d_utils.location_3d_to_region_2d(region, rv3d, corner) for corner in bound_corners]
|
|
|
|
# check_if_2d_point_is_inside_rectangle_(defined_by_min_and_max_points)
|
|
for corner_2d in bound_corners_2d:
|
|
if corner_2d and (rect_min.x <= corner_2d.x <= rect_max.x and rect_min.y <= corner_2d.y <= rect_max.y):
|
|
return True
|
|
|
|
# check_if_any_part_of_the_bounding_box_intersects_the_selection_rectangle
|
|
min_x = min(corner_2d.x for corner_2d in bound_corners_2d if corner_2d)
|
|
max_x = max(corner_2d.x for corner_2d in bound_corners_2d if corner_2d)
|
|
min_y = min(corner_2d.y for corner_2d in bound_corners_2d if corner_2d)
|
|
max_y = max(corner_2d.y for corner_2d in bound_corners_2d if corner_2d)
|
|
|
|
return not (max_x < rect_min.x or min_x > rect_max.x or max_y < rect_min.y or min_y > rect_max.y)
|
|
|
|
|
|
def selection_fallback(self, context, objects, include_cutters=False):
|
|
"""Selects mesh objects that fall inside given 2d rectangle coordinates"""
|
|
"""Used to get exactly which objects should be cut and avoid adding and applying unnecessary modifiers"""
|
|
"""NOTE: bounding box isn't always returning correct results for objects, but full surface check would be too expensive"""
|
|
|
|
# convert_2d_rectangle_coordinates_to_world_coordinates
|
|
if self.origin == 'EDGE':
|
|
if self.shape == 'POLYLINE':
|
|
x_values = [point[0] for point in self.mouse_path]
|
|
y_values = [point[1] for point in self.mouse_path]
|
|
rect_min = mathutils.Vector((min(x_values), min(y_values)))
|
|
rect_max = mathutils.Vector((max(x_values), max(y_values)))
|
|
else:
|
|
rect_min = mathutils.Vector((min(self.mouse_path[0][0], self.mouse_path[1][0]),
|
|
min(self.mouse_path[0][1], self.mouse_path[1][1])))
|
|
rect_max = mathutils.Vector((max(self.mouse_path[0][0], self.mouse_path[1][0]),
|
|
max(self.mouse_path[0][1], self.mouse_path[1][1])))
|
|
|
|
elif self.origin == 'CENTER':
|
|
# ensure_bounding_box_(needed_when_array_is_set_before_original_is_drawn)
|
|
if len(self.center_origin) == 0:
|
|
get_bounding_box_coords(self, self.verts)
|
|
|
|
rect_min = mathutils.Vector((min(self.center_origin[0][0], self.center_origin[1][0]),
|
|
min(self.center_origin[0][1], self.center_origin[1][1])))
|
|
rect_max = mathutils.Vector((max(self.center_origin[0][0], self.center_origin[1][0]),
|
|
max(self.center_origin[0][1], self.center_origin[1][1])))
|
|
|
|
# ARRAY
|
|
if self.rows > 1:
|
|
rect_max.x = rect_min.x + (rect_max.x - rect_min.x) * self.rows + (self.rows_gap * (self.rows - 1))
|
|
if self.columns > 1:
|
|
rect_min.y = rect_max.y - (rect_max.y - rect_min.y) * self.columns - (self.columns_gap * (self.columns - 1))
|
|
|
|
intersecting_objects = []
|
|
for obj in objects:
|
|
if obj.type != 'MESH':
|
|
continue
|
|
if obj == self.cutter:
|
|
continue
|
|
if tuple(round(v, 4) for v in obj.dimensions) == (0.0, 0.0, 0.0):
|
|
continue
|
|
if include_cutters == False and obj.booleans.cutter != "":
|
|
continue
|
|
|
|
if is_inside_selection(context, obj, rect_min, rect_max):
|
|
if is_linked(context, obj):
|
|
self.report({'ERROR'}, f"{obj.name} is linked and can not be carved")
|
|
continue
|
|
|
|
if self.mode == 'DESTRUCTIVE':
|
|
if obj.data.shape_keys:
|
|
self.report({'ERROR'}, f"Modifiers can't be applied to {obj.name} because it has shape keys")
|
|
continue
|
|
if is_instanced_data(obj):
|
|
self.report({'ERROR'}, f"Modifiers can't be applied to {obj.name} because it has instanced object data")
|
|
continue
|
|
|
|
intersecting_objects.append(obj)
|
|
|
|
return intersecting_objects
|