def add_light(self):
x, y = random.choice(list(self.world.columns()))
for z in reversed(range(self.world.depth)):
b = self.world.get_block(x, y, z)
if not b.is_void:
p = core.PointLight('pl-{}-{}-{}'.format(x, y, z))
p.setAttenuation(Point3(0, 0, 0.4))
pn = self.render.attachNewNode(p)
pn.setPos(x, y, z + 3)
self.render.setLight(pn)
def test_light_colortemp():
# Default is all white, assuming a D65 white point.
light = core.PointLight("light")
assert light.color == (1, 1, 1, 1)
assert light.color_temperature == 6500
# When setting color temp, it should preserve luminance.
for temp in range(2000, 15000):
light.color_temperature = temp
assert abs(luminance(light.color) - 1.0) < 0.001
# Setting it to the white point will make a white color.
light.color_temperature = 6500
assert light.color.almost_equal((1, 1, 1, 1), 0.001)
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
simplepbr.init()
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile, noCache=True)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.accept('w', self.toggle_wireframe)
self.accept('t', self.toggle_texture)
self.accept('shift-l', self.model_root.ls)
self.accept('shift-a', self.model_root.analyze)
if not self.model_root.find('**/+Light'):
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(-5, 5, 5)
self.render.set_light(self.light)
self.cam.set_pos(-6, 6, 6)
self.cam.look_at(self.model_root)
self.model_root.reparent_to(self.render)
if self.model_root.find('**/+Character'):
self.anims = p3d.AnimControlCollection()
p3d.autoBind(self.model_root.node(), self.anims, ~0)
if self.anims.get_num_anims() > 0:
self.anims.get_anim(0).loop(True)
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
self.setup_shaders(self.render)
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(-5, 5, 5)
self.render.set_light(self.light)
self.cam.set_pos(-10, 10, 10)
if self.model_root.find('**/+Character'):
self.actor = Actor(self.model_root)
self.actor.reparent_to(self.render)
anims = self.actor.get_anim_names()
if anims:
self.actor.loop(anims[0])
self.cam.look_at(self.actor)
else:
self.model_root.reparent_to(self.render)
self.cam.look_at(self.model_root)
def start(self):
# The main initialization of our class
# This creates the on screen title that is in every tutorial
self.title = OnscreenText(text="Panda3D: Tutorial - Lighting",
style=1, fg=(1, 1, 0, 1), shadow=(0, 0, 0, 0.5),
pos=(0.87, -0.95), scale = .07)
# Creates labels used for onscreen instructions
self.ambientText = self.makeStatusLabel(0)
self.directionalText = self.makeStatusLabel(1)
self.spotlightText = self.makeStatusLabel(2)
self.pointLightText = self.makeStatusLabel(3)
self.spinningText = self.makeStatusLabel(4)
self.ambientBrightnessText = self.makeStatusLabel(5)
self.directionalBrightnessText = self.makeStatusLabel(6)
self.spotlightBrightnessText = self.makeStatusLabel(7)
self.spotlightExponentText = self.makeStatusLabel(8)
self.lightingPerPixelText = self.makeStatusLabel(9)
self.lightingShadowsText = self.makeStatusLabel(10)
self.disco = self.loader.loadModel("disco_lights_models/disco_hall")
self.disco.reparentTo(self.render)
self.disco.setPosHpr(0, 50, -4, 90, 0, 0)
# First we create an ambient light. All objects are affected by ambient
# light equally
# Create and name the ambient light
self.ambientLight = self.render.attachNewNode(p3dc.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
# Now we create a directional light. Directional lights add shading from a
# given angle. This is good for far away sources like the sun
self.directionalLight = self.render.attachNewNode(
p3dc.DirectionalLight("directionalLight"))
self.directionalLight.node().setColor((.35, .35, .35, 1))
# The direction of a directional light is set as a 3D vector
self.directionalLight.node().setDirection(p3dc.LVector3(1, 1, -2))
# These settings are necessary for shadows to work correctly
self.directionalLight.setZ(6)
dlens = self.directionalLight.node().getLens()
dlens.setFilmSize(41, 21)
dlens.setNearFar(50, 75)
# self.directionalLight.node().showFrustum()
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight = self.camera.attachNewNode(p3dc.Spotlight("spotlight"))
self.spotlight.node().setColor((.45, .45, .45, 1))
self.spotlight.node().setSpecularColor((0, 0, 0, 1))
# The cone of a spotlight is controlled by it's lens. This creates the lens
self.spotlight.node().setLens(p3dc.PerspectiveLens())
# This sets the Field of View (fov) of the lens, in degrees for width
# and height. The lower the numbers, the tighter the spotlight.
self.spotlight.node().getLens().setFov(16, 16)
# Attenuation controls how the light fades with distance. The three
# values represent the three attenuation constants (constant, linear,
# and quadratic) in the internal lighting equation. The higher the
# numbers the shorter the light goes.
self.spotlight.node().setAttenuation(p3dc.LVector3(1, 0.0, 0.0))
# This exponent value sets how soft the edge of the spotlight is.
# 0 means a hard edge. 128 means a very soft edge.
self.spotlight.node().setExponent(60.0)
# Now we create three colored Point lights. Point lights are lights that
# radiate from a single point, like a light bulb. Like spotlights, they
# are given position by attaching them to NodePaths in the world
self.redHelper = self.loader.loadModel('disco_lights_models/sphere')
self.redHelper.setColor((1, 0, 0, 1))
self.redHelper.setPos(-6.5, -3.75, 0)
self.redHelper.setScale(.25)
self.redPointLight = self.redHelper.attachNewNode(
p3dc.PointLight("redPointLight"))
self.redPointLight.node().setColor((.35, 0, 0, 1))
self.redPointLight.node().setAttenuation(p3dc.LVector3(.1, 0.04, 0.0))
# The green point light and helper
self.greenHelper = self.loader.loadModel('disco_lights_models/sphere')
self.greenHelper.setColor((0, 1, 0, 1))
self.greenHelper.setPos(0, 7.5, 0)
self.greenHelper.setScale(.25)
self.greenPointLight = self.greenHelper.attachNewNode(
p3dc.PointLight("greenPointLight"))
self.greenPointLight.node().setAttenuation(p3dc.LVector3(.1, .04, .0))
self.greenPointLight.node().setColor((0, .35, 0, 1))
# The blue point light and helper
self.blueHelper = self.loader.loadModel('disco_lights_models/sphere')
self.blueHelper.setColor((0, 0, 1, 1))
self.blueHelper.setPos(6.5, -3.75, 0)
self.blueHelper.setScale(.25)
self.bluePointLight = self.blueHelper.attachNewNode(
p3dc.PointLight("bluePointLight"))
self.bluePointLight.node().setAttenuation(p3dc.LVector3(.1, 0.04, 0.0))
self.bluePointLight.node().setColor((0, 0, .35, 1))
self.bluePointLight.node().setSpecularColor((1, 1, 1, 1))
# Create a dummy node so the lights can be spun with one command
self.pointLightHelper = self.render.attachNewNode("pointLightHelper")
self.pointLightHelper.setPos(0, 50, 11)
self.redHelper.reparentTo(self.pointLightHelper)
self.greenHelper.reparentTo(self.pointLightHelper)
self.blueHelper.reparentTo(self.pointLightHelper)
# Finally we store the lights on the root of the scene graph.
# This will cause them to affect everything in the scene.
self.render.setLight(self.ambientLight)
self.render.setLight(self.directionalLight)
self.render.setLight(self.spotlight)
self.render.setLight(self.redPointLight)
self.render.setLight(self.greenPointLight)
self.render.setLight(self.bluePointLight)
# Create and start interval to spin the lights, and a variable to
# manage them.
self.pointLightsSpin = self.pointLightHelper.hprInterval(
6, p3dc.LVector3(360, 0, 0))
self.pointLightsSpin.loop()
self.arePointLightsSpinning = True
# Per-pixel lighting and shadows are initially off
self.perPixelEnabled = False
self.shadowsEnabled = False
# listen to keys for controlling the lights
self.accept("escape", sys.exit)
self.accept("a", self.toggleLights, [[self.ambientLight]])
self.accept("d", self.toggleLights, [[self.directionalLight]])
self.accept("s", self.toggleLights, [[self.spotlight]])
self.accept("p", self.toggleLights, [[self.redPointLight,
self.greenPointLight,
self.bluePointLight]])
self.accept("r", self.toggleSpinningPointLights)
self.accept("l", self.togglePerPixelLighting)
self.accept("e", self.toggleShadows)
self.accept("z", self.addBrightness, [self.ambientLight, -.05])
self.accept("x", self.addBrightness, [self.ambientLight, .05])
self.accept("c", self.addBrightness, [self.directionalLight, -.05])
self.accept("v", self.addBrightness, [self.directionalLight, .05])
self.accept("b", self.addBrightness, [self.spotlight, -.05])
self.accept("n", self.addBrightness, [self.spotlight, .05])
self.accept("q", self.adjustSpotlightExponent, [self.spotlight, -1])
self.accept("w", self.adjustSpotlightExponent, [self.spotlight, 1])
# Finally call the function that builds the instruction texts
self.updateStatusLabel()
def __init__(self):
if len(sys.argv) < 2:
print("Missing input file")
sys.exit(1)
super().__init__()
self.pipeline = simplepbr.init()
gltf.patch_loader(self.loader)
infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1]))
p3d.get_model_path().prepend_directory(infile.get_dirname())
self.model_root = self.loader.load_model(infile, noCache=True)
self.accept('escape', sys.exit)
self.accept('q', sys.exit)
self.accept('w', self.toggle_wireframe)
self.accept('t', self.toggle_texture)
self.accept('n', self.toggle_normal_maps)
self.accept('e', self.toggle_emission_maps)
self.accept('o', self.toggle_occlusion_maps)
self.accept('a', self.toggle_ambient_light)
self.accept('shift-l', self.model_root.ls)
self.accept('shift-a', self.model_root.analyze)
self.model_root.reparent_to(self.render)
bounds = self.model_root.getBounds()
center = bounds.get_center()
if bounds.is_empty():
radius = 1
else:
radius = bounds.get_radius()
fov = self.camLens.get_fov()
distance = radius / math.tan(math.radians(min(fov[0], fov[1]) / 2.0))
self.camLens.set_near(min(self.camLens.get_default_near(), radius / 2))
self.camLens.set_far(max(self.camLens.get_default_far(), distance + radius * 2))
trackball = self.trackball.node()
trackball.set_origin(center)
trackball.set_pos(0, distance, 0)
trackball.setForwardScale(distance * 0.006)
# Create a light if the model does not have one
if not self.model_root.find('**/+Light'):
self.light = self.render.attach_new_node(p3d.PointLight('light'))
self.light.set_pos(0, -distance, distance)
self.render.set_light(self.light)
# Move lights to render
self.model_root.clear_light()
for light in self.model_root.find_all_matches('**/+Light'):
light.parent.wrt_reparent_to(self.render)
self.render.set_light(light)
# Add some ambient light
self.ambient = self.render.attach_new_node(p3d.AmbientLight('ambient'))
self.ambient.node().set_color((.2, .2, .2, 1))
self.render.set_light(self.ambient)
if self.model_root.find('**/+Character'):
self.anims = p3d.AnimControlCollection()
p3d.autoBind(self.model_root.node(), self.anims, ~0)
if self.anims.get_num_anims() > 0:
self.anims.get_anim(0).loop(True)
def construct(self):
self.light = core.PointLight('plight')
self.light.setColor(self.color)
from panda3d import core
# Some dummy lights we can use for our light attributes.
spot = core.NodePath(core.Spotlight("spot"))
point = core.NodePath(core.PointLight("point"))
ambient = core.NodePath(core.AmbientLight("ambient"))
def test_lightattrib_compose_add():
# Tests a case in which a child node adds another light.
lattr1 = core.LightAttrib.make()
lattr1 = lattr1.add_on_light(spot)
lattr2 = core.LightAttrib.make()
lattr2 = lattr2.add_on_light(point)
lattr3 = lattr1.compose(lattr2)
assert lattr3.get_num_on_lights() == 2
assert spot in lattr3.on_lights
assert point in lattr3.on_lights
def test_lightattrib_compose_subtract():
# Tests a case in which a child node disables a light.
lattr1 = core.LightAttrib.make()
lattr1 = lattr1.add_on_light(spot)
lattr1 = lattr1.add_on_light(point)
lattr2 = core.LightAttrib.make()
lattr2 = lattr2.add_off_light(ambient)