def toggleItemSnaps( self ):
		if self.itemSnapMode == 1:
			self.itemSnapMode = 0
		else:
			self.itemSnapMode = 1
		WorldEditor.setOptionInt( "snaps/itemSnapMode", self.itemSnapMode )
		self.updateItemSnaps()
	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 updateState( self, dTime ):
		"""This function forces an update to be called in World Editor. 
		Usually called everyframe, however it still recieves a dTime 
		value which informs the update function how much time has passed 
		since the last update call."""

		# detect a change of space, and act accordingly
		if self.currentSpace != WorldEditor.getOptionString( "space/mru0" ):
			self.currentSpace = WorldEditor.getOptionString( "space/mru0" )
			# make sure the chunk viz resolution is set correctly
			self.enterChunkVizMode()

		GUI.update( dTime )
		self.cc.update( dTime )
		WorldEditor.camera().update( dTime )
		if ( WorldEditor.tool() != None and not WorldEditor.tool().applying ):
			self.objInfo.overGizmo = WorldEditor.gizmoUpdate( WorldEditor.worldRay() )

		# update the WorldEditor
		WorldEditor.update( dTime )

		# update tool views
		base = dTime / 5
		self.alphaToolTextureView.rotation += base * (1 + (self.alphaTool.strength / 650))
		self.heightView.rotation += base * (1 + (self.heightTool.strength / 650))
		self.filterToolTextureView.rotation += base

		if self.nextTimeDoSelUpdate == 2:
			self.itemTool.functor.script.restoreOldSelection()
			self.nextTimeDoSelUpdate = 0
		elif self.nextTimeDoSelUpdate == 1:
			self.itemTool.functor.script.clearAndSaveSelection()
			self.nextTimeDoSelUpdate = 2

		if WorldEditor.isInPlayerPreviewMode() and not self.avatarMode:
			WorldEditor.addCommentaryMsg( "entered avatar walkthrough mode." )
			self.avatarMode = 1
		if self.avatarMode and not WorldEditor.isInPlayerPreviewMode():
			self.qDown = 0
			self.eDown = 0
			self.avatarMode = 0
		if self.avatarMode:
			value = WorldEditor.getOptionString( "camera/speed" )
			speed = 1
			if value == "Medium":
				speed = 2
			if value == "Fast":
				speed = 3
			if value == "SuperFast":
				speed = 4
			if self.qDown and WorldEditor.getOptionInt( "graphics/cameraHeight" ) - speed <= 2:
				WorldEditor.setOptionInt( "graphics/cameraHeight", 2 )
			if self.qDown and WorldEditor.getOptionInt( "graphics/cameraHeight" ) > 2:
				WorldEditor.setOptionInt( "graphics/cameraHeight", WorldEditor.getOptionInt( "graphics/cameraHeight" ) - speed )
			if self.eDown:
				WorldEditor.setOptionInt( "graphics/cameraHeight", WorldEditor.getOptionInt( "graphics/cameraHeight" ) + speed )

			WorldEditor.snapCameraToTerrain()

		if WorldEditor.tool() == bd.alphaTool:
			bd.alphaTool.size						= WorldEditor.getOptionFloat  ( "terrain/texture/size" )
			bd.alphaTool.strength					= WorldEditor.getOptionFloat  ( "terrain/texture/strength" )
			bd.alphaTool.functor.displayOverlay		= WorldEditor.getOptionInt    ( "terrain/texture/maskoverlay" )
		
			WorldEditor.setPaintLayer(bd.alphaTool.functor.lastPaintedLayer)
			WorldEditor.setPaintPos(bd.alphaTool.functor.lastPaintedPos)
			if bd.alphaTool.functor.hadEscapeKey != 0:
				WorldEditor.setTerrainPaintEscKey(bd.alphaTool.functor.hadEscapeKey)
				bd.alphaTool.functor.hadEscapeKey = 0

		bd.heightTool.size						= WorldEditor.getOptionFloat ( "terrain/height/size" )
		bd.heightTool.strength					= WorldEditor.getOptionFloat ( "terrain/height/strength" )
		bd.setHeightFunctor.height				= WorldEditor.getOptionFloat ( "terrain/height/height" )
		bd.setHeightFunctor.relative			= WorldEditor.getOptionInt   ( "terrain/height/relative" )
		bd.heightFunctor.falloff				= WorldEditor.getOptionInt   ( "terrain/height/brushFalloff" )
																		
		bd.filterTool.size						= WorldEditor.getOptionFloat ( "terrain/filter/size" )
		bd.filterTool.functor.index				= WorldEditor.getOptionInt   ( "terrain/filter/index" )
																		
		bd.holeTool.size						= WorldEditor.getOptionFloat ( "terrain/cutRepair/size" )
		bd.holeTool.functor.fillNotCut			= WorldEditor.getOptionInt   ( "terrain/cutRepair/brushMode" )
		
		if self.needsChunkVizUpdate:
			self.enterChunkVizMode()
		
		return 1
