Select Git revision
io_import_scene_lwo.py
archipack_floor.py 36.36 KiB
# -*- 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>
# ----------------------------------------------------------
# Base code inspired by JARCH Vis
# Original Author: Jacob Morris
# Author : Stephen Leger (s-leger)
# ----------------------------------------------------------
import bpy
from bpy.types import Operator, PropertyGroup, Mesh, Panel
from bpy.props import (
BoolProperty, EnumProperty, FloatProperty,
IntProperty, CollectionProperty
)
from random import uniform, randint
from math import tan, pi, sqrt
from mathutils import Vector
from .bmesh_utils import BmeshEdit as bmed
from .archipack_manipulator import Manipulable
from .archipack_preset import ArchipackPreset, PresetMenuOperator
from .archipack_object import ArchipackCreateTool, ArchipackObject
def create_flooring(if_tile, over_width, over_length, b_width, b_length, b_length2, is_length_vary,
length_vary, num_boards, space_l, space_w, spacing, t_width, t_length, is_offset, offset,
is_ran_offset, offset_vary, t_width2, is_width_vary, width_vary, max_boards, is_ran_thickness,
ran_thickness, th, hb_dir):
# create siding
if if_tile == "1": # Tiles Regular
return tile_regular(over_width, over_length, t_width, t_length, spacing, is_offset, offset,
is_ran_offset, offset_vary, th)
elif if_tile == "2": # Large + Small
return tile_ls(over_width, over_length, t_width, t_length, spacing, th)
elif if_tile == "3": # Large + Many Small
return tile_lms(over_width, over_length, t_width, spacing, th)
elif if_tile == "4": # Hexagonal
return tile_hexagon(over_width, over_length, t_width2, spacing, th)
elif if_tile == "21": # Planks
return wood_regular(over_width, over_length, b_width, b_length, space_l, space_w,
is_length_vary, length_vary,
is_width_vary, width_vary,
is_offset, offset,
is_ran_offset, offset_vary,
max_boards, is_ran_thickness,
ran_thickness, th)
elif if_tile == "22": # Parquet
return wood_parquet(over_width, over_length, b_width, spacing, num_boards, th)
elif if_tile == "23": # Herringbone Parquet
return wood_herringbone(over_width, over_length, b_width, b_length2, spacing, th, hb_dir, True)
elif if_tile == "24": # Herringbone
return wood_herringbone(over_width, over_length, b_width, b_length2, spacing, th, hb_dir, False)
return [], []
def wood_herringbone(ow, ol, bw, bl, s, th, hb_dir, stepped):
verts = []
faces = []
an_45 = 0.5 * sqrt(2)
x, y, z = 0.0, 0.0, th
x_off, y_off = 0.0, 0.0 # used for finding farther forwards points when stepped
ang_s = s * an_45
s45 = s / an_45
# step variables
if stepped:
x_off = an_45 * bw
y_off = an_45 * bw
wid_off = an_45 * bl # offset from one end of the board to the other inline with width
len_off = an_45 * bl # offset from one end of the board to the other inline with length
w = bw / an_45 # width adjusted for 45 degree rotation
# figure out starting position
if hb_dir == "1":
y = -wid_off
elif hb_dir == "2":
x = ow
y = ol + wid_off
elif hb_dir == "3":
x = -wid_off
y = ol
elif hb_dir == "4":
x = ow + wid_off
# loop going forwards
while (hb_dir == "1" and y < ol + wid_off) or (hb_dir == "2" and y > 0 - wid_off) or \
(hb_dir == "3" and x < ow + wid_off) or (hb_dir == "4" and x > 0 - wid_off):
going_forwards = True
# loop going right
while (hb_dir == "1" and x < ow) or (hb_dir == "2" and x > 0) or (hb_dir == "3" and y > 0 - y_off) or \
(hb_dir == "4" and y < ol + y_off):
p = len(verts)
# add verts
# forwards
verts.append((x, y, z))
if hb_dir == "1":
if stepped and x != 0:
verts.append((x - x_off, y + y_off, z))
else:
verts.append((x, y + w, z))
if going_forwards:
y += wid_off
else:
y -= wid_off
x += len_off
verts.append((x, y, z))
if stepped:
verts.append((x - x_off, y + y_off, z))
x -= x_off - ang_s
if going_forwards:
y += y_off + ang_s
else:
y -= y_off + ang_s
else:
verts.append((x, y + w, z))
x += s
# backwards
elif hb_dir == "2":
if stepped and x != ow:
verts.append((x + x_off, y - y_off, z))
else:
verts.append((x, y - w, z))
if going_forwards:
y -= wid_off
else:
y += wid_off
x -= len_off
verts.append((x, y, z))
if stepped:
verts.append((x + x_off, y - y_off, z))
x += x_off - ang_s
if going_forwards:
y -= y_off + ang_s
else:
y += y_off + ang_s
else:
verts.append((x, y - w, z))
x -= s
# right
elif hb_dir == "3":
if stepped and y != ol:
verts.append((x + y_off, y + x_off, z))
else:
verts.append((x + w, y, z))
if going_forwards:
x += wid_off
else:
x -= wid_off
y -= len_off
verts.append((x, y, z))
if stepped:
verts.append((x + y_off, y + x_off, z))
y += x_off - ang_s
if going_forwards:
x += y_off + ang_s
else:
x -= y_off + ang_s
else:
verts.append((x + w, y, z))
y -= s
# left
else:
if stepped and y != 0:
verts.append((x - y_off, y - x_off, z))
else:
verts.append((x - w, y, z))
if going_forwards:
x -= wid_off
else:
x += wid_off
y += len_off
verts.append((x, y, z))
if stepped:
verts.append((x - y_off, y - x_off, z))
y -= x_off - ang_s
if going_forwards:
x -= y_off + ang_s
else:
x += y_off + ang_s
else:
verts.append((x - w, y, z))
y += s
# faces
faces.append((p, p + 2, p + 3, p + 1))
# flip going_right
going_forwards = not going_forwards
x_off *= -1
# if not in forwards position, then move back before adjusting values for next row
if not going_forwards:
x_off = abs(x_off)
if hb_dir == "1":
y -= wid_off
if stepped:
y -= y_off + ang_s
elif hb_dir == "2":
y += wid_off
if stepped:
y += y_off + ang_s
elif hb_dir == "3":
x -= wid_off
if stepped:
x -= y_off + ang_s
else:
x += wid_off
if stepped:
x += y_off + ang_s
# adjust forwards
if hb_dir == "1":
y += w + s45
x = 0
elif hb_dir == "2":
y -= w + s45
x = ow
elif hb_dir == "3":
x += w + s45
y = ol
else:
x -= w + s45
y = 0
return verts, faces
def tile_ls(ow, ol, tw, tl, s, z):
"""
pattern:
_____
| |_|
|___|
x and y are axis of big one
"""
verts = []
faces = []
# big half size
hw = (tw / 2) - (s / 2)
hl = (tl / 2) - (s / 2)
# small half size
hws = (tw / 4) - (s / 2)
hls = (tl / 4) - (s / 2)
# small, offset from big x,y
xo = 0.75 * tw
yo = 0.25 * tl
# offset for pattern
rx = 2.5 * tw
ry = 0.5 * tl
# width and a half of big
ow_x = ow + 0.5 * tw
ol_y = ol + 0.5 * tl
# start pattern with big one
x = tw
y = -tl
while y < ol_y:
while x < ow_x:
p = len(verts)
# Large
x0 = max(0, x - hw)
y0 = max(0, y - hl)
x1 = min(ow, x + hw)
y1 = min(ol, y + hl)
if y1 > 0:
if x1 > 0 and x0 < ow and y0 < ol:
verts.extend([(x0, y1, z), (x1, y1, z), (x1, y0, z), (x0, y0, z)])
faces.append((p, p + 1, p + 2, p + 3))
p = len(verts)
# Small
x0 = x + xo - hws
y0 = y + yo - hls
x1 = min(ow, x + xo + hws)
if x1 > 0 and x0 < ow and y0 < ol:
y1 = min(ol, y + yo + hls)
verts.extend([(x0, y1, z), (x1, y1, z), (x1, y0, z), (x0, y0, z)])
faces.append((p, p + 1, p + 2, p + 3))
x += rx
y += ry
x = x % rx - tw
if x < -tw:
x += rx
return verts, faces
def tile_hexagon(ow, ol, tw, s, z):
verts = []
faces = []
offset = False
w = tw / 2
y = 0.0
h = w * tan(pi / 6)
r = sqrt((w * w) + (h * h))
while y < ol + tw:
if not offset:
x = 0.0
else:
x = w + (s / 2)
while x < ow + tw:
p = len(verts)
verts.extend([(x + w, y + h, z), (x, y + r, z), (x - w, y + h, z),
(x - w, y - h, z), (x, y - r, z), (x + w, y - h, z)])
faces.extend([(p, p + 1, p + 2, p + 3), (p + 3, p + 4, p + 5, p)])
x += tw + s
y += r + h + s
offset = not offset
return verts, faces
def tile_lms(ow, ol, tw, s, z):
verts = []
faces = []
small = True
y = 0.0
ref = (tw - s) / 2
while y < ol:
x = 0.0
large = False
while x < ow:
if small:
x1 = min(x + ref, ow)
y1 = min(y + ref, ol)
p = len(verts)
verts.extend([(x, y1, z), (x, y, z)])
verts.extend([(x1, y1, z), (x1, y, z)])
faces.append((p, p + 1, p + 3, p + 2))
x += ref
else:
if not large:
x1 = min(x + ref, ow)
for i in range(2):
y0 = y + i * (ref + s)
if x < ow and y0 < ol:
y1 = min(y0 + ref, ol)
p = len(verts)
verts.extend([(x, y1, z), (x, y0, z)])
verts.extend([(x1, y1, z), (x1, y0, z)])
faces.append((p, p + 1, p + 3, p + 2))
x += ref
else:
x1 = min(x + tw, ow)
y1 = min(y + tw, ol)
p = len(verts)
verts.extend([(x, y1, z), (x, y, z)])
verts.extend([(x1, y1, z), (x1, y, z)])
faces.append((p, p + 1, p + 3, p + 2))
x += tw
large = not large
x += s
if small:
y += ref + s
else:
y += tw + s
small = not small
return verts, faces
def tile_regular(ow, ol, tw, tl, s, is_offset, offset, is_ran_offset, offset_vary, z):
verts = []
faces = []
off = False
o = 1 / (100 / offset)
y = 0.0
while y < ol:
tw2 = 0
if is_offset:
if is_ran_offset:
v = tw * 0.0049 * offset_vary
tw2 = uniform((tw / 2) - v, (tw / 2) + v)
elif off:
tw2 = o * tw
x = -tw2
y1 = min(ol, y + tl)
while x < ow:
p = len(verts)
x0 = max(0, x)
x1 = min(ow, x + tw)
verts.extend([(x0, y1, z), (x0, y, z), (x1, y, z), (x1, y1, z)])
faces.append((p, p + 1, p + 2, p + 3))
x = x1 + s
y += tl + s
off = not off
return verts, faces
def wood_parquet(ow, ol, bw, s, num_boards, z):
verts = []
faces = []
x = 0.0
start_orient_length = True
# figure board length
bl = (bw * num_boards) + (s * (num_boards - 1))
while x < ow:
y = 0.0
orient_length = start_orient_length
while y < ol:
if orient_length:
y0 = y
y1 = min(y + bl, ol)
for i in range(num_boards):
bx = x + i * (bw + s)
if bx < ow and y < ol:
# make sure board should be placed
x0 = bx
x1 = min(bx + bw, ow)
p = len(verts)
verts.extend([(x0, y0, z), (x1, y0, z), (x1, y1, z), (x0, y1, z)])
faces.append((p, p + 1, p + 2, p + 3))
else:
x0 = x
x1 = min(x + bl, ow)
for i in range(num_boards):
by = y + i * (bw + s)
if x < ow and by < ol:
y0 = by
y1 = min(by + bw, ol)
p = len(verts)
verts.extend([(x0, y0, z), (x1, y0, z), (x1, y1, z), (x0, y1, z)])
faces.append((p, p + 1, p + 2, p + 3))
y += bl + s
orient_length = not orient_length
start_orient_length = not start_orient_length
x += bl + s
return verts, faces
def wood_regular(ow, ol, bw, bl, s_l, s_w,
is_length_vary, length_vary,
is_width_vary, width_vary,
is_offset, offset,
is_ran_offset, offset_vary,
max_boards, is_r_h,
r_h, th):
verts = []
faces = []
x = 0.0
row = 0
while x < ow:
if is_width_vary:
v = bw * (width_vary / 100) * 0.499
bw2 = uniform(bw / 2 - v, bw / 2 + v)
else:
bw2 = bw
x1 = min(x + bw2, ow)
if is_offset:
if is_ran_offset:
v = bl * (offset_vary / 100) * 0.5
y = -uniform(bl / 2 - v, bl / 2 + v)
else:
y = -(row % 2) * bl * (offset / 100)
else:
y = 0
row += 1
counter = 1
while y < ol:
z = th
if is_r_h:
v = z * 0.5 * (r_h / 100)
z = uniform(z / 2 - v, z / 2 + v)
bl2 = bl
if is_length_vary:
if (counter >= max_boards):
bl2 = ol
else:
v = bl * (length_vary / 100) * 0.5
bl2 = uniform(bl / 2 - v, bl / 2 + v)
y0 = max(0, y)
y1 = min(y + bl2, ol)
if y1 > y0:
p = len(verts)
verts.extend([(x, y0, z), (x1, y0, z), (x1, y1, z), (x, y1, z)])
faces.append((p, p + 1, p + 2, p + 3))
y += bl2 + s_l
counter += 1
x += bw2 + s_w
return verts, faces
def tile_grout(ow, ol, depth, th):
z = min(th - 0.001, max(0.001, th - depth))
x = ow
y = ol
verts = [(0.0, 0.0, 0.0), (0.0, 0.0, z), (x, 0.0, z), (x, 0.0, 0.0),
(0.0, y, 0.0), (0.0, y, z), (x, y, z), (x, y, 0.0)]
faces = [(0, 3, 2, 1), (4, 5, 6, 7), (0, 1, 5, 4),
(1, 2, 6, 5), (3, 7, 6, 2), (0, 4, 7, 3)]
return verts, faces
def update(self, context):
self.update(context)
class archipack_floor(ArchipackObject, Manipulable, PropertyGroup):
tile_types = EnumProperty(
items=(
("1", "Tiles", ""),
("2", "Large + Small", ""),
("3", "Large + Many Small", ""),
("4", "Hexagonal", ""),
("21", "Planks", ""),
("22", "Parquet", ""),
("23", "Herringbone Parquet", ""),
("24", "Herringbone", "")
),
default="1",
description="Tile Type",
update=update,
name="")
b_length_s = FloatProperty(
name="Board Length",
min=0.01,
default=2.0,
unit='LENGTH', subtype='DISTANCE',
description="Board Length",
update=update)
hb_direction = EnumProperty(
items=(
("1", "Forwards (+y)", ""),
("2", "Backwards (-y)", ""),
("3", "Right (+x)", ""),
("4", "Left (-x)", "")
),
name="Direction",
description="Herringbone Direction",
update=update)
thickness = FloatProperty(
name="Floor Thickness",
min=0.01,
default=0.1,
unit='LENGTH', subtype='DISTANCE',
description="Thickness Of Flooring",
update=update)
num_boards = IntProperty(
name="# Of Boards",
min=2,
max=6,
default=4,
description="Number Of Boards In Square",
update=update)
space_l = FloatProperty(
name="Length Spacing",
min=0.001,
default=0.005,
step=0.01,
unit='LENGTH', subtype='DISTANCE',
description="Space Between Boards Length Ways",
update=update)
space_w = FloatProperty(
name="Width Spacing",
min=0.001,
default=0.005,
step=0.01,
unit='LENGTH', subtype='DISTANCE',
description="Space Between Boards Width Ways",
update=update)
spacing = FloatProperty(
name="Spacing",
min=0.001,
default=0.005,
step=0.01,
unit='LENGTH', subtype='DISTANCE',
description="Space Between Tiles/Boards",
update=update)
is_bevel = BoolProperty(
name="Bevel?",
default=False,
update=update)
bevel_res = IntProperty(
name="Bevel Resolution",
min=1,
max=10,
default=1,
update=update)
bevel_amo = FloatProperty(
name="Bevel Amount",
min=0.001,
default=0.0015,
step=0.01,
unit='LENGTH', subtype='DISTANCE',
description="Bevel Amount",
update=update)
is_ran_thickness = BoolProperty(
name="Random Thickness?",
default=False,
update=update)
ran_thickness = FloatProperty(
name="Thickness Variance",
min=0.1,
max=100.0,
default=50.0,
subtype="PERCENTAGE",
update=update)
is_floor_bottom = BoolProperty(
name="Floor bottom",
default=True,
update=update)
t_width = FloatProperty(
name="Tile Width",
min=0.01,
default=0.3,
unit='LENGTH', subtype='DISTANCE',
description="Tile Width",
update=update)
t_length = FloatProperty(
name="Tile Length",
min=0.01,
default=0.3,
unit='LENGTH', subtype='DISTANCE',
description="Tile Length",
update=update)
is_grout = BoolProperty(
name="Grout",
default=False,
description="Enable grout",
update=update)
grout_depth = FloatProperty(
name="Grout Depth",
min=0.001,
default=0.005,
step=0.01,
unit='LENGTH', subtype='DISTANCE',
description="Grout Depth",
update=update)
is_offset = BoolProperty(
name="Offset ?",
default=False,
description="Offset Rows",
update=update)
offset = FloatProperty(
name="Offset",
min=0.001,
max=100.0,
default=50.0,
subtype="PERCENTAGE",
description="Tile Offset Amount",
update=update)
is_random_offset = BoolProperty(
name="Random Offset?",
default=False,
description="Offset Tile Rows Randomly",
update=update)
offset_vary = FloatProperty(
name="Offset Variance",
min=0.001,
max=100.0,
default=50.0,
subtype="PERCENTAGE",
description="Offset Variance",
update=update)
t_width_s = FloatProperty(
name="Small Tile Width",
min=0.02,
default=0.2,
unit='LENGTH', subtype='DISTANCE',
description="Small Tile Width",
update=update)
over_width = FloatProperty(
name="Overall Width",
min=0.02,
default=4,
unit='LENGTH', subtype='DISTANCE',
description="Overall Width",
update=update)
over_length = FloatProperty(
name="Overall Length",
min=0.02,
default=4,
unit='LENGTH', subtype='DISTANCE',
description="Overall Length",
update=update)
b_width = FloatProperty(
name="Board Width",
min=0.01,
default=0.2,
unit='LENGTH', subtype='DISTANCE',
description="Board Width",
update=update)
b_length = FloatProperty(
name="Board Length",
min=0.01,
default=0.8,
unit='LENGTH', subtype='DISTANCE',
description="Board Length",
update=update)
is_length_vary = BoolProperty(
name="Vary Length?",
default=False,
description="Vary Lengths?",
update=update)
length_vary = FloatProperty(
name="Length Variance",
min=1.00,
max=100.0,
default=50.0,
subtype="PERCENTAGE",
description="Length Variance",
update=update)
max_boards = IntProperty(
name="Max # Of Boards",
min=2,
default=2,
description="Maximum Number Of Boards Possible In One Length",
update=update)
is_width_vary = BoolProperty(
name="Vary Width?",
default=False,
description="Vary Widths?",
update=update)
width_vary = FloatProperty(
name="Width Variance",
min=1.00,
max=100.0,
default=50.0,
subtype="PERCENTAGE",
description="Width Variance",
update=update)
is_mat_vary = BoolProperty(
name="Vary Material?",
default=False,
description="Vary Material indexes",
update=update)
mat_vary = IntProperty(
name="#variations",
min=1,
max=10,
default=1,
description="Material index maxi",
update=update)
auto_update = BoolProperty(
options={'SKIP_SAVE'},
default=True,
update=update
)
def setup_manipulators(self):
if len(self.manipulators) < 1:
# add manipulator for x property
s = self.manipulators.add()
s.prop1_name = "over_width"
# s.prop2_name = "x"
s.type_key = 'SIZE'
# add manipulator for y property
s = self.manipulators.add()
s.prop1_name = "over_length"
# s.prop2_name = "y"
s.type_key = 'SIZE'
def update(self, context):
o = self.find_in_selection(context, self.auto_update)
if o is None:
return
self.setup_manipulators()
verts, faces = create_flooring(self.tile_types, self.over_width,
self.over_length, self.b_width, self.b_length, self.b_length_s,
self.is_length_vary, self.length_vary, self.num_boards, self.space_l,
self.space_w, self.spacing, self.t_width, self.t_length, self.is_offset,
self.offset, self.is_random_offset, self.offset_vary, self.t_width_s,
self.is_width_vary, self.width_vary, self.max_boards, self.is_ran_thickness,
self.ran_thickness, self.thickness, self.hb_direction)
if self.is_mat_vary:
# hexagon made of 2 faces
if self.tile_types == '4':
matids = []
for i in range(int(len(faces) / 2)):
id = randint(1, self.mat_vary)
matids.extend([id, id])
else:
matids = [randint(1, self.mat_vary) for i in faces]
else:
matids = [1 for i in faces]
uvs = [[(0, 0), (0, 1), (1, 1), (1, 0)] for i in faces]
bmed.buildmesh(context,
o,
verts,
faces,
matids=matids,
uvs=uvs,
weld=False,
auto_smooth=False)
# cut hexa and herringbone wood
# disable when boolean modifier is found
enable_bissect = True
for m in o.modifiers:
if m.type == 'BOOLEAN':
enable_bissect = False
if enable_bissect and self.tile_types in ('4', '23', '24'):
bmed.bissect(context, o, Vector((0, 0, 0)), Vector((0, -1, 0)))
# Up
bmed.bissect(context, o, Vector((0, self.over_length, 0)), Vector((0, 1, 0)))
# left
bmed.bissect(context, o, Vector((0, 0, 0)), Vector((-1, 0, 0)))
# right
bmed.bissect(context, o, Vector((self.over_width, 0, 0)), Vector((1, 0, 0)))
if self.is_bevel:
bevel = self.bevel_amo
else:
bevel = 0
if self.is_grout:
th = min(self.grout_depth + bevel, self.thickness - 0.001)
bottom = th
else:
th = self.thickness
bottom = 0
bmed.solidify(context,
o,
th,
floor_bottom=(
self.is_floor_bottom and
self.is_ran_thickness and
self.tile_types in ('21')
),
altitude=bottom)
# bevel mesh
if self.is_bevel:
bmed.bevel(context, o, self.bevel_amo, segments=self.bevel_res)
# create grout
if self.is_grout:
verts, faces = tile_grout(self.over_width, self.over_length, self.grout_depth, self.thickness)
matids = [0 for i in faces]
uvs = [[(0, 0), (0, 1), (1, 1), (1, 0)] for i in faces]
bmed.addmesh(context,
o,
verts,
faces,
matids=matids,
uvs=uvs,
weld=False,
auto_smooth=False)
x, y = self.over_width, self.over_length
self.manipulators[0].set_pts([(0, 0, 0), (x, 0, 0), (1, 0, 0)])
self.manipulators[1].set_pts([(0, 0, 0), (0, y, 0), (-1, 0, 0)])
self.restore_context(context)
class ARCHIPACK_PT_floor(Panel):
bl_idname = "ARCHIPACK_PT_floor"
bl_label = "Flooring"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "Archipack"
@classmethod
def poll(cls, context):
# ensure your object panel only show when active object is the right one
return archipack_floor.filter(context.active_object)
def draw(self, context):
o = context.active_object
if not archipack_floor.filter(o):
return
layout = self.layout
# retrieve datablock of your object
props = archipack_floor.datablock(o)
# Manipulate mode operator
layout.operator('archipack.floor_manipulate', icon='HAND')
box = layout.box()
row = box.row(align=True)
# Presets operators
row.operator("archipack.floor_preset_menu",
text=bpy.types.ARCHIPACK_OT_floor_preset_menu.bl_label)
row.operator("archipack.floor_preset",
text="",
icon='ZOOMIN')
row.operator("archipack.floor_preset",
text="",
icon='ZOOMOUT').remove_active = True
layout.prop(props, "tile_types", icon="OBJECT_DATA")
layout.separator()
layout.prop(props, "over_width")
layout.prop(props, "over_length")
layout.separator()
# width and lengths
layout.prop(props, "thickness")
type = int(props.tile_types)
if type > 20:
# Wood types
layout.prop(props, "b_width")
else:
# Tiles types
if type != 4:
# Not hexagonal
layout.prop(props, "t_width")
layout.prop(props, "t_length")
else:
layout.prop(props, "t_width_s")
# Herringbone
if type in (23, 24):
layout.prop(props, "b_length_s")
layout.prop(props, "hb_direction")
# Parquet
if type == 22:
layout.prop(props, "num_boards")
# Planks
if type == 21:
layout.prop(props, "b_length")
layout.prop(props, "space_w")
layout.prop(props, "space_l")
layout.separator()
layout.prop(props, "is_length_vary", icon="NLA")
if props.is_length_vary:
layout.prop(props, "length_vary")
layout.prop(props, "max_boards")
layout.separator()
layout.prop(props, "is_width_vary", icon="UV_ISLANDSEL")
if props.is_width_vary:
layout.prop(props, "width_vary")
layout.separator()
layout.prop(props, "is_ran_thickness", icon="RNDCURVE")
if props.is_ran_thickness:
layout.prop(props, "ran_thickness")
layout.prop(props, "is_floor_bottom", icon="MOVE_DOWN_VEC")
else:
layout.prop(props, "spacing")
# Planks and tiles
if type in (1, 21):
layout.separator()
layout.prop(props, "is_offset", icon="OOPS")
if props.is_offset:
layout.prop(props, "is_random_offset", icon="NLA")
if not props.is_random_offset:
layout.prop(props, "offset")
else:
layout.prop(props, "offset_vary")
# bevel
layout.separator()
layout.prop(props, "is_bevel", icon="MOD_BEVEL")
if props.is_bevel:
layout.prop(props, "bevel_res", icon="OUTLINER_DATA_CURVE")
layout.prop(props, "bevel_amo")
# Grout
layout.separator()
layout.prop(props, "is_grout", icon="OBJECT_DATA")
if props.is_grout:
layout.prop(props, "grout_depth")
layout.separator()
layout.prop(props, "is_mat_vary", icon="MATERIAL")
if props.is_mat_vary:
layout.prop(props, "mat_vary")
class ARCHIPACK_OT_floor(ArchipackCreateTool, Operator):
bl_idname = "archipack.floor"
bl_label = "Floor"
bl_description = "Create Floor"
bl_category = 'Archipack'
bl_options = {'REGISTER', 'UNDO'}
def create(self, context):
# Create an empty mesh datablock
m = bpy.data.meshes.new("Floor")
# Create an object using the mesh datablock
o = bpy.data.objects.new("Floor", m)
# Add your properties on mesh datablock
d = m.archipack_floor.add()
# Link object into scene
context.scene.objects.link(o)
# select and make active
o.select = True
context.scene.objects.active = o
# Load preset into datablock
self.load_preset(d)
# add a material
self.add_material(o)
return o
def execute(self, context):
if context.mode == "OBJECT":
bpy.ops.object.select_all(action="DESELECT")
o = self.create(context)
o.location = bpy.context.scene.cursor_location
o.select = True
context.scene.objects.active = o
# Start manipulate mode
self.manipulate()
return {'FINISHED'}
else:
self.report({'WARNING'}, "Archipack: Option only valid in Object mode")
return {'CANCELLED'}
class ARCHIPACK_OT_floor_preset_menu(PresetMenuOperator, Operator):
bl_idname = "archipack.floor_preset_menu"
bl_label = "Floor preset"
preset_subdir = "archipack_floor"
class ARCHIPACK_OT_floor_preset(ArchipackPreset, Operator):
"""Add a Floor Preset"""
bl_idname = "archipack.floor_preset"
bl_label = "Add Floor preset"
preset_menu = "ARCHIPACK_OT_floor_preset_menu"
@property
def blacklist(self):
return ['manipulators', 'over_length', 'over_width']
class ARCHIPACK_OT_floor_manipulate(Operator):
bl_idname = "archipack.floor_manipulate"
bl_label = "Manipulate"
bl_description = "Manipulate"
bl_options = {'REGISTER', 'UNDO'}
@classmethod
def poll(self, context):
return archipack_floor.filter(context.active_object)
def invoke(self, context, event):
d = archipack_floor.datablock(context.active_object)
d.manipulable_invoke(context)
return {'FINISHED'}
def register():
bpy.utils.register_class(archipack_floor)
Mesh.archipack_floor = CollectionProperty(type=archipack_floor)
bpy.utils.register_class(ARCHIPACK_PT_floor)
bpy.utils.register_class(ARCHIPACK_OT_floor)
bpy.utils.register_class(ARCHIPACK_OT_floor_preset_menu)
bpy.utils.register_class(ARCHIPACK_OT_floor_preset)
bpy.utils.register_class(ARCHIPACK_OT_floor_manipulate)
def unregister():
bpy.utils.unregister_class(archipack_floor)
del Mesh.archipack_floor
bpy.utils.unregister_class(ARCHIPACK_PT_floor)
bpy.utils.unregister_class(ARCHIPACK_OT_floor)
bpy.utils.unregister_class(ARCHIPACK_OT_floor_preset_menu)
bpy.utils.unregister_class(ARCHIPACK_OT_floor_preset)
bpy.utils.unregister_class(ARCHIPACK_OT_floor_manipulate)