From 6d7fa6020e08d1e7e9921e67a25534a54e373bd3 Mon Sep 17 00:00:00 2001 From: Geoffrey Bantle Date: Wed, 20 Aug 2008 19:10:33 +0000 Subject: [PATCH] -> LOD and DOF editor scripts 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 | 834 ++++++++++++++++++++++++++++++ release/scripts/flt_lodedit.py | 518 +++++++++++++++++++ release/scripts/flt_properties.py | 19 +- 3 files changed, 1363 insertions(+), 8 deletions(-) create mode 100644 release/scripts/flt_dofedit.py create mode 100644 release/scripts/flt_lodedit.py diff --git a/release/scripts/flt_dofedit.py b/release/scripts/flt_dofedit.py new file mode 100644 index 00000000000..a01883d88c2 --- /dev/null +++ b/release/scripts/flt_dofedit.py @@ -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 index 00000000000..8860d6d5cb3 --- /dev/null +++ b/release/scripts/flt_lodedit.py @@ -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 diff --git a/release/scripts/flt_properties.py b/release/scripts/flt_properties.py index bc7c972ca66..4c841e9c0c0 100644 --- a/release/scripts/flt_properties.py +++ b/release/scripts/flt_properties.py @@ -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]