def initLights(self):
# Create some lighting
#self.environ.ls()
#print(self.environ.findAllMatches("**/Spot"))
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(0.8, 0.8, 0.8, 0.65))
"""
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-10, -10, 5))
directionalLight.showFrustum()
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
dirnp = render.attachNewNode(directionalLight)
dirnp.setPos(10, 0, 6)
"""
plight1 = PointLight('plight1')
plight1.setColor(VBase4(1, 1, 1, 1))
plight1.showFrustum()
#plight1.setShadowCaster(True)
plnp1 = render.attachNewNode(plight1)
plnp1.setPos(26.71, -33.2, 26)
plight2 = PointLight('plight2')
plight2.setColor(VBase4(1, 1, 1, 1))
plight2.showFrustum()
plnp2 = render.attachNewNode(plight2)
plnp2.setPos(-25, 25, 25)
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
lens.setFilmSize(1, 1) # Or whatever is appropriate for your scene
slight.setLens(lens)
slight.setShadowCaster(True, 512, 512)
slight.showFrustum()
slnp = render.attachNewNode(slight)
slnp.setPos(0, 0, 100)
slnp.lookAt(Vec3(0,0,0))
render.setLight(slnp)
render.setLight(plnp1)
render.setLight(plnp2)
#render.setLight(render.attachNewNode(ambientLight))
#render.setLight(dirnp)
render.setShaderAuto()
#render.setLight(render.attachNewNode(directionalLight))
"""
def makeLights(self, lights):
def makeSpot(parent, color=VBase4(1, 1, 1, 1), fov=8, atten=.003):
x = parent.attachNewNode(Spotlight("spot"))
x.node().setColor(color)
lens = PerspectiveLens()
lens.setFov(fov)
x.node().setLens(lens)
x.node().setAttenuation(VBase3(0, 0, atten))
return x
self.trainLights = lights.attachNewNode("trainLights")
if 1:
pl = self.trainLights.attachNewNode(PointLight("point"))
pl.setPos(2, 10, 10)
#pl.node().setColor(VBase4(.7, .7, .7, 1))
pl.node().setAttenuation(Vec3(0, 0, 0.005))
#pl.node().setShadowCaster(True, 512, 512)
self.base.render.setLight(pl)
pl.node().setShadowCaster(True)
spot = makeSpot(self.trainLights, VBase4(1, 1, 1, 1), 8)
spot.setPos(2, 0, 18)
spot.lookAt(self.cubes, Point3(0, .6, 0))
self.base.render.setLight(spot)
self.gameLights = lights.attachNewNode("gameLights")
if 1:
bg = self.gameLights.attachNewNode(PointLight("point"))
bg.node().setColor(VBase4(.1, .2, .6, 1))
bg.setPos(-6, 15, 2)
self.base.render.setLight(bg)
bg.node().setShadowCaster(True)
up = makeSpot(self.gameLights,
color=VBase4(.6, .6, .6, 1),
fov=25,
atten=.009)
up.setPos(self.cubes.getPos().x, 10, .4)
up.lookAt(self.cubes, Point3(0, 0, 1.3))
self.base.render.setLight(up)
self.rotLights = []
for color, pos in [
(VBase4(1, 1, 0, 1), Point3(4, 10, 10)),
(VBase4(0, .7, 0, 1), Point3(-4, 10, 10)),
(VBase4(0, .6, 1, 1), Point3(0, 20, 10)),
]:
s1 = makeSpot(self.gameLights, color=color, fov=8)
s1.setPos(pos)
s1.lookAt(self.cubes)
self.base.render.setLight(s1)
self.rotLights.append(s1)
def __init__(self):
ShowBase.__init__(self)
self.cap = cv2.VideoCapture(0)
self.classifier = cv2.CascadeClassifier(self.haar)
self.scene = self.loader.loadModel('models/abstractroom')
self.scene.reparentTo(self.render)
self.scene.setPos(-10, 100, 0)
self.shaderenable = 1
self.scene.setShaderAuto()
# Add ambient light
alight = AmbientLight('alight')
alight.setColor((0.1, 0.11, 0.11, 1))
alnp = self.render.attachNewNode(alight)
self.scene.setLight(alnp)
# Add point light.
plight = PointLight('plight')
plight.setColor((1, 1, 1, 1))
plight.setAttenuation(LVector3(0.1, 0.02, 0))
plnp = self.render.attachNewNode(plight)
plnp.setPos(-27, 100, 0)
self.scene.setLight(plnp)
# Create a sphere to denote the light
sphere = self.loader.loadModel("models/icosphere")
sphere.reparentTo(plnp)
self.taskMgr.add(self.display, 'Display')
print("%.1f, %.1f, %.1f" % (self.x, self.y, self.z))
def __init__(self, base, USE_RP):
self.base = base
""" direct.showbase.ShowBase """
if not USE_RP:
alight = AmbientLight('alight')
alnp = self.base.render.attachNewNode(alight)
alight.setColor((0.2, 0.2, 0.2, 1))
self.base.render.setLight(alnp)
# Put lighting on the main scene
dlight = DirectionalLight('dlight')
dlnp = self.base.render.attachNewNode(dlight)
dlnp.setPos(0, 5, 5)
dlight.setColor((0.8, 0.8, 0.5, 1))
dlnp.setHpr(0, 60, 0)
self.base.render.setLight(dlnp)
plight = PointLight('plight')
plnp = self.base.render.attachNewNode(plight)
plnp.setPos(0, -50, 50)
plnp.setHpr(0, 60, 0)
self.base.render.setLight(plnp)
self.sounds = {}
def generate(self, helperInfo):
color = self.mapObject.getPropertyValue("_light",
default=Vec4(
255, 255, 255, 255))
color = CIGlobals.colorFromRGBScalar255(color)
color = CIGlobals.vec3GammaToLinear(color)
constant = float(
self.mapObject.getPropertyValue("_constant_attn", default="0.0"))
linear = float(
self.mapObject.getPropertyValue("_linear_attn", default="0.0"))
quadratic = float(
self.mapObject.getPropertyValue("_quadratic_attn", default="1.0"))
# Scale intensity for unit 100 distance
ratio = (constant + 100 * linear + 100 * 100 * quadratic)
if ratio > 0:
color *= ratio
pl = PointLight("lightHelper-light")
pl.setColor(Vec4(color[0], color[1], color[2], 1.0))
pl.setAttenuation(Vec3(constant, linear, quadratic))
self.light = self.mapObject.helperRoot.attachNewNode(pl)
if self.mapObject.doc.numlights < 128:
self.mapObject.doc.render.setLight(self.light)
self.mapObject.doc.numlights += 1
self.hasLight = True
def addLight(self):
self.render.clearLight()
self.lightCenter = self.render.attachNewNode(PandaNode("center"))
#self.lightCenter.setCompass()
# ambient light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
self.alight = self.lightCenter.attachNewNode(self.ambientLight)
self.render.setLight(self.alight)
# point light
self.pointlight = PointLight("pLight")
self.light = self.lightCenter.attachNewNode(self.pointlight)
self.pointlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.light.setPos(0, 0, 2)
self.render.setLight(self.light)
# directional light
self.dirlight = DirectionalLight("dLight")
self.dlight = self.lightCenter.attachNewNode(self.dirlight)
self.dirlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.dirlight.setShadowCaster(True)
self.dlight.setPos(0, 0, 5)
self.dlight.lookAt(5, 10, 0)
self.render.setLight(self.dlight)
self.render.setShaderAuto()
def __init__(self):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -20, 5)
self.plane = self.loader.loadModel('my-models/planeTB')
self.plane.setPos(-5, 5, 0)
self.plane.reparentTo(self.render)
self.sphere = self.loader.loadModel("my-models/icosphere")
self.sphere.reparentTo(self.render)
alight = AmbientLight('alight')
alight.setColor((0.2, 0.2, 0.2, 1))
alnp = self.render.attachNewNode(alight)
self.plane.setLight(alnp)
plight = PointLight('plight')
plight.setColor((1, 1, 1, 1))
plnp = self.sphere.attachNewNode(plight)
self.plane.setLight(plnp)
self.render.setShaderAuto()
self.taskMgr.add(self.move_light, "move-light")
def __init__(self):
ShowBase.__init__(self)
simplepbr.init()
self.accept('escape', sys.exit)
self.accept('f11', self.debug)
m = loader.load_model("pbrcube.bam")
m.reparent_to(render)
# Camera
self.cam_gimbal = NodePath('gimbal')
self.cam_gimbal.reparent_to(render)
base.cam.reparent_to(self.cam_gimbal)
base.cam.set_pos(0, -10, 0)
base.cam.look_at(0, 0, 0)
self.add_task(self.update_camera)
# Light
light = PointLight('plight')
light.set_color((10, 10, 10, 10))
light.set_attenuation((1, 0, 1))
light_np = base.cam.attach_new_node(light)
render.set_light(light_np)
light_np.set_pos(0, 0, 2)
# Debug info
render.ls()
render.analyze()
def launch_panda_window(panda_widget, size):
"""
Configure and create Panda window
Connect to the gtk widget resize event
Load a panda
"""
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(*size)
props.setParentWindow(panda_widget.window.xid)
base.openDefaultWindow(props=props)
# ==
panda_widget.connect("size_allocate", resize_panda_window)
# ==
panda = loader.loadModel("panda")
panda.reparentTo(render)
panda.setPos(0, 40, -5)
pl = render.attachNewNode(PointLight("redPointLight"))
pl.node().setColor(Vec4(.9, .8, .8, 1))
render.setLight(pl)
pl.node().setAttenuation(Vec3(0, 0, 0.05))
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(2, 20, 0)
mid = PandaNode('mid')
panda.attachNewNode(mid)
# slnp.lookAt(mid)
render.setLight(slnp)
def setup_point_light(self, x, y, z):
plight = PointLight('plight')
plight.setColor(VBase4(0.9, 0.9, 0.9, 1))
light = self.base.render.attachNewNode(plight)
light.setPos(x, y, z)
self.point_light.append(light)
self.base.render.setLight(light)
def addPointLight(self, color=(0.2, 0.2, 0.2, 1), pos=(0, 0, 100)):
plight = PointLight('plight')
plight.setColor(color)
plnp = self.render.attachNewNode(plight)
plnp.setPos(pos)
self.render.setLight(plnp)
def addLight(self, id, parent, attenuation, position, color, specular,
stroboscopic, spot, lookat):
if spot:
slight = Spotlight(id)
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
light = render.attachNewNode(slight)
light.setPos(LVector3(position[0], position[1], position[2]))
if lookat == None:
light.lookAt(parent)
else:
light.lookAt(render.find("**/" + lookat))
else:
light = parent.attachNewNode(PointLight(id))
light.node().setAttenuation(attenuation)
light.setPos(LVector3(position[0], position[1], position[2]))
light.node().setColor(color)
light.node().setSpecularColor(specular)
render.setLight(light)
self.light_elements[id] = light
if stroboscopic:
self.stroboscopic_lights.append(id)
if id:
self.nodes_by_id[id] = light
return light
def load_scene(self):
self.scene_model = self.loader.loadModel("models/scene.egg")
self.scene_model.reparentTo(self.render)
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.1, 0.1, 0.1, 1))
self.alnp = self.render.attachNewNode(self.alight)
self.render.setLight(self.alnp)
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.5, 0.5, 0.5, 0.5))
self.dlnp = self.render.attachNewNode(self.dlight)
self.dlnp.setHpr(0, -60, 0)
self.render.setLight(self.dlnp)
self.plights = []
for position in [
[0, 0, 20],
# [10, 10, 20],
# [-10, 10, 20],
# [-10, -10, 20],
[10, -10, 20],
]:
plight = PointLight('plight_{}'.format(position))
plight.setColor(VBase4(0.4, 0.4, 0.4, 1))
plnp = self.render.attachNewNode(plight)
plnp.setPos(*position)
self.render.setLight(plnp)
self.plights.append(plight)
# self.camera.setPos(0, -20, 3)
self.trackball.node().setPos(0, 20, -3)
def _load_and_get_car_local(self, model_name):
car_local_node = self.app.loader.loadModel(model_name)
# translate model so that the bottom of it is at a height of 0 in the local reference frame
car_local_pos = car_local_node.getPos()
car_local_pos[2] = -car_local_node.getTightBounds()[0][2]
car_local_node.setPos(tuple(car_local_pos))
# cars need lights that are different from the scene lights
if model_name in ('camaro2', 'sport'):
ambient_color = (.1, .1, .1, 1)
sun_light_color = (.8, .8, .8, 1)
elif model_name == 'mazda6':
ambient_color = (.1, .1, .1, 1)
sun_light_color = (1, 1, 1, 1)
elif model_name == 'mitsubishi_lancer_evo':
ambient_color = (.2, .2, .2, 1)
sun_light_color = (1, 1, 1, 1)
else:
ambient_color = (.3, .3, .3, 1)
sun_light_color = (1, 1, 1, 1)
car_local_node.setLightOff()
ambient_light = self.app.render.attachNewNode(
AmbientLight('car_ambient_light'))
ambient_light.node().setColor(ambient_color)
car_local_node.setLight(ambient_light)
sun_light = self.app.render.attachNewNode(PointLight('car_sun_light'))
sun_light.node().setColor(sun_light_color)
sun_light.setPos((-2506., -634., 2596.))
car_local_node.setLight(sun_light)
car_local_node.flattenStrong()
return car_local_node
def _load_city(self):
try:
self.skybox_node = self.app.loader.loadModel(
"skyboxes/01-clean-day/skybox-mesh")
self.skybox_node.reparentTo(self.app.render)
self.skybox_node.flattenStrong()
except IOError:
print(
"Some models are missing. Skipping loading file skyboxes/01-clean-day/skybox-mesh"
)
self.skybox_node = None
try:
self.city_node = self.app.loader.loadModel(
"levels/urban-level-02-medium")
self.city_node.reparentTo(self.app.render)
self.ambient_light = self.app.render.attachNewNode(
AmbientLight('ambient_light'))
self.ambient_light.node().setColor((1, 1, 1, 1))
self.city_node.setLight(self.ambient_light)
self.sun_light = self.app.render.attachNewNode(
PointLight('sun_light'))
self.sun_light.node().setColor((.2, .2, .2, 1))
self.sun_light.setPos((-2506., -634., 2596.))
self.city_node.setLight(self.sun_light)
self.city_node.flattenStrong()
except IOError:
print(
"Some models are missing. Skipping loading file levels/urban-level-02-medium"
)
self.city_node = None
def __init__(self):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -12, 0)
self.tree = self.loader.loadModel('my-models/christmas_tree')
self.tree.setPos(0, 0, -2.5)
self.tree.reparentTo(self.render)
self.light_model = self.loader.loadModel('models/misc/sphere')
self.light_model.setScale(0.2, 0.2, 0.2)
self.light_model.setPos(4, 0, 0)
self.light_model.reparentTo(self.render)
plight = PointLight("plight")
plight.setColor((1,1,1,1))
self.plnp = self.light_model.attachNewNode(plight)
# plight.setAttenuation((0, 0, 1))
self.tree.setLight(self.plnp)
alight = AmbientLight("alight")
alight.setColor((0.04, 0.04, 0.04, 1))
alnp = self.render.attachNewNode(alight)
self.tree.setLight(alnp)
self.taskMgr.add(self.move_light, "move-light")
def initLights(self):
torches = self.level.findAllMatches("**/TorchTop*")
self.lights = []
for torch in torches:
tLight = PointLight(torch.getName())
tLight.setColor((.4, .2, .0, 1))
tlnp = render.attachNewNode(tLight)
tlnp.setPos(torch.getPos(render))
render.setLight(tlnp)
self.lights.append(tlnp)
windows = self.level.findAllMatches("**/Window*")
plates = self.level.findAllMatches("**/Plate*")
spikes = self.level.findAllMatches("**/Spikes*")
for window in windows:
wLight = Spotlight(window.getName())
lens = PerspectiveLens()
wLight.setLens(lens)
wLight.setColor((0.5, 0.4, 0.5, 1))
wlnp = render.attachNewNode(wLight)
wlnp.setPos(window.getPos(render))
wlnp.lookAt((0, window.getY(), 0))
for plate in plates:
plate.setLight(wlnp)
self.lights.append(wlnp)
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.1, .1, .025, 1))
render.setLight(render.attachNewNode(ambientLight))
def _load_quad(self):
self.quad_node = self.app.loader.loadModel('iris')
self.quad_node.reparentTo(self.app.render)
ambient_color = (.1, .1, .1, 1)
sun_light_color = (.5, .5, .5, 1)
self.quad_node.setLightOff()
ambient_light = self.app.render.attachNewNode(
AmbientLight('quad_ambient_light'))
ambient_light.node().setColor(ambient_color)
self.quad_node.setLight(ambient_light)
sun_light = self.app.render.attachNewNode(PointLight('quad_sun_light'))
sun_light.node().setColor(sun_light_color)
sun_light.setPos((-2506., -634., 2596.))
self.quad_node.setLight(sun_light)
self.quad_node.flattenStrong()
quad_prop_positions = [
np.array([0.20610, 0.13830, 0.025]), # blue, right
np.array([0.22254, -0.12507, 0.025]), # black, right
np.array([-0.20266, 0.13830, 0.025]), # blue, left
np.array([-0.21911, -0.12507, 0.025])
] # black, left
self.quad_prop_local_nodes = []
for quad_prop_id, quad_prop_pos in enumerate(quad_prop_positions):
is_ccw = quad_prop_id in (1, 2)
quad_prop_node = self.quad_node.attachNewNode('quad_prop_%d' %
quad_prop_id)
quad_prop_local_node = self.app.loader.loadModel(
'iris_prop_%s' % ('ccw' if is_ccw else 'cw'))
quad_prop_local_node.reparentTo(quad_prop_node)
quad_prop_node.setPos(tuple(quad_prop_pos))
quad_prop_node.flattenStrong()
self.quad_prop_local_nodes.append(quad_prop_local_node)
def setUpLights(self):
# ambient
#alight=AmbientLight("alight")
#alight.setColor(Vec4(Terrain.COLOR_AMB_50))
#alightP=self.base.render.attachNewNode(alight)
# point
plight = PointLight("plight")
plight.setColor(Vec4(Terrain.COLOR_WHITE))
self.plightP = self.base.render.attachNewNode(plight)
self.plightP.setPos(14, -30, 17)
# directional
# sun
sun = DirectionalLight("sun")
sun.setColor(Vec4(Terrain.COLOR_WHITE))
#sun.setShadowCaster(True, 1024, 1024)
sun.getLens().setFilmSize(Vec2(100, 100))
sun.getLens().setNearFar(10, 200)
sun.getLens().setFov(200)
#sun.showFrustum()
sunP = self.base.render.attachNewNode(sun)
sunP.setPos(0, -2, 20)
sunP.setHpr(-60, -90, -30)
# sky
sunSky = DirectionalLight("sunSky")
sunSky.setColor(Vec4(Terrain.COLOR_WHITE))
sunSkyP = self.base.render.attachNewNode(sunSky)
sunSkyP.setPos(-14, 30, -17)
sunSkyP.setHpr(-10, 60, -10)
#
#self.base.render.setLight(alightP)
self.base.render.setLight(sunP)
self.base.render.setLight(self.plightP)
def setupLights(self):
panda = self.app.panda
panda.setBackgroundColor(.9, .9, .9, 1)
panda.render.clearLight()
keylight = Spotlight('keylight')
keylight.setLens(PerspectiveLens())
np = self._insertLight(
keylight,
colour=(1, 1, 1, 1),
pos=(0, -5, 2),
)
np.lookAt((0, 0, 0.9))
# Turn off shadows until we have fix for
# https://bugs.launchpad.net/panda3d/+bug/1212752
# keylight.setShadowCaster(True, 512, 512)
sunlight = PointLight('sunlight')
self._insertLight(
sunlight,
colour=(1, 1, 1, 1),
pos=(1, -2, 20),
)
self._insertLight(
AmbientLight('ambientLight'),
colour=(.25, .25, .25, 1),
)
def __init__(self):
# Basics
ShowBase.__init__(self)
base.disableMouse()
base.setFrameRateMeter(True)
self.accept("escape", sys.exit)
self.camera.set_pos(-10, -10, 10)
self.camera.look_at(0, 0, 0)
# A light
plight = PointLight('plight')
plight.setColor(VBase4(0.5, 0.5, 0.5, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(10, 10, 10)
render.setLight(plnp)
# Create the geometry
self.sidelength = 30
self.map_a = self.create_map(self.sidelength)
self.map_b = self.map_a
geom = self.create_geom(self.sidelength)
np = NodePath(geom)
np.reparent_to(self.render)
# Start the task to interpolate the geometry each frame
self.last_time = 0.0
self.need_to_swap_maps = True
self.taskMgr.add(self.swap_maps, 'swap_geometry', sort = 5)
self.taskMgr.add(self.interpolate_maps, 'interpolate_geometry', sort = 10)
def insertLight(self, name, x, y, z):
lightball = self.loader.loadModel("lightball_1.obj", noCache=True)
lightball.reparentTo(self.render)
lightball.setPos(x, y, z)
plight = PointLight(name)
plight.setColor(VBase4(1.0, 1.0, 1.0, 1))
plnp = self.render.attachNewNode(plight)
plnp.setPos(x, y, z)
self.render.setLight(plnp)
def __init__(self, **kwargs):
self.type = 'ambient' # ambient or directional for now
self.color = color.rgb(0.3, 0.3, 0.3,
1) # a modest amount of full-spectrum light
self.direction = Vec3(
-1, -1, -1) # shining down from top-right corner, behind camera
self.position = None
self.attenuation = None
self.node = None
for key, value in kwargs.items():
if key == 'type':
if value in ('ambient', 'directional', 'point'):
self.type = value
else:
print("ERR Light type is not 'ambient' or 'directional'")
elif key == 'color':
self.color = value
elif key == 'direction':
self.direction = value
elif key == 'attenuation':
self.attenuation = value
elif key == 'position':
self.position = value
else:
print("Err ", key, " is not a valid keyword")
scene.lights.append(self) # light added for all subsequent entities
if self.type == 'ambient':
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(self.color)
self.node = scene.attachNewNode(ambientLight)
elif self.type == 'directional':
directionalLight = DirectionalLight('directionalLight')
directionalLight.setColor(self.color)
self.node = scene.attachNewNode(directionalLight)
# This light should be facing straight down, but clearly it isn't.
self.node.setHpr(
self.direction) # convert vector to Hpr (in degrees!?) first
elif self.type == 'point':
pointLight = PointLight('pointLight')
pointLight.setColor(self.color)
if self.attenuation is None:
self.attenuation = Vec3(1, 0, 0)
pointLight.setAttenuation(self.attenuation)
if self.position is None:
self.position = Vec3(0, 0, 0)
self.node = scene.attachNewNode(pointLight)
self.node.setPos(self.position)
def __init__(self):
ShowBase.__init__(self)
dir(self)
self.disableMouse()
# Load the environment model.
self.environ = self.loader.loadModel("../levels/level01.egg")
# Reparent the model to render.
self.environ.reparentTo(self.render)
'''add a light'''
self.light = PointLight("dLight")
self.light.setAttenuation((.01, .01, .01))
self.light.setSpecularColor(VBase4(1, 1, 0, 1))
self.lightNode = render.attachNewNode(self.light)
self.lightNode.setZ(10)
render.setLight(self.lightNode)
'''move light constants'''
self.moveLightDirection = -1000
self.taskMgr.add(self.moveLight, "lightMove")
self.taskMgr.add(self.fpsInput, "fpsInput")
'''fps cam controls'''
self.keymap = {
"w": 0,
"a": 0,
"s": 0,
"d": 0,
"e": 0,
"q": 0,
"j": 0,
"k": 0,
"l": 0,
"i": 0
}
self.fps = FpsCam(self.camera)
self.accept("a", self.setKey, ["a", 1])
self.accept("a-up", self.setKey, ['a', 0])
self.accept("w", self.setKey, ["w", 1])
self.accept("w-up", self.setKey, ["w", 0])
self.accept("s", self.setKey, ["s", 1])
self.accept("s-up", self.setKey, ["s", 0])
self.accept("d", self.setKey, ["d", 1])
self.accept("d-up", self.setKey, ["d", 0])
self.accept("e", self.setKey, ["e", 1])
self.accept("e-up", self.setKey, ["e", 0])
self.accept("q", self.setKey, ["q", 1])
self.accept("q-up", self.setKey, ["q", 0])
self.accept("j", self.setKey, ["j", 1])
self.accept("j-up", self.setKey, ["j", 0])
self.accept("k", self.setKey, ["k", 1])
self.accept("k-up", self.setKey, ["k", 0])
self.accept("l", self.setKey, ["l", 1])
self.accept("l-up", self.setKey, ["l", 0])
self.accept("i", self.setKey, ["i", 1])
self.accept("i-up", self.setKey, ["i", 0])
self.accept("escape", sys.exit)
def __init__(self, showbase, usersData, gameData):
DirectObject.__init__(self)
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
self.ambientLight = showbase.render.attachNewNode(
AmbientLight("ambientLight"))
# Set the color of the ambient light
self.ambientLight.node().setColor((.1, .1, .1, 1))
# add the newly created light to the lightAttrib
# showbase.render.setLight(self.ambientLight)
self.spotlight = None
numberOfPlayers = len(self.usersData)
for index, user in enumerate(self.usersData):
user.centipede = Centipede(showbase, index, numberOfPlayers,
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.spotlight = self.centipede.head.attachNewNode(
PointLight("playerSpotlight"))
self.spotlight.setPos(LVector3(0, 0, 8))
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight.node().setAttenuation(
LVector3(.025, 0.0005, 0.0001))
self.spotlight.node().setColor((0.35, 0.35, .35, 1))
self.spotlight.node().setSpecularColor((0.01, 0.01, 0.01, 1))
showbase.render.setLight(self.spotlight)
self.perPixelEnabled = True
self.shadowsEnabled = True
#if self.spotlight:
# self.spotlight.node().setShadowCaster(True, 512, 512)
showbase.render.setShaderAuto()
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
def pointlight(self, x, y, z):
"""
Erzeugt einen Schatten, je nach Position der Sonne
:return: die Schattierung des Planeten
"""
plight = PointLight('plight')
plight.setColor(VBase4(0.8, 0.8, 0.8, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(x, y, z)
return plnp
def __init__(self):
# Basics
ShowBase.__init__(self)
#base.disableMouse()
base.setFrameRateMeter(True)
self.accept("escape", sys.exit)
self.camera.set_pos(-10, -10, 10)
self.camera.look_at(0, 0, 0)
# A light
plight = PointLight("plight")
plight.setColor(VBase4(1, 1, 1, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(100, 100, 100)
render.setLight(plnp)
# Create the geometry
vformat = GeomVertexFormat.getV3n3c4()
vdata = GeomVertexData("Data", vformat, Geom.UHStatic)
vdata.setNumRows(3)
vertex = GeomVertexWriter(vdata, 'vertex')
normal = GeomVertexWriter(vdata, 'normal')
color = GeomVertexWriter(vdata, 'color')
vertex.addData3f(100, 0, 0)
normal.addData3f(0, 0, 1)
color.addData4f(0, 1, 0, 1)
vertex.addData3f(100, 100, 0)
normal.addData3f(0, 0, 1)
color.addData4f(0, 0, 1, 1)
vertex.addData3f(0, 100, 0)
normal.addData3f(0, 0, 1)
color.addData4f(1, 0, 0, 1)
prim = GeomTriangles(Geom.UHStatic)
prim.addVertices(0, 1, 2)
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode("GNode")
node.addGeom(geom)
nodePath = self.render.attachNewNode(node)
def makePointLight(name, color, pos, falloff=1.0):
point = PointLight(name + "-point")
point.setColor(color)
ATTN_FCTR = 0.0625
point.setAttenuation((0, 0, falloff * ATTN_FCTR))
pnp = render.attachNewNode(point)
pnp.setPos(pos)
if False:
sm = loader.loadModel("models/smiley.egg.pz")
sm.reparentTo(pnp)
return pnp
def __init__(self):
super().__init__(self)
self.var1 = 0
self.scene = loader.loadModel("models/world")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
self.player = self.scene.find("player")
self.player.setTexture(playerTexture)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
self.enemy = self.scene.find("enemy1")
self.enemy.setTexture(enemyTexture)
self.basePlane = self.scene.find("basePlane")
self.scene.reparentTo(self.render)
self.player.setPos(50, 50, 3)
self.enemy.setPos(50, 55, 0)
self.ambient = AmbientLight("ambient")
self.ambient.color = (0.1, 0.1, 0.1, 1)
self.ambientPath = self.render.attachNewNode(self.ambient)
render.setLight(self.ambientPath)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (1, 1, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(0, -90, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
self.pointLight = PointLight("point light")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(50, 52.5, 4)
self.pointLight.attenuation = (.5, 0, 0)
self.pointLight.setShadowCaster(True, 1024, 1024)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 300)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large")
filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1)
filters.setCartoonInk(separation=2, color=(0, 0, 0, 1))
self.taskMgr.add(self.update, "update")
def innitialize_fov(self):
render.set_shader_auto()
self.fov_point = PointLight("caster")
self.fov_point.set_shadow_caster(True, 256*2, 256*2, -1000)
self.fov_point.set_camera_mask(0b001)
self.fov_point.set_lens_active(4, False)
self.fov_point.set_lens_active(5, False)
for i in range(6):
self.fov_point.get_lens(i).set_near_far(0.5, 10)
self.fov_point_np = render.attach_new_node(self.fov_point)
self.fov_point_np.set_z(0.5)
self.fov_point.set_color(VBase4(1,1,1,1))
