def __init__(self, houseId, suncgDatasetRoot=None, size=(256, 256), debug=False, depth=False, realtime=False, dt=0.1, cameraTransform=None):
self.__dict__.update(houseId=houseId, suncgDatasetRoot=suncgDatasetRoot, size=size,
debug=debug, depth=depth, realtime=realtime, dt=dt, cameraTransform=cameraTransform)
self.scene = SunCgSceneLoader.loadHouseFromJson(houseId, suncgDatasetRoot)
agentRadius = 0.1
agentHeight = 1.6
if self.cameraTransform is None:
self.cameraTransform = TransformState.makePos(LVector3f(0.0, 0.0, agentHeight/2.0 - agentRadius))
self.renderWorld = Panda3dRenderer(self.scene, size, shadowing=False, depth=depth, cameraTransform=self.cameraTransform)
self.physicWorld = Panda3dBulletPhysics(self.scene, suncgDatasetRoot, debug=debug, objectMode='box',
agentRadius=agentRadius, agentHeight=agentHeight, agentMass=60.0, agentMode='capsule')
self.clock = ClockObject.getGlobalClock()
self.worlds = {
"physics": self.physicWorld,
"render": self.renderWorld,
}
self.agent = self.scene.agents[0]
self.agentRbNp = self.agent.find('**/+BulletRigidBodyNode')
self.labeledNavMap = None
self.occupancyMapCoord = None
def _scheduleNextProfile(self):
self._profileCounter += 1
self._timeElapsed = self._profileCounter * self._period
#assert isInteger(self._timeElapsed)
time = self._startTime + self._timeElapsed
# vary the actual delay between profiles by a random amount to prevent interaction
# with periodic events
jitter = self._jitter
if jitter is None:
jitter = normalDistrib(-self._jitterMagnitude,
self._jitterMagnitude)
time += jitter
else:
time -= jitter
jitter = None
self._jitter = jitter
sessionId = serialNum()
session = taskMgr.getProfileSession('FrameProfile-%s' % sessionId)
self._id2session[sessionId] = session
taskMgr.profileFrames(num=1,
session=session,
callback=Functor(self._analyzeResults,
sessionId))
# schedule the next profile
delay = max(time - ClockObject.getGlobalClock().getFrameTime(), 0.)
self._task = taskMgr.doMethodLater(delay,
self._scheduleNextProfileDoLater,
'FrameProfiler-%s' % serialNum())
def __init__(self):
ShowBase.__init__(self)
self.Clock = ClockObject.getGlobalClock()
self._alive = True
self._connected = False
self._display_region = self.cam.getNode(0).getDisplayRegion(0)
# Main menu and environment.
self.LOBBY = Lobby(self) # <-
self.ENV = Environment(self) # <-
self.PRE_VIEW = Pre_View(self) # <-
self.DISPLAY = self.LOBBY
self.SYS = None
self.SIM = Simulator(_sim.MAX_LOCAL_BODIES)
self.servers = []
self.sys_recipes = self.__refresh_Sys_Recipes()
# Player and main objects.
## self.PLAYER = Player() # <-
self.UEH = Default_UEH() # <-
self.setBackgroundColor(0,0,0)
self.disableMouse()
# Network.
'''self.host = socket.gethostbyname(socket.gethostname())
self.tcp_addr = (self.host, CLIENT_TCP_PORT)
self.udp_addr = (self.host, CLIENT_UDP_PORT)
## self.tcp_req_addr = (self.host, CLIENT_REQUEST_PORT)
self.proxy_tcp_addr = None ## self.client_proxy_tcp_addr'''
# Main loop.
taskMgr.add(self._main_loop_, "main_loop", appendTask=True, sort=0) # <-
taskMgr.doMethodLater(1/_net.BROADCAST_HZ, self._state_, "state_loop")
def _doCallback(self, callback, taskName, task):
assert self.notify.debugCall()
self.__taskNames.remove(taskName)
self._taskStartTime = ClockObject.getGlobalClock().getRealTime()
callback()
self._taskStartTime = None
return Task.done
def _setEnabled(self, enabled):
if enabled:
self.notify.info('frame profiler started')
self._startTime = ClockObject.getGlobalClock().getFrameTime()
self._profileCounter = 0
self._jitter = None
self._period2aggregateProfile = {}
self._id2session = {}
self._id2task = {}
# don't profile process startup
self._task = taskMgr.doMethodLater(
self._period, self._scheduleNextProfileDoLater,
'FrameProfilerStart-%s' % serialNum())
else:
self._task.remove()
del self._task
for session in self._period2aggregateProfile.values():
session.release()
del self._period2aggregateProfile
for task in self._id2task.values():
task.remove()
del self._id2task
for session in self._id2session.values():
session.release()
del self._id2session
self.notify.info('frame profiler stopped')
def __init__(self, scene, size=(800, 600), zNear=0.1, zFar=1000.0, fov=40.0, shadowing=False, interactive=True,
showPosition=False, cameraMask=None):
super(Viewer, self).__init__()
self.__dict__.update(scene=scene, size=size, fov=fov, shadowing=shadowing,
zNear=zNear, zFar=zFar, interactive=interactive, showPosition=showPosition,
cameraMask=cameraMask)
if cameraMask is not None:
self.cam.node().setCameraMask(self.cameraMask)
lens = self.cam.node().getLens()
lens.setFov(self.fov)
lens.setNear(self.zNear)
lens.setFar(self.zFar)
# Change window size
wp = WindowProperties()
wp.setSize(size[0], size[1])
wp.setTitle("Viewer")
wp.setCursorHidden(True)
self.win.requestProperties(wp)
self.disableMouse()
self.time = 0
self.centX = self.win.getProperties().getXSize() / 2
self.centY = self.win.getProperties().getYSize() / 2
# key controls
self.forward = False
self.backward = False
self.fast = 1.0
self.left = False
self.right = False
self.up = False
self.down = False
self.up = False
self.down = False
# sensitivity settings
self.movSens = 2
self.movSensFast = self.movSens * 5
self.sensX = self.sensY = 0.2
self.cam.setP(self.cam, 0)
self.cam.setR(0)
# reset mouse to start position:
self.win.movePointer(0, int(self.centX), int(self.centY))
# Reparent the scene to render.
self.scene.scene.reparentTo(self.render)
# Task
self.globalClock = ClockObject.getGlobalClock()
self.taskMgr.add(self.update, 'viewer-update')
self._addDefaultLighting()
self._setupEvents()
def updateDialTask(self, state):
# Update value
currT = ClockObject.getGlobalClock().getFrameTime()
dt = currT - state.lastTime
self.set(self.value + self.knobSF * dt)
state.lastTime = currT
return Task.cont
def __init__(self):
self.config = getConfigShowbase()
vfs = VirtualFileSystem.getGlobalPtr()
self.eventMgr = eventMgr
self.messenger = messenger
self.bboard = bulletinBoard
self.taskMgr = taskMgr
self.AISleep = self.config.GetFloat('ai-sleep', 0.04)
Task.TaskManager.taskTimerVerbose = self.config.GetBool(
'task-timer-verbose', 0)
Task.TaskManager.extendedExceptions = self.config.GetBool(
'extended-exceptions', 0)
self.sfxManagerList = None
self.musicManager = None
self.jobMgr = jobMgr
self.hidden = NodePath('hidden')
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
globalClock = ClockObject.getGlobalClock()
self.trueClock = TrueClock.getGlobalPtr()
globalClock.setRealTime(self.trueClock.getShortTime())
globalClock.setAverageFrameRateInterval(30.0)
globalClock.tick()
taskMgr.globalClock = globalClock
__builtins__['ostream'] = Notify.out()
__builtins__['globalClock'] = globalClock
__builtins__['vfs'] = vfs
__builtins__['hidden'] = self.hidden
self.restart()
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0,-a,a+3)#80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock=ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.monsters = []
self.accept('c',self._create)
base.enableParticles()
def updateStatusReadout(self, status, color=None):
if status:
# add new status line, first check to see if it already exists
alreadyExists = False
for currLine in self.statusLines:
if status == currLine[1]:
alreadyExists = True
break
if not alreadyExists:
time = ClockObject.getGlobalClock().getRealTime() + 15
self.statusLines.append([time, status, color])
# update display of new status lines
self.statusReadout.reparentTo(aspect2d)
statusText = ""
lastColor = None
for currLine in self.statusLines:
statusText += currLine[1] + '\n'
lastColor = currLine[2]
self.statusReadout.setText(statusText)
if lastColor:
self.statusReadout.textNode.setCardColor(lastColor[0],
lastColor[1],
lastColor[2],
lastColor[3])
self.statusReadout.textNode.setCardAsMargin(0.1, 0.1, 0.1, 0.1)
else:
self.statusReadout.textNode.setCardColor(1, 1, 1, 1)
self.statusReadout.textNode.setCardAsMargin(0.1, 0.1, 0.1, 0.1)
def __init__(self, scene, size=(800, 600), zNear=0.1, zFar=1000.0, fov=40.0, shadowing=False, showPosition=False,
cameraTransform=None, cameraMask=None):
ShowBase.__init__(self)
self.__dict__.update(scene=scene, size=size, fov=fov,
zNear=zNear, zFar=zFar, shadowing=shadowing, showPosition=showPosition,
cameraTransform=cameraTransform, cameraMask=cameraMask)
# Find agent and reparent camera to it
self.agent = self.scene.scene.find('**/agents/agent*/+BulletRigidBodyNode')
self.camera.reparentTo(self.agent)
if self.cameraTransform is not None:
self.camera.setTransform(cameraTransform)
if cameraMask is not None:
self.cam.node().setCameraMask(self.cameraMask)
lens = self.cam.node().getLens()
lens.setFov(self.fov)
lens.setNear(self.zNear)
lens.setFar(self.zFar)
# Change window size
wp = WindowProperties()
wp.setSize(size[0], size[1])
wp.setTitle("Controller")
wp.setCursorHidden(True)
self.win.requestProperties(wp)
self.disableMouse()
self.time = 0
self.centX = wp.getXSize() / 2
self.centY = wp.getYSize() / 2
self.win.movePointer(0, int(self.centX), int(self.centY))
# key controls
self.forward = False
self.backward = False
self.fast = 2.0
self.left = False
self.right = False
# sensitivity settings
self.movSens = 2
self.movSensFast = self.movSens * 5
self.sensX = self.sensY = 0.2
# Reparent the scene to render.
self.scene.scene.reparentTo(self.render)
self.render.setAntialias(AntialiasAttrib.MAuto)
# Task
self.globalClock = ClockObject.getGlobalClock()
self.taskMgr.add(self.update, 'controller-update')
self._addDefaultLighting()
self._setupEvents()
def __init__(self):
self.loadDefaultConfig()
self.loadLocalConfig()
if ConfigVariableBool("want-pstats", False):
PStatClient.connect()
# Set up some global objects
self.globalClock = ClockObject.getGlobalClock()
# We will manually manage the clock
self.globalClock.setMode(ClockObject.MSlave)
builtins.globalClock = self.globalClock
self.vfs = VirtualFileSystem.getGlobalPtr()
# For tasks that run every application frame
self.taskMgr = TaskManagerGlobal.taskMgr
builtins.taskMgr = self.taskMgr
# For tasks that run every simulation tick
self.simTaskMgr = Task.TaskManager()
self.simTaskMgr.mgr = AsyncTaskManager("sim")
builtins.simTaskmgr = self.simTaskMgr
self.eventMgr = EventManagerGlobal.eventMgr
builtins.eventMgr = self.eventMgr
self.messenger = MessengerGlobal.messenger
builtins.messenger = self.messenger
self.loader = Loader(self)
builtins.loader = self.loader
builtins.base = self
# What is the current frame number?
self.frameCount = 0
# Time at beginning of current frame
self.frameTime = self.globalClock.getRealTime()
# How long did the last frame take.
self.deltaTime = 0
#
# Variables pertaining to simulation ticks.
#
self.prevRemainder = 0
self.remainder = 0
# What is the current overall simulation tick?
self.tickCount = 0
# How many ticks are we going to run this frame?
self.totalTicksThisFrame = 0
# How many ticks have we run so far this frame?
self.currentTicksThisFrame = 0
# What tick are we currently on this frame?
self.currentFrameTick = 0
# How many simulations ticks are we running per-second?
self.ticksPerSec = 60
self.intervalPerTick = 1.0 / self.ticksPerSec
def postInit(self):
#
# initialize game content
#
# camera
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0, -a, a + 3) #80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock = ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
# manager
self.archiveManager = ArchiveManager()
self.mapManager = MapManager()
self.initHeroInfo = None
# Lock
self.lock = threading.Lock()
self.gameThread = None
self.filters = CommonFilters(base.win, base.cam)
# UI
self.menu = Menu()
self.option = Option()
self.archive = Archive()
self.death = Death()
# self.oobe()
#self.Archive_status = 0
# self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
# self.menuMusic.setLoop(True)
# self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
# self.fightMusic.setLoop(True)
# base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.titleVideo, self.titleCard = loadVideo('title.mp4')
self.isInited = False
self.isSkip = False
self.isRenew = False
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def step(self, task):
distance = ClockObject.getGlobalClock().getDt() * self.speed
rotMat = Mat3.rotateMatNormaxis(self.avatar.getH(), Vec3.up())
step = Vec3(rotMat.xform(Vec3.forward() * distance))
self.avatar.setFluidPos(Point3(self.avatar.getPos() + step))
return Task.cont
def takeHit(self, entry):
ENEMY_STOPPED = 2
index = int(entry.getFromNode().getTag('enemy'))
if self.world.enemies[index].phase != ENEMY_STOPPED and ClockObject.getGlobalClock().getLongTime() - self.lastCollision > INVULN_TIME:
self.lastCollision = ClockObject.getGlobalClock().getLongTime()
self.health = self.health - 1
self.screamSound.play()
self.world.livesSprites[self.health].setImage('images/healthicon_depleted.png')
self.world.livesSprites[self.health].setTransparency(TransparencyAttrib.MAlpha)
# print "Health: " + str(self.health)
self.blinkStart = -1
taskMgr.add(self.blink, "blinking")
#If health = 0, we need to do something
if self.health <= 0:
# print "YOU ARE DEAD!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
self.dead = True
def mouseDown(self, event):
""" Begin mouse interaction """
# Exectute user redefinable callback function (if any)
self['relief'] = SUNKEN
if self['preCallback']:
self['preCallback'](*self['callbackData'])
self.velocitySF = 0.0
self.updateTask = taskMgr.add(self.updateFloaterTask, 'updateFloater')
self.updateTask.lastTime = ClockObject.getGlobalClock().getFrameTime()
def taskTimeLeft(self):
"""returns True if there is time left for the current task callback
to run without going over the allotted timeslice"""
if self._taskStartTime is None:
# we must not be in a task callback, we must be running in non-threaded
# mode
return True
return (ClockObject.getGlobalClock().getRealTime() -
self._taskStartTime) < self.__timeslice
def startCallback(self, t, callback):
if self.started:
self.stop()
self.callback = callback
self.finalT = t
self.startT = ClockObject.getGlobalClock().getFrameTime()
self.currT = 0.0
taskMgr.add(self.__timerTask, self.name + '-run')
self.started = 1
def updateFloaterTask(self, state):
"""
Update floaterWidget value based on current scaleFactor
Adjust for time to compensate for fluctuating frame rates
"""
currT = ClockObject.getGlobalClock().getFrameTime()
dt = currT - state.lastTime
self.set(self.value + self.velocitySF * dt)
state.lastTime = currT
return Task.cont
def play(self, node, time=0.0, loop=0):
if self.xyzNurbsCurve is None and self.hprNurbsCurve is None:
print('Mopath: Mopath has no curves')
return
self.node = node
self.loop = loop
self.stop()
t = taskMgr.add(self.__playTask, self.name + '-play')
t.currentTime = time
t.lastTime = ClockObject.getGlobalClock().getFrameTime()
def sendHeartbeat(self):
datagram = PyDatagram()
# Add message type
datagram.addUint16(CLIENT_HEARTBEAT_CMU)
# Send it!
self.send(datagram)
self.lastHeartbeat = ClockObject.getGlobalClock().getRealTime()
# This is important enough to consider flushing immediately
# (particularly if we haven't run readerPollTask recently).
self.considerFlush()
def play(self, task):
if not self.playList:
return Task.done
fLoop = self.loopVar.get()
currT = ClockObject.getGlobalClock().getFrameTime()
deltaT = currT - self.lastT
self.lastT = currT
for actorControl in self.playList:
# scale time by play rate value
actorControl.play(deltaT * actorControl.playRate, fLoop)
return Task.cont
def getListenerVelocity(self):
"""
Get the velocity of the listener.
"""
if self.listener_vel is not None:
return self.listener_vel
elif self.listener_target is not None:
clock = ClockObject.getGlobalClock()
return self.listener_target.getPosDelta(self.root) / clock.getDt()
else:
return VBase3(0, 0, 0)
def getListenerVelocity(self):
"""
Get the velocity of the listener.
"""
if self.listener_vel is not None:
return self.listener_vel
elif self.listener_target is not None:
clock = ClockObject.getGlobalClock()
return self.listener_target.getPosDelta(self.root) / clock.getDt()
else:
return VBase3(0, 0, 0)
def _doThreadCallback(self, thread, taskName, task):
assert self.notify.debugCall()
self._taskStartTime = ClockObject.getGlobalClock().getRealTime()
thread.run()
self._taskStartTime = None
if thread.isFinished():
thread._destroy()
self.__taskNames.remove(taskName)
self.__threads.remove(thread)
return Task.done
else:
return Task.cont
def __init__(self, base, numberOfPlayers):
self.base = base
self.render = base.render
self.taskMgr = base.taskMgr
self.loader = base.loader
self.windowEventSetup()
# Create separate nodes so that shaders apply to
# stuff in the worldRender but not the outsideWorldRender
self.worldRender = render.attachNewNode("world")
self.outsideWorldRender = render.attachNewNode("world")
self.base.setFrameRateMeter(True)
self.globalClock = ClockObject.getGlobalClock()
self.globalClock.setMode(ClockObject.MLimited)
self.globalClock.setFrameRate(60)
self.base.disableMouse()
if not 0 < numberOfPlayers < 5:
raise ValueError("Number of players must be from 1 to 4")
self.numberOfPlayers = numberOfPlayers
self.createLights()
self.initialisePhysics(debug=False)
# Load the default arena
self.level = Level("01.json", self)
# disable default cam so that we can have multiplayer
base.camNode.setActive(False)
# moved player setup out to its own method
self.setupPlayers(self.numberOfPlayers)
# Set up shaders for shadows and cartoon outline
self.setupShaders()
# Create an audio manager. This is attached to the camera for
# player 1, so sounds close to other players might not be very
# loud
self.audioManager = Audio3DManager.Audio3DManager(self.base.sfxManagerList[0], self.playerCameras[0])
# Distance should be in m, not feet
self.audioManager.setDistanceFactor(3.28084)
# Now initialise audio for all vehicles that were
# previously set up. We can't just create the audio manager
# first because we need the player 1 camera
for vehicle in self.playerVehicles:
vehicle.initialiseSound(self.audioManager)
self.initialiseCollisionInfo()
def __timerTask(self, task):
t = ClockObject.getGlobalClock().getFrameTime()
te = t - self.startT
self.currT = te
if te >= self.finalT:
if self.callback is not None:
self.callback()
else:
from direct.showbase.MessengerGlobal import messenger
messenger.send(self.name)
return Task.done
return Task.cont
def updateStatusReadoutTimeouts(self, task=None):
removalList = []
for currLine in self.statusLines:
if ClockObject.getGlobalClock().getRealTime() >= currLine[0]:
removalList.append(currLine)
for currRemoval in removalList:
self.statusLines.remove(currRemoval)
self.updateStatusReadout(None)
# perform doMethodLater again after delay
# This crashes when CTRL-C'ing, so this is a cheap hack.
#return 2
from direct.task import Task
return Task.again
def move_enemies_task(self, task): # pylint: disable=unused-argument
"""The task that handles enemy movement."""
if self.game_state != "active":
return Task.cont
for enemy in set(self.enemies):
if not enemy.generated:
enemy.generate(self.terrain.path_finder, self.base.loader,
self.terrain.geom_node, self.terrain.get_tile)
if not enemy.check_active():
self.enemies.remove(enemy)
continue
# enemy.model.setPos(self.player.pos)
enemy.move(ClockObject.getGlobalClock().getDt())
return Task.cont
def tower_task(self, task):
if self.game_state != "active":
return Task.cont
for tower in set(self.terrain.towers):
if not tower.generated:
tower.generate(self.base.loader, self.terrain.geom_node,
self.terrain.get_tile)
if not tower.check_active():
self.terrain.towers.remove(tower)
self.terrain[tower.grid_pos] = Floor()
continue
tower.move(ClockObject.getGlobalClock().getDt(), self.enemies)
tower.generate_bullet(self.base.loader, self.terrain.geom_node,
self.terrain.get_tile)
return Task.cont
def __init__(self):
self.globalClock = ClockObject.getGlobalClock()
# self.delta is the relative delta from our clock to the
# server's clock.
self.delta = 0
# self.uncertainty represents the number of seconds plus or
# minus in which we are confident our delta matches the
# server's actual time. The initial value, None, represents
# infinity--we have no idea.
self.uncertainty = None
# self.lastResync is the time at which self.uncertainty
# was measured. It is important to remember because our
# uncertainty increases over time (due to relative clock
# drift).
self.lastResync = 0.0
self.accept("resetClock", self.__resetClock)
def __playTask(self, task):
time = ClockObject.getGlobalClock().getFrameTime()
dTime = time - task.lastTime
task.lastTime = time
if self.loop:
cTime = (task.currentTime + dTime) % self.getMaxT()
else:
cTime = task.currentTime + dTime
if self.loop == 0 and cTime > self.getMaxT():
self.stop()
messenger.send(self.name + '-done')
self.node = None
return task.done
self.goTo(self.node, cTime)
task.currentTime = cTime
return task.cont
def togglePhysicsPause(self):
if (self._GCLK == None):
self.disableParticles()
self._GCLK = ClockObject.getGlobalClock()
self._FT = self._GCLK.getFrameTime()
self._GCLK.setMode(ClockObject.MSlave)
else:
self._GCLK.setRealTime(self._FT)
self._GCLK.setMode(ClockObject.MNormal)
self.enableParticles()
self._GCLK = None
def _physics_(self, alive, sys):
sim_throttle = Throttle(_sim.HZ)
sys_root = self.__init_Sim_System(self.sys_recipe)
dir_vec = LVector3d(0, 0, 0)
clock = ClockObject.getGlobalClock()
G = _phys.G
def apply_physics(body, parent, dt):
if parent:
# Find distance and direction from body to its parent.
dir_vec.set(*body['POS'] - parent['POS'])
dist = dir_vec.length()
dir_vec.normalize()
# Apply parent's gravity.
F = (G * (parent['mass'] + body['mass'])) / (dist**2)
body['delta_vec'] = -dir_vec * F * dt
body['VEC'] += body['delta_vec'] + parent['delta_vec']
body['POS'] += body['VEC'] * dt
# Update self.BODIES.
b = self.BODIES[body['name']]
pos, vec, hpr, rot = body['POS'], body['VEC'], body[
'HPR'], body['ROT']
b['x'].value, b['y'].value, b['z'].value = pos.x, pos.y, pos.z
b['vx'].value, b['vy'].value, b[
'vz'].value = vec.x, vec.y, vec.z
b['h'].value, b['p'].value, b['r'].value = hpr.x, hpr.y, hpr.z
b['rh'].value, b['rp'].value, b[
'rr'].value = rot.x, rot.y, rot.z
for sat in body['bodies']:
apply_physics(sat, body, dt)
p_time = 0
dt = 0
while alive.value:
with sim_throttle:
## with TimeIt() as tt:
c_time = clock.getRealTime()
dt = c_time - p_time
apply_physics(sys_root, None, dt)
p_time = c_time
def __init__(self, graphicsInterface, backend, gameState):
ShowBase.__init__(self)
self.graphicsInterface = graphicsInterface
self.backend = backend
self.gameState = gameState
self.groundNodes = None
self.firstTick = True
# This is available as a global, but pylint gives an undefined-variable
# warning if we use it that way. Looking at
# https://www.panda3d.org/manual/index.php/ShowBase
# I would have thought we could reference it as either
# self.globalClock, direct.showbase.ShowBase.globalClock, or possibly
# direct.showbase.globalClock, but none of those seems to work. To
# avoid the pylint warnings, create self.globalClock manually.
self.globalClock = ClockObject.getGlobalClock()
# Set up event handling.
self.mouseState = {}
self.keys = {}
self.setupEventHandlers()
# Set up camera control.
self.cameraHolder = self.render.attachNewNode('CameraHolder')
self.cameraHolder.setPos(0, 0, 100)
self.prevCameraHpr = (0, -80, 0)
self.usingCustomCamera = True
self.setCameraCustom()
self.prevMousePos = None
self.selectionBox = None
self.selectionBoxNode = None
self.selectionBoxOrigin = None
# Define the ground plane by a normal (+z) and a point (the origin).
self.groundPlane = core.Plane(core.Vec3(0, 0, 1), core.Point3(0, 0, 0))
graphicsInterface.graphicsReady(self)
def __init__(self, graphicsInterface):
ShowBase.__init__(self)
# This is available as a global, but pylint gives an undefined-variable
# warning if we use it that way. Looking at
# https://www.panda3d.org/manual/index.php/ShowBase
# I would have thought we could reference it as either
# self.globalClock, direct.showbase.ShowBase.globalClock, or possibly
# direct.showbase.globalClock, but none of those seems to work. To
# avoid the pylint warnings, create self.globalClock manually.
self.globalClock = ClockObject.getGlobalClock()
self.graphicsInterface = graphicsInterface
# Mapping from gids to entities.
self.entities = {}
# Set up event handling.
self.mouseState = {}
self.keys = {}
self.setupEventHandlers()
# Set up camera control.
self.cameraHolder = self.render.attachNewNode('CameraHolder')
self.cameraHolder.setPos(0, 0, 100)
self.prevCameraHpr = (0, -80, 0)
self.usingCustomCamera = True
self.setCameraCustom()
self.prevMousePos = None
self.selectionBox = None
self.selectionBoxNode = None
self.selectionBoxOrigin = None
# TODO[#3]: Magic numbers bad.
self.resourceDisplay = OnscreenText(pos=(-0.98,.9),
align=TextNode.ALeft,
mayChange=True)
# Define the ground plane by a normal (+z) and a point (the origin).
self.groundPlane = core.Plane(core.Vec3(0, 0, 1), core.Point3(0, 0, 0))
self.graphicsInterface.graphicsReady(self)
def __init__(self):
self.globalClock = ClockObject.getGlobalClock()
# self.delta is the relative delta from our clock to the
# server's clock.
self.delta = 0
# self.uncertainty represents the number of seconds plus or
# minus in which we are confident our delta matches the
# server's actual time. The initial value, None, represents
# infinity--we have no idea.
self.uncertainty = None
# self.lastResync is the time at which self.uncertainty
# was measured. It is important to remember because our
# uncertainty increases over time (due to relative clock
# drift).
self.lastResync = 0.0
self.accept("resetClock", self.__resetClock)
def getSoundVelocity(self, sound):
"""
Get the velocity of the sound.
"""
if sound in self.vel_dict:
vel = self.vel_dict[sound]
if vel is not None:
return vel
for known_object in list(self.sound_dict.keys()):
if self.sound_dict[known_object].count(sound):
node_path = known_object.getNodePath()
if not node_path:
# The node has been deleted.
del self.sound_dict[known_object]
continue
clock = ClockObject.getGlobalClock()
return node_path.getPosDelta(self.root) / clock.getDt()
return VBase3(0, 0, 0)
def _physics_(self, alive, sys):
sim_throttle = Throttle(_sim.HZ)
sys_root = self.__init_Sim_System(self.sys_recipe)
dir_vec = LVector3d(0,0,0)
clock = ClockObject.getGlobalClock()
G = _phys.G
def apply_physics(body, parent, dt):
if parent:
# Find distance and direction from body to its parent.
dir_vec.set(*body['POS']-parent['POS'])
dist = dir_vec.length()
dir_vec.normalize()
# Apply parent's gravity.
F = (G*(parent['mass']+body['mass'])) / (dist**2)
body['delta_vec'] = -dir_vec * F * dt
body['VEC'] += body['delta_vec'] + parent['delta_vec']
body['POS'] += body['VEC'] * dt
# Update self.BODIES.
b = self.BODIES[body['name']]
pos, vec, hpr, rot = body['POS'], body['VEC'], body['HPR'], body['ROT']
b['x'].value, b['y'].value, b['z'].value = pos.x, pos.y, pos.z
b['vx'].value, b['vy'].value, b['vz'].value = vec.x, vec.y, vec.z
b['h'].value, b['p'].value, b['r'].value = hpr.x, hpr.y, hpr.z
b['rh'].value, b['rp'].value, b['rr'].value = rot.x, rot.y, rot.z
for sat in body['bodies']:
apply_physics(sat, body, dt)
p_time = 0
dt = 0
while alive.value:
with sim_throttle:
## with TimeIt() as tt:
c_time = clock.getRealTime()
dt = c_time - p_time
apply_physics(sys_root, None, dt)
p_time = c_time
def __init__(self):
self.Clock = ClockObject.getGlobalClock()
self.UEH = None
self.ENV = None
self._alive = False
self._prev_t = 0
def update_bullet(self, task):
dt = ClockObject.getGlobalClock().getDt()
self.bullet_world.doPhysics(dt)
return task.cont
__all__ = []
from .ShowBase import ShowBase, WindowControls
from direct.directnotify.DirectNotifyGlobal import directNotify, giveNotify
from panda3d.core import VirtualFileSystem, Notify, ClockObject, PandaSystem
from panda3d.core import ConfigPageManager, ConfigVariableManager
from panda3d.core import NodePath, PGTop
from panda3d.direct import get_config_showbase
config = get_config_showbase()
__dev__ = config.GetBool('want-dev', __debug__)
vfs = VirtualFileSystem.getGlobalPtr()
ostream = Notify.out()
globalClock = ClockObject.getGlobalClock()
cpMgr = ConfigPageManager.getGlobalPtr()
cvMgr = ConfigVariableManager.getGlobalPtr()
pandaSystem = PandaSystem.getGlobalPtr()
# This is defined here so GUI elements can be instantiated before ShowBase.
aspect2d = NodePath(PGTop("aspect2d"))
# Set direct notify categories now that we have config
directNotify.setDconfigLevels()
def run():
assert ShowBase.notify.warning("run() is deprecated, use base.run() instead")
base.run()
def inspect(anObject):
def step(self, task):
step = ClockObject.getGlobalClock().getDt() * self.speed
self.avatar.setH(self.avatar.getH() + step)
return Task.cont
