archipack: T52120 release to official

1 files changed, 678 insertions, 0 deletions

diff --git a/archipack/archipack_autoboolean.py b/archipack/archipack_autoboolean.py
new file mode 100644
index 00000000..a171532c
--- /dev/null
+++ b/archipack/archipack_autoboolean.py
@@ -0,0 +1,678 @@
+# -*- coding:utf-8 -*-
+
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# ----------------------------------------------------------
+# Author: Stephen Leger (s-leger)
+#
+# ----------------------------------------------------------
+import bpy
+from bpy.types import Operator
+from bpy.props import EnumProperty
+from mathutils import Vector
+from .materialutils import MaterialUtils
+
+from os import path
+
+
+def debug_using_gl(context, filename):
+    context.scene.update()
+    temp_path = "C:\\tmp\\"
+    context.scene.render.filepath = path.join(temp_path, filename + ".png")
+    bpy.ops.render.opengl(write_still=True)
+
+
+class ArchipackBoolManager():
+    """
+        Handle three methods for booleans
+        - interactive: one modifier for each hole right on wall
+        - robust: one single modifier on wall and merge holes in one mesh
+        - mixed: merge holes with boolean and use result on wall
+            may be slow, but is robust
+    """
+    def __init__(self, mode, solver_mode='CARVE'):
+        """
+            mode in 'ROBUST', 'INTERACTIVE', 'HYBRID'
+        """
+        self.mode = mode
+        self.solver_mode = solver_mode
+        # internal variables
+        self.itM = None
+        self.min_x = 0
+        self.min_y = 0
+        self.min_z = 0
+        self.max_x = 0
+        self.max_y = 0
+        self.max_z = 0
+
+    def _get_bounding_box(self, wall):
+        self.itM = wall.matrix_world.inverted()
+        x, y, z = wall.bound_box[0]
+        self.min_x = x
+        self.min_y = y
+        self.min_z = z
+        x, y, z = wall.bound_box[6]
+        self.max_x = x
+        self.max_y = y
+        self.max_z = z
+        self.center = Vector((
+            self.min_x + 0.5 * (self.max_x - self.min_x),
+            self.min_y + 0.5 * (self.max_y - self.min_y),
+            self.min_z + 0.5 * (self.max_z - self.min_z)))
+
+    def _contains(self, pt):
+        p = self.itM * pt
+        return (p.x >= self.min_x and p.x <= self.max_x and
+            p.y >= self.min_y and p.y <= self.max_y and
+            p.z >= self.min_z and p.z <= self.max_z)
+
+    def filter_wall(self, wall):
+        d = wall.data
+        return (d is None or
+               'archipack_window' in d or
+               'archipack_window_panel' in d or
+               'archipack_door' in d or
+               'archipack_doorpanel' in d or
+               'archipack_hole' in wall or
+               'archipack_robusthole' in wall or
+               'archipack_handle' in wall)
+
+    def datablock(self, o):
+        """
+            get datablock from windows and doors
+            return
+                datablock if found
+                None when not found
+        """
+        d = None
+        if o.data:
+            if "archipack_window" in o.data:
+                d = o.data.archipack_window[0]
+            elif "archipack_door" in o.data:
+                d = o.data.archipack_door[0]
+        return d
+
+    def prepare_hole(self, hole):
+        hole.lock_location = (True, True, True)
+        hole.lock_rotation = (True, True, True)
+        hole.lock_scale = (True, True, True)
+        hole.draw_type = 'WIRE'
+        hole.hide_render = True
+        hole.hide_select = True
+        hole.select = True
+        hole.cycles_visibility.camera = False
+        hole.cycles_visibility.diffuse = False
+        hole.cycles_visibility.glossy = False
+        hole.cycles_visibility.shadow = False
+        hole.cycles_visibility.scatter = False
+        hole.cycles_visibility.transmission = False
+
+    def get_child_hole(self, o):
+        for hole in o.children:
+            if "archipack_hole" in hole:
+                return hole
+        return None
+
+    def _generate_hole(self, context, o):
+        # use existing one
+        if self.mode != 'ROBUST':
+            hole = self.get_child_hole(o)
+            if hole is not None:
+                # print("_generate_hole Use existing hole %s" % (hole.name))
+                return hole
+        # generate single hole from archipack primitives
+        d = self.datablock(o)
+        hole = None
+        if d is not None:
+            if (self.itM is not None and (
+                    self._contains(o.location) or
+                    self._contains(o.matrix_world * Vector((0, 0, 0.5 * d.z))))
+                    ):
+                if self.mode != 'ROBUST':
+                    hole = d.interactive_hole(context, o)
+                else:
+                    hole = d.robust_hole(context, o.matrix_world)
+                # print("_generate_hole Generate hole %s" % (hole.name))
+            else:
+                hole = d.interactive_hole(context, o)
+        return hole
+
+    def partition(self, array, begin, end):
+        pivot = begin
+        for i in range(begin + 1, end + 1):
+            if array[i][1] <= array[begin][1]:
+                pivot += 1
+                array[i], array[pivot] = array[pivot], array[i]
+        array[pivot], array[begin] = array[begin], array[pivot]
+        return pivot
+
+    def quicksort(self, array, begin=0, end=None):
+        if end is None:
+            end = len(array) - 1
+
+        def _quicksort(array, begin, end):
+            if begin >= end:
+                return
+            pivot = self.partition(array, begin, end)
+            _quicksort(array, begin, pivot - 1)
+            _quicksort(array, pivot + 1, end)
+        return _quicksort(array, begin, end)
+
+    def sort_holes(self, wall, holes):
+        """
+            sort hole from center to borders by distance from center
+            may improve nested booleans
+        """
+        center = wall.matrix_world * self.center
+        holes = [(o, (o.matrix_world.translation - center).length) for o in holes]
+        self.quicksort(holes)
+        return [o[0] for o in holes]
+
+    def difference(self, basis, hole, solver=None):
+        # print("difference %s" % (hole.name))
+        m = basis.modifiers.new('AutoBoolean', 'BOOLEAN')
+        m.operation = 'DIFFERENCE'
+        if solver is None:
+            m.solver = self.solver_mode
+        else:
+            m.solver = solver
+        m.object = hole
+
+    def union(self, basis, hole):
+        # print("union %s" % (hole.name))
+        m = basis.modifiers.new('AutoMerge', 'BOOLEAN')
+        m.operation = 'UNION'
+        m.solver = self.solver_mode
+        m.object = hole
+
+    def remove_modif_and_object(self, context, o, to_delete):
+        # print("remove_modif_and_object removed:%s" % (len(to_delete)))
+        for m, h in to_delete:
+            if m is not None:
+                if m.object is not None:
+                    m.object = None
+                o.modifiers.remove(m)
+            if h is not None:
+                context.scene.objects.unlink(h)
+                bpy.data.objects.remove(h, do_unlink=True)
+
+    # Mixed
+    def create_merge_basis(self, context, wall):
+        # print("create_merge_basis")
+        h = bpy.data.meshes.new("AutoBoolean")
+        hole_obj = bpy.data.objects.new("AutoBoolean", h)
+        context.scene.objects.link(hole_obj)
+        hole_obj['archipack_hybridhole'] = True
+        if wall.parent is not None:
+            hole_obj.parent = wall.parent
+        hole_obj.matrix_world = wall.matrix_world.copy()
+        MaterialUtils.add_wall2_materials(hole_obj)
+        return hole_obj
+
+    def update_hybrid(self, context, wall, childs, holes):
+        """
+            Update all holes modifiers
+            remove holes not found in childs
+
+            robust -> mixed:
+                there is only one object taged with "archipack_robusthole"
+            interactive -> mixed:
+                many modifisers on wall taged with "archipack_hole"
+                keep objects
+        """
+        existing = []
+        to_delete = []
+
+        # robust/interactive -> mixed
+        for m in wall.modifiers:
+            if m.type == 'BOOLEAN':
+                if m.object is None:
+                    to_delete.append([m, None])
+                elif 'archipack_hole' in m.object:
+                    h = m.object
+                    if h in holes:
+                        to_delete.append([m, None])
+                    else:
+                        to_delete.append([m, h])
+                elif 'archipack_robusthole' in m.object:
+                    to_delete.append([m, m.object])
+
+        # remove modifier and holes not found in new list
+        self.remove_modif_and_object(context, wall, to_delete)
+
+        m = wall.modifiers.get("AutoMixedBoolean")
+        if m is None:
+            m = wall.modifiers.new('AutoMixedBoolean', 'BOOLEAN')
+            m.solver = self.solver_mode
+            m.operation = 'DIFFERENCE'
+
+        if m.object is None:
+            hole_obj = self.create_merge_basis(context, wall)
+        else:
+            hole_obj = m.object
+        # debug_using_gl(context, "260")
+        m.object = hole_obj
+        self.prepare_hole(hole_obj)
+        # debug_using_gl(context, "263")
+        to_delete = []
+
+        # mixed-> mixed
+        for m in hole_obj.modifiers:
+            h = m.object
+            if h in holes:
+                existing.append(h)
+            else:
+                to_delete.append([m, h])
+
+        # remove modifier and holes not found in new list
+        self.remove_modif_and_object(context, hole_obj, to_delete)
+        # debug_using_gl(context, "276")
+        # add modifier and holes not found in existing
+        for h in holes:
+            if h not in existing:
+                self.union(hole_obj, h)
+        # debug_using_gl(context, "281")
+
+    # Interactive
+    def update_interactive(self, context, wall, childs, holes):
+
+        existing = []
+
+        to_delete = []
+
+        hole_obj = None
+
+        # mixed-> interactive
+        for m in wall.modifiers:
+            if m.type == 'BOOLEAN':
+                if m.object is not None and 'archipack_hybridhole' in m.object:
+                    hole_obj = m.object
+                    break
+
+        if hole_obj is not None:
+            for m in hole_obj.modifiers:
+                h = m.object
+                if h not in holes:
+                    to_delete.append([m, h])
+            # remove modifier and holes not found in new list
+            self.remove_modif_and_object(context, hole_obj, to_delete)
+            context.scene.objects.unlink(hole_obj)
+            bpy.data.objects.remove(hole_obj, do_unlink=True)
+
+        to_delete = []
+
+        # interactive/robust -> interactive
+        for m in wall.modifiers:
+            if m.type == 'BOOLEAN':
+                if m.object is None:
+                    to_delete.append([m, None])
+                elif 'archipack_hole' in m.object:
+                    h = m.object
+                    if h in holes:
+                        existing.append(h)
+                    else:
+                        to_delete.append([m, h])
+                elif 'archipack_robusthole' in m.object:
+                    to_delete.append([m, m.object])
+
+        # remove modifier and holes not found in new list
+        self.remove_modif_and_object(context, wall, to_delete)
+
+        # add modifier and holes not found in existing
+        for h in holes:
+            if h not in existing:
+                self.difference(wall, h)
+
+    # Robust
+    def update_robust(self, context, wall, childs):
+
+        modif = None
+
+        to_delete = []
+
+        # robust/interactive/mixed -> robust
+        for m in wall.modifiers:
+            if m.type == 'BOOLEAN':
+                if m.object is None:
+                    to_delete.append([m, None])
+                elif 'archipack_robusthole' in m.object:
+                    modif = m
+                    to_delete.append([None, m.object])
+                elif 'archipack_hole' in m.object:
+                    to_delete.append([m, m.object])
+                elif 'archipack_hybridhole' in m.object:
+                    to_delete.append([m, m.object])
+                    o = m.object
+                    for m in o.modifiers:
+                        to_delete.append([None, m.object])
+
+        # remove modifier and holes
+        self.remove_modif_and_object(context, wall, to_delete)
+
+        if bool(len(context.selected_objects) > 0):
+            # more than one hole : join, result becomes context.object
+            if len(context.selected_objects) > 1:
+                bpy.ops.object.join()
+                context.object['archipack_robusthole'] = True
+
+            hole = context.object
+            hole.name = 'AutoBoolean'
+
+            childs.append(hole)
+
+            if modif is None:
+                self.difference(wall, hole)
+            else:
+                modif.object = hole
+        elif modif is not None:
+            wall.modifiers.remove(modif)
+
+    def autoboolean(self, context, wall):
+        """
+            Entry point for multi-boolean operations like
+            in T panel autoBoolean and RobustBoolean buttons
+        """
+        bpy.ops.object.select_all(action='DESELECT')
+        context.scene.objects.active = None
+        childs = []
+        holes = []
+        # get wall bounds to find what's inside
+        self._get_bounding_box(wall)
+
+        # either generate hole or get existing one
+        for o in context.scene.objects:
+            h = self._generate_hole(context, o)
+            if h is not None:
+                holes.append(h)
+                childs.append(o)
+        # debug_using_gl(context, "395")
+        self.sort_holes(wall, holes)
+
+        # hole(s) are selected and active after this one
+        for hole in holes:
+            self.prepare_hole(hole)
+        # debug_using_gl(context, "401")
+
+        # update / remove / add  boolean modifier
+        if self.mode == 'INTERACTIVE':
+            self.update_interactive(context, wall, childs, holes)
+        elif self.mode == 'ROBUST':
+            self.update_robust(context, wall, childs)
+        else:
+            self.update_hybrid(context, wall, childs, holes)
+
+        bpy.ops.object.select_all(action='DESELECT')
+        # parenting childs to wall reference point
+        if wall.parent is None:
+            x, y, z = wall.bound_box[0]
+            context.scene.cursor_location = wall.matrix_world * Vector((x, y, z))
+            # fix issue #9
+            context.scene.objects.active = wall
+            bpy.ops.archipack.reference_point()
+        else:
+            wall.parent.select = True
+            context.scene.objects.active = wall.parent
+        # debug_using_gl(context, "422")
+        wall.select = True
+        for o in childs:
+            if 'archipack_robusthole' in o:
+                o.hide_select = False
+            o.select = True
+        # debug_using_gl(context, "428")
+
+        bpy.ops.archipack.parent_to_reference()
+
+        for o in childs:
+            if 'archipack_robusthole' in o:
+                o.hide_select = True
+        # debug_using_gl(context, "435")
+
+    def detect_mode(self, context, wall):
+        for m in wall.modifiers:
+            if m.type == 'BOOLEAN' and m.object is not None:
+                if 'archipack_hole' in m.object:
+                    self.mode = 'INTERACTIVE'
+                if 'archipack_hybridhole' in m.object:
+                    self.mode = 'HYBRID'
+                if 'archipack_robusthole' in m.object:
+                    self.mode = 'ROBUST'
+
+    def singleboolean(self, context, wall, o):
+        """
+            Entry point for single boolean operations
+            in use in draw door and windows over wall
+            o is either a window or a door
+        """
+        # generate holes for crossing window and doors
+        self.itM = wall.matrix_world.inverted()
+        d = self.datablock(o)
+        hole = None
+        hole_obj = None
+        # default mode defined by __init__
+        self.detect_mode(context, wall)
+
+        if d is not None:
+            if self.mode != 'ROBUST':
+                hole = d.interactive_hole(context, o)
+            else:
+                hole = d.robust_hole(context, o.matrix_world)
+        if hole is None:
+            return
+
+        self.prepare_hole(hole)
+
+        if self.mode == 'INTERACTIVE':
+            # update / remove / add  boolean modifier
+            self.difference(wall, hole)
+
+        elif self.mode == 'HYBRID':
+            m = wall.modifiers.get('AutoMixedBoolean')
+
+            if m is None:
+                m = wall.modifiers.new('AutoMixedBoolean', 'BOOLEAN')
+                m.operation = 'DIFFERENCE'
+                m.solver = self.solver_mode
+
+            if m.object is None:
+                hole_obj = self.create_merge_basis(context, wall)
+                m.object = hole_obj
+            else:
+                hole_obj = m.object
+            self.union(hole_obj, hole)
+
+        bpy.ops.object.select_all(action='DESELECT')
+
+        # parenting childs to wall reference point
+        if wall.parent is None:
+            x, y, z = wall.bound_box[0]
+            context.scene.cursor_location = wall.matrix_world * Vector((x, y, z))
+            # fix issue #9
+            context.scene.objects.active = wall
+            bpy.ops.archipack.reference_point()
+        else:
+            context.scene.objects.active = wall.parent
+
+        if hole_obj is not None:
+            hole_obj.select = True
+
+        wall.select = True
+        o.select = True
+        bpy.ops.archipack.parent_to_reference()
+        wall.select = True
+        context.scene.objects.active = wall
+        d = wall.data.archipack_wall2[0]
+        g = d.get_generator()
+        d.setup_childs(wall, g)
+        d.relocate_childs(context, wall, g)
+
+        if hole_obj is not None:
+            self.prepare_hole(hole_obj)
+
+
+class ARCHIPACK_OT_single_boolean(Operator):
+    bl_idname = "archipack.single_boolean"
+    bl_label = "SingleBoolean"
+    bl_description = "Add single boolean for doors and windows"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+    mode = EnumProperty(
+        name="Mode",
+        items=(
+            ('INTERACTIVE', 'INTERACTIVE', 'Interactive, fast but may fail', 0),
+            ('ROBUST', 'ROBUST', 'Not interactive, robust', 1),
+            ('HYBRID', 'HYBRID', 'Interactive, slow but robust', 2)
+            ),
+        default='HYBRID'
+        )
+    solver_mode = EnumProperty(
+        name="Solver",
+        items=(
+            ('CARVE', 'CARVE', 'Slow but robust (could be slow in hybrid mode with many holes)', 0),
+            ('BMESH', 'BMESH', 'Fast but more prone to errors', 1)
+            ),
+        default='BMESH'
+        )
+    """
+        Wall must be active object
+        window or door must be selected
+    """
+
+    @classmethod
+    def poll(cls, context):
+        w = context.active_object
+        return (w.data is not None and
+            "archipack_wall2" in w.data and
+            len(context.selected_objects) == 2
+            )
+
+    def draw(self, context):
+        pass
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            wall = context.active_object
+            manager = ArchipackBoolManager(mode=self.mode, solver_mode=self.solver_mode)
+            for o in context.selected_objects:
+                if o != wall:
+                    manager.singleboolean(context, wall, o)
+                    break
+            o.select = False
+            wall.select = True
+            context.scene.objects.active = wall
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+class ARCHIPACK_OT_auto_boolean(Operator):
+    bl_idname = "archipack.auto_boolean"
+    bl_label = "AutoBoolean"
+    bl_description = "Automatic boolean for doors and windows"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+    mode = EnumProperty(
+        name="Mode",
+        items=(
+            ('INTERACTIVE', 'INTERACTIVE', 'Interactive, fast but may fail', 0),
+            ('ROBUST', 'ROBUST', 'Not interactive, robust', 1),
+            ('HYBRID', 'HYBRID', 'Interactive, slow but robust', 2)
+            ),
+        default='HYBRID'
+        )
+    solver_mode = EnumProperty(
+        name="Solver",
+        items=(
+            ('CARVE', 'CARVE', 'Slow but robust (could be slow in hybrid mode with many holes)', 0),
+            ('BMESH', 'BMESH', 'Fast but more prone to errors', 1)
+            ),
+        default='BMESH'
+        )
+
+    def draw(self, context):
+        layout = self.layout
+        row = layout.row()
+        row.prop(self, 'mode')
+        row.prop(self, 'solver_mode')
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            manager = ArchipackBoolManager(mode=self.mode, solver_mode=self.solver_mode)
+            active = context.scene.objects.active
+            walls = [wall for wall in context.selected_objects if not manager.filter_wall(wall)]
+            bpy.ops.object.select_all(action='DESELECT')
+            for wall in walls:
+                manager.autoboolean(context, wall)
+                bpy.ops.object.select_all(action='DESELECT')
+                wall.select = True
+                context.scene.objects.active = wall
+                if wall.data is not None and 'archipack_wall2' in wall.data:
+                    bpy.ops.archipack.wall2_manipulate('EXEC_DEFAULT')
+            # reselect walls
+            bpy.ops.object.select_all(action='DESELECT')
+            for wall in walls:
+                wall.select = True
+            context.scene.objects.active = active
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+class ARCHIPACK_OT_generate_hole(Operator):
+    bl_idname = "archipack.generate_hole"
+    bl_label = "Generate hole"
+    bl_description = "Generate interactive hole for doors and windows"
+    bl_category = 'Archipack'
+    bl_options = {'REGISTER', 'UNDO'}
+
+    def execute(self, context):
+        if context.mode == "OBJECT":
+            manager = ArchipackBoolManager(mode='HYBRID')
+            o = context.active_object
+            d = manager.datablock(o)
+            if d is None:
+                self.report({'WARNING'}, "Archipack: active object must be a door or a window")
+                return {'CANCELLED'}
+            bpy.ops.object.select_all(action='DESELECT')
+            o.select = True
+            context.scene.objects.active = o
+            hole = manager._generate_hole(context, o)
+            manager.prepare_hole(hole)
+            hole.select = False
+            o.select = True
+            context.scene.objects.active = o
+            return {'FINISHED'}
+        else:
+            self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
+            return {'CANCELLED'}
+
+
+def register():
+    bpy.utils.register_class(ARCHIPACK_OT_generate_hole)
+    bpy.utils.register_class(ARCHIPACK_OT_single_boolean)
+    bpy.utils.register_class(ARCHIPACK_OT_auto_boolean)
+
+
+def unregister():
+    bpy.utils.unregister_class(ARCHIPACK_OT_generate_hole)
+    bpy.utils.unregister_class(ARCHIPACK_OT_single_boolean)
+    bpy.utils.unregister_class(ARCHIPACK_OT_auto_boolean)