def setupLights(self):
"""Setup extrnal lights"""
# ambient light
alight = AmbientLight('alight')
alight.setColor((0.2, 0.2, 0.2, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# directional light
dlight = DirectionalLight('dlight')
dlight.setColor((0.8, 0.8, 0.5, 1))
lens = PerspectiveLens()
lens.setNearFar(1, 5)
dlight.setLens(lens)
dlight.setShadowCaster(True, args.shadow_resolution,
args.shadow_resolution)
dlnp = self.render.attachNewNode(dlight)
dlnp.setPos(2, -2, 3)
dlnp.lookAt(0, 0, 0)
self.render.setLight(dlnp)
# spotlight
slight = Spotlight('slight')
slight.setColor((0.7, 0.7, 1.0, 1))
lens = PerspectiveLens()
lens.setNearFar(1, 5)
slight.setLens(lens)
slight.setShadowCaster(True, args.shadow_resolution,
args.shadow_resolution)
slnp = self.render.attachNewNode(slight)
slnp.setPos(1, 1, 2)
slnp.lookAt(0, 0, 0)
self.render.setLight(slnp)
def __setDirectionalLight(self, props):
light = DirectionalLight(props['name'])
light.setShadowCaster(props['castShadows'], 1024, 1024)
lens = PerspectiveLens()
light.setLens(lens)
lens.setFov(1200 / props['pos'].z)
return self.__createLight(light, props)
def _set_general_lights(self, train_np):
"""Set initial Sun lights.
Args:
train_np (panda3d.core.NodePath): Train node.
Returns:
panda3d.core.AmbientLight: Sun ambient light.
panda3d.core.DirectionalLight: Sun directional light.
panda3d.core.NodePath: NodePath of the Sun.
"""
amb_light = AmbientLight("sun_amb")
amb_light.setColor(self._color["amb"])
render.setLight(render.attachNewNode(amb_light)) # noqa: F821
lens = PerspectiveLens()
lens.setNearFar(1, 100)
lens.setFov(20, 20)
sun_light = Spotlight("sun_dir")
sun_light.setColor(self._color["dir"])
sun_light.setShadowCaster(True, 8192, 8192, sort=-2000)
sun_light.setLens(lens)
sun_light.setExponent(0.5)
sun_light.setCameraMask(0b0001)
sun_np = train_np.attachNewNode(sun_light)
render.setLight(sun_np) # noqa: F821
return amb_light, sun_light, sun_np
def test_perspectivelens_project():
lens = PerspectiveLens()
lens.set_fov(90, 90)
lens.set_near_far(0.5, 100)
point = Point2()
assert not lens.project((0, 0, 0), point)
assert not lens.project((-1, 0.5, 0), point)
assert lens.project((0, 0.5, 0), point)
assert point.almost_equal((0, 0), 0.001)
assert lens.project((0, 100, 0), point)
assert point.almost_equal((0, 0), 0.001)
assert lens.project((-0.5, 0.5, -0.5), point)
assert point.almost_equal((-1, -1), 0.001)
assert lens.project((-100, 100, -100), point)
assert point.almost_equal((-1, -1), 0.001)
assert lens.project((0.5, 0.5, 0), point)
assert point.almost_equal((1, 0), 0.001)
assert lens.project((100, 100, 0), point)
assert point.almost_equal((1, 0), 0.001)
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 setupPerspectiveLens(self, near=0.1, far=100.0, fov=(90, 90)):
self.lens = PerspectiveLens()
self.lens.setNearFar(near, far)
self.lens.setFov(fov[0], fov[1])
self.camera.setLens(self.lens)
self.nearPlane = near
self.farPlane = far
def generate(self):
self.level = 12
self.maxHealth = 200
self.health = 200
Suit.generate(self,
FactorySneakGuardSuit.SUIT,
FactorySneakGuardSuit.VARIANT,
hideFirst=False)
self.setName(self.suitPlan.getName(), None)
self.cleanupPropeller()
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4. / 3.))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def generate(self):
data = CIGlobals.SuitBodyData[self.SUIT]
type = data[0]
team = data[1]
self.team = team
self.level = 12
self.suit = type
Suit.generate(self, SuitBank.MrHollywood, 0, hideFirst=False)
self.suit = type
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def __init__(self, manager, xml):
self.light = PSpotLight('slight')
lens = PerspectiveLens()
self.light.setLens(lens)
self.lightNode = render.attachNewNode(self.light)
self.reload(manager, xml)
def set_lens(self, lens_type="OrthographicLens"):
"""
Permite cambiar la lente de la camara
:param lens_type: El tipo de lente a utilizar: OrthographicLens/PerspectiveLens
:return: None
"""
self.lens_type = lens_type
width = self.panda3d.win.getXSize()
height = self.panda3d.win.getYSize()
if lens_type is "OrthographicLens":
lens = OrthographicLens()
lens.setFilmSize(width, height )
if lens_type is "PerspectiveLens":
lens = PerspectiveLens()
lens.setFilmSize(width , height )
else:
# Default value
lens = OrthographicLens()
lens.setFilmSize(width / 100, height / 100)
print("new lens {}: {} {}".format(lens_type, width / 100, height / 100))
print(lens)
self.panda3d.cam.node().setLens(lens)
shader_control = self.panda3d.shader_control
if shader_control is not None:
shader_control.update_camera_lens(lens)
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 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 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 debugCamera():
global PERSPECTIVE
PERSPECTIVE = True
sandbox.base.enableMouse()
lens = PerspectiveLens()
sandbox.base.cam.node().setLens(lens)
sandbox.base.cam.setPos(0, 0, 0)
def set_up(self):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.perspective_lens = base.camLens # use panda3d's default for automatic aspect ratio on window resize
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(window.aspect_ratio)
self.perspective_lens_node = LensNode('perspective_lens_node',
self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio,
self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node',
self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40 # horizontal fov
# self.fov = 22.5
self.clip_plane_near = 0.1
self.clip_plane_far = 10000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
# moved set_film_size() to window module for correct aspect ratio after setting window size
self.ui_lens.set_near_far(-1000, 1000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
self.ui_render = NodePath('ui_render')
self.ui_render.set_depth_test(0)
self.ui_render.set_depth_write(0)
self.ui_camera.reparent_to(self.ui_render)
self.ui_display_region.set_camera(self.ui_camera)
scene.ui_camera = self.ui_camera
self.ui = Entity(eternal=True,
name='ui',
parent=self.ui_camera,
scale=(self.ui_size * .5, self.ui_size * .5))
self.overlay = Entity(parent=self.ui,
model='quad',
scale=99,
color=color.clear,
eternal=True,
z=-99)
# these get created when setting a shader
self.filter_manager = None
self.filter_quad = None
self.render_texture = None
self.filter_quad = None
self.depth_texture = None
def toggle_flashlight():
current_flashlight = self.render.find_all_matches("**/flashlight")
if self.flashlight_state == 0:
if len(current_flashlight) == 0:
self.slight = 0
self.slight = Spotlight('flashlight')
self.slight.set_shadow_caster(True, 1024, 1024)
self.slight.set_color(VBase4(0.5, 0.6, 0.6,
1)) # slightly bluish
lens = PerspectiveLens()
lens.set_near_far(0.5, 5000)
self.slight.set_lens(lens)
self.slight.set_attenuation((0.5, 0, 0.0000005))
self.slight = self.render.attach_new_node(self.slight)
self.slight.set_pos(-0.1, 0.3, -0.4)
self.slight.reparent_to(self.camera)
self.flashlight_state = 1
self.render.set_light(self.slight)
elif len(current_flashlight) > 0:
self.render.set_light(self.slight)
self.flashlight_state = 1
elif self.flashlight_state > 0:
self.render.set_light_off(self.slight)
self.flashlight_state = 0
def __init__(self):
ShowBase.__init__(self)
props = WindowProperties()
props.setTitle("Big Bang")
self.win.requestProperties(props)
self.win.setClearColor((0, 0, 0, 1))
self.disableMouse()
self.locked = False
lens = PerspectiveLens()
lens.set_fov(70)
lens.setNear(0.01)
self.cam.node().setLens(lens)
render.setAntialias(AntialiasAttrib.MMultisample)
b=OnscreenImage(parent=render2d, image="space.png")
base.cam.node().getDisplayRegion(0).setSort(20)
loader = Loader(self)
bang = loader.loadModel("sphere.obj")
bang.setScale((0.15, 0.15, 0.15))
pos = (0, 4, 0)
bang.setPos(pos)
bang.reparentTo(render)
sizeInterval1 = bang.scaleInterval(3,
Point3(5, 5, 5),
startScale=Point3(0.001, 0.001, 0.001))
sizeInterval2 = bang.scaleInterval(0.1,
Point3(0.001, 0.001, 0.001),
startScale=Point3(5,5,5))
sizeInterval3 = bang.scaleInterval(1,
Point3(0.001, 0.001, 0.001),
startScale=Point3(0.001, 0.001, 0.001))
sizeInterval4 = bang.scaleInterval(0.1,
Point3(0.1, 0.1, 1),
startScale=Point3(0.1, 0.1, 0.1))
sizeInterval5 = bang.scaleInterval(0.1,
Point3(1, 0.1, 0.1),
startScale=Point3(0.1, 0.1, 0.1))
#posInterval1 = bang.posInterval(3,
# Point3(0, 8, 0),
# startPos=Point3(pos))
#posInterval2 = bang.posInterval(0.1,
# Point3(pos),
# startPos=Point3(0, 8, 0))
#posInterval3 = bang.posInterval(1,
# Point3(pos),
# startPos=Point3(pos))
#posInterval4 = bang.posInterval(0.1,
# Point3(pos),
# startPos=Point3(pos))
grow = Sequence(sizeInterval1, sizeInterval2, sizeInterval3, sizeInterval4, sizeInterval5,
name="grow")
grow.loop()
#move = Sequence(posInterval1, posInterval2, posInterval3, posInterval4, posInterval4,
# name="move")
#move.loop()
self.accept("e", self.lockMouse)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.cameraControl, "CameraControl")
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
def create(self):
Level.create(self)
# reset game vars when going to main menu
self.level_holder.reset_game_vars()
self.sprites = loader.loadModel("mainmenu/mainmenu.egg")
# red pawn
pawn_red = Actor("pawns/pawn.bam")
pawn_red.setPos(-4, 20, -2)
pawn_red.setH(-145)
pawn_red.loop('breath')
self.actors["actor_pawn_red"] = pawn_red
# red pawn light
dlight_red = DirectionalLight('DL Red')
dlight_red.setColor((0.682 / 1.5, 0.125 / 1.5, 0.121 / 1.5, 1))
dlight_red.setLens(PerspectiveLens())
dlight_red_np = render.attachNewNode(dlight_red)
self.lights["dlight_red_np"] = dlight_red_np
self.lights["dlight_red_np"].setPos(10, 15, 10)
self.lights["dlight_red_np"].lookAt(self.actors["actor_pawn_red"])
# white pawn
pawn_white = Actor("pawns/pawn.bam")
pawn_white.setPos(4, 20, -2)
pawn_white.setH(145)
pawn_white.loop('breath')
self.actors["actor_pawn_white"] = pawn_white
# light
dlight_white = DirectionalLight('DL White')
dlight_white.setColor((0.9 / 2.5, 0.9 / 2.5, 0.9 / 2.5, 1))
dlight_white.setLens(PerspectiveLens())
dlight_white_np = render.attachNewNode(dlight_white)
self.lights["dlight_white_np"] = dlight_white_np
self.lights["dlight_white_np"].setPos(-10, 15, 10)
self.lights["dlight_white_np"].lookAt(self.actors["actor_pawn_white"])
# upon creation, enable these items
self.actors["actor_pawn_red"].reparentTo(render)
self.actors["actor_pawn_red"].setLight(self.lights["dlight_red_np"])
self.actors["actor_pawn_white"].reparentTo(render)
self.actors["actor_pawn_white"].setLight(
self.lights["dlight_white_np"])
self.goto_home()
def test_perspectivelens_near_inf():
lens = PerspectiveLens()
lens.set_fov(90, 90)
lens.set_near_far(float("inf"), 2)
lens.coordinate_system = CS_zup_right
mat = lens.get_projection_mat()
assert mat[1][2] == -1
assert mat[3][2] == 4
def aspect_ratio(self, value):
self.perspective_lens = PerspectiveLens()
self.perspective_lens.set_aspect_ratio(value)
application.base.cam.node().set_lens(self.perspective_lens)
self.ui_lens.set_film_size(self.ui_size * .5 * value, self.ui_size * .5)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
print('setting camera aspect ratio')
def set_up(self, use_filters=True):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(window.aspect_ratio)
self.perspective_lens.set_focal_length(50)
self.perspective_lens_node = LensNode('perspective_lens_node',
self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio,
self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node',
self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40
self.clip_plane_near = 0.0001
self.clip_plane_far = 70000000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
self.ui_lens.set_film_size(self.ui_size * .5 * self.aspect_ratio,
self.ui_size * .5)
self.ui_lens.set_near_far(-1000, 70000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
self.ui_render = NodePath('ui_render')
self.ui_render.set_depth_test(0)
self.ui_render.set_depth_write(0)
self.ui_camera.reparent_to(self.ui_render)
self.ui_display_region.set_camera(self.ui_camera)
scene.ui_camera = self.ui_camera
# ui_camera.hide()
# self.black_bars_display_region = win.make_display_region()
# self.black_bars_display_region.set_sort(-100)
self.ui = Entity(eternal=True,
name='ui',
parent=self.ui_camera,
scale=(self.ui_size * .5, self.ui_size * .5))
scene.ui = self.ui
if (use_filters):
self.filter_manager = FilterManager(base.win, base.cam)
self.render_texture = PandaTexture()
self.filter_quad = None
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 _initDepthCapture(self):
for camera in self.cameras:
camNode = Camera('Depth camera')
camNode.setCameraMask(self.cameraMask)
lens = PerspectiveLens()
lens.setFov(self.fov)
lens.setAspectRatio(float(self.size[0]) / float(self.size[1]))
lens.setNear(self.zNear)
lens.setFar(self.zFar)
camNode.setLens(lens)
camNode.setScene(self.scene.scene)
cam = camera.attachNewNode(camNode)
winprops = WindowProperties.size(self.size[0], self.size[1])
fbprops = FrameBufferProperties.getDefault()
fbprops = FrameBufferProperties(fbprops)
fbprops.setRgbColor(False)
fbprops.setRgbaBits(0, 0, 0, 0)
fbprops.setStencilBits(0)
fbprops.setMultisamples(0)
fbprops.setBackBuffers(0)
fbprops.setDepthBits(16)
flags = GraphicsPipe.BFFbPropsOptional
if self.mode == 'onscreen':
flags = flags | GraphicsPipe.BFRequireWindow
elif self.mode == 'offscreen':
flags = flags | GraphicsPipe.BFRefuseWindow
else:
raise Exception('Unsupported rendering mode: %s' % (self.mode))
buf = self.graphicsEngine.makeOutput(self.pipe, 'Depth buffer', 0,
fbprops, winprops, flags)
if buf is None:
raise Exception('Unable to create depth buffer')
# Set to render at the end
buf.setSort(10000)
dr = buf.makeDisplayRegion()
dr.setSort(0)
dr.setCamera(cam)
dr = camNode.getDisplayRegion(0)
tex = Texture()
tex.setFormat(Texture.FDepthComponent)
tex.setComponentType(Texture.TFloat)
buf.addRenderTexture(tex, GraphicsOutput.RTMCopyRam,
GraphicsOutput.RTPDepth)
# XXX: should use tex.setMatchFramebufferFormat(True)?
agent = camera.getParent()
self.depthBuffers[agent.getName()] = buf
self.depthTextures[agent.getName()] = tex
def setupPerspectiveLens(self, near=0.1, far=100.0, fov=(90, 90)):
""" Setups a PerspectiveLens with a given near plane, far plane
and FoV. The FoV is a tuple in the format (Horizontal FoV, Vertical FoV) """
self.lens = PerspectiveLens()
self.lens.setNearFar(near, far)
self.lens.setFov(fov[0], fov[1])
self.camera.setLens(self.lens)
self.nearPlane = near
self.farPlane = far
self.rebuildMatrixCache()
def __setSpotlight(self, props):
light = Spotlight(props['name'])
light.setShadowCaster(props['castShadows'], 2048, 2048)
light.setAttenuation(props['attenuation'])
lens = PerspectiveLens()
fov = math.degrees(props['range'].x)
lens.setFov(fov)
lens.setFilmSize(5096)
light.setLens(lens)
return self.__createLight(light, props)
def set_up(self):
self.display_region = base.camNode.get_display_region(0)
win = self.display_region.get_window()
self.perspective_lens = PerspectiveLens()
self.lens = self.perspective_lens
self.perspective_lens.set_aspect_ratio(window.aspect_ratio)
self.perspective_lens.set_focal_length(50)
self.perspective_lens_node = LensNode('perspective_lens_node',
self.perspective_lens)
self.lens_node = self.perspective_lens_node
self.orthographic_lens = OrthographicLens()
self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio,
self.fov)
self.orthographic_lens_node = LensNode('orthographic_lens_node',
self.orthographic_lens)
application.base.cam.node().set_lens(self.lens)
self.orthographic = False
self.fov = 40
self.clip_plane_near = 0.0001
self.clip_plane_far = 10000
self.ui_display_region = win.make_display_region()
self.ui_display_region.set_sort(20)
self.ui_camera = NodePath(PandaCamera('ui_camera'))
self.ui_lens = OrthographicLens()
self.ui_lens.set_film_size(self.ui_size * .5 * self.aspect_ratio,
self.ui_size * .5)
self.ui_lens.set_near_far(-1000, 1000)
self.ui_camera.node().set_lens(self.ui_lens)
self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens)
self.ui_render = NodePath('ui_render')
self.ui_render.set_depth_test(0)
self.ui_render.set_depth_write(0)
self.ui_camera.reparent_to(self.ui_render)
self.ui_display_region.set_camera(self.ui_camera)
scene.ui_camera = self.ui_camera
# ui_camera.hide()
# self.black_bars_display_region = win.make_display_region()
# self.black_bars_display_region.set_sort(-100)
self.ui = Entity()
self.ui.eternal = True
self.ui.name = 'ui'
self.ui.parent = self.ui_camera
self.ui.scale = (self.ui_size * .5, self.ui_size * .5)
# self.ui.model = 'quad'
scene.ui = self.ui
def set_perspective_lens(self, fov, near_plane, far_plane, pos, direction):
transform_mat = Mat4.translate_mat(-pos)
temp_lens = PerspectiveLens(fov, fov)
temp_lens.set_film_offset(0, 0)
temp_lens.set_near_far(near_plane, far_plane)
temp_lens.set_view_vector(direction, LVector3.up())
self.set_matrix_lens(transform_mat * temp_lens.get_projection_mat())
hexahedron = temp_lens.make_bounds()
center = (hexahedron.get_min() + hexahedron.get_max()) * 0.5
self._bounds = BoundingSphere(pos + center,
(hexahedron.get_max() - center).length())
def SetupCamera(self ):
width = self.base.win.getProperties().getXSize()
height = self.base.win.getProperties().getYSize()
lens = PerspectiveLens()
lens.setFov(60)
lens.setAspectRatio(width / height)
# lens.setFilmSize(width,height)
# lens.setFocalLength(self.FOCAL_LENGTH)
lens.setFar(50000.0)
self.base.cam.node().setLens(lens)
self.SetCameraLoc([100, -80, 0, 40.0, -8.0])
def create_frustum(pos=None, mat=None):
"""Return an infinite frustum centered on the origin, looking towards +Y
and with a near plane at (0, 1.0, 0)
The default FoV is 30deg"""
if pos is None:
pos = LPoint3d()
if mat is None:
mat = LMatrix4()
lens = PerspectiveLens()
bh = lens.make_bounds()
f = InfiniteFrustum(bh, mat, pos)
return f