예제 #4
0
def onHideOrthoMode( item ):
		WorldEditor.setOptionInt( "camera/ortho", 0 )
		WorldEditor.changeToCamera(0)
예제 #5
0
def doSnapObstacleLock(item):
    WorldEditor.setOptionInt("snaps/itemSnapMode", 2)
    bd.updateItemSnaps()
예제 #6
0
def doSnapFreePositioning(item):
    WorldEditor.setOptionInt("snaps/itemSnapMode", 0)
    bd.updateItemSnaps()
예제 #7
0
def heightMap(item):
    WorldEditor.setOptionInt("render/chunk/vizMode", 2)
    bd.enterChunkVizMode()
예제 #8
0
def normalMode(item):
    WorldEditor.setOptionInt("render/chunk/vizMode", 0)
    bd.enterChunkVizMode()
예제 #9
0
def onHideOrthoMode(item):
    WorldEditor.setOptionInt("camera/ortho", 0)
    WorldEditor.changeToCamera(0)
예제 #10
0
def doSnapFreePositioning( item ):
	WorldEditor.setOptionInt( "snaps/itemSnapMode", 0 )
	bd.updateItemSnaps()
예제 #11
0
def meshMode( item ):
	WorldEditor.setOptionInt( "render/chunk/vizMode", 3 )
	bd.enterChunkVizMode()
예제 #12
0
def heightMap( item ):
	WorldEditor.setOptionInt( "render/chunk/vizMode", 2 )
	bd.enterChunkVizMode()
예제 #13
0
def boundaryBox( item ):
	WorldEditor.setOptionInt( "render/chunk/vizMode", 1 )
	bd.enterChunkVizMode()
예제 #14
0
def normalMode( item ):
	WorldEditor.setOptionInt( "render/chunk/vizMode", 0 )
	bd.enterChunkVizMode()
예제 #15
0
def onDisableUmbraMode( item ):
	""" Sets both Umbra and the useUmbra Option so that 
	    the game will start in the last set state
	"""
	BigWorld.setWatcher( "Render/Umbra/enabled", 0 )
	WorldEditor.setOptionInt( "render/useUmbra", 0)
예제 #16
0
def onShowOrthoMode(item):
    WorldEditor.setOptionInt("camera/ortho", 1)
    WorldEditor.changeToCamera(1)
예제 #17
0
def doSnapTerrainLock( item ):
	WorldEditor.setOptionInt( "snaps/itemSnapMode", 1 )
	bd.updateItemSnaps()
예제 #18
0
def onDisableUmbraMode(item):
    """ Sets both Umbra and the useUmbra Option so that 
	    the game will start in the last set state
	"""
    BigWorld.setWatcher("Render/Umbra/enabled", 0)
    WorldEditor.setOptionInt("render/useUmbra", 0)
예제 #19
0
def doSnapObstacleLock( item ):
	WorldEditor.setOptionInt( "snaps/itemSnapMode", 2 )
	bd.updateItemSnaps()
예제 #20
0
def boundaryBox(item):
    WorldEditor.setOptionInt("render/chunk/vizMode", 1)
    bd.enterChunkVizMode()
예제 #21
0
def doShowAllOutside( item ):
	WorldEditor.setOptionInt( "render/hideOutsideObjects", 0 )
	WorldEditor.setOptionInt( "render/scenery/shells/gameVisibility", 1 )
