Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

Blaze	Blaze is a 2D rasteriser. It it mainly used by InfiniText and canvas in PowerUI as it uniquely performs rapid SDF rendering at runtime, however it can also be used directly. To use it directly, you'll need to create a Scanner object - these can and should be shared globally. The best place to see full usage is the internals of the CanvasContext object.
AtlasEntity	Any object that can be written to an atlas.
AtlasLocation	Represents the location of an image on an atlas.
AtlasStack	A stack of atlases. All graphics from all your UI's are grouped together into one of two stacks like this.
TextureAtlas	Represents a texture atlas which is dynamically added to and modified. Must be used with an AtlasStack. It internally tracks which textures it has to prevent frequent rebuilds. By using a texture atlas like this, many drawcalls can be compressed to one. It also supports dynamic textures. These write directly to the atlas pixels.
UVBlock	Represents a block of four UV coordinates. Commonly shared globally.
DistanceCachePoint	A glyph vector is broken down into a series of points on its outline. These points are added to a grid - the distance cache - and used for fast distance testing during SDF rendering.
DistanceCacheSquare	Each glyph is first broken down into nodes around it's edge (about 50 on average). These nodes are then added into a block of cells in a grid, aka distance cache squares, which they are "in range" of. Each output pixel then checks which of the nodes in the cell it's in is the nearest, and then bases its final colour from that.
Scanner	Performs rasterisation scanning of glyphs/ vectors.
ScannerPixel	Scanner pixels are used during the live raster process. These objects store information about intersects temporarily and are globally cached.
ScannerScanLine	Represents a scan line across a glyph. Used during the raster process. Note that some lines may be empty.
SubRaster	Represents a scanned vector. Essentially one of these is a midway point between the raw vector outline and a bitmap. It has the bonus of being extremely compact in memory yet extremely fast to produce the full bitmap from.
SubScanPixel	Represents a pixel in a scan line. We scan the vector for each row of pixels. Whenever our scanner intersects with the vector, we generate one of these pixels. So the overall count of these for a semi-rastered vector is tiny.
TriangulationVertex	An intermediate vertex which is used for rapid triangulation.
Triangulator
ArcLinePoint	A node which immediately follows an arc.
CurveLinePoint	A node which immediately follows a bezier curve.
MoveToPoint
QuadLinePoint	A node which immediately follows a quadratic curve.
StraightLinePoint	A node which immediately follows a straight line.
VectorLine
VectorPath
VectorPoint
VectorTransform	Used to transform one vector and, in the case of InfiniText, combine it with another.
InfiniText	InfiniText is PowerUI's text management system. It primarily loads font files and then renders glyphs (letters) using the Blaze rasteriser.
Glyph	Represents a character within a font for display on the screen. Extends the InfiniText glyph object. This saves memory and avoids fragmentation.
FontFace	A font face for a particular font family. Note that you must consider if this font face has been loaded (see RequiresLoad) yet if you use deferred loading. The metrics will always be available however - just the glyphs will not be if RequiresLoad is true.
FontFamily	A font family is a collection of font faces (Font objects). A font family is e.g. Arial, and it's faces are e.g. bold and italic variants.
FontLoader
FontParser
Fonts
CompositeGlyph
GlyphPoint	Used as a temporary holder of data during glyph loading.
LoadMetaPoint	A node which stores unloaded glyph information. These are used to help improve glyph load time without causing additional memory usage. This is because they act like a point - the only point in the path.
RightToLeft	A "map" of right-to-left characters. They come in four major blocks. Originally was a map of exceptions from these blocks, but the exceptions are not necessary.
CffGlyphParser
CffStack
CffStackEntry
CffSubPosition
CffTables
CharMapTables
GlyfTables
HeaderTables
HheaTables
HmtxTables
KerningTables
LigatureLookupTable
LigatureSubstitution
LocaTables
MaxpTables
NameTables
OS2Tables
PostTables
GposTables
GsubTables	Loads glyph substitution tables (ligatures). Ligatures are language sensitive. Each language group defines a bunch of "features" a font supports. Features can be, for example, turning 1/2 into a fraction; the "frac" feature.
Nitro	Contains the Nitro script compiler and engine. Part of the Wrench Framework.
Assemblies	Used for obtaining the current assembly.
CodeAssembly	Used for security domains. Represents an assembly that types may be found in.
CodeLexer	Provides a wrapper for reading characters from a string of code. It strips comments and other junk internally such as tabs and spaces.
CodeReference	Represents an in-code using reference. e.g. using System.System.Text;
BreakPoint	Represents a break or continue statement (one which breaks out of a loop, or skips the remaining code within a loop).
CodeFragment	Represents a fragment of the text input code. Once compiled, it becomes a CompiledFragment. CompiledFragments are also types of CodeFragment as this allows them to be parented into the original structure.
ArrayFragment	Represents a new array construct.
BaseFragment	Represents the root node/fragment of all code.
BracketFragment	Represents any pair of brackets.
ConstructorFragment	Represents a constructor call.
ForFragment	Represents a for or while loop.
IfFragment	Represents an if statement.
IndexFragment	Represents something being indexed, e.g. variable[index].
MethodFragment	Represents a method call.
NumberFragment	Represents a fixed number. (e.g. 14).
OperationFragment	Represents a single operation.
OperatorFragment	Represents a usage of an operator (e.g. '+').
PropertyFragment	Represents a property of an object (e.g. something.property).
StringFragment	Represents a fixed text string in the code. (e.g. "hello").
SwitchFragment	Represents a switch block.
TypeFragment	Represents a type. (e.g. new TYPE or :TYPE).
VariableFragment	Represents a variable. These are essentially text in the code that are not keywords. (e.g. hello=14;)
CompilationException	Represents an error in the compilation of some nitro code.
CompilationServices	Provides some global methods for compiling operations into executable instructions.
CompiledClass	Represents a class being compiled from a nitro code string.
CompiledFragment	Represents a code fragment that has been compiled and can now be written out as IL.
CompiledMethod	Represents a method/function that is currently being compiled.
DynamicMethodCompiler	Compiles dynamic method calls in code into actual calls.
Handlers	Used when parsing code into code fragments. This class figures out what type of fragment we have next in order for that type to 'handle' the text from the code.
KeyWords	Represents special keywords in the code that must be handled differently, such as return or break.
MethodOverloads	This represents a set of methods each with the same name and return type. It's used by classes being compiled to track the methods within them.
Modifiers	Helper classes for looking for modifiers such as private var.
NitroCode	This class represents a compiled script. It's not directly callable though. You'll need to Instance an object (and cast to whatever baseType used) using the Instance method and can then call methods on that.
NitroIL	This is the heart of Nitro. A debuggable IL stream that all nitro outputs IL into. It is essentially a wrapper for the ILGenerator class, enabling the output to be logged. It will automatically log its content by setting defining an 'ildebug' compile time variable.
Operation	Represents a compiled operation which can be emitted to IL.
AddOperation	Represents the add (A+B) operation.
AndOperation	Represents the logical and (A&&B) operation.
ArrayOperation	Represents the array construct (new array[]{default,values};, new array[](length);) operation.
BaseOperation	Represents the base object. Use this for calling parent methods in overriding methods.
BitwiseXOrOperation	Represents the bitwise xor (A^B) operation.
BoxOperation	Represents a box operation. These convert a value type into an object.
BreakOperation	Represents the break operation. This is used to leave for/while loops. Break may also be followed by a constant value, e.g. break 2, for leaving nested loops.
CastOperation	Represents a cast operation. num:float=(14):float; (int to float cast). Casts one object of a certain type to a different type.
ConstructOperation	Represents a construct operation. E.g. new typename();
ContinueOperation	Represents a continue operation. It's used to skip remaining code within a loop. It may skip nested loops too using e.g. continue 2;.
DivideOperation	Represents the division (A/B) operation.
EqualsOperation	Represents the logical equality (A==B) operation.
ForOperation	Represents a for or while loop.
GreaterThanOperation	Represents the greater than (A>B) operation.
IfOperation	Represents an if operation.
IndexOperation	Represents an indexing operation on an array. e.g. AppliedTo[Index].
LessThanOperation	Represents the less than (A<B) operation.
MethodOperation	Represents a method call.
ModuloOperation	Represents the modulo (AB) operation.
MultiplyOperation	Represents the multiplication (A*B) operation.
OrOperation	Represents the logical or (A||B) operation.
PropertyOperation	Represents the a property get/set (Of.property) operation.
ReturnOperation	Represents a return (return 14) operation.
SetOperation	Represents a set (A=B) operation.
ShiftLeftOperation	Represents a left shift (A<<B) operation.
ShiftRightOperation	Represents a right shift (A>>B) operation.
SubtractOperation	Represents a subtract (A-B) or negation (-A) operation.
SwitchOperation	Represents a switch.
ThisOperation	Represents the this keyword which is used to enforce accessing a property of this class over using a local variable.
TypeOperation	Represents a type being used as an object. E.g. for statics, such as string.concat(..).
UnboxOperation	Represents an unbox operation. These convert an object into a value type.
Operator	Base class of all operators (+,- etc) and a global lookup for finding an operator instance from its text. When the system starts, all operators are automatically discovered by looking for any Operator classes. You can essentially create your own by simply deriving the Operator class.
OperatorAdd	Represents the add (A+B) operator.
OperatorAddTo	Represents the add into (A+=B) operator.
OperatorBitwiseAnd	Represents the bitwise and (A&B) operator.
OperatorBitwiseOr	Represents the bitwise or (A|B) operator.
OperatorBitwiseXOr	Represents the bitwise XOR (A^B) operator.
OperatorDecrement	Represents the decrement (A–) operator.
OperatorDivide	Represents the divide operator (A/B).
OperatorDivideInTo	Represents the division into (A/=B) operator.
OperatorGreaterThan	Represents the greater than (A>B) operator.
OperatorGreaterThanOrEql	Represents the greater than or equal (A>=B) operator.
OperatorIncrement	Represents the increment (A++) operator.
OperatorLessThan	Represents the less than (A<B) operator.
OperatorLessThanOrEql	Represents the less than or equal (A<=B) operator.
OperatorLogicAnd	Represents the logical and (A&&B) operator.
OperatorLogicEql	Represents the logical equals (==) operator.
OperatorLogicNotEql	Represents the logical not equals (!=) operator.
OperatorLogicOr	Represents the logical or (A||B) operator.
OperatorLShift	Represents the left shift (A<<B) operator.
OperatorModulo	Represents the modulo (AB) operator.
OperatorMultiply	Represents the multiply (A*B) operator.
OperatorMultiplyInTo	Represents the multiply into (A*=B) operator.
OperatorNot	Represents the not (!A) operator.
OperatorRShift	Represents the right shift (A>>B) operator.
OperatorSet	Represents the set (A=B) operator.
OperatorSubtract	Represents the subtract (A-B) or negation (-A) operators.
OperatorSubtractFrom	Represents the subtract from (A-=B) operator.
ISettable	Represents an object which may have a value set to it. e.g. a variable or an indexed array (something[14]=value;)
Types	Global methods that relate to handling variable types and changing/ casting between them.
Variable	The base class for a variable and its value. E.g. var something:type;
LocalVariable	Represents a local variable; One defined within the body of a method.
ParameterVariable	Represents a parameter variable; A value that is received in a method as a parameter. methodName(param1,param2){.
DynamicMethod< T >	Represents a method that can be called at runtime. Essentially acts like a delegate.
NitroDomainManager	A security manager which defines what is accessible by Nitro.
Script	A base class that code instances derive from by default. Nitro.NitroCode.Instance returns an object which should be casted to this unless a different base type was used in the NitroCode constructor.
SecureName	Represents a name of a namespace or type that can be allowed or blocked from use.
TypeAliases	Stores a map of aliases to system types. E.g. int to System.Int32.
Void	Represents Void (nothing) in nitro.
Pico	Pico compiles C# into a DLL allowing it to be obfuscated and also prevents it from being continually recompiled.
FlagSet	Holds a set of compiler flags.
Module	Holds settings about a precompiled "module" - that's just a group of source files compiled together under one name.
Precompiler	Precompiles modules/ libraries so they don't get rebuilt by Unity every time any source file changes. This can be used by any of your modules too, so do make use of this side feature to really speed up your build times!
SourceFileSet	Holds a set of source files.
PowerUI	The PowerUI namespace manages almost everything to do with PowerUI such as html, css and it's rendering.
Css	Known as Spark, this is PowerUI's CSS engine. CSS properties and general CSS management is performed by Spark.
Functions
Rgba	Represents the rgb() and rgba() css functions.
Url	Represents the url() css function.
Properties
BackgroundClip	Represents the background-clip: css property.
BackgroundColor	Represents the background-color: css property.
BackgroundImageProperty	Represents the background-image: css property.
BackgroundPosition	Represents the background-position: css property.
BackgroundRepeat	Represents the background-repeat: css property.
BackgroundSize	Represents the background-size: css property.
BorderColor	Represents the border-color: css property.
BorderImageSlice	Represents the border-image-slice: css property.
BorderRadius	Represents the border-radius: css property.
BorderStyleProperty	Represents the border-style: css property.
BorderWidth	Represents the border-width: css property.
Bottom	Represents the bottom: css property.
Clip	Should this element be clipped at all? This is similar to the effect seen when using overflow:visible, but this applies to the main screen also. Useful if you've got transformations (e.g. a rotation) which go over the edge of the screen.
ColorProperty	Represents the color: css property.
ColorOverlay	Represents the color-overlay: css property. Specific to PowerUI. This overlays the given colour over any element.
Content	Represents the content: css property. Note that this one is not textual - this is actually correct. It doesn't apply to text - rather it 'is' text.
Direction	Represents the direction: css property.
Display	Represents the display: css property.
FilteringMode	Represents the filter-mode: css property. Specific to PowerUI - this defines the image filtering.
Float	Represents the float: css property.
FontFamily	Represents the font-family: css property.
FontSize	Represents the font-size: css property.
FontStyle	Represents the font-style: css property.
FontWeight	Represents the font-weight: css property.
Height	Represents the height: css property.
Left	Represents the left: css property.
LetterSpacing	Represents the letter-spacing: css property.
LineHeight	Represents the line-height: css property.
Margin	Represents the margin: css property.
MaxHeight	Represents the max-height: css property.
MaxWidth	Represents the max-width: css property.
MinHeight	Represents the min-height: css property.
MinWidth	Represents the min-width: css property.
OnAtlas	Represents the on-atlas: css property. Specific to PowerUI. This tells particular images to render off the main atlas.
Overflow	Represents the overflow: css property.
Padding	Represents the padding: css property.
Position	Represents the position: css property.
Right	Represents the right: css property.
Rotate	Represents the rotate: css property.
Scale	Represents the scale: css property.
Scroll	An animatable scroll-top and scroll-left CSS property.
Lighting	Represents the lighting: css property. It's either on or off.
ShaderFamily	Represents the shader-family: css property. This can be used to assign custom shaders. Note that it's a "family" because there is a group of shaders which can potentially be used depending on other CSS settings (e.g. lit and unlit). Each shader must be named e.g:
TextShadow	Represents the text-shadow: css property.
TextStroke	Represents the text-stroke: css property. Used to add outlines to text.
Skew	Represents the skew: css property.
UrlSrc	src: CSS property. Used by -face.
TextAlign	Represents the text-align: css property.
TextAlignLast	Represents the text-align-last: css property.
TextDecorationColor	Represents the text-decoration-color: css property.
TextDecorationLine	Represents the text-decoration-line: css property.
TextExtrude	Represents the text-extrude: css property. This makes text 3D - it's best used in WorldUI's. Usage is text-extrude:[extrusion, float]. e.g. text-extrude:2.4
Top	Represents the top: css property.
TransformOrigin	Represents the transform-origin: css property.
TransformOriginPosition	Represents the transform-origin-position: css property.
Translate	Represents the translate: css property.
VerticalAlign	Represents the vertical-align: css property.
Visibility	Represents the visibility: css property.
WhiteSpace	Represents the white-space: css property.
Width	Represents the width: css property.
WordSpacing	Represents the word-spacing: css property.
ZIndex	Represents the z-index: css property.
Calculation	Used for the calc(..) css function. Currently syntax only support; superceded by box-sizing CSS property.
ComputedStyle	Contains methods for interacting with a CSS class applied to the computed style.
CssFunction	A CSS function. You can create custom ones by deriving from this class. Note that they are instanced globally.
CssFunctions	A global lookup of function name to function. E.g. rgba() is a CSS function. Css functions are instanced globally and mapped to the names they use. Note that functions are not instanced per element.
CssProperties	A global lookup of property name to property. CssHandlers are instanced globally and mapped to the property names they accept. Note that properties are not instanced per element.
CssProperty	A CSS property. You can create custom ones by deriving from this class. Note that they are instanced globally.
CssUnit	A CSS function. You can create custom ones by deriving from this class. Note that they are instanced globally.
BackgroundColour	Represents the solid background colour of an element.
BackgroundImage	Represents the background image of an element. May also be a video (pro only) or animation.
BorderProperty	Represents the border around an element.
RoundCorner	Represents the a rounded corner of a border. This works by creating two sections - the "inverse" border and the border itself. The inverse border is essentially a series of transparent whose purpose is just to affect the depth buffer.
RoundedCorners	Represents the set of round corners for a particular border.
DisplayableProperty	Base class for any property of an element that can be visually displayed, e.g. backgrounds and borders.
RoundBorderInverseProperty	Represents the inverse section of round borders. Simply acts as a block allocation container, separating the "inverse" corner from the main coloured corner.
TextRenderingProperty	This class manages rendering text to the screen.
ElementStyle	The .style property of a html element.
ShaderData	Used to store shading information about a particular element.
ShadowData	Stores shadow data for text-shadow.
StrokeData	Stores stroke data for text-stroke.
Selector	Used when a,series,of,selectors are defined in CSS. They are stored in this parsed structure until the full block is loaded
SelectorStyle	Holds a block of css properties for a given selector (e.g. .name and #name are selectors).
Style	Holds a set of css style properties.
StyleSheet	Holds a set of selector styles. A selector is something like .name or #name.
TextDecorationInfo	Info about a line drawn over some text.
Value	This represents a parsed value of a css property.
About	Displays some info about PowerUI.
CreateHtmlContext	Useful context option for creating a new HTML file.
CreateSimpleUIContext	Useful context option for creating a new HTML file.
EmojiSettings	Displays options for enabling Emoji. All this does is download a bunch of default graphics.
GeneralSettings	Displays some general settings for PowerUI.
ImageImport	Handles automatically applying the required import settings to images.
ImageImportContext	Displays options for enabling Emoji. All this does is download a bunch of default graphics.
NitroAOT	Looks for and compiles Nitro script ahead of time for iOS. The Nitro can be located in any .html file.
NitroSettings	Displays a small checkbox for compiling Nitro AOT.
PowerUIEditor	A class used to locate where the PowerUI folder is in the project.
PrecompileSettings	Displays options for precompiling PowerUI. Highly recommended you use this!
RenameFontsContext	Displays a handy option for renaming font files so PowerUI can read them.
SymbolDefines	Defines and undefines useful symbols, like PowerUI
AutoTranslate	Displays options for automatically translating your UI language files.
TranslationInfo	Holds information about a particular translation.
Translations	Used for Automatic whole UI Translations from the Editor.
CreateWorldUI	Allows component based creation of WorldUI's.
Ajax	Wraps around the UnityHttp.Http class so Nitro can easily perform web requests.
AttributeLookup	A lookup is used to cache e.g. elements by ID. They hugely increase lookup speed and are automatically created for high traffic attributes (like ID).
AttributeLookupLink	Sometimes more than one element has the same attribute. When that happens, they end up as a linked list. This is one of the links.
Document	Represents a HTML Document. UI.document is the main UI document. Use PowerUI.Document.innerHTML to set it's content.
Element	This function is called when a -face font is done loading.
UIBatch	A UI Batch represents a block of the UI that can be safely rendered with a single drawcall (i.e. all in one mesh). Batches can be isolated - that means it can have its own material or texture atlas. Batches are created on demand by the renderer and based on the requests of the elements being rendered. An animation, for example, will generate an isolated batch.
UIBatchPool
BoxRegion	BoxRegion defines a 2D screen region. Mostly used for clipping.
CameraPool	Managed automatically. You don't need to do anything with this class. When cameras are placed on the main UI, the UI must be broken up and rendered by multiple cameras. This class represents the set of cameras. It's created on first demand, and used from UI.MainCameraPool.
CharacterProvider	This class provides graphical characters, such as for Emoji. Each one of these defines a range of unicode characters that it provides for. Any character found within it's defined range will be directed to the provider, but only if it wasn't found in the font.
CharacterProviders	Used for e.g. Emoji. Holds all CharacterProvider instances. When a character is not found in the font, PowerUI checks with these character providers to see if any of them can provide it instead. Add custom providers if you have your own set of images to add.
Clipboard	Wraps copy/paste functionality into a simple interface.
ContentType	A helper for detecting some file types.
AnimatedProperty	A single css property being animated. Note that composite properties such as colours or rotations must be broken down into their inner properties (e.g. rgba, xyz). This is done internally by PowerUI.UIAnimation.
UIAnimation	Handles all actively animated css properties. Also keeps track of a single set of css properties as used in any animate method (PowerUI.Element.animate) and can be used to monitor the progress of an animation.
ShaderSet	Represents a family of shaders. Globally cached to minimise memory usage.
DataPackage	Retrieves a block of binary data for use on the UI. Used by e.g. fonts.
DesignSize	This class represents design size information. Used by UI.Resolution to essentially match the visual appearance of your design on every screen.
DocumentElements	Allows easy iteration through all elements of a document. See Document.allElements to use this.
DynamicFont	Represents a font suitable for displaying text on the screen with. There is one of these per PowerUI.Renderman.
DynamicMesh	A mesh made up of a dynamic number of "blocks". Each block always consists of two triangles and 4 vertices. This is used for displaying the content in 3D with a single mesh.
DynamicTexture	A dynamic texture renders it's pixels in a custom way. This can be considered similar to a canvas element. This allows for some very dynamic graphics on the UI (for example, a curved health bar).
ErrorHandlers	Manages events such as 404 pages.
ErrorInfo	Contains information about an error, such as a 404 page not found.
HttpErrorInfo	Contains information about a HTTP protocol error, such as a 404 page not found.
FileErrorInfo	Contains information about a protocol error such as file not found. Applies to Resources and Http requests.
FilePath	Represents a path to a file with a protocol. e.g. http://www.site.com/aFile.png The path may also be relative to some other path (aFile.png relative to http://www.site.com).
CacheProtocol	This protocol is used if you have a Texture2D object and want it on the screen. You must add the object to the ImageCache with a name, then use cache://thename to access it.
DynamicProtocol	This protocol, dynamic:// is for dynamic textures. They draw directly to the texture atlas and achieve high performance. Used by e.g. Curved Healthbars.
FileProtocol	Represents a custom protocol:// as used by PowerUI files. For example, if you wish to deliver content in a custom way to PowerUI, implement a new FileProtocol (e.g. 'cdn') Then, setup its OnGetGraphic function.
FileProtocols	Manages all current file protocols://. File protocols such as http, cache, dynamic, scene etc enable PowerUI to load files in custom ways - for example if your game uses a specialised cdn, you may easily implement it as a new FileProtocol.
HttpProtocol	Handles the http:// protocol. Downloads files and text from the web and also handles web links. Note that this protocol (and many others) have been designed to be removeable - just delete the file.
ResourcesProtocolCallback	This callback is used to ensure that resources protocol content is loaded on the main thread.
ResourcesProtocol	Handles the resources (default) protocol. Files here are loaded from the Unity 'Resources' folder in the project. Note that animation files must end in .bytes (e.g. animation.spa.bytes) and all images must be read/write enabled as well as have a "To power 2" of none.
SceneProtocol	This scene:// protocol enables a link to point to another scene. E.g. href="scene://sceneName" will load the scene called 'sceneName' when clicked.
FixedSizeBuffer< T >	A special type of array which is made up of a set of 'blocks'. Each block consists of a fixed amount of type T elements. This fixed amount is the block size. It regulates an internal array and only resizes when necessary. Example usage: PowerUI.DynamicMesh.Vertices For example, A block size of 4 (e.g. 4 vertices in a square) and a block count of 3 generates a 12 element array.
FlatWorldUI	Flat WorldUI's render to textures. Normal worldUI's are better for performance but flat worldUI's are more flexible. Free/Indie users should use normal WorldUI's instead for performance purposes, however this can still be used. The difference here is the texture can be e.g. applied to a curved surface.
FlatWorldUIHandler	This class manages rendering flat WorldUI's for Unity Indie (free) users. You don't need to use it directly - PowerUI will set this up for you when you create a FlatWorldUI.
Focus	Manages the currently focused element.
FormData	Represents information entered into a html form. It maps field names to their current selected value.
HitResult	Represents the result of a Physics Mode input test. These are used when a player clicks on the UI and the UI is in Physics mode or when WorldUI's are listening for input.
HtmlTagHandler	A base class for all html tag types (e.g. script, a, body etc). These tag handlers tell the UI how to render and work with this type of tag. Tag handlers are stored globally for lookup and instanced per element.
DynamicFormat	Represents the built in dynamic image format.
ImageFormat	Represents a specific type of image format, e.g. a video or an SVG.
ImageFormats	Manages all current image formats.
PictureFormat	Represents the default "picture" format. Png, jpeg etc are handled with this.
SpaFormat	Represents the SPA animation format.
VideoFormat	Represents the video format.
ImagePackage	An object which holds and retrieves different types of graphics such as animations, videos (pro only) and textures.
Input	This class manages input such as clicking, hovering and keypresses.
JSArray	An object returned from JSON text.
JSObject	An object returned from JSON text.
JSON	Handles parsing of JSON objects.
JSValue	Represents an actual JSON value.
KeyboardMode	Represents the type of mobile keyboard that can show up. Similar to Unities TouchScreenKeyboardType, however also has a None option to allow an element to not display any keyboard at all.
MeshBlock	A block of two triangles in a dynamic mesh. The triangles are positioned to create a flat 2D rectangle. The colour and position can be adjusted to fit content onto the block.
NitroCache
RemoteDebug	Handles remote DOM debugging. It calls out to a known address, which may be a facilitator. Once connected and authenticated, all DOM events are sent to the debugger.
Renderman	This helps 'render' elements from the DOM into a set of 3D meshes. It also performs things such as alignment and line packing.
ImageResizer	This class helps resize images.
ResizedImage	Represents an image that has been resized by the ImageResizer. Cached such that they don't get resized again.
ResizedImages	A cache for resized images. Used with the resize:// protocol.
ResizeProtocol	Automatically resizes the "actual" image to prevent wasting memory. With this, you can have one set of high-res images for all your devices and they'll just fit. Requests from Resources only.
ResolutionInfo	This class represents resolution information. Use this and Document.SetResolution if you are targeting different resolutions.
ScreenInfo	Provides general information about the screen such as where the corners are in world units. Note: The world origin is in the middle of the screen. The provided world screen origin is the top left corner.
SPA	SPA (SPrite Animation) is a custom file format which holds optimized sprite animations and also supports alpha. As it's a custom format, we also have a freely available tool on the website which will encode a series of images into an .SPA file. Important Note: You must add .bytes onto the end of any .spa file in your Resources folder, otherwise it won't work! (e.g. countdown.spa.bytes).
SPAInstance	A single instance of an SPA animation. It's instanced like this so that the same animation can be played back multiple times at once; the instance keeps track of which frame the animation is currently at.
SPASprite	Represents a single sprite in an SPA animation. Note that a single sprite isn't always a single frame; one sprite can contain multiple frames itself. The frames are stored on the sprite from top to bottom, left to right. I.e. The first frame is in the top left corner; the next is below it. If there is no more height left, the next frame is at the top again but one column further right.
StandardUpdater	PowerUI creates one of these automatically if it's needed. It causes the Update routine to occur.
ClickLinkTag	Represents a clickable link. Note that target is handled internally by the http protocol.
AbbrTag	Represents a HTML abbr(eviation) element.
AcronymTag	Represents a HTML acronym element. It's reccommended to use abbr instead.
AddressTag	Represents a HTML5 address element.
ArticleTag	Represents a HTML5 article element.
AsideTag	Represents a HTML5 aside element.
BoldTag	Represents the bold tag.
BaseTag	Represents a HTML base element.
BdiTag	Represents a HTML5 Bi-direction isolation element.
BdoTag	Represents a HTML5 Bi-direction override element.
BigTag	Represents a big element.
BlockquoteTag	Represents a HTML blockquote element.
BodyTag	Represents the body tag. Note that this is added automatically by PowerUI and isn't required.
BrTag	Represents line breaks.
ButtonTag	Represents a html button. This is the same as <input type="button">, but a little shorter.
CameraTag	Custom tag for an inline camera. You can place your UI before and after this as normal. You must importantly set the path="" attribute to the path in the hierarchy of the camera itself. This tag also has a mask="file_path" attribute which can be used to shape the camera in interesting ways e.g. a circular minimap. You must also set the height and width of this element using either css or height="" and width="".
CanvasContext	Represents a canvas context which lets you draw 2D shapes and polygons on the UI. See the canvas html tag for more information.
CanvasContext2D	Represents a canvas context which lets you draw 2D shapes and polygons on the UI. See the canvas html tag for more information.
CanvasTag	Represents a canvas which lets you draw 2D shapes and polygons on the UI.
CenterTag	Represents the center tag.
CiteTag	Represents a HTML cite element.
CodeTag	Represents a code element.
CommentTag	Represents an in-html comment which will be completely ignored.
DescriptionDTag	Represents a HTML5 description element.
DDBoxTag	Dropdown box. Used by select internally.
DDButtonTag	Dropdown button tag. Used by select internally - when clicked, it displays the dropdown menu.
DelTag	Represents a HTML del(eted) element. These get striked through.
DetailsTag	Represents a HTML5 details element.
DefinitionTag	Handles the definition tag.
DirTag	Represents a standard dir block element.
DivTag	Represents a standard div block element.
DescriptionLTag	Represents a HTML5 description list element.
DoctypeTag	Represents the doctype tag.
DescriptionTTag	Represents a HTML5 description element.
EmTag	Handles the emphasis tag.
FigCaptionTag	Handles the HTML5 figure caption element.
FigureTag	Represents a HTML figure element.
FontTag	Handles the standard inline font element.
FooterTag	Represents a HTML5 footer element.
FormTag	Represents a html form which lets you collect information from the player. For those new to html, see input and select tags. Supports onsubmit="nitroMethodName" and the action attributes.
H1Tag	Represents a standard header block element.
H2Tag	Represents a standard header block element.
H3Tag	Represents a standard header block element.
H4Tag	Represents a standard header block element.
H5Tag	Represents a standard header block element.
H6Tag	Represents a standard header block element.
HeadTag
HeaderTag	Represents a HTML5 header element.
HRTag	Represents a standard horizontal rule element.
HScrollTabTag	Handles the tab (draggable part) of a horizontal scrollbar.
HtmlTag	Represents the html tag. Note that this is added automatically by PowerUI and isn't required.
ItalicTag	Handles the italics tag.
IframeTag	Handles iframes. Supports the src="" attribute.
ImgTag	Handles an image tag. The src attribute is supported.
InputTag	Represents the input tag which handles various types of input on forms. Note that all input tags are expected to be on a form to work correctly. E.g. radio buttons won't work if they are not on a form. Supports the type, name, value and checked attributes. Also supports a 'content' attribute which accepts a value as html; great for buttons.
InsTag	Represents a HTML ins(erted) element. Underlines the new text.
LabelTag	Handles the standard inline label element. Clicking on them acts just like clicking on the input they target.
LegendTag	Represents a standard legend element.
LiTag	Represents a standard list entry element.
LinkTag	Handles the link tag commonly used for linking external style sheets. Note that this isn't for clickable links - that's the a tag as defined in html. The href must end in .css, or either rel="stylesheet" or type="text/css" must be defined. Otherwise, this tag is ignored by PowerUI.
MainTag	Represents a HTML5 main content block element.
MarkTag	Handles the mark tag.
MarqueeTag	Represents a non-standard marquee tag.
MetaTag	Handles the meta tag. These are essentially just ignored by PowerUI.
NavTag	Represents a HTML5 nav element.
OlTag	Represents a standard ordered list element.
OptionTag	Handles option tags for dropdowns. Supports the selected and value="" attributes.
ParagraphTag	Represents a standard paragraph (p) block element.
ParamTag	Represents object parameters. Although object itself isn't supported this tag is; a page with an object on it can still load.
PreTag	Represents a pre element.
RPTag	Handles the rp tag.
RTTag	Handles the rt tag.
RubyTag	Handles the ruby tag.
STag	Represents a HTML5 s element. Defines text which is no longer correct and is striked through.
SampTag	Represents a samp(le) element.
ScriptTag	Handles script tags. They should have type="text/nitro" to be handled by PowerUI; Javascript is ignored. The src="" attribute is also supported if you wish to reuse script by loading it externally.
ScrollDownTag	Handles the scroll down button on scrollbars.
ScrollLeftTag	Handles the scroll left button on scrollbars.
ScrollRightTag	Handles the scroll right button on scrollbars.
ScrollTabTag	Handles the tab (draggable part) of a horizontal or vertical scrollbar.
ScrollUpTag	Handles the scroll up button on scrollbars.
SectionTag	Handles the HTML5 section element.
SelectTag	Select dropdowns. Supports the onchange="nitroMethod" and name attributes.
SmallTag	Represents a small element.
SourceTag	Represents HTML5 audio sources.
SpanTag	Handles the standard inline span element.
StrikeTag	Represents a HTML strike element. Strikes through this text.
StrongTag	Represents the strong tag.
StyleTag	Handles the style tag containing inline css. Use the link tag if you wish to add external css.
SubTag	Handles the standard sub(script) element.
SummaryTag	Represents a HTML5 summary element.
SupTag	Handles the standard sup(erscript) element.
TableTag	Handles a table.
TableBodyTag	Represents a table body element.
TdTag	Handles a table cell.
TextareaTag	Handles textarea tags.
TableFooterTag	Represents a table footer element.
ThTag	Handles a table header cell.
TableHeaderTag	Represents a table header element.
TimeTag	Handles the standard inline time element.
TitleTag	Handles the title tag. Note that the title is set to PowerUI.Document.title if you wish to use it.
TrTag	Handles a table row.
TrackTag	Represents HTML5 video tracks.
UlTag	Represents a standard unordered list element.
VideoTag	Handles a video. Note that videos can also be used for the css background-image property. You must also set the height and width of this element using either css or height="" and width="".
VScrollTabTag	Handles the tab (draggable part) of a vertical scrollbar.
WbrTag	Represents line break opportunities.
Text3D	Stores information about text being rendered in actual 3D. To use this, use the text-extrude CSS property. This allows you full formatting power and PowerUI can batch accordingly.
TextElement	A html element which represents renderable text. The children of this element should always be a PowerUI.WordElement.
TextPackage	Retrieves a block of text for use on the UI.
AtlasStacks	All the major stacks used by PowerUI. Each one represents a stack of texture atlases which are shared across all UI's.
Callback	Callbacks can be used to make sure certain things run on Unities main thread. To use them, you must inherit this callback class and override OnRun. When you create an instance, call instance.Go(); to request a run on the main thread. Note that order is not necessarily retained if you happen to call Go on the main thread anyway - it will run immediately.
Callbacks	A class which manages callbacks running on Unities main thread.
Transformation	Represents a transformation applied to the vertices of an element on the UI. It generates a matrix when applied. This matrix is then applied to any existing matrix (the current top of a stack) and the result is pushed to the same stack. The matrix at the top of the stack is the one which is actually applied to elements.
TransformationStack	Represents a stack of transformations (e.g. scale, translate, rotate). PowerUI.Renderman.Transformations The renderman maintains a stack of transformations. The frame on the top of the stack is applied to each element being renderered as a post process.
UICamera	When cameras are placed on the main UI, the UI must be broken up and rendered by multiple cameras. This class represents one of those cameras in a stack.
UICode	Represents code parsed and loaded from a script block.
UIEvent	A UI Event represents a click or keypress. An event object is always provided with any onmousedown/onmouseup/onkeydown etc.
UITimer	Provides a way of interrupting a timer event. Returned by PowerUI.UICode.setTimeout and PowerUI.UICode.setInterval. This object can be passed to PowerUI.UICode.clearInterval to prevent any further timing events.
VariableElement	A html element which is created when using . They are tracked in this way so their content can be replaced if the language of the UI changes.
Window	Represents the javascript window object.
WordElement	A html element which represents a single word.
WorldUI	A world UI is one which can be placed in a particular spot in the game world and seen with the game camera. For example, an in-game computer screen/ billboard etc. It has a pixel height and width, a document (which works just like UI.document does) and can have its resolution and origin changed. The resolution defines how many pixels make up one world unit and the origin defines where the gameobjects origin is relative to the UI. By default, it's in the middle.
UnityHttp	Performs event based HTTP loading. ajax.get is built on top of this.
HttpRequest	Represents a single http request.
Http	Performs Http requests independently. Note that you must call Update to keep all the requests active.
Wrench	The Wrench Framework contains the Nitro scripting engine and compiler and also provides some generic markup language parsing as well as other shared features. This framework is shared by PowerUI and SoundStudio's KSA Player.
UnityLanguageLoader	This class loads data for a language within Unity at runtime. The language must always be located in the Resources folder, under Resources/Languages/{path}.
Log	This class handles logging messages. When a message occurs, it fires an event so a specific application can handle them how it wishes. All logging can also be disabled with Wrench.Log.Active.
MLElement	This object represents any Markup Language (ML) tag such as html, sml, xml etc.
MLLexer	A Markup Language (ML) lexer reads xml-like markup languages from a string. It's used to help form a DOM like structure from any markup string such as html, sml, xml etc.
MLTextElement
MLVariableElement
PropertyTextReader	Reads properties/ attributes from a lexer. These are of the form propertyName="propertyValue", propertyName=value or singleProperty (i.e. no value).
StringReader	Treats a string of characters as a stream. This allows it to be read one character at a time. Attempting to read after the end of the stream will generate a Wrench.StringReader.NULL character.
TagHandler	A tag handler represents methods for handling markup tags - for example a <span and="attributes">.
LanguageTag	This handles the language tag at the top of a language file. It must define the name and code of the language.
LanguageTagHandler	Handles a tags contained in a language file.
VariableTag	Handles a variable tag within a language file. Variable tags define what a should be replaced with and essentially seperate layout or structure from the language.
TagHandlers	A global lookup of tag text to handler. TagHandlers are instanced globally and mapped to the tags they accept. When a tag is found, it is then instanced. One instance of a tag is created per element.
FullVariableSet	This set represents a set of variables in text, denoted by Implemented at e.g. UI.Variables/Speech.Variables. The event OnFind can be used to resolve a variable not found in either custom variables or the language (for localization) set. Nested variables (variables in a variables text) are evaluated at the point of replacement, not load.
LanguageElement	This represents the language tag seen at the top of a language file.
LanguageLoader	Override this class to provide methods for loading language files. They may be delivered in many different ways because of this.
LanguageSet	A set of variables for a particular language. Used for localization.
Text	This class simply represents a global Language service. Things such as the UI/Speech sign on to the language change event and update themselves accordingly when it's fired.
VariableSet	Represents a set of used for localization.
TypeData	Provides methods for dealing with types across platforms.
AboveHeadTextExample	This script simply shows a message above an object in the gameworld. The message is full HTML, so it can be anything at all.
CameraController
CSharpExample	This example shows an alternative way of accepting mousedowns other than with Nitro by using C# delegates and anonymous delegates.
DragScroller
DynamicTexturesExample
EpicItem	This class is used by the Nitro Example. It shows that nitro can easily work with objects of your own design.
FlatInWorldUI
FormExampleHandler	Shows how to call C# directly from your html. This receives an onsubmit call when a form is submitted through onsubmit="FormExampleHandler.OnSubmit". That maps to this class and its OnSubmit method.
HealthBar
ImageCache	There may be times when you want to display an image for which you only have the Texture2D object. In this case, you can add it to the cache with a given name and then access it in PowerUI using cache://theNameYouUsed. The most useful method for this is PowerUI.ImageCache.Add.
NitroExampleClass	This class is used in the NitroExample. It shows that Nitro can call C# functions directly and work with your games objects. Note that you can block calls like this with nitro security domains.
PowerBar
PoweruiManager	This class is the default PowerUI Manager Monobehaviour. To use it, it needs to be attached to a gameobject in the scene.
PoweruiManagerMinimal	This class is a minimal PowerUI manager. As a minimum, you only need to write to the UI and nothing more.
SimpleHealthPoints
Text3DCameraController
Text3DHandler
TVScreen
UI	This class holds global variables and methods for managing PowerUI. The most important ones are: UI.Start UI.Update UI.document
UIScriptDomainManager	The default nitro script security domain manager. UI.Start(UIScriptDomainManager) for passing in a custom domain manager to extend or override this one.