Source code for direct.showbase.BufferViewer

"""Contains the BufferViewer class, which is used as a debugging aid
when debugging render-to-texture effects.  It shows different views at
the bottom of the screen showing the various render targets.

When using ShowBase, the normal way to enable the BufferViewer is using the
following code::

    base.bufferViewer.toggleEnable()

Or, you can enable the following variable in your Config.prc::

    show-buffers true
"""

__all__ = ['BufferViewer']

from panda3d.core import *
from direct.task import Task
from direct.task.TaskManagerGlobal import taskMgr
from direct.directnotify.DirectNotifyGlobal import *
from direct.showbase.DirectObject import DirectObject
import math


[docs]class BufferViewer(DirectObject): notify = directNotify.newCategory('BufferViewer')
[docs] def __init__(self, win, parent): """Access: private. Constructor.""" self.enabled = 0 size = ConfigVariableDouble('buffer-viewer-size', '0 0') self.sizex = size[0] self.sizey = size[1] self.position = ConfigVariableString('buffer-viewer-position', "lrcorner").getValue() self.layout = ConfigVariableString('buffer-viewer-layout', "hline").getValue() self.include = "all" self.exclude = "none" self.cullbin = "fixed" self.cullsort = 10000 self.win = win self.engine = GraphicsEngine.getGlobalPtr() self.renderParent = parent self.cards = [] self.cardindex = 0 self.cardmaker = CardMaker("cubemaker") self.cardmaker.setFrame(-1,1,-1,1) self.task = 0 self.dirty = 1 self.accept("render-texture-targets-changed", self.refreshReadout) if ConfigVariableBool("show-buffers", 0): self.enable(1)
[docs] def refreshReadout(self): """Force the readout to be refreshed. This is usually invoked by GraphicsOutput::add_render_texture (via an event handler). However, it is also possible to invoke it manually. Currently, the only time I know of that this is necessary is after a window resize (and I ought to fix that).""" self.dirty = 1 # Call enabled again, mainly to ensure that the task has been # started. self.enable(self.enabled)
[docs] def isValidTextureSet(self, x): """Access: private. Returns true if the parameter is a list of GraphicsOutput and Texture, or the keyword 'all'.""" if isinstance(x, list): for elt in x: if not self.isValidTextureSet(elt): return 0 else: return (x=="all") or (isinstance(x, Texture)) or (isinstance(x, GraphicsOutput))
[docs] def isEnabled(self): """Returns true if the buffer viewer is currently enabled.""" return self.enabled
[docs] def enable(self, x): """Turn the buffer viewer on or off. The initial state of the buffer viewer depends on the Config variable 'show-buffers'.""" if x != 0 and x != 1: BufferViewer.notify.error('invalid parameter to BufferViewer.enable') return self.enabled = x self.dirty = 1 if (x and self.task == 0): self.task = taskMgr.add(self.maintainReadout, "buffer-viewer-maintain-readout", priority=1)
[docs] def toggleEnable(self): """Toggle the buffer viewer on or off. The initial state of the enable flag depends on the Config variable 'show-buffers'.""" self.enable(1-self.enabled)
[docs] def setCardSize(self, x, y): """Set the size of each card. The units are relative to render2d (ie, 1x1 card is not square). If one of the dimensions is zero, then the viewer will choose a value for that dimension so as to ensure that the aspect ratio of the card matches the aspect ratio of the source-window. If both dimensions are zero, the viewer uses a heuristic to choose a reasonable size for the card. The initial value is (0, 0).""" if x < 0 or y < 0: BufferViewer.notify.error('invalid parameter to BufferViewer.setCardSize') return self.sizex = x self.sizey = y self.dirty = 1
[docs] def setPosition(self, pos): """Set the position of the cards. The valid values are: - *llcorner* - put them in the lower-left corner of the window - *lrcorner* - put them in the lower-right corner of the window - *ulcorner* - put them in the upper-left corner of the window - *urcorner* - put them in the upper-right corner of the window - *window* - put them in a separate window The initial value is 'lrcorner'.""" valid = ["llcorner", "lrcorner", "ulcorner", "urcorner", "window"] if valid.count(pos) == 0: BufferViewer.notify.error('invalid parameter to BufferViewer.setPosition') BufferViewer.notify.error('valid parameters are: llcorner, lrcorner, ulcorner, urcorner, window') return if pos == "window": BufferViewer.notify.error('BufferViewer.setPosition - "window" mode not implemented yet.') return self.position = pos self.dirty = 1
[docs] def setLayout(self, lay): """Set the layout of the cards. The valid values are: - *vline* - display them in a vertical line - *hline* - display them in a horizontal line - *vgrid* - display them in a vertical grid - *hgrid* - display them in a horizontal grid - *cycle* - display one card at a time, using selectCard/advanceCard The default value is 'hline'.""" valid=["vline", "hline", "vgrid", "hgrid", "cycle"] if valid.count(lay) == 0: BufferViewer.notify.error('invalid parameter to BufferViewer.setLayout') BufferViewer.notify.error('valid parameters are: vline, hline, vgrid, hgrid, cycle') return self.layout = lay self.dirty = 1
[docs] def selectCard(self, i): """Only useful when using setLayout('cycle'). Sets the index that selects which card to display. The index is taken modulo the actual number of cards.""" self.cardindex = i self.dirty = 1
[docs] def advanceCard(self): """Only useful when using setLayout('cycle'). Increments the index that selects which card to display. The index is taken modulo the actual number of cards.""" self.cardindex += 1 self.dirty = 1
[docs] def setInclude(self, x): """Set the include-set for the buffer viewer. The include-set specifies which of the render-to-texture targets to display. Valid inputs are the string 'all' (display every render-to-texture target), or a list of GraphicsOutputs or Textures. The initial value is 'all'.""" if not self.isValidTextureSet(x): BufferViewer.notify.error('setInclude: must be list of textures and buffers, or "all"') return self.include = x self.dirty = 1
[docs] def setExclude(self, x): """Set the exclude-set for the buffer viewer. The exclude-set should be a list of GraphicsOutputs and Textures to ignore. The exclude-set is subtracted from the include-set (so the excludes effectively override the includes.) The initial value is the empty list.""" if not self.isValidTextureSet(x): BufferViewer.notify.error('setExclude: must be list of textures and buffers') return self.exclude = x self.dirty = 1
[docs] def setSort(self, bin, sort): """Set the cull-bin and sort-order for the output cards. The default value is 'fixed', 10000.""" self.cullbin = bin self.cullsort = sort self.dirty = 1
[docs] def setRenderParent(self, renderParent): """Set the scene graph root to which the output cards should be parented. The default is render2d. """ self.renderParent = renderParent self.dirty = 1
[docs] def analyzeTextureSet(self, x, set): """Access: private. Converts a list of GraphicsObject, GraphicsEngine, and Texture into a table of Textures.""" if isinstance(x, list): for elt in x: self.analyzeTextureSet(elt, set) elif isinstance(x, Texture): set[x] = 1 elif isinstance(x, GraphicsOutput): for itex in range(x.countTextures()): tex = x.getTexture(itex) set[tex] = 1 elif isinstance(x, GraphicsEngine): for iwin in range(x.getNumWindows()): win = x.getWindow(iwin) self.analyzeTextureSet(win, set) elif x == "all": self.analyzeTextureSet(self.engine, set) else: return
[docs] def makeFrame(self, sizex, sizey): """Access: private. Each texture card is displayed with a two-pixel wide frame (a ring of black and a ring of white). This routine builds the frame geometry. It is necessary to be precise so that the frame exactly aligns to pixel boundaries, and so that it doesn't overlap the card at all.""" format = GeomVertexFormat.getV3c() vdata = GeomVertexData('card-frame', format, Geom.UHDynamic) vwriter = GeomVertexWriter(vdata, 'vertex') cwriter = GeomVertexWriter(vdata, 'color') ringoffset = [0, 1, 1, 2] ringbright = [0, 0, 1, 1] for ring in range(4): offsetx = (ringoffset[ring]*2.0) / float(sizex) offsety = (ringoffset[ring]*2.0) / float(sizey) bright = ringbright[ring] vwriter.addData3f(-1-offsetx, 0, -1-offsety) vwriter.addData3f(1+offsetx, 0, -1-offsety) vwriter.addData3f(1+offsetx, 0, 1+offsety) vwriter.addData3f(-1-offsetx, 0, 1+offsety) cwriter.addData3f(bright, bright, bright) cwriter.addData3f(bright, bright, bright) cwriter.addData3f(bright, bright, bright) cwriter.addData3f(bright, bright, bright) triangles = GeomTriangles(Geom.UHStatic) for i in range(2): delta = i*8 triangles.addVertices(0+delta, 4+delta, 1+delta) triangles.addVertices(1+delta, 4+delta, 5+delta) triangles.addVertices(1+delta, 5+delta, 2+delta) triangles.addVertices(2+delta, 5+delta, 6+delta) triangles.addVertices(2+delta, 6+delta, 3+delta) triangles.addVertices(3+delta, 6+delta, 7+delta) triangles.addVertices(3+delta, 7+delta, 0+delta) triangles.addVertices(0+delta, 7+delta, 4+delta) triangles.closePrimitive() geom = Geom(vdata) geom.addPrimitive(triangles) geomnode=GeomNode("card-frame") geomnode.addGeom(geom) return NodePath(geomnode)
[docs] def maintainReadout(self, task): """Access: private. Whenever necessary, rebuilds the entire display from scratch. This is only done when the configuration parameters have changed.""" # If nothing has changed, don't update. if not self.dirty: return Task.cont self.dirty = 0 # Delete the old set of cards. for card in self.cards: card.removeNode() self.cards = [] # If not enabled, return. if not self.enabled: self.task = 0 return Task.done # Generate the include and exclude sets. exclude = {} include = {} self.analyzeTextureSet(self.exclude, exclude) self.analyzeTextureSet(self.include, include) # Use a custom sampler when applying the textures. This fixes # wrap issues and prevents depth compare on shadow maps. sampler = SamplerState() sampler.setWrapU(SamplerState.WM_clamp) sampler.setWrapV(SamplerState.WM_clamp) sampler.setWrapW(SamplerState.WM_clamp) sampler.setMinfilter(SamplerState.FT_linear) sampler.setMagfilter(SamplerState.FT_nearest) # Generate a list of cards and the corresponding windows. cards = [] wins = [] for iwin in range(self.engine.getNumWindows()): win = self.engine.getWindow(iwin) for itex in range(win.countTextures()): tex = win.getTexture(itex) if (tex in include) and (tex not in exclude): if tex.getTextureType() == Texture.TTCubeMap: for face in range(6): self.cardmaker.setUvRangeCube(face) card = NodePath(self.cardmaker.generate()) card.setTexture(tex, sampler) cards.append(card) elif tex.getTextureType() == Texture.TT2dTextureArray: for layer in range(tex.getZSize()): self.cardmaker.setUvRange((0, 1, 1, 0), (0, 0, 1, 1),\ (layer, layer, layer, layer)) card = NodePath(self.cardmaker.generate()) # 2D texture arrays are not supported by # the fixed-function pipeline, so we need to # enable the shader generator to view them. card.setShaderAuto() card.setTexture(tex, sampler) cards.append(card) else: card = win.getTextureCard() card.setTexture(tex, sampler) cards.append(card) wins.append(win) exclude[tex] = 1 self.cards = cards if len(cards) == 0: self.task = 0 return Task.done ncards = len(cards) # Decide how many rows and columns to use for the layout. if self.layout == "hline": rows = 1 cols = ncards elif self.layout == "vline": rows = ncards cols = 1 elif self.layout == "hgrid": rows = int(math.sqrt(ncards)) cols = rows if rows * cols < ncards: cols += 1 if rows * cols < ncards: rows += 1 elif self.layout == "vgrid": rows = int(math.sqrt(ncards)) cols = rows if rows * cols < ncards: rows += 1 if rows * cols < ncards: cols += 1 elif self.layout == "cycle": rows = 1 cols = 1 else: BufferViewer.notify.error('shouldnt ever get here in BufferViewer.maintainReadout') # Choose an aspect ratio for the cards. All card size # calculations are done in pixel-units, using integers, # in order to ensure that everything ends up neatly on # a pixel boundary. aspectx = wins[0].getXSize() aspecty = wins[0].getYSize() for win in wins: if win.getXSize() * aspecty != win.getYSize() * aspectx: aspectx = 1 aspecty = 1 # Choose a card size. If the user didn't specify a size, # use a heuristic, otherwise, just follow orders. The # heuristic uses an initial card size of 42.66666667% of # the screen vertically, which comes to 256 pixels on # an 800x600 display. Then, it double checks that the # readout will fit on the screen, and if not, it shrinks it. bordersize = 4.0 if (float(self.sizex)==0.0) and (float(self.sizey)==0.0): sizey = int(0.4266666667 * self.win.getYSize()) sizex = (sizey * aspectx) // aspecty v_sizey = (self.win.getYSize() - (rows-1) - (rows*2)) // rows v_sizex = (v_sizey * aspectx) // aspecty if (v_sizey < sizey) or (v_sizex < sizex): sizey = v_sizey sizex = v_sizex adjustment = 2 h_sizex = float (self.win.getXSize() - adjustment) / float (cols) h_sizex -= bordersize if h_sizex < 1.0: h_sizex = 1.0 h_sizey = (h_sizex * aspecty) // aspectx if (h_sizey < sizey) or (h_sizex < sizex): sizey = h_sizey sizex = h_sizex else: sizex = int(self.sizex * 0.5 * self.win.getXSize()) sizey = int(self.sizey * 0.5 * self.win.getYSize()) if sizex == 0: sizex = (sizey * aspectx) // aspecty if sizey == 0: sizey = (sizex * aspecty) // aspectx # Convert from pixels to render2d-units. fsizex = (2.0 * sizex) / float(self.win.getXSize()) fsizey = (2.0 * sizey) / float(self.win.getYSize()) fpixelx = 2.0 / float(self.win.getXSize()) fpixely = 2.0 / float(self.win.getYSize()) # Choose directional offsets if self.position == "llcorner": dirx = -1.0 diry = -1.0 elif self.position == "lrcorner": dirx = 1.0 diry = -1.0 elif self.position == "ulcorner": dirx = -1.0 diry = 1.0 elif self.position == "urcorner": dirx = 1.0 diry = 1.0 else: BufferViewer.notify.error('window mode not implemented yet') # Create the frame frame = self.makeFrame(sizex, sizey) # Now, position the cards on the screen. # For each card, create a frame consisting of eight quads. for r in range(rows): for c in range(cols): index = c + r*cols if index < ncards: index = (index + self.cardindex) % len(cards) posx = dirx * (1.0 - ((c + 0.5) * (fsizex + fpixelx * bordersize))) - (fpixelx * dirx) posy = diry * (1.0 - ((r + 0.5) * (fsizey + fpixely * bordersize))) - (fpixely * diry) placer = NodePath("card-structure") placer.setPos(Point3.rfu(posx, 0, posy)) placer.setScale(Vec3.rfu(fsizex*0.5, 1.0, fsizey*0.5)) placer.setBin(self.cullbin, self.cullsort) placer.reparentTo(self.renderParent) frame.instanceTo(placer) cards[index].reparentTo(placer) cards[index] = placer return Task.cont
# Snake-case aliases, for people who prefer these. advance_card = advanceCard analyze_texture_set = analyzeTextureSet is_enabled = isEnabled is_valid_texture_set = isValidTextureSet maintain_readout = maintainReadout make_frame = makeFrame refresh_readout = refreshReadout select_card = selectCard set_card_size = setCardSize set_exclude = setExclude set_include = setInclude set_layout = setLayout set_position = setPosition set_render_parent = setRenderParent set_sort = setSort toggle_enable = toggleEnable