def setupWindow(self, windowType, x, y, width, height,
parent):
""" Applies the indicated window parameters to the prc
settings, for future windows; or applies them directly to the
main window if the window has already been opened. This is
called by the browser. """
if self.started and base.win:
# If we've already got a window, this must be a
# resize/reposition request.
wp = WindowProperties()
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
if windowType == 'embedded':
wp.setParentWindow(parent)
wp.setFullscreen(False)
base.win.requestProperties(wp)
self.windowProperties = wp
return
# If we haven't got a window already, start 'er up. Apply the
# requested setting to the prc file, and to the default
# WindowProperties structure.
self.__clearWindowProperties()
if windowType == 'hidden':
data = 'window-type none\n'
else:
data = 'window-type onscreen\n'
wp = WindowProperties.getDefault()
wp.clearParentWindow()
wp.clearOrigin()
wp.clearSize()
wp.setFullscreen(False)
if windowType == 'fullscreen':
wp.setFullscreen(True)
if windowType == 'embedded':
wp.setParentWindow(parent)
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
self.windowProperties = wp
self.windowPrc = loadPrcFileData("setupWindow", data)
WindowProperties.setDefault(wp)
self.gotWindow = True
# Send this call to the main thread; don't call it directly.
messenger.send('AppRunner_startIfReady', taskChain = 'default')
def setupWindow(self, windowType, x, y, width, height,
parent):
""" Applies the indicated window parameters to the prc
settings, for future windows; or applies them directly to the
main window if the window has already been opened. This is
called by the browser. """
if self.started and base.win:
# If we've already got a window, this must be a
# resize/reposition request.
wp = WindowProperties()
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
if windowType == 'embedded':
wp.setParentWindow(parent)
wp.setFullscreen(False)
base.win.requestProperties(wp)
self.windowProperties = wp
return
# If we haven't got a window already, start 'er up. Apply the
# requested setting to the prc file, and to the default
# WindowProperties structure.
self.__clearWindowProperties()
if windowType == 'hidden':
data = 'window-type none\n'
else:
data = 'window-type onscreen\n'
wp = WindowProperties.getDefault()
wp.clearParentWindow()
wp.clearOrigin()
wp.clearSize()
wp.setFullscreen(False)
if windowType == 'fullscreen':
wp.setFullscreen(True)
if windowType == 'embedded':
wp.setParentWindow(parent)
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
self.windowProperties = wp
self.windowPrc = loadPrcFileData("setupWindow", data)
WindowProperties.setDefault(wp)
self.gotWindow = True
# Send this call to the main thread; don't call it directly.
messenger.send('AppRunner_startIfReady', taskChain = 'default')
def resetWindowProperties(self, pipe, properties):
if base.win:
currentProperties = WindowProperties(base.win.getProperties())
gsg = base.win.getGsg()
else:
currentProperties = WindowProperties.getDefault()
gsg = None
newProperties = WindowProperties(currentProperties)
newProperties.addProperties(properties)
if base.pipe != pipe:
gsg = None
if gsg == None or currentProperties.getFullscreen() != newProperties.getFullscreen() or currentProperties.getParentWindow() != newProperties.getParentWindow():
self.notify.debug('window properties: %s' % properties)
self.notify.debug('gsg: %s' % gsg)
base.pipe = pipe
if not base.openMainWindow(props=properties, gsg=gsg, keepCamera=True):
self.notify.warning('OPEN MAIN WINDOW FAILED')
return 0
self.notify.info('OPEN MAIN WINDOW PASSED')
base.graphicsEngine.openWindows()
if base.win.isClosed():
self.notify.warning('Window did not open, removing.')
base.closeWindow(base.win)
return 0
base.disableShowbaseMouse()
if 'libotp' in sys.modules:
from libotp import NametagGlobals
NametagGlobals.setCamera(base.cam)
NametagGlobals.setMouseWatcher(base.mouseWatcherNode)
else:
self.notify.debug('Adjusting properties')
base.win.requestProperties(properties)
base.graphicsEngine.renderFrame()
return 1
def __init__(self, parent, res=(1024, 768)):
self.parent = parent
# Init pipe
ShowBase()
base.makeDefaultPipe()
screen = (base.pipe.getDisplayWidth(), base.pipe.getDisplayHeight())
win = WindowProperties.getDefault()
xsize = ConfigVariableInt("resx", res[0]).getValue()
ysize = ConfigVariableInt("resy", res[1]).getValue()
win.setSize(xsize, ysize)
win.setFullscreen(False)
base.openDefaultWindow(win)
def __init__(self):
ShowBase.__init__(self)
properties = WindowProperties()
properties.setSize(1000, 1000)
self.win.requestProperties(properties)
self.disableMouse()
self.environment = loader.loadModel("environment/environment")
self.environment.reparentTo(render)
self.useTrackball()
self.monkey = Actor("models/monkey")
self.monkey.set_scale(.25)
self.monkey.reparentTo(render)
self.monkey.set_pos(0, 0, 2)
self.monkey2 = Actor("models/monkey")
self.monkey2.set_scale(.25)
self.monkey2.reparentTo(render)
self.monkey2.set_pos(0, 3, 2)
self.camera.reparentTo(self.monkey)
props = WindowProperties.getDefault()
props.setOrigin(0, 0)
props.setSize(300, 300)
props.setFixedSize(True)
offwindow = self.openWindow(props,
makeCamera=False,
type="onscreen",
requireWindow=True)
display_region = offwindow.makeDisplayRegion(0, 1.0, 0, 1.0)
self.graphicsEngine.renderFrame()
texture = display_region.getScreenshot()
numpy_image = memoryview(texture.getRamImage())
numpy_image_data = np.array(texture.getRamImage())
print(numpy_image_data[0:100])
self.taskMgr.add(self.example_Task, "updateTask")
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
render.setShaderAuto()
def init_wp(window_type, size):
"""Initial / default WindowProperties.
Args:
window_type (str): Window type.
size (Iterable, 2): Width, height.
Return:
(WindowProperties): WindowProperties object.
"""
if window_type == "onscreen":
wp = WindowProperties.getDefault()
wp.setSize(size[0], size[1])
elif window_type == "offscreen":
wp = WindowProperties.size(size[0], size[1])
return wp
def __init__(self):
if DEBUG:
from pandac.PandaModules import ConfigPageManager
print ConfigPageManager.getGlobalPtr()
#Set application properties
wp = WindowProperties.getDefault()
wp.setTitle(APPNAME)
wp.setSize(APPX, APPY)
WindowProperties.setDefault(wp)
ShowBase.__init__(self)
self.initScene()
#InitialSettings
#~ self.scene.simul_time = datetime(2024,12,31, 8, 44)#sun rise
#~ self.scene.simul_time = datetime(9999,12,31, 8, 44)
self.Camera.hm.look(self.sun)
self.Camera.hm.follow(self.home)
def __init__(self):
if DEBUG:
from pandac.PandaModules import ConfigPageManager
print ConfigPageManager.getGlobalPtr()
#Set application properties
wp = WindowProperties.getDefault()
wp.setTitle(APPNAME)
wp.setSize(APPX, APPY)
WindowProperties.setDefault(wp)
ShowBase.__init__(self)
self.initScene()
#InitialSettings
#~ self.scene.simul_time = datetime(2024,12,31, 8, 44)#sun rise
#~ self.scene.simul_time = datetime(9999,12,31, 8, 44)
self.Camera.hm.look(self.sun)
self.Camera.hm.follow(self.home)
def __init__(self):
ShowBase.__init__(self)
# base.useDrive()
# TODO: Mouse Control
# base.disableMouse()
wp = WindowProperties.getDefault()
wp.setOrigin(0, 0)
base.win.requestProperties(wp)
# self.waveShader = loader.loadShader("wave.sha")
# self.UWShader = loader.loadShader("underwater.sha")
# self.UWMShader = loader.loadShader("UWModel.sha")
self.mainNode = render.attachNewNode("Main Node")
print(type(self.mainNode))
self.selectedNode = render.attachNewNode("Selected")
self.selectedNode.showTightBounds()
self.UWNode = render.attachNewNode("Underwater Node")
self.initScene()
self.pandaKeys = KeyboardManager(self)
base.setBackgroundColor(.5, .5, .5)
# commands queue
taskMgr.doMethodLater(0, self.processCmdQueue, 'processCmdQueue')
def get_aspect_ratio(output):
"""Returns aspect ratio of `output`'s window, or default aspect
ratio if it has no window.
Args:
output (GraphicsOutput): Graphics output.
Return:
(float): Aspect ratio.
"""
aspect_ratio = 1
if output.hasSize():
aspect_ratio = (float(output.getSbsLeftXSize()) /
float(output.getSbsLeftYSize()))
else:
wp = output.getRequestedProperties()
if not wp.hasSize():
wp = WindowProperties.getDefault()
aspect_ratio = float(wp.getXSize()) / float(wp.getYSize())
return aspect_ratio
config_menuitems=ConfigVariableString('key_menuitems', 'v')
config_useitem=ConfigVariableString('key_useitem', 'u')
config_nextitem=ConfigVariableString('key_nextitem', 'i')
config_forward=ConfigVariableString('key_forward', 'w|arrow_up')
config_back=ConfigVariableString('key_back', 's|arrow_down')
config_left=ConfigVariableString('key_left', 'a|arrow_left')
config_right=ConfigVariableString('key_right', 'd|arrow_right')
config_camera_left=ConfigVariableString('key_cam_left', 'q|delete')
config_camera_right=ConfigVariableString('key_cam_right', 'e|page_down')
config_action1=ConfigVariableString('key_action1', 'mouse1|enter')
config_action2=ConfigVariableString('key_action2', 'mouse3|space')
config_zoomin=ConfigVariableString('key_zoomin', 'wheel_up|r')
config_zoomout=ConfigVariableString('key_zoomout', 'wheel_down|f')
#if(config_aa.getValue()>0):
# loadPrcFileData('','multisamples '+str(config_aa.getValue()))
wp = WindowProperties.getDefault()
#wp = base.win.getProperties()
wp.setFixedSize(False)
wp.setCursorHidden(True)
wp.setUndecorated(True)
wp.setOrigin(-2,-2)
wp.setTitle("Avolition - Demo v.1.0, www.indiedb.com/games/avolition/")
if(config_fulscreen.getValue ()==1):
wp.setFullscreen(True)
wp.setSize(config_win_size.getWord(0),config_win_size.getWord(1))
#WindowProperties.setDefault(wp)
#base.win.requestProperties(wp)
from panda3d.core import *
#import direct.directbase.DirectStart
from panda3d.core import loadPrcFileData
loadPrcFileData('','textures-power-2 None')#needed for fxaa
loadPrcFileData('','win-size 1024 768')
from direct.showbase.AppRunnerGlobal import appRunner
from panda3d.core import Filename
if appRunner:
path=appRunner.p3dFilename.getDirname()+'/'
else:
path=""
from panda3d.core import WindowProperties
wp = WindowProperties.getDefault()
#wp.setFixedSize(True) #needed for fxaa
wp.setOrigin(-2,-2)
wp.setTitle("Simple Level Editor for Panda3D")
WindowProperties.setDefault(wp)
from panda3d.core import *
import direct.directbase.DirectStart
from direct.showbase.DirectObject import DirectObject
from direct.filter.FilterManager import FilterManager
from camcon import CameraControler
from buffpaint import BufferPainter
from guihelper import GuiHelper
import os, sys
from random import uniform
BUFFER_HEIGHT=0
BUFFER_ATR=1
BUFFER_COLOR=2
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "back":0, "cam-left":0, "cam-right":0}
self.flag1=0
self.flag2=0
self.flag3=0
self.flag4=0
self.count=0
self.health = 100
self.points = -5
self.flagd=1
self.player_points = 0
base.win.setClearColor(Vec4(0,0,0,1))
self.mySound=base.loader.loadSfx("sounds/trial.mp3")
self.mySound.play()
self.title = addTitle("Bumping Cars")
#Full Screen
props = WindowProperties.getDefault()
w=base.pipe.getDisplayWidth()
h=base.pipe.getDisplayHeight()
props.setSize(w,h)
props.setFullscreen(True)
props.setCursorHidden(True)
base.win.requestProperties(props)
# Load World
self.environ = loader.loadModel("models/world.egg")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
#Load Sky
self.sky = loader.loadModel("models/clouds.egg")
self.sky.reparentTo(render)
self.sky.setPos(60,0,-450)
# Create Player Car
carStartPos = self.environ.find("**/start_point").getPos()
self.car = Actor("models/carnsx")
self.car.reparentTo(render)
self.car.setScale(0.25)
#self.car.place()
self.car.setPos(carStartPos)
# Create Enemy Car 1
enemyCarStartPos1 = (-108,-1,-.5)
self.car1 = Actor("models/enemy_cars/monstercar/carmonster")
self.car1.reparentTo(render)
self.car1.setScale(0.25)
#self.car1.place()
self.car1.setPos(enemyCarStartPos1)
# Create Enemy Car 2
enemyCarStartPos2 = (-104,-26,-.02)
self.car2 = Actor("models/enemy_cars/yugo/yugo")
self.car2.reparentTo(render)
self.car2.setScale(0.15)
#self.car2.place()
self.car2.setPos(enemyCarStartPos2)
# Create Enemy Car 3
enemyCarStartPos3 = (-111,-26,0)
self.car3 = Actor("models/enemy_cars/truck/cartruck")
self.car3.reparentTo(render)
self.car3.setScale(0.25)
#self.car3.place()
self.car3.setPos(enemyCarStartPos3)
# Create Enemy Car 4
enemyCarStartPos4 = (-111,-2,-.5)
self.car4 = Actor("models/enemy_cars/truck/cartruck-purple")
self.car4.reparentTo(render)
self.car4.setScale(0.25)
#self.car4.place()
self.car4.setPos(enemyCarStartPos4)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_up",self.setKey, ["forward",1])
self.accept("arrow_left",self.setKey, ["left",1])
self.accept("arrow_down",self.setKey, ["back",1])
self.accept("arrow_right",self.setKey, ["right",1])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("arrow_up-up",self.setKey, ["forward",0])
self.accept("arrow_left-up",self.setKey, ["left",0])
self.accept("arrow_right-up",self.setKey, ["right",0])
self.accept("arrow_down-up",self.setKey, ["back",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.car.getX(),self.car.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# AI
self.AIworld = AIWorld(render)
# AI Car 1
self.AIchar1 = AICharacter("car1",self.car1, 70, 0.1, 3)
self.AIworld.addAiChar(self.AIchar1)
self.AIbehaviors1 = self.AIchar1.getAiBehaviors()
self.AIbehaviors1.pursue(self.car)
# AI Car 2
self.AIchar2 = AICharacter("car2",self.car2, 180, 0.1, 1)
self.AIworld.addAiChar(self.AIchar2)
self.AIbehaviors2 = self.AIchar2.getAiBehaviors()
self.AIbehaviors2.pursue(self.car4)
# AI Car 3
self.AIchar3 = AICharacter("car3",self.car3, 70, 0.1, 3)
self.AIworld.addAiChar(self.AIchar3)
self.AIbehaviors3 = self.AIchar3.getAiBehaviors()
self.AIbehaviors3.pursue(self.car)
# AI Car 4
self.AIchar4 = AICharacter("car4",self.car4, 200, 0.5, 2)
self.AIworld.addAiChar(self.AIchar4)
self.AIbehaviors4 = self.AIchar4.getAiBehaviors()
self.AIbehaviors4.pursue(self.car3)
# Obstacle avoidance
self.AIbehaviors1.obstacleAvoidance(1.0)
self.AIworld.addObstacle(self.car2)
self.AIworld.addObstacle(self.car3)
self.AIworld.addObstacle(self.car4)
self.AIbehaviors2.obstacleAvoidance(1.0)
self.AIbehaviors3.obstacleAvoidance(1.0)
self.AIbehaviors4.obstacleAvoidance(1.0)
#AI World update
taskMgr.add(self.AIUpdate,"AIUpdate")
self.cTrav = CollisionTraverser()
#self.cTrav.showCollisions(render)
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.carGroundColNp = self.car.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.carGroundColNp, self.ralphGroundHandler)
#car1
self.car1Ray = CollisionSphere(0,0,0,4)
self.car1GroundCol = CollisionNode('car1Ray')
self.car1GroundCol.addSolid(self.car1Ray)
self.car1GroundCol.setFromCollideMask(BitMask32.bit(0))
self.car1GroundCol.setIntoCollideMask(BitMask32.allOff())
self.car1GroundColNp = self.car.attachNewNode(self.car1GroundCol)
self.car1GroundHandler = CollisionHandlerQueue()
#self.car1GroundColNp.show()
self.cTrav.addCollider(self.car1GroundColNp, self.car1GroundHandler)
cnodePath = self.car1.attachNewNode(CollisionNode('cnode1'))
cnodePath.node().addSolid(self.car1Ray)
#cnodePath.show()
#car2
self.car2Ray = CollisionSphere(0,0,0,4)
self.car2GroundCol = CollisionNode('car2Ray')
self.car2GroundCol.addSolid(self.car2Ray)
self.car2GroundCol.setFromCollideMask(BitMask32.bit(0))
self.car2GroundCol.setIntoCollideMask(BitMask32.allOff())
self.car2GroundColNp = self.car.attachNewNode(self.car2GroundCol)
self.car2GroundHandler = CollisionHandlerQueue()
#self.car2GroundColNp.show()
self.cTrav.addCollider(self.car2GroundColNp, self.car2GroundHandler)
cnodePath = self.car2.attachNewNode(CollisionNode('cnode2'))
cnodePath.node().addSolid(self.car2Ray)
#cnodePath.show()
#car3
self.car3Ray = CollisionSphere(0,0,0,4)
self.car3GroundCol = CollisionNode('car3Ray')
self.car3GroundCol.addSolid(self.car3Ray)
self.car3GroundCol.setFromCollideMask(BitMask32.bit(0))
self.car3GroundCol.setIntoCollideMask(BitMask32.allOff())
self.car3GroundColNp = self.car.attachNewNode(self.car3GroundCol)
self.car3GroundHandler = CollisionHandlerQueue()
#self.car3GroundColNp.show()
self.cTrav.addCollider(self.car3GroundColNp, self.car3GroundHandler)
cnodePath = self.car3.attachNewNode(CollisionNode('cnode3'))
cnodePath.node().addSolid(self.car3Ray)
#cnodePath.show()
#car4
self.car4Ray = CollisionSphere(0,0,0,4)
self.car4GroundCol = CollisionNode('car4Ray')
self.car4GroundCol.addSolid(self.car4Ray)
self.car4GroundCol.setFromCollideMask(BitMask32.bit(0))
self.car4GroundCol.setIntoCollideMask(BitMask32.allOff())
self.car4GroundColNp = self.car.attachNewNode(self.car4GroundCol)
self.car4GroundHandler = CollisionHandlerQueue()
#self.car4GroundColNp.show()
self.cTrav.addCollider(self.car4GroundColNp, self.car4GroundHandler)
cnodePath = self.car4.attachNewNode(CollisionNode('cnode4'))
cnodePath.node().addSolid(self.car4Ray)
#cnodePath.show()
#camera
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def initialize(self):
self.lens = self.makeLens()
self.camera = self.doc.render.attachNewNode(
ModelNode("viewportCameraParent"))
self.camNode = Camera("viewportCamera")
self.camNode.setLens(self.lens)
self.camNode.setCameraMask(self.getViewportMask())
self.cam = self.camera.attachNewNode(self.camNode)
winprops = WindowProperties.getDefault()
winprops.setParentWindow(int(self.winId()))
winprops.setForeground(False)
winprops.setUndecorated(True)
gsg = self.doc.gsg
output = base.graphicsEngine.makeOutput(
base.pipe, "viewportOutput", 0, FrameBufferProperties.getDefault(),
winprops,
(GraphicsPipe.BFFbPropsOptional | GraphicsPipe.BFRequireWindow),
gsg)
self.qtWindow = QtGui.QWindow.fromWinId(
output.getWindowHandle().getIntHandle())
self.qtWidget = QtWidgets.QWidget.createWindowContainer(
self.qtWindow, self, QtCore.Qt.WindowDoesNotAcceptFocus
| QtCore.Qt.WindowTransparentForInput
| QtCore.Qt.WindowStaysOnBottomHint
| QtCore.Qt.BypassWindowManagerHint | QtCore.Qt.SubWindow) #,
#(QtCore.Qt.FramelessWindowHint | QtCore.Qt.WindowDoesNotAcceptFocus
#| QtCore.Qt.WindowTransparentForInput | QtCore.Qt.BypassWindowManagerHint
#| QtCore.Qt.SubWindow | QtCore.Qt.WindowStaysOnBottomHint))
self.qtWidget.setFocusPolicy(QtCore.Qt.NoFocus)
self.inputDevice = output.getInputDevice(0)
assert output is not None, "Unable to create viewport output!"
dr = output.makeDisplayRegion()
dr.disableClears()
dr.setCamera(self.cam)
self.displayRegion = dr
output.disableClears()
output.setClearColor(Viewport.ClearColor)
output.setClearColorActive(True)
output.setClearDepthActive(True)
output.setActive(True)
self.win = output
# keep track of the mouse in this viewport
mak = MouseAndKeyboard(self.win, 0, "mouse")
mouse = base.dataRoot.attachNewNode(mak)
self.mouseAndKeyboard = mouse
self.mouseWatcher = MouseWatcher()
self.mouseWatcher.setDisplayRegion(self.displayRegion)
mw = mouse.attachNewNode(self.mouseWatcher)
self.mouseWatcherNp = mw
# listen for keyboard and mouse events in this viewport
bt = ButtonThrower("kbEvents")
bt.setButtonDownEvent("btndown")
bt.setButtonUpEvent("btnup")
mods = ModifierButtons()
mods.addButton(KeyboardButton.shift())
mods.addButton(KeyboardButton.control())
mods.addButton(KeyboardButton.alt())
mods.addButton(KeyboardButton.meta())
bt.setModifierButtons(mods)
self.buttonThrower = mouse.attachNewNode(bt)
# collision objects for clicking on objects from this viewport
self.clickRay = CollisionRay()
self.clickNode = CollisionNode("viewportClickRay")
self.clickNode.addSolid(self.clickRay)
self.clickNp = NodePath(self.clickNode)
self.clickQueue = CollisionHandlerQueue()
self.setupRender2d()
self.setupCamera2d()
self.gizmo = ViewportGizmo(self)
self.doc.viewportMgr.addViewport(self)
self.makeGrid()
