def toggleItemSnaps( self ): if self.itemSnapMode == 1: self.itemSnapMode = 0 else: self.itemSnapMode = 1 WorldEditor.setOptionInt( "snaps/itemSnapMode", self.itemSnapMode ) self.updateItemSnaps()
def enterChunkVizMode( self ): t = WorldEditor.tool() if ( t != None ): curr = WorldEditor.getOptionInt( "render/chunk/vizMode" ) t.delView( "chunkViz" ) vizRes = 0; if t.functor == self.alphaTool.functor: vizRes = WorldEditor.terrainBlendsRes() elif t.functor == self.itemTool.functor or t.functor == self.heightTool.functor or t.functor == self.filterTool.functor: vizRes = WorldEditor.terrainHeightMapRes() elif t.functor == self.holeTool.functor: vizRes = WorldEditor.terrainHoleMapRes() if vizRes == 0: self.needsChunkVizUpdate = True vizRes = 1 # set it to some sensible value else: self.needsChunkVizUpdate = False if curr == 1: t.addView( self.chunkViz, "chunkViz" ) elif curr == 2: self.vertexViz.numPerChunk = vizRes t.addView( self.vertexViz, "chunkViz" ) elif curr == 3: self.meshViz.numPerChunk = vizRes t.addView( self.meshViz, "chunkViz" )
def startDragSelect( self ): # add a drag select tool, which will pop itself and set our # selection when done. nt = WorldEditor.Tool() nt.locator = bd.itemTool.locator.subLocator nt.functor = Functor.ScriptedFunctor( DragSelectFunctor(nt, self) ) WorldEditor.pushTool( nt )
def doRedo( item ): what = WorldEditor.redo(0) if what: WorldEditor.addCommentaryMsg( "Redoing: " + what ) WorldEditor.redo() bd.itemTool.functor.script.selUpdate()
def actUndoExecute():
what = WorldEditor.undo(0)
if what:
WorldEditor.addCommentaryMsg("Undoing: " + what)
WorldEditor.undo()
bd.itemTool.functor.script.selUpdate()
def onMouseEvent( self, mx, my, mz ): handled = 0 if not handled: handled = WorldEditor.tool().handleMouseEvent( mx, my, mz ) if not handled: handled = WorldEditor.camera().handleMouseEvent( mx, my, mz ) return handled
def doRedo(item):
what = WorldEditor.redo(0)
if what:
WorldEditor.addCommentaryMsg("Redoing: " + what)
WorldEditor.redo()
bd.itemTool.functor.script.selUpdate()
def actUndoExecute(): what = WorldEditor.undo(0) if what: WorldEditor.addCommentaryMsg( "Undoing: " + what ) WorldEditor.undo() bd.itemTool.functor.script.selUpdate()
def onKeyEvent( self, isDown, key, modifiers ): handled = WorldEditor.camera().handleKeyEvent( isDown, key, modifiers ) if not handled and isDown: handled = self.ownKeyEvent( key, modifiers ) if not handled: handled = WorldEditor.tool().handleKeyEvent( isDown, key, modifiers ) return handled
def doUndo(item):
"""This function performs an undo operation."""
what = WorldEditor.undo(0)
if what:
WorldEditor.addCommentaryMsg("Undoing: " + what)
WorldEditor.undo()
bd.itemTool.functor.script.selUpdate()
def render( self, dTime ): """This function forces World Editor to render everything on the scene. Usually called everyframe, however it still recieves a dTime value which informs the renderer how much time has passed since the last render call.""" WorldEditor.camera().render( dTime ) WorldEditor.render( dTime ) GUI.draw() return 1
def doUndo( item ): """This function performs an undo operation.""" what = WorldEditor.undo(0) if what: WorldEditor.addCommentaryMsg( "Undoing: " + what ) WorldEditor.undo() bd.itemTool.functor.script.selUpdate()
def onPause( self ): self.cc.visible = 0 self.cc.delAsView() if ( WorldEditor.tool() != None ): WorldEditor.popTool() pass
def setObjectTab( self, tabName ): if self.tabName != "": # store the current selection currentFilter = WorldEditor.getOptionString( "tools/selectFilter" ) prevSectionName = "object/" + self.tabName + "/selectFilter" WorldEditor.setOptionString( prevSectionName, currentFilter ) self.tabName = tabName currSectionName = "object/" + self.tabName + "/selectFilter" return WorldEditor.getOptionString( currSectionName )
def updateItemSnaps( self ): #this method calculates itemSnapMode based on the #entries in the options.xml if ( WorldEditor.getOptionInt( "snaps/itemSnapMode" ) == 2 ): self.itemSnapMode = 2 elif ( WorldEditor.getOptionInt( "snaps/itemSnapMode" ) == 1 ): self.itemSnapMode = 1 else: self.itemSnapMode = 0 self.enterItemSnapMode()
def edtMiscSnapsZExit(value):
if value[-2:] == "cm":
floatValue = float(value[:-2]) / 100.0
elif value[-1] == "m":
floatValue = float(value[:-1])
else:
floatValue = float(value)
ns = WorldEditor.getOptionVector3("snaps/movement")
WorldEditor.setOptionVector3("snaps/movement", (ns[0], ns[1], floatValue))
def edtFarPlaneExit( value ): """This function allows the farPlane distance to be set in centimetres and metres.""" if value[-2:] == "cm": floatValue = float(value[:-2])/100.0 elif value[-1] == "m": floatValue = float(value[:-1]) else: floatValue = float(value) WorldEditor.farPlane( floatValue )
def edtMiscSnapsXExit( value ): if value[-2:] == "cm": floatValue = float(value[:-2])/100.0 elif value[-1] == "m": floatValue = float(value[:-1]) else: floatValue = float(value) ns = WorldEditor.getOptionVector3( "snaps/movement" ) WorldEditor.setOptionVector3( "snaps/movement", ( floatValue, ns[1], ns[2] ) )
def edtFarPlaneExit(value):
"""This function allows the farPlane distance to be set in centimetres and metres."""
if value[-2:] == "cm":
floatValue = float(value[:-2]) / 100.0
elif value[-1] == "m":
floatValue = float(value[:-1])
else:
floatValue = float(value)
WorldEditor.farPlane(floatValue)
def handleWheelCameraSpeed( self, mz ): # look at the rotator for changing the camera speed c = WorldEditor.camera() currentValue = WorldEditor.getOptionString( "camera/speed" ) speeds = ["Slow", "Medium", "Fast", "SuperFast"] iSpeed = 0 if currentValue == speeds[1]: iSpeed = 1 elif currentValue == speeds[2]: iSpeed = 2 elif currentValue == speeds[3]: iSpeed = 3 if mz > 0: iSpeed = iSpeed + 1 if iSpeed > 3: iSpeed = 3 elif mz < 0: iSpeed = iSpeed - 1 if iSpeed < 0: iSpeed = 0 value = speeds[iSpeed] handled = 0 if value != currentValue: c = WorldEditor.camera() WorldEditor.setOptionString( "camera/speed", value ) c.speed = WorldEditor.getOptionFloat( "camera/speed/" + value ) c.turboSpeed = WorldEditor.getOptionFloat( "camera/speed/" + value + "/turbo" ) handled = 1 WorldEditor.addCommentaryMsg( "New camera speed %s" % value, 1 ) return handled
def _onInput(self, fov):
if fov <= 0.017:
LOG_ERROR('[VSE] Wrong Camera FOV: {0}'.format(fov))
elif fov >= 3.1416:
LOG_ERROR('[VSE] Wrong Camera FOV: {0}'.format(fov))
elif IS_CLIENT:
BigWorld.projection().fov = fov
else:
import WorldEditor
WorldEditor.setCameraFOV(fov)
return 'out'
def pgcTerrainTabSelect(value):
if value == "tabTerrainTextures":
bd.enterMode("TerrainTexture")
elif value == "tabTerrainBrushes":
bd.enterMode("TerrainHeight")
elif value == "tabTerrainFilters":
bd.enterMode("TerrainFilter")
elif value == "tabTerrainTools":
bd.enterMode("TerrainHoleCut")
else:
WorldEditor.addCommentaryMsg(value + " unknown tab", 1)
def pgcTerrainTabSelect( value ): if value == "tabTerrainTextures": bd.enterMode( "TerrainTexture" ) elif value == "tabTerrainBrushes": bd.enterMode( "TerrainHeight" ) elif value == "tabTerrainFilters": bd.enterMode( "TerrainFilter" ) elif value == "tabTerrainTools": bd.enterMode( "TerrainHoleCut" ) else: WorldEditor.addCommentaryMsg( value + " unknown tab", 1 )
def actFreeSnapsExecute():
newSnaps = (0.1, 0.1, 0.1)
WorldEditor.setOptionVector3("snaps/movement", newSnaps)
WorldEditor.setOptionFloat("snaps/angle", 1)
WorldEditor.addCommentaryMsg("Movement snaps are %f,%f,%f" %
(newSnaps[0], newSnaps[1], newSnaps[2]))
WorldEditor.addCommentaryMsg("Rotation snaps are %f" %
WorldEditor.getOptionFloat("snaps/angle"))
def onStop( self ): self.selEditor = None WorldEditor.setCurrentEditors() # Remove the closed captions commentary viewer self.cc.visible = 0 self.cc.delAsView() del self.cc # Remove options entries that are messy and transient WorldEditor.saveOptions() return 0
def update( self, dTime, tool ): if self.currentSpace_ != WorldEditor.getOptionString( "space/mru0" ): self.currentSpace_ = WorldEditor.getOptionString( "space/mru0" ) set_clear( self.selection ) self.selUpdate() if self.objInfo.overGizmo: self.mouseView.revealer = None else: self.mouseView.revealer = self.mouseRevealer # TODO: Check if mouse button down and threshold crossed. # If so start a drag with the current object pass
def enterItemSnapMode( self ): newLoc = None t = self.itemTool if self.itemSnapMode == 0: newLoc = self.itemToolXZLocator t.delView( "stdView" ) t.addView( self.itemToolPlaneView, "stdView" ) t.size = 1 WorldEditor.addCommentaryMsg( "Entering free snap mode" ) elif self.itemSnapMode == 1: newLoc = Locator.TerrainToolLocator() t.delView( "stdView" ) t.addView( self.itemToolTextureView, "stdView" ) t.size = 1 WorldEditor.addCommentaryMsg( "Entering terrain snap mode" ) elif self.itemSnapMode == 2: newLoc = Locator.ChunkObstacleToolLocator() t.delView( "stdView" ) t.addView( self.itemToolModelView, "stdView" ) t.size = 1 WorldEditor.addCommentaryMsg( "Entering obstacle snap mode" ) else: WorldEditor.addCommentaryMsg( "Unknown snap mode" ) #finally, recreate the functor self.itemTool.locator.subLocator = newLoc
def onMiddleMouse( self ): # ensure that we both have a selection and something under the mouse if not self.selection.size or not self.mouseRevealer.size: return # ensure that we're in shell mode if not WorldEditor.isChunkSelected(): return # If v is held down, clone and snap the shell under the cursor if WorldEditor.isKeyDown( KEY_V ): group = WorldEditor.cloneAndAutoSnap( self.mouseRevealer, self.selection ) if ( group != None ): set_assign( self.selection, group ) self.selUpdate() else: WorldEditor.addCommentaryMsg( "No matching portals", 2 ) return # if the selection is different to what's under the mouse, if set_difference_new( self.selection, self.mouseRevealer ).size: # auto snap the shells together if not WorldEditor.autoSnap( self.selection, self.mouseRevealer ): WorldEditor.addCommentaryMsg( "No matching portals" )
def doSelectAll( item ): """This function selects all editable items in all loaded chunks.""" group = WorldEditor.selectAll() if ( group != None ): bd.itemTool.functor.script.selection.rem( bd.itemTool.functor.script.selection ) bd.itemTool.functor.script.selection.add( group ) bd.itemTool.functor.script.selUpdate()
def _onInput(self, position, yaw, pitch, roll):
self._parent.setRotateYPR(Math.Vector3(yaw, pitch, roll))
self._parent.translation = position
if IS_CLIENT:
if g_hangarSpace is not None:
clientHangarSpace = g_hangarSpace.space
if clientHangarSpace:
strategy = clientHangarSpace.hangarCamera.getStateStrategy(
)
if strategy and isinstance(
strategy, BigWorld.CameraStrategySuperFree):
direction = Math.Vector3(self._parent.get(2, 0),
self._parent.get(2, 1),
self._parent.get(2, 2))
fakeTarget = Math.Vector3(position.x + direction.x,
position.y + direction.y,
position.z + direction.z)
self._source.setTranslate(position)
self._target.setTranslate(fakeTarget)
strategy.sourceProvider = self._source
strategy.targetProvider = self._target
BigWorld.camera().parentMatrix = self._parent
else:
import WorldEditor
self._parent.invert()
WorldEditor.camera(0).view = self._parent
return 'out'
def actSelectAllExecute(): """This function selects all editable items in all loaded chunks.""" group = WorldEditor.selectAll() if ( group != None ): bd.itemTool.functor.script.selection.rem( bd.itemTool.functor.script.selection ) bd.itemTool.functor.script.selection.add( group ) bd.itemTool.functor.script.selUpdate()
def updateState( self, dTime ): GUI.update( dTime ) self.cc.update( dTime ) WorldEditor.camera().update( dTime ) if not WorldEditor.tool().applying: self.objInfo.overGizmo = WorldEditor.gizmoUpdate( WorldEditor.worldRay() ) WorldEditor.update( dTime ) return 1
def _onInput(self, position, targetPos):
localPos = targetPos - position
localPos.normalise()
yawOnTarget = math.atan2(localPos.x, localPos.z)
pitchOnTarget = -math.asin(clamp(-1.0, localPos.y, 1.0))
if self.prevYaw:
alternativeYaw = yawOnTarget - math.pi if yawOnTarget > 0 else yawOnTarget + math.pi
if math.fabs(alternativeYaw -
self.prevYaw) < math.fabs(yawOnTarget - self.prevYaw):
yawOnTarget = alternativeYaw
pitchOnTarget = math.pi - pitchOnTarget if pitchOnTarget > 0 else -math.pi - pitchOnTarget
self.prevYaw = yawOnTarget
self._matrix.setRotateYPR((yawOnTarget, pitchOnTarget, 0))
self._matrix.translation = position
if self.prevMatrixYaw:
if math.fabs(self.prevMatrixYaw - self._matrix.yaw) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
elif math.fabs(self.prevMatrixPitch - self._matrix.pitch) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
elif math.fabs(self.prevMatrixRoll - self._matrix.roll) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
else:
self.prevMatrixYaw = self._matrix.yaw
self.prevMatrixPitch = self._matrix.pitch
self.prevMatrixRoll = self._matrix.roll
if self.skipFrames > 0:
self.skipFrames = self.skipFrames - 1
self._parent.translation = self._matrix.translation
else:
self._parent.set(self._matrix)
if math.fabs(
math.fabs(self.prevMatrixYaw) -
math.fabs(self._matrix.yaw)) < 0.05 and math.fabs(
math.fabs(self.prevMatrixPitch) -
math.fabs(self._matrix.pitch)) < 0.05:
self.prevMatrixYaw = self._matrix.yaw
self.prevMatrixPitch = self._matrix.pitch
self.prevMatrixRoll = self._matrix.roll
if IS_CLIENT:
if g_hangarSpace is not None:
clientHangarSpace = g_hangarSpace.space
if clientHangarSpace:
strategy = clientHangarSpace.hangarCamera.getStateStrategy(
)
if strategy and isinstance(
strategy, BigWorld.CameraStrategySuperFree):
strategy.parentProvider = self._parent
BigWorld.camera().parentMatrix = self._parent
clientHangarSpace.hangarCamera.setDirectAngle(
yawOnTarget, pitchOnTarget)
else:
import WorldEditor
self._inverted.set(self._parent)
self._inverted.invert()
WorldEditor.camera(0).view = self._inverted
return 'out'
def onKeyEvent( self, isDown, key, modifiers ): if not WorldEditor.cursorOverGraphicsWnd(): return 0 if key == KEY_RIGHTMOUSE: if ( not self.rightMouseButtonDown ) and isDown: self.rightMouseButtonDown = 1 self.mouseMoved = 0 elif self.rightMouseButtonDown and not isDown: self.rightMouseButtonDown = 0 if not self.mouseMoved: self.onRightMouse() handled = 0 if self.avatarMode and key == KEY_Q: self.qDown = isDown self.eDown = 0 handled = 1 if self.avatarMode and key == KEY_E: self.eDown = isDown self.qDown = 0 handled = 1 if not handled: handled = WorldEditor.camera().handleKeyEvent( isDown, key, modifiers ) if not handled and isDown: handled = self.ownKeyEvent( key, modifiers ) if not handled and WorldEditor.tool() != None: handled = WorldEditor.tool().handleKeyEvent( isDown, key, modifiers ) if not handled and isDown and key == KEY_LEFTMOUSE and self.objInfo.overGizmo: WorldEditor.gizmoClick() handled = 1 return handled
def selUpdate( self ): if self.selection.size: if WorldEditor.isKeyDown( KEY_C ): self.selEditor = WorldEditor.ChunkEditor( self.selection ) else: self.selEditor = WorldEditor.ChunkItemEditor( self.selection ) WorldEditor.setCurrentEditors( self.selEditor ) print "Selected a", self.selEditor.description else: self.selEditor = None WorldEditor.setCurrentEditors()
def __init__( self ): global bd bd = self self.objInfo = ObjInfo() global oi oi = self.objInfo self.modeName = "Object" self.terrainModeName = "TerrainTexture" self.itemSnapMode = 0 self.nextTimeDoSelUpdate = 0 self.currentTerrainFilter = -1 self.rightMouseButtonDown = 0 self.mouseMoved = 0 self.eDown = 0 self.qDown = 0 self.avatarMode = 0 self.modeStack = [] self.needsChunkVizUpdate = False self.currentSpace = "" WorldEditor.setNoSelectionFilter( "portal" ) WorldEditor.setOptionInt( "render/chunk/vizMode", 0 );
def addChunkModel( self ):
#If we are adding a model file, then simply
#add the resource name to the chunk at the locator.
bp = self.objInfo.getBrowsePath()
if len(bp)>6 and bp[-6:] == ".model":
d = ResMgr.DataSection( "model" )
d.writeString( "resource", bp )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator, 2 )
if ( group != None ):
self.chunkItemAdded( d.name );
if len(bp)>4 and bp[-4:] == ".spt":
d = ResMgr.DataSection( "speedtree" )
d.writeString( "spt", bp )
d.writeInt( "seed", 1 )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator, 2 )
if ( group != None ):
self.chunkItemAdded( d.name );
# if it's a .xml file in the particles directory, add a ChunkParticles chunk item
if bp.find("particles/") != -1 and (len(bp)>4 and bp[-4:] == ".xml"):
d = ResMgr.DataSection( "particles" )
d.writeString( "resource", bp )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator, 2 )
if ( group != None ):
self.chunkItemAdded( d.name );
#XML files represent completely generic additions to the chunk,
#and so all the information must be deep-copied and added
#to the chunk.
elif len(bp)>4 and bp[-4:] == ".xml":
s = ResMgr.openSection( bp ).values()[0]
if ( s != None ):
d = ResMgr.DataSection( s.name )
deepCopy( d, s )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator )
if ( group != None ):
self.chunkItemAdded( d.name );
# If it's a .py file, add an entity with the same name
elif len(bp)>3 and bp[-3:] == ".py":
d = ResMgr.DataSection( "entity" )
d.writeString( "type", bp[ bp.rfind("/")+1 : -3 ] )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator )
if ( group != None ):
self.chunkItemAdded( d.name );
# If it's a .def file, add an entity with the same name
elif len(bp)>4 and bp[-4:] == ".def":
if bp.find("user_data_object") == -1:
d = ResMgr.DataSection( "entity" )
d.writeString( "type", bp[ bp.rfind("/")+1 : -4 ] )
else:
d = ResMgr.DataSection( "UserDataObject" )
d.writeString( "type", bp[ bp.rfind("/")+1 : -4 ] )
group = WorldEditor.createChunkItem( d, self.mouseLocator.subLocator )
if ( group != None ):
self.chunkItemAdded( d.name );
def brwObjectUalItemSelect(value, dblClick):
if dblClick == 0:
global oi
if value.find("/shells") == -1 and value[:7] != "shells/":
oi.setShellMode(0)
ualSelectFilterChange("All Except Terrain and Shells")
else:
oi.setShellMode(1)
ualSelectFilterChange("Shells + Contents")
oi.setBrowsePath(value)
oi.showBrowse()
else:
if value[-6:] == ".brush":
WorldEditor.setToolMode("TerrainTexture")
WorldEditor.setCurrentBrush(value)
elif WorldEditor.isTerrainTexture(value):
WorldEditor.setToolMode("TerrainTexture")
WorldEditor.setCurrentTexture(value)
def brwObjectUalItemSelect( value, dblClick ): if dblClick == 0: global oi if value.find( "/shells" ) == -1 and value[:7] != "shells/": oi.setShellMode( 0 ) ualSelectFilterChange( "All Except Terrain and Shells" ) else: oi.setShellMode( 1 ) ualSelectFilterChange( "Shells + Contents" ) oi.setBrowsePath( value ) oi.showBrowse() else: if value[-6:] == ".brush": WorldEditor.setToolMode( "TerrainTexture" ) WorldEditor.setCurrentBrush( value ) elif WorldEditor.isTerrainTexture( value ): WorldEditor.setToolMode( "TerrainTexture" ) WorldEditor.setCurrentTexture( value )
def update( self, dTime, tool ): # must use update to check for this, key events aren't reliable if not WorldEditor.isKeyDown( KEY_LEFTMOUSE ): if (WorldEditor.isKeyDown( KEY_LCONTROL ) or WorldEditor.isKeyDown( KEY_RCONTROL )): # add the set set_union( self.chunkItemFunctor.selection, self.mouseRevealer ) elif WorldEditor.isKeyDown( KEY_LALT ) or WorldEditor.isKeyDown( KEY_RALT ): # remove the set self.chunkItemFunctor.selection.rem( self.mouseRevealer ) else: # set the selection to our mouse revaler set_assign( self.chunkItemFunctor.selection, self.mouseRevealer ) if not WorldEditor.isKeyDown( KEY_LALT ) and not WorldEditor.isKeyDown( KEY_RALT ): # not removing, so also add whatever is under the cursor set_union( self.chunkItemFunctor.selection, self.chunkItemFunctor.mouseRevealer ) self.chunkItemFunctor.selUpdate() WorldEditor.popTool( )
def __init__( self, tool, oi ): # set up the tool we are part of self.mouseLocator = Locator.ChunkItemLocator( Locator.TerrainToolLocator() ) self.mouseRevealer = self.mouseLocator.revealer self.selection = WorldEditor.ChunkItemGroup() self.mouseView = View.ChunkItemBounds( self.mouseRevealer, 0xff0000ff ) self.selView = View.ChunkItemBounds( self.selection, 0xff00ff00 ) tool.locator = self.mouseLocator tool.addView( self.mouseView ) tool.addView( self.selView ) # store a reference to the object info class self.objInfo = oi
def onLeftMouse( self ): self.clickX = 0 self.clickY = 0 # first see if there's a gizmo in the house if self.objInfo.overGizmo: # if so, let it take care of things WorldEditor.gizmoClick() return if not self.mouseRevealer.size: # nothing to click on, start a marquee selection. This will take # care of clearing the selection if it's only a click. self.startDragSelect() return # Check if control is held down, it indicates that we want to toggle # what's pointed to in/out of the selection if (WorldEditor.isKeyDown( KEY_LCONTROL ) or WorldEditor.isKeyDown( KEY_RCONTROL )): # if we're pointing at a subset of the selection if set_issubset( self.selection, self.mouseRevealer): # remove the subset self.selection.rem( self.mouseRevealer ) self.selUpdate() return else: # add the mouseRevealer to the selection set_union( self.selection, self.mouseRevealer ) self.selUpdate() return else: # if the selection is totally different to what's under the mouse # specifically, if we're only pointing at a subset of the # selection, we don't want to set the selection to that, we want # to drag it instead (which happens below ) #if not set_intersection_new( self.selection, self.mouseRevealer).size: if not set_issubset( self.selection, self.mouseRevealer ): # set the selection to what's under the mouse set_assign( self.selection, self.mouseRevealer ) self.selUpdate() # nothing under the mouse, bail if not self.selection.size: return if not WorldEditor.getOptionInt( "dragOnSelect" ): if not WorldEditor.isKeyDown( KEY_V ): return # ok, it's drag time self.dragging = 1
def handleEvent( self, type, key, modifiers, c ): if ( WorldEditor.isKeyDown( key ) ): if ( key == Keys.KEY_LEFTMOUSE ) : c.textureName = self.textureMouseDown self.clickState = 1 return 1 else: if ( key == Keys.KEY_LEFTMOUSE ) : c.textureName = self.textureFocus if ( self.clickState == 1 ): if ( self.eventHandler != None ): self.eventHandler.onClick( self.buttonEvent ) return 1 return 0
def handleEvent(self, type, key, modifiers, c):
if (WorldEditor.isKeyDown(key)):
if (key == Keys.KEY_LEFTMOUSE):
c.textureName = self.textureMouseDown
self.clickState = 1
return 1
else:
if (key == Keys.KEY_LEFTMOUSE):
c.textureName = self.textureFocus
if (self.clickState == 1):
if (self.eventHandler != None):
self.eventHandler.onClick(self.buttonEvent)
return 1
return 0
def doSaveCameraPosition(item):
dir = WorldEditor.getOptionString("space/mru0")
dirDS = ResMgr.openSection(dir)
if not dirDS:
WorldEditor.addCommentaryMsg("Unable to open local directory " + dir)
return
ds = dirDS["space.localsettings"]
if ds == None:
ds = dirDS.createSection("space.localsettings")
if ds == None:
WorldEditor.addCommentaryMsg("Unable to create space.localsettings")
return
m = WorldEditor.camera(0).view
m.invert()
ds.writeVector3("startPosition", m.translation)
ds.writeVector3("startDirection", (m.roll, m.pitch, m.yaw))
ds.save()
WorldEditor.addCommentaryMsg("Camera position saved")
def selUpdate( self ): try: # tell big bang what the current selection is WorldEditor.revealSelection( self.selection ) if self.selection.size: self.selEditor = WorldEditor.ChunkItemEditor( self.selection ) WorldEditor.setCurrentEditors( self.selEditor ) #if hasattr(self.selEditor, "description"): # print "Selected a", str(self.selEditor.description) #else: # print "Selected a group" # inform the user of stats about the selection #if ( self.objInfo.shellMode == 1 and self.selection.size > 1): # WorldEditor.showChunkReport( self.selection ) else: self.selEditor = None WorldEditor.setCurrentEditors() except EnvironmentError, e: WorldEditor.addCommentaryMsg( e.args[0], 1 )
def actSaveCameraPositionExecute(): dir = WorldEditor.getOptionString( "space/mru0" ) dirDS = ResMgr.openSection( dir ) if not dirDS: WorldEditor.addCommentaryMsg( "Unable to open local directory " + dir ) return ds = dirDS["space.localsettings"] if ds == None: ds = dirDS.createSection( "space.localsettings" ) if ds == None: WorldEditor.addCommentaryMsg( "Unable to create space.localsettings" ) return m = WorldEditor.camera(0).view m.invert() ds.writeVector3( "startPosition", m.translation ) ds.writeVector3( "startDirection", (m.roll, m.pitch, m.yaw) ) ds.save() WorldEditor.addCommentaryMsg( "Camera position saved" )
class ChunkItemFunctor: def __init__( self, tool, oi ): # set up the tool we are part of self.mouseLocator = Locator.ChunkItemLocator( Locator.TerrainToolLocator() ) self.mouseRevealer = self.mouseLocator.revealer self.selection = WorldEditor.ChunkItemGroup() self.mouseView = View.ChunkItemBounds( self.mouseRevealer, 0xff0000ff ) self.selView = View.ChunkItemBounds( self.selection, 0xff00ff00 ) tool.locator = self.mouseLocator tool.addView( self.mouseView ) tool.addView( self.selView ) # store a reference to the object info class self.objInfo = oi # key event entry point def onKeyEvent( self, (isDown, key, modifiers), tool ): handled = 0 if isDown: if key == KEY_LEFTMOUSE: self.onLeftMouse() handled = 1 elif key == KEY_INSERT: bp = self.objInfo.getBrowsePath() if len(bp)>6 and bp[-6:] == ".model": d = ResMgr.DataSection( "model" ) d.writeString( "resource", bp ) # WorldEditor.createChunkItem( d, self.mouseLocator.subLocator ) elif key == KEY_DELETE: if self.selection.size: WorldEditor.deleteChunkItem( self.selection ) self.selection.rem( self.selection ) return handled
def onLeftMouse( self ): # first see if there's a gizmo in the house if self.objInfo.overGizmo: # if so, let it take care of things WorldEditor.gizmoClick() return # we have to compare what's under the cursor to our selection # if there's no selection then (for now) set it to that # and do nothing more if not self.selection.size: self.selection.add( self.mouseRevealer ) self.selUpdate() return # if there's a selection but nothing under the mouse, # clear the selection if self.selection.size and not self.mouseRevealer.size: self.selection.rem( self.selection ) self.selUpdate() return # if the selection is different to what's under the mouse, # change the selection diff = WorldEditor.ChunkItemGroup() diff.add( self.selection ) diff.rem( self.mouseRevealer ) # cumbersome I know if diff.size: self.selection.rem( self.selection ) self.selection.add( self.mouseRevealer ) self.selUpdate() return # ok the selection and what's under the mouse are the same, # start a drag of the selection # first make the tool nt = WorldEditor.Tool() nt.locator = self.mouseLocator nt.functor = Functor.MatrixMover( self.selection ) # and then push it onto the stack. it'll pop itself off when done WorldEditor.pushTool( nt )
def actImportExecute(): WorldEditor.importDataGUI()
def actSaveChunkTemplateExecute(): if bd.itemTool.functor.script.selection.size: WorldEditor.saveChunkTemplate( bd.itemTool.functor.script.selection ) else: WorldEditor.addCommentaryMsg( "Nothing selected" )
def addChunkPrefab( self ): group = WorldEditor.loadChunkPrefab( self.objInfo.getBrowsePath(), self.mouseLocator.subLocator ) if ( group != None ): self.chunkItemAdded( self.objInfo.getBrowsePath() );
def chunkItemAdded( self, name ): WorldEditor.addItemToHistory( self.objInfo.getBrowsePath(), "FILE" ); WorldEditor.addCommentaryMsg( "Added " + name )