def addLight(self, type, tag, pos, color, hpr):
''' Create a light of the given type and assign the given properties.
Dynamic class instantantiation is difficult due to the Panda module
layout so we use conditionals
TODO - support for attenuation.
'''
LOG.debug("[GXMgr] Adding light of type %s"%type)
if hasattr(pandac.PandaModules, type):
LOG.debug("[GXMgr] Found light class - %s"%type)
if (type.lower() == 'ambientlight'):
from pandac.PandaModules import AmbientLight
l = AmbientLight(tag)
if color:
l.setColor(color)
lnp = render.attachNewNode(l)
elif (type.lower() == 'directionallight'):
from pandac.PandaModules import DirectionalLight
l = DirectionalLight(tag)
if color:
l.setColor(color)
lnp = render.attachNewNode(l)
if hpr:
lnp.setHpr(hpr)
elif (type.lower() == 'pointlight'):
from pandac.PandaModules import PointLight
l = PointLight(tag)
if color:
l.setColor(color)
lnp = render.attachNewNode(l)
if pos:
lnp.setPos(pos)
elif (type.lower() == 'spotlight'):
from pandac.PandaModules import Spotlight
l = Spotlight(tag)
if lens:
lightLens = PerspectiveLens()
l.setLens(lightLens)
if color:
l.setColor(color)
lnp = render.attachNewNode(l)
if hpr:
lnp.setHpr(hpr)
if pos:
lnp.setPos(pos)
self.lightList.append(lnp)
render.setLight(lnp)
else:
LOG.error("[GXMgr] Unknown light class - %s"%type)
def __init__(self):
super(SimViewer, self).__init__()
# Make a window.
size = (700, 520)
self.create_output(size, "SimViewer")
self.output.setClearColor((0.0, 0.0, 0.0, 1.0))
# Lights node
self.lights = NodePath('lights')
# Create a spotlight
slight = Spotlight('slight')
slight.setScene(self.root)
slight.setShadowCaster(True, 2**11, 2**11)
# Set shadow mask, so we can exclude objects from casting shadows
self.shadow_mask = BitMask32.bit(2)
slight.setCameraMask(self.shadow_mask)
c = 1.4
slight.setColor((c, c, c, 1.0))
slight.getLens().setNearFar(4, 100)
slight.getLens().setFov(45)
slnp = self.lights.attachNewNode(slight)
slnp.setPos((7, 10, 40))
slnp.lookAt(2, 0, 1.5)
self.root.setLight(slnp)
# Create an ambient light.
alight = AmbientLight('alight')
c = 0.6
alight.setColor((c, c, c, 1.0))
alnp = self.lights.attachNewNode(alight)
self.root.setLight(alnp)
self.lights.reparentTo(self.root)
# Set auto shading for shadows.
self.root.setShaderAuto()
# Set antialiasing on.
self.root.setAntialias(AntialiasAttrib.MAuto)
# Camera.
lens = PerspectiveLens()
self.lens = lens
self.lens.setNearFar(0.1, 1000.)
self.lens.setFov((40, 30))
self.cameras = self.root.attachNewNode('cameras')
self.camera = self.make_camera(self.output, lens=self.lens)
self.camera.setPos(15, 44, 3.)
self.camera.setPos(15, 35, 15.)
self.camera.lookAt(0, 0, 1.)
def buildSpotlight(self, pos, fov, exponent, casts_shadow, shadow_caster,
pitch, near, far, color):
"""
Builds a Panda3D Spotlight at the specified position with the specified
field of view and color
"""
self.light_counter += 1
light = Spotlight("light%s" % self.light_counter)
if casts_shadow:
x, y = shadow_caster
light.setShadowCaster(True, x, y)
light.getLens().setFar(far)
else:
light.setShadowCaster(False)
light.getLens().setFar(2)
light.setColor(VBase4(*color))
light.getLens().setNear(near)
lightnp = render.attachNewNode(light)
lightnp.setPos(*pos)
lightnp.setP(pitch)
light.getLens().setFov(fov)
light.setExponent(exponent)
return lightnp
def __init__(self):
"""Initialise the scene."""
# Show the framerate
base.setFrameRateMeter(True)
# Initialise terrain:
# Make 4 terrain nodepath objects with different hilliness values
# and arrange them side-by-side in a 2x2 grid, giving a big terrain
# with variable hilly and flat areas.
color = (0.6, 0.8, 0.5, 1) # Bright green-ish
scale = 12
height = 18 # FIXME: For now we are raising the terrain so it
# floats above the sea to prevent lakes from
# appearing (but you still get them sometimes)
t1 = Terrain(color=color,
scale=scale,
trees=0.7,
pos=P.Point3(0, 0, height))
t1.prime.reparentTo(render)
t2 = Terrain(color=color,
scale=scale,
h=24,
pos=P.Point3(32 * scale, 0, height),
trees=0.5)
t2.prime.reparentTo(render)
t3 = Terrain(color=color,
scale=scale,
h=16,
pos=P.Point3(32 * scale, 32 * scale, height),
trees=0.3)
t3.prime.reparentTo(render)
t4 = Terrain(color=color,
scale=scale,
h=2,
pos=P.Point3(0, 32 * scale, height),
trees=0.9)
t4.prime.reparentTo(render)
#tnp1.setPos(tnp1,-32,-32,terrainHeight)
# Initialise sea
sea = Sea()
# Initialise skybox.
self.box = loader.loadModel("models/skybox/space_sky_box.x")
self.box.setScale(6)
self.box.reparentTo(render)
# Initialise characters
self.characters = []
self.player = C.Character(model='models/eve',
run='models/eve-run',
walk='models/eve-walk')
self.player.prime.setZ(100)
self.player._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
self.player.maxforce = 0.4
self.player.maxspeed = 0.55
EdgeScreenTracker(self.player.prime, dist=200) # Setup camera
for i in range(0, 11):
self.characters.append(C.Character())
self.characters[i].prime.setZ(100)
self.characters[i].wander()
self.characters[i].maxforce = 0.3
self.characters[i].maxspeed = 0.2
self.characters[i]._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
C.setContainer(
ContainerSquare(pos=SteerVec(32 * 12, 32 * 12), radius=31 * 12))
#C.toggleAnnotation()
# Initialise keyboard controls.
self.accept("c", C.toggleAnnotation)
self.accept("escape", sys.exit)
# Setup CollisionRay and CollisionHandlerQueue for mouse picking.
self.pickerQ = P.CollisionHandlerQueue()
self.picker = camera.attachNewNode(
P.CollisionNode('Picker CollisionNode'))
self.picker.node().addSolid(P.CollisionRay())
# We want the picker ray to collide with the floor and nothing else.
self.picker.node().setFromCollideMask(C.floorMASK)
self.picker.setCollideMask(P.BitMask32.allOff())
base.cTrav.addCollider(self.picker, self.pickerQ)
try:
handler.addCollider(self.picker, camera)
except:
pass
self.accept('mouse1', self.onClick)
# Set the far clipping plane to be far enough away that we can see the
# skybox.
base.camLens.setFar(10000)
# Initialise lighting
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.35, 0.35, 0.35, 1))
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.dlnp = render.attachNewNode(self.dlight)
self.dlnp.setHpr(45, -45, 0)
render.setLight(self.dlnp)
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.5, 1))
self.plnp = render.attachNewNode(self.plight)
self.plnp.setPos(160, 160, 50)
self.slight = Spotlight('slight')
self.slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
self.slight.setLens(lens)
self.slnp = render.attachNewNode(self.slight)
self.slnp.setPos(-20, -20, 20)
self.slnp.lookAt(50, 50, 0)
# Initialise some scene-wide exponential fog
colour = (0.5, 0.8, 0.8)
self.expfog = Fog("Scene-wide exponential Fog object")
self.expfog.setColor(*colour)
self.expfog.setExpDensity(0.0005)
render.setFog(self.expfog)
base.setBackgroundColor(*colour)
# Add a task for this Plant to the global task manager.
self.stepcount = 0
taskMgr.add(self.step, "Plant step task")
def __init__(self):
ShowBase.__init__(self)
resize_window = ConfigVariableBool('viewer-resize-window', '#t')
if resize_window.getValue():
self.win_size = (800, 800)
# Black background
self.win.setClearColor((0.0, 0.0, 0.0, 1.0))
# Set up lights.
self.lights = NodePath("lights")
# Spotlight. Casts shadows.
slight = Spotlight("slight")
slight.setScene(self.render)
slight.setShadowCaster(True, 2**11, 2**11)
# Set shadow mask, so we can exclude objects from casting shadows
self.shadow_mask = BitMask32.bit(2)
slight.setCameraMask(self.shadow_mask)
slight.setColor((1.2, 1.2, 1.2, 1.))
slight.getLens().setFov(45)
slight.getLens().setNearFar(1, 100)
slnp = self.lights.attachNewNode(slight)
slnp.setPos((6, 8, 20))
slnp.lookAt(0, 0, 0)
self.render.setLight(slnp)
# Ambient light.
alight = AmbientLight("alight")
a = 0.75
alight.setColor((a, a, a, 1.0))
#alight.setColor((0.8, 0.8, 0.8, 1.0))
alnp = self.lights.attachNewNode(alight)
self.render.setLight(alnp)
self.lights.reparentTo(self.render)
# Set auto shading for shadows
use_shaders = ConfigVariableBool('viewer-use-shaders', '#t')
if use_shaders.getValue():
self.render.setShaderAuto()
# Set antialiasing on
self.render.setAntialias(AntialiasAttrib.MAuto)
# Camera
self.camera_rot = self.render.attachNewNode("camera_rot")
self.cameras = self.camera_rot.attachNewNode("cameras")
self.cameras.setPos(14, 32, 9.)
self.look_at = self.render.attachNewNode("look_at")
self.look_at.setPos(Point3(2, 0, 1))
self.cameras.lookAt(self.look_at)
self.camera.reparentTo(self.cameras)
# Adjust the camera's lens
lens = PerspectiveLens()
self.camLens = lens
self.camLens.setNearFar(0.01, 1000.0)
setlens = ConfigVariableBool('viewer-set-cam-lens', '#t')
if setlens:
self.cam.node().setLens(self.camLens)
#
# Initialize / set variables
self.sso = None
self.ssos = []
self.cache = None
self.scene = SSO("scene")
self.scene.reparentTo(self.render)
# Key callbacks.
self.accept("shift-control-escape", self.exit)
self.accept("escape", self.exit)
self.accept("0", self.reset_sso)
self.accept("arrow_left", self.prev)
self.accept("arrow_right", self.next)
self.accept("page_down", self.prev, [100])
self.accept("page_up", self.next, [100])
self.accept("f1", self.toggle_debug)
self.accept("o", self.physics_once, extraArgs=[1. / 10])
self.accept("i", self.physics_once, extraArgs=[1. / 10000])
# Remove existing keyboard tasks.
self.mandatory_events = ("window-event", "async_loader_0",
"render-texture-targets-changed",
"shift-control-escape")
# Task list: name: (key, args)
events = {
"physics": ("p", ),
"repel": ("t", ),
"bump": ("f", ),
"rotate": ("r", 20),
"rotate90": ("h", ),
"ss_task": ("s", ),
"ssa_task": ("w", ),
"bp": ("b", )
}
# Add events
for key, val in events.iteritems():
call = [key] + list(val[1:])
self.accept(val[0], self.toggle_task, call)
# These are the key events that we will never ignore
self.permanent_events = self.getAllAccepting()
# These are the key events that we will never ignore
self.permanent_tasks = [
task.getName() for task in self.taskMgr.getAllTasks()
]
self.start_time = -1
self.old_elapsed = 0
terrain.setScale(10)
floorcollider = terrain.find("**/floor_collide")
floorcollider.node().setFromCollideMask(BitMask32.allOff())
floorcollider.node().setIntoCollideMask(FLOOR_MASK)
wallcollider = terrain.find("**/wall_collide")
wallcollider.node().setFromCollideMask(BitMask32.allOff())
wallcollider.node().setIntoCollideMask(WALL_MASK)
#** Here the sentinel - the only collider we put in it is the ray detector (see below)
sentinel = loader.loadModel("frowney")
sentinel.setCollideMask(BitMask32.allOff())
sentinel.reparentTo(render)
sentinel.setPos((7.83, -25.31, 24))
avatar_in_sight = False
# we create a spotlight that will be the sentinel's eye and will be used to fire the inView method
slight = Spotlight('slight')
slight.setColor((1, 1, 1, 1))
lens = PerspectiveLens()
lens.setFar(80)
slight.setLens(lens)
slnp = sentinel.attachNewNode(slight)
render.setLight(slnp)
# this is important: as we said the inView method don't cull geometry but take everything is in sight frustum - therefore to simulate an hide and seek feature we gotta cheat a little: this ray is masked to collide with walls and so if the avatar is behind a wall the ray will be 'deflected' (we'll see how later in the sent_traverse function) - so we know who's behind a wall but we fake we can't see it.
sentraygeom = CollisionRay(0, 0, 0, 0, 1, 0)
sentinelRay = sentinel.attachNewNode(CollisionNode('sentinelray'))
sentinelRay.node().addSolid(sentraygeom)
# we set to the ray a cumulative masking using the or operator to detect either the avatar's body and the wall geometry
sentinelRay.node().setFromCollideMask(SENTINEL_MASK | WALL_MASK)
sentinelRay.node().setIntoCollideMask(BitMask32.allOff())
# we add the ray to the sentinel collider and now it is ready to go
base.cTrav.addCollider(sentinelRay, sentinelHandler)
def collectPlayer(self, task):
'''
Wait until all players are ready
'''
if len(self._players) > 0 and self.player_buttonpressed[0] < task.time:
if self._players[0].device.boost and self.countdown <= 0:
loading = False
for player in self._players:
if player.vehicle.model_loading:
loading = True
break
self._notify.debug("Loading vehicle: %s" % (loading))
if not loading:
taskMgr.remove("selectVehicle")
self.track = trackgen3d.Track3d(1000, 1800, 1600, 1200,
5) # len(self._players))
self.streetPath = render.attachNewNode(
self.track.createRoadMesh())
# self.borderleftPath = render.attachNewNode(self.track.createBorderLeftMesh())
self.borderleftPath = render.attachNewNode(
self.track.createBorderLeftMesh())
self.borderrightPath = render.attachNewNode(
self.track.createBorderRightMesh())
self.borderleftcollisionPath = NodePath(
self.track.createBorderLeftCollisionMesh())
self.borderrightcollisionPath = NodePath(
self.track.createBorderRightCollisionMesh())
# #self.borderPath = render.attachNewNode(self.track.createBorderMesh())
textures = ["tube", "tube2", "street"]
tex = textures[random.randint(0, len(textures) - 1)]
roadtex = loader.loadTexture('data/textures/' + tex +
'.png')
bordertex = loader.loadTexture('data/textures/border.png')
self.streetPath.setTexture(roadtex)
self.borderleftPath.setTexture(bordertex)
self.borderrightPath.setTexture(bordertex)
# self.streetPath = loader.loadModel('data/models/Street.egg')
# self.streetPath = loader.loadModel('data/models/Street.egg')
# tex = loader.loadTexture('data/models/StreetTex.png')
# self.nodePath.setTexture(tex)
self._parent.startGame(self.streetPath,
self.borderleftPath,
self.borderrightPath,
self.track.trackpoints,
self.borderleftcollisionPath,
self.borderrightcollisionPath)
return task.done
for device in self.unusedDevices:
if device.boost:
self.countdown = COUNTDOWN_START
self.player_buttonpressed.append(0)
self._parent.addPlayer(device)
# Set the PlayerCam to the Vehicle select menu Node
vehicleSelectNode = NodePath("VehicleSelectNode")
self._players[-1].camera.camera.reparentTo(vehicleSelectNode)
# Light, that casts shadows
plight = Spotlight('plight')
plight.setColor(VBase4(10.0, 10.0, 10.0, 1))
if (base.win.getGsg().getSupportsBasicShaders() != 0):
pass
# plight.setShadowCaster(True, 2048, 2048)#enable shadows for this light ##TODO wegen Linux
# Light
plight.getLens().setFov(80)
plnp = vehicleSelectNode.attachNewNode(plight)
plnp.setPos(2, -10, 10)
plnp.lookAt(0, 0, 0)
vehicleSelectNode.setLight(plnp)
# vehicleSelectNode.setShaderAuto()#enable autoshader so we can use shadows
# Light
ambilight = AmbientLight('ambilight')
ambilight.setColor(VBase4(0.2, 0.2, 0.2, 1))
vehicleSelectNode.setLight(
vehicleSelectNode.attachNewNode(ambilight))
self.platform.instanceTo(
vehicleSelectNode) # Load the platform
# instance shown text
self.countdown_node.instanceTo(
vehicleSelectNode) # Instance the Countdown
self.loading.instanceTo(
vehicleSelectNode) # Show the Loading-Text
self.attributes.copyTo(vehicleSelectNode).hide()
self._players[-1].vehicle.model_loading = True
# start loading the model
loader.loadModel(self.vehicle_list[0],
callback=self._players[-1].setVehicle)
self._notify.debug("Loading initial vehicle: %s" %
(self.vehicle_list[0]))
self.unusedDevices.remove(device)
self.player_buttonpressed[-1] = task.time + self.KEY_DELAY
# Add the Skybox
skybox = loader.loadModel("data/models/skybox.egg")
t = Texture()
t.load(PNMImage("data/textures/skybox_hangar.png"))
skybox.setTexture(t)
skybox.setBin("background", 1)
skybox.setDepthWrite(0)
skybox.setDepthTest(0)
skybox.setLightOff()
skybox.setScale(10000)
skybox.reparentTo(vehicleSelectNode)
for player in self._players:
if self.player_buttonpressed[self._players.index(
player)] < task.time:
if player.device.use_item:
self.countdown = COUNTDOWN_START
self._notify.debug("Removing player: %s" % (player))
self.unusedDevices.append(player.device)
self.player_buttonpressed.pop(self._players.index(player))
self._parent.removePlayer(player)
return task.cont