예제 #22
0
def meshMode(item):
    WorldEditor.setOptionInt("render/chunk/vizMode", 3)
    bd.enterChunkVizMode()
	def ownKeyEvent( self, key, modifiers ):
		
		if key == KEY_B:
			if (modifiers & MODIFIER_CTRL) == 0:
				curr = WorldEditor.getOptionInt( "drawBSP" )
				curr = ( curr + 1 ) % 2
				WorldEditor.setOptionInt( "drawBSP", curr )
				self.showBSPMsg( curr )
		
		elif key == KEY_M:
			curr = WorldEditor.getOptionInt( "dragOnSelect" )
			curr = ( curr + 1 ) % 2
			WorldEditor.setOptionInt( "dragOnSelect", curr )
			self.dragOnSelectMsg( curr )
	
		elif key == KEY_F8:
			curr = WorldEditor.getOptionString( "tools/coordFilter" )
			if curr == "World":
				curr = "Local"	
			elif curr == "Local":
				curr = "View"
			elif curr == "View":
				curr = "World"
			WorldEditor.setOptionString( "tools/coordFilter", curr )	
			WorldEditor.addCommentaryMsg( "Reference Coordinate System: %s" % curr )
		
		elif key == KEY_L:
			if modifiers & MODIFIER_CTRL:
				curr = WorldEditor.getOptionInt( "render/lighting" )
				curr = ( curr + 1 ) % 3
				WorldEditor.setOptionInt( "render/lighting", curr )
				self.lightingModeMsg( curr )
				
		elif key == KEY_G:
			curr = WorldEditor.getOptionInt( "snaps/xyzEnabled" )
			curr = ( curr + 1 )% 2
			WorldEditor.setOptionInt( "snaps/xyzEnabled", curr )
			self.objectSnapMsg( curr )

		elif key == KEY_1 and not modifiers:
			WorldEditor.setToolMode( "Objects" )
			
		elif key == KEY_2 and not modifiers:
			WorldEditor.setToolMode( "TerrainTexture" )
			
		elif key == KEY_3 and not modifiers:
			WorldEditor.setToolMode( "TerrainHeight" )
			
		elif key == KEY_4 and not modifiers:
			WorldEditor.setToolMode( "TerrainFilter" )
			
		elif key == KEY_5 and not modifiers:
			WorldEditor.setToolMode( "TerrainMesh" )
			
		elif key == KEY_6 and not modifiers:
			WorldEditor.setToolMode( "TerrainImpExp" )
			
		elif key == KEY_7 and not modifiers:
			WorldEditor.setToolMode( "Project" )
		
		t = WorldEditor.tool()

		sizeSection = ''
		strengthSection = ''
		minSizeSection = ''
		maxSizeSection = ''
		minStrengthSection = ''
		maxStrengthSection = ''
		if t == self.alphaTool:
			sizeSection = 'terrain/texture/size'
			minSizeSection = 'terrain/texture/minsizelimit'
			maxSizeSection = 'terrain/texture/maxsizelimit'
			strengthSection = 'terrain/texture/strength'
			minStrengthSection = 'terrain/texture/minstrengthlimit'
			maxStrengthSection = 'terrain/texture/maxstrengthlimit'
		elif t == self.heightTool:
			sizeSection = 'terrain/height/size'
			minSizeSection = 'terrain/height/minsizelimit'
			maxSizeSection = 'terrain/height/maxsizelimit'
			strengthSection = 'terrain/height/strength'
			minStrengthSection = 'terrain/height/minstrengthlimit'
			maxStrengthSection = 'terrain/height/maxstrengthlimit'
		elif t == self.filterTool:
			sizeSection = 'terrain/filter/size'
			minSizeSection = 'terrain/filter/minsizelimit'
			maxSizeSection = 'terrain/filter/maxsizelimit'
		elif t == self.holeTool:
			sizeSection = 'terrain/cutRepair/size'
			minSizeSection = 'terrain/cutRepair/minsizelimit'
			maxSizeSection = 'terrain/cutRepair/maxsizelimit'

		if sizeSection:
			size = WorldEditor.getOptionFloat( sizeSection )
			minSize = WorldEditor.getOptionFloat( minSizeSection )
			maxSize = WorldEditor.getOptionFloat( maxSizeSection )
			if key == KEY_RBRACKET:
				if not ( modifiers & MODIFIER_SHIFT ):
					size = size * 1.25 + 1
					if size > maxSize:
						size = maxSize
					t.size = size
					WorldEditor.setOptionFloat( sizeSection, size )
					WorldEditor.addCommentaryMsg( "Tool size %0.1f" % size )
			elif key == KEY_LBRACKET:
				if not ( modifiers & MODIFIER_SHIFT ):
					size = size * 0.8 - 1
					if size < minSize:
						size = minSize
					t.size = size
					WorldEditor.setOptionFloat( sizeSection, size )
					WorldEditor.addCommentaryMsg( "Tool size %0.1f" % size )
		if strengthSection:
			strength = WorldEditor.getOptionFloat( strengthSection )
			minStrength = WorldEditor.getOptionFloat( minStrengthSection )
			maxStrength = WorldEditor.getOptionFloat( maxStrengthSection )
			if key == KEY_RBRACKET and strength >= 0 or key == KEY_LBRACKET and strength < 0:
				if modifiers & MODIFIER_SHIFT:
					if strength >= 0:
						strength = strength * 1.25 + 1
					else:
						strength = strength * 1.25 - 1
					if strength > maxStrength:
						strength = maxStrength
					t.strength = strength
					WorldEditor.setOptionFloat( strengthSection, strength )
					WorldEditor.addCommentaryMsg( "Tool strength %0.1f" % strength )
			elif key == KEY_LBRACKET and strength >= 0 or key == KEY_RBRACKET and strength < 0:
				if modifiers & MODIFIER_SHIFT:
					if strength >= 0:
						strength = strength * 0.8 - 1
					else:
						strength = strength * 0.8 + 1
					if strength < minStrength:
						strength = minStrength
					t.strength = strength
					WorldEditor.setOptionFloat( strengthSection, strength )
					WorldEditor.addCommentaryMsg( "Tool strength %0.1f" % strength )
