Make room splitting a bit more optional

Author: rogual

common_utils.py

@@ -60,6 +60,48 @@ def pad_front(xs, n, pad):
     return xs
 
 
+@dataclass
+class Vec2:
+    x: float
+    y: float
+
+    def __getitem__(self, i):
+        return [self.x, self.y][i]
+
+    def __setitem__(self, i, v):
+        if i == 0: self.x = v
+        elif i == 1: self.y = v
+        else: raise IndexError(i)
+
+    def __add__(self, o):
+        return Vec2(self.x + o.x, self.y + o.y)
+
+    def __sub__(self, o):
+        return Vec2(self.x - o.x, self.y - o.y)
+
+    def __mul__(self, f):
+        return Vec2(self.x * f, self.y * f)
+
+    def __iter__(self):
+        return iter([self.x, self.y])
+
+
+@dataclass
+class Vec3:
+    x: float
+    y: float
+    z: float
+
+    def __getitem__(self, i):
+        return [self.x, self.y, self.z][i]
+
+    def __setitem__(self, i, v):
+        if i == 0: self.x = v
+        elif i == 1: self.y = v
+        elif i == 2: self.z = v
+        else: raise IndexError(i)
+
+
 @dataclass
 class Range:
     a: float = float('inf')
@@ -171,4 +213,62 @@ def __bool__(self):
 def bounds_union(a, b): return a.union(b)
 def bounds_intersection(a, b): return a.intersection(b)
 
+@dataclass
+class Rect:
+    origin: Vec2
+    size: Vec2
+
+    @classmethod
+    def centered(cls, c, size):
+        return Rect(
+            c - size * .5,
+            size
+        )
 
+    @property
+    def min(self):
+        return self.origin
+
+    @min.setter
+    def min(self, p):
+        self.origin = p
+
+    @property
+    def max(self):
+        return self.origin + self.size
+
+    @max.setter
+    def max(self, p):
+        self.size = p - self.origin
+
+    @classmethod
+    def bounding_points(cls, *points):
+        log('bp', points)
+        r = Rect(
+            points[0],
+            Vec2(0, 0)
+        )
+        for p in points[1:]:
+            r = r.bounds_union(Rect(p, Vec2(1, 1)))
+        return r
+
+    def bounds_union(self, o):
+        log(self, o, self.min, o.min)
+        x0 = min(self.min.x, o.min.x)
+        x1 = max(self.max.x, o.max.x)
+        y0 = min(self.min.y, o.min.y)
+        y1 = max(self.max.y, o.max.y)
+        return Rect(Vec2(x0, y0), Vec2(x1 - x0, y1 - y0))
+
+    def expand(self, v):
+        r = Rect(self.origin, self.size)
+        r.origin = r.origin - Vec2(v, v)
+        r.size = r.size + Vec2(2*v, 2*v)
+        return r
+
+    def __add__(self, v):
+        return Rect(
+            self.origin + v,
+            self.size
+        )
+        

scene.py

@@ -94,6 +94,9 @@ def floors(self):
 
         planes = floor_planes + [ztop]
 
