mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-26 13:12:30 -06:00
1917 lines
77 KiB
Python
1917 lines
77 KiB
Python
|
""" Mopath Recorder Panel Module """
|
||
|
|
|
||
|
|
__all__ = ['MopathRecorder']
|
||
|
|
|
||
|
|
# Import Tkinter, Pmw, and the dial code from this directory tree.
|
||
|
|
from pandac.PandaModules import *
|
||
|
|
from direct.showbase.DirectObject import DirectObject
|
||
|
|
from direct.showbase.TkGlobal import *
|
||
|
|
from direct.tkwidgets.AppShell import *
|
||
|
|
from direct.directtools.DirectGlobals import *
|
||
|
|
from direct.directtools.DirectUtil import *
|
||
|
|
from direct.directtools.DirectGeometry import *
|
||
|
|
from direct.directtools.DirectSelection import *
|
||
|
|
from tkFileDialog import *
|
||
|
|
from Tkinter import *
|
||
|
|
import Pmw, os, string
|
||
|
|
from direct.tkwidgets import Dial
|
||
|
|
from direct.tkwidgets import Floater
|
||
|
|
from direct.tkwidgets import Slider
|
||
|
|
from direct.tkwidgets import EntryScale
|
||
|
|
from direct.tkwidgets import VectorWidgets
|
||
|
|
import __builtin__
|
||
|
|
|
||
|
|
PRF_UTILITIES = [
|
||
|
|
'lambda: base.direct.camera.lookAt(render)',
|
||
|
|
'lambda: base.direct.camera.setZ(render, 0.0)',
|
||
|
|
'lambda s = self: s.playbackMarker.lookAt(render)',
|
||
|
|
'lambda s = self: s.playbackMarker.setZ(render, 0.0)',
|
||
|
|
'lambda s = self: s.followTerrain(10.0)']
|
||
|
|
|
||
|
|
class MopathRecorder(AppShell, DirectObject):
|
||
|
|
# Override class variables here
|
||
|
|
appname = 'Mopath Recorder Panel'
|
||
|
|
frameWidth = 450
|
||
|
|
frameHeight = 550
|
||
|
|
usecommandarea = 0
|
||
|
|
usestatusarea = 0
|
||
|
|
count = 0
|
||
|
|
|
||
|
|
def __init__(self, parent = None, **kw):
|
||
|
|
INITOPT = Pmw.INITOPT
|
||
|
|
name = 'recorder-%d' % MopathRecorder.count
|
||
|
|
MopathRecorder.count += 1
|
||
|
|
optiondefs = (
|
||
|
|
('title', self.appname, None),
|
||
|
|
('nodePath', None, None),
|
||
|
|
('name', name, None)
|
||
|
|
)
|
||
|
|
self.defineoptions(kw, optiondefs)
|
||
|
|
|
||
|
|
# Call superclass initialization function
|
||
|
|
AppShell.__init__(self)
|
||
|
|
|
||
|
|
self.initialiseoptions(MopathRecorder)
|
||
|
|
|
||
|
|
self.selectNodePathNamed('camera')
|
||
|
|
|
||
|
|
def appInit(self):
|
||
|
|
self.name = self['name']
|
||
|
|
# Dictionary of widgets
|
||
|
|
self.widgetDict = {}
|
||
|
|
self.variableDict = {}
|
||
|
|
# Initialize state
|
||
|
|
# The active node path
|
||
|
|
self.nodePath = self['nodePath']
|
||
|
|
self.playbackNodePath = self.nodePath
|
||
|
|
# The active node path's parent
|
||
|
|
self.nodePathParent = render
|
||
|
|
# Top level node path
|
||
|
|
self.recorderNodePath = base.direct.group.attachNewNode(self.name)
|
||
|
|
# Temp CS for use in refinement/path extension
|
||
|
|
self.tempCS = self.recorderNodePath.attachNewNode(
|
||
|
|
'mopathRecorderTempCS')
|
||
|
|
# Marker for use in playback
|
||
|
|
self.playbackMarker = loader.loadModel('models/misc/smiley')
|
||
|
|
self.playbackMarker.setName('Playback Marker')
|
||
|
|
self.playbackMarker.reparentTo(self.recorderNodePath)
|
||
|
|
self.playbackMarkerIds = self.getChildIds(
|
||
|
|
self.playbackMarker.getChild(0))
|
||
|
|
self.playbackMarker.hide()
|
||
|
|
# Tangent marker
|
||
|
|
self.tangentGroup = self.playbackMarker.attachNewNode('Tangent Group')
|
||
|
|
self.tangentGroup.hide()
|
||
|
|
self.tangentMarker = loader.loadModel('models/misc/sphere')
|
||
|
|
self.tangentMarker.reparentTo(self.tangentGroup)
|
||
|
|
self.tangentMarker.setScale(0.5)
|
||
|
|
self.tangentMarker.setColor(1, 0, 1, 1)
|
||
|
|
self.tangentMarker.setName('Tangent Marker')
|
||
|
|
self.tangentMarkerIds = self.getChildIds(
|
||
|
|
self.tangentMarker.getChild(0))
|
||
|
|
self.tangentLines = LineNodePath(self.tangentGroup)
|
||
|
|
self.tangentLines.setColor(VBase4(1, 0, 1, 1))
|
||
|
|
self.tangentLines.setThickness(1)
|
||
|
|
self.tangentLines.moveTo(0, 0, 0)
|
||
|
|
self.tangentLines.drawTo(0, 0, 0)
|
||
|
|
self.tangentLines.create()
|
||
|
|
# Active node path dictionary
|
||
|
|
self.nodePathDict = {}
|
||
|
|
self.nodePathDict['marker'] = self.playbackMarker
|
||
|
|
self.nodePathDict['camera'] = base.direct.camera
|
||
|
|
self.nodePathDict['widget'] = base.direct.widget
|
||
|
|
self.nodePathDict['mopathRecorderTempCS'] = self.tempCS
|
||
|
|
self.nodePathNames = ['marker', 'camera', 'selected']
|
||
|
|
# ID of selected object
|
||
|
|
self.manipulandumId = None
|
||
|
|
self.trace = LineNodePath(self.recorderNodePath)
|
||
|
|
self.oldPlaybackNodePath = None
|
||
|
|
# Count of point sets recorded
|
||
|
|
self.pointSet = []
|
||
|
|
self.prePoints = []
|
||
|
|
self.postPoints = []
|
||
|
|
self.pointSetDict = {}
|
||
|
|
self.pointSetCount = 0
|
||
|
|
self.pointSetName = self.name + '-ps-' + repr(self.pointSetCount)
|
||
|
|
# User callback to call before recording point
|
||
|
|
self.samplingMode = 'Continuous'
|
||
|
|
self.preRecordFunc = None
|
||
|
|
# Hook to start/stop recording
|
||
|
|
self.startStopHook = 'f6'
|
||
|
|
self.keyframeHook = 'f10'
|
||
|
|
# Curve fitter object
|
||
|
|
self.lastPos = Point3(0)
|
||
|
|
self.curveFitter = CurveFitter()
|
||
|
|
# Curve variables
|
||
|
|
# Number of ticks per parametric unit
|
||
|
|
self.numTicks = 1
|
||
|
|
# Number of segments to represent each parametric unit
|
||
|
|
# This just affects the visual appearance of the curve
|
||
|
|
self.numSegs = 40
|
||
|
|
# The nurbs curves
|
||
|
|
self.curveCollection = None
|
||
|
|
# Curve drawers
|
||
|
|
self.nurbsCurveDrawer = NurbsCurveDrawer()
|
||
|
|
self.nurbsCurveDrawer.setCurves(ParametricCurveCollection())
|
||
|
|
self.nurbsCurveDrawer.setNumSegs(self.numSegs)
|
||
|
|
self.nurbsCurveDrawer.setShowHull(0)
|
||
|
|
self.nurbsCurveDrawer.setShowCvs(0)
|
||
|
|
self.nurbsCurveDrawer.setNumTicks(0)
|
||
|
|
self.nurbsCurveDrawer.setTickScale(5.0)
|
||
|
|
self.curveNodePath = self.recorderNodePath.attachNewNode(
|
||
|
|
self.nurbsCurveDrawer.getGeomNode())
|
||
|
|
useDirectRenderStyle(self.curveNodePath)
|
||
|
|
# Playback variables
|
||
|
|
self.maxT = 0.0
|
||
|
|
self.playbackTime = 0.0
|
||
|
|
self.loopPlayback = 1
|
||
|
|
self.playbackSF = 1.0
|
||
|
|
# Sample variables
|
||
|
|
self.desampleFrequency = 1
|
||
|
|
self.numSamples = 100
|
||
|
|
self.recordStart = 0.0
|
||
|
|
self.deltaTime = 0.0
|
||
|
|
self.controlStart = 0.0
|
||
|
|
self.controlStop = 0.0
|
||
|
|
self.recordStop = 0.0
|
||
|
|
self.cropFrom = 0.0
|
||
|
|
self.cropTo = 0.0
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
# For terrain following
|
||
|
|
self.iRayCS = self.recorderNodePath.attachNewNode(
|
||
|
|
'mopathRecorderIRayCS')
|
||
|
|
self.iRay = SelectionRay(self.iRayCS)
|
||
|
|
# Set up event hooks
|
||
|
|
self.actionEvents = [
|
||
|
|
('DIRECT_undo', self.undoHook),
|
||
|
|
('DIRECT_pushUndo', self.pushUndoHook),
|
||
|
|
('DIRECT_undoListEmpty', self.undoListEmptyHook),
|
||
|
|
('DIRECT_redo', self.redoHook),
|
||
|
|
('DIRECT_pushRedo', self.pushRedoHook),
|
||
|
|
('DIRECT_redoListEmpty', self.redoListEmptyHook),
|
||
|
|
('DIRECT_selectedNodePath', self.selectedNodePathHook),
|
||
|
|
('DIRECT_deselectedNodePath', self.deselectedNodePathHook),
|
||
|
|
('DIRECT_manipulateObjectStart', self.manipulateObjectStartHook),
|
||
|
|
('DIRECT_manipulateObjectCleanup',
|
||
|
|
self.manipulateObjectCleanupHook),
|
||
|
|
]
|
||
|
|
for event, method in self.actionEvents:
|
||
|
|
self.accept(event, method)
|
||
|
|
|
||
|
|
def createInterface(self):
|
||
|
|
interior = self.interior()
|
||
|
|
# FILE MENU
|
||
|
|
# Get a handle on the file menu so commands can be inserted
|
||
|
|
# before quit item
|
||
|
|
fileMenu = self.menuBar.component('File-menu')
|
||
|
|
fileMenu.insert_command(
|
||
|
|
fileMenu.index('Quit'),
|
||
|
|
label = 'Load Curve',
|
||
|
|
command = self.loadCurveFromFile)
|
||
|
|
fileMenu.insert_command(
|
||
|
|
fileMenu.index('Quit'),
|
||
|
|
label = 'Save Curve',
|
||
|
|
command = self.saveCurveToFile)
|
||
|
|
|
||
|
|
# Add mopath recorder commands to menubar
|
||
|
|
self.menuBar.addmenu('Recorder', 'Mopath Recorder Panel Operations')
|
||
|
|
self.menuBar.addmenuitem(
|
||
|
|
'Recorder', 'command',
|
||
|
|
'Save current curve as a new point set',
|
||
|
|
label = 'Save Point Set',
|
||
|
|
command = self.extractPointSetFromCurveCollection)
|
||
|
|
self.menuBar.addmenuitem(
|
||
|
|
'Recorder', 'command',
|
||
|
|
'Toggle widget visability',
|
||
|
|
label = 'Toggle Widget Vis',
|
||
|
|
command = base.direct.toggleWidgetVis)
|
||
|
|
self.menuBar.addmenuitem(
|
||
|
|
'Recorder', 'command',
|
||
|
|
'Toggle widget manipulation mode',
|
||
|
|
label = 'Toggle Widget Mode',
|
||
|
|
command = base.direct.manipulationControl.toggleObjectHandlesMode)
|
||
|
|
|
||
|
|
self.createComboBox(self.menuFrame, 'Mopath', 'History',
|
||
|
|
'Select input points to fit curve to', '',
|
||
|
|
self.selectPointSetNamed, expand = 1)
|
||
|
|
|
||
|
|
self.undoButton = Button(self.menuFrame, text = 'Undo',
|
||
|
|
command = base.direct.undo)
|
||
|
|
if base.direct.undoList:
|
||
|
|
self.undoButton['state'] = 'normal'
|
||
|
|
else:
|
||
|
|
self.undoButton['state'] = 'disabled'
|
||
|
|
self.undoButton.pack(side = LEFT, expand = 0)
|
||
|
|
self.bind(self.undoButton, 'Undo last operation')
|
||
|
|
|
||
|
|
self.redoButton = Button(self.menuFrame, text = 'Redo',
|
||
|
|
command = base.direct.redo)
|
||
|
|
if base.direct.redoList:
|
||
|
|
self.redoButton['state'] = 'normal'
|
||
|
|
else:
|
||
|
|
self.redoButton['state'] = 'disabled'
|
||
|
|
self.redoButton.pack(side = LEFT, expand = 0)
|
||
|
|
self.bind(self.redoButton, 'Redo last operation')
|
||
|
|
|
||
|
|
# Record button
|
||
|
|
mainFrame = Frame(interior, relief = SUNKEN, borderwidth = 2)
|
||
|
|
frame = Frame(mainFrame)
|
||
|
|
# Active node path
|
||
|
|
# Button to select active node path
|
||
|
|
widget = self.createButton(frame, 'Recording', 'Node Path:',
|
||
|
|
'Select Active Mopath Node Path',
|
||
|
|
lambda s = self: base.direct.select(s.nodePath),
|
||
|
|
side = LEFT, expand = 0)
|
||
|
|
widget['relief'] = FLAT
|
||
|
|
self.nodePathMenu = Pmw.ComboBox(
|
||
|
|
frame, entry_width = 20,
|
||
|
|
selectioncommand = self.selectNodePathNamed,
|
||
|
|
scrolledlist_items = self.nodePathNames)
|
||
|
|
self.nodePathMenu.selectitem('camera')
|
||
|
|
self.nodePathMenuEntry = (
|
||
|
|
self.nodePathMenu.component('entryfield_entry'))
|
||
|
|
self.nodePathMenuBG = (
|
||
|
|
self.nodePathMenuEntry.configure('background')[3])
|
||
|
|
self.nodePathMenu.pack(side = LEFT, fill = X, expand = 1)
|
||
|
|
self.bind(self.nodePathMenu,
|
||
|
|
'Select active node path used for recording and playback')
|
||
|
|
# Recording type
|
||
|
|
self.recordingType = StringVar()
|
||
|
|
self.recordingType.set('New Curve')
|
||
|
|
widget = self.createRadiobutton(
|
||
|
|
frame, 'left',
|
||
|
|
'Recording', 'New Curve',
|
||
|
|
('Next record session records a new path'),
|
||
|
|
self.recordingType, 'New Curve', expand = 0)
|
||
|
|
widget = self.createRadiobutton(
|
||
|
|
frame, 'left',
|
||
|
|
'Recording', 'Refine',
|
||
|
|
('Next record session refines existing path'),
|
||
|
|
self.recordingType, 'Refine', expand = 0)
|
||
|
|
widget = self.createRadiobutton(
|
||
|
|
frame, 'left',
|
||
|
|
'Recording', 'Extend',
|
||
|
|
('Next record session extends existing path'),
|
||
|
|
self.recordingType, 'Extend', expand = 0)
|
||
|
|
frame.pack(fill = X, expand = 1)
|
||
|
|
|
||
|
|
frame = Frame(mainFrame)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Recording', 'Record',
|
||
|
|
'On: path is being recorded', self.toggleRecord, 0,
|
||
|
|
side = LEFT, fill = BOTH, expand = 1)
|
||
|
|
widget.configure(foreground = 'Red', relief = RAISED, borderwidth = 2,
|
||
|
|
anchor = CENTER, width = 16)
|
||
|
|
widget = self.createButton(frame, 'Recording', 'Add Keyframe',
|
||
|
|
'Add Keyframe To Current Path',
|
||
|
|
self.addKeyframe,
|
||
|
|
side = LEFT, expand = 1)
|
||
|
|
frame.pack(fill = X, expand = 1)
|
||
|
|
|
||
|
|
mainFrame.pack(expand = 1, fill = X, pady = 3)
|
||
|
|
|
||
|
|
# Playback controls
|
||
|
|
playbackFrame = Frame(interior, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
Label(playbackFrame, text = 'PLAYBACK CONTROLS',
|
||
|
|
font=('MSSansSerif', 12, 'bold')).pack(fill = X)
|
||
|
|
# Main playback control slider
|
||
|
|
widget = self.createEntryScale(
|
||
|
|
playbackFrame, 'Playback', 'Time', 'Set current playback time',
|
||
|
|
resolution = 0.01, command = self.playbackGoTo, side = TOP)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
# Kill playback task if drag slider
|
||
|
|
widget['preCallback'] = self.stopPlayback
|
||
|
|
# Jam duration entry into entry scale
|
||
|
|
self.createLabeledEntry(widget.labelFrame, 'Resample', 'Path Duration',
|
||
|
|
'Set total curve duration',
|
||
|
|
command = self.setPathDuration,
|
||
|
|
side = LEFT, expand = 0)
|
||
|
|
# Start stop buttons
|
||
|
|
frame = Frame(playbackFrame)
|
||
|
|
widget = self.createButton(frame, 'Playback', '<<',
|
||
|
|
'Jump to start of playback',
|
||
|
|
self.jumpToStartOfPlayback,
|
||
|
|
side = LEFT, expand = 1)
|
||
|
|
widget['font'] = (('MSSansSerif', 12, 'bold'))
|
||
|
|
widget = self.createCheckbutton(frame, 'Playback', 'Play',
|
||
|
|
'Start/Stop playback',
|
||
|
|
self.startStopPlayback, 0,
|
||
|
|
side = LEFT, fill = BOTH, expand = 1)
|
||
|
|
widget.configure(anchor = 'center', justify = 'center',
|
||
|
|
relief = RAISED, font = ('MSSansSerif', 12, 'bold'))
|
||
|
|
widget = self.createButton(frame, 'Playback', '>>',
|
||
|
|
'Jump to end of playback',
|
||
|
|
self.jumpToEndOfPlayback,
|
||
|
|
side = LEFT, expand = 1)
|
||
|
|
widget['font'] = (('MSSansSerif', 12, 'bold'))
|
||
|
|
self.createCheckbutton(frame, 'Playback', 'Loop',
|
||
|
|
'On: loop playback',
|
||
|
|
self.setLoopPlayback, self.loopPlayback,
|
||
|
|
side = LEFT, fill = BOTH, expand = 0)
|
||
|
|
frame.pack(fill = X, expand = 1)
|
||
|
|
|
||
|
|
# Speed control
|
||
|
|
frame = Frame(playbackFrame)
|
||
|
|
widget = Button(frame, text = 'PB Speed Vernier', relief = FLAT,
|
||
|
|
command = lambda s = self: s.setSpeedScale(1.0))
|
||
|
|
widget.pack(side = LEFT, expand = 0)
|
||
|
|
self.speedScale = Scale(frame, from_ = -1, to = 1,
|
||
|
|
resolution = 0.01, showvalue = 0,
|
||
|
|
width = 10, orient = 'horizontal',
|
||
|
|
command = self.setPlaybackSF)
|
||
|
|
self.speedScale.pack(side = LEFT, fill = X, expand = 1)
|
||
|
|
self.speedVar = StringVar()
|
||
|
|
self.speedVar.set("0.00")
|
||
|
|
self.speedEntry = Entry(frame, textvariable = self.speedVar,
|
||
|
|
width = 8)
|
||
|
|
self.speedEntry.bind(
|
||
|
|
'<Return>',
|
||
|
|
lambda e = None, s = self: s.setSpeedScale(
|
||
|
|
string.atof(s.speedVar.get())))
|
||
|
|
self.speedEntry.pack(side = LEFT, expand = 0)
|
||
|
|
frame.pack(fill = X, expand = 1)
|
||
|
|
|
||
|
|
playbackFrame.pack(fill = X, pady = 2)
|
||
|
|
|
||
|
|
# Create notebook pages
|
||
|
|
self.mainNotebook = Pmw.NoteBook(interior)
|
||
|
|
self.mainNotebook.pack(fill = BOTH, expand = 1)
|
||
|
|
self.resamplePage = self.mainNotebook.add('Resample')
|
||
|
|
self.refinePage = self.mainNotebook.add('Refine')
|
||
|
|
self.extendPage = self.mainNotebook.add('Extend')
|
||
|
|
self.cropPage = self.mainNotebook.add('Crop')
|
||
|
|
self.drawPage = self.mainNotebook.add('Draw')
|
||
|
|
self.optionsPage = self.mainNotebook.add('Options')
|
||
|
|
|
||
|
|
## RESAMPLE PAGE
|
||
|
|
label = Label(self.resamplePage, text = 'RESAMPLE CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
|
||
|
|
# Resample
|
||
|
|
resampleFrame = Frame(
|
||
|
|
self.resamplePage, relief = SUNKEN, borderwidth = 2)
|
||
|
|
label = Label(resampleFrame, text = 'RESAMPLE CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold')).pack()
|
||
|
|
widget = self.createSlider(
|
||
|
|
resampleFrame, 'Resample', 'Num. Samples',
|
||
|
|
'Number of samples in resampled curve',
|
||
|
|
resolution = 1, min = 2, max = 1000, command = self.setNumSamples)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
widget['postCallback'] = self.sampleCurve
|
||
|
|
|
||
|
|
frame = Frame(resampleFrame)
|
||
|
|
self.createButton(
|
||
|
|
frame, 'Resample', 'Make Even',
|
||
|
|
'Apply timewarp so resulting path has constant velocity',
|
||
|
|
self.makeEven, side = LEFT, fill = X, expand = 1)
|
||
|
|
self.createButton(
|
||
|
|
frame, 'Resample', 'Face Forward',
|
||
|
|
'Compute HPR so resulting hpr curve faces along xyz tangent',
|
||
|
|
self.faceForward, side = LEFT, fill = X, expand = 1)
|
||
|
|
frame.pack(fill = X, expand = 0)
|
||
|
|
resampleFrame.pack(fill = X, expand = 0, pady = 2)
|
||
|
|
|
||
|
|
# Desample
|
||
|
|
desampleFrame = Frame(
|
||
|
|
self.resamplePage, relief = SUNKEN, borderwidth = 2)
|
||
|
|
Label(desampleFrame, text = 'DESAMPLE CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold')).pack()
|
||
|
|
widget = self.createSlider(
|
||
|
|
desampleFrame, 'Resample', 'Points Between Samples',
|
||
|
|
'Specify number of points to skip between samples',
|
||
|
|
min = 1, max = 100, resolution = 1,
|
||
|
|
command = self.setDesampleFrequency)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
widget['postCallback'] = self.desampleCurve
|
||
|
|
desampleFrame.pack(fill = X, expand = 0, pady = 2)
|
||
|
|
|
||
|
|
## REFINE PAGE ##
|
||
|
|
refineFrame = Frame(self.refinePage, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
label = Label(refineFrame, text = 'REFINE CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
|
||
|
|
widget = self.createSlider(refineFrame,
|
||
|
|
'Refine Page', 'Refine From',
|
||
|
|
'Begin time of refine pass',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setRecordStart)
|
||
|
|
widget['preCallback'] = self.setRefineMode
|
||
|
|
widget['postCallback'] = lambda s = self: s.getPrePoints('Refine')
|
||
|
|
widget = self.createSlider(
|
||
|
|
refineFrame, 'Refine Page',
|
||
|
|
'Control Start',
|
||
|
|
'Time when full control of node path is given during refine pass',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setControlStart)
|
||
|
|
widget['preCallback'] = self.setRefineMode
|
||
|
|
widget = self.createSlider(
|
||
|
|
refineFrame, 'Refine Page',
|
||
|
|
'Control Stop',
|
||
|
|
'Time when node path begins transition back to original curve',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setControlStop)
|
||
|
|
widget['preCallback'] = self.setRefineMode
|
||
|
|
widget = self.createSlider(refineFrame, 'Refine Page', 'Refine To',
|
||
|
|
'Stop time of refine pass',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setRefineStop)
|
||
|
|
widget['preCallback'] = self.setRefineMode
|
||
|
|
widget['postCallback'] = self.getPostPoints
|
||
|
|
refineFrame.pack(fill = X)
|
||
|
|
|
||
|
|
## EXTEND PAGE ##
|
||
|
|
extendFrame = Frame(self.extendPage, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
label = Label(extendFrame, text = 'EXTEND CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
|
||
|
|
widget = self.createSlider(extendFrame,
|
||
|
|
'Extend Page', 'Extend From',
|
||
|
|
'Begin time of extend pass',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setRecordStart)
|
||
|
|
widget['preCallback'] = self.setExtendMode
|
||
|
|
widget['postCallback'] = lambda s = self: s.getPrePoints('Extend')
|
||
|
|
widget = self.createSlider(
|
||
|
|
extendFrame, 'Extend Page',
|
||
|
|
'Control Start',
|
||
|
|
'Time when full control of node path is given during extend pass',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setControlStart)
|
||
|
|
widget['preCallback'] = self.setExtendMode
|
||
|
|
extendFrame.pack(fill = X)
|
||
|
|
|
||
|
|
## CROP PAGE ##
|
||
|
|
cropFrame = Frame(self.cropPage, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
label = Label(cropFrame, text = 'CROP CURVE',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
|
||
|
|
widget = self.createSlider(
|
||
|
|
cropFrame,
|
||
|
|
'Crop Page', 'Crop From',
|
||
|
|
'Delete all curve points before this time',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setCropFrom)
|
||
|
|
|
||
|
|
widget = self.createSlider(
|
||
|
|
cropFrame,
|
||
|
|
'Crop Page', 'Crop To',
|
||
|
|
'Delete all curve points after this time',
|
||
|
|
resolution = 0.01,
|
||
|
|
command = self.setCropTo)
|
||
|
|
|
||
|
|
self.createButton(cropFrame, 'Crop Page', 'Crop Curve',
|
||
|
|
'Crop curve to specified from to times',
|
||
|
|
self.cropCurve, fill = NONE)
|
||
|
|
cropFrame.pack(fill = X)
|
||
|
|
|
||
|
|
## DRAW PAGE ##
|
||
|
|
drawFrame = Frame(self.drawPage, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
|
||
|
|
self.sf = Pmw.ScrolledFrame(self.drawPage, horizflex = 'elastic')
|
||
|
|
self.sf.pack(fill = 'both', expand = 1)
|
||
|
|
sfFrame = self.sf.interior()
|
||
|
|
|
||
|
|
label = Label(sfFrame, text = 'CURVE RENDERING STYLE',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
|
||
|
|
frame = Frame(sfFrame)
|
||
|
|
Label(frame, text = 'SHOW:').pack(side = LEFT, expand = 0)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'Path',
|
||
|
|
'On: path is visible', self.setPathVis, 1,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'Knots',
|
||
|
|
'On: path knots are visible', self.setKnotVis, 1,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'CVs',
|
||
|
|
'On: path CVs are visible', self.setCvVis, 0,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'Hull',
|
||
|
|
'On: path hull is visible', self.setHullVis, 0,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'Trace',
|
||
|
|
'On: record is visible', self.setTraceVis, 0,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
widget = self.createCheckbutton(
|
||
|
|
frame, 'Style', 'Marker',
|
||
|
|
'On: playback marker is visible', self.setMarkerVis, 0,
|
||
|
|
side = LEFT, fill = X, expand = 1)
|
||
|
|
frame.pack(fill = X, expand = 1)
|
||
|
|
# Sliders
|
||
|
|
widget = self.createSlider(
|
||
|
|
sfFrame, 'Style', 'Num Segs',
|
||
|
|
'Set number of segments used to approximate each parametric unit',
|
||
|
|
min = 1.0, max = 400, resolution = 1.0,
|
||
|
|
value = 40,
|
||
|
|
command = self.setNumSegs, side = TOP)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
widget = self.createSlider(
|
||
|
|
sfFrame, 'Style', 'Num Ticks',
|
||
|
|
'Set number of tick marks drawn for each unit of time',
|
||
|
|
min = 0.0, max = 10.0, resolution = 1.0,
|
||
|
|
value = 0.0,
|
||
|
|
command = self.setNumTicks, side = TOP)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
widget = self.createSlider(
|
||
|
|
sfFrame, 'Style', 'Tick Scale',
|
||
|
|
'Set visible size of time tick marks',
|
||
|
|
min = 0.01, max = 100.0, resolution = 0.01,
|
||
|
|
value = 5.0,
|
||
|
|
command = self.setTickScale, side = TOP)
|
||
|
|
widget.component('hull')['relief'] = RIDGE
|
||
|
|
self.createColorEntry(
|
||
|
|
sfFrame, 'Style', 'Path Color',
|
||
|
|
'Color of curve',
|
||
|
|
command = self.setPathColor,
|
||
|
|
value = [255.0, 255.0, 255.0, 255.0])
|
||
|
|
self.createColorEntry(
|
||
|
|
sfFrame, 'Style', 'Knot Color',
|
||
|
|
'Color of knots',
|
||
|
|
command = self.setKnotColor,
|
||
|
|
value = [0, 0, 255.0, 255.0])
|
||
|
|
self.createColorEntry(
|
||
|
|
sfFrame, 'Style', 'CV Color',
|
||
|
|
'Color of CVs',
|
||
|
|
command = self.setCvColor,
|
||
|
|
value = [255.0, 0, 0, 255.0])
|
||
|
|
self.createColorEntry(
|
||
|
|
sfFrame, 'Style', 'Tick Color',
|
||
|
|
'Color of Ticks',
|
||
|
|
command = self.setTickColor,
|
||
|
|
value = [255.0, 0, 0, 255.0])
|
||
|
|
self.createColorEntry(
|
||
|
|
sfFrame, 'Style', 'Hull Color',
|
||
|
|
'Color of Hull',
|
||
|
|
command = self.setHullColor,
|
||
|
|
value = [255.0, 128.0, 128.0, 255.0])
|
||
|
|
|
||
|
|
#drawFrame.pack(fill = X)
|
||
|
|
|
||
|
|
## OPTIONS PAGE ##
|
||
|
|
optionsFrame = Frame(self.optionsPage, relief = SUNKEN,
|
||
|
|
borderwidth = 2)
|
||
|
|
label = Label(optionsFrame, text = 'RECORDING OPTIONS',
|
||
|
|
font=('MSSansSerif', 12, 'bold'))
|
||
|
|
label.pack(fill = X)
|
||
|
|
# Hooks
|
||
|
|
frame = Frame(optionsFrame)
|
||
|
|
widget = self.createLabeledEntry(
|
||
|
|
frame, 'Recording', 'Record Hook',
|
||
|
|
'Hook used to start/stop recording',
|
||
|
|
value = self.startStopHook,
|
||
|
|
command = self.setStartStopHook)[0]
|
||
|
|
label = self.getWidget('Recording', 'Record Hook-Label')
|
||
|
|
label.configure(width = 16, anchor = W)
|
||
|
|
self.setStartStopHook()
|
||
|
|
widget = self.createLabeledEntry(
|
||
|
|
frame, 'Recording', 'Keyframe Hook',
|
||
|
|
'Hook used to add a new keyframe',
|
||
|
|
value = self.keyframeHook,
|
||
|
|
command = self.setKeyframeHook)[0]
|
||
|
|
label = self.getWidget('Recording', 'Keyframe Hook-Label')
|
||
|
|
label.configure(width = 16, anchor = W)
|
||
|
|
self.setKeyframeHook()
|
||
|
|
frame.pack(expand = 1, fill = X)
|
||
|
|
# PreRecordFunc
|
||
|
|
frame = Frame(optionsFrame)
|
||
|
|
widget = self.createComboBox(
|
||
|
|
frame, 'Recording', 'Pre-Record Func',
|
||
|
|
'Function called before sampling each point',
|
||
|
|
PRF_UTILITIES, self.setPreRecordFunc,
|
||
|
|
history = 1, expand = 1)
|
||
|
|
widget.configure(label_width = 16, label_anchor = W)
|
||
|
|
widget.configure(entryfield_entry_state = 'normal')
|
||
|
|
# Initialize preRecordFunc
|
||
|
|
self.preRecordFunc = eval(PRF_UTILITIES[0])
|
||
|
|
self.createCheckbutton(frame, 'Recording', 'PRF Active',
|
||
|
|
'On: Pre Record Func enabled',
|
||
|
|
None, 0,
|
||
|
|
side = LEFT, fill = BOTH, expand = 0)
|
||
|
|
frame.pack(expand = 1, fill = X)
|
||
|
|
# Pack record frame
|
||
|
|
optionsFrame.pack(fill = X, pady = 2)
|
||
|
|
|
||
|
|
self.mainNotebook.setnaturalsize()
|
||
|
|
|
||
|
|
def pushUndo(self, fResetRedo = 1):
|
||
|
|
base.direct.pushUndo([self.nodePath])
|
||
|
|
|
||
|
|
def undoHook(self, nodePathList = []):
|
||
|
|
# Reflect new changes
|
||
|
|
pass
|
||
|
|
|
||
|
|
def pushUndoHook(self):
|
||
|
|
# Make sure button is reactivated
|
||
|
|
self.undoButton.configure(state = 'normal')
|
||
|
|
|
||
|
|
def undoListEmptyHook(self):
|
||
|
|
# Make sure button is deactivated
|
||
|
|
self.undoButton.configure(state = 'disabled')
|
||
|
|
|
||
|
|
def pushRedo(self):
|
||
|
|
base.direct.pushRedo([self.nodePath])
|
||
|
|
|
||
|
|
def redoHook(self, nodePathList = []):
|
||
|
|
# Reflect new changes
|
||
|
|
pass
|
||
|
|
|
||
|
|
def pushRedoHook(self):
|
||
|
|
# Make sure button is reactivated
|
||
|
|
self.redoButton.configure(state = 'normal')
|
||
|
|
|
||
|
|
def redoListEmptyHook(self):
|
||
|
|
# Make sure button is deactivated
|
||
|
|
self.redoButton.configure(state = 'disabled')
|
||
|
|
|
||
|
|
def selectedNodePathHook(self, nodePath):
|
||
|
|
"""
|
||
|
|
Hook called upon selection of a node path used to select playback
|
||
|
|
marker if subnode selected
|
||
|
|
"""
|
||
|
|
taskMgr.remove(self.name + '-curveEditTask')
|
||
|
|
print nodePath.id()
|
||
|
|
if nodePath.id() in self.playbackMarkerIds:
|
||
|
|
base.direct.select(self.playbackMarker)
|
||
|
|
elif nodePath.id() in self.tangentMarkerIds:
|
||
|
|
base.direct.select(self.tangentMarker)
|
||
|
|
elif nodePath.id() == self.playbackMarker.id():
|
||
|
|
self.tangentGroup.show()
|
||
|
|
taskMgr.add(self.curveEditTask,
|
||
|
|
self.name + '-curveEditTask')
|
||
|
|
elif nodePath.id() == self.tangentMarker.id():
|
||
|
|
self.tangentGroup.show()
|
||
|
|
taskMgr.add(self.curveEditTask,
|
||
|
|
self.name + '-curveEditTask')
|
||
|
|
else:
|
||
|
|
self.tangentGroup.hide()
|
||
|
|
|
||
|
|
def getChildIds(self, nodePath):
|
||
|
|
ids = [nodePath.id()]
|
||
|
|
kids = nodePath.getChildren()
|
||
|
|
for kid in kids:
|
||
|
|
ids += self.getChildIds(kid)
|
||
|
|
return ids
|
||
|
|
|
||
|
|
def deselectedNodePathHook(self, nodePath):
|
||
|
|
"""
|
||
|
|
Hook called upon deselection of a node path used to select playback
|
||
|
|
marker if subnode selected
|
||
|
|
"""
|
||
|
|
if ((nodePath.id() == self.playbackMarker.id()) or
|
||
|
|
(nodePath.id() == self.tangentMarker.id())):
|
||
|
|
self.tangentGroup.hide()
|
||
|
|
|
||
|
|
def curveEditTask(self, state):
|
||
|
|
if self.curveCollection != None:
|
||
|
|
# Update curve position
|
||
|
|
if self.manipulandumId == self.playbackMarker.id():
|
||
|
|
# Show playback marker
|
||
|
|
self.playbackMarker.getChild(0).show()
|
||
|
|
pos = Point3(0)
|
||
|
|
hpr = Point3(0)
|
||
|
|
pos = self.playbackMarker.getPos(self.nodePathParent)
|
||
|
|
hpr = self.playbackMarker.getHpr(self.nodePathParent)
|
||
|
|
self.curveCollection.adjustXyz(
|
||
|
|
self.playbackTime, VBase3(pos[0], pos[1], pos[2]))
|
||
|
|
self.curveCollection.adjustHpr(
|
||
|
|
self.playbackTime, VBase3(hpr[0], hpr[1], hpr[2]))
|
||
|
|
# Note: this calls recompute on the curves
|
||
|
|
self.nurbsCurveDrawer.draw()
|
||
|
|
# Update tangent
|
||
|
|
if self.manipulandumId == self.tangentMarker.id():
|
||
|
|
# If manipulating marker, update tangent
|
||
|
|
# Hide playback marker
|
||
|
|
self.playbackMarker.getChild(0).hide()
|
||
|
|
# Where is tangent marker relative to playback marker
|
||
|
|
tan = self.tangentMarker.getPos()
|
||
|
|
# Transform this vector to curve space
|
||
|
|
tan2Curve = Vec3(
|
||
|
|
self.playbackMarker.getMat(
|
||
|
|
self.nodePathParent).xformVec(tan))
|
||
|
|
# Update nurbs curve
|
||
|
|
self.curveCollection.getXyzCurve().adjustTangent(
|
||
|
|
self.playbackTime,
|
||
|
|
tan2Curve[0], tan2Curve[1], tan2Curve[2])
|
||
|
|
# Note: this calls recompute on the curves
|
||
|
|
self.nurbsCurveDrawer.draw()
|
||
|
|
else:
|
||
|
|
# Show playback marker
|
||
|
|
self.playbackMarker.getChild(0).show()
|
||
|
|
# Update tangent marker line
|
||
|
|
tan = Point3(0)
|
||
|
|
self.curveCollection.getXyzCurve().getTangent(
|
||
|
|
self.playbackTime, tan)
|
||
|
|
# Transform this point to playback marker space
|
||
|
|
tan.assign(
|
||
|
|
self.nodePathParent.getMat(
|
||
|
|
self.playbackMarker).xformVec(tan))
|
||
|
|
self.tangentMarker.setPos(tan)
|
||
|
|
# In either case update tangent line
|
||
|
|
self.tangentLines.setVertex(1, tan[0], tan[1], tan[2])
|
||
|
|
return Task.cont
|
||
|
|
|
||
|
|
def manipulateObjectStartHook(self):
|
||
|
|
self.manipulandumId = None
|
||
|
|
if base.direct.selected.last:
|
||
|
|
if base.direct.selected.last.id() == self.playbackMarker.id():
|
||
|
|
self.manipulandumId = self.playbackMarker.id()
|
||
|
|
elif base.direct.selected.last.id() == self.tangentMarker.id():
|
||
|
|
self.manipulandumId = self.tangentMarker.id()
|
||
|
|
|
||
|
|
def manipulateObjectCleanupHook(self, nodePathList = []):
|
||
|
|
# Clear flag
|
||
|
|
self.manipulandumId = None
|
||
|
|
|
||
|
|
def onDestroy(self, event):
|
||
|
|
# Remove hooks
|
||
|
|
for event, method in self.actionEvents:
|
||
|
|
self.ignore(event)
|
||
|
|
# remove start stop hook
|
||
|
|
self.ignore(self.startStopHook)
|
||
|
|
self.ignore(self.keyframeHook)
|
||
|
|
self.curveNodePath.reparentTo(self.recorderNodePath)
|
||
|
|
self.trace.reparentTo(self.recorderNodePath)
|
||
|
|
self.recorderNodePath.removeNode()
|
||
|
|
# Make sure markers are deselected
|
||
|
|
base.direct.deselect(self.playbackMarker)
|
||
|
|
base.direct.deselect(self.tangentMarker)
|
||
|
|
# Remove tasks
|
||
|
|
taskMgr.remove(self.name + '-recordTask')
|
||
|
|
taskMgr.remove(self.name + '-playbackTask')
|
||
|
|
taskMgr.remove(self.name + '-curveEditTask')
|
||
|
|
|
||
|
|
def createNewPointSet(self):
|
||
|
|
self.pointSetName = self.name + '-ps-' + repr(self.pointSetCount)
|
||
|
|
# Update dictionary and record pointer to new point set
|
||
|
|
self.pointSet = self.pointSetDict[self.pointSetName] = []
|
||
|
|
# Update combo box
|
||
|
|
comboBox = self.getWidget('Mopath', 'History')
|
||
|
|
scrolledList = comboBox.component('scrolledlist')
|
||
|
|
listbox = scrolledList.component('listbox')
|
||
|
|
names = list(listbox.get(0,'end'))
|
||
|
|
names.append(self.pointSetName)
|
||
|
|
scrolledList.setlist(names)
|
||
|
|
comboBox.selectitem(self.pointSetName)
|
||
|
|
# Update count
|
||
|
|
self.pointSetCount += 1
|
||
|
|
|
||
|
|
def extractPointSetFromCurveFitter(self):
|
||
|
|
# Get new point set based on newly created curve
|
||
|
|
self.createNewPointSet()
|
||
|
|
for i in range(self.curveFitter.getNumSamples()):
|
||
|
|
time = self.curveFitter.getSampleT(i)
|
||
|
|
pos = Point3(self.curveFitter.getSampleXyz(i))
|
||
|
|
hpr = Point3(self.curveFitter.getSampleHpr(i))
|
||
|
|
self.pointSet.append([time, pos, hpr])
|
||
|
|
|
||
|
|
def extractPointSetFromCurveCollection(self):
|
||
|
|
# Use curve to compute new point set
|
||
|
|
# Record maxT
|
||
|
|
self.maxT = self.curveCollection.getMaxT()
|
||
|
|
# Determine num samples
|
||
|
|
# Limit point set to 1000 points and samples per second to 30
|
||
|
|
samplesPerSegment = min(30.0, 1000.0/self.curveCollection.getMaxT())
|
||
|
|
self.setNumSamples(self.maxT * samplesPerSegment)
|
||
|
|
# Sample the curve but don't create a new curve collection
|
||
|
|
self.sampleCurve(fCompute = 0)
|
||
|
|
# Update widgets based on new data
|
||
|
|
self.updateWidgets()
|
||
|
|
|
||
|
|
def selectPointSetNamed(self, name):
|
||
|
|
self.pointSet = self.pointSetDict.get(name, None)
|
||
|
|
# Reload points into curve fitter
|
||
|
|
# Reset curve fitters
|
||
|
|
self.curveFitter.reset()
|
||
|
|
for time, pos, hpr in self.pointSet:
|
||
|
|
# Add it to the curve fitters
|
||
|
|
self.curveFitter.addXyzHpr(time, pos, hpr)
|
||
|
|
# Compute curve
|
||
|
|
self.computeCurves()
|
||
|
|
|
||
|
|
def setPathVis(self):
|
||
|
|
if self.getVariable('Style', 'Path').get():
|
||
|
|
self.curveNodePath.show()
|
||
|
|
else:
|
||
|
|
self.curveNodePath.hide()
|
||
|
|
|
||
|
|
def setKnotVis(self):
|
||
|
|
self.nurbsCurveDrawer.setShowKnots(
|
||
|
|
self.getVariable('Style', 'Knots').get())
|
||
|
|
|
||
|
|
def setCvVis(self):
|
||
|
|
self.nurbsCurveDrawer.setShowCvs(
|
||
|
|
self.getVariable('Style', 'CVs').get())
|
||
|
|
|
||
|
|
def setHullVis(self):
|
||
|
|
self.nurbsCurveDrawer.setShowHull(
|
||
|
|
self.getVariable('Style', 'Hull').get())
|
||
|
|
|
||
|
|
def setTraceVis(self):
|
||
|
|
if self.getVariable('Style', 'Trace').get():
|
||
|
|
self.trace.show()
|
||
|
|
else:
|
||
|
|
self.trace.hide()
|
||
|
|
|
||
|
|
def setMarkerVis(self):
|
||
|
|
if self.getVariable('Style', 'Marker').get():
|
||
|
|
self.playbackMarker.reparentTo(self.recorderNodePath)
|
||
|
|
else:
|
||
|
|
self.playbackMarker.reparentTo(hidden)
|
||
|
|
|
||
|
|
def setNumSegs(self, value):
|
||
|
|
self.numSegs = int(value)
|
||
|
|
self.nurbsCurveDrawer.setNumSegs(self.numSegs)
|
||
|
|
|
||
|
|
def setNumTicks(self, value):
|
||
|
|
self.nurbsCurveDrawer.setNumTicks(float(value))
|
||
|
|
|
||
|
|
def setTickScale(self, value):
|
||
|
|
self.nurbsCurveDrawer.setTickScale(float(value))
|
||
|
|
|
||
|
|
def setPathColor(self, color):
|
||
|
|
self.nurbsCurveDrawer.setColor(
|
||
|
|
color[0]/255.0, color[1]/255.0, color[2]/255.0)
|
||
|
|
self.nurbsCurveDrawer.draw()
|
||
|
|
|
||
|
|
def setKnotColor(self, color):
|
||
|
|
self.nurbsCurveDrawer.setKnotColor(
|
||
|
|
color[0]/255.0, color[1]/255.0, color[2]/255.0)
|
||
|
|
|
||
|
|
def setCvColor(self, color):
|
||
|
|
self.nurbsCurveDrawer.setCvColor(
|
||
|
|
color[0]/255.0, color[1]/255.0, color[2]/255.0)
|
||
|
|
|
||
|
|
def setTickColor(self, color):
|
||
|
|
self.nurbsCurveDrawer.setTickColor(
|
||
|
|
color[0]/255.0, color[1]/255.0, color[2]/255.0)
|
||
|
|
|
||
|
|
def setHullColor(self, color):
|
||
|
|
self.nurbsCurveDrawer.setHullColor(
|
||
|
|
color[0]/255.0, color[1]/255.0, color[2]/255.0)
|
||
|
|
|
||
|
|
def setStartStopHook(self, event = None):
|
||
|
|
# Clear out old hook
|
||
|
|
self.ignore(self.startStopHook)
|
||
|
|
# Record new one
|
||
|
|
hook = self.getVariable('Recording', 'Record Hook').get()
|
||
|
|
self.startStopHook = hook
|
||
|
|
# Add new one
|
||
|
|
self.accept(self.startStopHook, self.toggleRecordVar)
|
||
|
|
|
||
|
|
def setKeyframeHook(self, event = None):
|
||
|
|
# Clear out old hook
|
||
|
|
self.ignore(self.keyframeHook)
|
||
|
|
# Record new one
|
||
|
|
hook = self.getVariable('Recording', 'Keyframe Hook').get()
|
||
|
|
self.keyframeHook = hook
|
||
|
|
# Add new one
|
||
|
|
self.accept(self.keyframeHook, self.addKeyframe)
|
||
|
|
|
||
|
|
def reset(self):
|
||
|
|
self.pointSet = []
|
||
|
|
self.hasPoints = 0
|
||
|
|
self.curveCollection = None
|
||
|
|
self.curveFitter.reset()
|
||
|
|
self.nurbsCurveDrawer.hide()
|
||
|
|
|
||
|
|
def setSamplingMode(self, mode):
|
||
|
|
self.samplingMode = mode
|
||
|
|
|
||
|
|
def disableKeyframeButton(self):
|
||
|
|
self.getWidget('Recording', 'Add Keyframe')['state'] = 'disabled'
|
||
|
|
def enableKeyframeButton(self):
|
||
|
|
self.getWidget('Recording', 'Add Keyframe')['state'] = 'normal'
|
||
|
|
|
||
|
|
def setRecordingType(self, type):
|
||
|
|
self.recordingType.set(type)
|
||
|
|
|
||
|
|
def setNewCurveMode(self):
|
||
|
|
self.setRecordingType('New Curve')
|
||
|
|
|
||
|
|
def setRefineMode(self):
|
||
|
|
self.setRecordingType('Refine')
|
||
|
|
|
||
|
|
def setExtendMode(self):
|
||
|
|
self.setRecordingType('Extend')
|
||
|
|
|
||
|
|
def toggleRecordVar(self):
|
||
|
|
# Get recording variable
|
||
|
|
v = self.getVariable('Recording', 'Record')
|
||
|
|
# Toggle it
|
||
|
|
v.set(1 - v.get())
|
||
|
|
# Call the command
|
||
|
|
self.toggleRecord()
|
||
|
|
|
||
|
|
def toggleRecord(self):
|
||
|
|
if self.getVariable('Recording', 'Record').get():
|
||
|
|
# Kill old tasks
|
||
|
|
taskMgr.remove(self.name + '-recordTask')
|
||
|
|
taskMgr.remove(self.name + '-curveEditTask')
|
||
|
|
# Remove old curve
|
||
|
|
self.nurbsCurveDrawer.hide()
|
||
|
|
# Reset curve fitters
|
||
|
|
self.curveFitter.reset()
|
||
|
|
# Update sampling mode button if necessary
|
||
|
|
if self.samplingMode == 'Continuous':
|
||
|
|
self.disableKeyframeButton()
|
||
|
|
# Create a new point set to hold raw data
|
||
|
|
self.createNewPointSet()
|
||
|
|
# Clear out old trace, get ready to draw new
|
||
|
|
self.initTrace()
|
||
|
|
# Keyframe mode?
|
||
|
|
if (self.samplingMode == 'Keyframe'):
|
||
|
|
# Record first point
|
||
|
|
self.lastPos.assign(Point3(
|
||
|
|
self.nodePath.getPos(self.nodePathParent)))
|
||
|
|
# Init delta time
|
||
|
|
self.deltaTime = 0.0
|
||
|
|
# Record first point
|
||
|
|
self.recordPoint(self.recordStart)
|
||
|
|
# Everything else
|
||
|
|
else:
|
||
|
|
if ((self.recordingType.get() == 'Refine') or
|
||
|
|
(self.recordingType.get() == 'Extend')):
|
||
|
|
# Turn off looping playback
|
||
|
|
self.loopPlayback = 0
|
||
|
|
# Update widget to reflect new value
|
||
|
|
self.getVariable('Playback', 'Loop').set(0)
|
||
|
|
# Select tempCS as playback nodepath
|
||
|
|
self.oldPlaybackNodePath = self.playbackNodePath
|
||
|
|
self.setPlaybackNodePath(self.tempCS)
|
||
|
|
# Parent record node path to temp
|
||
|
|
self.nodePath.reparentTo(self.playbackNodePath)
|
||
|
|
# Align with temp
|
||
|
|
self.nodePath.setPosHpr(0, 0, 0, 0, 0, 0)
|
||
|
|
# Set playback start to self.recordStart
|
||
|
|
self.playbackGoTo(self.recordStart)
|
||
|
|
# start flying nodePath along path
|
||
|
|
self.startPlayback()
|
||
|
|
# Start new task
|
||
|
|
t = taskMgr.add(
|
||
|
|
self.recordTask, self.name + '-recordTask')
|
||
|
|
t.startTime = globalClock.getFrameTime()
|
||
|
|
else:
|
||
|
|
if self.samplingMode == 'Continuous':
|
||
|
|
# Kill old task
|
||
|
|
taskMgr.remove(self.name + '-recordTask')
|
||
|
|
if ((self.recordingType.get() == 'Refine') or
|
||
|
|
(self.recordingType.get() == 'Extend')):
|
||
|
|
# Reparent node path back to parent
|
||
|
|
self.nodePath.wrtReparentTo(self.nodePathParent)
|
||
|
|
# Restore playback Node Path
|
||
|
|
self.setPlaybackNodePath(self.oldPlaybackNodePath)
|
||
|
|
else:
|
||
|
|
# Add last point
|
||
|
|
self.addKeyframe(0)
|
||
|
|
# Reset sampling mode
|
||
|
|
self.setSamplingMode('Continuous')
|
||
|
|
self.enableKeyframeButton()
|
||
|
|
# Clean up after refine or extend
|
||
|
|
if ((self.recordingType.get() == 'Refine') or
|
||
|
|
(self.recordingType.get() == 'Extend')):
|
||
|
|
# Merge prePoints, pointSet, postPoints
|
||
|
|
self.mergePoints()
|
||
|
|
# Clear out pre and post list
|
||
|
|
self.prePoints = []
|
||
|
|
self.postPoints = []
|
||
|
|
# Reset recording mode
|
||
|
|
self.setNewCurveMode()
|
||
|
|
# Compute curve
|
||
|
|
self.computeCurves()
|
||
|
|
|
||
|
|
def recordTask(self, state):
|
||
|
|
# Record raw data point
|
||
|
|
time = self.recordStart + (
|
||
|
|
globalClock.getFrameTime() - state.startTime)
|
||
|
|
self.recordPoint(time)
|
||
|
|
return Task.cont
|
||
|
|
|
||
|
|
def addKeyframe(self, fToggleRecord = 1):
|
||
|
|
# Make sure we're in a recording mode!
|
||
|
|
if (fToggleRecord and
|
||
|
|
(not self.getVariable('Recording', 'Record').get())):
|
||
|
|
# Set sampling mode
|
||
|
|
self.setSamplingMode('Keyframe')
|
||
|
|
# This will automatically add the first point
|
||
|
|
self.toggleRecordVar()
|
||
|
|
else:
|
||
|
|
# Use distance as a time
|
||
|
|
pos = self.nodePath.getPos(self.nodePathParent)
|
||
|
|
deltaPos = Vec3(pos - self.lastPos).length()
|
||
|
|
if deltaPos != 0:
|
||
|
|
# If we've moved at all, use delta Pos as time
|
||
|
|
self.deltaTime = self.deltaTime + deltaPos
|
||
|
|
else:
|
||
|
|
# Otherwise add one second
|
||
|
|
self.deltaTime = self.deltaTime + 1.0
|
||
|
|
# Record point at new time
|
||
|
|
self.recordPoint(self.recordStart + self.deltaTime)
|
||
|
|
# Update last pos
|
||
|
|
self.lastPos.assign(pos)
|
||
|
|
|
||
|
|
def easeInOut(self, t):
|
||
|
|
x = t * t
|
||
|
|
return (3 * x) - (2 * t * x)
|
||
|
|
|
||
|
|
def setPreRecordFunc(self, func):
|
||
|
|
# Note: If func is one defined at command prompt, need to set
|
||
|
|
# __builtins__.func = func at command line
|
||
|
|
self.preRecordFunc = eval(func)
|
||
|
|
# Update widget to reflect new value
|
||
|
|
self.getVariable('Recording', 'PRF Active').set(1)
|
||
|
|
|
||
|
|
def recordPoint(self, time):
|
||
|
|
# Call user define callback before recording point
|
||
|
|
if (self.getVariable('Recording', 'PRF Active').get() and
|
||
|
|
(self.preRecordFunc != None)):
|
||
|
|
self.preRecordFunc()
|
||
|
|
# Get point
|
||
|
|
pos = self.nodePath.getPos(self.nodePathParent)
|
||
|
|
hpr = self.nodePath.getHpr(self.nodePathParent)
|
||
|
|
qNP = Quat()
|
||
|
|
qNP.setHpr(hpr)
|
||
|
|
# Blend between recordNodePath and self.nodePath
|
||
|
|
if ((self.recordingType.get() == 'Refine') or
|
||
|
|
(self.recordingType.get() == 'Extend')):
|
||
|
|
if ((time < self.controlStart) and
|
||
|
|
((self.controlStart - self.recordStart) != 0.0)):
|
||
|
|
rPos = self.playbackNodePath.getPos(self.nodePathParent)
|
||
|
|
rHpr = self.playbackNodePath.getHpr(self.nodePathParent)
|
||
|
|
qR = Quat()
|
||
|
|
qR.setHpr(rHpr)
|
||
|
|
t = self.easeInOut(((time - self.recordStart)/
|
||
|
|
(self.controlStart - self.recordStart)))
|
||
|
|
# Transition between the recorded node path and the driven one
|
||
|
|
pos = (rPos * (1 - t)) + (pos * t)
|
||
|
|
q = qSlerp(qR, qNP, t)
|
||
|
|
hpr.assign(q.getHpr())
|
||
|
|
elif ((self.recordingType.get() == 'Refine') and
|
||
|
|
(time > self.controlStop) and
|
||
|
|
((self.recordStop - self.controlStop) != 0.0)):
|
||
|
|
rPos = self.playbackNodePath.getPos(self.nodePathParent)
|
||
|
|
rHpr = self.playbackNodePath.getHpr(self.nodePathParent)
|
||
|
|
qR = Quat()
|
||
|
|
qR.setHpr(rHpr)
|
||
|
|
t = self.easeInOut(((time - self.controlStop)/
|
||
|
|
(self.recordStop - self.controlStop)))
|
||
|
|
# Transition between the recorded node path and the driven one
|
||
|
|
pos = (pos * (1 - t)) + (rPos * t)
|
||
|
|
q = qSlerp(qNP, qR, t)
|
||
|
|
hpr.assign(q.getHpr())
|
||
|
|
# Add it to the point set
|
||
|
|
self.pointSet.append([time, pos, hpr])
|
||
|
|
# Add it to the curve fitters
|
||
|
|
self.curveFitter.addXyzHpr(time, pos, hpr)
|
||
|
|
# Update trace now if recording keyframes
|
||
|
|
if (self.samplingMode == 'Keyframe'):
|
||
|
|
self.trace.reset()
|
||
|
|
for t, p, h in self.pointSet:
|
||
|
|
self.trace.drawTo(p[0], p[1], p[2])
|
||
|
|
self.trace.create()
|
||
|
|
|
||
|
|
def computeCurves(self):
|
||
|
|
# Check to make sure curve fitters have points
|
||
|
|
if (self.curveFitter.getNumSamples() == 0):
|
||
|
|
print 'MopathRecorder.computeCurves: Must define curve first'
|
||
|
|
return
|
||
|
|
# Create curves
|
||
|
|
# XYZ
|
||
|
|
self.curveFitter.sortPoints()
|
||
|
|
self.curveFitter.wrapHpr()
|
||
|
|
self.curveFitter.computeTangents(1)
|
||
|
|
# This is really a collection
|
||
|
|
self.curveCollection = self.curveFitter.makeNurbs()
|
||
|
|
self.nurbsCurveDrawer.setCurves(self.curveCollection)
|
||
|
|
self.nurbsCurveDrawer.draw()
|
||
|
|
# Update widget based on new curve
|
||
|
|
self.updateWidgets()
|
||
|
|
|
||
|
|
def initTrace(self):
|
||
|
|
self.trace.reset()
|
||
|
|
# Put trace line segs under node path's parent
|
||
|
|
self.trace.reparentTo(self.nodePathParent)
|
||
|
|
# Show it
|
||
|
|
self.trace.show()
|
||
|
|
|
||
|
|
def updateWidgets(self):
|
||
|
|
if not self.curveCollection:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
# Widgets depending on max T
|
||
|
|
maxT = self.curveCollection.getMaxT()
|
||
|
|
maxT_text = '%0.2f' % maxT
|
||
|
|
# Playback controls
|
||
|
|
self.getWidget('Playback', 'Time').configure(max = maxT_text)
|
||
|
|
self.getVariable('Resample', 'Path Duration').set(maxT_text)
|
||
|
|
# Refine widgets
|
||
|
|
widget = self.getWidget('Refine Page', 'Refine From')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(0.0)
|
||
|
|
widget = self.getWidget('Refine Page', 'Control Start')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(0.0)
|
||
|
|
widget = self.getWidget('Refine Page', 'Control Stop')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(maxT))
|
||
|
|
widget = self.getWidget('Refine Page', 'Refine To')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(maxT))
|
||
|
|
# Extend widgets
|
||
|
|
widget = self.getWidget('Extend Page', 'Extend From')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(0.0))
|
||
|
|
widget = self.getWidget('Extend Page', 'Control Start')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(0.0))
|
||
|
|
# Crop widgets
|
||
|
|
widget = self.getWidget('Crop Page', 'Crop From')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(0.0))
|
||
|
|
widget = self.getWidget('Crop Page', 'Crop To')
|
||
|
|
widget.configure(max = maxT)
|
||
|
|
widget.set(float(maxT))
|
||
|
|
self.maxT = float(maxT)
|
||
|
|
# Widgets depending on number of samples
|
||
|
|
numSamples = self.curveFitter.getNumSamples()
|
||
|
|
widget = self.getWidget('Resample', 'Points Between Samples')
|
||
|
|
widget.configure(max=numSamples)
|
||
|
|
widget = self.getWidget('Resample', 'Num. Samples')
|
||
|
|
widget.configure(max = 4 * numSamples)
|
||
|
|
widget.set(numSamples, 0)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def selectNodePathNamed(self, name):
|
||
|
|
nodePath = None
|
||
|
|
if name == 'init':
|
||
|
|
nodePath = self.nodePath
|
||
|
|
# Add Combo box entry for the initial node path
|
||
|
|
self.addNodePath(nodePath)
|
||
|
|
elif name == 'selected':
|
||
|
|
nodePath = base.direct.selected.last
|
||
|
|
# Add Combo box entry for this selected object
|
||
|
|
self.addNodePath(nodePath)
|
||
|
|
else:
|
||
|
|
nodePath = self.nodePathDict.get(name, None)
|
||
|
|
if (nodePath == None):
|
||
|
|
# See if this evaluates into a node path
|
||
|
|
try:
|
||
|
|
nodePath = eval(name)
|
||
|
|
if isinstance(nodePath, NodePath):
|
||
|
|
self.addNodePath(nodePath)
|
||
|
|
else:
|
||
|
|
# Good eval but not a node path, give up
|
||
|
|
nodePath = None
|
||
|
|
except:
|
||
|
|
# Bogus eval
|
||
|
|
nodePath = None
|
||
|
|
# Clear bogus entry from listbox
|
||
|
|
listbox = self.nodePathMenu.component('scrolledlist')
|
||
|
|
listbox.setlist(self.nodePathNames)
|
||
|
|
else:
|
||
|
|
if name == 'widget':
|
||
|
|
# Record relationship between selected nodes and widget
|
||
|
|
base.direct.selected.getWrtAll()
|
||
|
|
if name == 'marker':
|
||
|
|
self.playbackMarker.show()
|
||
|
|
# Initialize tangent marker position
|
||
|
|
tan = Point3(0)
|
||
|
|
if self.curveCollection != None:
|
||
|
|
self.curveCollection.getXyzCurve().getTangent(
|
||
|
|
self.playbackTime, tan)
|
||
|
|
self.tangentMarker.setPos(tan)
|
||
|
|
else:
|
||
|
|
self.playbackMarker.hide()
|
||
|
|
# Update active node path
|
||
|
|
self.setNodePath(nodePath)
|
||
|
|
|
||
|
|
def setNodePath(self, nodePath):
|
||
|
|
self.playbackNodePath = self.nodePath = nodePath
|
||
|
|
if self.nodePath:
|
||
|
|
# Record nopath's parent
|
||
|
|
self.nodePathParent = self.nodePath.getParent()
|
||
|
|
# Put curve drawer under record node path's parent
|
||
|
|
self.curveNodePath.reparentTo(self.nodePathParent)
|
||
|
|
# Set entry color
|
||
|
|
self.nodePathMenuEntry.configure(
|
||
|
|
background = self.nodePathMenuBG)
|
||
|
|
else:
|
||
|
|
# Flash entry
|
||
|
|
self.nodePathMenuEntry.configure(background = 'Pink')
|
||
|
|
|
||
|
|
def setPlaybackNodePath(self, nodePath):
|
||
|
|
self.playbackNodePath = nodePath
|
||
|
|
|
||
|
|
def addNodePath(self, nodePath):
|
||
|
|
self.addNodePathToDict(nodePath, self.nodePathNames,
|
||
|
|
self.nodePathMenu, self.nodePathDict)
|
||
|
|
|
||
|
|
def addNodePathToDict(self, nodePath, names, menu, dict):
|
||
|
|
if not nodePath:
|
||
|
|
return
|
||
|
|
# Get node path's name
|
||
|
|
name = nodePath.getName()
|
||
|
|
if name in ['mopathRecorderTempCS', 'widget', 'camera', 'marker']:
|
||
|
|
dictName = name
|
||
|
|
else:
|
||
|
|
# Generate a unique name for the dict
|
||
|
|
dictName = name + '-' + repr(nodePath.id())
|
||
|
|
if dictName not in dict:
|
||
|
|
# Update combo box to include new item
|
||
|
|
names.append(dictName)
|
||
|
|
listbox = menu.component('scrolledlist')
|
||
|
|
listbox.setlist(names)
|
||
|
|
# Add new item to dictionary
|
||
|
|
dict[dictName] = nodePath
|
||
|
|
menu.selectitem(dictName)
|
||
|
|
|
||
|
|
def setLoopPlayback(self):
|
||
|
|
self.loopPlayback = self.getVariable('Playback', 'Loop').get()
|
||
|
|
|
||
|
|
def playbackGoTo(self, time):
|
||
|
|
if self.curveCollection == None:
|
||
|
|
return
|
||
|
|
self.playbackTime = CLAMP(time, 0.0, self.maxT)
|
||
|
|
if self.curveCollection != None:
|
||
|
|
pos = Point3(0)
|
||
|
|
hpr = Point3(0)
|
||
|
|
self.curveCollection.evaluate(self.playbackTime, pos, hpr)
|
||
|
|
self.playbackNodePath.setPosHpr(self.nodePathParent, pos, hpr)
|
||
|
|
|
||
|
|
def startPlayback(self):
|
||
|
|
if self.curveCollection == None:
|
||
|
|
return
|
||
|
|
# Kill any existing tasks
|
||
|
|
self.stopPlayback()
|
||
|
|
# Make sure checkbutton is set
|
||
|
|
self.getVariable('Playback', 'Play').set(1)
|
||
|
|
# Start new playback task
|
||
|
|
t = taskMgr.add(
|
||
|
|
self.playbackTask, self.name + '-playbackTask')
|
||
|
|
t.currentTime = self.playbackTime
|
||
|
|
t.lastTime = globalClock.getFrameTime()
|
||
|
|
|
||
|
|
def setSpeedScale(self, value):
|
||
|
|
self.speedScale.set(math.log10(value))
|
||
|
|
|
||
|
|
def setPlaybackSF(self, value):
|
||
|
|
self.playbackSF = pow(10.0, float(value))
|
||
|
|
self.speedVar.set('%0.2f' % self.playbackSF)
|
||
|
|
|
||
|
|
def playbackTask(self, state):
|
||
|
|
time = globalClock.getFrameTime()
|
||
|
|
dTime = self.playbackSF * (time - state.lastTime)
|
||
|
|
state.lastTime = time
|
||
|
|
if self.loopPlayback:
|
||
|
|
cTime = (state.currentTime + dTime) % self.maxT
|
||
|
|
else:
|
||
|
|
cTime = state.currentTime + dTime
|
||
|
|
# Stop task if not looping and at end of curve
|
||
|
|
# Or if refining curve and past recordStop
|
||
|
|
if ((self.recordingType.get() == 'Refine') and
|
||
|
|
(cTime > self.recordStop)):
|
||
|
|
# Go to recordStop
|
||
|
|
self.getWidget('Playback', 'Time').set(self.recordStop)
|
||
|
|
# Then stop playback
|
||
|
|
self.stopPlayback()
|
||
|
|
# Also kill record task
|
||
|
|
self.toggleRecordVar()
|
||
|
|
return Task.done
|
||
|
|
elif ((self.loopPlayback == 0) and (cTime > self.maxT)):
|
||
|
|
# Go to maxT
|
||
|
|
self.getWidget('Playback', 'Time').set(self.maxT)
|
||
|
|
# Then stop playback
|
||
|
|
self.stopPlayback()
|
||
|
|
return Task.done
|
||
|
|
elif ((self.recordingType.get() == 'Extend') and
|
||
|
|
(cTime > self.controlStart)):
|
||
|
|
# Go to final point
|
||
|
|
self.getWidget('Playback', 'Time').set(self.controlStart)
|
||
|
|
# Stop playback
|
||
|
|
self.stopPlayback()
|
||
|
|
return Task.done
|
||
|
|
# Otherwise go to specified time and continue
|
||
|
|
self.getWidget('Playback', 'Time').set(cTime)
|
||
|
|
state.currentTime = cTime
|
||
|
|
return Task.cont
|
||
|
|
|
||
|
|
def stopPlayback(self):
|
||
|
|
self.getVariable('Playback', 'Play').set(0)
|
||
|
|
taskMgr.remove(self.name + '-playbackTask')
|
||
|
|
|
||
|
|
def jumpToStartOfPlayback(self):
|
||
|
|
self.stopPlayback()
|
||
|
|
self.getWidget('Playback', 'Time').set(0.0)
|
||
|
|
|
||
|
|
def jumpToEndOfPlayback(self):
|
||
|
|
self.stopPlayback()
|
||
|
|
if self.curveCollection != None:
|
||
|
|
self.getWidget('Playback', 'Time').set(self.maxT)
|
||
|
|
|
||
|
|
def startStopPlayback(self):
|
||
|
|
if self.getVariable('Playback', 'Play').get():
|
||
|
|
self.startPlayback()
|
||
|
|
else:
|
||
|
|
self.stopPlayback()
|
||
|
|
|
||
|
|
def setDesampleFrequency(self, frequency):
|
||
|
|
self.desampleFrequency = frequency
|
||
|
|
|
||
|
|
def desampleCurve(self):
|
||
|
|
if (self.curveFitter.getNumSamples() == 0):
|
||
|
|
print 'MopathRecorder.desampleCurve: Must define curve first'
|
||
|
|
return
|
||
|
|
# NOTE: This is destructive, points will be deleted from curve fitter
|
||
|
|
self.curveFitter.desample(self.desampleFrequency)
|
||
|
|
# Compute new curve based on desampled data
|
||
|
|
self.computeCurves()
|
||
|
|
# Get point set from the curve fitter
|
||
|
|
self.extractPointSetFromCurveFitter()
|
||
|
|
|
||
|
|
def setNumSamples(self, numSamples):
|
||
|
|
self.numSamples = int(numSamples)
|
||
|
|
|
||
|
|
def sampleCurve(self, fCompute = 1):
|
||
|
|
if self.curveCollection == None:
|
||
|
|
print 'MopathRecorder.sampleCurve: Must define curve first'
|
||
|
|
return
|
||
|
|
# Reset curve fitters
|
||
|
|
self.curveFitter.reset()
|
||
|
|
# Sample curve using specified number of samples
|
||
|
|
self.curveFitter.sample(self.curveCollection, self.numSamples)
|
||
|
|
if fCompute:
|
||
|
|
# Now recompute curves
|
||
|
|
self.computeCurves()
|
||
|
|
# Get point set from the curve fitter
|
||
|
|
self.extractPointSetFromCurveFitter()
|
||
|
|
|
||
|
|
def makeEven(self):
|
||
|
|
# Note: segments_per_unit = 2 seems to give a good fit
|
||
|
|
self.curveCollection.makeEven(self.maxT, 2)
|
||
|
|
# Get point set from curve
|
||
|
|
self.extractPointSetFromCurveCollection()
|
||
|
|
|
||
|
|
def faceForward(self):
|
||
|
|
# Note: segments_per_unit = 2 seems to give a good fit
|
||
|
|
self.curveCollection.faceForward(2)
|
||
|
|
# Get point set from curve
|
||
|
|
self.extractPointSetFromCurveCollection()
|
||
|
|
|
||
|
|
def setPathDuration(self, event):
|
||
|
|
newMaxT = float(self.getWidget('Resample', 'Path Duration').get())
|
||
|
|
self.setPathDurationTo(newMaxT)
|
||
|
|
|
||
|
|
def setPathDurationTo(self, newMaxT):
|
||
|
|
# Compute scale factor
|
||
|
|
sf = newMaxT/self.maxT
|
||
|
|
# Scale curve collection
|
||
|
|
self.curveCollection.resetMaxT(newMaxT)
|
||
|
|
# Scale point set
|
||
|
|
# Save handle to old point set
|
||
|
|
oldPointSet = self.pointSet
|
||
|
|
# Create new point set
|
||
|
|
self.createNewPointSet()
|
||
|
|
# Reset curve fitters
|
||
|
|
self.curveFitter.reset()
|
||
|
|
# Now scale values
|
||
|
|
for time, pos, hpr in oldPointSet:
|
||
|
|
newTime = time * sf
|
||
|
|
# Update point set
|
||
|
|
self.pointSet.append([newTime, Point3(pos), Point3(hpr)])
|
||
|
|
# Add it to the curve fitters
|
||
|
|
self.curveFitter.addXyzHpr(newTime, pos, hpr)
|
||
|
|
# Update widgets
|
||
|
|
self.updateWidgets()
|
||
|
|
# Compute curve
|
||
|
|
#self.computeCurves()
|
||
|
|
|
||
|
|
def setRecordStart(self, value):
|
||
|
|
self.recordStart = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
# Adjust refine widgets
|
||
|
|
# Make sure we're in sync
|
||
|
|
self.getWidget('Refine Page', 'Refine From').set(
|
||
|
|
self.recordStart)
|
||
|
|
self.getWidget('Extend Page', 'Extend From').set(
|
||
|
|
self.recordStart)
|
||
|
|
# Check bounds
|
||
|
|
if self.recordStart > self.controlStart:
|
||
|
|
self.getWidget('Refine Page', 'Control Start').set(
|
||
|
|
self.recordStart)
|
||
|
|
self.getWidget('Extend Page', 'Control Start').set(
|
||
|
|
self.recordStart)
|
||
|
|
if self.recordStart > self.controlStop:
|
||
|
|
self.getWidget('Refine Page', 'Control Stop').set(
|
||
|
|
self.recordStart)
|
||
|
|
if self.recordStart > self.recordStop:
|
||
|
|
self.getWidget('Refine Page', 'Refine To').set(self.recordStart)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def getPrePoints(self, type = 'Refine'):
|
||
|
|
# Switch to appropriate recording type
|
||
|
|
self.setRecordingType(type)
|
||
|
|
# Reset prePoints
|
||
|
|
self.prePoints = []
|
||
|
|
# See if we need to save any points before recordStart
|
||
|
|
for i in range(len(self.pointSet)):
|
||
|
|
# Have we passed recordStart?
|
||
|
|
if self.recordStart < self.pointSet[i][0]:
|
||
|
|
# Get a copy of the points prior to recordStart
|
||
|
|
self.prePoints = self.pointSet[:i-1]
|
||
|
|
break
|
||
|
|
|
||
|
|
def setControlStart(self, value):
|
||
|
|
self.controlStart = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
# Adjust refine widgets
|
||
|
|
# Make sure both pages are in sync
|
||
|
|
self.getWidget('Refine Page', 'Control Start').set(
|
||
|
|
self.controlStart)
|
||
|
|
self.getWidget('Extend Page', 'Control Start').set(
|
||
|
|
self.controlStart)
|
||
|
|
# Check bounds on other widgets
|
||
|
|
if self.controlStart < self.recordStart:
|
||
|
|
self.getWidget('Refine Page', 'Refine From').set(
|
||
|
|
self.controlStart)
|
||
|
|
self.getWidget('Extend Page', 'Extend From').set(
|
||
|
|
self.controlStart)
|
||
|
|
if self.controlStart > self.controlStop:
|
||
|
|
self.getWidget('Refine Page', 'Control Stop').set(
|
||
|
|
self.controlStart)
|
||
|
|
if self.controlStart > self.recordStop:
|
||
|
|
self.getWidget('Refine Page', 'Refine To').set(
|
||
|
|
self.controlStart)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def setControlStop(self, value):
|
||
|
|
self.controlStop = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
if self.controlStop < self.recordStart:
|
||
|
|
self.getWidget('Refine Page', 'Refine From').set(
|
||
|
|
self.controlStop)
|
||
|
|
if self.controlStop < self.controlStart:
|
||
|
|
self.getWidget('Refine Page', 'Control Start').set(
|
||
|
|
self.controlStop)
|
||
|
|
if self.controlStop > self.recordStop:
|
||
|
|
self.getWidget('Refine Page', 'Refine To').set(
|
||
|
|
self.controlStop)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def setRefineStop(self, value):
|
||
|
|
self.recordStop = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
if self.recordStop < self.recordStart:
|
||
|
|
self.getWidget('Refine Page', 'Refine From').set(
|
||
|
|
self.recordStop)
|
||
|
|
if self.recordStop < self.controlStart:
|
||
|
|
self.getWidget('Refine Page', 'Control Start').set(
|
||
|
|
self.recordStop)
|
||
|
|
if self.recordStop < self.controlStop:
|
||
|
|
self.getWidget('Refine Page', 'Control Stop').set(
|
||
|
|
self.recordStop)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def getPostPoints(self):
|
||
|
|
# Set flag so we know to do a refine pass
|
||
|
|
self.setRefineMode()
|
||
|
|
# Reset postPoints
|
||
|
|
self.postPoints = []
|
||
|
|
# See if we need to save any points after recordStop
|
||
|
|
for i in range(len(self.pointSet)):
|
||
|
|
# Have we reached recordStop?
|
||
|
|
if self.recordStop < self.pointSet[i][0]:
|
||
|
|
# Get a copy of the points after recordStop
|
||
|
|
self.postPoints = self.pointSet[i:]
|
||
|
|
break
|
||
|
|
|
||
|
|
def mergePoints(self):
|
||
|
|
# prepend pre points
|
||
|
|
self.pointSet[0:0] = self.prePoints
|
||
|
|
for time, pos, hpr in self.prePoints:
|
||
|
|
# Add it to the curve fitters
|
||
|
|
self.curveFitter.addXyzHpr(time, pos, hpr)
|
||
|
|
# And post points
|
||
|
|
# What is end time of pointSet?
|
||
|
|
endTime = self.pointSet[-1][0]
|
||
|
|
for time, pos, hpr in self.postPoints:
|
||
|
|
adjustedTime = endTime + (time - self.recordStop)
|
||
|
|
# Add it to point set
|
||
|
|
self.pointSet.append([adjustedTime, pos, hpr])
|
||
|
|
# Add it to the curve fitters
|
||
|
|
self.curveFitter.addXyzHpr(adjustedTime, pos, hpr)
|
||
|
|
|
||
|
|
def setCropFrom(self, value):
|
||
|
|
self.cropFrom = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
if self.cropFrom > self.cropTo:
|
||
|
|
self.getWidget('Crop Page', 'Crop To').set(
|
||
|
|
self.cropFrom)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def setCropTo(self, value):
|
||
|
|
self.cropTo = value
|
||
|
|
# Someone else is adjusting values, let them take care of it
|
||
|
|
if self.fAdjustingValues:
|
||
|
|
return
|
||
|
|
self.fAdjustingValues = 1
|
||
|
|
if self.cropTo < self.cropFrom:
|
||
|
|
self.getWidget('Crop Page', 'Crop From').set(
|
||
|
|
self.cropTo)
|
||
|
|
# Move playback node path to specified time
|
||
|
|
self.getWidget('Playback', 'Time').set(value)
|
||
|
|
self.fAdjustingValues = 0
|
||
|
|
|
||
|
|
def cropCurve(self):
|
||
|
|
if self.pointSet == None:
|
||
|
|
print 'Empty Point Set'
|
||
|
|
return
|
||
|
|
# Keep handle on old points
|
||
|
|
oldPoints = self.pointSet
|
||
|
|
# Create new point set
|
||
|
|
self.createNewPointSet()
|
||
|
|
# Copy over points between from/to
|
||
|
|
# Reset curve fitters
|
||
|
|
self.curveFitter.reset()
|
||
|
|
# Add start point
|
||
|
|
pos = Point3(0)
|
||
|
|
hpr = Point3(0)
|
||
|
|
self.curveCollection.evaluate(self.cropFrom, pos, hpr)
|
||
|
|
self.curveFitter.addXyzHpr(0.0, pos, hpr)
|
||
|
|
# Get points within bounds
|
||
|
|
for time, pos, hpr in oldPoints:
|
||
|
|
# Is it within the time?
|
||
|
|
if ((time > self.cropFrom) and
|
||
|
|
(time < self.cropTo)):
|
||
|
|
# Add it to the curve fitters
|
||
|
|
t = time - self.cropFrom
|
||
|
|
self.curveFitter.addXyzHpr(t, pos, hpr)
|
||
|
|
# And the point set
|
||
|
|
self.pointSet.append([t, pos, hpr])
|
||
|
|
# Add last point
|
||
|
|
pos = Vec3(0)
|
||
|
|
hpr = Vec3(0)
|
||
|
|
self.curveCollection.evaluate(self.cropTo, pos, hpr)
|
||
|
|
self.curveFitter.addXyzHpr(self.cropTo - self.cropFrom, pos, hpr)
|
||
|
|
# Compute curve
|
||
|
|
self.computeCurves()
|
||
|
|
|
||
|
|
def loadCurveFromFile(self):
|
||
|
|
# Use first directory in model path
|
||
|
|
mPath = getModelPath()
|
||
|
|
if mPath.getNumDirectories() > 0:
|
||
|
|
if repr(mPath.getDirectory(0)) == '.':
|
||
|
|
path = '.'
|
||
|
|
else:
|
||
|
|
path = mPath.getDirectory(0).toOsSpecific()
|
||
|
|
else:
|
||
|
|
path = '.'
|
||
|
|
if not os.path.isdir(path):
|
||
|
|
print 'MopathRecorder Info: Empty Model Path!'
|
||
|
|
print 'Using current directory'
|
||
|
|
path = '.'
|
||
|
|
mopathFilename = askopenfilename(
|
||
|
|
defaultextension = '.egg',
|
||
|
|
filetypes = (('Egg Files', '*.egg'),
|
||
|
|
('Bam Files', '*.bam'),
|
||
|
|
('All files', '*')),
|
||
|
|
initialdir = path,
|
||
|
|
title = 'Load Nurbs Curve',
|
||
|
|
parent = self.parent)
|
||
|
|
if mopathFilename:
|
||
|
|
self.reset()
|
||
|
|
nodePath = loader.loadModel(
|
||
|
|
Filename.fromOsSpecific(mopathFilename))
|
||
|
|
self.curveCollection = ParametricCurveCollection()
|
||
|
|
# MRM: Add error check
|
||
|
|
self.curveCollection.addCurves(nodePath.node())
|
||
|
|
nodePath.removeNode()
|
||
|
|
if self.curveCollection:
|
||
|
|
# Draw the curve
|
||
|
|
self.nurbsCurveDrawer.setCurves(self.curveCollection)
|
||
|
|
self.nurbsCurveDrawer.draw()
|
||
|
|
# Save a pointset for this curve
|
||
|
|
self.extractPointSetFromCurveCollection()
|
||
|
|
else:
|
||
|
|
self.reset()
|
||
|
|
|
||
|
|
def saveCurveToFile(self):
|
||
|
|
# Use first directory in model path
|
||
|
|
mPath = getModelPath()
|
||
|
|
if mPath.getNumDirectories() > 0:
|
||
|
|
if repr(mPath.getDirectory(0)) == '.':
|
||
|
|
path = '.'
|
||
|
|
else:
|
||
|
|
path = mPath.getDirectory(0).toOsSpecific()
|
||
|
|
else:
|
||
|
|
path = '.'
|
||
|
|
if not os.path.isdir(path):
|
||
|
|
print 'MopathRecorder Info: Empty Model Path!'
|
||
|
|
print 'Using current directory'
|
||
|
|
path = '.'
|
||
|
|
mopathFilename = asksaveasfilename(
|
||
|
|
defaultextension = '.egg',
|
||
|
|
filetypes = (('Egg Files', '*.egg'),
|
||
|
|
('Bam Files', '*.bam'),
|
||
|
|
('All files', '*')),
|
||
|
|
initialdir = path,
|
||
|
|
title = 'Save Nurbs Curve as',
|
||
|
|
parent = self.parent)
|
||
|
|
if mopathFilename:
|
||
|
|
self.curveCollection.writeEgg(Filename(mopathFilename))
|
||
|
|
|
||
|
|
def followTerrain(self, height = 1.0):
|
||
|
|
self.iRay.rayCollisionNodePath.reparentTo(self.nodePath)
|
||
|
|
entry = self.iRay.pickGeom3D()
|
||
|
|
if entry:
|
||
|
|
hitPtDist = Vec3(entry.getFromIntersectionPoint()).length()
|
||
|
|
self.nodePath.setZ(self.nodePath, height - hitPtDist)
|
||
|
|
self.iRay.rayCollisionNodePath.reparentTo(self.recorderNodePath)
|
||
|
|
|
||
|
|
## WIDGET UTILITY FUNCTIONS ##
|
||
|
|
def addWidget(self, widget, category, text):
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
|
||
|
|
def getWidget(self, category, text):
|
||
|
|
return self.widgetDict[category + '-' + text]
|
||
|
|
|
||
|
|
def getVariable(self, category, text):
|
||
|
|
return self.variableDict[category + '-' + text]
|
||
|
|
|
||
|
|
def createLabeledEntry(self, parent, category, text, balloonHelp,
|
||
|
|
value = '', command = None,
|
||
|
|
relief = 'sunken', side = LEFT,
|
||
|
|
expand = 1, width = 12):
|
||
|
|
frame = Frame(parent)
|
||
|
|
variable = StringVar()
|
||
|
|
variable.set(value)
|
||
|
|
label = Label(frame, text = text)
|
||
|
|
label.pack(side = LEFT, fill = X)
|
||
|
|
self.bind(label, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text + '-Label'] = label
|
||
|
|
entry = Entry(frame, width = width, relief = relief,
|
||
|
|
textvariable = variable)
|
||
|
|
entry.pack(side = LEFT, fill = X, expand = expand)
|
||
|
|
self.bind(entry, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = entry
|
||
|
|
self.variableDict[category + '-' + text] = variable
|
||
|
|
if command:
|
||
|
|
entry.bind('<Return>', command)
|
||
|
|
frame.pack(side = side, fill = X, expand = expand)
|
||
|
|
return (frame, label, entry)
|
||
|
|
|
||
|
|
def createButton(self, parent, category, text, balloonHelp, command,
|
||
|
|
side = 'top', expand = 0, fill = X):
|
||
|
|
widget = Button(parent, text = text)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createCheckbutton(self, parent, category, text,
|
||
|
|
balloonHelp, command, initialState,
|
||
|
|
side = 'top', fill = X, expand = 0):
|
||
|
|
bool = BooleanVar()
|
||
|
|
bool.set(initialState)
|
||
|
|
widget = Checkbutton(parent, text = text, anchor = W,
|
||
|
|
variable = bool)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
self.variableDict[category + '-' + text] = bool
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createRadiobutton(self, parent, side, category, text,
|
||
|
|
balloonHelp, variable, value,
|
||
|
|
command = None, fill = X, expand = 0):
|
||
|
|
widget = Radiobutton(parent, text = text, anchor = W,
|
||
|
|
variable = variable, value = value)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createFloater(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, min = 0.0, resolution = None,
|
||
|
|
maxVelocity = 10.0, **kw):
|
||
|
|
kw['text'] = text
|
||
|
|
kw['min'] = min
|
||
|
|
kw['maxVelocity'] = maxVelocity
|
||
|
|
kw['resolution'] = resolution
|
||
|
|
widget = apply(Floater.Floater, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createAngleDial(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, **kw):
|
||
|
|
kw['text'] = text
|
||
|
|
widget = apply(Dial.AngleDial, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createSlider(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, min = 0.0, max = 1.0,
|
||
|
|
resolution = None,
|
||
|
|
side = TOP, fill = X, expand = 1, **kw):
|
||
|
|
kw['text'] = text
|
||
|
|
kw['min'] = min
|
||
|
|
kw['max'] = max
|
||
|
|
kw['resolution'] = resolution
|
||
|
|
#widget = apply(EntryScale.EntryScale, (parent,), kw)
|
||
|
|
from direct.tkwidgets import Slider
|
||
|
|
widget = apply(Slider.Slider, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createEntryScale(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, min = 0.0, max = 1.0,
|
||
|
|
resolution = None,
|
||
|
|
side = TOP, fill = X, expand = 1, **kw):
|
||
|
|
kw['text'] = text
|
||
|
|
kw['min'] = min
|
||
|
|
kw['max'] = max
|
||
|
|
kw['resolution'] = resolution
|
||
|
|
widget = apply(EntryScale.EntryScale, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createVector2Entry(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, **kw):
|
||
|
|
# Set label's text
|
||
|
|
kw['text'] = text
|
||
|
|
widget = apply(VectorWidgets.Vector2Entry, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createVector3Entry(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, **kw):
|
||
|
|
# Set label's text
|
||
|
|
kw['text'] = text
|
||
|
|
widget = apply(VectorWidgets.Vector3Entry, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createColorEntry(self, parent, category, text, balloonHelp,
|
||
|
|
command = None, **kw):
|
||
|
|
# Set label's text
|
||
|
|
kw['text'] = text
|
||
|
|
widget = apply(VectorWidgets.ColorEntry, (parent,), kw)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def createOptionMenu(self, parent, category, text, balloonHelp,
|
||
|
|
items, command):
|
||
|
|
optionVar = StringVar()
|
||
|
|
if len(items) > 0:
|
||
|
|
optionVar.set(items[0])
|
||
|
|
widget = Pmw.OptionMenu(parent, labelpos = W, label_text = text,
|
||
|
|
label_width = 12, menu_tearoff = 1,
|
||
|
|
menubutton_textvariable = optionVar,
|
||
|
|
items = items)
|
||
|
|
# Do this after the widget so command isn't called on creation
|
||
|
|
widget['command'] = command
|
||
|
|
widget.pack(fill = X)
|
||
|
|
self.bind(widget.component('menubutton'), balloonHelp)
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
self.variableDict[category + '-' + text] = optionVar
|
||
|
|
return optionVar
|
||
|
|
|
||
|
|
def createComboBox(self, parent, category, text, balloonHelp,
|
||
|
|
items, command, history = 0,
|
||
|
|
side = LEFT, expand = 0, fill = X):
|
||
|
|
widget = Pmw.ComboBox(parent,
|
||
|
|
labelpos = W,
|
||
|
|
label_text = text,
|
||
|
|
label_anchor = 'e',
|
||
|
|
label_width = 12,
|
||
|
|
entry_width = 16,
|
||
|
|
history = history,
|
||
|
|
scrolledlist_items = items)
|
||
|
|
# Don't allow user to edit entryfield
|
||
|
|
widget.configure(entryfield_entry_state = 'disabled')
|
||
|
|
# Select first item if it exists
|
||
|
|
if len(items) > 0:
|
||
|
|
widget.selectitem(items[0])
|
||
|
|
# Bind selection command
|
||
|
|
widget['selectioncommand'] = command
|
||
|
|
widget.pack(side = side, fill = fill, expand = expand)
|
||
|
|
# Bind help
|
||
|
|
self.bind(widget, balloonHelp)
|
||
|
|
# Record widget
|
||
|
|
self.widgetDict[category + '-' + text] = widget
|
||
|
|
return widget
|
||
|
|
|
||
|
|
def makeCameraWindow(self):
|
||
|
|
# First, we need to make a new layer on the window.
|
||
|
|
chan = base.win.getChannel(0)
|
||
|
|
self.cLayer = chan.makeLayer(1)
|
||
|
|
self.layerIndex = 1
|
||
|
|
self.cDr = self.cLayer.makeDisplayRegion(0.6, 1.0, 0, 0.4)
|
||
|
|
self.cDr.setClearDepthActive(1)
|
||
|
|
self.cDr.setClearColorActive(1)
|
||
|
|
self.cDr.setClearColor(Vec4(0))
|
||
|
|
|
||
|
|
# It gets its own camera
|
||
|
|
self.cCamera = render.attachNewNode('cCamera')
|
||
|
|
self.cCamNode = Camera('cCam')
|
||
|
|
self.cLens = PerspectiveLens()
|
||
|
|
self.cLens.setFov(40, 40)
|
||
|
|
self.cLens.setNear(0.1)
|
||
|
|
self.cLens.setFar(100.0)
|
||
|
|
self.cCamNode.setLens(self.cLens)
|
||
|
|
self.cCamNode.setScene(render)
|
||
|
|
self.cCam = self.cCamera.attachNewNode(self.cCamNode)
|
||
|
|
|
||
|
|
self.cDr.setCamera(self.cCam)
|
||
|
|
|