OpenGLContext.scenegraph.text.font

Abstract base-class for all font implementations

Classes

class BitmapFontMixIn( object ):
Mix-in providing justification routines for bitmap fonts
For OpenGL 3.1 and beyond, we'll need some more bookkeeping done at the font level, basically we'll have X textures/shaders per font. The characters to render for the shader will all be composed into a single VBO to be rendered. Changing the text will update the VBO set (which is a fairly small data-set, as it's just the quads involved).
Each character needs a reference to the texture involved as well as the texture-coordinates for the 4 vertices.
So we're going to wind up getting a general "compile" operation that iterates over all lines which use a Font, gathering the (translated) coordinates to pass to the renderer, when those are all gathered, we render the data-set to the card in one go...
centerJustify( self , lines , fontStyle , mode = None )
Center-justify a list of lines
leftJustify( self , lines , fontStyle , mode = None )
Left-justify a list of lines
render( self , * args , ** named )
Special depth-buffer mode for direct-to-screen bitmap fonts
Basically we don't want the direct-to-screen bitmap fonts to generate depth-buffer blocks.
rightJustify( self , lines , fontStyle , mode = None )
Right-justify a list of lines
class CharacterMetrics( object ):
Storage for character metrics
__init__( self , char , width , height )
__repr__( self )
class Font( object ):
Abstract base-class for all font implementations
__del__( self )
Clean up our display lists on deletion
centerJustify( self , lines , fontStyle , mode = None )
Center-justify a list of lines
createChar( self , char , fontStyle , mode = None )
Create the single-character display list
getChar( self , char , mode = None )
Get (and/or create) a single-character display-list (with metrics)
getSpacing( self , fontStyle , mode = None )
Get the vertical spacing multiplier
leftJustify( self , lines , fontStyle , mode = None )
Left-justify a list of lines
lineHeight( self , mode = None )
Retrieve normal line-height for this font
lists( self , value , mode = None )
Get a sequence of display-list integers for value
Basically, this does a bit of trickery to do as-required compilation of display-lists, so that only those characters actually required by the displayed text are compiled.
NOTE: Must be called from within the rendering thread and within the rendering pass!
normalise( self , value )
Return a normalised value for the given value
In our case, this means decoding utf-8 strings if they are passed.
render( self , lines , fontStyle = None , mode = None )
Render value in this font, with control-character support
lines
list of Line objects to be rendered, alternately a string/unicode object to be converted to lines with self.toLines( lines, mode=mode )
mode
active rendering mode
rightJustify( self , lines , fontStyle , mode = None )
Right-justify a list of lines
toLines( self , value , mode = None )
Convert value to a set of expanded lines
Basically what this does is split value by line, then expand tabs (using 4-spaces per-tab), then return a list of Line instances for the resulting strings.
totalHeight( self , lines , spacing , mode = None )
Calculate total height of the line-set
totalWidth( self , lines , mode = None )
Calculate total width of the line-set
verticalAdjust( self , spacing , lines , fontStyle , mode = None )
Calculate adjustement for first line's position
This needs to take into account the fontStyle's "minor" alignment, which specifies one of: FIRST -- use the bottom of the first line BEGIN -- if topToBottom true, top of top line, bottom of bottom line otherwise MIDDLE -- y-coordinate middle of the middle-most line END -- if topToBottom true, bottom edge of the last line
class Line( object ):
Holds meta-data about a rendered line of text
__init__( self , base , font , mode = None )
_width( self , mode = None )
Calculate the width of the line
class NoDepthBufferMixIn( object ):
Mix-in providing disabling of depth-buffer writes
render( self , * args , ** named )
Special depth-buffer mode for direct-to-screen bitmap fonts
Basically we don't want the direct-to-screen bitmap fonts to generate depth-buffer blocks.
class PolygonalFontMixIn( object ):
Mix-in providing justification functions for polygonal text
_centerJustify( self , lines , fontStyle , mode = None )
Center-justify a list of lines
_leftJustify( self , lines , fontStyle , mode = None )
Left-justify a list of lines (actual function)
_rightJustify( self , lines , fontStyle , mode = None )
Right-justify a list of lines
centerJustify( self , lines , fontStyle , mode = None )
Center-justify a list of lines (wrapper to do in child matrix)
leftJustify( self , lines , fontStyle , mode = None )
Left-justify a list of lines (wrapper to do in child matrix)
rightJustify( self , lines , fontStyle , mode = None )
Right-justify a list of lines (wrapper to do in child matrix)
class RenderSelectMixIn( object ):
Mix-in providing quadrangle-based invisible-pass rendering
XXX This should all be display-listed! XXX This is only usable for polygonal geometry!
_centerJustifyQuads( self , lines , fontStyle , mode = None )
Draw center-justified quadrangles
_leftJustifyQuads( self , lines , fontStyle , mode = None )
Draw left-justified quadrangles
_rightJustifyQuads( self , lines , fontStyle , mode = None )
Draw right-justified quadrangles
centerJustify( self , lines , fontStyle , mode = None )
Center-justify a list of lines
leftJustify( self , lines , fontStyle , mode = None )
Left-justify a list of lines
rightJustify( self , lines , fontStyle , mode = None )
Right-justify a list of lines