class _Camera_:
key_map = {}
mouse_map = {}
# Public.
def set_focus(self, obj):
if self.FOCUS and obj is self.FOCUS: return
self.FOCUS = obj
self.focus_pos.set(0, obj.radius*12, 0)
obj_state = self.env.client.SIM.get_object_state(obj.name, ["sys_pos"])
obj.sys_pos = LVector3d(*obj_state['sys_pos'])
self.sys_pos = obj.sys_pos - self.focus_pos
# Setup.
def __init__(self, env):
self.env = env
self.cam_node = Camera(self.__class__.__name__.lower())
self.cam_node.setScene(env.NP)
self.NP = NodePath(self.cam_node)
self.NP.reparentTo(env.NP)
self.LENS = self.cam_node.getLens()
self.LENS.setFar(_cam.FAR)
self.LENS.setFov(base.camLens.getFov())
self.FOCUS = None
self.focus_pos = LVector3d(0,0,0)
self.sys_pos = LVector3d(0,0,0)
class _Camera_:
key_map = {}
mouse_map = {}
# Public.
def set_focus(self, obj):
if self.FOCUS and obj is self.FOCUS: return
self.FOCUS = obj
self.focus_pos.set(0, obj.radius * 12, 0)
obj_state = self.env.client.SIM.get_object_state(obj.name, ["sys_pos"])
obj.sys_pos = LVector3d(*obj_state['sys_pos'])
self.sys_pos = obj.sys_pos - self.focus_pos
# Setup.
def __init__(self, env):
self.env = env
self.cam_node = Camera(self.__class__.__name__.lower())
self.cam_node.setScene(env.NP)
self.NP = NodePath(self.cam_node)
self.NP.reparentTo(env.NP)
self.LENS = self.cam_node.getLens()
self.LENS.setFar(_cam.FAR)
self.LENS.setFov(base.camLens.getFov())
self.FOCUS = None
self.focus_pos = LVector3d(0, 0, 0)
self.sys_pos = LVector3d(0, 0, 0)
class LightManager(DebugObject):
""" This class is internally used by the RenderingPipeline to handle
Lights and their Shadows. It stores a list of lights, and updates the
required ShadowSources per frame. There are two main update methods:
updateLights processes each light and does a basic frustum check.
If the light is in the frustum, its ID is passed to the light precompute
container (set with setLightingCuller). Also, each shadowSource of
the light is checked, and if it reports to be invalid, it's queued to
the list of queued shadow updates.
updateShadows processes the queued shadow updates and setups everything
to render the shadow depth textures to the shadow atlas.
Lights can be added with addLight. Notice you cannot change the shadow
resolution or even wether the light casts shadows after you called addLight.
This is because it might already have a position in the atlas, and so
the atlas would have to delete it's map, which is not supported (yet).
This shouldn't be an issue, as you usually always know before if a
light will cast shadows or not.
"""
def __init__(self, pipeline):
""" Creates a new LightManager. It expects a RenderPipeline as parameter. """
DebugObject.__init__(self, "LightManager")
self._initArrays()
self.pipeline = pipeline
self.settings = pipeline.getSettings()
# Create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.queuedShadowUpdates = []
self.allLightsArray = ShaderStructArray(Light, self.maxTotalLights)
self.updateCallbacks = []
self.cullBounds = None
self.shadowScene = Globals.render
# Create atlas
self.shadowAtlas = ShadowAtlas()
self.shadowAtlas.setSize(self.settings.shadowAtlasSize)
self.shadowAtlas.create()
self.maxShadowMaps = 24
self.maxShadowUpdatesPerFrame = self.settings.maxShadowUpdatesPerFrame
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowMaps)
# Create shadow compute buffer
self._createShadowComputationBuffer()
# Create the initial shadow state
self.shadowComputeCamera.setTagStateKey("ShadowPassShader")
# self.shadowComputeCamera.setInitialState(RenderState.make(
# ColorWriteAttrib.make(ColorWriteAttrib.C_off),
# ColorWriteAttrib.make(ColorWriteAttrib.C_rgb),
# DepthWriteAttrib.make(DepthWriteAttrib.M_on),
# CullFaceAttrib.make(CullFaceAttrib.MCullNone),
# 100))
self._createTagStates()
self.shadowScene.setTag("ShadowPassShader", "Default")
# Create debug overlay
self._createDebugTexts()
# Disable buffer on start
self.shadowComputeTarget.setActive(False)
# Bind arrays
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(
self.shadowComputeTarget, "updateSources")
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
self.skip = 0
self.skipRate = 0
def _createTagStates(self):
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster/vertex.glsl",
"Shader/DefaultShadowCaster/fragment.glsl",
"Shader/DefaultShadowCaster/geometry.glsl")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
self.shadowComputeCamera.setTagState(
"Default", initialState.getState())
def _createShadowComputationBuffer(self):
""" This creates the internal shadow buffer which also is the
shadow atlas. Shadow maps are rendered to this using Viewports
(thank you rdb for adding this!). It also setups the base camera
which renders the shadow objects, although a custom mvp is passed
to the shaders, so the camera is mainly a dummy """
# Create camera showing the whole scene
self.shadowComputeCamera = Camera("ShadowComputeCamera")
self.shadowComputeCameraNode = self.shadowScene.attachNewNode(
self.shadowComputeCamera)
self.shadowComputeCamera.getLens().setFov(90, 90)
self.shadowComputeCamera.getLens().setNearFar(10.0, 100000.0)
# Disable culling
self.shadowComputeCamera.setBounds(OmniBoundingVolume())
self.shadowComputeCameraNode.setPos(0, 0, 150)
self.shadowComputeCameraNode.lookAt(0, 0, 0)
self.shadowComputeTarget = RenderTarget("ShadowAtlas")
self.shadowComputeTarget.setSize(self.shadowAtlas.getSize())
self.shadowComputeTarget.addDepthTexture()
self.shadowComputeTarget.setDepthBits(32)
if self.settings.enableGlobalIllumination:
self.shadowComputeTarget.addColorTexture()
self.shadowComputeTarget.setColorBits(16)
self.shadowComputeTarget.setSource(
self.shadowComputeCameraNode, Globals.base.win)
self.shadowComputeTarget.prepareSceneRender()
# This took me a long time to figure out. If not removing the quad
# children, the color and aux buffers will be overridden each frame.
# Quite annoying!
self.shadowComputeTarget.getQuad().node().removeAllChildren()
self.shadowComputeTarget.getInternalRegion().setSort(-200)
self.shadowComputeTarget.getInternalRegion().setNumRegions(
self.maxShadowUpdatesPerFrame + 1)
self.shadowComputeTarget.getInternalRegion().setDimensions(0,
(0, 0, 0, 0))
self.shadowComputeTarget.getInternalBuffer().setSort(-300)
# We can't clear the depth per viewport.
# But we need to clear it in any way, as we still want
# z-testing in the buffers. So well, we create a
# display region *below* (smaller sort value) each viewport
# which has a depth-clear assigned. This is hacky, I know.
self.depthClearer = []
for i in range(self.maxShadowUpdatesPerFrame):
buff = self.shadowComputeTarget.getInternalBuffer()
dr = buff.makeDisplayRegion()
dr.setSort(-250)
for k in xrange(16):
dr.setClearActive(k, True)
dr.setClearValue(k, Vec4(0.5,0.5,0.5,1))
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
dr.setDimensions(0,0,0,0)
dr.setActive(False)
self.depthClearer.append(dr)
# When using hardware pcf, set the correct filter types
dTex = self.shadowComputeTarget.getDepthTexture()
if self.settings.useHardwarePCF:
dTex.setMinfilter(Texture.FTShadow)
dTex.setMagfilter(Texture.FTShadow)
dTex.setWrapU(Texture.WMClamp)
dTex.setWrapV(Texture.WMClamp)
def getAllLights(self):
""" Returns all attached lights """
return self.lights
def _createDebugTexts(self):
""" Creates a debug overlay if specified in the pipeline settings """
self.lightsVisibleDebugText = None
self.lightsUpdatedDebugText = None
if self.settings.displayDebugStats:
try:
from Code.GUI.FastText import FastText
self.lightsVisibleDebugText = FastText(pos=Vec2(
Globals.base.getAspectRatio() - 0.1, 0.84), rightAligned=True, color=Vec3(1, 1, 0), size=0.036)
self.lightsUpdatedDebugText = FastText(pos=Vec2(
Globals.base.getAspectRatio() - 0.1, 0.8), rightAligned=True, color=Vec3(1, 1, 0), size=0.036)
except Exception, msg:
self.debug(
"Overlay is disabled because FastText wasn't loaded")
class Hud():
def __init__(self, root):
self.root = root
self.cam = Camera("hudcam")
self.cam.getLens().setFov(90)
self.cam.getLens().setNear(0.8)
self.camNode = NodePath(self.cam)
self.region = base.win.makeDisplayRegion()
self.region.setCamera(self.camNode)
self.node = loader.loadModel("assets/models/hud.bam")
self.node.reparentTo(self.camNode)
self.node.setZ(-0.6)
self.screen = self.node.find("**/screen")
self.screen.setScale((0.8, 0.5, 1))
self.screen.reparentTo(self.node)
self.screencard = self.screen.find("**/card")
self.cursor = self.screen.find("**/cursor")
self.gauge = {}
for gauge in ("speed", "air", "fuel"):
self.gauge[gauge] = self.node.find("**/levels_" + gauge)
SwitchNode(gauge).replaceNode(self.gauge[gauge].node())
self.gauge["mileage"] = self.node.find("**/levels_miles")
self.val = Purses(30, 1)
self.val.move(0, 0)
self.val.addstr(" 500", ["yellow", None])
self.val.move(21, 0)
self.val.addstr("NULL", ["yellow", None])
self.val.refresh()
self.val.node.setScale((0.5, 1, 0.03))
self.val.node.setPos((0.075, 0, -0.68))
self.screen.setY(1)
self.screen.setP(60)
self.holodek = NodePath("holodek")
self.hololight = self.node.find("**/hololight")
self.lighten()
def lighten(self):
l = DirectionalLight("hudlight")
l.setColor((2, 2, 2, 1))
ln = NodePath(l)
ln.setHpr(100, -60, 90)
self.node.setLight(ln)
def setGravity(self, gravity):
a = ["yellow", None]
self.val.addstr(0, 0, " ", a)
self.val.addstr(0, 0, str((gravity + 2) * 100), a)
self.val.refresh()
def setSpeed(self, speed):
self.gauge["speed"].node().setVisibleChild(int(speed))
def setAir(self, air):
if int(air) < -1:
air = -1
self.gauge["air"].node().setVisibleChild(int(air) + 1)
def setFuel(self, fuel):
if int(fuel) < -1:
fuel = 0
self.gauge["fuel"].node().setVisibleChild(int(fuel) + 1)
def setMiles(self, miles, maplength):
miles = 1 / (miles + 0.001)
l = 1 / (maplength * 2)
w = l / miles
if w > 1:
w = 1
self.gauge["mileage"].setScale(w, 1, 1)
def screenUp(self):
self.val.node.hide()
self.screen.setZ(-1)
taskMgr.add(self.moveScreen, extraArgs=["u"], appendTask=True)
def screenDown(self):
self.screen.setZ(0)
taskMgr.add(self.moveScreen, extraArgs=["d"], appendTask=True)
def setScreen(self, texture):
self.screencard.setTexture(texture)
def moveScreen(self, d, task):
speed = 0.03
z = self.screen.getZ()
if d == "u":
self.val.node.hide()
if z < 0:
self.screen.setZ(z + speed)
return task.cont
else:
if z > -1:
self.screen.setZ(z - speed)
return task.cont
self.val.node.show()
return task.done
def setCursor(self, x, y, w, h):
w = 1 / w
h = 1 / h
x = (-0.5 + (w / 2) + (w * x))
y = (0.5 - (h / 2) - (h * y))
self.cursor.setScale((w, h, 1))
self.cursor.setPos((x, y, 0.001))
def setHolodek(self, model, lights=[]):
self.holodek.removeNode()
self.hololight.hide()
self.holodek = NodePath("holodek")
if model:
model.setScale(0.15)
model.setHpr((-20, -10, 10))
model.setPos(0.8, 1, 0.1)
model.reparentTo(self.holodek)
for light in lights:
model.setLight(light)
self.hololight.show()
taskMgr.add(self.holospin,
"holospin",
extraArgs=[model],
appendTask=True)
self.holodek.reparentTo(self.node)
def holospin(self, node, task):
node.setH(node.getH() + 1)
return task.cont
class LightManager(DebugObject):
def __init__(self):
DebugObject.__init__(self, "LightManager")
self._initArrays()
# create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.allLightsArray = ShaderStructArray(Light, 30)
self.cullBounds = None
self.shadowScene = render
## SHADOW ATLAS ##
# todo: move to separate class
# When you change this, change also SHADOW_MAP_ATLAS_SIZE in configuration.include,
# and reduce the default shadow map resolution of point lights
self.shadowAtlasSize = 512
self.maxShadowMaps = 24
# When you change it , change also SHAODOW_GEOMETRY_MAX_VERTICES and
# SHADOW_MAX_UPDATES_PER_FRAME in configuration.include!
self.maxShadowUpdatesPerFrame = 2
self.tileSize = 128
self.tileCount = self.shadowAtlasSize / self.tileSize
self.tiles = []
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(ShadowSource,
self.maxShadowMaps)
# self.shadowAtlasTex = Texture("ShadowAtlas")
# self.shadowAtlasTex.setup2dTexture(
# self.shadowAtlasSize, self.shadowAtlasSize, Texture.TFloat, Texture.FRg16)
# self.shadowAtlasTex.setMinfilter(Texture.FTLinear)
# self.shadowAtlasTex.setMagfilter(Texture.FTLinear)
self.debug("Init shadow atlas with tileSize =", self.tileSize,
", tileCount =", self.tileCount)
for i in xrange(self.tileCount):
self.tiles.append([None for j in xrange(self.tileCount)])
# create shadow compute buffer
self.shadowComputeCamera = Camera("ShadowComputeCamera")
self.shadowComputeCameraNode = self.shadowScene.attachNewNode(
self.shadowComputeCamera)
self.shadowComputeCamera.getLens().setFov(90, 90)
self.shadowComputeCamera.getLens().setNearFar(10.0, 100000.0)
self.shadowComputeCameraNode.setPos(0, 0, 150)
self.shadowComputeCameraNode.lookAt(0, 0, 0)
self.shadowComputeTarget = RenderTarget("ShadowCompute")
self.shadowComputeTarget.setSize(self.shadowAtlasSize,
self.shadowAtlasSize)
# self.shadowComputeTarget.setLayers(self.maxShadowUpdatesPerFrame)
self.shadowComputeTarget.addRenderTexture(RenderTargetType.Depth)
self.shadowComputeTarget.setDepthBits(32)
self.shadowComputeTarget.setSource(self.shadowComputeCameraNode,
base.win)
self.shadowComputeTarget.prepareSceneRender()
self.shadowComputeTarget.getInternalRegion().setSort(3)
self.shadowComputeTarget.getRegion().setSort(3)
self.shadowComputeTarget.getInternalRegion().setNumRegions(
self.maxShadowUpdatesPerFrame + 1)
self.shadowComputeTarget.getInternalRegion().setDimensions(
0, (0, 1, 0, 1))
self.shadowComputeTarget.setClearDepth(False)
self.depthClearer = []
for i in xrange(self.maxShadowUpdatesPerFrame):
buff = self.shadowComputeTarget.getInternalBuffer()
dr = buff.makeDisplayRegion()
dr.setSort(2)
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
dr.setClearColorActive(False)
dr.setDimensions(0, 0, 0, 0)
self.depthClearer.append(dr)
self.queuedShadowUpdates = []
# Assign copy shader
self._setCopyShader()
# self.shadowComputeTarget.setShaderInput("atlas", self.shadowComputeTarget.getColorTexture())
# self.shadowComputeTarget.setShaderInput(
# "renderResult", self.shadowComputeTarget.getDepthTexture())
# self.shadowComputeTarget.setActive(False)
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster.vertex",
"Shader/DefaultShadowCaster.fragment",
"Shader/DefaultShadowCaster.geometry")
self.shadowComputeCamera.setTagStateKey("ShadowPass")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
self.shadowComputeCamera.setInitialState(
RenderState.make(ColorWriteAttrib.make(ColorWriteAttrib.C_off),
DepthWriteAttrib.make(DepthWriteAttrib.M_on),
100))
self.shadowComputeCamera.setTagState("True", initialState.getState())
self.shadowScene.setTag("ShadowPass", "True")
self._createDebugTexts()
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(self.shadowComputeTarget,
"updateSources")
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
# Tries to create debug text to show how many lights are currently visible
# / rendered
def _createDebugTexts(self):
try:
from FastText import FastText
self.lightsVisibleDebugText = FastText(pos=Vec2(
base.getAspectRatio() - 0.1, 0.84),
rightAligned=True,
color=Vec3(1, 0, 0),
size=0.036)
self.lightsUpdatedDebugText = FastText(pos=Vec2(
base.getAspectRatio() - 0.1, 0.8),
rightAligned=True,
color=Vec3(1, 0, 0),
size=0.036)
except Exception, msg:
self.debug("Could not load fast text:", msg)
self.debug("Overlay is disabled because FastText wasn't loaded")
self.lightsVisibleDebugText = None
self.lightsUpdatedDebugText = None
class LightManager(DebugObject):
""" This class is internally used by the RenderingPipeline to handle
Lights and their Shadows. It stores a list of lights, and updates the
required ShadowSources per frame. There are two main update methods:
updateLights processes each light and does a basic frustum check.
If the light is in the frustum, its ID is passed to the light precompute
container (set with setLightingCuller). Also, each shadowSource of
the light is checked, and if it reports to be invalid, it's queued to
the list of queued shadow updates.
updateShadows processes the queued shadow updates and setups everything
to render the shadow depth textures to the shadow atlas.
Lights can be added with addLight. Notice you cannot change the shadow
resolution or wether the light casts shadows after you called addLight.
This is because it might already have a position in the atlas, and so
the atlas would have to delete it's map, which is not supported (yet).
This shouldn't be an issue, as you usually always know before if a
light will cast shadows or not.
"""
def __init__(self, pipeline):
""" Creates a new LightManager. It expects a RenderPipeline as parameter. """
DebugObject.__init__(self, "LightManager")
self._initArrays()
self.pipeline = pipeline
self.settings = pipeline.getSettings()
# Create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.queuedShadowUpdates = []
self.allLightsArray = ShaderStructArray(Light, self.maxTotalLights)
self.updateCallbacks = []
self.cullBounds = None
self.shadowScene = Globals.render
# Create atlas
self.shadowAtlas = ShadowAtlas()
self.shadowAtlas.setSize(self.settings.shadowAtlasSize)
self.shadowAtlas.create()
self.maxShadowMaps = 24
self.maxShadowUpdatesPerFrame = self.settings.maxShadowUpdatesPerFrame
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowMaps)
# Create shadow compute buffer
self._createShadowComputationBuffer()
# Create the initial shadow state
self.shadowComputeCamera.setTagStateKey("ShadowPassShader")
self._createTagStates()
self.shadowScene.setTag("ShadowPassShader", "Default")
# Create debug overlay
self._createDebugTexts()
# Disable buffer on start
self.shadowComputeTarget.setActive(False)
# Bind arrays
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(
self.shadowComputeTarget, "updateSources")
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
self.skip = 0
self.skipRate = 0
def _createTagStates(self):
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster/vertex.glsl",
"Shader/DefaultShadowCaster/fragment.glsl",
"Shader/DefaultShadowCaster/geometry.glsl")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
# initialState.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
self.shadowComputeCamera.setTagState(
"Default", initialState.getState())
def _createShadowComputationBuffer(self):
""" This creates the internal shadow buffer which also is the
shadow atlas. Shadow maps are rendered to this using Viewports
(thank you rdb for adding this!). It also setups the base camera
which renders the shadow objects, although a custom mvp is passed
to the shaders, so the camera is mainly a dummy """
# Create camera showing the whole scene
self.shadowComputeCamera = Camera("ShadowComputeCamera")
self.shadowComputeCameraNode = self.shadowScene.attachNewNode(
self.shadowComputeCamera)
self.shadowComputeCamera.getLens().setFov(30, 30)
self.shadowComputeCamera.getLens().setNearFar(1.0, 2.0)
# Disable culling
self.shadowComputeCamera.setBounds(OmniBoundingVolume())
self.shadowComputeCamera.setCullBounds(OmniBoundingVolume())
self.shadowComputeCamera.setFinal(True)
self.shadowComputeCameraNode.setPos(0, 0, 1500)
self.shadowComputeCameraNode.lookAt(0, 0, 0)
self.shadowComputeTarget = RenderTarget("ShadowAtlas")
self.shadowComputeTarget.setSize(self.shadowAtlas.getSize())
self.shadowComputeTarget.addDepthTexture()
self.shadowComputeTarget.setDepthBits(32)
self.shadowComputeTarget.setSource(
self.shadowComputeCameraNode, Globals.base.win)
self.shadowComputeTarget.prepareSceneRender()
# This took me a long time to figure out. If not removing the quad
# children, the color and aux buffers will be overridden each frame.
# Quite annoying!
self.shadowComputeTarget.getQuad().node().removeAllChildren()
self.shadowComputeTarget.getInternalRegion().setSort(-200)
self.shadowComputeTarget.getInternalRegion().setNumRegions(
self.maxShadowUpdatesPerFrame + 1)
self.shadowComputeTarget.getInternalRegion().setDimensions(0,
(0, 0, 0, 0))
self.shadowComputeTarget.getInternalRegion().disableClears()
self.shadowComputeTarget.getInternalBuffer().disableClears()
self.shadowComputeTarget.getInternalBuffer().setSort(-300)
# We can't clear the depth per viewport.
# But we need to clear it in any way, as we still want
# z-testing in the buffers. So well, we create a
# display region *below* (smaller sort value) each viewport
# which has a depth-clear assigned. This is hacky, I know.
self.depthClearer = []
for i in range(self.maxShadowUpdatesPerFrame):
buff = self.shadowComputeTarget.getInternalBuffer()
dr = buff.makeDisplayRegion()
dr.setSort(-250)
for k in xrange(16):
dr.setClearActive(k, True)
dr.setClearValue(k, Vec4(0.5,0.5,0.5,1))
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
dr.setDimensions(0,0,0,0)
dr.setActive(False)
self.depthClearer.append(dr)
# When using hardware pcf, set the correct filter types
if self.settings.useHardwarePCF:
self.pcfSampleState = SamplerState()
self.pcfSampleState.setMinfilter(SamplerState.FTShadow)
self.pcfSampleState.setMagfilter(SamplerState.FTShadow)
self.pcfSampleState.setWrapU(SamplerState.WMClamp)
self.pcfSampleState.setWrapV(SamplerState.WMClamp)
dTex = self.getAtlasTex()
dTex.setWrapU(Texture.WMClamp)
dTex.setWrapV(Texture.WMClamp)
def getAllLights(self):
""" Returns all attached lights """
return self.lights
def getPCFSampleState(self):
""" Returns the pcf sample state used to sample the shadow map """
return self.pcfSampleState
def processCallbacks(self):
""" Processes all updates from the previous frame """
for update in self.updateCallbacks:
update.onUpdated()
self.updateCallbacks = []
def _createDebugTexts(self):
""" Creates a debug overlay if specified in the pipeline settings """
self.lightsVisibleDebugText = None
self.lightsUpdatedDebugText = None
if self.settings.displayDebugStats:
try:
from Code.GUI.FastText import FastText
self.lightsVisibleDebugText = FastText(pos=Vec2(
Globals.base.getAspectRatio() - 0.1, 0.84), rightAligned=True, color=Vec3(1, 1, 0), size=0.036)
self.lightsUpdatedDebugText = FastText(pos=Vec2(
Globals.base.getAspectRatio() - 0.1, 0.8), rightAligned=True, color=Vec3(1, 1, 0), size=0.036)
except Exception, msg:
self.debug(
"Overlay is disabled because FastText wasn't loaded")
