mirror of
https://github.com/blender/blender-addons.git
synced 2025-08-20 13:22:58 +00:00
694 lines
26 KiB
Python
694 lines
26 KiB
Python
# ##### 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 #####
|
|
|
|
bl_info = {
|
|
"name": "Import GIMP Image to Scene (.xcf/.xjt)",
|
|
"author": "Daniel Salazar (ZanQdo)",
|
|
"version": (2, 0, 1),
|
|
"blender": (2, 73, 0),
|
|
"location": "File > Import > GIMP Image to Scene(.xcf/.xjt)",
|
|
"description": "Imports GIMP multilayer image files as a series of multiple planes",
|
|
"warning": "XCF import requires xcftools installed",
|
|
"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
|
|
"Scripts/Import-Export/GIMPImageToScene",
|
|
"category": "Import-Export",
|
|
}
|
|
|
|
"""
|
|
This script imports GIMP layered image files into 3D Scenes (.xcf, .xjt)
|
|
"""
|
|
|
|
def main(report, File, Path, LayerViewers, MixerViewers, LayerOffset,
|
|
LayerScale, OpacityMode, AlphaMode, ShadelessMats,
|
|
SetCamera, SetupCompo, GroupUntagged, Ext):
|
|
|
|
#-------------------------------------------------
|
|
|
|
#Folder = '['+File.rstrip(Ext)+']'+'_images/'
|
|
Folder = 'images_'+'['+File.rstrip(Ext)+']/'
|
|
|
|
if not bpy.data.is_saved:
|
|
PathSaveRaw = Path+Folder
|
|
PathSave = PathSaveRaw.replace(' ', '\ ')
|
|
try: os.mkdir(PathSaveRaw)
|
|
except: pass
|
|
else:
|
|
PathSave = bpy.data.filepath
|
|
RSlash = PathSave.rfind('/')
|
|
PathSaveRaw = PathSave[:RSlash+1]+Folder
|
|
PathSave = PathSaveRaw.replace(' ', '\ ')
|
|
try: os.mkdir(PathSaveRaw)
|
|
except: pass
|
|
PathSaveRaw = bpy.path.relpath(PathSaveRaw)+'/'
|
|
|
|
PathRaw = Path
|
|
Path = Path.replace(' ', '\ ')
|
|
if Ext == '.xjt':
|
|
ExtSave = '.jpg'
|
|
#-------------------------------------------------
|
|
# EXTRACT XJT
|
|
import tarfile
|
|
|
|
IMG = tarfile.open ('%s%s' % (PathRaw, File))
|
|
PRP = IMG.extractfile('PRP')
|
|
|
|
Members = IMG.getmembers()
|
|
|
|
for Member in Members:
|
|
Name = Member.name
|
|
if Name.startswith('l') and Name.endswith('.jpg'):
|
|
IMG.extract(Name, path=PathSaveRaw)
|
|
|
|
#-------------------------------------------------
|
|
# INFO XJT
|
|
IMGs = []
|
|
for Line in PRP.readlines():
|
|
Line = str(Line)
|
|
|
|
if Line.startswith("b'GIMP_XJ_IMAGE"):
|
|
for Segment in Line.split():
|
|
if Segment.startswith('w/h:'):
|
|
ResX, ResY = map (int, Segment[4:].split(','))
|
|
if Line.startswith(("b'L", "b'l")):
|
|
|
|
"""The "nice" method to check if layer has alpha channel
|
|
sadly GIMP sometimes decides not to export an alpha channel
|
|
if it's pure white so we are not completly sure here yet"""
|
|
if Line.startswith("b'L"): HasAlpha = True
|
|
else: HasAlpha = False
|
|
|
|
md = None
|
|
op = 1
|
|
ox, oy = 0,0
|
|
|
|
for Segment in Line.split():
|
|
|
|
if Segment.startswith("b'"):
|
|
imageFile = 'l' + Segment[3:] + '.jpg'
|
|
imageFileAlpha ='la'+Segment[3:]+'.jpg'
|
|
|
|
"""Phisically double checking if alpha image exists
|
|
now we can be sure! (damn GIMP)"""
|
|
if HasAlpha:
|
|
if not os.path.isfile(PathSaveRaw+imageFileAlpha): HasAlpha = False
|
|
|
|
# Get Widht and Height from images
|
|
data = open(PathSaveRaw+imageFile, "rb").read()
|
|
|
|
hexList = []
|
|
for ch in data:
|
|
byt = "%02X" % ch
|
|
hexList.append(byt)
|
|
|
|
for k in range(len(hexList)-1):
|
|
if hexList[k] == 'FF' and (hexList[k+1] == 'C0' or hexList[k+1] == 'C2'):
|
|
ow = int(hexList[k+7],16)*256 + int(hexList[k+8],16)
|
|
oh = int(hexList[k+5],16)*256 + int(hexList[k+6],16)
|
|
|
|
elif Segment.startswith('md:'): # mode
|
|
md = Segment[3:]
|
|
|
|
elif Segment.startswith('op:'): # opacity
|
|
op = float(Segment[3:])*.01
|
|
|
|
elif Segment.startswith('o:'): # origin
|
|
ox, oy = map(int, Segment[2:].split(','))
|
|
|
|
elif Segment.startswith('n:'): # name
|
|
n = Segment[3:-4]
|
|
OpenBracket = n.find ('[')
|
|
CloseBracket = n.find (']')
|
|
|
|
if OpenBracket != -1 and CloseBracket != -1:
|
|
RenderLayer = n[OpenBracket+1:CloseBracket]
|
|
NameShort = n[:OpenBracket]
|
|
|
|
else:
|
|
RenderLayer = n
|
|
NameShort = n
|
|
|
|
os.rename(PathSaveRaw+imageFile, PathSaveRaw+NameShort+'.jpg')
|
|
if HasAlpha: os.rename(PathSaveRaw+imageFileAlpha, PathSaveRaw+NameShort+'_A'+'.jpg')
|
|
|
|
IMGs.append({'LayerMode':md, 'LayerOpacity':op,
|
|
'LayerName':n, 'LayerNameShort':NameShort,
|
|
'RenderLayer':RenderLayer, 'LayerCoords':[ow, oh, ox, oy], 'HasAlpha':HasAlpha})
|
|
|
|
else: # Ext == '.xcf':
|
|
ExtSave = '.png'
|
|
#-------------------------------------------------
|
|
# CONFIG
|
|
XCFInfo = 'xcfinfo'
|
|
XCF2PNG = 'xcf2png'
|
|
#-------------------------------------------------
|
|
# INFO XCF
|
|
|
|
try:
|
|
Info = subprocess.check_output((XCFInfo, Path+File))
|
|
except FileNotFoundError as e:
|
|
if XCFInfo in str(e):
|
|
report({'ERROR'}, "Please install xcftools, xcfinfo seems to be missing (%s)" % str(e))
|
|
return False
|
|
else:
|
|
raise e
|
|
|
|
Info = Info.decode()
|
|
IMGs = []
|
|
for Line in Info.split('\n'):
|
|
if Line.startswith ('+'):
|
|
|
|
Line = Line.split(' ', 4)
|
|
|
|
RenderLayer = Line[4]
|
|
|
|
OpenBracket = RenderLayer.find ('[')
|
|
CloseBracket = RenderLayer.find (']')
|
|
|
|
if OpenBracket != -1 and CloseBracket != -1:
|
|
RenderLayer = RenderLayer[OpenBracket+1:CloseBracket]
|
|
NameShort = Line[4][:OpenBracket]
|
|
else:
|
|
NameShort = Line[4].rstrip()
|
|
if GroupUntagged:
|
|
RenderLayer = '__Undefined__'
|
|
else:
|
|
RenderLayer = NameShort
|
|
|
|
LineThree = Line[3]
|
|
Slash = LineThree.find('/')
|
|
if Slash == -1:
|
|
Mode = LineThree
|
|
Opacity = 1
|
|
else:
|
|
Mode = LineThree[:Slash]
|
|
Opacity = float(LineThree[Slash+1:LineThree.find('%')])*.01
|
|
|
|
IMGs.append ({
|
|
'LayerMode': Mode,
|
|
'LayerOpacity': Opacity,
|
|
'LayerName': Line[4].rstrip(),
|
|
'LayerNameShort': NameShort,
|
|
'LayerCoords': list(map(int, Line[1].replace('x', ' ').replace('+', ' +').replace('-', ' -').split())),
|
|
'RenderLayer': RenderLayer,
|
|
'HasAlpha': True,
|
|
})
|
|
elif Line.startswith('Version'):
|
|
ResX, ResY = map (int, Line.split()[2].split('x'))
|
|
|
|
#-------------------------------------------------
|
|
# EXTRACT XCF
|
|
if OpacityMode == 'BAKE':
|
|
Opacity = ()
|
|
else:
|
|
Opacity = ("--percent", "100")
|
|
xcf_path = Path + File
|
|
for Layer in IMGs:
|
|
png_path = "%s%s.png" % (PathSave, Layer['LayerName'].replace(' ', '_'))
|
|
subprocess.call((XCF2PNG, "-C", xcf_path, "-o", png_path, Layer['LayerName']) + Opacity)
|
|
|
|
#-------------------------------------------------
|
|
Scene = bpy.context.scene
|
|
#-------------------------------------------------
|
|
# CAMERA
|
|
|
|
if SetCamera:
|
|
bpy.ops.object.camera_add(location=(0, 0, 10))
|
|
|
|
Camera = bpy.context.active_object.data
|
|
|
|
Camera.type = 'ORTHO'
|
|
Camera.ortho_scale = ResX * .01
|
|
|
|
#-------------------------------------------------
|
|
# RENDER SETTINGS
|
|
|
|
Render = Scene.render
|
|
|
|
if SetCamera:
|
|
Render.resolution_x = ResX
|
|
Render.resolution_y = ResY
|
|
Render.resolution_percentage = 100
|
|
Render.alpha_mode = 'TRANSPARENT'
|
|
|
|
#-------------------------------------------------
|
|
# 3D VIEW SETTINGS
|
|
|
|
Scene.game_settings.material_mode = 'GLSL'
|
|
|
|
Areas = bpy.context.screen.areas
|
|
|
|
for Area in Areas:
|
|
if Area.type == 'VIEW_3D':
|
|
Area.spaces.active.viewport_shade = 'TEXTURED'
|
|
Area.spaces.active.show_textured_solid = True
|
|
Area.spaces.active.show_floor = False
|
|
|
|
#-------------------------------------------------
|
|
# 3D LAYERS
|
|
|
|
def Make3DLayer (Name, NameShort, Z, Coords, RenderLayer, LayerMode, LayerOpacity, HasAlpha):
|
|
|
|
# RenderLayer
|
|
|
|
if SetupCompo:
|
|
if not bpy.context.scene.render.layers.get(RenderLayer):
|
|
|
|
bpy.ops.scene.render_layer_add()
|
|
|
|
LayerActive = bpy.context.scene.render.layers.active
|
|
LayerActive.name = RenderLayer
|
|
LayerActive.use_pass_vector = True
|
|
LayerActive.use_sky = False
|
|
LayerActive.use_edge_enhance = False
|
|
LayerActive.use_strand = False
|
|
LayerActive.use_halo = False
|
|
|
|
global LayerNum
|
|
for i in range (0,20):
|
|
if not i == LayerNum:
|
|
LayerActive.layers[i] = False
|
|
|
|
bpy.context.scene.layers[LayerNum] = True
|
|
|
|
LayerFlags[RenderLayer] = bpy.context.scene.render.layers.active.layers
|
|
|
|
LayerList.append([RenderLayer, LayerMode, LayerOpacity])
|
|
|
|
LayerNum += 1
|
|
|
|
# Object
|
|
bpy.ops.mesh.primitive_plane_add(view_align=False,
|
|
enter_editmode=False,
|
|
rotation=(0, 0, 0))
|
|
|
|
bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)
|
|
|
|
|
|
Active = bpy.context.active_object
|
|
|
|
if SetupCompo:
|
|
Active.layers = LayerFlags[RenderLayer]
|
|
|
|
Active.location = (
|
|
(float(Coords[2])-(ResX*0.5))*LayerScale,
|
|
(-float(Coords[3])+(ResY*0.5))*LayerScale, Z)
|
|
|
|
for Vert in Active.data.vertices:
|
|
Vert.co[0] += 1
|
|
Vert.co[1] += -1
|
|
|
|
Active.dimensions = float(Coords[0])*LayerScale, float(Coords[1])*LayerScale, 0
|
|
|
|
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
|
|
|
|
bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
|
|
|
|
Active.show_wire = True
|
|
|
|
Active.name = NameShort
|
|
bpy.ops.mesh.uv_texture_add()
|
|
|
|
# Material
|
|
|
|
'''if bpy.data.materials.get(NameShort):
|
|
Mat = bpy.data.materials[NameShort]
|
|
if not Active.material_slots:
|
|
bpy.ops.object.material_slot_add()
|
|
Active.material_slots[0].material = Mat
|
|
else:'''
|
|
|
|
Mat = bpy.data.materials.new(NameShort)
|
|
Mat.diffuse_color = (1,1,1)
|
|
Mat.use_raytrace = False
|
|
Mat.use_shadows = False
|
|
Mat.use_cast_buffer_shadows = False
|
|
Mat.use_cast_approximate = False
|
|
if HasAlpha:
|
|
Mat.use_transparency = True
|
|
if OpacityMode == 'MAT': Mat.alpha = LayerOpacity
|
|
else: Mat.alpha = 0
|
|
if ShadelessMats: Mat.use_shadeless = True
|
|
|
|
if Ext == '.xcf':
|
|
# Color & Alpha PNG
|
|
Tex = bpy.data.textures.new(NameShort, 'IMAGE')
|
|
Tex.extension = 'CLIP'
|
|
Tex.use_preview_alpha = True
|
|
|
|
Img = bpy.data.images.new(NameShort, 128, 128)
|
|
Img.source = 'FILE'
|
|
Img.alpha_mode = AlphaMode
|
|
Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
|
|
|
|
UVFace = Active.data.uv_textures[0].data[0]
|
|
UVFace.image = Img
|
|
|
|
Tex.image = Img
|
|
|
|
Mat.texture_slots.add()
|
|
TexSlot = Mat.texture_slots[0]
|
|
TexSlot.texture = Tex
|
|
TexSlot.use_map_alpha = True
|
|
TexSlot.texture_coords = 'UV'
|
|
if OpacityMode == 'TEX': TexSlot.alpha_factor = LayerOpacity
|
|
elif OpacityMode == 'MAT': TexSlot.blend_type = 'MULTIPLY'
|
|
|
|
else: # Ext == '.xjt'
|
|
# Color JPG
|
|
Tex = bpy.data.textures.new(NameShort, 'IMAGE')
|
|
Tex.extension = 'CLIP'
|
|
|
|
Img = bpy.data.images.new(NameShort, 128, 128)
|
|
Img.source = 'FILE'
|
|
Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
|
|
|
|
UVFace = Active.data.uv_textures[0].data[0]
|
|
UVFace.image = Img
|
|
|
|
Tex.image = Img
|
|
|
|
Mat.texture_slots.add()
|
|
TexSlot = Mat.texture_slots[0]
|
|
TexSlot.texture = Tex
|
|
TexSlot.texture_coords = 'UV'
|
|
|
|
if HasAlpha:
|
|
# Alpha JPG
|
|
Tex = bpy.data.textures.new(NameShort+'_A', 'IMAGE')
|
|
Tex.extension = 'CLIP'
|
|
Tex.use_preview_alpha = True
|
|
|
|
Img = bpy.data.images.new(NameShort+'_A', 128, 128)
|
|
Img.source = 'FILE'
|
|
Img.alpha_mode = AlphaMode
|
|
Img.filepath = '%s%s_A%s' % (PathSaveRaw, Name, ExtSave)
|
|
Img.use_alpha = False
|
|
|
|
Tex.image = Img
|
|
|
|
Mat.texture_slots.add()
|
|
TexSlot = Mat.texture_slots[1]
|
|
TexSlot.texture = Tex
|
|
TexSlot.use_map_alpha = True
|
|
TexSlot.use_map_color_diffuse = False
|
|
TexSlot.texture_coords = 'UV'
|
|
if OpacityMode == 'TEX': TexSlot.alpha_factor = LayerOpacity
|
|
elif OpacityMode == 'MAT': TexSlot.blend_type = 'MULTIPLY'
|
|
|
|
if not Active.material_slots:
|
|
bpy.ops.object.material_slot_add()
|
|
|
|
Active.material_slots[0].material = Mat
|
|
|
|
|
|
Z = 0
|
|
global LayerNum
|
|
LayerNum = 0
|
|
LayerFlags = {}
|
|
LayerList = []
|
|
|
|
for Layer in IMGs:
|
|
Make3DLayer(Layer['LayerName'].replace(' ', '_'),
|
|
Layer['LayerNameShort'].replace(' ', '_'),
|
|
Z,
|
|
Layer['LayerCoords'],
|
|
Layer['RenderLayer'],
|
|
Layer['LayerMode'],
|
|
Layer['LayerOpacity'],
|
|
Layer['HasAlpha'],
|
|
)
|
|
|
|
Z -= LayerOffset
|
|
|
|
if SetupCompo:
|
|
#-------------------------------------------------
|
|
# COMPO NODES
|
|
|
|
Scene.use_nodes = True
|
|
|
|
Tree = Scene.node_tree
|
|
|
|
for i in Tree.nodes:
|
|
Tree.nodes.remove(i)
|
|
|
|
LayerList.reverse()
|
|
|
|
Offset = 0
|
|
LayerLen = len(LayerList)
|
|
|
|
for Layer in LayerList:
|
|
|
|
Offset += 1
|
|
|
|
X_Offset = (500*Offset)
|
|
Y_Offset = (-300*Offset)
|
|
|
|
Node = Tree.nodes.new('CompositorNodeRLayers')
|
|
Node.location = (-500+X_Offset, 300+Y_Offset)
|
|
Node.name = 'R_'+ str(Offset)
|
|
Node.scene = Scene
|
|
Node.layer = Layer[0]
|
|
|
|
if LayerViewers:
|
|
Node_V = Tree.nodes.new('CompositorNodeViewer')
|
|
Node_V.name = Layer[0]
|
|
Node_V.location = (-200+X_Offset, 200+Y_Offset)
|
|
|
|
Tree.links.new(Node.outputs[0], Node_V.inputs[0])
|
|
|
|
if LayerLen > Offset:
|
|
|
|
Mode = LayerList[Offset][1] # has to go one step further
|
|
LayerOpacity = LayerList[Offset][2]
|
|
|
|
if not Mode in {'Normal', '-1'}:
|
|
|
|
Node = Tree.nodes.new('CompositorNodeMixRGB')
|
|
if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value = LayerOpacity
|
|
else: Node.inputs['Fac'].default_value = 1
|
|
Node.use_alpha = True
|
|
|
|
if Mode in {'Addition', '7'}: Node.blend_type = 'ADD'
|
|
elif Mode in {'Subtract', '8'}: Node.blend_type = 'SUBTRACT'
|
|
elif Mode in {'Multiply', '3'}: Node.blend_type = 'MULTIPLY'
|
|
elif Mode in {'DarkenOnly', '9'}: Node.blend_type = 'DARKEN'
|
|
elif Mode in {'Dodge', '16'}: Node.blend_type = 'DODGE'
|
|
elif Mode in {'LightenOnly', '10'}: Node.blend_type = 'LIGHTEN'
|
|
elif Mode in {'Difference', '6'}: Node.blend_type = 'DIFFERENCE'
|
|
elif Mode in {'Divide', '15'}: Node.blend_type = 'DIVIDE'
|
|
elif Mode in {'Overlay', '5'}: Node.blend_type = 'OVERLAY'
|
|
elif Mode in {'Screen', '4'}: Node.blend_type = 'SCREEN'
|
|
elif Mode in {'Burn', '17'}: Node.blend_type = 'BURN'
|
|
elif Mode in {'Color', '13'}: Node.blend_type = 'COLOR'
|
|
elif Mode in {'Value', '14'}: Node.blend_type = 'VALUE'
|
|
elif Mode in {'Saturation', '12'}: Node.blend_type = 'SATURATION'
|
|
elif Mode in {'Hue', '11'}: Node.blend_type = 'HUE'
|
|
elif Mode in {'Softlight', '19'}: Node.blend_type = 'SOFT_LIGHT'
|
|
else: pass
|
|
|
|
else:
|
|
Node = Tree.nodes.new('CompositorNodeAlphaOver')
|
|
if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value = LayerOpacity
|
|
Node.name = 'M_' + str(Offset)
|
|
Node.location = (300+X_Offset, 250+Y_Offset)
|
|
|
|
if MixerViewers:
|
|
Node_V = Tree.nodes.new('CompositorNodeViewer')
|
|
Node_V.name = Layer[0]
|
|
Node_V.location = (500+X_Offset, 350+Y_Offset)
|
|
|
|
Tree.links.new(Node.outputs[0], Node_V.inputs[0])
|
|
|
|
else:
|
|
Node = Tree.nodes.new('CompositorNodeComposite')
|
|
Node.name = 'Composite'
|
|
Node.location = (400+X_Offset, 350+Y_Offset)
|
|
|
|
Nodes = bpy.context.scene.node_tree.nodes
|
|
|
|
if LayerLen > 1:
|
|
for i in range (1, LayerLen + 1):
|
|
if i == 1:
|
|
Tree.links.new(Nodes['R_'+str(i)].outputs[0], Nodes['M_'+str(i)].inputs[1])
|
|
if 1 < i < LayerLen:
|
|
Tree.links.new(Nodes['M_'+str(i-1)].outputs[0], Nodes['M_'+str(i)].inputs[1])
|
|
if 1 < i < LayerLen+1:
|
|
Tree.links.new(Nodes['R_'+str(i)].outputs[0], Nodes['M_'+str(i-1)].inputs[2])
|
|
if i == LayerLen:
|
|
Tree.links.new(Nodes['M_'+str(i-1)].outputs[0], Nodes['Composite'].inputs[0])
|
|
else:
|
|
Tree.links.new(Nodes['R_1'].outputs[0], Nodes['Composite'].inputs[0])
|
|
|
|
for i in Tree.nodes:
|
|
i.location[0] += -250*Offset
|
|
i.location[1] += 150*Offset
|
|
|
|
return True
|
|
|
|
#------------------------------------------------------------------------
|
|
import os, subprocess
|
|
import bpy
|
|
from bpy.props import *
|
|
from math import pi
|
|
|
|
# Operator
|
|
class GIMPImageToScene(bpy.types.Operator):
|
|
""""""
|
|
bl_idname = "import.gimp_image_to_scene"
|
|
bl_label = "GIMP Image to Scene"
|
|
bl_description = "Imports GIMP multilayer image files into 3D Scenes"
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
filename = StringProperty(name="File Name",
|
|
description="Name of the file")
|
|
directory = StringProperty(name="Directory",
|
|
description="Directory of the file")
|
|
|
|
LayerViewers = BoolProperty(name="Layer Viewers",
|
|
description="Add Viewer nodes to each Render Layer node",
|
|
default=True)
|
|
|
|
MixerViewers = BoolProperty(name="Mixer Viewers",
|
|
description="Add Viewer nodes to each Mix node",
|
|
default=True)
|
|
|
|
AlphaMode = EnumProperty(name="Alpha Mode",
|
|
description="Representation of alpha information in the RGBA pixels",
|
|
items=(
|
|
('STRAIGHT', 'Texture Alpha Factor', 'Transparent RGB and alpha pixels are unmodified'),
|
|
('PREMUL', 'Material Alpha Value', 'Transparent RGB pixels are multiplied by the alpha channel')),
|
|
default='STRAIGHT')
|
|
|
|
ShadelessMats = BoolProperty(name="Shadeless Material",
|
|
description="Set Materials as Shadeless",
|
|
default=True)
|
|
|
|
OpacityMode = EnumProperty(name="Opacity Mode",
|
|
description="Layer Opacity management",
|
|
items=(
|
|
('TEX', 'Texture Alpha Factor', ''),
|
|
('MAT', 'Material Alpha Value', ''),
|
|
('COMPO', 'Mixer Node Factor', ''),
|
|
('BAKE', 'Baked in Image Alpha', '')),
|
|
default='TEX')
|
|
|
|
SetCamera = BoolProperty(name="Set Camera",
|
|
description="Create an Ortho Camera matching image resolution",
|
|
default=True)
|
|
|
|
SetupCompo = BoolProperty(name="Setup Node Compositing",
|
|
description="Create a compositing node setup (will delete existing nodes)",
|
|
default=False)
|
|
|
|
GroupUntagged = BoolProperty(name="Group Untagged",
|
|
description="Layers with no tag go to a single Render Layer",
|
|
default=False)
|
|
|
|
LayerOffset = FloatProperty(name="Layer Separation",
|
|
description="Distance between each 3D Layer in the Z axis",
|
|
min=0,
|
|
default=0.50)
|
|
|
|
LayerScale = FloatProperty(name="Layer Scale",
|
|
description="Scale pixel resolution by Blender units",
|
|
min=0,
|
|
default=0.01)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
box = layout.box()
|
|
box.label('3D Layers:', icon='SORTSIZE')
|
|
box.prop(self, 'SetCamera', icon='OUTLINER_DATA_CAMERA')
|
|
box.prop(self, 'OpacityMode', icon='GHOST')
|
|
if self.OpacityMode == 'COMPO' and self.SetupCompo == False:
|
|
box.label('Tip: Enable Node Compositing', icon='INFO')
|
|
box.prop(self, 'AlphaMode', icon='IMAGE_RGB_ALPHA')
|
|
box.prop(self, 'ShadelessMats', icon='SOLID')
|
|
box.prop(self, 'LayerOffset')
|
|
box.prop(self, 'LayerScale')
|
|
|
|
box = layout.box()
|
|
box.label('Compositing:', icon='RENDERLAYERS')
|
|
box.prop(self, 'SetupCompo', icon='NODETREE')
|
|
if self.SetupCompo:
|
|
box.prop(self, 'GroupUntagged', icon='IMAGE_ZDEPTH')
|
|
box.prop(self, 'LayerViewers', icon='NODE')
|
|
box.prop(self, 'MixerViewers', icon='NODE')
|
|
|
|
def execute(self, context):
|
|
# File Path
|
|
filename = self.filename
|
|
directory = self.directory
|
|
|
|
# Settings
|
|
LayerViewers = self.LayerViewers
|
|
MixerViewers = self.MixerViewers
|
|
OpacityMode = self.OpacityMode
|
|
AlphaMode = self.AlphaMode
|
|
ShadelessMats = self.ShadelessMats
|
|
SetCamera = self.SetCamera
|
|
SetupCompo = self.SetupCompo
|
|
GroupUntagged = self.GroupUntagged
|
|
LayerOffset = self.LayerOffset
|
|
LayerScale = self.LayerScale
|
|
|
|
Ext = None
|
|
if filename.endswith('.xcf'): Ext = '.xcf'
|
|
elif filename.endswith('.xjt'): Ext = '.xjt'
|
|
|
|
# Call Main Function
|
|
if Ext:
|
|
ret = main(self.report, filename, directory, LayerViewers, MixerViewers, LayerOffset,
|
|
LayerScale, OpacityMode, AlphaMode, ShadelessMats,
|
|
SetCamera, SetupCompo, GroupUntagged, Ext)
|
|
if not ret:
|
|
return {'CANCELLED'}
|
|
else:
|
|
self.report({'ERROR'},"Selected file wasn't valid, try .xcf or .xjt")
|
|
return {'CANCELLED'}
|
|
|
|
return {'FINISHED'}
|
|
|
|
def invoke(self, context, event):
|
|
wm = bpy.context.window_manager
|
|
wm.fileselect_add(self)
|
|
|
|
return {'RUNNING_MODAL'}
|
|
|
|
|
|
# Registering / Unregister
|
|
def menu_func(self, context):
|
|
self.layout.operator(GIMPImageToScene.bl_idname, text="GIMP Image to Scene (.xcf, .xjt)", icon='PLUGIN')
|
|
|
|
|
|
def register():
|
|
bpy.utils.register_module(__name__)
|
|
|
|
bpy.types.INFO_MT_file_import.append(menu_func)
|
|
|
|
|
|
def unregister():
|
|
bpy.utils.unregister_module(__name__)
|
|
|
|
bpy.types.INFO_MT_file_import.remove(menu_func)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
register()
|