class EditorPlugin(gp.GamePlugin):
def OnInit(self):
gp.GamePlugin.OnInit(self)
self.playing = False
# Add new commands to command module.
setattr(cmds, 'AddScript', self.AddScript)
self.AddDragDropFileTypeHandler('.py', self.DropScript)
self.AddDragDropFileTypeHandler('.pyc', self.DropScript)
self.app.accept('escape', self.OnPause)
self.BuildPlaybackToolBar()
panelInfo = (wx.aui.AuiPaneInfo().Name('tbPlay').Caption(
'Playback Toolbar').ToolbarPane().Top())
self.AddUiWindow(ID_WIND_PLAY_TOOLBAR, self.tbPlay, panelInfo)
def BuildPlaybackToolBar(self):
"""Build playback toolbar."""
dirPath = os.path.join(os.path.split(__file__)[0], 'images')
playbackActns = [
ActionItem('Play', os.path.join(dirPath, 'play.png'), self.OnPlay,
ID_PLAY, 'Play'),
ActionItem('Pause', os.path.join(dirPath, 'pause.png'),
self.OnPause, ID_PAUSE, 'Pause')
]
self.tbPlay = CustomAuiToolBar(self.ui,
-1,
style=wx.aui.AUI_TB_DEFAULT_STYLE)
self.tbPlay.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbPlay.AppendActionItems(playbackActns)
def AddScript(self, np, filePath):
# Try to load the script. Warn the user if the script fails in any
# way.
try:
scriptWrprCls = base.game.nodeMgr.nodeWrappers['Script']
scriptWrpr = scriptWrprCls.Create(filePath=filePath)
except:
wxUtils.ErrorDialog(traceback.format_exc(), 'Script Error')
return
# A NodePath needs a PandaObject as an anchor in order to attach a
# script to it. Create one if it doesn't already exist and add it to
# the list of undoable actions.
actns = []
pObjWrprCls = base.game.nodeMgr.nodeWrappers[TAG_PANDA_OBJECT]
pObj = PandaObjectNPO.Get(np)
if pObj is None:
pObjWrpr = pObjWrprCls.Create()
actns.append(actions.Add(pObjWrpr.data))
else:
pObjWrpr = pObjWrprCls(pObj)
pObjWrpr.SetParent(np)
scriptWrpr.SetParent(pObjWrpr.data)
actns.append(actions.Add(scriptWrpr.data))
# Create a composite action, exectute it and push it onto the undo
# queue.
actn = actions.Composite(actns)
wx.GetApp().actnMgr.Push(actn)
actn()
wx.GetApp().doc.OnModified()
def DropScript(self, filePath, np=None):
"""Drag drop handler for attaching scripts to NodePaths."""
if np is not None:
cmds.AddScript(np, filePath)
def OnPlay(self, evt=None):
# Set playing flag
if self.playing:
return
self.playing = True
# Save temp scene file
self.app.scene.Save(filePath=TEMP_SCENE_PATH)
# Start panda behaviours
base.pandaMgr.Init()
base.pandaMgr.Start()
# Update UI
self.app.doc.OnRefresh()
def OnPause(self, evt=None):
# Set playing flag
if not self.playing:
return
self.playing = False
# Stop panda behaviours
base.pandaMgr.Stop()
base.pandaMgr.Del()
# Set up a new scene and load the contents of the temp scene saved
# before the user pressed play
oldPath = self.app.doc.filePath
self.app.CreateScene(TEMP_SCENE_PATH, newDoc=False)
self.app.scene.Load(filePath=TEMP_SCENE_PATH)
self.app.doc.filePath = oldPath
# Set the document contents back to the temp scene we loaded
self.app.doc.contents = self.app.scene
self.app.doc.OnRefresh()
def OnUpdate(self, msg):
# Disable all toolbar tools
self.tbPlay.EnableAllTools(False)
# Enable the pause tool if in play mode
if self.playing:
self.tbPlay.EnableTool(ID_PAUSE, True)
else:
self.tbPlay.EnableTool(ID_PLAY, True)
# Refresh toolbars in order to show changes
self.tbPlay.Refresh()
def OnProjectFilesModified(self, filePaths):
# Don't reload files during playback. They will be reloaded once
# playback is finished anyway when the scene is reloaded.
if self.playing:
return
# Get .py files
pyFilePaths = []
for filePath in filePaths:
if os.path.splitext(filePath)[1] == '.py':
pyFilePaths.append(filePath)
# Reload scripts
if pyFilePaths:
for pyFilePath in pyFilePaths:
print 'Reloading script: ', pyFilePath
nps = [
np for np in base.scene.rootNp.findAllMatches('**/*')
if np.getPythonTag(TAG_PANDA_OBJECT) is not None
]
for np in nps:
pObjWrpr = base.game.nodeMgr.Wrap(PandaObjectNPO.Get(np))
for pyFilePath in pyFilePaths:
pObjWrpr.ReloadScript(pyFilePath)
class MainFrame(wx.Frame):
"""Panda Editor user interface."""
def __init__(self, *args, **kwargs):
wx.Frame.__init__(self, *args, **kwargs)
self.app = wx.GetApp()
self.preMaxPos = None
self.preMaxSize = None
self.actns = {
ID_EDIT_UNDO: self.app.Undo,
ID_EDIT_REDO: self.app.Redo,
ID_EDIT_GROUP: self.app.Group,
ID_EDIT_UNGROUP: self.app.Ungroup,
ID_EDIT_PARENT: self.app.Parent,
ID_EDIT_UNPARENT: self.app.Unparent
}
# Bind frame events
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.Bind(wx.EVT_KEY_UP, p3d.wx.OnKeyUp)
self.Bind(wx.EVT_KEY_DOWN, p3d.wx.OnKeyDown)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_MOVE, self.OnMove)
# Bind publisher events
pub.subscribe(self.OnUpdate, 'Update')
# Build application preferences
self.cfg = wx.Config('pandaEditor')
# Build toolbars
self.BuildFileActions()
self.BuildEditActions()
self.BuildModifyActions()
self.BuildXformActions()
self.BuildLayoutActions()
# Build viewport. Don't initialise just yet as ShowBase has not yet
# been created.
self.pnlViewport = Viewport(self)
# Build editor panels
self.pnlSceneGraph = SceneGraphPanel(self, style=wx.SUNKEN_BORDER)
self.pnlLightLinker = LightLinkerPanel(self, style=wx.SUNKEN_BORDER)
self.pnlProps = PropertiesPanel(self, style=wx.SUNKEN_BORDER)
self.pnlRsrcs = ResourcesPanel(self, style=wx.SUNKEN_BORDER)
self.pnlLog = LogPanel(self, style=wx.SUNKEN_BORDER)
# Build aui manager to hold all the widgets
self.BuildAuiManager()
# Build menus and menu bar
self.mb = wx.MenuBar()
self.BuildViewMenu()
self.BuildCreateMenu()
self.BuildWindowMenu()
self.BuildMenuBar()
# Populate the panels menu bar with items representing each floating
# panel.
self.RebuildPanelMenu()
# Update the view menu based on the perspective saved in preferences
self.OnUpdateWindowMenu(None)
def _GetSavePath(self):
# Get default paths from current project directory, or the scene's
# current location on disk
defaultDir = ''
defaultFile = ''
if self.app.doc.filePath is not None:
defaultDir, defaultFile = os.path.split(self.app.doc.filePath)
elif self.app.project.path is not None:
defaultDir = self.app.project.GetScenesDirectory()
# Open file browser
filePath = wxUtils.FileSaveDialog('Save Scene As',
WILDCARD_SCENE,
defaultDir=defaultDir,
defaultFile=defaultFile)
if filePath and os.path.exists(filePath):
# Warn user if the chosen file path already exists
msg = ''.join([
'The file "', filePath,
'" already exists.\nDo you want to replace it?'
])
if wxUtils.YesNoDialog(msg, 'Replace File?',
wx.ICON_WARNING) == wx.ID_NO:
return False
return filePath
def _CheckForSave(self):
"""
If there is already a file loaded and it is dirty, query the user to
save the file. Return False for cancel, True otherwise.
"""
if self.app.doc.dirty:
# Show dialog, record result
msg = ''.join([
'The document "', self.app.doc.title,
'" was modified after last save.\nSave changes before continuing?'
])
result = wxUtils.YesNoCancelDialog(msg, 'Save Changes?',
wx.ICON_WARNING)
if result == wx.ID_YES:
self.OnFileSave(None)
elif result == wx.ID_CANCEL:
return False
# Document not dirty, return True
return True
def OnClose(self, evt):
"""Save frame and aui preferences, hide the window and quit."""
# Check if ok to continue, stop the closing process if the user
# cancelled
if not self._CheckForSave():
evt.Veto()
return
# Save prefs, hide window and quit
self.auiCfg.Save()
if self.preMaxPos is not None:
self.auiCfg.SavePosition(*self.preMaxPos)
if self.preMaxSize is not None:
self.auiCfg.SaveSize(*self.preMaxSize)
if self.app.project.path is not None:
self.cfg.Write('projDirPath', self.app.project.path)
self.Show(False)
self.app.Quit()
def OnFileNew(self, evt):
"""Show project settings panel and create new scene."""
# Check if ok to continue, return if the user cancelled
if not self._CheckForSave():
return
# Create new document
self.app.CreateScene()
self.app.doc.OnRefresh()
def OnFileOpen(self, evt, filePath=None):
"""Create a new document and load the scene."""
# Check if ok to continue, return if the user cancelled
if not self._CheckForSave():
return
# Create new document from file path and load it
if filePath is None:
# Get the start directory. This will be the current working
# directory if the project is not set.
scnsDirPath = self.app.project.GetScenesDirectory()
if scnsDirPath is None:
scnsDirPath = os.getcwd()
filePath = wxUtils.FileOpenDialog('Open Scene',
WILDCARD_SCENE,
defaultDir=scnsDirPath)
# Create new document
if filePath:
self.app.CreateScene(filePath)
self.app.doc.Load()
def OnFileSave(self, evt, saveAs=False):
"""Save the document."""
# Set a file path for the document if one does not exist, or for save
# as
if self.app.doc.filePath is None or saveAs:
# Query a new save path
filePath = self._GetSavePath()
if filePath:
self.app.doc.filePath = filePath
else:
return
# Save the file
self.app.doc.Save()
def OnFileSaveAs(self, evt):
"""
Call save using the saveAs flag in order to bring up a new dialog box
so the user may set an alternate save path.
"""
self.OnFileSave(evt, True)
def OnFileImport(self, evt):
"""Import assets to project."""
filePaths = wxUtils.FileOpenDialog('Import Models', WILDCARD_MODEL,
wx.MULTIPLE)
if filePaths:
for filePath in filePaths:
self.app.project.ImportAsset(filePath)
def OnFileNewProject(self, evt):
"""Build project directory and set project."""
dirPath = wxUtils.DirDialog('Set New Project Directory')
if dirPath:
self.app.project.New(dirPath)
self.SetProjectPath(dirPath)
self.app.doc.OnRefresh()
def OnFileSetProject(self, evt):
"""
Set the active project directory path and rebuild the resources panel.
"""
dirPath = wxUtils.DirDialog('Set Project Directory')
if dirPath:
self.SetProjectPath(dirPath)
self.app.doc.OnRefresh()
def OnFileBuildProject(self, evt):
"""Build the current project to a p3d file."""
filePath = wxUtils.FileSaveDialog('Build Project', WILDCARD_P3D)
if not filePath:
return
if filePath and os.path.exists(filePath):
# Warn user if the chosen file path already exists
msg = ''.join([
'The file "', filePath,
'" already exists.\nDo you want to replace it?'
])
if wxUtils.YesNoDialog(msg, 'Replace File?',
wx.ICON_WARNING) == wx.ID_NO:
return
self.app.project.Build(filePath)
def OnSingleCommand(self, evt):
id = evt.GetId()
fn = self.actns[id]
fn()
def OnEngagePhysics(self, evt):
wrpr = base.game.nodeMgr.Wrap(base.scene.physicsWorld)
if base.scene.physicsTask not in taskMgr.getAllTasks():
wrpr.EnablePhysics()
else:
wrpr.DisablePhysics()
def OnViewGrid(self, evt):
"""
Show or hide the grid based on the checked value of the menu item.
"""
checked = evt.Checked()
if checked:
self.app.grid.show()
else:
self.app.grid.hide()
def OnViewCamera(self, evt, yaw_pitch):
"""
Orbit camera top or bottom by manipulating delta values
See p3d.camera.Orbit for more
"""
delta = pm.Vec2(-base.edCamera.getH() + yaw_pitch[0],
-base.edCamera.getP() + yaw_pitch[1])
base.edCamera.Orbit(delta)
def OnCreate(self, evt, typeStr):
self.app.AddComponent(typeStr)
def OnCreateActor(self, evt):
"""
Turn the selection into actors. This is still a massive hack - we need
a more concise way of storing this information.
"""
comps = []
for wrpr in self.app.selection.wrprs:
attr = wrpr.FindProperty('modelPath')
if attr is None:
continue
wrprCls = base.game.nodeMgr.nodeWrappers['Actor']
aWrpr = wrprCls.Create(modelPath=attr.Get())
aWrpr.data.setTransform(wrpr.data.getTransform())
aWrpr.SetDefaultValues()
aWrpr.SetParent(wrpr.GetDefaultParent())
cmds.Replace(wrpr.data, aWrpr.data)
def OnCreatePrefab(self, evt):
"""
Create a new prefab for the selected object in the prefab directory.
"""
np = self.app.selection.GetNodePaths()[0]
dirPath = self.app.project.GetPrefabsDirectory()
assetName = self.app.project.GetUniqueAssetName('prefab.xml', dirPath)
assetPath = os.path.join(dirPath, assetName)
base.game.scnParser.Save(np, assetPath)
def OnCreateCgShader(self, evt):
"""
"""
self.app.project.CreateCgShader()
def OnCreateGlslShader(self, evt):
"""
"""
self.app.project.CreateGlslShader()
def OnShowHidePane(self, evt):
"""
Show or hide the pane based on the menu item that was (un)checked.
"""
pane = self.paneDefs[evt.GetId()][0]
self._mgr.GetPane(pane).Show(evt.Checked())
# Make sure to call or else we won't see any changes.
self._mgr.Update()
self.app.doc.OnRefresh()
def OnXformSetActiveGizmo(self, evt):
if evt.GetId() == ID_XFORM_WORLD:
self.app.SetGizmoLocal(not evt.Checked())
return
arg = None
if evt.GetId() == ID_XFORM_POS:
arg = 'pos'
elif evt.GetId() == ID_XFORM_ROT:
arg = 'rot'
elif evt.GetId() == ID_XFORM_SCL:
arg = 'scl'
self.app.SetActiveGizmo(arg)
def OnLayout(self, evt):
if evt.GetId() == ID_LAYOUT_GAME:
base.LayoutGameView()
elif evt.GetId() == ID_LAYOUT_EDITOR:
base.LayoutEditorView()
elif evt.GetId() == ID_LAYOUT_BOTH:
base.LayoutBothView()
def OnUpdateWindowMenu(self, evt):
"""
Set the checks in the window menu to match the visibility of the
panes.
"""
def UpdateWindowMenu():
# Check those menus representing panels which are still shown
# after the event
for id in self.paneDefs:
pane = self.paneDefs[id][0]
if self.mPnl.FindItemById(id) and self._mgr.GetPane(
pane).IsShown():
self.mPnl.Check(id, True)
# Uncheck all menus
for id in self.paneDefs:
if self.mPnl.FindItemById(id):
self.mPnl.Check(id, False)
# Call after or IsShown() won't return a useful value
wx.CallAfter(UpdateWindowMenu)
def OnUpdate(self, comps=None):
"""
Change the appearance and states of buttons on the form based on the
state of the loaded document.
NOTE: Don't use freeze / thaw as this will cause the 3D viewport to
flicker.
"""
self.OnUpdateFile(comps)
self.OnUpdateEdit(comps)
self.OnUpdateModify(comps)
self.OnUpdateView(comps)
self.OnUpdateProject(comps)
self.OnUpdateXform(comps)
# Set the frame's title to include the document's file path, include
# dirty 'star'
title = ''.join([FRAME_TITLE, ' - ', self.app.doc.title])
if self.app.doc.dirty:
title += ' *'
self.SetTitle(title)
self.app.game.pluginMgr.OnUpdate(comps)
def OnUpdateFile(self, msg):
"""
Update the file menu. Disable all menu and toolbar items then turn
those back on depending on the document's state.
"""
self.mFile.EnableAllTools(False)
self.tbFile.EnableAllTools(False)
self.mFile.Enable(ID_FILE_NEW, True)
self.mFile.Enable(ID_FILE_OPEN, True)
self.mFile.Enable(ID_FILE_SAVE_AS, True)
self.mFile.Enable(ID_FILE_PROJ, True)
self.tbFile.EnableTool(ID_FILE_NEW, True)
self.tbFile.EnableTool(ID_FILE_OPEN, True)
self.tbFile.EnableTool(ID_FILE_SAVE_AS, True)
if self.app.doc.dirty:
self.mFile.Enable(ID_FILE_SAVE, True)
self.tbFile.EnableTool(ID_FILE_SAVE, True)
if self.app.project.path is not None:
self.mFile.Enable(ID_FILE_IMPORT, True)
self.tbFile.Refresh()
def OnUpdateEdit(self, msg):
"""
Update the edit menu. Disable undo or redo queus if they are empty
and make sure to refresh the toolbar.
"""
val = len(self.app.actnMgr.undoList) > 0
self.mEdit.Enable(ID_EDIT_UNDO, val)
self.tbEdit.EnableTool(ID_EDIT_UNDO, val)
val = len(self.app.actnMgr.redoList) > 0
self.mEdit.Enable(ID_EDIT_REDO, val)
self.tbEdit.EnableTool(ID_EDIT_REDO, val)
self.tbEdit.Refresh()
def OnUpdateModify(self, msg):
self.tbModify.EnableTool(ID_MODIFY_PHYSICS, False)
if base.scene.physicsWorld is not None:
self.tbModify.EnableTool(ID_MODIFY_PHYSICS, True)
if base.scene.physicsTask not in taskMgr.getAllTasks():
self.tbModify.ToggleTool(ID_MODIFY_PHYSICS, False)
else:
self.tbModify.ToggleTool(ID_MODIFY_PHYSICS, True)
self.tbModify.Refresh()
def OnUpdateView(self, msg):
"""
Update the view menu. Ensure the grid menu item's checked state
matches the visibility of the grid.
"""
self.mView.Check(ID_VIEW_GRID, False)
if not self.app.grid.isHidden():
self.mView.Check(ID_VIEW_GRID, True)
def OnUpdateProject(self, msg):
self.mProj.EnableAllTools(False)
self.mProj.Enable(ID_PROJ_NEW, True)
self.mProj.Enable(ID_PROJ_SET, True)
if self.app.project.path is not None:
self.mProj.EnableAllTools(True)
def OnUpdateXform(self, msg):
gizmo = self.app.gizmoMgr.GetActiveGizmo()
if gizmo is None:
self.tbXform.ToggleTool(ID_XFORM_SEL, True)
elif gizmo.getName() == 'pos':
self.tbXform.ToggleTool(ID_XFORM_POS, True)
elif gizmo.getName() == 'rot':
self.tbXform.ToggleTool(ID_XFORM_ROT, True)
elif gizmo.getName() == 'scl':
self.tbXform.ToggleTool(ID_XFORM_SCL, True)
val = not self.app.gizmoMgr.GetGizmoLocal('pos')
self.tbXform.ToggleTool(ID_XFORM_WORLD, val)
self.tbXform.Refresh()
def OnShowPreferences(self, evt):
try:
self.frmPrefs.Close()
except:
pass
self.frmPrefs = PreferencesFrame(self)
self.frmPrefs.Center()
self.frmPrefs.Show()
def OnMove(self, evt):
"""
Keep the window's position on hand before it gets maximized as this is
the number we need to save to preferences.
"""
if not self.IsMaximized():
self.preMaxPos = self.GetPosition()
def OnSize(self, evt):
"""
Keep the window's size on hand before it gets maximized as this is the
number we need to save to preferences.
"""
if not self.IsMaximized():
self.preMaxSize = self.GetSize()
def SetProjectPath(self, dirPath):
"""
Set the project path and rebuild the resources panel.
"""
self.app.project.Set(dirPath)
self.pnlRsrcs.Build(self.app.project.path)
def BuildFileActions(self):
"""Add tools, set long help strings and bind toolbar events."""
commonActns = [
ActionItem('New', os.path.join('data', 'images', 'document.png'),
self.OnFileNew, ID_FILE_NEW),
ActionItem(
'Open',
os.path.join('data', 'images', 'folder-horizontal-open.png'),
self.OnFileOpen, ID_FILE_OPEN),
ActionItem('Save', os.path.join('data', 'images',
'disk-black.png'), self.OnFileSave,
ID_FILE_SAVE),
ActionItem('Save As',
os.path.join('data', 'images', 'disk-black-pencil.png'),
self.OnFileSaveAs, ID_FILE_SAVE_AS),
]
# Create file menu
self.mFile = CustomMenu()
self.mFile.AppendActionItems(commonActns, self)
self.mFile.AppendSeparator()
self.mFile.AppendActionItem(
ActionItem('Import...', '', self.OnFileImport, ID_FILE_IMPORT),
self)
# Create project actions as a submenu
self.mProj = CustomMenu()
actns = [
ActionItem('New...', '', self.OnFileNewProject, ID_PROJ_NEW),
ActionItem('Set...', '', self.OnFileSetProject, ID_PROJ_SET),
ActionItem('Build...', '', self.OnFileBuildProject, ID_PROJ_BUILD)
]
self.mProj.AppendActionItems(actns, self)
self.mFile.AppendMenu(ID_FILE_PROJ, '&Project', self.mProj)
# Create file toolbar
self.tbFile = CustomAuiToolBar(self, -1)
self.tbFile.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbFile.AppendActionItems(commonActns)
self.tbFile.Realize()
def BuildEditActions(self):
"""Add tools, set long help strings and bind toolbar events."""
commonActns = [
ActionItem('Undo',
os.path.join('data', 'images', 'arrow-curve-flip.png'),
self.OnSingleCommand, ID_EDIT_UNDO),
ActionItem('Redo', os.path.join('data', 'images',
'arrow-curve.png'),
self.OnSingleCommand, ID_EDIT_REDO)
]
grpActns = [
ActionItem('Group', '', self.OnSingleCommand, ID_EDIT_GROUP),
ActionItem('Ungroup', '', self.OnSingleCommand, ID_EDIT_UNGROUP)
]
pntActns = [
ActionItem('Parent', '', self.OnSingleCommand, ID_EDIT_PARENT),
ActionItem('Unparent', '', self.OnSingleCommand, ID_EDIT_UNPARENT)
]
# Create edit menu
self.mEdit = CustomMenu()
self.mEdit.AppendActionItems(commonActns, self)
self.mEdit.AppendSeparator()
self.mEdit.AppendActionItems(grpActns, self)
#self.mEdit.AppendSeparator()
#self.mEdit.AppendActionItems( pntActns, self )
# Create edit toolbar
self.tbEdit = CustomAuiToolBar(self, -1)
self.tbEdit.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbEdit.AppendActionItems(commonActns)
self.tbEdit.Realize()
def BuildModifyActions(self):
"""Add tools, set long help strings and bind toolbar events."""
actns = [
ActionItem('Engage Physics',
os.path.join('data', 'images', 'point.png'),
self.OnEngagePhysics,
ID_MODIFY_PHYSICS,
kind=wx.ITEM_CHECK)
]
# Create edit menu
self.mModify = CustomMenu()
self.mModify.AppendActionItems(actns, self)
# Create edit toolbar
self.tbModify = CustomAuiToolBar(self, -1)
self.tbModify.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbModify.AppendActionItems(actns)
self.tbModify.Realize()
def BuildXformActions(self):
"""Add tools, set long help strings and bind toolbar events."""
fn = self.OnXformSetActiveGizmo
actns = [
ActionItem('Select',
os.path.join('data', 'images', 'select.png'),
fn,
ID_XFORM_SEL,
kind=wx.ITEM_RADIO),
ActionItem('Move',
os.path.join('data', 'images', 'move.png'),
fn,
ID_XFORM_POS,
kind=wx.ITEM_RADIO),
ActionItem('Rotate',
os.path.join('data', 'images', 'rotate.png'),
fn,
ID_XFORM_ROT,
kind=wx.ITEM_RADIO),
ActionItem('Scale',
os.path.join('data', 'images', 'scale.png'),
fn,
ID_XFORM_SCL,
kind=wx.ITEM_RADIO),
ActionItem('World Transform',
os.path.join('data', 'images', 'globe.png'),
fn,
ID_XFORM_WORLD,
kind=wx.ITEM_CHECK)
]
# Create xform toolbar
self.tbXform = CustomAuiToolBar(self, -1)
self.tbXform.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbXform.AddSpacer(
0
) # Need to insert a null object here or the radio buttons don't seem to work (win7 at least).
self.tbXform.AppendActionItems(actns)
self.tbXform.Realize()
def BuildLayoutActions(self):
"""Add tools, set long help strings and bind toolbar events."""
actns = [
ActionItem('Editor',
os.path.join('data', 'images',
'application-sidebar-list.png'),
self.OnLayout,
ID_LAYOUT_EDITOR,
kind=wx.ITEM_RADIO),
ActionItem('Game',
os.path.join('data', 'images', 'layout-game.png'),
self.OnLayout,
ID_LAYOUT_GAME,
kind=wx.ITEM_RADIO),
ActionItem('Both',
os.path.join('data', 'images', 'layout-both.png'),
self.OnLayout,
ID_LAYOUT_BOTH,
kind=wx.ITEM_RADIO)
]
# Create layout toolbar
self.tbLayout = CustomAuiToolBar(self, -1)
self.tbLayout.SetToolBitmapSize(TBAR_ICON_SIZE)
self.tbLayout.AddSpacer(
0
) # Need to insert a null object here or the radio buttons don't seem to work (win7 at least).
self.tbLayout.AppendActionItems(actns)
self.tbLayout.ToggleTool(ID_LAYOUT_EDITOR, True)
self.tbLayout.Realize()
def BuildViewMenu(self):
"""Build the view menu."""
viewActns = [
ActionItem('Grid',
'',
self.OnViewGrid,
ID_VIEW_GRID,
kind=wx.ITEM_CHECK)
]
camActns = [
ActionItem('Top',
'',
self.OnViewCamera,
ID_VIEW_TOP,
args=(0, -90)),
ActionItem('Bottom',
'',
self.OnViewCamera,
ID_VIEW_BOTTOM,
args=(0, 90)),
ActionItem('Left',
'',
self.OnViewCamera,
ID_VIEW_LEFT,
args=(-90, 0)),
ActionItem('Right',
'',
self.OnViewCamera,
ID_VIEW_RIGHT,
args=(90, 0)),
ActionItem('Front',
'',
self.OnViewCamera,
ID_VIEW_FRONT,
args=(0, 0)),
ActionItem('Back',
'',
self.OnViewCamera,
ID_VIEW_BACK,
args=(-180, 0))
]
self.mCameras = CustomMenu()
self.mCameras.AppendActionItems(camActns, self)
# Append to view menu
self.mView = CustomMenu()
self.mView.AppendActionItems(viewActns, self)
self.mView.AppendSeparator()
self.mView.AppendSubMenu(self.mCameras, '&Camera')
def BuildCreateMenu(self):
"""Build the create menu."""
lightActns = [
ActionItem('Ambient', '', self.OnCreate, args='AmbientLight'),
ActionItem('Point', '', self.OnCreate, args='PointLight'),
ActionItem('Directional',
'',
self.OnCreate,
args='DirectionalLight'),
ActionItem('Spot', '', self.OnCreate, args='Spotlight')
]
mLights = CustomMenu()
mLights.AppendActionItems(lightActns, self)
collActns = [
ActionItem('Node', '', self.OnCreate, args='CollisionNode'),
ActionItem('Box', '', self.OnCreate, args='CollisionBox'),
ActionItem('Ray', '', self.OnCreate, args='CollisionRay'),
ActionItem('Sphere', '', self.OnCreate, args='CollisionSphere'),
ActionItem('Inverse Sphere',
'',
self.OnCreate,
args='CollisionInvSphere'),
ActionItem('Tube', '', self.OnCreate, args='CollisionTube')
]
mColl = CustomMenu()
mColl.AppendActionItems(collActns, self)
texActns = [
ActionItem('Texture', '', self.OnCreate, args='Texture') #,
#ActionItem( 'Texture Stage', '', self.OnCreate, args='TextureStage' )
]
mTex = CustomMenu()
mTex.AppendActionItems(texActns, self)
shaActns = [ActionItem('Shader', '', self.OnCreate, args='Shader')]
mSha = CustomMenu()
mSha.AppendActionItems(shaActns, self)
bltActions = [
ActionItem('World', '', self.OnCreate, args='BulletWorld'),
ActionItem('Debug Node', '', self.OnCreate,
args='BulletDebugNode'),
ActionItem('Rigid Body Node',
'',
self.OnCreate,
args='BulletRigidBodyNode'),
ActionItem('Character Controller Node',
'',
self.OnCreate,
args='BulletCharacterControllerNode'),
ActionItem('Box Shape', '', self.OnCreate, args='BulletBoxShape'),
ActionItem('Plane Shape',
'',
self.OnCreate,
args='BulletPlaneShape'),
ActionItem('Capsule Shape',
'',
self.OnCreate,
args='BulletCapsuleShape')
]
mBlt = CustomMenu()
mBlt.AppendActionItems(bltActions, self)
self.mCreate = CustomMenu()
self.mCreate.AppendActionItem(
ActionItem('Panda Node', '', self.OnCreate, args='PandaNode'),
self)
self.mCreate.AppendActionItem(
ActionItem('Actor', '', self.OnCreateActor), self)
self.mCreate.AppendActionItem(
ActionItem('Fog', '', self.OnCreate, args='Fog'), self)
self.mCreate.AppendSubMenu(mColl, '&Collision')
self.mCreate.AppendSubMenu(mLights, '&Lights')
self.mCreate.AppendSubMenu(mTex, '&Texture')
self.mCreate.AppendSubMenu(mSha, '&Shader')
self.mCreate.AppendSubMenu(mBlt, '&Bullet')
self.mCreate.AppendSeparator()
self.mCreate.AppendActionItem(
ActionItem('Prefab', '', self.OnCreatePrefab), self)
#self.mCreate.AppendSeparator()
#self.mCreate.AppendActionItem( ActionItem( 'Cg Shader', '', self.OnCreateCgShader ), self )
#self.mCreate.AppendActionItem( ActionItem( 'Glsl Shader', '', self.OnCreateGlslShader ), self )
def BuildWindowMenu(self):
"""Build show / hide controls for panes."""
self.mPnl = CustomMenu()
self.mWind = CustomMenu()
self.mWind.AppendMenu(ID_WIND_PANEL, '&Panel', self.mPnl)
self.mWind.AppendActionItem(
ActionItem('Preferences', '', self.OnShowPreferences,
ID_WIND_PREFERENCES), self)
def RebuildPanelMenu(self):
self.Freeze()
self.mPnl.Clear()
for id, paneDef in self.paneDefs.items():
if paneDef[1]:
self.mPnl.AppendCheckItem(id, paneDef[2].caption)
self.Bind(wx.EVT_MENU, self.OnShowHidePane, id=id)
self.OnUpdateWindowMenu(None)
self.Thaw()
def BuildMenuBar(self):
"""Build the menu bar and attach all menus to it."""
self.mb.Append(self.mFile, '&File')
self.mb.Append(self.mEdit, '&Edit')
self.mb.Append(self.mView, '&View')
self.mb.Append(self.mCreate, '&Create')
self.mb.Append(self.mWind, '&Window')
self.SetMenuBar(self.mb)
def BuildAuiManager(self):
"""
Define the behaviour for each aui manager panel, then add them to the
manager.
"""
# Define aui manager panes
# Each tuple is defined as: widget, show in window menu, aui panel
# info
self.paneDefs = {
ID_WIND_FILE_TOOLBAR:
(self.tbFile, True, wx.aui.AuiPaneInfo().Name('tbFile').Caption(
'File Toolbar').ToolbarPane().Top()),
ID_WIND_EDIT_TOOLBAR:
(self.tbEdit, True, wx.aui.AuiPaneInfo().Name('tbEdit').Caption(
'Edit Toolbar').ToolbarPane().Top()),
ID_WIND_MODIFY_TOOLBAR:
(self.tbModify, True, wx.aui.AuiPaneInfo().Name(
'tbModify').Caption('Modify Toolbar').ToolbarPane().Top()),
ID_WIND_XFORM_TOOLBAR:
(self.tbXform, True, wx.aui.AuiPaneInfo().Name('tbXform').Caption(
'Transform Toolbar').ToolbarPane().Top()),
ID_WIND_LAYOUT_TOOLBAR:
(self.tbLayout, True, wx.aui.AuiPaneInfo().Name(
'tbLayout').Caption('Layout Toolbar').ToolbarPane().Top()),
ID_WIND_VIEWPORT:
(self.pnlViewport, False,
wx.aui.AuiPaneInfo().Name('pnlViewport').Caption(
'Viewport').CloseButton(False).MaximizeButton(True).Center()),
ID_WIND_SCENE_GRAPH:
(self.pnlSceneGraph, True,
wx.aui.AuiPaneInfo().Name('pnlSceneGraph').Caption(
'Scene Graph').CloseButton(True).MaximizeButton(True).MinSize(
(100, 100)).Left().Position(2)),
ID_WIND_LIGHT_LINKER:
(self.pnlLightLinker, True, wx.aui.AuiPaneInfo().Name(
'pnlLightLinker').Caption('Light Linker').CloseButton(
True).MaximizeButton(True).MinSize(
(100, 100)).Right().Position(2)),
ID_WIND_RESOURCES:
(self.pnlRsrcs, True,
wx.aui.AuiPaneInfo().Name('pnlRsrcs').Caption(
'Resources').CloseButton(True).MaximizeButton(True).MinSize(
(100, 100)).Right().Position(2)),
ID_WIND_PROPERTIES:
(self.pnlProps, True,
wx.aui.AuiPaneInfo().Name('pnlProps').Caption(
'Properties').CloseButton(True).MaximizeButton(True).MinSize(
(100, 100)).Right()),
ID_WIND_LOG:
(self.pnlLog, True, wx.aui.AuiPaneInfo().Name('pnlLog').Caption(
'Log').CloseButton(True).MaximizeButton(True).MinSize(
(100, 100)).Bottom().Position(1))
}
# Build aui manager and add each pane
self._mgr = wx.aui.AuiManager(self)
for paneDef in self.paneDefs.values():
self._mgr.AddPane(paneDef[0], paneDef[2])
# Bind aui manager events
self._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE, self.OnUpdateWindowMenu)
# Create config and load preferences for all panels
self.auiCfg = AuiManagerConfig(self._mgr, 'pandaEditorWindow')
self.auiCfg.Load()
self._mgr.Update()