-> LOD and DOF editor scripts
authorGeoffrey Bantle <hairbat@yahoo.com>
Wed, 20 Aug 2008 19:10:33 +0000 (19:10 +0000)
committerGeoffrey Bantle <hairbat@yahoo.com>
Wed, 20 Aug 2008 19:10:33 +0000 (19:10 +0000)
 Two new scripts for the 'Misc' Menu. LOD and DOF
 Editors for creating/editing DOF and LOD FLT nodes
 inside of blender.

release/scripts/flt_dofedit.py [new file with mode: 0644]
release/scripts/flt_lodedit.py [new file with mode: 0644]
release/scripts/flt_properties.py

diff --git a/release/scripts/flt_dofedit.py b/release/scripts/flt_dofedit.py
new file mode 100644 (file)
index 0000000..a01883d
--- /dev/null
@@ -0,0 +1,834 @@
+#!BPY
+
+"""
+Name: 'FLT DOF Editor'
+Blender: 240
+Group: 'Misc'
+Tooltip: 'Degree of Freedom editor for FLT nodes'
+"""
+
+__author__ = "Geoffrey Bantle"
+__version__ = "1.0 11/21/07"
+__email__ = ('scripts', 'Author, ')
+__url__ = ('blender', 'blenderartists.org')
+
+__bpydoc__ ="""\
+This script provides tools for working with OpenFlight databases in Blender. OpenFlight is a
+registered trademark of MultiGen-Paradigm, Inc.
+
+Feature overview and more availible at:
+http://wiki.blender.org/index.php/Scripts/Manual/FLTools
+"""
+
+# --------------------------------------------------------------------------
+# flt_palettemanager.py version 0.1 2005/04/08
+# --------------------------------------------------------------------------
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# Copyright (C) 2007: Blender Foundation
+#
+# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# ***** END GPL LICENCE BLOCK *****
+# --------------------------------------------------------------------------
+
+import Blender.Draw as Draw
+from Blender.BGL import *
+import Blender
+import flt_properties
+reload(flt_properties)
+from flt_properties import *
+
+#event codes
+evcode = {
+       "DOF_MAKE" : 100,
+       "DOF_UPDATE" : 138,
+       "DOF_DELETE" : 101,
+       "DOF_TRANSX" : 102,
+       "DOF_TRANSY" : 103,
+       "DOF_TRANSZ" : 104,
+       "DOF_ROTX" : 105,
+       "DOF_ROTY" : 106,
+       "DOF_ROTZ" : 107,
+       "DOF_SCALEX" : 108,
+       "DOF_SCALEY" : 109,
+       "DOF_SCALEZ" : 110,
+       "DOF_MIN_TRANSX" : 111,
+       "DOF_MIN_TRANSY" : 112,
+       "DOF_MIN_TRANSZ" : 113,
+       "DOF_MIN_ROTX" : 114,
+       "DOF_MIN_ROTY" : 115,
+       "DOF_MIN_ROTZ" : 116,
+       "DOF_MIN_SCALEX" : 117,
+       "DOF_MIN_SCALEY" : 118,
+       "DOF_MIN_SCALEZ" : 119,
+       "DOF_MAX_TRANSX" : 120,
+       "DOF_MAX_TRANSY" : 121,
+       "DOF_MAX_TRANSZ" : 122,
+       "DOF_MAX_ROTX" : 123,
+       "DOF_MAX_ROTY" : 124,
+       "DOF_MAX_ROTZ" : 125,
+       "DOF_MAX_SCALEX" : 126,
+       "DOF_MAX_SCALEY" : 127,
+       "DOF_MAX_SCALEZ" : 128,
+       "DOF_STEP_TRANSX" : 129,
+       "DOF_STEP_TRANSY" : 130,
+       "DOF_STEP_TRANSZ" : 131,
+       "DOF_STEP_ROTX" : 132,
+       "DOF_STEP_ROTY" : 133,
+       "DOF_STEP_ROTZ" : 134,
+       "DOF_STEP_SCALEX" : 135,
+       "DOF_STEP_SCALEY" : 136,
+       "DOF_STEP_SCALEZ" : 137
+}
+
+#system
+DOF_MAKE = None
+DOF_UPDATE = None
+DOF_DELETE = None
+
+#toggle buttons
+DOF_TRANSX = None
+DOF_TRANSY = None
+DOF_TRANSZ = None
+DOF_ROTX = None
+DOF_ROTY = None
+DOF_ROTZ = None
+DOF_SCALEX = None
+DOF_SCALEY = None
+DOF_SCALEZ = None
+
+#Minimums
+DOF_MIN_TRANSX = None
+DOF_MIN_TRANSY = None
+DOF_MIN_TRANSZ = None
+DOF_MIN_ROTX = None
+DOF_MIN_ROTY = None
+DOF_MIN_ROTZ = None
+DOF_MIN_SCALEX = None
+DOF_MIN_SCALEY = None
+DOF_MIN_SCALEZ = None
+
+#maximums
+DOF_MAX_TRANSX = None
+DOF_MAX_TRANSY = None
+DOF_MAX_TRANSZ = None
+DOF_MAX_ROTX = None
+DOF_MAX_ROTY = None
+DOF_MAX_ROTZ = None
+DOF_MAX_SCALEX = None
+DOF_MAX_SCALEY = None
+DOF_MAX_SCALEZ = None
+
+#step
+DOF_STEP_TRANSX = None
+DOF_STEP_TRANSY = None
+DOF_STEP_TRANSZ = None
+DOF_STEP_ROTX = None
+DOF_STEP_ROTY = None
+DOF_STEP_ROTZ = None
+DOF_STEP_SCALEX = None
+DOF_STEP_SCALEY = None
+DOF_STEP_SCALEZ = None
+
+#labels
+DOF_ROTSTRING = None
+DOF_TRANSTRING = None
+DOF_SCALESTRING = None
+DOF_EDITLABEL = None
+
+#make ID props easier/morereadable
+zmin = '14d!ZMIN'
+zmax = '15d!ZMAX'
+zcur = '16d!ZCUR'
+zstep = '17d!ZSTEP'
+ymin = '18d!YMIN'
+ymax = '19d!YMAX'
+ycur = '20d!YCUR'
+ystep = '21d!YSTEP'
+xmin = '22d!XMIN'
+xmax = '23d!XMAX'
+xcur = '24d!XCUR'
+xstep = '25d!XSTEP'
+pitchmin = '26d!PITCH-MIN'
+pitchmax = '27d!PITCH-MAX'
+pitchcur = '28d!PITCH-CUR'
+pitchstep = '29d!PITCH-STEP'
+rollmin = '30d!ROLL-MIN'
+rollmax = '31d!ROLL-MAX'
+rollcur = '32d!ROLL-CUR'
+rollstep = '33d!ROLL-STEP'
+yawmin = '34d!YAW-MIN'
+yawmax = '35d!YAW-MAX'
+yawcur = '36d!YAW-CUR'
+yawstep = '37d!YAW-STEP'
+zscalemin = '38d!ZSIZE-MIN'
+zscalemax = '39d!ZSIZE-MAX'
+zscalecur = '40d!ZSIZE-CUR'
+zscalestep = '41d!ZSIZE-STEP'
+yscalemin = '42d!YSIZE-MIN'
+yscalemax = '43d!YSIZE-MAX'
+yscalecur = '44d!YSIZE-CUR'
+yscalestep = '45d!YSIZE-STEP'
+xscalemin = '46d!XSIZE-MIN'
+xscalemax = '47d!XSIZE-MAX'
+xscalecur = '48d!XSIZE-CUR'
+xscalestep = '49d!XSIZE-STEP'
+
+
+
+def update_state():
+       state = dict()
+       state["activeScene"] = Blender.Scene.GetCurrent()
+       state["activeObject"] = state["activeScene"].objects.active
+       if state["activeObject"] and not state["activeObject"].sel:
+               state["activeObject"] = None
+       state["activeMesh"] = None
+       if state["activeObject"] and state["activeObject"].type == 'Mesh':
+               state["activeMesh"] = state["activeObject"].getData(mesh=True)
+       
+
+       state["activeFace"] = None
+       if state["activeMesh"]:
+               if state["activeMesh"].faceUV and state["activeMesh"].activeFace != None:
+                       state["activeFace"] = state["activeMesh"].faces[state["activeMesh"].activeFace]
+               
+               
+       #update editmode
+       state["editmode"]       = Blender.Window.EditMode()
+
+       return state
+       
+def idprops_append(object, typecode, props):
+       object.properties["FLT"] = dict()
+       object.properties["FLT"]['type'] = typecode 
+       for prop in props:
+               object.properties["FLT"][prop] = props[prop]
+       object.properties["FLT"]['3t8!id'] = object.name
+
+def idprops_kill():
+       state = update_state()
+       if state["activeObject"] and state["activeObject"].properties.has_key('FLT'):
+               state["activeObject"].properties.pop('FLT')
+
+def idprops_copy(source):
+       state = update_state()
+       if source.properties.has_key('FLT'):
+               for object in state["activeScene"].objects:
+                       if object.sel and object != source and (state["activeScene"].Layers & object.Layers):
+                               idprops_kill(object)
+                               object.properties['FLT'] = dict()
+                               for key in source.properties['FLT']:
+                                       object.properties['FLT'][key] = source.properties['FLT'][key]
+
+def select_by_typecode(typecode):
+       state = update_state()
+       
+       for object in state["activeScene"].objects:
+               if object.properties.has_key('FLT') and object.properties['FLT']['type'] == typecode and state["activeScene"].Layers & object.Layers:
+                               object.select(1)
+
+def DOF_get_frame():
+       state = update_state()
+       
+       if not state["activeObject"] and not id_props_type(state["activeObject"], 14):
+               return
+       
+       #Warning! assumes 1 BU == 10 meters.
+       #do origin
+       state["activeObject"].properties['FLT']['5d!ORIGX'] = state["activeObject"].getLocation('worldspace')[0]*10.0
+       state["activeObject"].properties['FLT']['6d!ORIGY'] = state["activeObject"].getLocation('worldspace')[1]*10.0
+       state["activeObject"].properties['FLT']['7d!ORIGZ'] = state["activeObject"].getLocation('worldspace')[2]*10.0
+       #do X axis
+       x = Blender.Mathutils.Vector(1.0,0.0,0.0)
+       x = x * state["activeObject"].getMatrix('worldspace')
+       x = x * 10.0
+       state["activeObject"].properties['FLT']['8d!XAXIS-X'] = x[0]
+       state["activeObject"].properties['FLT']['9d!XAXIS-Y'] = x[1]
+       state["activeObject"].properties['FLT']['10d!XAXIS-Z'] = x[2]
+       #do X/Y plane
+       x = Blender.Mathutils.Vector(0.0,1.0,0.0)
+       x.normalize()
+       x = x * state["activeObject"].getMatrix('worldspace')
+       x = x * 10.0
+       state["activeObject"].properties['FLT']['11d!XYPLANE-X'] = x[0]
+       state["activeObject"].properties['FLT']['12d!XYPLANE-Y'] = x[1]
+       state["activeObject"].properties['FLT']['13d!XZPLANE-Z'] = x[2]
+
+def idprops_type(object, typecode):
+       if object.properties.has_key('FLT') and object.properties['FLT'].has_key('type') and object.properties['FLT']['type'] == typecode:
+               return True
+       return False
+
+#ui type code
+def get_prop(typecode, prop):
+       
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], typecode):
+               props = state["activeObject"].properties['FLT']
+       else:
+               props =  flt_properties.FLTDOF
+               
+       return props[prop]      
+
+def set_prop(typecode, prop, value):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"],typecode):
+               state["activeObject"].properties['FLT'][prop] = value           
+
+lockxtrans = (1 << 31)
+lockytrans = (1 << 30)
+lockztrans = (1 << 29)
+lockxrot = (1 << 28)
+lockyrot = (1 << 27)
+lockzrot = (1 << 26)
+lockxscale = (1 << 25)
+lockyscale = (1 << 24)
+lockzscale = (1 << 23)
+
+def get_lockmask(mask):        
+       state = update_state()
+       if state["activeObject"]:
+               flag = get_prop(14,'50I!FLAG')
+               if flag & mask:
+                       return True
+       return False    
+
+def set_lockmask(mask):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 14):
+               oldvalue = state["activeObject"].properties['FLT']['50I!FLAG']
+               oldvalue = struct.unpack('>I', struct.pack('>i', oldvalue))[0]
+               oldvalue |= mask
+               state["activeObject"].properties['FLT']['50I!FLAG'] = struct.unpack('>i', struct.pack(">I", oldvalue))[0]
+
+def clear_lockmask(mask):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 14):
+               oldvalue = state["activeObject"].properties['FLT']['50I!FLAG']
+               oldvalue = struct.unpack('>I', struct.pack('>i', oldvalue))[0]
+               oldvalue &= ~mask
+               state["activeObject"].properties['FLT']['50I!FLAG'] = struct.unpack('>i',struct.pack('>I',oldvalue))[0] 
+
+       
+def create_dof():
+       state = update_state()
+       actobj = state["activeObject"]
+       if actobj and not idprops_type(actobj, 14):
+               idprops_kill()
+               idprops_append(actobj,14, flt_properties.FLTDOF)
+               DOF_get_frame()
+       
+               
+def event(evt,val):
+       if evt == Draw.ESCKEY:
+               Draw.Exit()
+               
+def but_event(evt):
+       global DOF_MAKE
+       global DOF_UPDATE
+       global DOF_DELETE
+
+       global DOF_TRANSX
+       global DOF_TRANSY
+       global DOF_TRANSZ
+       global DOF_ROTX
+       global DOF_ROTY
+       global DOF_ROTZ
+       global DOF_SCALEX
+       global DOF_SCALEY
+       global DOF_SCALEZ
+
+       global DOF_MIN_TRANSX
+       global DOF_MIN_TRANSY
+       global DOF_MIN_TRANSZ
+       global DOF_MIN_ROTX
+       global DOF_MIN_ROTY
+       global DOF_MIN_ROTZ
+       global DOF_MIN_SCALEX
+       global DOF_MIN_SCALEY
+       global DOF_MIN_SCALEZ
+
+       global DOF_MAX_TRANSX
+       global DOF_MAX_TRANSY
+       global DOF_MAX_TRANSZ
+       global DOF_MAX_ROTX
+       global DOF_MAX_ROTY
+       global DOF_MAX_ROTZ
+       global DOF_MAX_SCALEX
+       global DOF_MAX_SCALEY
+       global DOF_MAX_SCALEZ
+
+       global DOF_STEP_TRANSX
+       global DOF_STEP_TRANSY
+       global DOF_STEP_TRANSZ
+       global DOF_STEP_ROTX
+       global DOF_STEP_ROTY
+       global DOF_STEP_ROTZ
+       global DOF_STEP_SCALEX
+       global DOF_STEP_SCALEY
+       global DOF_STEP_SCALEZ
+       
+       #labels
+       global DOF_ROTSTRING
+       global DOF_TRANSTRING
+       global DOF_SCALESTRING
+       
+       
+       #masks
+       global lockxtrans
+       global lockytrans
+       global lockztrans
+       global lockxrot
+       global lockyrot
+       global lockzrot
+       global lockxscale
+       global lockyscale
+       global lockzscale
+
+       global zmin
+       global zmax
+       global zcur
+       global zstep
+       global ymin
+       global ymax
+       global ycur
+       global ystep
+       global xmin
+       global xmax
+       global xcur
+       global xstep
+       global pitchmin
+       global pitchmax
+       global pitchcur
+       global pitchstep
+       global rollmin
+       global rollmax
+       global rollcur
+       global rollstep
+       global yawmin
+       global yawmax
+       global yawcur
+       global yawstep
+       global zscalemin
+       global zscalemax
+       global zscalecur
+       global zscalestep
+       global yscalemin
+       global yscalemax
+       global yscalecur
+       global yscalestep
+       global xscalemin
+       global xscalemax
+       global xscalecur
+       global xscalestep       
+
+       
+       
+       #do "system" events
+       if evt == evcode["DOF_MAKE"]:
+               create_dof()
+
+       if evt == evcode["DOF_UPDATE"]:
+               DOF_get_frame()
+       
+       if evt == evcode["DOF_DELETE"]:
+               idprops_kill()
+       #do translation lock events
+       if evt == evcode["DOF_TRANSX"]:
+               if DOF_TRANSX.val == True:
+                       set_lockmask(lockxtrans)
+               else:
+                       clear_lockmask(lockxtrans)
+
+       if evt == evcode["DOF_TRANSY"]:
+               if DOF_TRANSY.val == True:
+                       set_lockmask(lockytrans)
+               else:
+                       clear_lockmask(lockytrans)
+
+       if evt == evcode["DOF_TRANSZ"]:
+               if DOF_TRANSZ.val == True:
+                       set_lockmask(lockztrans)
+               else:
+                       clear_lockmask(lockztrans)
+
+
+       #do rotation lock events
+       if evt == evcode["DOF_ROTX"]:
+               if DOF_ROTX.val == True:
+                       set_lockmask(lockxrot)
+               else:
+                       clear_lockmask(lockxrot)
+
+       if evt == evcode["DOF_ROTY"]:
+               if DOF_ROTY.val == True:
+                       set_lockmask(lockyrot)
+               else:
+                       clear_lockmask(lockyrot)
+
+       if evt == evcode["DOF_ROTZ"]:
+               if DOF_ROTZ.val == True:
+                       set_lockmask(lockzrot)
+               else:
+                       clear_lockmask(lockzrot)
+
+       #do scale lock events
+       if evt == evcode["DOF_SCALEX"]:
+               if DOF_SCALEX.val == True:
+                       set_lockmask(lockxscale)
+               else:
+                       clear_lockmask(lockxscale)
+
+       if evt == evcode["DOF_SCALEY"]:
+               if DOF_SCALEY.val == True:
+                       set_lockmask(lockyscale)
+               else:
+                       clear_lockmask(lockyscale)
+
+       if evt == evcode["DOF_SCALEZ"]:
+               if DOF_SCALEZ.val == True:
+                       set_lockmask(lockzscale)
+               else:
+                       clear_lockmask(lockzscale)
+                       
+       
+       #do translation buttons
+       if evt == evcode["DOF_MIN_TRANSX"]:
+               set_prop(14, xmin, DOF_MIN_TRANSX.val)
+       if evt == evcode["DOF_MAX_TRANSX"]:
+               set_prop(14,xmax, DOF_MAX_TRANSX.val)
+       if evt == evcode["DOF_STEP_TRANSX"]:
+               set_prop(14,xstep, DOF_STEP_TRANSX.val)
+               
+       if evt == evcode["DOF_MIN_TRANSY"]:
+               set_prop(14, ymin, DOF_MIN_TRANSY.val)
+       if evt == evcode["DOF_MAX_TRANSY"]:
+               set_prop(14,ymax, DOF_MAX_TRANSY.val)
+       if evt == evcode["DOF_STEP_TRANSY"]:
+               set_prop(14,ystep, DOF_STEP_TRANSY.val)
+               
+       if evt == evcode["DOF_MIN_TRANSZ"]:
+               set_prop(14, zmin, DOF_MIN_TRANSZ.val)
+       if evt == evcode["DOF_MAX_TRANSZ"]:
+               set_prop(14, zmax, DOF_MAX_TRANSZ.val)
+       if evt == evcode["DOF_STEP_TRANSZ"]:
+               set_prop(14, zstep, DOF_STEP_TRANSZ.val)
+
+       #do rotation buttons
+       if evt == evcode["DOF_MIN_ROTX"]:
+               set_prop(14, pitchmin, DOF_MIN_ROTX.val)
+       if evt == evcode["DOF_MAX_ROTX"]:
+               set_prop(14, pitchmax, DOF_MAX_ROTX.val)
+       if evt == evcode["DOF_STEP_ROTX"]:
+               set_prop(14, pitchstep, DOF_STEP_ROTX.val)
+
+       if evt == evcode["DOF_MIN_ROTY"]:
+               set_prop(14, rollmin, DOF_MIN_ROTY.val)
+       if evt == evcode["DOF_MAX_ROTY"]:
+               set_prop(14, rollmax, DOF_MAX_ROTY.val)
+       if evt == evcode["DOF_STEP_ROTY"]:
+               set_prop(14, rollstep, DOF_STEP_ROTY.val)       
+
+       if evt == evcode["DOF_MIN_ROTZ"]:
+               set_prop(14, yawmin, DOF_MIN_ROTZ.val)
+       if evt == evcode["DOF_MAX_ROTZ"]:
+               set_prop(14, yawmax, DOF_MAX_ROTZ.val)
+       if evt == evcode["DOF_STEP_ROTZ"]:
+               set_prop(14, yawstep, DOF_STEP_ROTZ.val)        
+               
+       #do scale buttons
+       if evt == evcode["DOF_MIN_SCALEX"]:
+               set_prop(14, xscalemin, DOF_MIN_SCALEX.val)
+       if evt == evcode["DOF_MAX_SCALEX"]:
+               set_prop(14, xscalemax, DOF_MAX_SCALEX.val)
+       if evt == evcode["DOF_STEP_SCALEX"]:
+               set_prop(14, xscalestep, DOF_STEP_SCALEX.val)
+       
+       if evt == evcode["DOF_MIN_SCALEY"]:
+               set_prop(14, yscalemin, DOF_MIN_SCALEY.val)
+       if evt == evcode["DOF_MAX_SCALEY"]:
+               set_prop(14, yscalemax, DOF_MAX_SCALEY.val)
+       if evt == evcode["DOF_STEP_SCALEY"]:
+               set_prop(14, yscalestep, DOF_STEP_SCALEY.val)   
+
+       if evt == evcode["DOF_MIN_SCALEZ"]:
+               set_prop(14, zscalemin, DOF_MIN_SCALEZ.val)
+       if evt == evcode["DOF_MAX_SCALEZ"]:
+               set_prop(14, zscalemax, DOF_MAX_SCALEZ.val)
+       if evt == evcode["DOF_STEP_SCALEZ"]:
+               set_prop(14, zscalestep, DOF_STEP_SCALEZ.val)
+
+
+       Draw.Redraw(1)
+       Blender.Window.RedrawAll()
+
+def draw_propsheet(x,y):
+       #UI buttons
+       global DOF_MAKE
+       global DOF_UPDATE
+       global DOF_DELETE
+
+       global DOF_TRANSX
+       global DOF_TRANSY
+       global DOF_TRANSZ
+       global DOF_ROTX
+       global DOF_ROTY
+       global DOF_ROTZ
+       global DOF_SCALEX
+       global DOF_SCALEY
+       global DOF_SCALEZ
+
+       global DOF_MIN_TRANSX
+       global DOF_MIN_TRANSY
+       global DOF_MIN_TRANSZ
+       global DOF_MIN_ROTX
+       global DOF_MIN_ROTY
+       global DOF_MIN_ROTZ
+       global DOF_MIN_SCALEX
+       global DOF_MIN_SCALEY
+       global DOF_MIN_SCALEZ
+
+       global DOF_MAX_TRANSX
+       global DOF_MAX_TRANSY
+       global DOF_MAX_TRANSZ
+       global DOF_MAX_ROTX
+       global DOF_MAX_ROTY
+       global DOF_MAX_ROTZ
+       global DOF_MAX_SCALEX
+       global DOF_MAX_SCALEY
+       global DOF_MAX_SCALEZ
+
+       global DOF_STEP_TRANSX
+       global DOF_STEP_TRANSY
+       global DOF_STEP_TRANSZ
+       global DOF_STEP_ROTX
+       global DOF_STEP_ROTY
+       global DOF_STEP_ROTZ
+       global DOF_STEP_SCALEX
+       global DOF_STEP_SCALEY
+       global DOF_STEP_SCALEZ
+
+       #labels
+       global DOF_ROTSTRING
+       global DOF_TRANSTRING
+       global DOF_SCALESTRING  
+       global DOF_EDITLABEL
+       
+       #masks
+       global lockxtrans
+       global lockytrans
+       global lockztrans
+       global lockxrot
+       global lockyrot
+       global lockzrot
+       global lockxscale
+       global lockyscale
+       global lockzscale
+       
+       global zmin
+       global zmax
+       global zcur
+       global zstep
+       global ymin
+       global ymax
+       global ycur
+       global ystep
+       global xmin
+       global xmax
+       global xcur
+       global xstep
+       global pitchmin
+       global pitchmax
+       global pitchcur
+       global pitchstep
+       global rollmin
+       global rollmax
+       global rollcur
+       global rollstep
+       global yawmin
+       global yawmax
+       global yawcur
+       global yawstep
+       global zscalemin
+       global zscalemax
+       global zscalecur
+       global zscalestep
+       global yscalemin
+       global yscalemax
+       global yscalecur
+       global yscalestep
+       global xscalemin
+       global xscalemax
+       global xscalecur
+       global xscalestep       
+
+       
+       global evcode
+       
+       state = update_state()
+       
+       row_height = 20
+       toggle_width = 50
+       input_width = 100
+       pad = 10
+       origx = x
+       origy = y
+
+
+       #editor label
+       x = origx
+       y = y - (row_height + pad)
+       DOF_EDITLABEL = Blender.Draw.Label("FLT Degree of Freedom Editor", x, y, 200, row_height)
+
+
+       #draw Translation limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_TRANSTRING = Blender.Draw.Label("Translation Limits", x, y, input_width, row_height)
+
+
+       #X limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_TRANSX = Blender.Draw.Toggle("LimX", evcode["DOF_TRANSX"], x, y, toggle_width, row_height, get_lockmask(lockxtrans), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_TRANSX = Blender.Draw.Number("MinX", evcode["DOF_MIN_TRANSX"], x, y, input_width, row_height,get_prop(14,xmin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_TRANSX = Blender.Draw.Number("MaxX", evcode["DOF_MAX_TRANSX"], x, y, input_width, row_height,get_prop(14,xmax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_TRANSX = Blender.Draw.Number("StepX", evcode["DOF_STEP_TRANSX"], x, y, input_width, row_height,get_prop(14,xstep), -100.0, 100.0, "")
+       
+       #Y limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_TRANSY = Blender.Draw.Toggle("LimY", evcode["DOF_TRANSY"], x, y, toggle_width, row_height, get_lockmask(lockytrans), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_TRANSY = Blender.Draw.Number("MinY", evcode["DOF_MIN_TRANSY"], x, y, input_width, row_height, get_prop(14,ymin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_TRANSY = Blender.Draw.Number("MaxY", evcode["DOF_MAX_TRANSY"], x, y, input_width, row_height, get_prop(14,ymax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_TRANSY = Blender.Draw.Number("StepY", evcode["DOF_STEP_TRANSY"], x, y, input_width, row_height, get_prop(14,ystep), -100.0, 100.0, "") 
+       
+       #Z limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_TRANSZ = Blender.Draw.Toggle("LimZ", evcode["DOF_TRANSZ"], x, y, toggle_width, row_height, get_lockmask(lockztrans), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_TRANSZ = Blender.Draw.Number("MinZ", evcode["DOF_MIN_TRANSZ"], x, y, input_width, row_height, get_prop(14,zmin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_TRANSZ = Blender.Draw.Number("MaxZ", evcode["DOF_MAX_TRANSZ"], x, y, input_width, row_height, get_prop(14,zmax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_TRANSZ = Blender.Draw.Number("StepZ", evcode["DOF_STEP_TRANSZ"], x, y, input_width, row_height, get_prop(14,zstep), -100.0, 100.0, "")
+       
+       #draw Rotation limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_ROTSTRING = Blender.Draw.Label("Rotation Limits", x, y, input_width, row_height)
+
+       #draw Rotation limits
+       #X limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_ROTX = Blender.Draw.Toggle("LimX", evcode["DOF_ROTX"], x, y, toggle_width, row_height, get_lockmask(lockxrot), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_ROTX = Blender.Draw.Number("MinX", evcode["DOF_MIN_ROTX"], x, y, input_width, row_height, get_prop(14,pitchmin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_ROTX = Blender.Draw.Number("MaxX", evcode["DOF_MAX_ROTX"], x, y, input_width, row_height, get_prop(14,pitchmax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_ROTX = Blender.Draw.Number("StepX", evcode["DOF_STEP_ROTX"], x, y, input_width, row_height, get_prop(14,pitchstep), -100.0, 100.0, "")
+               
+       #Y limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_ROTY = Blender.Draw.Toggle("LimY", evcode["DOF_ROTY"], x, y, toggle_width, row_height, get_lockmask(lockyrot), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_ROTY = Blender.Draw.Number("MinY", evcode["DOF_MIN_ROTY"], x, y, input_width, row_height, get_prop(14,rollmin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_ROTY = Blender.Draw.Number("MaxY", evcode["DOF_MAX_ROTY"], x, y, input_width, row_height, get_prop(14,rollmax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_ROTY = Blender.Draw.Number("StepY", evcode["DOF_STEP_ROTY"], x, y, input_width, row_height, get_prop(14,rollstep), -100.0, 100.0, "")
+               
+       #Z limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_ROTZ = Blender.Draw.Toggle("LimZ", evcode["DOF_ROTZ"], x, y, toggle_width, row_height, get_lockmask(lockzrot), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_ROTZ = Blender.Draw.Number("MinZ", evcode["DOF_MIN_ROTZ"], x, y, input_width, row_height, get_prop(14, yawmin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_ROTZ = Blender.Draw.Number("MaxZ", evcode["DOF_MAX_ROTZ"], x, y, input_width, row_height, get_prop(14, yawmax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_ROTZ = Blender.Draw.Number("StepZ", evcode["DOF_STEP_ROTZ"], x, y, input_width, row_height, get_prop(14, yawstep), -100.0, 100.0, "")
+                       
+
+       #draw Scale limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_SCALESTRING = Blender.Draw.Label("Scale Limits", x, y, input_width, row_height)
+
+       #draw Scale limits
+       #X limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_SCALEX = Blender.Draw.Toggle("LimX", evcode["DOF_SCALEX"], x, y, toggle_width, row_height, get_lockmask(lockxscale), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_SCALEX = Blender.Draw.Number("MinX", evcode["DOF_MIN_SCALEX"], x, y, input_width, row_height, get_prop(14, xscalemin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_SCALEX = Blender.Draw.Number("MaxX", evcode["DOF_MAX_SCALEX"], x, y, input_width, row_height, get_prop(14, xscalemax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_SCALEX = Blender.Draw.Number("StepX", evcode["DOF_STEP_SCALEX"], x, y, input_width, row_height, get_prop(14, xscalestep), -100.0, 100.0, "")
+               
+       #Y limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_SCALEY = Blender.Draw.Toggle("LimY", evcode["DOF_SCALEY"], x, y, toggle_width, row_height, get_lockmask(lockyscale), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_SCALEY = Blender.Draw.Number("MinY", evcode["DOF_MIN_SCALEY"], x, y, input_width, row_height, get_prop(14, yscalemin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_SCALEY = Blender.Draw.Number("MaxY", evcode["DOF_MAX_SCALEY"], x, y, input_width, row_height, get_prop(14, yscalemax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_SCALEY = Blender.Draw.Number("StepY", evcode["DOF_STEP_SCALEY"], x, y, input_width, row_height, get_prop(14, yscalestep), -100.0, 100.0, "")           
+
+       #Z limits
+       x = origx
+       y = y- (row_height + pad)
+       DOF_SCALEZ = Blender.Draw.Toggle("LimZ", evcode["DOF_SCALEZ"], x, y, toggle_width, row_height, get_lockmask(lockzscale), "")
+       x = x + (toggle_width + pad)
+       DOF_MIN_SCALEZ = Blender.Draw.Number("MinZ", evcode["DOF_MIN_SCALEZ"], x, y, input_width, row_height, get_prop(14, zscalemin),  -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_MAX_SCALEZ = Blender.Draw.Number("MaxZ", evcode["DOF_MAX_SCALEZ"], x, y, input_width, row_height, get_prop(14, zscalemax), -100.0, 100.0, "")
+       x = x + (input_width + pad)
+       DOF_STEP_SCALEZ = Blender.Draw.Number("StepZ", evcode["DOF_STEP_SCALEZ"], x, y, input_width, row_height, get_prop(14, zscalestep), -100.0, 100.0, "")           
+
+       #System
+       x = origx
+       y = y - (row_height + (pad)*3)
+       DOF_MAKE = Blender.Draw.PushButton("Make DOF", evcode["DOF_MAKE"], x, y, input_width, row_height, "Make a Dof Node out of Active Object")
+       x = x + (input_width + pad)
+       DOF_UPDATE = Blender.Draw.PushButton("Grab Loc/Rot", evcode["DOF_UPDATE"], x, y, input_width, row_height, "Update the Dof Node position/orientation")
+       x = x + (input_width + pad)
+       DOF_DELETE = Blender.Draw.PushButton("Delete DOF", evcode["DOF_DELETE"], x, y, input_width, row_height, "Delete the Dof Node properties")
+
+
+       
+       
+def gui():
+       #draw the propsheet/toolbox.
+       psheety = 800
+       #psheetx = psheety + 10
+       draw_propsheet(20,psheety)
+
+Draw.Register(gui,event,but_event)
+       
\ No newline at end of file
diff --git a/release/scripts/flt_lodedit.py b/release/scripts/flt_lodedit.py
new file mode 100644 (file)
index 0000000..8860d6d
--- /dev/null
@@ -0,0 +1,518 @@
+#!BPY
+
+"""
+Name: 'FLT LOD Editor'
+Blender: 240
+Group: 'Misc'
+Tooltip: 'Level of Detail Edtior for FLT nodes'
+"""
+
+__author__ = "Geoffrey Bantle"
+__version__ = "1.0 11/21/07"
+__email__ = ('scripts', 'Author, ')
+__url__ = ('blender', 'blenderartists.org')
+
+__bpydoc__ ="""\
+This script provides tools for working with OpenFlight databases in Blender. OpenFlight is a
+registered trademark of MultiGen-Paradigm, Inc.
+
+Feature overview and more availible at:
+http://wiki.blender.org/index.php/Scripts/Manual/FLTools
+"""
+
+# --------------------------------------------------------------------------
+# flt_palettemanager.py version 0.1 2005/04/08
+# --------------------------------------------------------------------------
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# Copyright (C) 2007: Blender Foundation
+#
+# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# ***** END GPL LICENCE BLOCK *****
+# --------------------------------------------------------------------------
+
+import Blender.Draw as Draw
+from Blender.BGL import *
+import Blender
+import flt_properties
+reload(flt_properties)
+from flt_properties import *
+
+#event codes
+evcode = {
+       "LOD_MAKE" : 100,
+       "LOD_DELETE" : 101,
+       "LOD_CALC_CENTER" : 102,
+       "LOD_GRAB_CENTER" : 103,
+       "LOD_X" : 104,
+       "LOD_Y" : 105,
+       "LOD_Z" : 106,
+       "LOD_FREEZE" : 107,
+       "LOD_SIG" : 108,
+       "LOD_IN" : 109,
+       "LOD_OUT" : 110,
+       "LOD_TRANS" : 111,              
+       "LOD_PREVIOUS" : 112
+}
+
+
+#system
+LOD_MAKE = None                        #PushButton
+LOD_DELETE = None              #PushButton
+LOD_CALC_CENTER = None #PushButton
+LOD_GRAB_CENTER = None #Pushbutton
+LOD_FREEZE = None              #Toggle
+LOD_PREVIOUS = None            #Toggle
+
+LOD_X = None                   #Input
+LOD_Y = None                   #Input
+LOD_Z = None                   #Input
+
+LOD_SIG = None                 #Input
+LOD_IN = None                  #Input
+LOD_OUT = None                 #Input
+LOD_TRANS = None               #Input
+
+#labels
+LOD_EDITLABEL = None
+LOD_SWITCHLABEL = None
+LOD_CENTERLABEL = None
+
+LOD_XLABEL = None
+LOD_YLABEL = None
+LOD_ZLABEL = None
+LOD_SIGLABEL = None
+LOD_INLABEL = None
+LOD_OUTLABEL = None
+LOD_TRANSLABEL = None
+
+
+#ID Props
+switch_in = '5d!switch in'
+switch_out = '6d!switch out'
+xco = '10d!X co'
+yco = '11d!Y co'
+zco = '12d!Z co'
+trans = '13d!Transition'
+sig_size = '14d!Sig Size'
+
+#Flags
+lodflag = '9I!flags'
+previous_mask = (1 << 31)
+freeze_mask = (1 << 29)
+
+def update_state():
+       state = dict()
+       state["activeScene"] = Blender.Scene.GetCurrent()
+       state["activeObject"] = state["activeScene"].objects.active
+       if state["activeObject"] and not state["activeObject"].sel:
+               state["activeObject"] = None
+       state["activeMesh"] = None
+       if state["activeObject"] and state["activeObject"].type == 'Mesh':
+               state["activeMesh"] = state["activeObject"].getData(mesh=True)
+       
+       state["activeFace"] = None
+       if state["activeMesh"]:
+               if state["activeMesh"].faceUV and state["activeMesh"].activeFace != None:
+                       state["activeFace"] = state["activeMesh"].faces[state["activeMesh"].activeFace]
+               
+               
+       #update editmode
+       state["editmode"]       = Blender.Window.EditMode()
+
+       return state
+       
+def idprops_append(object, typecode, props):
+       object.properties["FLT"] = dict()
+       object.properties["FLT"]['type'] = typecode 
+       for prop in props:
+               object.properties["FLT"][prop] = props[prop]
+       object.properties["FLT"]['3t8!id'] = object.name
+
+def idprops_kill():
+       state = update_state()
+       if state["activeObject"] and state["activeObject"].properties.has_key('FLT'):
+               state["activeObject"].properties.pop('FLT')
+
+def idprops_copy(source):
+       state = update_state()
+       if source.properties.has_key('FLT'):
+               for object in state["activeScene"].objects:
+                       if object.sel and object != source and (state["activeScene"].Layers & object.Layers):
+                               idprops_kill(object)
+                               object.properties['FLT'] = dict()
+                               for key in source.properties['FLT']:
+                                       object.properties['FLT'][key] = source.properties['FLT'][key]
+
+def select_by_typecode(typecode):
+       state = update_state()
+       
+       for object in state["activeScene"].objects:
+               if object.properties.has_key('FLT') and object.properties['FLT']['type'] == typecode and state["activeScene"].Layers & object.Layers:
+                               object.select(1)
+
+def idprops_type(object, typecode):
+       if object.properties.has_key('FLT') and object.properties['FLT'].has_key('type') and object.properties['FLT']['type'] == typecode:
+               return True
+       return False
+
+#ui type code
+def get_prop(typecode, prop):
+       
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], typecode):
+               props = state["activeObject"].properties['FLT']
+       else:
+               props =  flt_properties.FLTLOD
+               
+       return props[prop]      
+
+def set_prop(typecode, prop, value):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"],typecode):
+               state["activeObject"].properties['FLT'][prop] = value           
+
+
+
+def get_lockmask(mask):
+       global lodflag
+       state = update_state()
+       if state["activeObject"]:
+               flag = get_prop(73,lodflag)
+               if flag & mask:
+                       return True
+       return False    
+
+def set_lockmask(mask):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 73):
+               oldvalue = state["activeObject"].properties['FLT'][lodflag]
+               oldvalue = struct.unpack('>I', struct.pack('>i', oldvalue))[0]
+               oldvalue |= mask
+               state["activeObject"].properties['FLT'][lodflag] = struct.unpack('>i', struct.pack(">I", oldvalue))[0]
+
+def clear_lockmask(mask):
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 73):
+               oldvalue = state["activeObject"].properties['FLT'][lodflag]
+               oldvalue = struct.unpack('>I', struct.pack('>i', oldvalue))[0]
+               oldvalue &= ~mask
+               state["activeObject"].properties['FLT'][lodflag] = struct.unpack('>i',struct.pack('>I',oldvalue))[0]    
+
+def findchildren(object):
+       state = update_state()
+       children = list()
+       for candidate in state["activeScene"].objects:
+               if candidate.parent == object:
+                       children.append(candidate)
+       retlist = list(children)
+       for child in children:
+               retlist = retlist + findchildren(child)
+       return retlist
+
+def get_object_center(object):
+       bbox = object.getBoundBox(1)
+       average = Blender.Mathutils.Vector(0.0, 0.0, 0.0)
+       
+       for point in bbox:
+               average[0] += point[0]
+               average[1] += point[1]
+               average[2] += point[2]
+       
+       average[0] = average[0] / 8.0
+       average[1] = average[1] / 8.0
+       average[2] = average[2] / 8.0
+       
+       return average
+       
+
+def calc_center():
+       
+       global xco
+       global yco
+       global zco
+       
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 73):
+               average = Blender.Mathutils.Vector(0.0, 0.0, 0.0)
+               children = findchildren(state["activeObject"]) #get children objects    
+               if children:
+                       for child in children:
+                               center = get_object_center(child)
+                               average[0] += center[0]
+                               average[1] += center[1]
+                               average[2] += center[2]
+                       
+                       average[0] = average[0] / len(children)
+                       average[1] = average[1] / len(children)
+                       average[2] = average[2] / len(children)
+                       
+               set_prop(73, xco, average[0])
+               set_prop(73, yco, average[1])
+               set_prop(73, zco, average[2])
+               
+
+def grab_center():
+       
+       global xco
+       global yco
+       global zco
+       
+       state = update_state()
+       if state["activeObject"] and idprops_type(state["activeObject"], 73):
+               center = Blender.Window.GetCursorPos()
+               
+               set_prop(73, xco, center[0])
+               set_prop(73, yco, center[1])
+               set_prop(73, zco, center[2])    
+
+
+def create_lod():
+       state = update_state()
+       actobj = state["activeObject"]
+       if actobj and not idprops_type(actobj, 73):
+               idprops_kill()
+               idprops_append(actobj,73, flt_properties.FLTLOD)
+               calc_center()
+
+       
+               
+def event(evt,val):
+       if evt == Draw.ESCKEY:
+               Draw.Exit()
+               
+def but_event(evt):
+
+       global LOD_MAKE
+       global LOD_DELETE
+       global LOD_CALC_CENTER
+       global LOD_GRAB_CENTER
+       global LOD_FREEZE
+       global LOD_PREVIOUS
+       global LOD_X
+       global LOD_Y
+       global LOD_Z
+       global LOD_SIG
+       global LOD_IN
+       global LOD_OUT
+       global LOD_TRANS
+       
+       global switch_in
+       global switch_out
+       global xco
+       global yco
+       global zco
+       global trans
+       global sig_size
+       
+       global lodflag
+       global previous_mask
+       global freeze_mask
+       
+       global evcode
+       
+       #do "system" events
+       if evt == evcode["LOD_MAKE"]:
+               create_lod()
+
+       if evt == evcode["LOD_CALC_CENTER"]:
+               calc_center()
+       
+       if evt == evcode["LOD_DELETE"]:
+               idprops_kill()
+       
+       if evt == evcode["LOD_GRAB_CENTER"]:
+               grab_center()
+
+       #do mask events
+       if evt == evcode["LOD_FREEZE"]:
+               if LOD_FREEZE.val == True:
+                       set_lockmask(freeze_mask)
+               else:
+                       clear_lockmask(freeze_mask)
+                       
+       if evt == evcode["LOD_PREVIOUS"]:
+               if LOD_PREVIOUS.val == True:
+                       set_lockmask(previous_mask)
+               else:
+                       clear_lockmask(previous_mask)
+                       
+       #do input events
+       if evt == evcode["LOD_X"]:
+               set_prop(73, xco, LOD_X.val)
+       if evt == evcode["LOD_Y"]:
+               set_prop(73, yco, LOD_Y.val)
+       if evt == evcode["LOD_Z"]:
+               set_prop(73, zco, LOD_Z.val)
+       if evt == evcode["LOD_SIG"]:
+               set_prop(73, sig_size, LOD_SIG.val)
+       if evt == evcode["LOD_IN"]:
+               set_prop(73, switch_in, LOD_IN.val)
+       if evt == evcode["LOD_OUT"]:
+               set_prop(73, switch_out, LOD_OUT.val)
+       if evt == evcode["LOD_TRANS"]:
+               set_prop(73, trans, LOD_TRANS.val)      
+                               
+
+       Draw.Redraw(1)
+       Blender.Window.RedrawAll()
+
+def draw_propsheet(x,y):
+
+       global LOD_MAKE
+       global LOD_DELETE
+       global LOD_CALC_CENTER
+       global LOD_GRAB_CENTER
+       global LOD_FREEZE
+       global LOD_PREVIOUS
+       global LOD_X
+       global LOD_Y
+       global LOD_Z
+       global LOD_SIG
+       global LOD_IN
+       global LOD_OUT
+       global LOD_TRANS
+
+       #labels
+       global LOD_EDITLABEL
+       global LOD_SWITCHLABEL
+       global LOD_CENTERLABEL
+       global LOD_XLABEL
+       global LOD_YLABEL
+       global LOD_ZLABEL
+       global LOD_SIGLABEL
+       global LOD_INLABEL
+       global LOD_OUTLABEL
+       global LOD_TRANSLABEL
+       
+       
+       global switch_in
+       global switch_out
+       global xco
+       global yco
+       global zco
+       global trans
+       global sig_size
+       
+       global lodflag
+       global previous_mask
+       global freeze_mask
+       
+       global evcode
+
+
+       global evcode
+       
+       state = update_state()
+
+       label_width = 100       
+       row_height = 20
+       toggle_width = 50
+       input_width = 100
+       pad = 10
+       origx = x
+       origy = y
+
+
+       #editor label
+       x = origx
+       y = y - (row_height + pad)
+       LOD_EDITLABEL = Blender.Draw.Label("FLT Level of Detail Editor", x, y, 250, row_height)
+
+
+       #Center inputs
+       x = origx
+       y = y- (row_height + pad)
+       LOD_CENTERLABEL = Blender.Draw.Label("LOD center", x, y, label_width, row_height)
+       y = y- (row_height + pad)
+       LOD_XLABEL = Blender.Draw.Label("X Coordinate", x, y, label_width, row_height)
+       x = origx + (label_width + pad)
+       LOD_X = Blender.Draw.Number("", evcode["LOD_X"], x, y, input_width, row_height,get_prop(73,xco),  -100.0, 100.0, "")
+       x = origx
+       y = y- (row_height + pad)
+       LOD_YLABEL = Blender.Draw.Label("Y Coordinate", x, y, label_width, row_height)  
+       x = origx + (label_width + pad)
+       LOD_Y = Blender.Draw.Number("", evcode["LOD_Y"], x, y, input_width, row_height,get_prop(73,yco), -100.0, 100.0, "")
+       x = origx
+       y = y- (row_height + pad)
+       LOD_ZLABEL = Blender.Draw.Label("Z Coordinate", x, y, label_width, row_height)
+       x = origx + (label_width + pad)         
+       LOD_Z = Blender.Draw.Number("", evcode["LOD_Z"], x, y, input_width, row_height,get_prop(73,zco), -100.0, 100.0, "")
+
+
+       #Switch inputs
+       x = origx
+       y = y- (row_height + pad)
+       LOD_SWITCHLABEL = Blender.Draw.Label("Switch Settings", x, y, input_width, row_height)
+       y = y- (row_height + pad)
+       LOD_SIGLABEL = Blender.Draw.Label("Significant Size", x, y, label_width, row_height)
+       x = origx + (label_width + pad)
+       LOD_SIG = Blender.Draw.Number("", evcode["LOD_SIG"], x, y, input_width, row_height, get_prop(73,sig_size),  -100.0, 100.0, "")
+       x = origx
+       y = y- (row_height + pad)
+       LOD_INLABEL = Blender.Draw.Label("Switch In", x, y, label_width, row_height)
+       x = origx + (label_width + pad)
+       LOD_IN = Blender.Draw.Number("", evcode["LOD_IN"], x, y, input_width, row_height, get_prop(73,switch_in), -100.0, 100.0, "")
+       x = origx
+       y = y- (row_height + pad)
+       LOD_OUTLABEL = Blender.Draw.Label("Switch Out", x, y, label_width, row_height)  
+       x = origx + (label_width + pad)
+       LOD_OUT = Blender.Draw.Number("", evcode["LOD_OUT"], x, y, input_width, row_height, get_prop(73,switch_out), -100.0, 100.0, "")
+       x = origx
+       y = y- (row_height + pad)
+       LOD_TRANSLABEL = Blender.Draw.Label("Transition", x, y, label_width, row_height)                
+       x = origx + (label_width + pad)
+       LOD_TRANS = Blender.Draw.Number("", evcode["LOD_TRANS"], x, y, input_width, row_height, get_prop(73,trans), -100.0, 100.0, "")  
+
+
+       x = origx
+       y = y - (row_height + pad)      
+       LOD_MAKE = Blender.Draw.PushButton("Make LOD", evcode["LOD_MAKE"], x, y, input_width + label_width + pad, row_height, "Make a LOD Node out of Active Object")
+       y = y - (row_height + pad)      
+       LOD_DELETE = Blender.Draw.PushButton("Delete LOD", evcode["LOD_DELETE"], x, y, input_width + label_width + pad, row_height, "Delete the LOD Node properties")
+       y = y - (row_height + pad)
+       LOD_CALC_CENTER = Blender.Draw.PushButton("Calculate Center", evcode["LOD_CALC_CENTER"], x, y, input_width + label_width + pad, row_height, "Calculate the center of this LOD")
+       y = y - (row_height + pad)
+       LOD_GRAB_CENTER = Blender.Draw.PushButton("Grab Center", evcode["LOD_GRAB_CENTER"], x, y, input_width + label_width + pad, row_height, "Grab center from 3d cursor")
+       y = y - (row_height + pad)
+       LOD_FREEZE = Blender.Draw.Toggle("Freeze Center", evcode["LOD_FREEZE"], x, y, input_width + label_width + pad, row_height, get_lockmask(freeze_mask), "")
+       y = y - (row_height + pad)
+       LOD_PREVIOUS = Blender.Draw.Toggle("Previous Range", evcode["LOD_PREVIOUS"], x, y, input_width + label_width + pad, row_height, get_lockmask(previous_mask), "")
+
+       maxy = y
+
+
+
+               
+
+
+
+
+
+       #Toggles
+       x = origx
+       y = y - (row_height + (pad)*3)
+
+       
+       
+def gui():
+       #draw the propsheet/toolbox.
+       psheety = 800
+       #psheetx = psheety + 10
+       draw_propsheet(20,psheety)
+
+Draw.Register(gui,event,but_event)
+       
\ No newline at end of file
index bc7c972ca6676fa9c549a56ab8e4db11471ba442..4c841e9c0c03b7d5b06a4e05ddd7b9b338d3979b 100644 (file)
@@ -197,7 +197,10 @@ def write_prop(fw,type,value,length):
        elif type == 'i':
                fw.write_int(value)
        elif type == 'I':
-               fw.write_uint(value)
+               #NOTE!:
+               #there is no unsigned int type in python, but we can only store signed ints in ID props
+               newvalue = struct.unpack('>I', struct.pack('>i', value))[0]
+               fw.write_uint(newvalue)
        elif type == 'd':
                fw.write_double(value)
        elif type == 'f':
@@ -267,16 +270,16 @@ FLTObjectDisplay = [10]
 FLTLOD = {
        '3t8!id' : 'L',
        '4i!reserved' : 0,
-       '5d!switch in' : 0,
-       '6d!switch out' : 0,
+       '5d!switch in' : 0.0,
+       '6d!switch out' : 0.0,
        '7s!sfx ID1' : 0,
        '8s!sfx ID2' : 0,
        '9I!flags' : 0,
-       '10d!X co' : 0,
-       '11d!Y co' : 0,
-       '12d!Z co' : 0,
-       '13d!Transition' : 0,
-       '14d!Sig Size' : 0
+       '10d!X co' : 0.0,
+       '11d!Y co' : 0.0,
+       '12d!Z co' : 0.0,
+       '13d!Transition' : 0.0,
+       '14d!Sig Size' : 0.0
 }
 FLTLODDisplay = [4]