def create(self):
""" Creates the passes """
self.cloudStartHeight = 900.0
self.cloudEndHeight = 3300.0
self.cloudResolution = 768
self.cloudResolutionH = 128
self.voxelGrid = Texture("CloudVoxelGrid")
self.voxelGrid.setup3dTexture(self.cloudResolution, self.cloudResolution, self.cloudResolutionH, Texture.TFloat, Texture.FR16)
self.voxelGrid.setWrapU(Texture.WMRepeat)
self.voxelGrid.setWrapV(Texture.WMRepeat)
self.voxelGrid.setWrapW(Texture.WMClamp)
self.cloudNoise = Texture("CloudNoise")
self.cloudNoise.setup3dTexture(64, 64, 64, Texture.TFloat, Texture.FR16)
self.cloudNoise.setWrapU(Texture.WMRepeat)
self.cloudNoise.setWrapV(Texture.WMRepeat)
self.cloudNoise.setWrapW(Texture.WMRepeat)
MemoryMonitor.addTexture("CloudVoxelGrid", self.voxelGrid)
MemoryMonitor.addTexture("CloudNoise", self.cloudNoise)
self._createInitialGrid()
self.renderPass = CloudRenderPass()
self.pipeline.getRenderPassManager().registerPass(self.renderPass)
self.pipeline.getRenderPassManager().registerStaticVariable("cloudVoxelGrid", self.voxelGrid)
self.pipeline.getRenderPassManager().registerStaticVariable("cloudStartHeight", self.cloudStartHeight)
self.pipeline.getRenderPassManager().registerStaticVariable("cloudEndHeight", self.cloudEndHeight)
self.pipeline.getRenderPassManager().registerStaticVariable("cloudNoise", self.cloudNoise)
self.pipeline.getRenderPassManager().registerDefine("CLOUDS_ENABLED", 1)
def init(self):
""" Initializes the vertex buffers and makes them available as shader
inputs. """
self.vertexBuffers = []
for i in xrange(2):
vertexBuffer = Texture("VertexPositionBuffer-" + str(i))
vertexBuffer.setup2dTexture(self.split,
self.maxVertexCount / self.split,
Texture.TFloat, Texture.FRgba32)
vertexBuffer.setClearColor(Vec4(0))
vertexBuffer.clearImage()
MemoryMonitor.addTexture("DynamicObjectVtxBuffer" + str(i),
vertexBuffer)
Globals.render.setShaderInput("dynamicObjectVtxBuffer" + str(i),
vertexBuffer)
BufferViewerGUI.registerTexture("Vtx Positions " + str(i),
vertexBuffer)
vertexBuffer.setWrapU(Texture.WMClamp)
vertexBuffer.setWrapV(Texture.WMClamp)
vertexBuffer.setMinfilter(Texture.FTNearest)
vertexBuffer.setMagfilter(Texture.FTNearest)
self.vertexBuffers.append(vertexBuffer)
Globals.render.setShaderInput("dynamicVtxSplit", self.split)
def create(self):
""" Creates the passes required to compute the occlusion, selecting
the appropriate pass for the selected technique """
technique = self.pipeline.settings.occlusionTechnique
if technique not in self.availableTechniques:
self.error("Unrecognized technique: " + technique)
return
if technique == "None":
return
# Create the ambient occlusion pass. The technique is selected in the
# shader later, based on the defines
self.aoPass = AmbientOcclusionPass()
self.pipeline.getRenderPassManager().registerPass(self.aoPass)
# Create the ambient occlusion blur pass
self.blurPass = OcclusionBlurPass()
self.pipeline.getRenderPassManager().registerPass(self.blurPass)
# Register the configuration defines
self.pipeline.getRenderPassManager().registerDefine(
"OCCLUSION_TECHNIQUE_" + technique, 1)
self.pipeline.getRenderPassManager().registerDefine("USE_OCCLUSION", 1)
self.pipeline.getRenderPassManager().registerDefine(
"OCCLUSION_RADIUS", self.pipeline.settings.occlusionRadius)
self.pipeline.getRenderPassManager().registerDefine(
"OCCLUSION_STRENGTH", self.pipeline.settings.occlusionStrength)
self.pipeline.getRenderPassManager().registerDefine(
"OCCLUSION_SAMPLES", self.pipeline.settings.occlusionSampleCount)
if self.pipeline.settings.useLowQualityBlur:
self.pipeline.getRenderPassManager().registerDefine(
"USE_LOW_QUALITY_BLUR", 1)
if self.pipeline.settings.useOcclusionNoise:
self.pipeline.getRenderPassManager().registerDefine(
"USE_OCCLUSION_NOISE", 1)
if self.pipeline.settings.useTemporalOcclusion:
# Create a texture to store the last frame occlusion
self.lastFrameOcclusionTex = Texture("LastFrameOcclusion")
self.lastFrameOcclusionTex.setup2dTexture(Globals.resolution.x,
Globals.resolution.y,
Texture.TFloat,
Texture.FR16)
self.pipeline.getRenderPassManager().registerStaticVariable(
"lastFrameOcclusion", self.lastFrameOcclusionTex)
BufferViewerGUI.registerTexture("LastFrameOcclusion",
self.lastFrameOcclusionTex)
MemoryMonitor.addTexture("LastFrameOcclusion",
self.lastFrameOcclusionTex)
self.pipeline.getRenderPassManager().registerDefine(
"USE_TEMPORAL_OCCLUSION", 1)
self.combinePass = OcclusionCombinePass()
self.pipeline.getRenderPassManager().registerPass(self.combinePass)
def _createLastFrameBuffers(self):
""" Creates the buffers which store the last frame depth, as the render
target matcher cannot handle this """
self.lastFrameDepth = Texture("LastFrameDepth")
self.lastFrameDepth.setup2dTexture(Globals.resolution.x, Globals.resolution.y,
Texture.TFloat, Texture.FR32)
BufferViewerGUI.registerTexture("LastFrameDepth", self.lastFrameDepth)
MemoryMonitor.addTexture("LastFrameDepth", self.lastFrameDepth)
self.renderPassManager.registerStaticVariable("lastFrameDepth", self.lastFrameDepth)
def deleteBuffer(self):
""" Deletes this buffer, restoring the previous state """
MemoryMonitor.unregisterRenderTarget(self._name, self)
self._internalBuffer.clearRenderTextures()
self._engine.removeWindow(self._internalBuffer)
self._active = False
BufferViewerGUI.unregisterBuffer(self._name)
if self._createOverlayQuad:
self._quad.removeNode()
def create(self):
""" Creates the passes required to compute the occlusion, selecting
the appropriate pass for the selected technique """
technique = self.pipeline.settings.occlusionTechnique
if technique not in self.availableTechniques:
self.error("Unrecognized technique: " + technique)
return
if technique == "None":
return
# Create the ambient occlusion pass. The technique is selected in the
# shader later, based on the defines
self.aoPass = AmbientOcclusionPass()
self.pipeline.getRenderPassManager().registerPass(self.aoPass)
# Create the ambient occlusion blur pass
self.blurPass = OcclusionBlurPass()
self.pipeline.getRenderPassManager().registerPass(self.blurPass)
# Register the configuration defines
self.pipeline.getRenderPassManager().registerDefine("OCCLUSION_TECHNIQUE_" + technique, 1)
self.pipeline.getRenderPassManager().registerDefine("USE_OCCLUSION", 1)
self.pipeline.getRenderPassManager().registerDefine("OCCLUSION_RADIUS",
self.pipeline.settings.occlusionRadius)
self.pipeline.getRenderPassManager().registerDefine("OCCLUSION_STRENGTH",
self.pipeline.settings.occlusionStrength)
self.pipeline.getRenderPassManager().registerDefine("OCCLUSION_SAMPLES",
self.pipeline.settings.occlusionSampleCount)
if self.pipeline.settings.useLowQualityBlur:
self.pipeline.getRenderPassManager().registerDefine("USE_LOW_QUALITY_BLUR", 1)
if self.pipeline.settings.useOcclusionNoise:
self.pipeline.getRenderPassManager().registerDefine("USE_OCCLUSION_NOISE", 1)
if self.pipeline.settings.useTemporalOcclusion:
# Create a texture to store the last frame occlusion
self.lastFrameOcclusionTex = Texture("LastFrameOcclusion")
self.lastFrameOcclusionTex.setup2dTexture(Globals.base.win.getXSize(),
Globals.base.win.getYSize(), Texture.TFloat, Texture.FR16)
self.pipeline.getRenderPassManager().registerStaticVariable("lastFrameOcclusion", self.lastFrameOcclusionTex)
BufferViewerGUI.registerTexture("LastFrameOcclusion", self.lastFrameOcclusionTex)
MemoryMonitor.addTexture("LastFrameOcclusion", self.lastFrameOcclusionTex)
self.pipeline.getRenderPassManager().registerDefine("USE_TEMPORAL_OCCLUSION", 1)
self.combinePass = OcclusionCombinePass()
self.pipeline.getRenderPassManager().registerPass(self.combinePass)
def deleteBuffer(self):
""" Deletes this buffer, restoring the previous state """
MemoryMonitor.unregisterRenderTarget(self._name, self)
self._internalBuffer.clearRenderTextures()
self._engine.removeWindow(self._internalBuffer)
self._active = False
BufferViewerGUI.unregisterBuffer(self._name)
if self._createOverlayQuad:
self._quad.removeNode()
for target in RenderTargetType.All:
if self.hasTarget(target):
tex = self.getTarget(target)
class Monitor:
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
def get_monitoring_data(self):
data = {}
#data.append(self.memoryMonitor.get_memory_usage())
data['memory']= self.memoryMonitor.get_meminfo()
data['loadavg'] = self.systemLoadMonitor.get_loadavg()
data['http'] = self.httpMonitor.get_http_connections()
return data
def send_monitoring_data(self,data):
'''
connect to a server to send monitoring data
'''
try:
logging.debug('Connecting to Monitoring Server...')
server = xmlrpclib.ServerProxy('%s:%s'%(settings.SERVER, settings.SERVER_PORT))
sent = server.get_vm_notification(data)
except (socket_error, xmlrpclib.Fault, xmlrpclib.ProtocolError, xmlrpclib.ResponseError), error_code:
print error_code
logging.error('Err: (%s)'%error_code)
def initTransparencyPass(self):
""" Creates the pass which renders the transparent objects into the scene """
self.transparencyPass = TransparencyPass()
self.pipeline.getRenderPassManager().registerPass(self.transparencyPass)
# Create the atomic counter which stores the amount of rendered transparent
# pixels. For now this a 1x1 texture, as atomic counters are not implemented.
self.pixelCountBuffer = Texture("MaterialCountBuffer")
self.pixelCountBuffer.setup2dTexture(1, 1, Texture.TInt, Texture.FR32i)
# Creates the buffer which stores all transparent pixels. Pixels are inserted
# into the buffer in the order they are rendered, using the pixelCountBuffer
# to determine their index
self.materialDataBuffer = Texture("MaterialDataBuffer")
self.materialDataBuffer.setupBufferTexture(self.maxPixelCount, Texture.TFloat,
Texture.FRgba32, GeomEnums.UH_static)
# Creates the list head buffer, which stores the first transparent pixel for
# each window pixel. The index stored in this buffer is the index into the
# materialDataBuffer
self.listHeadBuffer = Texture("ListHeadBuffer")
self.listHeadBuffer.setup2dTexture(self.pipeline.getSize().x, self.pipeline.getSize().y,
Texture.TInt, Texture.FR32i)
# Creates the spinlock buffer, which ensures that writing to the listHeadBuffer
# is sequentially
self.spinLockBuffer = Texture("SpinLockBuffer")
self.spinLockBuffer.setup2dTexture(self.pipeline.getSize().x, self.pipeline.getSize().y,
Texture.TInt, Texture.FR32i)
# Set the buffers as input to the main scene. Maybe we can do this more elegant
target = self.pipeline.showbase.render
target.setShaderInput("pixelCountBuffer", self.pixelCountBuffer)
target.setShaderInput("spinLockBuffer", self.spinLockBuffer)
target.setShaderInput("materialDataBuffer", self.materialDataBuffer)
target.setShaderInput("listHeadBuffer", self.listHeadBuffer)
# Provides the buffers as global shader inputs
self.pipeline.getRenderPassManager().registerStaticVariable("transpPixelCountBuffer", self.pixelCountBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable("transpSpinLockBuffer", self.spinLockBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable("transpListHeadBuffer", self.listHeadBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable("transpMaterialDataBuffer", self.materialDataBuffer)
# Registers the transparency settings to the shaders
self.pipeline.getRenderPassManager().registerDefine("USE_TRANSPARENCY", 1)
self.pipeline.getRenderPassManager().registerDefine("MAX_TRANSPARENCY_LAYERS",
self.pipeline.settings.maxTransparencyLayers)
self.pixelCountBuffer.setClearColor(Vec4(0, 0, 0, 0))
self.spinLockBuffer.setClearColor(Vec4(0, 0, 0, 0))
self.listHeadBuffer.setClearColor(Vec4(0, 0, 0, 0))
MemoryMonitor.addTexture("MaterialCountBuffer", self.pixelCountBuffer)
MemoryMonitor.addTexture("MaterialDataBuffer", self.materialDataBuffer)
MemoryMonitor.addTexture("ListHeadBuffer", self.listHeadBuffer)
MemoryMonitor.addTexture("SpinLockBuffer", self.spinLockBuffer)
def _makeRenderedLightsBuffer(self):
""" Creates the buffer which stores the indices of all rendered lights """
bufferSize = 16
bufferSize += LightLimits.maxLights["PointLight"]
bufferSize += LightLimits.maxLights["PointLightShadow"]
bufferSize += LightLimits.maxLights["DirectionalLight"]
bufferSize += LightLimits.maxLights["DirectionalLightShadow"]
bufferSize += LightLimits.maxLights["SpotLight"]
bufferSize += LightLimits.maxLights["SpotLightShadow"]
self.renderedLightsBuffer = Texture("RenderedLightsBuffer")
self.renderedLightsBuffer.setupBufferTexture(bufferSize, Texture.TInt, Texture.FR32i, GeomEnums.UHDynamic)
self.pipeline.getRenderPassManager().registerStaticVariable(
"renderedLightsBuffer", self.renderedLightsBuffer)
MemoryMonitor.addTexture("Rendered Lights Buffer", self.renderedLightsBuffer)
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
self.sshAccessMonitor = SSHAccessMonitor()
self.availabilityMonitor = AvailabilityMonitor()
self.backupMonitor = BackupMonitor()
self.encryptionMonitor = EncryptionMonitor()
self.integrityMonitor = IntegrityMonitor()
self.malwareMonitor = MalwareMonitor()
self.passwordMonitor = PasswordMonitor()
self.vulnerabilityMonitor = VulnerabilityMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
class Monitor:
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
self.sshAccessMonitor = SSHAccessMonitor()
self.availabilityMonitor = AvailabilityMonitor()
self.backupMonitor = BackupMonitor()
self.encryptionMonitor = EncryptionMonitor()
self.integrityMonitor = IntegrityMonitor()
self.malwareMonitor = MalwareMonitor()
self.passwordMonitor = PasswordMonitor()
self.vulnerabilityMonitor = VulnerabilityMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
def get_monitoring_data(self):
data = {}
#data.append(self.memoryMonitor.get_memory_usage())
data['memory'] = self.memoryMonitor.get_meminfo()
data['loadavg'] = self.systemLoadMonitor.get_loadavg()
data['http'] = self.httpMonitor.get_http_connections()
data['sshattempts'] = self.sshAccessMonitor.get_ssh_access_attempts()
data['availabity'] = self.availabilityMonitor.get_availability_info()
data['backup'] = self.backupMonitor.get_backup_info()
data['encryption'] = self.encryptionMonitor.get_encryption_info()
data['integrity'] = self.integrityMonitor.get_integrity_info()
data['malware'] = self.malwareMonitor.get_malware_info()
data['password'] = self.passwordMonitor.get_password_security()
data[
'vulnerability'] = self.vulnerabilityMonitor.get_vulnerability_info(
)
return data
def send_monitoring_data(self, data):
'''
connect to a server to send monitoring data
'''
try:
logging.debug('Connecting to Monitoring Server...')
server = xmlrpclib.ServerProxy(
'%s:%s' % (settings.SERVER, settings.SERVER_PORT))
sent = server.get_vm_notification(data)
except (socket_error, xmlrpclib.Fault, xmlrpclib.ProtocolError,
xmlrpclib.ResponseError), error_code:
print error_code
logging.error('Err: (%s)' % error_code)
def _makeRenderedLightsBuffer(self):
""" Creates the buffer which stores the indices of all rendered lights """
bufferSize = 16
bufferSize += LightLimits.maxLights["PointLight"]
bufferSize += LightLimits.maxLights["PointLightShadow"]
bufferSize += LightLimits.maxLights["DirectionalLight"]
bufferSize += LightLimits.maxLights["DirectionalLightShadow"]
bufferSize += LightLimits.maxLights["SpotLight"]
bufferSize += LightLimits.maxLights["SpotLightShadow"]
self.renderedLightsBuffer = Texture("RenderedLightsBuffer")
self.renderedLightsBuffer.setupBufferTexture(bufferSize, Texture.TInt,
Texture.FR32i,
GeomEnums.UHDynamic)
self.pipeline.getRenderPassManager().registerStaticVariable(
"renderedLightsBuffer", self.renderedLightsBuffer)
MemoryMonitor.addTexture("Rendered Lights Buffer",
self.renderedLightsBuffer)
def create(self):
""" Creates the passes """
self.cloudStartHeight = 900.0
self.cloudEndHeight = 3300.0
self.cloudResolution = 768
self.cloudResolutionH = 128
self.voxelGrid = Texture("CloudVoxelGrid")
self.voxelGrid.setup3dTexture(self.cloudResolution,
self.cloudResolution,
self.cloudResolutionH, Texture.TFloat,
Texture.FR16)
self.voxelGrid.setWrapU(Texture.WMRepeat)
self.voxelGrid.setWrapV(Texture.WMRepeat)
self.voxelGrid.setWrapW(Texture.WMClamp)
self.cloudNoise = Texture("CloudNoise")
self.cloudNoise.setup3dTexture(64, 64, 64, Texture.TFloat,
Texture.FR16)
self.cloudNoise.setWrapU(Texture.WMRepeat)
self.cloudNoise.setWrapV(Texture.WMRepeat)
self.cloudNoise.setWrapW(Texture.WMRepeat)
MemoryMonitor.addTexture("CloudVoxelGrid", self.voxelGrid)
MemoryMonitor.addTexture("CloudNoise", self.cloudNoise)
self._createInitialGrid()
self.renderPass = CloudRenderPass()
self.pipeline.getRenderPassManager().registerPass(self.renderPass)
self.pipeline.getRenderPassManager().registerStaticVariable(
"cloudVoxelGrid", self.voxelGrid)
self.pipeline.getRenderPassManager().registerStaticVariable(
"cloudStartHeight", self.cloudStartHeight)
self.pipeline.getRenderPassManager().registerStaticVariable(
"cloudEndHeight", self.cloudEndHeight)
self.pipeline.getRenderPassManager().registerStaticVariable(
"cloudNoise", self.cloudNoise)
self.pipeline.getRenderPassManager().registerDefine(
"CLOUDS_ENABLED", 1)
def init(self):
""" Initializes the vertex buffers and makes them available as shader
inputs. """
self.vertexBuffers = []
for i in xrange(2):
vertexBuffer = Texture("VertexPositionBuffer-" + str(i))
vertexBuffer.setup2dTexture(self.split, self.maxVertexCount / self.split, Texture.TFloat, Texture.FRgba32)
vertexBuffer.setClearColor(Vec4(0))
vertexBuffer.clearImage()
MemoryMonitor.addTexture("DynamicObjectVtxBuffer"+str(i), vertexBuffer)
Globals.render.setShaderInput("dynamicObjectVtxBuffer"+str(i), vertexBuffer)
BufferViewerGUI.registerTexture("Vtx Positions " + str(i), vertexBuffer)
vertexBuffer.setWrapU(Texture.WMClamp)
vertexBuffer.setWrapV(Texture.WMClamp)
vertexBuffer.setMinfilter(Texture.FTNearest)
vertexBuffer.setMagfilter(Texture.FTNearest)
self.vertexBuffers.append(vertexBuffer)
Globals.render.setShaderInput("dynamicVtxSplit", self.split)
class Monitor:
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
self.sshAccessMonitor = SSHAccessMonitor()
self.availabilityMonitor = AvailabilityMonitor()
self.backupMonitor = BackupMonitor()
self.encryptionMonitor = EncryptionMonitor()
self.integrityMonitor = IntegrityMonitor()
self.malwareMonitor = MalwareMonitor()
self.passwordMonitor = PasswordMonitor()
self.vulnerabilityMonitor = VulnerabilityMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
def get_monitoring_data(self):
data = {}
#data.append(self.memoryMonitor.get_memory_usage())
data['memory']= self.memoryMonitor.get_meminfo()
data['loadavg'] = self.systemLoadMonitor.get_loadavg()
data['http'] = self.httpMonitor.get_http_connections()
data['sshattempts'] = self.sshAccessMonitor.get_ssh_access_attempts()
data['availabity'] = self.availabilityMonitor.get_availability_info()
data['backup'] = self.backupMonitor.get_backup_info()
data['encryption'] = self.encryptionMonitor.get_encryption_info()
data['integrity'] = self.integrityMonitor.get_integrity_info()
data['malware'] = self.malwareMonitor.get_malware_info()
data['password'] = self.passwordMonitor.get_password_security()
data['vulnerability'] = self.vulnerabilityMonitor.get_vulnerability_info()
return data
def send_monitoring_data(self,data):
'''
connect to a server to send monitoring data
'''
try:
logging.debug('Connecting to Monitoring Server...')
server = xmlrpclib.ServerProxy('%s:%s'%(settings.SERVER, settings.SERVER_PORT))
sent = server.get_vm_notification(data)
except (socket_error, xmlrpclib.Fault, xmlrpclib.ProtocolError, xmlrpclib.ResponseError), error_code:
print error_code
logging.error('Err: (%s)'%error_code)
def __init__(self):
self.memoryMonitor = MemoryMonitor()
self.systemLoadMonitor = SystemLoadMonitor()
self.httpMonitor = HTTPConMonitor()
self.sshAccessMonitor = SSHAccessMonitor()
self.availabilityMonitor = AvailabilityMonitor()
self.backupMonitor = BackupMonitor()
self.encryptionMonitor = EncryptionMonitor()
self.integrityMonitor = IntegrityMonitor()
self.malwareMonitor = MalwareMonitor()
self.passwordMonitor = PasswordMonitor()
self.vulnerabilityMonitor = VulnerabilityMonitor()
while True:
now = datetime.datetime.now()
print now.strftime("%d-%m-%Y %H:%M:%S")
data = self.get_monitoring_data()
self.send_monitoring_data(data)
time.sleep(300) # 5 minutes for now
def _showDebugOutput(self):
""" Lists the available debug options """
print "\n" * 5
print "DEBUG MENU"
print "-" * 50
print "Select an option:"
print "\t(1) Connect to pstats"
print "\t(2) Toggle frame rate meter"
print "\t(3) Reset to initial position"
print "\t(4) Display camera position"
print "\t(5) Show scene graph"
print "\t(6) Open placement window"
print "\t(7) Analyze VRAM"
print
selectedOption = raw_input("Which do you want to choose?: ")
try:
selectedOption = int(selectedOption.strip())
except:
print "Option has to be a valid number!"
return False
if selectedOption < 1 or selectedOption > 7:
print "Invalid option!"
return False
# pstats
if selectedOption == 1:
print "Connecting to pstats .."
print "If you have no pstats running, this will take 5 seconds to timeout .."
PStatClient.connect()
# frame rate meter
elif selectedOption == 2:
print "Toggling frame rate meter .."
self.showbase.setFrameRateMeter(not self.showbase.frameRateMeter)
# initial position
elif selectedOption == 3:
print "Reseting camera position / hpr .."
self._resetToInitial()
# display camera pos
elif selectedOption == 4:
print "Debug information:"
print "\tCamera is at", self.showbase.cam.getPos(self.showbase.render)
print "\tCamera hpr is", self.showbase.cam.getHpr(self.showbase.render)
# show scene graph
elif selectedOption == 5:
print "SCENE GRAPH:"
print "-" * 50
self.showbase.render.ls()
print "-" * 50
print
print "ANALYZED:"
print "-" * 50
self.showbase.render.analyze()
print "-" * 50
# placement window
elif selectedOption == 6:
print "Opening placement window. You need tkinter installed to be able to use it"
self.showbase.render.place()
# print "It seems .place() is currently not working. Sorry!!"
# vram analyszs
elif selectedOption == 7:
print "Analyzing VRAM ..."
MemoryMonitor.analyzeMemory()
def _create(self):
""" Attempts to create this buffer """
# if len(self._targets.keys()) < 1:
# print "WARNING:", self._debug_name, "has no attachments!"
colorIsFloat = self._colorBits >= 16
auxIsFloat = self._auxBits >= 16
self.debug("Bitcount: color=" + str(self._colorBits) + "; aux=" +
str(self._auxBits) + "; depth=" + str(self._depthBits))
# set wrap modes for color + auxtextures,
# also set correct formats:
# panda doesnt use sized formats automatically, this
# gives problems when using imageLoad / imageStore
prepare = [
RenderTargetType.Color,
RenderTargetType.Aux0,
RenderTargetType.Aux1,
RenderTargetType.Aux2,
RenderTargetType.Aux3,
]
for target in prepare:
if not self.hasTarget(target):
continue
handle = self.getTarget(target)
handle.setWrapU(Texture.WMClamp)
handle.setWrapV(Texture.WMClamp)
handle.setWrapW(Texture.WMClamp)
handle.setMinfilter(Texture.FTLinear)
handle.setMagfilter(Texture.FTLinear)
handle.setAnisotropicDegree(0)
handle.setXSize(self._width)
handle.setYSize(self._height)
if target == RenderTargetType.Color:
if colorIsFloat:
handle.setComponentType(Texture.TFloat)
if self._colorBits == 8:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba8)
else:
handle.setFormat(Texture.FRgb8)
elif self._colorBits == 16:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba16)
else:
handle.setFormat(Texture.FRgb16)
elif self._colorBits == 32:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba32)
else:
handle.setFormat(Texture.FRgb32)
else:
if auxIsFloat:
handle.setComponentType(Texture.TFloat)
if self._auxBits == 8:
handle.setFormat(Texture.FRgba8)
elif self._auxBits == 16:
handle.setFormat(Texture.FRgba16)
elif self._auxBits == 32:
handle.setFormat(Texture.FRgba32)
if self._layers > 1:
if self._useTextureArrays:
handle.setup2dTextureArray(self._layers)
else:
handle.setup3dTexture(self._layers)
# set layers for depth texture
if self._layers > 1 and self.hasTarget(RenderTargetType.Depth):
if self._useTextureArrays:
self.getTarget(RenderTargetType.Depth).setup2dTextureArray(
self._layers)
else:
self.getTarget(RenderTargetType.Depth).setup3dTexture(
self._layers)
# Create buffer descriptors
windowProps = WindowProperties.size(self._width, self._height)
bufferProps = FrameBufferProperties()
# Set color and alpha bits
if self.hasTarget(RenderTargetType.Color):
bufferProps.setRgbaBits(
self._colorBits, self._colorBits, self._colorBits,
self._colorBits if self._haveColorAlpha else 0)
if colorIsFloat:
bufferProps.setFloatColor(True)
# Set aux bits
if self.hasTarget(RenderTargetType.Aux0) and auxIsFloat:
# FRAMEBUFFER INCOMPLETE when using this to render to a 3d texture
# bufferProps.setAuxFloat(True)
pass
# Set depth bits and depth texture format
if self.hasTarget(RenderTargetType.Depth):
depthTarget = self.getTarget(RenderTargetType.Depth)
bufferProps.setDepthBits(self._depthBits)
bufferProps.setFloatDepth(True)
if self._depthBits != 32:
self.error(
"You cannot request a non-32bit float depth buffer! Requesting a non-float depth buffer instead"
)
bufferProps.setFloatDepth(False)
if self._depthBits == 16:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent16)
if self._depthBits == 24:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent24)
elif self._depthBits == 32:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent32)
depthTarget.setXSize(self._width)
depthTarget.setYSize(self._height)
# We need no stencil (not supported yet)
bufferProps.setStencilBits(0)
numAuxtex = 0
# Python really needs switch()
# FIXME: Why is it 2 when only 1 AUX texture is attached?!
if self.hasTarget(RenderTargetType.Aux3):
numAuxtex = 3
elif self.hasTarget(RenderTargetType.Aux2):
numAuxtex = 3
elif self.hasTarget(RenderTargetType.Aux1):
numAuxtex = 2
elif self.hasTarget(RenderTargetType.Aux0):
numAuxtex = 1
self.debug("Num Auxtex=", numAuxtex)
# Add aux textures (either 8 or 16 bit)
if auxIsFloat:
bufferProps.setAuxHrgba(numAuxtex)
else:
bufferProps.setAuxRgba(numAuxtex)
bufferProps.setMultisamples(self._multisamples)
# Register the target for the memory monitoring
MemoryMonitor.addRenderTarget(self._name, self)
# Create internal graphics output
self._internalBuffer = self._engine.makeOutput(
self._sourceWindow.getPipe(), self._name, 1, bufferProps,
windowProps, GraphicsPipe.BFRefuseWindow,
self._sourceWindow.getGsg(), self._sourceWindow)
if self._internalBuffer is None:
self.error("Failed to create buffer :(")
return False
# Add render targets
if self.hasTarget(RenderTargetType.Depth):
self._internalBuffer.addRenderTexture(
self.getTarget(RenderTargetType.Depth), self._bindMode,
GraphicsOutput.RTPDepth)
if self.hasTarget(RenderTargetType.Color):
self._internalBuffer.addRenderTexture(
self.getTarget(RenderTargetType.Color), self._bindMode,
GraphicsOutput.RTPColor)
modes = [
(RenderTargetType.Aux0, GraphicsOutput.RTPAuxHrgba0,
GraphicsOutput.RTPAuxRgba0),
(RenderTargetType.Aux1, GraphicsOutput.RTPAuxHrgba1,
GraphicsOutput.RTPAuxRgba1),
(RenderTargetType.Aux2, GraphicsOutput.RTPAuxHrgba2,
GraphicsOutput.RTPAuxRgba2),
(RenderTargetType.Aux3, GraphicsOutput.RTPAuxHrgba3,
GraphicsOutput.RTPAuxRgba3),
]
for target, floatMode, normalMode in modes:
if self.hasTarget(target):
self._internalBuffer.addRenderTexture(
self.getTarget(target), self._bindMode,
floatMode if auxIsFloat else normalMode)
# Increment global sort counter
RenderTarget.numBuffersAllocated += 1
self._sort = -300 + RenderTarget.numBuffersAllocated * 10
self.debug("our sort value is", self._sort)
self._internalBuffer.setSort(self._sort)
self._internalBuffer.disableClears()
self._internalBuffer.getDisplayRegion(0).disableClears()
for i in xrange(16):
self._internalBuffer.setClearActive(i, False)
self._internalBuffer.getDisplayRegion(0).setClearActive(i, False)
self._internalBuffer.setClearStencilActive(False)
if self.hasTarget(RenderTargetType.Depth):
depthTarget = self.getTarget(RenderTargetType.Depth)
if self._depthBits == 16:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent16)
elif self._depthBits == 24:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent24)
elif self._depthBits == 32:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent32)
return True
def initTransparencyPass(self):
""" Creates the pass which renders the transparent objects into the scene """
self.transparencyPass = TransparencyPass()
self.pipeline.getRenderPassManager().registerPass(
self.transparencyPass)
self.transparencyShadePass = TransparencyShadePass(self.pipeline)
self.transparencyShadePass.setBatchSize(
self.pipeline.settings.transparencyBatchSize)
self.pipeline.getRenderPassManager().registerPass(
self.transparencyShadePass)
# Create the atomic counter which stores the amount of rendered transparent
# pixels. For now this a 1x1 texture, as atomic counters are not implemented.
self.pixelCountBuffer = Texture("MaterialCountBuffer")
self.pixelCountBuffer.setup2dTexture(1, 1, Texture.TInt, Texture.FR32i)
# Creates the buffer which stores all transparent pixels. Pixels are inserted
# into the buffer in the order they are rendered, using the pixelCountBuffer
# to determine their index
self.materialDataBuffer = Texture("MaterialDataBuffer")
self.materialDataBuffer.setupBufferTexture(self.maxPixelCount,
Texture.TFloat,
Texture.FRgba32,
GeomEnums.UH_static)
# Creates the list head buffer, which stores the first transparent pixel for
# each window pixel. The index stored in this buffer is the index into the
# materialDataBuffer
self.listHeadBuffer = Texture("ListHeadBuffer")
self.listHeadBuffer.setup2dTexture(Gloabls.resolution.x,
Globals.resolution.y, Texture.TInt,
Texture.FR32i)
# Creates the spinlock buffer, which ensures that writing to the listHeadBuffer
# is sequentially
self.spinLockBuffer = Texture("SpinLockBuffer")
self.spinLockBuffer.setup2dTexture(Gloabls.resolution.x,
Globals.resolution.y, Texture.TInt,
Texture.FR32i)
# Set the buffers as input to the main scene. Maybe we can do this more elegant
target = self.pipeline.showbase.render
target.setShaderInput("pixelCountBuffer", self.pixelCountBuffer)
target.setShaderInput("spinLockBuffer", self.spinLockBuffer)
target.setShaderInput("materialDataBuffer", self.materialDataBuffer)
target.setShaderInput("listHeadBuffer", self.listHeadBuffer)
# Provides the buffers as global shader inputs
self.pipeline.getRenderPassManager().registerStaticVariable(
"transpPixelCountBuffer", self.pixelCountBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable(
"transpSpinLockBuffer", self.spinLockBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable(
"transpListHeadBuffer", self.listHeadBuffer)
self.pipeline.getRenderPassManager().registerStaticVariable(
"transpMaterialDataBuffer", self.materialDataBuffer)
# Registers the transparency settings to the shaders
self.pipeline.getRenderPassManager().registerDefine(
"USE_TRANSPARENCY", 1)
self.pipeline.getRenderPassManager().registerDefine(
"MAX_TRANSPARENCY_LAYERS",
self.pipeline.settings.maxTransparencyLayers)
self.pipeline.getRenderPassManager().registerDefine(
"TRANSPARENCY_RANGE", self.pipeline.settings.maxTransparencyRange)
self.pipeline.getRenderPassManager().registerDefine(
"TRANSPARENCY_BATCH_SIZE",
self.pipeline.settings.transparencyBatchSize)
self.pixelCountBuffer.setClearColor(Vec4(0, 0, 0, 0))
self.spinLockBuffer.setClearColor(Vec4(0, 0, 0, 0))
self.listHeadBuffer.setClearColor(Vec4(0, 0, 0, 0))
MemoryMonitor.addTexture("MaterialCountBuffer", self.pixelCountBuffer)
MemoryMonitor.addTexture("MaterialDataBuffer", self.materialDataBuffer)
MemoryMonitor.addTexture("ListHeadBuffer", self.listHeadBuffer)
MemoryMonitor.addTexture("SpinLockBuffer", self.spinLockBuffer)
def setup(self):
""" Setups everything for the GI to work """
assert (self.distributionSteps % 2 == 0)
self._createDebugTexts()
self.pipeline.getRenderPassManager().registerDefine(
"USE_GLOBAL_ILLUMINATION", 1)
self.pipeline.getRenderPassManager().registerDefine(
"GI_SLIDE_COUNT", self.slideCount)
self.pipeline.getRenderPassManager().registerDefine(
"GI_QUALITY_LEVEL", self.qualityLevelIndex)
# make the grid resolution a constant
self.pipeline.getRenderPassManager().registerDefine(
"GI_GRID_RESOLUTION", self.voxelGridResolution)
self.taskManager.addTask(3, self.stepVoxelize)
self.taskManager.addTask(self.distributionSteps, self.stepDistribute)
# Create the voxelize pass which is used to voxelize the scene from
# several directions
self.voxelizePass = VoxelizePass(self.pipeline)
self.voxelizePass.setVoxelGridResolution(self.voxelGridResolution)
self.voxelizePass.setVoxelGridSize(self.voxelGridSize)
self.voxelizePass.setGridResolutionMultiplier(1)
self.pipeline.getRenderPassManager().registerPass(self.voxelizePass)
self.generationTextures = []
# Create the buffers used to create the voxel grid
for color in "rgb":
tex = Texture("VoxelGeneration-" + color)
tex.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution, Texture.TInt,
Texture.FR32)
tex.setClearColor(Vec4(0))
self.generationTextures.append(tex)
Globals.render.setShaderInput("voxelGenDest" + color.upper(), tex)
MemoryMonitor.addTexture("VoxelGenerationTex-" + color.upper(),
tex)
self.bindTo(Globals.render, "giData")
self.convertGridTarget = RenderTarget("ConvertGIGrid")
self.convertGridTarget.setSize(
self.voxelGridResolution * self.slideCount,
self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.convertGridTarget.addColorTexture()
self.convertGridTarget.prepareOffscreenBuffer()
# Set a near-filter to the texture
if self.pipeline.settings.useDebugAttachments:
self.convertGridTarget.getColorTexture().setMinfilter(
Texture.FTNearest)
self.convertGridTarget.getColorTexture().setMagfilter(
Texture.FTNearest)
self.clearGridTarget = RenderTarget("ClearGIGrid")
self.clearGridTarget.setSize(
self.voxelGridResolution * self.slideCount,
self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.clearGridTarget.addColorTexture()
self.clearGridTarget.prepareOffscreenBuffer()
for idx, color in enumerate("rgb"):
self.convertGridTarget.setShaderInput(
"voxelGenSrc" + color.upper(), self.generationTextures[idx])
self.clearGridTarget.setShaderInput("voxelGenTex" + color.upper(),
self.generationTextures[idx])
# Create the data textures
self.dataTextures = []
self.directions = ["PosX", "NegX", "PosY", "NegY", "PosZ", "NegZ"]
for i, direction in enumerate(self.directions):
tex = Texture("GIDataTex" + direction)
tex.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution, Texture.TFloat,
Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelDataTex-" + direction, tex)
self.dataTextures.append(tex)
self.pipeline.getRenderPassManager().registerStaticVariable(
"giVoxelData" + direction, tex)
# Create ping / pong textures
self.pingDataTextures = []
self.pongDataTextures = []
for i, direction in enumerate(self.directions):
texPing = Texture("GIPingDataTex" + direction)
texPing.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution, Texture.TFloat,
Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelPingDataTex-" + direction, texPing)
self.pingDataTextures.append(texPing)
texPong = Texture("GIPongDataTex" + direction)
texPong.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution, Texture.TFloat,
Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelPongDataTex-" + direction, texPong)
self.pongDataTextures.append(texPong)
self.convertGridTarget.setShaderInput("voxelDataDest" + direction,
self.pingDataTextures[i])
# self.clearGridTarget.setShaderInput("voxelDataDest" + str(i), self.pongDataTextures[i])
# Set texture wrap modes
for tex in self.pingDataTextures + self.pongDataTextures + self.dataTextures + self.generationTextures:
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
tex.setWrapU(Texture.WMBorderColor)
tex.setWrapV(Texture.WMBorderColor)
tex.setWrapW(Texture.WMBorderColor)
tex.setAnisotropicDegree(0)
tex.setBorderColor(Vec4(0))
for tex in self.dataTextures:
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
self.distributeTarget = RenderTarget("DistributeVoxels")
self.distributeTarget.setSize(
self.voxelGridResolution * self.slideCount,
self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.distributeTarget.addColorTexture()
self.distributeTarget.prepareOffscreenBuffer()
# Set a near-filter to the texture
if self.pipeline.settings.useDebugAttachments:
self.distributeTarget.getColorTexture().setMinfilter(
Texture.FTNearest)
self.distributeTarget.getColorTexture().setMagfilter(
Texture.FTNearest)
self.distributeTarget.setShaderInput("isLastStep", False)
# Create solidness texture
self.voxelSolidTex = Texture("GIDataSolidTex")
self.voxelSolidTex.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution,
Texture.TFloat, Texture.FR16)
self.convertGridTarget.setShaderInput("voxelSolidDest",
self.voxelSolidTex)
self.distributeTarget.setShaderInput("voxelSolidTex",
self.voxelSolidTex)
MemoryMonitor.addTexture("VoxelSolidTex", self.voxelSolidTex)
self.voxelSolidStableTex = Texture("GIDataSolidStableTex")
self.voxelSolidStableTex.setup3dTexture(self.voxelGridResolution,
self.voxelGridResolution,
self.voxelGridResolution,
Texture.TFloat, Texture.FR16)
self.distributeTarget.setShaderInput("voxelSolidWriteTex",
self.voxelSolidStableTex)
self.pipeline.getRenderPassManager().registerStaticVariable(
"giVoxelSolidTex", self.voxelSolidStableTex)
# Create the final gi pass
self.finalPass = GlobalIlluminationPass()
self.pipeline.getRenderPassManager().registerPass(self.finalPass)
self.pipeline.getRenderPassManager().registerDynamicVariable(
"giData", self.bindTo)
self.pipeline.getRenderPassManager().registerStaticVariable(
"giReadyState", self.readyStateFlag)
# Visualize voxels
if False:
self.voxelCube = loader.loadModel("Box")
self.voxelCube.reparentTo(render)
# self.voxelCube.setTwoSided(True)
self.voxelCube.node().setFinal(True)
self.voxelCube.node().setBounds(OmniBoundingVolume())
self.voxelCube.setInstanceCount(self.voxelGridResolution**3)
# self.voxelCube.hide()
self.bindTo(self.voxelCube, "giData")
for i in xrange(5):
self.voxelCube.setShaderInput("giDataTex" + str(i),
self.pingDataTextures[i])
self.disableTargets()
def _create(self):
""" Attempts to create this buffer """
colorIsFloat = self._colorBits >= 16
auxIsFloat = self._auxBits >= 16
self.debug(
"Bitcount: color="
+ str(self._colorBits)
+ "; aux="
+ str(self._auxBits)
+ "; depth="
+ str(self._depthBits)
)
# set wrap modes for color + auxtextures,
# also set correct formats:
# panda doesnt use sized formats automatically, this
# gives problems when using imageLoad / imageStore
prepare = [
RenderTargetType.Color,
RenderTargetType.Aux0,
RenderTargetType.Aux1,
RenderTargetType.Aux2,
RenderTargetType.Aux3,
]
for target in prepare:
if not self.hasTarget(target):
continue
handle = self.getTarget(target)
handle.setWrapU(Texture.WMClamp)
handle.setWrapV(Texture.WMClamp)
handle.setWrapW(Texture.WMClamp)
handle.setMinfilter(Texture.FTLinear)
handle.setMagfilter(Texture.FTLinear)
handle.setAnisotropicDegree(0)
handle.setXSize(self._width)
handle.setYSize(self._height)
if target == RenderTargetType.Color:
if colorIsFloat:
handle.setComponentType(Texture.TFloat)
if self._colorBits == 8:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba8)
else:
handle.setFormat(Texture.FRgb8)
elif self._colorBits == 16:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba16)
else:
handle.setFormat(Texture.FRgb16)
elif self._colorBits == 32:
if self._haveColorAlpha:
handle.setFormat(Texture.FRgba32)
else:
handle.setFormat(Texture.FRgb32)
else:
if auxIsFloat:
handle.setComponentType(Texture.TFloat)
if self._auxBits == 8:
handle.setFormat(Texture.FRgba8)
elif self._auxBits == 16:
handle.setFormat(Texture.FRgba16)
elif self._auxBits == 32:
handle.setFormat(Texture.FRgba32)
if self._layers > 1:
if self._useTextureArrays:
handle.setup2dTextureArray(self._layers)
else:
handle.setup3dTexture(self._layers)
# set layers for depth texture
if self._layers > 1 and self.hasTarget(RenderTargetType.Depth):
if self._useTextureArrays:
self.getTarget(RenderTargetType.Depth).setup2dTextureArray(self._layers)
else:
self.getTarget(RenderTargetType.Depth).setup3dTexture(self._layers)
# Create buffer descriptors
windowProps = WindowProperties.size(self._width, self._height)
bufferProps = FrameBufferProperties()
# Set color and alpha bits
if self.hasTarget(RenderTargetType.Color):
bufferProps.setRgbaBits(
self._colorBits, self._colorBits, self._colorBits, self._colorBits if self._haveColorAlpha else 0
)
if colorIsFloat:
bufferProps.setFloatColor(True)
# Set aux bits
if self.hasTarget(RenderTargetType.Aux0) and auxIsFloat:
# FRAMEBUFFER INCOMPLETE when using this to render to a 3d texture
# bufferProps.setAuxFloat(True)
pass
# Set depth bits and depth texture format
if self.hasTarget(RenderTargetType.Depth):
depthTarget = self.getTarget(RenderTargetType.Depth)
bufferProps.setDepthBits(self._depthBits)
bufferProps.setFloatDepth(True)
if self._depthBits == 24:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent24)
elif self._depthBits == 32:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent32)
depthTarget.setXSize(self._width)
depthTarget.setYSize(self._height)
# We need no stencil (not supported yet)
bufferProps.setStencilBits(0)
numAuxtex = 0
# Python really needs switch()
# FIXME: Why is it 2 when only 1 AUX texture is attached?!
if self.hasTarget(RenderTargetType.Aux3):
numAuxtex = 3
elif self.hasTarget(RenderTargetType.Aux2):
numAuxtex = 3
elif self.hasTarget(RenderTargetType.Aux1):
numAuxtex = 2
elif self.hasTarget(RenderTargetType.Aux0):
numAuxtex = 1
self.debug("Num Auxtex=", numAuxtex)
# Add aux textures (either 8 or 16 bit)
if auxIsFloat:
bufferProps.setAuxHrgba(numAuxtex)
else:
bufferProps.setAuxRgba(numAuxtex)
bufferProps.setMultisamples(self._multisamples)
# Register the target for the memory monitoring
MemoryMonitor.addRenderTarget(self._name, self)
# Create internal graphics output
self._internalBuffer = self._engine.makeOutput(
self._sourceWindow.getPipe(),
self._name,
1,
bufferProps,
windowProps,
GraphicsPipe.BFRefuseWindow | GraphicsPipe.BFResizeable,
self._sourceWindow.getGsg(),
self._sourceWindow,
)
if self._internalBuffer is None:
self.error("Failed to create buffer :(")
return False
# Add render targets
if self.hasTarget(RenderTargetType.Depth):
self._internalBuffer.addRenderTexture(
self.getTarget(RenderTargetType.Depth), self._bindMode, GraphicsOutput.RTPDepth
)
if self.hasTarget(RenderTargetType.Color):
self._internalBuffer.addRenderTexture(
self.getTarget(RenderTargetType.Color), self._bindMode, GraphicsOutput.RTPColor
)
modes = [
(RenderTargetType.Aux0, GraphicsOutput.RTPAuxHrgba0, GraphicsOutput.RTPAuxRgba0),
(RenderTargetType.Aux1, GraphicsOutput.RTPAuxHrgba1, GraphicsOutput.RTPAuxRgba1),
(RenderTargetType.Aux2, GraphicsOutput.RTPAuxHrgba2, GraphicsOutput.RTPAuxRgba2),
(RenderTargetType.Aux3, GraphicsOutput.RTPAuxHrgba3, GraphicsOutput.RTPAuxRgba3),
]
for target, floatMode, normalMode in modes:
if self.hasTarget(target):
self._internalBuffer.addRenderTexture(
self.getTarget(target), self._bindMode, floatMode if auxIsFloat else normalMode
)
# Increment global sort counter
RenderTarget.numBuffersAllocated += 1
self._sort = -300 + RenderTarget.numBuffersAllocated * 10
self.debug("our sort value is", self._sort)
self._internalBuffer.setSort(self._sort)
self._internalBuffer.disableClears()
self._internalBuffer.getDisplayRegion(0).disableClears()
for i in xrange(16):
self._internalBuffer.setClearActive(i, False)
self._internalBuffer.getDisplayRegion(0).setClearActive(i, False)
self._internalBuffer.setClearStencilActive(False)
if self.hasTarget(RenderTargetType.Depth):
depthTarget = self.getTarget(RenderTargetType.Depth)
if self._depthBits == 24:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent24)
elif self._depthBits == 32:
# depthTarget.setComponentType(Texture.TFloat)
depthTarget.setFormat(Texture.FDepthComponent32)
return True
def setup(self):
""" Setups everything for the GI to work """
# Create the voxelize pass which is used to voxelize the scene from
# several directions
self.voxelizePass = VoxelizePass()
self.voxelizePass.setVoxelGridResolution(self.voxelGridResolution)
self.voxelizePass.setVoxelGridSize(self.voxelGridSizeWS)
self.voxelizePass.initVoxelStorage()
self.pipeline.getRenderPassManager().registerPass(self.voxelizePass)
# Create 3D Texture which is a copy of the voxel generation grid but
# stable, as the generation grid is updated part by part and that would
# lead to flickering
self.voxelStableTex = Texture("VoxelsStable")
self.voxelStableTex.setup3dTexture(self.voxelGridResolution.x, self.voxelGridResolution.y,
self.voxelGridResolution.z, Texture.TFloat, Texture.FRgba8)
# Set appropriate filter types:
# The stable texture has mipmaps, which are generated during the process.
# This is required for cone tracing.
self.voxelStableTex.setMagfilter(SamplerState.FTLinear)
self.voxelStableTex.setMinfilter(SamplerState.FTLinearMipmapLinear)
self.voxelStableTex.setWrapU(SamplerState.WMBorderColor)
self.voxelStableTex.setWrapV(SamplerState.WMBorderColor)
self.voxelStableTex.setWrapW(SamplerState.WMBorderColor)
self.voxelStableTex.setBorderColor(Vec4(0,0,0,0))
MemoryMonitor.addTexture("Voxel Grid Texture", self.voxelStableTex)
# Setups the render target to convert the voxel grid
self.convertBuffer = RenderTarget("VoxelConvertBuffer")
self.convertBuffer.setSize(self.voxelGridResolution.x, self.voxelGridResolution.y)
self.convertBuffer.setColorWrite(False)
# self.convertBuffer.addColorTexture()
self.convertBuffer.prepareOffscreenBuffer()
self.convertBuffer.setShaderInput("src", self.voxelizePass.getVoxelTex())
self.convertBuffer.setShaderInput("dest", self.voxelStableTex)
self.convertBuffer.setActive(False)
# Store the frame index, we need that to decide which step we are currently
# doing
self.frameIndex = 0
# Create the various render targets to generate the mipmaps of the stable voxel grid
self.mipmapTargets = []
computeSize = LVecBase3i(self.voxelGridResolution)
currentMipmap = 0
while computeSize.z > 1:
computeSize /= 2
target = RenderTarget("GIMiplevel" + str(currentMipmap))
target.setSize(computeSize.x, computeSize.y)
target.setColorWrite(False)
# target.addColorTexture()
target.prepareOffscreenBuffer()
target.setActive(False)
target.setShaderInput("sourceMipmap", currentMipmap)
target.setShaderInput("source", self.voxelStableTex)
target.setShaderInput("dest", self.voxelStableTex, False, True, -1, currentMipmap + 1)
self.mipmapTargets.append(target)
currentMipmap += 1
# Create the final gi pass
self.finalPass = GlobalIlluminationPass()
self.pipeline.getRenderPassManager().registerPass(self.finalPass)
self.pipeline.getRenderPassManager().registerDynamicVariable("giVoxelGridData", self.bindTo)
def _showDebugOutput(self):
""" Lists the available debug options """
print "\n" * 5
print "DEBUG MENU"
print "-" * 50
print "Select an option:"
print "\t(1) Connect to pstats"
print "\t(2) Toggle frame rate meter"
print "\t(3) Reset to initial position"
print "\t(4) Display camera position"
print "\t(5) Show scene graph"
print "\t(6) Open placement window"
print "\t(7) Analyze VRAM"
print
selectedOption = raw_input("Which do you want to choose?: ")
try:
selectedOption = int(selectedOption.strip())
except:
print "Option has to be a valid number!"
return False
if selectedOption < 1 or selectedOption > 7:
print "Invalid option!"
return False
# pstats
if selectedOption == 1:
print "Connecting to pstats .."
print "If you have no pstats running, this will take 5 seconds to timeout .."
PStatClient.connect()
# frame rate meter
elif selectedOption == 2:
print "Toggling frame rate meter .."
self.showbase.setFrameRateMeter(not self.showbase.frameRateMeter)
# initial position
elif selectedOption == 3:
print "Reseting camera position / hpr .."
self._resetToInitial()
# display camera pos
elif selectedOption == 4:
print "Debug information:"
campos = self.showbase.cam.getPos(self.showbase.render)
camrot = self.showbase.cam.getHpr(self.showbase.render)
print "camPos = Vec3(" + str(round(campos.x, 2)) + "," + str(
round(campos.y, 2)) + "," + str(round(campos.z, 2)) + ")"
print "camHpr = Vec3(" + str(round(camrot.x, 2)) + "," + str(
round(camrot.y, 2)) + "," + str(round(camrot.z, 2)) + ")"
# show scene graph
elif selectedOption == 5:
print "SCENE GRAPH:"
print "-" * 50
self.showbase.render.ls()
print "-" * 50
print
print "ANALYZED:"
print "-" * 50
self.showbase.render.analyze()
print "-" * 50
# placement window
elif selectedOption == 6:
print "Opening placement window. You need tkinter installed to be able to use it"
self.showbase.render.place()
# print "It seems .place() is currently not working. Sorry!!"
# vram analyszs
elif selectedOption == 7:
print "Analyzing VRAM ..."
MemoryMonitor.analyzeMemory()
def setup(self):
""" Setups everything for the GI to work """
assert(self.distributionSteps % 2 == 0)
self._createDebugTexts()
self.pipeline.getRenderPassManager().registerDefine("USE_GLOBAL_ILLUMINATION", 1)
self.pipeline.getRenderPassManager().registerDefine("GI_SLIDE_COUNT", self.slideCount)
self.pipeline.getRenderPassManager().registerDefine("GI_QUALITY_LEVEL", self.qualityLevelIndex)
# make the grid resolution a constant
self.pipeline.getRenderPassManager().registerDefine("GI_GRID_RESOLUTION", self.voxelGridResolution)
self.taskManager.addTask(3, self.stepVoxelize)
self.taskManager.addTask(self.distributionSteps, self.stepDistribute)
# Create the voxelize pass which is used to voxelize the scene from
# several directions
self.voxelizePass = VoxelizePass(self.pipeline)
self.voxelizePass.setVoxelGridResolution(self.voxelGridResolution)
self.voxelizePass.setVoxelGridSize(self.voxelGridSize)
self.voxelizePass.setGridResolutionMultiplier(1)
self.pipeline.getRenderPassManager().registerPass(self.voxelizePass)
self.generationTextures = []
# Create the buffers used to create the voxel grid
for color in "rgb":
tex = Texture("VoxelGeneration-" + color)
tex.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TInt, Texture.FR32)
tex.setClearColor(Vec4(0))
self.generationTextures.append(tex)
Globals.render.setShaderInput("voxelGenDest" + color.upper(), tex)
MemoryMonitor.addTexture("VoxelGenerationTex-" + color.upper(), tex)
self.bindTo(Globals.render, "giData")
self.convertGridTarget = RenderTarget("ConvertGIGrid")
self.convertGridTarget.setSize(self.voxelGridResolution * self.slideCount, self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.convertGridTarget.addColorTexture()
self.convertGridTarget.prepareOffscreenBuffer()
# Set a near-filter to the texture
if self.pipeline.settings.useDebugAttachments:
self.convertGridTarget.getColorTexture().setMinfilter(Texture.FTNearest)
self.convertGridTarget.getColorTexture().setMagfilter(Texture.FTNearest)
self.clearGridTarget = RenderTarget("ClearGIGrid")
self.clearGridTarget.setSize(self.voxelGridResolution * self.slideCount, self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.clearGridTarget.addColorTexture()
self.clearGridTarget.prepareOffscreenBuffer()
for idx, color in enumerate("rgb"):
self.convertGridTarget.setShaderInput("voxelGenSrc" + color.upper(), self.generationTextures[idx])
self.clearGridTarget.setShaderInput("voxelGenTex" + color.upper(), self.generationTextures[idx])
# Create the data textures
self.dataTextures = []
self.directions = ["PosX", "NegX", "PosY", "NegY", "PosZ", "NegZ"]
for i, direction in enumerate(self.directions):
tex = Texture("GIDataTex" + direction)
tex.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TFloat, Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelDataTex-" + direction, tex)
self.dataTextures.append(tex)
self.pipeline.getRenderPassManager().registerStaticVariable("giVoxelData" + direction, tex)
# Create ping / pong textures
self.pingDataTextures = []
self.pongDataTextures = []
for i, direction in enumerate(self.directions):
texPing = Texture("GIPingDataTex" + direction)
texPing.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TFloat, Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelPingDataTex-" + direction, texPing)
self.pingDataTextures.append(texPing)
texPong = Texture("GIPongDataTex" + direction)
texPong.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TFloat, Texture.FR11G11B10)
MemoryMonitor.addTexture("VoxelPongDataTex-" + direction, texPong)
self.pongDataTextures.append(texPong)
self.convertGridTarget.setShaderInput("voxelDataDest"+direction, self.pingDataTextures[i])
# self.clearGridTarget.setShaderInput("voxelDataDest" + str(i), self.pongDataTextures[i])
# Set texture wrap modes
for tex in self.pingDataTextures + self.pongDataTextures + self.dataTextures + self.generationTextures:
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
tex.setWrapU(Texture.WMBorderColor)
tex.setWrapV(Texture.WMBorderColor)
tex.setWrapW(Texture.WMBorderColor)
tex.setAnisotropicDegree(0)
tex.setBorderColor(Vec4(0))
for tex in self.dataTextures:
tex.setMinfilter(Texture.FTLinear)
tex.setMagfilter(Texture.FTLinear)
self.distributeTarget = RenderTarget("DistributeVoxels")
self.distributeTarget.setSize(self.voxelGridResolution * self.slideCount, self.voxelGridResolution * self.slideVertCount)
if self.pipeline.settings.useDebugAttachments:
self.distributeTarget.addColorTexture()
self.distributeTarget.prepareOffscreenBuffer()
# Set a near-filter to the texture
if self.pipeline.settings.useDebugAttachments:
self.distributeTarget.getColorTexture().setMinfilter(Texture.FTNearest)
self.distributeTarget.getColorTexture().setMagfilter(Texture.FTNearest)
self.distributeTarget.setShaderInput("isLastStep", False)
# Create solidness texture
self.voxelSolidTex = Texture("GIDataSolidTex")
self.voxelSolidTex.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TFloat, Texture.FR16)
self.convertGridTarget.setShaderInput("voxelSolidDest", self.voxelSolidTex)
self.distributeTarget.setShaderInput("voxelSolidTex", self.voxelSolidTex)
MemoryMonitor.addTexture("VoxelSolidTex", self.voxelSolidTex)
self.voxelSolidStableTex = Texture("GIDataSolidStableTex")
self.voxelSolidStableTex.setup3dTexture(self.voxelGridResolution, self.voxelGridResolution, self.voxelGridResolution, Texture.TFloat, Texture.FR16)
self.distributeTarget.setShaderInput("voxelSolidWriteTex", self.voxelSolidStableTex)
self.pipeline.getRenderPassManager().registerStaticVariable("giVoxelSolidTex", self.voxelSolidStableTex)
# Create the final gi pass
self.finalPass = GlobalIlluminationPass()
self.pipeline.getRenderPassManager().registerPass(self.finalPass)
self.pipeline.getRenderPassManager().registerDynamicVariable("giData", self.bindTo)
self.pipeline.getRenderPassManager().registerStaticVariable("giReadyState", self.readyStateFlag)
# Visualize voxels
if False:
self.voxelCube = loader.loadModel("Box")
self.voxelCube.reparentTo(render)
# self.voxelCube.setTwoSided(True)
self.voxelCube.node().setFinal(True)
self.voxelCube.node().setBounds(OmniBoundingVolume())
self.voxelCube.setInstanceCount(self.voxelGridResolution**3)
# self.voxelCube.hide()
self.bindTo(self.voxelCube, "giData")
for i in xrange(5):
self.voxelCube.setShaderInput("giDataTex" + str(i), self.pingDataTextures[i])
self.disableTargets()
