bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity
6d7fa6020e
blender/release/scripts/flt_dofedit.py

834 lines
24 KiB
Python
Raw Normal View History

-> 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.
2008-08-20 19:10:33 +00:00
#!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)
Reference in New Issue Copy Permalink