?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GPencil Tools: Optimize Undo for Rotate Canvas
[blender-addons.git] / archimesh / achm_window_panel.py
blob9be5231fd638ff5e2cfd873b87ab008024bb3249
1 # SPDX-FileCopyrightText: 2016-2022 Blender Foundation
2 #
3 # SPDX-License-Identifier: GPL-2.0-or-later
4
5 # ----------------------------------------------------------
6 # Main panel for windows
7 # Author: Antonio Vazquez (antonioya)
8 #
9 # This code is base on the windows generator add-on created by SayProduction
10 # and has been adapted to continuous editing and cycles materials
11 #
12 # ----------------------------------------------------------
13 # noinspection PyUnresolvedReferences
14 import bpy
15 from math import cos, sin, radians, sqrt, pi
16 from mathutils import Vector
17 from bpy.types import Operator, PropertyGroup, Object, Panel
18 from bpy.props import StringProperty, FloatProperty, BoolProperty, IntProperty, FloatVectorProperty, \
19 CollectionProperty, EnumProperty
20 from .achm_tools import *
21
22
23 def fitil(vr, fc, px, pz, x, y, z, zz, xx):
24 k3 = z * 2
25 vr.extend([[px[x] + xx, -z + zz, pz[y] + xx], [px[x] + xx + k3, -z + zz, pz[y] + xx + k3],
26 [px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx, z + zz, pz[y] + xx]])
27 vr.extend([[px[x] + xx, -z + zz, pz[y + 1] - xx], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
28 [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3], [px[x] + xx, z + zz, pz[y + 1] - xx]])
29 vr.extend([[px[x + 1] - xx, -z + zz, pz[y + 1] - xx], [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3],
30 [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx, z + zz, pz[y + 1] - xx]])
31 vr.extend([[px[x + 1] - xx, -z + zz, pz[y] + xx], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3],
32 [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3], [px[x + 1] - xx, z + zz, pz[y] + xx]])
33 n = len(vr)
34 fc.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9, n - 10]])
35 fc.extend([[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6]])
36 fc.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
37 fc.extend([[n - 4, n - 3, n - 15, n - 16], [n - 3, n - 2, n - 14, n - 15], [n - 2, n - 1, n - 13, n - 14]])
38 z = 0.005
39 vr.extend([[px[x] + xx + k3, -z + zz, pz[y] + xx + k3], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
40 [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3]])
41 vr.extend([[px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3],
42 [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3]])
43 fc.extend([[n + 1, n + 0, n + 3, n + 2], [n + 4, n + 5, n + 6, n + 7]])
44
45
46 def kapak(vr, fc, px, pz, x, y, z, zz):
47 k2 = z * 2
48 vr.extend(
49 [[px[x], -z + zz, pz[y]], [px[x] + k2, -z + zz, pz[y] + k2], [px[x] + k2, z + zz, pz[y] + k2],
50 [px[x], z + zz, pz[y]]])
51 vr.extend([[px[x], -z + zz, pz[y + 1]], [px[x] + k2, -z + zz, pz[y + 1] - k2], [px[x] + k2, z + zz, pz[y + 1] - k2],
52 [px[x], z + zz, pz[y + 1]]])
53 vr.extend(
54 [[px[x + 1], -z + zz, pz[y + 1]], [px[x + 1] - k2, -z + zz, pz[y + 1] - k2],
55 [px[x + 1] - k2, z + zz, pz[y + 1] - k2],
56 [px[x + 1], z + zz, pz[y + 1]]])
57 vr.extend([[px[x + 1], -z + zz, pz[y]], [px[x + 1] - k2, -z + zz, pz[y] + k2], [px[x + 1] - k2, z + zz, pz[y] + k2],
58 [px[x + 1], z + zz, pz[y]]])
59 n = len(vr)
60 fc.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9, n - 10],
61 [n - 13, n - 16, n - 12, n - 9]])
62 fc.extend([[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6],
63 [n - 9, n - 12, n - 8, n - 5]])
64 fc.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
65 [n - 5, n - 8, n - 4, n - 1]])
66 fc.extend([[n - 4, n - 3, n - 15, n - 16], [n - 3, n - 2, n - 14, n - 15], [n - 2, n - 1, n - 13, n - 14],
67 [n - 1, n - 4, n - 16, n - 13]])
68
69
70 # -----------------------------------------
71 # Set default values for each window type
72 # -----------------------------------------
73 def set_defaults(s):
74 if s.prs == '1':
75 s.gen = 3
76 s.yuk = 1
77 s.kl1 = 5
78 s.kl2 = 5
79 s.fk = 2
80 s.gny0 = 190
81 s.mr = True
82 s.gnx0 = 60
83 s.gnx1 = 110
84 s.gnx2 = 60
85 s.k00 = True
86 s.k01 = False
87 s.k02 = True
88 if s.prs == '2':
89 s.gen = 3
90 s.yuk = 1
91 s.kl1 = 5
92 s.kl2 = 5
93 s.fk = 2
94 s.gny0 = 190
95 s.mr = True
96 s.gnx0 = 60
97 s.gnx1 = 60
98 s.gnx2 = 60
99 s.k00 = True
100 s.k01 = False
101 s.k02 = True
102 if s.prs == '3':
103 s.gen = 3
104 s.yuk = 1
105 s.kl1 = 5
106 s.kl2 = 5
107 s.fk = 2
108 s.gny0 = 190
109 s.mr = True
110 s.gnx0 = 55
111 s.gnx1 = 50
112 s.gnx2 = 55
113 s.k00 = True
114 s.k01 = False
115 s.k02 = True
116 if s.prs == '4':
117 s.gen = 3
118 s.yuk = 1
119 s.kl1 = 5
120 s.kl2 = 5
121 s.fk = 2
122 s.gny0 = 150
123 s.mr = True
124 s.gnx0 = 55
125 s.gnx1 = 50
126 s.gnx2 = 55
127 s.k00 = True
128 s.k01 = False
129 s.k02 = True
130 if s.prs == '5':
131 s.gen = 3
132 s.yuk = 1
133 s.kl1 = 5
134 s.kl2 = 5
135 s.fk = 2
136 s.gny0 = 150
137 s.mr = True
138 s.gnx0 = 50
139 s.gnx1 = 40
140 s.gnx2 = 50
141 s.k00 = True
142 s.k01 = False
143 s.k02 = True
144 if s.prs == '6':
145 s.gen = 1
146 s.yuk = 1
147 s.kl1 = 5
148 s.kl2 = 5
149 s.fk = 2
150 s.gny0 = 40
151 s.mr = True
152 s.gnx0 = 40
153 s.k00 = False
154 if s.prs == '7':
155 s.gen = 1
156 s.yuk = 2
157 s.kl1 = 5
158 s.kl2 = 5
159 s.fk = 2
160 s.gny0 = 195
161 s.gny1 = 40
162 s.gnx0 = 70
163 s.k00 = True
164 s.k10 = False
165 s.mr = False
166 if s.prs == '8':
167 s.gen = 1
168 s.yuk = 2
169 s.kl1 = 5
170 s.kl2 = 5
171 s.fk = 2
172 s.gny0 = 180
173 s.gny1 = 35
174 s.gnx0 = 70
175 s.k00 = True
176 s.k10 = False
177 s.mr = False
178
179
180 # ------------------------------------------------------------------
181 # Define operator class to create window panels
182 # ------------------------------------------------------------------
183 class ARCHIMESH_PT_Win(Operator):
184 bl_idname = "mesh.archimesh_winpanel"
185 bl_label = "Panel Window"
186 bl_description = "Generate editable flat windows"
187 bl_category = 'View'
188 bl_options = {'REGISTER', 'UNDO'}
189
190 # -----------------------------------------------------
191 # Draw (create UI interface)
192 # -----------------------------------------------------
193 # noinspection PyUnusedLocal
194 def draw(self, context):
195 layout = self.layout
196 row = layout.row()
197 row.label(text="Use Properties panel (N) to define parms", icon='INFO')
198
199 # -----------------------------------------------------
200 # Execute
201 # -----------------------------------------------------
202 # noinspection PyUnusedLocal
203 def execute(self, context):
204 if bpy.context.mode == "OBJECT":
205 create_window()
206 return {'FINISHED'}
207 else:
208 self.report({'WARNING'}, "Archimesh: Option only valid in Object mode")
209 return {'CANCELLED'}
210
211
212 # ------------------------------------------------------------------------------
213 # Create the window
214 # ------------------------------------------------------------------------------
215 def create_window():
216 # deselect all objects
217 for o in bpy.data.objects:
218 o.select_set(False)
219 # Create main object
220 window_mesh = bpy.data.meshes.new("Window")
221 window_object = bpy.data.objects.new("Window", window_mesh)
222
223 # Link object to scene
224 bpy.context.collection.objects.link(window_object)
225 window_object.WindowPanelGenerator.add()
226 window_object.location = bpy.context.scene.cursor.location
227
228 # Shape the mesh.
229 do_mesh(window_object, window_mesh)
230
231 # deactivate others
232 for o in bpy.data.objects:
233 if o.select_get() is True and o.name != window_object.name:
234 o.select_set(False)
235
236 # Select, and activate object
237 window_object.select_set(True)
238 bpy.context.view_layer.objects.active = window_object
239
240 do_ctrl_box(window_object)
241 # Reselect
242 window_object.select_set(True)
243 bpy.context.view_layer.objects.active = window_object
244
245
246 # ------------------------------------------------------------------------------
247 # Update mesh of the window
248 # ------------------------------------------------------------------------------
249 # noinspection PyUnusedLocal
250 def update_window(self, context):
251 # When update, the active object is the main object.
252 o = bpy.context.active_object
253 oldmesh = o.data
254 oldname = o.data.name
255 # Now deselect that object to not delete it.
256 o.select_set(False)
257 # # and create a new mesh for the object:
258 # tmp_mesh = bpy.data.meshes.new("temp")
259 # deselect all objects
260 for obj in bpy.data.objects:
261 obj.select_set(False)
262 # ---------------------------------
263 # Clear Parent objects (autohole)
264 # ---------------------------------
265 myparent = o.parent
266 if myparent is not None:
267 ploc = myparent.location
268 else:
269 ploc = o.location
270 if myparent is not None:
271 o.parent = None
272 o.location = ploc
273 # remove_children(parent)
274 for child in myparent.children:
275 # noinspection PyBroadException
276 try:
277 # clear child data
278 child.hide_viewport = False # must be visible to avoid bug
279 child.hide_render = False # must be visible to avoid bug
280 old = child.data
281 child.select_set(True)
282 bpy.ops.object.delete()
283 bpy.data.meshes.remove(old)
284 except:
285 pass
286
287 myparent.select_set(True)
288 bpy.ops.object.delete()
289
290 # Finally create all that again
291 tmp_mesh = bpy.data.meshes.new("temp")
292 do_mesh(o, tmp_mesh, True)
293 o.data = tmp_mesh
294 # Remove data (mesh of active object),
295 if oldmesh.users == 0:
296 bpy.data.meshes.remove(oldmesh)
297 else:
298 oldmesh.name = "invalid"
299
300 tmp_mesh.name = oldname
301 # deactivate others
302 for ob in bpy.data.objects:
303 if ob.select_get() is True and ob.name != o.name:
304 ob.select_set(False)
305 # and select, and activate, the object.
306 o.select_set(True)
307 bpy.context.view_layer.objects.active = o
308
309 do_ctrl_box(o)
310
311 # Reselect
312 o.select_set(True)
313 bpy.context.view_layer.objects.active = o
314
315
316 # ------------------------------------------------------------------------------
317 # Generate object
318 # For object, it only shapes mesh
319 # ------------------------------------------------------------------------------
320 # noinspection PyUnusedLocal
321 def do_mesh(myobject, tmp_mesh, update=False):
322 # noinspection PyBroadException
323 try:
324 op = myobject.WindowPanelGenerator[0]
325 # Create only mesh, because the object was created before.
326 r = generate_window_object(op, tmp_mesh)
327 if r is False:
328 return False
329
330 # refine unit
331 remove_doubles(myobject)
332 set_normals(myobject)
333
334 # saves OpenGL data
335 # sum width
336 totx = myobject.dimensions.x
337 op.glpoint_a = (-totx / 2, 0, 0)
338 top_a, top_b, top_c = get_high_points(myobject, totx, op.UST)
339 op.glpoint_b = (-totx / 2, 0, top_a)
340 op.glpoint_c = (totx / 2, 0, top_b)
341 op.glpoint_d = (0, 0, top_c)
342
343 # Lock
344 myobject.lock_location = (True, True, True)
345 myobject.lock_rotation = (True, True, True)
346 return True
347 except:
348 return False
349
350
351 # ------------------------------------------------------------------------------
352 # Generate ctrl box
353 #
354 # ------------------------------------------------------------------------------
355 # noinspection PyUnusedLocal
356 def do_ctrl_box(myobject):
357 op = myobject.WindowPanelGenerator[0]
358 # -------------------------
359 # Create empty and parent
360 # -------------------------
361 bpy.ops.object.empty_add(type='PLAIN_AXES')
362 myempty = bpy.data.objects[bpy.context.active_object.name]
363 myempty.location = myobject.location
364
365 myempty.name = "Window_Group"
366 parentobject(myempty, myobject)
367 myobject["archimesh.hole_enable"] = True
368 # Rotate Empty
369 myempty.rotation_euler.z = radians(op.r)
370 # Create control box to open wall holes
371 myctrl = create_ctrl_box(myobject, "CTRL_Hole")
372
373 # Add custom property to detect Controller
374 myctrl["archimesh.ctrl_hole"] = True
375
376 set_normals(myctrl)
377 myctrl.parent = myempty
378 myctrl.location.x = 0
379 myctrl.location.y = 0
380 myctrl.location.z = 0
381 myctrl.display_type = 'WIRE'
382 myctrl.hide_viewport = False
383 myctrl.hide_render = True
384 if bpy.context.scene.render.engine in {'CYCLES', 'BLENDER_EEVEE'}:
385 myctrl.visible_camera = False
386 myctrl.visible_diffuse = False
387 myctrl.visible_glossy = False
388 myctrl.visible_transmission = False
389 myctrl.visible_shadow = False
390
391 mat = create_transparent_material("hidden_material", False)
392 set_material(myctrl, mat)
393
394
395 # ------------------------------------------------------------------------------
396 # Update the parameters using a default value
397 # ------------------------------------------------------------------------------
398 # noinspection PyUnusedLocal
399 def update_using_default(self, context):
400 o = context.object
401 myobject = o.WindowPanelGenerator[0]
402 if myobject.son != myobject.prs:
403 set_defaults(myobject)
404 myobject.son = myobject.prs
405
406
407 # ------------------------------------------------------------------------------
408 # Generate window object
409 # ------------------------------------------------------------------------------
410 def generate_window_object(op, mymesh):
411 myvertex = []
412 mfaces = []
413 # noinspection PyBroadException
414 try:
415 rst, ft1, cam, mer, sm = generate_vertex_data(op, myvertex, mfaces)
416 if rst is not True:
417 return False
418
419 mymesh.from_pydata(myvertex, [], mfaces)
420 # Uncomment for debug
421 # mymesh.validate(verbose=True)
422 # Assign materials
423 if op.mt1 == '1':
424 mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
425 elif op.mt1 == '2':
426 mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
427 elif op.mt1 == '3':
428 mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))
429 if op.mt2 == '1':
430 mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
431 elif op.mt2 == '2':
432 mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
433 elif op.mt2 == '3':
434 mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))
435
436 mymesh.materials.append(create_glass_material("Glass", False))
437 if op.mr is True:
438 mymesh.materials.append(create_diffuse_material("Marble", False, 0.9, 0.8, 0.7, 0.9, 0.8, 0.7))
439
440 p = len(mymesh.polygons)
441 for i in ft1:
442 if -1 < i < p:
443 mymesh.polygons[i].material_index = 1
444 for i in cam:
445 if -1 < i < p:
446 mymesh.polygons[i].material_index = 2
447 for i in mer:
448 if -1 < i < p:
449 mymesh.polygons[i].material_index = 3
450 for i in sm:
451 if -1 < i < p:
452 mymesh.polygons[i].use_smooth = 1
453
454 mymesh.update(calc_edges=True)
455
456 return True
457 except:
458 return False
459
460
461 # -----------------------------------------
462 # Generate vertex and faces data
463 # -----------------------------------------
464 def generate_vertex_data(op, myvertex, myfaces):
465 # noinspection PyBroadException
466 try:
467 h1 = 0
468 c = 0
469 t1 = 0
470
471 mx = op.gen
472 my = op.yuk
473 k1 = op.kl1 / 100
474 k2 = op.kl2 / 100
475 k3 = op.fk / 200
476 res = op.res
477
478 u = op.kl1 / 100
479 xlist = [0, round(u, 2)]
480 if mx > 0:
481 u += op.gnx0 / 100
482 xlist.append(round(u, 2))
483 u += k2
484 xlist.append(round(u, 2))
485 if mx > 1:
486 u += op.gnx1 / 100
487 xlist.append(round(u, 2))
488 u += k2
489 xlist.append(round(u, 2))
490 if mx > 2:
491 u += op.gnx2 / 100
492 xlist.append(round(u, 2))
493 u += k2
494 xlist.append(round(u, 2))
495 if mx > 3:
496 u += op.gnx3 / 100
497 xlist.append(round(u, 2))
498 u += k2
499 xlist.append(round(u, 2))
500 if mx > 4:
501 u += op.gnx4 / 100
502 xlist.append(round(u, 2))
503 u += k2
504 xlist.append(round(u, 2))
505 if mx > 5:
506 u += op.gnx5 / 100
507 xlist.append(round(u, 2))
508 u += k2
509 xlist.append(round(u, 2))
510 if mx > 6:
511 u += op.gnx6 / 100
512 xlist.append(round(u, 2))
513 u += k2
514 xlist.append(round(u, 2))
515 if mx > 7:
516 u += op.gnx7 / 100
517 xlist.append(round(u, 2))
518 u += k2
519 xlist.append(round(u, 2))
520
521 xlist[-1] = xlist[-2] + k1
522
523 u = op.kl1 / 100
524 zlist = [0, round(u, 2)]
525 if my > 0:
526 u += op.gny0 / 100
527 zlist.append(round(u, 2))
528 u += k2
529 zlist.append(round(u, 2))
530 if my > 1:
531 u += op.gny1 / 100
532 zlist.append(round(u, 2))
533 u += k2
534 zlist.append(round(u, 2))
535 if my > 2:
536 u += op.gny2 / 100
537 zlist.append(round(u, 2))
538 u += k2
539 zlist.append(round(u, 2))
540 if my > 3:
541 u += op.gny3 / 100
542 zlist.append(round(u, 2))
543 u += k2
544 zlist.append(round(u, 2))
545 if my > 4:
546 u += op.gny4 / 100
547 zlist.append(round(u, 2))
548 u += k2
549 zlist.append(round(u, 2))
550 zlist[-1] = zlist[-2] + k1
551
552 u = xlist[-1] / 2
553 for i in range(0, len(xlist)):
554 xlist[i] -= u
555 kx = [[op.k00, op.k10, op.k20, op.k30, op.k40],
556 [op.k01, op.k11, op.k21, op.k31, op.k41],
557 [op.k02, op.k12, op.k22, op.k32, op.k42],
558 [op.k03, op.k13, op.k23, op.k33, op.k43],
559 [op.k04, op.k14, op.k24, op.k34, op.k44],
560 [op.k05, op.k15, op.k25, op.k35, op.k45],
561 [op.k06, op.k16, op.k26, op.k36, op.k46],
562 [op.k07, op.k17, op.k27, op.k37, op.k47]]
563 cam = []
564 mer = []
565 ftl = []
566 sm = []
567 # -------------------------
568 # VERTICES
569 # -------------------------
570 myvertex.extend([[xlist[0], -k1 / 2, zlist[0]], [xlist[0], k1 / 2, zlist[0]]])
571 for x in range(1, len(xlist) - 1):
572 myvertex.extend([[xlist[x], -k1 / 2, zlist[1]], [xlist[x], k1 / 2, zlist[1]]])
573 myvertex.extend([[xlist[-1], -k1 / 2, zlist[0]], [xlist[-1], k1 / 2, zlist[0]]])
574 for z in range(2, len(zlist) - 2, 2):
575 for x in range(0, len(xlist)):
576 myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
577 for x in range(0, len(xlist)):
578 myvertex.extend([[xlist[x], -k1 / 2, zlist[z + 1]], [xlist[x], k1 / 2, zlist[z + 1]]])
579 z = len(zlist) - 2
580 myvertex.extend([[xlist[0], -k1 / 2, zlist[z + 1]], [xlist[0], k1 / 2, zlist[z + 1]]])
581 alt = []
582 ust = [len(myvertex) - 2, len(myvertex) - 1]
583 for x in range(1, len(xlist) - 1):
584 myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
585 alt.extend([len(myvertex) - 2, len(myvertex) - 1])
586 myvertex.extend([[xlist[-1], -k1 / 2, zlist[z + 1]], [xlist[-1], k1 / 2, zlist[z + 1]]])
587 son = [len(myvertex) - 2, len(myvertex) - 1]
588 # -------------------------
589 # FACES
590 # -------------------------
591 myfaces.append([0, 1, 3 + mx * 4, 2 + mx * 4])
592 fb = [0]
593 fr = [1]
594 for i in range(0, mx * 4, 4):
595 myfaces.append([i + 3, i + 2, i + 4, i + 5])
596 fb.extend([i + 2, i + 4])
597 fr.extend([i + 3, i + 5])
598 fr.append(3 + mx * 4)
599 fb.append(2 + mx * 4)
600 fb.reverse()
601 myfaces.extend([fb, fr])
602 # Yatay
603 y = (mx * 4 + 4)
604 v = mx * 4 + 2
605 for z in range(0, (my - 1) * y * 2, y * 2):
606 myfaces.extend([[z + y + 1, z + y, z + y + 4 + mx * 4, z + y + 5 + mx * 4],
607 [z + y + v, z + y + v + 1, z + y + v + 5 + mx * 4, z + y + v + 4 + mx * 4]])
608 for i in range(0, mx * 4 + 2, 2):
609 myfaces.extend([[z + i + y + 0, z + i + y + 2, z + i + y + v + 4, z + i + y + v + 2],
610 [z + i + y + 3, z + i + y + 1, z + i + y + v + 3, z + i + y + v + 5]])
611 for i in range(0, mx * 4 - 3, 4):
612 myfaces.extend([[z + i + y + 2, z + i + y + 3, z + i + y + 5, z + i + y + 4],
613 [z + i + y + v + 5, z + i + y + v + 4, z + i + y + v + 6,
614 z + i + y + v + 7]])
615 # Dikey
616 for y in range(0, my):
617 z = y * (mx * 4 + 4) * 2
618 for i in range(0, mx * 4 + 2, 4):
619 myfaces.extend([[z + i + 1, z + i + 0, z + i + v + 2, z + i + v + 3],
620 [z + i + 3, z + i + 1, z + i + v + 3, z + i + v + 5],
621 [z + i + 2, z + i + 3, z + i + v + 5, z + i + v + 4],
622 [z + i + 0, z + i + 2, z + i + v + 4, z + i + v + 2]])
623 # Fitil
624 if op.UST == '1':
625 y1 = my
626 else:
627 y1 = my - 1
628 for y in range(0, y1):
629 for x in range(0, mx):
630 if kx[x][y] is True:
631 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
632 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
633 else:
634 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
635 m = len(myfaces)
636 cam.extend([m - 1, m - 2])
637 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13, m - 14])
638 # -----------------------------------------------------
639 if op.UST == '1': # Duz
640 myfaces.append([ust[1], ust[0], son[0], son[1]])
641 for i in range(0, mx * 4, 4):
642 myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
643 on = [ust[0]]
644 ar = [ust[1]]
645 for i in range(0, len(alt) - 1, 2):
646 on.append(alt[i])
647 ar.append(alt[i + 1])
648 on.append(son[0])
649 myfaces.append(on)
650 ar.append(son[1])
651 ar.reverse()
652 myfaces.append(ar)
653 elif op.UST == '2': # Arch
654 if op.DT2 == '1':
655 h1 = op.VL1 / 100
656 if op.VL1 < 6:
657 h1 = 6 / 100
658
659 if h1 < 0.01:
660 h1 = 0.01
661 # op.VL1 = 1
662 elif h1 >= u:
663 h1 = u - 0.01
664 # op.VL1 = h1 * 100
665 if h1 < 0.07:
666 h1 = 0.07
667
668 h = sqrt(u ** 2 + h1 ** 2) / 2
669 e = h * (u / h1)
670 c = sqrt(h ** 2 + e ** 2)
671 t1 = zlist[-1] - h1
672 elif op.DT2 == '2':
673 c = op.VL2 / 100
674 if c < u + 0.01:
675 c = u + 0.01
676 # op.VL2 = c * 100
677 t1 = sqrt(c ** 2 - u ** 2) + zlist[-1] - c
678 r = c - k1
679 z = zlist[-1] - c
680
681 myvertex[ust[0]][2] = t1
682 myvertex[ust[1]][2] = t1
683 myvertex[son[0]][2] = t1
684 myvertex[son[1]][2] = t1
685 for i in alt:
686 myvertex[i][2] = sqrt(r ** 2 - myvertex[i][0] ** 2) + z
687
688 on = [son[0]]
689 u1 = []
690 for i in range(0, res):
691 a = i * pi / res
692 x = cos(a) * c
693 if -u < x < u:
694 myvertex.append([x, -k1 / 2, sin(a) * c + z])
695 on.append(len(myvertex) - 1)
696 u1.extend(on)
697 u1.append(ust[0])
698 on.extend([ust[0], alt[0]])
699 ar = []
700 d1 = []
701 d2 = []
702 for i in range(0, len(alt) - 2, 4):
703 x1 = myvertex[alt[i + 0]][0]
704 x2 = myvertex[alt[i + 2]][0]
705 on.append(alt[i + 0])
706 ar.append(alt[i + 1])
707 t1 = [alt[i + 0]]
708 t2 = [alt[i + 1]]
709 for j in range(0, res):
710 a = j * pi / res
711 x = -cos(a) * r
712 if x1 < x < x2:
713 myvertex.extend([[x, -k1 / 2, sin(a) * r + z], [x, k1 / 2, sin(a) * r + z]])
714 on.append(len(myvertex) - 2)
715 ar.append(len(myvertex) - 1)
716 t1.append(len(myvertex) - 2)
717 t2.append(len(myvertex) - 1)
718 on.append(alt[i + 2])
719 ar.append(alt[i + 3])
720 t1.append(alt[i + 2])
721 t2.append(alt[i + 3])
722 d1.append(t1)
723 d2.append(t2)
724 ar.append(son[1])
725 u2 = [son[1]]
726 for i in range(0, res):
727 a = i * pi / res
728 x = cos(a) * c
729 if -u < x < u:
730 myvertex.append([x, k1 / 2, sin(a) * c + z])
731 ar.append(len(myvertex) - 1)
732 u2.append(len(myvertex) - 1)
733 ar.append(ust[1])
734 u2.append(ust[1])
735 ar.reverse()
736 myfaces.extend([on, ar])
737 for i in range(0, len(u1) - 1):
738 myfaces.append([u1[i + 1], u1[i], u2[i], u2[i + 1]])
739 sm.append(len(myfaces) - 1)
740 for a in range(0, mx):
741 for i in range(0, len(d1[a]) - 1):
742 myfaces.append([d1[a][i + 1], d1[a][i], d2[a][i], d2[a][i + 1]])
743 sm.append(len(myfaces) - 1)
744 y = my - 1
745 for x in range(0, mx):
746 if kx[x][y] is True:
747 fr = (k1 + k2) * 0.5 - 0.01
748 ek = k2
749 r = c - k1
750 k = r - k2
751
752 x1 = xlist[x * 2 + 1]
753 x2 = xlist[x * 2 + 2]
754 myvertex.extend([[x2, fr - k2 / 2, z + 1], [x2 - k2, fr - k2 / 2, z + 1],
755 [x2 - k2, fr + k2 / 2, z + 1],
756 [x2, fr + k2 / 2, z + 1]])
757 myvertex.extend([[x2, fr - k2 / 2, zlist[-3]], [x2 - k2, fr - k2 / 2, zlist[-3] + k2],
758 [x2 - k2, fr + k2 / 2,
759 zlist[-3] + k2],
760 [x2, fr + k2 / 2, zlist[-3]]])
761 myvertex.extend([[x1, fr - k2 / 2, zlist[-3]], [x1 + k2, fr - k2 / 2, zlist[-3] + k2],
762 [x1 + k2, fr + k2 / 2,
763 zlist[-3] + k2],
764 [x1, fr + k2 / 2, zlist[-3]]])
765 myvertex.extend([[x1, fr - k2 / 2, z + 1], [x1 + k2, fr - k2 / 2, z + 1],
766 [x1 + k2, fr + k2 / 2, z + 1],
767 [x1, fr + k2 / 2, z + 1]])
768
769 n = len(myvertex)
770 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
771 [n - 14, n - 13, n - 9, n - 10], [n - 13, n - 16, n - 12, n - 9]])
772 myfaces.extend(
773 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6],
774 [n - 9, n - 12, n - 8, n - 5]])
775 myfaces.extend(
776 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
777 [n - 5, n - 8, n - 4, n - 1]])
778 alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
779 myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
780 myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
781 myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
782 myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
783 myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
784 myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
785 myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
786 myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z
787
788 d1 = []
789 d2 = []
790 t1 = []
791 t2 = []
792 for i in range(0, res):
793 a = i * pi / res
794 y1 = cos(a) * r
795 y2 = -cos(a) * k
796 if x1 < y1 < x2:
797 myvertex.extend([[y1, fr - k2 / 2, sin(a) * r + z], [y1, fr + k2 / 2,
798 sin(a) * r + z]])
799 t1.append(len(myvertex) - 2)
800 t2.append(len(myvertex) - 1)
801 if x1 + k2 < y2 < x2 - k2:
802 myvertex.extend([[y2, fr - k2 / 2, sin(a) * k + z], [y2, fr + k2 / 2,
803 sin(a) * k + z]])
804 d1.append(len(myvertex) - 2)
805 d2.append(len(myvertex) - 1)
806 on = [alt[1], alt[0]]
807 on.extend(t1)
808 on.extend([alt[4], alt[5]])
809 on.extend(d1)
810 ar = [alt[2], alt[3]]
811 ar.extend(t2)
812 ar.extend([alt[7], alt[6]])
813 ar.extend(d2)
814 ar.reverse()
815
816 if d1 == [] and t1 == []:
817 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], alt[0], alt[
818 3]]])
819 m = len(myfaces)
820 sm.extend(
821 [m - 1, m - 2])
822 elif d1 == [] and t1 != []:
823 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], t1[-1], t2[-1]],
824 [alt[0], alt[3], t2[0], t1[0]]])
825 m = len(myfaces)
826 sm.extend(
827 [m - 1, m - 2, m - 3])
828 elif d1 != [] and t1 == []:
829 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
830 [alt[7], alt[4], alt[0], alt[3]]])
831 m = len(myfaces)
832 sm.extend(
833 [m - 1, m - 2, m - 3])
834 else:
835 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
836 [alt[7], alt[4], t1[-1], t2[-1]], [alt[0], alt[3], t2[0], t1[0]]])
837 m = len(myfaces)
838 sm.extend(
839 [m - 1, m - 2, m - 3, m - 4])
840
841 for i in range(0, len(d1) - 1):
842 myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
843 sm.append(len(myfaces) - 1)
844 for i in range(0, len(t1) - 1):
845 myfaces.append([t1[i + 1], t1[i], t2[i], t2[i + 1]])
846 sm.append(len(myfaces) - 1)
847 r = c - k1 - k2
848 k = r - k3 * 2
849 else:
850 fr = 0
851 ek = 0
852 r = c - k1
853 k = r - k3 * 2
854 # Fitil
855 x1 = xlist[x * 2 + 1] + ek
856 x2 = xlist[x * 2 + 2] - ek
857 myvertex.extend([[x2, fr - k3, z + 1], [x2 - k3 * 2, fr - k3, z + 1], [x2 - k3 * 2, fr + k3, z + 1],
858 [x2, fr + k3, z + 1]])
859 myvertex.extend([[x2, fr - k3, zlist[-3] + ek], [x2 - k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
860 [x2 - k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x2, fr + k3, zlist[-3] + ek]])
861 myvertex.extend([[x1, fr - k3, zlist[-3] + ek], [x1 + k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
862 [x1 + k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x1, fr + k3, zlist[-3] + ek]])
863 myvertex.extend([[x1, fr - k3, z + 1], [x1 + k3 * 2, fr - k3, z + 1], [x1 + k3 * 2, fr + k3, z + 1],
864 [x1, fr + k3, z + 1]])
865 n = len(myvertex)
866 myfaces.extend(
867 [[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9,
868 n - 10]])
869 myfaces.extend(
870 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6]])
871 myfaces.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1,
872 n - 2]])
873 m = len(myfaces)
874 ftl.extend([m - 1, m - 2, m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9])
875 alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
876 myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
877 myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
878 myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
879 myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
880 myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
881 myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
882 myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
883 myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z
884 d1 = []
885 d2 = []
886 t1 = []
887 t2 = []
888 for i in range(0, res):
889 a = i * pi / res
890 y1 = cos(a) * r
891 y2 = -cos(a) * k
892 if x1 < y1 < x2:
893 myvertex.extend([[y1, fr - k3, sin(a) * r + z], [y1, fr + k3, sin(a) * r + z]])
894 t1.append(len(myvertex) - 2)
895 t2.append(len(myvertex) - 1)
896 ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
897 if x1 + k3 * 2 < y2 < x2 - k3 * 2:
898 myvertex.extend([[y2, fr - k3, sin(a) * k + z], [y2, fr + k3, sin(a) * k + z]])
899 d1.append(len(myvertex) - 2)
900 d2.append(len(myvertex) - 1)
901 ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
902 on = [alt[1], alt[0]]
903 on.extend(t1)
904 on.extend([alt[4], alt[5]])
905 on.extend(d1)
906 ar = [alt[2], alt[3]]
907 ar.extend(t2)
908 ar.extend([alt[7], alt[6]])
909 ar.extend(d2)
910 ar.reverse()
911
912 if not d1:
913 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]]])
914 m = len(myfaces)
915 ftl.extend([m - 1, m - 2, m - 3])
916 sm.extend([m - 1])
917 else:
918 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]]])
919 m = len(myfaces)
920 ftl.extend([m - 1, m - 2, m - 3, m - 4])
921 sm.extend([m - 1, m - 2])
922
923 for i in range(0, len(d1) - 1):
924 myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
925 ftl.append(len(myfaces) - 1)
926 sm.append(len(myfaces) - 1)
927 # Cam
928 x1 = xlist[x * 2 + 1] + ek + k3 * 2
929 x2 = xlist[x * 2 + 2] - ek - k3 * 2
930 on = []
931 ar = []
932 for i in range(0, res):
933 a = i * pi / res
934 y1 = -cos(a) * k
935 if x1 < y1 < x2:
936 myvertex.extend([[y1, fr - 0.005, sin(a) * k + z], [y1, fr + 0.005, sin(a) * k + z]])
937 n = len(myvertex)
938 on.append(n - 1)
939 ar.append(n - 2)
940 myvertex.extend(
941 [[x1, fr - 0.005, sqrt(k ** 2 - x1 ** 2) + z], [x1, fr + 0.005,
942 sqrt(k ** 2 - x1 ** 2) + z]])
943 myvertex.extend([[x1, fr - 0.005, zlist[-3] + ek + k3 * 2], [x1, fr + 0.005, zlist[-3] + ek + k3 * 2]])
944 myvertex.extend([[x2, fr - 0.005, zlist[-3] + ek + k3 * 2], [x2, fr + 0.005, zlist[-3] + ek + k3 * 2]])
945 myvertex.extend(
946 [[x2, fr - 0.005, sqrt(k ** 2 - x2 ** 2) + z], [x2, fr + 0.005,
947 sqrt(k ** 2 - x2 ** 2) + z]])
948 n = len(myvertex)
949 on.extend([n - 1, n - 3, n - 5, n - 7])
950 ar.extend([n - 2, n - 4, n - 6, n - 8])
951 myfaces.append(on)
952 ar.reverse()
953 myfaces.append(ar)
954 m = len(myfaces)
955 cam.extend([m - 1, m - 2])
956
957 elif op.UST == '3': # Egri
958 if op.DT3 == '1':
959 h1 = (op.VL1 / 200) / u
960 elif op.DT3 == '2':
961 h1 = op.VL3 / 100
962 elif op.DT3 == '3':
963 h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
964 z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
965 k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
966 f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
967 myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
968 myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
969 for i in alt:
970 myvertex[i][2] = zlist[-1] + myvertex[i][0] * h1 - z
971 myvertex[son[0]][2] = zlist[-1] + myvertex[son[0]][0] * h1
972 myvertex[son[1]][2] = zlist[-1] + myvertex[son[1]][0] * h1
973 myfaces.append([ust[1], ust[0], son[0], son[1]])
974 for i in range(0, mx * 4, 4):
975 myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
976 on = [ust[0]]
977 ar = [ust[1]]
978 for i in range(0, len(alt) - 1, 2):
979 on.append(alt[i])
980 ar.append(alt[i + 1])
981 on.append(son[0])
982 myfaces.append(on)
983 ar.append(son[1])
984 ar.reverse()
985 myfaces.append(ar)
986 y = my - 1
987 for x in range(0, mx):
988 if kx[x][y] is True:
989 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
990 n = len(myvertex)
991 myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
992 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
993 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
994 myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
995 myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
996 myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
997 myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
998 myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
999 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
1000 n = len(myvertex)
1001 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
1002 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
1003 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
1004 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
1005 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
1006 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
1007 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
1008 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
1009 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
1010 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
1011 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
1012 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
1013 else:
1014 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1015 n = len(myvertex)
1016 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
1017 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
1018 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
1019 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
1020 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
1021 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
1022 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
1023 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
1024 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
1025 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
1026 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
1027 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
1028 m = len(myfaces)
1029 cam.extend([m - 1, m - 2])
1030 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13, m - 14])
1031 elif op.UST == '4': # Ucgen
1032 if op.DT3 == '1':
1033 h1 = (op.VL1 / 100) / u
1034 elif op.DT3 == '2':
1035 h1 = op.VL3 / 100
1036 elif op.DT3 == '3':
1037 h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
1038 z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
1039 k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
1040 f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
1041 myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
1042 myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
1043 for i in alt:
1044 myvertex[i][2] = zlist[-1] - abs(myvertex[i][0]) * h1 - z
1045 myvertex[son[0]][2] = zlist[-1] - myvertex[son[0]][0] * h1
1046 myvertex[son[1]][2] = zlist[-1] - myvertex[son[1]][0] * h1
1047 myvertex.extend([[0, -k1 / 2, zlist[-1]], [0, k1 / 2, zlist[-1]]])
1048
1049 x = 0
1050 for j in range(2, len(alt) - 2, 4):
1051 if myvertex[alt[j]][0] < 0 < myvertex[alt[j + 2]][0]:
1052 x = 1
1053
1054 n = len(myvertex)
1055 myfaces.extend([[ust[1], ust[0], n - 2, n - 1], [n - 1, n - 2, son[0], son[1]]])
1056 on = [son[0], n - 2, ust[0]]
1057 ar = [son[1], n - 1, ust[1]]
1058
1059 if x == 0:
1060 myvertex.extend([[0, -k1 / 2, zlist[-1] - z], [0, k1 / 2, zlist[-1] - z]])
1061 for j in range(0, len(alt) - 2, 4):
1062 if myvertex[alt[j]][0] < 0 and myvertex[alt[j + 2]][0] < 0:
1063 myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
1064 on.extend([alt[j], alt[j + 2]])
1065 ar.extend([alt[j + 1], alt[j + 3]])
1066 elif myvertex[alt[j]][0] > 0 and myvertex[alt[j + 2]][0] > 0:
1067 myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
1068 on.extend([alt[j], alt[j + 2]])
1069 ar.extend([alt[j + 1], alt[j + 3]])
1070 else:
1071 n = len(myvertex)
1072 myfaces.extend([[alt[j], alt[j + 1], n - 1, n - 2], [n - 2, n - 1, alt[j + 3], alt[j + 2]]])
1073 on.extend([alt[j + 0], n - 2, alt[j + 2]])
1074 ar.extend([alt[j + 1], n - 1, alt[j + 3]])
1075 myfaces.append(on)
1076 ar.reverse()
1077 myfaces.append(ar)
1078 y = my - 1
1079 for x in range(0, mx):
1080 if myvertex[alt[x * 4]][0] < 0 and myvertex[alt[x * 4 + 2]][0] < 0:
1081 if kx[x][y] is True:
1082 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
1083 n = len(myvertex)
1084 myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
1085 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
1086 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
1087 myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
1088 myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
1089 myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
1090 myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
1091 myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
1092 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
1093 n = len(myvertex)
1094 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
1095 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
1096 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
1097 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
1098 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
1099 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
1100 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
1101 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
1102 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
1103 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
1104 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
1105 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
1106 else:
1107 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1108 n = len(myvertex)
1109 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
1110 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
1111 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
1112 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
1113 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
1114 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
1115 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
1116 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
1117 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
1118 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
1119 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
1120 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
1121 m = len(myfaces)
1122 cam.extend([m - 1, m - 2])
1123 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11,
1124 m - 12, m - 13, m - 14])
1125 elif myvertex[alt[x * 4]][0] > 0 and myvertex[alt[x * 4 + 2]][0] > 0:
1126 if kx[x][y] is True:
1127 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
1128 n = len(myvertex)
1129 myvertex[n - 5][2] = zlist[-1] - myvertex[n - 5][0] * h1 - z
1130 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k
1131 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k
1132 myvertex[n - 8][2] = zlist[-1] - myvertex[n - 8][0] * h1 - z
1133 myvertex[n - 9][2] = zlist[-1] - myvertex[n - 9][0] * h1 - z
1134 myvertex[n - 10][2] = zlist[-1] - myvertex[n - 10][0] * h1 - z - k
1135 myvertex[n - 11][2] = zlist[-1] - myvertex[n - 11][0] * h1 - z - k
1136 myvertex[n - 12][2] = zlist[-1] - myvertex[n - 12][0] * h1 - z
1137 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
1138 n = len(myvertex)
1139 myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - k - f
1140 myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - k - f
1141 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k - f
1142 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k - f
1143 myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z - k
1144 myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - k - f
1145 myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - k - f
1146 myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z - k
1147 myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z - k
1148 myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - k - f
1149 myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - k - f
1150 myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z - k
1151 else:
1152 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1153 n = len(myvertex)
1154 myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - f
1155 myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - f
1156 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - f
1157 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - f
1158 myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z
1159 myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - f
1160 myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - f
1161 myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z
1162 myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z
1163 myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - f
1164 myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - f
1165 myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z
1166 m = len(myfaces)
1167 cam.extend([m - 1, m - 2])
1168 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10,
1169 m - 11, m - 12, m - 13, m - 14])
1170 else:
1171 k4 = k3 * 2
1172 if kx[x][y] is True:
1173 zz = (k1 + k2) * 0.5 - 0.01
1174 xx = xlist[x * 2 + 1]
1175 myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx + k2, -k2 / 2 + zz, zlist[-3] + k2],
1176 [xx + k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
1177 myvertex.extend(
1178 [[xx, -k2 / 2 + zz, zlist[-1] + xx * h1 - z], [xx + k2, -k2 / 2 + zz,
1179 zlist[-1] + (xx + k2) * h1 - z - k],
1180 [xx + k2, k2 / 2 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
1181 [xx, k2 / 2 + zz, zlist[-1] + xx * h1 - z]])
1182 myvertex.extend([[0, -k2 / 2 + zz, zlist[-1] - z], [0, -k2 / 2 + zz, zlist[-1] - z - k],
1183 [0, k2 / 2 + zz, zlist[-1] - z - k], [0, k2 / 2 + zz, zlist[-1] - z]])
1184 xx = xlist[x * 2 + 2]
1185 myvertex.extend(
1186 [[xx, -k2 / 2 + zz, zlist[-1] - xx * h1 - z], [xx - k2, -k2 / 2 + zz,
1187 zlist[-1] - (xx - k2) * h1 - z - k],
1188 [xx - k2, k2 / 2 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
1189 [xx, k2 / 2 + zz, zlist[-1] - xx * h1 - z]])
1190 myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx - k2, -k2 / 2 + zz, zlist[-3] + k2],
1191 [xx - k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
1192 n = len(myvertex)
1193 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1194 [n - 18, n - 17, n - 13, n - 14], [n - 17, n - 20, n - 16, n - 13]])
1195 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1196 [n - 14, n - 13, n - 9, n - 10], [n - 13, n - 16, n - 12, n - 9]])
1197 myfaces.extend(
1198 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9,
1199 n - 5, n - 6],
1200 [n - 9, n - 12, n - 8, n - 5]])
1201 myfaces.extend(
1202 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
1203 [n - 5, n - 8, n - 4, n - 1]])
1204 myfaces.extend(
1205 [[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1206 [n - 2, n - 1, n - 17, n - 18],
1207 [n - 1, n - 4, n - 20, n - 17]])
1208 xx = xlist[x * 2 + 1]
1209 myvertex.extend([[xx + k2, -k3 + zz, zlist[-3] + k2], [xx + k4 + k2, -k3 + zz,
1210 zlist[-3] + k2 + k4],
1211 [xx + k4 + k2, k3 + zz, zlist[-3] + k2 + k4], [xx + k2, k3 + zz,
1212 zlist[-3] + k2]])
1213 myvertex.extend([[xx + k2, -k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
1214 [xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1215 [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1216 [xx + k2, k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k]])
1217 myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z], [0, -k3 + zz, zlist[-1] - k - z - f],
1218 [0, k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z]])
1219 xx = xlist[x * 2 + 2]
1220 myvertex.extend([[xx - k2, -k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
1221 [xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1222 [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1223 [xx - k2, k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k]])
1224 myvertex.extend([[xx - k2, -k3 + zz, zlist[-3] + k2],
1225 [xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4],
1226 [xx - k4 - k2, k3 + zz, zlist[-3] + k2 + k4],
1227 [xx - k2, k3 + zz, zlist[-3] + k2]])
1228 n = len(myvertex)
1229 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1230 [n - 18, n - 17, n - 13, n - 14]])
1231 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1232 [n - 14, n - 13, n - 9, n - 10]])
1233 myfaces.extend(
1234 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10,
1235 n - 9, n - 5, n - 6]])
1236 myfaces.extend(
1237 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
1238 myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1239 [n - 2, n - 1, n - 17, n - 18]])
1240 xx = xlist[x * 2 + 1]
1241 myvertex.extend(
1242 [[xx + k4 + k2, -k3 + zz, zlist[-3] + k2 + k4], [xx + k4 + k2, k3 + zz, zlist[-3] +
1243 k2 + k4]])
1244 myvertex.extend([[xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1245 [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f]])
1246 myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z - f]])
1247 xx = xlist[x * 2 + 2]
1248 myvertex.extend([[xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1249 [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f]])
1250 myvertex.extend(
1251 [[xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4], [xx - k4 - k2, k3 + zz, zlist[-3] +
1252 k2 + k4]])
1253 myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
1254 else:
1255 xx = xlist[x * 2 + 1]
1256 myvertex.extend(
1257 [[xx, -k3, zlist[-3]], [xx + k4, -k3, zlist[-3] + k4], [xx + k4, k3, zlist[-3] + k4],
1258 [xx, k3, zlist[-3]]])
1259 myvertex.extend(
1260 [[xx, -k3, zlist[-1] + xx * h1 - z], [xx + k4, -k3, zlist[-1] + (xx + k4) * h1 - z - f],
1261 [xx + k4, k3, zlist[-1] + (xx + k4) * h1 - z - f], [xx, k3, zlist[-1] + xx * h1 - z]])
1262 myvertex.extend(
1263 [[0, -k3, zlist[-1] - z], [0, -k3, zlist[-1] - z - f], [0, k3, zlist[-1] - z - f],
1264 [0, k3, zlist[-1] - z]])
1265 xx = xlist[x * 2 + 2]
1266 myvertex.extend(
1267 [[xx, -k3, zlist[-1] - xx * h1 - z], [xx - k4, -k3, zlist[-1] - (xx - k4) * h1 - z - f],
1268 [xx - k4, k3, zlist[-1] - (xx - k4) * h1 - z - f], [xx, k3, zlist[-1] - xx * h1 - z]])
1269 myvertex.extend(
1270 [[xx, -k3, zlist[-3]], [xx - k4, -k3, zlist[-3] + k4], [xx - k4, k3, zlist[-3] + k4],
1271 [xx, k3, zlist[-3]]])
1272 n = len(myvertex)
1273 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1274 [n - 18, n - 17, n - 13, n - 14]])
1275 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1276 [n - 14, n - 13, n - 9, n - 10]])
1277 myfaces.extend(
1278 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5,
1279 n - 6]])
1280 myfaces.extend(
1281 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
1282 myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1283 [n - 2, n - 1, n - 17, n - 18]])
1284 xx = xlist[x * 2 + 1]
1285 myvertex.extend([[xx + k4, -0.005, zlist[-3] + k4], [xx + k4, 0.005, zlist[-3] + k4]])
1286 myvertex.extend([[xx + k4, -0.005, zlist[-1] + (xx + k4) * h1 - z - f],
1287 [xx + k4, 0.005, zlist[-1] + (xx + k4) * h1 - z - f]])
1288 myvertex.extend([[0, -0.005, zlist[-1] - z - f], [0, 0.005, zlist[-1] - z - f]])
1289 xx = xlist[x * 2 + 2]
1290 myvertex.extend([[xx - k4, -0.005, zlist[-1] - (xx - k4) * h1 - z - f],
1291 [xx - k4, 0.005, zlist[-1] - (xx - k4) * h1 - z - f]])
1292 myvertex.extend([[xx - k4, -0.005, zlist[-3] + k4], [xx - k4, 0.005, zlist[-3] + k4]])
1293 myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
1294 m = len(myfaces)
1295 cam.extend([m - 1, m - 2])
1296 ftl.extend(
1297 [m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13,
1298 m - 14, m - 15,
1299 m - 16, m - 17])
1300 # Mermer
1301 if op.mr is True:
1302 mrh = -op.mr1 / 100
1303 mrg = op.mr2 / 100
1304 mdv = (op.mr3 / 200) + mrg
1305 msv = -(mdv + (op.mr4 / 100))
1306 myvertex.extend([[-u, mdv, 0], [u, mdv, 0], [-u, msv, 0], [u, msv, 0], [-u, mdv, mrh], [u, mdv, mrh],
1307 [-u, msv, mrh],
1308 [u, msv, mrh]])
1309 n = len(myvertex)
1310 myfaces.extend([[n - 1, n - 2, n - 4, n - 3], [n - 3, n - 4, n - 8, n - 7], [n - 6, n - 5, n - 7, n - 8],
1311 [n - 2, n - 1, n - 5, n - 6], [n - 4, n - 2, n - 6, n - 8], [n - 5, n - 1, n - 3, n - 7]])
1312 n = len(myfaces)
1313 mer.extend([n - 1, n - 2, n - 3, n - 4, n - 5, n - 6])
1314
1315 return True, ftl, cam, mer, sm
1316 except:
1317 return False, None, None, None, None
1318
1319
1320 # ------------------------------------
1321 # Get highest points of the panel
1322 # ------------------------------------
1323 def get_high_points(selobject, width, tip):
1324 obverts = selobject.data.vertices
1325
1326 top_a = 0
1327 top_b = 0
1328 top_c = 0
1329 # --------------------------
1330 # Recover all vertex
1331 # --------------------------
1332 for vertex in obverts:
1333 if vertex.co[0] == -width / 2:
1334 if vertex.co[2] >= top_a:
1335 top_a = vertex.co[2]
1336 if vertex.co[0] == width / 2:
1337 if vertex.co[2] >= top_b:
1338 top_b = vertex.co[2]
1339 # top center
1340 if tip == "2":
1341 if vertex.co[2] >= top_c:
1342 top_c = vertex.co[2]
1343 else:
1344 if vertex.co[0] == 0 and vertex.co[2] >= top_c:
1345 top_c = vertex.co[2]
1346
1347 return top_a, top_b, top_c
1348
1349
1350 # ---------------------------------------------------------
1351 # Defines a point
1352 # ---------------------------------------------------------
1353 class Cpoint:
1354
1355 def __init__(self, x, y):
1356 self.x = float(x)
1357 self.y = float(y)
1358
1359
1360 # ---------------------------------------------------------
1361 # Get angle between two vectors
1362 # ---------------------------------------------------------
1363 def get_angle(p1, p2):
1364 v1 = Vector((p1[0], 0.0, p1[1]))
1365 v2 = Vector((p2[0], 0.0, p2[1]))
1366
1367 a = v1.angle(v2)
1368 return a
1369
1370
1371 # ---------------------------------------------------------
1372 # Get center of circle base on 3 points
1373 #
1374 # Point a: (x,z)
1375 # Point b: (x,z)
1376 # Point c: (x,z)
1377 # Return:
1378 # x, y: center position
1379 # r: radio
1380 # ang: angle
1381 # ---------------------------------------------------------
1382 def get_circle_center(a, b, c):
1383 try:
1384 # line between a and b: s1 + k * d1
1385 s1 = Cpoint((a.x + b.x) / 2.0, (a.y + b.y) / 2.0)
1386 d1 = Cpoint(b.y - a.y, a.x - b.x)
1387 # line between a and c: s2 + k * d2
1388 s2 = Cpoint((a.x + c.x) / 2.0, (a.y + c.y) / 2.0)
1389 d2 = Cpoint(c.y - a.y, a.x - c.x)
1390 # intersection of both lines:
1391 l = d1.x * (s2.y - s1.y) - d1.y * (s2.x - s1.x)
1392 l /= d2.x * d1.y - d2.y * d1.x
1393 center = Cpoint(s2.x + l * d2.x, s2.y + l * d2.y)
1394 dx = center.x - a.x
1395 dy = center.y - a.y
1396 radio = sqrt(dx * dx + dy * dy)
1397
1398 # angle
1399 v1 = (a.x - center.x, a.y - center.y)
1400 v2 = (b.x - center.x, b.y - center.y)
1401 ang = get_angle(v1, v2)
1402 return center, radio, ang
1403 except ZeroDivisionError:
1404 return Cpoint(0, 0), 1, 1
1405
1406
1407 # -----------------------------------------
1408 # Get limits
1409 # lb, rb: limits x
1410 # lt, rt: limits z
1411 # mp: limit z in med point
1412 # lo: Z low limit
1413 # my: max y
1414 # top: top vertex
1415 # -----------------------------------------
1416 def get_limits(myobject):
1417 verts = myobject.data.vertices
1418
1419 lb = 0
1420 lt = 0
1421 rb = 0
1422 rt = 0
1423 mp = 0
1424 lo = 0
1425 my = 0
1426 top = 0
1427 for v in verts:
1428 if v.co[2] > top:
1429 top = v.co[2]
1430
1431 if v.co[2] < lo:
1432 lo = v.co[2]
1433
1434 if v.co[1] > my:
1435 my = v.co[1]
1436 if v.co[0] > rb:
1437 rb = v.co[0]
1438 if v.co[0] < lb:
1439 lb = v.co[0]
1440 if v.co[0] == 0:
1441 if v.co[2] > mp:
1442 mp = v.co[2]
1443 # max sides
1444 for v in verts:
1445 if v.co[2] > lt and v.co[0] == lb:
1446 lt = v.co[2]
1447 if v.co[2] > rt and v.co[0] == rb:
1448 rt = v.co[2]
1449
1450 return lb, lt, rb, rt, mp, lo, my, top
1451
1452
1453 # ------------------------------------------
1454 # Create control box for panels
1455 #
1456 # ------------------------------------------
1457 def create_ctrl_box(parentobj, objname):
1458 myvertex = []
1459 myfaces = []
1460
1461 o = parentobj
1462 op = o.WindowPanelGenerator[0]
1463
1464 lb, lt, rb, rt, mp, lo, my, top = get_limits(o)
1465 ypos = my * 1.8
1466 # -----------------------------
1467 # Flat, Triangle and inclined
1468 # -----------------------------
1469 if op.UST == "1" or op.UST == "3" or op.UST == "4":
1470 if mp == 0:
1471 myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (rb, ypos, rt), (rb, ypos, lo)])
1472 myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (rb, -ypos, rt), (rb, -ypos, lo)])
1473 myfaces.extend([(0, 4, 5, 1), (3, 2, 6, 7), (0, 1, 2, 3), (4, 7, 6, 5), (1, 5, 6, 2), (0, 3, 7, 4)])
1474 else:
1475 myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (0, ypos, mp), (rb, ypos, rt), (rb, ypos, lo)])
1476 myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (0, -ypos, mp), (rb, -ypos, rt), (rb, -ypos, lo)])
1477 myfaces.extend([(0, 5, 6, 1), (4, 3, 8, 9), (0, 1, 2, 3, 4), (9, 8, 7, 6, 5), (1, 6, 7, 2), (2, 7, 8, 3),
1478 (0, 4, 9, 5)])
1479 # -----------------------------
1480 # Arch
1481 # -----------------------------
1482 if op.UST == "2":
1483 center, r, ang = get_circle_center(Cpoint(lb, lt), Cpoint(0, top), Cpoint(rb, rt))
1484
1485 # cx = center.x
1486 cz = center.y
1487
1488 sg = op.res
1489 arc = ((pi / 2) + ang) - ((pi / 2) - ang)
1490 step = arc / sg
1491 a = (pi / 2) + ang
1492
1493 myvertex.extend([(lb, ypos, lt), (lb, -ypos, lt)])
1494 for x in range(0, sg):
1495 myvertex.extend([(r * cos(a), ypos, r * sin(a) + cz),
1496 (r * cos(a), -ypos, r * sin(a) + cz)])
1497 a -= step
1498
1499 # close sides
1500 myvertex.extend([(rb, ypos, rt), (rb, -ypos, rt)])
1501
1502 v = 0
1503 nf = len(myvertex)
1504 for x in range(0, nf - 2, 2):
1505 myfaces.extend([(v, v + 1, v + 3, v + 2)])
1506 v += 2
1507
1508 nf = len(myvertex)
1509 myvertex.extend([(lb, ypos, lo), (lb, -ypos, lo)])
1510 myvertex.extend([(rb, ypos, lo), (rb, -ypos, lo)])
1511
1512 nf2 = len(myvertex)
1513 myfaces.extend([(0, nf2 - 4, nf2 - 3, 1)])
1514 myfaces.extend([(nf - 2, nf - 1, nf2 - 1, nf2 - 2)])
1515
1516 nf2 = len(myvertex)
1517 myfaces.extend([(nf2 - 4, nf2 - 2, nf2 - 1, nf2 - 3)])
1518
1519 # --------------------------
1520 # Create mesh
1521 # --------------------------
1522 myfaces = check_mesh_errors(myvertex, myfaces)
1523 mymesh = bpy.data.meshes.new(objname)
1524 myobj = bpy.data.objects.new(objname, mymesh)
1525
1526 myobj.location = bpy.context.scene.cursor.location
1527 bpy.context.collection.objects.link(myobj)
1528
1529 mymesh.from_pydata(myvertex, [], myfaces)
1530 mymesh.update(calc_edges=True)
1531
1532 return myobj
1533
1534
1535 # ------------------------------------------------------------------
1536 # Define property group class to create or modify
1537 # ------------------------------------------------------------------
1538 class GeneralPanelProperties(PropertyGroup):
1539 prs: EnumProperty(
1540 items=(
1541 ('1', "WINDOW 250X200", ""),
1542 ('2', "WINDOW 200X200", ""),
1543 ('3', "WINDOW 180X200", ""),
1544 ('4', "WINDOW 180X160", ""),
1545 ('5', "WINDOW 160X160", ""),
1546 ('6', "WINDOW 50X50", ""),
1547 ('7', "DOOR 80X250", ""),
1548 ('8', "DOOR 80X230", ""),
1549 ),
1550 name="",
1551 description='Predefined types',
1552 update=update_using_default,
1553 )
1554 son: EnumProperty(
1555 items=(
1556 ('1', "WINDOW 250X200", ""),
1557 ('2', "WINDOW 200X200", ""),
1558 ('3', "WINDOW 180X200", ""),
1559 ('4', "WINDOW 180X160", ""),
1560 ('5', "WINDOW 160X160", ""),
1561 ('6', "WINDOW 50X50", ""),
1562 ('7', "DOOR 80X250", ""),
1563 ('8', "DOOR 80X230", ""),
1564 ),
1565 name="",
1566 description='Predefined types',
1567 update=update_using_default,
1568 )
1569 gen: IntProperty(
1570 name='H Count', min=1, max=8, default=3,
1571 description='Horizontal Panes',
1572 update=update_window,
1573 )
1574 yuk: IntProperty(
1575 name='V Count', min=1, max=5, default=1,
1576 description='Vertical Panes',
1577 update=update_window,
1578 )
1579 kl1: IntProperty(
1580 name='Outer Frame', min=2, max=50, default=5,
1581 description='Outside Frame Thickness',
1582 update=update_window,
1583 )
1584 kl2: IntProperty(
1585 name='Risers', min=2, max=50, default=5,
1586 description='Risers Width',
1587 update=update_window,
1588 )
1589 fk: IntProperty(
1590 name='Inner Frame', min=1, max=20, default=2,
1591 description='Inside Frame Thickness',
1592 update=update_window,
1593 )
1594
1595 mr: BoolProperty(name='Sill', default=True, description='Window Sill', update=update_window)
1596 mr1: IntProperty(name='', min=1, max=20, default=4, description='Height', update=update_window)
1597 mr2: IntProperty(name='', min=0, max=20, default=4, description='First Depth', update=update_window)
1598 mr3: IntProperty(name='', min=1, max=50, default=20, description='Second Depth', update=update_window)
1599 mr4: IntProperty(name='', min=0, max=50, default=0, description='Extrusion for Jamb',
1600 update=update_window)
1601
1602 mt1: EnumProperty(
1603 items=(
1604 ('1', "PVC", ""),
1605 ('2', "WOOD", ""),
1606 ('3', "Plastic", ""),
1607 ),
1608 name="",
1609 default='1',
1610 description='Material to use',
1611 update=update_window,
1612 )
1613 mt2: EnumProperty(
1614 items=(
1615 ('1', "PVC", ""),
1616 ('2', "WOOD", ""),
1617 ('3', "Plastic", ""),
1618 ),
1619 name="",
1620 default='3',
1621 description='Material to use',
1622 update=update_window,
1623 )
1624
1625 r: FloatProperty(
1626 name='Rotation',
1627 min=0, max=360, default=0, precision=1,
1628 description='Panel rotation',
1629 update=update_window,
1630 )
1631
1632 UST: EnumProperty(
1633 items=(
1634 ('1', "Flat", ""),
1635 ('2', "Arch", ""),
1636 ('3', "Inclined", ""),
1637 ('4', "Triangle", ""),
1638 ),
1639 name="Top", default='1',
1640 description='Type of window upper section',
1641 update=update_window,
1642 )
1643 DT2: EnumProperty(
1644 items=(
1645 ('1', "Difference", ""),
1646 ('2', "Radius", ""),
1647 ),
1648 name="",
1649 default='1',
1650 update=update_window,
1651 )
1652 DT3: EnumProperty(
1653 items=(
1654 ('1', "Difference", ""),
1655 ('2', "Incline %", ""),
1656 ('3', "Incline Angle", ""),
1657 ),
1658 name="",
1659 default='1', update=update_window,
1660 )
1661
1662 VL1: IntProperty(name='', min=-10000, max=10000, default=30, update=update_window) # Fark
1663 VL2: IntProperty(name='', min=1, max=10000, default=30, update=update_window) # Cap
1664 VL3: IntProperty(name='', min=-100, max=100, default=30, update=update_window) # Egim %
1665 VL4: IntProperty(name='', min=-45, max=45, default=30, update=update_window) # Egim Aci
1666
1667 res: IntProperty(name='Resolution', min=2, max=360, default=36, update=update_window) # Res
1668
1669 gnx0: IntProperty(name='', min=1, max=300, default=60, description='1st Window Width',
1670 update=update_window)
1671 gnx1: IntProperty(name='', min=1, max=300, default=110, description='2nd Window Width',
1672 update=update_window)
1673 gnx2: IntProperty(name='', min=1, max=300, default=60, description='3rd Window Width',
1674 update=update_window)
1675 gnx3: IntProperty(name='', min=1, max=300, default=60, description='4th Window Width',
1676 update=update_window)
1677 gnx4: IntProperty(name='', min=1, max=300, default=60, description='5th Window Width',
1678 update=update_window)
1679 gnx5: IntProperty(name='', min=1, max=300, default=60, description='6th Window Width',
1680 update=update_window)
1681 gnx6: IntProperty(name='', min=1, max=300, default=60, description='7th Window Width',
1682 update=update_window)
1683 gnx7: IntProperty(name='', min=1, max=300, default=60, description='8th Window Width',
1684 update=update_window)
1685
1686 gny0: IntProperty(name='', min=1, max=300, default=190, description='1st Row Height',
1687 update=update_window)
1688 gny1: IntProperty(name='', min=1, max=300, default=45, description='2nd Row Height',
1689 update=update_window)
1690 gny2: IntProperty(name='', min=1, max=300, default=45, description='3rd Row Height',
1691 update=update_window)
1692 gny3: IntProperty(name='', min=1, max=300, default=45, description='4th Row Height',
1693 update=update_window)
1694 gny4: IntProperty(name='', min=1, max=300, default=45, description='5th Row Height',
1695 update=update_window)
1696
1697 k00: BoolProperty(name='', default=True, update=update_window)
1698 k01: BoolProperty(name='', default=False, update=update_window)
1699 k02: BoolProperty(name='', default=True, update=update_window)
1700 k03: BoolProperty(name='', default=False, update=update_window)
1701 k04: BoolProperty(name='', default=False, update=update_window)
1702 k05: BoolProperty(name='', default=False, update=update_window)
1703 k06: BoolProperty(name='', default=False, update=update_window)
1704 k07: BoolProperty(name='', default=False, update=update_window)
1705
1706 k10: BoolProperty(name='', default=False, update=update_window)
1707 k11: BoolProperty(name='', default=False, update=update_window)
1708 k12: BoolProperty(name='', default=False, update=update_window)
1709 k13: BoolProperty(name='', default=False, update=update_window)
1710 k14: BoolProperty(name='', default=False, update=update_window)
1711 k15: BoolProperty(name='', default=False, update=update_window)
1712 k16: BoolProperty(name='', default=False, update=update_window)
1713 k17: BoolProperty(name='', default=False, update=update_window)
1714
1715 k20: BoolProperty(name='', default=False, update=update_window)
1716 k21: BoolProperty(name='', default=False, update=update_window)
1717 k22: BoolProperty(name='', default=False, update=update_window)
1718 k23: BoolProperty(name='', default=False, update=update_window)
1719 k24: BoolProperty(name='', default=False, update=update_window)
1720 k25: BoolProperty(name='', default=False, update=update_window)
1721 k26: BoolProperty(name='', default=False, update=update_window)
1722 k27: BoolProperty(name='', default=False, update=update_window)
1723
1724 k30: BoolProperty(name='', default=False, update=update_window)
1725 k31: BoolProperty(name='', default=False, update=update_window)
1726 k32: BoolProperty(name='', default=False, update=update_window)
1727 k33: BoolProperty(name='', default=False, update=update_window)
1728 k34: BoolProperty(name='', default=False, update=update_window)
1729 k35: BoolProperty(name='', default=False, update=update_window)
1730 k36: BoolProperty(name='', default=False, update=update_window)
1731 k37: BoolProperty(name='', default=False, update=update_window)
1732
1733 k40: BoolProperty(name='', default=False, update=update_window)
1734 k41: BoolProperty(name='', default=False, update=update_window)
1735 k42: BoolProperty(name='', default=False, update=update_window)
1736 k43: BoolProperty(name='', default=False, update=update_window)
1737 k44: BoolProperty(name='', default=False, update=update_window)
1738 k45: BoolProperty(name='', default=False, update=update_window)
1739 k46: BoolProperty(name='', default=False, update=update_window)
1740 k47: BoolProperty(name='', default=False, update=update_window)
1741 # opengl internal data
1742 glpoint_a: FloatVectorProperty(
1743 name="glpointa",
1744 description="Hidden property for opengl",
1745 default=(0, 0, 0),
1746 )
1747 glpoint_b: FloatVectorProperty(
1748 name="glpointb",
1749 description="Hidden property for opengl",
1750 default=(0, 0, 0),
1751 )
1752 glpoint_c: FloatVectorProperty(
1753 name="glpointc",
1754 description="Hidden property for opengl",
1755 default=(0, 0, 0),
1756 )
1757 glpoint_d: FloatVectorProperty(
1758 name="glpointc",
1759 description="Hidden property for opengl",
1760 default=(0, 0, 0),
1761 )
1762
1763
1764 bpy.utils.register_class(GeneralPanelProperties)
1765 Object.WindowPanelGenerator = CollectionProperty(type=GeneralPanelProperties)
1766
1767
1768 # ------------------------------------------------------------------
1769 # Define panel class to modify myobjects.
1770 # ------------------------------------------------------------------
1771 class ARCHIMESH_PT_WindowEdit(Panel):
1772 bl_idname = "ARCHIMESH_PT_window_edit"
1773 bl_label = "Window Panel"
1774 bl_space_type = 'VIEW_3D'
1775 bl_region_type = 'UI'
1776 bl_category = 'Create'
1777
1778 # -----------------------------------------------------
1779 # Verify if visible
1780 # -----------------------------------------------------
1781 @classmethod
1782 def poll(cls, context):
1783 o = context.object
1784 if o is None:
1785 return False
1786 if 'WindowPanelGenerator' not in o:
1787 return False
1788 else:
1789 return True
1790
1791 # -----------------------------------------------------
1792 # Draw (create UI interface)
1793 # -----------------------------------------------------
1794 def draw(self, context):
1795 o = context.object
1796 # If the selected object didn't be created with the group 'WindowPanelGenerator', this panel is not created.
1797 # noinspection PyBroadException
1798 try:
1799 if 'WindowPanelGenerator' not in o:
1800 return
1801 except:
1802 return
1803
1804 layout = self.layout
1805 if bpy.context.mode == 'EDIT_MESH':
1806 layout.label(text='Warning: Operator does not work in edit mode.', icon='ERROR')
1807 else:
1808 myobject = o.WindowPanelGenerator[0]
1809 layout.prop(myobject, 'prs')
1810 box = layout.box()
1811 box.prop(myobject, 'gen')
1812 box.prop(myobject, 'yuk')
1813 box.prop(myobject, 'kl1')
1814 box.prop(myobject, 'kl2')
1815 box.prop(myobject, 'fk')
1816 box.prop(myobject, 'r') # rotation
1817
1818 box.prop(myobject, 'mr')
1819 if myobject.mr is True:
1820 row = box.row()
1821 row.prop(myobject, 'mr1')
1822 row.prop(myobject, 'mr2')
1823 row = box.row()
1824 row.prop(myobject, 'mr3')
1825 row.prop(myobject, 'mr4')
1826 row = layout.row()
1827 row.label(text='Frame')
1828 row.label(text='Inner Frame')
1829 row = layout.row()
1830 row.prop(myobject, 'mt1')
1831 row.prop(myobject, 'mt2')
1832
1833 box.prop(myobject, 'UST')
1834 if myobject.UST == '2':
1835 row = box.row()
1836 row.prop(myobject, 'DT2')
1837 if myobject.DT2 == '1':
1838 row.prop(myobject, 'VL1')
1839 elif myobject.DT2 == '2':
1840 row.prop(myobject, 'VL2')
1841 box.prop(myobject, 'res')
1842 elif myobject.UST == '3':
1843 row = box.row()
1844 row.prop(myobject, 'DT3')
1845 if myobject.DT3 == '1':
1846 row.prop(myobject, 'VL1')
1847 elif myobject.DT3 == '2':
1848 row.prop(myobject, 'VL3')
1849 elif myobject.DT3 == '3':
1850 row.prop(myobject, 'VL4')
1851 elif myobject.UST == '4':
1852 row = box.row()
1853 row.prop(myobject, 'DT3')
1854 if myobject.DT3 == '1':
1855 row.prop(myobject, 'VL1')
1856 elif myobject.DT3 == '2':
1857 row.prop(myobject, 'VL3')
1858 elif myobject.DT3 == '3':
1859 row.prop(myobject, 'VL4')
1860 row = layout.row()
1861 for i in range(0, myobject.gen):
1862 row.prop(myobject, 'gnx' + str(i))
1863 for j in range(0, myobject.yuk):
1864 row = layout.row()
1865 row.prop(myobject, 'gny' + str(myobject.yuk - j - 1))
1866 for i in range(0, myobject.gen):
1867 row.prop(myobject, 'k' + str(myobject.yuk - j - 1) + str(i))
Central repository of Blender addons