def __init__(self):
self.base = ShowBase()
# graphics
# window
props = WindowProperties()
self.win_size = 600
props.setSize(self.win_size, self.win_size)
self.base.win.requestProperties(props)
# set up key
self.accept("c", self.move_center)
self.accept("b", self.plot_bananas)
self.accept("space", self.change_both)
self.num_bananas = 10
# total area is 100 (not true of the game, but just scales.
# was easier to make everything 1/2 size for this size window)
high_area = 0.25 * 0.33 * 100
middle_area = 0.25 * 100
self.high_radius = sqrt(high_area / pi)
self.middle_radius = sqrt(middle_area / pi)
self.high_reward = 6
self.middle_reward = 4
self.low_reward = 2
#print self.high_radius
#print self.middle_radius
self.weight_center = (random.uniform(-5, 5), random.uniform(-5, 5))
#print('weight center', self.weight_center)
self.banana_model = []
self.center_model = None
self.high_node = None
self.high_circle = None
self.middle_node = None
self.middle_circle = None
self.plot_border()
self.plot_bananas()
self.plot_circles()
def __init__(self):
DirectObject.__init__(self)
self.base = ShowBase()
resolution = (1024, 768)
wp = WindowProperties()
wp.setSize(int(resolution[0]), int(resolution[1]))
wp.setOrigin(0, 0)
self.base.win.requestProperties(wp)
# depth completely doesn't matter for this, since just 2d, and no layers
self.depth = 0
self.base.setBackgroundColor(115 / 255, 115 / 255, 115 / 255)
# set up a 2d camera
camera = self.base.camList[0]
lens = OrthographicLens()
lens.setFilmSize(int(resolution[0]), int(resolution[1]))
lens.setNearFar(-100, 100)
camera.node().setLens(lens)
camera.reparentTo(self.base.render)
self.accept("escape", sys.exit)
# spread out some positions
self.positions = [(-200, 0, -200),
(0, 0, -200),
(200, 0, -200),
(-200, 0, 0),
(0, 0, 0),
(200, 0, 0),
(-200, 0, 200),
(0, 0, 200),
(200, 0, 200)]
self.all_smiles()
def __init__(self):
# INIT Needed things.
# Inst. for Player Class playership.
initPlayerShip = PlayerShip()
self.playershipOB = initPlayerShip.playerShip
### SETUP CONTROL MAPS ###
self.controlMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "wheel-in": 0, "wheel-out": 0}
self.mousebtn = [0, 0, 0]
### SETUP KEYBOARD ###
# Setup the control [KEYS] for movement w,a,s,d. | This is basic will have to adjust for advance controls.
self.accept("escape", sys.exit)
self.accept("w", self.setControl, ["forward", 1])
self.accept("a", self.setControl, ["left", 1])
self.accept("s", self.setControl, ["backward", 1])
self.accept("d", self.setControl, ["right", 1])
self.accept("w-up", self.setControl, ["forward", 0])
self.accept("a-up", self.setControl, ["left", 0])
self.accept("s-up", self.setControl, ["backward", 0])
self.accept("d-up", self.setControl, ["right", 0])
# Setup mouse [ZOOM].
self.accept("wheel_up", self.setControl, ["wheel-in", 1])
self.accept("wheel_down", self.setControl, ["wheel-out", 1])
# Add the "moveTask"
taskMgr.add(self.move, "moveTask")
# Game State Variable.
self.IsMoving = False
###>
### SETUP CAMERA ###
# Reparent the -main- Camera to PlayerShip.
base.camera.reparentTo(self.playershipOB)
# The vertical offset. To view over ship.
self.cameraHeight = 0.05
# Camera Distance from playerShip. On Start.
self.cameraDistance = 0.23
# Camera Pitch.
self.cameraPitch = 0.04
# Disable the basic camera controls.
base.disableMouse()
# This should be used together with a right click function, for the camera rotate. Like in wow.
WinProps = WindowProperties()
# Hide the cursor. | This will change with the rightClick function.
# Giving us the cursor when not rotating. If the player wants to rotate basic [KEYS] left/right can turn while cursor is active.
WinProps.setCursorHidden(True)
base.win.requestProperties(WinProps)
def exitGameOver(self):
base.taskMgr.remove("menu")
properties = WindowProperties()
properties.setCursorHidden(True)
base.win.requestProperties(properties)
self.gm.destroy()
def setMouseModeRelative(self, state):
props = WindowProperties()
if not state:
props.setMouseMode(WindowProperties.MAbsolute)
else:
props.setMouseMode(WindowProperties.MRelative)
self.targetWin.requestProperties(props)
def __init__(self, parent, pos):
self.parent = parent
self.node = render.attachNewNode('PlayerNode')
self.node.setPos(pos[0]*TILE_SIZE,pos[1]*TILE_SIZE,TILE_SIZE*ASPECT/1.5)
taskMgr.add(self.updatePlayer, 'UpdatePlayerTask')
taskMgr.add(self.updateBullets, 'UpdateBulletsTask')
self.centerx = base.win.getProperties().getXSize()/2
self.centery = base.win.getProperties().getYSize()/2
self.speed = TILE_SIZE - 4
self.sprint_speed = self.speed * 1.8
self.can_move = True
self.camera = True
self.mouse_owner = True
self.max_health = 100
self.health = self.max_health
self.max_bullets = 10
self.bullets = 4
self.bullet_objects = []
self.sprint = False
self.moving = False
self.gunshot_at = None
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# Create player flashlight
self.slight = Spotlight('slight')
self.slight.setColor(VBase4(1, 1, 0.6, 1))
#self.lens = PerspectiveLens()
#self.slight.setLens(self.lens)
self.slnp = self.node.attachNewNode(self.slight)
self.slnp.node().getLens().setFov(88)
self.slnp.node().getLens().setNearFar(1, 70)
self.slight.setExponent(10)
self.slight.setAttenuation(Point3(0.737, 0.134, 0.001))
render.setLight(self.slnp)
self.flashlight = True
self.shoot_sound = base.loader.loadSfx("audio/GUN_FIRE-GoodSoundForYou-820112263.wav")
self.gun_click_sound = base.loader.loadSfx("audio/Dry Fire Gun-SoundBible.com-2053652037.wav")
self.heart_sound = base.loader.loadSfx("audio/Slow_HeartBeat-Mike_Koenig-1853475164.wav")
self.heart_sound.setLoop(True)
self.heart_sound.setVolume(0.6)
self.heart_sound.play()
self.scratches = loadImageAsPlane('models/scr.png')
self.scratches.setTransparency(TransparencyAttrib.MAlpha)
self.damage_anim = Parallel()
self.keys = {}
self.keys['forward'] = 0
self.keys['back'] = 0
self.keys['strafe_left'] = 0
self.keys['strafe_right'] = 0
self.keys['sprint'] = 0
self.setKeyEvents()
self.pause = False
def __init__(self):
DirectObject.__init__(self)
self.close=lambda:None
#create main window
base=ShowBase()
__builtin__.base=base
props = WindowProperties()
#props.setTitle(ConfigVariableString('win-title').getValue())
props.setFullscreen(ConfigVariableBool('fullscreen').getValue())
props.setSize(ConfigVariableInt('win-width').getValue(),ConfigVariableInt('win-height').getValue())
base.win.requestProperties(props)
self.width=base.win.getXSize()
self.height=base.win.getYSize()
print 'size=',self.width,'x',self.height
self.accept('window-event',self.on_resize)
base.disableMouse()
#set fps limit
globalClock=ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(ConfigVariableDouble('clock-frame-rate').getValue())
__builtin__.screen=self
__builtin__.gui=pixel2d.attachNewNode('Screen.gui')
#gui is the node for 2d rendering, scaled to the screen resolution,
#with origin at bottom-left, and max at top-right
gui.setZ(gui,-self.height)
__builtin__.console=Console(print_messenger_events=False)
__builtin__.out=console.out
console.request('Open')
__builtin__.mouse=base.pointerWatcherNodes[0]
#is used as a stack. stores frames showed to the user (top at the front of the screen)
self.frames=[]
def __init__(self, parentChar, keyMap):
assert isinstance(parentChar, Character)
base.disableMouse()
self.char = parentChar
self.keyMap = keyMap
print 'keymap is',keyMap
parentChar.node.rotationallyImmune = True
self.floater = NodePath('floater')
self.floater.reparentTo(parentChar.node)
self.floater.setPos(1,0,2)
base.camera.reparentTo(self.floater)
base.camera.setPos(0,-5,0)
base.camera.setH(0)
print base.camera.getPos(render)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
taskMgr.add(self.controlCamera, 'camera-task')
self.h = parentChar.node.getH()
self.p = parentChar.node.getP()
def main():
# Handles CLI arguments
p = OptionParser()
p.add_option('-m', '--nomusic', action="store_false", dest="music", default = True, help = u"Disable music")
p.add_option('-e', '--editor-mode', action="store_true", dest="editor", default = False, help = u"Editor mode")
options, args = p.parse_args()
levelname = 'level1'
if args:
levelname = args[0]
# Instantiate the ShowBase
base = ShowBase()
# Toggle events verbosity :
#base.messenger.toggleVerbose()
# Set window properties:
# - Hide mouse cursor
# - move the window (because of the pekwm bug)
curProps = base.win.getProperties()
props = WindowProperties()
props.setOrigin(curProps.getXOrigin() + 1, curProps.getYOrigin() + 1)
props.setCursorHidden(True)
base.win.requestProperties(props)
# Now instantiate Gate's own stuff
fps = FPS(base, levelname, options)
osd = OSD(base, fps)
mplayer = MusicPlayer(base, osd)
if options.music:
mplayer.play_random_track()
player = Player(base, fps, osd)
# And run the ShowBase
base.run()
def __init__(self):
ShowBase.__init__(self)
wp = WindowProperties()
wp.setSize(850, 480)
wp.setTitle("GAME")
base.win.requestProperties(wp)
bgg = BlockGeometryGenerator()
blocks = []
for x in xrange(1):
for y in xrange(512):
for z in xrange(64):
bid = random.randint(0, 255)
blocks.append(bid)
bgg.GenerateBlockGeometry(x, y, z, Block(bid), [0])
#blocks[x * 512 * 64 + y * 64 + z] = 1
print x
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
ambientLightNP = render.attachNewNode(ambientLight)
render.setLight(ambientLightNP)
def catchCursor(self):
# center the mouse in the middle of the window
base.win.movePointer(0, self.win_width_half, self.win_height_half)
# Set mouse mode to relative which should work best for our purpose
wp = WindowProperties()
wp.setMouseMode(WindowProperties.M_relative)
base.win.requestProperties(wp)
def createBuffer(self, name, xsize, ysize, texgroup, depthbits=1):
""" Low-level buffer creation. Not intended for public use. """
winprops = WindowProperties()
winprops.setSize(xsize, ysize)
props = FrameBufferProperties(FrameBufferProperties.getDefault())
props.setBackBuffers(0)
props.setRgbColor(1)
props.setDepthBits(depthbits)
props.setStereo(self.win.isStereo())
depthtex, colortex, auxtex0, auxtex1 = texgroup
if (auxtex0 != None):
props.setAuxRgba(1)
if (auxtex1 != None):
props.setAuxRgba(2)
buffer=base.graphicsEngine.makeOutput(
self.win.getPipe(), name, -1,
props, winprops, GraphicsPipe.BFRefuseWindow | GraphicsPipe.BFResizeable,
self.win.getGsg(), self.win)
if (buffer == None):
return buffer
if (depthtex):
buffer.addRenderTexture(depthtex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepth)
if (colortex):
buffer.addRenderTexture(colortex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
if (auxtex0):
buffer.addRenderTexture(auxtex0, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
if (auxtex1):
buffer.addRenderTexture(auxtex1, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba1)
buffer.setSort(self.nextsort)
buffer.disableClears()
self.nextsort += 1
return buffer
def setResolution( self, w, h ): wp = WindowProperties() wp.setSize( w, h ) if os.name == 'posix': self.openMainWindow() self.graphicsEngine.openWindows() self.win.requestProperties( wp )
def toggleMouse(self):
print "Toggling mouse visibility"
self.hideMouse = not self.hideMouse
wp = WindowProperties()
wp.setCursorHidden(self.hideMouse)
self.base.win.requestProperties(wp)
def __clearWindowProperties(self):
""" Clears the windowPrc file that was created in a previous
call to setupWindow(), if any. """
if self.windowPrc:
unloadPrcFile(self.windowPrc)
self.windowPrc = None
WindowProperties.clearDefault()
def setCursor(self):
base.win.clearRejectedProperties()
props = WindowProperties()
if sys.platform.startswith('linux'):
props.setCursorFilename("./assets/cursor.x11")
else:
props.setCursorFilename("./assets/cursor.ico")
base.win.requestProperties(props)
def hide_cursor():
"""set the Cursor invisible"""
props = WindowProperties()
props.setCursorHidden(True)
# somehow the window gets undecorated after hiding the cursor
# so we reset it here to the value we need
# props.setUndecorated(settings.fullscreen)
base.win.requestProperties(props)
def test_winprops_size_staticmethod():
props = WindowProperties.size(1, 2)
assert props.has_size()
assert props.get_size() == (1, 2)
props = WindowProperties.size((1, 2))
assert props.has_size()
assert props.get_size() == (1, 2)
def toggle_fullscreen(self):
wp = WindowProperties()
self.isFullScreen = not self.isFullScreen
wp.setFullscreen(self.isFullScreen)
wp.setSize(1024, 768)
base.openMainWindow()
base.win.requestProperties(wp)
base.graphicsEngine.openWindows()
def tick(self):
# Select appropriate mouse mode
if self.constrain_center_mouse:
mouse_mode = WindowProperties.M_relative
elif self.confine_mouse:
mouse_mode = WindowProperties.M_confined
else:
mouse_mode = WindowProperties.M_absolute
# Set mouse mode
props = WindowProperties()
props.set_mouse_mode(mouse_mode)
props.set_cursor_hidden(not self.mouse_visible)
base.win.requestProperties(props)
# Get mouse position
mouse_node = base.mouseWatcherNode
if not mouse_node.hasMouse():
return
x = mouse_node.getMouseX()
y = mouse_node.getMouseY()
mouse_position = x, y
last_mouse_position = self.mouse_position
if last_mouse_position:
last_x, last_y = last_mouse_position
mouse_delta = (x - last_x, y - last_y)
else:
mouse_delta = (0.0, 0.0)
# Set mouse position and delta
self.mouse_position = mouse_position
self.mouse_delta = mouse_delta
# Get event states
is_down = mouse_node.is_button_down
active_events = {v for k, v in panda_to_input_button.items() if is_down(k)}
entered_events = active_events - self._down_events
released_events = input_button_values - active_events
# Build converted state
PRESSED = ButtonStates.pressed
HELD = ButtonStates.held
RELEASED = ButtonStates.released
converted_events = {e: HELD for e in active_events}
converted_events.update({e: PRESSED for e in entered_events})
converted_events.update({e: RELEASED for e in released_events})
self._down_events = active_events
self.buttons_state = converted_events
self._world.messenger.send("input_updated", input_manager=self)
def setUpCamera(self):
""" puts camera behind the player in third person """
# Set up the camera
# Adding the camera to actor is a simple way to keep the camera locked
# in behind actor regardless of actor's movement.
base.camera.reparentTo(self.actor)
# We don't actually want to point the camera at actors's feet.
# This value will serve as a vertical offset so we can look over the actor
self.cameraTargetHeight = 0.5
# How far should the camera be from the actor
self.cameraDistance = 10
# Initialize the pitch of the camera
self.cameraPitch = 45
# The mouse moves rotates the camera so lets get rid of the cursor
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
#set up FOV
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
# A CollisionRay beginning above the camera and going down toward the
# ground is used to detect camera collisions and the height of the
# camera above the ground. A ray may hit the terrain, or it may hit a
# rock or a tree. If it hits the terrain, we detect the camera's
# height. If it hits anything else, the camera is in an illegal
# position.
"""
TODO:: This will need to be changed to bullet
"""
self.cTrav = CollisionTraverser()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0,0,1000)
self.groundRay.setDirection(0,0,-1)
self.groundCol = CollisionNode('camRay')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setFromCollideMask(BitMask32.bit(1))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = base.camera.attachNewNode(self.groundCol)
self.groundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.groundColNp, self.groundHandler)
# We will detect anything obstructing the camera's view of the player
self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(0,5,5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.actor.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def pause(self):
if self._running:
self._running = False
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
if self._revealMouseAt:
base.win.movePointer(0, self._revealMouseAt[0], self._revealMouseAt[1])
self._revealMouseAt = None
def __init__(self):
ShowBase.__init__(self)
wp = WindowProperties()
wp.setSize(850, 480)
wp.setTitle("GAME")
base.win.requestProperties(wp)
c = Client()
def stop(self):
# For now show the mouseCursor
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.ignoreMouseButtons()
# App exit temp
base.ignore("escape")
def reconnectMouse(self):
self.mouse_owner = True
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0, self.centerx, self.centery)
def start(self):
# For now hide the mouseCursor
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# App exit temp
base.accept("escape", self.engine.stop)
self.setMouseButtons()
def start(self):
self.gameApp.disableMouse()
self.camera.setP(self.refNode, 0)
self.camera.setR(self.refNode, 0)
# hide mouse cursor, comment these 3 lines to see the cursor
props = WindowProperties()
props.setCursorHidden(True)
self.gameApp.win.requestProperties(props)
# reset mouse to start position:
self.gameApp.win.movePointer(0, self.centX, self.centY)
self.gameApp.taskMgr.add(self.cameraTask, 'HxMouseLook::cameraTask')
# Task for changing direction/position
self.accept("w", setattr, [self, "forward", True])
self.accept("shift-w", setattr, [self, "forward", True])
self.accept("w-up", setattr, [self, "forward", False])
self.accept("s", setattr, [self, "backward", True])
self.accept("shift-s", setattr, [self, "backward", True])
self.accept("s-up", setattr, [self, "backward", False])
self.accept("a", setattr, [self, "left", True])
self.accept("shift-a", setattr, [self, "left", True])
self.accept("a-up", setattr, [self, "left", False])
self.accept("d", setattr, [self, "right", True])
self.accept("shift-d", setattr, [self, "right", True])
self.accept("d-up", setattr, [self, "right", False])
self.accept("r", setattr, [self, "up", True])
self.accept("shift-r", setattr, [self, "up", True])
self.accept("r-up", setattr, [self, "up", False])
self.accept("f", setattr, [self, "down", True])
self.accept("shift-f", setattr, [self, "down", True])
self.accept("f-up", setattr, [self, "down", False])
self.accept("q", setattr, [self, "rollLeft", True])
self.accept("q-up", setattr, [self, "rollLeft", False])
self.accept("e", setattr, [self, "rollRight", True])
self.accept("e-up", setattr, [self, "rollRight", False])
self.accept("shift", setattr, [self, "fast", 10.0])
self.accept("shift-up", setattr, [self, "fast", 1.0])
# setup collisions
# setup collisions
if self.collisionHandler != None:
# setup collisions
nearDist = self.camera.node().getLens().getNear()
# Create a collision node for this camera.
# and attach it to the camera.
self.collisionNP = self.camera.attachNewNode(
CollisionNode("firstPersonCamera"))
# Attach a collision sphere solid to the collision node.
self.collisionNP.node().addSolid(
CollisionSphere(0, 0, 0, nearDist * 1.1))
# self.collisionNP.show()
# setup camera "from" bit-mask
self.collisionNP.node().setFromCollideMask(self.collideMask)
# add to collisionHandler (Pusher)
self.collisionHandler.addCollider(self.collisionNP, self.camera)
# add camera to collision system
self.gameApp.cTrav.addCollider(
self.collisionNP, self.collisionHandler)
def test_winprops_copy_ctor():
props = WindowProperties()
props.set_size(1, 2)
props2 = WindowProperties(props)
assert props == props2
assert props2.get_size() == (1, 2)
with pytest.raises(TypeError):
WindowProperties(None)
def setMouseLook(self, mouseLook):
self.mouseLook = mouseLook
self.mouseGrabbed = mouseLook # for now
wp = WindowProperties()
wp.setMouseMode(mouseLook and WindowProperties.MConfined or WindowProperties.MAbsolute)
wp.setCursorHidden(mouseLook)
self.base.win.requestProperties(wp)
self.base.taskMgr.doMethodLater(0, self.resolveMouse, "resolve mouse")
def enterGameOver(self, n):
properties = WindowProperties()
properties.setCursorHidden(False)
base.win.requestProperties(properties)
self.gm = gameover.init(n)
if n == 1:
base.taskMgr.add(base.menusTasks, "menu", extraArgs=["gameover1"], appendTask=True)
else:
base.taskMgr.add(base.menusTasks, "menu", extraArgs=["gameover2"], appendTask=True)
def __init__(self, rendering: bool):
"""
Constructor
:param rendering: boolean indicating whether to use RenderPipeline or default Panda3d as visualization-module.
"""
super().__init__(self)
self.dir = Filename.fromOsSpecific(
pyrado.PANDA_ASSETS_DIR).getFullpath()
# Initialize RenderPipeline
if rendering:
sys.path.insert(0, pyrado.RENDER_PIPELINE_DIR)
from rpcore import RenderPipeline
self.render_pipeline = RenderPipeline()
self.render_pipeline.pre_showbase_init()
self.render_pipeline.set_loading_screen_image(
osp.join(self.dir, "logo.png"))
self.render_pipeline.settings["pipeline.display_debugger"] = False
self.render_pipeline.create(self)
self.render_pipeline.daytime_mgr.time = "17:00"
else:
self.render_pipeline = None
# Activate antialiasing
self.render.setAntialias(AntialiasAttrib.MAuto)
# Set window properties
self.windowProperties = WindowProperties()
self.windowProperties.setForeground(True)
self.windowProperties.setTitle("Experiment")
# Set background color
self.setBackgroundColor(1, 1, 1)
# Configuration of the lighting
self.directionalLight1 = DirectionalLight("directionalLight")
self.directionalLightNP1 = self.render.attachNewNode(
self.directionalLight1)
self.directionalLightNP1.setHpr(0, -8, 0)
self.render.setLight(self.directionalLightNP1)
self.directionalLight2 = DirectionalLight("directionalLight")
self.directionalLightNP2 = self.render.attachNewNode(
self.directionalLight2)
self.directionalLightNP2.setHpr(180, -20, 0)
self.render.setLight(self.directionalLightNP2)
self.ambientLight = AmbientLight("ambientLight")
self.ambientLightNP = self.render.attachNewNode(self.ambientLight)
self.ambientLight.setColor((0.1, 0.1, 0.1, 1))
self.render.setLight(self.ambientLightNP)
# Create a text node displaying the physic parameters on the top left of the screen
self.text = TextNode("parameters")
self.textNodePath = aspect2d.attachNewNode(self.text)
self.text.setTextColor(0, 0, 0, 1) # black
self.textNodePath.setScale(0.07)
self.textNodePath.setPos(-1.9, 0, 0.9)
# Configure trace
self.trace = LineSegs()
self.trace.setThickness(3)
self.trace.setColor(0.8, 0.8, 0.8) # light grey
self.lines = self.render.attachNewNode("Lines")
self.last_pos = None
# Adds one instance of the update function to the task-manager, thus initializes the animation
self.taskMgr.add(self.update, "update")
def main():
props = WindowProperties()
props.setTitle('Hostil Galaxy')
props.setCursorFilename(Filename.binaryFilename('cursor.ico'))
props.setCursorHidden(False)
props.setFullscreen(False)
props.setSize(1024, 768)
game = World()
game.win.setClearColor((0, 0, 0, 1))
game.win.requestProperties(props)
game.setFrameRateMeter(True)
game.run()
class TestScreen:
def __init__(self, main_screen, screen):
self.main_screen = main_screen
self.props = WindowProperties()
self.props.set_size(800, 600)
self.props.set_origin(100 + screen * self.main_screen.res[0], 100)
self.props.set_undecorated(True)
self.props.set_foreground(True)
self._monitor = screen
self.window = self.main_screen.openWindow(props=self.props)
self.lens = self.main_screen.camList[-1].node().getLens()
def fullscreen(self, border=0):
if self.window.get_size()[0] == 800:
self.props.set_size((self.main_screen.res[0] - 2 * border,
self.main_screen.res[1] - 2 * border))
self.props.setOrigin(
self._monitor * self.main_screen.res[0] + border, border)
self.lens.setAspectRatio(
float(self.main_screen.res[0] / self.main_screen.res[1]))
else:
self.props.set_size(800, 600)
self.props.setOrigin(100 + self._monitor * self.main_screen.res[0],
100)
self.lens.setAspectRatio(4 / 3)
self.window.requestProperties(self.props)
def __init__(self):
super().__init__()
# self.set_background_color(0, 0, 0, 1)
# base.camera.setPos(0, 0, 0)
# print("Skybox")
self.skysphere = loader.loadModel("SkySphere.bam")
self.skysphere.setBin('background', 1)
self.skysphere.setDepthWrite(0)
self.skysphere.reparentTo(self.render)
lightIntensity = 0.7
# C:\Users\Bill\anaconda3\Lib\site-packages\panda3d\models
#self.floor = self.loader.loadModel('myModels/soil_6') # material texture must be png (jpg not okay)
#self.floor.setPos(0, 0, -0.5) #-2.5
#self.floor.reparentTo(self.render)
self.floor = self.loader.loadModel('myModels/slab')
self.floor.setPos(0, 0, -1.5) # -2.5
self.floor.reparentTo(self.render)
tex = self.loader.loadTexture('myModels/tex/soil_6.jpg')
self.floor.setTexture(tex, 1)
self.floor.setTexScale(TextureStage.getDefault(), 50, 50)
rndRange = 1.2
for i in range(20): # PUT 3x100 lettuce on teh scene:
self.lett_1 = self.loader.loadModel(
'myModels/lettuce_3'
) # material texture must be png (jpg not okay)
rnd = random.random() * 0.1 * rndRange
self.lett_1.setPos(-0.5 - rnd, 2 + i / 2, -0.5)
self.lett_1.setScale(0.1, 0.1, 0.1)
self.lett_1.reparentTo(self.render)
self.lett_2 = self.loader.loadModel(
'myModels/lettuce_32'
) # material texture must be png (jpg not okay)
rnd = random.random() * 0.1 * rndRange
self.lett_2.setPos(0 - rnd, 2 + i / 2, -0.5)
self.lett_2.setScale(0.1, 0.1, 0.1)
self.lett_2.reparentTo(self.render)
self.lett_3 = self.loader.loadModel(
'myModels/lettuce_32'
) # material texture must be png (jpg not okay)
rnd = random.random() * 0.1 * rndRange
self.lett_3.setPos(0.5 - rnd, 2 + i / 2, -0.5)
self.lett_3.setScale(0.1, 0.1, 0.1)
self.lett_3.reparentTo(self.render)
#self.cone = self.loader.loadModel('myModels/cone') # material texture must be png (jpg not okay)
#self.cone.setPos(1, 2, -1)
##self.cone.setScale(0.1, 0.1, 0.1)
#self.cone.reparentTo(self.render)
self.tree3 = self.loader.loadModel('myModels/christmas_tree')
self.tree3.setPos(-4, 7, -0.5)
self.tree3.reparentTo(self.render)
self.box = self.loader.loadModel('models/box')
self.box.setPos(0, 0, 0) # liked to camera -0.2 0.2
self.box.setScale(0.2, 0.2, 0.2)
self.box.reparentTo(self.cam)
# ********* END MODELS ********
# ****** AMBIENT light **********
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.7, 0.7, 0.7,
1)) # 0.2 0.2 0.2 lightIntensity
self.ambientLightNodePath = self.render.attachNewNode(
ambientLight) # attach to renderer ambiant light node path
#self.trees.setLight(ambientLightNodePath)
self.render.setLight(
self.ambientLightNodePath) # illuminate everything
# ****** DIRECTIONAL light **********
mainLight = DirectionalLight("main light")
mainLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
self.mainLightNodePath = self.render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees: setHpr(45, -45, 0)
self.mainLightNodePath.setHpr(45, -90, 0)
render.setLight(self.mainLightNodePath)
self.render.setShaderAuto() # create shadow
# ********* CAMERA ********
#self.camera.lookAt(0, 1, -0.5) # Camera tilted with Y & Z coordinates
self.camera.setPos(0, 0, 0)
#self.camera.setHpr(90, 0, 0) #not reacting
#base.camera.setHpr(90, 0, 0)
# SECOND stationery:
wp = WindowProperties()
wp.setSize(500, 500)
wp.setOrigin(800, 50)
win2 = base.openWindow(props=wp, aspectRatio=1)
cam2 = base.camList[1]
cam2.setPos(0, 18, 5) # 2nd relative to 'camera' 2 -20 10
cam2.lookAt(0, 0, 0)
cam2.reparentTo(render)
taskMgr.add(self.skysphereTask, "SkySphere Task")
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
self.stimtype = 'image_sequence'
#session_start
self.session_start_time = datetime.datetime.now()
self.accept("escape", sys.exit, [0])
self.accept('q', self.close)
self.accept('Q', self.close)
# disable mouse control so that we can place the camera
base.disableMouse()
camera.setPosHpr(0, 0, 10, 0, -90, 0)
mat = Mat4(camera.getMat())
mat.invertInPlace()
base.mouseInterfaceNode.setMat(mat)
# base.enableMouse()
props = WindowProperties()
# props.setFullscreen(True)
props.setCursorHidden(True)
props.setMouseMode(WindowProperties.M_relative)
base.win.requestProperties(props)
base.setBackgroundColor(0, 0, 0) # set the background color to black
#set up the textures
# we now get buffer thats going to hold the texture of our new scene
altBuffer = self.win.makeTextureBuffer("hello", 1524, 1024)
# altBuffer.getDisplayRegion(0).setDimensions(0.5,0.9,0.5,0.8)
# altBuffer = base.win.makeDisplayRegion()
# altBuffer.makeDisplayRegion(0,1,0,1)
# now we have to setup a new scene graph to make this scene
self.dr2 = base.win.makeDisplayRegion(0, 0.1, 0, 0.1)
altRender = NodePath("new render")
# this takes care of setting up ther camera properly
self.altCam = self.makeCamera(altBuffer)
self.dr2.setCamera(self.altCam)
self.altCam.reparentTo(altRender)
self.altCam.setPos(0, -10, 0)
self.bufferViewer.setPosition("llcorner")
# self.bufferViewer.position = (.1,.4,.1,.4)
self.bufferViewer.setCardSize(1.0, 0.0)
print(self.bufferViewer.position)
self.imagesTexture = MovieTexture("image_sequence")
# success = self.imagesTexture.read("models/natural_images.avi")
success = self.imagesTexture.read("models/movie_5hz.mpg")
self.imagesTexture.setPlayRate(1.0)
self.imagesTexture.setLoopCount(10)
# self.imageTexture =loader.loadTexture("models/NaturalImages/BSDs_8143.tiff")
# self.imagesTexture.reparentTo(altRender)
cm = CardMaker("stimwindow")
cm.setFrame(-4, 4, -3, 3)
# cm.setUvRange(self.imagesTexture)
self.card = NodePath(cm.generate())
self.card.reparentTo(altRender)
if self.stimtype == 'image_sequence':
self.card.setTexture(self.imagesTexture, 1)
# self.imagesTexture.play()
# self.bufferViewer.setPosition("lrcorner")
# self.bufferViewer.setCardSize(1.0, 0.0)
self.accept("v", self.bufferViewer.toggleEnable)
self.accept("V", self.bufferViewer.toggleEnable)
# Load the tunnel
self.initTunnel()
#initialize some things
# for the tunnel construction:
self.boundary_to_add_next_segment = -1 * TUNNEL_SEGMENT_LENGTH
self.current_number_of_segments = 8
#task flow booleans
self.in_waiting_period = False
self.stim_started = False
self.looking_for_a_cue_zone = True
self.in_reward_window = False
self.show_stimulus = False
#for task control
self.interval = 0
self.time_waiting_in_cue_zone = 0
self.wait_time = 1.0
self.stim_duration = 4.0 # in seconds
self.max_stim_duration = 6.0 # in seconds
self.stim_elapsed = 0.0 # in seconds
self.last_position = base.camera.getZ()
self.position_on_track = base.camera.getZ()
#for reward control
self.reward_window = 1.0 # in seconds
self.reward_elapsed = 0.0
self.reward_volume = 0.008 # in mL. this is for the hardcoded 0.1 seconds of reward time
self.reward_time = 0.1 # in sec, based on volume. hard coded right now but should be modified by the (1) calibration and (2) optionally by the main loop for dynamic reward scheduling
# self.lick_buffer = []
#INITIALIZE NIDAQ
self.nidevice = 'Dev1'
self.encodervinchannel = 0
self.encodervsigchannel = 1
self.invertdo = False
self.diport = 1
self.lickline = 1
self.doport = 0
self.rewardline = 0
self.rewardlines = [0]
self._setupDAQ()
self.do.WriteBit(1, 1)
self.do.WriteBit(
3, 1
) #set reward high, because the logic is flipped somehow. possibly by haphazard wiring of the circuit (12/24/2018 djd)
self.previous_encoder_position = self.ai.data[0][2]
self.encoder_gain = -20
#INITIALIZE LICK SENSOR
self._lickSensorSetup()
#INITIALIZE output data
self.lickData = []
self.x = []
self.t = []
self.trialData = []
self.rewardData = []
#INITIALIZE KEY SENSOR, for backup inputs and other user controls
self.keys = key.KeyStateHandler()
self.accept('r', self._give_reward, [self.reward_volume])
img_list = glob.glob('models/NaturalImages/*.tiff')[:10]
print(img_list)
self.imageTextures = [loader.loadTexture(img) for img in img_list]
if AUTO_MODE:
self.gameTask = taskMgr.add(self.autoLoop2, "autoLoop2")
self.rewardTask = taskMgr.add(self.rewardControl, "reward")
self.cue_zone = concatenate(
(self.cue_zone,
arange(
self.current_number_of_segments * -TUNNEL_SEGMENT_LENGTH -
10,
self.current_number_of_segments * -TUNNEL_SEGMENT_LENGTH -
TUNNEL_SEGMENT_LENGTH - 10, -1)))
self.auto_position_on_track = 0
self.auto_restart = False
self.auto_running = True
self.contTunnel()
else:
# Now we create the task. taskMgr is the task manager that actually
# calls the function each frame. The add method creates a new task.
# The first argument is the function to be called, and the second
# argument is the name for the task. It returns a task object which
# is passed to the function each frame.
self.gameTask = taskMgr.add(self.gameLoop, "gameLoop")
# self.stimulusTask = taskMgr.add(self.stimulusControl, "stimulus")
self.lickTask = taskMgr.add(self.lickControl, "lick")
self.rewardTask = taskMgr.add(self.rewardControl, "reward")
def properties(self):
if not self.pipe:
self.makeDefaultPipe()
props = WindowProperties()
props.setTitle("Title placeholder")
if self.option[Options.FULL.value]:
props.setSize(self.option[Options.RES.value][Options.X.value],
self.option[Options.RES.value][Options.Y.value])
props.setFullscreen(True)
loadPrcFileData('', 'fullscreen t')
else:
props.setSize(self.option[Options.RES.value][Options.X.value],
self.option[Options.RES.value][Options.Y.value])
props.setCursorHidden(True)
props.setDefault(props)
self.openMainWindow(props)
from direct.gui.DirectGui import *
import sys
import random
import math
import buildingsDB
from cameraController import CameraController
from planetInfoView import PlanetInfoView
from planetBuildView import PlanetBuildView
from star import Star
from planet import Planet
from moon import Moon
base = ShowBase()
wp = WindowProperties()
wp.setSize(1080, 600)
base.win.requestProperties(wp)
class World(DirectObject):
def __init__(self):
# The standard camera, light and background initialization
base.setBackgroundColor(0, 0, 0)
base.disableMouse()
self.cam_ctrl = CameraController()
self.cam_ctrl.reset()
alight = AmbientLight('alight')
alight.setColor((0.2, 0.2, 0.2, 1))
alnp = render.attachNewNode(alight)
def __init__(self):
ShowBase.__init__(self)
# self.setFrameRateMeter(True)
wp = WindowProperties()
wp.setSize(1280, 720)
wp.setFullscreen(False)
self.win.requestProperties(wp)
self.disableMouse()
# Load the background starfield.
self.setBackgroundColor((0, 0, 0, 1))
self.font = loader.loadFont('textures/inconsolata.egg')
self.bg = loadObject("star_field.png", scale=73, depth=200,
transparency=False)
self.bg.setTag('back_ground', '1')
self.bg.setSx(73*16/9)
# Load the ship and set its initial velocity. Create a ship entity
self.keys = { "turnLeft": 0,
"turnRight": 0,
"accel": 0,
"fire": 0,
"laser": 0,
"e_to_s": 0,
"s_to_e": 0,
"cloak": 0,
"p2turnLeft": 0,
"p2turnRight": 0,
"p2accel": 0,
"p2fire": 0,
"p2laser": 0,
"e_to_s2": 0,
"s_to_e2": 0,
"cloak2": 0,
"toggle_debug": 0,
"e_field": 0,
"e_field2": 0,
"mouse_l": 0,
}
self.accept("escape", sys.exit) # Escape quits
# Other keys events set the appropriate value in our key dictionary
self.accept("a", self.setKey, ["turnLeft", 1])
self.accept("a-up", self.setKey, ["turnLeft", 0])
self.accept("d", self.setKey, ["turnRight", 1])
self.accept("d-up", self.setKey, ["turnRight", 0])
self.accept("w", self.setKey, ["accel", 1])
self.accept("w-up", self.setKey, ["accel", 0])
self.accept("f", self.setKey, ["fire", 1])
self.accept("f-up", self.setKey, ["fire", 0])
self.accept("h", self.setKey, ["laser", 1])
self.accept("h-up", self.setKey, ["laser", 0])
self.accept("r", self.setKey, ["e_to_s", 1])
self.accept("r-up", self.setKey, ["e_to_s", 0])
self.accept("t", self.setKey, ["s_to_e", 1])
self.accept("t-up", self.setKey, ["s_to_e", 0])
self.accept("s", self.setKey, ["cloak", 1])
self.accept("s-up", self.setKey, ["cloak", 0])
self.accept("g", self.setKey, ["e_field", 1])
self.accept("g-up", self.setKey, ["e_field", 0])
self.accept("arrow_left", self.setKey, ["p2turnLeft", 1])
self.accept("arrow_left-up", self.setKey, ["p2turnLeft", 0])
self.accept("arrow_right", self.setKey, ["p2turnRight", 1])
self.accept("arrow_right-up", self.setKey, ["p2turnRight", 0])
self.accept("arrow_up", self.setKey, ["p2accel", 1])
self.accept("arrow_up-up", self.setKey, ["p2accel", 0])
# NUMPAD for p2
self.accept("1", self.setKey, ["p2fire", 1])
self.accept("1-up", self.setKey, ["p2fire", 0])
self.accept("3", self.setKey, ["p2laser", 1])
self.accept("3-up", self.setKey, ["p2laser", 0])
self.accept("4", self.setKey, ["e_to_s2", 1])
self.accept("4-up", self.setKey, ["e_to_s2", 0])
self.accept("5", self.setKey, ["s_to_e2", 1])
self.accept("5-up", self.setKey, ["s_to_e2", 0])
self.accept("2", self.setKey, ["e_field2", 1])
self.accept("2-up", self.setKey, ["e_field2", 0])
# NO NUMPAD for p2
self.accept("l", self.setKey, ["p2fire", 1])
self.accept("l-up", self.setKey, ["p2fire", 0])
self.accept("'", self.setKey, ["p2laser", 1])
self.accept("'-up", self.setKey, ["p2laser", 0])
self.accept("o", self.setKey, ["e_to_s2", 1])
self.accept("o-up", self.setKey, ["e_to_s2", 0])
self.accept("p", self.setKey, ["s_to_e2", 1])
self.accept("p-up", self.setKey, ["s_to_e2", 0])
self.accept(";", self.setKey, ["e_field2", 1])
self.accept(";-up", self.setKey, ["e_field2", 0])
self.accept("arrow_down", self.setKey, ["cloak2", 1])
self.accept("arrow_down-up", self.setKey, ["cloak2", 0])
self.accept("f1", self.setKey, ["toggle_debug", 1])
self.accept("mouse1", self.setKey, ["mouse_l", 1])
self.accept("mouse1-up", self.setKey, ["mouse_l", 0])
init_menu(self)
self.gameTask = taskMgr.add(self.menuLoop, "gameLoop")
def showMouse(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
def __init__(self):
ShowBase.__init__(self)
#renaming properties
properties = WindowProperties()
#set windows size property
properties.setSize(1000, 750)
#activate the property to the current window
self.win.requestProperties(properties)
#Calling one of Panda's lighting functions and naming it
ambientLight = AmbientLight("ambient light")
#setting the colour
ambientLight.setColor(Vec4(1, 1, 1, 1))
#creating a lighting node and adding it to the render list (doesn't do anything yet)
self.ambientLightNodePath = self.render.attachNewNode(ambientLight)
#We need to also use the setLight function to actually light the scene
self.render.setLight(self.ambientLightNodePath)
#choose shader
self.render.setShaderAuto()
#gather main camera generated by showbase
self.first_person_camera_node = self.cam
self.mouseLook = FirstPersonCamera(self, self.first_person_camera_node,
self.render)
lens = OrthographicLens()
lens.setFilmSize(2, 2) # Or whatever is appropriate for your scene
self.spot_camera = Camera("Spot Camera")
self.spot_camera.setLens(lens)
self.spot_camera_node = self.render.attachNewNode(self.spot_camera)
self.spot_camera_node.node().setLens(lens)
self.spot_camera_node.setName("Spot Camera")
self.spot_camera_node.setPos(2, 0, 0)
self.spot_camera_node.lookAt(0, 0, 0)
dr = base.camNode.getDisplayRegion(0)
dr.setActive(0)
window = dr.getWindow()
dr1 = window.makeDisplayRegion(0, 0.8, 0, 1)
dr1.setSort(dr.getSort())
dr2 = window.makeDisplayRegion(0.8, 0.9, 0.2, 0.4)
dr2.setSort(dr.getSort())
dr1.setCamera(self.first_person_camera_node)
dr2.setCamera(self.spot_camera_node)
axes = self.createAxes(2)
axes.reparentTo(self.render)
self.Line = self.render.attachNewNode(LineSegs().create())
self.taskMgr.add(self.update, "Update")
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')
props.setSize(width, height)
if base and base.win:
base.win.requestProperties(props)
# Start ShowBase, but don't open a Panda window yet
base = ShowBase(windowType='none')
# Start Tkinter integration, get the root window handle
base.startTk()
frame = base.tkRoot
frame.bind('<Configure>', on_resize)
frame.update()
id = frame.winfo_id()
width = frame.winfo_width()
height = frame.winfo_height()
props = WindowProperties()
props.setParentWindow(id)
props.setOrigin(0, 0)
props.setSize(width, height)
base.makeDefaultPipe()
base.openDefaultWindow(props=props)
scene = base.loader.loadModel("environment")
scene.reparentTo(base.render)
base.run()
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = Player(Vec3(0, 0, 0),
"Models/PandaChan/act_p3d_chan",
{
"stand" : "Models/PandaChan/a_p3d_chan_idle",
"walk" : "Models/PandaChan/a_p3d_chan_run"
},
5,
10,
"player")
self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
def __init__(self):
ShowBase.__init__(self)
self.models = []
self.base_textures = []
# window title
props = WindowProperties()
props.setTitle(pathlib.Path(args.project).name)
base.win.requestProperties(props)
# we would like an orthographic lens
self.lens = OrthographicLens()
self.lens.setFilmSize(20, 15)
base.camNode.setLens(self.lens)
self.cam_pos = [0.0, 0.0, 10000.0]
self.camera.setPos(self.cam_pos[0], self.cam_pos[1], self.cam_pos[2])
self.camera.setHpr(0, -90.0, 0)
self.view_size = 100.0
self.last_ysize = 0
self.top_image = 0
# modules
self.surface = surface.Surface(proj.analysis_dir)
self.annotations = annotations.Annotations(self.render, self.surface,
proj, ned_ref, tk_root)
self.reticle = reticle.Reticle(self.render, self.surface, ned_ref)
self.draw_reticle = True
#self.messenger.toggleVerbose()
# event handlers
self.accept('arrow_left', self.cam_move, [-0.1, 0, 0])
self.accept('arrow_right', self.cam_move, [0.1, 0, 0])
self.accept('arrow_down', self.cam_move, [0, -0.1, 0])
self.accept('arrow_up', self.cam_move, [0, 0.1, 0])
self.accept('=', self.cam_zoom, [1.1])
self.accept('shift-=', self.cam_zoom, [1.1])
self.accept('-', self.cam_zoom, [1.0 / 1.1])
self.accept('wheel_up', self.cam_zoom, [1.1])
self.accept('wheel_down', self.cam_zoom, [1.0 / 1.1])
self.accept('mouse1', self.mouse_state, [0, 1])
self.accept('mouse1-up', self.mouse_state, [0, 0])
self.accept('0', self.image_select, [0])
self.accept('1', self.image_select, [1])
self.accept('2', self.image_select, [2])
self.accept('3', self.image_select, [3])
self.accept('4', self.image_select, [4])
self.accept('5', self.image_select, [5])
self.accept('6', self.image_select, [6])
self.accept('7', self.image_select, [7])
self.accept('8', self.image_select, [8])
self.accept('9', self.image_select, [9])
self.accept('f', self.toggle_filter)
self.accept('m', self.toggle_view_mode)
self.accept('r', self.toggle_reticle)
self.accept(',', self.update_sequential_num, [-1])
self.accept('.', self.update_sequential_num, [1])
self.accept('escape', self.quit)
self.accept('mouse3', self.annotations.toggle, [self.cam_pos])
# mouse state
self.last_mpos = [0, 0]
self.mouse = [0, 0, 0]
self.last_mouse = [0, 0, 0]
# Add the tasks to the task manager.
self.taskMgr.add(self.updateCameraTask, "updateCameraTask")
# Shader (aka filter?)
self.filter = 'none'
# Set default view mode
self.view_mode = 'best'
# self.view_mode = 'sequential'
self.sequential_num = 0
# dump a summary of supposed card capabilities
self.query_capabilities(display=True)
# test shader
# self.shader = Shader.load(Shader.SL_GLSL, vertex="explore/myshader.vert", fragment="explore/myshader.frag", geometry="explore/myshader.geom")
self.shader = Shader.load(Shader.SL_GLSL,
vertex="explore/myshader.vert",
fragment="explore/myshader.frag")
def __updateCursor(self, cursorName):
wp = WindowProperties()
wp.setCursorFilename(self.MouseCursors.get(cursorName))
base.win.requestProperties(wp)
class Panda3dViewer(BaseViewer, ShowBase):
def __init__(self, params=None, **kwargs):
# Load 3d-Model and parameter
super(Panda3dViewer, self).__init__(params=params)
self.world_x_range = kwargs.pop("x_range", [-40, 40])
self.world_y_range = kwargs.pop("y_range", [-40, 40])
self.follow_agent_id = kwargs.pop("follow_agent_id", -1)
self.screen_dims = kwargs.pop("screen_dims", [1024, 1024])
self.path = os.path.join(
os.path.dirname(os.path.abspath(__file__))
) # TODO(@fortiss): load into parameter at a earlier stage
self.agent_model_path = kwargs.pop("model_path",
self.path + "/models/box_car")
self.agent_scale = kwargs.pop("model_scale",
np.array([3.65, 1.8, 0.8], dtype=float))
self.agent_orientation = \
kwargs.pop("model_orientation",np.array([180, 0,0],
dtype=float))
self.agent_translation = kwargs.pop("model_translation",
np.array([3.2, 0.9], dtype=float))
self.range_for_zoom = kwargs.pop("is_zoom_range", False)
self.line_thicknesses = kwargs.pop(
"line_thickness",
{ #Dict of keys cameras and values [line thickness, height] which are needed to calculate the dynamic thickness
-2: [0.35, 700],
-1: [0.35, 700],
0: [0.1, 70]
})
# Parameter for agent camera views
# [driving direction offset, height, x-orientation,y-orientation,z-orientation offset to driving direction, LookAt?]
self.agent_cam_parameter = kwargs.pop(
"agent_view", {
"bird_agent": [0, 70, 0, 270, 270, False],
"third": [-35, 15, 0, 0, 0, True],
"first": [1.2, 2.7, 180, 190, 90, False]
})
# Set Window Size
self.wp = WindowProperties().getDefault()
self.wp.setSize(self.screen_dims[0], self.screen_dims[1])
self.wp.setTitle("BARK Panda3d Viewer")
WindowProperties.setDefault(self.wp)
ShowBase.__init__(self)
# Render Objects Dict
self.agent_nodes = {}
# Agent Poses Dict
self.agent_poses = {}
self.setLight()
# Creating a plane as floor #TODO parameter from map parameter
frame = [
-self.screen_dims[0] / 2, self.screen_dims[0] / 2,
-self.screen_dims[1] / 2, self.screen_dims[1] / 2
]
color = VBase4(self.plane_color[0], self.plane_color[1],
self.plane_color[2], self.plane_alpha)
self.createPlane(frame=frame, color=color)
# Set up the camera loop task
self.camera_list = [-1]
self.initCam()
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Set up the line generator
self.setDrawer(budget=100000)
# -2 : global camera with camera control, -1: transition state for enabling mouse control, 0: agent cameras
self.perspectives = {
-2: ["birdview", "autozoom"],
-1: ["None"],
0: ["bird_agent", "third", "first"]
}
self.perspective = self.perspectives[self.camIndex(
self.follow_agent_id)]
self.line_thickness = self.line_thicknesses[self.camIndex(
self.follow_agent_id)][0]
self.addButtons()
def setDrawer(self, budget=100000):
"""Initializes the MeshDrawer() generator to draw lines in Panda3d
Keyword Arguments:
budget {int} -- maximum triangles for rendering the mesh (default: {100000})
"""
self.generator = MeshDrawer()
self.generator.setBudget(budget)
self.generatorNode = self.generator.getRoot()
self.generatorNode.reparentTo(self.render)
def createPlane(self, frame=None, color=VBase4(1, 1, 1, 1)):
""" Creates a Plane/Card with the Panda3d Cardmaker() class
Keyword Arguments:
frame {list} -- The coordinates [x1,y1,x2,y2] of the planes/cards edges (default: {[-1, -1, 1, 1]})
color {VBase4} -- The color of the planes/cards (default: {VBase4(1, 1, 1, 1)})
"""
frame = frame or [-1, -1, 1, 1]
card = CardMaker("plane")
card.set_color(color)
card.set_frame(frame[0], frame[1], frame[2], frame[3])
n = NodePath()
self.plane = n.attach_new_node(card.generate())
self.plane.reparentTo(self.render)
self.plane.setHpr(0, 270, 0)
def setLight(self, color=VBase4(1, 1, 1, 1)):
"""Sets an ambient and omnidirectional light for rendering
Keyword Arguments:
color {VBase4} -- color of the ambient light (default: {VBase4(1, 1, 1, 1)})
"""
alight = AmbientLight('alight')
alight.setColor(color)
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
def addButtons(self):
self.cam_btn = DirectButton(text="Camera",
scale=0.05,
command=self.switchCamera,
pos=Vec3(0.9, 0, 0.9))
self.per_btn = DirectButton(text="View",
scale=0.05,
command=self.switchView,
pos=Vec3(0.9, 0, 0.85))
def camIndex(self, follow_id):
return np.minimum(follow_id, 0)
def switchCamera(self):
# Switches between global and agent cameras
self.follow_agent_id = self.camera_list.pop(0)
self.camera_list.append(self.follow_agent_id)
self.perspective = self.perspectives[self.camIndex(
self.follow_agent_id)].copy()
self.line_thickness = self.line_thicknesses[self.camIndex(
self.follow_agent_id)][0]
def switchView(self):
# Switches between the perspectives defined by the camera
self.perspective.append(self.perspective[0])
self.perspective.pop(0)
def updateCamera(self, lookAt=False):
"""Updates the camera position from calls using variables self.cam_pose and self.cam_or
Keyword Arguments:
lookAt {bool} -- If true the orientation is calculated by the agents position (default: {False})
"""
self.camera.setPos(self.cam_pose[0], self.cam_pose[1],
self.cam_pose[2])
if lookAt:
self.camera.lookAt(self.agent_nodes[self.follow_agent_id])
else:
self.camera.setHpr(self.cam_or[2], self.cam_or[1], self.cam_or[0])
def spinCameraTask(self, task):
"""This function sets and updates the camera according to environment variables and parameters
Arguments:
task {task} -- Panda3d Task
Returns:
Task.cont -- Panda3d Task Return
"""
if self.follow_agent_id is -1: # Transition into camera control view
self.setMouseControl()
if self.follow_agent_id is -2: # Global Camera
if (self.perspective[0] is self.perspectives[-2][1]):
self.setAutoZoomCam(self.agent_poses)
if self.follow_agent_id >= 0: # Camera for all agents
self.setAgentCam(self.perspective[0],
self.agent_poses[self.follow_agent_id])
return Task.cont
def initCam(self,
poses=None,
orientation=None): #TODO Calculate from map parameter before
poses = poses or [0, 0, 700]
orientation = orientation or [0, 270, 0]
self.cam_pose = np.array(poses, dtype=float)
self.cam_or = np.array(orientation, dtype=float)
def setMouseControl(self):
# Enables Panda3d Standard Mouse Control
# Right mouse button: zoom, left mouse Button: move, middle mouse button: tilt
self.initCam()
self.updateCamera(lookAt=False)
self.mat = Mat4(self.camera.getMat())
self.mat.invertInPlace()
base.mouseInterfaceNode.setMat(self.mat)
base.enableMouse()
self.follow_agent_id = -2
self.perspective = self.perspectives[self.camIndex(
self.follow_agent_id)].copy()
def setAutoZoomCam(self, agent_poses):
"""This function calculates the camera position so that all agents are visible
Arguments:
agent_poses {[dict]} -- [look up table of all agent poses]
"""
points = np.array([[]], dtype=float)
if ((self.world_x_range is not None)
and (self.world_y_range is not None) and self.range_for_zoom):
points = np.array([[self.world_x_range[0], self.world_y_range[0]],
[self.world_x_range[1], self.world_y_range[1]]])
# Build concat matrix of all positions
for _, agent in agent_poses.items():
if points.size is 0:
points = np.array([[agent[0], agent[1]]], dtype=float)
else:
points = np.append(points, [[agent[0], agent[1]]], axis=0)
# Calculate maximum distance between min,max of x or y poses
max_dist = np.max(np.max(points, axis=0) - np.min(points, axis=0))
# Calculate mean positions as center for camera
center = (np.max(points, axis=0) + np.min(points, axis=0)) / 2
# Lower bound for vieweable area
max_dist = np.maximum(max_dist * 1.25, 40)
# Calculate camera height
zoom = max_dist * np.tan(pi * (60 / 180))
self.cam_pose = np.array([center[0], center[1], zoom], dtype=float)
self.cam_or = np.array([0, 270, 0], dtype=float)
self.updateCamera(lookAt=False)
def setAgentCam(self, perspective, agent_poses):
"""Sets up the class variable for the camerea position and orientation
Arguments:
perspective {list} -- List of strings describing the perspective currently ["bird_agent","third","first"] which is used as an index for the parameters dict
agent_poses {np.array([x,y,theta])} -- Describes the agent position
"""
base.disableMouse()
self.cam_pose[0] = agent_poses[0] + self.agent_cam_parameter[
perspective][0] * np.cos(agent_poses[2])
self.cam_pose[1] = agent_poses[1] + self.agent_cam_parameter[
perspective][0] * np.sin(agent_poses[2])
self.cam_pose[2] = self.agent_cam_parameter[perspective][1]
self.cam_or = np.array([
self.agent_cam_parameter[perspective][2],
self.agent_cam_parameter[perspective][3],
(agent_poses[2] * 180) / pi +
self.agent_cam_parameter[perspective][4]
],
dtype=float)
self.updateCamera(lookAt=self.agent_cam_parameter[perspective][5])
def calcLineThickness(self, cameras=None):
"""Uses a linear approximation between two cameras to calculate the line thickness
Arguments:
cameras {int array} -- Sets the indices of the target cameras
Returns:
[float] -- [The approximated thickness]
"""
cameras = cameras or [-1, 0]
incline = (self.line_thicknesses[cameras[0]][0] -
self.line_thicknesses[cameras[1]][0]) / (
self.line_thicknesses[cameras[0]][1] -
self.line_thicknesses[cameras[1]][1])
return np.maximum(
(self.line_thicknesses[cameras[1]][0] + incline *
(self.camera.getZ() - self.line_thicknesses[cameras[1]][1])),
0.01)
def drawPolygon2d(self, polygon, color, alpha):
# Draws a polygon with drawLine2d
points = polygon.toArray()
self.line_thickness = self.calcLineThickness()
for point in points:
self.generator.link_segment(Vec3(point[0], point[1], 2),
Vec4(0, 0, 1, 1), self.line_thickness,
self.getColor(color))
self.generator.link_segment_end(Vec4(0, 0, 1, 1), self.getColor(color))
def drawLine2d(self, line2d, color=Viewer.Color.Blue, alpha=1.0):
line2d_np = line2d.toArray()
for point in line2d_np:
self.generator.link_segment(Vec3(point[0], point[1], 2),
Vec4(0, 0, 1, 1), self.line_thickness,
self.getColor(color))
self.generator.link_segment_end(Vec4(0, 0, 1, 1), self.getColor(color))
def drawAgent(self, agent):
"""Draws an agent object with a model previosly set in set with self.agent_model_path
Arguments:
agent -- Agent object from world
"""
# Adds new agent to dict of Panda3d nodes
if not agent.id in self.agent_nodes:
self.agent_nodes[agent.id] = self.loader.loadModel(
self.agent_model_path)
self.agent_nodes[agent.id].reparentTo(self.render)
self.agent_nodes[agent.id].setPos(0, 0, 2)
self.agent_nodes[agent.id].setScale(self.agent_scale[0],
self.agent_scale[1],
self.agent_scale[2])
self.agent_poses[agent.id] = np.array([0, 0, 0], dtype=float)
self.camera_list.insert(len(self.camera_list), agent.id)
# Set new pose of agent in world cordinates
state = agent.followed_trajectory[-1, :]
self.agent_poses[agent.id][0] = state[int(StateDefinition.X_POSITION)]
self.agent_poses[agent.id][1] = state[int(StateDefinition.Y_POSITION)]
self.agent_poses[agent.id][2] = state[int(
StateDefinition.THETA_POSITION)]
transformed_polygon = agent.shape.transform(self.agent_poses[agent.id])
self.drawPolygon2d(transformed_polygon, self.color_agents, 1.0)
# Fitting of 3d-Model frame to agent positon
angle = ((self.agent_poses[agent.id][2] * 180) / pi +
self.agent_orientation[0])
self.agent_nodes[agent.id].setHpr(angle, self.agent_orientation[1],
self.agent_orientation[2])
translation = self.agent_translation
if not np.all(translation == 0):
r = np.array([[
np.cos(self.agent_poses[agent.id][2]),
np.sin(self.agent_poses[agent.id][2])
],
[
np.cos(self.agent_poses[agent.id][2] + pi * 0.5),
np.sin(self.agent_poses[agent.id][2] + pi * 0.5)
]],
dtype=float)
translation = np.dot(translation, r)
self.agent_nodes[agent.id].setPos(
self.agent_poses[agent.id][0] + translation[0],
self.agent_poses[agent.id][1] + translation[1], 2)
if self.draw_route:
self.drawRoute(agent)
def getColor(self, color):
if isinstance(color, Viewer.Color):
return {
Viewer.Color.White:
Vec4(1, 1, 1, 1),
Viewer.Color.Red:
Vec4(1, 0, 0, 1),
Viewer.Color.Blue:
Vec4(0, 0, 1, 1),
Viewer.Color.Magenta:
Vec4(100.0 / 255.0, 1, 100.0 / 255.0, 1),
Viewer.Color.Brown:
Vec4(150.0 / 255.0, 50.0 / 255.0, 50.0 / 255.0, 1),
Viewer.Color.Black:
Vec4(0, 0, 0, 1)
}.get(color, Vec4(0, 0, 0, 1))
else:
return Vec4(color[0], color[1], color[2], 1)
def drawWorld(self, world, eval_agent_ids=None):
self.generator.begin(base.cam, self.render)
super(Panda3dViewer, self).drawWorld(world, eval_agent_ids)
self.generator.end()
self.taskMgr.step()
def __init__(self,
cam_pos=np.array([2.0, 0.5, 2.0]),
lookat_pos=np.array([0, 0, 0.25]),
up=np.array([0, 0, 1]),
fov=40,
w=1920,
h=1080,
lens_type="perspective",
toggle_debug=False,
auto_cam_rotate=False):
"""
:param cam_pos:
:param lookat_pos:
:param fov:
:param w: width of window
:param h: height of window
author: weiwei
date: 2015?, 20201115
"""
# the taskMgr, loader, render2d, etc. are added to builtin after initializing the showbase parental class
super().__init__()
# set up window
winprops = WindowProperties(base.win.getProperties())
winprops.setTitle("WRS Robot Planning and Control System")
base.win.requestProperties(winprops)
self.disableAllAudio()
self.setBackgroundColor(1, 1, 1)
# set up lens
lens = PerspectiveLens()
lens.setFov(fov)
lens.setNearFar(0.001, 5000.0)
if lens_type == "orthographic":
lens = OrthographicLens()
lens.setFilmSize(640, 480)
# disable the default mouse control
self.disableMouse()
self.cam.setPos(cam_pos[0], cam_pos[1], cam_pos[2])
self.cam.lookAt(Point3(lookat_pos[0], lookat_pos[1], lookat_pos[2]),
Vec3(up[0], up[1], up[2]))
self.cam.node().setLens(lens)
# set up slight
## ambient light
ablight = AmbientLight("ambientlight")
ablight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ablightnode = self.cam.attachNewNode(ablight)
self.render.setLight(self.ablightnode)
## point light 1
ptlight0 = PointLight("pointlight0")
ptlight0.setColor(Vec4(1, 1, 1, 1))
self._ptlightnode0 = self.cam.attachNewNode(ptlight0)
self._ptlightnode0.setPos(0, 0, 0)
self.render.setLight(self._ptlightnode0)
## point light 2
ptlight1 = PointLight("pointlight1")
ptlight1.setColor(Vec4(.4, .4, .4, 1))
self._ptlightnode1 = self.cam.attachNewNode(ptlight1)
self._ptlightnode1.setPos(self.cam.getPos().length(), 0,
self.cam.getPos().length())
self.render.setLight(self._ptlightnode1)
## point light 3
ptlight2 = PointLight("pointlight2")
ptlight2.setColor(Vec4(.3, .3, .3, 1))
self._ptlightnode2 = self.cam.attachNewNode(ptlight2)
self._ptlightnode2.setPos(-self.cam.getPos().length(), 0,
self.cam.getPos().length())
self.render.setLight(self._ptlightnode2)
# helpers
self.p3dh = p3dh
# self.o3dh = o3dh
self.rbtmath = rm
# set up inputmanager
self.lookatpos = lookat_pos
self.inputmgr = im.InputManager(self, self.lookatpos)
taskMgr.add(self._interaction_update, "interaction", appendTask=True)
# set up rotational cam
if auto_cam_rotate:
taskMgr.doMethodLater(.1, self._rotatecam_update, "rotate cam")
# set window size
props = WindowProperties()
props.setSize(w, h)
self.win.requestProperties(props)
# outline edge shader
# self.set_outlineshader()
# set up cartoon effect
self._separation = 1
self.filter = flt.Filter(self.win, self.cam)
self.filter.setCartoonInk(separation=self._separation)
# self.filter.setViewGlow()
# set up physics world
self.physics_scale = 1e3
self.physicsworld = BulletWorld()
self.physicsworld.setGravity(Vec3(0, 0, -9.81 * self.physics_scale))
taskMgr.add(self._physics_update, "physics", appendTask=True)
globalbprrender = base.render.attachNewNode("globalbpcollider")
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
self._debugNP = globalbprrender.attachNewNode(debugNode)
self._debugNP.show()
self.toggledebug = toggle_debug
if toggle_debug:
self.physicsworld.setDebugNode(self._debugNP.node())
self.physicsbodylist = []
# set up render update (TODO, only for dynamics?)
self._internal_update_obj_list = [
] # the nodepath, collision model, or bullet dynamics model to be drawn
self._internal_update_robot_list = []
taskMgr.add(self._internal_update, "internal_update", appendTask=True)
# for remote visualization
self._external_update_objinfo_list = [] # see anime_info.py
self._external_update_robotinfo_list = []
taskMgr.add(self._external_update, "external_update", appendTask=True)
# for stationary models
self._noupdate_model_list = []
def set_window_icon(file: str):
winprops = WindowProperties()
winprops.setIconFilename(file)
base = app.get_show_base()
base.win.requestProperties(winprops)
def __init__(self, parent, pos):
self.parent = parent
self.node = render.attachNewNode('PlayerNode')
self.node.setPos(pos[0] * TILE_SIZE, pos[1] * TILE_SIZE,
TILE_SIZE * ASPECT / 1.5)
taskMgr.add(self.updatePlayer, 'UpdatePlayerTask')
taskMgr.add(self.updateBullets, 'UpdateBulletsTask')
self.centerx = base.win.getProperties().getXSize() / 2
self.centery = base.win.getProperties().getYSize() / 2
self.speed = TILE_SIZE - 4
self.sprint_speed = self.speed * 1.8
self.can_move = True
self.camera = True
self.mouse_owner = True
self.max_health = 100
self.health = self.max_health
self.max_bullets = 10
self.bullets = 4
self.bullet_objects = []
self.sprint = False
self.moving = False
self.gunshot_at = None
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# Create player flashlight
self.slight = Spotlight('slight')
self.slight.setColor(VBase4(1, 1, 0.6, 1))
#self.lens = PerspectiveLens()
#self.slight.setLens(self.lens)
self.slnp = self.node.attachNewNode(self.slight)
self.slnp.node().getLens().setFov(88)
self.slnp.node().getLens().setNearFar(1, 70)
self.slight.setExponent(10)
self.slight.setAttenuation(Point3(0.737, 0.134, 0.001))
render.setLight(self.slnp)
self.flashlight = True
self.shoot_sound = base.loader.loadSfx(
"audio/GUN_FIRE-GoodSoundForYou-820112263.wav")
self.gun_click_sound = base.loader.loadSfx(
"audio/Dry Fire Gun-SoundBible.com-2053652037.wav")
self.heart_sound = base.loader.loadSfx(
"audio/Slow_HeartBeat-Mike_Koenig-1853475164.wav")
self.heart_sound.setLoop(True)
self.heart_sound.setVolume(0.6)
self.heart_sound.play()
self.scratches = loadImageAsPlane('models/scr.png')
self.scratches.setTransparency(TransparencyAttrib.MAlpha)
self.damage_anim = Parallel()
self.keys = {}
self.keys['forward'] = 0
self.keys['back'] = 0
self.keys['strafe_left'] = 0
self.keys['strafe_right'] = 0
self.keys['sprint'] = 0
self.setKeyEvents()
self.pause = False
def hide_cursor(self):
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.exitFunc = self.cleanup
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.accept("trapEnemy-into-wall", self.stopTrap)
self.accept("trapEnemy-into-trapEnemy", self.stopTrap)
self.accept("trapEnemy-into-player", self.trapHitsSomething)
self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = None
self.enemies = []
self.trapEnemies = []
self.deadEnemies = []
self.spawnPoints = []
numPointsPerWall = 5
for i in range(numPointsPerWall):
coord = 7.0 / numPointsPerWall + 0.5
self.spawnPoints.append(Vec3(-7.0, coord, 0))
self.spawnPoints.append(Vec3(7.0, coord, 0))
self.spawnPoints.append(Vec3(coord, -7.0, 0))
self.spawnPoints.append(Vec3(coord, 7.0, 0))
self.initialSpawnInterval = 1.0
self.minimumSpawnInterval = 0.2
self.spawnInterval = self.initialSpawnInterval
self.spawnTimer = self.spawnInterval
self.maxEnemies = 2
self.maximumMaxEnemies = 20
self.numTrapsPerSide = 2
self.difficultyInterval = 5.0
self.difficultyTimer = self.difficultyInterval
self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg")
self.gameOverScreen = DirectDialog(frameSize=(-0.7, 0.7, -0.7, 0.7),
fadeScreen=0.4,
relief=DGG.FLAT,
frameTexture="UI/stoneFrame.png")
self.gameOverScreen.hide()
self.font = loader.loadFont("Fonts/Wbxkomik.ttf")
buttonImages = (loader.loadTexture("UI/UIButton.png"),
loader.loadTexture("UI/UIButtonPressed.png"),
loader.loadTexture("UI/UIButtonHighlighted.png"),
loader.loadTexture("UI/UIButtonDisabled.png"))
label = DirectLabel(text="Game Over!",
parent=self.gameOverScreen,
scale=0.1,
pos=(0, 0, 0.2),
text_font=self.font,
relief=None)
self.finalScoreLabel = DirectLabel(text="",
parent=self.gameOverScreen,
scale=0.07,
pos=(0, 0, 0),
text_font=self.font,
relief=None)
btn = DirectButton(text="Restart",
command=self.startGame,
pos=(-0.3, 0, -0.2),
parent=self.gameOverScreen,
scale=0.07,
text_font=self.font,
clickSound=loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture=buttonImages,
frameSize=(-4, 4, -1, 1),
text_scale=0.75,
relief=DGG.FLAT,
text_pos=(0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text="Quit",
command=self.quit,
pos=(0.3, 0, -0.2),
parent=self.gameOverScreen,
scale=0.07,
text_font=self.font,
clickSound=loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture=buttonImages,
frameSize=(-4, 4, -1, 1),
text_scale=0.75,
relief=DGG.FLAT,
text_pos=(0, -0.2))
btn.setTransparency(True)
self.titleMenuBackdrop = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-1, 1, -1, 1),
parent=render2d)
self.titleMenu = DirectFrame(frameColor=(1, 1, 1, 0))
title = DirectLabel(text="Panda-chan",
scale=0.1,
pos=(0, 0, 0.9),
parent=self.titleMenu,
relief=None,
text_font=self.font,
text_fg=(1, 1, 1, 1))
title2 = DirectLabel(text="and the",
scale=0.07,
pos=(0, 0, 0.79),
parent=self.titleMenu,
text_font=self.font,
frameColor=(0.5, 0.5, 0.5, 1))
title3 = DirectLabel(text="Endless Horde",
scale=0.125,
pos=(0, 0, 0.65),
parent=self.titleMenu,
relief=None,
text_font=self.font,
text_fg=(1, 1, 1, 1))
btn = DirectButton(text="Start Game",
command=self.startGame,
pos=(0, 0, 0.2),
parent=self.titleMenu,
scale=0.1,
text_font=self.font,
clickSound=loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture=buttonImages,
frameSize=(-4, 4, -1, 1),
text_scale=0.75,
relief=DGG.FLAT,
text_pos=(0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text="Quit",
command=self.quit,
pos=(0, 0, -0.2),
parent=self.titleMenu,
scale=0.1,
text_font=self.font,
clickSound=loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture=buttonImages,
frameSize=(-4, 4, -1, 1),
text_scale=0.75,
relief=DGG.FLAT,
text_pos=(0, -0.2))
btn.setTransparency(True)
music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg")
music.setLoop(True)
music.setVolume(0.075)
music.play()
def __init__(self, params=None, **kwargs):
# Load 3d-Model and parameter
super(Panda3dViewer, self).__init__(params=params)
self.world_x_range = kwargs.pop("x_range", [-40, 40])
self.world_y_range = kwargs.pop("y_range", [-40, 40])
self.follow_agent_id = kwargs.pop("follow_agent_id", -1)
self.screen_dims = kwargs.pop("screen_dims", [1024, 1024])
self.path = os.path.join(
os.path.dirname(os.path.abspath(__file__))
) # TODO(@fortiss): load into parameter at a earlier stage
self.agent_model_path = kwargs.pop("model_path",
self.path + "/models/box_car")
self.agent_scale = kwargs.pop("model_scale",
np.array([3.65, 1.8, 0.8], dtype=float))
self.agent_orientation = \
kwargs.pop("model_orientation",np.array([180, 0,0],
dtype=float))
self.agent_translation = kwargs.pop("model_translation",
np.array([3.2, 0.9], dtype=float))
self.range_for_zoom = kwargs.pop("is_zoom_range", False)
self.line_thicknesses = kwargs.pop(
"line_thickness",
{ #Dict of keys cameras and values [line thickness, height] which are needed to calculate the dynamic thickness
-2: [0.35, 700],
-1: [0.35, 700],
0: [0.1, 70]
})
# Parameter for agent camera views
# [driving direction offset, height, x-orientation,y-orientation,z-orientation offset to driving direction, LookAt?]
self.agent_cam_parameter = kwargs.pop(
"agent_view", {
"bird_agent": [0, 70, 0, 270, 270, False],
"third": [-35, 15, 0, 0, 0, True],
"first": [1.2, 2.7, 180, 190, 90, False]
})
# Set Window Size
self.wp = WindowProperties().getDefault()
self.wp.setSize(self.screen_dims[0], self.screen_dims[1])
self.wp.setTitle("BARK Panda3d Viewer")
WindowProperties.setDefault(self.wp)
ShowBase.__init__(self)
# Render Objects Dict
self.agent_nodes = {}
# Agent Poses Dict
self.agent_poses = {}
self.setLight()
# Creating a plane as floor #TODO parameter from map parameter
frame = [
-self.screen_dims[0] / 2, self.screen_dims[0] / 2,
-self.screen_dims[1] / 2, self.screen_dims[1] / 2
]
color = VBase4(self.plane_color[0], self.plane_color[1],
self.plane_color[2], self.plane_alpha)
self.createPlane(frame=frame, color=color)
# Set up the camera loop task
self.camera_list = [-1]
self.initCam()
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Set up the line generator
self.setDrawer(budget=100000)
# -2 : global camera with camera control, -1: transition state for enabling mouse control, 0: agent cameras
self.perspectives = {
-2: ["birdview", "autozoom"],
-1: ["None"],
0: ["bird_agent", "third", "first"]
}
self.perspective = self.perspectives[self.camIndex(
self.follow_agent_id)]
self.line_thickness = self.line_thicknesses[self.camIndex(
self.follow_agent_id)][0]
self.addButtons()
def disconnectMouse(self):
self.mouse_owner = False
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
def __init__(self):
ShowBase.__init__(self)
self.accept("escape", sys.exit)
self.accept("mouse1", self.startShoot)
self.accept("mouse1-up", self.endShoot)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.heading = 0
self.pitch = 0
self.mousex = 0
self.mousey = 0
self.flight = []
self.cs_flight = []
self.explosion = []
self.score = 0
self.life = 20
self.m1down = 1
self.environ = self.loader.loadModel("models/terrain")
self.environ.reparentTo(self.render)
self.environ.setScale(0.8, 0.8, 0.8)
self.environ.setPos(0, 0, -10)
self.environ.setHpr(-90, 0, 0)
for k in range(0, 5):
self.flight.append(self.loader.loadModel("models/spitfire"))
self.flight[k].reparentTo(self.render)
self.flight[k].setScale(0.1, 0.1, 0.1)
self.flight[k].setPos(randint(-40, 20), randint(300, 400),
randint(10, 20))
self.cs_flight.append(self.flight[k].attachNewNode(
CollisionNode(str(k))))
self.cs_flight[k].node().addSolid(CollisionSphere(0, 0, 5, 30))
#self.cs_flight[k].show()
self.flight[k].setCollideMask(BitMask32.bit(1))
self.bullets = []
self.crosshair = OnscreenImage(image='models/crosshair.png',
pos=(0, 0, 0))
self.crosshair.setScale(0.03, 0.03, 0.03)
self.crosshair.setTransparency(TransparencyAttrib.MAlpha)
self.title = OnscreenText(" ",
style=1,
fg=(1, 1, 1, 1),
pos=(0, 0),
scale=.07)
self.taskMgr.add(self.mouse_control, "mouse_control")
self.taskMgr.add(self.update_flight, "update_flight")
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
self.gun = OnscreenImage(image='models/gun.png', pos=(0.24, 0, -0.54))
self.gun.setScale(1, 0.6, 0.6)
self.gun.setTransparency(TransparencyAttrib.MAlpha)
self.sound = base.loader.loadSfx("models/sound.ogg")
base.setFrameRateMeter(True)
def show_cursor(self):
"""set the Cursor visible again"""
props = WindowProperties()
props.setCursorHidden(False)
self.win.requestProperties(props)
config_sfx = ConfigVariableInt('sound-volume', '100')
#keys
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')
from panda3d.core import WindowProperties
wp = WindowProperties.getDefault()
wp.setFixedSize(True)
wp.setCursorHidden(False)
wp.setFullscreen(False)
wp.setUndecorated(True)
wp.setTitle("Avolition - Configuration")
wp.setSize(512, 512)
wp.setOrigin(-2, -2)
WindowProperties.setDefault(wp)
from direct.gui.DirectGui import *
from panda3d.core import *
import direct.directbase.DirectStart
from direct.showbase.DirectObject import DirectObject
import sys
#import collections
def __init__(self):
ShowBase.__init__(self)
properties = WindowProperties()
properties.setSize(1000, 750)
self.dr = self.camNode.getDisplayRegion(0)
self.dr.setActive(0) # disable
print(self.dr.getSort())
self.dr1 = self.win.makeDisplayRegion(0.0, 0.5, 0, .5)
self.dr1.setSort(self.dr.getSort())
self.dr1.setCamera(self.camList[0])
self.dr2 = self.win.makeDisplayRegion(0.5, 1, 0, 0.5)
self.makeCamera(self.win,sort=0,displayRegion=(0.5,1,0.5,1),camName="cam2")
self.disableMouse()
self.environment = loader.loadModel("environment/environment")
self.environment.reparentTo(render)
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.camList[0].reparentTo(self.monkey)
self.camList[1].reparentTo(self.monkey2)
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()
print('Cameras')
print(self.camList)
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
print('Active Display Regions')
print(self.win.getActiveDisplayRegions())
self.win.removeDisplayRegion(self.win.getDisplayRegion(1))
self.win.removeDisplayRegion(self.win.getDisplayRegion(1))
self.win.removeDisplayRegion(self.win.getDisplayRegion(1))
print(self.win.getDisplayRegions())
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
self.disableMouse()
self.useTrackball()
#self.win.getDisplayRegion(2).saveScreenshotDefault('www')
#this works but I get black screen because it gets the SC before the rendering
texture = self.win.getDisplayRegion(1).getScreenshot()
numpy_image_data=np.array(texture.getRamImageAs("RGB"), np.float32)
print(np.max(numpy_image_data[123456]))
def __init__(self):
ShowBase.__init__(self)
self.grid = np.loadtxt("input/maze.txt")
f = open("input/start_point.txt", "r")
self.start_pos = eval(f.read())
if FULLSCREEN:
wp = WindowProperties()
wp.setFullscreen(True)
base.win.requestProperties(wp)
self.disableMouse()
self.accept("escape", sys.exit)
self.camera.setPosHpr(self.start_pos[0], self.start_pos[1],
CAMERA_SCALE, 0, -90, 0)
# maze wall
offset = 0.05 # expand collision boundaries for the walls
for i in range(-1, len(self.grid) + 1):
for j in range(-1, len(self.grid[0]) + 1):
if i == -1 or j == -1 or i == len(self.grid) or j == len(
self.grid[0]) or self.grid[i][j]:
#box-1_-1 is not a valid name so we change it to boxa_b
texti = i
textj = j
if i == -1:
texti = 'a'
if j == -1:
textj = 'b'
suffix = str(texti) + "_" + str(textj)
# model
exec("self.box" + suffix +
" = self.loader.loadModel('models/cube')")
exec("self.box" + suffix + ".reparentTo(self.render)")
exec("self.box" + suffix + ".setPos(" + str(i) + ", " +
str(j) + ", 1)")
# collision node
exec("self.boxCollider" + suffix + " = self.box" + suffix +
".attachNewNode(CollisionNode('wall_collide'))")
exec(
"self.boxCollider" + suffix +
".node().addSolid(CollisionBox(Point3(0-offset,0-offset,0-offset),Point3(1+offset,1+offset,1+offset)))"
)
exec("self.boxCollider" + suffix +
".node().setIntoCollideMask(BitMask32.bit(0))")
#exec("self.boxCollider" + suffix + ".show()")
# maze ground model
self.maze = loader.loadModel("models/cube")
self.maze.setScale(len(self.grid), len(self.grid[0]), 1)
self.maze.reparentTo(self.render)
# maze ground collision node
self.walls = self.maze.attachNewNode(CollisionNode('wall_collide'))
self.walls.node().addSolid(
CollisionBox(Point3(0, 0, 0), Point3(1, 1, 1)))
self.walls.node().setIntoCollideMask(BitMask32.bit(1))
# maze ground plane collision node
self.mazeGround = self.maze.attachNewNode(
CollisionNode('ground_collide'))
self.mazeGround.node().addSolid(
CollisionPlane(Plane(Vec3(0, 0, 1), Point3(2, 2, 1))))
self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
# ball model
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
# ball material
m = Material()
m.setSpecular((1, 1, 1, 1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
# ball collision node
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
# collision ray
self.ballGroundRay = CollisionRay()
self.ballGroundRay.setOrigin(0, 0, 10)
self.ballGroundRay.setDirection(0, 0, -1)
# ray collision node
self.ballGroundCol = CollisionNode('groundRay')
self.ballGroundCol.addSolid(self.ballGroundRay)
self.ballGroundCol.setFromCollideMask(BitMask32.bit(1))
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
# ray
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
# collision traverser and handler queue
self.cHandler = CollisionHandlerQueue()
self.cTrav = CollisionTraverser()
self.cTrav.addCollider(self.ballSphere, self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# visual effects
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -1))
directionalLight.setColor((0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
self.start()
def hideMouse(self):
#hiding mouse
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
class PandaVis(ShowBase):
"""Base class for all visualizations with panda3d"""
def __init__(self, rendering: bool):
"""
Constructor
:param rendering: boolean indicating whether to use RenderPipeline or default Panda3d as visualization-module.
"""
super().__init__(self)
self.dir = Filename.fromOsSpecific(
pyrado.PANDA_ASSETS_DIR).getFullpath()
# Initialize RenderPipeline
if rendering:
sys.path.insert(0, pyrado.RENDER_PIPELINE_DIR)
from rpcore import RenderPipeline
self.render_pipeline = RenderPipeline()
self.render_pipeline.pre_showbase_init()
self.render_pipeline.set_loading_screen_image(
osp.join(self.dir, "logo.png"))
self.render_pipeline.settings["pipeline.display_debugger"] = False
self.render_pipeline.create(self)
self.render_pipeline.daytime_mgr.time = "17:00"
else:
self.render_pipeline = None
# Activate antialiasing
self.render.setAntialias(AntialiasAttrib.MAuto)
# Set window properties
self.windowProperties = WindowProperties()
self.windowProperties.setForeground(True)
self.windowProperties.setTitle("Experiment")
# Set background color
self.setBackgroundColor(1, 1, 1)
# Configuration of the lighting
self.directionalLight1 = DirectionalLight("directionalLight")
self.directionalLightNP1 = self.render.attachNewNode(
self.directionalLight1)
self.directionalLightNP1.setHpr(0, -8, 0)
self.render.setLight(self.directionalLightNP1)
self.directionalLight2 = DirectionalLight("directionalLight")
self.directionalLightNP2 = self.render.attachNewNode(
self.directionalLight2)
self.directionalLightNP2.setHpr(180, -20, 0)
self.render.setLight(self.directionalLightNP2)
self.ambientLight = AmbientLight("ambientLight")
self.ambientLightNP = self.render.attachNewNode(self.ambientLight)
self.ambientLight.setColor((0.1, 0.1, 0.1, 1))
self.render.setLight(self.ambientLightNP)
# Create a text node displaying the physic parameters on the top left of the screen
self.text = TextNode("parameters")
self.textNodePath = aspect2d.attachNewNode(self.text)
self.text.setTextColor(0, 0, 0, 1) # black
self.textNodePath.setScale(0.07)
self.textNodePath.setPos(-1.9, 0, 0.9)
# Configure trace
self.trace = LineSegs()
self.trace.setThickness(3)
self.trace.setColor(0.8, 0.8, 0.8) # light grey
self.lines = self.render.attachNewNode("Lines")
self.last_pos = None
# Adds one instance of the update function to the task-manager, thus initializes the animation
self.taskMgr.add(self.update, "update")
def update(self, task: Task):
"""
Updates the visualization with every call.
:param task: Needed by panda3d task manager.
:return Task.cont: indicates that task should be called again next frame.
"""
return Task.cont
def reset(self):
"""
Resets the the visualization to a certain state, so that in can be run again. Removes the trace.
"""
self.lines.getChildren().detach()
self.last_pos = None
def draw_trace(self, point):
"""
Draws a line from the last point to the current point
:param point: Current position of pen. Needs 3 value vector.
"""
# Check if trace initialized
if self.last_pos:
# Set starting point of new line
self.trace.moveTo(self.last_pos)
# Draw line to that point
self.trace.drawTo(point)
# Save last position of pen
self.last_pos = point
# Show drawing
self.trace_np = NodePath(self.trace.create())
self.trace_np.reparentTo(self.lines)