+        if floor_planes == []:
+            return [Floor(self, 0, -9999, 9999)]
+
         return [
             Floor(self, index, low, high)
             for index, (low, high) in enumerate(itertools.pairwise(planes))

scene_map.py

@@ -230,15 +230,18 @@ def clipped_layer_geometry(self, layer):
             clipped_obj.data.materials.clear()
             clipped_obj.data.materials.append(mat_room)
 
-            # TODO: Create this node group
-            mod = clipped_obj.modifiers.new('mod', 'NODES')
-            mod.node_group = bpy.data.node_groups['FlipNormals']
+            # We can skip actually clipping it if this is a single-layer room
+            if len(layer.room.layers) > 1:
 
-            clip_object(clipped_obj, layer.floor.volume_object)
+                # TODO: Create this node group
+                mod = clipped_obj.modifiers.new('mod', 'NODES')
+                mod.node_group = bpy.data.node_groups['FlipNormals']
 
-            # TODO: Create this node group
-            mod = clipped_obj.modifiers.new('mod', 'NODES')
-            mod.node_group = bpy.data.node_groups['FlipNormals']
+                clip_object(clipped_obj, layer.floor.volume_object)
+
+                # TODO: Create this node group
+                mod = clipped_obj.modifiers.new('mod', 'NODES')
+                mod.node_group = bpy.data.node_groups['FlipNormals']
         return collection
 
 

scene_split.py

@@ -59,7 +59,7 @@ def split(scene):
         cull(room, room_geom)
 
         if len(room_geom.data.vertices) == 0:
-            raise Exception("Room {room} has no vertices")
+            raise Exception(f"{room} has no vertices")
 
 
 def cull(room, geom):

utils.py

@@ -97,108 +97,6 @@ def clip_object(obj1, obj2):
     #bpy.ops.object.modifier_apply(apply_as='DATA', modifier='mod')
 
 
-@dataclass
-class Vec2:
-    x: float
-    y: float
-
-    def __getitem__(self, i):
-        return [self.x, self.y][i]
-
-    def __setitem__(self, i, v):
-        if i == 0: self.x = v
-        elif i == 1: self.y = v
-        else: raise IndexError(i)
-
-    def __add__(self, o):
-        return Vec2(self.x + o.x, self.y + o.y)
-
-    def __sub__(self, o):
-        return Vec2(self.x - o.x, self.y - o.y)
-
-    def __mul__(self, f):
-        return Vec2(self.x * f, self.y * f)
-
-    def __iter__(self):
-        return iter([self.x, self.y])
-
-
-@dataclass
-class Vec3:
-    x: float
-    y: float
-    z: float
-
-    def __getitem__(self, i):
-        return [self.x, self.y, self.z][i]
-
-    def __setitem__(self, i, v):
-        if i == 0: self.x = v
-        elif i == 1: self.y = v
-        elif i == 2: self.z = v
-        else: raise IndexError(i)
-
-
-@dataclass
-class Rect:
-    origin: Vec2
-    size: Vec2
-
-    @classmethod
-    def centered(cls, c, size):
-        return Rect(
-            c - size * .5,
-            size
-        )
-
-    @property
-    def min(self):
-        return self.origin
-
-    @min.setter
-    def min(self, p):
-        self.origin = p
-
-    @property
-    def max(self):
-        return self.origin + self.size
-
-    @max.setter
-    def max(self, p):
-        self.size = p - self.origin
-
-    @classmethod
-    def bounding_points(cls, *points):
-        log('bp', points)
-        r = Rect(
-            points[0],
-            Vec2(0, 0)
-        )
-        for p in points[1:]:
-            r = r.bounds_union(Rect(p, Vec2(1, 1)))
-        return r
-
-    def bounds_union(self, o):
-        log(self, o, self.min, o.min)
-        x0 = min(self.min.x, o.min.x)
-        x1 = max(self.max.x, o.max.x)
-        y0 = min(self.min.y, o.min.y)
-        y1 = max(self.max.y, o.max.y)
-        return Rect(Vec2(x0, y0), Vec2(x1 - x0, y1 - y0))
-
-    def expand(self, v):
-        r = Rect(self.origin, self.size)
-        r.origin = r.origin - Vec2(v, v)
-        r.size = r.size + Vec2(2*v, 2*v)
-        return r
-
-    def __add__(self, v):
-        return Rect(
-            self.origin + v,
-            self.size
-        )
-        
-
 def map_rect(from_rect, to_rect):
     ax0, ay0 = from_rect.origin
     bx0, by0 = to_rect.origin
@@ -214,6 +112,7 @@ def map_rect(from_rect, to_rect):
 
 
 
+
 class Image:
     def __init__(self, key):
         self.key = key