GIMPImagetoScene: Moving to addons. Docs here (for now). Still some

discussion over naming conventions

http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/File_I-O/GIMPImageToScene

io_convert_image_to_scene_gimp.py

+# ##### 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_addon_info = {
+	"name": "Convert GIMP Image to Scene (.xcf, .xjt)",
+	"author": "Daniel Salazar (ZanQdo)",
+	"version": (2,0,0),
+	"blender": (2, 5, 5),
+	"api": 33419,
+	"location": "File > Import > GIMP Image to Scene(.xcf, .xjt)",
+	"description": "Imports GIMP multilayer image files into 3D Layers",
+	"warning": "XCF import requires xcftools installed",
+	"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+		"Scripts/File_I-O/GIMPImageToScene",
+	"tracker_url": "http://projects.blender.org/tracker/index.php?"\
+		"func=detail&aid=25136&group_id=153&atid=469",
+	"category": "Import/Export"}
+
+"""
+This script imports GIMP layered image files into 3D Scenes (.xcf, .xjt)
+"""
+
+def main(File, Path, LayerViewers, MixerViewers, LayerOffset,\
+	LayerScale, OpacityMode, PremulAlpha, ShadelessMats,\
+	SetCamera, SetupCompo, GroupUntagged, Ext):
+	
+	#-------------------------------------------------
+	
+	#Folder = '['+File.rstrip(Ext)+']'+'_images/'
+	Folder = 'images_'+'['+File.rstrip(Ext)+']/'
+	
+	if bpy.data.is_dirty:
+		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") or Line.startswith("b'l"):
+				
+				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'
+						
+						# 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
+		
+		CMD = '%s %s%s' % (XCFInfo, Path, File)
+		
+		Info = os.popen(CMD)
+		
+		IMGs = []
+		for Line in Info.readlines():
+			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'
+		for Layer in IMGs:
+			CMD = '%s -C %s%s -o %s%s.png "%s"%s' %\
+			(XCF2PNG, Path, File, PathSave, Layer['LayerName'].replace(' ', '_'), Layer['LayerName'], Opacity)
+			os.system(CMD)
+	
+	#-------------------------------------------------
+	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
+	if PremulAlpha: Render.alpha_mode = 'PREMUL'
+	
+	#-------------------------------------------------
+	# 3D VIEW SETTINGS
+	
+	Scene.game_settings.material_mode = 'GLSL'
+	
+	Areas = bpy.context.screen.areas
+	
+	for Area in Areas:
+		if Area.type == 'VIEW_3D':
+			Area.active_space.viewport_shade = 'TEXTURED'
+			Area.active_space.show_textured_solid = True
+			Area.active_space.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, pi))
+		
+		bpy.ops.object.rotation_apply()
+		
+		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.scale_apply()
+		
+		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)
+			Img.source = 'FILE'
+			if PremulAlpha: Img.use_premultiply = True
+			Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
+			
+			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)
+			Img.source = 'FILE'
+			Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
+			
+			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
+				Tex.use_alpha = False
+				
+				Img = bpy.data.images.new(NameShort+'_A')
+				Img.source = 'FILE'
+				if PremulAlpha: Img.use_premultiply = True
+				Img.filepath = '%s%s_A%s' % (PathSaveRaw, Name, ExtSave)
+				
+				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('R_LAYERS')
+			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('VIEWER')
+				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('MIX_RGB')
+					if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value[0] = LayerOpacity
+					else: Node.inputs['Fac'].default_value[0] = 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('ALPHAOVER')
+					if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value[0] = LayerOpacity
+				Node.name = 'M_' + str(Offset)
+				Node.location = (300+X_Offset, 250+Y_Offset)
+				
+				if MixerViewers:
+					Node_V = Tree.nodes.new('VIEWER')
+					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('COMPOSITE')
+				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
+
+#------------------------------------------------------------------------
+import os
+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)
+	
+	PremulAlpha = BoolProperty(name="Premuliply Alpha",
+		description="Set Image and Render settings to premultiplied alpha",
+		default=True)
+
+	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.01)
+	
+	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, 'PremulAlpha', 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
+		PremulAlpha = self.PremulAlpha
+		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:
+			main(filename, directory, LayerViewers, MixerViewers, LayerOffset,\
+				LayerScale, OpacityMode, PremulAlpha, ShadelessMats,\
+				SetCamera, SetupCompo, GroupUntagged, Ext)
+		else:
+			self.report({'ERROR'},"Selected file wasn't valid, try .xcf or .xjt")
+		
+		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.types.INFO_MT_file_import.append(menu_func)
+
+
+def unregister():
+	bpy.types.INFO_MT_file_import.remove(menu_func)
+
+
+if __name__ == "__main__":
+	register()