-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathio_import_gimp_as_planes.py
1493 lines (1176 loc) · 56.4 KB
/
io_import_gimp_as_planes.py
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
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# ##### 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 #####
BLENDER = True
if __name__ == "__main__":
BLENDER = False
import subprocess as sp
import shlex
import re
import os
from pathlib import Path
import warnings
from itertools import count, repeat
from collections import namedtuple
from math import pi
if BLENDER:
import bpy
from bpy.types import Operator
from mathutils import Vector
from bpy.props import (
StringProperty,
BoolProperty,
EnumProperty,
FloatProperty,
CollectionProperty,
)
from bpy_extras.object_utils import (
AddObjectHelper,
world_to_camera_view,
)
from bpy_extras.image_utils import load_image
re_imgsize = re.compile( r'IMGSIZE ([0-9]+)x([0-9]+)' )
bl_info = {
"name": "Import GIMP Image as Layers (.xcf, .xfcgz, .xfcbz2 etc.)",
"author": "Markus Schatten (AILab-FOI)",
"version": (1, 0, 0),
"blender": (2, 80, 0),
"location": "File > Import > Import GIMP image layers as planes",
"description": "Imports GIMP multilayer image files as a series of multiple planes. Based on Import Images as Planes by Florian Meyer (tstscr), mont29, matali and Ted Schundler (SpkyElctrc) as well as on Import GIMP Image to Scene (.xcf, .xjt) by Daniel Salazar (ZanQdo).",
"warning": "Requires GIMP installed and on system path. Currently offsets and opacity of original layers are not preserved.",
"tracker_url": "https://github.com/AILab-FOI/gimp-blender-import/issues",
"category": "Import-Export"}
'''
;; Script-fu script for getting layer data.
;; Stolen partly from: https://github.com/pft/script-fu/
;; SAVE-LAYERS "filename.xcf"
;; OUTPUT:
;; "layer name":TYPE:OPACITY:OFFSET:WIDTH:HEIGHT:VISIBLE
;;
;; TYPE in { RGB-IMAGE (0), RGBA-IMAGE (1), GRAY-IMAGE (2), GRAYA-IMAGE (3), INDEXED-IMAGE (4), INDEXEDA-IMAGE (5) }
;;
;; OPACITY in 0.0 - 100.0
;;
;; OFFSET (X Y) X,Y are integers
;;
;; WIDTH, HEIGHT (X), (Y) integers
;;
;; VISIBLE 0 or 1
'''
script_fu = r"""
(define (save-layers img)
(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE img img)))
(basename (car (gimp-image-get-filename image))))
(when (string=? basename "")
(set! basename (string-append
(car (gimp-temp-name ""))
(car (gimp-image-get-name image)))))
(write "!----------BEGIN----------!" (open-output-file "/dev/stderr"))
(write-char #\Newline (open-output-file "/dev/stderr"))
(let loop ((layers (vector->list (cadr (gimp-image-get-layers image)))))
(unless (null? layers)
(gimp-edit-copy (car layers))
(let ((img (car (gimp-edit-paste-as-new)))
(new-name (string-append
"%s"
"/"
(car (gimp-drawable-get-name (car layers)))
".png")))
(file-png-save TRUE
img
(aref (cadr (gimp-image-get-layers img)) 0)
new-name
new-name
TRUE 9 FALSE TRUE FALSE FALSE TRUE)
(let ((mode (gimp-drawable-type (car layers))))
(write mode (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(let ((opacity (gimp-layer-get-opacity (car layers))))
(write opacity (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(let ((offset (gimp-drawable-offsets (car layers))))
(write offset (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(let ((width (gimp-drawable-width (car layers))))
(write width (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(let ((height (gimp-drawable-height (car layers))))
(write height (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(let ((visible (gimp-item-get-visible (car layers))))
(write visible (open-output-file "/dev/stderr")))
(write-char #\: (open-output-file "/dev/stderr"))
(write (car (gimp-drawable-get-name (car layers))) (open-output-file "/dev/stderr"))
(write-char #\Newline (open-output-file "/dev/stderr"))
(gimp-image-delete img))
(loop (cdr layers)))))
(write "!----------END----------!" (open-output-file "/dev/stderr"))
(write-char #\Newline (open-output-file "/dev/stderr")))
"""
def get_type( num ):
if num == 0:
return 'RGB', False
elif num == 1:
return 'RGB', True
elif num == 2:
return 'GRAY-IMAGE', False
elif num == 3:
return 'GRAY-IMAGE', True
elif num == 4:
return 'INDEXED-IMAGE', False
elif num == 5:
return 'INDEXED-IMAGE', True
raise Exception( 'Type index out of range 0 - 5, got %d' % num )
def get_img_size( fname ):
cmd = """gimp -idf -b '(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE "%s" "%s"))) (img-width (car (gimp-image-width image))) (img-height (car (gimp-image-height image)))) (gimp-message (string-append "IMGSIZE " (number->string img-height) "x" (number->string img-width))))' -b '(gimp-quit 0)'""" % ( fname, fname )
args = shlex.split( cmd )
gb = sp.run( args, capture_output = True )
output = gb.stderr.decode( 'utf-8' )
x, y = [ int( i ) for i in re_imgsize.findall( output )[ 0 ] ]
return x, y
def export_images( fname ):
width, height = get_img_size( fname )
path = Path( fname ).stem
err = True
appendix = 0
savepath = path
while err:
err = False
try:
if appendix:
savepath = path + '_' + str( appendix )
os.mkdir( savepath )
else:
os.mkdir( path )
except:
appendix += 1
err = True
cmd = """gimp -idf -b '%s (save-layers "%s")' -b '(gimp-quit 0)'""" % ( script_fu % savepath, fname )
args = shlex.split( cmd )
gb = sp.run( args, capture_output = True )
output = gb.stderr.decode( 'utf-8' )
layers = []
start = False
end = False
for line in output.split( '\n' ):
if line == '"!----------BEGIN----------!"':
start = True
continue
if line == '"!----------END----------!"':
end = True
if start and not end:
#print( line )
parts = line.split( ':', 7 )
layer = {}
typ, alpha = get_type( int( parts[ 0 ][ 1:-1 ] ) )
layer[ 'type' ] = typ
layer[ 'alpha' ] = alpha
layer[ 'opacity' ] = float( parts[ 1 ][ 1:-1 ] ) * 0.01
offx, offy = [ int( i ) for i in parts[ 2 ][ 1:-1 ].split() ]
layer[ 'offsetX' ] = offx
layer[ 'offsetY' ] = offy
layer[ 'width' ] = int( parts[ 3 ][ 1:-1 ] )
layer[ 'height' ] = int( parts[ 4 ][ 1:-1 ] )
layer[ 'visible' ] = bool( int( parts[ 5 ][ 1:-1 ] ) )
layer[ 'name' ] = parts[ 6 ][ 1:-1 ]
layer[ 'filename' ] = os.path.join( savepath, layer[ 'name' ] + '.png' )
layer[ 'image width' ] = width
layer[ 'image height' ] = height
layers.append( layer )
print( layers )
return layers
def main(File, Path, LayerViewers, MixerViewers, LayerOffset,
LayerScale, OpacityMode, AlphaMode, ShadelessMats,
SetCamera, SetupCompo, GroupUntagged, Ext):
#-------------------------------------------------
fullpath = os.path.join( Path, File )
layers = export_images( fullpath )
IMGs = []
for layer in layers:
if layer[ 'visible' ]:
l = layer
l[ 'LayerMode' ] = layer[ 'type' ]
l[ 'LayerOpacity' ] = layer[ 'opacity' ]
l[ 'LayerName' ] = layer[ 'name' ]
l[ 'LayerNameShort' ] = layer[ 'name' ].split( '[' )[ 0 ]
l[ 'RenderLayer' ] = layer[ 'name' ]
l[ 'LayerCoords' ] = [ layer[ 'width' ], layer[ 'height' ], layer[ 'offsetX' ], layer[ 'offsetY' ] ]
l[ 'HasAlpha' ] = layer[ 'alpha' ]
IMGs.append( l )
ResX, ResY = get_img_size( fullpath )
if BLENDER:
# -----------------------------------------------------------------------------
# Module-level Shared State
watched_objects = {} # used to trigger compositor updates on scene updates
# -----------------------------------------------------------------------------
# Misc utils.
def add_driver_prop(driver, name, type, id, path):
"""Configure a new driver variable."""
dv = driver.variables.new()
dv.name = name
dv.type = 'SINGLE_PROP'
target = dv.targets[0]
target.id_type = type
target.id = id
target.data_path = path
# -----------------------------------------------------------------------------
# Image loading
ImageSpec = namedtuple(
'ImageSpec',
['image', 'size', 'frame_start', 'frame_offset', 'frame_duration'])
num_regex = re.compile('[0-9]') # Find a single number
nums_regex = re.compile('[0-9]+') # Find a set of numbers
def find_image_sequences(files):
"""From a group of files, detect image sequences.
This returns a generator of tuples, which contain the filename,
start frame, and length of the detected sequence
>>> list(find_image_sequences([
... "test2-001.jp2", "test2-002.jp2",
... "test3-003.jp2", "test3-004.jp2", "test3-005.jp2", "test3-006.jp2",
... "blaah"]))
[('blaah', 1, 1), ('test2-001.jp2', 1, 2), ('test3-003.jp2', 3, 4)]
"""
files = iter(sorted(files))
prev_file = None
pattern = ""
matches = []
segment = None
length = 1
for filename in files:
new_pattern = num_regex.sub('#', filename)
new_matches = list(map(int, nums_regex.findall(filename)))
if new_pattern == pattern:
# this file looks like it may be in sequence from the previous
# if there are multiple sets of numbers, figure out what changed
if segment is None:
for i, prev, cur in zip(count(), matches, new_matches):
if prev != cur:
segment = i
break
# did it only change by one?
for i, prev, cur in zip(count(), matches, new_matches):
if i == segment:
# We expect this to increment
prev = prev + length
if prev != cur:
break
# All good!
else:
length += 1
continue
# No continuation -> spit out what we found and reset counters
if prev_file:
if length > 1:
yield prev_file, matches[segment], length
else:
yield prev_file, 1, 1
prev_file = filename
matches = new_matches
pattern = new_pattern
segment = None
length = 1
if prev_file:
if length > 1:
yield prev_file, matches[segment], length
else:
yield prev_file, 1, 1
def load_images(filenames, directory, force_reload=False, frame_start=1, find_sequences=False):
"""Wrapper for bpy's load_image
Loads a set of images, movies, or even image sequences
Returns a generator of ImageSpec wrapper objects later used for texture setup
"""
if find_sequences: # if finding sequences, we need some pre-processing first
file_iter = find_image_sequences(filenames)
else:
file_iter = zip(filenames, repeat(1), repeat(1))
for filename, offset, frames in file_iter:
image = load_image(filename, directory, check_existing=True, force_reload=force_reload)
# Size is unavailable for sequences, so we grab it early
size = tuple(image.size)
if image.source == 'MOVIE':
# Blender BPY BUG!
# This number is only valid when read a second time in 2.77
# This repeated line is not a mistake
frames = image.frame_duration
frames = image.frame_duration
elif frames > 1: # Not movie, but multiple frames -> image sequence
image.source = 'SEQUENCE'
yield ImageSpec(image, size, frame_start, offset - 1, frames)
# -----------------------------------------------------------------------------
# Position & Size Helpers
def offset_planes(planes, gap, axis):
"""Offset planes from each other by `gap` amount along a _local_ vector `axis`
For example, offset_planes([obj1, obj2], 0.5, Vector(0, 0, 1)) will place
obj2 0.5 blender units away from obj1 along the local positive Z axis.
This is in local space, not world space, so all planes should share
a common scale and rotation.
"""
prior = planes[0]
offset = Vector()
for current in planes[1:]:
local_offset = abs((prior.dimensions + current.dimensions).dot(axis)) / 2.0 + gap
offset += local_offset * axis
current.location = current.matrix_world @ offset
prior = current
def compute_camera_size(context, center, fill_mode, aspect):
"""Determine how large an object needs to be to fit or fill the camera's field of view."""
scene = context.scene
camera = scene.camera
view_frame = camera.data.view_frame(scene=scene)
frame_size = \
Vector([max(v[i] for v in view_frame) for i in range(3)]) - \
Vector([min(v[i] for v in view_frame) for i in range(3)])
camera_aspect = frame_size.x / frame_size.y
# Convert the frame size to the correct sizing at a given distance
if camera.type == 'ORTHO':
frame_size = frame_size.xy
else:
# Perspective transform
distance = world_to_camera_view(scene, camera, center).z
frame_size = distance * frame_size.xy / (-view_frame[0].z)
# Determine what axis to match to the camera
match_axis = 0 # match the Y axis size
match_aspect = aspect
if (fill_mode == 'FILL' and aspect > camera_aspect) or \
(fill_mode == 'FIT' and aspect < camera_aspect):
match_axis = 1 # match the X axis size
match_aspect = 1.0 / aspect
# scale the other axis to the correct aspect
frame_size[1 - match_axis] = frame_size[match_axis] / match_aspect
return frame_size
def center_in_camera(scene, camera, obj, axis=(1, 1)):
"""Center object along specified axis of the camera"""
camera_matrix_col = camera.matrix_world.col
location = obj.location
# Vector from the camera's world coordinate center to the object's center
delta = camera_matrix_col[3].xyz - location
# How far off center we are along the camera's local X
camera_x_mag = delta.dot(camera_matrix_col[0].xyz) * axis[0]
# How far off center we are along the camera's local Y
camera_y_mag = delta.dot(camera_matrix_col[1].xyz) * axis[1]
# Now offset only along camera local axis
offset = camera_matrix_col[0].xyz * camera_x_mag + \
camera_matrix_col[1].xyz * camera_y_mag
obj.location = location + offset
# -----------------------------------------------------------------------------
# Cycles/Eevee utils
def get_input_nodes(node, links):
"""Get nodes that are a inputs to the given node"""
# Get all links going to node.
input_links = {lnk for lnk in links if lnk.to_node == node}
# Sort those links, get their input nodes (and avoid doubles!).
sorted_nodes = []
done_nodes = set()
for socket in node.inputs:
done_links = set()
for link in input_links:
nd = link.from_node
if nd in done_nodes:
# Node already treated!
done_links.add(link)
elif link.to_socket == socket:
sorted_nodes.append(nd)
done_links.add(link)
done_nodes.add(nd)
input_links -= done_links
return sorted_nodes
def auto_align_nodes(node_tree):
"""Given a shader node tree, arrange nodes neatly relative to the output node."""
x_gap = 200
y_gap = 180
nodes = node_tree.nodes
links = node_tree.links
output_node = None
for node in nodes:
if node.type == 'OUTPUT_MATERIAL' or node.type == 'GROUP_OUTPUT':
output_node = node
break
else: # Just in case there is no output
return
def align(to_node):
from_nodes = get_input_nodes(to_node, links)
for i, node in enumerate(from_nodes):
node.location.x = min(node.location.x, to_node.location.x - x_gap)
node.location.y = to_node.location.y
node.location.y -= i * y_gap
node.location.y += (len(from_nodes) - 1) * y_gap / (len(from_nodes))
align(node)
align(output_node)
def clean_node_tree(node_tree):
"""Clear all nodes in a shader node tree except the output.
Returns the output node
"""
nodes = node_tree.nodes
for node in list(nodes): # copy to avoid altering the loop's data source
if not node.type == 'OUTPUT_MATERIAL':
nodes.remove(node)
return node_tree.nodes[0]
def get_shadeless_node(dest_node_tree):
"""Return a "shadless" cycles/eevee node, creating a node group if nonexistent"""
try:
node_tree = bpy.data.node_groups['IAP_SHADELESS']
except KeyError:
# need to build node shadeless node group
node_tree = bpy.data.node_groups.new('IAP_SHADELESS', 'ShaderNodeTree')
output_node = node_tree.nodes.new('NodeGroupOutput')
input_node = node_tree.nodes.new('NodeGroupInput')
node_tree.outputs.new('NodeSocketShader', 'Shader')
node_tree.inputs.new('NodeSocketColor', 'Color')
# This could be faster as a transparent shader, but then no ambient occlusion
diffuse_shader = node_tree.nodes.new('ShaderNodeBsdfDiffuse')
node_tree.links.new(diffuse_shader.inputs[0], input_node.outputs[0])
emission_shader = node_tree.nodes.new('ShaderNodeEmission')
node_tree.links.new(emission_shader.inputs[0], input_node.outputs[0])
light_path = node_tree.nodes.new('ShaderNodeLightPath')
is_glossy_ray = light_path.outputs['Is Glossy Ray']
is_shadow_ray = light_path.outputs['Is Shadow Ray']
ray_depth = light_path.outputs['Ray Depth']
transmission_depth = light_path.outputs['Transmission Depth']
unrefracted_depth = node_tree.nodes.new('ShaderNodeMath')
unrefracted_depth.operation = 'SUBTRACT'
unrefracted_depth.label = 'Bounce Count'
node_tree.links.new(unrefracted_depth.inputs[0], ray_depth)
node_tree.links.new(unrefracted_depth.inputs[1], transmission_depth)
refracted = node_tree.nodes.new('ShaderNodeMath')
refracted.operation = 'SUBTRACT'
refracted.label = 'Camera or Refracted'
refracted.inputs[0].default_value = 1.0
node_tree.links.new(refracted.inputs[1], unrefracted_depth.outputs[0])
reflection_limit = node_tree.nodes.new('ShaderNodeMath')
reflection_limit.operation = 'SUBTRACT'
reflection_limit.label = 'Limit Reflections'
reflection_limit.inputs[0].default_value = 2.0
node_tree.links.new(reflection_limit.inputs[1], ray_depth)
camera_reflected = node_tree.nodes.new('ShaderNodeMath')
camera_reflected.operation = 'MULTIPLY'
camera_reflected.label = 'Camera Ray to Glossy'
node_tree.links.new(camera_reflected.inputs[0], reflection_limit.outputs[0])
node_tree.links.new(camera_reflected.inputs[1], is_glossy_ray)
shadow_or_reflect = node_tree.nodes.new('ShaderNodeMath')
shadow_or_reflect.operation = 'MAXIMUM'
shadow_or_reflect.label = 'Shadow or Reflection?'
node_tree.links.new(shadow_or_reflect.inputs[0], camera_reflected.outputs[0])
node_tree.links.new(shadow_or_reflect.inputs[1], is_shadow_ray)
shadow_or_reflect_or_refract = node_tree.nodes.new('ShaderNodeMath')
shadow_or_reflect_or_refract.operation = 'MAXIMUM'
shadow_or_reflect_or_refract.label = 'Shadow, Reflect or Refract?'
node_tree.links.new(shadow_or_reflect_or_refract.inputs[0], shadow_or_reflect.outputs[0])
node_tree.links.new(shadow_or_reflect_or_refract.inputs[1], refracted.outputs[0])
mix_shader = node_tree.nodes.new('ShaderNodeMixShader')
node_tree.links.new(mix_shader.inputs[0], shadow_or_reflect_or_refract.outputs[0])
node_tree.links.new(mix_shader.inputs[1], diffuse_shader.outputs[0])
node_tree.links.new(mix_shader.inputs[2], emission_shader.outputs[0])
node_tree.links.new(output_node.inputs[0], mix_shader.outputs[0])
auto_align_nodes(node_tree)
group_node = dest_node_tree.nodes.new("ShaderNodeGroup")
group_node.node_tree = node_tree
return group_node
# -----------------------------------------------------------------------------
# Corner Pin Driver Helpers
@bpy.app.handlers.persistent
def check_drivers(*args, **kwargs):
"""Check if watched objects in a scene have changed and trigger compositor update
This is part of a hack to ensure the compositor updates
itself when the objects used for drivers change.
It only triggers if transformation matricies change to avoid
a cyclic loop of updates.
"""
if not watched_objects:
# if there is nothing to watch, don't bother running this
bpy.app.handlers.depsgraph_update_post.remove(check_drivers)
return
update = False
for name, matrix in list(watched_objects.items()):
try:
obj = bpy.data.objects[name]
except KeyError:
# The user must have removed this object
del watched_objects[name]
else:
new_matrix = tuple(map(tuple, obj.matrix_world)).__hash__()
if new_matrix != matrix:
watched_objects[name] = new_matrix
update = True
if update:
# Trick to re-evaluate drivers
bpy.context.scene.frame_current = bpy.context.scene.frame_current
def register_watched_object(obj):
"""Register an object to be monitored for transformation changes"""
name = obj.name
# known object? -> we're done
if name in watched_objects:
return
if not watched_objects:
# make sure check_drivers is active
bpy.app.handlers.depsgraph_update_post.append(check_drivers)
watched_objects[name] = None
def find_plane_corner(object_name, x, y, axis, camera=None, *args, **kwargs):
"""Find the location in camera space of a plane's corner"""
if args or kwargs:
# I've added args / kwargs as a compatibility measure with future versions
warnings.warn("Unknown Parameters Passed to \"Images as Planes\". Maybe you need to upgrade?")
plane = bpy.data.objects[object_name]
# Passing in camera doesn't work before 2.78, so we use the current one
camera = camera or bpy.context.scene.camera
# Hack to ensure compositor updates on future changes
register_watched_object(camera)
register_watched_object(plane)
scale = plane.scale * 2.0
v = plane.dimensions.copy()
v.x *= x / scale.x
v.y *= y / scale.y
v = plane.matrix_world @ v
camera_vertex = world_to_camera_view(
bpy.context.scene, camera, v)
return camera_vertex[axis]
@bpy.app.handlers.persistent
def register_driver(*args, **kwargs):
"""Register the find_plane_corner function for use with drivers"""
bpy.app.driver_namespace['import_image__find_plane_corner'] = find_plane_corner
# -----------------------------------------------------------------------------
# Compositing Helpers
def group_in_frame(node_tree, name, nodes):
frame_node = node_tree.nodes.new("NodeFrame")
frame_node.label = name
frame_node.name = name + "_frame"
min_pos = Vector(nodes[0].location)
max_pos = min_pos.copy()
for node in nodes:
top_left = node.location
bottom_right = top_left + Vector((node.width, -node.height))
for i in (0, 1):
min_pos[i] = min(min_pos[i], top_left[i], bottom_right[i])
max_pos[i] = max(max_pos[i], top_left[i], bottom_right[i])
node.parent = frame_node
frame_node.width = max_pos[0] - min_pos[0] + 50
frame_node.height = max(max_pos[1] - min_pos[1] + 50, 450)
frame_node.shrink = True
return frame_node
def position_frame_bottom_left(node_tree, frame_node):
newpos = Vector((100000, 100000)) # start reasonably far top / right
# Align with the furthest left
for node in node_tree.nodes.values():
if node != frame_node and node.parent != frame_node:
newpos.x = min(newpos.x, node.location.x + 30)
# As high as we can get without overlapping anything to the right
for node in node_tree.nodes.values():
if node != frame_node and not node.parent:
if node.location.x < newpos.x + frame_node.width:
print("Below", node.name, node.location, node.height, node.dimensions)
newpos.y = min(newpos.y, node.location.y - max(node.dimensions.y, node.height) - 20)
frame_node.location = newpos
def setup_compositing(context, plane, img_spec):
# Node Groups only work with "new" dependency graph and even
# then it has some problems with not updating the first time
# So instead this groups with a node frame, which works reliably
scene = context.scene
scene.use_nodes = True
node_tree = scene.node_tree
name = plane.name
image_node = node_tree.nodes.new("CompositorNodeImage")
image_node.name = name + "_image"
image_node.image = img_spec.image
image_node.location = Vector((0, 0))
image_node.frame_start = img_spec.frame_start
image_node.frame_offset = img_spec.frame_offset
image_node.frame_duration = img_spec.frame_duration
scale_node = node_tree.nodes.new("CompositorNodeScale")
scale_node.name = name + "_scale"
scale_node.space = 'RENDER_SIZE'
scale_node.location = image_node.location + \
Vector((image_node.width + 20, 0))
scale_node.show_options = False
cornerpin_node = node_tree.nodes.new("CompositorNodeCornerPin")
cornerpin_node.name = name + "_cornerpin"
cornerpin_node.location = scale_node.location + \
Vector((0, -scale_node.height))
node_tree.links.new(scale_node.inputs[0], image_node.outputs[0])
node_tree.links.new(cornerpin_node.inputs[0], scale_node.outputs[0])
# Put all the nodes in a frame for organization
frame_node = group_in_frame(
node_tree, name,
(image_node, scale_node, cornerpin_node)
)
# Position frame at bottom / left
position_frame_bottom_left(node_tree, frame_node)
# Configure Drivers
for corner in cornerpin_node.inputs[1:]:
id = corner.identifier
x = -1 if 'Left' in id else 1
y = -1 if 'Lower' in id else 1
drivers = corner.driver_add('default_value')
for i, axis_fcurve in enumerate(drivers):
driver = axis_fcurve.driver
# Always use the current camera
add_driver_prop(driver, 'camera', 'SCENE', scene, 'camera')
# Track camera location to ensure Deps Graph triggers (not used in the call)
add_driver_prop(driver, 'cam_loc_x', 'OBJECT', scene.camera, 'location[0]')
# Don't break if the name changes
add_driver_prop(driver, 'name', 'OBJECT', plane, 'name')
driver.expression = "import_image__find_plane_corner(name or %s, %d, %d, %d, camera=camera)" % (
repr(plane.name),
x, y, i
)
driver.type = 'SCRIPTED'
driver.is_valid = True
axis_fcurve.is_valid = True
driver.expression = "%s" % driver.expression
context.view_layer.update()
# -----------------------------------------------------------------------------
# Operator
class IMPORT_GIMP_OT_to_plane( Operator, AddObjectHelper ):
bl_idname = "import_gimp.to_plane"
bl_label = "Import GIMP image layers as planes"
bl_options = {'REGISTER', 'PRESET', 'UNDO'}
# ----------------------
# File dialog properties
files: CollectionProperty(type=bpy.types.OperatorFileListElement, options={'HIDDEN', 'SKIP_SAVE'})
directory: StringProperty(maxlen=1024, subtype='FILE_PATH', options={'HIDDEN', 'SKIP_SAVE'})
filter_glob: StringProperty(
default='*.xcf;*.xcfgz;*.xcf.gz;*.xcfbz2;*.xcf.bz2',
options={'HIDDEN'}
)
# ----------------------
# Properties - Importing
import_hidden: BoolProperty(
name="Import Hidden Layers", default=False,
description="Import Layers Which Have Been Hidden In GIMP Image"
)
force_reload: BoolProperty(
name="Force Reload", default=False,
description="Force reloading of the image if already opened elsewhere in Blender"
)
image_sequence: BoolProperty(
name="Animate Image Sequences", default=False,
description="Import sequentially numbered images as an animated "
"image sequence instead of separate planes"
)
# -------------------------------------
# Properties - Position and Orientation
keep_offsets: BoolProperty( name="Keep Offsets", default=True, description="Keep Offsets Of Layers From The Original GIMP Image" )
axis_id_to_vector = {
'X+': Vector(( 1, 0, 0)),
'Y+': Vector(( 0, 1, 0)),
'Z+': Vector(( 0, 0, 1)),
'X-': Vector((-1, 0, 0)),
'Y-': Vector(( 0, -1, 0)),
'Z-': Vector(( 0, 0, -1)),
}
offset: BoolProperty(name="Offset Planes", default=True, description="Offset Planes From Each Other")
OFFSET_MODES = (
('X+', "X+", "Side by Side to the Left"),
('Y+', "Y+", "Side by Side, Downward"),
('Z+', "Z+", "Stacked Above"),
('X-', "X-", "Side by Side to the Right"),
('Y-', "Y-", "Side by Side, Upward"),
('Z-', "Z-", "Stacked Below"),
)
offset_axis: EnumProperty(
name="Orientation", default='Z-', items=OFFSET_MODES,
description="How planes are oriented relative to each others' local axis"
)
offset_amount: FloatProperty(
name="Offset", soft_min=0, default=0.1, description="Space between planes",
subtype='DISTANCE', unit='LENGTH'
)
AXIS_MODES = (
('X+', "X+", "Facing Positive X"),
('Y+', "Y+", "Facing Positive Y"),
('Z+', "Z+ (Up)", "Facing Positive Z"),
('X-', "X-", "Facing Negative X"),
('Y-', "Y-", "Facing Negative Y"),
('Z-', "Z- (Down)", "Facing Negative Z"),
('CAM', "Face Camera", "Facing Camera"),
('CAM_AX', "Main Axis", "Facing the Camera's dominant axis"),
)
align_axis: EnumProperty(
name="Align", default='CAM_AX', items=AXIS_MODES,
description="How to align the planes"
)
# prev_align_axis is used only by update_size_model
prev_align_axis: EnumProperty(
items=AXIS_MODES + (('NONE', '', ''),), default='NONE', options={'HIDDEN', 'SKIP_SAVE'})
align_track: BoolProperty(
name="Track Camera", default=False, description="Always face the camera"
)
# -----------------
# Properties - Size
def update_size_mode(self, context):
"""If sizing relative to the camera, always face the camera"""
if self.size_mode == 'CAMERA':
self.prev_align_axis = self.align_axis
self.align_axis = 'CAM'
else:
# if a different alignment was set revert to that when
# size mode is changed
if self.prev_align_axis != 'NONE':
self.align_axis = self.prev_align_axis
self._prev_align_axis = 'NONE'
SIZE_MODES = (
('ABSOLUTE', "Absolute", "Use absolute size"),
('CAMERA', "Camera Relative", "Scale to the camera frame"),
('DPI', "Dpi", "Use definition of the image as dots per inch"),
('DPBU', "Dots/BU", "Use definition of the image as dots per Blender Unit"),
)
size_mode: EnumProperty(
name="Size Mode", default='ABSOLUTE', items=SIZE_MODES,
update=update_size_mode,
description="How the size of the plane is computed")
FILL_MODES = (
('FILL', "Fill", "Fill camera frame, spilling outside the frame"),
('FIT', "Fit", "Fit entire image within the camera frame"),
)
fill_mode: EnumProperty(name="Scale", default='FILL', items=FILL_MODES,
description="How large in the camera frame is the plane")
height: FloatProperty(name="Height", description="Height of the created plane",
default=1.0, min=0.001, soft_min=0.001, subtype='DISTANCE', unit='LENGTH')
factor: FloatProperty(name="Definition", min=1.0, default=600.0,
description="Number of pixels per inch or Blender Unit")
# ------------------------------
# Properties - Material / Shader
SHADERS = (
('PRINCIPLED',"Principled","Principled Shader"),
('SHADELESS', "Shadeless", "Only visible to camera and reflections"),
('EMISSION', "Emit", "Emission Shader"),
)
shader: EnumProperty(name="Shader", items=SHADERS, default='SHADELESS', description="Node shader to use")
emit_strength: FloatProperty(
name="Strength", min=0.0, default=1.0, soft_max=10.0,
step=100, description="Brightness of Emission Texture")
overwrite_material: BoolProperty(
name="Overwrite Material", default=True,
description="Overwrite existing Material (based on material name)")
compositing_nodes: BoolProperty(
name="Setup Corner Pin", default=False,
description="Build Compositor Nodes to reference this image "
"without re-rendering")
# ------------------
# Properties - Image
use_transparency: BoolProperty(
name="Use Alpha", default=True,
description="Use alpha channel for transparency")
t = bpy.types.Image.bl_rna.properties["alpha_mode"]
alpha_mode_items = tuple((e.identifier, e.name, e.description) for e in t.enum_items)
alpha_mode: EnumProperty(
name=t.name, items=alpha_mode_items, default=t.default,
description=t.description)
t = bpy.types.ImageUser.bl_rna.properties["use_auto_refresh"]
use_auto_refresh: BoolProperty(name=t.name, default=True, description=t.description)
relative: BoolProperty(name="Relative Paths", default=True, description="Use relative file paths")
# -------
# Draw UI
def draw_import_config(self, context):
# --- Import Options --- #
layout = self.layout
box = layout.box()
box.label(text="Import Options:", icon='IMPORT')
row = box.row()
row.active = bpy.data.is_saved
row.prop(self, "relative")
box.prop(self, "import_hidden")
#box.prop(self, "force_reload")
box.prop(self, "image_sequence")
def draw_material_config(self, context):
# --- Material / Rendering Properties --- #
layout = self.layout
box = layout.box()
box.label(text="Compositing Nodes:", icon='RENDERLAYERS')
box.prop(self, "compositing_nodes")