Added openflight import/export- Blight v1.2

1 files changed, 1803 insertions, 0 deletions

diff --git a/release/scripts/flt_import.py b/release/scripts/flt_import.py
new file mode 100755
index 00000000000..2553f34dbf0
--- /dev/null
+++ b/release/scripts/flt_import.py
@@ -0,0 +1,1803 @@
+#!BPY
+
+# flt_import.py is an OpenFlight importer for blender.
+# Copyright (C) 2005 Greg MacDonald
+#
+# 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.
+
+""" Registration info for Blender menus:
+Name: 'OpenFlight (.flt)...'
+Blender: 238
+Group: 'Import'
+Tip: 'Import OpenFlight (.flt)'
+"""
+
+__author__ = "Greg MacDonald"
+__version__ = "1.2 10/20/05"
+__url__ = ("blender", "elysiun", "Author's homepage, http://sourceforge.net/projects/blight/")
+__bpydoc__ = """\
+This script imports OpenFlight files into Blender. OpenFlight is a
+registered trademark of MultiGen-Paradigm, Inc.
+
+Run from "File->Import" menu.
+
+Options are available from Blender's "Scripts Config Editor," accessible through
+the "Scripts->System" menu from the scripts window.
+
+All options are toggle switches that let the user choose what is imported. Most
+are straight-forward, but one option could be a source of confusion. The 
+"Diffuse Color From Face" option when set pulls the diffuse color from the face
+colors. Otherwise the diffuse color comes from the material. What may be
+confusing is that this options only works if the "Diffuse Color" option is set.
+
+New Features:<br>
+* Importer is 14 times faster.<br>
+* External triangle module is no longer required, but make sure the importer
+has a 3d View screen open while its running or triangulation won't work.<br>
+* Should be able to import all versions of flight files.
+
+Features:<br>
+* Heirarchy retained.<br>
+* First texture imported.<br>
+* Colors imported from face or material.<br>
+* LOD seperated out into different layers.<br>
+* Asks for location of unfound textures or external references.<br>
+* Searches Blender's texture directory in the user preferences panel.<br>
+* Triangles with more than 4 verts are triangulated if the Triangle python
+module is installed.<br>
+* Matrix transforms imported.<br>
+* External references to whole files are imported.
+
+Things To Be Aware Of:<br>
+* Each new color and face attribute creates a new material and there are only a maximum of 16
+materials per object.<br>
+* For triangulated faces, normals must be recomputed outward manually by typing
+CTRL+N in edit mode.<br>
+* You can change options only after an initial import.<br>
+* External references are imported as geometry and will be exported that way.<br>
+* A work around for not using the Triangle python module is to simply to 
+triangulate in Creator before importing. This is only necessary if your
+model contains 5 or more vertices.<br>
+* You have to manually blend the material color with the texture color.
+
+What's Not Handled:<br>
+* Special texture repeating modes.<br>
+* Replications and instancing.<br>
+* Comment and attribute fields.<br>
+* Light points.<br>
+* Animations.<br>
+* External references to a node within a file.<br>
+* Multitexturing.<br>
+* Vetex colors.<br>
+"""
+
+import Blender
+import os
+
+from flt_filewalker import FltIn, FileFinder
+
+def col_to_gray(c):
+    return 0.3*c[0] + 0.59*c[1] + 0.11*c[2]
+
+class ImporterOptions:
+    def __init__(self):
+        self.defaults = { 'Texture': True,
+                          'Diffuse Color': True,
+                          'Specular Color': False,
+                          'Emissive Intensity': False,
+                          'Alpha': True,
+                          'Ambient Intensity': False,
+                          'Shininess': True,
+                          'Diffuse Color From Face': True}
+
+        d = Blender.Registry.GetKey('flt_import', True)
+
+        if d == None or d.keys() != self.defaults.keys():
+            d = self.defaults
+            Blender.Registry.SetKey('flt_import', d, True)
+
+        self.verbose = 1
+        self.get_texture = d['Texture']
+        self.get_diffuse = d['Diffuse Color']
+        self.get_specular = d['Specular Color']
+        self.get_emissive = d['Emissive Intensity']
+        self.get_alpha = d['Alpha']
+        self.get_ambient = d['Ambient Intensity']
+        self.get_shininess = d['Shininess']
+        self.color_from_face = d['Diffuse Color From Face']
+
+options = ImporterOptions()
+
+# Contributed by Campbell Barton:
+# http://en.wikibooks.org/wiki/Blending_Into_Python:_Cookbook#Expanded_Scanfill_function
+msg_once = False
+def scanFillPoints(pointList):
+    global msg_once
+    
+    screen_info = Blender.Window.GetScreenInfo(Blender.Window.Types.VIEW3D)
+    if screen_info == []:
+        if not msg_once:
+            msg = 'Error: A 3D View window must be open while the script is running for triangulation to occur.'
+            Blender.Draw.PupMenu(msg)
+            print msg
+            print
+            msg_once = True
+        return None
+        
+    Blender.Window.EditMode(0)
+ 
+    nme = Blender.NMesh.GetRaw('.scanfill')
+    if nme:
+        nme.verts = []
+        nme.edges = []
+        nme. faces = []
+    else:
+        nme = Blender.NMesh.New('.scanfill')
+        
+    for p in pointList:
+        v = Blender.NMesh.Vert( p[0], p[1], p[2] )
+        nme.verts.append(v)
+        v.sel = 1
+
+        if len(nme.verts) >= 2:
+            nme.addEdge(nme.verts[-2], nme.verts[-1])
+
+    nme.addEdge(nme.verts[0], nme.verts[-1])
+
+    nme.update()
+    
+    scn = Blender.Scene.GetCurrent()
+
+    actOb = scn.getActiveObject()
+    if actOb:
+        actSel = actOb.sel
+    else:
+        actSel = 0
+
+    try:
+        ob = Blender.Object.Get('.scanfill')
+    except AttributeError:
+        ob = Blender.Object.New('Mesh')
+        ob.setName('.scanfill')
+        ob.link(nme)
+    
+    scn.link(ob)
+    scn.layers = range(1,20)
+    ob.sel = 1
+    Blender.Window.EditMode(1)
+
+    winid = screen_info[0]['id']
+    Blender.Window.SetKeyQualifiers(Blender.Window.Qual.SHIFT)
+    Blender.Window.QAdd(winid, Blender.Draw.FKEY,1)
+    Blender.Window.QHandle(winid)
+    Blender.Window.SetKeyQualifiers(0)
+
+    Blender.Window.EditMode(0)
+    scn.unlink(ob)
+
+    # Select the old active object.
+    if actOb:
+        actOb.sel = actSel
+
+    # Return the scanfilled faces.
+    return ob.getData()
+
+class MaterialDesc:
+    # Was going to use int(f*1000.0) instead of round(f,3), but for some reason
+    # round produces better results, as in less dups.
+    def make_key(self):
+        key = []
+        if options.get_texture:
+            if self.tex0:
+                key.append(self.tex0.getName())
+            else:
+                key.append(None)
+        
+        if options.get_alpha:
+            key.append(round(self.alpha, 3))
+        else:
+            key.append(None)
+            
+        if options.get_shininess:
+            key.append(round(self.shininess, 3))
+        else:
+            key.append(None)
+        
+        if options.get_emissive:
+            key.append(round(self.emissive, 3))
+        else:
+            key.append(None)
+        
+        if options.get_ambient:
+            key.append(round(self.ambient, 3))
+        else:
+            key.append(None)
+        
+        if options.get_specular:
+            for n in self.specular:
+                key.append(round(n, 3))
+        else:
+            key.extend([None, None, None])
+        
+        if options.get_diffuse:
+            for n in self.diffuse:
+                key.append(round(n, 3))
+        else:
+            key.extend([None, None, None])
+        
+#        key.extend(self.face_props.values())
+        
+        return tuple(key)
+
+    def __init__(self):
+        self.name = 'Material'
+        # Colors, List of 3 floats.
+        self.diffuse = [1.0, 1.0, 1.0]
+        self.specular = [1.0, 1.0, 1.0]
+
+        # Scalars
+        self.ambient = 0.0 # [0.0, 1.0]
+        self.emissive = 0.0 # [0.0, 1.0]
+        self.shininess = 0.5 # Range is [0.0, 2.0]
+        self.alpha = 1.0 # Range is [0.0, 1.0]
+
+        self.tex0 = None
+        
+        # OpenFlight Face attributes
+        self.face_props = dict.fromkeys(['comment', 'ir color', 'priority', 
+                            'draw type', 'texture white', 'template billboard',
+                            'smc', 'fid', 'ir material', 'lod generation control',
+                            'flags', 'light mode'])
+
+class VertexDesc:
+    def make_key(self):
+        return (round(self.x,3), round(self.y, 3), round(self.z, 3))
+        
+    def __init__(self):
+        self.x = 0.0
+        self.y = 0.0
+        self.z = 0.0
+        self.nx = 0.0
+        self.ny = 1.0
+        self.nz = 0.0
+        self.u = 0.0
+        self.v = 0.0
+        self.r = 1.0
+        self.g = 1.0
+        self.b = 1.0
+        self.a = 1.0        
+
+class LightPointAppDesc:
+    def make_key(self):
+        d = dict(self.props)
+        del d['id']
+        del d['type']
+        
+        if d['directionality'] != 0: # not omni
+            d['nx'] = 0.0
+            d['ny'] = 0.0
+            d['nz'] = 0.0
+        
+        return tuple(d.values())
+        
+    def __init__(self):
+        self.props = dict()
+        self.props.update({'type': 'LPA'})
+        self.props.update({'id': 'ap'})
+        # Attribs not found in inline lightpoint.
+        self.props.update({'visibility range': 0.0})
+        self.props.update({'fade range ratio': 0.0})
+        self.props.update({'fade in duration': 0.0})
+        self.props.update({'fade out duration': 0.0})
+        self.props.update({'LOD range ratio': 0.0})
+        self.props.update({'LOD scale': 0.0})
+
+class GlobalResourceRepository:
+    def request_lightpoint_app(self, desc):
+        match = self.light_point_app.get(desc.make_key())
+        
+        if match:
+            return match.getName()
+        else:
+            # Create empty and fill with properties.
+            name = desc.props['type'] + ': ' + desc.props['id']
+            object = Blender.Object.New('Empty', name)
+            
+            scene.link(object)
+    
+            # Attach properties
+            for name, value in desc.props.items():
+                object.addProperty(name, value)
+            
+            self.light_point_app.update({desc.make_key(): object})
+            
+            return object.getName()
+            
+    def request_vert(self, desc):
+        match = self.vert_dict.get(desc.make_key())
+
+        if match:
+            return match
+        else:
+            vert = Blender.NMesh.Vert(desc.x, desc.y, desc.z)
+
+            vert.no[0] = desc.nx
+            vert.no[1] = desc.ny
+            vert.no[2] = desc.nz
+
+            self.vert_dict.update({desc.make_key(): vert})
+            return vert
+
+    def request_mat(self, mat_desc):
+        match = self.mat_dict.get(mat_desc.make_key())
+        if match: return match
+        
+        mat = Blender.Material.New(mat_desc.name)
+
+        if mat_desc.tex0 != None:
+            mat.setTexture(0, mat_desc.tex0, Blender.Texture.TexCo.UV)
+
+        mat.setAlpha(mat_desc.alpha)
+        mat.setSpec(mat_desc.shininess)
+        mat.setHardness(255)
+        mat.setEmit(mat_desc.emissive)
+        mat.setAmb(mat_desc.ambient)
+        mat.setSpecCol(mat_desc.specular)
+        mat.setRGBCol(mat_desc.diffuse)
+        
+        # Create a text object to store openflight face attribs until
+        # user properties can be set on materials.
+#        t = Blender.Text.New('FACE: ' + mat.getName())
+#
+#        for name, value in mat_desc.face_props.items():
+#            t.write(name + '\n' + str(value) + '\n\n')    
+                
+        self.mat_dict.update({mat_desc.make_key(): mat})
+
+        return mat
+        
+    def request_image(self, filename_with_path):
+        if not options.get_texture: return None
+
+        img = self.img_dict.get(filename_with_path)
+        if img: return img
+            
+        img =  Blender.Image.Load(filename_with_path)
+        self.img_dict.update({filename_with_path: img})
+        return img
+        
+    def request_texture(self, image):
+        if not options.get_texture:
+            return None
+
+        tex = self.tex_dict.get(image.filename)
+        if tex: return tex
+        
+        tex = Blender.Texture.New(Blender.sys.basename(image.filename))
+        tex.setImage(image)
+        tex.setType('Image')
+        self.tex_dict.update({image.filename: tex})
+        return tex
+        
+    def __init__(self):
+        # material
+        self.mat_dict = dict()
+        mat_lst = Blender.Material.Get()
+        for mat in mat_lst:
+            mat_desc = MaterialDesc()
+            mapto_lst = mat.getTextures()
+            if mapto_lst[0]:
+                mat_desc.tex0 = mapto_lst[0].tex
+            else:
+                mat_desc.tex0 = None
+            mat_desc.alpha = mat.getAlpha()
+            mat_desc.shininess = mat.getSpec()
+            mat_desc.emissive = mat.getEmit()
+            mat_desc.ambient = mat.getAmb()
+            mat_desc.specular = mat.getSpecCol()
+            mat_desc.diffuse = mat.getRGBCol()
+            
+            self.mat_dict.update({mat_desc.make_key(): mat})
+            
+        # texture
+        self.tex_dict = dict()
+        tex_lst = Blender.Texture.Get()
+        
+        for tex in tex_lst:
+            img = tex.getImage()
+            # Only interested in textures with images.
+            if img:
+                self.tex_dict.update({img.filename: tex})
+                
+        # image
+        img_lst = Blender.Image.Get()
+        self.img_dict = dict()
+        for img in img_lst:
+            self.img_dict.update({img.filename: img})
+            
+        # vertex
+        self.vert_dict = dict()
+        
+        # light point
+        self.light_point_app = dict()
+        
+# Globals
+GRR = GlobalResourceRepository()
+FF = FileFinder()
+current_layer = 0x1
+scene = Blender.Scene.getCurrent()
+
+# Opcodes that indicate its time to return control to parent.
+throw_back_opcodes = [2, 73, 4, 11, 96, 14, 91, 98, 63]
+do_not_report_opcodes = [76, 78, 79, 80, 81, 82, 94, 83, 33, 112, 100, 101, 102, 97, 31, 103, 104, 117, 118, 120, 121, 124, 125]
+
+opcode_name = { 0: 'db',
+                1: 'head',
+                2: 'grp',
+                4: 'obj',
+                5: 'face',
+                10: 'push',
+                11: 'pop',
+                14: 'dof',
+                19: 'push sub',
+                20: 'pop sub',
+                21: 'push ext',
+                22: 'pop ext',
+                23: 'cont',
+                31: 'comment',
+                32: 'color pal',
+                33: 'long id',
+                49: 'matrix',
+                50: 'vector',
+                52: 'multi-tex',
+                53: 'uv lst',
+                55: 'bsp',
+                60: 'rep',
+                61: 'inst ref',
+                62: 'inst def',
+                63: 'ext ref',
+                64: 'tex pal',
+                67: 'vert pal',
+                68: 'vert w col',
+                69: 'vert w col & norm',
+                70: 'vert w col, norm & uv',
+                71: 'vert w col & uv',
+                72: 'vert lst',
+                73: 'lod',
+                74: 'bndin box',
+                76: 'rot edge',
+                78: 'trans',
+                79: 'scl',
+                80: 'rot pnt',
+                81: 'rot and/or scale pnt',
+                82: 'put',
+                83: 'eyepoint & trackplane pal',
+                84: 'mesh',
+                85: 'local vert pool',
+                86: 'mesh prim',
+                87: 'road seg',
+                88: 'road zone',
+                89: 'morph vert lst',
+                90: 'link pal',
+                91: 'snd',
+                92: 'rd path',
+                93: 'snd pal',
+                94: 'gen matrix',
+                95: 'txt',
+                96: 'sw',
+                97: 'line styl pal',
+                98: 'clip reg',
+                100: 'ext',
+                101: 'light src',
+                102: 'light src pal',
+                103: 'reserved',
+                104: 'reserved',
+                105: 'bndin sph',
+                106: 'bndin cyl',
+                107: 'bndin hull',
+                108: 'bndin vol cntr',
+                109: 'bndin vol orient',
+                110: 'rsrvd',
+                111: 'light pnt',
+                112: 'tex map pal',
+                113: 'mat pal',
+                114: 'name tab',
+                115: 'cat',
+                116: 'cat dat',
+                117: 'rsrvd',
+                118: 'rsrvd',
+                119: 'bounding hist',
+                120: 'rsrvd',
+                121: 'rsrvd',
+                122: 'push attrib',
+                123: 'pop attrib',
+                124: 'rsrvd',
+                125: 'rsrvd',
+                126: 'curv',
+                127: 'road const',
+                128: 'light pnt appear pal',
+                129: 'light pnt anim pal',
+                130: 'indexed lp',
+                131: 'lp sys',
+                132: 'indx str',
+                133: 'shdr pal'}
+
+class Handler:
+    def in_throw_back_lst(self, opcode):
+        return opcode in self.throw_back_lst
+        
+    def handle(self, opcode):
+        return self.handler[opcode]()
+    
+    def handles(self, opcode):
+        return opcode in self.handler.keys()
+    
+    def throws_back_all_unhandled(self):
+        return self.throw_back_unhandled
+        
+    def set_throw_back_lst(self, a):
+        self.throw_back_lst = a
+        
+    def set_throw_back_all_unhandled(self):
+        self.throw_back_unhandled = True
+        
+    def set_only_throw_back_specified(self):
+        self.throw_back_unhandled = False
+        
+    def set_handler(self, d):
+        self.handler = d
+        
+    def __init__(self):
+        # Dictionary of opcodes to handler methods.
+        self.handler = dict()
+        # Send all opcodes not handled to the parent node.
+        self.throw_back_unhandled = False
+        # If throw_back_unhandled is False then only throw back
+        # if the opcodes in throw_back are encountered.
+        self.throw_back_lst = []
+        
+class Node:
+    def blender_import(self):
+        if self.opcode in opcode_name and options.verbose >= 2:
+            for i in range(self.get_level()):
+                print ' ',
+            print opcode_name[self.opcode],
+            print '-', self.props['id'],
+            print '-', self.props['comment'],
+
+            print
+
+        for child in self.children:
+            child.blender_import()
+        
+        # Import comment.
+#        if self.props['comment'] != '':
+#            name = 'COMMENT: ' + self.props['id']
+#            t = Blender.Text.New(name)
+#            t.write(self.props['comment'])
+#            self.props['comment'] = name
+        
+    # Always ignore extensions and anything in between them.
+    def parse_push_extension(self):
+        self.saved_handler = self.active_handler
+        self.active_handler = self.extension_handler
+        return True
+    
+    def parse_pop_extension(self):
+        self.active_handler = self.saved_handler
+        return True
+    
+    def parse_push(self):
+        self.header.fw.up_level()
+        # Ignore unknown children.
+        self.ignore_unhandled = True
+        # Don't do child records that might overwrite parent info. ex: longid
+        self.active_handler = self.child_handler
+        return True
+        
+    def parse_pop(self):
+        self.header.fw.down_level()
+        
+        if self.header.fw.get_level() == self.level:
+            return False
+        
+        return True
+    
+    def parse(self):
+        while self.header.fw.begin_record():
+            opcode = self.header.fw.get_opcode()
+
+            # Print out info on opcode and tree level.
+            if options.verbose >= 3:
+                p = ''
+                for i in range(self.header.fw.get_level()):
+                    p = p + '  '
+                if opcode in opcode_name:
+                    p = p + opcode_name[opcode]
+                else:
+                    if options.verbose >= 1:
+                        print 'undocumented opcode', opcode
+                    continue
+                            
+            if self.global_handler.handles(opcode):
+                if options.verbose >= 3:
+                    print p + ' handled globally'
+                if self.global_handler.handle(opcode) == False:
+                    break
+                    
+            elif self.active_handler.handles(opcode):
+                if options.verbose >= 4:
+                    print p + ' handled'
+                if self.active_handler.handle(opcode) == False:
+                    break
+                    
+            else:
+                if self.active_handler.throws_back_all_unhandled():
+                    if options.verbose >= 3:
+                        print p + ' handled elsewhere'              
+                    self.header.fw.repeat_record()
+                    break
+
+                elif self.active_handler.in_throw_back_lst(opcode):
+                    if options.verbose >= 3:
+                        print p + ' handled elsewhere'              
+                    self.header.fw.repeat_record()
+                    break
+
+                else:
+                    if options.verbose >= 3:
+                        print p + ' ignored'
+                    elif options.verbose >= 1 and not opcode in do_not_report_opcodes and opcode in opcode_name:
+                        print opcode_name[opcode], 'not handled'                        
+                    
+    def get_level(self):
+        return self.level
+        
+    def parse_long_id(self):
+        self.props['id'] = self.header.fw.read_string(self.header.fw.get_length()-4)
+        return True
+
+    def parse_comment(self):
+        self.props['comment'] = self.header.fw.read_string(self.header.fw.get_length()-4)
+        return True
+
+    def __init__(self, parent, header):
+        self.root_handler = Handler()
+        self.child_handler = Handler()
+        self.extension_handler = Handler()
+        self.global_handler = Handler()
+        
+        self.global_handler.set_handler({21: self.parse_push_extension})
+        self.active_handler = self.root_handler
+        
+        # used by parse_*_extension
+        self.extension_handler.set_handler({22: self.parse_pop_extension})
+        self.saved_handler = None
+        
+        self.header = header
+        self.children = []
+
+        self.parent = parent
+
+        if parent:
+            parent.children.append(self)
+
+        self.level = self.header.fw.get_level()
+        self.opcode = self.header.fw.get_opcode()
+
+        self.props = {'id': 'unnamed', 'comment': '', 'type': 'untyped'}
+
+class VertexPalette(Node):
+    def blender_import(self):
+        for vert_desc in self.vert_desc_lst:
+            vert = GRR.request_vert(vert_desc)
+            self.blender_verts.append(vert)
+
+    def parse_vertex_common(self):
+        # Add this vertex to an offset to index dictionary.
+        self.index_lst.append( (self.offset, self.next_index) )
+        self.next_index += 1
+        # Get ready for next record.
+        self.offset += self.header.fw.get_length()
+
+        v = VertexDesc()
+
+        self.header.fw.read_ahead(2)
+        v.flags = self.header.fw.read_short()
+
+        v.x = self.header.fw.read_double()
+        v.y = self.header.fw.read_double()
+        v.z = self.header.fw.read_double()
+
+        return v
+
+    def parse_vertex_post_common(self, v):
+        if not v.flags & 0x2000: # 0x2000 = no color
+            if v.flags & 0x1000: # 0x1000 = packed color
+                v.a = self.header.fw.read_uchar()
+                v.b = self.header.fw.read_uchar()
+                v.g = self.header.fw.read_uchar()
+                v.r = self.header.fw.read_uchar()
+            else:
+                self.header.fw.read_ahead(4)
+
+            color_index = self.header.fw.read_uint()
+            color = self.header.get_color(color_index)
+            v.r = color[0]
+            v.g = color[1]
+            v.b = color[2]
+            v.a = color[3]
+
+        self.vert_desc_lst.append(v)
+        
+        return True
+
+    def parse_vertex_c(self):
+        v = self.parse_vertex_common()
+
+        self.parse_vertex_post_common(v)
+        
+        return True
+
+    def parse_vertex_cn(self):
+        v = self.parse_vertex_common()
+
+        v.nx = self.header.fw.read_float()
+        v.ny = self.header.fw.read_float()
+        v.nz = self.header.fw.read_float()
+
+        self.parse_vertex_post_common(v)
+        
+        return True
+
+    def parse_vertex_cuv(self):
+        v = self.parse_vertex_common()
+
+        v.u = self.header.fw.read_float()
+        v.v = self.header.fw.read_float()
+
+        self.parse_vertex_post_common(v)
+        
+        return True
+
+    def parse_vertex_cnuv(self):
+        v = self.parse_vertex_common()
+
+        v.nx = self.header.fw.read_float()
+        v.ny = self.header.fw.read_float()
+        v.nz = self.header.fw.read_float()
+
+        v.u = self.header.fw.read_float()
+        v.v = self.header.fw.read_float()
+
+        self.parse_vertex_post_common(v)
+        
+        return True
+
+    def parse(self):
+        Node.parse(self)
+
+        self.index = dict(self.index_lst)
+        del self.index_lst
+
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        self.root_handler.set_handler({68: self.parse_vertex_c,
+                                       69: self.parse_vertex_cn,
+                                       70: self.parse_vertex_cnuv,
+                                       71: self.parse_vertex_cuv})
+        self.root_handler.set_throw_back_all_unhandled()
+
+        self.vert_desc_lst = []
+        self.blender_verts = []
+        self.offset = 8
+        # Used to create a map from byte offset to vertex index.
+        self.index = dict()
+        self.index_lst = []
+        self.next_index = 0
+
+class InterNode(Node):
+    def blender_import(self):
+#        name = self.props['type'] + ': ' + self.props['id']
+        name = self.props['id']
+        if self.isMesh:
+            self.object = Blender.Object.New('Mesh', name)
+            self.mesh = self.object.getData()
+        else:
+            self.object = Blender.Object.New('Empty', name)
+
+        if self.parent:
+            self.parent.object.makeParent([self.object])
+
+        scene.link(self.object)
+
+        self.object.Layer = current_layer
+
+        Node.blender_import(self)
+
+        if self.isMesh:
+            self.mesh.update(recalc_normals=1)
+            
+        if self.matrix:
+            self.object.setMatrix(self.matrix)
+        
+        # Attach properties
+        #for name, value in self.props.items():
+        #    self.object.addProperty(name, value)
+        
+    def parse_face(self):
+        child = Face(self)
+        child.parse()
+        return True
+
+    def parse_group(self):
+        child = Group(self)
+        child.parse()
+        return True
+
+    def move_to_next_layer(self):
+        global current_layer
+        current_layer = current_layer << 1
+        if current_layer > 0x80000:
+            current_layer = 1
+
+    def parse_lod(self):
+        child = LOD(self)
+        child.parse()
+        return True
+
+    def parse_unhandled(self):
+        child = Unhandled(self)
+        child.parse()
+        return True
+
+    def parse_object(self):
+        child = Object(self)
+        child.parse()
+        return True
+    
+    def parse_xref(self):
+        child = XRef(self)
+        child.parse()
+        return True
+
+    def parse_indexed_light_point(self):
+        child = IndexedLightPoint(self)
+        child.parse()
+        return True
+        
+    def parse_inline_light_point(self):
+        child = InlineLightPoint(self)
+        child.parse()
+        return True
+        
+    def parse_matrix(self):
+        m = []
+        for i in range(4):
+            m.append([])
+            for j in range(4):
+                f = self.header.fw.read_float()
+                m[i].append(f)
+        self.matrix = Blender.Mathutils.Matrix(m[0], m[1], m[2], m[3])
+        
+    def __init__(self):
+        self.object = None
+        self.mesh = None
+        self.isMesh = False
+        self.matrix = None
+        
+class Face(Node):
+    def blender_import_face(self, indices, material_index, image):
+        mesh = self.parent.mesh
+        face = Blender.NMesh.Face()
+        
+        # Add vertices to face.
+        for i in indices:
+            # Add uv info to face.
+            vert_desc = self.header.vert_pal.vert_desc_lst[i]
+            if vert_desc.u != None and vert_desc.v != None:
+                mesh.hasFaceUV(True)
+                face.uv.append((vert_desc.u, vert_desc.v))
+            
+            # Add vert to face.
+            vert = self.header.vert_pal.blender_verts[i]
+            face.v.append(vert)
+            
+            # Add vert to mesh.
+            if not vert in mesh.verts:
+                mesh.verts.append(vert)
+            
+        if image:
+            face.image = image           
+        face.materialIndex = material_index
+        face.smooth = True
+        
+        mesh.addFace(face)
+        
+    def parse_comment(self):
+        self.comment = self.header.fw.read_string(self.header.fw.get_length()-4)
+        return True
+        
+    # returns a tuple (material, image) where material is the blender material and
+    # image is the blender image or None.
+    def create_blender_material(self):
+         # Create face material.
+        mat_desc = MaterialDesc()
+        
+        if self.mat_index != -1:
+            if not self.mat_index in self.header.mat_desc_pal:
+                if options.verbose >= 1:
+                    print 'Warning: Material index', self.mat_index, 'not in material palette.'
+            else:
+                mat_pal_desc = self.header.mat_desc_pal[self.mat_index]
+                mat_desc.alpha = mat_pal_desc.alpha * self.alpha # combine face and mat alphas
+                mat_desc.ambient = mat_pal_desc.ambient
+                mat_desc.diffuse = mat_pal_desc.diffuse
+                mat_desc.specular = mat_pal_desc.specular
+                mat_desc.emissive = mat_pal_desc.emissive
+                mat_desc.shininess = mat_pal_desc.shininess
+        else:
+            # if no material get alpha from just face.
+            mat_desc.alpha = self.alpha
+
+        # Color.
+        if options.color_from_face:
+            color = None
+            if not self.props['flags'] & 0x40000000:
+                if self.props['flags'] & 0x10000000: # packed color
+                    color = self.packed_color
+                else:
+                    color = self.header.get_color(self.color_index)
+
+            if color:
+                r = float(color[0])/255.0
+                g = float(color[1])/255.0
+                b = float(color[2])/255.0
+                mat_desc.diffuse = [r, g, b]
+
+        # Texture
+        image = None
+        if self.tex_index != -1 and self.tex_index in self.header.bl_tex_pal:
+            mat_desc.tex0 = self.header.bl_tex_pal[self.tex_index]
+            if mat_desc.tex0:
+                mat_desc.name = FF.strip_path(self.header.tex_pal[self.tex_index])
+                image = mat_desc.tex0.image
+
+        # OpenFlight Face Attributes
+        mat_desc.face_props = self.props
+        
+        # Get material.
+        mat = GRR.request_mat(mat_desc)
+        
+        # Add material to mesh.
+        mesh = self.parent.mesh
+        try:
+            mesh.addMaterial(mat)
+        except AttributeError:
+            pass
+        except RuntimeError:
+            if options.verbose >= 1:
+                print 'Warning: Too many materials per mesh object. Only a maximum of 16 ' + \
+                      'allowed. Using 16th material instead.'
+            mat = mesh.materials[-1]
+
+        # Return where it is in the mesh for faces.
+        material_index = mesh.materials.index(mat)
+        
+        return (material_index, image)
+        
+    def triangulate(self):
+        point_lst = []
+        for i in self.indices:
+            vert_desc = self.header.vert_pal.vert_desc_lst[i]
+            point_lst.append(self.header.vert_pal.blender_verts[i].co)
+        
+        mesh = scanFillPoints(point_lst)
+        if not mesh:
+            return []
+            
+        # mesh.verts and vert_lst should be in the same order unless blender rearranged them during triangulation, unlikely.
+        tri_lst = []
+        for f in mesh.faces:
+            tri = []
+            for vert in f.v:
+                i = mesh.verts.index(vert)
+                tri.append(self.indices[i])
+            tri_lst.append(tri)
+            
+        return tri_lst
+        
+    def blender_import(self):
+        vert_count = len(self.indices)
+        if vert_count == 0:
+            if options.verbose >= 2:
+                print 'Warning: Ignoring face with no vertices.'
+            return
+
+        material = self.create_blender_material()
+        
+        if vert_count > 4:
+            tri_lst = self.triangulate()
+        else:
+            tri_lst = [self.indices]
+            
+        for tri in tri_lst:
+            self.blender_import_face(tri, material[0], material[1])
+        
+        # Store comment info in parent.
+        if self.comment != '':
+            if self.parent.props['comment'] != '':
+                self.parent.props['comment'] += '\n\nFrom Face:\n' + self.comment
+            else:
+                self.parent.props['comment'] = self.comment
+        
+    def parse_vertex_list(self):
+        length = self.header.fw.get_length()
+        fw = self.header.fw
+        vert_pal = self.header.vert_pal
+
+        count = (length-4)/4
+
+        for i in range(count):
+            byte_offset = fw.read_int()
+            if byte_offset in vert_pal.index:
+                index = vert_pal.index[byte_offset]
+                self.indices.append(index)
+            elif options.verbose >= 1:
+                print 'Warning: Unable to map byte offset %s' + \
+                      ' to vertex index.' % byte_offset
+      
+        return True
+
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        self.root_handler.set_handler({31: self.parse_comment,
+                                       10: self.parse_push})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({72: self.parse_vertex_list,
+                                        10: self.parse_push,
+                                        11: self.parse_pop})
+        
+        if parent:
+            parent.isMesh = True
+
+        self.indices = []
+        
+        self.comment = ''
+        self.props = dict.fromkeys(['ir color', 'priority', 
+                                    'draw type', 'texture white', 'template billboard',
+                                    'smc', 'fid', 'ir material', 'lod generation control',
+                                    'flags', 'light mode'])
+        
+        self.header.fw.read_ahead(8) # face id
+        # Load face.
+        self.props['ir color'] = self.header.fw.read_int()
+        self.props['priority'] = self.header.fw.read_short()
+        self.props['draw type'] = self.header.fw.read_char()
+        self.props['texture white'] = self.header.fw.read_char()
+        self.header.fw.read_ahead(4) # color name indices
+        self.header.fw.read_ahead(1) # reserved
+        self.props['template billboard'] = self.header.fw.read_uchar()
+        self.detail_tex_index = self.header.fw.read_short()
+        self.tex_index = self.header.fw.read_short()
+        self.mat_index = self.header.fw.read_short()
+        self.props['smc'] = self.header.fw.read_short()
+        self.props['fid'] = self.header.fw.read_short()
+        self.props['ir material'] = self.header.fw.read_int()
+        self.alpha = 1.0 - float(self.header.fw.read_ushort()) / 65535.0
+        self.props['lod generation control'] = self.header.fw.read_uchar()
+        self.header.fw.read_ahead(1) # line style index
+        self.props['flags'] = self.header.fw.read_int()
+        self.props['light mode'] = self.header.fw.read_uchar()
+        self.header.fw.read_ahead(7)
+        a = self.header.fw.read_uchar()
+        b = self.header.fw.read_uchar()
+        g = self.header.fw.read_uchar()
+        r = self.header.fw.read_uchar()
+        self.packed_color = [r, g, b, a]
+        a = self.header.fw.read_uchar()
+        b = self.header.fw.read_uchar()
+        g = self.header.fw.read_uchar()
+        r = self.header.fw.read_uchar()
+        self.alt_packed_color = [r, g, b, a]
+        self.tex_map_index = self.header.fw.read_short()
+        self.header.fw.read_ahead(2)
+        self.color_index = self.header.fw.read_uint()
+        self.alt_color_index = self.header.fw.read_uint()
+        #self.header.fw.read_ahead(2)
+        #self.shader_index = self.header.fw.read_short()
+
+class Object(InterNode):
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+       
+        self.child_handler.set_handler({5: self.parse_face,
+                                        #130: self.parse_indexed_light_point,
+                                        #111: self.parse_inline_light_point,
+                                        10: self.parse_push,
+                                        11: self.parse_pop})
+
+        self.props['type'] = 'Object'
+        self.props['id'] = self.header.fw.read_string(8)
+
+class Group(InterNode):
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({5: self.parse_face,
+                                        #130: self.parse_indexed_light_point,
+                                        #111: self.parse_inline_light_point,
+                                        2: self.parse_group,
+                                        73: self.parse_lod,
+                                        4: self.parse_object,
+                                        10: self.parse_push,
+                                        11: self.parse_pop,
+                                        96: self.parse_unhandled,
+                                        14: self.parse_unhandled,
+                                        91: self.parse_unhandled,
+                                        98: self.parse_unhandled,
+                                        63: self.parse_xref})
+        self.props = dict.fromkeys(['type', 'id', 'comment', 'priority', 'flags', 'special1',
+                                    'special2', 'significance', 'layer code', 'loop count',
+                                    'loop duration', 'last frame duration'])
+        
+        self.props['type'] = 'Group'
+        self.props['comment'] = ''
+        self.props['id'] = self.header.fw.read_string(8)
+        self.props['priority'] = self.header.fw.read_short()
+        self.header.fw.read_ahead(2)
+        self.props['flags'] = self.header.fw.read_int()
+        self.props['special1'] = self.header.fw.read_short()
+        self.props['special2'] = self.header.fw.read_short()
+        self.props['significance'] = self.header.fw.read_short()
+        self.props['layer code'] = self.header.fw.read_char()
+        self.header.fw.read_ahead(5)
+        self.props['loop count'] = self.header.fw.read_int()
+        self.props['loop duration'] = self.header.fw.read_float()
+        self.props['last frame duration'] = self.header.fw.read_float()               
+
+class XRef(InterNode):
+    def parse(self):
+        if self.xref:
+            self.xref.parse()
+        Node.parse(self)
+
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+
+        self.root_handler.set_handler({49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        xref_filename = self.header.fw.read_string(200)
+        filename = FF.find(xref_filename)
+
+        self.props['type'] = 'XRef'
+        
+        if filename != None:
+            self.xref = Database(filename, self)
+            self.props['id'] = 'X: ' + Blender.sys.splitext(Blender.sys.basename(filename))[0]
+        else:
+            self.xref = None
+            self.props['id'] = 'X: broken'
+
+class LOD(InterNode):
+    def blender_import(self):
+        self.move_to_next_layer()
+        InterNode.blender_import(self)
+
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({2: self.parse_group,
+                                        73: self.parse_lod,
+                                        4: self.parse_object,
+                                        10: self.parse_push,
+                                        11: self.parse_pop,
+                                        96: self.parse_unhandled, # switch
+                                        14: self.parse_unhandled, # DOF
+                                        91: self.parse_unhandled, # sound
+                                        98: self.parse_unhandled, # clip
+                                        63: self.parse_xref})
+
+        self.props['type'] = 'LOD'
+        self.props['id'] = self.header.fw.read_string(8)
+
+class InlineLightPoint(InterNode):
+    # return dictionary: lp_app name => index list
+    def group_points(self, props):
+        
+        name_to_indices = {}
+        
+        for i in self.indices:
+            vert_desc = self.header.vert_pal.vert_desc_lst[i]
+            app_desc = LightPointAppDesc()
+            app_desc.props.update(props)
+            # add vertex normal and color
+            app_desc.props.update({'nx': vert_desc.nx})
+            app_desc.props.update({'ny': vert_desc.ny})
+            app_desc.props.update({'nz': vert_desc.nz})
+            
+            app_desc.props.update({'r': vert_desc.r})
+            app_desc.props.update({'g': vert_desc.g})
+            app_desc.props.update({'b': vert_desc.b})
+            app_desc.props.update({'a': vert_desc.a})
+            
+            app_name = GRR.request_lightpoint_app(app_desc)
+
+            if name_to_indices.get(app_name):
+                name_to_indices[app_name].append(i)
+            else:
+                name_to_indices.update({app_name: [i]})
+            
+        return name_to_indices
+        
+    def blender_import(self):
+        name = self.props['type'] + ': ' + self.props['id']
+
+        name_to_indices = self.group_points(self.app_props)
+
+        for app_name, indices in name_to_indices.items():
+            self.object = Blender.Object.New('Mesh', name)
+            self.mesh = self.object.getData()
+
+            if self.parent:
+                self.parent.object.makeParent([self.object])
+                
+            for i in indices:
+                vert = self.header.vert_pal.blender_verts[i]
+                self.mesh.verts.append(vert)
+            
+            scene.link(self.object)
+    
+            self.object.Layer = current_layer
+            
+            if self.matrix:
+                self.object.setMatrix(self.matrix)
+                
+            # Import comment.
+            if self.props['comment'] != '':
+                name = 'COMMENT: ' + self.props['id']
+                t = Blender.Text.New(name)
+                t.write(self.props['comment'])
+                self.props['comment'] = name
+                
+            # Attach properties.
+            self.props.update({'appearance': app_name})
+            for name, value in self.props.items():
+                self.object.addProperty(name, value)
+            
+            self.mesh.update()
+            
+    def parse_vertex_list(self):
+        length = self.header.fw.get_length()
+        fw = self.header.fw
+        vert_pal = self.header.vert_pal
+
+        count = (length-4)/4
+
+        for i in range(count):
+            byte_offset = fw.read_int()
+            if byte_offset in vert_pal.index:
+                index = vert_pal.index[byte_offset]
+                self.indices.append(index)
+            elif options.verbose >= 1:
+                print 'Warning: Unable to map byte offset %s' + \
+                      ' to vertex index.' % byte_offset
+      
+        return True
+        
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({72: self.parse_vertex_list,
+                                        10: self.parse_push,
+                                        11: self.parse_pop})
+
+        self.indices = []
+                
+        self.props = dict.fromkeys(['id', 'type', 'comment', 'draw order', 'appearance'])
+        self.app_props = dict()
+        
+        self.props['comment'] = ''
+        self.props['type'] = 'Light Point'
+        self.props['id'] = self.header.fw.read_string(8)
+        
+        self.app_props.update({'smc': self.header.fw.read_short()})
+        self.app_props.update({'fid': self.header.fw.read_short()})
+        self.app_props.update({'back color: a': self.header.fw.read_uchar()})
+        self.app_props.update({'back color: b': self.header.fw.read_uchar()})
+        self.app_props.update({'back color: g': self.header.fw.read_uchar()})
+        self.app_props.update({'back color: r': self.header.fw.read_uchar()})
+        self.app_props.update({'display mode': self.header.fw.read_int()})
+        self.app_props.update({'intensity': self.header.fw.read_float()})
+        self.app_props.update({'back intensity': self.header.fw.read_float()})
+        self.app_props.update({'minimum defocus': self.header.fw.read_float()})
+        self.app_props.update({'maximum defocus': self.header.fw.read_float()})
+        self.app_props.update({'fading mode': self.header.fw.read_int()})
+        self.app_props.update({'fog punch mode': self.header.fw.read_int()})
+        self.app_props.update({'directional mode': self.header.fw.read_int()})
+        self.app_props.update({'range mode': self.header.fw.read_int()})
+        self.app_props.update({'min pixel size': self.header.fw.read_float()})
+        self.app_props.update({'max pixel size': self.header.fw.read_float()})
+        self.app_props.update({'actual size': self.header.fw.read_float()})
+        self.app_props.update({'trans falloff pixel size': self.header.fw.read_float()})
+        self.app_props.update({'trans falloff exponent': self.header.fw.read_float()})
+        self.app_props.update({'trans falloff scalar': self.header.fw.read_float()})
+        self.app_props.update({'trans falloff clamp': self.header.fw.read_float()})
+        self.app_props.update({'fog scalar': self.header.fw.read_float()})
+        self.app_props.update({'fog intensity': self.header.fw.read_float()})
+        self.app_props.update({'size threshold': self.header.fw.read_float()})
+        self.app_props.update({'directionality': self.header.fw.read_int()})
+        self.app_props.update({'horizontal lobe angle': self.header.fw.read_float()})
+        self.app_props.update({'vertical lobe angle': self.header.fw.read_float()})
+        self.app_props.update({'lobe roll angle': self.header.fw.read_float()})
+        self.app_props.update({'dir falloff exponent': self.header.fw.read_float()})
+        self.app_props.update({'dir ambient intensity': self.header.fw.read_float()})
+        self.header.fw.read_ahead(12) # Animation settings.        
+        self.app_props.update({'significance': self.header.fw.read_float()})
+        self.props['draw order'] = self.header.fw.read_int()
+        self.app_props.update({'flags': self.header.fw.read_int()})
+        #self.fw.read_ahead(12) # More animation settings.                
+        
+class IndexedLightPoint(InterNode):
+    # return dictionary: lp_app name => index list
+    def group_points(self, props):
+        
+        name_to_indices = {}
+        
+        for i in self.indices:
+            vert_desc = self.header.vert_pal.vert_desc_lst[i]
+            app_desc = LightPointAppDesc()
+            app_desc.props.update(props)
+            # add vertex normal and color
+            app_desc.props.update({'nx': vert_desc.nx})
+            app_desc.props.update({'ny': vert_desc.ny})
+            app_desc.props.update({'nz': vert_desc.nz})
+            
+            app_desc.props.update({'r': vert_desc.r})
+            app_desc.props.update({'g': vert_desc.g})
+            app_desc.props.update({'b': vert_desc.b})
+            app_desc.props.update({'a': vert_desc.a})
+            
+            app_name = GRR.request_lightpoint_app(app_desc)
+
+            if name_to_indices.get(app_name):
+                name_to_indices[app_name].append(i)
+            else:
+                name_to_indices.update({app_name: [i]})
+            
+        return name_to_indices
+        
+    def blender_import(self):
+        name = self.props['type'] + ': ' + self.props['id']
+        
+        name_to_indices = self.group_points(self.header.lightpoint_appearance_pal[self.index])
+        
+        for app_name, indices in name_to_indices.items():        
+            self.object = Blender.Object.New('Mesh', name)
+            self.mesh = self.object.getData()
+            
+            if self.parent:
+                self.parent.object.makeParent([self.object])
+                
+            for i in indices:
+                vert = self.header.vert_pal.blender_verts[i]
+                self.mesh.verts.append(vert)
+            
+            scene.link(self.object)
+    
+            self.object.Layer = current_layer
+            
+            if self.matrix:
+                self.object.setMatrix(self.matrix)
+                
+            # Import comment.
+            if self.props['comment'] != '':
+                name = 'COMMENT: ' + self.props['id']
+                t = Blender.Text.New(name)
+                t.write(self.props['comment'])
+                self.props['comment'] = name
+                
+            # Attach properties.
+            self.props.update({'appearance': app_name})
+            for name, value in self.props.items():
+                self.object.addProperty(name, value)
+            
+            self.mesh.update()
+            
+    def parse_vertex_list(self):
+        length = self.header.fw.get_length()
+        fw = self.header.fw
+        vert_pal = self.header.vert_pal
+
+        count = (length-4)/4
+
+        for i in range(count):
+            byte_offset = fw.read_int()
+            if byte_offset in vert_pal.index:
+                index = vert_pal.index[byte_offset]
+                self.indices.append(index)
+            elif options.verbose >= 1:
+                print 'Warning: Unable to map byte offset %s' + \
+                      ' to vertex index.' % byte_offset
+      
+        return True
+        
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({72: self.parse_vertex_list,
+                                        10: self.parse_push,
+                                        11: self.parse_pop})
+
+        self.indices = []
+        
+        self.props = dict.fromkeys(['id', 'type', 'comment', 'draw order', 'appearance'])
+        self.props['comment'] = ''
+        self.props['type'] = 'Light Point'
+        self.props['id'] = self.header.fw.read_string(8)
+        self.index = self.header.fw.read_int()
+        self.header.fw.read_ahead(4) # animation index
+        self.props['draw order'] = self.header.fw.read_int()        
+
+class Unhandled(InterNode):
+    def __init__(self, parent):
+        Node.__init__(self, parent, parent.header)
+        InterNode.__init__(self)
+        
+        self.root_handler.set_handler({33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       10: self.parse_push,
+                                       49: self.parse_matrix})
+        self.root_handler.set_throw_back_lst(throw_back_opcodes)
+        
+        self.child_handler.set_handler({2: self.parse_group,
+                                        73: self.parse_lod,
+                                        4: self.parse_object,
+                                        10: self.parse_push,
+                                        11: self.parse_pop,
+                                        96: self.parse_unhandled, # switch
+                                        14: self.parse_unhandled, # DOF
+                                        91: self.parse_unhandled, # sound
+                                        98: self.parse_unhandled, # clip
+                                        63: self.parse_xref})
+
+        self.props['id'] = self.header.fw.read_string(8)
+
+class Database(InterNode):
+    def blender_import(self):
+        self.tex_pal = dict(self.tex_pal_lst)
+        del self.tex_pal_lst
+
+        # Setup Textures
+        bl_tex_pal_lst = []
+        for i in self.tex_pal.keys():
+            path_filename = FF.find(self.tex_pal[i])
+            if path_filename != None:
+                img = GRR.request_image(path_filename)
+                if img:
+                    tex = GRR.request_texture(img)
+                    tex.setName(FF.strip_path(self.tex_pal[i]))
+                    bl_tex_pal_lst.append( (i, tex) )
+                else:
+                    bl_tex_pal_lst.append( (i, None) )
+            elif options.verbose >= 1:
+                print 'Warning: Unable to find', self.tex_pal[i]
+
+        self.bl_tex_pal = dict(bl_tex_pal_lst)
+
+        # Setup Materials
+        self.mat_desc_pal = dict(self.mat_desc_pal_lst)
+
+        InterNode.blender_import(self)
+
+    def parse_appearance_palette(self):
+        props = dict()
+        self.fw.read_ahead(4) # reserved
+        props.update({'id': self.fw.read_string(256)})
+        index = self.fw.read_int()
+        props.update({'smc': self.fw.read_short()})
+        props.update({'fid': self.fw.read_short()})
+        props.update({'back color: a': self.fw.read_uchar()})
+        props.update({'back color: b': self.fw.read_uchar()})
+        props.update({'back color: g': self.fw.read_uchar()})
+        props.update({'back color: r': self.fw.read_uchar()})
+        props.update({'display mode': self.fw.read_int()})
+        props.update({'intensity': self.fw.read_float()})
+        props.update({'back intensity': self.fw.read_float()})
+        props.update({'minimum defocus': self.fw.read_float()})
+        props.update({'maximum defocus': self.fw.read_float()})
+        props.update({'fading mode': self.fw.read_int()})
+        props.update({'fog punch mode': self.fw.read_int()})
+        props.update({'directional mode': self.fw.read_int()})
+        props.update({'range mode': self.fw.read_int()})
+        props.update({'min pixel size': self.fw.read_float()})
+        props.update({'max pixel size': self.fw.read_float()})
+        props.update({'actual size': self.fw.read_float()})
+        props.update({'trans falloff pixel size': self.fw.read_float()})
+        props.update({'trans falloff exponent': self.fw.read_float()})
+        props.update({'trans falloff scalar': self.fw.read_float()})
+        props.update({'trans falloff clamp': self.fw.read_float()})
+        props.update({'fog scalar': self.fw.read_float()})
+        props.update({'fog intensity': self.fw.read_float()})
+        props.update({'size threshold': self.fw.read_float()})
+        props.update({'directionality': self.fw.read_int()})
+        props.update({'horizontal lobe angle': self.fw.read_float()})
+        props.update({'vertical lobe angle': self.fw.read_float()})
+        props.update({'lobe roll angle': self.fw.read_float()})
+        props.update({'dir falloff exponent': self.fw.read_float()})
+        props.update({'dir ambient intensity': self.fw.read_float()})
+        props.update({'significance': self.fw.read_float()})
+        props.update({'flags': self.fw.read_int()})
+        props.update({'visibility range': self.fw.read_float()})
+        props.update({'fade range ratio': self.fw.read_float()})
+        props.update({'fade in duration': self.fw.read_float()})
+        props.update({'fade out duration': self.fw.read_float()})
+        props.update({'LOD range ratio': self.fw.read_float()})
+        props.update({'LOD scale': self.fw.read_float()})
+        
+        self.lightpoint_appearance_pal.update({index: props})
+        
+    def parse_header(self):
+        self.props['type'] = 'Header'
+        self.props['comment'] = ''
+        self.props['id'] = self.fw.read_string(8)
+        self.props['version'] = self.fw.read_int()
+        self.fw.read_ahead(46)
+        self.props['units'] = self.fw.read_char()
+        self.props['set white'] = bool(self.fw.read_char())
+        self.props['flags'] = self.fw.read_int()
+        self.fw.read_ahead(24)
+        self.props['projection type'] = self.fw.read_int()
+        self.fw.read_ahead(36)
+        self.props['sw x'] = self.fw.read_double()
+        self.props['sw y'] = self.fw.read_double()
+        self.props['dx'] = self.fw.read_double()
+        self.props['dy'] = self.fw.read_double()
+        self.fw.read_ahead(24)
+        self.props['sw lat'] = self.fw.read_double()
+        self.props['sw lon'] = self.fw.read_double()
+        self.props['ne lat'] = self.fw.read_double()
+        self.props['ne lon'] = self.fw.read_double()
+        self.props['origin lat'] = self.fw.read_double()
+        self.props['origin lon'] = self.fw.read_double()
+        self.props['lambert lat1'] = self.fw.read_double()
+        self.props['lambert lat2'] = self.fw.read_double()
+        self.fw.read_ahead(16)
+        self.props['ellipsoid model'] = self.fw.read_int()
+        self.fw.read_ahead(4)
+        self.props['utm zone'] = self.fw.read_short()
+        self.fw.read_ahead(6)
+        self.props['dz'] = self.fw.read_double()
+        self.props['radius'] = self.fw.read_double()
+        self.fw.read_ahead(8)
+        self.props['major axis'] = self.fw.read_double()
+        self.props['minor axis'] = self.fw.read_double()
+        
+        if options.verbose >= 1:
+            print 'OpenFlight Version:', float(self.props['version']) / 100.0
+            print
+            
+        return True
+
+    def parse_mat_palette(self):
+        mat_desc = MaterialDesc()
+        index = self.fw.read_int()
+
+        name = self.fw.read_string(12)
+        if len(mat_desc.name) > 0:
+            mat_desc.name = name
+
+        flag = self.fw.read_int()
+        # skip material if not used
+        if not flag & 0x80000000:
+            return True
+
+        ambient_col = [self.fw.read_float(), self.fw.read_float(), self.fw.read_float()]
+        mat_desc.diffuse = [self.fw.read_float(), self.fw.read_float(), self.fw.read_float()]
+        mat_desc.specular = [self.fw.read_float(), self.fw.read_float(), self.fw.read_float()]
+        emissive_col = [self.fw.read_float(), self.fw.read_float(), self.fw.read_float()]
+
+        mat_desc.shininess = self.fw.read_float() / 64.0 # [0.0, 128.0] => [0.0, 2.0]
+        mat_desc.alpha = self.fw.read_float()
+
+        # Convert ambient and emissive colors into intensitities.
+        mat_desc.ambient = col_to_gray(ambient_col)
+        mat_desc.emissive = col_to_gray(emissive_col)
+
+        self.mat_desc_pal_lst.append( (index, mat_desc) )
+        
+        return True
+    
+    def get_color(self, color_index):
+        index = color_index / 128
+        intensity = float(color_index - 128.0 * index) / 127.0
+
+        if index >= 0 and index <= 1023:
+            brightest = self.col_pal[index]
+            r = int(brightest[0] * intensity)
+            g = int(brightest[1] * intensity)
+            b = int(brightest[2] * intensity)
+            #a = int(brightest[3] * intensity)
+            a = int(brightest[3])
+            
+            color = [r, g, b, a]
+            
+        return color
+    
+    def parse_color_palette(self):
+        self.header.fw.read_ahead(128)
+        for i in range(1024):
+            a = self.header.fw.read_uchar()
+            b = self.header.fw.read_uchar()
+            g = self.header.fw.read_uchar()
+            r = self.header.fw.read_uchar()
+            self.col_pal.append((r, g, b, a))
+        return True
+        
+    def parse_vertex_palette(self):
+        self.vert_pal = VertexPalette(self)
+        self.vert_pal.parse()
+        return True
+        
+    def parse_texture_palette(self):
+        name = self.fw.read_string(200)
+        index = self.fw.read_int()
+        self.tex_pal_lst.append( (index, name) )
+        return True
+        
+    def __init__(self, filename, parent=None):
+        if options.verbose >= 1:
+            print 'Parsing:', filename
+            print
+        
+        self.fw = FltIn(filename)
+        Node.__init__(self, parent, self)
+        InterNode.__init__(self)
+        
+        self.root_handler.set_handler({1: self.parse_header,
+                                       67: self.parse_vertex_palette,
+                                       33: self.parse_long_id,
+                                       31: self.parse_comment,
+                                       64: self.parse_texture_palette,
+                                       32: self.parse_color_palette,
+                                       113: self.parse_mat_palette,
+                                       128: self.parse_appearance_palette,
+                                       10: self.parse_push})
+        if parent:
+            self.root_handler.set_throw_back_lst(throw_back_opcodes)
+
+        self.child_handler.set_handler({#130: self.parse_indexed_light_point,
+                                        #111: self.parse_inline_light_point,
+                                        2: self.parse_group,
+                                        73: self.parse_lod,
+                                        4: self.parse_object,
+                                        10: self.parse_push,
+                                        11: self.parse_pop,
+                                        96: self.parse_unhandled,
+                                        14: self.parse_unhandled,
+                                        91: self.parse_unhandled,
+                                        98: self.parse_unhandled,
+                                        63: self.parse_xref})
+        
+        self.vert_pal = None
+        self.lightpoint_appearance_pal = dict()
+        self.tex_pal = dict()
+        self.tex_pal_lst = []
+        self.bl_tex_pal = dict()
+        self.col_pal = []
+        self.mat_desc_pal_lst = []
+        self.mat_desc_pal = dict()
+        self.props = dict.fromkeys(['id', 'type', 'comment', 'version', 'units', 'set white',
+            'flags', 'projection type', 'sw x', 'sw y', 'dx', 'dy', 'dz', 'sw lat',
+            'sw lon', 'ne lat', 'ne lon', 'origin lat', 'origin lon', 'lambert lat1',
+            'lambert lat2', 'ellipsoid model', 'utm zone', 'radius', 'major axis', 'minor axis'])
+
+def select_file(filename):
+    Blender.Window.WaitCursor(True)
+
+    if filename[-4:] != '.flt':
+        msg = 'Error: Not a flight file.'
+        Blender.Draw.PupMenu(msg)
+        print msg
+        print
+        return
+
+    if not Blender.sys.exists(filename):
+        msg = 'Error: File ' + filename + ' does not exist.'
+        Blender.Draw.PupMenu(msg)
+        return
+
+    FF.add_file_to_search_path(filename)
+    
+    if options.verbose >= 1:
+        print 'Pass 1: Loading.'
+        print
+
+    load_time = Blender.sys.time()    
+    db = Database(filename)
+    db.parse()
+    load_time = Blender.sys.time() - load_time
+
+    if options.verbose >= 1:
+        print
+        print 'Pass 2: Importing to Blender.'
+        print
+
+    import_time = Blender.sys.time()
+    db.blender_import()
+    import_time = Blender.sys.time() - import_time
+    
+    Blender.Window.ViewLayer(range(1,21))
+    Blender.Window.RedrawAll()
+        
+    if options.verbose >= 1:
+        print 'Done.'
+        print
+        print 'Time to parse file: %.3f seconds' % load_time
+        print 'Time to import to blender: %.3f seconds' % import_time
+        print 'Total time: %.3f seconds' % (load_time + import_time)
+    
+    Blender.Window.WaitCursor(False)
+
+
+if options.verbose >= 1:
+    print
+    print 'OpenFlight Importer'
+    print 'Version:', __version__
+    print 'Author: Greg MacDonald'
+    print __url__[2]
+    print
+
+Blender.Window.EditMode(0)
+
+winid = Blender.Window.GetScreenInfo(Blender.Window.Types.VIEW3D)[0]['id']
+
+Blender.Window.FileSelector(select_file, "Import OpenFlight", "*.flt")