OpenGLContext.scenegraph.text.toolsfont

rendering of TTF outlines (as provided by _fonttools)

Classes

class _OutlineFont( Font ):

Outline-Glyph specialisation of a fonttools-based font

class _SolidFont( Font ):

Solid-Glyph specialisation of a fonttools-based font

class _ToolsFontProvider( TTFFontProvider ):

Singleton for creating new ToolsFont fonts

__init__( self , fontClass )

create( self , fontStyle , mode = None )

Create a new font for the given fontStyle and mode

key( self , fontStyle , mode = None )

Calculate the key for the fontStyle

match( self , fontStyle , mode = None )

Attempt to find matching font-file for our fontstyle

Should match any name passed into addFontFile, as well as the short filename for the font.

class OutlineGlyph( Glyph ):

Glyph that can render to outlines, contours and control-points

renderAdvance( self , scale = 400.0 )

Advance the rendering position by our advance width

renderContours( self , scale = 400.0 )

Render the contour "hulls" which control the outline

renderControlPoints( self , scale = 400.0 )

Render the contour control points as dots

renderOutlines( self , scale = 400.0 )

Simplistic rendering of the compiled outlines

class SolidGlyph( OutlineGlyph ):

Glyph composed of triangle geometry

_calculateCapData( self , scale = 400.0 )

Calculate the tessellated data-sets for this glyph

_calculateExtrusionData( self , scale = 400.0 )

Calculate extrusion points + normals for the glyph

renderCap( self , scale = 400.0 , front = 1 )

The cap is generated with GLU tessellation routines...

renderExtrusion( self , scale = 400.0 , distance = 1.0 )

Render the extrusion of the font backward by distance (using GLE)

This is pretty simple, save that there's no good way to specify the normals for the edge properly :( , basically anything we do is going to look weird because we can only specify one normal for each vertex on the outline.

class ToolsFontMixIn( object ):

Mixin providing ToolsFont common operations

__init__( self , fontStyle = None , font = None )

Initialise the 3D-font object

fontStyle: fontStyle node for this font, normally should be a FontStyle3D node to provide extra information regarding extrusion, capping and the like. Otherwise uses defaults for just about everything.

createChar( self , char , mode = None )

Create the single-character display list

getScale( self )

Calculate scaling from font units to fontStyle size

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!

toLines( self , value , mode = None )

Convert value to a set of expanded lines

Overridden to do entire compilation of the string in one go instead of having each line open the file for each character it finds is missing from the cache.

class ToolsOutlineFont( ToolsFontMixInPolygonalFontMixInFont ):

A FontTools-provided Outline (line-set) Font

XXX should make the debug rendering modes accessible

renderGlyph( self , glyph , mode = None )

Render a single glyph

class ToolsSolidFont( ToolsFontMixInPolygonalFontMixInFont ):

A FontTools-provided Solid (polygonal) Font

renderGlyph( self , glyph , mode = None )

Render a single glyph

This method can render a significant number of sub-components: front-cap rear-cap sides outlines outline-normals contours control-points