1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
|
# ##### 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>
import bpy
from mathutils import Color, Vector
__all__ = (
"PrincipledBSDFWrapper",
)
def _set_check(func):
from functools import wraps
@wraps(func)
def wrapper(self, *args, **kwargs):
if self.is_readonly:
assert(not "Trying to set value to read-only shader!")
return
return func(self, *args, **kwargs)
return wrapper
def rgb_to_rgba(rgb):
return list(rgb) + [1.0]
def rgba_to_rgb(rgba):
return Color((rgba[0], rgba[1], rgba[2]))
class ShaderWrapper():
"""
Base class with minimal common ground for all types of shader interfaces we may want/need to implement.
"""
# The two mandatory nodes any children class should support.
NODES_LIST = (
"node_out",
"_node_texcoords",
)
__slots__ = (
"is_readonly",
"material",
"_textures",
"_grid_locations",
*NODES_LIST,
)
_col_size = 300
_row_size = 300
def _grid_to_location(self, x, y, dst_node=None, ref_node=None):
if ref_node is not None: # x and y are relative to this node location.
nx = round(ref_node.location.x / self._col_size)
ny = round(ref_node.location.y / self._row_size)
x += nx
y += ny
loc = None
while True:
loc = (x * self._col_size, y * self._row_size)
if loc not in self._grid_locations:
break
loc = (x * self._col_size, (y - 1) * self._row_size)
if loc not in self._grid_locations:
break
loc = (x * self._col_size, (y - 2) * self._row_size)
if loc not in self._grid_locations:
break
x -= 1
self._grid_locations.add(loc)
if dst_node is not None:
dst_node.location = loc
dst_node.width = min(dst_node.width, self._col_size - 20)
return loc
def __init__(self, material, is_readonly=True, use_nodes=True):
self.is_readonly = is_readonly
self.material = material
self.use_nodes = use_nodes
self.update()
def update(self): # Should be re-implemented by children classes...
for node in self.NODES_LIST:
setattr(self, node, None)
self._textures = {}
self._grid_locations = set()
def use_nodes_get(self):
return self.material.use_nodes
@_set_check
def use_nodes_set(self, val):
self.material.use_nodes = val
self.update()
use_nodes = property(use_nodes_get, use_nodes_set)
def node_texcoords_get(self):
if not self.use_nodes:
return None
if self._node_texcoords is ...:
# Running only once, trying to find a valid texcoords node.
for n in self.material.node_tree.nodes:
if n.bl_idname == 'ShaderNodeTexCoord':
self._node_texcoords = n
self._grid_to_location(0, 0, ref_node=n)
break
if self._node_texcoords is ...:
self._node_texcoords = None
if self._node_texcoords is None and not self.is_readonly:
tree = self.material.node_tree
nodes = tree.nodes
links = tree.links
node_texcoords = nodes.new(type='ShaderNodeTexCoord')
node_texcoords.label = "Texture Coords"
self._grid_to_location(-5, 1, dst_node=node_texcoords)
self._node_texcoords = node_texcoords
return self._node_texcoords
node_texcoords = property(node_texcoords_get)
class PrincipledBSDFWrapper(ShaderWrapper):
"""
Hard coded shader setup, based in Principled BSDF.
Should cover most common cases on import, and gives a basic nodal shaders support for export.
Supports basic: diffuse/spec/reflect/transparency/normal, with texturing.
"""
NODES_LIST = (
"node_out",
"node_principled_bsdf",
"_node_normalmap",
"_node_texcoords",
)
__slots__ = (
"is_readonly",
"material",
*NODES_LIST,
)
NODES_LIST = ShaderWrapper.NODES_LIST + NODES_LIST
def __init__(self, material, is_readonly=True, use_nodes=True):
super(PrincipledBSDFWrapper, self).__init__(material, is_readonly, use_nodes)
def update(self):
super(PrincipledBSDFWrapper, self).update()
if not self.use_nodes:
return
tree = self.material.node_tree
nodes = tree.nodes
links = tree.links
# --------------------------------------------------------------------
# Main output and shader.
node_out = None
node_principled = None
for n in nodes:
if n.bl_idname == 'ShaderNodeOutputMaterial' and n.inputs[0].is_linked:
node_out = n
node_principled = n.inputs[0].links[0].from_node
elif n.bl_idname == 'ShaderNodeBsdfPrincipled' and n.outputs[0].is_linked:
node_principled = n
for lnk in n.outputs[0].links:
node_out = lnk.to_node
if node_out.bl_idname == 'ShaderNodeOutputMaterial':
break
if (
node_out is not None and node_principled is not None and
node_out.bl_idname == 'ShaderNodeOutputMaterial' and
node_principled.bl_idname == 'ShaderNodeBsdfPrincipled'
):
break
node_out = node_principled = None # Could not find a valid pair, let's try again
if node_out is not None:
self._grid_to_location(0, 0, ref_node=node_out)
elif not self.is_readonly:
node_out = nodes.new(type='ShaderNodeOutputMaterial')
node_out.label = "Material Out"
node_out.target = 'ALL'
self._grid_to_location(1, 1, dst_node=node_out)
self.node_out = node_out
if node_principled is not None:
self._grid_to_location(0, 0, ref_node=node_principled)
elif not self.is_readonly:
node_principled = nodes.new(type='ShaderNodeBsdfPrincipled')
node_principled.label = "Principled BSDF"
self._grid_to_location(0, 1, dst_node=node_principled)
# Link
links.new(node_principled.outputs["BSDF"], self.node_out.inputs["Surface"])
self.node_principled_bsdf = node_principled
# --------------------------------------------------------------------
# Normal Map, lazy initialization...
self._node_normalmap = ...
# --------------------------------------------------------------------
# Tex Coords, lazy initialization...
self._node_texcoords = ...
def node_normalmap_get(self):
if not self.use_nodes:
return None
if self.node_principled_bsdf is not None:
node_principled = self.node_principled_bsdf
if self._node_normalmap is ...:
# Running only once, trying to find a valid normalmap node.
if node_principled.inputs["Normal"].is_linked:
node_normalmap = node_principled.inputs["Normal"].links[0].from_node
if node_normalmap.bl_idname == 'ShaderNodeNormalMap':
self._node_normalmap = node_normalmap
self._grid_to_location(0, 0, ref_node=node_normalmap)
if self._node_normalmap is ...:
self._node_normalmap = None
if self._node_normalmap is None and not self.is_readonly:
tree = self.material.node_tree
nodes = tree.nodes
links = tree.links
node_normalmap = nodes.new(type='ShaderNodeNormalMap')
node_normalmap.label = "Normal/Map"
self._grid_to_location(-1, -2, dst_node=node_normalmap, ref_node=node_principled)
# Link
links.new(node_normalmap.outputs["Normal"], node_principled.inputs["Normal"])
return self._node_normalmap
node_normalmap = property(node_normalmap_get)
# --------------------------------------------------------------------
# Base Color.
def base_color_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return self.material.diffuse_color
return rgba_to_rgb(self.node_principled_bsdf.inputs["Base Color"].default_value)
@_set_check
def base_color_set(self, color):
self.material.diffuse_color = color
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Base Color"].default_value = rgb_to_rgba(color)
base_color = property(base_color_get, base_color_set)
def base_color_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["Base Color"],
grid_row_diff=1,
)
base_color_texture = property(base_color_texture_get)
# --------------------------------------------------------------------
# Specular.
def specular_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return self.material.specular_intensity
return self.node_principled_bsdf.inputs["Specular"].default_value
@_set_check
def specular_set(self, value):
self.material.specular_intensity = value
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Specular"].default_value = value
specular = property(specular_get, specular_set)
def specular_tint_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return 0.0
return rgba_to_rgb(self.node_principled_bsdf.inputs["Specular Tint"].default_value)
@_set_check
def specular_tint_set(self, value):
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Specular Tint"].default_value = rgb_to_rgba(value)
specular_tint = property(specular_tint_get, specular_tint_set)
# Will only be used as gray-scale one...
def specular_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
print("NO NODES!")
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["Specular"],
grid_row_diff=0,
)
specular_texture = property(specular_texture_get)
# --------------------------------------------------------------------
# Roughness (also sort of inverse of specular hardness...).
def roughness_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return self.material.roughness
return self.node_principled_bsdf.inputs["Roughness"].default_value
@_set_check
def roughness_set(self, value):
self.material.roughness = value
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Roughness"].default_value = value
roughness = property(roughness_get, roughness_set)
# Will only be used as gray-scale one...
def roughness_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["Roughness"],
grid_row_diff=0,
)
roughness_texture = property(roughness_texture_get)
# --------------------------------------------------------------------
# Metallic (a.k.a reflection, mirror).
def metallic_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return self.material.metallic
return self.node_principled_bsdf.inputs["Metallic"].default_value
@_set_check
def metallic_set(self, value):
self.material.metallic = value
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Metallic"].default_value = value
metallic = property(metallic_get, metallic_set)
# Will only be used as gray-scale one...
def metallic_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["Metallic"],
grid_row_diff=0,
)
metallic_texture = property(metallic_texture_get)
# --------------------------------------------------------------------
# Transparency settings.
def ior_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return 1.0
return self.node_principled_bsdf.inputs["IOR"].default_value
@_set_check
def ior_set(self, value):
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["IOR"].default_value = value
ior = property(ior_get, ior_set)
# Will only be used as gray-scale one...
def ior_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["IOR"],
grid_row_diff=-1,
)
ior_texture = property(ior_texture_get)
def transmission_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return 0.0
return self.node_principled_bsdf.inputs["Transmission"].default_value
@_set_check
def transmission_set(self, value):
if self.use_nodes and self.node_principled_bsdf is not None:
self.node_principled_bsdf.inputs["Transmission"].default_value = value
transmission = property(transmission_get, transmission_set)
# Will only be used as gray-scale one...
def transmission_texture_get(self):
if not self.use_nodes or self.node_principled_bsdf is None:
return None
return ShaderImageTextureWrapper(
self, self.node_principled_bsdf,
self.node_principled_bsdf.inputs["Transmission"],
grid_row_diff=-1,
)
transmission_texture = property(transmission_texture_get)
# TODO: Do we need more complex handling for alpha (allowing masking and such)?
# Would need extra mixing nodes onto Base Color maybe, or even its own shading chain...
# --------------------------------------------------------------------
# Normal map.
def normalmap_strength_get(self):
if not self.use_nodes or self.node_normalmap is None:
return 0.0
return self.node_normalmap.inputs["Strength"].default_value
@_set_check
def normalmap_strength_set(self, value):
if self.use_nodes and self.node_normalmap is not None:
self.node_normalmap.inputs["Strength"].default_value = value
normalmap_strength = property(normalmap_strength_get, normalmap_strength_set)
def normalmap_texture_get(self):
if not self.use_nodes or self.node_normalmap is None:
return None
return ShaderImageTextureWrapper(
self, self.node_normalmap,
self.node_normalmap.inputs["Color"],
grid_row_diff=-2,
)
normalmap_texture = property(normalmap_texture_get)
class ShaderImageTextureWrapper():
"""
Generic 'image texture'-like wrapper, handling image node, some mapping (texture coordinates transformations),
and texture coordinates source.
"""
# Note: this class assumes we are using nodes, otherwise it should never be used...
NODES_LIST = (
"node_dst",
"socket_dst",
"_node_image",
"_node_mapping",
)
__slots__ = (
"owner_shader",
"is_readonly",
"grid_row_diff",
"use_alpha",
*NODES_LIST,
)
def __new__(cls, owner_shader: ShaderWrapper, node_dst, socket_dst, *args, **kwargs):
instance = owner_shader._textures.get((node_dst, socket_dst), None)
if instance is not None:
return instance
instance = super(ShaderImageTextureWrapper, cls).__new__(cls)
owner_shader._textures[(node_dst, socket_dst)] = instance
return instance
def __init__(self, owner_shader: ShaderWrapper, node_dst, socket_dst, grid_row_diff=0, use_alpha=False):
self.owner_shader = owner_shader
self.is_readonly = owner_shader.is_readonly
self.node_dst = node_dst
self.socket_dst = socket_dst
self.grid_row_diff = grid_row_diff
self.use_alpha = use_alpha
self._node_image = ...
self._node_mapping = ...
tree = node_dst.id_data
nodes = tree.nodes
links = tree.links
if socket_dst.is_linked:
from_node = socket_dst.links[0].from_node
if from_node.bl_idname == 'ShaderNodeTexImage':
self._node_image = from_node
if self.node_image is not None:
socket_dst = self.node_image.inputs["Vector"]
if socket_dst.is_linked:
from_node = socket_dst.links[0].from_node
if from_node.bl_idname == 'ShaderNodeMapping':
self._node_mapping = from_node
def copy_from(self, tex):
# Avoid generating any node in source texture.
is_readonly_back = tex.is_readonly
tex.is_readonly = True
if tex.node_image is not None:
self.image = tex.image
self.projection = tex.projection
self.texcoords = tex.texcoords
self.copy_mapping_from(tex)
tex.is_readonly = is_readonly_back
def copy_mapping_from(self, tex):
# Avoid generating any node in source texture.
is_readonly_back = tex.is_readonly
tex.is_readonly = True
if tex.node_mapping is None: # Used to actually remove mapping node.
if self.has_mapping_node():
# We assume node_image can never be None in that case...
# Find potential existing link into image's Vector input.
socket_dst = socket_src = None
if self.node_mapping.inputs["Vector"].is_linked:
socket_dst = self.node_image.inputs["Vector"]
socket_src = self.node_mapping.inputs["Vector"].links[0].from_socket
tree = self.owner_shader.material.node_tree
tree.nodes.remove(self.node_mapping)
self._node_mapping = None
# If previously existing, re-link texcoords -> image
if socket_src is not None:
tree.links.new(socket_src, socket_dst)
elif self.node_mapping is not None:
self.translation = tex.translation
self.rotation = tex.rotation
self.scale = tex.scale
self.use_min = tex.use_min
self.use_max = tex.use_max
self.min = tex.min
self.max = tex.max
tex.is_readonly = is_readonly_back
# --------------------------------------------------------------------
# Image.
def node_image_get(self):
if self._node_image is ...:
# Running only once, trying to find a valid image node.
if self.socket_dst.is_linked:
node_image = self.socket_dst.links[0].from_node
if node_image.bl_idname == 'ShaderNodeTexImage':
self._node_image = node_image
self.owner_shader._grid_to_location(0, 0, ref_node=node_image)
if self._node_image is ...:
self._node_image = None
if self._node_image is None and not self.is_readonly:
tree = self.owner_shader.material.node_tree
node_image = tree.nodes.new(type='ShaderNodeTexImage')
self.owner_shader._grid_to_location(-1, 0 + self.grid_row_diff, dst_node=node_image, ref_node=self.node_dst)
tree.links.new(node_image.outputs["Alpha" if self.use_alpha else "Color"], self.socket_dst)
self._node_image = node_image
return self._node_image
node_image = property(node_image_get)
def image_get(self):
return self.node_image.image if self.node_image is not None else None
@_set_check
def image_set(self, image):
self.node_image.image = image
image = property(image_get, image_set)
def projection_get(self):
return self.node_image.projection if self.node_image is not None else 'FLAT'
@_set_check
def projection_set(self, projection):
self.node_image.projection = projection
projection = property(projection_get, projection_set)
def texcoords_get(self):
if self.node_image is not None:
socket = (self.node_mapping if self.has_mapping_node() else self.node_image).inputs["Vector"]
if socket.is_linked:
return socket.links[0].from_socket.name
return 'UV'
@_set_check
def texcoords_set(self, texcoords):
# Image texture node already defaults to UVs, no extra node needed.
# ONLY in case we do not have any texcoords mapping!!!
if texcoords == 'UV' and not self.has_mapping_node():
return
tree = self.node_image.id_data
links = tree.links
node_dst = self.node_mapping if self.has_mapping_node() else self.node_image
socket_src = self.owner_shader.node_texcoords.outputs[texcoords]
links.new(socket_src, node_dst.inputs["Vector"])
texcoords = property(texcoords_get, texcoords_set)
# --------------------------------------------------------------------
# Mapping.
def has_mapping_node(self):
return self._node_mapping not in {None, ...}
def node_mapping_get(self):
if self._node_mapping is ...:
# Running only once, trying to find a valid mapping node.
if self.node_image is None:
return None
if self.node_image.inputs["Vector"].is_linked:
node_mapping = self.node_image.inputs["Vector"].links[0].from_node
if node_mapping.bl_idname == 'ShaderNodeMapping':
self._node_mapping = node_mapping
self.owner_shader._grid_to_location(0, 0 + self.grid_row_diff, ref_node=node_mapping)
if self._node_mapping is ...:
self._node_mapping = None
if self._node_mapping is None and not self.is_readonly:
# Find potential existing link into image's Vector input.
socket_dst = self.node_image.inputs["Vector"]
# If not already existing, we need to create texcoords -> mapping link (from UV).
socket_src = (socket_dst.links[0].from_socket if socket_dst.is_linked
else self.owner_shader.node_texcoords.outputs['UV'])
tree = self.owner_shader.material.node_tree
node_mapping = tree.nodes.new(type='ShaderNodeMapping')
node_mapping.vector_type = 'TEXTURE'
self.owner_shader._grid_to_location(-1, 0, dst_node=node_mapping, ref_node=self.node_image)
# Link mapping -> image node.
tree.links.new(node_mapping.outputs["Vector"], socket_dst)
# Link texcoords -> mapping.
tree.links.new(socket_src, node_mapping.inputs["Vector"])
self._node_mapping = node_mapping
return self._node_mapping
node_mapping = property(node_mapping_get)
def translation_get(self):
return self.node_mapping.translation if self.node_mapping is not None else Vector((0.0, 0.0, 0.0))
@_set_check
def translation_set(self, translation):
self.node_mapping.translation = translation
translation = property(translation_get, translation_set)
def rotation_get(self):
return self.node_mapping.rotation if self.node_mapping is not None else Vector((0.0, 0.0, 0.0))
@_set_check
def rotation_set(self, rotation):
self.node_mapping.rotation = rotation
rotation = property(rotation_get, rotation_set)
def scale_get(self):
return self.node_mapping.scale if self.node_mapping is not None else Vector((1.0, 1.0, 1.0))
@_set_check
def scale_set(self, scale):
self.node_mapping.scale = scale
scale = property(scale_get, scale_set)
def use_min_get(self):
return self.node_mapping.use_min if self_mapping.node is not None else False
@_set_check
def use_min_set(self, use_min):
self.node_mapping.use_min = use_min
use_min = property(use_min_get, use_min_set)
def use_max_get(self):
return self.node_mapping.use_max if self_mapping.node is not None else False
@_set_check
def use_max_set(self, use_max):
self.node_mapping.use_max = use_max
use_max = property(use_max_get, use_max_set)
def min_get(self):
return self.node_mapping.min if self.node_mapping is not None else Vector((0.0, 0.0, 0.0))
@_set_check
def min_set(self, min):
self.node_mapping.min = min
min = property(min_get, min_set)
def max_get(self):
return self.node_mapping.max if self.node_mapping is not None else Vector((0.0, 0.0, 0.0))
@_set_check
def max_set(self, max):
self.node_mapping.max = max
max = property(max_get, max_set)
|