예제 #24
0
def doSnapTerrainLock(item):
    WorldEditor.setOptionInt("snaps/itemSnapMode", 1)
    bd.updateItemSnaps()
	def onStart( self ):

		# create chunk viz
		self.chunkViz = View.TerrainChunkTextureToolView( "resources/maps/gizmo/square.dds" )
		self.chunkViz.numPerChunk = 1

		# create vertex viz
		self.vertexViz = View.TerrainChunkTextureToolView( "resources/maps/gizmo/vertices.dds" )
		self.vertexViz.numPerChunk = 25

		# create terrain mesh viz
		self.meshViz = View.TerrainChunkTextureToolView( "resources/maps/gizmo/quads.dds" )
		self.meshViz.numPerChunk = 25

		# create alpha tool
		self.alphaTool = WorldEditor.Tool()
		self.alphaTool.functor = Functor.TerrainTextureFunctor()
		self.alphaTool.locator = Locator.TerrainToolLocator()
		self.alphaToolTextureView = View.TerrainTextureToolView( "resources/maps/gizmo/alphatool.tga" )
		self.alphaTool.addView( self.alphaToolTextureView, "stdView" )
		self.alphaTool.size = 30
		self.alphaTool.strength = 1000

		# create height filter tool
		self.heightFunctor = Functor.TerrainHeightFilterFunctor()
		self.heightFunctor.index = 0 # this index must match the filters.xml file
		self.heightFunctor.strengthMod = 1
		self.heightFunctor.framerateMod = 1
		self.heightFunctor.constant = 1.0
		self.heightFunctor.falloff = 2

		self.setHeightFunctor = Functor.TerrainSetHeightFunctor()
		self.setHeightFunctor.height = 0
		self.setHeightFunctor.relative = 0
		
		self.heightView = View.TerrainTextureToolView( "resources/maps/gizmo/heighttool.tga" )
		self.setHeightView = View.TerrainTextureToolView( "resources/maps/gizmo/squaretool.dds" )

		self.heightTool = WorldEditor.Tool()
		self.heightTool.locator = Locator.TerrainToolLocator()
		self.heightTool.functor = Functor.TeeFunctor( self.heightFunctor, self.setHeightFunctor, KEY_LCONTROL )
		self.heightToolTextureView = View.TeeView( self.heightView, self.setHeightView, KEY_LCONTROL )
		self.heightTool.addView( self.heightToolTextureView, "stdView" )
		self.heightTool.size = 30

		# create general filter tool
		self.filterTool = WorldEditor.Tool()
		self.filterTool.locator = Locator.TerrainToolLocator()
		self.filterTool.functor = Functor.TerrainHeightFilterFunctor()
		self.filterTool.functor.strengthMod = 1
		self.filterTool.functor.constant = 0.0
		self.filterToolTextureView = View.TerrainTextureToolView( "resources/maps/gizmo/filtertool.tga" )
		self.filterTool.addView( self.filterToolTextureView, "stdView" )
		self.filterTool.size = 30

		# create a hole cutter
		self.holeTool = WorldEditor.Tool()		
		self.holeTool.locator = Locator.TerrainHoleToolLocator()
		view = View.TerrainTextureToolView( "resources/maps/gizmo/squaretool.dds" )
		view.showHoles = True
		self.holeTool.addView( view, "stdView" )
		self.holeTool.functor = Functor.TerrainHoleFunctor()
		self.holeTool.size = 30

		# create the item tool
		self.itemTool = WorldEditor.Tool()
		self.itemToolXZLocator = Locator.ItemToolLocator()
		self.itemTool.locator = Locator.TerrainToolLocator()
		self.itemToolTextureView = View.TerrainTextureToolView( "resources/maps/gizmo/cross2.dds" )
		self.itemToolModelView = View.ModelToolView( "resources/models/pointer.model" )
		self.itemToolPlaneView = View.ModelToolView( "resources/models/freepointer.model" )
		self.itemTool.addView( self.itemToolTextureView, "stdView" )
		# This changes our locator to a ChunkItemLocator
		self.itemTool.functor = Functor.ScriptedFunctor( ChunkItemFunctor( self.itemTool, self.objInfo ) )
		# Setup the correct subLocator for the ChunkItemLocator
		self.itemTool.locator.subLocator = self.itemToolXZLocator
		self.itemTool.size = 1

		# Make the closed captions commentary viewer
		self.cc = GUI.ClosedCaptions( WorldEditor.getOptionInt( "consoles/numMessageLines", 5 ) )
		self.cc.addAsView()
		self.cc.visible = 1

		if ( WorldEditor.getOptionInt( "tools/showChunkVisualisation" ) == 1 ):
			WorldEditor.setOptionInt( "render/chunk/vizMode", 1)
		self.enterChunkVizMode()

		self.enterMode( self.modeName, 1 )

		# initialise the mouse move camera
		# load up the start position from space.localsettings
		startPos = (0,1.85,0)
		startDir = (0,0,0)

		dir = WorldEditor.getOptionString( "space/mru0" )
		dirDS = ResMgr.openSection( dir )
		ds = dirDS["space.localsettings"]
		if ds != None:
			startPos = ds.readVector3( "startPosition", startPos )
			startDir = ds.readVector3( "startDirection", startDir )

		m = WorldEditor.camera(0).view
		m.setIdentity()
		m.setRotateYPR( (startDir[2], startDir[1], startDir[0]) )
		m.translation = startPos
		m.invert()
		WorldEditor.camera(0).view = m

		# select the camera as specified in the options
		WorldEditor.changeToCamera( WorldEditor.getOptionInt( "camera/ortho" ) )

		# read the initial item snap mode
		self.updateItemSnaps();
예제 #26
0
def doShowAllOutside(item):
    WorldEditor.setOptionInt("render/hideOutsideObjects", 0)
    WorldEditor.setOptionInt("render/scenery/shells/gameVisibility", 1)
예제 #27
0
def onShowOrthoMode( item ):
		WorldEditor.setOptionInt( "camera/ortho", 1 )
		WorldEditor.changeToCamera(1)