Detailed Description

A scene node type that renders text.

The text scene node class is a primitive class that renders text using specific styling rules.

Three variants are available: CYIBitmapTextSceneNode, CYIAtlasTextSceneNode, and CYISDFAtlasTextSceneNode. The CYIBitmapTextSceneNode renders its text as a single bitmap rendered on a single quad mesh, the CYIAtlasTextSceneNode object renders glyphs into an atlas texture with a specialized mesh used to select the texture, while the CYISDFAtlasTextSceneNode object also renders glyphs into an atlas but the algorithm used for rendering the glyphs is specialized for applications that use many different fonts and sizes or that want to use animated text.

Box Text vs Point Text

Text can be configured in two different modes, which affect what bounds the text scene node will render into.

First is Box Text. Box text is the typical use case for text and can be enabled by calling the SetBoxTypeOn function. When in Box Text mode, text will be aligned such that the top of the first character is aligned with the (0,0) position of the text scene node. Box text is configured with a specific box width and box height. When justification is used, the text will be aligned within a box defined by the (0,0) position of the text scene node and the configured box size. Any text whose width exceeds the configured box width will be wrapped onto a second line. If a line does not fit within the configured box height, it will not be rendered. This includes the first line – if the first line does not fit within the configured box size, then nothing will be rendered.

Second is Point Text. Point text is used mostly for labels and can be enabled by calling the SetPointTypeOn() function. When in Point Text mode, text will be aligned horizontally around the (0,0) position, taking justification into consideration. For example, if right-justification is used, the right-most rendered character will have its right edge placed at the (0,0) position. Vertically, point text is aligned such that its baseline is at the (0,0) position. Point text can be configured with a maximum width. If the rendered text exceeds this width, the words that do not fit will not be rendered.

Both point text and box text can be configured to insert an ellipsis when some of the text does not fit within the configured bounds.

Sizing

Sizing is used by the layout system to measure and position text scene nodes. The reported size of a text scene node will be the size of the rendered text, not the configured bounds of the text. Furthermore, the reported size of a text scene node will be based on the 'glyph box' of the text rather than on a 'tight fit' of the text. This is to avoid the height of the measured text changing depending on the specific characters that are present in the text. The glyph box is roughly based on the total ascenders and descenders of each line of text (including modified leadings).

Note: Because the size of the text is based on the rendered text rather than on the specified bounds, specifying a minimum width or minimum height may result in an actual size that is below the specified minimums.

Rich Text

Text styles can be set on text scene node. Some of these styles, such as the font size and text color, can be set on a per-character basis. By default, setting those styles will apply to the whole text. However, the setter functions allow for a code point index and length to be provided so that the specific style is applied only to a range of characters. The code point index represent a character index in the text string. These are based on character code points rather than bytes since a character code point may be represented by multiple bytes.

Note: Changing the text does not update the configured text styles. Upon changing the text of a text scene node that has custom per-character styling, it may be necessary to re-configure those styles, or to reset the styles using ResetPerCharacterStyles.

The current style for a specific code point can be accessed using the getters (such as GetFontID ) while specifying a code point index to fetch the style for. If no code point index is specified, the style of the first character in the text is returned.

A specific style can also be set for the 'ellipsis' character. By default, the style of the ellipsis will be the style of the last character in the text (note: not the style of the last rendered character!). To specify a style for the ellipsis regardless of what other styles are present on the text, set a style of length 1 at code point index CYITextEngine::g_uTextEllipsisCodepointIndex.

Notes about the "em" Unit

An em is a unit in the field of typography, equal to the currently specified point size. For example, one em in a 16-point typeface is 16 points. Therefore, this unit is the same for all typefaces at a given point size.

Notes about Code Points

A code point is a character and can be represented by one or more code units depending on the encoding. A code unit is the number of bits an encoding uses. For example, UTF-8 would use 8 units (or bits) and UTF-16 would use 16 units.

Node Properties Specification

Though this class is not a CYISceneView, properties can still be set on it (either through code or in the After Effects workflow).

Label	Default value	Accepted values	Description
text-wrap	normal	none, normal	Specifies if text should wrap when it does not fit in the configured Box Width. Does not apply to Point Text.
text-overflow	off	off, ellipsis	Specifies if an ellipsis should be rendered when the text does not fit in the configured Box. Does not apply to Point Text.
leading	auto	positive decimal numbers	Specifies the spacing between lines of text. If absent, line spacing will be calculated from the font size. Does not apply to Point Text.
markup-parser	youi	none, youi	Specifies the markup parser to use. By default, the You.I text markup parser is used. Set to 'none' to disable parsing of text markup.
text-placeholder	false	true, false	Specifies if text should be exported. This property only affects third party tools which generate text scene nodes. When set to true, those tools will not export the user-entered text.
class	CYIAtlasTextSceneNode	CYIAtlasTextSceneNode, CYIBitmapTextSceneNode, CYISDFAtlasTextSceneNode	Used to select between Atlas, Bitmap and SDF text scene nodes.

When placed within a layout, the usual layout properties can be set to control the size of text scene nodes.

See also: CYILayout

#include <scenetree/YiTextSceneNode.h>

Inheritance diagram for CYITextSceneNode:

[legend]

Classes
struct	YI_TEXT_DEF

struct	YI_TEXT_STYLE_DEF

Public Types
enum	X_JUSTIFY { X_JUSTIFY_LEFT, X_JUSTIFY_RIGHT, X_JUSTIFY_CENTER }

Public Types inherited from CYISceneNode
enum	DirtyFlag { DirtyClean = 0x0000, DirtySceneGraph = 0x0001, DirtyVisibility = 0x0002, DirtyOpacity = 0x0004, DirtyLocalTransform = 0x0008, DirtyWorldTransform = 0x0010, DirtyUniform = 0x0020, DirtyWorldBoundingBox = 0x0040, DirtyMesh = 0x0080, DirtyWorldSurfaceScale = 0x0100, DirtyWorldScale = 0x0200, DirtyLocalBoundingBox = 0x0400, DirtyEverything = (DirtySceneGraph \| DirtyVisibility \| DirtyOpacity \| DirtyLocalTransform \| DirtyWorldTransform \| DirtyUniform \| DirtyWorldBoundingBox \| DirtyWorldSurfaceScale \| DirtyWorldScale \| DirtyLocalBoundingBox) }

enum	LayoutDirtyFlag { LayoutClean, LayoutChildDirty, LayoutDirty }

enum	LayoutConfigFetchMode { LAYOUT_CONFIG_DO_NOT_LAZY_INSTANTIATE = 0, LAYOUT_CONFIG_LAZY_INSTANTIATE }

enum	MeasureMode { MEASURE_UNSPECIFIED, MEASURE_UP_TO, MEASURE_EXACTLY }

enum	FETCH_TYPE { FETCH_OPTIONAL = 0, FETCH_MANDATORY }

typedef std::reverse_iterator< Iterator >	ReverseIterator

Public Types inherited from CYIEventTarget
enum	EVENT_PHASE { BUBBLE, CAPTURE }

Public Member Functions
	CYITextSceneNode ()

virtual	~CYITextSceneNode ()

