Inherits DirectObject.

Public Member Functions
def	__init__
def	cleanup
def	enterRegion
def	findAvailableHoles
def	findEmptyRuns
def	findHole
def	findHolePieces
def	findLargestHole
def	findOverflowHole
def	formatSize
def	graphicsMemoryLimitChanged
def	isolateTexture
def	leaveRegion
def	makeCanvasBackground
def	mouseClick
def	placeTexture
def	reconfigureWindow
def	repack
def	setLimit
def	setRollover
def	setupCanvas
def	setupGui
def	unplaceTexture
def	updateTextures
def	windowEvent
Public Attributes
	area
	aspect2d
	background
	bitmasks
	canvas
	canvasBackground
	canvasDR
	canvasLens
	canvasRoot
	checkTex
	cleanedUp
	dynamicLimit
	gsg
	h
	isolate
	isolated
	lens
	limit
	lruLimit
	maxHeight
	mouse
	mw
	name
	needsRepack
	nextTexRecordKey
	pipe
	placedQSize
	placedSize
	quantize
	render2d
	rollover
	sizeText
	sizeTextNP
	status
	statusBackground
	statusText
	statusTextNP
	task
	texPlacements
	texRecordsByKey
	texRecordsByTex
	top
	totalSize
	w
	win
	winSize
Static Public Attributes
int	NextIndex = 1
int	StatusHeight = 20

Detailed Description

This class creates a separate graphics window that displays an
approximation of the current texture memory, showing the textures
that are resident and/or active, and an approximation of the
amount of texture memory consumed by each one.  It's intended as a
useful tool to help determine where texture memory is being spent.

Although it represents the textures visually in a 2-d space, it
doesn't actually have any idea how textures are physically laid
out in memory--but it has to lay them out somehow, so it makes
something up.  It occasionally rearranges the texture display when
it feels it needs to, without regard to what the graphics card is
actually doing.  This tool can't be used to research texture
memory fragmentation issues.

Constructor & Destructor Documentation

def __init__	(	self,
		gsg = `None`,
		limit = `None`
	)

Member Function Documentation

def cleanup ( self )

def enterRegion	(	self,
		region,
		buttonName
	)

the mouse has rolled over a texture.

def findAvailableHoles	(	self,
		area,
		w = `None`,
		h = `None`
	)

Finds a list of available holes, of at least the indicated
area.  Returns a list of tuples, where each tuple is of the
form (area, tp).

If w and h are non-None, this will short-circuit on the first
hole it finds that fits w x h, and return just that hole in a
singleton list.

def findEmptyRuns	(	self,
		bm
	)

Separates a bitmask into a list of (l, r) tuples,
corresponding to the empty regions in the row between 0 and
self.w.

def findHole	(	self,
		area,
		w,
		h
	)

Searches for a rectangular hole that is at least area
square units big, regardless of its shape, but attempt to find
one that comes close to the right shape, at least.  If one is
found, returns an appropriate TexPlacement; otherwise, returns
None.

def findHolePieces	(	self,
		area
	)

Returns a list of holes whose net area sums to the given
area, or None if there are not enough holes.

def findLargestHole ( self )

def findOverflowHole	(	self,
		area,
		w,
		h
	)

Searches for a hole large enough for (w, h), in the
overflow space.  Since the overflow space is infinite, this
will always succeed.

def formatSize	(	self,
		size
	)

Returns a size in MB, KB, GB, whatever.

def graphicsMemoryLimitChanged ( self )

def isolateTexture	(	self,
		tr
	)

Isolates the indicated texture onscreen, or None to
restore normal mode.

def leaveRegion	(	self,
		region,
		buttonName
	)

the mouse is no longer over a texture.

def makeCanvasBackground ( self )

def mouseClick ( self )

Received a mouse-click within the window.  This isolates
the currently-highlighted texture into a full-window
presentation.

def placeTexture	(	self,
		tr
	)

Places the texture somewhere on the canvas where it will
fit.

def reconfigureWindow ( self )

Resets everything for a new window size.

def repack ( self )

Repacks all of the current textures.

def setLimit	(	self,
		limit = `None`
	)

Indicates the texture memory limit.  If limit is None or
unspecified, the limit is taken from the GSG, if any; or there
is no limit.

def setRollover	(	self,
		tr,
		pi
	)

Sets the highlighted texture (due to mouse rollover) to
the indicated texture, or None to clear it.

def setupCanvas ( self )

Creates the "canvas", which is the checkerboard area where
texture memory is laid out.  The canvas has its own
DisplayRegion.

def setupGui ( self )

Creates the gui elements and supporting structures.

def unplaceTexture	(	self,
		tr
	)

Removes the texture from its place on the canvas.

def updateTextures	(	self,
		task
	)

Gets the current list of resident textures and adds new
textures or removes old ones from the onscreen display, as
necessary.

def windowEvent	(	self,
		win
	)

Member Data Documentation

int NextIndex = 1 [static]

int StatusHeight = 20 [static]

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation