# ##### 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()