float	GetTextWidth ()

float	GetTextHeight ()

YI_FLOAT_RECT	CalculateTightTextRect ()

virtual YI_FLOAT_RECT_REL	CalculateGlyphBox ()

void	SetTextOffsetX (float fTextOffsetX)

void	SetTextMaxWidth (float fMaxWidth)

bool	SetFont (const CYIString &fontFamilyName, const CYIString &fontStyle, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetFontID (ssize_t nFontID, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

bool	SetFontFamily (const CYIString &fontFamilyName, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

bool	SetFontStyle (const CYIString &fontStyleName, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetFontSize (int32_t nFontSize, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetFontColor (const CYIColor &Color, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetAllCaps (bool bEnable, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetScriptMode (YI_SCRIPT_MODE eScriptMode, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetBaselineShift (int32_t nBaselineShift, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetTracking (int32_t nBaselineShift, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetKerning (int32_t nBaselineShift, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetLeading (int32_t uLeading, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

void	SetEllipses (bool bEnable)

void	SetMultiline (bool bEnable)

virtual void	SetSize (const glm::vec3 &vSize, bool bDirtyLayout=true) override

void	SetText (const CYIString &rText)

void	SetMarkedUpText (const CYIString &rMarkedUpText, CYITextMarkupParser pMarkupParser=nullptr, const CYICustomMarkupTagsProvider pExternalTagsProvider=nullptr)

void	SetXJustify (X_JUSTIFY eXJustify)

void	SetPointTypeOn (int32_t nWidth=0)

void	SetBoxTypeOn (int32_t nBoxWidth, int32_t nBoxHeight)

void	SetLineStyle (YI_TEXT_LINE_STYLE eTextLineStyle, uint32_t uFirstCodepointIndex=0, uint32_t uLength=std::numeric_limits< uint32_t >::max())

float	GetTextOffsetX () const

const CYIString &	GetText () const

const CYIString &	GetMarkedUpText () const

int32_t	GetLength () const

X_JUSTIFY	GetXJustify () const

bool	GetMultiline () const

bool	GetEllipses () const

ssize_t	GetFontID (uint32_t uCodepointIndex=0) const

const CYIString &	GetFontFamily (uint32_t uCodepointIndex=0) const

const CYIString &	GetFontStyle (uint32_t uCodepointIndex=0) const

int32_t	GetFontSize (uint32_t uCodepointIndex=0) const

const CYIColor &	GetFontColor (uint32_t uCodepointIndex=0) const

bool	IsAllCaps (uint32_t uCodepointIndex=0) const

YI_TEXT_LINE_STYLE	GetLineStyle (uint32_t uCodepointIndex=0) const

int32_t	GetLeading (uint32_t uCodepointIndex=0) const

YI_SCRIPT_MODE	GetScriptMode (uint32_t uCodepointIndex=0) const

int32_t	GetBaselineShift (uint32_t uCodepointIndex=0) const

int32_t	GetTracking (uint32_t uCodepointIndex=0) const

int32_t	GetKerning (uint32_t uCodepointIndex=0) const

const std::vector< YI_TEXT_STYLE_DEF > &	GetTextStyles () const

const YI_TEXT_STYLE_DEF &	GetTextStyle (uint32_t uCodepointIndex) const

void	SetTextStyle (const YI_TEXT_STYLE_DEF &style, uint32_t uFirstCodepointIndex)

void	SetTextStyles (const std::vector< YI_TEXT_STYLE_DEF > &styles)

void	SetEllipsisStyle (const YI_TEXT_STYLE_DEF &style)

void	ResetPerCharacterStyles ()

int32_t	GetBoxWidth () const

int32_t	GetBoxHeight () const

void	SetUseFontTables (bool bUseFontTables)

bool	IsUsingFontTables () const

bool	IsBoxType () const

bool	IsPointType () const

virtual YI_FLOAT_RECT	GetRectForTextRange (int32_t nStartIndex, int32_t nEndIndex, float fHorizontalPixelRatio, float fVerticalPixelRatio)

int32_t	GetIndexOfPosition (float fX, float fY, float fHorizontalPixelRatio, float fVerticalPixelRatio)

virtual void	Measure (const MeasureSpec &widthSpec, const MeasureSpec &heightSpec, const MeasureSpec &depthSpec) override

virtual void	ApplyMeasurements () override

Public Member Functions inherited from CYISceneNode
	CYISceneNode ()

virtual	~CYISceneNode ()

virtual bool	Init ()

void	ForceDirty ()

void	ClearDirtyFlag ()

void	SetDirtyFlag (DirtyFlag eDirtyFlag)

DirtyFlag	GetDirtyFlag () const

DirtyFlag	GetPreviousDirtyFlag () const

const CYIString &	GetName () const

CYIString	GetUniqueName () const

void	SetSceneManager (CYISceneManager *pSceneManager)

void	SetName (const CYIString &name)

int32_t	GetID () const

void	SetID (int32_t nID)

uint64_t	GetUniqueID () const

bool	AddChild (std::unique_ptr< CYISceneNode > pSceneNode)

bool	AddChild (std::unique_ptr< CYISceneNode >, int32_t nIndex)

bool	InsertChildAfter (CYISceneNode *pRefNode, std::unique_ptr< CYISceneNode > pSceneNode)

std::unique_ptr< CYISceneNode >	RemoveChild (CYISceneNode *pSceneNode)

bool	ReorderChild (uint32_t uFromIndex, uint32_t uToIndex)

CYISceneNode *	GetParent () const

bool	ChangeParent (CYISceneNode *pParent)

CYISceneNode *	GetDrawParent () const

bool	IsAncestorOf (const CYISceneNode *pNode) const

CYISceneManager *	GetSceneManager () const

uint32_t	GetChildCount () const

uint32_t	GetChildCountRecursive () const

CYISceneNode *	GetChild (uint32_t nIndex) const

Iterator	begin (Iterator::ITERATION_MODE eMode=Iterator::IMMEDIATE_CHILDREN) const

Iterator	end (Iterator::ITERATION_MODE eMode=Iterator::IMMEDIATE_CHILDREN) const

ReverseIterator	rbegin (Iterator::ITERATION_MODE eMode=Iterator::IMMEDIATE_CHILDREN) const

ReverseIterator	rend (Iterator::ITERATION_MODE eMode=Iterator::IMMEDIATE_CHILDREN) const

CYISceneNode *	GetChild (const CYIString &sName) const

uint32_t	GetDrawChildCount () const

CYISceneNode *	GetDrawChild (uint32_t uIndex) const

CYISceneNode *	GetDrawChildByID (int32_t nID) const

template<class YI_SCENE_NODE_SUBCLASS >
YI_SCENE_NODE_SUBCLASS *	GetChild (uint32_t uTargetMatchedNodeCount=1) const

template<class YI_SCENE_NODE_SUBCLASS >
std::list< YI_SCENE_NODE_SUBCLASS * >	GetChildren () const

int32_t	GetIndexOfChild (const CYISceneNode *pSceneNode) const

void	Show ()

void	Hide ()

void	SetVisibility (bool bVisible)

void	SetOpacity (float fOpacity)

float	GetCompositeOpacity () const

float	GetLocalOpacity () const

bool	IsVisible () const

bool	IsTrulyVisible () const

CYISceneNode *	GetNode (const CYIString &name)

CYISceneNode *	GetNode (const CYIString &name, const CYIRuntimeTypeInfo &enforceClassType)

CYISceneNode *	GetNode (const CYIRuntimeTypeInfo &enforceClassType)

CYISceneNode *	GetNodeAfterTarget (const CYIRuntimeTypeInfo &enforceClassType, CYISceneNode *pStartAfterTarget)

template<class YI_SCENE_NODE_SUBCLASS >
YI_SCENE_NODE_SUBCLASS *	GetNode (const CYIString &name)

CYISceneNode *	GetNode (const int32_t nID)

CYISceneNode *	GetNode (const int32_t nID, const CYIRuntimeTypeInfo &enforceClassType)

template<class YI_SCENE_NODE_SUBCLASS >
bool	FindNode (YI_SCENE_NODE_SUBCLASS *&pNode, const CYIString &nodeName, FETCH_TYPE eType, const CYIString &tag)

std::list< CYISceneNode * >	GetNodes (const CYIString &name)

std::list< CYISceneNode * >	GetNodes (int32_t nID)

std::list< CYISceneNode * >	GetNodes (const CYIRuntimeTypeInfo &enforceClassType)

template<class YI_SCENE_NODE_SUBCLASS >
const YI_SCENE_NODE_SUBCLASS *	GetNode (uint32_t uTargetMatchedNodeCount=1) const

template<class YI_SCENE_NODE_SUBCLASS >
YI_SCENE_NODE_SUBCLASS *	GetNode (uint32_t uTargetMatchedNodeCount=1)

void	SetMesh (const std::shared_ptr< CYIMesh > &pMesh)

void	SetMaterial (const std::shared_ptr< CYIMaterial > &pMaterial, uint32_t nIndex=0)

void	AddEffect (const std::shared_ptr< CYIEffect > &pEffect)

void	RemoveEffect (const std::shared_ptr< CYIEffect > &pEffect)

uint32_t	GetEffectCount () const

std::shared_ptr< CYIEffect >	GetEffect (uint32_t uIndex) const

void	ConnectEffectsToTimelines (const CYITimelineTrack *pTrack)

void	AddMask (std::unique_ptr< CYIMask > pMask)

std::unique_ptr< CYIMask >	RemoveMask (const CYIMask *pMask)

uint32_t	GetMaskCount () const

const CYIMask *	GetMask (uint32_t uIndex) const

CYIMask *	GetMask (uint32_t uIndex)

const std::shared_ptr< CYIMesh > &	GetMesh () const

uint32_t	GetMaterialCount () const

const std::shared_ptr< CYIMaterial >	GetMaterial (uint32_t nIndex=0) const

const std::shared_ptr< IYIUniformBufferObject > &	GetShaderUniforms () const

void	SetMeshTransform (const glm::mat4 &rTransform)

void	DestroyChildren ()

const glm::mat4 &	GetLocalTransform () const

const glm::mat4 &	GetEffectTransform () const

const glm::mat4 &	GetWorldTransform () const

bool	Intersects (const CYISceneNode *pNode) const

void	SetRenderTarget (const std::shared_ptr< CYIRenderTarget > &pRenderTarget)

const std::shared_ptr< CYIRenderTarget >	GetRenderTarget () const

virtual void	BuildDrawList (std::vector< IYIRenderer::Command > &drawList, CYIAbstractCameraSceneNode *pCameraToDrawWith=nullptr)

const CYIAABB &	GetWorldAABB () const

const CYIAABB &	GetLocalAABB () const

void	SetAnchorPoint (const glm::vec3 &ref)

void	SetAnchorPoint (float fX, float fY, float fZ)

void	SetAnchorPointX (float fX)

void	SetAnchorPointY (float fY)

void	SetAnchorPointZ (float fZ)

void	SetPosition (const glm::vec3 &ref)

void	SetPosition (float fX, float fY, float fZ)

void	SetPositionX (float fX)

void	SetPositionY (float fY)

void	SetPositionZ (float fZ)

void	SetRotation (const glm::vec3 &fEulerDegrees)

void	SetRotation (float fPitchDegrees, float fYawDegrees, float fRollDegrees)

void	SetRotationX (float fPitchDegrees)

void	SetRotationY (float fYawDegrees)

void	SetRotationZ (float fRollDegrees)

void	SetOrientation (float fPitchDegrees, float fYawDegrees, float fRollDegrees)

void	SetOrientation (const glm::quat &orient)

void	SetScale (const glm::vec3 &fScaleFactors)

void	SetScale (float fFactorX, float fFactorY, float fFactorZ)

void	SetScaleX (float fFactor)

void	SetScaleY (float fFactor)

void	SetScaleZ (float fFactor)

const glm::vec3 &	GetPosition () const

const glm::vec3 &	GetScale () const

const glm::vec3 &	GetWorldScale () const

const glm::vec3 &	GetWorldSurfaceScale () const

const glm::vec3 &	GetRotation () const

const glm::quat &	GetOrientation () const

const glm::vec3 &	GetAnchorPoint () const

const glm::vec3 &	GetSize () const

const glm::vec3 &	GetInitialSize () const

void	SetMeasuredSize (const glm::vec3 &vMeasuredSize)

const glm::vec3 &	GetMeasuredSize () const

void	SetInternalCustomTimelineValue (uint32_t nTrackID, const CYIVariant &value)

virtual void	SetCustomTimelineValue (uint32_t nTrackID, const CYIVariant &value)

void	SetClippingOn ()

void	SetClippingOff ()

bool	GetClipping () const

void	SetClippingBox (const CYIAABB &rWorldBox)

const CYIAABB &	GetClippingBox () const

void	StartPropertyAnimation (YI_NODE_PROPERTY_TYPE ePropType, float fFrom, float fTo, uint32_t nDurMs, CYITimeInterpolator *pTimeInterpolator=nullptr, bool bDirtyLayout=true)

void	StopPropertyAnimation (YI_NODE_PROPERTY_TYPE ePropType)

void	UpdateLocalSpaceCollision (CYIActionEvent *pActionEvent)

virtual bool	BroadcastEvent (const std::shared_ptr< CYIEventDispatcher > &pDispatcher, CYIEvent *pEvent)

void	UpdateEventForLocalSpace (CYIActionEvent *pActionEvent, glm::vec3 &rayOrigin, glm::vec3 &rayNonOriginPoint) const

bool	IsBoundingBoxHit (const CYIRay &rWorldSpaceRay) const

bool	IsMeshHit (const CYIRay &rWorldSpaceRay) const

void	DumpTree () const

void	StartCaptureKeyboardEvents ()

void	StopCaptureKeyboardEvents ()

void	StartCaptureTrackpadEvents ()

void	StopCaptureTrackpadEvents ()

void	StartCapturePointerEvents (uint8_t uPointerID)

void	StopCapturePointerEvents (uint8_t uPointerID)

bool	DrawBehindChildren (CYISceneNode *pSceneNode)

bool	DrawInFrontOfChildren (CYISceneNode *pSceneNode)

bool	DrawBehind (CYISceneNode *pSceneNode)

bool	DrawInFront (CYISceneNode *pSceneNode)

bool	IsFocusRoot () const

void	SetIsFocusRoot (bool bIsFocusRoot)

virtual void	OnFocusGainedInDescendants ()

virtual void	FocusGainedInDescendants ()

virtual void	OnFocusLostInDescendants ()

virtual void	FocusLostInDescendants ()

virtual void	OnFocusChangedInDescendants ()

virtual void	FocusChangedInDescendants ()

virtual bool	ContainsFocusableDescendant (const CYIFocusSearchOptions &options=CYIFocusSearchOptions()) const

void	ShowPointerDebugNode (CYIActionEvent *pActionEvent)

void	SetUseLocalTransformAndAlpha (bool bUse)

virtual bool	GetProperty (const CYIString &rPropertyName, CYIString *pValue) const override

virtual const std::map< CYIString, CYIString > &	GetProperties () const override

void	SetProperty (const CYIString &rPropertyName, const CYIString &rPropertyValue)

const std::shared_ptr< CYISceneNodeProxy > &	GetSceneNodeProxy () const

void	SetLayoutConfig (std::unique_ptr< CYILayoutConfig > pLayoutConfig)

const CYILayoutConfig *	GetLayoutConfig (LayoutConfigFetchMode eFetchMode=LAYOUT_CONFIG_LAZY_INSTANTIATE) const

CYILayoutConfig *	GetLayoutConfig (LayoutConfigFetchMode eFetchMode=LAYOUT_CONFIG_LAZY_INSTANTIATE)

void	SetLayoutState (std::unique_ptr< CYILayoutState > pLayoutState)

const CYILayoutState *	GetLayoutState () const

CYILayoutState *	GetLayoutState ()

void	RequestLayout ()

LayoutDirtyFlag	GetLayoutDirtyFlag () const

virtual void	SetLayoutDirtyFlag (LayoutDirtyFlag eFlag)

CYIAbstractCameraSceneNode *	FindActiveCamera () const

template<typename T >
bool	CanCastTo () const

Public Member Functions inherited from CYIEventTarget
	CYIEventTarget ()

virtual	~CYIEventTarget ()

bool	AddEventListener (YI_EVENT_TYPE eEventType, CYIEventHandler *pListener, EVENT_PHASE ePhase=BUBBLE)

bool	RemoveEventListener (YI_EVENT_TYPE eEventType, CYIEventHandler *pListener, EVENT_PHASE ePhase=BUBBLE)

void	SetSpecialTypeFlag (YI_SPECIAL_EVENT_TARGET_TYPE eType)

void	ClearSpecialTypeFlag (YI_SPECIAL_EVENT_TARGET_TYPE eType)

YI_SPECIAL_EVENT_TARGET_TYPE	GetSpecialTypes () const

Public Member Functions inherited from CYIScriptableRTTIObject
	CYIScriptableRTTIObject ()

virtual	~CYIScriptableRTTIObject ()

virtual const CYIRuntimeTypeInfo *	GetRuntimeTypeInfoForScriptObject () const override

Public Member Functions inherited from CYIScriptableObject
	CYIScriptableObject ()

	CYIScriptableObject (const CYIScriptableObject &other)

CYIScriptableObject &	operator= (const CYIScriptableObject &other)

virtual	~CYIScriptableObject ()

CYIBindingImplementation *	GetBindingImplementation () const

void	SetBindingImplementation (CYIBindingImplementation *pBindingImplementation)

Public Member Functions inherited from CYISignalHandler
	CYISignalHandler ()

	CYISignalHandler (const CYISignalHandler &rSignalHandler)

virtual	~CYISignalHandler ()

CYISignalHandler &	operator= (const CYISignalHandler &rSignalHandler)

void	MoveToThread (CYIThread *pThread)
	This function allows the user to override the default thread affinity to any CYIThread that may or may not be running. More...

CYIThreadHandle	GetThreadAffinity () const

void	SetThreadAffinity (const CYIThreadHandle &rThreadAffinity)

virtual bool	IsConnected () const

virtual bool	IsConnected (const CYISignalBase &rSignal) const

void	Disconnect (CYISignalBase &rSignal)

void	DisconnectFromAllSignals ()

Public Member Functions inherited from CYIThread::Listener
	Listener ()

virtual	~Listener ()

virtual void	OnThreadStarted (CYIThread *)

virtual void	OnThreadTerminated (CYIThread *)

virtual void	OnThreadFinished (CYIThread *)

Public Member Functions inherited from IYIPropertiesSource
virtual	~IYIPropertiesSource ()

Protected Member Functions
const std::shared_ptr< const CYITextLayout > &	GetTextLayout (const YI_TEXT_RENDER_INFO &textRenderInfo)

YI_TEXT_RENDER_INFO	CreateTextRenderInfo ()

YI_TEXT_RENDER_INFO	CreateTextRenderInfo (const YI_RECT_REL &textRect)

virtual YI_FLOAT_RECT_REL	CalculateGlyphBox (const YI_RECT_REL &boxRect)

YI_FLOAT_RECT_REL	CalculateGlyphBox (const CYITextLayout *pLayout, const YI_RECT_REL &layoutRect) const

YI_FLOAT_RECT_REL	CalculateGlyphBox (const CYITextLayout *pLayout, const YI_FLOAT_RECT_REL &layoutRect) const

virtual void	PrepareToDraw ()=0

virtual void	TransformUpdated () override

virtual void	UpdateEnd () override

virtual void	WorldSurfaceScaleUpdated () override

virtual CYIString	GetDumpTreeString () const override

void	SetTextDirty ()

virtual void	UpdateTextRect ()

Protected Member Functions inherited from CYISceneNode
void	Update (bool bForceDirty=false)

virtual void	OnUpdateBegin ()

virtual void	UpdateBegin ()

virtual void	OnUpdateEnd ()

virtual void	OnDirtyFlagChanged ()

virtual void	DirtyFlagChanged ()

virtual void	OnTransformUpdated ()

virtual void	OnWorldScaleUpdated ()

virtual void	WorldScaleUpdated ()

virtual void	OnWorldSurfaceScaleUpdated ()

virtual void	OnVisibilityUpdated ()

virtual void	VisibilityUpdated ()

virtual void	OnCompositeOpacityUpdated ()

virtual void	CompositeOpacityUpdated ()

virtual void	OnWorldBoundingBoxUpdated ()

virtual void	WorldBoundingBoxUpdated ()

virtual void	OnLocalBoundingBoxUpdated ()

virtual void	LocalBoundingBoxUpdated ()

virtual void	OnChildAdded (CYISceneNode *pChild)

virtual void	ChildAdded (CYISceneNode *pChild)

virtual void	OnChildRemoved (CYISceneNode *pChild)

virtual void	ChildRemoved (CYISceneNode *pChild)

virtual void	OnSizeChanged ()

virtual void	SizeChanged ()

virtual void	CalculateLocalTransform (glm::mat4 *pTransform) const

virtual void	ChildNeedsLayout ()

virtual void	LayoutDirtied ()

virtual void	OnChildVisibilityChanged (CYISceneNode *pChild)

virtual void	ChildVisibilityChanged (CYISceneNode *pChild)

virtual bool	ProcessEvent (const std::shared_ptr< CYIEventDispatcher > &pDispatcher, CYIEvent *pEvent) override

LayoutDirtyFlag	GetCurrentLayoutDirtyFlag () const

void	DumpTree (int32_t nIndentLevel) const

void	SetShaderUniforms ()

virtual void	SetCustomUniforms ()

template<class T >
void	SetNodeType ()

virtual CYISceneNode *	GetNodeFromChildren (const CYIString &name)

virtual CYISceneNode *	GetNodeFromChildren (const int32_t nID)

virtual CYISceneNode *	GetNodeFromChildren (const CYIRuntimeTypeInfo &enforceClassType)

CYISceneNode *	GetNodeFromChildrenAfterTarget (const CYIRuntimeTypeInfo &enforceClassType, bool pbTargetReached, CYISceneNode pStartAfterTarget)

Protected Member Functions inherited from CYIScriptableRTTIObject
virtual std::pair< const CYIRuntimeTypeInfo , const void >	GetRuntimeTypeInfoWithObject () const =0

Static Protected Member Functions
static bool	HasAllCaps (const YI_TEXT_DEF &rTextDef)

static void	UpdateTextForAllCaps (const YI_TEXT_DEF &rTextDef, CYIString &rText)

Protected Attributes
YI_TEXT_DEF	m_TextDef

CYIString	m_markedUpText

YI_RECT_REL	m_BoxRect

YI_RECT_REL	m_LayoutRect

YI_RECT_REL	m_MeasuredBoxRect

YI_RECT_REL	m_PreferredBoxRect

float	m_fTextMaxWidth

bool	m_bTextBufferDirty

bool	m_bIsBoxType

bool	m_bTextRectDirty

bool	m_bUsesFontTables

Protected Attributes inherited from CYISceneNode
CYIString	m_name

CYISceneNode *	m_pParent

CYISceneNode *	m_pDrawParent

CYISceneManager *	m_pSceneManager

std::vector< std::unique_ptr< CYISceneNode > >	m_children

std::vector< CYISceneNode * >	m_drawChildren

std::map< CYIString, CYIString >	m_Properties

std::vector< std::shared_ptr< CYIMaterial > >	m_pMaterials

std::vector< std::unique_ptr< CYIMask > >	m_Masks

std::vector< std::shared_ptr< CYIEffect > >	m_Effects

std::vector< PropertyAnimation * >	m_propertyAnimations

float	m_fLocalOpacity

CYIAABB	m_WSClipBox

glm::mat4	m_EffectTransform

glm::quat	m_Orientation

glm::vec3	m_Rotate

glm::vec3	m_AnchorPoint

glm::vec3	m_Position

glm::vec3	m_Scale

glm::vec3	m_vSize

glm::vec3	m_vInitialSize

glm::vec3	m_vMeasuredSize

glm::vec3	m_vlsLastCollision

bool	m_bClip

bool	m_bIsRotated

bool	m_bIsOriented

bool	m_bLocalVisibility

int32_t	m_nID

uint64_t	m_uGUID

std::shared_ptr< CYIRenderTarget >	m_pRenderTarget

std::shared_ptr< CYIMesh >	m_pMesh

std::shared_ptr< IYIUniformBufferObject >	m_pShaderUniforms

Protected Attributes inherited from CYIEventTarget
YI_SPECIAL_EVENT_TARGET_TYPE	m_eSpecialTypes

std::vector< EventListenerEntry >	m_listeners

Additional Inherited Members
Static Public Member Functions inherited from CYISceneNode
static void	RegisterAllSceneNodes ()

Public Attributes inherited from CYISceneNode
CYISignal< CYISceneNode *, YI_NODE_PROPERTY_TYPE >	PropertyAnimationComplete

CYISignal	DescendantGainedFocus
	Emitted when focus has entered this tree. More...

CYISignal	DescendantLostFocus
	Emitted when focus has left this tree. More...

CYISignal	DescendantsChangedFocus
	Emitted when focus has changed within this tree. More...

Static Public Attributes inherited from CYISceneNode
static const float	OPACITY_NOT_VISIBLE_EPSILON

Member Enumeration Documentation

enum CYITextSceneNode::X_JUSTIFY

Enumerator
X_JUSTIFY_LEFT	Represents left justification for text.
X_JUSTIFY_RIGHT	Represents right justification for text.
X_JUSTIFY_CENTER	Represents center justification for horizontally aligned text.

Constructor & Destructor Documentation

CYITextSceneNode::CYITextSceneNode ( )

virtual CYITextSceneNode::~CYITextSceneNode ( )

virtual

Member Function Documentation

virtual void CYITextSceneNode::ApplyMeasurements ( )

overridevirtual

Applies the measured sizes of this node's children.

Note: Typically, if ApplyMeasurements is overridden then Measure must also be overridden.; Measurements should be applied before calculating position for layout.

Warning: Subclasses that override this function must ensure that the ApplyMeasurements function of ALL children of this scene node is called.

Note: Subclasses that override this function should make use of the GetCurrentLayoutDirtyFlag() function (rather than GetLayoutDirtyFlag() ).

Reimplemented from CYISceneNode.

virtual YI_FLOAT_RECT_REL CYITextSceneNode::CalculateGlyphBox ( )

virtual

Calculates a rectangle around the text. The rectangle is calculated using the glyph box of the individual characters. The height of that glyph box remains constant even if the specific characters renderered change, thus the height of the returned will remain constant so long as the number of lines in the rendered text does not increase. The rectangle is in local coordinate space.

Note: With some characters or fonts, the rendered text may overflow the glyph box.

Reimplemented in CYISDFAtlasTextSceneNode.

virtual YI_FLOAT_RECT_REL CYITextSceneNode::CalculateGlyphBox ( const YI_RECT_REL & boxRect )

protectedvirtual

Returns a tight fitting rectangle that describes the total size of the rendered glyphs including text with multiple lines. The boxRect is used to compute the glyph box size. The returned rectangle is in local space.

Reimplemented in CYISDFAtlasTextSceneNode.

YI_FLOAT_RECT_REL CYITextSceneNode::CalculateGlyphBox	(	const CYITextLayout *	pLayout,
		const YI_RECT_REL &	layoutRect
	)		const

protected

Returns a tight fitting rectangle that describes the total size of the rendered glyphs including text with multiple lines. The pLayout and layoutRect is used to compute the glyph box size. The returned rectangle is in local space.

YI_FLOAT_RECT_REL CYITextSceneNode::CalculateGlyphBox	(	const CYITextLayout *	pLayout,
		const YI_FLOAT_RECT_REL &	layoutRect
	)		const

protected

Returns a tight fitting rectangle that describes the total size of the rendered glyphs including text with multiple lines. The pLayout and layoutRect is used to compute the glyph box size. The returned rectangle is in local space.

Note: This function differs from CalculateGlyphBox(const CYITextLayout *, const YI_FLOAT_RECT_REL &) in that it takes an integer rect as input.

YI_FLOAT_RECT CYITextSceneNode::CalculateTightTextRect ( )

Calculates a tight rectangle around the text. The resulting rectangle is in local coordinate space.

Note: The rectangle top-left corner could contain negative values.

YI_TEXT_RENDER_INFO CYITextSceneNode::CreateTextRenderInfo ( )

protected

Creates and returns a render information object describing this text scene node.

YI_TEXT_RENDER_INFO CYITextSceneNode::CreateTextRenderInfo ( const YI_RECT_REL & textRect )

protected

Creates and returns a render information object describing this text scene node with a size set to textRect.

int32_t CYITextSceneNode::GetBaselineShift ( uint32_t uCodepointIndex = 0 ) const

int32_t CYITextSceneNode::GetBoxHeight ( ) const

Returns the height of the text box - this can be updated by SetBoxTypeOn. Point text does not have a specified height and would return 0.

Note: This does not reflect the size of the actual text.

See also: SetPointTypeOn; SetBoxTypeOn

int32_t CYITextSceneNode::GetBoxWidth ( ) const

Returns the width of the text box - this can be updated by SetPointTypeOn() and SetBoxTypeOn().

Note: This does not reflect the size of the actual text.

See also: SetPointTypeOn; SetBoxTypeOn

virtual CYIString CYITextSceneNode::GetDumpTreeString ( ) const

overrideprotectedvirtual

Returns a string containing useful information about this node, displayed by DumpTree

Subclasses can implement this method to specify different or additional information. Appending to the default string is recommended.

See also: DumpTree()

Reimplemented from CYISceneNode.

bool CYITextSceneNode::GetEllipses ( ) const

const CYIColor& CYITextSceneNode::GetFontColor ( uint32_t uCodepointIndex = 0 ) const

const CYIString& CYITextSceneNode::GetFontFamily ( uint32_t uCodepointIndex = 0 ) const

ssize_t CYITextSceneNode::GetFontID ( uint32_t uCodepointIndex = 0 ) const

int32_t CYITextSceneNode::GetFontSize ( uint32_t uCodepointIndex = 0 ) const

const CYIString& CYITextSceneNode::GetFontStyle ( uint32_t uCodepointIndex = 0 ) const

int32_t CYITextSceneNode::GetIndexOfPosition	(	float	fX,
		float	fY,
		float	fHorizontalPixelRatio,
		float	fVerticalPixelRatio
	)

Returns the glyph index that intersects the coordinate provided. World surface scales are typically used as horizontal and vertical ratios.

int32_t CYITextSceneNode::GetKerning ( uint32_t uCodepointIndex = 0 ) const

int32_t CYITextSceneNode::GetLeading ( uint32_t uCodepointIndex = 0 ) const

int32_t CYITextSceneNode::GetLength ( ) const

YI_TEXT_LINE_STYLE CYITextSceneNode::GetLineStyle ( uint32_t uCodepointIndex = 0 ) const

const CYIString& CYITextSceneNode::GetMarkedUpText ( ) const

bool CYITextSceneNode::GetMultiline ( ) const

virtual YI_FLOAT_RECT CYITextSceneNode::GetRectForTextRange	(	int32_t	nStartIndex,
		int32_t	nEndIndex,
		float	fHorizontalPixelRatio,
		float	fVerticalPixelRatio
	)

virtual

Returns a rectangle in local space describing the dimensions of the text from the starting glyph index to the ending glyph index. The fHorizontalPixelRatio and fVerticalPixelRatio is used to transform the returned rectangle into local space. World surface scales are typically used as horizontal and vertical ratios.

Reimplemented in CYISDFAtlasTextSceneNode.

YI_SCRIPT_MODE CYITextSceneNode::GetScriptMode ( uint32_t uCodepointIndex = 0 ) const

const CYIString& CYITextSceneNode::GetText ( ) const

float CYITextSceneNode::GetTextHeight ( )

Returns the height of the rendered text in local space, including all lines in multi-line text.

Convenience method for retrieving just the height of CalculateTightTextRect.

See also: CalculateTightTextRect

const std::shared_ptr<const CYITextLayout>& CYITextSceneNode::GetTextLayout ( const YI_TEXT_RENDER_INFO & textRenderInfo )

protected

Returns a CYITextLayout object to use for rendering. The layout object will be cached by the text engine.

float CYITextSceneNode::GetTextOffsetX ( ) const

const YI_TEXT_STYLE_DEF& CYITextSceneNode::GetTextStyle ( uint32_t uCodepointIndex ) const

Finds and returns the text style that applies to the code point inde uCodepointIndex.

const std::vector<YI_TEXT_STYLE_DEF>& CYITextSceneNode::GetTextStyles ( ) const

Returns the list of currently-assigned per-character text styles. Each entry in the returned vector represents a range for which the specified text style applies.

float CYITextSceneNode::GetTextWidth ( )

Returns the width of the rendered text in local space, including all lines in multi-line text.

Convenience method for retrieving just the width of CalculateTightTextRect.

See also: CalculateTightTextRect

int32_t CYITextSceneNode::GetTracking ( uint32_t uCodepointIndex = 0 ) const

X_JUSTIFY CYITextSceneNode::GetXJustify ( ) const

static bool CYITextSceneNode::HasAllCaps ( const YI_TEXT_DEF & rTextDef )

staticprotected

Returns true if any text style definition belonging to the text definition has the all caps style applied.

bool CYITextSceneNode::IsAllCaps ( uint32_t uCodepointIndex = 0 ) const

bool CYITextSceneNode::IsBoxType ( ) const

Returns true if the text is a box type.

See also: SetBoxTypeOn

bool CYITextSceneNode::IsPointType ( ) const

Returns true if the text is a point type.

See also: SetPointTypeOn

bool CYITextSceneNode::IsUsingFontTables ( ) const

Returns true if the font table usage is enabled.

virtual void CYITextSceneNode::Measure	(	const MeasureSpec &	widthSpec,
		const MeasureSpec &	heightSpec,
		const MeasureSpec &	depthSpec
	)

overridevirtual

Measures this scene node, considering the layout configuration constraints (if available) and the provided measure specifications. The Measure function is used by the layout system to determine the 'desired' size of elements in a container. The result of calls to this function can be accessed through the GetMeasuredSize() function.

Note: The Measure function may be called multiple times on a single scene node during a layout pass.; The measure specs passed in must take in consideration the node's scale. For example, if a node is calling the Measure function on one of its children and that child has a scale of glm::vec3(1, 3, 1), then the fSize of heightSpec must be divided by 3.; The measured values may exceed the provided measure specifications if the specifications cannot be met given the constraints placed on this scene node. In other words, the constraints placed on this node have a higher priority than the provided measure specifications.

Warning: Subclasses that override this function must ensure that the Measure function of ALL children of this scene node is called at least once, even if those children are hidden.

Note: Typically, if Measure is overridden then ApplyMeasurements must also be overridden.; Subclasses that override this function should make use of the GetCurrentLayoutDirtyFlag() function (rather than GetLayoutDirtyFlag() ).

Reimplemented from CYISceneNode.

virtual void CYITextSceneNode::PrepareToDraw ( )

protectedpure virtual

Called when the bounds of the text have changed but before the text has been drawn. The work performed in this function is usually work that needs to be done in advance of rendering, such as creating a text mesh.

Implemented in CYISDFAtlasTextSceneNode, and CYIAtlasTextSceneNode.

void CYITextSceneNode::ResetPerCharacterStyles ( )

Clears any per-character styles. After calling this function, all of the text set in this object will be rendered with the same style. The style used will be the style currently assigned to the first character.

void CYITextSceneNode::SetAllCaps	(	bool	bEnable,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Specifies if text should be rendered in all caps.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the all caps mode of the whole text.

void CYITextSceneNode::SetBaselineShift	(	int32_t	nBaselineShift,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the baseline shift for the text. The baseline shift specifies how far a character should be moved 'up' away from the baseline. A character with a modified baseline shift will not result in inter-line leading being modified, nor will it result in a larger (or small) glyph box being calculated. Baseline shift is independent of font size, and is specified in composition units. By default, the baseline shift is 0.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the baseline shift of the whole text.

void CYITextSceneNode::SetBoxTypeOn	(	int32_t	nBoxWidth,
		int32_t	nBoxHeight
	)

Sets the type to box type with size given by nBoxWidth and nBoxHeight,

If this text is being converted from point text in AE, also provide nHeightAboveBase and the anchor point of this node will be updated accordingly.

See also: GetBoxWidth; GetBoxHeight

void CYITextSceneNode::SetEllipses ( bool bEnable )

Enables or disables ellipsis on this text scene node. If enabled and this node's text does not fit in the configured text bounds, the unrenderable text will be replaced by an ellipsis.

By default, the ellipsis uses the style of the last style in the text styles list. To set an ellipsis style indepedently of what the rest of the text is styled with, use the code point index CYITextEngine::g_uTextEllipsisCodepointIndex when setting text styles.

void CYITextSceneNode::SetEllipsisStyle ( const YI_TEXT_STYLE_DEF & style )

Sets the text style used for ellipsis.

Note: The m_uLastCodepointIndex value of the style is ignored when setting an ellipsis style.

bool CYITextSceneNode::SetFont	(	const CYIString &	fontFamilyName,
		const CYIString &	fontStyle,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font for the text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font of the whole text.

Note: Unlike the SetFontID() function, calling this function requires that the font identified by fontFamilyName and fontStyle can be found in the text engine at the time where the call to SetFont is made. Returns false without modifying the existing text styles, if the font cannot be found.

See also: SetFontID

void CYITextSceneNode::SetFontColor	(	const CYIColor &	Color,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font color for the text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font color of the whole text.

bool CYITextSceneNode::SetFontFamily	(	const CYIString &	fontFamilyName,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font family for the text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font of the whole text.

Note: This function will attempt to preserve the font style used within the text. If no font has been assigned yet (or if the specified font cannot be found), the style used will fallback to 'Regular'. Unlike the SetFontID() function, all relevant fonts are required to be present in the text engine at the time where the call to SetFontFamily is made. If the effective font used by a section of the text cannot be found (as identified by fontFamilyName and the font style for the relevant text style), this function aborts and returns false without modifying the existing text styles.

See also: SetFontID; SetFont; SetFontStyle

void CYITextSceneNode::SetFontID	(	ssize_t	nFontID,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font ID for the text. The font ID is the ID reported for a specific font by the text engine.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font ID of the whole text.

See also: CYITextEngine

void CYITextSceneNode::SetFontSize	(	int32_t	nFontSize,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font size for the text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font size of the whole text.

bool CYITextSceneNode::SetFontStyle	(	const CYIString &	fontStyleName,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the font style for the text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the font of the whole text.

Note: This function will attempt to preserve the font family used within the text. If no font has been assigned yet (or if the specific font cannot be found), this function aborts and returns false without modifying the existing text styles. Unlike the SetFontID() function, all relevant fonts are required to be present in the text engine at the time where the call to SetFontStyle() is made. If the effective font used by a section of text cannot be found (as identified by fontFamilyStyle and the font family for the relevant text style), this function aborts and returns false without modifying the existing text styles.

See also: SetFontID; SetFont; SetFontFamily

void CYITextSceneNode::SetKerning	(	int32_t	nBaselineShift,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the kerning for the text. The kerning modifies how much space is in between the current character and the previous character, and is typically used to space to specific characters. Kerning is specified in 1/1000 em, and thus is proportional to font size. Positive values increase the inter-character spacing, and negative values decrease inter-character spacing.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the kerning of the whole text.

void CYITextSceneNode::SetLeading	(	int32_t	uLeading,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Set the leading (line spacing) in composition units for the text. Call with a negative value to use automatic leading. By default, the leading is calculated automatically based on the font size.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the leading of the whole text.

void CYITextSceneNode::SetLineStyle	(	YI_TEXT_LINE_STYLE	eTextLineStyle,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Specifies if text should be rendered with line decoration.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the line decoration mode of the whole text.

void CYITextSceneNode::SetMarkedUpText	(	const CYIString &	rMarkedUpText,
		CYITextMarkupParser *	pMarkupParser = `nullptr`,
		const CYICustomMarkupTagsProvider *	pExternalTagsProvider = `nullptr`
	)

Parses the provided marked-up text rMarkedUpText, assigns the parsed text to this node, and assigns parsed text styles to this node.

If pMarkupParser is null, the default You.i Engine text markup parser is used. An 'external tags' provider can optionally be supplied through the pExternalTagsProvider pointer.

Warning: If an external tags provider is supplied, it must be compatible with the provided markup parser (or be compatible with the defualt markup parser if no markup parser is provided).

Note: Existing text styles will be cleared (with the exception of the first text style), and will be replaced with the styles specified in the marked-up text. This is done even if the marked-up text contains no styling markup!; The GetText() function returns the parsed text without markup. The GetMarkedUpText() function can be used to access the original marked-up text.

See also: SetText

void CYITextSceneNode::SetMultiline ( bool bEnable )

Sets the wrapping behaviour of the text. If bEnable is true, text will wrap onto a second line if the text is wider than the box width. If false, only one line of text will be rendered. By default, text does not wrap.

void CYITextSceneNode::SetPointTypeOn ( int32_t nWidth = 0 )

Sets the type to point type. if nWidth is specified and greater than 0, this will count as the maximum width of the node.

The box size of this node will be updated to have a width of nWidth and a height of 0.

Multiline is turned off by default for point text.

See also: GetBoxWidth; GetBoxHeight

void CYITextSceneNode::SetScriptMode	(	YI_SCRIPT_MODE	eScriptMode,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the script mode for the text. The script mode is used to specify if some text should be rendered as superscript, subscript or a regular text.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the script mode of the whole text.

virtual void CYITextSceneNode::SetSize	(	const glm::vec3 &	vSize,
		bool	bDirtyLayout = `true`
	)

overridevirtual

Sets the size of this node to vSize.

Note: Changing the size of a node may affect other properties of the node (such as the mesh size or the node's scale); Subclasses that override this function must call the OnSizeChanged function if the size changed. Subclasses that override this function should dirty the layout if the size changed and bDirtyLayout is true.

Reimplemented from CYISceneNode.

Reimplemented in CYIBitmapTextSceneNode.

void CYITextSceneNode::SetText ( const CYIString & rText )

Sets the text. If this node is point type, passing in text which contains a newline will turn multiline mode on. Setting text without a newline will clear multiline mode.

SetMultiline can be called after SetText to override the automatic multiline setting.

Note: The text will be modified if unicode normalization is required, in which case rText will be normalized, and any calls to GetText() will return the normalized text.

Existing text styles will be preserved when new text is set. Use CYITextSceneNode::ResetPerCharacterStyles() to clear existing text styles.

void CYITextSceneNode::SetTextDirty ( )

protected

Sets the text node dirty state, dirties the screne graph and invalidates the layout.

void CYITextSceneNode::SetTextMaxWidth ( float fMaxWidth )

Sets the maximum width in local space. This value will override the calculated text width, after box width has been applied. Use this in combination with SetTextOffsetX to show only a specified area of the text node.

See also: SetTextOffsetX

void CYITextSceneNode::SetTextOffsetX ( float fTextOffsetX )

Sets the first position in the stored text string to show in local space. Use this in combination with SetTextMaxWidth to show only a specified area of the text node.

See also: SetTextMaxWidth

void CYITextSceneNode::SetTextStyle	(	const YI_TEXT_STYLE_DEF &	style,
		uint32_t	uFirstCodepointIndex
	)

Sets the text style at code point index uFirstCodepointIndex to style.

Some existing text styles may be removed if the provided style completely 'covers' them. Does nothing if the provided style's m_uLastCodepointIndex value is smaller or equal to uCodepointIndex (but a warning will be logged).

void CYITextSceneNode::SetTextStyles ( const std::vector< YI_TEXT_STYLE_DEF > & styles )

Replaces the existing texts styles with those in the provided vector styles.

The last style's uCodepointIndex will be changed to std::numeric_limits<uint32_t>::max() if it isn't already. The styles are expected to be ordered in increasing value of m_uLastCodepointIndex – out of order styles, and those with duplicate m_uLastCodepointIndex values, will be ignored (and a warning will be logged). Does nothing if the provided vector is empty (but a warning will be logged).

Note: Calling this function will also replace the ellipsis style, if such a style exists.

See also: SetEllipsisStyle

void CYITextSceneNode::SetTracking	(	int32_t	nBaselineShift,
		uint32_t	uFirstCodepointIndex = `0`,
		uint32_t	uLength = `std::numeric_limits< uint32_t >::max()`
	)

Sets the tracking for the text. The tracking modifies how much space is in between the current character and the next character, and is typically used on whole words. Tracking is ignored on the last character in a line of text. Tracking is specified in 1/1000 em, and thus is proportional to font size. Positive values increase the inter-character spacing, and negative values decrease inter-character spacing.

Optionally, a range of characters to which the property applies can be specified using uFirstcodepointIndex and uLength. By default, calling this function changes the tracking of the whole text.

void CYITextSceneNode::SetUseFontTables ( bool bUseFontTables )

Turns the usage of font tables on or off. If font table usage is off, kerning and ligatures will not be available.

Note: Font table usage is on by default.

void CYITextSceneNode::SetXJustify ( X_JUSTIFY eXJustify )

Sets the text alignment. The text can be either left-aligned, right-aligned, or centered. The mode of the text (point text or box text) affects what the text is aligned around: for box text, the text is aligned between the configured box bounds. For point text, the text is aligned around the (0,0) point of the text node. The default justification is left-aligned.

virtual void CYITextSceneNode::TransformUpdated ( )

overrideprotectedvirtual

Called by Update() when the transform update process is complete. Subclasses may overload this function to do post-processing.

Warning: The dirty flag will be cleared prior to calling this function to allow new dirty state to be recorded from this function. If querying information about the dirty state of the node, use GetPreviousDirtyFlag().; Overrides must call the base class implementation.

See also: Update(); OnTransformUpdated()

Reimplemented from CYISceneNode.

virtual void CYITextSceneNode::UpdateEnd ( )

overrideprotectedvirtual

This hook provides subclasses a means to do operations subsequent to update. This hook is called after all children of the current node have been updated.

Warning: The dirty flag will be cleared prior to calling this function to allow new dirty state to be recorded from this function. If querying information about the dirty state of the node, use GetPreviousDirtyFlag().; Overrides must call the base class implementation.

See also: Update(); OnUpdateEnd()

Reimplemented from CYISceneNode.

static void CYITextSceneNode::UpdateTextForAllCaps	(	const YI_TEXT_DEF &	rTextDef,
		CYIString &	rText
	)

staticprotected

Applies the all caps styles, if it has been set, to the supplied rText.

virtual void CYITextSceneNode::UpdateTextRect ( )

protectedvirtual

Updates the text rectangle for the text type. Depending on the text type (point or box), the values for width and height may not be calculated until the mesh is created.

virtual void CYITextSceneNode::WorldSurfaceScaleUpdated ( )

overrideprotectedvirtual

Called by Update() when the transform update process is complete and only when the world surface scale has changed. Subclasses may overload this function to do post-processing.

Warning: The dirty flag will be cleared prior to calling this function to allow new dirty state to be recorded from this function. If querying information about the dirty state of the node, use GetPreviousDirtyFlag().

See also: GetWorldSurfaceScale

Warning: Overrides must call the base class implementation.

See also: Update(); OnWorldSurfaceScaleUpdated()

Reimplemented from CYISceneNode.

Reimplemented in CYISDFAtlasTextSceneNode.

Member Data Documentation

bool CYITextSceneNode::m_bIsBoxType

protected

Flag to indicate if the text node type is box

YI_RECT_REL CYITextSceneNode::m_BoxRect

protected

Box dimensions in local space. Used for point type text as well

bool CYITextSceneNode::m_bTextBufferDirty

protected

Flag to indicate that the content has been changed and associated dimensions need to be recalculated

bool CYITextSceneNode::m_bTextRectDirty

protected

Flag indicating the layout needs to be recalculated

bool CYITextSceneNode::m_bUsesFontTables

protected

Flag indicating that FreeType font tables are being used

float CYITextSceneNode::m_fTextMaxWidth

protected

Maximum width of the text in local space

YI_RECT_REL CYITextSceneNode::m_LayoutRect

protected

Used when calculating the glyph box

CYIString CYITextSceneNode::m_markedUpText

protected

Marked-up text for this node.

See also: SetMarkedUpText

YI_RECT_REL CYITextSceneNode::m_MeasuredBoxRect

protected

Measured size for the text

YI_RECT_REL CYITextSceneNode::m_PreferredBoxRect

protected

Original box type size

YI_TEXT_DEF CYITextSceneNode::m_TextDef

protected

Text definition for this node

The documentation for this class was generated from the following file:

scenetree/YiTextSceneNode.h

Detailed Description

Classes

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation