Incisor® API Documentation
This document is part of the compiled knowledge base for the Incisor® Software Development Platform.
Any use of this content is subject to the INCISOR® end user license and terms of use agreement.
https://www.incisordev.com/eultua
2025.12.18.13.09.02






----------------------------------------------------------
TABLE OF CONTENTS:
----------------------------------------------------------
Section 1: GLOBAL
Section 2: INCISOR
Section 3: AppEvent
Section 4: PauseEvent
Section 5: SpeedControl
Section 6: FocusChangeInfo
Section 7: AssetComponent
Section 8: LoadingTierDefinition
Section 9: Button
Section 10: Camera
Section 11: OrthographicCamera
Section 12: Intersection
Section 13: Code
Section 14: Constants
Section 15: ConstructDefinition
Section 16: Blueprint
Section 17: Construct
Section 18: CursorInputOverrideButton
Section 19: Curve
Section 20: CurvePoint
Section 21: CustomAddOnDefinition
Section 22: RegisteredProperty
Section 23: CustomAddOn_SceneObject
Section 24: CustomAddOn_GraphicObject
Section 25: CustomAddOn_Button
Section 26: CustomAddOn_TextBox
Section 27: CustomAddOn_TextAssembly
Section 28: CustomAddOn_ParticleSystem
Section 29: CustomAddOn_Construct
Section 30: CustomObjectDefinition
Section 31: shapifySwoop
Section 32: shapifyAddMotion
Section 33: shapify
Section 34: shearSwoop
Section 35: shearAddMotion
Section 36: shear
Section 37: EffectControllerDefinition
Section 38: EffectNode
Section 39: IncisorExtensions
Section 40: ProcessResult
Section 41: InspectorPanel
Section 42: FileBrowser
Section 43: PrePublishInfoObject
Section 44: PostPublishInfoObject
Section 45: ProcessConfiguration
Section 46: FileIO
Section 47: IncrCommsResponseObject
Section 48: PathInfo
Section 49: FlowController
Section 50: FlowState
Section 51: FlowStateElement
Section 52: FontDefinition
Section 53: Geometry
Section 54: GeometryEditor
Section 55: GraphicAsset
Section 56: MaterialPreset
Section 57: GraphicExpander
Section 58: GraphicObject
Section 59: Masking
Section 60: MaskGroup
Section 61: IncisorApp
Section 62: IncisorAppBasic
Section 63: LayoutObject
Section 64: LayoutStack
Section 65: LazyUpdater
Section 66: MaterialMaster
Section 67: Material
Section 68: Matrix4
Section 69: Matrix4Array
Section 70: Motion
Section 71: MotionControllers
Section 72: MotionType
Section 73: ParticleSystemDefinition
Section 74: ParticleSystem
Section 75: ParticleSystemRamp
Section 76: ParticleSystemRamp1
Section 77: ParticleSystemRamp2
Section 78: ParticleSystemRamp3
Section 79: ParticleSystemRamp4
Section 80: ParticleInfo
Section 81: ParticleSystemDefinitions
Section 82: Paths
Section 83: Pdf
Section 84: PdfSection
Section 85: PdfParagraph
Section 86: PdfHeader
Section 87: PdfFooter
Section 88: PdfImage
Section 89: PdfTable
Section 90: PdfRow
Section 91: PdfCell
Section 92: PdfTextFrame
Section 93: PivotPointAdjuster
Section 94: PixelsObject
Section 95: PixelsObjects
Section 96: TimePlaybackController
Section 97: ValuePlaybackController
Section 98: PlaybackController
Section 99: Precomp
Section 100: ProjectConfiguration
Section 101: AssetConfiguration
Section 102: Publishing
Section 103: RenderTarget
Section 104: SceneObject
Section 105: Scene
Section 106: Layer
Section 107: LayersByScene
Section 108: ScrollingPanel
Section 109: SlotReel
Section 110: Sound
Section 111: VolumeControl
Section 112: SpriteSetter
Section 113: Supervisor
Section 114: Swooper
Section 115: TweenType
Section 116: TweenControllers
Section 117: TextAssembly
Section 118: TextBox
Section 119: HtmlBacking
Section 120: RangeInfo
Section 121: TextFormat
Section 122: CharacterMaterial
Section 123: Texture
Section 124: Timeline
Section 125: TimeStamp
Section 126: UiBooleanSupervisor_checkbox
Section 127: UiButton
Section 128: UiCollapsibleStack
Section 129: UiDropDownMenu
Section 130: UiGraphicButton
Section 131: UiKeyboardNavigator
Section 132: UiKeyboardNavigable
Section 133: UiLinkButton
Section 134: UiMenu
Section 135: UiMenuItem
Section 136: UiNumberSupervisor_textField
Section 137: UiPopupWindow
Section 138: UiStringSupervisor_menu
Section 139: UiStringSupervisor_textField
Section 140: UiStyle
Section 141: UiPanel
Section 142: UiOutline
Section 143: UiTextField
Section 144: UiText
Section 145: UiVectorSupervisor_textField
Section 146: UiVisualFocus
Section 147: UiZoom
Section 148: UrlParameterIterator
Section 149: Vector1Swoop
Section 150: Vector2Swoop
Section 151: Vector3Swoop
Section 152: Vector4Swoop
Section 153: ColorSwoop
Section 154: Vector1AddMotion
Section 155: Vector2AddMotion
Section 156: Vector3AddMotion
Section 157: Vector4AddMotion
Section 158: ColorAddMotion
Section 159: Vector4Base
Section 160: Vector4
Section 161: Color
Section 162: Vector3Base
Section 163: Vector3
Section 164: Vector2Base
Section 165: Vector2
Section 166: VectorBase
Section 167: Vector1
Section 168: Video
Section 169: WaitThen
Section 170: Deprecation Schedule
Section 171: Release Notes










----------------------------------------------------------
Section 1: GLOBAL
----------------------------------------------------------


GLOBAL
[type: scope] 
The global scope of a given Incisor project.





nc
[type: INCISOR] 
Object housing all of the main Incisor functionality. Accessible via 'nc' from anywhere within project code, excluding code within the 'PreloadConfiguration.js' file (that code is executed before 'nc' is instantiated).





pr
[type: ProjectMain] 
Object housing the main entry-point for the entire project





constants
[type: Constants] 
Object housing predefined constant values for various Incisor® options and modes.





CODE
[type: Code] 
Object housing tools for pre-process manipulation of code.





nce
[type: IncisorExtensions] [requires: unpublished only, license - extensions] 
Object housing all of the Incisor Extensions functionality. In general, this object has much of the same functionality as nc/INCISOR and is therefore documented as extending that object but not all of the same functionality is available through this object, so auto-complete may show some non-existent members on this object. 










----------------------------------------------------------
Section 2: INCISOR
----------------------------------------------------------


INCISOR
[type: class] [NON-INSTANTIABLE] 
Class housing all of the main Incisor functionality. Accessible via 'nc' from anywhere within project code, excluding code within the 'PreloadConfiguration.js' file (that code is executed before 'nc' is instantiated). 





INCISOR.projectName
[type: string] 
The name of the project.





INCISOR.appEvents
[type: dictionary] 
Object housing Incisor® AppEvents, which enable callbacks for software events including screen updates, cursor/pointer/mouse events, keyboard events, and many more.


INCISOR.appEvents.fixedUpdate
[type: AppEvent] 
The fixed updater AppEvent occurs in an automatically repeating manner at a rate dictated by 'nc.targetFixedUpdateRate' (defaults to 60 fps). This AppEvent should be used to drive the logic and sequencing in a given project. It is a 'fixed' updater because it will be called at the designated rate regardless of 'dropped' screen updates, and logic/sequencing using this AppEvent will never experience 'time slippage' due to any software performance issues.


INCISOR.appEvents.lateFixedUpdate
[type: AppEvent] 
The fixed updater AppEvent occurs in an automatically repeating manner at a rate dictated by 'nc.targetFixedUpdateRate' (defaults to 60 fps). This AppEvent should be used to drive the logic and sequencing in a given project. It is a 'fixed' updater because it will be called at the designated rate regardless of 'dropped' screen updates, and logic/sequencing using this AppEvent will never experience 'time slippage' due to any software performance issues. This AppEvent will always happen after the 'fixedUpdate' AppEvent. This AppEvent is 'ordered', meaning callbacks added can provide a 'callbackOrder' parameter, which is used to determine the execution order of callbacks.


INCISOR.appEvents.screenUpdate
[type: AppEvent] 
The screen updater AppEvent occurs in an automatically repeating manner at a rate dictated by 'nc.targetScreenUpdateRate' (defaults to 60 fps). This AppEvent should only be used to drive processes that are tied to rendering - it occurs before each auto-render of the Cameras. It is a 'screen' updater because it is only called when the system's performance allows - if project logic or sequencing are tied to this AppEvent, they may experience 'time slippage' if there are any software performance issues.


INCISOR.appEvents.lateScreenUpdate
[type: AppEvent] 
The late updater AppEvent occurs in an automatically repeating manner at a rate dictated by 'nc.targetScreenUpdateRate' (defaults to 60 fps). This AppEvent should only be used to drive processes that are tied to rendering - it occurs after each auto-render of the Cameras. It is a 'late' updater because it is called after rendering, and can be used to wrap up rendering processes, and prep for the next render. Much like the 'screenUpdate', the lateScreenUpdate only happens when system performance allows, and so would experience time slippage with performance issues. This AppEvent will always happen after the 'screenUpdate'. This AppEvent is 'ordered', meaning callbacks added can provide a 'callbackOrder' parameter, which is used to determine the execution order of callbacks.


INCISOR.appEvents.start
[type: AppEvent] 
The start AppEvent occurs one time after ProjectMain.init (pr.init) has been called, which happens directly before the automatic iterative appEvents (i.e. fixedUpdate, screenUpdate etc...) begin. This AppEvent can be used to perform tasks which require that all SceneObjects and CustomAddOns to be 'in place' and set up before running. An example use of this AppEvent would be within a CustomAddOn that resides on an item inside a Construct - if you put code that references other CustomAddOns in a constructor, there's no guarantee that the other CustomAddOns or their owners will be populated yet. So in this case it would be better to run that same code in a 'start' callback, which waits for all of the setup before running. It should be noted that callbacks added after the official 'start' occurs will be invoked on the next fixedUpdate. This AppEvent is 'ordered', meaning callbacks added can provide a 'callbackOrder' parameter, which is used to determine the execution order of callbacks.


INCISOR.appEvents.keyboardEvent
[type: AppEvent] 
The keyboardEvent is triggered for all keyboard events such as 'keydown' and 'keyup'. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.canvasResize
[type: AppEvent] 
The canvasResize is triggered any time a key canvas is resized. The native browser-triggered event will be sent to all callbacks as their first parameter.


INCISOR.appEvents.keyDown
[type: AppEvent] 
The keyDown is triggered any time a key on the keyboard is pushed down. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.keyUp
[type: AppEvent] 
The keyUp is triggered any time a key on the keyboard that was previously pushed down is released. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorMove
[type: AppEvent] 
The cursorMove is triggered any time the cursor is moved. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorPress
[type: AppEvent] 
The cursorPress is triggered any time the cursor is 'pressed down', which would be either by clicking the mouse button, or touching a touch-screen device. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorRelease
[type: AppEvent] 
The cursorRelease is triggered any time the cursor is 'let up', which would be either by realeasing the mouse button, or lifting a finger from a touch-screen device. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorScroll
[type: AppEvent] 
The cursorScroll is triggered any time mouse scroll wheel is used. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.contextMenu
[type: AppEvent] 
The contextMenu is triggered when the context menu (right-click dropdown menu) is accessed. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorLeave
[type: AppEvent] 
The cursorLeave is triggered any time the cursor leaves the canvas altogether. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.cursorEvent
[type: AppEvent] 
The cursorEvent is triggered any time the cursorMove, cursorPress, cursorRelease, cursorScroll, or contextMenu events are triggered. Use this AppEvent if you want to have a single callback receive the feedback from all of the cursor events. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.focusChange
[type: AppEvent] 
The focusChange AppEvent is triggered any time 'nc.singularFocusObject' is set to a new object. A FocusChangeInfo object will be sent to all callbacks as their first parameter - this object contains references to the object that is losing focus, as well as the object gaining focus.


INCISOR.appEvents.osFocusChange
[type: AppEvent] 
The osFocusChange AppEvent is triggered any time the OS changes its focus to or from the browser/app running this instance of Incisor®. The status of the browser/app ('focused' or 'unfocused') will be sent to all callbacks as their first parameter.


INCISOR.appEvents.visibilityChange
[type: AppEvent] 
The visibilityChange AppEvent is triggered any time the OS-level visibility of the browser/app running this instance of Incisor® changes. The status of the browser/app ('hidden' or 'visible') will be sent to all callbacks as their first parameter. This AppEvent is 'ordered', meaning callbacks added can provide a 'callbackOrder' parameter, which is used to determine the execution order of callbacks.


INCISOR.appEvents.clipboardEvent
[type: AppEvent] 
The clipboardEvent is triggered any time the browser encounters a 'copy', 'cut', or 'paste' event, affecting the OS clipboard. Use this AppEvent if you want to have a single callback receive the feedback from all of the clipboard events. The native browser-triggered event will be sent to all callbacks as their first parameter. Callbacks added to this AppEvent also have a 'singular focus option', meaning they can require that a particular object be 'focused' in order for the callback to be invoked - this enables certain functionality related to user-input to be restricted to the appropriate contexts within a UI.


INCISOR.appEvents.uiZoomChange
[type: AppEvent] 
The uiZoomChange AppEvent is triggered any time nc.uiZoom.totalZoom is changed, which can happen when nc.uiZoom.zoomValue changes or when the browser's devicePixelRatio changes. The updated totalZoom value will be sent to all callbacks as their first parameter.





INCISOR.pauseEvents
[type: dictionary] 
Object housing all defined PauseEvents. A given PauseEvent can be used as a parameter in 'nc.pause' and 'nc.resume' to pause and resume various time-based and user-interaction processes. Pausable processes react to pausing or resuming with PauseEvents unless those processes have a given PauseEvent as part of their designated 'pauseImmunity', which can determined in the parameters of a pausable-process-initiating method.


INCISOR.pauseEvents.MainPauseEvent
[type: PauseEvent] 
One of the currently defined PauseEvents.


INCISOR.pauseEvents.InspectorPauseEvent
[type: PauseEvent] 
One of the currently defined PauseEvents.





INCISOR.speedControls
[type: dictionary] 
Object housing all defined SpeedControls. SpeedControls can be used to control the speed of time-based sequencing processes such as Motions, Swoops, or Timelines. Applicable processes can subscribe to multiple SpeedControls - the 'speed' values of all of the SpeedControls a process subscribes to are multiplied together to determine the overall pacing of the given time-based process.


INCISOR.speedControls.MainSpeedControl
[type: SpeedControl] 
One of the currently defined SpeedControls.





INCISOR.defaultPauseImmunity
[type: [PauseEvent], PauseEvent] [default: [nc.pauseEvents.MainPauseEvent]] 
This is the pause immunity that is automatically applied if the 'pauseImmunity' parameter of any pausable-process-initiating method is left undefined. This value can be changed between big blocks of code to distinguish how groups of functionality react to different pauseEvents without needing to include specific 'pauseImmunity' for every single process initiated within each block.





INCISOR.defaultSpeedControl
[type: [SpeedControl], SpeedControl] [default: [nc.speedControls.MainSpeedControl]] 
The SpeedControl(s) that are automatically applied if the 'speedControl' parameter is left undefined in any method that initiates a speed controllable process. This value can be changed between big blocks of code to distinguish how groups of functionality interact with different sets of SpeedControls without needing to include specific 'speedControl' parameters for every single applicable process initiated within each block.





INCISOR.defaultFocusFallback
[type: SceneObject] [default: undefined] 
The default focusFallback value for new SceneObjects. This property can be changed at the top of any block of code where a lot of related SceneObjects are instantiated, and as a result all of those SceneObjects will receive the same new default focusFallback value.





INCISOR.targetFixedUpdateRate
[type: number] [default: 60] 
The number of times per second that the fixedUpdate will occur.





INCISOR.targetScreenUpdateRate
[type: number] [default: 60] 
The number of times per second that the screenUpdate will occur.





INCISOR.softwareSpeed
[type: number] [default: 1] 
When changed from 1, this value will increase or decrease the pacing of the fixedUpdate (independently from the 'targetFixedUpdateRate'), as well as the playback rate of all sounds played. The screenUpdate is not effected by this value. Manipulating this value can serve as a 'fast-forward' for the entire project.





INCISOR.singularFocusObject
[type: SceneObject] 
The singularFocusObject determines which callbacks connected to certain user-input AppEvents are invoked. For example, when a 'keyboardEvent' callback is added, a 'singularFocusRequirements' parameter can be supplied and that callback will only be invoked if the singularFocusObject is listed in the supplied 'singularFocusRequirements'. This is a way of adding keyboard AppEvent callbacks that will only be called if an associated contextual object is 'focused'.





INCISOR.singularFocusButtonPressRequirements
[type: [Button]] [default: undefined] 
Optional array of Buttons that can be supplied while a given object is the singularFocusObject; any cursor press must then be within one of the given Buttons in order for that focus to be maintained. A cursor press anywhere outside of these buttons will result in nc.reliquishFocus to be called. When a TextBox is focused via editing or selecting, this value is automatically set to the TextBox, and as a result, any exterior cursor press un-focuses the TextBox. When this property is undefined, cursor presses do not affect focus at all.





INCISOR.hiddenUpdating
[type: boolean] [default: false;] 
Flag determining if this project will continue its processes in any way while it is hidden by the OS.





INCISOR.hiddenScreenUpdating
[type: boolean] [default: false;] 
Flag determining if this project's ScreenUpdate will occur while it is hidden by the OS.





INCISOR.maxReconciliationTime
[type: number] [default: 1;] 
In the event that tasks within the 'fixedUpdate' and 'lateFixedUpdate' processes take longer than their alloted time for sustained periods, a sort of 'computational pile-up' can occur, where more instructions are scheduled per second that can be completed. This property limits the amount of 'catching up' that the system will try to do to, effectively allowing time to slip in these processes to avoid such computational pile-up. It should be noted that this value corresponds to the the maximum reconciliation time for when nc.hiddenUpdating is set to false.





INCISOR.maxHiddenReconciliationTime
[type: number] [default: 10;] 
In the event that tasks within the 'fixedUpdate' and 'lateFixedUpdate' processes take longer than their alloted time for sustained periods, a sort of 'computational pile-up' can occur, where more instructions are scheduled per second that can be completed. This property limits the amount of 'catching up' that the system will try to do to, effectively allowing time to slip in these processes to avoid such computational pile-up. It should be noted that this value corresponds to the the maximum reconciliation time for when nc.hiddenUpdating is set to true.





INCISOR.cursorMode
[type: string] [default: "autoDetect"] 
Flag determining which events are informing cursor interaction. When nc.cursorMode is set to 'autoDetect', the next cursor event will received will set the cursor mode; if it's a touch event then cursorMode will be set to 'touch', and if the it's a mouse event then cursorMode will be set to 'mouse'. When nc.cursorMode is set to 'mouse', Incisor is using the mousedown, mouseup, mouseleave, wheel, and mousemove browser events to inform cursor interactions. When nc.cursorMode is set to 'touch', Incisor is using the touchstart, touchend, touchcancel, and touchmove browser events to inform cursor interactions.





INCISOR.loadingTiers
[type: dictionary] 
Dictionary of loading tiers - each loading tier has a number designation. Loading tiers are a means to organize AssetComponents into separately downloadable groups.


INCISOR.loadingTiers.100
[type: number] 
The numeric designation of the '100' loading tier.





INCISOR.multiTapInterval
[type: number] [default: 0.25] 
The max amount of time between two Button presses for the Button presses to be considered part of the same 'doubleTap' or 'tripleTap'.





INCISOR.cameras
[type: dictionary] 
Dictionary of all registered Cameras in this project.


INCISOR.cameras.MainCamera
[type: OrthographicCamera] 
One of the currently defined Cameras.





INCISOR.mainCamera
[type: OrthographicCamera] 
The 'MainCamera' Camera.





INCISOR.canvasElement
[type: HTMLCanvasElement] 
The main canvas element for this project.





INCISOR.constants
[type: Constants] 
Object housing predefined constant values for various Incisor® options and modes.





INCISOR.constructDefs
[type: dictionary] 
Dictionary of available ConstructDefinitions.





INCISOR.customAddOnDefs
[type: dictionary] [NON-INSTANTIABLE] 
A dictionary of the CustomAddOn definitions currently registered with this project. CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





INCISOR.customObjectDefs
[type: dictionary] [NON-INSTANTIABLE] 
A dictionary of the CustomObject definitions currently registered with this project. CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





INCISOR.effectControllers
[type: dictionary] 
Dictionary of EffectControllerDefinitions for all of the registered EffectControllers.


INCISOR.effectControllers.fillColor
[type: fillColor_Definition] 
The info-object for the 'fillColor' EffectController.


INCISOR.effectControllers.mainTexture
[type: mainTexture_Definition] 
The info-object for the 'mainTexture' EffectController.


INCISOR.effectControllers.colorMultiply
[type: colorMultiply_Definition] 
The info-object for the 'colorMultiply' EffectController.


INCISOR.effectControllers.shapify
[type: shapify_Definition] 
The info-object for the 'shapify' EffectController.


INCISOR.effectControllers.shear
[type: shear_Definition] 
The info-object for the 'shear' EffectController.


INCISOR.effectControllers.shear_center
[type: shear_center_Definition] 
The info-object for the 'shear_center' EffectController.





INCISOR.effectNodes
[type: dictionary] 
Dictionary of all defined EffectNodes.


INCISOR.effectNodes.FillColor
[type: EffectNode] 
One of the currently defined EffectNodes.


INCISOR.effectNodes.SampleMainTexture
[type: EffectNode] 
One of the currently defined EffectNodes.


INCISOR.effectNodes.ColorMultiply
[type: EffectNode] 
One of the currently defined EffectNodes.


INCISOR.effectNodes.Shapify
[type: EffectNode] 
One of the currently defined EffectNodes.


INCISOR.effectNodes.MaskingReturn
[type: EffectNode] 
One of the currently defined EffectNodes.


INCISOR.effectNodes.Shear
[type: EffectNode] 
One of the currently defined EffectNodes.





INCISOR.fileIO
[type: FileIO] [requires: license - fileIO] 
Object housing functionality to perform file IO tasks such as 'writeTextFile', 'moveTo', 'createDirectory' an more. This functionality only exists within un-built projects, and also requires that the user account has access to the FileIO features.





INCISOR.flows
[type: dictionary] [NON-INSTANTIABLE] [requires: license - proGaming, module - flowControllers] 
The FlowControllers currently defined in this project. FlowControllers provide a way to organize the general flow of state-based items in a project. For example if your project is a game with an intro, a menu, and several levels, you could create a FlowController named "GameFlowController" and then define and add an 'Intro' FlowState, a 'Menu' FlowState, and 'LevelXX' FlowStates to that FlowController. Within each FlowState in the FlowController, timed callback elements can be added to help define the sequencing within each FlowState. Once created, FlowControllers, FlowStates, and FlowStateElements can be accessed via 'nc.flows'. This class is not meant to be instantiated or provided directly to 'FlowController.addFlowState', rather it is meant to be a class for user-defined FlowStates to extend. Call 'nc.defineFlowController' to create a new FlowController, then use 'nc.flows' to access it. 


INCISOR.flows.incr_replaceText_flowControllersDocumentation
[type: dictionary] 






INCISOR.fontNames
[type: dictionary] 
Dictionary of the names of the fonts available within this project.


INCISOR.fontNames.NullFont
[type: string] 
The 'NullFont' font name string.


INCISOR.fontNames.incr_inspectorFont
[type: string] 
The 'incr_inspectorFont' font name string.


INCISOR.fontNames.MonoSpace
[type: string] 
The 'MonoSpace' font name string.





INCISOR.geometries
[type: dictionary] 
Dictionary of all registered Geometries.


INCISOR.geometries.WhiteBox
[type: Geometry] 
One of the currently defined Geometries.


INCISOR.geometries.WhiteTriangle
[type: Geometry] 
One of the currently defined Geometries.


INCISOR.geometries.NullFont_Char0
[type: Geometry] 
One of the currently defined Geometries.





INCISOR.graphicAssets
[type: dictionary] 
Dictionary of all registered GraphicAssets.


INCISOR.graphicAssets.WhiteBox
[type: GraphicAsset] 
One of the currently defined GraphicAssets.


INCISOR.graphicAssets.WhiteTriangle
[type: GraphicAsset] 
One of the currently defined GraphicAssets.


INCISOR.graphicAssets.NullFont_Char0
[type: GraphicAsset] 
One of the currently defined GraphicAssets.





INCISOR.maskGroups
[type: dictionary] 
The MaskGroups available in this project.


INCISOR.maskGroups.MainMaskGroup
[type: MaskGroup] 
One of the currently defined MaskGroups.





INCISOR.incisorApp
[type: IncisorApp] [requires: unpublished only, license - advancedTools] 
Object housing functionality allowing for direct interactions with the Incisor® application from within the javascript runtime. Such functionality includes the ability to get/set project and application settings, initiate the hosting of files in local directories, script the opening of new browser tabs, and perform other transactions with the Incisor® application.





INCISOR.incisorAppBasic
[type: IncisorAppBasic] [requires: unpublished only] 
Object housing basic functionality allowing for direct interactions with the Incisor® application from within the javascript runtime. Such functionality includes the ability to get the list of optional code modules from the Incisor™ application. See 'nc.incisorApp' for many more application interaction options.





INCISOR.keyDownStates
[type: object] 
Dictionary with the current state of each key on the keyboard, regardless of pause states or focused objects (see nc.singularFocusObject). This can be used used to check the state of modifier keys such as the 'shift' or 'option' key. If the key in question is down, this object will have a member (with the key as the name) that is true, otherise the member will be undefined.





INCISOR.defaultDepthTesting
[type: boolean] [default: false] 
The default value for the 'depthTest' property on all GraphicObject Materials. It should be noted that some GraphicAssets may have Material presets that determine a specific value for 'depthTest', and those Material presets supersede this value.





INCISOR.defaultDepthWriting
[type: boolean] [default: true] 
The default value for the 'depthWrite' property on all GraphicObject Materials. It should be noted that some GraphicAssets may have Material presets that determine a specific value for 'depthWrite', and those Material presets supersede this value.





INCISOR.motionTypes
[type: dictionary] 
Object housing all defined MotionTypes. MotionTypes are used in conjunction with Motions and define a method of continuous change for numeric properties.


INCISOR.motionTypes.Pendulum
[type: MotionType] 
The 'Pendulum' MotionType. This MotionType smoothly swings the value or values back and forth between the lower and upper bounds. While some MotionTypes are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





INCISOR.particleSystemDefs
[type: dictionary] 
Dictionary of all registered ParticleSystemDefinitions.


INCISOR.particleSystemDefs.incr_replaceText_particleSystemsDocumentation
[type: dictionary] 






INCISOR.paths
[type: Paths] 
Object housing functionality manipulate paths including 'splitPath', 'getFileName', and 'getParentDirectory'.





INCISOR.pixelsObjects
[type: PixelsObjects] [requires: module - pixelsObjects] 
Object housing functionality for PixelsObjects, which are RGBA bitmap images in a simple, 'data-only' format, used for basic image access and manipulation.





INCISOR.precomps
[type: dictionary] 
Dictionary of Precomps





INCISOR.projectConfiguration
[type: ProjectConfiguration] 
Object housing the configuration settings for this project. Many of the members of this object are customizable on a 'per configuration' basis by editing the 'ProjectSettings' file within the project. The user-customizable 'PreloadConfiguration' code is executed within this object, so members created within that code will be accessible on this object.





INCISOR.publishing
[type: Publishing] [requires: unpublished only, license - publishing] 
Object housing functionality for publishing projects.





INCISOR.renderTargets
[type: dictionary] 
Dictionary of all registered RenderTargets in this project. RenderTargets are objects that contain Textures to render to, as well as settings for how those textures may be resized automatically based on environmental factors such as canvas size, canvas aspect ratio, and the current asset package scale.


INCISOR.renderTargets.MainRenderTarget
[type: RenderTarget] 
One of the currently defined RenderTargets.





INCISOR.globalRenderTargetResolutionScaler
[type: number] [default: 1] 
Value that multiplies the resolution scale of all RenderTargets whose 'globalRenderTargetResolutionScaling' property is true.





INCISOR.mainRenderTarget
[type: RenderTarget] 
The main canvas RenderTarget.





INCISOR.scenes
[type: dictionary] 
Dictionary of all registered Scenes in this project. Scenes are the root SceneObjects in hierarchies. All SceneObjects are either Scenes or descendants of Scenes.


INCISOR.scenes.MainScene
[type: Scene] 
One of the currently defined Scenes.





INCISOR.layers
[type: dictionary] 
Dictionary of all registered Layers in this project.


INCISOR.layers.DefaultLayer
[type: Layer] 
One of the currently defined Layers.


INCISOR.layers.PageLayer
[type: Layer] 
One of the currently defined Layers.


INCISOR.layers.UiVisualFocusDimmerLayer
[type: Layer] 
One of the currently defined Layers.


INCISOR.layers.UiVisualFocusLayer
[type: Layer] 
One of the currently defined Layers.





INCISOR.mainScene
[type: Scene] 
The 'MainScene' Scene.





INCISOR.layersByScene
[type: LayersByScene] 
A 2D dictionary that lists the available Layers in each Scene. These dictionaries are not ordered, for the order of the Layers in a given Scene, see 'Scene.layerOrderLedger'.





INCISOR.sounds
[type: dictionary] [requires: module - sounds] 
Dictionary of all registered Sounds.


INCISOR.sounds.incr_replaceText_soundsDocumentation
[type: dictionary] 






INCISOR.volumeControls
[type: dictionary] [requires: module - sounds] 
Dictionary of all registered VolumeControls.


INCISOR.volumeControls.incr_replaceText_volumeControlsDocumentation
[type: dictionary] 






INCISOR.tweenTypes
[type: dictionary] 
Object housing all defined TweenTypes. TweenTypes are used in conjunction with 'Swoopers' and define a method of numeric property interpolation between any two values or sets of values. TweenTypes can vary the timing of interpolation between two sets of values, as well as the path of the interpolation.


INCISOR.tweenTypes.Linear
[type: TweenType] 
The 'Linear' TweenType. This TweenType interpolates linearly between the current value/values and the end value/values. While some TweenTypes are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.


INCISOR.tweenTypes.Ease
[type: TweenType] 
The 'Ease' TweenType. This TweenType interpolates between the current value/values and the end value/values smoothly, accelerating from the starting values, and decelarating as the ending values are approached. While some TweenTypes are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.


INCISOR.tweenTypes.ExtremeEaseOut
[type: TweenType] 
The 'ExtremeEaseOut' TweenType. This TweenType changes very slowly at first and speeds up. While some TweenTypes are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.


INCISOR.tweenTypes.ExtremeEaseIn
[type: TweenType] 
The 'ExtremeEaseIn' TweenType. This TweenType changes very quickly at first and slows down. While some TweenTypes are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





INCISOR.mainModifierKey
[type: string] [default: "Control"] 
The name of the keyboard key that serves as the main modifier key for keyboard input. For example while editing the text in a TextBox, the nc.mainModifierKey + the "A" key will select all.





INCISOR.textures
[type: dictionary] 
Dictionary of all registered Textures.


INCISOR.textures.incr_icons_sheet0
[type: Texture] 
One of the currently defined Textures.


INCISOR.textures."NotoSansMono_Condensed-Medium0"
[type: Texture] 
One of the currently defined Textures.


INCISOR.textures.incr_inspectorFont0
[type: Texture] 
One of the currently defined Textures.


INCISOR.textures.WhiteBox
[type: Texture] 
One of the currently defined Textures.


INCISOR.textures.NullFont_Char0
[type: Texture] 
One of the currently defined Textures.





INCISOR.timeStamp
[type: TimeStamp] [requires: module - timeStamp] 
Object housing functionality for time stamps, the Incisor® standardized format for date and time.





INCISOR.phraseIDs
[type: dictionary] 
Dictionary of the phraseIDs contained in the ProjectTranscript. Using phraseIDs to populate TextBoxes and TextAssemblies will enable the text content to be dynamically populated based on the current language setting of the project.


INCISOR.phraseIDs."Hello World"
[type: string] 
One of the phrases defined in the ProjectTranscript.


INCISOR.phraseIDs."Goodbye World"
[type: string] 
One of the phrases defined in the ProjectTranscript.





INCISOR.phrases
[type: dictionary] 
Dictionary of the phrases contained in the ProjectTranscript (listed by phraseID). Using phraseIDs to populate TextBoxes and TextAssemblies will enable the text content to be dynamically populated based on the current language setting of the project.


INCISOR.phrases."Hello World"
[type: string] 
One of the phrases defined in the ProjectTranscript.


INCISOR.phrases."Goodbye World"
[type: string] 
One of the phrases defined in the ProjectTranscript.





INCISOR.uiStyle
[type: UiStyle] [requires: module - extendedUi] 
Object housing default TextFormats, and Colors for various Gui objects such as 'UiButton', 'DropDownMenu' and 'PopUpWindow'.





INCISOR.enableIncisorInspectorAutoPositioning
[type: boolean] [default: false] [requires: module - extendedUi] 
Boolean determining if certain automatic positioning features specifically related to the Incisor Inspector are enabled. It should be noted that the Incisor Inspector uses a non-standard coordinate system with (0,0) in the upperleft corner. Automatica positioning features include: automatic placement of UiPopupWindows in the center of the screen and automatic adjustment of UiMenus to avoid them extending outside of the Inspector viewing area.





INCISOR.useNearestPixelRenderingForAllUiItems
[type: boolean] [default: true] 
Boolean determining if 'useNearestPixelRendering' defaults to true for 'UI' items such as UiButton or UiText. In general, you should use 'useNearestPixelRendering' for situations when the area being rendered is the same exact resolution as the RenderTarget it's being used to; it is a means to have 'pixel perfect' TextBox rendering. If the camera is rendering a variable area or an area that doesn't match the RenderTarget being rendered to (such such as when the camera's adaptiveCameraMode is set to 'maximizeSafeZone') then 'useNearestPixelRendering' should not be used and this value should be false;





INCISOR.visualFocusObject
[type: UiVisualFocus] [requires: module - extendedUi] 
Read-only property denoting which object (if any) is currently visually focused. 'VisualFocus' is a mode that focuses the end-user's attention the given SceneObject by placing it in front of a dimmer layer whenever the object is the the current 'singularFocusObject'. See 'SceneObject.configureUiVisualFocus' for more information.





INCISOR.visualFocusEnabled
[type: boolean] [default: true] [requires: module - extendedUi] 
Boolean determining if the entire Visual Focus system is enabled.  'VisualFocus' is a mode that focuses the end-user's attention the given SceneObject by placing it in front of a dimmer layer whenever the object is the the current 'singularFocusObject'. See 'SceneObject.configureUiVisualFocus' for more information.





INCISOR.visualFocusDimmerAmount
[type: number] [default: .5] 
Number determining how strong the visual focus dimmer is on a scale of 0 to 1.





INCISOR.uiZoom
[type: UiZoom] 
Object housing functionality associated with the user interface zoom, which enables end-users to increase or decrease the overall size of text and other user interface items (when those items have uiZoom functionality enabled).





INCISOR.urlParameterIterator
[type: UrlParameterIterator] [requires: module - urlParameterIterator] 
Object housing testing functionality that enables a project to refresh itself repeatedly with different url parameters. Such functionality can help with batch testing of a project's configurations or settings. To use this functionality, first call the 'UrlParameterIteration.setup' method, passing it an array of objects where each object represents the url parameters you would like the browser to refresh with. When ready to start the iteration, call 'UrlParameterIteration.start'. Then add the desired functionality per url parameter - be sure to implement what you want conditionally based on the url params (otherwise everything will happen on every refresh). When the desired tasks (testing, screen shots, etc...) have completed for each set of url parameters, call 'UrlParameterIteration.next', this will proceed to refresh with the next set of url parameters.





INCISOR.videos
[type: dictionary] [requires: module - videos] 
Dictionary of all registered Videos. When compressed video assets (mp4 or webm) are included in a project a Texture, Geometry, GraphicAsset, and Video with that same name are created in Incisor. Once included, any GraphicObject can be set to the corresponding GraphicAsset, and the associated Video object can control the video's playback. It should be noted that the visual content of any instance or use of the GraphicAsset will be same everywhere - as video's content is pushed to the associated texture, all objects using that Texture will see the same content. Videos in Incisor rely entirely on the browser's decoding and playback capabilities, which typically don't support rapid/repeated changes to video properties. In practice, videos perform well when playing once normally or free-running, but do not do well with a lot of rapid time jumps or scrubbing. Video formats are not uniformly supported for use within all browsers, and their use is not advised within projects meant to be universally accessible. Acceptable extensions for video files include ".mp4" and ".webm", and while webm (VP8 or VP9) typically supports transparency, there are currently no video formats that support transparency on any Apple mobile or desktop products.


INCISOR.videos.incr_replaceText_videosDocumentation
[type: dictionary] 






INCISOR.incisorExtensions_project
[type: object] [requires: unpublished only, license - extensions] 
The object housing the Incisor project extensions scope. This property will be undefined if the requirements are met, or if there are no project extensions.





INCISOR.incisorExtensions_global
[type: object] [requires: unpublished only, license - extensions] 
The object housing the Incisor global extensions scope. This property will be undefined if the requirements are met, or if there are no global extensions.





INCISOR.defineAppEvent(eventName, hasSingularFocusScheme, isOrdered, hasConsumableCallbacks)
[type: function] [returns: AppEvent] 
Defines a new custom Incisor® AppEvent that can have callbacks added and can be triggered using 'AppEvent.trigger'.

INCISOR.defineAppEvent parameter: eventName
[type: string] 
The name of the new AppEvent being defined.

INCISOR.defineAppEvent parameter: hasSingularFocusScheme
[type: boolean] [default: false] [optional] 
Flag indicating if this AppEvent will have a 'singular focus scheme' which is a system that restricts callback invocation to items associated with the currently 'focused' object as determined by nc.singularFocusObject.

INCISOR.defineAppEvent parameter: isOrdered
[type: boolean] [default: false] [optional] 
Flag indicating if this AppEvent will be 'ordered', which allows callbacks added to this AppEvent to be provided a callback order number, which is then used to sort the callbacks when the AppEvent is triggered.

INCISOR.defineAppEvent parameter: hasConsumableCallbacks
[type: boolean] [default: false] [optional] 
Flag indicating if this AppEvent removes callbacks after one invocation.

example:
// Objective: Trigger a custom AppEvent.
// Expected Result: You will see a green square.

// create a white box GraphicObject
this.whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );

// define a custom AppEvent and add its callback
nc.defineAppEvent( "MyCustomAppEvent" );
nc.appEvents.MyCustomAppEvent.addCallback( this, "myAppEventCallback" );

// the AppEvent callback will update the fillColor of the box
this.myAppEventCallback = function( r, g, b, a ) {
    this.whiteBox.fillColor = new Color( r, g, b, a );
}

// trigger my AppEvent passing in parameters as an array (set the red and blue to zero)
nc.appEvents.MyCustomAppEvent.trigger( [0, 1, 0, 1] );





INCISOR.definePauseEvent(pauseEventName)
[type: function] [returns: PauseEvent] 
Defines a new PauseEvent. The various time-based and user-interaction processes in Incisor® can be paused by calling 'nc.pause' with a PauseEvent parameter. Pausable processes can also opt out of being paused by providing a 'pauseImmunity' list during their initiation (as will be indicated in initiating method parameters). The pauseImmunity list is a list of PauseEvents that the given process will be immune to. All defined PauseEvents can be found at 'nc.pauseEvents'.

INCISOR.definePauseEvent parameter: pauseEventName
[type: string] 
The name of the new PauseEvent.





INCISOR.pause(pauseEvent)
[type: function] 
Pauses the various time-based and user-interaction processes that can be paused by the supplied PauseEvent. Processes that list the supplied PauseEvent in their 'pauseImmunity' will be immune to this pause.

INCISOR.pause parameter: pauseEvent
[type: PauseEvent] 
The PauseEvent being triggered. Available PauseEvents can be found in 'nc.pauseEvents'.

example:
// Objective: Pause and resume motion.
// Expected Result: The white box will move up and down along the y axis for 3 seconds, then pause for 3 seconds, then resume again.

// create a GraphicObject with the white box asset
let graphic = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// add motion to the position of this GraphicObject along the y axis with a motion speed of 2
graphic.position.addMotion.y( -300, 300, 2 );
// create a PauseEvent
nc.definePauseEvent("BoxPause");
// wait 3 seconds, then call "pause", passing BoxPause as the PauseEvent
nc.waitThen( 3, nc, "pause", [nc.pauseEvents.BoxPause] );
       
// wait 6 seconds, then call "resume"
// NOTE: At this point, "resume" is paused by the BoxPause event. This is why we must also
// pass the BoxPause event as the "pauseImmunity" parameter.
nc.waitThen( 6, nc, "resume", nc.pauseEvents.BoxPause , undefined, nc.pauseEvents.BoxPause );





INCISOR.resume(pauseEvent)
[type: function] 
Resumes the processes that were paused by the supplied PauseEvent. Some processes may not resume if they are still being affected by other PauseEvents.

INCISOR.resume parameter: pauseEvent
[type: PauseEvent] 
The PauseEvent being resumed. Available PauseEvents can be found in 'nc.pauseEvents'.

example:
// Objective: Pause and resume motion.
// Expected Result: The white box will move up and down along the y axis for 3 seconds, then pause for 3 seconds, then resume again.

// create a GraphicObject with the white box asset
let graphic = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// add motion to the position of this GraphicObject along the y axis with a motion speed of 2
graphic.position.addMotion.y( -300, 300, 2 );
// create a PauseEvent
nc.definePauseEvent("BoxPause");
// wait 3 seconds, then call "pause", passing BoxPause as the PauseEvent
nc.waitThen( 3, nc, "pause", [nc.pauseEvents.BoxPause] );
       
// wait 6 seconds, then call "resume"
// NOTE: At this point, "resume" is paused by the BoxPause event. This is why we must also
// pass the BoxPause event as the "pauseImmunity" parameter.
nc.waitThen( 6, nc, "resume", nc.pauseEvents.BoxPause , undefined, nc.pauseEvents.BoxPause );





INCISOR.defineSpeedControl(speedControlName)
[type: function] [returns: SpeedControl] 
Defines a new SpeedControl. SpeedControls can be used to control the speed of time-based sequencing processes such as Motions, Swoops, or Timelines. Applicable processes can subscribe to multiple SpeedControls; the 'speed' values of all of the SpeedControls a process subscribes to are multiplied together to determine the overall pacing of the given time-based process. All defined SpeedControls can be found at 'nc.speedControls'.

INCISOR.defineSpeedControl parameter: speedControlName
[type: string] 
The name of the new SpeedControl.





INCISOR.getAllEventRecipients()
[type: function] [returns: object] 
Returns a dictionary containing lists of all active callbacks per AppEvent.





INCISOR.relinquishFocus()
[type: function] 
Sets nc.singularFocusObject to nc.singularFocusObject.focusFallback.





INCISOR.copyToClipboard(text)
[type: function] 
Copies the given text to the clipboard.

INCISOR.copyToClipboard parameter: text
[type: string] 
The text to be copied to the clipboard.





INCISOR.getClipboardText()
[type: function] [returns: string] 
Retrieves text from the clipboard.





INCISOR.loadTier(tier, prioritize)
[type: function] 
Initiates the process of loading all of the assets in a given loading tier. This function does not need to be called for 'auto-loaded' LoadingTiers.

INCISOR.loadTier parameter: tier
[type: number] 
The desired tier for loading. For a list of available LoadingTiers, see nc.LoadingTiers.

INCISOR.loadTier parameter: prioritize
[type: boolean] [default: true] [optional] 
Bool determining if the tier in question will jump to the frot of the loading queue.





INCISOR.addTierLoadedCallback(tiers, callbackOwner, callbackName, callbackArgs, callbackOrder)
[type: function] 
Adds a callback that will be called once the designated tier(s) are loaded. A callback order can be provided to rank the order of the given callback.

INCISOR.addTierLoadedCallback parameter: tiers
[type: number, [number]] 
The tier or tiers whose loading will trigger this callback.

INCISOR.addTierLoadedCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

INCISOR.addTierLoadedCallback parameter: callbackName
[type: string] 
The name of the callback function.

INCISOR.addTierLoadedCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function.

INCISOR.addTierLoadedCallback parameter: callbackOrder
[type: number] [default: 0] [optional] 
Number designating the order the callback will be invoked relative to the other callbacks associated with this tier. A lower callbackOrder equates to an earlier callback.





INCISOR.awaitLoadedTiers(tiers)
[type: function] 
An awaitable asyncronous function that delays until the specified tier(s) are loaded.

INCISOR.awaitLoadedTiers parameter: tiers
[type: number, [number]] 
The tier or tiers whose loading is being awaited.





INCISOR.inheritButton(obj, graphicAsset, parent, name)
[type: function] 
Adds Button functionality to the object supplied.

INCISOR.inheritButton parameter: obj
[type: object] 
The object that Button functionality is being added to.

INCISOR.inheritButton parameter: graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] [optional] 
The GraphicAsset that the new Button will initially be set to. For a list of available GraphicAssets, see 'nc.graphicAssets'.

INCISOR.inheritButton parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new Button's parent in the Scene hierarchy.

INCISOR.inheritButton parameter: name
[type: string] [default: 'Button'] [optional] 
The name of the new Button.





INCISOR.addButton(graphicAsset, parent, name)
[type: function] [returns: Button] 
Adds a Button set to the provided GraphicAsset as a child of the given SceneObject.

INCISOR.addButton parameter: graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] [optional] 
The GraphicAsset that the new Button will initially be set to. For a list of available GraphicAssets, see 'nc.graphicAssets'.

INCISOR.addButton parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new Button's parent in the Scene hierarchy.

INCISOR.addButton parameter: name
[type: string] [default: 'Button'] [optional] 
The name of the new Button.

example:
// Objective: Use Incisor to add a Button.
// Expected Result: The console should display all of the properties of the new button. 

let button = nc.addButton( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
console.log(button);





INCISOR.inheritOrthographicCamera(obj, parent, name)
[type: function] 
Adds OrthographicCamera functionality to the object supplied.

INCISOR.inheritOrthographicCamera parameter: obj
[type: object] 
The object that Camera functionality is being added to.

INCISOR.inheritOrthographicCamera parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The parent of the new Camera.

INCISOR.inheritOrthographicCamera parameter: name
[type: string] [optional] 
The name of the new Camera.





INCISOR.addOrthographicCamera(parent, name)
[type: function] [returns: OrthographicCamera] 
Adds an OrthographicCamera to the given parent.

INCISOR.addOrthographicCamera parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new OrthographicCamera's parent.

INCISOR.addOrthographicCamera parameter: name
[type: string] [default: OrthographicCamera] [optional] 
The name of the new OrthographicCamera. This name must be unique among camera names.





INCISOR.getCanvasPixelResolution()
[type: function] [returns: Vector2] 
Returns a Vector2 with the pixel resolution of nc.mainRenderTarget.





INCISOR.defineConstruct(name, blueprint)
[type: function] [returns: ConstructDefinition] 
A means to manually create a ConstructDefinition. It should be noted that most users will not need to use this function, as Constructs are typically created in the Incisor® GUI.

INCISOR.defineConstruct parameter: name
[type: string] 
The name of the new ConstructDefinition. This name must be a unique class name, must not start with digits, and must not contain special characters or spaces.

INCISOR.defineConstruct parameter: blueprint
[type: Blueprint] [optional] 
Object containing the core instructions for recreating the collection of objects that will define this Construct. The function 'nc.gatherObjectBlueprint' can be used to get a Blueprint object from a pre-existing object. If this parameter is left undefined, then an empty Construct is defined.





INCISOR.gatherObjectBlueprint(sceneObject, includeRoot, includeDescendants)
[type: function] 
This function can be used to collect the core information needed to define a Construct based on a group of objects whithin a Scene. Just provide a root SceneObject and information about its entire sub-hierarchy will be gathered and returned in the form of a 'Blueprint' object, which can then be used to define Constructs using 'nc.defineConstruct'. It should be noted that most users will not need to use this functionality; it is used in the Creation of Constructs, which are typically just created in the Incisor® GUI.

INCISOR.gatherObjectBlueprint parameter: sceneObject
[type: SceneObject] 
The root SceneObject to gather a Blueprint for.

INCISOR.gatherObjectBlueprint parameter: includeRoot
[type: boolean] [default: true] [optional] 
If true, the provided root will be included in the construct, if false the root will be omitted.

INCISOR.gatherObjectBlueprint parameter: includeDescendants
[type: boolean] [default: true] [optional] 
Boolean determining if the descendants will be included in the gathered blueprint.





INCISOR.recreateObjectFromBlueprint(parent, blueprint)
[type: function] [returns: SceneObject] 
Recreates the objects stored in the Blueprint, placing them in the provided parent SceneObject, and returning the newly created root-most object(s). This functionality is the foundation for Incisor® Constructs.

INCISOR.recreateObjectFromBlueprint parameter: parent
[type: SceneObject] 
The SceneObject that will be the parent of the newly recreated collection of objects.

INCISOR.recreateObjectFromBlueprint parameter: blueprint
[type: Blueprint] 
The blueprint containing the information about the collection of objects that will be recreated.





INCISOR.duplicateViaBlueprint(source, parent, includeDescendants)
[type: function] [returns: SceneObject] 
Duplicates the given source object according to its 'blueprint', which is the serialized form of objects used by Constructs. It should be noted that this form of duplication will only capture values for standard components and properties - customizations will be lost in the process.

INCISOR.duplicateViaBlueprint parameter: source
[type: SceneObject] 
The source object for the duplication.

INCISOR.duplicateViaBlueprint parameter: parent
[type: SceneObject] 
The SceneObject that will become the new copy's parent.

INCISOR.duplicateViaBlueprint parameter: includeDescendants
[type: boolean] [default: true] [optional] 
Boolean determining if the source object's descendants will be included in the duplicate.





INCISOR.inheritCursorInputOverrideButton(obj, graphicAsset, parent, name)
[type: function] 
Adds CursorInputOverrideButton functionality to the object supplied.

INCISOR.inheritCursorInputOverrideButton parameter: obj
[type: object] 
The object that CursorInputOverrideButton functionality is being added to.

INCISOR.inheritCursorInputOverrideButton parameter: graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] [optional] 
The GraphicAsset that the new CursorInputOverrideButton will initially be set to. For a list of available GraphicAssets, see 'nc.graphicAssets'.

INCISOR.inheritCursorInputOverrideButton parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new CursorInputOverrideButton's parent in the Scene hierarchy.

INCISOR.inheritCursorInputOverrideButton parameter: name
[type: string] [default: 'CursorInputOverrideButton'] [optional] 
The name of the new CursorInputOverrideButton.





INCISOR.inheritCurve(obj, parent, name)
[type: function] 
Adds Curve functionality to the object supplied.

INCISOR.inheritCurve parameter: obj
[type: object] 
The object that Curve functionality is being added to.

INCISOR.inheritCurve parameter: parent
[type: SceneObject] 
The SceneObject that will become the new Curve's parent in the Scene hierarchy.

INCISOR.inheritCurve parameter: name
[type: string] [default: 'Curve'] 
The name of the new Curve.





INCISOR.addCurve(parent, name)
[type: function] 
Adds a SceneObject as a child of the given SceneObject.

INCISOR.addCurve parameter: parent
[type: SceneObject] 
The SceneObject that will become the new Curve's parent in the Scene hierarchy.

INCISOR.addCurve parameter: name
[type: string] [default: 'Curve'] 
The name of the new Curve.





INCISOR.registerCustomAddOn(classDefinition)
[type: function] [returns: CustomAddOnDefinition] 
Registers the given class definition as a CustomAddOn with the Incisor inspector. Once registered, instances of the given object can be added to other objects using the GUI (in the Construct Editor etc...).

INCISOR.registerCustomAddOn parameter: classDefinition
[type: object] 
The desired class definition to register with the Incisor inspector as a CustomAddOn. The provided class definition must inherit from a 'CustomAddOn' type such as 'CustomAddOn_SceneObject' or 'CustomAddOn_GraphicObject'.





INCISOR.registerCustomAddOnProperty(classDefinition, propertyType, propertyPath)
[type: function] [returns: RegisteredProperty] 
Registers a property of the given CustomAddOn with Incisor. Registered properties are accessible for monitoring and manipulating within the inspector. Registered properties can also be flagged as 'persistent', which enables their values to be stored in containing Constructs.

INCISOR.registerCustomAddOnProperty parameter: classDefinition
[type: object] 
The class definition of the CustomAddOn for which to register a property.

INCISOR.registerCustomAddOnProperty parameter: propertyType
[type: string] 
The type of the property to register. The available types can be found in constants.registeredPropertyTypes

INCISOR.registerCustomAddOnProperty parameter: propertyPath
[type: [string], string] 
The path to the desired property to register in terms of member names. If the property owned directly by the CustomAddOn, the name of the property can be provided as a single string. If the property is a sub-member of a property, each accessing member should be listed in an Array, or a single 'dot-separated' string can be provided.





INCISOR.registerCustomObject(classDefinition)
[type: function] [returns: CustomObjectDefinition] 
Registers the given class definition as a CustomObject with the Incisor inspector. Once registered, instances of the given object can be added to Constructs using the GUI (in the Construct Editor etc...).

INCISOR.registerCustomObject parameter: classDefinition
[type: object] 
The desired class definition to register with the Incisor inspector as a CustomObject. The provided class definition must inherit from a standard hierarchy object type such as SceneObject, GraphicObject, or Button etc...





INCISOR.registerCustomObjectProperty(classDefinition, propertyType, propertyPath)
[type: function] [returns: RegisteredProperty] 
Registers a property of the given CustomObject with Incisor. Registered properties are accessible for monitoring and manipulating within the inspector. Registered properties can also be flagged as 'persistent', which enables their values to be stored in containing Constructs.

INCISOR.registerCustomObjectProperty parameter: classDefinition
[type: object] 
The class definition of the CustomObject for which to register a property.

INCISOR.registerCustomObjectProperty parameter: propertyType
[type: string] 
The type of the property to register. The available types can be found in constants.registeredPropertyTypes

INCISOR.registerCustomObjectProperty parameter: propertyPath
[type: [string], string] 
The path to the desired property to register in terms of member names. If the property owned directly by the CustomObject, the name of the property can be provided as a single string. If the property is a sub-member of a property, each accessing member should be listed in an Array, or a single 'dot-separated' string can be provided.





INCISOR.dispose(objectForDisposal)
[type: function] 
Removes the provided object from all Incisor® registries. Send any object slated for deletion to this function to ensure that references to the object are not being kept in Incisor®'s regestries. Doing this can help prevent memory leaks.

INCISOR.dispose parameter: objectForDisposal
[type: object] 
The object that will be disposed.





INCISOR.defineEffectController(name, baseType, componentNames, defaultValues, mixMode, likelyRanges, effectControllerDescription, componentDescriptions)
[type: function] 
Defines a new EffectController for use in conjunction with an EffectNode. EffectControllers provide the ability to dynamically control EffectNodes and their resulting visual effects. EffectControllers are generally one of 3 base types, Vectors, numbers, and Textures. Once defined, EffectControllers will be generally available on all SceneObjects, Materials, MaterialMaster, CharacterMaterial objects; It should be noted that while these objects will have all EffectControllers as members, only the EffectControllers tied to the objects' current EffectNodes will cause any change visually. It should also be noted EffectControllers with 'mixMode=materialOnly' will not be available on SceneObjects for inheritance, and will instead only be on Material and MaterialMaster objects for direct manipulation.

INCISOR.defineEffectController parameter: name
[type: string] 
The name of the new EffectController. This name must be unique, and it must not contain any javascript delimeters (no spaces, commas, periods, etc...)

INCISOR.defineEffectController parameter: baseType
[type: string] 
The base type of the new EffectController. For a list of available base types, see 'nc.constants.effectControllerBaseTypes'.

INCISOR.defineEffectController parameter: componentNames
[type: [string]] 
An array of names for the components of this EffectController. An example would be ['magnitude', 'brightness', 'fadeAmount']. It should be noted that EffectControllers with componentNames ["red","green","blue","alpha"] will automatically have type 'Color', and similarly componentNames ["x","y", etc...] will have the associated 'Vector' type. For non-Vector types this can be left undefined.

INCISOR.defineEffectController parameter: defaultValues
[type: [number], number, Texture] 
An array of numbers (for Vector baseTypes), number (for number baseTypes), or Texture (for Texture baseTypes) that serve as the default value(s) for this EffectController's components.

INCISOR.defineEffectController parameter: mixMode
[type: string] 
The means by which parent and child EffectControllers' values are blended together. Please note that a mixMode value of 'materialOnly' means that the given EffectController will only appear directly on Material and MaterialMaster objects, and therefore no mixing of values will ever take place. For a list of available mixModes, see 'nc.constants.effectControllerMixModes'.

INCISOR.defineEffectController parameter: likelyRanges
[type: [[number]]] [default: [[0,10] [optional] 
A list of likely ranges for the components of this EffectController. This is used to inform the Incisor® GUI, specifically the sensativity of EffectoController 'sliders'.,[0,10]...]]

INCISOR.defineEffectController parameter: effectControllerDescription
[type: string] [default: ""] [optional] 
Optional description to help populate IDE autocomplete related to this EffectController.

INCISOR.defineEffectController parameter: componentDescriptions
[type: [string], string] [default: [] [optional] 
Optional list of component descriptions to help populate IDE autocomplete related to this EffectController.]





INCISOR.defineEffectNode(name, vertexNodeSupport, vertexNode, fragmentNodeSupport, fragmentNode, associatedEffectControllers, requiresDerivativesShaderExtension, requiresFragDepthShaderExtension, requiresDrawBuffersShaderExtension, requiresTextureLODShaderExtension)
[type: function] [returns: EffectNode] 
Defines a new EffectNode. Defined EffectNodes are available at 'nc.effectNodes'. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.

INCISOR.defineEffectNode parameter: name
[type: string] 
The name of the new EffectNode. This name must be unique among EffectNodes.

INCISOR.defineEffectNode parameter: vertexNodeSupport
[type: [string], string] 
The portion of the GLSL shader code for this EffectNode above the 'vertex main'. This segment of code is where uniform and varying variables for the vertex portion of this effect are likely to be declared.

INCISOR.defineEffectNode parameter: vertexNode
[type: string] 
The portion of the GLSL shader code for this EffectNode within the 'vertex main'. This segment of code is is where this effect can make its adjustments to the 'vertex' vec3.

INCISOR.defineEffectNode parameter: fragmentNodeSupport
[type: [string], string] 
The portion of the GLSL shader code for this EffectNode above the 'fragment main'. This segment of code is where uniform and varying variables for the fragment portion of this effect are likely to be declared.

INCISOR.defineEffectNode parameter: fragmentNode
[type: string] 
The portion of the GLSL shader code for this EffectNode within the 'fragment main'. This segment of code is is where this effect can make its adjustments to the 'fragment' vec4.

INCISOR.defineEffectNode parameter: associatedEffectControllers
[type: [EffectControllerDefinition], EffectControllerDefinition] 
The array of the EffectController that this EffectNode is associated with. These EffectControllers will be the means of dynamic manipulation for this EffectNode's visual effects. See 'nc.effectControllers' for a list of available EffectControllers.

INCISOR.defineEffectNode parameter: requiresDerivativesShaderExtension
[type: boolean] [default: false] [optional] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'FragDepth' extension.

INCISOR.defineEffectNode parameter: requiresFragDepthShaderExtension
[type: boolean] [default: false] [optional] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'FragDepth' extension.

INCISOR.defineEffectNode parameter: requiresDrawBuffersShaderExtension
[type: boolean] [default: false] [optional] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'DrawBuffers' extension.

INCISOR.defineEffectNode parameter: requiresTextureLODShaderExtension
[type: boolean] [default: false] [optional] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'TextureLOD' extension.





INCISOR.defineFlowController(name)
[type: function] 
Defines a new FlowController FlowControllers provide a way to organize the general flow of state-based items in a project. For example if your project is a game with an intro, a menu, and several levels, you could create a FlowController named "GameFlowController" and then define and add an 'Intro' FlowState, a 'Menu' FlowState, and 'LevelXX' FlowStates to that FlowController. Within each FlowState in the FlowController, timed callback elements can be added to help define the sequencing within each FlowState. Once created, FlowControllers, FlowStates, and FlowStateElements can be accessed via 'nc.flows'. This class is not meant to be instantiated or provided directly to 'FlowController.addFlowState', rather it is meant to be a class for user-defined FlowStates to extend. Use 'nc.flows' to access the newly defined FlowController.

INCISOR.defineFlowController parameter: name
[type: string] 
The name of the new FlowController





INCISOR.defineGeometry(name, createBox)
[type: function] [returns: GeometryEditor] 
Defines a new square 100x100 Geometry, and returns a GeometryEditor object for further customization.

INCISOR.defineGeometry parameter: name
[type: string] 
The name of the new Geometry being defined. This name must be unique among Geometries.

INCISOR.defineGeometry parameter: createBox
[type: boolean] [default: true] 
Whether to initialize the geometry with a 100x100 box with positon and uv attributes.





INCISOR.editGeometry(geometry, callbackOwner, callbackName, callbackArgs)
[type: function] [returns: GeometryEditor] 
Asyncronously retrieves a GeometryEditor to enable the editing of the Geometry provided. Please note that before you attempt to do any editing, the source Geometry must be loaded; you must either asyncronously await this function call, or provide a callback, which will be called once the souece Geometry is loaded. The first parameter of the callback will be the desired GeometryEditor.

INCISOR.editGeometry parameter: geometry
[type: Geometry] 
The source Geometry to be edited.

INCISOR.editGeometry parameter: callbackOwner
[type: object] [optional] 
The object owning the callback that will be called when the source Geometry loads.

INCISOR.editGeometry parameter: callbackName
[type: string] [optional] 
The name of the callback that will be called when the source Geometry loads.

INCISOR.editGeometry parameter: callbackArgs
[type: Array, any] [optional] 
The arguments for the callback that will be called when the source Geometry loads.





INCISOR.defineGraphicAssetFromPixelsObject(name, pixelsObject, includeNormals)
[type: function] [returns: GraphicAsset] 
Defines a new GraphicAsset from a supplied PixelsObject. See 'nc.graphicAssets' for a list of all available GraphicAssets.

INCISOR.defineGraphicAssetFromPixelsObject parameter: name
[type: string] 
The name of the new GraphicAsset. This name must be unique among registered GraphicAssets, Geometries, and Textures.

INCISOR.defineGraphicAssetFromPixelsObject parameter: pixelsObject
[type: PixelsObject] 
The PixelsObject that will be the source for this new GraphicAsset.

INCISOR.defineGraphicAssetFromPixelsObject parameter: includeNormals
[type: boolean] [default: false] [optional] 
Boolean determining if the vertex data in the geometry of the new GraphicAsset will have the 'normals' attribute.





INCISOR.defineGraphicAssetFromRenderTarget(name, renderTarget, disconnectFromRenderTarget, includeNormals)
[type: function] [returns: GraphicAsset] 
Defines a new GraphicAsset based on the RenderTarget supplied. Unless otherwise specified, this GraphicAsset will have a dynamic connection to the RenderTarget, so that if the RenderTarget is rendered to, GraphicObjects set to this new GraphicAsset will reflect new contents of the RenderTarget. See 'nc.graphicAssets' for a list of all available GraphicAssets.

INCISOR.defineGraphicAssetFromRenderTarget parameter: name
[type: string] 
The name of the new GraphicAsset. This name must be unique among registered GraphicAssets, Geometries, and Textures.

INCISOR.defineGraphicAssetFromRenderTarget parameter: renderTarget
[type: RenderTarget] 
The RenderTarget that will be the source for this new GraphicAsset.

INCISOR.defineGraphicAssetFromRenderTarget parameter: disconnectFromRenderTarget
[type: boolean] [default: false] [optional] 
Boolean determining if the new GraphicAsset will maintain a dynamic connection to the supplied RenderTarget.

INCISOR.defineGraphicAssetFromRenderTarget parameter: includeNormals
[type: boolean] [default: false] [optional] 
Boolean determining if the vertex data in the geometry of the new GraphicAsset will have the 'normals' attribute.





INCISOR.defineGraphicAssetFromTextureAndGeometry(name, texture, geometry)
[type: function] [returns: GraphicAsset] 
Defines a new GraphicAsset based on the Texture and Geometry supplied. See 'nc.graphicAssets' for a list of all available GraphicAssets.

INCISOR.defineGraphicAssetFromTextureAndGeometry parameter: name
[type: string] 
The name of the new GraphicAsset. This name must be unique among registered GraphicAssets.

INCISOR.defineGraphicAssetFromTextureAndGeometry parameter: texture
[type: Texture] 
The Texture that will be the source Texture for this new GraphicAsset.

INCISOR.defineGraphicAssetFromTextureAndGeometry parameter: geometry
[type: Geometry] 
The Geometry that will be the source Geometry for this new GraphicAsset.





INCISOR.defineGraphicAssetFromImageBase64(name, imageBase64)
[type: function] [returns: GraphicAsset] 
Defines a new GraphicAsset based on the image base64 supplied. See 'nc.graphicAssets' for a list of all available GraphicAssets.

INCISOR.defineGraphicAssetFromImageBase64 parameter: name
[type: string] 
The name of the new GraphicAsset. This name must be unique among registered GraphicAssets.

INCISOR.defineGraphicAssetFromImageBase64 parameter: imageBase64
[type: string] 
The base64 string for the image to be made into a GraphicAsset.





INCISOR.inheritGraphicObject(obj, graphicAsset, parent, name)
[type: function] 
Adds GraphicObject functionality to the object supplied.

INCISOR.inheritGraphicObject parameter: obj
[type: object] 
The object that GraphicObject functionality is being added to.

INCISOR.inheritGraphicObject parameter: graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] [optional] 
The GraphicAsset that the new GraphicObject will initially be set to. For a list of available GraphicAssets, see 'nc.graphicAssets'.

INCISOR.inheritGraphicObject parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new GraphicObject's parent in the Scene hierarchy.

INCISOR.inheritGraphicObject parameter: name
[type: string] [default: 'GraphicObject'] [optional] 
The name of the new GraphicObject.





INCISOR.addGraphicObject(graphicAsset, parent, name)
[type: function] [returns: GraphicObject] 
Adds a GraphicObject set to the provided GraphicAsset as a child of the given SceneObject.

INCISOR.addGraphicObject parameter: graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] [optional] 
The GraphicAsset that the new GraphicObject will initially be set to. For a list of available GraphicAssets, see 'nc.graphicAssets'.

INCISOR.addGraphicObject parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new GraphicObject's parent in the Scene hierarchy.

INCISOR.addGraphicObject parameter: name
[type: string] [default: 'GraphicObject'] [optional] 
The name of the new GraphicObject.

example:
// Objective: Use Incisor to add a GraphicObject, rotate it, change its color and move its position.
// Expected Result: You should see a blue, diamond shaped box, moved up and left of center. 

let graphicObject = nc.addGraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject" );

// rotate 45 degrees around the z axis to create a "diamond" shape
graphicObject.rotation.z = 45;
// set the red and green channels to zero to make the box blue
graphicObject.colorMultiply.red = 0;
graphicObject.colorMultiply.green = 0;
// move the box up and to the left
graphicObject.position.x = -500;
graphicObject.position.y = 500;





INCISOR.defineMaskGroup(maskGroupName)
[type: function] [returns: MaskGroup] 
Defines a new MaskGroup. MaskGroups can be used to selectively render partial areas of GraphicObjects. Once a MaskGroup is defined, GraphicObjects can be made into 'masks', which results in their shape contributing to the MaskGroup area. GraphicObjects can also be made into 'masked', which results in them only rendering within the designated MaskGroup area. Please note that the masking area is calculated off of the full-fill Geometry of the 'mask' GraphicObjects; the transperancy of pixels within a 'mask' GraphicObject does not make any difference to masking.

INCISOR.defineMaskGroup parameter: maskGroupName
[type: string] 
The name of the new MaskGroup. This must be a unique name among MaskGroups.

example:
// Objective: Use a mask to reveal only a portion of the phrase "Hello World."
// Expected Result: You will see the word "World." on screen.

// define "MyMask"
let maskGroup = nc.defineMaskGroup( "MyMask" );
 
// create a TextBox
let textBox = nc.addTextBox( nc.mainScene );
textBox.string = "Hello World.";
textBox.masking.makeMasked( nc.maskGroups.MyMask ); // mask it with "MyMask"

// create a GraphicObject rectangle and position it to cover the word "World."
this.masker = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Masker" );
this.masker.scale.x = 2; // rectangle
this.masker.position.x = 75; // position
this.masker.masking.makeMask( nc.maskGroups.MyMask ); // make it a masker for "MyMask"





INCISOR.inheritLayoutStack(obj, parent, name)
[type: function] 
Adds LayoutStack functionality to the object supplied.

INCISOR.inheritLayoutStack parameter: obj
[type: object] 
The object that LayoutStack functionality is being added to.

INCISOR.inheritLayoutStack parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new LayoutStack's parent in the Scene hierarchy.

INCISOR.inheritLayoutStack parameter: name
[type: string] [default: 'LayoutStack'] [optional] 
The name of the new LayoutStack.





INCISOR.addLayoutStack(parent, name)
[type: function] [returns: LayoutStack] 
Adds a LayoutStack as a child of the given SceneObject.

INCISOR.addLayoutStack parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will be the new LayoutStack's parent.

INCISOR.addLayoutStack parameter: name
[type: string] [default: 'LayoutStack'] [optional] 
The name of the new LayoutStack.

example:
// Objective: Use a LayoutStack to vertically align elements.
// Expected Result: You will see 3 elements stacked vertically.

// create a TextAssembly
let text = new TextAssembly( nc.mainScene, "MyText" );
text.string = "With Incisor, you need only build it once.";

// create a white box GraphicObject
let whiteBox = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "MyWhiteBox" );

// create a link
let link = new TextBox( nc.mainScene, "MyButton" );
link.string = "Click Here";
link.colorMultiply = new Color( 0, 0, 1, 1 );
link.scale.x = .5;
link.scale.y = .5;

// add a LayoutStack to the main Scene and add 3 elements to it
let layoutStack = nc.addLayoutStack( nc.mainScene, "MyLayoutStack" );
layoutStack.addElements( [text, whiteBox, link ] );
layoutStack.isVertical = true; // set vertical alignment





INCISOR.inheritLazyUpdater(obj, updateCallbackOwner, updateCallbackName, updateCallbackArgs)
[type: function] 
Adds LazyUpdater functionality to the object supplied.

INCISOR.inheritLazyUpdater parameter: obj
[type: object] 
The object that LazyUpdater functionality is being added to.

INCISOR.inheritLazyUpdater parameter: updateCallbackOwner
[type: object] 
The object owning the callback function being managed by this LazyUpdater.

INCISOR.inheritLazyUpdater parameter: updateCallbackName
[type: string] 
The name of the callback function being managed by this LazyUpdater.

INCISOR.inheritLazyUpdater parameter: updateCallbackArgs
[type: Array, any] [optional] 
Arguments for the callback function.





INCISOR.inheritMatrix4(obj)
[type: function] 
Adds Matrix4 functionality to the object supplied.

INCISOR.inheritMatrix4 parameter: obj
[type: object] 
The object that Martix4 functionality is being added to.





INCISOR.defineMotionType(name, motionFunction, motionControllerNames, motionControllerDefaultValues, description, controllerDescriptions)
[type: function] [returns: MotionType] 
Defines a new MotionType. MotionTypes are used in conjunction with 'Motions' and define a method of continuous change for numeric properties. The MotionType 'Pendulum' is automatically defined, which defines a smooth sinusoidal oscillation between the lower and upper bounds. All defined MotionTypes can be found at 'nc.motionTypes'.

INCISOR.defineMotionType parameter: name
[type: string] 
The name of the new MotionType.

INCISOR.defineMotionType parameter: motionFunction
[type: function] 
The function controlling the continuous change of the numeric properties being affected by the Motion using this MotionType. This function should be implemented to take a single 'Motion' parameter, using it's 'progress', 'lowerBound', 'upperBound', 'motionSpeed', and 'motionArgs' members to calculate and return an array of current values.

INCISOR.defineMotionType parameter: motionControllerNames
[type: [string]] [optional] 
The names of optional controllers that can be used to dynamically affect the nature of the motion type.

INCISOR.defineMotionType parameter: motionControllerDefaultValues
[type: [number]] [optional] 
The default values of optional controllers that can be used to dynamically affect the nature of the motion type.

INCISOR.defineMotionType parameter: description
[type: string] [optional] 
The description of the MotionType - this will appear in the autocomplete documentation.

INCISOR.defineMotionType parameter: controllerDescriptions
[type: [string]] [optional] 
The descriptions of the MotionType controllers - these will appear in the autocomplete documentation.

example:
// Objective: Define a custom MotionType.
// Expected Result: The white box will move continuously in a circular motion.

function moveInCircleFunction(motion) {   
    let progress = motion.progress;
    // Calculate circle center and radius.
    let centerX = (motion.lowerBounds[0]+motion.upperBounds[0])*.5;
    let centerY = (motion.lowerBounds[1]+motion.upperBounds[1])*.5;
    let radiusX = motion.upperBounds[0]-centerX;
    let radiusY = motion.upperBounds[1]-centerY;
    // Apply circle math.
    motion.currentValues[0]=centerX+radiusX*Math.cos(progress*Math.PI);
    motion.currentValues[1]=centerY+radiusY*Math.sin(progress*Math.PI);
    motion.currentValues[2]=0;
}

// Define 'MoveInCircle' Motion
nc.defineMotionType(
    "MoveInCircle",
    moveInCircleFunction,
    undefined,
    undefined,
    "This MotionType moves x and y components in a circle."
 );

 // Create a GraphicObject.
 let graphicObject = new GraphicObject();
 // Add a motion to the GraphicObject's position using the 'MoveInCircle' TweenType. A 'Motion' object is returned and can be manipulted.
 let motion = graphicObject.position.addMotion.each([-300,-100,0],[300,100,10],1,nc.motionTypes.MoveInCircle);





INCISOR.addMotion(propertyOwners, propertyNames, lowerBounds, upperBounds, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion defining a continuous change a given numeric property or set of properties, and returns a Motion object, which can be used to control the motion dynamically.

INCISOR.addMotion parameter: propertyOwners
[type: object, [object]] 
The object or array of objects owning the numeric properties to add motion to.

INCISOR.addMotion parameter: propertyNames
[type: string, [string]] 
The name or array of names of the numeric properties to add motion to.

INCISOR.addMotion parameter: lowerBounds
[type: number, [number]] 
The lower bounds for the motion being added.

INCISOR.addMotion parameter: upperBounds
[type: number, [number]] 
The upper bounds for the motion being added.

INCISOR.addMotion parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

INCISOR.addMotion parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

INCISOR.addMotion parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

INCISOR.addMotion parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

INCISOR.addMotion parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

INCISOR.addMotion parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Add motion to the white box along the x axis.
// Expected Result: The white box should continuously move back and forth.

let whiteSquare = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteSquare" );
// add motion to the "x" property of the position of the white square
nc.addMotion( whiteSquare.position, "x", -500, 500, .5 );





INCISOR.defineParticleSystem(name)
[type: function] [returns: ParticleSystemDefinition] 
Defines a new ParticleSystemDefinition. This can then be used to instantiate a new ParticleSystem. Multiple ParticleSystemDefinitions that use the same ParticleSystemDefinition will share the Geometry and EffectNode created by the ParticleSystemDefinition. Therefore, creation of additional ParticleSystemDefinitions that use the same ParticleSystemDefinition incur much less memory usage and initialization time compared to multiple ParticleSystemDefinitions that each use their own ParticleSystemDefinition.

INCISOR.defineParticleSystem parameter: name
[type: string] 
The name of the ParticleSystemDefinition.





INCISOR.addParticleSystem(particleSystemDefinition, parent, name, pauseImmunity, speedControl)
[type: function] [returns: ParticleSystem] 
Adds a ParticleSystem set to the provided ParticleSystemDefinition as a child of the given SceneObject.

INCISOR.addParticleSystem parameter: particleSystemDefinition
[type: ParticleSystemDefinition] [default: nc.particleSystemDefs.MainParticleSystem] [optional] 
The definition used to build this ParticleSystem. If left undefined, then 'MainParticleSystem' will be chosen - if 'MainParticleSystem' is not yet defined, it will automatically be defined and then used as the default.

INCISOR.addParticleSystem parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new ParticleSystem's parent in the Scene hierarchy.

INCISOR.addParticleSystem parameter: name
[type: string] [default: 'ParticleSystem'] [optional] 
The name of the new ParticleSystem.

INCISOR.addParticleSystem parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this ParticleSystem will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

INCISOR.addParticleSystem parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this ParticleSystem is affected by.

example:
// Objective: Add a ParticleSystem.
// Expected Result: You will see white triangles continuously "bursting" out from the center of the screen.

// add a ParticleSystem using the predefined "BurstWithGravity" ParticleSystemDefinition
let particles = nc.addParticleSystem( nc.particleSystemDefs.BurstWithGravity, nc.mainScene, "MyParticles" );
particles.playbackController.play();





INCISOR.inheritParticleSystemRamp1(obj)
[type: function] 
Adds ParticleSystemRamp1 functionality to the object supplied.

INCISOR.inheritParticleSystemRamp1 parameter: obj
[type: object] 
The object that ParticleSystemRamp1 functionality is being added to.





INCISOR.inheritParticleSystemRamp2(obj)
[type: function] 
Adds ParticleSystemRamp2 functionality to the object supplied.

INCISOR.inheritParticleSystemRamp2 parameter: obj
[type: object] 
The object that ParticleSystemRamp2 functionality is being added to.





INCISOR.inheritParticleSystemRamp3(obj)
[type: function] 
Adds ParticleSystemRamp3 functionality to the object supplied.

INCISOR.inheritParticleSystemRamp3 parameter: obj
[type: object] 
The object that ParticleSystemRamp3 functionality is being added to.





INCISOR.inheritParticleSystemRamp4(obj)
[type: function] 
Adds ParticleSystemRamp4 functionality to the object supplied.

INCISOR.inheritParticleSystemRamp4 parameter: obj
[type: object] 
The object that ParticleSystemRamp4 functionality is being added to.





INCISOR.inheritSceneObject(obj, parent, name)
[type: function] 
Adds SceneObject functionality to the object supplied.

INCISOR.inheritSceneObject parameter: obj
[type: object] 
The object that SceneObject functionality is being added to.

INCISOR.inheritSceneObject parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new SceneObject's parent in the Scene hierarchy.

INCISOR.inheritSceneObject parameter: name
[type: string] [default: 'SceneObject'] [optional] 
The name of the new SceneObject.





INCISOR.definePrecomp(name, coreWidth, coreHeight, autoRender)
[type: function] [returns: Precomp] 
Defines a new Precomp with the given name.

INCISOR.definePrecomp parameter: name
[type: string] 
The name of the new Precomp. This name must be unique among Precomps, GraphicAssets, Geometries, and Textures.

INCISOR.definePrecomp parameter: coreWidth
[type: number] 
The number informing the initial coreViewWidth of the Precomp's Camera, and the initial coreWidth of the Precomp's RenderTarget.

INCISOR.definePrecomp parameter: coreHeight
[type: number] 
The number informing the initial coreViewHeight of the Precomp's Camera, and the initial coreHeight of the Precomp's RenderTarget.

INCISOR.definePrecomp parameter: autoRender
[type: boolean] 
The initial 'autoRender' setting for the Precomp's Camera. It should be noted that if autoRender is set to false, an internal callback will automatically render this Precomp once when its content is loaded.





INCISOR.inheritRenderTarget(obj, name, coreWidth, coreHeight)
[type: function] 
Adds RenderTarget functionality to the supplied object.

INCISOR.inheritRenderTarget parameter: obj
[type: object] 
The object to give RenderTarget funcionality to.

INCISOR.inheritRenderTarget parameter: name
[type: string] 
The name given to the RenderTarget. This name must be unique.

INCISOR.inheritRenderTarget parameter: coreWidth
[type: number] 
The base width value of this RenderTarget, prior to the application of any automatic resolution or aspect ratio adjustments that can occur.

INCISOR.inheritRenderTarget parameter: coreHeight
[type: number] 
The base height value of this RenderTarget, prior to the application of any automatic resolution or aspect ratio adjustments that can occur.





INCISOR.sanitizeNameForCode(name)
[type: function] [returns: string] 
Sanitizes the provided name to make it suitable for code by removing any leading digits, spaces, or special characters.

INCISOR.sanitizeNameForCode parameter: name
[type: string] 
The name to be sanitized.





INCISOR.getAncestors(sceneObject)
[type: function] [returns: [SceneObject]] 
Returns a list of all of the ancesters of the given SceneObject. Ancesters consist of the SceneObject's parent, and that parent's parent, etc...

INCISOR.getAncestors parameter: sceneObject
[type: SceneObject] 
The SceneObject whose ancestors will be listed.





INCISOR.getDescendants(sceneObject, enabledOnly, includeEnclosedScenes)
[type: function] [returns: [SceneObject]] 
Returns a list of all of the descendants of the given SceneObject. Descendants consist of the SceneObject's children, and their children, etc...

INCISOR.getDescendants parameter: sceneObject
[type: SceneObject] 
The SceneObject whose descendants will be listed.

INCISOR.getDescendants parameter: enabledOnly
[type: boolean] [default: true] 
Boolean determining if only enabled SceneObjects are added to the returned list.

INCISOR.getDescendants parameter: includeEnclosedScenes
[type: boolean] 
Boolean determining if sub-descendants of ScrollingPanels' Scenes will be included in the returned list. [DAFAULT: false]





INCISOR.addSceneObject(parent, name)
[type: function] [returns: SceneObject] 
Adds a SceneObject as a child of the given SceneObject.

INCISOR.addSceneObject parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will be the new SceneObject's parent.

INCISOR.addSceneObject parameter: name
[type: string] [default: 'SceneObject'] [optional] 
The name of the new SceneObject.

example:
// Objective: Add a SceneObject with a graphic and rotate it.
// Expected Result: The white box has rotated 45 degrees into a diamond shape.

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = nc.addSceneObject( nc.mainScene, "MySceneObject" );
// Add a GraphicObject to the SceneObject using the GraphicObject constructor.
// Note: To use a custom graphic, add your image file to the assets directory and access it using nc.graphicAssets['MyImage']
new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "MyGraphicObject" );
// Rotate the SceneObject 45 degrees around the z axis.
mySceneObject.rotation.z = 45;





INCISOR.assessCumulativeLoadingTierRequirements(sceneObject, ignoreCachedAssessment)
[type: function] [returns: [number]] 
Returns the list of LoadingTiers that must be loaded for the given SceneObject, its descendants, and all Textures and Geometries to be fully loaded.

INCISOR.assessCumulativeLoadingTierRequirements parameter: sceneObject
[type: SceneObject] 
The SceneObject whose LoadingTier will be assessed.

INCISOR.assessCumulativeLoadingTierRequirements parameter: ignoreCachedAssessment
[type: boolean] [default: false] [optional] 
Boolean determining if any cached assessments will be ignored, forcing an entirely new assessment to be made.





INCISOR.inheritScene(obj, name)
[type: function] 
Adds Scene functionality to the object supplied.

INCISOR.inheritScene parameter: obj
[type: object] 
The object that Scene functionality is being added to.

INCISOR.inheritScene parameter: name
[type: string] 
The name of the new Scene.





INCISOR.defineLayer(name, scene, placeBehindThisLayer)
[type: function] 
Defines a new Layer within a Scene.

INCISOR.defineLayer parameter: name
[type: string] 
The name of the new Layer.

INCISOR.defineLayer parameter: scene
[type: Scene] [default: nc.mainScene] [optional] 
The Scene in which to define a new layer.

INCISOR.defineLayer parameter: placeBehindThisLayer
[type: Layer] [default: nc.layers.DefaultLayer] [optional] 
Supply this optional Layer, and the newly defined Layer will be populated behind the provided Layer.





INCISOR.addScene(name)
[type: function] [returns: Scene] 
Adds a Scene to the project.

INCISOR.addScene parameter: name
[type: string] [default: 'Scene'] [optional] 
The name of the new Scene. The name of the Scene must be unique.





INCISOR.saveScreenShot(path, isPathRelative)
[type: function] [returns: string] 
Saves a screen shot of the project, and returns the path of the new screen shot.

INCISOR.saveScreenShot parameter: path
[type: string] 
The path to the screenshot. If left undefined, a timestamped screen shot will be placed in the directory indicated by 'ProjectSettings.screenShotDestination'.

INCISOR.saveScreenShot parameter: isPathRelative
[type: boolean] 
Boolean determining if the screen shot's path is relative to the project.





INCISOR.inheritScrollingPanel(obj, parent, name)
[type: function] 
Adds ScrollingPanel functionality to the object supplied.

INCISOR.inheritScrollingPanel parameter: obj
[type: object] 
The object that ScrollingPanel functionality is being added to.

INCISOR.inheritScrollingPanel parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new ScrollingPanel's parent in the Scene hierarchy.

INCISOR.inheritScrollingPanel parameter: name
[type: string] [default: 'ScrollingPanel'] [optional] 
The name of the new ScrollingPanel.





INCISOR.defineSyncedLoopingTrackGroup(name, includedSounds)
[type: function] [requires: module - sounds] 
Defines a new group of sounds that will stay synced while looping. Sounds in HTML5 run on a separate thread from the main javascript thread, and as a result there can be small delays between the instructions to play sounds, and when the sounds actually play. These discrepancies can lead to difficulty with keeping multiple looping tracks in sync. This function creates a group of sounds whose instructions are linked in a way that keeps them in sync, regardless of pausing/resuming, changes to volume, or lazy-loaded sounds starting mid-stream.

INCISOR.defineSyncedLoopingTrackGroup parameter: name
[type: string] 
The name of the new SyncedLoopingTrackGroup. This name must be unique among SyncedLoopingTrackGroups.

INCISOR.defineSyncedLoopingTrackGroup parameter: includedSounds
[type: [Sound]] 
Array of Sounds to include in the SyncedLoopingTrackGroup.





INCISOR.defineVolumeControl(name)
[type: function] [returns: VolumeControl] [requires: module - sounds] 
Defines a new VolumeControl. VolumeControls are a way to control the volumes of groups of sounds, much like a 'audio bus'. To make a particular Sound subscribe to a VolumeControl, add the VolumeControl to the Sound's 'volumeControl' array.

INCISOR.defineVolumeControl parameter: name
[type: string] 
The name of the new VolumeControl. This name must be unique among VolumeControls.





INCISOR.inheritSupervisor(obj, owner)
[type: function] 
Adds Supervisor functionality to the object supplied.

INCISOR.inheritSupervisor parameter: obj
[type: object] 
The object that Supervisor functionality is being added to.

INCISOR.inheritSupervisor parameter: owner
[type: SceneObject] 
The SceneObject owning the visual components associated with the Supervisor.





INCISOR.defineTweenType(name, tweenFunction, tweenControllerNames, tweenControllerDefaultValues, description, controllerDescriptions)
[type: function] [returns: TweenType] 
Defines a new TweenType. TweenTypes are used in conjunction with Swoopers and define a method of interpolation between any two values or sets of values. The TweenType 'Linear' is automatically defined, and it defines a perfectly even interpolation between the startValues and endValues. TweenTypes can vary the timing of interpolation between two sets of values, as well as the path of the interpolation. All defined TweenTypes can be found at 'nc.tweenTypes'.

INCISOR.defineTweenType parameter: name
[type: string] 
The name of the new TweenType.

INCISOR.defineTweenType parameter: tweenFunction
[type: function] 
The function controlling the interpolation between values. This function should be implemented to take a single 'Swooper' parameter, using it's 'progress', 'startValues', 'endValues', and 'tweenArgs' members to calculate and set its 'currentValues' property.

INCISOR.defineTweenType parameter: tweenControllerNames
[type: [string]] [optional] 
The names of optional controllers that can be used to dynamically affect the nature of the motion for this TweenType.

INCISOR.defineTweenType parameter: tweenControllerDefaultValues
[type: [number]] [optional] 
The default values of th optional controllers that can be used to dynamically affect the nature of the motion for this TweenType.

INCISOR.defineTweenType parameter: description
[type: string] [optional] 
The description of the TweenType - this will appear in the autocomplete documentation.

INCISOR.defineTweenType parameter: controllerDescriptions
[type: [string]] [optional] 
The descriptions of the TweenType controllers - these will appear in the autocomplete documentation.

example:
// Objective: Define a custom TweenType.
// Expected Result: The white box will zigzag while moving up along the y axis.

// create a white box
let graphic = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );

// define a TweenType function. Use the given swooper progress 
// to update the box's position as it completes its swoop
let myTweenFunction = function( swooper ) {
    let progress = swooper.progress;
  
    let updatedX = swooper.currentValues[0] ? swooper.currentValues[0] : 0;
    let updatedY = swooper.endValues[1] * progress;

     if ( progress < .20 ) {
         updatedX += 10 * progress;
     } else if ( progress >= .20 && progress < .40 ) {
         updatedX -= 8 * progress;
     } else if ( progress >= .40 && progress < .60 ) {
         updatedX += 6 * progress;
     } else if ( progress >= .60 && progress < .80 ) {
         updatedX -= 4 * progress;
     } else {
         updatedX += 2 * progress;
     }
 
     swooper.currentValues = [ updatedX, updatedY, 0 ];

 }

// define the TweenType with our custom function and swoop the box's position
let myTweenType = nc.defineTweenType( "MyTweenType", myTweenFunction );
graphic.position.swoop.each( [0,500,0], 10, myTweenType );





INCISOR.swoopValue(propertyOwner, propertyName, endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, updaterCallbackOwner, updaterCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) a given numeric property from its current value to a designated end value over a duration.

INCISOR.swoopValue parameter: propertyOwner
[type: object] 
The object owning the numeric property to be swooped.

INCISOR.swoopValue parameter: propertyName
[type: string] 
The name of the numeric property to be swooped.

INCISOR.swoopValue parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

INCISOR.swoopValue parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

INCISOR.swoopValue parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

INCISOR.swoopValue parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

INCISOR.swoopValue parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

INCISOR.swoopValue parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

INCISOR.swoopValue parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

INCISOR.swoopValue parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

INCISOR.swoopValue parameter: updaterCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

INCISOR.swoopValue parameter: updaterCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

example:
// Objective: Adjust the motion speed of a "bouncing" white box.
// Expected Result: The white box will bounce, gradually slowing down over a period of 5 seconds, then it will gradually speed back up over a period of 5 seconds.

// Create a GraphicObject using the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "MyGraphicObject" );
// Give the box motion along the y axis. Set the speed to 2.
myGraphicObject.position.addMotion.y(-300,300,2);
 
// Swoop the 'speed' property of the MainSpeedControl down to .05 over a period of 5 seconds and provide callback arguments to swoop the 'speed' property again back up to speed 1 over a period of 10 seconds.
nc.swoopValue( 
            nc.speedControls.MainSpeedControl, 
            "speed", 
            .05, 
            5, 
            undefined, 
            nc, 
            "swoopValue", 
            [nc.speedControls.MainSpeedControl, "speed", 1, 10] 
            );





INCISOR.swoopValues(propertyOwners, propertyNames, endValues, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, updaterCallbackOwner, updaterCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) a given set of numeric properties from their current values to a designated set of end values over a duration.

INCISOR.swoopValues parameter: propertyOwners
[type: [object]] 
The object or objects owning the numeric properties to be swooped.

INCISOR.swoopValues parameter: propertyNames
[type: [string]] 
The names of the numeric property to be swooped.

INCISOR.swoopValues parameter: endValues
[type: [number]] 
The ending values for the numeric properties being swooped.

INCISOR.swoopValues parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

INCISOR.swoopValues parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

INCISOR.swoopValues parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

INCISOR.swoopValues parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

INCISOR.swoopValues parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

INCISOR.swoopValues parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

INCISOR.swoopValues parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

INCISOR.swoopValues parameter: updaterCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

INCISOR.swoopValues parameter: updaterCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





INCISOR.inheritTextAssembly(obj, parent, name)
[type: function] 
Adds TextAssembly functionality to the object supplied.

INCISOR.inheritTextAssembly parameter: obj
[type: object] 
The object that TextAssembly functionality is being added to.

INCISOR.inheritTextAssembly parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new TextAssembly's parent in the Scene hierarchy.

INCISOR.inheritTextAssembly parameter: name
[type: string] [optional] 
The name of the new TextAssembly.





INCISOR.addTextAssembly(parent, name)
[type: function] [returns: TextAssembly] 
Adds a TextAssembly as a child of the given SceneObject.

INCISOR.addTextAssembly parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new TextAssembly's parent in the Scene hierarchy.

INCISOR.addTextAssembly parameter: name
[type: string] [default: 'TextBox'] [optional] 
The name of the new TextAssembly.

example:
// Objective: Add a TextAssembly.
// Expected Result: You will see the text "Incisor - Build It Once." on screen.

let textAssembly = nc.addTextAssembly( nc.mainScene );
textAssembly.string = "Incisor - Build It Once."





INCISOR.inheritTextBox(obj, parent, name)
[type: function] 
Adds TextBox functionality to the object supplied.

INCISOR.inheritTextBox parameter: obj
[type: object] 
The object that TextBox functionality is being added to.

INCISOR.inheritTextBox parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new TextBox's parent in the Scene hierarchy.

INCISOR.inheritTextBox parameter: name
[type: string] [optional] 
The name of the new TextBox.





INCISOR.addTextBox(parent, name)
[type: function] [returns: TextBox] 
Adds a TextBox as a child of the given SceneObject.

INCISOR.addTextBox parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will become the new TextBox's parent in the Scene hierarchy.

INCISOR.addTextBox parameter: name
[type: string] [default: 'TextBox'] [optional] 
The name of the new TextBox.

example:
// Objective: Add a TextBox.
// Expected Result: You will see the text "Incisor - Build It Once." on screen.

let textBox = nc.addTextBox( nc.mainScene );
textBox.string = "Incisor - Build It Once."





INCISOR.inheritTextFormat(obj, fontName, characterScaleX, characterScaleY, kerning, verticalShift, lineHeightMultiplier)
[type: function] 
Adds TextFormat functionality to the object supplied.

INCISOR.inheritTextFormat parameter: obj
[type: object] 
The object that TextFormat functionality is being added to.

INCISOR.inheritTextFormat parameter: fontName
[type: string] [default: "MainFont"] [optional] 
The name of the font that characters with this TextFormat will use.

INCISOR.inheritTextFormat parameter: characterScaleX
[type: number] [default: 1] [optional] 
The x-axis scale multiplier for the characters that use this TextFormat.

INCISOR.inheritTextFormat parameter: characterScaleY
[type: number] [default: 1] [optional] 
The y-axis scale multiplier for the characters that use this TextFormat.

INCISOR.inheritTextFormat parameter: kerning
[type: number] [default: 0] [optional] 
Number representing an added or reduced spacing between the characters that use this TextFormat

INCISOR.inheritTextFormat parameter: verticalShift
[type: number] [default: 0] [optional] 
Number representing a veritcal offset that will be applied to the characters that use this TextForamt.

INCISOR.inheritTextFormat parameter: lineHeightMultiplier
[type: number] [default: 1] [optional] 
Number that multiplies the effective layout height of the characters that use this TextFormat.





INCISOR.defineTexture(name, source)
[type: function] [returns: Texture] 
Defines a new Texture from a supplied PixelsObject or Base64 string. For a list of all available Textures, see 'nc.textures'.

INCISOR.defineTexture parameter: name
[type: string] 
The name of the new Texture. This name must be unique among registered Textures.

INCISOR.defineTexture parameter: source
[type: PixelsObject, string] 
The source for this new Texture - either a PixelsObject or the base64 string .





INCISOR.defineTextures(names, sources)
[type: function] [returns: [Texture]] 
Defines new Textures from a supplied array of PixelsObjects or Base64 strings. Use this function instead of 'nc.defineTexture' when creating many textures, as it is able to asynchronously multi-task the creation of the Textures, making it faster in that scenario.

INCISOR.defineTextures parameter: names
[type: [string]] 
The names of the new Textures. Each name must be unique among registered Textures.

INCISOR.defineTextures parameter: sources
[type: [PixelsObject], [string]] 
The sources for these new Textures - either an array of PixelsObjects or the array of base64 strings.





INCISOR.getPhrase(phraseID, dynamicValues)
[type: function] [returns: string] 
Retrieves the given phrase from the ProjectTranscript. This function is similar to using 'nc.phrases' to fetch phrases, but additionaly it includes a parameter that can be used to populate dynamic values in phrases with dynamic value tags (i.e. '{value:myDynamicValue}'). To populate a dynamic value in a phrase containing a dynamic value tag, include a dictionary with the dynamic values in the 'dynamicValues' parameter (i.e. {myDynamicValue:1000}).

INCISOR.getPhrase parameter: phraseID
[type: string] 
The ID of the phrase to be fetched. A dictionary of phraseIDs can be found at 'nc.phraseIDs'.

INCISOR.getPhrase parameter: dynamicValues
[type: object] [optional] 
Optional dictionary of dynamic values to be populated within the phrase.





INCISOR.inheritUiBooleanSupervisor_checkbox(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiBooleanSupervisor_checkbox functionality to the object supplied.

INCISOR.inheritUiBooleanSupervisor_checkbox parameter: obj
[type: object] 
The object that UiBooleanSupervisor_checkbox functionality is being added to.

INCISOR.inheritUiBooleanSupervisor_checkbox parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiBooleanSupervisor_checkbox's parent in the Scene hierarchy.

INCISOR.inheritUiBooleanSupervisor_checkbox parameter: name
[type: string] [default: 'UiBooleanSupervisor_checkbox'] [optional] 
The name of the new UiBooleanSupervisor_checkbox.





INCISOR.inheritUiButton(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiButton functionality to the object supplied.

INCISOR.inheritUiButton parameter: obj
[type: object] 
The object that UiButton functionality is being added to.

INCISOR.inheritUiButton parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiButton's parent in the Scene hierarchy.

INCISOR.inheritUiButton parameter: name
[type: string] [default: 'UiButton'] [optional] 
The name of the new UiButton.





INCISOR.inheritUiCollapsibleStack(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiCollapsibleStack functionality to the object supplied.

INCISOR.inheritUiCollapsibleStack parameter: obj
[type: object] 
The object that UiCollapsibleStack functionality is being added to.

INCISOR.inheritUiCollapsibleStack parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiCollapsibleStack's parent in the Scene hierarchy.

INCISOR.inheritUiCollapsibleStack parameter: name
[type: string] [default: 'UiCollapsibleStack'] [optional] 
The name of the new UiCollapsibleStack.





INCISOR.inheritUiDropDownButton(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiDropDownMenu functionality to the object supplied.

INCISOR.inheritUiDropDownButton parameter: obj
[type: object] 
The object that UiDropDownMenu functionality is being added to.

INCISOR.inheritUiDropDownButton parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiDropDownMenu's parent in the Scene hierarchy.

INCISOR.inheritUiDropDownButton parameter: name
[type: string] [default: 'UiDropDownMenu'] [optional] 
The name of the new UiDropDownMenu.





INCISOR.inheritUiGraphicButton(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiGraphicButton functionality to the object supplied.

INCISOR.inheritUiGraphicButton parameter: obj
[type: object] 
The object that UiGraphicButton functionality is being added to.

INCISOR.inheritUiGraphicButton parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiGraphicButton's parent in the Scene hierarchy.

INCISOR.inheritUiGraphicButton parameter: name
[type: string] [default: 'UiGraphicButton'] [optional] 
The name of the new UiGraphicButton.





INCISOR.inheritUiLinkButton(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiLinkButton functionality to the object supplied.

INCISOR.inheritUiLinkButton parameter: obj
[type: object] 
The object that UiLinkButton functionality is being added to.

INCISOR.inheritUiLinkButton parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiLinkButton's parent in the Scene hierarchy.

INCISOR.inheritUiLinkButton parameter: name
[type: string] [default: 'UiLinkButton'] [optional] 
The name of the new UiLinkButton.





INCISOR.inheritUiMenu(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiMenu functionality to the object supplied.

INCISOR.inheritUiMenu parameter: obj
[type: object] 
The object that UiMenu functionality is being added to.

INCISOR.inheritUiMenu parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiMenu's parent in the Scene hierarchy.

INCISOR.inheritUiMenu parameter: name
[type: string] [default: 'UiMenu'] [optional] 
The name of the new UiMenu.





INCISOR.inheritUiNumberSupervisor_textField(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiNumberSupervisor_textField functionality to the object supplied.

INCISOR.inheritUiNumberSupervisor_textField parameter: obj
[type: object] 
The object that UiNumberSupervisor_textField functionality is being added to.

INCISOR.inheritUiNumberSupervisor_textField parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiNumberSupervisor_textField's parent in the Scene hierarchy.

INCISOR.inheritUiNumberSupervisor_textField parameter: name
[type: string] [default: 'UiNumberSupervisor_textField'] [optional] 
The name of the new UiNumberSupervisor_textField.





INCISOR.inheritUiPopupWindow(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiPopupWindow functionality to the object supplied.

INCISOR.inheritUiPopupWindow parameter: obj
[type: object] 
The object that UiPopupWindow functionality is being added to.

INCISOR.inheritUiPopupWindow parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiPopupWindow's parent in the Scene hierarchy.

INCISOR.inheritUiPopupWindow parameter: name
[type: string] [default: 'UiPopupWindow'] [optional] 
The name of the new UiPopupWindow.





INCISOR.inheritUiStringSupervisor_menu(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiStringSupervisor_menu functionality to the object supplied.

INCISOR.inheritUiStringSupervisor_menu parameter: obj
[type: object] 
The object that UiStringSupervisor_menu functionality is being added to.

INCISOR.inheritUiStringSupervisor_menu parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiStringSupervisor_menu's parent in the Scene hierarchy.

INCISOR.inheritUiStringSupervisor_menu parameter: name
[type: string] [default: 'UiStringSupervisor_menu'] [optional] 
The name of the new UiStringSupervisor_menu.





INCISOR.inheritUiStringSupervisor_textField(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiStringSupervisor_textField functionality to the object supplied.

INCISOR.inheritUiStringSupervisor_textField parameter: obj
[type: object] 
The object that UiStringSupervisor_textField functionality is being added to.

INCISOR.inheritUiStringSupervisor_textField parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiStringSupervisor_textField's parent in the Scene hierarchy.

INCISOR.inheritUiStringSupervisor_textField parameter: name
[type: string] [default: 'UiStringSupervisor_textField'] [optional] 
The name of the new UiStringSupervisor_textField.





INCISOR.inheritUiTextField(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiTextField functionality to the object supplied.

INCISOR.inheritUiTextField parameter: obj
[type: object] 
The object that UiTextField functionality is being added to.

INCISOR.inheritUiTextField parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiTextField's parent in the Scene hierarchy.

INCISOR.inheritUiTextField parameter: name
[type: string] [default: 'UiTextField'] [optional] 
The name of the new UiTextField.





INCISOR.inheritUiText(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds UiText functionality to the object supplied.

INCISOR.inheritUiText parameter: obj
[type: object] 
The object that UiText functionality is being added to.

INCISOR.inheritUiText parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new UiText's parent in the Scene hierarchy.

INCISOR.inheritUiText parameter: name
[type: string] [default: 'UiText'] [optional] 
The name of the new UiText.





INCISOR.inheritUiVectorSupervisor_textField(obj, parent, name)
[type: function] [requires: module - extendedUi] 
Adds inheritUiVectorSupervisor_textField functionality to the object supplied.

INCISOR.inheritUiVectorSupervisor_textField parameter: obj
[type: object] 
The object that inheritUiVectorSupervisor_textField functionality is being added to.

INCISOR.inheritUiVectorSupervisor_textField parameter: parent
[type: SceneObject] [optional] 
The SceneObject that will become the new inheritUiVectorSupervisor_textField's parent in the Scene hierarchy.

INCISOR.inheritUiVectorSupervisor_textField parameter: name
[type: string] [default: 'inheritUiVectorSupervisor_textField'] [optional] 
The name of the new inheritUiVectorSupervisor_textField.





INCISOR.inheritVector4(obj, x, y, z, w)
[type: function] 
Adds Vector4 functionality to the supplied object.

INCISOR.inheritVector4 parameter: obj
[type: object] 
The object to give Vector4 functionality to.

INCISOR.inheritVector4 parameter: x
[type: number] [default: 0] [optional] 
The value for the first component.

INCISOR.inheritVector4 parameter: y
[type: number] [default: 0] [optional] 
The value for the second component.

INCISOR.inheritVector4 parameter: z
[type: number] [default: 0] [optional] 
The value for the third component.

INCISOR.inheritVector4 parameter: w
[type: number] [default: 0] [optional] 
The value for the forth component.





INCISOR.inheritVector3(obj, x, y, z)
[type: function] 
Adds Vector3 functionality to the supplied object.

INCISOR.inheritVector3 parameter: obj
[type: object] 
The object to give Vector3 functionality to.

INCISOR.inheritVector3 parameter: x
[type: number] [default: 0] [optional] 
The value for the first component.

INCISOR.inheritVector3 parameter: y
[type: number] [default: 0] [optional] 
The value for the second component.

INCISOR.inheritVector3 parameter: z
[type: number] [default: 0] [optional] 
The value for the third component.





INCISOR.inheritVector2(obj, x, y)
[type: function] 
Adds Vector2 functionality to the supplied object.

INCISOR.inheritVector2 parameter: obj
[type: object] 
The object to give Vector2 functionality to.

INCISOR.inheritVector2 parameter: x
[type: number] [default: 0] [optional] 
The value for the first component.

INCISOR.inheritVector2 parameter: y
[type: number] [default: 0] [optional] 
The value for the second component.





INCISOR.inheritVector1(obj, x)
[type: function] 
Adds Vector1 functionality to the supplied object.

INCISOR.inheritVector1 parameter: obj
[type: object] 
The object to give Vector1 functionality to.

INCISOR.inheritVector1 parameter: x
[type: number] [default: 0] [optional] 
The value for the first component.





INCISOR.waitThen(duration, callbackOwner, callbackName, callbackArgs, name, pauseImmunity, speedControl)
[type: function] [requires: module - waitThens] 
Sets up a WaitThen (from an internal pool), invoking the given callback after the specified delay. Since the WaitThen being used here is internal, the object itself cannot be referenced; to stop a pooled WaitThen, call 'nc.stopAllWaitThensByName' or 'nc.stopAllWaitThensByCallback'.

INCISOR.waitThen parameter: duration
[type: number] 
Seconds before the callback will occur.

INCISOR.waitThen parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when the WaitThen completes.

INCISOR.waitThen parameter: callbackName
[type: string] 
The name of the function that is called when the WaitThen completes.

INCISOR.waitThen parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the WaitThen completes.

INCISOR.waitThen parameter: name
[type: string] [default: "WaitThen"] [optional] 
The name of this WaitThen.

INCISOR.waitThen parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this WaitThen will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

INCISOR.waitThen parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this WaitThen is affected by.

example:
// Objective: Use a waitThen function
// Expected Result: The screen will show "Wait for it..." for 3 seconds then "Incisor!" will appear.

this.textBox = new TextBox( nc.mainScene );
this.textBox.string = "Wait for it...";

// call waitThen with a duration of 3 seconds
nc.waitThen( 3, this, "waitThenCallback" );

this.waitThenCallback = function() {
    this.textBox.string = "Incisor!";
}





INCISOR.stopAllWaitThensByName(name, performCallback)
[type: function] [requires: module - waitThens] 
Stops all currently active WaitThens whose name matches the name given.

INCISOR.stopAllWaitThensByName parameter: name
[type: string] 
The name of the WaitThens to stop.

INCISOR.stopAllWaitThensByName parameter: performCallback
[type: boolean] [default: false] [optional] 
Boolean determining if the callback function will be called immediately, or if it will be skipped entirely.





INCISOR.stopAllWaitThensByCallback(callbackOwner, callbackName, performCallback)
[type: function] [requires: module - waitThens] 
Stops all currently active WaitThens whose callback info matches the given callback info.

INCISOR.stopAllWaitThensByCallback parameter: callbackOwner
[type: object] 
The owner of the callback associated with the WaitThens to stop.

INCISOR.stopAllWaitThensByCallback parameter: callbackName
[type: string] 
The name of the callback associated with the WaitThens to stop.

INCISOR.stopAllWaitThensByCallback parameter: performCallback
[type: boolean] [default: false] [optional] 
Boolean determining if the callback function will be called immediately, or if it will be skipped entirely.





INCISOR.inheritWaitThen(obj, name)
[type: function] [requires: module - waitThens] 
Adds WaitThen functionality to the supplied object.

INCISOR.inheritWaitThen parameter: obj
[type: object] 
The object to give WaitThen functionality to.

INCISOR.inheritWaitThen parameter: name
[type: string] 
The name of the new WaitThen object.





INCISOR. Welcome to Incisor!
[type: information] 
Incisor® is a comprehensive platform that enables developers and designers to build high-quality interactive software and gaming products. The platform consists of JavaScript or TypeScript APIs, a customizable GUI, and other tools bundled together into a single application. Incisor® can be used to create extremely lightweight apps that operate on any target device or EGM - all from a single codebase. With Incisor®, your team can Build It Once.

The primary driving force behind Incisor® is making the development of commercial-grade software more collaborative, efficient, flexible, and generally straightforward. Whether your focus is on highly optimized products downloadable at a fraction of the size without sacrificing quality, or creating 4k resolution products for the casino floor, Incisor® is the only solution. The platform incorporates countless efficiencies into both the production process and the published result, enabling not only better products, but better development










----------------------------------------------------------
Section 3: AppEvent
----------------------------------------------------------


AppEvent
[type: class] [NON-INSTANTIABLE] 
Object housing functionality for a system of method callbacks that are triggered by a given type of event. There are AppEvents for automatically recurring events such as the 'fixedUpdate' and 'screenUpdate', as well as user-input driven events such as keyboard and mouse events. Access Incisor®'s AppEvents via 'nc.appEvents', and use them to add custom functionality that responds to these events. 





AppEvent.type
[type: string] 
Type identifier





AppEvent.name
[type: string] 
Name of AppEvent

example:
// Objective: Get the name of an AppEvent.
// Expected Result: The console should read "myAppEvent name keyboardEvent".

// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
console.log("myAppEvent name", myAppEvent.name);





AppEvent.hasSingularFocusScheme
[type: boolean] [default: false] 
Readonly flag indicating if this AppEvent has a 'singular focus scheme' which is a system that restricts callback invocation to items associated with the currently 'focused' object as determined by nc.singularFocusObject.





AppEvent.isOrdered
[type: boolean] [default: false] 
Readonly flag indicating if this AppEvent is 'ordered', which allows callbacks added to this AppEvent to be provided a callback order number, which is then used to sort the callbacks when the AppEvent is triggered. Built-in AppEvents with this flag true include start, lateFixedUpdate, and lateScreenUpdate.





AppEvent.hasConsumableCallbacks
[type: boolean] [default: false] 
Readonly flag indicating if this AppEvent removes callbacks after one invocation.





AppEvent.addCallback(callbackOwner, callbackName, callbackArgs, pauseImmunity, singularFocusRequirements, callbackOrder)
[type: function] 
Adds the provided function to the list of functions called with the associated AppEvent occurs.

AppEvent.addCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

AppEvent.addCallback parameter: callbackName
[type: string] 
The name of the callback function.

AppEvent.addCallback parameter: callbackArgs
[type: [any], any] [optional] 
Extra parameters for the callback function. It should be noted that some AppEvents are triggered with 'event-wide' args. In this case, these extra args are appended to the event-wide args.

AppEvent.addCallback parameter: pauseImmunity
[type: [PauseEvent], PauseEvent] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this AppEvent callback will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

AppEvent.addCallback parameter: singularFocusRequirements
[type: [object], object] [default: undefined] [optional] 
If this AppEvent's 'hasSingularFocusScheme' property is true, supplying this object or Array of objects is a way of requiring the correct focus context for this callback to occur. If left undefined, the callback will be invoked with any triggering event. If supplied, one of the objects in the singularFocusRequirements must be 'in focus' for the callback to be invoked.

AppEvent.addCallback parameter: callbackOrder
[type: number] [default: 0] [optional] 
If this AppEvent's 'isOrdered' property is true, this number will be used to sort the callbacks before they are invoked. An early number corresponds to the callback being called earlier.

example:
// Objective: Add a callback to an AppEvent.
// Action: Press a key on the keyboard. For this example, press the letter 'a'.
// Expected Result: The console should have 2 log messages as follows:
//   callback type: keydown a
//   callback type: keyup a

// Add a callback function.
this.myCallback = function(args) {
    console.log('callback type:', args.type, args.key);
}

// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
// Add the callback.
myAppEvent.addCallback( this, "myCallback" );





AppEvent.removeCallback(callbackOwner, callbackName)
[type: function] 
Removes the provided function from the list of functions called with the associated AppEvent occurs.

AppEvent.removeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function to be removed.

AppEvent.removeCallback parameter: callbackName
[type: string] 
The name of the callback function to be removed.

example:
// Objective: Remove a callback from an AppEvent.
// Actions: 
// 1. Press a key on the keyboard. For this example, press the letter 'a'.
// 1. Expected Result: The console should have 2 log messages as follows:
//   callback type: keydown a
//   callback type: keyup a
//
// 2. Click the white box to remove the AppEvent.
// 2. Expected Result: Upon clicking the white box, the console should read "removing the callback". You will no longer see console log messages upon  pressing the keyboard.

// Add a callback function and name it 'myEventCallback'.
this.myEventCallback = function(args) {
    console.log('callback type:', args.type, args.key);
}
// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
// Add the callback.
myAppEvent.addCallback( this, "myEventCallback" );

// Create a button to use to remove the callback. Use the WhiteBox GraphicAsset.
this.removeButton = nc.addButton( nc.graphicAssets.WhiteBox, nc.mainScene, "RemoveButton" );
// Create a callback function that handles the click of the white box and executes removeCallback(). Name the callback function "myButtonCallback".
this.myButtonCallback = function(args) {
    console.log('removing the callback');
    // Inside this press callback, remove the callback
    myAppEvent.removeCallback( this, "myEventCallback" );
}
// Add the PressCallback to handle the clicking of the white box
this.removeButton.addPressCallback( this, "myButtonCallback" );





AppEvent.getRecipients()
[type: function] [returns: [object]] 
Returns an Array listing all of the callbacks currently connected to this AppEvent. The returned Array lists objects containing the callbackOwner, callbackName, and paused state for each callback.

example:
// Objective: List all of the callbacks currently connected to this AppEvent.
// Expected Result: The console should have 2 log messages as follows:
//   recipient myCallback1
//   recipient myCallback2
//   recipient myCallback3

// Make 3 callbacks.
this.myCallback1 = function(args) {
    console.log('myCallback1 callback type:', args.type, args.key);
}
this.myCallback2 = function(args) {
    console.log('myCallback2 callback type:', args.type, args.key);
}
this.myCallback3 = function(args) {
    console.log('myCallback3 callback type:', args.type, args.key);
}

// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
// Add all 3 callbacks to this AppEvent.
myAppEvent.addCallback( this, "myCallback1" );
myAppEvent.addCallback( this, "myCallback2" );
myAppEvent.addCallback( this, "myCallback3" );

// Iterate and console log the array of recipients.
let recipients = myAppEvent.getRecipients();
for ( let r of recipients ) {
    console.log('recipient', r.callbackName);
}





AppEvent.trigger(callbackArgs)
[type: function] 
Method that 'Triggers' the AppEvent, invoking all of the callback functions that have been added to it.

AppEvent.trigger parameter: callbackArgs
[type: Array, any] [optional] 
Parameter or Array of parameters that will be sent to this AppEvent's callback functions. It should be noted that if an Array is supplied, the individual members of the Array will be sent to callback functions as individual parameters.





AppEvent.asyncTrigger(callbackArgs)
[type: function] 
Method that 'Triggers' the AppEvent, invoking all of the callback functions that have been added to it, and asyncronously awaiting each of them.

AppEvent.asyncTrigger parameter: callbackArgs
[type: Array, any] [optional] 
Parameter or Array of parameters that will be sent to this AppEvent's callback functions. It should be noted that if an Array is supplied, the individual members of the Array will be sent to callback functions as individual parameters.










----------------------------------------------------------
Section 4: PauseEvent
----------------------------------------------------------


PauseEvent
[type: class] [NON-INSTANTIABLE] 
A PauseEvent can be used as a parameter in 'nc.pause' and 'nc.resume' to pause and resume various time-based and user-interaction processes. Pausable processes react to pausing or resuming with PauseEvents unless those processes have a given PauseEvent as part of their designated 'pauseImmunity', which can determined in the parameters of a pausable-process-initiating method. Use 'nc.definePauseEvent' to create a new PauseEvent. 





PauseEvent.type
[type: string] 
Type identifier





PauseEvent.name
[type: string] 
Name of PauseEvent

example:
// Objective: Get the name of an AppEvent.
// Expected Result: The console should read "myAppEvent name keyboardEvent".

// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
console.log("myAppEvent name", myAppEvent.name);










----------------------------------------------------------
Section 5: SpeedControl
----------------------------------------------------------


SpeedControl
[type: class] [NON-INSTANTIABLE] 
SpeedControls can be used to control the speed of time-based sequencing processes such as Motions, Swoops, or Timelines. Applicable processes can subscribe to multiple SpeedControls; the 'speed' values of all of the SpeedControls a process subscribes to are multiplied together to determine the overall pacing of the given time-based process. Use 'nc.defineSpeedControl' to create a new SpeedControl. 





SpeedControl.type
[type: string] 
Type identifier





SpeedControl.name
[type: string] 
Name of SpeedControl

example:
// Objective: Get the name of an AppEvent.
// Expected Result: The console should read "myAppEvent name keyboardEvent".

// Get an instance of the keyboardEvent AppEvent.
let myAppEvent = nc.appEvents.keyboardEvent;
console.log("myAppEvent name", myAppEvent.name);





SpeedControl.speed
[type: number] [default: 1] 
The speed value. This value multiplies the speed of processes that subscribe to this SpeedControl

example:
// Objective: Adjust the motion speed of a "bouncing" white box.
// Expected Result: The white box will bounce, gradually slowing down over a period of 5 seconds, then it will gradually speed back up over a period of 5 seconds.

// Create a GraphicObject using the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "MyGraphicObject" );
// Give the box motion along the y axis. Set the speed to 2.
myGraphicObject.position.addMotion.y(-300,300,2);
 
// Swoop the 'speed' property of the MainSpeedControl down to .05 over a period of 5 seconds and provide callback arguments to swoop the 'speed' property again back up to speed 1 over a period of 10 seconds.
nc.swoopValue( 
            nc.speedControls.MainSpeedControl, 
            "speed", 
            .05, 
            5, 
            undefined, 
            nc, 
            "swoopValue", 
            [nc.speedControls.MainSpeedControl, "speed", 1, 10] 
            );










----------------------------------------------------------
Section 6: FocusChangeInfo
----------------------------------------------------------


FocusChangeInfo
[type: class] [NON-INSTANTIABLE] 
Object containing information about a change to the 'nc.singularFocusObject' value. An instance of this object is sent as a first parameter to all callbacks registered with the nc.appEvents.focusChange AppEvent. 





FocusChangeInfo.objectLosingFocus
[type: object] 
A reference to the previous nc.singularFocusObject.

example:
// Objective: Add a callback to the focusChange AppEvent.
// Expected Result: After waiting 5 seconds, the console should have 3 log messages as follows:
//    changing focus to Scene2
//    object gaining focus Scene2
//    object losing focus Scene1

// Create 2 scenes, "Scene1" and "Scene2"
this.scene1 = new Scene("Scene1");
this.scene2 = new Scene("Scene2");
// Set the singular focus to "Scene1"
nc.singularFocusObject = this.scene1;

// Create a callback to handle the focus change. Name is "focusChangeCallback".
this.focusChangeCallback = function(args) {
   console.log("object gaining focus", args.objectGainingFocus.name);
   console.log("object losing focus", args.objectLosingFocus.name);
}
// Get an instance of the focusChange AppEvent and add the focus change callback.
this.focusChangeEvent = nc.appEvents.focusChange;
this.focusChangeEvent.addCallback( this, "focusChangeCallback" );

// Create a focus changer that will change the singular focus.
this.focusChanger = function(args) {
   console.log("changing focus to Scene2");
   nc.singularFocusObject = this.scene2;
}
// Use nc.waitThen() to wait 5 seconds before executing the focus changer.
nc.waitThen( 5, this, "focusChanger" );





FocusChangeInfo.objectGainingFocus
[type: object] 
A reference to the new nc.singularFocusObject.

example:
// Objective: Add a callback to the focusChange AppEvent.
// Expected Result: After waiting 5 seconds, the console should have 3 log messages as follows:
//    changing focus to Scene2
//    object gaining focus Scene2
//    object losing focus Scene1

// Create 2 scenes, "Scene1" and "Scene2"
this.scene1 = new Scene("Scene1");
this.scene2 = new Scene("Scene2");
// Set the singular focus to "Scene1"
nc.singularFocusObject = this.scene1;

// Create a callback to handle the focus change. Name is "focusChangeCallback".
this.focusChangeCallback = function(args) {
   console.log("object gaining focus", args.objectGainingFocus.name);
   console.log("object losing focus", args.objectLosingFocus.name);
}
// Get an instance of the focusChange AppEvent and add the focus change callback.
this.focusChangeEvent = nc.appEvents.focusChange;
this.focusChangeEvent.addCallback( this, "focusChangeCallback" );

// Create a focus changer that will change the singular focus.
this.focusChanger = function(args) {
   console.log("changing focus to Scene2");
   nc.singularFocusObject = this.scene2;
}
// Use nc.waitThen() to wait 5 seconds before executing the focus changer.
nc.waitThen( 5, this, "focusChanger" );










----------------------------------------------------------
Section 7: AssetComponent
----------------------------------------------------------


AssetComponent
[type: class] [NON-INSTANTIABLE] 
The base object defining the fundamental content builing-blocks for Incisor® such as Textures, Geometry, and Sounds. 





AssetComponent.type
[type: string] 
Type identifier





AssetComponent.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





AssetComponent.name
[type: string] 
The AssetComponent's name. This must be unique among AssetComponents of its type.





AssetComponent.isLoaded
[type: boolean] 
Boolean indicating if this AssetComponent is currently loaded.





AssetComponent.loadingTierRequirements
[type: [number]] 
The LoadingTier that this AssetComponent belongs too. LoadingTiers are a means to organize AssetComponents into separately downloadable groups.





AssetComponent.duplicateSource
[type: string] [default: undefined] 
String indicating the source of this AssetComponent if it is a duplicate. Incisor® automatically detects when two or more AssetComponents are identical, ensuring that only one copy of the associated data is loaded to reduce the loaded size of the project. Those AssetComponents that are duplicates are marked by indicating the name of the source of their data. This member is undefined for AssetComponents that are not duplicates.










----------------------------------------------------------
Section 8: LoadingTierDefinition
----------------------------------------------------------


LoadingTierDefinition
[type: class] [NON-INSTANTIABLE] 
Object with information about a loading tier. Loading tiers are a means to organize AssetComponents into separately downloadable groups. 





LoadingTierDefinition.type
[type: string] 
Type identifier.





LoadingTierDefinition.loadingTier
[type: number] 
The loading tier number.





LoadingTierDefinition.isAutoLoaded
[type: boolean] 
Bool determining if this loading tier is automatically loaded on startup.





LoadingTierDefinition.incrementalContentProcessing
[type: boolean] 
Bool determining if the processing of the data in this loading tier is processed incrementally. This setting can be used to minimize performance hits caused when asset data is 'lazy-loaded' during the end-user experience; When true, the processing of assets within a tier is spread out over multiple screen updates.





LoadingTierDefinition.assetDataFileSizeLimitKB
[type: number] 
A limit on the size of the published asset data files within this loading tier. This setting can be used to break up the loading of asset data in order to help minimize performance hits caused when asset data is 'lazy-loaded' during the end-user experience; It should be noted that this is a soft-limit; individual assetComponents whose data is larger than this limit will result in oversized asset data files.





LoadingTierDefinition.spriteSheetDimensionLimit
[type: number] 
A limit on the dimensions of sprite sheets within this loading tier. It should be noted that this is a soft-limit; individual GraphicAssets whose dimensions are larger than this limit will result in oversized sprite sheet files.





LoadingTierDefinition.isLoaded
[type: boolean] 
Bool indicating if all of the assets in this loading tier have been loaded.





LoadingTierDefinition.isLoading
[type: boolean] 
Bool indicating if this LoadingTier is in the process of loading or is queued to load.










----------------------------------------------------------
Section 9: Button
----------------------------------------------------------


Button
[type: class] [extends: GraphicObject] 
Buttons are specialized GraphicObjects that can provide callbacks for cursor interactions. Buttons adhere to layering - only the frontmost Button receives cursor input.





Button.buttonActive
[type: boolean] [default: true] 
Flag that determines if this Button responds to cursor interaction. If false, this Button acts no differently than a GraphicObject.





Button.rolloverFlag
[type: boolean] 
Flag that reports if the cursor is currently directly over this Button. It should be noted that Buttons adhere to layering - only the frontmost active Button receives input.





Button.buttonDown
[type: boolean] 
Flag that reports if the Button is currently being 'pressed'.





Button.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this Button will be immune to. Set the value to [] to create callbacks with no immunity. This property defaults to the value currently in nc.defaultPauseImmunity, which can be changed at any time.





Button.addCursorMoveCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when the cursor is moved over this Button.

Button.addCursorMoveCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addCursorMoveCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addCursorMoveCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a CursorMoveCallback to a Button.
// Action: Move your mouse pointer in and out of the white box.
// Expected Result: As you move your mouse pointer inside the box it will flash different colors.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a reference to a callback function passing the owner of the function and the function name.
this.button.addCursorMoveCallback( this, "myCallback", ["myArgs0", "myArgs1"] );

// Add a callback function. Your first 2 parameters will always be the browser event and the camera.
this.myCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = Math.random();
    this.button.fillColor.blue  = Math.random();
    this.button.fillColor.green = Math.random();
}





Button.removeCursorMoveCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the cursor is moved over this Button.

Button.removeCursorMoveCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeCursorMoveCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateCursorMoveCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'cursorMove' callback for this Button.

Button.simulateCursorMoveCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateCursorMoveCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addCursorInCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when the cursor is moved into this Button's bounds.

Button.addCursorInCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addCursorInCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addCursorInCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a CursorInCallback and CursorOutCallback to a Button.
// Action: Move your mouse pointer in and out of the box.
// Expected Result: When you move your mouse pointer into the box, the box becomes blue. When you move it out, it will become red.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a reference to a callback function passing the owner of the function and the function name.
this.button.addCursorInCallback( this, "myInCallback", ["myArgs0", "myArgs1"] );
this.button.addCursorOutCallback( this, "myOutCallback", ["myArgs0", "myArgs1", "myArgs2"] );

// Add callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myInCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 0;
    this.button.fillColor.blue  = 1;
    this.button.fillColor.green = 0;
}
this.myOutCallback = function( event, camera, callbackArgs0, callbackArgs1, callbackArgs2 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1, callbackArgs2);
    this.button.fillColor.red   = 1;
    this.button.fillColor.blue  = 0;
    this.button.fillColor.green = 0;
}





Button.removeCursorInCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the cursor is moved into this Button's bounds.

Button.removeCursorInCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeCursorInCallback parameter: callbackName
[type: string] 
The name of the callback function.

example:
// Objective: Remove a CursorInCallback from a Button.
// Actions: 
// 1. Move your mouse pointer in and out of the white box.
// 1. Expected Result: The console should read "action: mousemove" each time your mouse enters the white box.

// 2. Click the white triangle to remove the CursorInCallback.
// 2. Expected Result: Upon clicking the white triangle, the console should read "removing the callback". Moving the mouse in and out of the white box no longer generates any console messages
  
// Create a button to use to remove the callback. Use the WhiteTriangle GraphicAsset.
this.removeCallbackButton = nc.addButton( nc.graphicAssets.WhiteTriangle, nc.mainScene, "RemoveCallbackButton" );
// Move the white triangle to the right 200 world units.
this.removeCallbackButton.position.x = 200;
// Create a callback function that handles the click of the white triangle and executes removeCursorInCallback() 
this.myRemovePressCallback = function(args) {
    console.log('removing the callback');
    // Inside this press callback, remove the CursorInCallback
    this.button.removeCursorInCallback( this, "myActionCallback" );
}
// Add the PressCallback to handle the clicking of the white triangle
this.removeCallbackButton.addPressCallback( this, "myRemovePressCallback" );

// Create a button using the "nc" factory method.
this.button = nc.addButton( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );

// Create a callback function.
this.myActionCallback = function(args) {
    console.log('action:', args.type);
}

// Add a CursorInCallback
this.button.addCursorInCallback( this, "myActionCallback" );





Button.simulateCursorInCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'cursorIn' callback for this Button.

Button.simulateCursorInCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateCursorInCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addCursorOutCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when the cursor is moved out of this Button's bounds.

Button.addCursorOutCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addCursorOutCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addCursorOutCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a CursorInCallback and CursorOutCallback to a Button.
// Action: Move your mouse pointer in and out of the box.
// Expected Result: When you move your mouse pointer into the box, the box becomes blue. When you move it out, it will become red.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a reference to a callback function passing the owner of the function and the function name.
this.button.addCursorInCallback( this, "myInCallback", ["myArgs0", "myArgs1"] );
this.button.addCursorOutCallback( this, "myOutCallback", ["myArgs0", "myArgs1", "myArgs2"] );

// Add callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myInCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 0;
    this.button.fillColor.blue  = 1;
    this.button.fillColor.green = 0;
}
this.myOutCallback = function( event, camera, callbackArgs0, callbackArgs1, callbackArgs2 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1, callbackArgs2);
    this.button.fillColor.red   = 1;
    this.button.fillColor.blue  = 0;
    this.button.fillColor.green = 0;
}





Button.removeCursorOutCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the cursor is moved out of this Button's bounds.

Button.removeCursorOutCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeCursorOutCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateCursorOutCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'cursorOut' callback for this Button.

Button.simulateCursorOutCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateCursorOutCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addDragCallback(callbackOwner, callbackName, callbackArgs, allowInOutAndMove, requireDragInitiationThreshold)
[type: function] 
Adds a callback for when this Button is dragged.

Button.addDragCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addDragCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addDragCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

Button.addDragCallback parameter: allowInOutAndMove
[type: boolean] [default: false] [optional] 
Boolean determining if other buttons will receive cursorIn, cursorOut, and cursorMove events while this Button is being dragged.

Button.addDragCallback parameter: requireDragInitiationThreshold
[type: boolean] [default: true] [optional] 
Boolean determining if the cursor must be dragged by a minimum threshold before 'drag' callbacks start to happen. See 'Camera.mouseDragInitiationThreshold' and 'Camera.touchDragInitiationThreshold' for more information.

example:
// Objective: Add a DragCallback and a DropCallback to a Button.
// Action: Drag the box.
// Expected Result: As you are dragging the box it will be white. When you drop it, it will turn red.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add callbacks, passing the owner of the function and the function name.
this.button.addDragCallback( this, "myDragCallback", ["myArgs0", "myArgs1"] );
this.button.addDropCallback( this, "myDropCallback", ["myArgs0", "myArgs1"] );

// Add both callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myDragCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('drag callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.green = 1;
    this.button.fillColor.blue = 1;
    this.button.position.x = nc.mainCamera.getCursorPosition().x;
    this.button.position.y = nc.mainCamera.getCursorPosition().y;
}
// Your first 2 parameters will always be the browser event and the camera. For a DropCallback you will receive 2 additional arguments, the dragged button and the button being dropped onto. 
this.myDropCallback = function( event, camera, draggedButton, dropTargetButton, callbackArgs0, callbackArgs1 ) {
    console.log('drop callback:', event.type, camera.name, draggedButton.name, dropTargetButton.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.green = 0;
    this.button.fillColor.blue = 0;
}





Button.removeDragCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is dragged.

Button.removeDragCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeDragCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateDragCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'drag' callback for this Button.

Button.simulateDragCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateDragCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addDropCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this Button is dropped (after being dragged). Please note that the Button must have a drag callback in order for any drop callbacks to occur.

Button.addDropCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addDropCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addDropCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, the viewing Camera, the dragged Button, and the Button being dropped onto (if any) will automatically be prepended to this list of arguments, so the callback implementation must plan to receive those as its first four parameters.

example:
// Objective: Add a DragCallback and a DropCallback to a Button.
// Action: Drag the box.
// Expected Result: As you are dragging the box it will be white. When you drop it, it will turn red.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add callbacks, passing the owner of the function and the function name.
this.button.addDragCallback( this, "myDragCallback", ["myArgs0", "myArgs1"] );
this.button.addDropCallback( this, "myDropCallback", ["myArgs0", "myArgs1"] );

// Add both callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myDragCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('drag callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.green = 1;
    this.button.fillColor.blue = 1;
    this.button.position.x = nc.mainCamera.getCursorPosition().x;
    this.button.position.y = nc.mainCamera.getCursorPosition().y;
}
// Your first 2 parameters will always be the browser event and the camera. For a DropCallback you will receive 2 additional arguments, the dragged button and the button being dropped onto. 
this.myDropCallback = function( event, camera, draggedButton, dropTargetButton, callbackArgs0, callbackArgs1 ) {
    console.log('drop callback:', event.type, camera.name, draggedButton.name, dropTargetButton.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.green = 0;
    this.button.fillColor.blue = 0;
}





Button.removeDropCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is dropped (after being dragged).

Button.removeDropCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeDropCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateDropCallback(simulatedEvent, simulatedCamera, simulatedDropRecipient)
[type: function] 
Manually triggers the 'drop' callback for this Button.

Button.simulateDropCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateDropCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.

Button.simulateDropCallback parameter: simulatedDropRecipient
[type: Button] [optional] 
Button acting as the Button that is being dropped onto.





Button.addPressCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this Button is pressed down.

Button.addPressCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addPressCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addPressCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a PressCallback and a ReleaseCallback to a Button.
// Action: Press and release the button to change its color.
// Expected Result: Each time you are pressing the button it will be red. When you release it, it will turn back to green.

// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Initially, make the button green.
this.button.fillColor.red = 0;
this.button.fillColor.blue = 0;
// Add callbacks, passing the owner of the function and the function name.
this.button.addPressCallback( this, "myPressCallback", ["myArgs0", "myArgs1"] );
this.button.addReleaseCallback( this, "myReleaseCallback", ["myArgs0", "myArgs1"] );

// Add callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myPressCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 1;
    this.button.fillColor.green = 0;
}
this.myReleaseCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 0;
    this.button.fillColor.green = 1;
}





Button.removePressCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is pressed down.

Button.removePressCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removePressCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulatePressCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'press' callback for this Button.

Button.simulatePressCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulatePressCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addReleaseCallback(callbackOwner, callbackName, callbackArgs, releaseRequiresInitialPress)
[type: function] 
Adds a callback for when this Button is released.

Button.addReleaseCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addReleaseCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addReleaseCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

Button.addReleaseCallback parameter: releaseRequiresInitialPress
[type: boolean] [default: true] [optional] 
If true, the Button must be pressed before being released in order for the callback to occur.

example:
// Objective: Add a PressCallback and a ReleaseCallback to a Button.
// Action: Press and release the button to change its color.
// Expected Result: Each time you are pressing the button it will be red. When you release it, it will turn back to green.

// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Initially, make the button green.
this.button.fillColor.red = 0;
this.button.fillColor.blue = 0;
// Add callbacks, passing the owner of the function and the function name.
this.button.addPressCallback( this, "myPressCallback", ["myArgs0", "myArgs1"] );
this.button.addReleaseCallback( this, "myReleaseCallback", ["myArgs0", "myArgs1"] );

// Add callback functions. Your first 2 parameters will always be the browser event and the camera.
this.myPressCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 1;
    this.button.fillColor.green = 0;
}
this.myReleaseCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
    this.button.fillColor.red   = 0;
    this.button.fillColor.green = 1;
}





Button.removeReleaseCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is released.

Button.removeReleaseCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeReleaseCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateReleaseCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'release' callback for this Button.

Button.simulateReleaseCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateReleaseCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addDoubleTapCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this Button is tapped twice in fast succession. See 'nc.multiTapInterval' to adjust the multi-tap speed.

Button.addDoubleTapCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addDoubleTapCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addDoubleTapCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a DoubleTapCallback to a Button.
// Action: Double tap the box.
// Expected Result: Each time you double tap the box it expands to 4 times its original size or contracts back to its original size.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a callback, passing the owner of the function and the function name.
this.button.addDoubleTapCallback( this, "myCallback", ["myArgs0", "myArgs1"] );
  
// Add a callback function. Your first 2 parameters will always be the browser event and the camera.
this.myCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);

    if ( this.button.scale.x == 1 ) {
        this.button.scale.x = 4;
        this.button.scale.y = 4;
    } else {
        this.button.scale.x = 1;
        this.button.scale.y = 1;
    }
 }





Button.removeDoubleTapCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is tapped twice in fast succession.

Button.removeDoubleTapCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeDoubleTapCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateDoubleTapCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'doubleTap' callback for this Button.

Button.simulateDoubleTapCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateDoubleTapCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addTripleTapCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this Button is tapped three times in fast succession. See 'nc.multiTapInterval' to adjust the multi-tap speed.

Button.addTripleTapCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addTripleTapCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addTripleTapCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a TripleTapCallback to a Button.
// Action: Triple tap the box.
// Expected Result: Each time you triple tap the box it expands to 4 times its original size or contracts back to its original size.
 
// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a callback, passing the owner of the function and the function name.
this.button.addTripleTapCallback( this, "myCallback", ["myArgs0", "myArgs1"] );
  
// Add a callback function. Your first 2 parameters will always be the browser event and the camera.
this.myCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);

    if ( this.button.scale.x == 1 ) {
        this.button.scale.x = 4;
        this.button.scale.y = 4;
    } else {
        this.button.scale.x = 1;
        this.button.scale.y = 1;
    }
 }





Button.removeTripleTapCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when this Button is tapped three times in fast succession.

Button.removeTripleTapCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeTripleTapCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateTripleTapCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'tripleTap' callback for this Button.

Button.simulateTripleTapCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateTripleTapCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addScrollCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when the cursor 'scroll' occurs over this Button. Invoke the 'preventDefault' method on the event sent to the callback to prevent browser-level scrolling functionality.

Button.addScrollCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addScrollCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addScrollCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a ScrollCallback to a Button.
// Action: Mouse wheel up and down over the white box.
// Expected Result: As you mouse wheel up, the box expands. As you wheel down, it contacts.

// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a callback, passing the owner of the function and the function name.
this.button.addScrollCallback( this, "myCallback", ["myArgs0", "myArgs1"] );

// Add a callback function. Your first 2 parameters will always be the browser event and the camera.
this.myCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
    console.log('callback:', event.name, camera.name, callbackArgs0, callbackArgs1);
    
    // Use the event to get the delta of the mouse wheel
    if ( event.wheelDelta > 0 ) {
        // "zoom in" no greater than 5 x original size
        if ( this.button.scale.x <= 5 ) {
           this.button.scale.x = this.button.scale.x + .1;
           this.button.scale.y = this.button.scale.y + .1;
        }    
    } else {
        // zoom out no smaller than .05 original size
        if ( this.button.scale.x >= 0.5 ) {
            this.button.scale.x = this.button.scale.x - .1;
            this.button.scale.y = this.button.scale.y - .1;
        }    
    }
}





Button.removeScrollCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the cursor 'scroll' occurs over this Button.

Button.removeScrollCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeScrollCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateScrollCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'scroll' callback for this Button.

Button.simulateScrollCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateScrollCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.





Button.addContextMenuCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when the in-browser context menu is activated over this Button. Invoke the 'preventDefault' method on the event sent to the callback to prevent built-in browser context menu from appearing.

Button.addContextMenuCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.addContextMenuCallback parameter: callbackName
[type: string] 
The name of the callback function.

Button.addContextMenuCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the callback-triggering browser-generated event, and the viewing Camera will automatically be prepended to this list of arguments, so the callback implementation must be written to receive those as its first two parameters.

example:
// Objective: Add a ContextMenuCallback to a Button.
// Action: Bring the mouse into the white box and right click your mouse.
// Expected Result: The console should read "callback: contextmenu MainCamera myArgs0 myArgs1".

// Create a button using the Button constructor.
this.button = new Button( nc.graphicAssets.WhiteBox, nc.mainScene, "MyButton" );
// Add a reference to a callback function passing the owner of the function and the function name.
this.button.addContextMenuCallback( this, "myCallback", ["myArgs0", "myArgs1"] );

// Add a callback function. Your first 2 parameters will always be the browser event and the camera.
this.myCallback = function( event, camera, callbackArgs0, callbackArgs1 ) {
   console.log('callback:', event.type, camera.name, callbackArgs0, callbackArgs1);
}





Button.removeContextMenuCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the in-browser context menu is activated over this Button.

Button.removeContextMenuCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Button.removeContextMenuCallback parameter: callbackName
[type: string] 
The name of the callback function.





Button.simulateContextMenuCallback(simulatedEvent, simulatedCamera)
[type: function] 
Manually triggers the 'contextMenu' callback for this Button.

Button.simulateContextMenuCallback parameter: simulatedEvent
[type: object] [optional] 
Event object that can be supplied in place of the authentic browser-generated event that occurs when the callback is triggered naturally.

Button.simulateContextMenuCallback parameter: simulatedCamera
[type: object] [optional] 
The Camera that will be supplied to the callback as the 'triggering' Camera.

































































































































































































































































































































































































----------------------------------------------------------
Section 10: Camera
----------------------------------------------------------


Camera
[type: class] [extends: SceneObject] [NON-INSTANTIABLE] 
A Camera is a specialized SceneObject with the ability to render the Scene that contains it to a RenderTarget. 





Camera.autoRender
[type: boolean] [default: true] 
Boolean determining if this Camera is automatically rendered with every screen update.





Camera.autoRenderOrder
[type: number] [default: 0] 
Number determining this Camera's order in the list of automatically rendered Cameras. Higher numbers correspond to earlier render order.





Camera.backgroundColor
[type: Color] [default: Color(0,0,0,0)] 
Color determining the background color (aka the 'clear color') of this Camera. Please note that the 'MainCamera' defaults to [0.1,0.08,0.08,1], while all other cameras default to [0,0,0,0]. These values can be changed at any time.





Camera.cursorInteractive
[type: boolean] [default: false] 
Boolean determining if this camera will be used in conjunction with a cursor for Buttons or other cursor activity. Cameras are responsible for relating the cursor's screen position to a position within the Scene and this flag informs the Camera of that requirement. To optimize your project, ensure that this property is only set to true when cursor interactivity (Buttons etc...) in the Scene that this Camera is rendering.





Camera.adaptiveCameraMode
[type: string] 
Property determining the 'adaptive camera mode' of this Camera. Adaptive camera modes can put a Camera into a state where it reacts to the shape it's RenderTarget, extending or contracting the view area of the Camera as the shape if it's RenderTarget changes. The adaptive camera modes are as follows: 'none' - the view width and height of the camera do not change, regardless of the size and shape of the Camera's RenderTarget. 'unitsMatchPixels' - the camera bounds will consistently be updated, matching the view width and height (in world units) of the Camera with the current render resolution of the Camera's RenderTarget. 'maximizeSafeZone' - the camera bounds will consistently be updated, ensuring that the core view area (as defined by coreViewWidth and coreViewHeight) is rendered as large as it can be on the Camera's RenderTarget. [DEFUALT: constants.adaptiveCameraModes.none]





Camera.clearsColor
[type: boolean] 
Boolean determining if the color buffer is cleared in this Camera's RenderTarget prior to rendering. [DEFUALT: true]





Camera.clearsDepth
[type: boolean] 
Boolean determining if the depth buffer is cleared in this Camera's RenderTarget prior to rendering. [DEFUALT: true]





Camera.clearsStencil
[type: boolean] 
Boolean determining if the stencil buffer is cleared in this Camera's RenderTarget prior to rendering. [DEFUALT: true]





Camera.renderTarget
[type: RenderTarget] 
The RenderTarget this Camera will render to when Camera.render is invoked. [DEFUALT: undefined]





Camera.cursorInputOverride()
[type: function, CursorInputOverrideButton] 
This property provides means to override the automated setting of this Camera's cursorViewPosition. This is most commonly deployed when a RenderTarget used within a primary Scene serves as a 'window' into a secondary Scene that requires cursor interaction - this property would be used to map the cursor interaction through the window into the secondary screen. This property can be used two ways: 1. Define a CursorInputOverrideButton and set this property to that object. When you do this, the button serves as a 'cursor mapping surface', where the edges of the CursorInputOverrideButton correspond to the edges of the secondary Camera's view area. 2. Set this property to a function that remaps the cursorViewPosition manually. This method can be used to further customize the setting of this Camera's cursorViewPosition. If implemented, the first parameter of the function should take the triggering browser-generated cursor event, and the second parameter will be a Vector2 holding the default-calculated cursorViewPosition. The function should use those parameters as input, generate the desired remapped values, and call 'setCursorViewPosition' on the camera accordingly. [DEFUALT: undefined]





Camera.touchDragInitiationThreshold
[type: number] [default: 0.05] 
Proportion of the Camera's view area that a touch-based cursor drag must travel in order to initiate a Button 'drag'. While using a touch-based device, tapping the screen often produces a tiny unintentional cursor drag. This value creates a threshold; if the cursor moves less than this portion of the Camera's view area during a screen touch, no Button 'drag' occurs.





Camera.mouseDragInitiationThreshold
[type: number] [default: 0.005] 
Proportion of the Camera's view area that a mouse-based cursor drag must travel in order to initiate a Button 'drag'. While using a mouse, clicking sometimes produces a tiny un-intentional cursor drag. This value creates a threshold; if the cursor moves less than this portion of the Camera's view area during a click, no Button 'drag' occurs.





Camera.isCurrentlyRendering
[type: boolean] 
Boolean denoting if the Camera is currently in the process of rendering. This property can be queried prior to any potentially recursive 'Camera.render' calls to prevent an infinite self-invocation scenario.





Camera.timelineRenderDriver
[type: Timeline] [default: undefined] 
Optional TimelineManager that can drive this camera's rendering. This property defaults to undefined, but when it is set to a given TimelineManager the Camera will render continuously as long as one or more Timeline with non-zero influence is playing. If the 'generatesPrecomp' setting for a given Construct is true, and if that Construct has one or more Timelines, then the associate Precomp Camera's 'timelineRenderDriver' value is automatically set to the Construct instance's TimelineManager. This enables Construct-generated Precomps to render while timelines are playing, and rest while timelines are not playing.





Camera.render(skipRenderPreparations)
[type: function] 
Renders the contents of the Scene within the Camera's view area to the RenderTarget.

Camera.render parameter: skipRenderPreparations
[type: boolean] [default: false] [optional] 
Boolean that, if true, tells the rendering process to skip render preparations for efficiency. This flag is best used with secondary Cameras that render Scenes that have already been rendered once in their current state (as the preparations would have already been completed).





Camera.setCursorViewPosition(x, y, z, simulateCursorMoveEvent)
[type: function] 
Updates the Camera's cursor view position to the given x and y coordinates. Camera view coordinates operate with bounds from -.5 to .5, where -.5 is the left/bottom edge of the view plane, and .5 is the right/top edge. The cursor view position is used to calculate cursor interaction with Buttons etc.

Camera.setCursorViewPosition parameter: x
[type: number] 
The x position for the cursor in terms of Camera view coordinates [-.5,.5]

Camera.setCursorViewPosition parameter: y
[type: number] 
The y position for the cursor in terms of Camera view coordinates [-.5,.5]

Camera.setCursorViewPosition parameter: z
[type: number] 
The z position for the cursor in terms of Camera view coordinates [-.5,.5] (where .5 is the near side of the frustum)

Camera.setCursorViewPosition parameter: simulateCursorMoveEvent
[type: boolean] [default: false] 
Boolean indicating if the "simulateCursorMoveEvent" will automatically be called. If true it should be noted that the associated call to 'simulateCursorMoveEvent' will use the default param 'updateScene=true', which could result in an extra performance cost per invocation.





Camera.getCursorViewPosition(returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 with the cursor position in terms of Camera view coordinates. Camera view coordinates operate with bounds from -.5 to .5, where -.5 is the left/bottom/far edge of the frustum, and .5 is the right/top/near edge.

Camera.getCursorViewPosition parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.





Camera.setCursorPosition(x, y, z, simulateCursorMoveEvent)
[type: function] 
Updates the Camera's cursor position from a given world position. The cursor position is used to calculate cursor interaction with Buttons etc.

Camera.setCursorPosition parameter: x
[type: number] 
The x position for the cursor in terms of world coordinates

Camera.setCursorPosition parameter: y
[type: number] 
The y position for the cursor in terms of world coordinates

Camera.setCursorPosition parameter: z
[type: number] 
The z position for the cursor in terms of world coordinates

Camera.setCursorPosition parameter: simulateCursorMoveEvent
[type: boolean] [default: false] 
Boolean indicating if the 'simulateCursorMoveEvent' will automatically be called. If true it should be noted that the associated call to 'simulateCursorMoveEvent' will use the default param 'updateScene=true', which could result in an extra performance cost per invocation.





Camera.getCursorPosition(returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 with the cursor position in terms of world coordinates. The cursor position is used to calculate cursor interaction with Buttons etc.

Camera.getCursorPosition parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.





Camera.performManualCursorRolloverCheck()
[type: function] 
Manually checks this Camera's cursor position, triggering any appropriate 'cursorIn' or 'cursorOut' callbacks for the appropriate Buttons. This function can be used to ensure that 'cursorIn' or 'cursorOut' callbacks are triggered even when there is no originating cursor event; for example, if Buttons are moving themselves, and a new Button moves under the cursor, invoking this function would evaluate the cursor and button positions and ultimately trigger the 'cursorIn' callback for the new Button.





Camera.simulateCursorMoveEvent(updateScene)
[type: function] 
Simulates a 'cursorMove' AppEvent at the current cursor position. Please note that either setCursorViewPosition or setCursorPosition will need to called to actually change the position of the cursor, as this method is only responsible for triggering the cursorMove-related Button callbacks. You can reposition the cursor AND get cursorMove-related Button callbacks by calling setCursorViewPosition or setCursorPosition with paramater simulateCursorMoveEvent=true. Also, please note this Camera must render once before the cursorPosition will intersect with any Buttons.

Camera.simulateCursorMoveEvent parameter: updateScene
[type: boolean] [default: true] [optional] 
Boolean determining if the Scene will be manually updated prior to the simulated AppEvent; this ensures that the most recent Scene changes (changes within the current screenUpdate) affecting Button detection are accounted for, but can result in an extra cost to performance per invocation, so should not be overly used.





Camera.simulateCursorPressEvent(updateScene)
[type: function] 
Simulates a 'cursorPress' AppEvent at the current cursor position. Call setCursorViewPosition or setCursorPosition prior to calling this function to change the cursor position if needed. Please note this Camera must render once before the cursorPosition will intersect with any Buttons.

Camera.simulateCursorPressEvent parameter: updateScene
[type: boolean] [default: true] [optional] 
Boolean determining if the Scene will be manually updated prior to the simulated AppEvent; this ensures that the most recent Scene changes (changes within the current screenUpdate) affecting Button detection are accounted for, but can result in an extra cost to performance per invocation, so should not be overly used.





Camera.simulateCursorReleaseEvent(updateScene)
[type: function] 
Simulates a 'cursorRelease' AppEvent at the current cursor position. Call setCursorViewPosition or setCursorPosition prior to calling this function to change the cursor position if needed. Please note this Camera must render once before the cursorPosition will intersect with any Buttons.

Camera.simulateCursorReleaseEvent parameter: updateScene
[type: boolean] [default: true] [optional] 
Boolean determining if the Scene will be manually updated prior to the simulated AppEvent; this ensures that the most recent Scene changes (changes within the current screenUpdate) affecting Button detection are accounted for, but can result in an extra cost to performance per invocation, so should not be overly used.





Camera.simulateCursorScrollEvent(updateScene)
[type: function] 
Simulates a 'cursorScroll' AppEvent at the current cursor position. Call setCursorViewPosition or setCursorPosition prior to calling this function to change the cursor position if needed. Please note this Camera must render once before the cursorPosition will intersect with any Buttons.

Camera.simulateCursorScrollEvent parameter: updateScene
[type: boolean] [default: true] [optional] 
Boolean determining if the Scene will be manually updated prior to the simulated AppEvent; this ensures that the most recent Scene changes (changes within the current screenUpdate) affecting Button detection are accounted for, but can result in an extra cost to performance per invocation, so should not be overly used.





Camera.simulateContextMenuEvent(updateScene)
[type: function] 
Simulates a 'contextMenu' AppEvent at the current cursor position. Call setCursorViewPosition or setCursorPosition prior to calling this function to change the cursor position if needed. Please note this Camera must render once before the cursorPosition will intersect with any Buttons. Also, it should be noted that this method is not capable of producing the browser's actual context menu, it is only a means to trigger the Incisor®-level AppEvents and callbacks that such an event would produce.

Camera.simulateContextMenuEvent parameter: updateScene
[type: boolean] [default: true] [optional] 
Boolean determining if the Scene will be manually updated prior to the simulated AppEvent; this ensures that the most recent Scene changes (changes within the current screenUpdate) affecting Button detection are accounted for, but can result in an extra cost to performance per invocation, so should not be overly used.





Camera.getIntersections(viewPosition, sceneObjects, intersectionsArray)
[type: function] [returns: [Intersection]] 
The means to determine which SceneObject (if any) intersect with a given position within the Camera's view.

Camera.getIntersections parameter: viewPosition
[type: Vector2] [default: Camera.getViewPosition()] [optional] 
The position within the Camera's view space [-.5,.5]x[-.5,.5] to use when determining if any SceneObjects intersect.

Camera.getIntersections parameter: sceneObjects
[type: [SceneObject]] [default: Scene.getDescendants()] [optional] 
The list of SceneObjects to test for intersection.

Camera.getIntersections parameter: intersectionsArray
[type: Array] [optional] 
Optional array that can be provided as an optimization to avoid the creation of a new array.





Camera.clear(clearColor, clearDepth, clearStencil)
[type: function] 
Clears the connected RenderTarget's buffers as specified.

Camera.clear parameter: clearColor
[type: boolean] [default: true] [optional] 
Boolean indicating if the color buffer should be cleared from the attached RenderTarget.

Camera.clear parameter: clearDepth
[type: boolean] [default: true] [optional] 
Boolean indicating if the depth buffer should be cleared from the attached RenderTarget.

Camera.clear parameter: clearStencil
[type: boolean] [default: true] [optional] 
Boolean indicating if the clearStencil buffer should be cleared from the attached RenderTarget.






















































































































































































































































































































----------------------------------------------------------
Section 11: OrthographicCamera
----------------------------------------------------------


OrthographicCamera
[type: class] [extends: Camera] 
An OrthographicCamera is a camera that renders orthographically, with no perspective.





OrthographicCamera.coreViewWidth
[type: number] [default: 500] 
The base width of the camera view area (frustum) in 'world units'. This number may not match the actual view width for certain settings of the 'adaptiveCameraMode' property.





OrthographicCamera.coreViewHeight
[type: number] [default: 500] 
The base height of the camera view area (frustum) in 'world units'. This number may not match the actual view height for certain settings of the 'adaptiveCameraMode' property.





OrthographicCamera.viewDepth
[type: number] [default: 2000] 
The depth of the camera view area (frustum) in 'world units'.





OrthographicCamera.getCurrentViewDimensions()
[type: function] [returns: Vector3] 
Returns a Vector3 containing current dimensions of this Camera's current view area, inclusive of any changes brought about by its adaptiveCameraMode.





























































































































































































































































































































































































































































----------------------------------------------------------
Section 12: Intersection
----------------------------------------------------------


Intersection
[type: class] [NON-INSTANTIABLE] 
Class holding the information about an intersection between a point in a Camera's view and a SceneObject in the Scene. Objects of this type are returned from the Camera.getIntersections method. 





Intersection.sceneObject
[type: SceneObject] 
The SceneObject that is intersected.





Intersection.intersectionPosition
[type: Vector3] 
The global position of the intersection within the given Scene.










----------------------------------------------------------
Section 13: Code
----------------------------------------------------------


Code
[type: class] [NON-INSTANTIABLE] 
Object housing tools for pre-process manipulation of code such as including files and conditional code. An instance of this object can be refrenced globally by the name of 'CODE'. 





Code.includeIf___published
[type: object] 
Conditional code opener. Use this tag at the beginning of a section of code that will only be included when the project is published.





Code.includeEnd___published
[type: object] 
Conditional code closer. Use this tag at the end of a section of code that will only be included when the project is published.

example:
console.log('this is always happening');
CODE.includeIf___published;
  console.log('this is only happening when the project is published');
CODE.includeEnd___published;





Code.includeIf___unpublished
[type: object] 
Conditional code opener. Use this tag at the beginning of a section of code that will only be included when the project is not published.

example:
console.log('this is always happening');
CODE.includeIf___unpublished;
  console.log('this is only happening when the project is not published');
CODE.includeEnd___unpublished;





Code.includeEnd___unpublished
[type: object] 
Conditional code closer. Use this tag at the end of a section of code that will only be included when the project is not published.

example:
console.log('this is always happening');
CODE.includeIf___unpublished;
  console.log('this is only happening when the project is not published');
CODE.includeEnd___unpublished;





Code.preserve___begin
[type: object] 
Preservation opener. Use this tag at the beginning of a block of code to exempt it from all forms of code formatting including minification, whitespace removal, and comment removal.





Code.preserve___end
[type: object] 
Preservation closer. Use this tag at the end of a block of code to exempt it from all forms of code formatting including minification, whitespace removal, and comment removal.





Code.runBeforeInit___begin
[type: object] 
A code tag that denotes the beginning of a 'runBeforeInit' block. Generally, code written within Incisor® is completely object-oriented, and as such all code execution must originate from within class objects. In other words, if you open up a new javascript file, and type "nc.addGraphicObject();", you would get an error pointing out that 'nc' doesn't exist, since that code is running in a class-declaration scope. To get that code to execute properly, you would either need to included in a class function that is ultimately called as a result of the ProjectMain.init function, OR you can include that code in a 'runBeforeInit' block, which actually moves the code so that it will be executed right before the invocation of ProjectMain.init. It should be noted that 'runBeforeInit' blocks also exist for code assets, as well as Incisor® extensions, and have a similar effect - moving blocks of code to the same scope as the entry-points for those contexts.

example:
CODE.runBeforeInit___begin;
   // since this code is inside of a 'runBeforeInit' block, it will be run right before ProjectMain.init, and all standard classes will have access to the 'whiteBox' var.
   var whiteBox = nc.addGraphicObject();
CODE.runBeforeInit___end;





Code.runBeforeInit___end
[type: object] 
A code tag that denotes the end of a 'runBeforeInit' block. Generally, code written within Incisor® is completely object-oriented, and as such all code execution must originate from within class objects. In other words, if you open up a new javascript file, and type "nc.addGraphicObject();", you would get an error pointing out that 'nc' doesn't exist, since that code is running in a class-declaration scope. To get that code to execute properly, you would either need to included in a class function that is ultimately called as a result of the ProjectMain.init function, OR you can include that code in a 'runBeforeInit' block, which actually moves the code so that it will be executed right before the invocation of ProjectMain.init. It should be noted that 'runBeforeInit' blocks also exist for code assets, as well as Incisor® extensions, and have a similar effect - moving blocks of code to the same scope as the entry-points for those contexts.

example:
CODE.runBeforeInit___begin;
   // since this code is inside of a 'runBeforeInit' block, it will be run right before ProjectMain.init, and all standard classes will have access to the 'whiteBox' var.
   var whiteBox = nc.addGraphicObject();
CODE.runBeforeInit___end;





Code.includeIf___MyConditionalCodeTag
[type: object] 
Conditional code opener. Use this tag at the beginning of a section of code that will only be included when the associated conditional code tag is enabled in the given configuration.

example:
console.log('this is always happening');
this.includeIf___MyConditionalCodeTag;
  console.log('this is only happening when the MyConditionalCodeTag tag is included in the conditionalCodeTagsIncluded array for the current configuration.');
this.includeEnd___MyConditionalCodeTag;





Code.includeEnd___MyConditionalCodeTag
[type: object] 
Conditional code closer. Use this tag at the end of a section of code that will only be included when the associated conditional code tag is enabled in the given configuration.

example:
console.log('this is always happening');
this.includeIf___MyConditionalCodeTag;
  console.log('this is only happening when the MyConditionalCodeTag tag is included in the conditionalCodeTagsIncluded array for the current configuration.');
this.includeEnd___MyConditionalCodeTag;





Code.includeFile()
[type: function] 
Function that inserts Javascript code from another file at the location of the function call.










----------------------------------------------------------
Section 14: Constants
----------------------------------------------------------


Constants
[type: class] [NON-INSTANTIABLE] 
Object housing predefined constant values for various Incisor® options and modes. 





Constants.wrapModes
[type: dictionary] 
The available options for texture wrap modes.


Constants.wrapModes.clamp
[type: string] 



Constants.wrapModes.repeat
[type: string] 



Constants.wrapModes.mirroredRepeat
[type: string] 






Constants.textureDownscalingModes
[type: dictionary] 
The available options for texture down-scaling modes.


Constants.textureDownscalingModes.linear
[type: string] 



Constants.textureDownscalingModes.nearest
[type: string] 



Constants.textureDownscalingModes.discreteMipmapNearest
[type: string] 



Constants.textureDownscalingModes.discreteMipmapLinear
[type: string] 



Constants.textureDownscalingModes.mipmapLinear
[type: string] 






Constants.textureUpscalingModes
[type: dictionary] 
The available options for texture up-scaling modes.


Constants.textureUpscalingModes.linear
[type: string] 



Constants.textureUpscalingModes.nearest
[type: string] 






Constants.adaptiveCameraModes
[type: dictionary] 
The available options for adaptive camera modes.


Constants.adaptiveCameraModes.none
[type: string] 



Constants.adaptiveCameraModes.maximizeSafeZone
[type: string] 



Constants.adaptiveCameraModes.unitsMatchPixels
[type: string] 






Constants.effectControllerBaseTypes
[type: dictionary] 
The available options for EffectController base types.


Constants.effectControllerBaseTypes.Vector4
[type: string] 



Constants.effectControllerBaseTypes.Vector3
[type: string] 



Constants.effectControllerBaseTypes.Vector2
[type: string] 



Constants.effectControllerBaseTypes.number
[type: string] 



Constants.effectControllerBaseTypes.Texture
[type: string] 



Constants.effectControllerBaseTypes.Matrix4
[type: string] 



Constants.effectControllerBaseTypes.Matrix4Array
[type: string] 






Constants.effectControllerMixModes
[type: dictionary] 
The available options for EffectController mix modes.


Constants.effectControllerMixModes.addition
[type: string] 



Constants.effectControllerMixModes.multiplication
[type: string] 



Constants.effectControllerMixModes.materialOnly
[type: string] 






Constants.blendingModes
[type: dictionary] 
The available options for material blending modes.


Constants.blendingModes.standard
[type: string] 



Constants.blendingModes.add
[type: string] 



Constants.blendingModes.multiply
[type: string] 






Constants.justifications
[type: dictionary] 
The available options for layout justifications.


Constants.justifications.left
[type: string] 



Constants.justifications.right
[type: string] 



Constants.justifications.center
[type: string] 



Constants.justifications.top
[type: string] 



Constants.justifications.bottom
[type: string] 






Constants.geometryAttributeNumberTypes
[type: dictionary] 
The available options for Geometry attribute number types.


Constants.geometryAttributeNumberTypes.Int8
[type: string] 



Constants.geometryAttributeNumberTypes.UInt8
[type: string] 



Constants.geometryAttributeNumberTypes.Int16
[type: string] 



Constants.geometryAttributeNumberTypes.UInt16
[type: string] 



Constants.geometryAttributeNumberTypes.Int32
[type: string] 



Constants.geometryAttributeNumberTypes.UInt32
[type: string] 



Constants.geometryAttributeNumberTypes.Float32
[type: string] 



Constants.geometryAttributeNumberTypes.Float64
[type: string] 






Constants.textBoxEditingModes
[type: dictionary] 
The available options textBox editing modes.


Constants.textBoxEditingModes.none
[type: string] 



Constants.textBoxEditingModes.selectable
[type: string] 



Constants.textBoxEditingModes.selecting
[type: string] 



Constants.textBoxEditingModes.editable
[type: string] 



Constants.textBoxEditingModes.editing
[type: string] 






Constants.playbackStates
[type: dictionary] 
The available playback states for PlaybackControllers.


Constants.playbackStates.stopped
[type: string] 



Constants.playbackStates.paused
[type: string] 



Constants.playbackStates.playing
[type: string] 






Constants.particleSystemEmitterShapes
[type: dictionary] 
The available types of ParticleSystemDefinition shapes


Constants.particleSystemEmitterShapes.rectangle
[type: string] 



Constants.particleSystemEmitterShapes.circleUniform
[type: string] 



Constants.particleSystemEmitterShapes.circleCenter
[type: string] 



Constants.particleSystemEmitterShapes.point
[type: string] 



Constants.particleSystemEmitterShapes.custom
[type: string] 






Constants.particleSystemRampInterpolationTypes
[type: dictionary] 
The available ParticleSystemDefinition ramp interpolation types.


Constants.particleSystemRampInterpolationTypes.linear
[type: string] 



Constants.particleSystemRampInterpolationTypes.smoothStep
[type: string] 



Constants.particleSystemRampInterpolationTypes.catmullRom
[type: string] 






Constants.particleSystemRampInputTypes
[type: dictionary] 
The available types of input for ParticleSystemDefinition ramps.


Constants.particleSystemRampInputTypes.emissionTime
[type: string] 



Constants.particleSystemRampInputTypes.ageRatio
[type: string] 






Constants.pdfUnderlineTypes
[type: dictionary] 
The styles of underlining available within the Pdf object.


Constants.pdfUnderlineTypes.single
[type: string] 



Constants.pdfUnderlineTypes.dash
[type: string] 



Constants.pdfUnderlineTypes.dotDash
[type: string] 



Constants.pdfUnderlineTypes.dotDotDash
[type: string] 



Constants.pdfUnderlineTypes.words
[type: string] 






Constants.pdfHeightRuleTypes
[type: dictionary] 
The options avaiable within the Pdf object for fitting items within a designated area height.


Constants.pdfHeightRuleTypes.autoFit
[type: string] 



Constants.pdfHeightRuleTypes.exactly
[type: string] 



Constants.pdfHeightRuleTypes.atLeast
[type: string] 






Constants.maskingTypes
[type: dictionary] 
Options for masking - either being masked, or doing the masking.


Constants.maskingTypes.mask
[type: string] 



Constants.maskingTypes.masked
[type: string] 






Constants.registeredPropertyTypes
[type: dictionary] 
The property types available to be registered within a CutsomObject or CustomAddOn.


Constants.registeredPropertyTypes.number
[type: string] 



Constants.registeredPropertyTypes.string
[type: string] 



Constants.registeredPropertyTypes.boolean
[type: string] 



Constants.registeredPropertyTypes.function
[type: string] 






Constants.curvePointBezierHandleTypes
[type: dictionary] 
The types of CurvePoint bezier handles that are available to be used within Curves.


Constants.curvePointBezierHandleTypes.independent
[type: string] 
The left and right handles can be moved independently, allowing for sharp discontinuities in the tangent of the Curve.


Constants.curvePointBezierHandleTypes.aligned
[type: string] 
The left and right handles are always colinear with the position.


Constants.curvePointBezierHandleTypes.symmetric
[type: string] 
The left and right handles are always colinear with the position, and both handles are the same distance from the position.





Constants.curveTypes
[type: dictionary] 
The available curve types.


Constants.curveTypes.bezier
[type: string] 
Each CurvePoint has left and right handles, allowing for manual control of the Curve's tangent, including sharp discontinuities. The Curve passes through all CurvePoints.


Constants.curveTypes.hermite
[type: string] 
Each CurvePoint has a right handle, allowing for manual control of the Curve's tangent and enforcing a smoothly continuous tangent. The Curve passes through all CurvePoints.


Constants.curveTypes.cardinal
[type: string] 
Each CurvePoint has no handles, and the Curve's tangent is automatically computed based on the surrounding CurvePoints, producing a smoothly continuous tangent. The Curve starts at the second CurvePoint and ends at the second to last CurvePoint, and passes through all intermediate CurvePoints. At least 4 CurvePoints are required.


Constants.curveTypes.basis
[type: string] 
Also known as a B-spline. Each CurvePoint has no handles, and the Curve's tangent is automatically computed based on the surrounding CurvePoints. The Curve starts at the second CurvePoint and ends at the second to last CurvePoint. The curve will not necessarily pass through any of the CurvePoints, but will exhibit smoothly continuous tangent and acceleration when using 'evaluateT'. At least 4 CurvePoints are required.





Constants.slotReelStates
[type: dictionary] 
Dictionary of available 'reelState' values within the SlotReel.


Constants.slotReelStates.stopped
[type: string] 
For when the SlotReel is stopped.


Constants.slotReelStates.windup
[type: string] 
For when the SlotReel is winding up before it spins.


Constants.slotReelStates.spinFree
[type: string] 
For when the SlotReel freely spinning.


Constants.slotReelStates.stopping
[type: string] 
For when the SlotReel begins to stop, spinning until the symbols in the stopping window are encountered.


Constants.slotReelStates.stopImminent
[type: string] 
This state occurs when the final stopping symbols are active on the SlotReel, and they just need to travel into their final position.


Constants.slotReelStates.bounce
[type: string] 
Right before the SlotReel spin is over, and the symbols are bouncing around to simulate a physical recoil action.





Constants.cursorMode
[type: dictionary] 
Dictionary of available values for 'nc.cursorMode'.


Constants.cursorMode.autoDetect
[type: string] 
When nc.cursorMode is set to this value, the next cursor event will received will set the cursor mode - if it's a touch event then cursorMode will be set to 'touch', and if the it's a mouse event then cursorMode will be set to 'mouse'.


Constants.cursorMode.mouse
[type: string] 
When in this mode, Incisor is using the mousedown, mouseup, mouseleave, wheel, and mousemove browser events to inform cursor interactions.


Constants.cursorMode.touch
[type: string] 
When in this mode, Incisor is using the touchstart, touchend, touchcancel, and touchmove browser events to inform cursor interactions.










----------------------------------------------------------
Section 15: ConstructDefinition
----------------------------------------------------------


ConstructDefinition
[type: class] [NON-INSTANTIABLE] 
ConstructDefinitions house the defining attributes of Constructs. To create an instance of a given Construct, use 'nc.myConstruct.add()'. 





ConstructDefinition.type
[type: string] 
Type identifier.





ConstructDefinition.name
[type: string] 
The name of the ConstructDefinition.





ConstructDefinition.blueprint
[type: Blueprint] 
Object defining the Construct's composition and layout.





ConstructDefinition.unitsPerPixel
[type: [number]] 
Array of numbers that multiply all of the positions and scales related to this Construct.





ConstructDefinition.add(parent, name)
[type: function] 
Adds an instance of this Construct to the given parent.

ConstructDefinition.add parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The SceneObject that will be the parent of the newly added Construct instance.

ConstructDefinition.add parameter: name
[type: string] [optional] 
The name of the newly added Construct instance. If left undefined, this propery will default to the name of the Construct.





ConstructDefinition.getPortableObject()
[type: function] 
Returns an object version of the ConstructDefinition equivalent to the '.construct' file that defines this Construct.










----------------------------------------------------------
Section 16: Blueprint
----------------------------------------------------------


Blueprint
[type: class] 
Object that stores information about a collection of SceneObjects that can be recreated later. This object is the foundation for Incisor® Constructs.










----------------------------------------------------------
Section 17: Construct
----------------------------------------------------------


Construct
[type: class] [extends: SceneObject] [NON-INSTANTIABLE] 
Constructs are collections of different types of SceneObjects that can be built, arranged, and animated from within the Incisor® GUI. For a list of available ConstructDefinitions, see 'nc.constructDefs'. 





Construct.constructDefinition
[type: ConstructDefinition] 
The ConstructDefinition associated with this Construct. Once a Construct is instantiated, this value cannot change.






















































































































































































































































































































----------------------------------------------------------
Section 18: CursorInputOverrideButton
----------------------------------------------------------


CursorInputOverrideButton
[type: class] [extends: Button] 
CursorInputOverrideButtons are specialized Buttons that serve as 'cursor input remapping surfaces'. These objects can be connected to Cameras (via Camera.cursorInputOverride), and serve as the means to map cursor input from an outer Scene into an inner Scene. When connected, the moving the cursor around the inside edge of the CursorInputOverrideButton will map the cursor to the inner edge of the Camera's viewing area within the Scene that the Camera is rendering. This only applies to Cameras whose 'cursorInteractive' property is set to true.





CursorInputOverrideButton.allowExtendedDrag
[type: boolean] [default: false] 
Flag determining if items within the inner scene can be dragged outside of the bounds of the viewing camera.


























































































































































































































































































































































































































































































































































































----------------------------------------------------------
Section 19: Curve
----------------------------------------------------------


Curve
[type: class] 
A Curve is a path defined by CurvePoints. The value of 'curveType' determines how the CurvePoints are interpreted to form the path.





Curve.curveType
[type: string] [default: "bezier"] 
The type of spline defining this Curve. See 'constants.curveTypes' for a list of available values.





Curve.cardinalTension
[type: number] [default: 0.5] 
When curveType is set to 'cardinal', this controls the curvature of the Curve. 0 produces straight lines between CurvePoints. 0.5 produces a Catmull-Rom spline.





Curve.points
[type: [CurvePoint]] 
The list of CurvePoints that define the curve shape. Each value of 'curveType' causes this list of CurvePoints to produce a different curve.





Curve.evaluateT(t, positionResult, tangentResult, normalResult, rotationResult, velocityResult)
[type: function] 
Evaluates the Curve at the given T value, which spans the entire curve in the range 0-1. Note that this typically does not progress with a constant speed, but is faster than evaluating a given distance with evaluateDistance.

Curve.evaluateT parameter: t
[type: number] 
The T value to evaluate, mapped to the range 0-1 along the length of the curve.

Curve.evaluateT parameter: positionResult
[type: Vector3] 
The resulting position expressed in the local space of the curve.

Curve.evaluateT parameter: tangentResult
[type: Vector3] [optional] 
The resulting tangent expressed in the local space of the curve. This corresponds to the velocity of a point following the curve via evaluateT, and is not normalized.

Curve.evaluateT parameter: normalResult
[type: Vector3] [optional] 
The resulting normal expressed in the local space of the curce. This vector is orthogonal to the tangent and is normalized.

Curve.evaluateT parameter: rotationResult
[type: Vector3] [optional] 
The resulting rotation that corresponds to the tangent and normal vectors.

Curve.evaluateT parameter: velocityResult
[type: Vector3] [optional] 
The resulting velocity expressed in the local space of the curve. If a point were to follow this curve via linearly increasing t values, this would be the velocity of the point at this position. Also known as the Curve's derivative.





Curve.evaluateDistance(distance, positionResult, tangentResult, normalResult, rotationResult, velocityResult)
[type: function] 
Evaluates the Curve at the given distance value, which spans the curve's length. Note that this allows progression at a constant speed, but is slower than evaluating a given T value with evaluateT.

Curve.evaluateDistance parameter: distance
[type: number] 
The distance to evaluate along the arc length of the curve.

Curve.evaluateDistance parameter: positionResult
[type: Vector3] 
The resulting position expressed in the local space of the curve.

Curve.evaluateDistance parameter: tangentResult
[type: Vector3] [optional] 
The resulting tangent expressed in the local space of the curve. This corresponds to the velocity of a point following the curve via evaluateT, and is not normalized.

Curve.evaluateDistance parameter: normalResult
[type: Vector3] [optional] 
The resulting normal expressed in the local space of the curce. This vector is orthogonal to the tangent and is normalized.

Curve.evaluateDistance parameter: rotationResult
[type: Vector3] [optional] 
The resulting rotation that corresponds to the tangent and normal vectors.

Curve.evaluateDistance parameter: velocityResult
[type: Vector3] [optional] 
The resulting velocity expressed in the local space of the curve. If a point were to follow this curve via linearly increasing t values, this would be the velocity of the point at this position. Also known as the Curve's derivative.





Curve.updatePoints()
[type: function] 
If ControlPoints are added to or removed from the points array, the curve will not be updated. This function foces the curve to reevaluate the points.





Curve.addCurveChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that will be called when the curve shape changes. This includes changes to the CurvePoints, and changes to the curveType and cardinalTension.

Curve.addCurveChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Curve.addCurveChangeCallback parameter: callbackName
[type: string] 
The name of the callback function.

Curve.addCurveChangeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function. Please note that the Curve object will be prepended to the list of callback parameters.





Curve.removeCurveChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the callback for when the curve shape changes.

Curve.removeCurveChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

Curve.removeCurveChangeCallback parameter: callbackName
[type: string] 
The name of the callback function.





Curve.addPoint()
[type: function] [returns: CurvePoint] 
Adds a new CurvePoint to the points array.





Curve.getLength()
[type: function] [returns: number] 
Returns the total arc of the curve.










----------------------------------------------------------
Section 20: CurvePoint
----------------------------------------------------------


CurvePoint
[type: class] [NON-INSTANTIABLE] 
A CurvePoint is a point used to define a Curve's shape. 





CurvePoint.position
[type: Vector3] [default: new Vector3(0,0,0)] 
The position of the CurvePoint in the local space of the Curve.





CurvePoint.leftHandle
[type: Vector3] [default: new Vector3(-100,0,0)] 
The left handle of the CurvePoint, expressed with respect to the CurvePoint's position. If the Curve's curveType is not 'bezier' or the CurvePoint is the first in the points array, this is undefined.





CurvePoint.rightHandle
[type: Vector3] [default: new Vector3(100,0,0)] 
The right handle of the CurvePoint, expressed with respect to the CurvePoint's position. If the Curve's curveType is not 'bezier' or 'hermite' or the CurvePoint is the last in the points array, this is undefined.





CurvePoint.bezierHandleType
[type: string] [default: "aligned"] 
The behavior of this CurvePoint when the Curve's curveType is "bezier" and one of the handles is moved. When a handle moves, "aligned" will ensure that the other handle remains colinear with the position and moved handle. "symmetric" will ensure that the other handle remains colinear with the position and moved handle, and matches the moved handles distance from the position.





CurvePoint.clone()
[type: function] [returns: number] 
Returns a unique copy of this CurvePoint.










----------------------------------------------------------
Section 21: CustomAddOnDefinition
----------------------------------------------------------


CustomAddOnDefinition
[type: class] [NON-INSTANTIABLE] 
Object housing information about the CustomAddOns currently registered in this project. 





CustomAddOnDefinition.name
[type: string] 
The name of the CustomAddOn.





CustomAddOnDefinition.baseType
[type: string] 
The the name base type of the given CustomAddOn definition. Every registered CustomAddOn must extend one of the CustomAddOn types (i.e. CustomAddOn_SceneObject, CustomAddOn_GraphicObject, etc...), and this value denotes which of those types were extended to to create this particular CustomAddOn.





CustomAddOnDefinition.acceptableOwner
[type: string] 
The name of the type that is required as an owner. For example, if the CustomAddOn extended CustomAddOn_Button, then the 'acceptableOnwer' value would be 'Button' and this CustomAddOn can only be added to objects that extend the Button type.





CustomAddOnDefinition.properties
[type: [object]] 
Array of objects that containing information about the registered properties for this CustomAddOn. Registered properties are accessible for monitoring and manipulating within the inspector. Registered properties can also be flagged as 'persistent', which enables their values to be stored in containing Constructs. To register a property for a CustomAddOn call 'nc.registerCustomAddOnProperty'. If this CustomAddOn has no registered properties, then this member will be undefined.





CustomAddOnDefinition.classDefinition
[type: object] 
The class definition for this CustomAddOn.










----------------------------------------------------------
Section 22: RegisteredProperty
----------------------------------------------------------


RegisteredProperty
[type: class] [NON-INSTANTIABLE] 
Object housing information about the CustomAddOns currently registered in this project. 





RegisteredProperty.type
[type: string] 
The type of the RegisteredProperty.





RegisteredProperty.propertyPath
[type: [string]] 
The path from given CustomAddOn instance to the property.





RegisteredProperty.isPersistent
[type: boolean] [default: true] 
Flag determining if the registered property's value should be stored in an owning Construct. To make the values of this property persistent within Constructs, set this flag to true.





RegisteredProperty.validationList
[type: [any]] [default: undefined] 
If this property is of type 'number' or 'string', then an Array of the given type can be provided so that the values appear in a drop-down list in the inspector, thus ensuring that only the given values are available to be selected within the GUI.





RegisteredProperty.validationCallbackOwner
[type: object] [default: undefined] 
If this property is of type 'number' or 'string', and a validation list has not been provided, then a function callback can be provided for a method which accepts the property value and returns a sanitized version of the value. This property is the owner of that callback.





RegisteredProperty.validationCallbackName
[type: string] [default: undefined] 
If this property is of type 'number' or 'string', and a validation list has not been provided, then a function callback can be provided for a method which accepts the property value and returns a sanitized version of the value. This property is the name of that callback.





RegisteredProperty.validationCallbackArgs
[type: string] [default: undefined] 
If this property is of type 'number' or 'string', and a validation list has not been provided, then a function callback can be provided for a method which accepts the property value and returns a sanitized version of the value. This property represents the parameters for that callback.





RegisteredProperty.dragMultiplier
[type: number] [default: 1] 
If this property is of type 'number', then this number can control how sensative the property's supervisor is with regards to the cursor-drag interactivity.





RegisteredProperty.displayInGui
[type: boolean] [default: true] 
Flag determining if this RegisteredProperty will appear as a Supervisor in the GUI.










----------------------------------------------------------
Section 23: CustomAddOn_SceneObject
----------------------------------------------------------


CustomAddOn_SceneObject
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_SceneObject.type
[type: string] 
Type identifier.





CustomAddOn_SceneObject.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_SceneObject.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_SceneObject.owner
[type: SceneObject] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_SceneObject.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_SceneObject.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_SceneObject.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_SceneObject.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_SceneObject.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_SceneObject.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_SceneObject.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_SceneObject.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 24: CustomAddOn_GraphicObject
----------------------------------------------------------


CustomAddOn_GraphicObject
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_GraphicObject.type
[type: string] 
Type identifier.





CustomAddOn_GraphicObject.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_GraphicObject.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_GraphicObject.owner
[type: GraphicObject] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_GraphicObject.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_GraphicObject.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_GraphicObject.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_GraphicObject.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_GraphicObject.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_GraphicObject.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_GraphicObject.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_GraphicObject.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 25: CustomAddOn_Button
----------------------------------------------------------


CustomAddOn_Button
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_Button.type
[type: string] 
Type identifier.





CustomAddOn_Button.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_Button.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_Button.owner
[type: Button] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_Button.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_Button.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_Button.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_Button.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_Button.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_Button.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_Button.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_Button.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 26: CustomAddOn_TextBox
----------------------------------------------------------


CustomAddOn_TextBox
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_TextBox.type
[type: string] 
Type identifier.





CustomAddOn_TextBox.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_TextBox.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_TextBox.owner
[type: TextBox] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_TextBox.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_TextBox.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_TextBox.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_TextBox.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_TextBox.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_TextBox.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_TextBox.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_TextBox.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 27: CustomAddOn_TextAssembly
----------------------------------------------------------


CustomAddOn_TextAssembly
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_TextAssembly.type
[type: string] 
Type identifier.





CustomAddOn_TextAssembly.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_TextAssembly.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_TextAssembly.owner
[type: TextAssembly] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_TextAssembly.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_TextAssembly.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_TextAssembly.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_TextAssembly.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_TextAssembly.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_TextAssembly.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_TextAssembly.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_TextAssembly.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 28: CustomAddOn_ParticleSystem
----------------------------------------------------------


CustomAddOn_ParticleSystem
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_ParticleSystem.type
[type: string] 
Type identifier.





CustomAddOn_ParticleSystem.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_ParticleSystem.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_ParticleSystem.owner
[type: ParticleSystem] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_ParticleSystem.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_ParticleSystem.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_ParticleSystem.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_ParticleSystem.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_ParticleSystem.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_ParticleSystem.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_ParticleSystem.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_ParticleSystem.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 29: CustomAddOn_Construct
----------------------------------------------------------


CustomAddOn_Construct
[type: class] [NON-INSTANTIABLE] 
CustomAddOns are objects containing modular user-defined functionality that can be added to different types of SceneObjects in the GUI. The type of the particular CustomAddOn determines what type of SceneObject it can be added to. For example, a CustomAddOn_SceneObject can be added to all objects that inherit from SceneObject, while a CustomAddOn_Button can only be added to objects that inherit from Button. To add a CustomAddOn in code, simply create a new instance of the CustomAddOn, passing the owning object as the parameter. To make a CustomAddOn available in the Incisor inspector build a class that extends one of the CustomAddOn types within a 'codeAsset' file, then call 'nc.registerCustomAddOn' in a 'runBeforeInit' block to register the new CustomAddOn type with the GUI. Once a CustomAddOn is added to another object, it can be found in that object's 'customAddOns' member, which is a dictionary of CustomAddOns. 





CustomAddOn_Construct.type
[type: string] 
Type identifier.





CustomAddOn_Construct.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CustomAddOn_Construct.name
[type: string] 
The name of the CustomAddOn - this will automatically be set to match the name of the class definition.





CustomAddOn_Construct.owner
[type: Construct] 
The owner of this CustomAddOn. This is the object that this CustomAddOn is meant to add its functionality to.





CustomAddOn_Construct.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback for when this CustomAddOn is disposed. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.

CustomAddOn_Construct.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_Construct.addDisposalCallback parameter: callbackName
[type: string] 
The name of the callback that occurs when this CustomAddOn is disposed.

CustomAddOn_Construct.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for this callback.





CustomAddOn_Construct.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes a callback for when this CustomAddOn is disposed.

CustomAddOn_Construct.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

CustomAddOn_Construct.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





CustomAddOn_Construct.dispose()
[type: function] 
Removes this CustomAddOn from its owner and performs any registered disposal callbacks. It should be noted that this CustomAddOn will be automatically disposed if the owning object is disposed.










----------------------------------------------------------
Section 30: CustomObjectDefinition
----------------------------------------------------------


CustomObjectDefinition
[type: class] [NON-INSTANTIABLE] 
Object housing information about the CustomObjects currently registered in this project. A 'CustomObject' is any object that inherits from one of the standard hierarchy objects (i.e. SceneObject, GraphicObject, Button, etc...), that is registered with the Incisor inspector using 'nc.registerCustomObject'. Once registered, CustomObjects can be added to Constructs from within the Incisor GUI. CustomObject properties can also be registered with Incisor, making them accessible for monitoring and manipulating from within the inspector. To create a CustomObject, build a class that extends one of the standard Incisor hierarchy object types within a 'codeAsset' file, then call 'nc.registerCustomObject' in a 'runBeforeInit' block to register the new CustomObject type with the GUI. 





CustomObjectDefinition.name
[type: string] 
The name of the CustomObject.





CustomObjectDefinition.baseType
[type: string] 
The the name base type of the given CustomObject definition. Every registered CustomObject must extend one of the allowable CustomObject types (i.e. SceneObject, GraphicObject, etc...), and this value denotes which of those types were extended to create this particular CustomObject.





CustomObjectDefinition.properties
[type: [object]] 
Array of objects that containing information about the registered properties for this CustomObject. Registered properties are accessible for monitoring and manipulating within the inspector. Registered properties can also be flagged as 'persistent', which enables their values to be stored in containing Constructs. To register a property for a CustomObject call 'nc.registerCustomObjectProperty'. If this CustomObject has no registered properties, then this member will be undefined.





CustomObjectDefinition.classDefinition
[type: object] 
The class definition for this CustomObject.










----------------------------------------------------------
Section 31: shapifySwoop
----------------------------------------------------------


shapifySwoop
[type: class] 
The shapify Swoop object - contains the swoopers for this EffectController's components.





shapifySwoop.edgeOffset(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) 'edgeOffset' component from its current value to the given end value over the duration.

shapifySwoop.edgeOffset parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

shapifySwoop.edgeOffset parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

shapifySwoop.edgeOffset parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

shapifySwoop.edgeOffset parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

shapifySwoop.edgeOffset parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

shapifySwoop.edgeOffset parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

shapifySwoop.edgeOffset parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shapifySwoop.edgeOffset parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

shapifySwoop.edgeOffset parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

shapifySwoop.edgeOffset parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





shapifySwoop.edgeFeather(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) 'edgeFeather' component from its current value to the given end value over the duration.

shapifySwoop.edgeFeather parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

shapifySwoop.edgeFeather parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

shapifySwoop.edgeFeather parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

shapifySwoop.edgeFeather parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

shapifySwoop.edgeFeather parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

shapifySwoop.edgeFeather parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

shapifySwoop.edgeFeather parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shapifySwoop.edgeFeather parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

shapifySwoop.edgeFeather parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

shapifySwoop.edgeFeather parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.










----------------------------------------------------------
Section 32: shapifyAddMotion
----------------------------------------------------------


shapifyAddMotion
[type: class] 
The shapify AddMotion object - contains the 'addMotion' functions for this EffectController's components.





shapifyAddMotion.edgeOffset(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the 'edgeOffset' component and returns a Motion object, which can be used to control the motion dynamically.

shapifyAddMotion.edgeOffset parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

shapifyAddMotion.edgeOffset parameter: upperBound
[type: number] 
The upper bound for the motion being added.

shapifyAddMotion.edgeOffset parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

shapifyAddMotion.edgeOffset parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

shapifyAddMotion.edgeOffset parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shapifyAddMotion.edgeOffset parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

shapifyAddMotion.edgeOffset parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

shapifyAddMotion.edgeOffset parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.





shapifyAddMotion.edgeFeather(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the 'edgeFeather' component and returns a Motion object, which can be used to control the motion dynamically.

shapifyAddMotion.edgeFeather parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

shapifyAddMotion.edgeFeather parameter: upperBound
[type: number] 
The upper bound for the motion being added.

shapifyAddMotion.edgeFeather parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

shapifyAddMotion.edgeFeather parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

shapifyAddMotion.edgeFeather parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shapifyAddMotion.edgeFeather parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

shapifyAddMotion.edgeFeather parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

shapifyAddMotion.edgeFeather parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.










----------------------------------------------------------
Section 33: shapify
----------------------------------------------------------


shapify
[type: class] [extends: Vector2] 
The EffectController for the 'Shapify' EffectNode. The Shapify EffectNode converts edge data stored in a 'shapified' Texture into a presentable image with edges that stay sharp regardless of the scale of the associated GraphicObject. This class is a dynamically created EffectController (with base type 'Vector2'), and is therefore non-instantiable. To create a new instance, use "nc.effectControllers['shapify'].new". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





shapify.edgeOffset
[type: number] 
This 'shapify' component determines how far to expand or contract the shape's edge from the position of the edge in the source image. This is a pseudonym for the x vector component.





shapify.edgeFeather
[type: number] 
This 'shapify' component determines the how many pixels the image's edge transition spans. For example, a value of 5 would lead to a soft edge, as the transition from inside the image's shape to outside the shape would take place over 5 pixels. This is a pseudonym for the y vector component.





shapify.swoop
[type: shapifySwoop] 
Object containing the swoopers for this EffectController's components.





shapify.addMotion
[type: shapifyAddMotion] 
Object containing the 'addMotion' functions for this EffectController's components.




























































----------------------------------------------------------
Section 34: shearSwoop
----------------------------------------------------------


shearSwoop
[type: class] 
The shear Swoop object - contains the swoopers for this EffectController's components.





shearSwoop.xAngle(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) 'xAngle' component from its current value to the given end value over the duration.

shearSwoop.xAngle parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

shearSwoop.xAngle parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

shearSwoop.xAngle parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

shearSwoop.xAngle parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

shearSwoop.xAngle parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

shearSwoop.xAngle parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

shearSwoop.xAngle parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearSwoop.xAngle parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

shearSwoop.xAngle parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

shearSwoop.xAngle parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





shearSwoop.yAngle(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) 'yAngle' component from its current value to the given end value over the duration.

shearSwoop.yAngle parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

shearSwoop.yAngle parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

shearSwoop.yAngle parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

shearSwoop.yAngle parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

shearSwoop.yAngle parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

shearSwoop.yAngle parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

shearSwoop.yAngle parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearSwoop.yAngle parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

shearSwoop.yAngle parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

shearSwoop.yAngle parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





shearSwoop.preserveArea(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) 'preserveArea' component from its current value to the given end value over the duration.

shearSwoop.preserveArea parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

shearSwoop.preserveArea parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

shearSwoop.preserveArea parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

shearSwoop.preserveArea parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

shearSwoop.preserveArea parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

shearSwoop.preserveArea parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

shearSwoop.preserveArea parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearSwoop.preserveArea parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

shearSwoop.preserveArea parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

shearSwoop.preserveArea parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.










----------------------------------------------------------
Section 35: shearAddMotion
----------------------------------------------------------


shearAddMotion
[type: class] 
The shear AddMotion object - contains the 'addMotion' functions for this EffectController's components.





shearAddMotion.xAngle(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the 'xAngle' component and returns a Motion object, which can be used to control the motion dynamically.

shearAddMotion.xAngle parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

shearAddMotion.xAngle parameter: upperBound
[type: number] 
The upper bound for the motion being added.

shearAddMotion.xAngle parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

shearAddMotion.xAngle parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

shearAddMotion.xAngle parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearAddMotion.xAngle parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

shearAddMotion.xAngle parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

shearAddMotion.xAngle parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.





shearAddMotion.yAngle(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the 'yAngle' component and returns a Motion object, which can be used to control the motion dynamically.

shearAddMotion.yAngle parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

shearAddMotion.yAngle parameter: upperBound
[type: number] 
The upper bound for the motion being added.

shearAddMotion.yAngle parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

shearAddMotion.yAngle parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

shearAddMotion.yAngle parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearAddMotion.yAngle parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

shearAddMotion.yAngle parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

shearAddMotion.yAngle parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.





shearAddMotion.preserveArea(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the 'preserveArea' component and returns a Motion object, which can be used to control the motion dynamically.

shearAddMotion.preserveArea parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

shearAddMotion.preserveArea parameter: upperBound
[type: number] 
The upper bound for the motion being added.

shearAddMotion.preserveArea parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

shearAddMotion.preserveArea parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

shearAddMotion.preserveArea parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

shearAddMotion.preserveArea parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

shearAddMotion.preserveArea parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

shearAddMotion.preserveArea parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.










----------------------------------------------------------
Section 36: shear
----------------------------------------------------------


shear
[type: class] [extends: Vector3] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. This class is a dynamically created EffectController (with base type 'Vector3'), and is therefore non-instantiable. To create a new instance, use "nc.effectControllers['shear'].new". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





shear.xAngle
[type: number] 
The amount in degrees to rotate the X axis. This is a pseudonym for the x vector component.





shear.yAngle
[type: number] 
The amount in degrees to rotate the Y axis. This is a pseudonym for the y vector component.





shear.preserveArea
[type: number] 
How much to preserve the original area. 1 preserves area exactly. 0 allows the area to approach 0 as the axes approach each other. This is a pseudonym for the z vector component.





shear.swoop
[type: shearSwoop] 
Object containing the swoopers for this EffectController's components.





shear.addMotion
[type: shearAddMotion] 
Object containing the 'addMotion' functions for this EffectController's components.

































































----------------------------------------------------------
Section 37: EffectControllerDefinition
----------------------------------------------------------


EffectControllerDefinition
[type: class] [NON-INSTANTIABLE] 
Object housing the info about a particular EffectController. EffectControllers provide the ability to dynamically control EffectNodes and their resulting visual effects. EffectControllers are generally one of 3 base types, Vectors, numbers, and Textures. Once defined, EffectControllers will be generally available on all SceneObjects, Materials, MaterialMaster, CharacterMaterial objects; It should be noted that while these objects will have all EffectControllers as members, only the EffectControllers tied to the objects' current EffectNodes will cause any change visually. It should also be noted EffectControllers with 'mixMode=materialOnly' will not be available on SceneObjects for inheritance, and will instead only be on Material and MaterialMaster objects for direct manipulation. 





EffectControllerDefinition.name
[type: string] 
The name of the EffectController





EffectControllerDefinition.baseType
[type: string] 
The base type of the EffectController





EffectControllerDefinition.componentNames
[type: [string], string] 
The names of the components of this EffectController.





EffectControllerDefinition.defaultValues
[type: [number], number] 
The default component values for this EffectController.





EffectControllerDefinition.mixMode
[type: string] 
The mixMode for this EffectController. Mix modes determined the manner in which the values of EffectControllers are transfered to descendants in the hierarchy. So if the "multiplication" mixMode is chosen, a SceneObject's values for the given EffectController multiply the values of all of its descendants. The "materialOnly" mixMode indicates that a given EffectController will only be on Materials (not parent SceneObjects), so no mixing of EffectController value occurs.





EffectControllerDefinition.likelyRanges
[type: [[number]]] 
An array of likely ranges (each is an array of numbers) for the component values of this EffectController. These likely ranges help to inform the 'scrollSpeed' of GUI controllers for this EffectController - if the likely range is much larger, than the scroll speeds default to be higher etc...





EffectControllerDefinition.effectControllerDescription
[type: string] 
The description of the EffectController. This will inform the descriptions as they appear in the autocomplete for this project.





EffectControllerDefinition.componentDescriptions
[type: [string]] 
The description of the components of this EffectController. These descriptions will inform the component descriptions as they appear in the autocomplete for this project.










----------------------------------------------------------
Section 38: EffectNode
----------------------------------------------------------


EffectNode
[type: class] [NON-INSTANTIABLE] 
EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time. Ultimately, the EffectNodes on any given Material are compiled and determine the final GLSL code that comprises the associated shader for WebGL to use when rendering the associated surface. 





EffectNode.type
[type: string] 
Type identifier





EffectNode.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





EffectNode.name
[type: string] 
The EffectContoller's name. This must be unique among EffectControllers.





EffectNode.vertexNodeSupport
[type: [string], string] 
The portion of the GLSL shader code for this EffectNode above the 'vertex main'. This segment of code is where uniform and varying variables for the vertex portion of this effect are likely to be declared. Support components between EffectNodes are consolidated, so if a segment of code will be used in more than on EffectNode, be sure to provide it as its own distinct array entry in each EffectNode.





EffectNode.vertexNode
[type: string] 
The portion of the GLSL shader code for this EffectNode within the 'vertex main'. This segment of code is where this effect can make its adjustments to the 'vertex' vec3.





EffectNode.fragmentNodeSupport
[type: [string], string] 
The portion of the GLSL shader code for this EffectNode above the 'fragment main'. This segment of code is where uniform and varying variables for the fragment portion of this effect are likely to be declared. Support components between EffectNodes are consolidated, so if a segment of code will be used in more than on EffectNode, be sure to provide it as its own distinct array entry in each EffectNode.





EffectNode.fragmentNode
[type: string] 
The portion of the GLSL shader code for this EffectNode within the 'fragment main'. This segment of code is where this effect can make its adjustments to the 'fragment' vec4.





EffectNode.requiresDerivativesShaderExtension
[type: boolean] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'Derivatives' extension.





EffectNode.requiresFragDepthShaderExtension
[type: boolean] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'FragDepth' extension.





EffectNode.requiresDrawBuffersShaderExtension
[type: boolean] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'DrawBuffers' extension.





EffectNode.requiresTextureLODShaderExtension
[type: boolean] 
Boolean determining if the shader of any Material with this EffectNode is compiled to support the 'TextureLOD' extension.





EffectNode.getAssociatedEffectControllers()
[type: function] [returns: [string]] 
Returns the list of EffectControllers that are associated with this EffectNode.





EffectNode.setAssociatedEffectControllers(effectControllers)
[type: function] 
Updates the list of EffectControllers associated with this EffectNode.

EffectNode.setAssociatedEffectControllers parameter: effectControllers
[type: [string]] 
An array of the EffectControllers that this EffectNode is associated with. The associated EffectControllers will be the means of dynamic manipulation for this EffectNode's visual effects. See 'nc.effectControllers' for a list of available EffectControllers.










----------------------------------------------------------
Section 39: IncisorExtensions
----------------------------------------------------------


IncisorExtensions
[type: class] [extends: INCISOR] [NON-INSTANTIABLE] [requires: unpublished only, license - extensions, extensions scope] 
Object housing all of the Incisor Extensions functionality. In general, this object has much of the same functionality as nc/INCISOR and is therefore documented as extending that object but not all of the same functionality is available through this object, so auto-complete may show some non-existent members. This object is accessible in the 'CODE.runBeforeInit' block of the extensions scope by the instance name 'nce'. 





IncisorExtensions.incisorExtensions_global
[type: object] 
The global incisor extensions object. This corresponds to the scope of the javascript code placed in the "Global Extensions" folder in the "Application Support" directory (which can be accessed from the Incisor menu). It should be noted that the global extensions scope is initialized before the project extensions scope, and as such 'nce.incisorExtensions_project' member will likely be undefined from within the global scope on init. Once project extensions are loaded the 'nce.incisorExtensions_project' member is initialized.





IncisorExtensions.incisorExtensions_project
[type: object] 
The project extensions object. This corresponds to the scope of the javascript code placed in the "ProjectExtensions" folder in the "Utilities" directory of the given project. It should be noted that the global extensions scope is initialized before the project extensions scope, and as such 'nce.incisorExtensions_project' member will likely be undefined from within the global scope on init. Once project extensions are loaded the 'nce.incisorExtensions_project' member is initialized.





IncisorExtensions.projectNC
[type: INCISOR] 
A reference to the 'nc' object (INCISOR) inside of the target project. Please note that this value can be undefined, when the project is loading or if the project code has a runtime or syntax error. See also 'nce.addProjectConnectionCallback' and 'nce.addProjectDisconnectionCallback' for the associated callbacks.





IncisorExtensions.projectPR
[type: ProjectMain] 
A reference to the 'pr' object (ProjectMain) inside of the target project. Please note that this value can be undefined, when the project is loading or if the project code has a runtime or syntax error. See also 'nce.addProjectConnectionCallback' and 'nce.addProjectDisconnectionCallback' for the associated callbacks.





IncisorExtensions.addInspectorMenuItem(menuPath, callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds menu item to the menus along the top of the Incisor inspector, and registers a callback function (from within the Incisor extensions scope) that will be triggered whenever that menu item is selected. It should be noted that custom inspector menu items cannot be added to built-in Incisor menus.

IncisorExtensions.addInspectorMenuItem parameter: menuPath
[type: [string]] 
An array of menu item names, where the first name is the name of the root custom menu. For example ["MyMenu","MySubMenu","MyTargetMenuItem"], would create a 'MyMenu' menu in the inspector, with sub-menu 'SubMenu', which would hold the 'MyTargetMenuItem' option that triggers the desired callback.

IncisorExtensions.addInspectorMenuItem parameter: callbackOwner
[type: object] 
The object (from within the given IncisorExtensions context) that owns the callback function.

IncisorExtensions.addInspectorMenuItem parameter: callbackName
[type: string] 
The name of the callback function.

IncisorExtensions.addInspectorMenuItem parameter: callbackArgs
[type: Array] [optional] 
A list of parameters that will be sent to the callback function.





IncisorExtensions.registerInspectorPanelDefinition(name, classDefinition)
[type: function] 
Registers a custom InspectorPanel type with the Incisor GUI, enabling users to select this newly defined panel as an option from within the Inspector.

IncisorExtensions.registerInspectorPanelDefinition parameter: name
[type: string] 
The name of the InspectorPanel - this name should match (exactly) the name given to the InspectorPanel constructor 'panelTypeName' param. This is the name that will appear in the panel type selection drop down in the GUI.

IncisorExtensions.registerInspectorPanelDefinition parameter: classDefinition
[type: object] 
The class Definition for the new InspectorPanel type. The class definition provided for this parameter should extend 'InspectorPanel'





IncisorExtensions.saveProjectScreenShot(path, isPathRelative)
[type: function] [returns: string] 
Saves a screen shot of the project and returns the path of the screenshot.

IncisorExtensions.saveProjectScreenShot parameter: path
[type: string] 
The path to the screenshot. If left undefined, the 'screenShotDestination' value in the ProjectSettings is used.

IncisorExtensions.saveProjectScreenShot parameter: isPathRelative
[type: boolean] 
Boolean determining if the screen shot's path is relative to the project.





IncisorExtensions.saveInspectorScreenShot(path, isPathRelative)
[type: function] [returns: string] [requires: module - pixelsObjects] 
Saves a screen shot of the entire inspector and returns the path of the screenshot.

IncisorExtensions.saveInspectorScreenShot parameter: path
[type: string] 
The path to the screenshot. If left undefined, the 'screenShotDestination' value in the ProjectSettings is used.

IncisorExtensions.saveInspectorScreenShot parameter: isPathRelative
[type: boolean] 
Boolean determining if the screen shot's path is relative to the project.





IncisorExtensions.alert(popupTitleText, popupBodyText)
[type: function] 
Displays a standardized UiPopupWindow with the given title and body text populated. This method is asyncronously awaitable in the event the given alert needs to be shown before code excution continues.

IncisorExtensions.alert parameter: popupTitleText
[type: string] 
The text displayed in the title bar of the UiPopupWindow.

IncisorExtensions.alert parameter: popupBodyText
[type: string] 
The text displayed in the body of the UiPopupWindow.





IncisorExtensions.showYesNoQueryPopup(popupTitleText, popupBodyText)
[type: function] [returns: string] 
Displays a standardized UiPopupWindow that will return a Yes/No string based on which decision button the user presses. This method is asyncronously awaitable in the event the given popup to be shown before code excution continues.

IncisorExtensions.showYesNoQueryPopup parameter: popupTitleText
[type: string] 
The text displayed in the title bar of the UiPopupWindow.

IncisorExtensions.showYesNoQueryPopup parameter: popupBodyText
[type: string] 
The text displayed in the body of the UiPopupWindow.





IncisorExtensions.showTextQueryPopup(popupTitleText, popupBodyText, textFieldLabel, defaultResponse)
[type: function] [returns: string] 
Displays a standardized UiPopupWindow that will return a user-populated string based on what the user enters in a UiTextField. This method is asyncronously awaitable in the event the given popup to be shown before code excution continues.

IncisorExtensions.showTextQueryPopup parameter: popupTitleText
[type: string] 
The text displayed in the title bar of the UiPopupWindow.

IncisorExtensions.showTextQueryPopup parameter: popupBodyText
[type: string] 
The text displayed in the body of the UiPopupWindow.

IncisorExtensions.showTextQueryPopup parameter: textFieldLabel
[type: string] 
The label text for the UiTextField user-prompt.

IncisorExtensions.showTextQueryPopup parameter: defaultResponse
[type: string] 
The text value pre-populated in the UiTextField user-prompt.





IncisorExtensions.showPathQueryPopup(popupTitleText, popupBodyText, root, showFiles, selectableFiles, allowMultiSelect, rootSelectorActive)
[type: function] [returns: string] 
Displays a standardized UiPopupWindow that displays a FileBrowser and returns the user's selection. This method is asyncronously awaitable in the event the given popup to be shown before code excution continues.

IncisorExtensions.showPathQueryPopup parameter: popupTitleText
[type: string] 
The text displayed in the title bar of the UiPopupWindow.

IncisorExtensions.showPathQueryPopup parameter: popupBodyText
[type: string] 
The text displayed in the body of the UiPopupWindow.

IncisorExtensions.showPathQueryPopup parameter: root
[type: string] 
The root directory to show in the FileBrowser.

IncisorExtensions.showPathQueryPopup parameter: showFiles
[type: boolean] 
Flag determining if files are shown in the FileBrowser.

IncisorExtensions.showPathQueryPopup parameter: selectableFiles
[type: boolean] 
Flag determining if files are able to be selected in the FileBrowser.

IncisorExtensions.showPathQueryPopup parameter: allowMultiSelect
[type: boolean] 
Flag determining if multiple items can be selected at once in the FileBrowser.

IncisorExtensions.showPathQueryPopup parameter: rootSelectorActive
[type: boolean] 
Flag determining if the user can change the root directory of the FileBrowser.





IncisorExtensions.addProjectConnectionCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback for when the Inspector connects to the project.

IncisorExtensions.addProjectConnectionCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.addProjectConnectionCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.removeProjectConnectionCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

IncisorExtensions.removeProjectConnectionCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.removeProjectConnectionCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.addProjectDisconnectionCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback for when the Inspector disconnects from the project.

IncisorExtensions.addProjectDisconnectionCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.addProjectDisconnectionCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.removeProjectDisconnectionCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

IncisorExtensions.removeProjectDisconnectionCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.removeProjectDisconnectionCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.showProgressBar(name, progress, note)
[type: function] 
Displays a progress bar in the Incisor inspector.

IncisorExtensions.showProgressBar parameter: name
[type: string] 
The name of the task associated with this progress bar.

IncisorExtensions.showProgressBar parameter: progress
[type: number] 
Progress, as indicated by a number from 0 to 1. Call this function with a value of 1 to clear the progress bar.

IncisorExtensions.showProgressBar parameter: note
[type: string] 
An optional secondary note that can change as the progress us update.





IncisorExtensions.addPrePublishCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback that occurs directly before the publishing of the project. A PrePublishInfoObject is passed to the callbacks as the first parameter.

IncisorExtensions.addPrePublishCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.addPrePublishCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.removePrePublishCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

IncisorExtensions.removePrePublishCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.removePrePublishCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.addPostPublishCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback that occurs directly after the publishing of the project. A PostPublishInfoObject with name of the configuration, the publishing timestamp, the destination directory, and the hosted port (if applicable) is passed to the callbacks as the first parameter.

IncisorExtensions.addPostPublishCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.addPostPublishCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.removePostPublishCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

IncisorExtensions.removePostPublishCallback parameter: callbackOwner
[type: object] 
The object that owns the callback function.

IncisorExtensions.removePostPublishCallback parameter: callbackName
[type: string] 
The name of the callback function.





IncisorExtensions.addFileBrowser(parent, name, root, useRelativePaths, singularFocusTarget)
[type: function] [returns: FileBrowser] 
Adds a FileBrowser to the specified parent. A FileBrowser is a specialized LayoutStack with functionality which makes it an ineractive inspector for the OS file system. This class is meant for use in tool development within extensions, and provides a visual means for developers locate and manipulate directories and files. FileBrowsers can only be added to descendants of the 'bodyStack' of a ScrollingPanel.

IncisorExtensions.addFileBrowser parameter: parent
[type: SceneObject] 
The parent to add the FileBrowser to.

IncisorExtensions.addFileBrowser parameter: name
[type: string] 
The name of the new FileBrowser.

IncisorExtensions.addFileBrowser parameter: root
[type: string] [default: nce.paths.desktopPath] [optional] 
The root directory for the FileBrowser.

IncisorExtensions.addFileBrowser parameter: useRelativePaths
[type: boolean] [default: false] [optional] 
Boolean indicating if the paths displayed in the FileBrowser will be relative to the Project.

IncisorExtensions.addFileBrowser parameter: singularFocusTarget
[type: SceneObject] [default: undefined] [optional] 
The SceneObject that must be focused in order for this FileBrowser's keyboard functionality to be active.





IncisorExtensions.runProcess(processExecutable, args, directory)
[type: function] [returns: ProcessResult] 
Runs a provided external executable with the given arguments, returning a ProcessResult object with any ouput from the executable. This functionality is meant to run a given process in a 'one-shot' manner, performing a single setup and sending a single set of arguments to the executable, immediately closing the standard-in stream, and reading both the standard-out and standard-error streams. It should be noted that the "allowExternalExecutableProcesses" setting in ApplicationSettings must be set to true to use this method. Be aware of the risks you are assuming by using this functionality.

IncisorExtensions.runProcess parameter: processExecutable
[type: string] 
The absolute path to the external executable to be run.

IncisorExtensions.runProcess parameter: args
[type: string] [default: ""] [optional] 
The arguments to send to the given executable process.

IncisorExtensions.runProcess parameter: directory
[type: string] [default: ""] [optional] 
The 'working directory' for the executable process.





IncisorExtensions.reloadProject()
[type: function] 
Reloads the project, keeping the current instance of the inspector running. Calling this function is the equivalent of pressing the refresh button in the upper left corner of the 'Live View' panel.





IncisorExtensions.runCmd(command, directory, processConfigs)
[type: function] [returns: ProcessResult] 
Runs the given command within the Windows command prompt, returning a ProcessResult object with the related output. This functionality is meant to run a given command in a 'one-shot' manner, performing a single command, immediately closing the standard-in stream, and reading both the standard-out and standard-error streams. It should be noted that the "allowExternalExecutableProcesses" setting in ApplicationSettings must be set to true to use this method. Be aware of the risks you are assuming by using this functionality.

IncisorExtensions.runCmd parameter: command
[type: string] [default: ""] [optional] 
The command to send to the Windows command prompt.

IncisorExtensions.runCmd parameter: directory
[type: string] [default: ""] [optional] 
The 'working directory' for the executable process.

IncisorExtensions.runCmd parameter: processConfigs
[type: ProcessConfiguration] [default: undefined] [optional] 
Object containing configurations for how the process will be run.





IncisorExtensions.runBash(command, directory, processConfigs)
[type: function] [returns: ProcessResult] 
Runs the given bash command, returning a ProcessResult object with the related output. This functionality is meant to run a given command in a 'one-shot' manner, performing a single command, immediately closing the standard-in stream, and reading both the standard-out and standard-error streams. It should be noted that the "allowExternalExecutableProcesses" setting in ApplicationSettings must be set to true to use this method. Be aware of the risks you are assuming by using this functionality.

IncisorExtensions.runBash parameter: command
[type: string] [default: ""] [optional] 
The command to send to 'bash'.

IncisorExtensions.runBash parameter: directory
[type: string] [default: ""] [optional] 
The 'working directory' for the executable process.

IncisorExtensions.runBash parameter: processConfigs
[type: ProcessConfiguration] [default: undefined] [optional] 
Object containing configurations for how the process will be run.






































































































































































































































































































































































































































































































































































































































































































































































































































































































----------------------------------------------------------
Section 40: ProcessResult
----------------------------------------------------------


ProcessResult
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - extensions, extensions scope] 
Object containing information about the running of an executable via 'nce.runProcess'. 





ProcessResult.stdOut
[type: string] 
The standard output from the given executable process.





ProcessResult.stdErr
[type: string] 
The standard error from the given executable process.





ProcessResult.exception
[type: string] 
If there is an exception while attempting to run the given executable process, it will be populated in this value.










----------------------------------------------------------
Section 41: InspectorPanel
----------------------------------------------------------


InspectorPanel
[type: class] [requires: unpublished only, license - extensions, extensions scope] 
Object defining an inspector panel within the Incisor GUI. Custom panels can be defined and registered in Incisor extensions code placed in the 'Utilities/ProjectExtensions' directory within the project, or within the 'Global Extensions' directory in the application support directory (available from within the Incisor menu). To make a custom panel, define a class that extends this class, populating the 'headerScrollingPanel' and 'bodyScrollingPanel' members with the desired custom content. Then call 'nce.registerInspectorPanelDefinition' with the newly defined class as a parameter and the new panel should appear in the panel options menu.





InspectorPanel.type
[type: string] 
The type indicator for this object.





InspectorPanel.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





InspectorPanel.headerScrollingPanel
[type: ScrollingPanel] 
The ScrollingPanel that contains the header content for this InspectorPanel. This, and 'bodyScrollingPanel' are where the majority of the customization for user-defined panels take place. This will be undefined if the InspectorPanel is instantiated with 'includeBodyScrollingPanel=false'





InspectorPanel.bodyScrollingPanel
[type: ScrollingPanel] 
The ScrollingPanel that contains the body content for this InspectorPanel. This, and 'headerScrollingPanel' are where the majority of the customization for user-defined panels take place. This will be undefined if the InspectorPanel is instantiated with 'includeHeaderScrollingPanel=false'





InspectorPanel.panelWidth
[type: number] 
The current width of the InspectorPanel.





InspectorPanel.panelHeight
[type: number] 
The current height of the InspectorPanel.





InspectorPanel.headerScrollingPanelCoreHeight
[type: number] 
The core height of the headerScrollingPanel (before uiZoom is applied).





InspectorPanel.headerScrollingPanelHeight
[type: number] 
The current height of this InspectorPanel's headerScrollingPanel, with uiZoom factored in.





InspectorPanel.inspectorPanelUid
[type: number] 
The unique identifier for this InspectorPanel.





InspectorPanel.menubarHeight
[type: number] 
The current height of this InspectorPanel's menu bar.





InspectorPanel.panelType
[type: string] 
The name of the panel type. This is the name that will appear within the panel options drop down menu.





InspectorPanel.subPanels
[type: Array] 
Array containing the subPanels of this InspectorPanel. For standard 'content' panels, this array will be be empty, as subpanels are only present in InspectorPanels that are strictly 'container' panels.





InspectorPanel.divisionLocation
[type: number] [default: 0.5] 
Value used by 'container' panels to determine the proportion of its area that each subPanel will occupy. For standard 'content' panels this value is unused.





InspectorPanel.isColumns
[type: boolean] [default: {true}] 
Boolean value used by 'container' panels to determine if its subPanels are side-by-side or top-and-bottom. For standard 'content' panels this value is unused.





InspectorPanel.dividerButton
[type: Button] 
Button used by 'container' panels that allow the user to change the 'divisionLocation' value. For standard 'content' panels this member is undefined.





InspectorPanel.borderLeft
[type: GraphicObject] 
The GraphicObject that serves as the left border of this InspectorPanel.





InspectorPanel.borderRight
[type: GraphicObject] 
The GraphicObject that serves as the right border of this InspectorPanel.





InspectorPanel.borderTop
[type: GraphicObject] 
The GraphicObject that serves as the top border of this InspectorPanel.





InspectorPanel.borderBottom
[type: GraphicObject] 
The GraphicObject that serves as the bottom border of this InspectorPanel.





InspectorPanel.leftMenuStack
[type: LayoutStack] 
The horizontal LayoutStack on the left side of the InspectorPanel's menu bar. This LayoutStack contains the panel type selection UiDropDownMenu.





InspectorPanel.panelTypeMenu
[type: UiDropDownMenu] 
The drop down mene containing all of the panel type options. This menu is what is used by the users to select different panels.





InspectorPanel.rightMenuStack
[type: LayoutStack] 
The horizontal LayoutStack on the right side of the InspectorPanel's menu bar. This LayoutStack contains the '+' button and the 'x' button.





InspectorPanel.plusButton
[type: UiGraphicButton] 
The UiGraphicButton serving as the '+' button on the righthand side of the InspectorPanel's menu bar. Users use this button to add subPanels to this InspectorPanel.





InspectorPanel.exButton
[type: UiGraphicButton] 
The UiGraphicButton serving as the 'x' button on the righthand side of the InspectorPanel's menu bar. Users use this button to close this InspectorPanel.





InspectorPanel.menuBarBackground
[type: UiPanel, Button] 
The UiPanel/Button that serves as the background for this InspectorPanel's menu bar.





InspectorPanel.panelMaskGraphic
[type: Button] 
This Button serves as a mask for the 'panelTypeMenu', 'plusButton', and 'exButton', ensuring that those items don't extend outside of the menu bar  regardless of the uiZoom and size/aspect-ratio of the InspectorPanel.





InspectorPanel.rolloverButton
[type: Button] 
The Button responsible for setting the 'nc.singularFocusObject' to each InspectorPanel as the user's cursor moves over it (via 'addCursorInCallback').





InspectorPanel.quadrantButtonContainer
[type: SceneObject] 
SceneObject containing the 'quadrantButtons', which are the Buttons that enable the user to select the top, bottom, left, or right portionm of the InspectorPanel.





InspectorPanel.quadrantButtonLeft
[type: UiPanel, Button] 
The 'quadrantButton' that enables the user to select the left portion of this InspectorPanel.





InspectorPanel.quadrantButtonRight
[type: UiPanel, Button] 
The 'quadrantButton' that enables the user to select the right portion of this InspectorPanel.





InspectorPanel.quadrantButtonTop
[type: UiPanel, Button] 
The 'quadrantButton' that enables the user to select the top portion of this InspectorPanel.





InspectorPanel.quadrantButtonBottom
[type: UiPanel, Button] 
The 'quadrantButton' that enables the user to select the bottom portion of this InspectorPanel.





InspectorPanel.headerDivider
[type: GraphicObject] 
A thin line between the headerScrollingPanel and bodyScrollingPanel





InspectorPanel.addResizeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever the InspectorPanel is resized.

InspectorPanel.addResizeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

InspectorPanel.addResizeCallback parameter: callbackName
[type: string] 
The name of the callback function.

InspectorPanel.addResizeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the callback function.





InspectorPanel.removeResizeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback for when the InspectorPanel is resized.

InspectorPanel.removeResizeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

InspectorPanel.removeResizeCallback parameter: callbackName
[type: string] 
The name of the callback function.










----------------------------------------------------------
Section 42: FileBrowser
----------------------------------------------------------


FileBrowser
[type: class] [extends: LayoutStack] [NON-INSTANTIABLE] [requires: unpublished only, license - extensions, extensions scope] 
A FileBrowser is a specialized LayoutStack with functionality which makes it an ineractive inspector for the OS file system. This class is meant for use in tool development within extensions, and provides a visual means for developers locate and manipulate directories and files. FileBrowsers must be located within the 'bodyStack' of a ScrollingPanel. Call nce.addFileBrowser to make a new FileBrowser. 





FileBrowser.root
[type: string] [default: nc.paths.desktopPath] 
The path of the root directory of of the FileBrowser. The contents of the root directory are the 'topmost' items shown in this FileBrowser.





FileBrowser.showHiddenItems
[type: boolean] [default: true] 
Flag determining if hidden items are shown in the FileBrowser.





FileBrowser.selectableHiddenItems
[type: boolean] [default: true] 
Flag determining if hidden items are selectable within the FileBrowser.





FileBrowser.showFiles
[type: boolean] [default: true] 
Flag determining if files are shown in the FileBrowser. If false, the FileBrowser will only display directories.





FileBrowser.selectableFiles
[type: boolean] [default: true] 
Flag determining if files are selectable within the FileBrowser. If false, only directories will be selectable in the FileBrowser.





FileBrowser.allowRearrange
[type: boolean] [default: true] 
Flag determining if files and directories can be rearranged via dragging and dropping.





FileBrowser.allowMultiSelect
[type: boolean] [default: true] 
Flag determining if more than one path can be selected at once.





FileBrowser.overrideList
[type: [PathInfo]] [default: udefined] 
An array of PathInfos can be provided to have the FileBrowser show a specific group of files in a flat list. This can be used in conjunction with a UiTextField to provide a search field for the FileBrowser. Set this property to undefined to return to normal





FileBrowser.addFilterCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback function that is invoked when directory contents are displayed. An array of PathInfos are sent to each callback as the first parameter, and this list can be edited by the receiving callback as a means to apply specific filtering rules for what is displayed in this FileBrowser.

FileBrowser.addFilterCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.addFilterCallback parameter: callbackName
[type: number] 
The name of the callback function.

FileBrowser.addFilterCallback parameter: callbackArgs
[type: number] [optional] 
Arguments for the callback function.





FileBrowser.removeFilterCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

FileBrowser.removeFilterCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.removeFilterCallback parameter: callbackName
[type: number] 
The name of the callback function.





FileBrowser.addFileSystemChangeCallback(callbackOwner, callbackName, callbackArgs, callbackBeforeChange)
[type: function] 
Adds a callback function that is invoked when the FileBrowser initiates a file system change. For example if 'allowRearrange' is true, and a file is dragged to a new directory, then these callbacks will be invoked. The type of the file system change, and an array of the associated paramters are sent to the callbacks as the first two parameters.

FileBrowser.addFileSystemChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.addFileSystemChangeCallback parameter: callbackName
[type: number] 
The name of the callback function.

FileBrowser.addFileSystemChangeCallback parameter: callbackArgs
[type: number] [optional] 
Arguments for the callback function.

FileBrowser.addFileSystemChangeCallback parameter: callbackBeforeChange
[type: boolean] [default: true] [optional] 
Boolean determining if the given callback will be called before or after the change event.





FileBrowser.removeFileSystemChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

FileBrowser.removeFileSystemChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.removeFileSystemChangeCallback parameter: callbackName
[type: number] 
The name of the callback function.





FileBrowser.addSelectionChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback function that is invoked when there is a change to the files/directories that are currently selected in this FileBrowser.

FileBrowser.addSelectionChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.addSelectionChangeCallback parameter: callbackName
[type: number] 
The name of the callback function.

FileBrowser.addSelectionChangeCallback parameter: callbackArgs
[type: number] [optional] 
Arguments for the callback function.





FileBrowser.removeSelectionChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

FileBrowser.removeSelectionChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

FileBrowser.removeSelectionChangeCallback parameter: callbackName
[type: number] 
The name of the callback function.





FileBrowser.getCurrentSelection()
[type: function] [returns: [PathInfo]] 
Returns a list of the currently selected items for this FileBrowser.





FileBrowser.openToPath(path, openPathProvided)
[type: function] 
Instructs the FileBrowser to open all of the containing directories of the given path so that it is visible.

FileBrowser.openToPath parameter: path
[type: string] 
The path to open to.

FileBrowser.openToPath parameter: openPathProvided
[type: boolean] [default: false] [optional] 
Boolean determining if the given path itself should also be open (assumning it is a directory)





FileBrowser.refresh()
[type: function] 
Refreshes the FileBrowser, causing it to reflect any changes made since it was last refreshed.






































































































































































































































































































































































































----------------------------------------------------------
Section 43: PrePublishInfoObject
----------------------------------------------------------


PrePublishInfoObject
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - extensions, extensions scope] 
Object containing pre-publish information. 





PrePublishInfoObject.configurationName
[type: string] 
The name of the configuration to use when publishing.





PrePublishInfoObject.proceedWithPublishing
[type: boolean] [default: true] 
Boolean indicating whether or not to proceed with publishing. To cancel the publishing process, set this value to false.





PrePublishInfoObject.hostPublishedProject
[type: boolean] 
Boolean indicating whether the published project will be automatically hosted.










----------------------------------------------------------
Section 44: PostPublishInfoObject
----------------------------------------------------------


PostPublishInfoObject
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - extensions, extensions scope] 
Object containing post-publish information. 





PostPublishInfoObject.configurationName
[type: string] 
The name of the configuration to use when publishing.





PostPublishInfoObject.publishTimeStamp
[type: string] 
The time stamp of the published project.





PostPublishInfoObject.hostedPort
[type: string] 
The port that the newly published project is being hosted on (if applicable).





PostPublishInfoObject.destinationDirectory
[type: string] 
The relative path for the directory of the newly published project.










----------------------------------------------------------
Section 45: ProcessConfiguration
----------------------------------------------------------


ProcessConfiguration
[type: class] [requires: unpublished only, license - extensions, extensions scope] 
Object containing configurations for how a process will run during nce.runProcess, nce.runCmd, or nce.runBash.





ProcessConfiguration.createNoWindow
[type: boolean] [default: true] 
Determines if the new process will create a new window.





ProcessConfiguration.redirectStandardInput
[type: boolean] [default: true] 
Determines if 'StandardInput' will be redirected for the given process.





ProcessConfiguration.redirectStandardOutput
[type: boolean] [default: true] 
Determines if 'StandardOutput' will be redirected for the given process. If true, the standard out contents will be returned as part of the ProcessResult object returned.





ProcessConfiguration.redirectStandardError
[type: boolean] [default: true] 
Determines if 'StandardError' will be redirected for the given process. If true, the standard error contents will be returned as part of the ProcessResult object returned.





ProcessConfiguration.closeStandardInputImmediately
[type: boolean] [default: true] 
Determines if the 'StandardInput' stream for the given process will be immediately closed. This is sometimes necessary in order to prevent the process from locking up Incisor due to it waiting for input that's never coming. If true, the standard error contents will be returned as part of the ProcessResult object returned.





ProcessConfiguration.useShellExecute
[type: boolean] [default: false] 
Determines if the given process will use ShellExecute.





ProcessConfiguration.waitForExit
[type: boolean] [default: false] 
Determines if Incisor will wait for the process to exit before moving on.










----------------------------------------------------------
Section 46: FileIO
----------------------------------------------------------


FileIO
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - fileIO] 
Object housing functionality to perform file IO tasks such as 'writeTextFile', 'moveTo', 'createDirectory' an more.





FileIO.fileExists(filePath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject with a '.payload' bool stating if the file at the given path exists. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.fileExists parameter: filePath
[type: string] 
This is the relative or absolute path to the file in question.

FileIO.fileExists parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.readTextFile(filePath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject with a '.payload' string containing the contents of the text file at the given path. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.readTextFile parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

FileIO.readTextFile parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.readFileBase64(filePath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject with a '.payload' string containing the contents of the file at the given path in Base64 format. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.readFileBase64 parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

FileIO.readFileBase64 parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.rename(path, newName, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Renames the file or folder at the given path. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.rename parameter: path
[type: string] 
The relative or absolute path to the file in question.

FileIO.rename parameter: newName
[type: string] 
The new name (not including the path) of the item you wish to rename.

FileIO.rename parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.writeTextFile(filePath, fileContent, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Writes text content to a file at the given path. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.writeTextFile parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

FileIO.writeTextFile parameter: fileContent
[type: string] [default: ""] [optional] 
This is the text content that will be written in the file.

FileIO.writeTextFile parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.writeFileFromBase64(filePath, base64, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Writes a file from a base64 string. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.writeFileFromBase64 parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

FileIO.writeFileFromBase64 parameter: base64
[type: string] 
The source base64 string to write the file from.

FileIO.writeFileFromBase64 parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.appendTextFile(filePath, additionalContent, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Appends text content to the text file at the given file path. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.appendTextFile parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

FileIO.appendTextFile parameter: additionalContent
[type: string] 
This is the text content that will be written in the file.

FileIO.appendTextFile parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.directoryExists(directoryPath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject with a '.payload' bool stating if the directory at the given path exists. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.directoryExists parameter: directoryPath
[type: string] 
This is the relative or absolute path to the directory in question.

FileIO.directoryExists parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.getDirectoryContents(directoryPath, isPathRelative, recurseSubdirectories, includeHiddenFiles)
[type: function] [returns: [PathInfo]] 
Returns an IncrCommsResponseObject with a '.payload' array containing the paths to the directories and files within the given directory. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.getDirectoryContents parameter: directoryPath
[type: string] 
This is the relative or absolute path to the directory in question.

FileIO.getDirectoryContents parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

FileIO.getDirectoryContents parameter: recurseSubdirectories
[type: boolean] [default: false] [optional] 
Bool stating if list of paths returned should include all sub-directories.

FileIO.getDirectoryContents parameter: includeHiddenFiles
[type: boolean] [default: false] [optional] 
Bool stating if list of paths returned should include hidden files.





FileIO.createDirectory(directoryPath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject with a '.payload' string containing the contents of the text file at the given path. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.createDirectory parameter: directoryPath
[type: string] 
The relative or absolute path to the directory in question.

FileIO.createDirectory parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.copyTo(sourcePath, destinationPath, isPathRelative, newName)
[type: function] [returns: IncrCommsResponseObject] 
Copies the provided file or directory into the designated directory, with an option to rename the item while copying. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.copyTo parameter: sourcePath
[type: string] 
The relative or absolute path to the source item.

FileIO.copyTo parameter: destinationPath
[type: string] 
The relative or absolute path for the destination directory.

FileIO.copyTo parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

FileIO.copyTo parameter: newName
[type: string] [default: ""] [optional] 
The new name (not including the path) of the item you wish to rename. If "" is provided, then no rename occurs.





FileIO.moveTo(sourcePath, destinationPath, isPathRelative, newName)
[type: function] [returns: IncrCommsResponseObject] 
Moves the provided file or directory into the designated directory, with an option to rename the item while moving. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.moveTo parameter: sourcePath
[type: string] 
The relative or absolute path to the source item.

FileIO.moveTo parameter: destinationPath
[type: string] 
The relative or absolute path for the destination directory.

FileIO.moveTo parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

FileIO.moveTo parameter: newName
[type: string] [default: ""] [optional] 
The new name (not including the path) of the item you wish to rename. If "" is provided, then no rename occurs.





FileIO.delete(path, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Deletes the provided file or directory. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.delete parameter: path
[type: string] 
The relative or absolute path of the item to delete.

FileIO.delete parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.compress(sourcePath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Compresses the given file or directory into a zip file. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.compress parameter: sourcePath
[type: string] 
The relative or absolute path to the file or directory in question. If a directory path is provided, the directory must contain at least one file or an error will be encountered.

FileIO.compress parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.





FileIO.decompress(sourcePath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Decompresses the zip file at the given path into its source format. If an error is encountered, related information will be stored in the '.error' member of the returned IncrCommsResponseObject. This function is asynchronous and will return a promise if not 'awaited'.

FileIO.decompress parameter: sourcePath
[type: string] 
The relative or absolute path to the file or directory in question.

FileIO.decompress parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.










----------------------------------------------------------
Section 47: IncrCommsResponseObject
----------------------------------------------------------


IncrCommsResponseObject
[type: class] [NON-INSTANTIABLE] 
Standardized Incisor® communications protocol object that is returned from methods that incorporate external functionality. This serves as a 'wrapper' object to the desired return value. This object contains a 'payload' member and an 'error' member. If no issues are encountered during the external portion of the functionality, the desired return value can be found in the 'payload' member, otherwise the 'error' member will contain applicable information about the encountered issues. For example, if nc.fileIO.readTextFile('MyDrive/SomeDirectory/myFile.txt') is successful, then the returned text from the file will be in the 'payload' member of the returned IncrCommsResponseObject object, but if nc.fileIO.readTextFile('MyDrive/SomeDirectoryWithRestrictedAccess/myFile.txt') is unsuccessful, then the 'error' member of the returned IncrCommsResponseObject object may be something 'Could not read file in restricted directory...'. 





IncrCommsResponseObject.payload
[type: any] 
The desired return value from the method that returns this object.





IncrCommsResponseObject.error
[type: string] 
A string containing information about issues/errors/exceptions encountered during the performance of the external functionality that is required by the method that returns this object. If no issues were encountered, this value will default to an empty string.










----------------------------------------------------------
Section 48: PathInfo
----------------------------------------------------------


PathInfo
[type: class] 
Class containing a 'path' and a 'type' (where type is 'file' or 'directory')





PathInfo.path
[type: string] 
The path string.





PathInfo.type
[type: string] 
The type of the item at the given path. Value will either be 'file' or 'directory'.










----------------------------------------------------------
Section 49: FlowController
----------------------------------------------------------


FlowController
[type: class] [requires: license - proGaming, module - flowControllers] 
FlowControllers provide a way to organize the general flow of state-based items in a project. For example if your project is a game with an intro, a menu, and several levels, you could create a FlowController named "GameFlowController" and then define and add an 'Intro' FlowState, a 'Menu' FlowState, and 'LevelXX' FlowStates to that FlowController. Within each FlowState in the FlowController, timed callback elements can be added to help define the sequencing within each FlowState. Once created, FlowControllers, FlowStates, and FlowStateElements can be accessed via 'nc.flows'.





FlowController.name
[type: string] 
The name of the FlowController.





FlowController.inheritedTypes
[type: any] 
Dictionary object listing all of the types this object is compatible with.





FlowController.type
[type: string] 
Type identifier.





FlowController.currentFlowState
[type: FlowState] 
The current FlowState of this FlowController. Monitor or change the FlowState using this property. This property can also be set via 'nc.flows.[FlowControllerName].[FlowStateName].setToCurrentState'.





FlowController.isActive
[type: boolean] [default: true] 
Flag determining if this FlowController is actively updating the time of the current FlowState and evaluating which FlowStateElements to execute.





FlowController.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this FlowController will be immune to. Set this parameter to [] for this FlowController to have no pause immunity.





FlowController.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this FlowController is affected by.





FlowController.playbackRate
[type: number] [default: 1] 
Value multiplying the progression of the 'time' value. To play twice as fast use 2, for items that can play backwards, use negative values.





FlowController.netPlaybackRate
[type: number] 
Read-only value denoting the net playbackRate, including the effects of this FlowController's SpeedControls.





FlowController.addFlowState(flowStateDefinition)
[type: function] 
Adds a the given FlowState to this FlowController. To build a FlowState, define a class that extends the FlowState class, then provide that definition to this method to add it to this FlowController.

FlowController.addFlowState parameter: flowStateDefinition
[type: object] 
The class definition of the FlowState to add to this FlowController. The provided class definition must inherit from FlowState.





FlowController.setState(flowState, performFollowupEvaluation)
[type: function] 
Sets the 'currentFlowState' of this FlowController to the provided FlowState. This can also be achieved by calling 'setToCurrentState' on the given FlowState.

FlowController.setState parameter: flowState
[type: FlowState] 
The FlowState to set as this FlowController's current FlowState.

FlowController.setState parameter: performFollowupEvaluation
[type: boolean] [default: false] [optional] 
Flag determining if another evaluation of which FlowStateElement callbacks to execute will be done immediately (without waiting a fixedUpdate) after the state change.





FlowController.addFlowStateChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever the current FlowState of this FlowController is changed. The new FlowState and the previous FlowState are sent to the callback as its first two parameters.

FlowController.addFlowStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever the FlowState changes.

FlowController.addFlowStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever the FlowState changes.

FlowController.addFlowStateChangeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever the FlowState changes.





FlowController.removeFlowStateChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

FlowController.removeFlowStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

FlowController.removeFlowStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.










----------------------------------------------------------
Section 50: FlowState
----------------------------------------------------------


FlowState
[type: class] [NON-INSTANTIABLE] [requires: license - proGaming, module - flowControllers] 
This object represents a state within a FlowController. FlowControllers provide a way to organize the general flow of state-based items in a project. For example if your project is a game with an intro, a menu, and several levels, you could create a FlowController named "GameFlowController" and then define and add an 'Intro' FlowState, a 'Menu' FlowState, and 'LevelXX' FlowStates to that FlowController. Within each FlowState in the FlowController, timed callback elements can be added to help define the sequencing within each FlowState. Once created, FlowControllers, FlowStates, and FlowStateElements can be accessed via 'nc.flows'. This class is not meant to be instantiated or provided directly to 'FlowController.addFlowState', rather it is meant to be a class for user-defined FlowStates to extend. Call 'nc.defineFlowController' to create a new FlowController, then use 'nc.flows' to access it. 





FlowState.name
[type: string] 
The name of the FlowState.





FlowState.owner
[type: FlowController] 
The FlowController that owns this FlowState.





FlowState.time
[type: number] 
The current time of this FlowState.





FlowState.setTime(time, performFollowupEvaluation)
[type: function] 
Sets the current time of this FlowState

FlowState.setTime parameter: time
[type: number] 
The new time to set the FlowState to.

FlowState.setTime parameter: performFollowupEvaluation
[type: boolean] [default: false] [optional] 
Flag determining if another evaluation of which FlowStateElement callbacks to execute will be done immediately (without waiting a fixedUpdate) after the time change.





FlowState.setToCurrentState(performFollowupEvaluation)
[type: function] 
Sets the owning FlowController's 'currentFlowState' property equal to this FlowState.

FlowState.setToCurrentState parameter: performFollowupEvaluation
[type: boolean] [default: false] [optional] 
Flag determining if another evaluation of which FlowStateElement callbacks to execute will be done immediately (without waiting a fixedUpdate) after the state change.





FlowState.addElement(time, callbackName, callbackArgs, variableOffsets)
[type: function] [returns: FlowStateElement] 
Adds a new FlowStateElement to this FlowState. Such elements are essentially timed callbacks to functions within this FlowState, which are used to create the sequencing for this FlowState.

FlowState.addElement parameter: time
[type: number] 
The time within this FlowState at which the associated callback will occur.

FlowState.addElement parameter: callbackName
[type: string] 
The name of the function within this FlowState that will be called at the given time.

FlowState.addElement parameter: callbackArgs
[type: [any], any] [optional] 
Parameters for the callback associated with the new FlowStateElement.

FlowState.addElement parameter: variableOffsets
[type: [string], string] [optional] 
The name(s) of the numeric properties that can be adjusted to dynamically offset this FlowStateElement's time. These offset properties will be automatically added to the parent FlowState for easy manipulation of the timing of its FlowStateElements.





FlowState.addPause(time, callbackName, callbackArgs, variableOffsets)
[type: function] [returns: FlowStateElement] 
Adds a new 'pause' FlowStateElement to this FlowState. When the FlowState encounters this particular FlowStateElement, its 'time' property will not progress until the provided callback returns true.

FlowState.addPause parameter: time
[type: number] 
The time within this FlowState that the pause will take effect.

FlowState.addPause parameter: callbackName
[type: string] 
The name of the pause function within this FlowState that will control the pausing. When the function returns true, the FlowState resumes.

FlowState.addPause parameter: callbackArgs
[type: [any], any] [optional] 
Parameters for the callback associated with the new pause FlowStateElement.

FlowState.addPause parameter: variableOffsets
[type: [string], string] [optional] 
The name(s) of the numeric properties that can be adjusted to dynamically offset the FlowStateElement's time. These offset properties will be automatically added to the parent FlowState for easy manipulation of the timing of its FlowStateElements.





FlowState.getElements()
[type: function] [returns: [FlowStateElement]] 
Returns a shallow copy of the list of this FlowState's elements.










----------------------------------------------------------
Section 51: FlowStateElement
----------------------------------------------------------


FlowStateElement
[type: class] [NON-INSTANTIABLE] [requires: license - proGaming, module - flowControllers] 
This object represents one of the sequencing elements within a FlowState. Its properties define a timed callback within the FlowState. 





FlowStateElement.time
[type: number] 
The base time for when this FlowStateElement occurs within it's FlowState.





FlowStateElement.callbackName
[type: string] 
The name of the callback function that this FlowStateElement is associated with. The function must be within the owning FlowState class.





FlowStateElement.callbackArgs
[type: string] 
Parameters for this FlowStateElement's callback function.





FlowStateElement.isPauseElement
[type: boolean] 
Flag determining if this FlowStateElement is a pause element. When a pause element is encountered by the FlowState, its time will not incremented until the associated callback returns true.





FlowStateElement.netTime
[type: boolean] 
Read-only property denoting the aggregated callback time within the owning FlowState. This time is the sum of the 'time' base time together with each of the associated 'variableOffset' values.










----------------------------------------------------------
Section 52: FontDefinition
----------------------------------------------------------


FontDefinition
[type: class] [NON-INSTANTIABLE] 
Object defining a font within this project. Fonts originate from files within a project's "Assets" directory, Either by including '.ttf' or '.otf' files, or by including a specialized group of pngs whose names end with '_Char[X]' that must include '_Char0'. 





FontDefinition.kerningAdjustment
[type: number] 
A number that affects the layout width of all of the characters in this font. The number is expressed in terms of multiples 'characterWidth' value.





FontDefinition.lineHeight
[type: number] 
Number determining the line height of this font. This value originally defaults to the height of the null character provided (Char0), but can be changed.





FontDefinition.characterWidth
[type: number] 
Number determining the basic width of a character in this font. Some of the values used by TextFormats, Texts, and TextBoxes to arrange characters in fonts are denoted in terms of a proportion of this value. For example if the kerning of a given TextBox's TextFormat is .5, then all characters within the TextBox will be spaced apart by half of this 'characterWidth' value. This value originally defaults to the width of the null character provided (Char0), but can be changed in ProjectSettings or runtime.










----------------------------------------------------------
Section 53: Geometry
----------------------------------------------------------


Geometry
[type: class] [extends: AssetComponent] [NON-INSTANTIABLE] 
A Geometry is an object that defines a GraphicAsset's vertices, and the associated Materials and attributes. 





Geometry.sourceWidth
[type: number] 
The width of the source asset (with 'units per pixel' pre-applied).





Geometry.sourceHeight
[type: number] 
The height of the source asset (with 'units per pixel' pre-applied).





Geometry.unitsPerPixel
[type: [number]] 
The 'unitsPerPixel' scaler values for this Geometry.








































----------------------------------------------------------
Section 54: GeometryEditor
----------------------------------------------------------


GeometryEditor
[type: class] [NON-INSTANTIABLE] 
Object connected to a Geometry allowing changes to be made to that Geometry. Make the desired changes, then call 'commitChanges'. 





GeometryEditor.type
[type: string] 
Type identifier.





GeometryEditor.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





GeometryEditor.attributes
[type: object] 
Contains a key for each attribute added to this GeometryEditor. The value at each key is an Array of numbers containing the attribute data.





GeometryEditor.indices
[type: [[number]]] 
Each element in this Array corresponds to the elements in the materials Array of the Graphic that will use the resulting Geometry. Each element contains an Array of numbers containing the index data.





GeometryEditor.attributeDuplicateThresholds
[type: object] 
Contains a key for each attribute added to this GeometryEditor. The value at each key is the threshold used to determine if an attribute value should be considered to match another value in the same attribute Array. When a new vertex is added to the GeometryAccesor, its attribute values are compared to the existing vertices, by checking if the difference between the values is lower than this threshold.  If all attributes are considered to match, the existing vertex is re-used as an optimization. A threshold of 0 on any attribute will ensure that no vertices are ever considered to match each other, effectively disabling this optimization.





GeometryEditor.connectedGeometry
[type: Geometry] 
The Geometry that this GeometryEditor is connected to.





GeometryEditor.copyGeometry(geometry, callbackOwner, callbackName, callbackArgs)
[type: function] 
Copies the vertex, attribute, and material information from the given Geometry into this GeometryEditor. Please note that in many cases, this function operates asyncronously since the Geometry being copied may no be loaded yet. Consequently, using this GeometryEditor to operate on the copied Geometry will need to wait until the source Geomtry loads. This can be achieved by asyncronously awaiting this function, or by supplying a callback, which will be called when the source Geometry loads. The callback will receive the iniating GeometryEditor as its first parameter.

GeometryEditor.copyGeometry parameter: geometry
[type: Geometry] 
The source Geometry whose info will be copied into this GeometryEditor.

GeometryEditor.copyGeometry parameter: callbackOwner
[type: object] [optional] 
The object owning the callback that will be called when the source Geometry loads.

GeometryEditor.copyGeometry parameter: callbackName
[type: string] [optional] 
The name of the callback that will be called when the source Geometry loads.

GeometryEditor.copyGeometry parameter: callbackArgs
[type: Array, any] [optional] 
The arguments for the callback that will be called when the source Geometry loads.





GeometryEditor.addVertex(vertex)
[type: function] [returns: number] 
Adds a vertex that may be referenced by the indices.  The vertex's position in the attribute arrays is returned, and is the value that should be used by the indices to refer to this vertex. Note that the length of the attributes may not increase after this call completes if the vertex was found to be a duplicate of an existing vertex. In this scenario, the index of the existing vertex will be returned.

GeometryEditor.addVertex parameter: vertex
[type: object] 
Each key in this Object should be the name of an attribute in this GeometryEditor. The value should be a number, Vector2, Vector3, or Vector4 containing the value of the attribute at this vertex. The type of the value must correspond to the 'size' specified in 'addAttribute'. Duplicate vertices will be automatically handled according to the values in attributeDuplicateThresholds.





GeometryEditor.addTriangle(vertex0, vertex1, vertex2, materialIndex)
[type: function] 
Adds a triangle that will use the Material at 'materialIndex' of the Graphic that will use the resulting Geometry.

GeometryEditor.addTriangle parameter: vertex0
[type: object] 
Each key in this Object should be the name of an attribute in this GeometryEditor. The value should be a number, Vector2, Vector3, or Vector4 containing the value of the attribute at this vertex. Duplicate vertices will be automatically handled according to the values in attributeDuplicateThresholds.

GeometryEditor.addTriangle parameter: vertex1
[type: object] 
Each key in this Object should be the name of an attribute in this GeometryEditor. The value should be a number, Vector2, Vector3, or Vector4 containing the value of the attribute at this vertex. Duplicate vertices will be automatically handled according to the values in attributeDuplicateThresholds.

GeometryEditor.addTriangle parameter: vertex2
[type: object] 
Each key in this Object should be the name of an attribute in this GeometryEditor. The value should be a number, Vector2, Vector3, or Vector4 containing the value of the attribute at this vertex. Duplicate vertices will be automatically handled according to the values in attributeDuplicateThresholds.

GeometryEditor.addTriangle parameter: materialIndex
[type: number] 
The index into the materials Array of the Graphic that will use the resulting Geometry. Defaults to 0.





GeometryEditor.addAttribute(name, type, size)
[type: function] 
Adds a new attribute.  If an attribute aleady exists with this name, the attribute is re-initialized and will be empty.

GeometryEditor.addAttribute parameter: name
[type: string] 
The name of the attribute.

GeometryEditor.addAttribute parameter: type
[type: string] 
The type of number that should be used to store this attribute.

GeometryEditor.addAttribute parameter: size
[type: number] 
Specifies the number of components on this attribute. Must be 1, 2, 3, or 4.





GeometryEditor.deleteAllAttributesAndIndices()
[type: function] 
Deletes all attributes. This is typically used if the default attributes of 'position' and 'uv' are unneeded on a new GeometryEditor.





GeometryEditor.convertGeometryToGrid(horizontalSegments, verticalSegments)
[type: function] 
Converts the connected Geometry to a grid of triangles oriented on the XY plane. Attribute values at each new point will be interpoloted linearly across the grid, using the attribute values at the minimum and maximum vertices of the original geometry.

GeometryEditor.convertGeometryToGrid parameter: horizontalSegments
[type: number] 
The number of horizontal segments of the grid.

GeometryEditor.convertGeometryToGrid parameter: verticalSegments
[type: number] 
The number of vertical segments of the grid.





GeometryEditor.newGrid(width, height, horizontalSegments, verticalSegments)
[type: function] 
Creates a new grid of triangles oriented on the XY plane, centered around 0 on each axis.

GeometryEditor.newGrid parameter: width
[type: number] 
The width of the grid.

GeometryEditor.newGrid parameter: height
[type: number] 
The height of the grid.

GeometryEditor.newGrid parameter: horizontalSegments
[type: number] 
The number of horizontal segments of the grid.

GeometryEditor.newGrid parameter: verticalSegments
[type: number] 
The number of vertical segments of the grid.





GeometryEditor.translate(translation, attributeName)
[type: function] 
Translates all of the values of an attribute by the given translation amount.

GeometryEditor.translate parameter: translation
[type: number, Vector2, Vector3, Vector4] 
The amount the values of the attribute are translated. This parameter should be a number, Vector2, Vector3, or Vector4. The type should correspond to the size of the attribute. For example, the default 'position' attribute should be translated by a Vector3, and the default 'uv' attribute should be translated by a Vector2.

GeometryEditor.translate parameter: attributeName
[type: string] 
The name of the attribute data to be translated. Defaults to 'position'.





GeometryEditor.getVertexTemplate()
[type: function] 
Returns a new object structured appropriately to pass into the addVertex and addTriangle functions. For each currently defined attribute, a member of type number, Vector2, Vector3, or Vector4 is added.





GeometryEditor.getBounds(attributeName, lowerBounds, upperBounds)
[type: function] 
Calculates the lowest and highest values seen on each dimension of the attribute's data.

GeometryEditor.getBounds parameter: attributeName
[type: string] 
The name of the attribute data to search for bounds. Defaults to 'position'.

GeometryEditor.getBounds parameter: lowerBounds
[type: number] 
The array to populate with the lowest value found in each dimension of the attribute data.

GeometryEditor.getBounds parameter: upperBounds
[type: number] 
The array to populate with the highest value found in each dimension of the attribute data.





GeometryEditor.commitChanges()
[type: function] 
Applies the changes performed by this GeometryEditor to the connectect Geometry. To optimize performance, this should be called once after all changes have been performed, as this function can have a performance impact.










----------------------------------------------------------
Section 55: GraphicAsset
----------------------------------------------------------


GraphicAsset
[type: class] [NON-INSTANTIABLE] 
A GraphicAsset is an object that represents a piece of visual content such as an image file or an 'OBJ'. GraphicAssets contain a Geometry, and a set of MaterialPresets that, when applied via 'GraphicObject.graphicAsset' or 'GraphicObject.setGraphicAsset', change the appearance of a GraphicObject to that of the GraphicAsset. 





GraphicAsset.type
[type: string] 
Type identifier





GraphicAsset.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





GraphicAsset.name
[type: string] 
The GraphicAsset's name.

example:
// Objective: Set and Get the name of a GraphicAsset.
// Expected Result: The console should read "name is WhiteBox"

// Create a GraphicObject using the WhiteBox GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject" );
// Get an instance of the GraphicAsset from its GraphicObject.
let myGraphicAsset = myGraphicObject.graphicAsset;
// Console log the name of the GraphicAsset.
console.log("name is", myGraphicAsset.name );





GraphicAsset.geometry
[type: Geometry] 
This GraphicAsset's geometry.

example:
// Objective: Get the current Geometry of a GraphicAsset
// Expected Result: The console should have 2 log messages as follows:
//     myGraphicAsset (Box) sourceWidth, sourceHeight 100 100
//     myGraphicAsset (Triangle) sourceWidth, sourceHeight 50 100

// Create a GraphicObject using the white box GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "MyGraphicObject" );
// Get the GraphicAsset from the GraphicObject
let myGraphicAsset = myGraphicObject.graphicAsset;
// Console log the Geometry sourceWidth and sourceHeight of the GraphicAsset.
console.log("myGraphicAsset (Box) sourceWidth, sourceHeight", myGraphicAsset.geometry.sourceWidth, myGraphicAsset.geometry.sourceHeight);
// Update the Geometry of myGraphicAsset with the white triangle.
myGraphicAsset.geometry = nc.geometries.WhiteTriangle;
// Console log the Geometry sourceWidth and sourceHeight again.
console.log("myGraphicAsset (Triangle) sourceWidth, sourceHeight", myGraphicAsset.geometry.sourceWidth, myGraphicAsset.geometry.sourceHeight);





GraphicAsset.materialPresets
[type: [MaterialPreset]] 
List of MaterialPresets associated with this GraphicAsset.










----------------------------------------------------------
Section 56: MaterialPreset
----------------------------------------------------------


MaterialPreset
[type: class] [NON-INSTANTIABLE] 
A MaterialPreset is an object with the instructions for configuring a Material. A list of MaterialPresets is included with every GraphicAsset, so that when a GraphicObject is set to a given GraphicAsset, that GraphicObject's Materials can be configured accordingly. For example, for a standard image-file GraphicAsset, the typical MaterialPreset would list the "SampleMainTexture" EffectNode, and would also have the name of the Texture to set for the 'mainTexture' EffectController. 





MaterialPreset.type
[type: string] 
Type identifier





MaterialPreset.effectNodeNames
[type: [string]] 
List of the names of the EffectNodes to be applied to the Material.





MaterialPreset.materialValues
[type: object] 
Dictionary of EffectController values to be applied to the Material. Please note that the EffectController values stored in this object will be listed in a more primative form than elsewhere: EffectControllers that have a Vector base type will be stored as a simple array of numeric values within this object. Also Texture EffectController values are simply referenced by including the name of the Texture in question.










----------------------------------------------------------
Section 57: GraphicExpander
----------------------------------------------------------


GraphicExpander
[type: class] [NON-INSTANTIABLE] 
A GraphicExpander allows a region of a GraphicObject to be specified as expandable to a new size. When a new size is specified, this region of the GraphicObject will change size, but the area outside the expandable region will move and stretch to keep aligned to the expanded region. 





GraphicExpander.type
[type: string] 
Type identifier.





GraphicExpander.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





GraphicExpander.symmetric
[type: boolean] 
Flag determining if the GraphicExpander's expandable area and expanded area are both in the middle of the GraphicObject. When this value is true, the interface to configure the GraphicExpander includes expandableWidth, expandableHeight, expandedWidth, and expandedHeight. When this value is false, the interface to configure the GraphicExpander includes expandableAreaLeft, expandableAreaRight, expandableAreaBottom, expandableAreaTop, expandedAreaLeft, expandedAreaRight, expandedAreaBottom, and expandedAreaTop.





GraphicExpander.expandableWidth
[type: number] [default: 0] 
Value that determines the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is true.





GraphicExpander.expandableHeight
[type: number] [default: 0] 
Value that determines the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is true.





GraphicExpander.expandedWidth
[type: number] [default: 100] 
The expanded width of the GraphicExpander. Set this value to stretch or shrink the associated GraphicObject horizontally. This property is only applicable if the 'symmetric' property is true.





GraphicExpander.expandedHeight
[type: number] [default: 100] 
The expanded height of the GraphicExpander. Set this value to stretch or shrink the associated GraphicObject vertically. This property is only applicable if the 'symmetric' property is true.





GraphicExpander.expandableAreaLeft
[type: number] [default: 0] 
Value that defines the left bound of the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandableAreaRight
[type: number] [default: 0] 
Value that defines the right bound of the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandableAreaBottom
[type: number] [default: 0] 
Value that defines the bottom bound of the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandableAreaTop
[type: number] [default: 0] 
Value that defines the top bound of the portion of the GraphicObject that will be affected by this GraphicExpander. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandedAreaLeft
[type: number] [default: -50] 
Value that determines where the left bound of the expansion area will be after the expansion. Set this value to stretch or shrink the associated GraphicObject's left side. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandedAreaRight
[type: number] [default: 50] 
Value that determines where the right bound of the expansion area will be after the expansion. Set this value to stretch or shrink the associated GraphicObject's right side. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandedAreaBottom
[type: number] [default: -50] 
Value that determines where the bottom bound of the expansion area will be after the expansion. Set this value to stretch or shrink the associated GraphicObject's bottom side. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.expandedAreaTop
[type: number] [default: 50] 
Value that determines where the top bound of the expansion area will be after the expansion. Set this value to stretch or shrink the associated GraphicObject's top side. This property is only applicable if the 'symmetric' property is false.





GraphicExpander.dispose()
[type: function] 
Removes and destroys the GraphicExpander, restoring the original Geometry if possible.










----------------------------------------------------------
Section 58: GraphicObject
----------------------------------------------------------


GraphicObject
[type: class] [extends: SceneObject] 
GraphicObjects are SceneObjects with visible components such as Geometry, Materials, and Textures. Anything that you can see in an Incisor® Scene is some form of GraphicObject. GraphicObjects can easily be set to different GraphicAssets such as source Images, OBJs, or other customizable visuals.





GraphicObject.visible
[type: boolean] [default: true] 
Boolean determining if this GraphicObject is visible. Unlike the 'enabled' property of SceneObjects, 'GraphicObject.visible' does not affect any descendants of this GraphicObject. It should be noted that 'turning off' objects using 'GraphicObject.visible=false' is often less performant than 'SceneObject.enabled=false', because while the 'visible' property does prevent the object from rendering, the 'enabled' property also prevents several additional hierarchical calculations from occuring for the effected SceneObjects.

example:
// Objective: Make a GraphicObject not visible.
// Expected Result: Only the "WhiteTriangle" is visible. The "WhiteBox" is not.

// Add a "WhiteBox" GraphicObject to the main scene using the GraphicObject constructor.
let whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// move the "WhiteBox" 100 world units to the left
whiteBox.position.x = -100;

// Add a "WhiteTriangle" GraphicObject to the main scene using the GraphicObject constructor.
let whiteTriangle = new GraphicObject( nc.graphicAssets.WhiteTriangle, nc.mainScene, "WhiteTriangle" );
// move the "WhiteTriangle" 100 world units to the right
whiteTriangle.position.x = 100;

// Set "WhiteBox" to visible = false.
whiteBox.visible = false;





GraphicObject.layer
[type: Layer] [default: nc.layers.DefaultLayer] 
The GraphicObject's render-order Layer within the Scene. For a list of available layers per Scene, see 'nc.layersByScene'





GraphicObject.subLayer
[type: number] [default: 0] 
The GraphicObject's render-order within it's assigned Layer as represented by a number between -1 and 1.





GraphicObject.graphicAsset
[type: GraphicAsset] [default: nc.graphicAssets.WhiteBox] 
Use this to set or get the current GraphicAsset for this GraphicObject. Also see 'setGraphicAsset', which can set the GraphicAsset with options to forego the EffectNode and EffectController presets. When 'getting' this value, keep in mind that it will only reflect the GraphicAsset that this GraphicObject was previously set to; the value returned does not reflect customizations made to the Geometry, Materials, EffectNodes or EffectControllers that occurred since it was previously set.

example:
// Objective: Set the GraphicAsset of a GraphicObject
// Expected Result: You will see a WhiteTriangle on the screen and the console should have 2 log messages as follows:
// 'MyGraphicObject' GraphicAsset name: WhiteBox
// 'MyGraphicObject' GraphicAsset name: WhiteTriangle 

// Add a GraphicObject to the main scene using the GraphicObject constructor and the WhiteBox GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject" );
// Console log the name of the GraphicAsset
console.log("'MyGraphicObject' GraphicAsset name:", myGraphicObject.graphicAsset.name);
// Update 'MyGraphicObject' to the WhiteTriangle GraphicObject.
myGraphicObject.graphicAsset = nc.graphicAssets.WhiteTriangle;
// Console log the name of the GraphicAsset again.
console.log("'MyGraphicObject' GraphicAsset name:", myGraphicObject.graphicAsset.name);





GraphicObject.materialMaster
[type: MaterialMaster] 
The MaterialMaster is a convenience-based object that allows quick manipulation of all of the Materials on a given GraphicObject. To manipulate all of the Materials on a GraphicObject at the same time, you can simply manipulate its MaterialMaster. It should be noted that querying values from the MaterialMaster can be misleading, as the returned values only refer to the last values set on the MaterialMaster itself, and would not reflect individual changes made to the Materials themselves.

example:
// Objective: Use a GraphicObject's MaterialMaster to change its color.
// Expected Result: You will see a red box.

// Add a GraphicObject to the main scene using the GraphicObject constructor and the WhiteBox GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject" ) ;
// Get the instance of this GraphicObject's MaterialMaster
let materialMaster = myGraphicObject.materialMaster;
// By default, the RGB values of fillColor are set to 1. Set the green and blue values to zero to leave only red.
materialMaster.fillColor.green = 0;
materialMaster.fillColor.blue  = 0;





GraphicObject.geometry
[type: Geometry] [default: nc.geometries.WhiteBox] 
The current Geometry of this GraphicObject. Setting this GraphicObject's GraphicAsset will update its Geometry automatically, but the Geometry can be set directly for further customization.

example:
// Objective: Get the current Geometry of a GraphicObject
// Expected Result: The console should have 2 log messages as follows:
// 'MyGraphicObject' (Box) sourceWidth, sourceHeight 100 100
// 'MyGraphicObject' (Triangle) sourceWidth, sourceHeight 50 100
 
// Create a GraphicObject using the white box GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "MyGraphicObject" );
// Console log the Geometry sourceWidth and sourceHeight.
console.log("'MyGraphicObject' (Box) sourceWidth, sourceHeight", myGraphicObject.geometry.sourceWidth, myGraphicObject.geometry.sourceHeight);
// Update the Geometry of myGraphicObject with the white triangle.
myGraphicObject.geometry = nc.geometries.WhiteTriangle;
// Console log the Geometry sourceWidth and sourceHeight again.
console.log("'MyGraphicObject' (Triangle) sourceWidth, sourceHeight", myGraphicObject.geometry.sourceWidth, myGraphicObject.geometry.sourceHeight);





GraphicObject.graphicExpander
[type: GraphicExpander] 
A GraphicExpander allows a region of a GraphicObject to be specified as expandable to a new size. When a new size is specified, this region of the GraphicObject will change size, but the area outside the expandable region will move and stretch to keep aligned to the expanded region. This property defaults to undefined, but can be enabled by calling 'GraphicObject.configureGraphicExpander()'.

example:
[ReferenceSnippet: GraphicObject_ConfigureGraphicExpander]





GraphicObject.spriteSetter
[type: SpriteSetter] 
A SpriteSetter is a PlaybackController that switches a GraphicObject's graphicAsset between numerically sequential GraphicAssets. This property defaults to undefined, but can be enabled by calling 'GraphicObject.configureSpriteSetter()'.

example:
// Objective: Configure a SpriteSetter





GraphicObject.masking
[type: Masking] 
Object controlling the masking of a GraphicObject. Masking functionality enables selective rendering of portions of GraphicObjects. MaskGroups can be defined, and then GraphicObjects can be configured as 'mask', which add their shape to the area of the newly defined MaskGroup. Then, when other GraphicObjects are configured as 'masked', their rendering only occures within areas defined by the MaskGroup.





GraphicObject.frustumCulling
[type: boolean] [default: true] 
Boolean determining if the GraphicObject is automatically omitted from rendering when it is entirely outside of the Camera's viewing area (its frustum). While the value defaults to true, reasons to set it false include situations where the Geometry of a given GraphicObject is being adjusted via EffectNode (on the GPU), and so while an object's postion may indicate that it should be culled due to being out of view, its Geometry may be distorted into a position that is actually in view of the camera, and should therefore be rendered after all.





GraphicObject.setGraphicAsset(graphicAsset, maintainEffectNodes, maintainEffectControllerValues)
[type: function] 
Changes this GraphicObject's GraphicAsset, updating its Geometry and Materials.

GraphicObject.setGraphicAsset parameter: graphicAsset
[type: GraphicAsset] 
The GraphicAsset that this GraphicObject will become. For a list of available GraphicAssets, see 'nc.graphicAssets'.

GraphicObject.setGraphicAsset parameter: maintainEffectNodes
[type: boolean] [default: false] [optional] 
Boolean determining if the current EffectNodes will be maintained during the transformation to the new GraphicAsset.

GraphicObject.setGraphicAsset parameter: maintainEffectControllerValues
[type: boolean] [default: false] [optional] 
Boolean determining if the current EffectController values will be maintained during the transformation to the new GraphicAsset.

example:
// Objective: Set a GraphicAsset on a GraphicObject.
// Expected Result: You will see a white triangle. 

// Add a GraphicObject to the main scene using the GraphicObject constructor and the WhiteBox GraphicAsset.
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject") ;
// Call setGraphicAsset() to change the White Box to a White Triangle
myGraphicObject.setGraphicAsset( nc.graphicAssets.WhiteTriangle );





GraphicObject.setMaterials(materials)
[type: function] 
Sets this GraphicObject's Materials directly. This is used for specialized customization of GraphicObjects, and is not needed when working with standard GraphicAssets.

GraphicObject.setMaterials parameter: materials
[type: [Material], Material] 
The new list of Materials for this GraphicObject.





GraphicObject.getMaterials()
[type: function] [returns: [Material]] 
Returns the list of this GraphicObject's Materials.





GraphicObject.configureGraphicExpander()
[type: function] 
Adds a GraphicExpander instance to this GraphicObject, which allows the GraphicObject to be expanded to a new size from the middle out.





GraphicObject.configureSpriteSetter(keyGraphicAsset, frameRate, pauseImmunity, speedControl)
[type: function] 
Adds a SpriteSetter instance to this GraphicObject, which allows the GraphicObject's graphicAsset to be switched to numerically sequential GraphicAssets.

GraphicObject.configureSpriteSetter parameter: keyGraphicAsset
[type: GraphicAsset] 
Specifies the key GraphicAsset. This GraphicAsset's name should end in a number. All GraphicAssets whose name matches the key GraphicAsset's name with a different trailing number will be used to set the SpriteSetter's associated GraphicAssets list. For example, if the key GraphicAsset is named "MyAnimation001", all GraphicAssets with the name "MyAnimation" followed by any sequence of the digits 0-9 will be gathered into this SpriteSetter's associated GraphicAssets.

GraphicObject.configureSpriteSetter parameter: frameRate
[type: number] [default: nc.targetFixedUpdateRate] [optional] 
Specifies the frames per second at which the SpriteSetter should play. Note that this is reflected in the SpriteSetter's playbackRate value.

GraphicObject.configureSpriteSetter parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this ParticleSystem will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

GraphicObject.configureSpriteSetter parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this ParticleSystem is affected by.

example:
// Objective: Configure a SpriteSetter






















































































































































































































































































































----------------------------------------------------------
Section 59: Masking
----------------------------------------------------------


Masking
[type: class] 
Object controlling the masking of a GraphicObject. Masking functionality enables selective rendering of portions of GraphicObjects. MaskGroups can be defined, and then GraphicObjects can be configured as 'mask', which add their shape to the area of the newly defined MaskGroup. Then, when other GraphicObjects are configured as 'masked', their rendering only occures within areas defined by the MaskGroup.





Masking.inheritedTypes
[type: object] 
Dictionary of type that this object inherits from.





Masking.enabled
[type: boolean] [default: false] 
Flag determining if masking functionality is enabled (for both 'mask' and 'masked').





Masking.type
[type: string] [default: "masked"] 
String property that determines if this GraphicObject is a 'mask' or 'masked'. When masking functionality is enabled, a 'mask' contributes to the MaskGroup(s) it is associated with. When a GraphicObject is 'masked' it is only rendered in the areas determined by the MaskGroup(s) it is associated with. This setting does nothing when 'GraphicObject.masking.enabled' is false;





Masking.invert
[type: boolean] [default: false] 
Boolean determining if the affect of masking on a 'masked' GraphicObject is inverted, meaning that the areas where it is masked and the areas where it is not masked are switched. When this value is false, the masked GraphicObject in question is only rendered in areas that 'mask' GraphicObjects also occupy. When this value is true, the masked GraphicObject in question is only rendered in areas that 'mask' GraphicObjects do not occupy. This setting only applies to GraphicObjects with the 'masked' type, 'mask' GraphicObjects are unaffected by this setting. This setting does nothing when 'GraphicObject.masking.enabled' is false.





Masking.makeMask(maskGroups)
[type: function] 
Causes this GraphicObject to contribute to the given MaskGroup(s), adding its fully filled Geometry to the MaskGroups' areas.

Masking.makeMask parameter: maskGroups
[type: MaskGroup, [MaskGroup]] 
The MaskGroup(s) that this GraphicObject's shape will be added to. For a list of available MaskGroups, see 'nc.maskGroups'.

example:
// Objective: Use a mask to reveal only a portion of the phrase "Hello World."
// Expected Result: You will see the word "World." on screen.

// create a TextBox
let textBox = nc.addTextBox( nc.mainScene );
textBox.string = "Hello World."
textBox.makeMasked( nc.maskGroups.MainMaskGroup ); // mask it with "MainMaskGroup"

// create a GraphicObject rectangle and position it to cover the word "World."
this.masker = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Masker" );
this.masker.scale.x = 2; // rectangle
this.masker.position.x = 75; // position
this.masker.masking.makeMask( nc.maskGroups.MainMaskGroup ); // make it a masker for "MainMaskGroup"





Masking.makeMasked(maskGroups, invert)
[type: function] 
Causes this GraphicObject to only be rendered in the areas defined by the given MaskGroup(s).

Masking.makeMasked parameter: maskGroups
[type: MaskGroup, [MaskGroup]] 
The MaskGroup(s) that the rendering of this GraphicObject will be limited to. For a list of available MaskGroups, see 'nc.maskGroups'.

Masking.makeMasked parameter: invert
[type: boolean] [default: false] [optional] 
Inverts the effect of the masking, swapping the areas where this GraphicObject will and won't be rendered.

example:
// Objective: Use a mask to reveal only a portion of the phrase "Hello World."
// Expected Result: You will see the word "World." on screen.

// create a TextBox
let textBox = nc.addTextBox( nc.mainScene );
textBox.string = "Hello World."
textBox.makeMasked( nc.maskGroups.MainMaskGroup ); // mask it with "MainMaskGroup"

// create a GraphicObject rectangle and position it to cover the word "World."
this.masker = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Masker" );
this.masker.scale.x = 2; // rectangle
this.masker.position.x = 75; // position
this.masker.masking.makeMask( nc.maskGroups.MainMaskGroup ); // make it a masker for "MainMaskGroup"





Masking.setMaskGroups(maskGroups)
[type: function] 
Sets the MaskGroup or list of MaskGroups that this GraphicObject is associated with.

Masking.setMaskGroups parameter: maskGroups
[type: MaskGroup, [MaskGroup]] 
The MaskGroup or list of MaskGroups to set.





Masking.getMaskGroups()
[type: function] [returns: [MaskGroup]] 
Gets the list of MaskGroups that this GraphicObject is associated with.










----------------------------------------------------------
Section 60: MaskGroup
----------------------------------------------------------


MaskGroup
[type: class] 
Masking functionality enables selective rendering of portions of GraphicObjects. MaskGroups can be defined, and then GraphicObjects can be configured as 'mask', which add their shape to the area of the newly defined MaskGroup. Then, when other GraphicObjects are configured as 'masked', their rendering only occures within areas defined by the MaskGroup.





MaskGroup.type
[type: string] 
Type identifier.





MaskGroup.inheritedTypes
[type: object] 
Dictionary of type that this object inherits from.





MaskGroup.name
[type: string] 
The name of the MaskGroup





MaskGroup.maskGroupNumber
[type: number] 
The numeric value representing this MaskGroup.










----------------------------------------------------------
Section 61: IncisorApp
----------------------------------------------------------


IncisorApp
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - advancedTools] 
Object housing functionality allowing for direct interactions with the Incisor® application from within the javascript runtime. Such functionality includes the ability to get/set project and application settings, initiate the hosting of files in local directories, script the opening of new browser tabs, and perform other transactions with the Incisor® application.





IncisorApp.getProjectSettings()
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject whose '.payload' member is copy of the current ProjectSettings of the currently open project in javascript object form. In order to update the ProjectSettings, pass 'IncisorApp.setProjectSettings' a version of this payload that contains the desired modifications.





IncisorApp.setProjectSettings(projectSettings)
[type: function] [returns: IncrCommsResponseObject] 
Updates the ProjectSettings of the currently open project in memory. The current ProjectSettings can be retrieved using 'IncisorApp.getProjectSettings', modified, and updated using this function. ProjectSettings updated using this method will be automatically validated against the internal Incisor® schema. Once updated, the current project must be saved in order for the changes to be reflected in the ProjectSettings.json file within the project directory.

IncisorApp.setProjectSettings parameter: projectSettings
[type: object] 
The desired ProjectSettings to update the project with.





IncisorApp.getApplicationSettings()
[type: function] [returns: IncrCommsResponseObject] 
Returns an IncrCommsResponseObject whose '.payload' member is copy of the Incisor ApplicationSettings in javascript object form. In order to update the ApplicationSettings, pass 'IncisorApp.setApplicationSettings' a version of this payload that contains the desired modifications.





IncisorApp.setApplicationSettings(applicationSettings, commitToDisk)
[type: function] [returns: IncrCommsResponseObject] 
Updates the Incisor® application settings in memory. The current ApplicationSettings can be retrieved using 'IncisorApp.getApplicationSettings', modified, and updated using this function. ApplicationSettings updated using this method will be automatically validated against the internal Incisor® schema.

IncisorApp.setApplicationSettings parameter: applicationSettings
[type: object] 
The desired ApplicationSettings to update Incisor® with.

IncisorApp.setApplicationSettings parameter: commitToDisk
[type: boolean] [default: false] [optional] 
Boolean determining if the new settings are immediately saved on disk, ensuring their persistence on subsequent application launches.





IncisorApp.hostLocalDirectory(directoryPath, isPathRelative, allowRemoteHosting, enableGzip)
[type: function] [returns: IncrCommsResponseObject] 
Begins hosting files in the given directory, and returns an IncrCommsResponseObject whose '.payload' member contains the port selected by Incisor® to host from.

IncisorApp.hostLocalDirectory parameter: directoryPath
[type: string] 
The relative or absolute path to the directory to host files from.

IncisorApp.hostLocalDirectory parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

IncisorApp.hostLocalDirectory parameter: allowRemoteHosting
[type: boolean] [default: false] [optional] 
Bool stating if external connections can make requests from this host. If true, the 'allowRemoteHosting' item in application settings must also be set to true.

IncisorApp.hostLocalDirectory parameter: enableGzip
[type: boolean] [default: true] [optional] 
Bool stating files hosted from this connection should be compressed using 'gzip'.





IncisorApp.stopHostingLocalDirectory(directoryPath, isPathRelative)
[type: function] [returns: IncrCommsResponseObject] 
Ends hosting files from the given directory, freeing up the associated port.

IncisorApp.stopHostingLocalDirectory parameter: directoryPath
[type: string] 
The relative or absolute path to the directory to stop hosting files from.

IncisorApp.stopHostingLocalDirectory parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path.





IncisorApp.openTabToUrl(url)
[type: function] [returns: IncrCommsResponseObject] 
Opens a new tab in the browser at the given url without requiring user interaction.

IncisorApp.openTabToUrl parameter: url
[type: string] 
The url to open the new browser tab to.





IncisorApp.pauseProjectDirectoryWatcher()
[type: function] 
Temporarily stops Incisor's file system watcher, allowing fileIO changes to the project without Incisor auto-refreshing the project in the inspector.





IncisorApp.resumeProjectDirectoryWatcher()
[type: function] 
Resumes Incisor's file system watcher, such that fileIO changes result in Incisor auto-refreshing the project in the inspector.










----------------------------------------------------------
Section 62: IncisorAppBasic
----------------------------------------------------------


IncisorAppBasic
[type: class] [NON-INSTANTIABLE] [requires: unpublished only] 
Object housing basic functionality allowing for direct interactions with the Incisor® application from within the javascript runtime. Such functionality includes the ability to get the list of optional code modules from the Incisor™ application. See 'nc.incisorApp' for many more application interaction options.





IncisorAppBasic.getOptionalCodeModuleNames()
[type: function] [returns: [string]] 
Returns a list of the names of all of the Incisor® 'optional code' modules. Optional code modules are groups of functionality that can be left out of projects in order to optimize their overall published download size. Optional code modules can be marked for exclusion in ProjectSettings.










----------------------------------------------------------
Section 63: LayoutObject
----------------------------------------------------------


LayoutObject
[type: class] [NON-INSTANTIABLE] 
Object housing information about this particular SceneObject's LayoutObject functionality. LayoutObject functionality applies to SceneObjects that have been added as elements to a LayoutStack, which is responsible for organizing visual content (TextBoxes, Graphics, Buttons, etc...) into dynamic vertical or horizontal stacks. Until a SceneObject has been configured with LayoutObject functionality (either by calling 'SceneObject.configureLayoutObject' or by adding the SceneObject as an element to a LayoutStack), the 'SceneObject.layoutObject' member will be undefined. 





LayoutObject.type
[type: string] 
Type identifier.





LayoutObject.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





LayoutObject.width
[type: number] 
The width of this LayoutObject.





LayoutObject.height
[type: number] 
The height of this LayoutObject.





LayoutObject.leftBuffer
[type: number] [default: 0] 
A buffer that is included when this LayoutObject is laid out within a LayoutStack. This buffer is multiplied by nc.uiZoom.totalZoom if the containing LayoutStack is configured to be affected by iuZoom.





LayoutObject.rightBuffer
[type: number] [default: 0] 
A buffer that is included when this LayoutObject is laid out within a LayoutStack. This buffer is multiplied by nc.uiZoom.totalZoom if the containing LayoutStack is configured to be affected by iuZoom.





LayoutObject.bottomBuffer
[type: number] [default: 0] 
A buffer that is included when this LayoutObject is laid out within a LayoutStack. This buffer is multiplied by nc.uiZoom.totalZoom if the containing LayoutStack is configured to be affected by iuZoom.





LayoutObject.topBuffer
[type: number] [default: 0] 
A buffer that is included when this LayoutObject is laid out within a LayoutStack. This buffer is multiplied by nc.uiZoom.totalZoom if the containing LayoutStack is configured to be affected by iuZoom.





LayoutObject.justification
[type: string] [default: "left"] 
The justification of this LayoutObject within the LayoutStack that contains it (if applicable). See 'nc.constants.justifications' for a list of available values.





LayoutObject.overrideWidth
[type: number] [default: undefined] 
An override to the width value of this LayoutObject, which would otherwise be set by the 'refreshLayoutCallback' callback function connected to this LayoutObject.





LayoutObject.overrideHeight
[type: number] [default: undefined] 
An override to the height value of this LayoutObject, which would otherwise be set by the 'refreshLayoutCallback' callback function connected to this LayoutObject.





LayoutObject.refreshLayoutCallbackOwner
[type: object] 
The owner of the function that will be called automatically to refresh the layout of this LayoutObject and determine its layout dimensions. This function is responsible for laying out the LayoutObject's content and returning a Vector2 containing its dimensions, which will then be used to position this LayoutObject within the LayoutStack that contains it. GrapicObjects and TextBoxes automatically perform these functions internally without the need for this callback... Set this value to customize the process of laying out this SceneObject's content, and/or determining its layout width/height.





LayoutObject.refreshLayoutCallbackName
[type: string] 
The name of the function that will be called automatically to refresh the layout of this LayoutObject and determine its layout dimensions. This function is responsible for laying out the LayoutObject's content and returning a Vector2 containing its dimensions, which will then be used to position this LayoutObject within the LayoutStack that contains it. GrapicObjects and TextBoxes automatically perform these functions internally without the need for this callback... Set this value to customize the process of laying out this SceneObject's content, and/or determining its layout width/height.





LayoutObject.refreshLayoutCallbackArgs
[type: any] 
Parameters for the function that will be called automatically to refresh the layout of this LayoutObject and determine its layout dimensions. This function is responsible for laying out the LayoutObject's content and returning a Vector2 containing its dimensions, which will then be used to position this LayoutObject within the LayoutStack that contains it. GrapicObjects and TextBoxes automatically perform these functions internally without the need for this callback... Set this value to customize the process of laying out this SceneObject's content, and/or determining its layout width/height.





LayoutObject.layoutLazyUpdater
[type: LazyUpdater] 
The LazyUpdater in charge of laying out the contents of the SceneObject that owns this LayoutObject.





LayoutObject.informParentsOfLayoutChange()
[type: function] 
Informs the containing LayoutStack of a change in this LayoutObject's dimensions, telling the LayoutStack that it will need to refresh its Layout. Call this function whenever a custom LayoutObject's dimensions change.





LayoutObject.addSecondaryLayoutCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds an optional callback that occurs after this LayoutObject's layout is refreshed. This callback can be used to perform further actions that use the new layout after it is updated. It should be noted that this callback will not affect the width or height of this LayoutObject, it is only meant to be used for 'additonal styling' of the layout object using the updated layout.

LayoutObject.addSecondaryLayoutCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs after this LayoutObject's layout is refreshed

LayoutObject.addSecondaryLayoutCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs after this LayoutObject's layout is refreshed

LayoutObject.addSecondaryLayoutCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered after this LayoutObject's layout is refreshed





LayoutObject.removeSecondaryLayoutCallback(callbackOwner, callbackName)
[type: function] 
Removes the given secondaryLayout callback.

LayoutObject.removeSecondaryLayoutCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

LayoutObject.removeSecondaryLayoutCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.










----------------------------------------------------------
Section 64: LayoutStack
----------------------------------------------------------


LayoutStack
[type: class] [extends: SceneObject] [requires: license - gui, module - gui] 
Specialized SceneObject that organizes visual content (TextBoxes, Graphics, Buttons, etc...) into dynamic vertical or horizontal stacks. LayoutStacks automatically adjust their layout based on their elements. For example if a TextBox element gets larger, the other elements are shifted so that the TextBox doesn't overlap its neighboring elements. LayoutStacks manage this choreography using the "LayoutObject" member of each of its elements, which can be configured by calling SceneObject.configureLayoutObject. LayoutStacks are also automatically configured as LayoutObjects, so they can also be added to LayoutStacks for nesting.





LayoutStack.isVertical
[type: boolean] [default: true] 
Flag that determines if this LayoutStack is a vertical stack organized from top to bottom or a horizontal stack organzied from left to right.





LayoutStack.pivotPoint
[type: Vector2] [default: new Vector2(-.5,.5)] 
The pivot point for the LayoutStack, with [0,0] meaning center pivot, and [.5,.5] meaning right-top pivot. LayoutStacks are center-based by default like to most GraphicObjects. It should be noted that pivotPoint and justification seperate concepts and do not affect eachother. Justification affects the alignment of the content within the bounds of the LayoutStack, and pivotPoint affects where the 'origin' of the LayoutStack is relative to those bounds.





LayoutStack.elementSpacer
[type: number] [default: 0] 
Number corresponding to the amount of space between each element in the LayoutStack. For LayoutStacks with standardUiZoomFunctionality enabled, this these spaces will be scaled by nc.uiZoom.totalZoom.





LayoutStack.minWidth
[type: number] [default: 0] 
Optional minimum width for this LayoutStack.





LayoutStack.minHeight
[type: number] [default: 0] 
Optional minimum height for this LayoutStack.





LayoutStack.displayBorder
[type: boolean] [default: false] 
Boolean determining if a border (consisting of a UiOutline) is displayed. The border automatically changes shape based on the layoutObject.width and layoutObject.height properties. It should be noted that the associated LayoutStack.border member will be undefined until this flag is set to true.





LayoutStack.border
[type: UiOutline] [default: undefined] 
UiOutline that (when displayed) automatically adjusts to the layoutObject.width and layoutObject.height properties of this LayoutStack. It should be noted that this property is undefined unless LayoutStack.displayBorder is set to true.





LayoutStack.displayBackgroundPanel
[type: boolean] [default: false] 
Boolean determining if a background panel (consisting of a UiPanel) is displayed. The panel automatically changes shape based on the layoutObject.width and layoutObject.height properties. It should be noted that the associated LayoutStack.backgroundPanel member will be undefined until this flag is set to true.





LayoutStack.backgroundPanel
[type: UiPanel] [default: undefined] 
UiPanel that (when displayed) automatically adjusts to the layoutObject.width and layoutObject.height properties of this LayoutStack. It should be noted that this property is undefined unless LayoutStack.displayBackgroundPanel is set to true.





LayoutStack.addElements(elements, index)
[type: function] 
Adds the specified SceneObject(s) as elements to the LayoutStack. Please note that SceneObjects added to LayoutStacks are re-assigned to be children of that LayoutStack. If an added SceneObject has not yet been configured with LayoutObject functionality, the standard LayoutObject configuration will be applied. The LayoutObject configuration of any SceneObject can be customized by calling 'SceneObject.configureLayoutObject' before adding it to a LayoutStack. The LayoutObject configuration is a means by which a LayoutStack can determine the layout dimensions of its elements, inform the elements to refresh their layouts, and be informed by elements to update its layout due to a change in dimensions of the elements.

LayoutStack.addElements parameter: elements
[type: SceneObject, [SceneObject]] 
The SceneObject(s) to add as elements to the LayoutStack.

LayoutStack.addElements parameter: index
[type: number] [default: (pushed to end)] [optional] 
Optional index enabling inserting elements in locations other than at the end of the elements list.





LayoutStack.addSpacerElement(spacerWidth, spacerHeight, index)
[type: function] 
Adds a blank element as a spacer between other elements. For LayoutStacks with standardUiZoomFunctionality enabled, this these spacers will be scaled by nc.uiZoom.totalZoom.

LayoutStack.addSpacerElement parameter: spacerWidth
[type: number] 
The width (in world units) of the spacer to add.

LayoutStack.addSpacerElement parameter: spacerHeight
[type: number] 
The height (in world units) of the spacer to add.

LayoutStack.addSpacerElement parameter: index
[type: number] [default: (pushed to end)] [optional] 
Optional index enabling inserting spacers in locations other than at the end of the elements list.





LayoutStack.removeElementAt(index, dispose)
[type: function] 
Removes the element at the given index.

LayoutStack.removeElementAt parameter: index
[type: number] 
The index of the element to remove.

LayoutStack.removeElementAt parameter: dispose
[type: boolean] [default: true] [optional] 
Boolean determining of the item is disposed.





LayoutStack.getElements()
[type: function] [returns: [SceneObject]] 
Returns a shallow copy of the current array of elements.





LayoutStack.removeElement(element, dispose)
[type: function] 
Removes the given element from the LayoutStack.

LayoutStack.removeElement parameter: element
[type: object] 
The element to remove.

LayoutStack.removeElement parameter: dispose
[type: boolean] [default: true] [optional] 
Boolean determining if the item is disposed.





LayoutStack.clear(dispose)
[type: function] 
Clears all of the elements from the LayoutStack

LayoutStack.clear parameter: dispose
[type: boolean] [default: true] [optional] 
Boolean determining if cleared elements are also disposed.





LayoutStack.justifyAll(justification)
[type: function] 
Applies the given justification to all of the LayoutStack's elements. Calling this method also sets an internal default, so that when new SceneObjects that have never been configured as LayoutObjects are added as elements, the given justification will be applied.

LayoutStack.justifyAll parameter: justification
[type: string] 
The justification to apply to all of the LayoutStack's elements. For a list of justifications see 'nc.constants.justifications'.






















































































































































































































































































































----------------------------------------------------------
Section 65: LazyUpdater
----------------------------------------------------------


LazyUpdater
[type: class] 
Object that manages the calling of a given callback, ensuring that it is only called when necessary. This is often used to ensure that calls to methods that are performance-expensive are as limited as possible. First connect the performance-heavy task via the constructor callback parameters, then later call the 'updateIfNeeded' method; if the 'needsUpdate' flag has been set to true since the last 'updateIfNeeded' call, then callback will occur, otherwise it is skipped. An example of how you can use this is in situation where you are doing manual rendering; you only want to render once per ScreenUpdate, and you don't want to render if nothing substantive has changed in the scene. In this case, you would set the 'needsUpdate' flag to true every time something in the scene is adjusted, and ensure that a call to 'updateIfNeeded' is placed in a ScreenUpdater-driven function.





LazyUpdater.type
[type: string] 
Type identifier.





LazyUpdater.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





LazyUpdater.needsUpdate
[type: boolean] [default: false] 
Flag indicating whether the target method is in need of an update.





LazyUpdater.updateIfNeeded()
[type: function] 
Calls the target method if the 'needsUpdate' flag is true, and sets it to false either way.










----------------------------------------------------------
Section 66: MaterialMaster
----------------------------------------------------------


MaterialMaster
[type: class] [NON-INSTANTIABLE] 
The MaterialMaster is a convenience-based object that represents all of the Materials on a given GraphicObject. To manipulate all of the Materials on a GraphicObject at the same time, you can simply manipulate its MaterialMaster. It should be noted that querying values from the MaterialMaster can be misleading, as the returned values only refer to the last values set on the MaterialMaster itself, and would not reflect individual changes made to the Materials themselves. 





MaterialMaster.type
[type: string] 
Type identifier.





MaterialMaster.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





MaterialMaster.blending
[type: string] 
Sets the 'blending' value for all of this GraphicObject's Materials.





MaterialMaster.auxShaderSegment_vertexSupport
[type: string] 
Sets the 'auxShaderSegment_vertexSupport' value for all of this GraphicObject's Materials.





MaterialMaster.shaderSegment_matrixMath
[type: string] 
Sets the 'shaderSegment_matrixMath' value for all of this GraphicObject's Materials.





MaterialMaster.auxShaderSegment_postMatrixMath
[type: string] 
Sets the 'auxShaderSegment_postMatrixMath' value for all of this GraphicObject's Materials.





MaterialMaster.fillColor
[type: Color] 
The EffectController for the 'FillColor' EffectNode, which entirely fills the associated Geometry with the red, green, blue, and alpha color values provided. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





MaterialMaster.mainTexture
[type: Texture] 
The EffectController for the 'SampleMainTexture' EffectNode that tells it which Texture to render.





MaterialMaster.colorMultiply
[type: Color] 
The EffectController for the 'ColorMultiply' EffectNode, which multiplies the red, green, blue, and alpha color values of the Material it is applied to. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





MaterialMaster.shapify
[type: shapify] 
The EffectController for the 'Shapify' EffectNode. The Shapify EffectNode converts edge data stored in a 'shapified' Texture into a presentable image with edges that stay sharp regardless of the scale of the associated GraphicObject. This is an instance of the dynamically defined EffectController 'shapify' (base type: 'Vector2'). To get a new instance, use "nc.effectControllers['shapify'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





MaterialMaster.shear
[type: shear] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. This is an instance of the dynamically defined EffectController 'shear' (base type: 'Vector3'). To get a new instance, use "nc.effectControllers['shear'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





MaterialMaster.shear_center
[type: Vector2] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





MaterialMaster.setEffectNodes(effectNodes)
[type: function] 
Sets the EffectNodes for all of this GraphicObject's Materials.

MaterialMaster.setEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The new list of EffectNodes that will apply to all of this GraphicObject's Materials.





MaterialMaster.addEffectNodes(effectNodes)
[type: function] 
Adds EffectNodes to all of this GraphicObject's Materials.

MaterialMaster.addEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The EffectNodes that will be added to all of this GraphicObject's Materials.










----------------------------------------------------------
Section 67: Material
----------------------------------------------------------


Material
[type: class] 
Materials are objects that control how the visual 'surfaces' defined in a Geometry are configured and ultimately rendered by WebGL. This visual configuration is managed through the EffectNodes and EffectControllers on each Material.





Material.type
[type: string] 
Type identifier.





Material.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Material.blending
[type: string] [default: nc.constants.blendingModes.standard] 
String determining the blending mode that is applied to this Material. For a list of available blending options, see nc.constants.blendingModes.





Material.auxShaderSegment_vertexSupport
[type: string] [default: ""] 
An auxiliary shader support string that enables for the insertion of GLSL shader code before the vertex shader main. This can be used to add custom functionality to this Material's vertex shader beyond the built-in EffectNode functionality.





Material.shaderSegment_matrixMath
[type: string] [default: "gl_Position=projectionMatrix*(modelViewMatrix*vec4(vertex,1.0));"] 
A shader segment string, determining the GLSL code used in the 'matrix math' segment at the end of the vertex shader. This can be used to customize the vertex shader matrix math.





Material.auxShaderSegment_postMatrixMath
[type: string] [default: ""] 
An auxiliary shader support string that enables for the insertion of GLSL shader code after the 'matrix math' segment of the vertex shader. This can be used to add custom functionality to this Material's vertex shader beyond the standard built-in functionality.





Material.effectNodesLedger
[type: [string]] 
A list of the names of this Material's EffectNodes for quick-reference while debugging or inspecting. To access and manipulate the actual EffectNodes, use Material.getEffectNodes, Material.setEffectNodes, or Material.addEffectNodes.





Material.compiledVertexShader
[type: string] 
The the compiled GLSL vertex shader string for this Material, resulting from combining this Material's EffectNodes. This property is generally only meant for troubleshooting, and is read-only.





Material.compiledFragmentShader
[type: string] 
The the compiled GLSL fragment shader string for this Material, resulting from combining this Material's EffectNodes. This property is generally only meant for troubleshooting, and is read-only.





Material.faceCulling
[type: boolean] [default: false] 
Flag determining if triangles within the geometry that are facing away from the camera should be drawn. Please note that though the default value for this property is false, many GraphicAssets come with Material presets that can override the default.





Material.depthTest
[type: boolean] [default: nc.defaultDepthTesting] 
Flag determining if fragments (pixels) drawn with this Material are tested against other fragment depths (as stored in the depth buffer), ensuring that only the closest fragment is drawn. This flag is useful with geometries that have a full 3D shape such as those from OBJs etc... Please note that though the default value for this property is determined by the current value of nc.defaultDepthTesting, many GraphicAssets come with Material presets that can override the default.





Material.depthWrite
[type: boolean] [default: nc.defaultDepthWriting] 
Flag determining if the depths of fragments (pixels) drawn with this Material are written to the depth buffer, and can therefore be used to occlude other fragments. Please note that though the default value for this property is determined by the current value of nc.defaultDepthWriting, many GraphicAssets come with Material presets that can override the default.





Material.fillColor
[type: Color] 
The EffectController for the 'FillColor' EffectNode, which entirely fills the associated Geometry with the red, green, blue, and alpha color values provided. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





Material.mainTexture
[type: Texture] 
The EffectController for the 'SampleMainTexture' EffectNode that tells it which Texture to render.





Material.colorMultiply
[type: Color] 
The EffectController for the 'ColorMultiply' EffectNode, which multiplies the red, green, blue, and alpha color values of the Material it is applied to. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





Material.shapify
[type: shapify] 
The EffectController for the 'Shapify' EffectNode. The Shapify EffectNode converts edge data stored in a 'shapified' Texture into a presentable image with edges that stay sharp regardless of the scale of the associated GraphicObject. This is an instance of the dynamically defined EffectController 'shapify' (base type: 'Vector2'). To get a new instance, use "nc.effectControllers['shapify'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





Material.shear
[type: shear] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. This is an instance of the dynamically defined EffectController 'shear' (base type: 'Vector3'). To get a new instance, use "nc.effectControllers['shear'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





Material.shear_center
[type: Vector2] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





Material.getEffectNodes()
[type: function] [returns: [EffectNode]] 
Returns this Material's current EffectNodes. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.





Material.setEffectNodes(effectNodes)
[type: function] 
Sets the EffectNodes for this Material. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.

Material.setEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The new list of EffectNodes that will apply to this SceneObject and all of its Materials.





Material.addEffectNodes(effectNodes)
[type: function] 
Adds the given EffectNodes to this Material. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.

Material.addEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The EffectNodes to add to this Material.





Material.dispose()
[type: function] 
Disposes this Material, and removes internal Incisor® references to it to aid memory management.










----------------------------------------------------------
Section 68: Matrix4
----------------------------------------------------------


Matrix4
[type: class] 
A 4x4 Matrix, typically used as a transformation matrix for SceneObjects.





Matrix4.elements
[type: [number]] 
The 16 elements of the 4x4 matrix, stored in column major order. Defaults to the identity matrix.





Matrix4.copy(matrix)
[type: function] 
Sets all of this Matrix4's element values to the element values of the givem Matrix4.

Matrix4.copy parameter: matrix
[type: Matrix4] 
The matrix to copy element values from.





Matrix4.set(element00, element01, element02, element03, element10, element11, element12, element13, element20, element21, element22, element23, element30, element31, element32, element33)
[type: function] 
Sets this Matrix4's elements to the provided values.

Matrix4.set parameter: element00
[type: number] 
Element at column 0, row 0.

Matrix4.set parameter: element01
[type: number] 
Element at column 0, row 1.

Matrix4.set parameter: element02
[type: number] 
Element at column 0, row 2.

Matrix4.set parameter: element03
[type: number] 
Element at column 0, row 3.

Matrix4.set parameter: element10
[type: number] 
Element at column 1, row 0.

Matrix4.set parameter: element11
[type: number] 
Element at column 1, row 1.

Matrix4.set parameter: element12
[type: number] 
Element at column 1, row 2.

Matrix4.set parameter: element13
[type: number] 
Element at column 1, row 3.

Matrix4.set parameter: element20
[type: number] 
Element at column 2, row 0.

Matrix4.set parameter: element21
[type: number] 
Element at column 2, row 1.

Matrix4.set parameter: element22
[type: number] 
Element at column 2, row 2.

Matrix4.set parameter: element23
[type: number] 
Element at column 2, row 3.

Matrix4.set parameter: element30
[type: number] 
Element at column 3, row 0.

Matrix4.set parameter: element31
[type: number] 
Element at column 3, row 1.

Matrix4.set parameter: element32
[type: number] 
Element at column 3, row 2.

Matrix4.set parameter: element33
[type: number] 
Element at column 3, row 3.





Matrix4.clone()
[type: function] [returns: Matrix4] 
Returns a new Matrix4 with the same elements as this Matrix4.





Matrix4.getInverse(matrix)
[type: function] 
Sets this Matrix4 to the inverse of the givem Matrix4. If the Matrix can not be inverted, all elements will be set to 0.

Matrix4.getInverse parameter: matrix
[type: Matrix4] 
The matrix to invert.





Matrix4.multiply(matrix)
[type: function] 
Postmultiplies this Matrix4 by the provided Matrix4.

Matrix4.multiply parameter: matrix
[type: Matrix4] 
The matrix by which this Matrix4 is multiplied.





Matrix4.premultiply(matrix)
[type: function] 
Premultiplies this Matrix4 by the provided Matrix4.

Matrix4.premultiply parameter: matrix
[type: Matrix4] 
The matrix by which this Matrix4 is premultiplied.





Matrix4.multiplyMatrices(matrixA, matrixB)
[type: function] 
Sets this Matrix4 to the result of multiplying the provided Matrix4 parameters.

Matrix4.multiplyMatrices parameter: matrixA
[type: Matrix4] 
The first of the multiplied matrices.

Matrix4.multiplyMatrices parameter: matrixB
[type: Matrix4] 
The second of the multiplied matrices.





Matrix4.toArray(array, offset)
[type: function] [returns: [number]] 
Copies the numbers in the 'elements' array into the provided Array.

Matrix4.toArray parameter: array
[type: [number]] [default: [] [optional] 
The Array to copy the elements into.]

Matrix4.toArray parameter: offset
[type: number] [default: 0] [optional] 
The index in 'array' at which to place the first element.





Matrix4.identity()
[type: function] 
Sets this Matrix4 to the identity matrix.





Matrix4.compose(position, rotation, scale)
[type: function] 
Sets this Matrix4 to a transformation matrix representing the provided position, rotation, and scale.

Matrix4.compose parameter: position
[type: Vector3] 
The position represented by the transformation matrix.

Matrix4.compose parameter: rotation
[type: Vector3] 
The rotation represented by the transformation matrix.

Matrix4.compose parameter: scale
[type: Vector3] 
The scale represented by the transformation matrix.





Matrix4.decompose(position, rotation, scale, forceRotation, forceScale)
[type: function] 
Extracts the position, rotation and scale represented by this Matrix4. Note that it is not always possible to correctly decompose a Matrix4 into these components, such as when the Matrix4 contains skewing/shearing. Also note that multiple valid decompositions of a Matrix4 are possible. For example, a rotation of 180 degrees around the Z axis creates the same Matrix4 as a scale of -1 on the X and Y axes. To address this, the forceRotation and forceScale parameters can be used to indicate that the resulting rotation or scale are already known, and are already contained in the rotation or scale parameters.

Matrix4.decompose parameter: position
[type: Vector3] 
The resulting position.

Matrix4.decompose parameter: rotation
[type: Vector3] 
The resulting rotation. If 'forceRotation' is true, this value is used as input to improve the extraction of scale.

Matrix4.decompose parameter: scale
[type: Vector3] 
The resulting scale. If 'forceScale' is true, this value is used as input to improve the extraction of rotation.

Matrix4.decompose parameter: forceRotation
[type: boolean] [default: false] [optional] 
Determines whether the value in 'rotation' is already set to the known rotation to improve the extraction of scale.

Matrix4.decompose parameter: forceScale
[type: boolean] [default: false] [optional] 
Determines whether the value in 'scale' is already set to the known scale to improve the extraction of rotation.





Matrix4.determinant()
[type: function] [returns: number] 
Returns the determinant of this Matrix4. If this is 0, this Matrix4 can not be inverted.





Matrix4.applyToVector3(vector)
[type: function] 
Applies this Matrix4's transformation to the provided Vector3.

Matrix4.applyToVector3 parameter: vector
[type: Vector3] 
The Vector3 to be transformed by this Matrix4. This vector is modified in place.










----------------------------------------------------------
Section 69: Matrix4Array
----------------------------------------------------------


Matrix4Array
[type: class] 
An internal specialized type used for Spine Animation EffectControllers.










----------------------------------------------------------
Section 70: Motion
----------------------------------------------------------


Motion
[type: class] [NON-INSTANTIABLE] 
Object controlling a 'motion' (continuous change) on a given numeric property or properties (using fixedUpdate). An object of this type is returned from all 'addMotion' calls, providing a means to manage the given motion process. 





Motion.type
[type: string] 
Type identifier.





Motion.name
[type: string] 
Name of the Motion.





Motion.numProperties
[type: number] 
The number of properties being affected by this Motion.





Motion.influence
[type: number] [default: 1] 
Number determining the influence of this Motion over the associated numeric properties where a value of 0 corresponds to the property remaining at its baseValue with no change, and a value of 1 corresponds to the value of the property being entirely determined by the Motion.





Motion.motionSpeed
[type: number] [default: 1] 
Number informing the Motion's rate of increase on its 'progress' value, affecting the overall speed of the motion experienced by the associated properties.





Motion.progress
[type: number] [default: 0] 
The number driving the motionFunction for this motion. In a defined motion over time, this number is equivalent to time. This value is not meant to be manipulated as it is automatically changed over time via the internal fixedUpdate used by this Motion.





Motion.motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] 
The MotionType for this Motion. A MotionType defines a method of continuous change for a given set of numeric properties within a set of bounds over time. The default MotionType is 'Pendulum', which defines a smooth sinusoidal oscillation between the lower and upper bounds. MotionTypes can define any set of continuous motions for a set of numeric properties.





Motion.baseValues
[type: [number]] 
Array containing the base values for this Motion. These are the values that the properties being manipulated will return to if the 'influence' of this Motion is set to 0. Upon initiating a Motion for a given set numeric properties, their current values are stored in this array and used as 'home base' values and blended with the defined motion according to 'influence'.





Motion.currentValues
[type: [number]] 
Array containing the current values for this Motion. These are the values that the MotionType motion function manipulate based its 'progress' property to create the desired movement.





Motion.controllers
[type: MotionControllers] 
Dictionary of dictionaries (per MotionType) of values that can be used to control this motion dynamically.





Motion.lowerBounds
[type: [number]] 
Array containing the lower bound or bounds for the Motion. The length of this array depends on this Motion's 'numProperties'. While MotionType definitions are not all required to adhere to bounds, it is a common practice for MotionTypes result in property motion that is confined to these bounds.





Motion.upperBounds
[type: [number]] 
Array containing the upper bound or bounds for the Motion. The length of this array depends on this Motion's 'numProperties'. While MotionType definitions are not all required to adhere to bounds, it is a common practice for MotionTypes result in property motion that is confined to these bounds.





Motion.workspace
[type: object] 
An un-specified JS object of 'any' type to enable the user to stash persistant elements of their Motion within the motionFunction.





Motion.updaterCallbackOwner
[type: object] [default: undefined] 
The object owning the optional callback function invoked continuously (every fixedUpdate) during the motion process. This callback is only performed while the influence value is larger than 0.





Motion.updaterCallbackName
[type: string] [default: undefined] 
The name of the optional callback function invoked continuously (every fixedUpdate) during the motion process. This callback is only performed while the influence value is larger than 0.





Motion.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] for this Motion to have no pause immunity.





Motion.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.





Motion.swoopInfluence(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) the Motion's influence from its current value to the given end value over the duration.

Motion.swoopInfluence parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

Motion.swoopInfluence parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Motion.swoopInfluence parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Motion.swoopInfluence parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Motion.swoopInfluence parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Motion.swoopInfluence parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Motion.swoopInfluence parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Motion.swoopInfluence parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Motion.swoopInfluence parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Motion.swoopInfluence parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.










----------------------------------------------------------
Section 71: MotionControllers
----------------------------------------------------------


MotionControllers
[type: class] [NON-INSTANTIABLE] 
Dictionary of all registered MotionControllers. 










----------------------------------------------------------
Section 72: MotionType
----------------------------------------------------------


MotionType
[type: class] [NON-INSTANTIABLE] 
Object defining a particular type of motion that can be added to any property or group of properties via 'nc.addMotion' or 'Vector.addMotion'. 





MotionType.type
[type: string] 
Type identifier.





MotionType.name
[type: string] 
Name of the Motion.





MotionType.motionFunction()
[type: function] 
A reference to the function that defines the nature of the motion.





MotionType.motionControllerNames
[type: [string]] 
A list of optional motion controllers. These can be used to dynamically affect the nature of the motion.





MotionType.motionControllerDefaultValues
[type: [number]] 
A list of optional motion controller default values.





MotionType.description
[type: string] 
The description of the MotionType - this will appear in the autocomplete documentation.





MotionType.controllerDescriptions
[type: [string]] 
The description of the MotionType controllers - these descriptions will appear in the autocomplete documentation.










----------------------------------------------------------
Section 73: ParticleSystemDefinition
----------------------------------------------------------


ParticleSystemDefinition
[type: class] [NON-INSTANTIABLE] [requires: module - particleSystems] 
A ParticleSystemDefinition defines the parameters of a ParticleSystem. To decrease the memory needed and time required to instantiate multiple ParticleSystems that use the same parameters, a single definition is created that one or more ParticleSystems then reference.





ParticleSystemDefinition.type
[type: string] 
Type identifier.





ParticleSystemDefinition.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





ParticleSystemDefinition.emissionDuration
[type: number] 
The length of time over which to emit particles. Set to 0 to emit particles forever. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleLifetime
[type: number] 
The amount of time after its emission that each particle dies. Must not be a negative number. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleLifetimeRandomness
[type: number] 
A per particle perturbation of particleLifetime. Each particle chooses a random amount, limited to ± this value, to add to the base value. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emissionTimeRandomness
[type: number] 
A per particle perturbation of that particle's emission time. By default, particles are emitted at evenly spaced intervals. A random number between 0 and this value will added to the default emission time of each particle. Must not be a negative number. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.alpha
[type: number, string, ParticleSystemRamp1] 
The alpha (transparency) to apply to each particle. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.alphaRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'alpha'. Each particle chooses a random amount, limited to ± this value, to modify the alpha. For example, if the value is .2, each particle generates a random number in the range [.8 - 1.2] to multiply with 'alpha' and generate its own unique version of 'alpha'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.color
[type: Vector3, string, ParticleSystemRamp3] 
The color to apply to each particle. This may be set to a Vector3 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp3 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.brightnessRandomness
[type: number, string, ParticleSystemRamp3] 
A per particle perturbation of 'color'. Each particle chooses a random amount, limited to ± this value, to modify the color. For example, if the value is .2, each particle generates a random number in the range [.8 - 1.2] to multiply with 'color' and generate its own unique version of 'color'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp3 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleHueShift
[type: number, string, ParticleSystemRamp1] 
The amount to hue shift each particle. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleparticleHueShiftRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'particleHueShift'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emitterShape
[type: string] 
The shape of the area in which a particle may be created. See nc.constants.particleSystemEmitterShapes for valid values. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.customEmitterShapeExpression
[type: string] 
If emitterShape is set to nc.constants.particleSystemEmitterShapes.Custom, this expression will be used to choose a position for each emitted particle. Note that precomputed random numbers are available as vec4s named rand0 through rand5, though typically rand2.x and rand2.y are used in this context. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emitterShapeDimensions
[type: Vector2, string, ParticleSystemRamp2] 
The dimensions of the emitter shape. Use different values for X and Y to create oblong shapes. This may be set to a Vector2 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emissionVelocity
[type: Vector2, string, ParticleSystemRamp2] 
The velocity with which particles are emitted away from their initial position. The magnitude of this vector indicates the initial speed of the particles. Note that 'emissionConeAngle' causes particles to emit in a cone centered around this direction. This may be set to a Vector2 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emissionVelocityRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of the magnitude of 'emissionVelocity'. Each particle chooses a random amount, limited to ± this value, to modify the magnitude of 'emissionVelocity'. For example, if the value is .2, each particle generates a random number in the range [.8 - 1.2] to multiply with 'emissionVelocity' and generate its own unique version of 'emissionVelocity'. Thus, particles are emitted with varying velocities. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emissionConeAngle
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of the angle of 'emissionVelocity'. Each particle chooses a random amount, limited to ± half of this value in degrees, to modify the angle of 'emissionVelocity'. For example, if the value is 90 degrees, each particle will generate a unique version of 'emissionVelocity' randomly placed within ±45 degrees of 'emissionVelocity'. Thus, particles are emitted in a 90 degree cone. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.emitterPosition
[type: Vector2, string, ParticleSystemRamp2] 
The position with respect to the ParticleSystem's origin from which to emit particles. Note that when moving the ParticleSystem SceneObject itself, particles previoiusly emitted are also moved, which can look unnatural. By expressiong the emitter position as an expression or ParticleSystemRamp2, the ParticleSystem is able to maintain the trajectories of previously emitted particles while the emitter moves. This may be set to a Vector2 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.force
[type: Vector2, string, ParticleSystemRamp2] 
The force constantly applied to each particle. Commonly used to simulate gravity. This may be set to a Vector2 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.forceRandomness
[type: number, string, ParticleSystemRamp2] 
A per particle perturbation of 'force'. Each particle chooses a random amount, limited to ± this value, to modify the force. For example, if the value is .2, each particle generates a random number in the range [.8 - 1.2] to multiply with 'force' and generate its own unique version of 'force'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.extraVelocityX
[type: number, string, ParticleSystemRamp1] 
An extra amount always added to the X component of each particle's velocity. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.extraVelocityXRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'extraVelocityX'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization. Second line





ParticleSystemDefinition.extraVelocityY
[type: number, string, ParticleSystemRamp1] 
An extra amount always added to the Y component of each particle's velocity. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.extraVelocityYRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'extraVelocityY'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.motionStretch
[type: number, string, ParticleSystemRamp1] 
The amount by which to stretch each particle in the direction in which is is moving. Particles that are moving faster stretch further. This is typically used as a high performance approximation of motion blur. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.motionStretchAlphaInfluence
[type: number, string, ParticleSystemRamp1] 
The amount by which a particle's stretch, as caused by 'motionStretch', reduces its alpha. This is typically used as a high performance approximation of motion blur. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.ageRemap
[type: string] 
An expression used to remap particle age values to a new value. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSpeed
[type: number, string, ParticleSystemRamp1] 
The speed at which each particle rotates, in degrees per second. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSpeedRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'rotationSpeed'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.initialRotation
[type: number, string, ParticleSystemRamp1] 
The rotation in degrees of each particle when it is emitted. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.initialRotationRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'initialRotation'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwayStrength
[type: number, string, ParticleSystemRamp1] 
The maximum rotation, in degrees, that a particle will reach by oscillating its rotation. Note that this is additively combined with the result of 'rotationSpeed'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwayStrengthRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'rotationSwayStrength'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwaySpeed
[type: number, string, ParticleSystemRamp1] 
The speed at which to oscillate, in cycles/second, if rotationSwayStrength is not 0. Note that this is additively combined with the result of 'rotationSpeed'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwaySpeedRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'rotationSwaySpeed'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwayPhase
[type: number, string, ParticleSystemRamp1] 
A phase shift to the oscillation, if rotationSwayStrength is not 0. Effectively skips to a different point in the oscillation pattern. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.rotationSwayPhaseRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'rotationSwayPhase'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleStrengthX
[type: number, string, ParticleSystemRamp1] 
The distance to wiggle the particle in the X direction around the point where it would otherwise be. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleStrengthXRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'wiggleStrengthX'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleStrengthY
[type: number, string, ParticleSystemRamp1] 
The distance to wiggle the particle in the Y direction around the point where it would otherwise be. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleStrengthYRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'wiggleStrengthY'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleSpeedX
[type: number, string, ParticleSystemRamp1] 
The speed at which to wiggle the particle in the X direction around the point where it would otherwise be. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleSpeedXRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'wiggleSpeedX'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleSpeedY
[type: number, string, ParticleSystemRamp1] 
The speed at which to wiggle the particle in the Y direction around the point where it would otherwise be. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleSpeedYRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of 'wiggleSpeedY'. Each particle chooses a random amount, limited to ± this value, to add to the base value. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.wiggleCircularStrength
[type: number, string, ParticleSystemRamp1] 
Used to constrain wiggling particles to a circle shape. At a 'wiggleCircularStrength' of 0, a particle wiggling eqully on X and Y is allowed to move within the bounds of a square. At a 'wiggleCircularStrength' of 1, a particle wiggling eqully on X and Y is only allowed to move within the bounds of a circle. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleScale
[type: Vector2, string, ParticleSystemRamp2] 
The scale to apply to each particle. This may be set to a Vector2 to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp2 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.particleScaleRandomness
[type: number, string, ParticleSystemRamp1] 
A per particle perturbation of the magnitude of 'particleScale'. Each particle chooses a random amount, limited to ± this value, to modify the magnitude of 'particleScale'. For example, if the value is .2, each particle generates a random number in the range [.8 - 1.2] to multiply with 'particleScale' and generate its own unique version of 'particleScale'. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.randomnessDistribution
[type: number, string, ParticleSystemRamp1] 
The amount to bias all random numbers toward the center of their range. Typically ranges from 0 (no bias) to 1 (random numbers from -1 to 1 are squared, pulling them toward 0). However, values outside this range may be used for varying effects. This may be set to a number to apply a constant value, a string to apply a GLSL expression, or a ParticleSystemRamp1 to apply a value that changes based on a particle's age or time of emission. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleSystemDefinition.randomizeOnPlay
[type: boolean] 
This is the default value of randomizeOnPlay for any ParticleSystem instantiated using this ParticleSystemDefinition. Note that the value of randomizeOnPlay for each ParticleSystem instance can then be changed independently. When true, the ParticleSystem will automatically call randomize() each time it is restarted, including when playback loops.





ParticleSystemDefinition.particlePoolCount
[type: number] 
The total number of particles that are required by this ParticleSystemDefinition. Because particles that have 'died' can often be reused as later particles, this number will often be less than the total number seen throughout the ParticleSystem's playback.





ParticleSystemDefinition.effectNodeName
[type: string] 
The name of the EffectNode automatically created by this ParticleSystemDefinition. Useful when altering the EffectNodes of a ParticleSystem, because without this EffectNode applied, the ParticleSystem behavior will be lost.





ParticleSystemDefinition.particleDrawOrderSeed
[type: number] 
When 'graphicAssets' contains multiple GraphicAssets, the draw order of all the particles is shuffled to randomly interleave the particles. This seed will deterministically alter the outcome of this shuffle, creating a different draw order of the particles. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization. To randomize the behavior of a ParticleSystem without this costly rebuild, see ParticleSystem.randomize().





ParticleSystemDefinition.getParticleInfo()
[type: function] [returns: [ParticleInfo]] 
Returns the ParticleInfo objects used to populate the ParticleSystem.





ParticleSystemDefinition.setParticleInfo(particleInfo)
[type: function] 
Sets the ParticleInfo objects used to populate the ParticleSystem.

ParticleSystemDefinition.setParticleInfo parameter: particleInfo
[type: [ParticleInfo], ParticleInfo] 
Array of ParticleInfo objects used to populate the ParticleSystem.










----------------------------------------------------------
Section 74: ParticleSystem
----------------------------------------------------------


ParticleSystem
[type: class] [extends: GraphicObject] [requires: module - particleSystems] 
A ParticleSystem uses the Geometry and EffectNode create by a ParticleSystemDefinition to manage the behavior of many particles contained within a single SceneObject. To reduce the number of SceneObjects, all particles in a single ParticleSystem are merged into one SceneObject and their behavior is controlled by the EffectNode created by the ParticleSystemDefinition.





ParticleSystem.type
[type: string] 
Type identifier.





ParticleSystem.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





ParticleSystem.definition
[type: ParticleSystemDefinition] 
Dictionary object listing all of the types this object is compatible with.





ParticleSystem.playbackController
[type: PlaybackController] 
The PlaybackController managing the ParticleSystem's playback.





ParticleSystem.randomize()
[type: function] 
Randomly picks a new value for the material's particleSystemRandomSeed EffectController, which seeds the random number generation used in the ParticleSystem's EffectNode. The particleSystemRandomSeed EffectController can also be directly set to a desired value. Suggested values are in the range [0, 10].





ParticleSystem.stopEmitting(disableAfterParticlesDie)
[type: function] 
Forces the ParticleSystem to stop creating new particles. Previously emitted particles will not be affected and will be allowed to proceed to the end of their life. Commonly used to dynamically decide the duration of a ParticleSystem that is emitting infinitely, but can also stop a ParticleSystem with a known duration early.

ParticleSystem.stopEmitting parameter: disableAfterParticlesDie
[type: boolean] 
If true, the ParticleSystem will be automatically disabled at the latest possible time one of the existing particles could die.























































































































































































































































































































































































----------------------------------------------------------
Section 75: ParticleSystemRamp
----------------------------------------------------------


ParticleSystemRamp
[type: class] [NON-INSTANTIABLE] [requires: module - particleSystems] 






ParticleSystemRamp.inputType
[type: string] 
The input type used when evaluating. See nc.particleSystemRampInputTypes for valid values.





ParticleSystemRamp.inputMaximum
[type: number] 
When using inputType equal to 'EmissionTime', the emission time is divided by this number and the fractional component of the result is used to look up a value in the ramp. This means that particles emitted after this time will use values that wrap around to the beginning of the ramp. When using a non-infinite emissionDuration, it is common to set this value to emissionDuration + emissionTimeRandomness so that the ramp applies over the duration of the particle emission.





ParticleSystemRamp.interpolationType
[type: string] 
The type of interpolation to apply between the keyframes. See nc.constants.particleSystemRampInterpolationTypes for valid values.





ParticleSystemRamp.type
[type: string] 
Type identifier.





ParticleSystemRamp.refreshKeyframeOrder()
[type: function] 
Refreshes the order of the keyframes, ensuring they are stored in order of increasing time.





ParticleSystemRamp.removeKeyframe(x)
[type: function] 
Removes the keyframe with the given time value.

ParticleSystemRamp.removeKeyframe parameter: x
[type: number] 
The time value of the keyframe to remove. If no such keyframe exists, nothing is removed.










----------------------------------------------------------
Section 76: ParticleSystemRamp1
----------------------------------------------------------


ParticleSystemRamp1
[type: class] [requires: module - particleSystems] 
Object representing keyframes with number values used by ParticleSystemDefinition members.





ParticleSystemRamp1.values
[type: Array] 
Array of keyframes representing the ramp. Each keyframe is specified as an array with two elements. The first element must be a number representing the time of the keyframe. Ramp evaluations are performed in the range 0-1, but keyframes may specify times outside this range. The second element must be a number.]





ParticleSystemRamp1.addKeyframe(x, y)
[type: function] 
Adds a new keyframe. If a keyframe already exists at this time value, it is overwritten.

ParticleSystemRamp1.addKeyframe parameter: x
[type: number] 
The time value for this keyframe.

ParticleSystemRamp1.addKeyframe parameter: y
[type: number] 
The value stored at this keyframe.





ParticleSystemRamp1.isEqual(particleSystemRamp1)
[type: function] [returns: boolean] 
Tests whether another ParticleSystemRamp1 has identical contents to this ParticleSystemRamp1.

ParticleSystemRamp1.isEqual parameter: particleSystemRamp1
[type: ParticleSystemRamp1] 
The ParticleSystemRamp1 to compare to.










----------------------------------------------------------
Section 77: ParticleSystemRamp2
----------------------------------------------------------


ParticleSystemRamp2
[type: class] [extends: ParticleSystemRamp] [requires: module - particleSystems] 
Object representing keyframes with Vector2 values used by ParticleSystemDefinition members.





ParticleSystemRamp2.values
[type: Array] 
Array of keyframes representing the ramp. Each keyframe is specified as an array with two elements. The first element must be a number representing the time of the keyframe. Ramp evaluations are performed in the range 0-1, but keyframes may specify times outside this range. The second element must be a Vector2.]





ParticleSystemRamp2.addKeyframe(x, y)
[type: function] 
Adds a new keyframe. If a keyframe already exists at this time value, it is overwritten.

ParticleSystemRamp2.addKeyframe parameter: x
[type: number] 
The time value for this keyframe.

ParticleSystemRamp2.addKeyframe parameter: y
[type: Vector2] 
The value stored at this keyframe.





ParticleSystemRamp2.isEqual(particleSystemRamp2)
[type: function] [returns: boolean] 
Tests whether another ParticleSystemRamp2 has identical contents to this ParticleSystemRamp2.

ParticleSystemRamp2.isEqual parameter: particleSystemRamp2
[type: ParticleSystemRamp2] 
The ParticleSystemRamp2 to compare to.








































----------------------------------------------------------
Section 78: ParticleSystemRamp3
----------------------------------------------------------


ParticleSystemRamp3
[type: class] [extends: ParticleSystemRamp] [requires: module - particleSystems] 
Object representing keyframes with Vector3 values used by ParticleSystemDefinition members.





ParticleSystemRamp3.values
[type: Array] 
Array of keyframes representing the ramp. Each keyframe is specified as an array with two elements. The first element must be a number representing the time of the keyframe. Ramp evaluations are performed in the range 0-1, but keyframes may specify times outside this range. The second element must be a Vector3.]





ParticleSystemRamp3.addKeyframe(x, y)
[type: function] 
Adds a new keyframe. If a keyframe already exists at this time value, it is overwritten.

ParticleSystemRamp3.addKeyframe parameter: x
[type: number] 
The time value for this keyframe.

ParticleSystemRamp3.addKeyframe parameter: y
[type: Vector3] 
The value stored at this keyframe.





ParticleSystemRamp3.isEqual(particleSystemRamp3)
[type: function] [returns: boolean] 
Tests whether another ParticleSystemRamp3 has identical contents to this ParticleSystemRamp3.

ParticleSystemRamp3.isEqual parameter: particleSystemRamp3
[type: ParticleSystemRamp3] 
The ParticleSystemRamp3 to compare to.








































----------------------------------------------------------
Section 79: ParticleSystemRamp4
----------------------------------------------------------


ParticleSystemRamp4
[type: class] [extends: ParticleSystemRamp] [requires: module - particleSystems] 
Object representing keyframes with Vector4 values used by ParticleSystemDefinition members.





ParticleSystemRamp4.values
[type: Array] 
Array of keyframes representing the ramp. Each keyframe is specified as an array with two elements. The first element must be a number representing the time of the keyframe. Ramp evaluations are performed in the range 0-1, but keyframes may specify times outside this range. The second element must be a Vector4.]





ParticleSystemRamp4.addKeyframe(x, y)
[type: function] 
Adds a new keyframe. If a keyframe already exists at this time value, it is overwritten.

ParticleSystemRamp4.addKeyframe parameter: x
[type: number] 
The time value for this keyframe.

ParticleSystemRamp4.addKeyframe parameter: y
[type: Vector4] 
The value stored at this keyframe.





ParticleSystemRamp4.isEqual(particleSystemRamp4)
[type: function] [returns: boolean] 
Tests whether another ParticleSystemRamp4 has identical contents to this ParticleSystemRamp4.

ParticleSystemRamp4.isEqual parameter: particleSystemRamp4
[type: ParticleSystemRamp4] 
The ParticleSystemRamp4 to compare to.








































----------------------------------------------------------
Section 80: ParticleInfo
----------------------------------------------------------


ParticleInfo
[type: class] [requires: module - particleSystems] 
Object to allow adding graphics to a ParticleSystem with different emission rates and relative scales.





ParticleInfo.graphicAsset
[type: GraphicAsset] 
The GraphicAsset to add for this particle. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleInfo.particlesPerSecond
[type: number] 
The number of this particle to add ever second of 'emissionDuration'. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleInfo.scale
[type: number] 
The scale to apply to each of these particles. Useful for reusing assets with mismatched scales in the same particle system. Note that changing this value at run time causes a costly rebuild of the particle system and is only recommended during initialization.





ParticleInfo.clone()
[type: function] 
Returns a deep copy of this ParticleInfo instance.










----------------------------------------------------------
Section 81: ParticleSystemDefinitions
----------------------------------------------------------


ParticleSystemDefinitions
[type: class] [NON-INSTANTIABLE] 
Dictionary of all registered ParticleSystemDefinitions. 










----------------------------------------------------------
Section 82: Paths
----------------------------------------------------------


Paths
[type: class] [NON-INSTANTIABLE] 
Object housing functionality manipulate paths including 'splitPath', 'getFileName', and 'getParentDirectory'. 





Paths.projectPath
[type: string] [requires: unpublished only] 
The path to the project directory.





Paths.applicationSupportPath
[type: string] [requires: unpublished only] 
The path to the application support directory.





Paths.desktopPath
[type: string] [requires: unpublished only] 
The path to the desktop.





Paths.userDirectoryPath
[type: string] [requires: unpublished only] 
The path to the current user directory.





Paths.splitPath(path)
[type: function] [returns: [string]] 
Returns an array of separated path components. All paths in Incisor® use '\' as a path separator.

Paths.splitPath parameter: path
[type: string] 
The path to split.





Paths.getFileName(path)
[type: function] [returns: string] 
Returns the name of the last path component of the provided path. All paths in Incisor® use '\' as a path separator.

Paths.getFileName parameter: path
[type: string] 
The path to return the last path component of.





Paths.getParentDirectory(path)
[type: function] [returns: string] 
Returns the provided path minus the last path component. All paths in Incisor® use '\' as a path separator.

Paths.getParentDirectory parameter: path
[type: string] 
The path to return the last path component of.










----------------------------------------------------------
Section 83: Pdf
----------------------------------------------------------


Pdf
[type: class] [requires: unpublished only, license - pdfs] 
Object that can be used to define a PDF file, which can then be written to disk.





Pdf.type
[type: string] 
Type identifier.





Pdf.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Pdf.defaultFontSize
[type: number] [default: 40] 
The default font size for text within this Pdf.





Pdf.defaultFontName
[type: string] [default: "Noto Sans"] 
The default font for text within this Pdf. Please note that any fonts (ttf or otf files) used within Pdfs must reside within the 'Pdf Fonts' directory of the Incisor® application support directory, which can be accessed from the Incisor® menu.





Pdf.defineFont(name, regularFontFileName, boldFontFileName, italicFontFileName, boldItalicFontFileName)
[type: function] 
Defines a new font that can be used within this Pdf. Please note that any fonts (ttf or otf files) used within Pdfs must reside within the 'Pdf Fonts' directory of the Incisor® application support directory, which can be accessed from the Incisor® menu.

Pdf.defineFont parameter: name
[type: string] 
The name of the newly defined font to be made available to use within this Pdf.

Pdf.defineFont parameter: regularFontFileName
[type: string] 
The name of the font file (within the application support 'Pdf Fonts' directory) to be used for regular text.

Pdf.defineFont parameter: boldFontFileName
[type: string] [default: regularFontFileName] [optional] 
The name of the font file (within the application support 'Pdf Fonts' directory) to be used for bold text.

Pdf.defineFont parameter: italicFontFileName
[type: string] [default: regularFontFileName] [optional] 
The name of the font file (within the application support 'Pdf Fonts' directory) to be used for italic text.

Pdf.defineFont parameter: boldItalicFontFileName
[type: string] [default: regularFontFileName] [optional] 
The name of the font file (within the application support 'Pdf Fonts' directory) to be used for bold italic text.





Pdf.addSection()
[type: function] [returns: PdfSection] 
Adds a new PdfSection to this Pdf and returns it. A PdfSection is a group of pages with a shared style.





Pdf.writePdf(filePath, isPathRelative)
[type: function] 
Writes the Pdf file to the given path.

Pdf.writePdf parameter: filePath
[type: string] 
The relative or absolute path for the file to be written.

Pdf.writePdf parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.










----------------------------------------------------------
Section 84: PdfSection
----------------------------------------------------------


PdfSection
[type: class] [NON-INSTANTIABLE] 
A PdfSection is an object defining a group of pages within a Pdf that all share the same page style. To make a new PdfSection, call 'addSection' on the Pdf you wish to add the section to. 





PdfSection.type
[type: string] 
Type identifier.





PdfSection.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfSection.pageWidth
[type: number] [default: 2550] 
The width of the pages within this PdfSection.





PdfSection.pageHeight
[type: number] [default: 3300] 
The height of the pages within this PdfSection.





PdfSection.leftMargin
[type: number] [default: 150] 
The size of the left margin of the pages within this PdfSection.





PdfSection.rightMargin
[type: number] [default: 150] 
The size of the right margin of the pages within this PdfSection.





PdfSection.topMargin
[type: number] [default: 150] 
The size of the top margin of the pages within this PdfSection.





PdfSection.bottomMargin
[type: number] [default: 150] 
The size of the bottom margin of the pages within this PdfSection.





PdfSection.backgroundImage
[type: PdfImage] [default: undefined] 
The path of the backgroundImage within this PdfSection.





PdfSection.header
[type: PdfHeader] 
The header element for this PdfSection.





PdfSection.footer
[type: PdfFooter] 
The footer element for this PdfSection.





PdfSection.addParagraph()
[type: function] [returns: PdfParagraph] 
Adds a new PdfParagraph to this PdfSection and returns it. A PdfParagraph is simply a block of text.





PdfSection.addBackgroundImage(imagePath, isPathRelative, justificationH, justificationV)
[type: function] 
Adds a background image to this PdfSection.

PdfSection.addBackgroundImage parameter: imagePath
[type: string] 
The path of the background image being added within this PdfSection.

PdfSection.addBackgroundImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfSection.addBackgroundImage parameter: justificationH
[type: string] [default: "center"] [optional] 
The horizontal justification of the background image being added to this PdfSection. For acceptable values, see 'nc.constants.justfications'.

PdfSection.addBackgroundImage parameter: justificationV
[type: string] [default: "center"] [optional] 
The vertical justification of the background image being added to this PdfSection. For acceptable values, see 'nc.constants.justfications'.





PdfSection.addImage(imagePath, isPathRelative, justificationH, justificationV)
[type: function] [returns: PdfImage] 
Adds a new Image to this PdfSection and returns it.

PdfSection.addImage parameter: imagePath
[type: string] 
The path of the image being added within this PdfSection.

PdfSection.addImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfSection.addImage parameter: justificationH
[type: string] [default: "center"] [optional] 
The horizontal justification of the image being added to this PdfSection. For acceptable values, see 'nc.constants.justfications'.

PdfSection.addImage parameter: justificationV
[type: string] [default: "center"] [optional] 
The vertical justification of the image being added to this PdfSection. For acceptable values, see 'nc.constants.justfications'.





PdfSection.addTable(numRows, numCols, columnWidths)
[type: function] [returns: PdfTable] 
Adds a new PdfTable to this PdfSection and returns it.

PdfSection.addTable parameter: numRows
[type: number] 
The number of rows to add to this PdfTable.

PdfSection.addTable parameter: numCols
[type: number] 
The number of columns to add to each PdfRow in this PdfTable.

PdfSection.addTable parameter: columnWidths
[type: [number], number] 
An array containing the desired widths for each column in this PdfTable.





PdfSection.addTextFrame(width, height)
[type: function] [returns: PdfTextFrame] 
Adds a new PdfTextFrame to this PdfSection and returns it.

PdfSection.addTextFrame parameter: width
[type: number] 
The width of the PdfTextFrame being added.

PdfSection.addTextFrame parameter: height
[type: number] 
The height of the PdfTextFrame being added.





PdfSection.addPageBreak()
[type: function] 
Adds a page break after this PdfSection.





PdfSection.setMargins(margin)
[type: function] 
Sets all the margins of this PdfSection to a specified value.

PdfSection.setMargins parameter: margin
[type: number] 
Value to set all margins on this PdfSection to.










----------------------------------------------------------
Section 85: PdfParagraph
----------------------------------------------------------


PdfParagraph
[type: class] [NON-INSTANTIABLE] 
A PdfParagraph is an object defining a block of text and the associated formatting within a Pdf. To make a new PdfParagraph, call 'addParagraph' on the PdfSection, PdfCell, PdfHeader or PdfFooter, you wish to add the block of text to. 





PdfParagraph.type
[type: string] 
Type identifier.





PdfParagraph.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfParagraph.text
[type: string] [default: ""] 
The text to be displayed in this PdfParagraph.





PdfParagraph.justificationH
[type: string] [default: "center"] 
The justification of the text in this PdfParagraph. For acceptable values, see 'nc.constants.justfications'.





PdfParagraph.fontName
[type: string] [default: defaultFontName] 
The name of the font that will be used to render the text in this PdfParagraph. This value will default to the defualtFontName value of the containing Pdf. To use a new font, you must define it using "Pdf.defineFont", and also ensure that the associated font files are in the 'Pdf Fonts' directory of the Incisor® application support directory, which can be accessed from the Incisor® menu.





PdfParagraph.fontColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the text in this PdfParagraph.





PdfParagraph.fontSize
[type: number] [default: defaultFontSize] 
The height of the pages within this PdfSection. This value will default to the defaultFontSize value of the containing Pdf.





PdfParagraph.spaceAfter
[type: number] [default: 0] 
The space size that will be added after this PdfParagraph.





PdfParagraph.spaceBefore
[type: number] [default: 0] 
The space size that will be added before this PdfParagraph.





PdfParagraph.leftIndent
[type: number] [default: 0] 
The left indentation amount of this PdfParagraph.





PdfParagraph.rightIndent
[type: number] [default: 0] 
The right indentation amount of this PdfParagraph.





PdfParagraph.bold
[type: boolean] [default: false] 
Boolean determining if the text in this PdfParagraph should be bold.





PdfParagraph.italic
[type: boolean] [default: false] 
Boolean determining if the text in this PdfParagraph should be italicized.





PdfParagraph.underline
[type: string] [default: ""] 
The underline type of the text in this PdfPagraph. For acceptable values, see 'nc.constants.pdfUnderlineTypes'.





PdfParagraph.addPageField()
[type: function] 
Adds a page number to the end of this PdfParagraph.










----------------------------------------------------------
Section 86: PdfHeader
----------------------------------------------------------


PdfHeader
[type: class] [NON-INSTANTIABLE] 
A PdfHeader is an object defining a heading element and the associated formatting within a PdfSection. Each section has exactly one PdfHeader. 





PdfHeader.type
[type: string] 
Type identifier.





PdfHeader.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfHeader.addParagraph()
[type: function] [returns: PdfParagraph] 
Adds a new PdfParagraph to this PdfHeader and returns it. A PdfParagraph is simply a block of text.





PdfHeader.addImage(imagePath, isPathRelative, justificationH, justificationV)
[type: function] [returns: PdfImage] 
Adds a new Image to this PdfHeader and returns it.

PdfHeader.addImage parameter: imagePath
[type: string] 
The path of the image being added to this PdfHeader.

PdfHeader.addImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfHeader.addImage parameter: justificationH
[type: string] [optional] 
The horizontal justification of the image being added to this PdfHeader. For acceptable values, see 'nc.constants.justfications'.

PdfHeader.addImage parameter: justificationV
[type: string] [optional] 
The vertical justification of the image being added this PdfHeader. For acceptable values, see 'nc.constants.justfications'.





PdfHeader.addTable(numRows, numCols, columnWidths)
[type: function] [returns: PdfTable] 
Adds a new PdfTable to this PdfHeader and returns it.

PdfHeader.addTable parameter: numRows
[type: number] 
The number of rows to add to this PdfTable.

PdfHeader.addTable parameter: numCols
[type: number] 
The number of columns to add to each PdfRow in this PdfTable.

PdfHeader.addTable parameter: columnWidths
[type: [number], number] 
An array containing the desired widths for each column in this PdfTable.





PdfHeader.addTextFrame(width, height)
[type: function] [returns: PdfTextFrame] 
Adds a new PdfTextFrame to this PdfSection and returns it.

PdfHeader.addTextFrame parameter: width
[type: number] 
The width of the PdfTextFrame being added.

PdfHeader.addTextFrame parameter: height
[type: number] 
The height of the PdfTextFrame being added.










----------------------------------------------------------
Section 87: PdfFooter
----------------------------------------------------------


PdfFooter
[type: class] [NON-INSTANTIABLE] 
A PdfFooter is an object defining the footer element and associated formatting within a PdfSection. * Each section has exactly one PdfFooter. 





PdfFooter.type
[type: string] 
Type identifier.





PdfFooter.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfFooter.addParagraph()
[type: function] [returns: PdfParagraph] 
Adds a new PdfParagraph to this PdfHeader and returns it. A PdfParagraph is simply a block of text.





PdfFooter.addImage(imagePath, isPathRelative, justificationH, justificationV)
[type: function] [returns: PdfImage] 
Adds a new Image to this PdfFooter and returns it.

PdfFooter.addImage parameter: imagePath
[type: string] 
The path of the image being added to this PdfFooter.

PdfFooter.addImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfFooter.addImage parameter: justificationH
[type: string] [default: "center"] [optional] 
The horizontal justification of the image being added to this PdfFooter. For acceptable values, see 'nc.constants.justfications'.

PdfFooter.addImage parameter: justificationV
[type: string] [default: "center"] [optional] 
The vertical justification of the image being added to this PdfFooter. For acceptable values, see 'nc.constants.justfications'.





PdfFooter.addTable(numRows, numCols, columnWidths)
[type: function] [returns: PdfTable] 
Adds a new PdfTable to this PdfFooter and returns it.

PdfFooter.addTable parameter: numRows
[type: number] 
The number of rows to add to this PdfTable.

PdfFooter.addTable parameter: numCols
[type: number] 
The number of columns to add to each PdfRow in this PdfTable.

PdfFooter.addTable parameter: columnWidths
[type: [number], number] 
An array containing the desired widths for each column in this PdfTable.





PdfFooter.addTextFrame(width, height)
[type: function] [returns: PdfTextFrame] 
Adds a new PdfTextFrame to this PdfSection and returns it.

PdfFooter.addTextFrame parameter: width
[type: number] 
The width of the PdfTextFrame being added.

PdfFooter.addTextFrame parameter: height
[type: number] 
The height of the PdfTextFrame being added.










----------------------------------------------------------
Section 88: PdfImage
----------------------------------------------------------


PdfImage
[type: class] 
A PdfImage is an object defining an image element within a Pdf. A PdfImage can reside within a PdfSection, PdfHeader, PdfFooter or PdfCell.





PdfImage.type
[type: string] 
Type identifier.





PdfImage.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfImage.isPathLocal
[type: boolean] [default: true] 






PdfImage.imagePath
[type: string] [default: ""] 






PdfImage.justificationH
[type: string] [default: "center"] 
The horizontal justification of this PdfImage. For acceptable values, see 'nc.constants.justfications'.





PdfImage.justificationV
[type: string] [default: "center"] 
The vertical justification of this PdfImage For acceptable values, see 'nc.constants.justfications'.





PdfImage.scaleWidth
[type: number] [default: 1.0] 
The horizontal scale of this PdfImage.





PdfImage.scaleHeight
[type: number] [default: 1.0] 
The vertical scale of this PdfImage.





PdfImage.scaleImage(scaleValue)
[type: function] 
Sets the horizontal and vertical scales of this PdfImage.

PdfImage.scaleImage parameter: scaleValue
[type: number] 
The factor to scale the image by.










----------------------------------------------------------
Section 89: PdfTable
----------------------------------------------------------


PdfTable
[type: class] [NON-INSTANTIABLE] 
A PdfTable is an object that represents a table element within a Pdf A PdfTable can reside within a PdfSection, PdfHeader or PdfFooter. 





PdfTable.type
[type: string] 
Type identifier.





PdfTable.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfTable.totalWidth
[type: number] [default: 0] 
The total width of this PdfTable. This value is derived by adding up each column width in the table.





PdfTable.leftBorderThickness
[type: number] [default: 10] 
The thickness of the left border in this PdfTable.





PdfTable.rightBorderThickness
[type: number] [default: 10] 
The thickness of the right border in this PdfTable.





PdfTable.bottomBorderThickness
[type: number] [default: 10] 
The thickness of the bottom border in this PdfTable.





PdfTable.topBorderThickness
[type: number] [default: 10] 
The thickness of the top border in this PdfTable.





PdfTable.diagonalDownThickness
[type: number] [default: 0] 
The thickness of the diagonalDown (top left to bottom right diagonal) in this PdfTable.





PdfTable.diagonalUpThickness
[type: number] [default: 0] 
The thickness of the diagonalUp (top right to bottom left diagonal) in this PdfTable.





PdfTable.leftBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the left border in this PdfTable.





PdfTable.rightBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the right border in this PdfTable.





PdfTable.bottomBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the bottom border in this PdfTable.





PdfTable.topBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the top border in this PdfTable.





PdfTable.diagonalDownColor
[type: Color] [default: Color(1,1,1,1)] 
The color of the diagonalDown (top left to bottom right diagonal) in this PdfTable.





PdfTable.diagonalUpColor
[type: Color] [default: Color(1,1,1,1)] 
The thickness of the diagonalUp (top right to bottom left diagonal) in this PdfTable.





PdfTable.rows
[type: [PdfRow]] [default: []] 
An array containing the PdfRows that reside in this PdfTable.





PdfTable.numColumns
[type: number] [default: 0] 
The number of columns for each row in this PdfTable.





PdfTable.setBorder(thickness, color)
[type: function] 
Sets the thickness and color for all borders in this PdfTable.

PdfTable.setBorder parameter: thickness
[type: number] [optional] 
The thickness to set all borders to.

PdfTable.setBorder parameter: color
[type: Color] [optional] 
The color to set all borders to.





PdfTable.addRow()
[type: function] 
Adds a PdfRow to this PdfTable.





PdfTable.getCell(row, column)
[type: function] [returns: PdfCell, undefined] 
Returns the PdfCell at the given row and column if it exists.

PdfTable.getCell parameter: row
[type: number] 
The row of the cell to get.

PdfTable.getCell parameter: column
[type: number] 
The column of the cell to get.










----------------------------------------------------------
Section 90: PdfRow
----------------------------------------------------------


PdfRow
[type: class] [NON-INSTANTIABLE] 
A PdfRow is an object that represents a row that resides within a PdfTable. 





PdfRow.type
[type: string] 
Type identifier.





PdfRow.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfRow.height
[type: number] [default: 50] 
The height of this PdfRow.





PdfRow.heightRule
[type: string] [default: "autoFit"] 
Setting that determines how the height of a row is calculated in this table. For acceptable values, see 'nc.constants.pdfHeightRuleTypes'.





PdfRow.cells
[type: [PdfCell]] [default: []] 
Array of PdfCells that reside within this PdfRow.










----------------------------------------------------------
Section 91: PdfCell
----------------------------------------------------------


PdfCell
[type: class] [NON-INSTANTIABLE] 
A PdfCell is an object that resides within a PdfRow and can contain PdfParagraphs, PdfImages and PdfTables within it. 





PdfCell.type
[type: string] 
Type identifier.





PdfCell.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfCell.backgroundColor
[type: Color] [default: Color(1,1,1,1)] 
The background color of this PdfCell.





PdfCell.justificationV
[type: string] [default: "center"] 
The verticialJustifcation of this PdfCell. For acceptable values, see 'nc.constants.justfications'.





PdfCell.justificationH
[type: string] [default: "center"] 
The horizontalJustifcation of this PdfCell. For acceptable values, see 'nc.constants.justfications'.





PdfCell.leftIndent
[type: number] [default: 0] 
The left indentation amount of this PdfCell.





PdfCell.rightIndent
[type: number] [default: 0] 
The right indentation amount of this PdfCell.





PdfCell.leftBorderThickness
[type: number] [default: 1] 
The thickness of the left border in this PdfCell.





PdfCell.rightBorderThickness
[type: number] [default: 1] 
The thickness of the right border in this PdfCell.





PdfCell.bottomBorderThickness
[type: number] [default: 1] 
The thickness of the bottom border in this PdfCell.





PdfCell.topBorderThickness
[type: number] [default: 1] 
The thickness of the top border in this PdfCell.





PdfCell.diagonalDownThickness
[type: number] [default: 0] 
The thickness of the diagonalDown (top left to bottom right diagonal) in this PdfCell.





PdfCell.diagonalUpThickness
[type: number] [default: 0] 
The thickness of the diagonalUp (top right to bottom left diagonal) in this PdfCell.





PdfCell.leftBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the left border in this PdfCell.





PdfCell.rightBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the right border in this PdfCell.





PdfCell.bottomBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the bottom border in this PdfCell.





PdfCell.topBorderColor
[type: Color] [default: Color(0,0,0,1)] 
The color of the top border in this PdfCell.





PdfCell.diagonalDownColor
[type: Color] [default: Color(1,1,1,1)] 
The color of the diagonalDown (top left to bottom right diagonal) in this PdfCell.





PdfCell.diagonalUpColor
[type: Color] [default: Color(1,1,1,1)] 
The thickness of the diagonalUp (top right to bottom left diagonal) in this PdfCell.





PdfCell.spaceAfter
[type: number] [default: 0] 
The space size that will be added after this PdfCell.





PdfCell.spaceBefore
[type: number] [default: 0] 
The space size that will be added before this PdfCell.





PdfCell.setBorder(thickness, color)
[type: function] 
Sets the thickness and color for all borders in this PdfCell.

PdfCell.setBorder parameter: thickness
[type: number] [optional] 
The thickness to set all borders to.

PdfCell.setBorder parameter: color
[type: Color] [optional] 
The color to set all borders to.





PdfCell.addParagraph()
[type: function] [returns: PdfParagraph] 
Adds a new PdfParagraph to this PdfCell and returns it. A PdfParagraph is simply a block of text.





PdfCell.addImage(imagePath, isPathRelative, justificationH)
[type: function] [returns: PdfImage] 
Adds a new Image to this PdfCell and returns it.

PdfCell.addImage parameter: imagePath
[type: string] 
The path of the image being added within this PdfCell.

PdfCell.addImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfCell.addImage parameter: justificationH
[type: string] [default: "center"] [optional] 
The horizontal justification of the image being added to this PdfCell. For acceptable values, see 'nc.constants.justfications'.





PdfCell.addTable(numRows, numCols, columnWidths)
[type: function] [returns: PdfTable] 
Adds a new PdfTable to this PdfCell and returns it.

PdfCell.addTable parameter: numRows
[type: number] 
The number of rows to add to this PdfTable.

PdfCell.addTable parameter: numCols
[type: number] 
The number of columns to add to each PdfRow in this PdfTable.

PdfCell.addTable parameter: columnWidths
[type: [number], number] 
An array containing the desired widths for each column in this PdfTable.





PdfCell.mergeCellRight(numberOfCells)
[type: function] 
Merges this cell right by a specificed number of cells.

PdfCell.mergeCellRight parameter: numberOfCells
[type: number] 
The number of cells to merge.





PdfCell.addTextFrame(width, height)
[type: function] [returns: PdfTextFrame] 
Adds a new PdfTextFrame to this PdfSection and returns it.

PdfCell.addTextFrame parameter: width
[type: number] 
The width of the PdfTextFrame being added.

PdfCell.addTextFrame parameter: height
[type: number] 
The height of the PdfTextFrame being added.










----------------------------------------------------------
Section 92: PdfTextFrame
----------------------------------------------------------


PdfTextFrame
[type: class] [NON-INSTANTIABLE] 
A PdfTextFrame is an object that resides within a PdfSection, PdfHeader or PdfFooter and can contain PdfParagraphs, PdfImages and PdfTables within it. 





PdfTextFrame.type
[type: string] 
Type identifier.





PdfTextFrame.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PdfTextFrame.leftMargin
[type: number] [default: 0] 
The size of the left margin of the pages within this PdfTextFrame.





PdfTextFrame.rightMargin
[type: number] [default: 0] 
The size of the right margin of the pages within this PdfTextFrame.





PdfTextFrame.topMargin
[type: number] [default: 0] 
The size of the top margin of the pages within this PdfTextFrame.





PdfTextFrame.bottomMargin
[type: number] [default: 0] 
The size of the bottom margin of the pages within this PdfTextFrame.





PdfTextFrame.height
[type: number] [default: 0] 
The height of this PdfTextFrame.





PdfTextFrame.width
[type: number] [default: 0] 
The width of this PdfTextFrame.





PdfTextFrame.addParagraph()
[type: function] [returns: PdfParagraph] 
Adds a new PdfParagraph to this PdfTextFrame and returns it. A PdfParagraph is simply a block of text.





PdfTextFrame.addImage(imagePath, isPathRelative, justificationH, justificationV)
[type: function] [returns: PdfImage] 
Adds a new Image to this PdfTextFrame and returns it.

PdfTextFrame.addImage parameter: imagePath
[type: string] 
The path of the image being added within this PdfTextFrame.

PdfTextFrame.addImage parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PdfTextFrame.addImage parameter: justificationH
[type: string] [default: "center"] [optional] 
The horizontal justification of the image being added to this PdfTextFrame. For acceptable values, see 'nc.constants.justfications'.

PdfTextFrame.addImage parameter: justificationV
[type: string] [default: "center"] [optional] 
The vertical justification of the image being added to this PdfTextFrame. For acceptable values, see 'nc.constants.justfications'.





PdfTextFrame.addTable(numRows, numCols, columnWidths)
[type: function] [returns: PdfTable] 
Adds a new PdfTable to this PdfTextFrame and returns it.

PdfTextFrame.addTable parameter: numRows
[type: number] 
The number of rows to add to this PdfTextFrame.

PdfTextFrame.addTable parameter: numCols
[type: number] 
The number of columns to add to each PdfRow in this PdfTextFrame.

PdfTextFrame.addTable parameter: columnWidths
[type: [number], number] 
An array containing the desired widths for each column in this PdfTextFrame.










----------------------------------------------------------
Section 93: PivotPointAdjuster
----------------------------------------------------------


PivotPointAdjuster
[type: class] [NON-INSTANTIABLE] 
A PivotPointAdjuster gives a GraphicObject a unique copy of its Geometry, which can then be modified using the PivotPointAdjuster's position, rotation, and scale members. Note that changing the position, rotation, or scale at run time causes a costly rebuild of the Geometry data and is only recommended during initialization. 





PivotPointAdjuster.type
[type: string] 
Type identifier.





PivotPointAdjuster.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PivotPointAdjuster.position
[type: Vector3] 
The position offset to apply to every vertex in the Geometry. Note that changing this at run time causes a costly rebuild of the Geometry data and is only recommended during initialization.





PivotPointAdjuster.rotation
[type: Vector3] 
The rotation to apply to every vertex in the Geometry. Note that changing this at run time causes a costly rebuild of the Geometry data and is only recommended during initialization.





PivotPointAdjuster.lazyUpdater
[type: LazyUpdater] 
The lazy updater responsible for updating the GraphicObject's Geometry.





PivotPointAdjuster.dispose()
[type: function] 
Removes and destroys the PivotPointAdjuster, restoring the original Geometry if possible.










----------------------------------------------------------
Section 94: PixelsObject
----------------------------------------------------------


PixelsObject
[type: class] [NON-INSTANTIABLE] [requires: module - pixelsObjects] 
A PixelsObject is an RGBA bitmap image in a simple, 'data-only' format, used for basic image access and manipulation.





PixelsObject.type
[type: string] 
Type identifier.





PixelsObject.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PixelsObject.width
[type: number] 
The width of the PixelsObject.





PixelsObject.height
[type: number] 
The height of the PixelsObject.





PixelsObject.writePngFile(filePath, isPathRelative, writeRawBase64)
[type: function] [returns: IncrCommsResponseObject] 
Writes the bitmap from this PixelsObject to a ".png" file at the given path.

PixelsObject.writePngFile parameter: filePath
[type: string] 
The relative or absolute path to the file in question.

PixelsObject.writePngFile parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

PixelsObject.writePngFile parameter: writeRawBase64
[type: boolean] [default: false] [optional] 
Bool stating if the file written will be in Base64 text format.





PixelsObject.getPixel(x, y)
[type: function] [returns: Vector4] 
Returns a Vector4 containing the RGBA color of the pixel at the given coordinates.

PixelsObject.getPixel parameter: x
[type: number] 
The horizontal index of the pixel to get the color of.

PixelsObject.getPixel parameter: y
[type: number] 
The vertical index of the pixel to get the color of. The vertical position of pixels in PixelObjects map from bottom to top.





PixelsObject.setPixel(x, y, color)
[type: function] 
Sets the RGBA color Value of the pixel at the given coordinates

PixelsObject.setPixel parameter: x
[type: number] 
The horizontal index of the pixel to set the color of.

PixelsObject.setPixel parameter: y
[type: number] 
The vertical index of the pixel to get set color of. The vertical position of pixels in PixelObjects map from bottom to top.

PixelsObject.setPixel parameter: color
[type: Vector4] 
Vector with the RGBA color value for the desired pixel.





PixelsObject.unMultiply()
[type: function] 
Performs a transformation on the bitmap data stored in this PixelsObject that approximates the reversal of "premultiplication" of images with transparency. Depending on the source of the content within this PixelsObject, you may want to invoke 'unMultiply' before writing it to an image on disk. This is because Incisor® primarily works with normal 'unmultiplied' source images and premultiplies images during runtime, so PixelsObjects created from composites of those premultiplied images will likely need to be unmultiplied prior to being written to disk to ensure that the resulting image is saved in the original 'unmultiplied' color space.










----------------------------------------------------------
Section 95: PixelsObjects
----------------------------------------------------------


PixelsObjects
[type: class] [requires: module - pixelsObjects] 
Object housing functionality for PixelsObjects, which are RGBA bitmap images in a simple, 'data-only' format, used for basic image access and manipulation.





PixelsObjects.getNewBlankPixelsObject(width, height, color)
[type: function] [returns: PixelsObject] 
Returns a uniformly colored PixelsObject of the width, height, and color provided.

PixelsObjects.getNewBlankPixelsObject parameter: width
[type: number] 
The width of the desired PixelsObject.

PixelsObjects.getNewBlankPixelsObject parameter: height
[type: number] 
The height of the desired PixelsObject.

PixelsObjects.getNewBlankPixelsObject parameter: color
[type: Vector4] 
Vector with the RGBA color values for the new PixelsObject.





PixelsObjects.getPixelsObject(source)
[type: function] [returns: PixelsObject] 
Returns a PixelsObject generated from the given RenderTarget or Texture. It should be noted that the texture will need to be loaded before invoking this function - see nc.addTierLoadedCallback and nc.awaitLoadedTiers for more information.

PixelsObjects.getPixelsObject parameter: source
[type: RenderTarget, Texture] 
The RenderTarget or Texture to generate the PixelsObject from. It should be noted that Textures that were originally created from PixelsObjects cannot be used to create a PixelsObject.










----------------------------------------------------------
Section 96: TimePlaybackController
----------------------------------------------------------


TimePlaybackController
[type: class] [extends: PlaybackController] 
A time-based PlaybackController with "startTime", "time", and "endTime" properties.





TimePlaybackController.time
[type: number] 
The current time (in seconds) of the PlaybackController. While playing, this value is automatically updated every fixedUpdate, or it can also be set manually at any time.





TimePlaybackController.startTime
[type: number] 
The starting time of the PlaybackController.





TimePlaybackController.endTime
[type: number] 
The end time of the PlaybackController.





TimePlaybackController.initialTime
[type: number] 
The initial time for this TimePlaybackController when it is included in a newly instantiated Construct. This property will be set to the TimePlaybackController's 'startTime' as a default.



















































































































----------------------------------------------------------
Section 97: ValuePlaybackController
----------------------------------------------------------


ValuePlaybackController
[type: class] [extends: PlaybackController] 
A value-based PlaybackController with "startValue", "value", and "endValue" properties.





ValuePlaybackController.value
[type: number] 
The current value (in seconds) of the PlaybackController. While playing, this value is automatically updated every fixedUpdate, or it can also be set manually at any time.





ValuePlaybackController.startValue
[type: number] 
The starting value of the PlaybackController.





ValuePlaybackController.endValue
[type: number] 
The end value of the PlaybackController.





ValuePlaybackController.initialValue
[type: number] 
The initial value for this ValuePlaybackController when it is included in a newly instantiated Construct. This property will be set to the ValuePlaybackController's 'startValue' as a default.



















































































































----------------------------------------------------------
Section 98: PlaybackController
----------------------------------------------------------


PlaybackController
[type: class] [NON-INSTANTIABLE] 
Object managing the playing, pausing, and stopping of items that change over time such as Timelines, Sounds, or ParticleSystems. 





PlaybackController.type
[type: string] 
Type identifier.





PlaybackController.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





PlaybackController.lazyStop
[type: boolean] [default: false] 
Boolean flag determining if the PlaybackController will hault the next time the time reachs the endTime (or startTime if playback is a negative value). If this flag is false, the PlaybackController loops and continues playing indefinitely.





PlaybackController.duration
[type: number] 
The read-only length of this PlaybackController in seconds. To change the duration, adjust the 'startTime' or 'endTime' properties.





PlaybackController.playbackState
[type: string] [default: nc.constants.playbackStates.stopped] 
Read-only string denoting the current playback state: 'stopped', 'paused', or 'playing'. State values are available in 'nc.constants.playbackStates'.





PlaybackController.playbackRate
[type: number] [default: 1] 
Value multiplying the progression of the 'time' value. To play twice as fast use 2, for items that can play backwards, use negative values.





PlaybackController.netPlaybackRate
[type: number] 
Read-only value denoting the net playbackRate, including the effects of this PlaybackController's SpeedControls.





PlaybackController.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this PlaybackController will be immune to. Set this parameter to [] for this PlaybackController to have no pause immunity.





PlaybackController.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this PlaybackController is affected by.





PlaybackController.autoplayWhenInConstruct
[type: boolean] [default: true] 
Boolean determining if the PlaybackController automatically starts playing when included in a newly instantiated Construct.





PlaybackController.play()
[type: function] 
Changes the playbackState to "playing", and begins the progression of the 'time' value. While playing, the PlaybackController automatically updates the 'time' value once every fixedUpdate.





PlaybackController.playOnce(lazyStopCallbackOwner, lazyStopCallbackName, lazyStopCallbackArgs)
[type: function] 
Starts playing with 'time=startTime' (or if playbackRate is negative, 'time=endTime') and sets the 'lazyStop' value to true. An optional callback function can be provided for when playbackController stops - this callback is consumed upon stopping.

PlaybackController.playOnce parameter: lazyStopCallbackOwner
[type: object] [optional] 
The object owning the optional callback function that is triggered when a lazy stop occurs.

PlaybackController.playOnce parameter: lazyStopCallbackName
[type: string] [optional] 
The name of the optional callback function that is triggered when a lazy stop occurs.

PlaybackController.playOnce parameter: lazyStopCallbackArgs
[type: Array, any] [optional] 
Parameters for the optional callback function that is triggered when a lazy stop occurs.





PlaybackController.pause()
[type: function] 
Changes the playbackState to "paused", and pauses the progression of the 'time' value.





PlaybackController.stop()
[type: function] 
Changes the playbackState to "stopped" and sets the 'time' value to 'startTime'.





PlaybackController.addTimeUpdateCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs any time the 'time' property is updated, which happens while this PlaybackController is playing, but also when time is set directly. The time value will be sent to this callback as its first parameter, with any user-defined args following.

PlaybackController.addTimeUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is triggered when time is updated.

PlaybackController.addTimeUpdateCallback parameter: callbackName
[type: string] 
The name of the callback function that is triggered when time is updated.

PlaybackController.addTimeUpdateCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered when time is updated.





PlaybackController.removeTimeUpdateCallback(callbackOwner, callbackName)
[type: function] 
Removes the given timeUpdate callback.

PlaybackController.removeTimeUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

PlaybackController.removeTimeUpdateCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





PlaybackController.addLazyStopCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs upon the next 'lazyStop', which occurs any time the time reaches the startTime or endTime while the 'lazyStop' flag is true. It should be noted that all lazyStop callbacks are consumed upon encountering a lazyStop, and would need to be-added to be triggered upon subsequent lazyStops.

PlaybackController.addLazyStopCallback parameter: callbackOwner
[type: object] 
The object owning the optional callback function that is triggered when a lazy stop occurs.

PlaybackController.addLazyStopCallback parameter: callbackName
[type: string] 
The name of the optional callback function that is triggered when a lazy stop occurs.

PlaybackController.addLazyStopCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for the optional callback function that is triggered when a lazy stop occurs.





PlaybackController.removeLazyStopCallback(callbackOwner, callbackName)
[type: function] 
Removes the given lazyStop callback.

PlaybackController.removeLazyStopCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

PlaybackController.removeLazyStopCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





PlaybackController.addStateChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs if/when any component of this PlaybackController has changed. This can be used to manage processes that run entirely outside of the Incisor® system by providing a callback to update said processes upon any change. A string denoting the triggering change will be passed in as the callback function's first parameter, and user-defined parameters will follow.

PlaybackController.addStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the optional callback function that is triggered when any component of this PlaybackController has changed.

PlaybackController.addStateChangeCallback parameter: callbackName
[type: string] 
The name of the optional callback function that is triggered when any component of this PlaybackController has changed.

PlaybackController.addStateChangeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Parameters for the optional callback function that is triggered when any component of this PlaybackController has changed.





PlaybackController.removeStateChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given stateChange callback.

PlaybackController.removeStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

PlaybackController.removeStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





PlaybackController.dispose()
[type: function] 
Removes internal Incisor® references to this PlaybackController in order to aid memory management.










----------------------------------------------------------
Section 99: Precomp
----------------------------------------------------------


Precomp
[type: class] 
A Precomp (short for 'precomposition'), is an object with its own Scene, Camera, RenderTarget, and GraphicAsset. When the Precomp's Camera renders, it informs the associated GraphicAsset, which can be instantiated by making new GraphicObject. Precomps can be used for optimization in many ways, including precomposing several ScenenObjects together, rendering the Scene, and using the resulting GraphicAsset to recreate the collection in a single GraphicObject.





Precomp.type
[type: string] 
Type identifier.





Precomp.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Precomp.name
[type: string] 
The name of the Precomp. This name will also be used for the GraphicAsset, Texture, and Geometry that are created as part of this Precomp.





Precomp.scene
[type: Scene] 
The Scene holding the this Precomp's content. This is the Scene that is rendered to inform the associated GraphicAsset.





Precomp.camera
[type: OrthographicCamera] 
The OrthographicCamera that resides in, and renders, this Precomp's Scene.





Precomp.renderTarget
[type: RenderTarget] 
The RenderTarget that this Precomp's Camera renders to.





Precomp.graphicAsset
[type: GraphicAsset] 
The GraphicAsset using this Precomp's RenderTarget (using its Texture)





Precomp.automaticallyManageLoadingTierDelayedContentRendering
[type: boolean] [default: true] 
Boolean determining if this Precomp attempts to manage its own delayed rendering. With this value set to true and 'autorender=true', this Precomp will change the 'autoRenderOrder' of its own Camera to account for any Precomp nesting that migth occur. With this value set to true and 'autorender=false', this Precomp will set up an internal callback to render its Scene content once it all loads. If this value is set to false, no delayed rendering management actions occur unless manually triggered. The Precomp can be rendered at any time by calling 'Precomp.camera.render'.





Precomp.writePngFile(filePath, isPathRelative, postLoadCallbackOwner, postLoadCallbackName, postLoadCallbackArgs, unMultiply, writeRawBase64)
[type: function] [requires: unpublished only, license - fileIO] 
An awaitable method that writes the rendered content from this Precomp's RenderTarget to disk as a '.png' file once it has all loaded. A callback function can be provided to manipulate the contents of this Precomp once it has loaded before it is rendered and write to file.

Precomp.writePngFile parameter: filePath
[type: string] 
The relative or absolute path to the png file to be written to disk.

Precomp.writePngFile parameter: isPathRelative
[type: boolean] [default: true] [optional] 
Bool stating if the given path is relative to the project path or an absolute path. If an absolute path is used that is outside of the project directory, the 'allowUniversalFileIO' item in application settings must be set to true.

Precomp.writePngFile parameter: postLoadCallbackOwner
[type: object] [optional] 
The owner of the optional callback function that is called once the Precomp Scene's content is loaded before it is rendered.

Precomp.writePngFile parameter: postLoadCallbackName
[type: string] [optional] 
The name of the optional callback function that is called once the Precomp Scene's content is loaded before it is rendered.

Precomp.writePngFile parameter: postLoadCallbackArgs
[type: Array, any] [optional] 
Parameters for the optional callback function that is called once the Precomp Scene's content is loaded before it is rendered.

Precomp.writePngFile parameter: unMultiply
[type: boolean] [default: true] [optional] 
Boolean determining if the contents of the RenderTarget are 'un-multiplied' before the '.png' is written. Since textures loaded in Incisor® use premultiplied alpha, un-multiplication would need to happen to get a file with transparency that was equivalent to the original asset files.

Precomp.writePngFile parameter: writeRawBase64
[type: boolean] [default: false] [optional] 
Boolean Bool stating if the file written will be in Base64 text format.










----------------------------------------------------------
Section 100: ProjectConfiguration
----------------------------------------------------------


ProjectConfiguration
[type: class] [NON-INSTANTIABLE] 
Object housing the configuration settings for this project. Accessible via 'nc.projectConfiguration'. Many of the members of this object are customizable on a 'per configuration' basis by editing the ProjectSettings. The user-customizable 'PreloadConfiguration' code is executed within this object, so members created within that code will be accessible on this object. 





ProjectConfiguration.incisorVersion
[type: string] 
The specific 'version number' designation of the version of Incisor® that generated this project code.





ProjectConfiguration.incisorVersionSet
[type: string] 
The 'version set' designation of the version of Incisor® that generated this project code.





ProjectConfiguration.projectName
[type: string] 
The name of the current Incisor® project as determined in the 'ProjectSettings'.





ProjectConfiguration.publishTimestamp
[type: string] 
The date when the current project was published using the format "YYYY.MM.DD.hh.mm.ss". For unpublished projects, this value will be 'devMode'.





ProjectConfiguration.coreCanvasResolutionX
[type: number] [default: 1920] 
The core canvas pixel width. This represents the pixel width of the canvas RenderTarget at it's native scale. Runtime changes to this value must be made in PreloadConfiguration code, which is located in the 'ProjectCode/PreloadConfiguration' local directory.





ProjectConfiguration.coreCanvasResolutionY
[type: number] [default: 1080] 
The core canvas pixel height. This represents the pixel height of the canvas RenderTarget at it's native scale. Runtime changes to this value must be made in PreloadConfiguration code, which is located in the 'ProjectCode/PreloadConfiguration' local directory.





ProjectConfiguration.canvasTransparency
[type: boolean] [default: false] 
Boolean determining if any portion of the canvas will be transparent, enabling the html page to be partially viewed "through" the canvas.





ProjectConfiguration.mainCameraType
[type: string] [default: 'orthographic'] 
String value denoting the default camera type used for the 'mainCamera' in the 'mainScene'. Runtime changes to this value must be made in PreloadConfiguration code, which is located in the 'ProjectCode/PreloadConfiguration' local directory. Possible values for this property are 'orthographic' or 'perspective'.





ProjectConfiguration.maskingMode
[type: string] [default: 'overlapping'] 
String value denoting the masking mode for this project. The masking mode determines how different MaskGroups interact with eachother. Possible values for this property are 'overlapping' or 'disjoint'. When the maskingMode is 'overlapping', up to 8 MaskGroups can be defined and GraphicObjects can subscribe to any combination of those MaskGroups. When the maskingMode is 'disjoint', up to 255 MaskGroups can be defined, but GraphicObjects can only subscribe to one mask at a time.





ProjectConfiguration.preserveDrawingBuffer
[type: boolean] [default: true] 
Boolean value determining if the drawing buffer is preserved for reading. Preserving the drawing buffer enables several useful development features, but may cause performance issues in published software on some devices. It is therefore recommended that this flag be set to true for when the project is unpublished, and false for when the project is published. This can be done using a 'CODE.includeIf___published' within the 'preloadConfiguration' method in the PreloadConfiguration code.





ProjectConfiguration.canvasParent
[type: object] [default: document.body] 
DOM object that the canvas will be made a child of. For many projects the best value for this item is the default. Changes to this value must be made in PreloadConfiguration code, which is located in the 'ProjectCode/PreloadConfiguration' local directory.





ProjectConfiguration.isProjectPublished
[type: boolean] 
Ready-only bool indicating if the project that is currently running is published.





ProjectConfiguration.urlParams
[type: object] 
URL parameters. URL parameters included in the url used to access this project are automatically parsed and provided in this object.





ProjectConfiguration.defaultGraphicAssetEffectNodes
[type: [string]] 
List of Nodes added to the presets for all GraphicAssets. This item is determined by the associated field in the ProjectSettings.





ProjectConfiguration.assetConfiguration
[type: AssetConfiguration] 
Object housing the details of the current asset configuration. Runtime changes to this value must be made in PreloadConfiguration code, which is located in the 'ProjectCode/PreloadConfiguration' local directory. When setting these values, ensure the chosen values exist within the 'assetConfigurationDefinitions' in the 'ProjectSettings.json' file, and the overall assetConfiguration must in the list of 'supportedAssetConfigurations' listed within the current configuration within the 'ProjectSettings.json' file.





ProjectConfiguration.loadingTierDefinitions
[type: dictionary] 
Object housing information about the loading tiers in this project. Loading tiers are a means to organize AssetComponents into separately downloadable groups.


ProjectConfiguration.loadingTierDefinitions.100
[type: LoadingTierDefinition] 
Information about the 100 loading tier.





ProjectConfiguration.fontDefinitions
[type: dictionary] 
Object housing information about the fonts in this project.


ProjectConfiguration.fontDefinitions.NullFont
[type: FontDefinition] 
Information about the NullFont font.


ProjectConfiguration.fontDefinitions.incr_inspectorFont
[type: FontDefinition] 
Information about the incr_inspectorFont font.


ProjectConfiguration.fontDefinitions.MonoSpace
[type: FontDefinition] 
Information about the MonoSpace font.





ProjectConfiguration.refreshWithUpdatedParams()
[type: function] 
Refreshes the project within the browser, applying current/updated values of 'ProjectConfiguration.urlParams'. For example, a project could have functionality to allow the end-user to change a custom configuration (e.i. themeColor) of the project from within the published project runtime, and this could be done by calling "nc.projectConfiguration.urlParams.themeColor = 'purple';", and then calling "nc.projectConfiguration.refreshWithUpdatedParams();". The browser would then refresh, the url would include the suffix "?themeColor=purple", and the nc.projectConfiguration.urlParams would be updated from the very beginning of the project runtime, allowing the configuration to inform the loading and setup process.





ProjectConfiguration.canvasPositionOverride(canvasElement, left, top, width, height)
[type: function] 
An function that can override Incisor's built-in placement of the canvasElement, which as a default behaviour simply stretches the canvas over the entire browser window. This function is initially undefined, and can be defined to create custom canvas layout behaviours. This function is automatically called if the browser window is resized but it can also be called directly (if defined) in the event that the canvas needs to be moved for reasons not stemming from something other than a browser resize event.

ProjectConfiguration.canvasPositionOverride parameter: canvasElement
[type: HTMLCanvasElement] 
The main canvas element for this project (accessable via 'nc.canvasElement').

ProjectConfiguration.canvasPositionOverride parameter: left
[type: number] 
The input position of the left side of the canvas within the page window.

ProjectConfiguration.canvasPositionOverride parameter: top
[type: number] 
The input position of the top side of the canvas within the page window.

ProjectConfiguration.canvasPositionOverride parameter: width
[type: number] 
The input width of the canvas within the page window.

ProjectConfiguration.canvasPositionOverride parameter: height
[type: number] 
The inpu height of the canvas within the page window.










----------------------------------------------------------
Section 101: AssetConfiguration
----------------------------------------------------------


AssetConfiguration
[type: class] [NON-INSTANTIABLE] 
Dictionary of asset configurations. 





AssetConfiguration."assetPackageScale"
[type: string] 
Asset configuration for 'assetPackageScale'. Available options for this asset configuration can be found in the 'assetConfigurationDefinitions' item in the 'ProjectSettings'. This asset configuration is a built-in configuration. This is the current value for the 'assetPackageScale' configuration. This configuration changes the base resolution for all image assets loaded within the project.' Image assets can opt out of adherence to 'assetPackageScale' by changing the 'applyAssetPackageScaling' in the asset settings to false.





AssetConfiguration."soundQuality"
[type: string] 
Asset configuration for 'soundQuality'. Available options for this asset configuration can be found in the 'assetConfigurationDefinitions' item in the 'ProjectSettings'. This asset configuration is a built-in configuration. This is the current value for the 'soundQuality' configuration. This configuration changes the compression bitrate and the number of channels for all sound assets loaded within the project.'





AssetConfiguration."language"
[type: string] 
Asset configuration for 'language'. Available options for this asset configuration can be found in the 'assetConfigurationDefinitions' item in the 'ProjectSettings'. This asset configuration is a built-in configuration. This is the current value for the 'language' configuration. The language configuration determines which phrases are referenced in the 'ProjectTranscript.json.' This configuration can also be used to determine which language-specific assets to load based on flags within the given asset settings.










----------------------------------------------------------
Section 102: Publishing
----------------------------------------------------------


Publishing
[type: class] [NON-INSTANTIABLE] [requires: unpublished only, license - publishing] 
Object housing functionality for publishing projects. 





Publishing.publishProject(configurationName, hostPublishedProject)
[type: function] [returns: IncrCommsResponseObject] 
Compiles the user code from the current project together with the Incisor® code to produce a complete, optimized, and ready-to-host web package. Publishing configuration options such as asset packaging settings, code formatting settings, and more are defined in ProjectSettings. By default, newly published projects will be placed in the 'Publishing' directory in the project.

Publishing.publishProject parameter: configurationName
[type: string] [optional] 
The name of the configuration to be used in publishing this project.

Publishing.publishProject parameter: hostPublishedProject
[type: boolean] [optional] 
Flag determining if the published project should be automatically hosted. [Default: false]










----------------------------------------------------------
Section 103: RenderTarget
----------------------------------------------------------


RenderTarget
[type: class] 
RenderTargets are objects that contain Textures to render to, as well as settings for how those textures may be resized automatically based on environmental factors such as canvas size, canvas aspect ratio, and the current asset package scale.





RenderTarget.type
[type: string] 
Type identifier.





RenderTarget.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





RenderTarget.name
[type: string] 
The name of the RenderTarget. This name must be unique.





RenderTarget.coreWidth
[type: number] [default: 500] 
The base width value of this RenderTarget. To get the final horizontal render resolution of this RenderTarget's Texture, start with this value, then apply all of the enabled automatic adjustments (such as canvasAspectMatching and assetPackageScaleResolutionScaling).





RenderTarget.coreHeight
[type: number] [default: 500] 
The base height value of this RenderTarget. To get the final vertical render resolution of this RenderTarget's Texture, start with this value, then apply all of the enabled automatic adjustments (such as canvasAspectMatching and assetPackageScaleResolutionScaling).





RenderTarget.canvasAspectMatching
[type: boolean] [default: false] 
Flag determining whether or not this RenderTarget automatically matches the aspect ratio of the canvas.





RenderTarget.canvasSizeResolutionScaling
[type: boolean] [default: false] 
Flag determining whether or not this RenderTarget automatically scales its resolution based on the size of the canvas.





RenderTarget.capCanvasSizeResolutionScaling
[type: boolean] [default: false] 
Flag determining whether or not the canvasSizeResolutionScaling factor for this RenderTarget is capped to 1. This only applies if canvasSizeResolutionScaling is true.





RenderTarget.assetPackageScaleResolutionScaling
[type: boolean] [default: false] 
Flag determining whether or not this RenderTarget automatically scales its resolution based on the current assetPackageScale. The current assetPackageScale can be found at nc.projectConfiguration.assetConfiguration.assetPackageScale.





RenderTarget.auxiliaryResolutionScaleFactor
[type: number] [default: 1] 
Additional factor that multiplies this RenderTarget's resolution scale.





RenderTarget.globalRenderTargetResolutionScaling
[type: boolean] [default: true] 
Flag determining whether or not this RenderTarget automatically scales its resolution based on the current nc.globalRenderTargetResolutionScaler value.





RenderTarget.resizeLazyUpdater
[type: LazyUpdater] 
The LazyUpdater in charge of updating the size of this RenderTarget's Texture. The 'updateIfNeeded' call for this LazyUpdater is called whenever this RenderTarget is rendered to, but you can call it directly if you need to ensure that changes to the RenderTarget size are applied immediately for any reason.





RenderTarget.texture
[type: Texture] 
The Texture associated with this RenderTarget.





RenderTarget.renderResolutionLedger
[type: object] [requires: unpublished only] 
Aan object containing a complete record of all of the factors that contribute to the final render resolution of this RenderTarget.





RenderTarget.getCurrentRenderResolution()
[type: function] 
Returns a vector containing the current render resolution for this RenderTarget.










----------------------------------------------------------
Section 104: SceneObject
----------------------------------------------------------


SceneObject
[type: class] 
SceneObjects are the fundamental objects that populate a given project's world/hierarchy. Every object in a Scene's hierarchy inherits from SceneObject.





SceneObject.type
[type: string] 
Type identifier.

example:
// Objective: Determine the type of a SceneObject
// Expected Result: The console should have 3 log messages as follows:
//   MySceneObject is of type SceneObject
//   MyGraphicObject is of type GraphicObject
//   MyButton is of type Button

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Create a GraphicObject using the GraphicObject constructor adding it to "mySceneObject".
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "MyGraphicObject" );
// Create a Button using the Button constructor and adding it to myGraphicObject.
let myButton = new Button( nc.graphicAssets.WhiteTriangle, myGraphicObject, "MyButton" );

console.log(mySceneObject.name + ' is of type ' + mySceneObject.type);
console.log(myGraphicObject.name + ' is of type ' + myGraphicObject.type);
console.log(myButton.name + ' is of type ' + myButton.type);





SceneObject.inheritedTypes
[type: any] 
Dictionary object listing all of the types this object is compatible with.

example:
// Objective: Determine the inherited types of a Button.
// Expected Result: The console log should read "inherited types {"SceneObject":true,"GraphicObject":true,"Button":true}".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Add a Button named "MyButton" to the SceneObject.
let myButton = new Button( nc.graphicAssets.WhiteBox, mySceneObject, "MyButton" );
console.log("inherited types", JSON.stringify( myButton.inheritedTypes ) );





SceneObject.name
[type: string] [default: 'SceneObject'] 
The name of the SceneObject.

example:
// Objective: Set and Get the name of a SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    original name is MySceneObject
//    new name is MyDifferentSceneObject
 
// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
console.log("original name is", mySceneObject.name );
// Update the name of the SceneObject.
mySceneObject.name = "MyDifferentSceneObject";
console.log("new name is", mySceneObject.name );





SceneObject.enabled
[type: boolean] [default: true] 
Boolean determining if this SceneObject is enabled. Enabled SceneObjects are shown normally within the Scene while disabled SceneObjects are not shown. If a SceneObject is disabled, all of its children inherit its disabled state, but if it is enabled all of its childrens' states depend on their own 'enabled' properties.

example:
// Objective: Disable a SceneObject to disable its children.
// Expected Result: You do not see the white box.

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Add a GraphicObject to the SceneObject using the GraphicObject constructor.
new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "WhiteBox" );
// Set mySceneObject to enabled = false.
mySceneObject.enabled = false;





SceneObject.children
[type: [SceneObject]] 
The the array of this SceneObject's children SceneObjects in the hierarchy.

example:
// Objective: Add children to a SceneObject.
// Expected Result: The console log should read "children count 2".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Add 2 GraphicObjects to the SceneObject using the GraphicObject constructor.
new GraphicObject( nc.graphicAssets.WhiteBox, this.mySceneObject, "WhiteBox" );
new GraphicObject( nc.graphicAssets.WhiteTriangle, this.mySceneObject, "WhiteTriangle" );
console.log("children count", mySceneObject.children.length); 





SceneObject.parent
[type: SceneObject] 
The SceneObject that is this SceneObject's parent in the hierarcy. If this SceneObject is of type 'Scene', this value is left undefined. Set this property to change the parent of this SceneObject, or use 'SceneObject.setParent' to do the same thing but with the 'maintainGlobalPostion' optional parameter.

example:
// Objective: Get the parent of a scene object.
// Expected Result: The console log should read "parent name is MySceneObject".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Add a GraphicObject to the SceneObject using the GraphicObject constructor.
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, this.mySceneObject, "WhiteBox" );
// Console log the parent name of this GraphicObject.
console.log("parent name is", myGraphicObject.parent.name);





SceneObject.containingScene
[type: Scene] 
The Scene in which this SceneObject resides.

example:
// Objective: Determine the containing scene of a SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    The containing scene for 'MyMainSceneObject' is MainScene
//    The containing scene for 'MyOtherSceneObject' is MyScene

// Create a SceneObject using the SceneObject constructor. This will add "MyMainSceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MyMainSceneObject" );
console.log("The containing scene for 'MyMainSceneObject' is", mySceneObject.containingScene.name);

// Create a new Scene and name it "MyScene".
let myScene = new Scene("MyScene");
// Create a SceneObject using the SceneObject constructor. This will add "MyOtherSceneObject" to myScene ("MyScene").
let myOtherSceneObject = new SceneObject( myScene, "MyOtherSceneObject" );
console.log("The containing scene for 'MyOtherSceneObject' is", myOtherSceneObject.containingScene.name);





SceneObject.position
[type: Vector3] [default: new Vector3(0,0,0)] 
The position of this SceneObject relative to it's parent.

example:
// Objective: Move the position of the "WhiteTriangle" relative to the "WhiteBox".
// Expected Result: The "WhiteTriangle" is 300 world units above and 300 world units to the right of the "WhiteBox".

// Note: To use a custom graphic, add your image file to the assets directory and access it using nc.graphicAssets['MyImage']

// Add a GraphicObject to the main scene using the GraphicObject constructor.
new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// Add another GraphicObject to the main scene using the GraphicObject constructor, this time using the WhiteTriangle GraphicAsset.
let whiteTriangleGraphicObject =  new GraphicObject( nc.graphicAssets.WhiteTriangle, nc.mainScene, "WhiteTriangle" );
// Update the position of the "WhiteTriangle", moving it 300 world units above and 300 world units to the right of the "WhiteBox".
whiteTriangleGraphicObject.position.x = 300;
whiteTriangleGraphicObject.position.y = 300;





SceneObject.scale
[type: Vector3] [default: new Vector3(1,1,1)] 
The scale of this SceneObject relative to it's parent.

example:
// Objective: Using the scale property, increase the size of a GraphicObject.
// Expected Result: You will see a blue box in the center of the screen and a larger red box, now in the shape of a rectangle, to the right of it.

// Note: To use a custom graphic, add your image file to the assets directory and access it using nc.graphicAssets['MyImage']

// Add a GraphicObject to the main scene using the GraphicObject constructor. 
let blueBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "BlueBox" );
// Use fillColor to make it blue.
blueBox.fillColor = new Color( 0, 0, 1, 1 ); // blue

// Add another GraphicObject to the main scene using the GraphicObject constructor.
let redBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "RedBox" );
// Use fillColor to make it red.
redBox.fillColor = new Color( 1, 0, 0, 1 ); // red
// Use position to move the red box to the right 500 world units.
redBox.position.x = 500;
// Use scale to make the red box a larger rectangle 
redBox.scale.x = 2;
redBox.scale.y = 4;





SceneObject.rotation
[type: Vector3] [default: new Vector3(0,0,0)] 
The rotation (in degrees) of this SceneObject relative to it's parent. Positive values correspond to counter-clockwise rotation around the given axis.

example:
// Objective: Create a SceneObject with a graphic and rotate it.
// Expected Result: The white box has rotated 45 degrees into a diamond shape.

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Add a GraphicObject to the SceneObject using the GraphicObject constructor.
// Note: To use a custom graphic, add your image file to the assets directory and access it using nc.graphicAssets['MyImage']
new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "MyGraphicObject" );
// Rotate the SceneObject 45 degrees around the z axis.
mySceneObject.rotation.z = 45;





SceneObject.isEnabledWithInheritance
[type: boolean] 
Boolean that reflects if the overall state of this SceneObject is 'enabled', incorporating the state of its anscesters.

example:
// Objective: Use isEnabledWithInheritance to determine the enabled value at various levels of the heirarchy.
// Expected Result: The console should have 2 log messages as follows:
//   Top level scene object, enabled is true
//   Bottom level scene object, enabled is false

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject1" to the SceneObject.
let myGraphicObject1 = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "GraphicObject1" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject2" to the GraphicObject myGraphicObject1 (GraphicObject1). 
let myGraphicObject2 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject1, "GraphicObject2" );

// Set myGraphicObject1 to enabled = false. ("GraphicObject1").
myGraphicObject1.enabled = false;
// Console log the isEnabledWithInheritance value of the top level SceneObject ("MySceneObject").
console.log("Top level scene object, enabled is", mySceneObject.isEnabledWithInheritance); // true
// Console log the isEnabledWithInheritance value of the bottom level SceneObject ("GraphicObject2").
console.log("Bottom level scene object, enabled is", myGraphicObject2.isEnabledWithInheritance); // false





SceneObject.hierarchyDepth
[type: number] 
Number indicating how many ancesters this SceneObject has.

example:
// Objective: Retrieve the hierarchy depth of a SceneObject.
// Expected Result: The console log should read "myGraphicObject2 hierarchy depth is 3".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject1" to the SceneObject.
let myGraphicObject1 = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "GraphicObject1" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject2" to the GraphicObject myGraphicObject1 (GraphicObject1). 
let myGraphicObject2 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject1, "GraphicObject2" );
// Console log the hierarchy depth of myGraphicObject2 ("GraphicObject2").
console.log("myGraphicObject2 hierarchy depth is", myGraphicObject2.hierarchyDepth);





SceneObject.layoutObject
[type: LayoutObject] [NON-INSTANTIABLE] 
Object housing information about this particular SceneObject's LayoutObject functionality. LayoutObject functionality applies to SceneObjects that have been added as elements to a LayoutStack, which is responsible for organizing visual content (TextBoxes, Graphics, Buttons, etc...) into dynamic vertical or horizontal stacks. Until a SceneObject has been configured with LayoutObject functionality (either by calling 'SceneObject.configureLayoutObject' or by adding the SceneObject as an element to a LayoutStack), the 'SceneObject.layoutObject' member will be undefined. 

example:
// Objective: Configure a layout object.
// Expected Result: The console should read "layout object width and height after configuration: 20 10".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
    // return a Vector2 with a width of 20 and a height of 10
    return new Vector2( 20, 10 ); 
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.configureLayoutObject( this, "myCallback" );
console.log('layout object width and height after configuration:', this.mySceneObject.layoutObject.width, this.mySceneObject.layoutObject.height);





SceneObject.uiKeyboardNavigator
[type: UiKeyboardNavigator] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for keyboard navigation of this SceneObject's ui-related descendants. Keyboard navigation enables the end-user to press the tab, space, and enter keys to outline and trigger any 'uiKeyboardNavigable' descendants of the SceneObject owning this UiKeyboardNavigator when it is 'in focus' according to 'nc.singularFocusObject'. This property defaults to undefined, but can be enabled, by calling 'SceneObject.configureUiKeyboardNavigator()'.





SceneObject.uiKeyboardNavigable
[type: UiKeyboardNavigable] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for this SceneObject to be accessible via keyboard navigation. Keyboard navigation enables the end-user to press the arrow keys, tab, space, and enter keys to outline and trigger any 'uiKeyboardNavigable' SceneObjects within a UiKeyboardNavigator-enabled parent that is currently 'in focus' according to 'nc.singularFocusObject'. This property defaults to undefined, but can be enabled, by calling 'SceneObject.configureUiKeyboardNavigable()'.





SceneObject.uiVisualFocus
[type: UiVisualFocus] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for the SceneObject owning it to be 'visually focused', which focuses the end-user's attention the given SceneObject by placing it in front of a dimmer layer whenever the object is the the current 'singularFocusObject'. Calling 'configureUiVisualFocus' populates the 'uiVisualFocus' member for the owning SceneObject. It should be noted that the dimmer layer that the newly focused item is placed in front of is actually a button which, when pressed, calls the 'attemptExitUiVisualFocus' member of the current singularFocusObject if that member is defined.





SceneObject.snapToNearestWorldPosition
[type: boolean] [default: false] 
Flag that determines if this SceneObject's global position is always snapped to the nearest integer (for x and y only). This property is mainly used to help provide pixel-perfect rendering for TextBoxes, see 'TextBox.useNearestPixelRendering' for more information.





SceneObject.focusFallback
[type: SceneObject] [default: nc.defaultFocusFallback] 
Sets up a 'focus fallback' for this SceneObject. Once set, if 'nc.relinquishFocus' is called while this SceneObject is focused, then the fallback object will automatically become the new focused object.





SceneObject.customAddOns
[type: dictionary] 
A dictionary of the CustomAddOns included on a given SceneObject. It should be noted that by default, each of the CustomAddOns are undefined, and that their member will be populated once they are added to a SceneObject in the Incisor inspector or directly through code.





SceneObject.excludeChildrenFromBlueprint
[type: boolean] [default: false] 
Flag that determines if this SceneObject's children will be ignored during any 'gatherObjectBlueprint' calls. This flag should be set to true for objects that dynamically generate their own children objects so that those children are not mistakenly duplicated when a blueprint is used to reproduce a collection of objects. This flag general defaults to false, except with Construct instances and TextAssemblies, since those obects produce their own children on the fly. You would also want to set this flag to true if you are making a CustomObject that produces it's own children or a CustomAddOn that produces children within its owner.





SceneObject.localMatrix
[type: Matrix4] [default: Matrix4()] 
Matrx4 representing the transformation of this SceneObject with respect to its parent. If 'localMatrixOverrideMode' is false, this is automatically calculated based on the position, rotation, and scale of the SceneObject.





SceneObject.worldMatrix
[type: Matrix4] [default: Matrix4()] 
Matrx4 representing the transformation of the SceneObject with respect to the Scene that contains it. If 'worldMatrixOverrideMode' is false, this is automatically calculated by multiplying this SceneObject's parent's worldMatrix by this SceneObject's localMatrix. Because the same calculation is done for all ancestors, this Matrix4 accumulates the transformations of all ancestor SceneObjects.





SceneObject.localMatrixOverrideMode
[type: boolean] [default: false] 
If true, this SceneObejct's localMatrix will no longer be automatically be updated to reflect the SceneObejct's position, rotation, and scale. This is useful if the localMatrix is being calculated manually, so automatic updates are undesired.





SceneObject.worldMatrixOverrideMode
[type: boolean] [default: false] 
If true, this SceneObejct's worldMatrix will no longer be automatically be updated to reflect the transformations of itself and its ancestors. This is useful if the worldMatrix is being calculated manually, so automatic updates would interfere.





SceneObject.isDisposed
[type: boolean] [default: undefined] 
Flag indicating if this SceneObject has been disposed. If the SceneObject has not been disposed, this property will be undefined.





SceneObject.fillColor
[type: Color] 
The EffectController for the 'FillColor' EffectNode, which entirely fills the associated Geometry with the red, green, blue, and alpha color values provided. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





SceneObject.colorMultiply
[type: Color] 
The EffectController for the 'ColorMultiply' EffectNode, which multiplies the red, green, blue, and alpha color values of the Material it is applied to. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





SceneObject.shapify
[type: shapify] 
The EffectController for the 'Shapify' EffectNode. The Shapify EffectNode converts edge data stored in a 'shapified' Texture into a presentable image with edges that stay sharp regardless of the scale of the associated GraphicObject. This is an instance of a dynamically defined EffectController with base type 'Vector2'. To get a new instance, use "nc.effectControllers['shapify'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





SceneObject.shear
[type: shear] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. This is an instance of a dynamically defined EffectController with base type 'Vector3'. To get a new instance, use "nc.effectControllers['shear'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





SceneObject.shear_center
[type: Vector2] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





SceneObject.enable()
[type: function] 
Sets this SceneObject's 'enabled' value to true.

example:
// Objective: Call enable() on a previously disabled SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    enabled state is false
//    enabled state is true

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
    console.log('enabled state is', args);
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.addEnabledStateChangeCallback( this, "myCallback" );
// Set the enabled state of mySceneObject to false.
this.mySceneObject.enabled = false;
// Call enable() on mySceneObject. This will fire an enabled state change callback.
this.mySceneObject.enable();





SceneObject.disable()
[type: function] 
Sets this SceneObject's 'enabled' value to false.

example:
// Objective: Call disable() on a previously enabled SceneObject.
// Expected Result: The console should read "enabled state is false".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
    console.log('enabled state is', args);
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.addEnabledStateChangeCallback( this, "myCallback" );
// By default, the SceneObject is already enabled. Call disable() on mySceneObject. This will fire an enabled state change callback.
this.mySceneObject.disable();





SceneObject.addEnabledStateChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback function to the list of callbacks that occur whenever the state of this SceneObject's 'enabled' property changes. The true/false enabled state is sent to the callback as its first paremeter, followed by any 'callbackArgs' provided.

SceneObject.addEnabledStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when this SceneObject's enabled state changes.

SceneObject.addEnabledStateChangeCallback parameter: callbackName
[type: string] 
The name of the function that is called when this SceneObject's enabled state changes.

SceneObject.addEnabledStateChangeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when this SceneObject's enabled state changes.

example:
// Objective: Add an 'Enabled State Change' callback.
// Expected Result: The console should have 2 log messages as follows:
//    enabled state is false
//    enabled state is true

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
   console.log('enabled state is', args);
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.addEnabledStateChangeCallback( this, "myCallback" );
// Set mySceneObject to enabled = false. This will fire an enabled state change callback.
this.mySceneObject.enabled = false;
// Set mySceneObject to enabled = true. This will fire an enabled state change callback.
this.mySceneObject.enabled = true;





SceneObject.addUiZoomCallback(callbackOwner, callbackName, callbackArgs, additionalCallbackOrder)
[type: function] 
Adds a callback for when this SceneObject encounters a change in uiZoom. This is similar to adding a callback to the general uiZoomChange AppEvent, but with the added benefit that these callbacks happen in hierarchy-depth order from greatest to least. This means that callbacks associated with an object having 7 ancestors will occur before that of an object with 2 ancestors. This hierarchy-depth sorting enables layout changes to happen in a way that works better with LazyUpdaters. The nc.uiZoom.totalZoom value is sent to the callback as its first paremeter, followed by any 'callbackArgs' provided.

SceneObject.addUiZoomCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is called upon uiZoom change.

SceneObject.addUiZoomCallback parameter: callbackName
[type: string] 
The name of the function that is called upon uiZoom change.

SceneObject.addUiZoomCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called upon uiZoom change.

SceneObject.addUiZoomCallback parameter: additionalCallbackOrder
[type: number] [default: 0] [optional] 
An additional sorting value affecting when this callback will happen relative to other such callbacks associated with this SceneObject.





SceneObject.removeUiZoomCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

SceneObject.removeUiZoomCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

SceneObject.removeUiZoomCallback parameter: callbackName
[type: string] 
The name of the function.





SceneObject.removeEnabledStateChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes an 'enabledStateChange' callback.

SceneObject.removeEnabledStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function to remove.

SceneObject.removeEnabledStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback function to remove.

example:
// Objective: Add an 'Enabled State Change' callback.
// Expected Result: The console should have 2 log messages as follows:
//    enabled state is false
//    enabled state is true

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
    console.log('enabled state is', args);
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.addEnabledStateChangeCallback( this, "myCallback" );
// Set mySceneObject to enabled = false. This will fire an enabled state change callback.
this.mySceneObject.enabled = false;
// Set mySceneObject to enabled = true. This will fire an enabled state change callback.
this.mySceneObject.enabled = true;
// Remove the reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.removeEnabledStateChangeCallback( this, "myCallback" );
// Set mySceneObject to enabled = false. This will NO LONGER fire an enabled state change callback and no console message will be logged.
this.mySceneObject.enabled = false;





SceneObject.dispose()
[type: function] 
Removes this SceneObject and its descendants from the hierarchy, and removes internal Incisor® references to aid memory management.

example:
// Objective: Call dispose() on a SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    descendants before disposal 3
//    after wait descendants after disposal 1 

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject1" to the SceneObject.
let myGraphicObject1 = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "GraphicObject1" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject2" to myGraphicObject1.
let myGraphicObject2 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject1, "GraphicObject2" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject3" to myGraphicObject2.
let myGraphicObject3 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject2, "GraphicObject3" );

// Log the number of descendants of mySceneObject before calling dispose().
console.log( "descendants before disposal", mySceneObject.getDescendants().length );
// Call dispose() on myGraphicObject2.
myGraphicObject2.dispose();

// The call to dispose() can take some time to complete so lets wait 2 seconds before we log again.

// Create a callback function to log the descendants after calling dispose().
this.myWait = function() {
    console.log( "after wait descendants after disposal", mySceneObject.getDescendants().length );
}
// Using nc.WaitThen, wait 2 seconds before attempting to log the descendants again.
nc.waitThen( 2, this, "myWait" );





SceneObject.addDisposalCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback function to the list of callbacks that occur when this SceneObject is disposed.

SceneObject.addDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when this SceneObject is disposed.

SceneObject.addDisposalCallback parameter: callbackName
[type: string] 
The name of the function that is called when this SceneObject is disposed.

SceneObject.addDisposalCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when this SceneObject is disposed.

example:
// Objective: Add a 'Disposal' callback.
// Expected Result: The console should read "disposal callback: myDisposalData".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
   console.log('disposal callback:', args);
}

// Add a reference to a callback function passing the owner of the function, the function name, and any additional data we want.
this.mySceneObject.addDisposalCallback( this, "myCallback", ["myDisposalData"] );
// Call dispose() on mySceneObject. This will fire a disposal callback.
this.mySceneObject.dispose();





SceneObject.removeDisposalCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback function from the list of callbacks that occur when this SceneObject is disposed.

SceneObject.removeDisposalCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when this SceneObject is disposed.

SceneObject.removeDisposalCallback parameter: callbackName
[type: string] 
The name of the function that is called when this SceneObject is disposed.





SceneObject.addRenderCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback function to the list of callbacks that occur when this SceneObject is 'rendered'.

SceneObject.addRenderCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when this SceneObject is rendered.

SceneObject.addRenderCallback parameter: callbackName
[type: string] 
The name of the function that is called when this SceneObject is rendered.

SceneObject.addRenderCallback parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when this SceneObject is rendered.





SceneObject.removeRenderCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback function.

SceneObject.removeRenderCallback parameter: callbackOwner
[type: object] 
The object owning the callback function.

SceneObject.removeRenderCallback parameter: callbackName
[type: string] 
The name of the function.





SceneObject.setParent(parent, maintainGlobalPosition)
[type: function] 
Makes this SceneObject the child of the given SceneObject in the hierachy.

SceneObject.setParent parameter: parent
[type: SceneObject] 
The SceneObject that will become this SceneObject's new parent.

SceneObject.setParent parameter: maintainGlobalPosition
[type: boolean] [default: false] [optional] 
Boolean determining if the global position, scale, and rotation should be preserved during the change in hierarchy. Note that this preservation is not always possible during a parent change.

example:
// Objective: Set the parent of a SceneObject
// Expected Result: The console should have 2 log messages as follows:
//    GraphicObjectChild's parent is GraphicObjectA
//    GraphicObjectChild's parent is now GraphicObjectB

// Create a GraphicObject using the GraphicObject constructor. Name it "GraphicObjectA".
let graphicObjectA = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "GraphicObjectA" );
// Create a second GraphicObject using the GraphicObject constructor. Name it "GraphicObjectB".
let graphicObjectB = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "GraphicObjectB" );
// Create a third GraphicObject using the GraphicObject constructor. This time, make its parent graphicObjectA. Name it "GraphicObjectChild".
let graphicObjectChild = new GraphicObject( nc.graphicAssets.WhiteBox, graphicObjectA, "GraphicObjectChild" );
// Console log the parent.
console.log("GraphicObjectChild's parent is", graphicObjectChild.parent.name);
// Set the parent to graphicObjectB.
graphicObjectChild.setParent( graphicObjectB );
// Console log the parent.
console.log("GraphicObjectChild's parent is now", graphicObjectChild.parent.name);





SceneObject.getAncestors()
[type: function] [returns: [SceneObject]] 
Returns a list of this SceneObject's ancesters.

example:
// Objective: Get the ancestors of a SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    myGraphicObject3 ancestors count 4
//    myGraphicObject1 ancestors count 2

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject1" to the SceneObject.
let myGraphicObject1 = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "GraphicObject1" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject2" to the GraphicObject myGraphicObject1 (GraphicObject1). 
let myGraphicObject2 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject1, "GraphicObject2" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject3" to the GraphicObject myGraphicObject2 (GraphicObject2). 
let myGraphicObject3 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject2, "GraphicObject3" );
// Console log the ancestors count.
console.log( "myGraphicObject3 ancestors count", myGraphicObject3.getAncestors().length );
console.log( "myGraphicObject1 ancestors count", myGraphicObject1.getAncestors().length );





SceneObject.getDescendants(enabledOnly, includeEnclosedScenes)
[type: function] [returns: [SceneObject]] 
Returns a list of this SceneObject's descendants.

SceneObject.getDescendants parameter: enabledOnly
[type: boolean] [default: true] [optional] 
Boolean determining if only enabled SceneObjects are added to the returned list.

SceneObject.getDescendants parameter: includeEnclosedScenes
[type: boolean] [optional] 
Boolean determining if sub-descendants of ScrollingPanels' Scenes will be included in the returned list. [DAFAULT: false]

example:
// Objective: Get the descendants of a SceneObject.
// Expected Result: The console should have 2 log messages as follows:
//    myGraphicObject3 descendants count 0
//    myGraphicObject1 descendants count 2

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
let mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject1" to the SceneObject.
let myGraphicObject1 = new GraphicObject( nc.graphicAssets.WhiteBox, mySceneObject, "GraphicObject1" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject2" to the GraphicObject myGraphicObject1 (GraphicObject1). 
let myGraphicObject2 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject1, "GraphicObject2" );
// Using the GraphicObject constructor, add a GraphicObject named "GraphicObject3" to the GraphicObject myGraphicObject2 (GraphicObject2). 
let myGraphicObject3 = new GraphicObject( nc.graphicAssets.WhiteTriangle, myGraphicObject2, "GraphicObject3" );
// Console log the descendants count.
console.log( "myGraphicObject3 descendants count", myGraphicObject3.getDescendants().length );
console.log( "myGraphicObject1 descendants count", myGraphicObject1.getDescendants().length );





SceneObject.getGlobalPosition(returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 with the global position of this SceneObject within the Scene.

SceneObject.getGlobalPosition parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.

example:
// Objective: Get the global position of a SceneObject.
// Expected Result: 'InnerSceneObject' global position x,y 200 200

// Create a new Scene and name it "MyScene".
let myScene = new Scene("MyScene");
// Create a SceneObject using the SceneObject constructor. This will add "OuterSceneObject" to "MyScene".
let outerSceneObject = new SceneObject( myScene, "OuterSceneObject" );
// Create a SceneObject using the SceneObject constructor. This will add "InnerSceneObject" to "OuterSceneObject".
let innerSceneObject = new SceneObject( outerSceneObject, "InnerSceneObject" );
// Update the position of the outerSceneObject, moving it up and to the right, 100 world units.
outerSceneObject.position.x = 100;
outerSceneObject.position.y = 100;   
// Update the position of the innerSceneObject, moving it up and to the right, 100 world units.
innerSceneObject.position.x = 100;
innerSceneObject.position.y = 100;  
// Console log the x and y of mySceneObject using getGlobalPosition(). 
console.log( "'InnerSceneObject' global position x,y", innerSceneObject.getGlobalPosition().x, innerSceneObject.getGlobalPosition().y );





SceneObject.swoopGlobalPosition(endValues, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl)
[type: function] [returns: Swooper] 
Swoops this SceneObject's position using global coordinates.

SceneObject.swoopGlobalPosition parameter: endValues
[type: [number]] 
The array of target global position values [x,y,z].

SceneObject.swoopGlobalPosition parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation in seconds.

SceneObject.swoopGlobalPosition parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

SceneObject.swoopGlobalPosition parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

SceneObject.swoopGlobalPosition parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

SceneObject.swoopGlobalPosition parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

SceneObject.swoopGlobalPosition parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

SceneObject.swoopGlobalPosition parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

example:
// Objective: "Swoop" the position of the white box.
// Expected Result: The white box moves up and to the right, 300 world units, over a duration of 10 seconds.
 
// Add a GraphicObject to the main scene using the GraphicObject constructor.  
let whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// Call swoopGlobalPosition() giving it the array of x,y,z values to swoop to over a duration of 10 seconds.
whiteBox.swoopGlobalPosition( [300,300,0], 10 );





SceneObject.getGlobalScale(returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 with the global scale of this SceneObject within the Scene.

SceneObject.getGlobalScale parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.

example:
// Objective: Get the global scale of a SceneObject.
// Expected Result: The console should read "scale x,y 2 2.
   
// Add a GraphicObject to the main scene using the GraphicObject constructor. 
let whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// Use scale to make the "WhiteBox" twice as large
whiteBox.scale.x = 2;
whiteBox.scale.y = 2;

console.log( "scale x,y", whiteBox.getGlobalScale().x, whiteBox.getGlobalScale().y );





SceneObject.swoopGlobalScale(endValues, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl)
[type: function] [returns: Swooper] 
Swoops this SceneObject's scale using global coordinates.

SceneObject.swoopGlobalScale parameter: endValues
[type: [number]] 
The array of target global scale values [x,y,z].

SceneObject.swoopGlobalScale parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

SceneObject.swoopGlobalScale parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

SceneObject.swoopGlobalScale parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

SceneObject.swoopGlobalScale parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

SceneObject.swoopGlobalScale parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

SceneObject.swoopGlobalScale parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

SceneObject.swoopGlobalScale parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

example:
// Objective: "Swoop" the scale of the white box.
// Expected Result: The white box expands to 5 times its original size over a duration of 10 seconds.
  
// Add a GraphicObject to the main scene using the GraphicObject constructor.  
let whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// Call swoopGlobalScale() giving it the array of x,y,z values to expand to over a duration of 10 seconds.
whiteBox.swoopGlobalScale( [5,5,0], 10 );





SceneObject.getViewPosition(camera, returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 containing the coordinates for this SceneObject within the given Camera's view area. The camera's view area bounds are confined to x within [-.5, .5] and y within [-.5, .5] where -.5 corresponds to left and bottom.

SceneObject.getViewPosition parameter: camera
[type: Camera] [default: nc.mainCamera] 
The Camera to 'look through' when obtaining the view position of this SceneObject.

SceneObject.getViewPosition parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.

example:
// Objective: Get the view position of a SceneObject within a Camera's view area
// Expected Result: The console should have 2 log messages that look something like the following:
//    'MyGraphicObject' view position x,y 0.030978934324659233 0
//    'MyGraphicObject' view position x,y 0.061957868649318466 0
//
// NOTE: Because view position is relative to the Camera's view area, your x value will depend on the resolution of your screen. 
//       Try resizing your screen and running the test again. You will notice your x value has changed.
//

// Using the GraphicObject constructor, add a GraphicObject named "MyGraphicObject" to the main scene
let myGraphicObject = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "MyGraphicObject" );
// Update the x position of myGraphicObject, moving it to the right 100 world units.
myGraphicObject.position.x = 100;
// Console log the x and y of "MyGraphicObject" using getViewPosition(). 
console.log( "'MyGraphicObject' view position x,y", myGraphicObject.getViewPosition().x, myGraphicObject.getViewPosition().y );
// Update the x position of myGraphicObject again, moving it to the right 200 world units.
myGraphicObject.position.x = 200;
// Console log the x and y of "MyGraphicObject" using getViewPosition(). 
console.log( "'MyGraphicObject' view position x,y", myGraphicObject.getViewPosition().x, myGraphicObject.getViewPosition().y );





SceneObject.getGlobalRotation(returnVector3)
[type: function] [returns: Vector3] 
Returns a Vector3 with the global rotation of this SceneObject within the Scene.

SceneObject.getGlobalRotation parameter: returnVector3
[type: Vector3] [optional] 
Optional Vector3 that can be supplied to avoid the generation of a new Vector3 object for efficiency.





SceneObject.swoopGlobalRotation(endValues, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl)
[type: function] [returns: Swooper] 
Swoops this SceneObject's rotation using global coordinates.

SceneObject.swoopGlobalRotation parameter: endValues
[type: [number]] 
The array of target global scale values [x,y,z].

SceneObject.swoopGlobalRotation parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

SceneObject.swoopGlobalRotation parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

SceneObject.swoopGlobalRotation parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

SceneObject.swoopGlobalRotation parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

SceneObject.swoopGlobalRotation parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

SceneObject.swoopGlobalRotation parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

SceneObject.swoopGlobalRotation parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.





SceneObject.setEffectNodes(effectNodes, alsoSetDescendants)
[type: function] 
Sets the EffectNodes for the Materials associated with this SceneObject.  EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.

SceneObject.setEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The new list of EffectNodes that will apply to the Materials associated with this SceneObject.

SceneObject.setEffectNodes parameter: alsoSetDescendants
[type: boolean] [default: true] [optional] 
Boolean determining if this SceneObject's descendants' Materials will also adopt the provided list of EffectNodes.





SceneObject.addEffectNodes(effectNodes, alsoAddToDescendants)
[type: function] 
Adds the given EffectNodes to the Materials associated with this SceneObject. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of the given SceneObject or Material. When a GraphicObject is set to a particular GraphicAsset, it's Materials adopt the GraphicAsset's EffectNode and EffectController presets by default, but they can be customized at any time.

SceneObject.addEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The EffectNodes to add to this SceneObject and its Materials.

SceneObject.addEffectNodes parameter: alsoAddToDescendants
[type: boolean] [default: true] [optional] 
Boolean determining if the given EffectNodes will also be added to the SceneObject's descendants' Materials.





SceneObject.setLayers(layer, sceneObjectList)
[type: function] 
Sets the Layers of all of the GraphicObject descendants of this SceneObject to the supplied Layer.

SceneObject.setLayers parameter: layer
[type: Layer] 
The layer to change this SceneObject's descendants to.

SceneObject.setLayers parameter: sceneObjectList
[type: [SceneObject]] [optional] 
Optional list designating exactly which decendants to set the layers for. If left undefined, all GraphicObject descendants' layers will be updated.

example:
// Objective: Swap the position of GraphicObjects using setLayers().
// Action: Click the white triangle Button to swap the layering of the red and white boxes.
// Expected Result: Upon clicking the white triangle Button, the red and white boxes will swap positions.

// Start by creating 2 different GraphicObjects, red and white.
let redBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "RedBox" );
redBox.fillColor = new Color( 1,0,0,1 ); // make the white box red

let whiteBox = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "WhiteBox" );
// Offset the White Box, 25 world units, down and to the right.
whiteBox.position.x = 25;
whiteBox.position.y = -25;

// Define a new Layer named "LayerA" and set the red box to "LayerA".
nc.defineLayer( "LayerA", nc.mainScene );
redBox.layer = nc.layers.LayerA;
// Define a new Layer named "LayerB" and set the white box to "LayerB".
nc.defineLayer( "LayerB", nc.mainScene );
whiteBox.layer = nc.layers.LayerB;

// Using the nc factory method, create a white triangle button to handle the action of swapping layers.
let button = nc.addButton( nc.graphicAssets.WhiteTriangle, nc.mainScene, "MyButton" );
button.position.x = -120; // offset the button to the left
// Add a button callback function.
this.mySwapCallback = function(args) {
    // Swap the red and white Layers of the boxes.
    if ( redBox.layer === nc.layers.LayerA ) {
        redBox.setLayers( nc.layers.LayerB );
        whiteBox.setLayers( nc.layers.LayerA );
    } else {
        redBox.setLayers( nc.layers.LayerA );
        whiteBox.setLayers( nc.layers.LayerB );
    }
}
// Add a reference to a callback function passing the owner of the function and the function name.
button.addReleaseCallback( this, "mySwapCallback" );





SceneObject.setSubLayers(subLayer, sceneObjectList)
[type: function] 
Sets the SubLayer values of all of the GraphicObject descendants of this SceneObject to the supplied subLayer value.

SceneObject.setSubLayers parameter: subLayer
[type: Layer] 
The subLayer to change this SceneObject's descendants to.

SceneObject.setSubLayers parameter: sceneObjectList
[type: [SceneObject]] [optional] 
Optional list designating exactly which decendants to set the layers for. If left undefined, all GraphicObject descendants' layers will be updated.





SceneObject.configureLayoutObject(refreshLayoutCallbackOwner, refreshLayoutCallbackName, refreshLayoutCallbackArgs)
[type: function] 
Function to configure the SceneObject with LayoutObject functionality, which prepares it to be added as an element to a LayoutStack. Once configured, the configuration information can be found (and adjusted if necessary) in the SceneObject.layoutObject. Most SceneObject-inheriting objects have standard LayoutObject functionality that is automatically configured when they are added as elements to a LayoutStack, so this method is mainly for creating custom LayoutObject functionality. Configuration consists of supplying a callback to a user-defined function that refreshes the layout of the SceneObject in question and returns a Vector2 containing the resulting dimensions.

SceneObject.configureLayoutObject parameter: refreshLayoutCallbackOwner
[type: object] 
The object owning the callback function that is called by the LayoutStack containing this LayoutObject when the layout is refreshed.

SceneObject.configureLayoutObject parameter: refreshLayoutCallbackName
[type: string] 
The name of the callback function that is called by the LayoutStack containing this LayoutObject when the layout is refreshed.

SceneObject.configureLayoutObject parameter: refreshLayoutCallbackArgs
[type: Array, any] 
Arguments for the callback function that is called by the LayoutStack containing this LayoutObject when the layout is refreshed.

example:
// Objective: Configure a layout object.
// Expected Result: The console should read "layout object width and height after configuration: 20 10".

// Create a SceneObject using the SceneObject constructor. This will add "MySceneObject" to the main scene.
this.mySceneObject = new SceneObject( nc.mainScene, "MySceneObject" );

// Add a callback function.
this.myCallback = function(args) {
    // return a Vector2 with a width of 20 and a height of 10
    return new Vector2( 20, 10 ); 
}

// Add a reference to a callback function passing the owner of the function and the function name.
this.mySceneObject.configureLayoutObject( this, "myCallback" );
console.log('layout object width and height after configuration:', this.mySceneObject.layoutObject.width, this.mySceneObject.layoutObject.height);





SceneObject.configureUiKeyboardNavigator()
[type: function] 
Function to configure the SceneObject with UiKeyboardNavigator functionality, which enables the end-user to press the tab, space, and enter keys to outline and trigger any 'uiKeyboardNavigable' descendants of the SceneObject owning this UiKeyboardNavigator when it is 'in focus' according to 'nc.singularFocusObject'. Calling 'configureUiKeyboardNavigator' populates the 'uiKeyboardNavigator' member for the owning SceneObject.





SceneObject.configureUiKeyboardNavigable(setOutlineCallbackOwner, setOutlineCallbackName, triggerCallbackOwner, triggerCallbackName)
[type: function] 
Function to configure the SceneObject with UiKeyboardNavigable functionality, which enables the end-user access the SceneObject using keyboard navigation.  Calling 'configureUiKeyboardNavigable' populates the 'uiKeyboardNavigable' member for the owning SceneObject.

SceneObject.configureUiKeyboardNavigable parameter: setOutlineCallbackOwner
[type: object] 
The owner of the callback that occurs whenever keyboard navigation changes the 'outline' state of the UiKeyboardNavigable object. The outline state will be sent to the callback as its first parameter.

SceneObject.configureUiKeyboardNavigable parameter: setOutlineCallbackName
[type: string] 
The name of the callback that occurs whenever keyboard navigation changes the 'outline' state of the UiKeyboardNavigable object. The outline state will be sent to the callback as its first parameter.

SceneObject.configureUiKeyboardNavigable parameter: triggerCallbackOwner
[type: object] 
The owner of the callback that occurs whenever keyboard navigation triggers the UiKeyboardNavigable object via the spacebar or enter keys.

SceneObject.configureUiKeyboardNavigable parameter: triggerCallbackName
[type: string] 
The name of the callback that occurs whenever keyboard navigation triggers the UiKeyboardNavigable object via the spacebar or enter keys





SceneObject.configureUiVisualFocus()
[type: function] 
Function to configure the SceneObject with UiVisualFocus functionality, which focuses the end-user's attention on the given SceneObject by placing it in front of a dimmer layer whenever the object is the the current 'singularFocusObject'. Calling 'configureUiVisualFocus' populates the 'uiVisualFocus' member for the owning SceneObject. It should be noted that the dimmer layer that the newly focused item is placed in front of is actually a button which, when pressed, calls the 'attemptExitUiVisualFocus' member of the current singularFocusObject if that member is defined.





SceneObject.updateWorldMatrix(updateAncestors, updateDescendants)
[type: function] 
The worldMatrix is normally updated during scene traversal for rendering. If an updated worldMatrix is needed before then, this function forces the worldMatrix to be updated.

SceneObject.updateWorldMatrix parameter: updateAncestors
[type: boolean] [default: false] [optional] 
If true, the world matrices of all ancestors whose 'worldMatrixOverrideMode' is false will first be updated. This is useful if the worldMatrix is being updated to account for an ancestor's transformation changing.

SceneObject.updateWorldMatrix parameter: updateDescendants
[type: boolean] [default: false] [optional] 
If true, the world matrices of all descendants whose 'worldMatrixOverrideMode' is false with also be updated. This is useful if the world matrices of descendants need to immediately account for this SceneObejct's updated worldMatrix.










----------------------------------------------------------
Section 105: Scene
----------------------------------------------------------


Scene
[type: class] [extends: SceneObject] 
A Scene is a root SceneObject in the hierarchy. All SceneObjects are either Scenes or descendants of Scenes.





Scene.layerOrderLedger
[type: [string]] 
A read-only list of this Scene's layer names in order from back to front.





Scene.defineLayer(name, placeBehindThisLayer)
[type: function] [returns: Layer] 
Defines a new Layer within this Scene. For a list of all Layers within all Scenes, see 'nc.layers'. For a list of all Layers within specific Scenes, see 'nc.layersByScene'.

Scene.defineLayer parameter: name
[type: string] 
The name of the new Layer.

Scene.defineLayer parameter: placeBehindThisLayer
[type: Layer] [default: nc.layers.DefaultLayer] [optional] 
Supply this optional Layer, and the newly defined Layer will be populated behind the provided Layer.






















































































































































































































































































































----------------------------------------------------------
Section 106: Layer
----------------------------------------------------------


Layer
[type: class] [NON-INSTANTIABLE] 
Object representing a rendering order group. The 'GraphicObject.layer' property can assigned to specific Layers to manipulate the render order of the given GraphicObject. Use 'Scene.defineLayer' to add a new Layer to a Scene. To manipulate the render order of GraphicObjects within the same Layer, see the 'GraphicObject.subLayer' property. 





Layer.type
[type: string] 
The type identifier.





Layer.name
[type: string] 
The name of the Layer










----------------------------------------------------------
Section 107: LayersByScene
----------------------------------------------------------


LayersByScene
[type: class] [NON-INSTANTIABLE] 
Dictionary of Dictionaries of Layers per Scene. 





LayersByScene."MainScene"
[type: LayersInScene0] 
Dictionary of Layers in the 'MainScene' Scene.










----------------------------------------------------------
Section 108: ScrollingPanel
----------------------------------------------------------


ScrollingPanel
[type: class] [extends: CursorInputOverrideButton] 
A ScrollingPanel is a specialized GraphicObject with a Scene that it renders to its RenderTarget/Texture. The Cameara that renders the Scene is the 'view window' into the Scene in question, and if the content from the Scene is larger than the Camera's bounds, then scroll pills appear, and the end-user can navigate around the Scene by scrolling. Within the Scene, a LayoutStack manages the layout of the contained content an informs the ScrollingPanel of the contents' size.





ScrollingPanel.scene
[type: Scene] 
The Scene where the content in this ScrollingPanel resides.





ScrollingPanel.bodyStack
[type: LayoutStack] 
The LayoutStack that manages the content in this ScrollingPanel. In order for any content to be properly recognized by this ScrollingPanel, it must be added to the LayoutStack using 'ScrollingPanel.layoutStack.addElements'





ScrollingPanel.camera
[type: OrthographicCamera] 
The Camera that renders the 'view window' of this ScrollingPanel to it's RenderTarget/Texture.





ScrollingPanel.renderTarget
[type: RenderTarget] 
The RenderTarget that this ScrollingPanel is rendered to.





ScrollingPanel.width
[type: number] [default: 500] 
The width of the ScrollingPanel. This also informs the width of the Camera's view area within the Scene.





ScrollingPanel.height
[type: number] [default: 500] 
The height of the ScrollingPanel. This also informs the height of the Camera's view area within the Scene.





ScrollingPanel.dragPanelToScroll
[type: boolean] [default: true] 
Flag determining if the end-user can scroll by dragging anywhere within the ScrollingPanel. If false, the user can still Scroll using the standard mouse/trackpad methods, or by dragging the scroll pills.





ScrollingPanel.dragPanelMomentum
[type: boolean] [default: true] 
Flag determining if the scrolling motion maintains momentum when the end-user 'flings' their finger across the ScrollPanel (if 'dragPanelToScrol=true').





ScrollingPanel.panelDragMomentumDecay
[type: number] [default: 0.9] 
Value that multiplies the momentum speed of the ScrollingPanel (if applicable) each fixedUpdate, causing the 'flung' scrolling to slow down eventually.





ScrollingPanel.scrollPillVertical
[type: UiPanel] 
A UiPanel/Button that can be dragged up and down to control the vertical scroll of this ScrollingPanel. The scroll pills are children of the ScrollingPanel, and are not within the ScrollingPanel's Scene.





ScrollingPanel.scrollPillHorizontal
[type: UiPanel] 
A UiPanel/Button that can be dragged left and right to control the horizontal scroll of this ScrollingPanel. The scroll pills are children of the ScrollingPanel, and are not within the ScrollingPanel's Scene.





ScrollingPanel.scrollPillThickness
[type: number] [default: nc.uiStyle.spacer_medium] 
Width of the verticalScrollPill and height of the horizontalScrollPill. This value will be automatically adjusted down if it is more than 25% of the width or height of this ScrollingPanel.





ScrollingPanel.scrollPillShapeRatio
[type: number] [default: 3] 
Number determining the length to width ratio of the scroll pills. This value will be automatically adjusted down if it results in a scroll pill that is longer than 50% of its range of motion.





ScrollingPanel.scrollPillColor
[type: Color] 
The Color of the scroll pills.





ScrollingPanel.scrollPillHighlightColor
[type: Color] 
The Color of the scroll pills when highlighted. The 'alpha' value from this color is disregarded.





ScrollingPanel.scrollPillOpacity
[type: number] 
The baseline opacity of the scroll pills.





ScrollingPanel.scrollAmountVertical
[type: number] 
The current vertical scroll amount ranging from 0 to 1.





ScrollingPanel.scrollAmountHorizontal
[type: number] 
The current horizontal scroll amount ranging from 0 to 1.





ScrollingPanel.scrollPillFadeDelay
[type: number] [default: 1.2] 
The number of seconds (since the latest scrolling activity) before the scroll pills will fade away. The pills will re-appear upon new scroll activity. Set this value to 0 to make the scroll pills never fade away.





ScrollingPanel.pivotPoint
[type: Vector2] [default: new Vector2(-.5,.5)] 
The pivot point of the ScrollingPanel.





ScrollingPanel.useNearestPixelRendering
[type: boolean] [default: false] 
A ScrollingPanel is ultimately a 'pre-rendered' Scene that is positioned in the outer Scene and then rendered again. Because of this, certain canvas sizes or TextBox positioning can lead to slightly blurrier rendering that can be noticable for finer detail. Calling this function can mitigate such fine-detail-blurriness, as it sets the downscalingMode and upscalingMode to 'nearest', and sets the 'snapToNearestWorldPosition' to true. These settings help to ensure that the ScrollingPanel texture pixels are always aligned with the canvas pixels, preserving the original crispy edges. The tradeoff with using this mode is that the position of text will appear to always snap to the nearest pixel, which can lead to jerky-looking movement at slow speeds, and also rotation and other transformations will tear badly.





ScrollingPanel.uiZoomAffectsPanelSize
[type: boolean] [default: true] 
Boolean determining if uiZoom affects the affective view size of the ScrollingPanel.





ScrollingPanel.popToOuterSceneAndMaintainPosition(sceneObject)
[type: function] 
Re-parents a descendant of the ScrollingPanel Scene to the SceneContaining the ScrollingPanel itself while maintaining visual global position.

ScrollingPanel.popToOuterSceneAndMaintainPosition parameter: sceneObject
[type: SceneObject] 
The SceneObject to move from the ScrollingPanel Scene to the Scene that contains the ScrollingPanel.





ScrollingPanel.getOuterScenePosition(sceneObject)
[type: function] 
Returns a Vector3 corresponding to the global position of a SceneObject residing in the ScrollingPanel Scene, but from the context of the 'outer' Scene which contains the ScrollingPanel itself. This can be used to align something in the 'outer' Scene with something inside the ScrollingPanel Scene.

ScrollingPanel.getOuterScenePosition parameter: sceneObject
[type: SceneObject] 
The SceneObject within the ScrollingPanel Scene to get the position of.





ScrollingPanel.scrollToObject(sceneObject, width, height, widthBuffer, heightBuffer)
[type: function] 
Scrolls the ScrollingPanel so that the given SceneObject is visible within its Camera's viewing area. Dimensions, and buffer values can be supplied to ensure that the entire SceneObject is made visible upon calling this function.

ScrollingPanel.scrollToObject parameter: sceneObject
[type: SceneObject] 
The SceneObject to scroll to.

ScrollingPanel.scrollToObject parameter: width
[type: number] [default: 0] [optional] 
The width of the SceneObject can be supplied here to help ensure that the entire object is visible within the Camera's viewing area. If the SceneObject has a configured LayoutObject, then this parameter can be left undefined, and the LayourObject's width will automatically be applied.

ScrollingPanel.scrollToObject parameter: height
[type: number] [default: 0] [optional] 
The height of the SceneObject can be supplied here to help ensure that the entire object is visible within the Camera's viewing area. If the SceneObject has a configured LayoutObject, then this parameter can be left undefined, and the LayourObject's height will automatically be applied.

ScrollingPanel.scrollToObject parameter: widthBuffer
[type: number] [default: 0] [optional] 
A buffer can be supplied here to ensure that the scrolling results in the SceneObject being visible with X amount of room to spare.

ScrollingPanel.scrollToObject parameter: heightBuffer
[type: number] [default: 0] [optional] 
A buffer can be supplied here to ensure that the scrolling results in the SceneObject being visible with Y amount of room to spare.































































































































































































































































































































































































































































































































































































----------------------------------------------------------
Section 109: SlotReel
----------------------------------------------------------


SlotReel
[type: class] [extends: SceneObject] [requires: module - slotReels, license - proGaming] 
A specialized SceneObject which populates and manipulates 'symbol' objects to create a spinning reel to be used for slot games. The 'spinning' effect is created by moving each GraphicObject along a modulus-style path, where the represented symbol changes when each GraphicObject reaches the 'jump' point in the path. The symbols can be customized by supplying a CustomObjectDefinition or CustomAddOnDefinition, which will be used in the population of each symbol.





SlotReel.defaultSymbolPathTravelY
[type: number] [default: 200] 
If no 'symbolPathConstructDefinition' is connected to this SlotReel, then the defaultSymbolPathTravelX and defaultSymbolPathTravelY define the spinning motion of this SlotReel. The defaultSymbolPathTravelY value determines the amount of vertical travel per 'symbolPosition'. The symbolPosition property value is populated by the SlotReel as the symbols move, and it corresponds to each symbol's location along the symbol path, where a value of 0 corresponds to the center of the first main visible symbol, 1 corresponds to the next main visible symbol, and -1 corresponds to the top buffer symbol just above the symbol in position 0. So, the default value of 200 for this property means that each symbol will be 200 vertical world units from the next.





SlotReel.defaultSymbolPathTravelX
[type: number] 
If no 'symbolPathConstructDefinition' is connected to this SlotReel, then the defaultSymbolPathTravelX and defaultSymbolPathTravelY define the spinning motion of this SlotReel. The defaultSymbolPathTravelX value determines the amount of horizontal travel per 'symbolPosition'. The symbolPosition property value is populated by the SlotReel as the symbols move, and it corresponds to each symbol's location along the symbol path, where a value of 0 corresponds to the center of the first main visible symbol, 1 corresponds to the next main visible symbol, and -1 corresponds to the top buffer symbol just above the symbol in position 0. So, the default value of 0 for this property means that each symbol does not travel horizontally as it moves along the symbol path.





SlotReel.spinSpeed
[type: number] [default: -0.25] 
The spinSpeed property represents the rate of motion for each symbol object during the reel spin. The value corresponds to the amount of travel per 60th of a second, where a value of 1 indicates that each symbol will move one full symbol position each 60th of a second.





SlotReel.windupMotionFunctionOwner
[type: object] 
The owner of the function that defines this SlotReel's motion during the 'windup' state. The windup motion for this SlotReel can be customized by providing a bespoke function here. The windup function should take 2 numeric parameters (progress and windupMagnitude), and return a symbolPostion offset value. The progress parameter sent to the windup function will interpolate smoothly from 0 to 1 over a time corresponding to this SlotReel's 'windupDuration' property. The windupMagnitude value sent to the windup function will be taken directly from ths SlotReel's 'windupMagnitude' property, and can be used (optionally) in the function to change the motion dynamically. The windup function should return a value corresponding to the 'symbolPosition' offset that all of the symbols will experience given the current 'progress' value; so for a windup function to make the symbols move up half a symbol position, the provided windup function should return a value of 0.5 at its peak.





SlotReel.windupMotionFunctionName
[type: string] 
The name of the function that defines this SlotReel's motion during the 'windup' state. The windup motion for this SlotReel can be customized by providing a bespoke function here. The windup function should take 2 numeric parameters (progress and windupMagnitude), and return a symbolPostion offset value. The progress parameter sent to the windup function will interpolate smoothly from 0 to 1 over a time corresponding to this SlotReel's 'windupDuration' property. The windupMagnitude value sent to the windup function will be taken directly from ths SlotReel's 'windupMagnitude' property, and can be used (optionally) in the function to change the motion dynamically. The windup function should return a value corresponding to the 'symbolPosition' offset that all of the symbols will experience given the current 'progress' value; so for a windup function to make the symbols move up half a symbol position, the provided windup function should return a value of 0.5 at its peak.





SlotReel.windupDuration
[type: number] 
The amount of time that this SlotReel will spend in the 'windup' state.





SlotReel.windupMagnitude
[type: number] 
A value sent to the windup motion function that can be used (optionally) within the function to enable the windup motion to be manipulated dynamically.





SlotReel.bounceMotionFunctionOwner
[type: object] 
The owner of the function that defines this SlotReel's motion during the 'bounce' state. The bounce motion for this SlotReel can be customized by providing a bespoke function here. The bounce function should take 2 numeric parameters (progress and bounceMagnitude), and return a symbolPostion offset value. The progress parameter sent to the bounce function will interpolate smoothly from 0 to 1 over a time corresponding to this SlotReel's 'bounceDuration' property. The bounceMagnitude value sent to the bounce function will be taken directly from ths SlotReel's 'bounceMagnitude' property, and can be used (optionally) in the function to change the motion dynamically. The bounce function should return a value corresponding to the 'symbolPosition' offset that all of the symbols will experience given the current 'progress' value; so for a bounce function to make the symbols move up half a symbol position, the provided bounce function should return a value of 0.5 at its peak.





SlotReel.bounceMotionFunctionName
[type: string] 
The name of the function that defines this SlotReel's motion during the 'bounce' state. The bounce motion for this SlotReel can be customized by providing a bespoke function here. The bounce function should take 2 numeric parameters (progress and bounceMagnitude), and return a symbolPostion offset value. The progress parameter sent to the bounce function will interpolate smoothly from 0 to 1 over a time corresponding to this SlotReel's 'bounceDuration' property. The bounceMagnitude value sent to the bounce function will be taken directly from ths SlotReel's 'bounceMagnitude' property, and can be used (optionally) in the function to change the motion dynamically. The bounce function should return a value corresponding to the 'symbolPosition' offset that all of the symbols will experience given the current 'progress' value; so for a bounce function to make the symbols move up half a symbol position, the provided bounce function should return a value of 0.5 at its peak.





SlotReel.bounceDuration
[type: number] 
The amount of time that this SlotReel will spend in the 'bounce' state.





SlotReel.bounceMagnitude
[type: number] 
A value sent to the bounce motion function that can be used (optionally) within the function to enable the bounce motion to be manipulated dynamically.





SlotReel.assembleReelDataOnTheFly
[type: boolean] [default: false] 
Boolean indicating if this SlotReel is in 'assembleReelDataOnTheFly' mode. When true, the data for this reel is initially only seeded with a small portion of of reel data, and each reel spin adds its symbols (as provided to the 'setTarget' function) to the end of the reel data array. The reel data continues to grow with each spin until it meets the 'reelDataAssemblyMax' threshold, at which point the additional symbols overwrite a random portion of the existing reel data. When false, the entire reel must be provided initially.





SlotReel.reelDataAssemblyMax
[type: number] [default: 200] 
When 'assembleReelDataOnTheFly' for this SlotReel is true, this property acts a reel data length cap. Once the reel data length reaches this value additional symbols provided in the 'setTarget' call are randomly placed within the reel data, overwriting previously placed reel data.





SlotReel.reelState
[type: string] 
Read-only string indicating which state this SlotReel is in. States include 'stopped', 'windup', 'spinFree', 'stopping', 'stopImminent', and 'bounce', which can be found in constants.slotReelStates. - The 'stopped' state corresponds when the SlotReel is stopped. - The 'windup' state corresponds just before the main portion of the spin, when the SlotReel is 'winding up'. - The 'spinFree' state corresponds to when SlotReel is freely spinning, which will continue indefinitely until 'beginStop' or 'slam' are called. - The 'stopping' state corresponds to the time during the spin after 'beginStop' has been called; the SlotReel will continue in this state until the final stopping symbols have been found. - The 'stopImminent' state corresponds to when the final stopping symbols are active/visible on the SlotReel, and they just need to travel into their final position. - The 'bounce' state corresponds to right before the SlotReel spin is over, and the symbols are bouncing around to simulate a physical recoil action.





SlotReel.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this SlotReel will be immune to. Set this parameter to [] for this Swooper to have no pause immunity.





SlotReel.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this SlotReel is affected by.





SlotReel.numMainSymbols
[type: number] 
The number of 'symbol' GraphicObjects that are meant to be the main visible symbols for this SlotReel. This property is read-only since its value is set once in the constructor.





SlotReel.numTopBufferSymbols
[type: number] 
The number of symbol objects that will be populated 'above' the main visible symbols for this SlotReel. It should be noted that since the motion of the symbols in this SlotReel is completely customizable, these buffer symbols will not necessarily be above the main symbols. This property is read-only since its value is set once in the constructor.





SlotReel.numBottomBufferSymbols
[type: number] 
The number of symbol objects that will be populated 'below' the main visible symbols for this SlotReel. It should be noted that since the motion of the symbols in this SlotReel is completely customizable, these buffer symbols will not necessarily be below the main symbols. This property is read-only since its value is set once in the constructor.





SlotReel.numSymbols
[type: number] 
The total number of symbol objects that will be populated for this SlotReel, which includes the numMainSymbols, numTopBufferSymbols, and numBottomBufferSymbols. This property is read-only since its value is effectively set once in the constructor.





SlotReel.symbolDefinition
[type: CustomAddOnDefinition] 
The definition of the CustomObject CustomAddOn that was used to populate each of the symbol objects. The CustomObject or CustomAddOn in question should implement the 'setSymbol' function, which takes a single string parameter which will be passed whenever the associated symbol is altered. It can also implement the 'symbolPosition' numeric property, which will be updated by the SlotReel as each symbol moves along the symbol path for this SlotReel. The definition of this object is also where further customization of each symbol can be defined. This property is read-only since its value is set once in the constructor.





SlotReel.symbolPathOverrideMode
[type: boolean] [default: false] 
Boolean determining if the SlotReel's positioning of its symbol objects along the reel path is overriden. To entirely override reel path positioning of the symbols, set this property to true, and be sure to implement an 'updateSymbolPosition' function within the symbolDefinition object. Within that function, you can create custom positioning for each symbol based on the 'symbolPosition' property, which indicates the relative or 'unit' position of each symbol (ie a reel with 3 main symbols and a single buffer on top and bottom would have symbols with symbolPosition values of -1, 0, 1, 2, 3). Using the 'symbolPosition' property, you can write functionality to position each symbol as desired based on its relative position.





SlotReel.populateInitialReelData(reelData, initialSymbols)
[type: function] 
Call this function to provide this SlotReel with its initial reel data, and the symbols that will appear when the SlotReel is first displayed. Reel data consists of an array of strings that represent the designation of each symbol on the 'reel strip'. The data that is provided depends on whether or not the SlotReel is in 'assembleReelDataOnTheFly' mode. If assembleReelDataOnTheFly is true, then only a small portion of reel data need be provided, as each subsequent call to 'setTarget' will add to the reel data. If assembleReelDataOnTheFly is false, then the entire reel data set must be provided here.

SlotReel.populateInitialReelData parameter: reelData
[type: [string]] 
The set of initial reel data to provide to this SlotReel. If assembleReelDataOnTheFly is true, only a small portion of reel data need be provided, otherwise the entire reel data set must be provided here.

SlotReel.populateInitialReelData parameter: initialSymbols
[type: [string]] [optional] 
An array of strings representing the initial symbols to populate on the reel when it is first displayed. If left undefined, starting symbols will be taken directly from the reelData provided.





SlotReel.setTarget(target)
[type: function] 
Sets the target position in the reel data (the reel stop), or the target group of symbols to be displayed to be displayed when the SlotReel comes to a stop. If assembleReelDataOnTheFly is false, then provide an index in the reel data here, and the symbol at that index will be displayed in this SlotReel's first main visible position (position 0) spin ends, with the subsequent symbols displayed below respectively. If assembleReelDataOnTheFly is true, then provide an array of strings corresponding to the symbols to be displayed when the SlotReel spin stops - in this case be sure to provide enough symbol strings for the top buffer symbols, the main symbols, and the bottom buffer symbols.

SlotReel.setTarget parameter: target
[type: number, [string]] 
If assembleReelDataOnTheFly is false provide the final stopping reel data index, if it's true provide final stopping set of symbols in an array.





SlotReel.beginSpin()
[type: function] 
Function that begins the spin sequence for this SlotReel, changing the reelState from 'stopped' to 'windup'. The SlotReel will perform the windup sequence, and then the reelState will be changed to 'spinFree', which will lead the SlotReel to spin until further interaction.





SlotReel.beginStop(performSplice)
[type: function] 
Function the starts the process of stopping a reel from spinning, changing the reelState from 'spinFree' to 'stopping'. While the reelState is 'stopping', the SlotReel will continue to spin until it encounters the set of symbols it needs for the final stopped position. A 'performSplice' boolean (when true) will tell the SlotReel to jump to the position in the reel data such that each new symbol made visible during the spin will be one of the final symbols needed - this expedites the stopping process. This value should be false if the reel is meant to spin just a finite number of positions (i.e. 1 position), as a value of true would only extend the stopping process in this case.

SlotReel.beginStop parameter: performSplice
[type: boolean] [default: true] [optional] 
Boolean indicating if the SlotReel should jump to a place in the reel data such that the very next symbols made visible will be the final stopping symbols needed to stop the spin.





SlotReel.slam()
[type: function] 
Function that can be called during the SlotReel spin sequence to abruptly skip to the 'bounce' reelState.





SlotReel.getSymbol(index)
[type: function] [returns: SceneObject] 
Returns the 'symbol' object at the given index. Any index in [-numTopBufferSymbols, numMainSymbols+numBottomBufferSymbols-1] can be provided, as that is the set of available symbolPositions. If the SlotReel is currently in any reelState other than 'stopped' then the 'symbol' GraphicObject with the symbolPosition that is nearest to the index provided will be returned. It should be noted that the type of the returned object depends on the original 'symbolDefinition' supplied to the SlotReel's constructor. If a CustomObjectDefinition was provided, then the returned object will have that type, otherwise the returned object will be of type GraphicObject.

SlotReel.getSymbol parameter: index
[type: number] 
The index of the 'symbol' GraphicObject to fetch. Any index in [-numTopBufferSymbols, numMainSymbols+numBottomBufferSymbols-1] can be provided, as that is the set of available symbolPositions.





SlotReel.getSymbols(presortBySymbolPosition)
[type: function] [returns: [SceneObject]] 
Returns an Array with all of the 'symbol' objects in this SlotReel. It should be noted that the type of the objects in the returned array depends on the original 'symbolDefinition' supplied to the SlotReel's constructor. If a CustomObjectDefinition was provided, then the returned array will contain objects of that type, otherwise the the array will contain GraphicObjects.

SlotReel.getSymbols parameter: presortBySymbolPosition
[type: boolean] [optional] 
Boolean indicating if the returned symbols should be sorted by their 'symbolPosition' values.





SlotReel.addReelStateChangeCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever the 'reelState' of this SlotReel is changed. The new reelState and the previous reelState are sent to the callback as its first two parameters. - The 'stopped' state corresponds when the SlotReel is stopped. - The 'windup' state corresponds just before the main portion of the spin, when the SlotReel is 'winding up'. - The 'spinFree' state corresponds to when SlotReel is freely spinning, which will continue indefinitely until 'beginStop' or 'slam' are called. - The 'stopping' state corresponds to the time during the spin after 'beginStop' has been called; the SlotReel will continue in this state until the final stopping symbols have been found. - The 'stopImminent' state corresponds to when the final stopping symbols are active/visible on the SlotReel, and they just need to travel into their final position. - The 'bounce' state corresponds to right before the SlotReel spin is over, and the symbols are bouncing around to simulate a physical recoil action.

SlotReel.addReelStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever the FlowState changes.

SlotReel.addReelStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever the FlowState changes.

SlotReel.addReelStateChangeCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever the FlowState changes.





SlotReel.removeReelStateChangeCallback(callbackOwner, callbackName)
[type: function] 
Removes the given callback.

SlotReel.removeReelStateChangeCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

SlotReel.removeReelStateChangeCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.






















































































































































































































































































































----------------------------------------------------------
Section 110: Sound
----------------------------------------------------------


Sound
[type: class] [extends: TimePlaybackController] [NON-INSTANTIABLE] [requires: module - sounds] 
A specialized PlaybackController that manages the playback of sound assets. 





Sound.name
[type: string] 
The Sounds's name. This must be unique among Sounds.





Sound.isLoaded
[type: boolean] 
Boolean indicating if this Sound is currently loaded.





Sound.loadingTierRequirements
[type: [number]] 
The LoadingTier that this Sound belongs too. LoadingTiers are a means to organize AssetComponents into separately downloadable groups.





Sound.duplicateSource
[type: string] [default: undefined] 
String indicating the source of this Sound if it is a duplicate. Incisor® automatically detects when two or more AssetComponents are identical, ensuring that only one copy of the associated data is loaded to reduce the loaded size of the project. Those AssetComponents that are duplicates are marked by indicating the name of the source of their data. This member is undefined for AssetComponents that are not duplicates.





Sound.mainVolume
[type: number] 
The current volume setting for this Sound, where 0 is quiet and 1 is full volume.





Sound.volumeControl
[type: [VolumeControl]] [default: [nc.volumeControls.MainVolumeControl]] 
The VolumeControls that this Sounds currently subscribes to. VolumeControls are a way to control the volumes of groups of sounds, much like a 'audio bus'.





Sound.netVolume
[type: number] 
The net volume, including the mainVolume of the Sound, and all of the volumes of the Sound's VolumeControls.





Sound.swoopVolume(volume, duration, completionCallbackOwner, completionCallbackName, completionCallbackArgs)
[type: function] [returns: Swooper] 
Interpolates the mainVolum over the designated period of time.

Sound.swoopVolume parameter: volume
[type: number] 
The target volume to swoop to.

Sound.swoopVolume parameter: duration
[type: number] [default: 0] 
The duration of the volume change

Sound.swoopVolume parameter: completionCallbackOwner
[type: object] 
The object owning the function that will be called when the swoop is complete.

Sound.swoopVolume parameter: completionCallbackName
[type: string] 
The name of the function that will be called when the swoop is complete.

Sound.swoopVolume parameter: completionCallbackArgs
[type: Array, any] 
Parameters for the function that will be called when the swoop is complete.







































































































































----------------------------------------------------------
Section 111: VolumeControl
----------------------------------------------------------


VolumeControl
[type: class] [NON-INSTANTIABLE] [requires: module - sounds] 
VolumeControls are a way to control the volumes of groups of sounds, much like a 'audio bus'. To make a particular Sound subscribe to a VolumeControl, add the VolumeControl to the Sound's 'volumeControl' array. 





VolumeControl.type
[type: string] 
Type identifier.





VolumeControl.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





VolumeControl.name
[type: string] 
The VolumeControl's name. This must be unique among VolumeControls.





VolumeControl.volume
[type: number] 
The volume value for this VolumeControl. The volume values for Sounds typically range from 0 to 1.










----------------------------------------------------------
Section 112: SpriteSetter
----------------------------------------------------------


SpriteSetter
[type: class] [extends: ValuePlaybackController] [NON-INSTANTIABLE] 
A SpriteSetter is a PlaybackController that switches a GraphicObject's graphicAsset between numerically sequential GraphicAssets. It is typically used to create a sprite animation. 





SpriteSetter.type
[type: string] 
Type identifier.





SpriteSetter.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





SpriteSetter.getAssociatedGraphicAssets()
[type: function] [returns: [GraphicAsset]] 
Returns a copy of the array of GraphicAssets that are iterated through during playback.





SpriteSetter.setAssociatedGraphicAssets(graphicAsset)
[type: function] 
Manually populates the array of GraphicAssets that will be iterated through during playback.

SpriteSetter.setAssociatedGraphicAssets parameter: graphicAsset
[type: [GraphicAsset], GraphicAsset] 
GraphicAsset or Array of Graphic Assets that will be iterated through during playback.





SpriteSetter.setKeyGraphicAsset(graphicAsset)
[type: function] 
Sets the key GraphicAsset. This GraphicAsset's name should end in a number. All GraphicAssets whose name matches the key GraphicAsset's name with a different trailing number will be used to set the SpriteSetter's associated GraphicAssets list. For example, if the key GraphicAsset is named "MyAnimation001", all GraphicAssets with the name "MyAnimation" followed by any sequence of the digits 0-9 will be gathered into this SpriteSetter's associated GraphicAssets.

SpriteSetter.setKeyGraphicAsset parameter: graphicAsset
[type: GraphicAsset] 
The GraphicAssets used for automatical detection all all numerically similar GraphicAssets.





























































































































----------------------------------------------------------
Section 113: Supervisor
----------------------------------------------------------


Supervisor
[type: class] [requires: module - extendedUi] 
A Supervisor is a class that helps manage the processes behind UI components that allow the end-user to monitor and adjust values and properties during runtime. For example, the UiNumberSupervisor_TextField type is a specialized UiTextField that contains an additional Supervisor member, and its purpose is to serve as a visual 'supervisor' for any numeric property, displaying the current value as it changes, and updating the value if the end-user types a new number into the UiTextField. The Supervisor object itself houses callbacks for setting the target property, getting the target property, and updating the associated visual compoenents (i.e. setting the string in the UiTextField to the target number value).





Supervisor.type
[type: string] 
Type identifier.





Supervisor.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Supervisor.supervisedPropertyGetterCallbackOwner
[type: object] 
The owner of the callback function that is called whenever this Supervisor needs to retrieve the property being supervised. The provided callback function must return the value being supervised.





Supervisor.supervisedPropertyGetterCallbackName
[type: string] 
The name of the callback function that is called whenever this Supervisor needs to retrieve the property being supervised. The provided callback function must return the value being supervised.





Supervisor.supervisedPropertyGetterCallbackArgs
[type: any] 
Arguments for the callback function that is called whenever this Supervisor needs to retrieve the property being supervised. The provided callback function must return the value being supervised.





Supervisor.supervisedPropertySetterCallbackOwner
[type: object] 
The owner of the callback function that is called whenever this Supervisor sets the value of the property being supervised. The provided callback function will receive the new value for the property as its first parameter.





Supervisor.supervisedPropertySetterCallbackName
[type: string] 
The name of the callback function that is called whenever this Supervisor sets the value of the property being supervised. The provided callback function will receive the new value for the property as its first parameter.





Supervisor.supervisedPropertySetterCallbackArgs
[type: any] 
Arguments for the callback function that is called whenever this Supervisor sets the value of the property being supervised. The provided callback function will receive the new value for the property as its first parameter.





Supervisor.updateVisualsCallbackOwner
[type: object] 
The owner of the callback function that is called whenever this Supervisor updates the visuals to reflect changes to the value of the property being supervised. The provided callback function will receive the up-to-date property value as its first parameter.





Supervisor.updateVisualsCallbackName
[type: string] 
The name of the callback function that is called whenever this Supervisor updates the visuals to reflect changes to the value of the property being supervised. The provided callback function will receive the up-to-date property value as its first parameter.





Supervisor.updateVisualsCallbackArgs
[type: any] 
Arguments for the callback function that is called whenever this Supervisor updates the visuals to reflect changes to the value of the property being supervised. The provided callback function will receive the up-to-date property value as its first parameter.





Supervisor.setSupervisedProperty(value)
[type: function] 
Sets the supervised property's value. This call is invoked upon the end-user manipulation of the associated visual components.

Supervisor.setSupervisedProperty parameter: value
[type: any] 
The value to set the supervised property to.





Supervisor.performStandardSetup(supervisedPropertyOwner, supervisedPropertyName, validationFunctionOwner, validationFunctionName)
[type: function] 
Creates and connects to 'standard' setter and getter functions that are simply defined by getting an property (by owner and name), and setting a property (by owner and name); For more custom functionality, such as conditional getting and setting functionality, custom getter and setter functions can be built and linked to directly using 'supervisedPropertyGetterCallbackOwner', 'supervisedPropertyGetterCallbackName', 'supervisedPropertySetterCallbackOwner', and 'supervisedPropertySetterCallbackName'.

Supervisor.performStandardSetup parameter: supervisedPropertyOwner
[type: object] 
The owner of the propertry being supervised.

Supervisor.performStandardSetup parameter: supervisedPropertyName
[type: string] 
The name of the propertry being supervised.

Supervisor.performStandardSetup parameter: validationFunctionOwner
[type: object] [optional] 
The owner of an optional validation function. This function receives, sanitizes, and returns the supervised property.

Supervisor.performStandardSetup parameter: validationFunctionName
[type: string] [optional] 
The name of an optional validation function. This function receives, sanitizes, and returns the supervised property.





Supervisor.performStandardSetupForMultiSupervision(standardSetupPropertyOwnerArray, supervisedPropertyName, validationFunctionOwner, validationFunctionName)
[type: function] 
Creates and connects to 'standard' setter and getter functions for "multi-supervision" scenarios; For more custom functionality, such as conditional getting and setting functionality, custom getter and setter functions can be built and linked to directly using 'supervisedPropertyGetterCallbackOwner', 'supervisedPropertyGetterCallbackName', 'supervisedPropertySetterCallbackOwner', and 'supervisedPropertySetterCallbackName'.

Supervisor.performStandardSetupForMultiSupervision parameter: standardSetupPropertyOwnerArray
[type: Array] 
The array where the objects owning the supervised properties will be referenced.

Supervisor.performStandardSetupForMultiSupervision parameter: supervisedPropertyName
[type: string, [string]] 
The name of the propertry being supervised. An array can be supplied here if the supervised property not a direct member.

Supervisor.performStandardSetupForMultiSupervision parameter: validationFunctionOwner
[type: object] [optional] 
The owner of an optional validation function. This function receives, sanitizes, and returns the supervised property.

Supervisor.performStandardSetupForMultiSupervision parameter: validationFunctionName
[type: string] [optional] 
The name of an optional validation function. This function receives, sanitizes, and returns the supervised property.










----------------------------------------------------------
Section 114: Swooper
----------------------------------------------------------


Swooper
[type: class] [NON-INSTANTIABLE] 
Object controlling the 'swooping' (or interpolation) of a given numeric property or properties over a duration (using fixedUpdate). An object of this type is returned from all 'swoop' calls, providing a means to manage the given swooping process. 





Swooper.type
[type: string] 
Type identifier.





Swooper.name
[type: string] 
Name of the Swooper.





Swooper.numProperties
[type: number] 
The number of properties being interpolated by this Swooper.





Swooper.progress
[type: number] [default: 0] 
The number representing the progress of the interpolation of the value or values on where 0 corresponds to the startValues, and 1 corresponds to the endValues. This value is not meant to be manipulated as it is automatically changed over time via the internal fixedUpdate used by this Swooper.





Swooper.tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] 
The TweenType for this Swooper. A TweenType defines a method of interpolation between any two values or sets of values. The default TweenType is 'Linear', which defines a perfectly even interpolation between the startValues and endValues. TweenTypes can vary the timing of interpolation between two sets of values, as well as the path of the interpolation.





Swooper.controllers
[type: TweenControllers] [default: {}] 
Dictionary of dictionaries (per TweenType) of values that can be used to control this motion dynamically.





Swooper.startValues
[type: [number]] 
Array containing the starting value or values for the Swooper. The length of this array depends on this Swoop's 'numProperties'. Upon initiating a Swooper for a given numeric property/properties, their current values are stored in this array and used as the initial conditions for the interpolation.





Swooper.endValues
[type: [number]] 
Array containing the ending value or values for the Swooper. The length of this array depends on this Swoop's 'numProperties'. These values define the final target values for the swooped properties.





Swooper.currentValues
[type: [number]] 
Array containing the current value(s) for this Swooper. These are the values that the Tween function manipulates based its 'progress' property to create the desired movement.





Swooper.workspace
[type: object] 
An un-specified JS object of 'any' type to enable the user to stash persistant elements of their swooper within the tweenFunction.





Swooper.completionCallbackOwner
[type: object] [default: undefined] 
The object owning the optional callback function invoked when this Swooper completes.





Swooper.completionCallbackName
[type: string] [default: undefined] 
The name of the optional callback function invoked when this Swooper completes.





Swooper.completionCallbackArgs
[type: any] [default: undefined] 
Arguments for the optional callback function invoked when this Swooper completes.





Swooper.updaterCallbackOwner
[type: object] [default: undefined] 
The object owning the optional callback function invoked continuously (every fixedUpdate) during the interpolation process.





Swooper.updaterCallbackName
[type: string] [default: undefined] 
The name of the optional callback function invoked continuously (every fixedUpdate) during the interpolation process.





Swooper.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] for this Swooper to have no pause immunity.





Swooper.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.





Swooper.stop(setToEndValues, performCompletionCallback)
[type: function] 
Stops the Swooper if it is in progress.

Swooper.stop parameter: setToEndValues
[type: boolean] [default: false] [optional] 
Determines if the target properties are set to the endValues.

Swooper.stop parameter: performCompletionCallback
[type: boolean] [default: false] [optional] 
Determines if the pre-determined completionCallback (if defined) is performed.










----------------------------------------------------------
Section 115: TweenType
----------------------------------------------------------


TweenType
[type: class] 
Object defining a specific type of interpolation.





TweenType.type
[type: string] 
Type identifier.





TweenType.name
[type: string] 
Name of the Motion.





TweenType.tweenFunction()
[type: function] 
A reference to the function that defines the nature of the TweenType's motion.





TweenType.tweenControllerNames
[type: [string]] 
A list of optional tween controllers. These can be used to dynamically affect the nature of the TweenType's motion.





TweenType.tweenControllerDefaultValues
[type: [number]] 
A list of optional tween controller default values.





TweenType.description
[type: string] 
The description of the TweenType - this will appear in the autocomplete documentation.





TweenType.controllerDescriptions
[type: [string]] 
The description of the TweenType controllers - these descriptions will appear in the autocomplete documentation.










----------------------------------------------------------
Section 116: TweenControllers
----------------------------------------------------------


TweenControllers
[type: class] [NON-INSTANTIABLE] 
Dictionary of all registered TweenControllers. 










----------------------------------------------------------
Section 117: TextAssembly
----------------------------------------------------------


TextAssembly
[type: class] [extends: SceneObject] 
Specialized SceneObject that presents a group of GraphicObjects as text. TextAssemblies tend to be less performant that TextBoxes, as they result in more SceneObjects being rendered, But TextAssemblies have the adventage of being able to manipulate indivual characters freely.





TextAssembly.type
[type: string] 
Type identifier.





TextAssembly.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





TextAssembly.string
[type: string] [default: ""] 
The string value of the text to be displayed by this TextAssembly.





TextAssembly.phraseID
[type: string] [default: undefined] 
Property to set this TextAssembly's string based on the associated phrase in the ProjectTranscript, which is updated based on the current language setting of the project. See 'nc.phraseIDs' for a list of available phrases.

example:
// Objective: Set the text of a TextAssembly based on a phrase defined in the ProjectTranscript.
// Expected Result: You will see "Hello World" on screen if the project language is 'en', or "Hola Mundo" if the language is 'es'.

this.textAssembly = new TextAssembly();
this.textAssembly.phraseID = nc.phraseIDs["Hello World"];





TextAssembly.boxWidth
[type: number] [default: 0] 
The maximum width that the laid out text will adhere to if 'wrapToFit' or 'scaleToFit' are true. When greater than 0, this value also determines the positioning of left or right justified text. A value of 0 corresponds to no limits on the width of the text.





TextAssembly.boxHeight
[type: number] [default: 0] 
The maximum height that the laid out text will adhere to if 'scaleToFit' is true. When greater than 0, this value also determines the positioning of top-justified or bottom-justified text. A value of 0 corresponds to no limits on the height of the text.





TextAssembly.wrapToFit
[type: boolean] [default: true] 
Bool determining if text will automatically flow onto new lines in order to fit the text within the designated 'boxWidth' value.





TextAssembly.scaleToFit
[type: boolean] [default: true] 
Bool determining if the text will automatically be scaled down to fit within the boxWidth and/or boxHeight.





TextAssembly.horizontalJustification
[type: string] [default: "left"] 
The horizontalJustification of this TextAssembly. For acceptable values, see 'nc.constants.justfications'. Setting this value will change the horizontal justification for all of the text in this TextAssembly, but the value can be set for individual sections of the text using 'TextAssembly.setHorizontalJustification'.





TextAssembly.verticalJustification
[type: string] [default: "top"] 
The verticalJustification of this TextAssembly. For acceptable values, see 'nc.constants.justfications'. Setting this value will change the vertical justification for all of the text in this TextAssembly.





TextAssembly.textWidth
[type: number] 
The read-only width of the text (once laid out). This number encapsulates the final width of the laid out text, including all of the TextFormats, the boxWidth and boxHeight, scaleToFit, wrapToFit etc...





TextAssembly.textHeight
[type: number] 
The read-only height of the text (once laid out). This number encapsulates the final height of the laid out text, including all of the TextFormats, the boxWidth and boxHeight, scaleToFit, wrapToFit etc...





TextAssembly.scaleToFitFactor
[type: number] 
For Texts or Textboxes with 'scaleToFit' set to true, this number denotes the multiplier that was applied in order for the given text to fit within the boxWidth, and boxHeight.





TextAssembly.baselinePosition
[type: number] [default: .22] 
Number representing the vertical placement of the baseline within each line of text in this TextAssembly. A value of 0 corresponds to the baseline of the text being positioned at the very bottom of each line, and a value of .5 corresponds to the baseline of the text being positioned in the middle of each line.





TextAssembly.textFormat
[type: TextFormat] [default: new TextFormat()] 
Object housing information about the customization of the characters within this TextAssembly. This includes font, scale, baseline shift, kerning, line height, as well as information about EffectNodes and EffectController values used on the characters. Setting or adjusting this value will set the TextFormat for all of the characters in this TextAssembly. See 'TextAssembly.setTextFormat' to set the TextFormat for individual sections of this TextAssembly.





TextAssembly.layoutLazyUpdater
[type: LazyUpdater] 
The LazyUpdater ultimately responsible for initiating the layout of the text. The setting of 'needsUpdate' and the calling of 'updateIfNeeded' is magaged as much as is possible internally by Incisor®, but if the need to force an update arises, set 'needsUpdate' to true, and call 'updateIfNeeded'.





TextAssembly.showWhiteSpace
[type: boolean] [default: false] 
Boolean indicating if whitespace characters will be visible in this TextAssembly.





TextAssembly.setSubstitutionCharacter(characterToSubstitute, graphicAsset, textFormat)
[type: function] 
Method used to swap all instances of the given character with a designated GraphicAsset. A TextFormat can also be supplied to help position and format the substituted GraphicAsset within the text.

TextAssembly.setSubstitutionCharacter parameter: characterToSubstitute
[type: string] 
The the character that will be replaced with the designated GraphicAsset.

TextAssembly.setSubstitutionCharacter parameter: graphicAsset
[type: GraphicAsset] [optional] 
The GraphicAsset that will substitute for the given characters. When this parameter is undefined, any previously defined substitution using the provided character will be disposed. The formats for previously substituted characters will need to be dealt with separately.

TextAssembly.setSubstitutionCharacter parameter: textFormat
[type: TextFormat] [optional] 
Optional TextFromat to apply to the substituted GraphicAsset, which can be used to adjust its positioning and formating.





TextAssembly.setTextFormat(textFormat, startIdx, numChars)
[type: function] 
Sets the text format of the designated portion of text within a TextAssembly.

TextAssembly.setTextFormat parameter: textFormat
[type: TextFormat] 
The TextFormat that the specified characters will adopt.

TextAssembly.setTextFormat parameter: startIdx
[type: number] [optional] 
The index of the first character in the segment affected by this change. If left undefined, the given textFormat will be applied to all characters.

TextAssembly.setTextFormat parameter: numChars
[type: number] [default: infinity] [optional] 
The length of the segment affected by this change.





TextAssembly.setHorizontalJustification(justification, startIdx, numChars)
[type: function] 
Sets the horizontal justification of the given range of characters. It should be noted that when characters are laid out into multiple lines, the horizontal justification for a given line is determined by the horizontal horizontalJustification value associated with the first character on that line.

TextAssembly.setHorizontalJustification parameter: justification
[type: string] 
The horizontal justification that the specified characters will adopt. See 'nc.constants.justifications' for justification values.

TextAssembly.setHorizontalJustification parameter: startIdx
[type: number] [optional] 
The index of the first character in the segment affected by this change. If left undefined, the given horizontalJustification will be applied to all characters.

TextAssembly.setHorizontalJustification parameter: numChars
[type: number] [default: infinity] [optional] 
The length of the segment affected by this change.





TextAssembly.insert(startIndex, stringToInsert)
[type: function] 
Inserts the given string at the given index.

TextAssembly.insert parameter: startIndex
[type: number] 
The index that the first character of the inserted string.

TextAssembly.insert parameter: stringToInsert
[type: string] 
The string to insert.





TextAssembly.delete(startIndex, count)
[type: function] 
Deletes the given range of characters.

TextAssembly.delete parameter: startIndex
[type: number] 
The index of the first character to delete.

TextAssembly.delete parameter: count
[type: number] 
The number of characters to delete.





TextAssembly.addStringUpdateCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this TextBox string changed. The updated string is sent to the callback as its first parameter.

TextAssembly.addStringUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this TextBox string changed.

TextAssembly.addStringUpdateCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this TextBox string changed.

TextAssembly.addStringUpdateCallback parameter: callbackArgs
[type: any] [optional] 
Args for the callback function that occurs whenever this TextBox string changed.





TextAssembly.removeStringUpdateCallback(callbackOwner, callbackName)
[type: function] 
Removes the given stringUpdate callback.

TextAssembly.removeStringUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

TextAssembly.removeStringUpdateCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





TextAssembly.clearPools()
[type: function] 
Several object-pooling techniques are used internally within the TextAssembly and TextBox objects. Displaying/rendering text with large numbers of characters can leave a significant memory-footprint in these pools. This memory can be freed by calling this method - though the call itself may result in a one-time performance hit if large strings have been displayed/rendered previously.





TextAssembly.getCharacters()
[type: function] [returns: [GraphicObject]] 
Returns a new array containing the list of GraphicObjects that comprise the TextAssembly's current string.












































































































































































































































































































----------------------------------------------------------
Section 118: TextBox
----------------------------------------------------------


TextBox
[type: class] [extends: Button] 
A specialized Button that renders text to it's texture. All TextBoxes are connected to an internal text-rendering scene that renders directly to the given TextBox's RenderTarget. TextBoxes have 3 editing modes: none, selectable, and editable. Though TextBoxes inherit from Button, their default value for "buttonActive" value is false when the editing mode is set to 'none' TextBoxes tend to be more performant than TextAssemblies, since the resulting object is singular vs the many character-children of TextAssemblies.





TextBox.type
[type: string] 
Type identifier.





TextBox.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





TextBox.string
[type: string] [default: ""] 
The string value of the text to be displayed by this TextBox. Setting this value directly clears the 'phraseID' property of this TextBox (if applicable).

example:
// Objective: Set the text of a TextBox.
// Expected Result: You will see "My Text" on screen.

this.textBox = new TextBox();
this.textBox.string = "My Text";





TextBox.phraseID
[type: string] [default: undefined] 
Property to set this TextBox's string based on the associated phrase in the ProjectTranscript, which is updated based on the current language setting of the project. See 'nc.phraseIDs' for a list of available phrases.

example:
// Objective: Set the text of a TextBox based on a phrase defined in the ProjectTranscript.
// Expected Result: You will see "Hello World" on screen if the project language is 'en', or "Hola Mundo" if the language is 'es'.

this.textBox = new TextBox();
this.textBox.phraseID = nc.phraseIDs["Hello World"];





TextBox.boxWidth
[type: number] [default: 0] 
The maximum width that the laid out text will adhere to if 'wrapToFit' or 'scaleToFit' are true. When greater than 0, this value also determines the positioning of left or right justified text. A value of 0 corresponds to no limits on the width of the text.





TextBox.boxHeight
[type: number] [default: 0] 
The maximum height that the laid out text will adhere to if 'scaleToFit' is true. When greater than 0, this value also determines the positioning of top-justified or bottom-justified text. A value of 0 corresponds to no limits on the height of the text.





TextBox.wrapToFit
[type: boolean] [default: true] 
Bool determining if text will automatically flow onto new lines in order to fit the text within the designated 'boxWidth' value.





TextBox.scaleToFit
[type: boolean] [default: true] 
Bool determining if the text will automatically be scaled down to fit within the boxWidth and/or boxHeight.





TextBox.horizontalJustification
[type: string] [default: 'left'] 
The horizontalJustification of this TextBox. For acceptable values, see 'nc.constants.justfications'. Setting this value will change the horizontal justification for all of the text in this TextBox, but the value can be set for individual sections of the text using 'TextBox.setHorizontalJustification'.





TextBox.verticalJustification
[type: string] [default: 'top'] 
The verticalJustification of this TextBox. For acceptable values, see 'nc.constants.justfications'. Setting this value will change the vertical justification for all of the text in this TextBox.





TextBox.textWidth
[type: number] 
The read-only width of the text (once laid out). This number encapsulates the final width of the laid out text, including all of the TextFormats, the boxWidth and boxHeight, scaleToFit, wrapToFit etc...





TextBox.textHeight
[type: number] 
The read-only height of the text (once laid out). This number encapsulates the final height of the laid out text, including all of the TextFormats, the boxWidth and boxHeight, scaleToFit, wrapToFit etc...





TextBox.scaleToFitFactor
[type: number] 
For Texts or Textboxes with 'scaleToFit' set to true, this number denotes the multiplier that was applied in order for the given text to fit within the boxWidth, and boxHeight.





TextBox.baselinePosition
[type: number] [default: .22] 
Number representing the vertical placement of the baseline within each line of text in this TextBox. A value of 0 corresponds to the baseline of the text being positioned at the very bottom of each line, and a value of .5 corresponds to the baseline of the text being positioned in the middle of each line.





TextBox.textFormat
[type: TextFormat] [default: TextFormat()] 
Object housing information about the customization of the characters within this TextBox. This includes font, scale, baseline shift, kerning, line height, as well as information about EffectNodes and EffectController values used on the characters. Setting or adjusting this value will set the TextFormat for all of the characters in this TextBox. See 'TextBox.setTextFormat' to set the TextFormat for individual sections of this TextBox.





TextBox.layoutLazyUpdater
[type: LazyUpdater] 
The LazyUpdater is ultimately responsible for initiating the layout of the text. The setting of 'needsUpdate' and the calling of 'updateIfNeeded' is magaged as much as is possible internally by Incisor®, but if the need to force an update arises, set 'needsUpdate' to true, and call 'updateIfNeeded'.





TextBox.loadingTierRequirements
[type: [number]] 
A list of the loading tier requirements for this TextBox. These requirements tell the TextBox if/when the GraphicAssets used by the characters are loaded, and therefore inform when the text can first be rendered to the TextBox. If left undefined, this value will default to the loadingTierRequirements of the geometry of the first character's GraphicAssets.





TextBox.isTrimmed
[type: boolean] [default: 'false'] 
Flag determining if the Texture and Geometry of this TextBox are trimmed to fit the rendered text. If false, the Texture and Geometry will extend to the full bounds of this TextBox's boxWidth and boxHeight.





TextBox.editingMode
[type: string] [default: 'none'] 
Value determining the editing mode of this TextBox. See 'nc.constants.textBoxEditingModes' for a list of available options. When set to 'none' this TextBox is not interactive. When set to 'selectable' this TextBox is interactive via the keyboard and cursor: text in this TextBox can be selected but not edited. When set to 'editable' this TextBox is interactive via the keyboard and cursor: text in this TextBox can be selected and edited.

example:
// Objective: Edit the text of a TextBox.
// Expected Result: Click on "My Text" and edit it.

// Create a new TextBox.
this.textBox = new TextBox();
this.textBox.string = "My Text";
// Set the editingMode to editable.
this.textBox.editingMode = nc.constants.textBoxEditingModes.editable;





TextBox.highlightColor
[type: Vector4] [default: Vector4(.5,.6,1,.3)] 
The color value for the selection highlighter boxes.





TextBox.backgroundColor
[type: Vector4] [default: Vector4(0,0,0,0)] 
The background color for the TextBox.





TextBox.pivotPoint
[type: Vector2] [default: Vector2(0,0)] 
The pivot point for the TextBox, with [0,0] meaning center pivot, and [.5,.5] meaning right-top pivot. TextBoxes are center-based by default like to most GraphicObjects. It should be noted that pivotPoint and justification are seperate concepts and do not affect each other. Justification affects the alignment of the text within the bounds of the TextBox, and pivotPoint affects where the 'origin' of the TextBox is relative to those bounds.





TextBox.renderTarget
[type: RenderTarget] 
This TextBox's RenderTarget - the RenderTarget that its text gets rendered to.





TextBox.useNearestPixelRendering
[type: boolean] [default: false] 
A TextBox is ultimately 'pre-rendered' text that is positioned in the Scene and then rendered again. Because of this, certain canvas sizes or TextBox positioning can lead to slightly blurrier edges that can be noticable for small text. Calling this function can mitigate such small-text-blurriness, as it sets the downscalingMode and upscalingMode to 'nearest', and sets the 'snapToNearestWorldPosition' to true. These settings help to ensure that the TextBox texture pixels are always aligned with the canvas pixels, preserving the original crispy edges. The tradeoff with using this mode is that the position of text will appear to always snap to the nearest pixel, which can lead to jerky-looking movement at slow speeds, and also rotation and other transformations will tear badly. If these restrictions are un-workable, a "TextAssembly" is a good alternative.





TextBox.tabEndsEditing
[type: boolean] [default: true] 
Boolean determining if pressing the 'Tab' key ends the current editing session, relinquishing the focus. If this is true, and the newly focused object is a UiKeybaordNavigator, then the keyboard navigation would also be advanced. If this value is false, then pressing the 'Tab' key inserts 3 spaces.





TextBox.returnEndsEditing
[type: boolean] [default: true] 
Boolean determining if pressing the 'Return' key ends the current editing session, relinquishing the focus. If this value is false, then pressing the 'Return' key inserts a newline.





TextBox.singularFocusTarget
[type: SceneObject] 
The SceneObject that 'nc.singularFocusObject' will be set to when the end-user actively selects or edits this TextBox. The default value is set to this TextBox, but in the case where this TextBox is a descendant of a SceneObject that would be a better choice for singular focus (like when a TextBox is part of a TextField etc...), this option can be used to substitute a singular focus recipient.





TextBox.showWhiteSpace
[type: boolean] [default: false] 
Boolean indicating if whitespace characters will be visible in this TextBox.





TextBox.numHorizontalGridSegments
[type: number] [default: 1] 
The number of horizontal grid segments that will be used in this TextBox's Geometry.





TextBox.numVerticalGridSegments
[type: number] [default: 1] 
The number of vertical grid segments that will be used in this TextBox's Geometry.





TextBox.canvasSizeResolutionScaling
[type: number] 
A boolean determining if the resolution of this TextBox is affected by the scale of the canvas relative to it's core dimensions. In other words, if this flag is false, then the TextBox's RenderTarget is a static resolution, and if it is true then the RenderTarget will get bigger when the canvas is displayed bigger, and smaller as the canvas is shrunk. This flag effectively sets the 'canvasSizeResolutionScaling' value of this TextBox's RenderTarget, but in addition, it connects the TextBox to the 'canvasResize' appEvent, informing the TextBox to re-render whenever the canvas is resized.





TextBox.htmlBacking
[type: HtmlBacking] 
Object that allows this TextBox to be backed by a hidden HTML text input element. This allows mobile virtual keyboards to appear automatically when focusing on an Incisor TextBox.





TextBox.setSubstitutionCharacter(characterToSubstitute, graphicAsset, textFormat)
[type: function] 
Method used to swap all instances of the given character with a designated GraphicAsset. A TextFormat can also be supplied to help position and format the substituted GraphicAsset within the text.

TextBox.setSubstitutionCharacter parameter: characterToSubstitute
[type: string] 
The the character that will be replaced with the designated GraphicAsset.

TextBox.setSubstitutionCharacter parameter: graphicAsset
[type: GraphicAsset] 
The GraphicAsset that will substitute for the given characters.

TextBox.setSubstitutionCharacter parameter: textFormat
[type: TextFormat] [optional] 
Optional TextFromat to apply to the substituted GraphicAsset, which can be used to adjust its positioning and formating.

example:
// Objective: Substitute a character in a TextBox.
// Expected Result: The letter "A" in the word "PLAY" will be replaced by a white triangle.

// Create a new TextBox.
this.textBox = new TextBox();
this.textBox.string = "PRESS PLAY";

// Replace the letter A with a white triangle.
this.textBox.setSubstitutionCharacter( "A", nc.graphicAssets.WhiteTriangle );

// Create a TextFormat, update some of its properties and set it on the TextBox.
let textFormat = new TextFormat();
textFormat.kerning = 2;
textFormat.characterScaleY = .5;
textFormat.characterScaleX = .5;
textFormat.verticalShift = .50;
this.textBox.setTextFormat( textFormat, 8, 1 );





TextBox.setTextFormat(textFormat, startIdx, numChars)
[type: function] 
Sets the text format of the designated portion of text within a TextBox.

TextBox.setTextFormat parameter: textFormat
[type: TextFormat] 
The TextFormat that the specified characters will adopt.

TextBox.setTextFormat parameter: startIdx
[type: number] [optional] 
The index of the first character in the segment affected by this change. If left undefined, the given textFormat will be applied to all characters.

TextBox.setTextFormat parameter: numChars
[type: number] [default: infinity] [optional] 
The length of the segment affected by this change.

example:
// Objective: Use a TextFormat to manipulate characters in a TextBox.
// Expected Result: You will see the phrase "I Love Incisor". The word "Love" and the letter "I" in Incisor will be stretched and given extra space.

// Create a new TextBox.
this.textBox = new TextBox();
this.textBox.string = "I Love Incisor";
// Create a TextFormat and update some of its properties.
let textFormat = new TextFormat();
textFormat.kerning = 3;
textFormat.characterScaleY = 3;
textFormat.characterScaleX = 1.5;
// Set the TextFormat and provide the start index and number of characters affected.
this.textBox.setTextFormat( textFormat, 2, 6 );





TextBox.setHorizontalJustification(justification, startIdx, numChars)
[type: function] 
Sets the horizontal justification of the given range of characters. It should be noted that when characters are laid out into multiple lines, the horizontal justification for a given line is determined by the horizontal horizontalJustification value associated with the first character on that line.

TextBox.setHorizontalJustification parameter: justification
[type: string] 
The horizontal justification that the specified characters will adopt. See 'nc.constants.justifications' for justification values.

TextBox.setHorizontalJustification parameter: startIdx
[type: number] [optional] 
The index of the first character in the segment affected by this change. If left undefined, the given horizontalJustification will be applied to all characters.

TextBox.setHorizontalJustification parameter: numChars
[type: number] [default: infinity] [optional] 
The length of the segment affected by this change.





TextBox.insert(startIndex, stringToInsert)
[type: function] 
Inserts the given string at the given index.

TextBox.insert parameter: startIndex
[type: number] 
The index that the first character of the inserted string.

TextBox.insert parameter: stringToInsert
[type: string] 
The string to insert.





TextBox.delete(startIndex, count)
[type: function] 
Deletes the given range of characters.

TextBox.delete parameter: startIndex
[type: number] 
The index of the first character to delete.

TextBox.delete parameter: count
[type: number] 
The number of characters to delete.





TextBox.clearPools()
[type: function] 
Several object-pooling techniques are used internally within the TextAssembly and TextBox objects. Displaying/rendering text with large numbers of characters can leave a significant memory-footprint in these pools. This memory can be freed by calling this method - though the call itself may result in a one-time performance hit if large strings have been displayed/rednered previously.





TextBox.getSelectionRange()
[type: function] [returns: RangeInfo] 
Returns an object containing the start index, end index, and character count of the current selection. If the current selection is empty the values in the returned object will be -1.





TextBox.selectRange(startIndex, count)
[type: function] 
Selects the given range of characters.

TextBox.selectRange parameter: startIndex
[type: number] [default: 0] [optional] 
The first index of the desired range to select. If left undefined, the entire text will be selected.

TextBox.selectRange parameter: count
[type: number] [optional] 
The number of characters to be selected.





TextBox.addStringUpdateCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this TextBox string changed (even during editing). The updated string is sent to the callback as its first parameter.

TextBox.addStringUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this TextBox string changed.

TextBox.addStringUpdateCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this TextBox string changed.

TextBox.addStringUpdateCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that occurs whenever this TextBox string changed.





TextBox.removeStringUpdateCallback(callbackOwner, callbackName)
[type: function] 
Removes the given stringUpdate callback.

TextBox.removeStringUpdateCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

TextBox.removeStringUpdateCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





TextBox.addEditCommitCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this TextBox's 'editingMode' is changed from 'constants.textBoxEditingModes.editing' to any other value. The updated string is sent to the callback as its first parameter, and the original string is sent as the second parameter.

TextBox.addEditCommitCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this TextBox string changed.

TextBox.addEditCommitCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this TextBox string changed.

TextBox.addEditCommitCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that occurs whenever this TextBox string changed.





TextBox.removeEditCommitCallback(callbackOwner, callbackName)
[type: function] 
Removes the given editCommit callback.

TextBox.removeEditCommitCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

TextBox.removeEditCommitCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.
















































































































































































































































































































































































































































































































































































----------------------------------------------------------
Section 119: HtmlBacking
----------------------------------------------------------


HtmlBacking
[type: class] [NON-INSTANTIABLE] 
Object that allows this TextBox to be backed by a hidden HTML text input element. This allows mobile virtual keyboards to appear automatically when focusing on an Incisor TextBox. 





HtmlBacking.enabled
[type: boolean] 
Boolean determining if HTML backing is enabled. When enabled, an HTML textbox is added to the parent of the canvas element, and text input is routed through this hidden input, which allows support for mobile virtual keyboards.





HtmlBacking.autoPosition
[type: boolean] 
Boolean determining whether the HTML textbox will be automatically places at the same coordinates as the canvas element when Incisor TextBox editing begins.










----------------------------------------------------------
Section 120: RangeInfo
----------------------------------------------------------


RangeInfo
[type: class] [NON-INSTANTIABLE] 
Object describing a range of indices, including a startIndex, endIndex, and count. 





RangeInfo.startIndex
[type: number] 
The first index included in the range of indices.





RangeInfo.endIndex
[type: number] 
The lase index included in the range of indices.





RangeInfo.count
[type: number] 
The number of indices included in the range.










----------------------------------------------------------
Section 121: TextFormat
----------------------------------------------------------


TextFormat
[type: class] 
Object containing text formatting information that can be applied the characters within TextAssembly or TextBox objects.





TextFormat.type
[type: string] 
Type identifier.





TextFormat.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





TextFormat.fontName
[type: string] [default: "MainFont"] 
The name of the font that characters with this TextFormat will use. See 'nc.fontNames' for the names of the fonts available in this project. Please note that changing the fontName will result in the entire 'characterMaterial' object being reset to the materialPresets of the "xxx_Char0" character of the new font.





TextFormat.characterScaleX
[type: number] [default: 1] 
The x-axis scale multiplier for characters that use this TextFormat.





TextFormat.characterScaleY
[type: number] [default: 1] 
The y-axis scale multiplier for characters that use this TextFormat.





TextFormat.kerning
[type: number] [default: 0] 
Number representing an added or reduced spacing between characters that use this TextFormat. This kerning number denotes the proportion of the 'characterWidth' (see ProjectConfiguration.fontDefitions) that will be added to or subtracted from the width of each character. The effects of kerning are also automatically multiplied by the given format's 'characterScaleX' value, UiZoom.totalZoom (if applicable), and the 'scaleToFitFactor' (if applicable).





TextFormat.verticalShift
[type: number] [default: 0] 
Number representing a veritcal offset that will be applied to the characters that use this TextFormat. This number denotes the proportion of the font's 'lineHeight' (see ProjectConfiguration.fontDefitions) that will be added to or subtracted from the vertical position of the characters using this TextFormat. The effects of verticalShift are also automatically multiplied by the given format's 'characterScaleY' value, UiZoom.totalZoom (if applicable), and the 'scaleToFitFactor' (if applicable).





TextFormat.lineHeightMultiplier
[type: number] [default: 1] 
Number that multiplies the effective layout height of characters the that use this TextFormat. As a default, the 'layout height' of any character within a font is the font's 'lineHeight' value (see ProjectConfiguration.fontDefitions). This number acts as a multiplier on that effective character height.





TextFormat.characterMaterial
[type: CharacterMaterial] 
Object defining EffectNodes amd EffectController values that will be applied to the characters that used this TextFormat.





TextFormat.clone()
[type: function] [returns: TextFormat] 
Returns a new TextFormat instance with the same values.










----------------------------------------------------------
Section 122: CharacterMaterial
----------------------------------------------------------


CharacterMaterial
[type: class] [NON-INSTANTIABLE] 
Object representing the EffectNodes and EffectController values that will be applied to all of the TextBox or TextAssembly characters using the TextFormat that owns this CharacterMaterial. 





CharacterMaterial.type
[type: string] 
Type identifier.





CharacterMaterial.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





CharacterMaterial.fillColor
[type: Color] 
The EffectController for the 'FillColor' EffectNode, which entirely fills the associated Geometry with the red, green, blue, and alpha color values provided. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





CharacterMaterial.mainTexture
[type: Texture] 
The EffectController for the 'SampleMainTexture' EffectNode that tells it which Texture to render.





CharacterMaterial.colorMultiply
[type: Color] 
The EffectController for the 'ColorMultiply' EffectNode, which multiplies the red, green, blue, and alpha color values of the Material it is applied to. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





CharacterMaterial.shapify
[type: shapify] 
The EffectController for the 'Shapify' EffectNode. The Shapify EffectNode converts edge data stored in a 'shapified' Texture into a presentable image with edges that stay sharp regardless of the scale of the associated GraphicObject. This is an instance of the dynamically defined EffectController 'shapify' (base type: 'Vector2'). To get a new instance, use "nc.effectControllers['shapify'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





CharacterMaterial.shear
[type: shear] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. This is an instance of the dynamically defined EffectController 'shear' (base type: 'Vector3'). To get a new instance, use "nc.effectControllers['shear'].new()". While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





CharacterMaterial.shear_center
[type: Vector2] 
EffectController for the Shear EffectNode, which distorts the shape to appear slanted or skewed. While some EffectNodes and EffectControllers are included in projects automatically, many must first be added to the project as 'codeAsset' files using the 'TemplateLibrary' menu.





CharacterMaterial.getEffectNodes()
[type: function] [returns: [EffectNode]] 
Returns this CharacterMaterial's current EffectNodes. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of this CharacterMaterial.





CharacterMaterial.setEffectNodes(effectNodes)
[type: function] 
Sets the EffectNodes for this CharacterMaterial, effectively setting them for all of the affected characters. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of this CharacterMaterial.

CharacterMaterial.setEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The new list of EffectNodes that will apply this CharacterMaterial, which applies to all affected characters.





CharacterMaterial.addEffectNodes(effectNodes)
[type: function] 
Adds the given EffectNodes to this CharacterMaterial, effectively adding them to all of the affected characters. EffectNodes are GPU-driven visual effects assigned to SceneObjects, GraphicObjects, and ultimately Materials. Each EffectNode can be manipulated dynamically by one or more EffectControllers, which are accessable as direct members of this CharacterMaterial.

CharacterMaterial.addEffectNodes parameter: effectNodes
[type: [EffectNode], EffectNode] 
The EffectNodes to add to this CharacterMaterial, which applies to all affected characters.










----------------------------------------------------------
Section 123: Texture
----------------------------------------------------------


Texture
[type: class] [extends: AssetComponent] [NON-INSTANTIABLE] 
A Texture is a pixel map used for filling the surface of Geometry during rendering. 





Texture.wrapModeHorizontal
[type: string] 
Mode denoting how this Texture will behave beyond its horizontal bounds. The acceptable wrap modes can be found in 'nc.constants.wrapModes'.





Texture.wrapModeVertical
[type: string] 
Mode denoting how this Texture will behave beyond its vertical bounds. The various wrap modes can be found in 'nc.constants.wrapModes'.





Texture.downscalingMode
[type: string] 
Mode denoting how this Texture will be sampled when it is smaller than it's native size. The various downscaling modes can be found in 'nc.constants.textureDownscalingModes'.





Texture.upscalingMode
[type: string] 
Mode denoting how this Texture will be sampled when it is larger than it's native size. The various upscaling modes can be found in 'nc.constants.textureUpscalingModes'.





Texture.spriteSheet
[type: string] [default: undefined] 
The name of the SpriteSheet that this Texture is a part of (if applicable).





Texture.getResolution()
[type: function] [returns: Vector2] 
Returns a Vector2 with the pixel dimensions of this Texture.








































----------------------------------------------------------
Section 124: Timeline
----------------------------------------------------------


Timeline
[type: class] [extends: TimePlaybackController] [NON-INSTANTIABLE] 
Timelines are specialized PlaybackControllers that control animation of Constructs created in the Incisor® GUI. 





Timeline.type
[type: string] 
Type identifier.





Timeline.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Timeline.name
[type: string] [default: 'SceneObject'] 
The name of the SceneObject.





Timeline.influence
[type: number] 
This value determines the degree to which this particular timeline controls its construct. The total influence among all of the timelines always adds up to 1. When a particular Timeline's influence is actively increased, the influence of all other Timelines is decreased passively and proportionally in order to maintain a total influence of 1. A Timeline's influence cannot be directly decreased, it must be done passively be increasing the influence of another Timeline.





Timeline.swoopInfluence(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs)
[type: function] [returns: Swooper] 
Swoops (interpolates) the Timeline's influence from its current value to the given end value over the duration. It should be noted, that Timeline.influence cannont be directly decreased, this must be done passively be increasing the influence of another Timeline.

Timeline.swoopInfluence parameter: endValue
[type: number] 
The ending value for the influence.

Timeline.swoopInfluence parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Timeline.swoopInfluence parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Timeline.swoopInfluence parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Timeline.swoopInfluence parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Timeline.swoopInfluence parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.





Timeline.playOnce_swoopInfluence(fadeInTime, fadeOutTime, returnToTimeline, lazyStopCallbackOwner, lazyStopCallbackName, lazyStopCallbackArgs)
[type: function] [requires: module - waitThens] 
Plays this Timeline once, swooping influence up at its start and return-swooping influence just before its end for smooth transitions. The 'Ease' TweenType is used for both swoops.

Timeline.playOnce_swoopInfluence parameter: fadeInTime
[type: number] [optional] 
The amount of time to fade in this Timeline's influence. If left undefined, the value will default to either .25 seconds, or 10% of this Timeline's duration (whichever is smaller).

Timeline.playOnce_swoopInfluence parameter: fadeOutTime
[type: number] [optional] 
The amount of time to fade out this Timeline's influence before it ends. If left undefined, the value will default to either .25 seconds, or 10% of this Timeline's duration (whichever is smaller).

Timeline.playOnce_swoopInfluence parameter: returnToTimeline
[type: Timeline] [optional] 
The Timeline that will have influence after this 'event' completes. If this value is left undefined, then it will default to the Timeline that had the highest influence when this function was originally invoked.

Timeline.playOnce_swoopInfluence parameter: lazyStopCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the timeline is complete.

Timeline.playOnce_swoopInfluence parameter: lazyStopCallbackName
[type: string] [optional] 
The name of the function that is called when the timeline is complete.

Timeline.playOnce_swoopInfluence parameter: lazyStopCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the timeline is complete.





Timeline.play_swoopInfluence(fadeInTime)
[type: function] 
Invokes 'play' on the Timeline while swooping it's influence up over the given duration.

Timeline.play_swoopInfluence parameter: fadeInTime
[type: number] [default: 0.25] 
The amount of time to fade in this Timeline's influence.





























































































































----------------------------------------------------------
Section 125: TimeStamp
----------------------------------------------------------


TimeStamp
[type: class] [NON-INSTANTIABLE] [requires: module - timeStamp] 
Object housing functionality for time stamps, the Incisor® standardized format for date and time.





TimeStamp.getTimeStamp(includeMilliseconds)
[type: function] [returns: string] 
Produces the current time in the Incisor® standardized time stamp format: YYYY.MM.DD.hh.mm.ss(.mmmm)

TimeStamp.getTimeStamp parameter: includeMilliseconds
[type: boolean] 
A boolean indicating if the timestamp will include milliseconds.





TimeStamp.compareTimestamps(firstTimestamp, secondTimestamp)
[type: function] [returns: string] 
Compares two timestamps and returns a string describing their relationship ("lessThan","equal", or "greaterThan").

TimeStamp.compareTimestamps parameter: firstTimestamp
[type: string] 
The first timestamp to compare.

TimeStamp.compareTimestamps parameter: secondTimestamp
[type: string] 
The second timestamp to compare.





TimeStamp.compareIncisorVersionSets(firstVersionSetName, secondVersionSetName)
[type: function] [returns: string] 
Compares the names of two Incisor® version sets and returns a string describing their relationship ("lessThan","equal", or "greaterThan").

TimeStamp.compareIncisorVersionSets parameter: firstVersionSetName
[type: string] 
The first Incisor® version set name to compare.

TimeStamp.compareIncisorVersionSets parameter: secondVersionSetName
[type: string] 
The second Incisor® version set name to compare.










----------------------------------------------------------
Section 126: UiBooleanSupervisor_checkbox
----------------------------------------------------------


UiBooleanSupervisor_checkbox
[type: class] [extends: UiGraphicButton] [requires: module - extendedUi] 
A specialized UiGraphicButton that includes a Supervisor member, enabling it to monitor and adjust a boolean property's value during runtime. To use this class, configure the 'supervisedPropertyGetter' and 'supervisedPropertySetter' callbacks on the Supervisor. Once configured, the visibility of the 'graphicObject' member will be updated every fixed update to reflect the most current value of the supervised property, and the value of the supervised property will also be 'adjustable' via cursor interaction.





UiBooleanSupervisor_checkbox.supervisor
[type: Supervisor] 
Supervisor with callbacks that enable this UiBooleanSupervisor_checkbox to monitor and adjust a boolean property's value during runtime.







































































































































































































































































































































































































































































----------------------------------------------------------
Section 127: UiButton
----------------------------------------------------------


UiButton
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized horizontal LayoutStack housing a text-based Button (including a UiPanel background) with various UI functionalities and defaults applied. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • nearestPixelRendering-enabled.





UiButton.isActive
[type: boolean] [default: true] 
Boolean determining if the UiButton is available for end-user-internaction, or if it is unavailable and 'grayed out'.





UiButton.mainText
[type: TextBox] 
The TextBox with main text for this UiButton. The size of the text informs the button's size and layout.





UiButton.displayLabel
[type: boolean] [default: false] 
Boolean determining if a label TextBox is displayed to the left of the UiButton.





UiButton.label
[type: UiText] [default: undefined] 
A UiText that acts as a label for the UiButton. Please note that this item is undefined until the 'displayLabel' property is set to true.





UiButton.mainButton
[type: Button] 
The main Button for the UiButton, this object is a UiPanel which also implements Button.





UiButton.outline
[type: UiOutline] 
The outline of the button, which is used to indicate when the end-user outlines this UiButton using keyboard navigation (tab, arrows, etc...).





UiButton.buttonBackgroundColor
[type: Color] [default: nc.uiStyle.color_buttonPanel] 
The Color of the Button background.





UiButton.highlightedButtonBackgroundColor
[type: Color] [default: nc.uiStyle.color_highlightedButtonPanel] 
The Color of the Button background when it's highlighted.





UiButton.addTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this UiButton is triggered via the cursor or keyboard navigation. The triggering browser-created event, and the UiButton itself are sent to the callback as its first two parameters.

UiButton.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiButton is triggered via the cursor or keyboard navigation.

UiButton.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiButton is triggered via the cursor or keyboard navigation.

UiButton.addTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever this UiButton is triggered via the cursor or keyboard navigation.

example:
// Objective: Add a TriggerCallback to a button
// Expected Result: You will see a button with the button text "Press Me". Pressing it will display text that says "You pressed the button."

// Add a callback function.
this.myCallback = function(args) {
    let txt = new UiText( nc.mainScene, "ButtonMessageText" );
    txt.position.x = 100;
    txt.string = "You pressed the button."
}

let button = new UiButton( nc.mainScene, "MyButton" );
button.mainText.string = "Press Me";
button.displayLabel = false;
// add the trigger callback
button.addTriggerCallback( this, "myCallback" );





UiButton.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiButton.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiButton.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.

example:
// Objective: Remove a TriggerCallback to a button
// Expected Result: The "Press Me" button will increment the press count. Upon pressing the "Stop Counting" button, the "Press Me" button will no longer function.

let presses = 0;
let txt = new UiText( nc.mainScene, "ButtonMessageText" );
txt.position.x = 100;
txt.string = "You pressed the button 0 times.";

// Add a callback function ti increment the press count.
this.counter = function(args) {
   presses++;
   txt.string = "You pressed the button " + presses + " times.";
}

// Add a callback function to stop the counter callback
this.stopper = function(args) {
    pressMeButton.removeTriggerCallback( this, "counter" );
}

// the button that will increment the press count
let pressMeButton = new UiButton( nc.mainScene, "PressMeButton" );
pressMeButton.mainText.string = "Press Me";
pressMeButton.displayLabel = false;
// add the trigger callback
pressMeButton.addTriggerCallback( this, "counter" );

// the button that will remove the counter callback
let stopCountingButton = new UiButton( nc.mainScene, "StopCountingButton" );
stopCountingButton.mainText.string = "Stop Counting";
stopCountingButton.displayLabel = false;
stopCountingButton.position.x = -150;
// add the trigger callback
stopCountingButton.addTriggerCallback( this, "stopper" );






































































































































































































































































































































































































----------------------------------------------------------
Section 128: UiCollapsibleStack
----------------------------------------------------------


UiCollapsibleStack
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized vertical LayoutStack with an interactive title header that toggles the visibility of a main LayoutStack. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • nearestPixelRendering-enabled.





UiCollapsibleStack.bodyStack
[type: LayoutStack] 
The LayoutStack containing the main body of this UiCollapsibleStack. This LayoutStack is what is shown/expanded or hidden/collapsed by toggling the title header button.





UiCollapsibleStack.titleStack
[type: LayoutStack] 
The LayoutStack containing the title header UiCollapsibleStack. This LayoutStack holds the interactive text/button that collapses and expands the content of this UiCollapsibleStack.





UiCollapsibleStack.titleTextBox
[type: TextBox] 
The header title TextBox for this UiCollapsibleStack.





UiCollapsibleStack.caretIcon
[type: GraphicObject] 
An caret image that indicates if the UiCollapsibleStack is collapsed or expanded.





UiCollapsibleStack.caretIconScaleFactor
[type: number] 
A scale multiplier for the caretIcon GraphicObject. Use this property instead of directly scaling the caretIcon GraphicObject to preserve UiZoom and LayoutObject functionality.





UiCollapsibleStack.mainButton
[type: Button] 
The main Button for the UiCollapsibleStack title heaader button, this object is a UiPanel which also implements Button. This item defaults to 'visible=false'.





UiCollapsibleStack.outline
[type: UiOutline] 
The outline of the button, which is used to indicate when the end-user outlines this UiCollapsibleStack using keyboard navigation (tab, arrows, etc...).





UiCollapsibleStack.isExpanded
[type: boolean] [default: false] 
Boolean determining if the UiCollapsibleStack is collapsed or expanded.





UiCollapsibleStack.buttonTextColor
[type: Color] [default: nc.uiStyle.color_interactiveText] 
The base Color of the titleTextBox for this UiCollapsibleStack.





UiCollapsibleStack.highlightedButtonTextColor
[type: Color] [default: nc.uiStyle.color_highlightedInteractiveText] 
The highlighted Color of the titleTextBox for this UiCollapsibleStack.





UiCollapsibleStack.buttonIncludesTitle
[type: boolean] [default: true] 
Boolean indicating if the mainButton for this UiCollapsibleStack spans over the titleTextBox. When false the mainButton for this UiCollapsibleStack only encapsulates the caretIcon.





UiCollapsibleStack.addTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this UiCollapsibleStack is triggered via the cursor or keyboard navigation. In this case, 'triggering' also toggles the collapsed/expanded state of this UiCollapsibleStack, making this callback a good means to update the contents of the LayoutStack. The triggering browser-created event, and the UiCollapsibleStack itself are sent to the callback as its first two parameters.

UiCollapsibleStack.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiCollapsibleStack is triggered via the cursor or keyboard navigation.

UiCollapsibleStack.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiCollapsibleStack is triggered via the cursor or keyboard navigation.

UiCollapsibleStack.addTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever this UiCollapsibleStack is triggered via the cursor or keyboard navigation.





UiCollapsibleStack.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiCollapsibleStack.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiCollapsibleStack.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.






































































































































































































































































































































































































----------------------------------------------------------
Section 129: UiDropDownMenu
----------------------------------------------------------


UiDropDownMenu
[type: class] [extends: UiButton] [requires: module - extendedUi] 
A specialized UiButton that displays a UiMenu. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • nearestPixelRendering-enabled.





UiDropDownMenu.uiMenu
[type: UiMenu] 
The UiMenu that is displayed when the this button is triggered.
























































































































































































































































































































































































































































----------------------------------------------------------
Section 130: UiGraphicButton
----------------------------------------------------------


UiGraphicButton
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized horizontal LayoutStack housing an image-based Button (including a UiPanel background) with various UI functionalities and defaults applied. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • nearestPixelRendering-enabled.





UiGraphicButton.isActive
[type: boolean] [default: true] 
Boolean determining if the UiGraphicButton is available for end-user-internaction, or if it is unavailable and 'grayed out'.





UiGraphicButton.graphicObject
[type: GraphicObject] 
The GraphicObject for this UiGraphicButton.





UiGraphicButton.graphicScaleFactor
[type: number] 
A scale multiplier for the graphic object. Use this property instead of directly scaling the GraphicObject to preserve UiZoom and LayoutObject functionality. Please note that this facter does not affect the size of the Button, just the GraphicObject displayed on it.





UiGraphicButton.width
[type: number] 
The core width of the UiGraphicButton.





UiGraphicButton.height
[type: number] 
The core height of the UiGraphicButton.





UiGraphicButton.displayLabel
[type: boolean] [default: false] 
Boolean determining if a label TextBox is displayed to the left of the UiGraphicButton.





UiGraphicButton.label
[type: UiText] [default: undefined] 
A UiText that acts as a label for the UiGraphicButton. Please note that this item is undefined until the 'displayLabel' property is set to true.





UiGraphicButton.mainButton
[type: Button] 
The main Button for the UiGraphicButton, this object is a UiPanel which also implements Button.





UiGraphicButton.outline
[type: UiOutline] 
The outline of the button, which is used to indicate when the end-user outlines this UiGraphicButton using keyboard navigation (tab, arrows, etc...).





UiGraphicButton.buttonBackgroundColor
[type: Color] [default: nc.uiStyle.color_buttonPanel] 
The Color of the Button background.





UiGraphicButton.highlightedButtonBackgroundColor
[type: Color] [default: nc.uiStyle.color_highlightedButtonPanel] 
The Color of the Button background when it's highlighted.





UiGraphicButton.addTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this UiGraphicButton is triggered via the cursor or keyboard navigation. The triggering browser-created event, and the UiGraphicButton itself are sent to the callback as its first two parameters.

UiGraphicButton.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiGraphicButton is triggered via the cursor or keyboard navigation.

UiGraphicButton.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiGraphicButton is triggered via the cursor or keyboard navigation.

UiGraphicButton.addTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever this UiGraphicButton is triggered via the cursor or keyboard navigation.





UiGraphicButton.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiGraphicButton.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiGraphicButton.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.






































































































































































































































































































































































































----------------------------------------------------------
Section 131: UiKeyboardNavigator
----------------------------------------------------------


UiKeyboardNavigator
[type: class] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for keyboard navigation of this SceneObject's ui-related descendants. Keyboard navigation enables the end-user to press the tab, space, and enter keys to outline and trigger any 'uiKeyboardNavigable' descendants of the SceneObject owning this UiKeyboardNavigator when it is 'in focus' according to 'nc.singularFocusObject'. SceneObjects have a member named "uiKeyboardNavigator", which defaults to undefined, but can be enabled, by calling 'SceneObject.configureUiKeyboardNavigator()'.





UiKeyboardNavigator.type
[type: string] 
Type identifier.





UiKeyboardNavigator.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





UiKeyboardNavigator.defaultOutlined
[type: SceneObject] 
If defined, this SceneObject will automatically be outlined when the SceneObject owning this UiKeyboardNavigator is the 'singularFocusObject'.





UiKeyboardNavigator.gotoNext(direction)
[type: function] 
Instructs to the UiKeyboardNavigator to outline the next, current, or previous UiKeyboardNavigable descendant, based on the 'direction' paramter supplied.

UiKeyboardNavigator.gotoNext parameter: direction
[type: number] [default: 0] [optional] 
Value supplied determining the direction of the navigation. 1 goes to next item, 0 outlines the current item, and -1 outlines the previous item.





UiKeyboardNavigator.dispose()
[type: function] 
Disposes this UiKeyboardNavigator, disabling keyboard navigation for the SceneObject owning it, and freeing object for garbage collection.










----------------------------------------------------------
Section 132: UiKeyboardNavigable
----------------------------------------------------------


UiKeyboardNavigable
[type: class] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for this SceneObject to be accessible via keyboard navigation. Keyboard navigation enables the end-user to press the arrow keys, tab, space, and enter keys to outline and trigger any 'uiKeyboardNavigable' SceneObjects within a UiKeyboardNavigator-enabled parent that is currently 'in focus' according to 'nc.singularFocusObject'. SceneObjects have a member named "uiKeyboardNavigable", which defaults to undefined, but can be enabled, by calling 'SceneObject.configureUiKeyboardNavigable()'.





UiKeyboardNavigable.type
[type: string] 
Type identifier.





UiKeyboardNavigable.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





UiKeyboardNavigable.anyKeyTriggers
[type: boolean] [default: false] 
Flag determining if any key triggers the currently outlined UiKeyboardNavigable item. Standard UiKeyboardNavigable items are triggered by the "Enter" key and "Spacebar" key, when this flag is true, any key will trigger. Since the triggering keyboard event is sent through to the UiKeyboardNavigable item's 'trigger' callback, further costumizations can be added to the triggering key within the item itself (for example certain keys can be ignored etc...).





UiKeyboardNavigable.defaultOutlined
[type: SceneObject] 
Optional SceneObject that will automatically be outlined the first time the owner of this UiKeyboardNavigation becomes the 'singularFocusObject'.





UiKeyboardNavigable.isActive
[type: boolean] [default: true] 
Boolean determining if this UiKeyboardNavigable is currently active.





UiKeyboardNavigable.addSetOutlineCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback that occurs whenever this UiKeyboardNavigable item is in need of outlining or unoutlining. A boolean indicating the outline status is sent to the callback as its first parameter.

UiKeyboardNavigable.addSetOutlineCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiKeyboardNavigable item is in need of outlining or unoutlining.

UiKeyboardNavigable.addSetOutlineCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiKeyboardNavigable item is in need of outlining or unoutlining.





UiKeyboardNavigable.removeSetOutlineCallback(callbackOwner, callbackName)
[type: function] 
Removes the given setOutline callback.

UiKeyboardNavigable.removeSetOutlineCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiKeyboardNavigable.removeSetOutlineCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





UiKeyboardNavigable.addTriggerCallback(callbackOwner, callbackName)
[type: function] 
Adds a callback that occurs whenever this UiKeyboardNavigable item triggered via the enter key or the space bar. The triggering browser-generated event is sent to the callback as its first parameter.

UiKeyboardNavigable.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiKeyboardNavigable item triggered via the enter key or the space bar.

UiKeyboardNavigable.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiKeyboardNavigable item triggered via the enter key or the space bar.





UiKeyboardNavigable.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiKeyboardNavigable.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiKeyboardNavigable.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





UiKeyboardNavigable.dispose()
[type: function] 
Disposes this UiKeyboardNavigable, disabling keyboard navigation for the SceneObject owning it, and freeing object for garbage collection.










----------------------------------------------------------
Section 133: UiLinkButton
----------------------------------------------------------


UiLinkButton
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized horizontal LayoutStack housing a text-based Button with various UI functionalities and defaults applied. The UiLinkButton is similar to the UiButton, but has no visible background, and instead the text itself is the interactive component. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • nearestPixelRendering-enabled.





UiLinkButton.isActive
[type: boolean] [default: true] 
Boolean determining if the UiLinkButton is available for end-user-internaction, or if it is unavailable and 'grayed out'.





UiLinkButton.mainText
[type: TextBox] 
The TextBox with main text for this UiLinkButton. The size of the text informs the button's size and layout.





UiLinkButton.displayLabel
[type: boolean] [default: false] 
Boolean determining if a label TextBox is displayed to the left of the UiLinkButton.





UiLinkButton.label
[type: UiText] [default: undefined] 
A UiText that acts as a label for the UiLinkButton. Please note that this item is undefined until the 'displayLabel' property is set to true.





UiLinkButton.mainButton
[type: Button] 
The main Button for the UiLinkButton, this object is a UiPanel which also implements Button. This item defaults to 'visible=false'.





UiLinkButton.outline
[type: UiOutline] 
The outline of the button, which is used to indicate when the end-user outlines this UiLinkButton using keyboard navigation (tab, arrows, etc...).





UiLinkButton.buttonTextColor
[type: Color] [default: nc.uiStyle.color_interactiveText] 
The base Color of the TextBox for this UiLinkButton.





UiLinkButton.highlightedButtonTextColor
[type: Color] [default: nc.uiStyle.color_highlightedInteractiveText] 
The highlighted Color of the TextBox for this UiLinkButton.





UiLinkButton.addTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this UiLinkButton is triggered via the cursor or keyboard navigation. The triggering browser-created event, and the UiLinkButton itself are sent to the callback as its first two parameters.

UiLinkButton.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiLinkButton is triggered via the cursor or keyboard navigation.

UiLinkButton.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiLinkButton is triggered via the cursor or keyboard navigation.

UiLinkButton.addTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever this UiLinkButton is triggered via the cursor or keyboard navigation.





UiLinkButton.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiLinkButton.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiLinkButton.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.






































































































































































































































































































































































































----------------------------------------------------------
Section 134: UiMenu
----------------------------------------------------------


UiMenu
[type: class] [extends: SceneObject] [requires: module - extendedUi] 
A ui-specialized SceneObject that functions as a menu with menuItem options that can be selected with the cursor or with keyboard navigation. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • pre-configured with 'UiVisualFocus' functionality.  • nearestPixelRendering-enabled.





UiMenu.isOpen
[type: boolean] [default: false] 
Boolean determining if the menu is open or closed.





UiMenu.menuBackground
[type: UiPanel] 
The UiPanel shown behind the UiMenuItem options in this UiMenu.





UiMenu.searchable
[type: boolean] 
Boolean determining if a search UiTextField appears at the top of the menu. When true, end-users can type in the field to filter the options shown in the UiMenu.





UiMenu.searchBarMenuItem
[type: UiMenuItem] 
The search bar UiMenuItem.





UiMenu.searchIconScaleFactor
[type: number] 
Scale multiplier for the search icon graphic.





UiMenu.minWidth
[type: number] 
The minimum width of the UiMenu.





UiMenu.textFormat
[type: TextFormat] 
The default TextFormat for the text within the UiMenu.





UiMenu.menuItemBackgroundColor
[type: Color] 
The default Color for the UiMenuItem backgrounds.





UiMenu.textColor
[type: Color] 
The default Color for the active text within the UiMenu.





UiMenu.inactiveTextColor
[type: Color] 
The default Color for the inactive text within the UiMenu.





UiMenu.textBuffer
[type: number] 
The size of the buffer spacer around and between text.





UiMenu.parentMenu
[type: UiMenu] 
If this UiMenu is a subMenu, then this property will be populated with the parent UiMenu, otherwise it will be undefined.





UiMenu.singularFocusTarget
[type: SceneObject] 
The SceneObject that 'nc.singularFocusObject' will be set to when this UiMenu opens. The default value is set to this UiMenu, but in the case where this UiMenu is a descendant of a SceneObject that would be a better choice for singular focus (like when a UiMenu is part of a UiDropDownMenu etc...), this option can be used to substitute a singular focus recipient.





UiMenu.addMenuItem(name, leftIconGraphicAsset, secondaryString, rightIconGraphicAsset, index)
[type: function] [returns: UiMenuItem] 
Adds a new UiMenuItem to the UiMenu.

UiMenu.addMenuItem parameter: name
[type: string] 
The string that will appear in the UiMenu.

UiMenu.addMenuItem parameter: leftIconGraphicAsset
[type: GraphicAsset] [optional] 
Optional GraphicAsset to include on the left side of the UiMenuItem.

UiMenu.addMenuItem parameter: secondaryString
[type: string] [optional] 
Optional secondary string to display on the right side of the UiMenuItem

UiMenu.addMenuItem parameter: rightIconGraphicAsset
[type: GraphicAsset] [optional] 
Optional GraphicAsset to include on the right side of the UiMenuItem.

UiMenu.addMenuItem parameter: index
[type: number] [optional] 
Index array location to insert the new UiMenuItem.





UiMenu.removeMenuItem(uiMenuItem)
[type: function] 
Removes a UiMenuItem.

UiMenu.removeMenuItem parameter: uiMenuItem
[type: UiMenuItem] 
The UiMenuItem to remove.





UiMenu.removeMenuItemByName(name)
[type: function] 
Removes the UiMenuItem with the given name.

UiMenu.removeMenuItemByName parameter: name
[type: string] 
The name of the UiMenuItem to remove.





UiMenu.addMenuItemTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever one of the UiMenuItems is selected via the cursor or keyboard navigation. The triggering UiMenuItem, and the UiMenu itself are sent to the callback as its first two parameters.

UiMenu.addMenuItemTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever one of the UiMenuItems is selected via the cursor or keyboard navigation.

UiMenu.addMenuItemTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever one of the UiMenuItems is selected via the cursor or keyboard navigation.

UiMenu.addMenuItemTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that occurs whenever one of the UiMenuItems is selected via the cursor or keyboard navigation.





UiMenu.removeMenuItemTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiMenu.removeMenuItemTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiMenu.removeMenuItemTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





UiMenu.addOpenCloseCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever the UiMenu is opened or closed via triggering or direct manipulation of the 'isOpen' flag. The UiMenu itself is sent to the callback as its first parameter.

UiMenu.addOpenCloseCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever the UiMenu is opened or closed.

UiMenu.addOpenCloseCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever the UiMenu is opened or closed.

UiMenu.addOpenCloseCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that occurs whenever the UiMenu is opened or closed.





UiMenu.removeOpenCloseCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiMenu.removeOpenCloseCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiMenu.removeOpenCloseCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.





UiMenu.getMenuItems()
[type: function] [returns: [UiMenuItem]] 
Retuns an array of the current UiMenuItems in this UiMenu.





UiMenu.clearMenuItems()
[type: function] 
Clears all UiMenuItems.






















































































































































































































































































































----------------------------------------------------------
Section 135: UiMenuItem
----------------------------------------------------------


UiMenuItem
[type: class] [NON-INSTANTIABLE] [requires: module - extendedUi] 
A ui-specialized object with the components that comprise a menu item option within a UiMenu. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled. 





UiMenuItem.mainMenuItem
[type: TextBox, UiTextField] 
The main item showing in the UiMenu for each UiMenuItem. For all UiMenuItems except the searchBarMenuItem, this object is of type TextBox.





UiMenuItem.mainButton
[type: UiPanel] 
The main Button for the UiMenu for each UiMenuItem.





UiMenuItem.leftIconGraphicAsset
[type: GraphicAsset] 
The GraphicAsset for an optional icon to show on the left side of the UiMenuItem.





UiMenuItem.leftIconScaleFactor
[type: number] 
The scale factor for the optional icon to show on the left side of the UiMenuItem. Use this property instead of directly scaling the GraphicObject to preserve UiZoom and LayoutObject functionality.





UiMenuItem.leftIconGraphicObject
[type: GraphicObject] 
The read-only GraphicObject for the optional icon to show on the left side of the UiMenuItem.





UiMenuItem.rightIconGraphicAsset
[type: GraphicAsset] 
The GraphicAsset for an optional icon to show on the right side of the UiMenuItem.





UiMenuItem.rightIconScaleFactor
[type: number] 
The scale factor for the optional icon to show on the right side of the UiMenuItem. Use this property instead of directly scaling the GraphicObject to preserve UiZoom and LayoutObject functionality.





UiMenuItem.rightIconGraphicObject
[type: GraphicObject] 
The read-only GraphicObject for the optional icon to show on the right side of the UiMenuItem.





UiMenuItem.name
[type: string] 
The main string shown in the UiMenu for this UiMenuItem.





UiMenuItem.secondaryString
[type: string] 
The secondary string shown in the UiMenu on the right side of this UiMenuItem.





UiMenuItem.secondaryTextBox
[type: TextBox] 
The read-only TextBox for the optional secondary text to show on the right side of the UiMenuItem.





UiMenuItem.triggeringClosesMenu
[type: boolean] [default: true] 
Boolean determining if triggering this UiMenuItem automatically closes the menu.





UiMenuItem.subMenu
[type: UiMenu] 
If this UiMenuItem opens a sub-menu, then this property will be populated a reference to thed associated UiMenu, otherwise it will be undefined.





UiMenuItem.dispose()
[type: function] 
Disposes the UiMenuItem and all of its components










----------------------------------------------------------
Section 136: UiNumberSupervisor_textField
----------------------------------------------------------


UiNumberSupervisor_textField
[type: class] [extends: UiButton] [requires: module - extendedUi] 
A specialized UiTextField that includes a Supervisor member, enabling it to monitor and adjust a number property's value during runtime. To use this class, configure the 'supervisedPropertyGetter' and 'supervisedPropertySetter' callbacks on the Supervisor. Once configured, the 'mainText' TextBox will be updated every fixed update to reflect the most current value of the supervised property, and the value of the supervised property will also be 'adjustable' via keyboard and cursor interaction.





UiNumberSupervisor_textField.supervisor
[type: Supervisor] 
Supervisor with callbacks that enable this UiNumberSupervisor_textField to monitor and adjust a number property's value during runtime.





UiNumberSupervisor_textField.dragMultiplier
[type: number] [default: 1] 
Number that multiplies the affect of dragging with this UiNumberSupervisor_textField. For reference, a value of 1 is fitting for a numeric property whose range is roughly 500;





UiNumberSupervisor_textField.sliderArrowsIcon
[type: GraphicObject] 
GraphicObject on the leftmost side of this UiNumberSupervisor_textField indicating that it can be dragged and scrolled.





UiNumberSupervisor_textField.sliderArrowsIconScaleFactor
[type: number] 
Number multiplying the scale of the 'sliderArrowsIcon' GraphicObject. Use this property instead of directly scaling the sliderArrowsIcon GraphicObject to preserve UiZoom and LayoutObject functionality.





UiNumberSupervisor_textField.displayPrecision
[type: number] [default: 3] 
The number of digits shown to the right of the decimal within the UiTextField for this UiNumberSupervisor_textField.
























































































































































































































































































































































































































































----------------------------------------------------------
Section 137: UiPopupWindow
----------------------------------------------------------


UiPopupWindow
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized vertical LayoutStack that functions as a pop-up window. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • pre-configured with 'UiVisualFocus' functionality.  • nearestPixelRendering-enabled.





UiPopupWindow.isOpen
[type: boolean] 
Boolean determining if this UiPopupWindow is displayed/enabled. When this property is set to true, this UiPopupWindow becomes the 'singularFocusObject' and also assumes 'visual focus'.





UiPopupWindow.backgroundPanel
[type: UiPanel] 
A UiPanel that serves as the background to the UiPopupWindow.





UiPopupWindow.topBarLeftStack
[type: LayoutStack] 
The horizontal LayoutStack containing top bar, which includes the 'ex' button and the title TextBox.





UiPopupWindow.topBarBackground
[type: UiPanel] 
A UiPanel that serves as the background to the top bar in the UiPopupWindow.





UiPopupWindow.exButton
[type: UiGraphicButton] 
A UiGraphicButton that serves the 'ex' button in the top-left corner of the UiPopupWindow.





UiPopupWindow.titleText
[type: TextBox] 
The TextBox serving as the top bar title for the UiPopUpWindow.





UiPopupWindow.bodyStack
[type: LayoutStack] 
The LayoutStack containing the main body displayed by this UiPopupWindow.





UiPopupWindow.decisionButtonStack
[type: LayoutStack] 
The horizontal LayoutStack containing decision buttons (UiButtons) displayed in the lower-right corner of this UiPopupWindow.





UiPopupWindow.isMovable
[type: boolean] [default: true] 
Flag determining if the UiPopupWindow can be moved via dragging.





UiPopupWindow.allowEscape
[type: boolean] [default: false] 
Boolean determining if the end-user can press the 'Escape' key, click the 'ex' button, or click outside of the visual focus dimmer background to exit the UiPopupWindow. Setting this value to false would effectively require that the end-user click one of the decision buttons to exit the UiPopupWindow.





UiPopupWindow.setDecisionButtons(decisionNames, rightmostUiButtonIsAutoOutlined)
[type: function] 
A convienience function to bulk-add decision buttons, which are just a series of standardized UiButtons at the bottom of the UiPopupWindow. Once the decision buttons have been added, 'addDecisionButtonTriggerCallback' can be used to add a callback which receives the button's text string, the triggering UiButton itself, and the containing UiPopupWindow as its first three parameters.

UiPopupWindow.setDecisionButtons parameter: decisionNames
[type: [string]] 
An array of strings, where each string will become a UiButton at the bottom of the UiPopupWindow.

UiPopupWindow.setDecisionButtons parameter: rightmostUiButtonIsAutoOutlined
[type: string] [optional] 
Boolean determining if the rightmost decision button is automatically outlined whenever the UiPopupWindow is opened.





UiPopupWindow.addDecisionButtonTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever a decision button is triggered via the cursor or keyboard navigation. The decision string, the triggering UiButton, and the containing UiPopupWindow itself are sent to the callback as its first three parameters.

UiPopupWindow.addDecisionButtonTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever a decision button is triggered via the cursor or keyboard navigation.

UiPopupWindow.addDecisionButtonTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever a decision button is triggered via the cursor or keyboard navigation.

UiPopupWindow.addDecisionButtonTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever a decision button is triggered via the cursor or keyboard navigation.





UiPopupWindow.addOpenCloseCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever a UiPopupWindow is opened or closed. A boolean indicating if the UiPopupWindow is open, and the UiPopupWindow itself will be sent to the callback as the first two parameters.

UiPopupWindow.addOpenCloseCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever a this UiPopupWindow is opened or closed.

UiPopupWindow.addOpenCloseCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever a this UiPopupWindow is opened or closed.

UiPopupWindow.addOpenCloseCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that occurs whenever a this UiPopupWindow is opened or closed.





UiPopupWindow.awaitClose()
[type: function] 
Asynchronously awaits the closing of the UiPopupWindow.

































































































































































































































































































































































































----------------------------------------------------------
Section 138: UiStringSupervisor_menu
----------------------------------------------------------


UiStringSupervisor_menu
[type: class] [extends: UiDropDownMenu] [requires: module - extendedUi] 
A specialized UiDropDownMenu that includes a Superivor member, enabling it to monitor and adjust a string property's value during runtime. To use this class, configure the 'supervisedPropertyGetter' and 'supervisedPropertySetter' callbacks on the Supervisor. Once configured, the 'mainText' member will be updated every fixed update to reflect the most current value of the supervised string property, and the value of the supervised property will also be 'adjustable' via cursor interaction with the UiMenu.





UiStringSupervisor_menu.supervisor
[type: Supervisor] 
Supervisor with callbacks that enable this UiStringSupervisor_menu to monitor and adjust a boolean property's value during runtime.





UiStringSupervisor_menu.updateStringOptionsCallbackOwner
[type: object] 
The owner of the optional callback function that will be called whenever the UiMenu is opened in order to update the list of options. The provided callback function should return an Array of strings meant to be the options presented by this UiStringSupervisor_menu.





UiStringSupervisor_menu.updateStringOptionsCallbackName
[type: string] 
The name of the optional callback function that will be called whenever the UiMenu is opened in order to update the list of options. The provided callback function should return an Array of strings meant to be the options presented by this UiStringSupervisor_menu.





UiStringSupervisor_menu.updateStringOptionsCallbackArgs
[type: any] 
Parameters for the optional callback function that will be called whenever the UiMenu is opened in order to update the list of options. The provided callback function should return an Array of strings meant to be the options presented by this UiStringSupervisor_menu.





UiStringSupervisor_menu.setStringOptions(stringOptions)
[type: function] 
Method to update the list of string options available within the UiMenu. This method can be used once during setup in situations where the list of options is static. In such a case, the 'updateStringOptionsCallback' callback could be left undefined.

UiStringSupervisor_menu.setStringOptions parameter: stringOptions
[type: [string]] 
The list of strings that will appear as options in the drop down menu.





























































































































































































































































































































































































































































----------------------------------------------------------
Section 139: UiStringSupervisor_textField
----------------------------------------------------------


UiStringSupervisor_textField
[type: class] [extends: UiTextField] [requires: module - extendedUi] 
A specialized UiTextField that includes a Superivor member, enabling it to monitor and adjust a string property's value during runtime. To use this class, configure the 'supervisedPropertyGetter' and 'supervisedPropertySetter' callbacks on the Supervisor. Once configured, the 'mainText' TextBox will be updated every fixed update to reflect the most current value of the supervised property, and the value of the supervised property will also be 'adjustable' via direct editing of the 'mainText' TextBox.





UiStringSupervisor_textField.supervisor
[type: Supervisor] 
Supervisor with callbacks that enable this UiStringSupervisor_textField to monitor and adjust a string property's value during runtime.
























































































































































































































































































































































































































































----------------------------------------------------------
Section 140: UiStyle
----------------------------------------------------------


UiStyle
[type: class] [NON-INSTANTIABLE] [requires: module - pixelsObjects] 
Object housing default TextFormats, and Colors for various Gui objects such as 'UiButton', 'DropDownMenu' and 'PopUpWindow'.





UiStyle.type
[type: string] 
Type identifier.





UiStyle.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





UiStyle.textFormat_heading
[type: TextFormat] 
The default TextFormat for heading text in the Gui.





UiStyle.textFormat_subHeading
[type: TextFormat] 
The default TextFormat for sub-heading text in the Gui.





UiStyle.textFormat_body
[type: TextFormat] 
The default TextFormat for body text in the Gui.





UiStyle.textFormat_technical
[type: TextFormat] 
The default TextFormat for technical text in the Gui.





UiStyle.textFormat_tiny
[type: TextFormat] 
The default TextFormat for tiny text in the Gui.





UiStyle.color_appHeader
[type: Color] 
The default color for the application header.





UiStyle.color_headerTitle
[type: Color] 
The default color for the title in the header.





UiStyle.color_mainText
[type: Color] 
The default color for text.





UiStyle.color_inactiveText
[type: Color] 
The default color for text that is not active.





UiStyle.color_interactiveText
[type: Color] 
The default color for interactive text.





UiStyle.color_semiInteractiveText
[type: Color] 
The default color for semi-interactive text.





UiStyle.color_editorBackgroundDark
[type: Color] 
The default color for the dark parts of editor backgrounds.





UiStyle.color_editorBackgroundLight
[type: Color] 
The default color for the light parts of editor backgrounds.





UiStyle.color_highlightedInteractiveText
[type: Color] 
The default color for highlighted interactive text.





UiStyle.color_mainPanelBackground
[type: Color] 
The default color for background panels.





UiStyle.color_lightPanelBackground
[type: Color] 
The default color for light background panels.





UiStyle.color_darkPanelBackground
[type: Color] 
The default color for dark background panels.





UiStyle.color_panelHeader
[type: Color] 
The default color for panel headers.





UiStyle.color_panelBorder
[type: Color] 
The default color for panel borders.





UiStyle.color_panelHeaderHighlight
[type: Color] 
The default color for highlighted header panels.





UiStyle.color_buttonPanel
[type: Color] 
The default color for button panels.





UiStyle.color_highlightedButtonPanel
[type: Color] 
The default color for highlighted button panels.





UiStyle.color_builtInHeaderMenu
[type: Color] 
The default color for the built in header menus.





UiStyle.color_popupWindowHeader
[type: Color] 
The default color for popup window headers.





UiStyle.color_brightHighlightedButtonPanel
[type: Color] 
The default color for bright highlighted button panels.





UiStyle.color_navigationOutline
[type: Color] 
The default color for navigation outlining and highlighting.





UiStyle.color_selection
[type: Color] 
The default color for selected UI objects.





UiStyle.color_selectionOutlineBase
[type: Color] 
A deeper, more saturated version of 'color_selection'.





UiStyle.graphicAssetName_caret
[type: string] 
The name of the GraphicAsset to use wherever a caret icon (basically an arrow) is needed in UI components.





UiStyle.graphicAssetName_magnifyingglass
[type: string] 
The name of the GraphicAsset to use wherever a magnifying glass icon (like next to a search bar) is needed in UI components.





UiStyle.graphicAssetName_checkmark
[type: string] 
The name of the GraphicAsset to use wherever a checkmark icon is needed in UI components.





UiStyle.graphicAssetName_ex
[type: string] 
The name of the GraphicAsset to use wherever an 'X' icon is needed in UI components.





UiStyle.graphicAssetName_minus
[type: string] 
The name of the GraphicAsset to use wherever an '-' icon is needed in UI components.





UiStyle.spacer_tiny
[type: number] 
The standard 'tiny' spacer for the gui.





UiStyle.spacer_small
[type: number] 
The standard 'small' spacer for the gui.





UiStyle.spacer_medium
[type: number] 
The standard 'medium' spacer for the gui.





UiStyle.spacer_large
[type: number] 
The standard 'large' spacer for the gui.





UiStyle.addUiPanelCallbackOwner
[type: object] 
The owner of the callback function responsible for returning a UiPanel, which is a customizable rectangle of color. UiPanels are used throughout the various gui objects, like UiButton, UiTextField, DropdownMenu, PopupMenu etc., and generally contribute to the look of the gui. The provided callback must return an instance of this UiPanel, which is a SceneObject that has 2 additional properties (probably built with getter/setters) 'width' and 'height'. Also, the object produced from this callback will need to have EffectNodes that respond to the 'colorMultiply' EffectController, as that EffectController is used to set the color for the UiPanel for its different uses throughout the ui. This callback is defaults to an internal function that returns a UiPanel that is essentially a WhiteBox, but can be changed to customize the look of the gui.





UiStyle.addUiPanelCallbackName
[type: string] 
The name of the callback function responsible for returning a UiPanel, which is a customizable rectangle of color. UiPanels are used throughout the various gui objects, like UiButton, UiTextField, DropdownMenu, PopupMenu etc., and generally contribute to the look of the gui. The provided callback must return an instance of this UiPanel, which is a SceneObject that has 2 additional properties (probably built with getter/setters) 'width' and 'height'. Also, the object produced from this callback will need to have EffectNodes that respond to the 'colorMultiply' EffectController, as that EffectController is used to set the color for the UiPanel for its different uses throughout the ui. This callback is defaults to an internal function that returns a UiPanel that is essentially a WhiteBox, but can be changed to customize the look of the gui.





UiStyle.addUiOutlineCallbackOwner
[type: object] 
The owner of the callback function responsible for returning a UiOutline, which is a customizable rectangular outline. UiOutlines are used throughout the various gui objects, like UiButton, UiTextField, DropdownMenu, PopupMenu etc., and generally contribute to the look of the gui. The provided callback must return an instance of this UiOutline, which is a SceneObject that has 2 additional properties (probably built with getter/setters) 'width' and 'height'. Also, the object produced from this callback will need to have EffectNodes that respond to the 'colorMultiply' EffectController, as that EffectController is used to set the color for the UiPanel for its different uses throughout the ui. This callback is defaults to an internal function that returns a UiOutline that is essentially a rectangle made of 4 WhiteBoxes, but can be changed to customize the look of the gui.





UiStyle.addUiOutlineCallbackName
[type: string] 
The name of the callback function responsible for returning a UiOutline, which is a customizable rectangular outline. UiOutlines are used throughout the various gui objects, like UiButton, UiTextField, DropdownMenu, PopupMenu etc., and generally contribute to the look of the gui. The provided callback must return an instance of this UiOutline, which is a SceneObject that has 2 additional properties (probably built with getter/setters) 'width' and 'height'. Also, the object produced from this callback will need to have EffectNodes that respond to the 'colorMultiply' EffectController, as that EffectController is used to set the color for the UiPanel for its different uses throughout the ui. This callback is defaults to an internal function that returns a UiOutline that is essentially a rectangle made of 4 WhiteBoxes, but can be changed to customize the look of the gui.





UiStyle.addUiPanel(parent, name)
[type: function] [returns: UiPanel] 
Adds a new UiPanel to the given parent SceneObject.

UiStyle.addUiPanel parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The parent SceneObject that the new UiPanel will become a child of.

UiStyle.addUiPanel parameter: name
[type: string] [default: 'UiPanel'] [optional] 
The name of the new UiPanel.





UiStyle.addUiOutline(parent, name)
[type: function] [returns: UiOutline] 
Adds a new UiOutline to the given parent SceneObject.

UiStyle.addUiOutline parameter: parent
[type: SceneObject] [default: nc.mainScene] [optional] 
The parent SceneObject that the new UiOutline will become a child of.

UiStyle.addUiOutline parameter: name
[type: string] [default: 'UiOutline'] [optional] 
The name of the new UiOutline.





UiStyle.standardVisualFeedback(sceneObject)
[type: function] 
Provides a standardized visual feeback consiting of a fast burst of brightness. This feedback is used for most standardized trigger events such as Button presses and keynavigation triggers.

UiStyle.standardVisualFeedback parameter: sceneObject
[type: SceneObject] 
The SceneObject that the visual feeback will be applied to.










----------------------------------------------------------
Section 141: UiPanel
----------------------------------------------------------


UiPanel
[type: class] [extends: SceneObject] 
This is a customizable panel of color used throughout the various gui objects such as UiButton, UiTextField, DropdownMenu, PopupMenu etc., which generally contributes to the look of the gui. The nature of this object can be customized by supplying a new callback function to 'nc.uiStyle.addUiPanelCallbackOwner' and 'nc.uiStyle.addUiPanelCallbackName'.





UiPanel.width
[type: number] 
Number controlling the width of the UiPanel.





UiPanel.height
[type: number] 
Number controlling the height of the UiPanel.





UiPanel.colorMultiply
[type: Color] 
Color controlling the coloring of the UiPanel.

















































































































































































































































































































----------------------------------------------------------
Section 142: UiOutline
----------------------------------------------------------


UiOutline
[type: class] [extends: SceneObject] [NON-INSTANTIABLE] 
This is a customizable rectangular outline used throughout the various gui objects such as UiButton, UiTextField, DropdownMenu, PopupMenu etc., which generally contributes to the look of the gui. The nature of this object can be customized by supplying a new callback function to 'nc.uiStyle.addUiOutlineCallbackOwner' and 'nc.uiStyle.addUiOutlineCallbackName'. 





UiOutline.width
[type: number] 
Number controlling the width of the UiOutline.





UiOutline.height
[type: number] 
Number controlling the height of the UiOutline.





UiOutline.colorMultiply
[type: Color] 
Color controlling the coloring of the UiOutline.

















































































































































































































































































































----------------------------------------------------------
Section 143: UiTextField
----------------------------------------------------------


UiTextField
[type: class] [extends: LayoutStack] [requires: module - extendedUi] 
A ui-specialized horizontal LayoutStack housing an editable TextBox with various UI functionalities and defaults applied. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • pre-configured with 'UiKeyboardNavigable' functionality.  • uiZoom-enabled.  • pre-configured with 'UiVisualFocus' functionality.  • nearestPixelRendering-enabled.





UiTextField.isActive
[type: boolean] [default: true] 
Boolean determining if the UiTextField is available for end-user-internaction, or if it is unavailable and 'grayed out'.





UiTextField.mainText
[type: TextBox] 
The main editable TextBox for this UiTextField.





UiTextField.displayLabel
[type: boolean] [default: false] 
Boolean determining if a label TextBox is displayed to the left of the UiTextField.





UiTextField.label
[type: UiText] [default: undefined] 
A UiText that acts as a label for the UiTextField. Please note that this item is undefined until the 'displayLabel' property is set to true.





UiTextField.mainButton
[type: Button] 
The main Button for the UiTextField, this object is a UiPanel which also implements Button.





UiTextField.outline
[type: UiOutline] 
The outline of the button, which is used to indicate when the end-user outlines this UiTextField using keyboard navigation (tab, arrows, etc...).





UiTextField.buttonBackgroundColor
[type: Color] [default: nc.uiStyle.color_buttonPanel] 
The Color of the Button background.





UiTextField.highlightedButtonBackgroundColor
[type: Color] [default: nc.uiStyle.color_highlightedButtonPanel] 
The Color of the Button background when it's highlighted.





UiTextField.addTriggerCallback(callbackOwner, callbackName, callbackArgs)
[type: function] 
Adds a callback that occurs whenever this UiTextField is triggered via the cursor or keyboard navigation. The triggering browser-created event, and the UiTextField itself are sent to the callback as its first two parameters.

UiTextField.addTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback function that occurs whenever this UiTextField is triggered via the cursor or keyboard navigation.

UiTextField.addTriggerCallback parameter: callbackName
[type: string] 
The name of the callback function that occurs whenever this UiTextField is triggered via the cursor or keyboard navigation.

UiTextField.addTriggerCallback parameter: callbackArgs
[type: Array, any] [optional] 
Args for the callback function that is triggered whenever this UiTextField is triggered via the cursor or keyboard navigation.





UiTextField.removeTriggerCallback(callbackOwner, callbackName)
[type: function] 
Removes the given trigger callback.

UiTextField.removeTriggerCallback parameter: callbackOwner
[type: object] 
The object owning the callback to be removed.

UiTextField.removeTriggerCallback parameter: callbackName
[type: string] 
The name of the callback to be removed.






































































































































































































































































































































































































----------------------------------------------------------
Section 144: UiText
----------------------------------------------------------


UiText
[type: class] [extends: TextBox] [requires: module - extendedUi] 
A ui-specialized TextBox with various UI functionalities and defaults applied. UI functionality includes:  • pre-configured with LayoutObject functionality.  • uiStyle TextFormats and Colors applied.  • uiZoom-enabled.  • nearestPixelRendering-enabled.












































































































































































































































































































































































































































































































































































































































































































































































































----------------------------------------------------------
Section 145: UiVectorSupervisor_textField
----------------------------------------------------------


UiVectorSupervisor_textField
[type: class] [extends: UiCollapsibleStack] [requires: module - extendedUi] 
A specialized UiCollapsibleStack that includes a group of UiTextFields and a Superivor member, enabling it to monitor and adjust a Vector property's value during runtime. To use this class, configure the 'supervisedPropertyGetter' and 'supervisedPropertySetter' callbacks on the Supervisor. Once configured, the included UiTextFields will be updated every fixed update to reflect the most current values of the supervised Vector components, and the component values will also be 'adjustable' via direct editing of the UiTextFields, as well as through cursor interaction.





UiVectorSupervisor_textField.supervisor
[type: Supervisor] 
Supervisor with callbacks that enable this UiStringSupervisor_textField to monitor and adjust a Vector's component values during runtime.





UiVectorSupervisor_textField.defaultDimension
[type: number] [default: 3] 
The number of components shown by default - i.e. this is the number of components that will be shown when the supervisedPropertyGetter returns undefined.





UiVectorSupervisor_textField.displayPrecision
[type: number] [default: 3] 
The number of digits shown to the right of the decimal within the component UiTextFields of this UiVectorSupervisor_textField.





UiVectorSupervisor_textField.getComponentTextFields()
[type: function] [returns: [UiTextField]] 
Returns an array of the UiTextFields in this UiVectorSupervisor_textField.





UiVectorSupervisor_textField.setDragMultiplier(componentIndex, multiplierValue)
[type: function] 
Sets a value that multiplies the affect of dragging the component label. For reference, a value of 1 is fitting for a component whose range is roughly 500;

UiVectorSupervisor_textField.setDragMultiplier parameter: componentIndex
[type: number] 
The index of the component that the given multiplier will be applied to (0=x,1=y,2=z,3=w).

UiVectorSupervisor_textField.setDragMultiplier parameter: multiplierValue
[type: number] 
The value that will multiply the affect of dragging the label associated with the given component.







































































































































































































































































































































































































































































----------------------------------------------------------
Section 146: UiVisualFocus
----------------------------------------------------------


UiVisualFocus
[type: class] [NON-INSTANTIABLE] [requires: module - extendedUi] 
Object housing functionality that enables for the SceneObject owning it to be 'visually focused', which focuses the end-user's attention the given SceneObject by placing it in front of a dimmer layer whenever the object is the the current 'singularFocusObject'. Calling 'configureUiVisualFocus' populates the 'uiVisualFocus' member for the owning SceneObject. It should be noted that the dimmer layer that the newly focused item is placed in front of is actually a button which, when pressed, calls the 'attemptExitUiVisualFocus' member of the current singularFocusObject if that member is defined.





UiVisualFocus.dispose()
[type: function] 
Disposes this UiVisualFocus, disabling the visual focus functionality for the SceneObject owning it, and freeing the object for garbage collection.










----------------------------------------------------------
Section 147: UiZoom
----------------------------------------------------------


UiZoom
[type: class] [NON-INSTANTIABLE] 
Object housing functionality associated with the user interface zoom, which enables end-users to increase or decrease the overall size of text and other user interface items (when those items have uiZoom functionality enabled). 





UiZoom.zoomValue
[type: number] [default: 1] 
The number associated with the zoom level of user interface items.





UiZoom.totalZoom
[type: number] [default: 1] 
The read-only value associated with the overall zoom level of user interface items, including the 'devicePixelRatio', which is set by the browser. For UI items to accurately adjust to both the zoomValue and the browser's devicePixelRatio, use this value.





UiZoom.autoEnableStandardUiZoomFunctionality
[type: boolean] [default: false] 
Flag determining if certain uiZoom-capable objects will have the 'standard' uiZoom functionality automatically enabled upon their instantiation. Objects affected by this include TextBox, TextAssembly, LayoutStack, SrollingPanel, UiButton, UiTextField, UiCollapsibleStack, DropDownMenu, DropSideMenu, and PopupWindow. This flag works on a 'state-machine' basis; newly instantiated objects will automatically have the standard uiZoom functionality enabled while this flag is true. Otherwise, uiZoom functionality will not be automatically enabled on any objects, and would instead need to be manually enabled either using 'nc.uiZoom.enableStandardUiZoomFunctionality' or by implementing custom uiZoom functionality using 'nc.appEvents.uiZoomChange.addCallback'.





UiZoom.enableStandardUiZoomFunctionality(obj)
[type: function] 
Certain built-in Incisor® objects have standard uiZoom functionality that can be enabled. For example, TextBox objects have a standard uiZoom implementation that can be enabled, which consists of applying the 'nc.uiZoom.totalZoom' multiplier to the individual characters' scale, as well as the maxWidth, and maxHeight. The list of objects that have standard uiZoom implementations include SceneObject, GraphcObject, TextBox, TextAssembly, LayoutStack, SrollingPanel, UiButton, UiTextField, UiCollapsibleStack, DropDownMenu, DropSideMenu, and PopupWindow. Provide any of these objects as a parameter to this function, and their uiZoom functionality will be enabled. You can also set the 'autoEnableStandardUiZoomFunctionality' flag to true, which tells Incisor® to automatically enable the standard uiZoom functionality upon instantiation for some objects. If you want to create custom uiZoom functionality, just add a callback using 'nc.appEvents.uiZoomChange.addCallback', and perform the desired custom operations in that function.

UiZoom.enableStandardUiZoomFunctionality parameter: obj
[type: object] 
The object to enable the standard UiZoom functionality on.










----------------------------------------------------------
Section 148: UrlParameterIterator
----------------------------------------------------------


UrlParameterIterator
[type: class] [NON-INSTANTIABLE] [requires: module - urlParameterIterator, license - advancedTools] 
Object housing testing functionality that enables a project to refresh itself repeatedly with different url parameters. Such functionality can help with batch testing of a project's configurations or settings. To use this functionality, first call the 'UrlParameterIteration.setup' method, passing it an array of objects where each object represents the url parameters you would like the browser to refresh with. When ready to start the iteration, call 'UrlParameterIteration.start'. Then add the desired functionality per url parameter - be sure to implement what you want conditionally based on the url params (otherwise everything will happen on every refresh). When the desired tasks (testing, screen shots, etc...) have completed for each set of url parameters, call 'UrlParameterIteration.next', this will proceed to refresh with the next set of url parameters.





UrlParameterIterator.setup(urlParametersList, postIterationCallbackOwner, postIterationCallackName)
[type: function] 
Function that informs the UrlParameterIterator of the set of url parameters that it will iterate over. This function must be called un-conditionally upon every refresh in order for the UrlPerameterIterator to function properly.

UrlParameterIterator.setup parameter: urlParametersList
[type: [object]] 
Array of objects where each object represents the active url parameters for a particular iteration.

UrlParameterIterator.setup parameter: postIterationCallbackOwner
[type: object] 
The object owning the callback function to be called when the iteration completes.

UrlParameterIterator.setup parameter: postIterationCallackName
[type: string] 
The name of the callback function to be called when the iteration completes.





UrlParameterIterator.start(startingIndex)
[type: function] 
Starts the process of refreshing the browser, iterating through the list of url parameters provided in 'UrlParameterIterator.setup'.

UrlParameterIterator.start parameter: startingIndex
[type: number] [default: 0] [optional] 
Optional starting index, enabling iteration to start at a non-zero value.





UrlParameterIterator.next()
[type: function] 
Proceeds to the next item in the list of url parameters, refreshing the browser with the coorespoinging url.










----------------------------------------------------------
Section 149: Vector1Swoop
----------------------------------------------------------


Vector1Swoop
[type: class] [NON-INSTANTIABLE] 
Object housing the swoopers for this Vector's components 





Vector1Swoop.each(endValues, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) each of the Vector components from their current values to the given end values over the duration.

Vector1Swoop.each parameter: endValues
[type: [number]] 
The ending values for the numeric properties being swooped.

Vector1Swoop.each parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector1Swoop.each parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector1Swoop.each parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector1Swoop.each parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector1Swoop.each parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector1Swoop.each parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1Swoop.each parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector1Swoop.each parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector1Swoop.each parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





Vector1Swoop.all(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) all of the Vector components from their current values to the given end value over the duration.

Vector1Swoop.all parameter: endValue
[type: number] 
The ending value for the numeric properties being swooped.

Vector1Swoop.all parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector1Swoop.all parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector1Swoop.all parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector1Swoop.all parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector1Swoop.all parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector1Swoop.all parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1Swoop.all parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector1Swoop.all parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector1Swoop.all parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.





Vector1Swoop.x(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

Vector1Swoop.x parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

Vector1Swoop.x parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector1Swoop.x parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector1Swoop.x parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector1Swoop.x parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector1Swoop.x parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector1Swoop.x parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1Swoop.x parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector1Swoop.x parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector1Swoop.x parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.










----------------------------------------------------------
Section 150: Vector2Swoop
----------------------------------------------------------


Vector2Swoop
[type: class] [extends: Vector1Swoop] [NON-INSTANTIABLE] 
Object housing the swoopers for this Vector's components 





Vector2Swoop.y(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

Vector2Swoop.y parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

Vector2Swoop.y parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector2Swoop.y parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector2Swoop.y parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector2Swoop.y parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector2Swoop.y parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector2Swoop.y parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector2Swoop.y parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector2Swoop.y parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector2Swoop.y parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

























----------------------------------------------------------
Section 151: Vector3Swoop
----------------------------------------------------------


Vector3Swoop
[type: class] [extends: Vector2Swoop] [NON-INSTANTIABLE] 
Object housing the swoopers for this Vector's components 





Vector3Swoop.z(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

Vector3Swoop.z parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

Vector3Swoop.z parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector3Swoop.z parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector3Swoop.z parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector3Swoop.z parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector3Swoop.z parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector3Swoop.z parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector3Swoop.z parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector3Swoop.z parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector3Swoop.z parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.






























----------------------------------------------------------
Section 152: Vector4Swoop
----------------------------------------------------------


Vector4Swoop
[type: class] [extends: Vector3Swoop] [NON-INSTANTIABLE] 
Object housing the swoopers for this Vector's components 





Vector4Swoop.w(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

Vector4Swoop.w parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

Vector4Swoop.w parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

Vector4Swoop.w parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

Vector4Swoop.w parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

Vector4Swoop.w parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

Vector4Swoop.w parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

Vector4Swoop.w parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector4Swoop.w parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

Vector4Swoop.w parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

Vector4Swoop.w parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.



































----------------------------------------------------------
Section 153: ColorSwoop
----------------------------------------------------------


ColorSwoop
[type: class] [extends: Vector4Swoop] [NON-INSTANTIABLE] 
Object housing the swoopers for this Vector's components 





ColorSwoop.red(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

ColorSwoop.red parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

ColorSwoop.red parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

ColorSwoop.red parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

ColorSwoop.red parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

ColorSwoop.red parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

ColorSwoop.red parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

ColorSwoop.red parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorSwoop.red parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

ColorSwoop.red parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

ColorSwoop.red parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

example:
// Objective: Swoop the red Color of a GraphicObject.
// Expected Result: You will see a red box fade to black over a period of 10 seconds, then fade back to red over a period of 5 seconds.

// Create a Color using the Color constructor. Initially, make it red.
let color = new Color( 1, 0, 0, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "RedBox" );
// Set the GraphicObject's fillColor property to the new Color (initially red).
myGraphicObject.fillColor = color;
// Swoop the red color down to zero over 10 seconds then swoop it back to 1 over 5 seconds.
color.swoop.red( 0, 10, undefined, color.swoop, "red", [1,5] );





ColorSwoop.green(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

ColorSwoop.green parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

ColorSwoop.green parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

ColorSwoop.green parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

ColorSwoop.green parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

ColorSwoop.green parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

ColorSwoop.green parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

ColorSwoop.green parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorSwoop.green parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

ColorSwoop.green parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

ColorSwoop.green parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

example:
// Objective: Swoop the green Color of a GraphicObject.
// Expected Result: You will see a green box fade to black over a period of 10 seconds, then fade back to green over a period of 5 seconds.

// Create a Color using the Color constructor. Initially, make it green.
let color = new Color( 0, 1, 0, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "GreenBox" );
// Set the GraphicObject's fillColor property to the new Color (initially green).
myGraphicObject.fillColor = color;
// Swoop the green color down to zero over 10 seconds then swoop it back to 1 over 5 seconds.
color.swoop.green( 0, 10, undefined, color.swoop, "green", [1,5] );





ColorSwoop.blue(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

ColorSwoop.blue parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

ColorSwoop.blue parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

ColorSwoop.blue parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

ColorSwoop.blue parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

ColorSwoop.blue parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

ColorSwoop.blue parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

ColorSwoop.blue parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorSwoop.blue parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

ColorSwoop.blue parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

ColorSwoop.blue parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

example:
// Objective: Swoop the blue Color of a GraphicObject.
// Expected Result: You will see a blue box fade to black over a period of 10 seconds, then fade back to blue over a period of 5 seconds.

// Create a Color using the Color constructor. Initially, make it blue.
let color = new Color( 0, 0, 1, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "BlueBox" );
// Set the GraphicObject's fillColor property to the new Color (initially blue).
myGraphicObject.fillColor = color;
// Swoop the blue color down to zero over 10 seconds then swoop it back to 1 over 5 seconds.
color.swoop.blue( 0, 10, undefined, color.swoop, "blue", [1,5] );





ColorSwoop.alpha(endValue, duration, tweenType, completionCallbackOwner, completionCallbackName, completionCallbackArgs, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Swooper] 
Swoops (interpolates) given component from its current value to the given end value over the duration.

ColorSwoop.alpha parameter: endValue
[type: number] 
The ending value for the numeric property being swooped.

ColorSwoop.alpha parameter: duration
[type: number] [default: 0] [optional] 
The duration for the interpolation.

ColorSwoop.alpha parameter: tweenType
[type: TweenType] [default: nc.tweenTypes.Linear] [optional] 
The TweenType, determining the method of interpolation.

ColorSwoop.alpha parameter: completionCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called when the Swooper completes.

ColorSwoop.alpha parameter: completionCallbackName
[type: string] [optional] 
The name of the function that is called when the Swooper completes.

ColorSwoop.alpha parameter: completionCallbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the Swooper completes.

ColorSwoop.alpha parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Swooper will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorSwoop.alpha parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Swooper is affected by.

ColorSwoop.alpha parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the swooping process.

ColorSwoop.alpha parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the swooping process.

example:
// Objective: Swoop the alpha (transparency) of a GraphicObject.
// Expected Result: You will see a white box gradually disappear over a period of 10 seconds, then reappear back to white over a period of 5 seconds.

// Create a Color using the Color constructor. By default, it will be white.
let color = new Color();
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject(nc.graphicAssets.whiteBox, nc.mainScene, "WhiteBox");
// Set the GraphicObject's fillColor property to the new Color (initially white).
myGraphicObject.fillColor = color;
// Swoop the alpha value down to zero over 10 seconds then swoop it back to 1 over 5 seconds.
color.swoop.alpha(0, 10, undefined, color.swoop, "alpha", [1, 5]);








































----------------------------------------------------------
Section 154: Vector1AddMotion
----------------------------------------------------------


Vector1AddMotion
[type: class] [NON-INSTANTIABLE] 
Object housing the 'addMotion' functions for this Vector's components 





Vector1AddMotion.each(lowerBounds, upperBounds, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to each of the components of this Vector (bounds to be supplied individually), and returns a Motion object, which can be used to control the motion dynamically.

Vector1AddMotion.each parameter: lowerBounds
[type: [number]] 
The lower bound(s) for the motion being added.

Vector1AddMotion.each parameter: upperBounds
[type: [number]] 
The upper bound(s) for the motion being added.

Vector1AddMotion.each parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector1AddMotion.each parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector1AddMotion.each parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1AddMotion.each parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector1AddMotion.each parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector1AddMotion.each parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Use the each() function to add motion to the color of the box.
// Expected Result: You will see a box continuously fading in and out from bright white to a dark, semi-transparent blue.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// set the lower and upper color bounds as arrays and slow the motion speed to .2
box.colorMultiply.addMotion.each( [0, .1, .6, .4], [.7, 1, .8, 2], .2 );





Vector1AddMotion.all(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds the a motion to all of the components of this Vector (using the same set of bounds), and returns a Motion object, which can be used to control the motion dynamically.

Vector1AddMotion.all parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

Vector1AddMotion.all parameter: upperBound
[type: number] 
The upper bound for the motion being added.

Vector1AddMotion.all parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector1AddMotion.all parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector1AddMotion.all parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1AddMotion.all parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector1AddMotion.all parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector1AddMotion.all parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Use the all() function to add motion to the scale of a box.
// Expected Result: You will see a white box continuously expanding and contracting.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// set the upper and lower bounds of the scale of the box and slow the motion speed to .2
box.scale.addMotion.all(  0, 3, .2 );





Vector1AddMotion.x(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

Vector1AddMotion.x parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

Vector1AddMotion.x parameter: upperBound
[type: number] 
The upper bound for the motion being added.

Vector1AddMotion.x parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector1AddMotion.x parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector1AddMotion.x parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector1AddMotion.x parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector1AddMotion.x parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector1AddMotion.x parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Use the x() function to add motion along the x axis.
// Expected Result: You will see a white box continuously moving back and forth along the x axis.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// set the upper and lower bounds of the x position of the box and slow the motion speed to .2
box.position.addMotion.x(  -500, 500, .2 );










----------------------------------------------------------
Section 155: Vector2AddMotion
----------------------------------------------------------


Vector2AddMotion
[type: class] [extends: Vector1AddMotion] [NON-INSTANTIABLE] 
Object housing the 'addMotion' functions for this Vector's components 





Vector2AddMotion.y(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

Vector2AddMotion.y parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

Vector2AddMotion.y parameter: upperBound
[type: number] 
The upper bound for the motion being added.

Vector2AddMotion.y parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector2AddMotion.y parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector2AddMotion.y parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector2AddMotion.y parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector2AddMotion.y parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector2AddMotion.y parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Use the y() function to add motion along the y axis.
// Expected Result: You will see a white box continuously moving back and forth along the y axis.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// set the upper and lower bounds of the y position of the box and slow the motion speed to .2
box.position.addMotion.y(  -500, 500, .2 );

























----------------------------------------------------------
Section 156: Vector3AddMotion
----------------------------------------------------------


Vector3AddMotion
[type: class] [extends: Vector2AddMotion] [NON-INSTANTIABLE] 
Object housing the 'addMotion' functions for this Vector's components 





Vector3AddMotion.z(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

Vector3AddMotion.z parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

Vector3AddMotion.z parameter: upperBound
[type: number] 
The upper bound for the motion being added.

Vector3AddMotion.z parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector3AddMotion.z parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector3AddMotion.z parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector3AddMotion.z parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector3AddMotion.z parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector3AddMotion.z parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.






























----------------------------------------------------------
Section 157: Vector4AddMotion
----------------------------------------------------------


Vector4AddMotion
[type: class] [extends: Vector3AddMotion] [NON-INSTANTIABLE] 
Object housing the 'addMotion' functions for this Vector's components 





Vector4AddMotion.w(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

Vector4AddMotion.w parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

Vector4AddMotion.w parameter: upperBound
[type: number] 
The upper bound for the motion being added.

Vector4AddMotion.w parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

Vector4AddMotion.w parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

Vector4AddMotion.w parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

Vector4AddMotion.w parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

Vector4AddMotion.w parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

Vector4AddMotion.w parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.



































----------------------------------------------------------
Section 158: ColorAddMotion
----------------------------------------------------------


ColorAddMotion
[type: class] [extends: Vector4AddMotion] [NON-INSTANTIABLE] 
Object housing the 'addMotion' functions for this Vector's components 





ColorAddMotion.red(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

ColorAddMotion.red parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

ColorAddMotion.red parameter: upperBound
[type: number] 
The upper bound for the motion being added.

ColorAddMotion.red parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

ColorAddMotion.red parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

ColorAddMotion.red parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorAddMotion.red parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

ColorAddMotion.red parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

ColorAddMotion.red parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Create a blinking red box.
// Expected Result: You will see a box continuously blinking between red and black.

// Create a Color using the Color constructor. Initially, make it red.
let color = new Color( 1, 0, 0, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "RedBox" );
// Set the GraphicObject's fillColor property to the new Color.
myGraphicObject.fillColor = color;
// Add a blinking motion by setting the lower bound to black and the upper bound to red at a speed of 2.
color.addMotion.red( 0, 1, 2 );





ColorAddMotion.green(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

ColorAddMotion.green parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

ColorAddMotion.green parameter: upperBound
[type: number] 
The upper bound for the motion being added.

ColorAddMotion.green parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

ColorAddMotion.green parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

ColorAddMotion.green parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorAddMotion.green parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

ColorAddMotion.green parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

ColorAddMotion.green parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Create a blinking green box.
// Expected Result: You will see a box continuously blinking between green and black.

// Create a Color using the Color constructor. Initially, make it green.
let color = new Color( 0, 1, 0, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "GreenBox" );
// Set the GraphicObject's fillColor property to the new Color.
myGraphicObject.fillColor = color;
// Add a blinking motion by setting the lower bound to black and the upper bound to green at a speed of 2.
color.addMotion.green( 0, 1, 2 );





ColorAddMotion.blue(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

ColorAddMotion.blue parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

ColorAddMotion.blue parameter: upperBound
[type: number] 
The upper bound for the motion being added.

ColorAddMotion.blue parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

ColorAddMotion.blue parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

ColorAddMotion.blue parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorAddMotion.blue parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

ColorAddMotion.blue parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

ColorAddMotion.blue parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Create a blinking blue box.
// Expected Result: You will see a box continuously blinking between blue and black.

// Create a Color using the Color constructor. Initially, make it blue.
let color = new Color( 0, 0, 1, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "BlueBox" );
// Set the GraphicObject's fillColor property to the new Color.
myGraphicObject.fillColor = color;
// Add a blinking motion by setting the lower bound to black and the upper bound to blue at a speed of 2.
color.addMotion.blue( 0, 1, 2 );





ColorAddMotion.alpha(lowerBound, upperBound, motionSpeed, motionType, pauseImmunity, speedControl, eventCallbackOwner, eventCallbackName)
[type: function] [returns: Motion] 
Adds a motion to the given component and returns a Motion object, which can be used to control the motion dynamically.

ColorAddMotion.alpha parameter: lowerBound
[type: number] 
The lower bound for the motion being added.

ColorAddMotion.alpha parameter: upperBound
[type: number] 
The upper bound for the motion being added.

ColorAddMotion.alpha parameter: motionSpeed
[type: number] [default: 1] [optional] 
The speed factor for the added motion.

ColorAddMotion.alpha parameter: motionType
[type: MotionType] [default: nc.motionTypes.Pendulum] [optional] 
The MotionType, determining the nature of the motion being added.

ColorAddMotion.alpha parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this Motion will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

ColorAddMotion.alpha parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this Motion is affected by.

ColorAddMotion.alpha parameter: eventCallbackOwner
[type: object] [optional] 
The object owning the callback function that is called with each fixedUpdate during the motion.

ColorAddMotion.alpha parameter: eventCallbackName
[type: string] [optional] 
The name of the function that is called with each fixedUpdate during the motion.

example:
// Objective: Create a blinking box.
// Expected Result: You will see a box continuously blinking. It will gradually disappear and reappear back to white.

// Create a Color using the Color constructor. Initially, it will be white.
let color = new Color();
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "WhiteBox" );
// Set the GraphicObject's fillColor property to the new Color.
myGraphicObject.fillColor = color;
// Add a blinking motion by setting the lower bound to transparent(0) and the upper bound to opaque(1) at a speed of 2.
color.addMotion.alpha( 0, 1, 2 );








































----------------------------------------------------------
Section 159: Vector4Base
----------------------------------------------------------


Vector4Base
[type: class] [NON-INSTANTIABLE] 
The 'base' object for the Vector4 type. This is not for general use - use Vector4 instead. 





Vector4Base.type
[type: string] 
Type identifier.





Vector4Base.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Vector4Base.x
[type: number] 
The first component of this Vector.





Vector4Base.y
[type: number] 
The second component of this Vector.





Vector4Base.z
[type: number] 
The third component of this Vector.





Vector4Base.w
[type: number] 
The fourth component of this Vector.





Vector4Base.scaleByFactor(factor)
[type: function] 
Multiplies all Vector components by the given factor.

Vector4Base.scaleByFactor parameter: factor
[type: number] 
The value to multiply the Vector components by.

example:
// Objective: Use the scaleByFactor to change the color of the white box.
// Expected Result: You will see a half transparent gray box.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// multiplying with the box's default color (1,1,1,1) results in a final color of (.5, .5, .5, .5) 
box.fillColor.scaleByFactor( .5 );





Vector4Base.multiply(vector)
[type: function] 
Multiplies all components of this Vector by the given Vector.

Vector4Base.multiply parameter: vector
[type: Vector4] 
The Vector to multiply this Vector by.

example:
// Objective: Use the multiply function to change the color of the white box.
// Expected Result: You will see a denim blue box.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// create a color to multiply with the box's default color (1,1,1,1)
let colorMultiplier = new Color( 0, .5, 1, .8 );
// multiplying results in a final color of (0, .5, 1, .8) 
box.fillColor.multiply( colorMultiplier );





Vector4Base.multiplyByValues(x, y, z, w)
[type: function] 
Multiplies the components of this Vector by the values provided.

Vector4Base.multiplyByValues parameter: x
[type: number] [default: 1] [optional] 
The value to multiply the first component by.

Vector4Base.multiplyByValues parameter: y
[type: number] [default: 1] [optional] 
The value to multiply the second component by.

Vector4Base.multiplyByValues parameter: z
[type: number] [default: 1] [optional] 
The value to multiply the third component by.

Vector4Base.multiplyByValues parameter: w
[type: number] [default: 1] [optional] 
The value to multiply the fourth component by.

example:
// Objective: Use the multiplyByValues function to change the color of the white box.
// Expected Result: You will see a denim blue box.

// create a GraphicObject using the WhiteBox asset
let box = new GraphicObject( nc.graphicAssets.WhiteBox, nc.mainScene, "Box" );
// multiplying with the box's default color (1,1,1,1) results in a final color of (0, .5, 1, .8) 
box.fillColor.multiplyByValues( 0, .5, 1, .8  );





Vector4Base.copy(vector)
[type: function] 
Sets all of this Vector's component values to the component values of the given Vector.

Vector4Base.copy parameter: vector
[type: Vector4] 
The Vector to copy component values from.





Vector4Base.isEqual(vector)
[type: function] [returns: boolean] 
Determines if all of the components of this Vector are equal to their counterparts in the given Vector.

Vector4Base.isEqual parameter: vector
[type: Vector4] 
The Vector to compare against.





Vector4Base.clone()
[type: function] [returns: Vector4] 
Returns a new Vector4 with the same component values as this Vector.










----------------------------------------------------------
Section 160: Vector4
----------------------------------------------------------


Vector4
[type: class] [extends: Vector4Base] 
An object with 4 numeric properties (x, y, z, w).





Vector4.swoop
[type: Vector4Swoop] 
Object housing the built-in swoopers for this Vector's components.





Vector4.addMotion
[type: Vector4AddMotion] 
Object housing the built-in 'addMotion' functions for this Vector's components.






































































----------------------------------------------------------
Section 161: Color
----------------------------------------------------------


Color
[type: class] [extends: Vector4Base] 
An object with 4 numeric properties (red, green, blue, alpha) representing a color with transparency.





Color.swoop
[type: ColorSwoop] 
Object housing the built-in swoopers for this Vector's components.

example:
// Objective: Swoop the Color of a GraphicObject.
// Expected Result: You will see a red box fade to black over a period of 10 seconds, then fade back to red over a period of 5 seconds.

// Create a Color using the Color constructor. Initially, make it red.
let color = new Color( 1, 0, 0, 1 );
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "RedBox" );
// Set the GraphicObject's fillColor property to the new Color (initially red).
myGraphicObject.fillColor = color;
// Swoop the red color down to zero over 10 seconds then swoop it back to 1 over 5 seconds.
color.swoop.red( 0, 10, undefined, color.swoop, "red", [1,5] );





Color.addMotion
[type: ColorAddMotion] 
Object housing the built-in 'addMotion' functions for this Vector's components.

example:
// Objective: Add motion to the changing Colors of a box.
// Expected Result: You will see a box continuously changing colors as the red, green and blue values adjust up and down over different time intervals.

// Create a Color using the Color constructor. Initially, it will default to white.
let color = new Color();
// Create a GraphicObject using the GraphicObject constructor. Use the white box GraphicAsset and add it to the main Scene.
let myGraphicObject = new GraphicObject( nc.graphicAssets.whiteBox, nc.mainScene, "RedBox" );
// Set the GraphicObject's fillColor property to the new Color.
myGraphicObject.fillColor = color;
// Add motion to the red, green and blue values over different time intervals.
color.addMotion.red( 0, 1, .04 );
color.addMotion.green( 0, 1, .09 );
color.addMotion.blue( 0, 1, 1.5 );





Color.red
[type: number] 
The red value of this Color.

example:
// Objective: Get the red value of a Color.
// Expected Result: The console should read "The red value is 0.5".

// Create a color using the Color constructor. Set the red value to 0.5.
let color = new Color( 0.5, 0, 0, 1 );
console.log("The red value is", color.red);





Color.green
[type: number] 
The green value of this Color.

example:
// Objective: Get the green value of a Color.
// Expected Result: The console should read "The green value is 0.5".

// Create a color using the Color constructor. Set the green value to 0.5.
let color = new Color( 0, 0.5, 0, 1 );
console.log("The green value is", color.green);





Color.blue
[type: number] 
The blue value of this Color.

example:
// Objective: Get the blue value of a Color.
// Expected Result: The console should read "The blue value is 0.5".

// Create a color using the Color constructor. Set the blue value to 0.5.
let color = new Color( 0, 0, 0.5, 1 );
console.log("The blue value is", color.blue);





Color.alpha
[type: number] 
The alpha value of this Color.

example:
// Objective: Get the alpha value of a Color.
// Expected Result: The console should read "The alpha value is 0.5".

// Create a color using the Color constructor. Set the alpha value to 0.5.
let color = new Color( 0, 0, 0, 0.5 );
console.log("The alpha value is", color.alpha);






































































----------------------------------------------------------
Section 162: Vector3Base
----------------------------------------------------------


Vector3Base
[type: class] [NON-INSTANTIABLE] 
The 'base' object for the Vector3 type. This is not for general use - use Vector3 instead. 





Vector3Base.type
[type: string] 
Type identifier.





Vector3Base.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Vector3Base.x
[type: number] 
The first component of this Vector.





Vector3Base.y
[type: number] 
The second component of this Vector.





Vector3Base.z
[type: number] 
The third component of this Vector.





Vector3Base.scaleByFactor(factor)
[type: function] 
Multiplies all Vector components by the given factor.

Vector3Base.scaleByFactor parameter: factor
[type: number] 
The value to multiply the Vector components by.





Vector3Base.multiply(vector)
[type: function] 
Multiplies all components of this Vector by the given Vector.

Vector3Base.multiply parameter: vector
[type: Vector3] 
The Vector to multiply this Vector by.





Vector3Base.multiplyByValues(x, y, z)
[type: function] 
Multiplies the components of this Vector by the values provided.

Vector3Base.multiplyByValues parameter: x
[type: number] [default: 1] [optional] 
The value to multiply the first component by.

Vector3Base.multiplyByValues parameter: y
[type: number] [default: 1] [optional] 
The value to multiply the second component by.

Vector3Base.multiplyByValues parameter: z
[type: number] [default: 1] [optional] 
The value to multiply the third component by.





Vector3Base.copy(vector)
[type: function] 
Sets all of this Vector's component values to the component values of the given Vector.

Vector3Base.copy parameter: vector
[type: Vector3] 
The Vector to copy component values from.





Vector3Base.isEqual(vector)
[type: function] [returns: boolean] 
Determines if all of the components of this Vector are equal to their counterparts in the given Vector.

Vector3Base.isEqual parameter: vector
[type: Vector3] 
The Vector to compare against.





Vector3Base.clone()
[type: function] [returns: Vector3] 
Returns a new Vector3 with the same component values as this Vector.










----------------------------------------------------------
Section 163: Vector3
----------------------------------------------------------


Vector3
[type: class] [extends: Vector3Base] 
An object with 3 numeric properties (x, y, z).





Vector3.swoop
[type: Vector3Swoop] 
Object housing the built-in swoopers for this Vector's components.





Vector3.addMotion
[type: Vector3AddMotion] 
Object housing the built-in 'addMotion' functions for this Vector's components.

































































----------------------------------------------------------
Section 164: Vector2Base
----------------------------------------------------------


Vector2Base
[type: class] [NON-INSTANTIABLE] 
The 'base' object for the Vector2 type. This is not for general use - use Vector2 instead. 





Vector2Base.type
[type: string] 
Type identifier.





Vector2Base.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





Vector2Base.x
[type: number] 
The first component of this Vector.





Vector2Base.y
[type: number] 
The second component of this Vector.





Vector2Base.scaleByFactor(factor)
[type: function] 
Multiplies all Vector components by the given factor.

Vector2Base.scaleByFactor parameter: factor
[type: number] 
The value to multiply the Vector components by.





Vector2Base.multiply(vector)
[type: function] 
Multiplies all components of this Vector by the given Vector.

Vector2Base.multiply parameter: vector
[type: Vector2] 
The Vector to multiply this Vector by.





Vector2Base.multiplyByValues(x, y)
[type: function] 
Multiplies the components of this Vector by the values provided.

Vector2Base.multiplyByValues parameter: x
[type: number] [default: 1] [optional] 
The value to multiply the first component by.

Vector2Base.multiplyByValues parameter: y
[type: number] [default: 1] [optional] 
The value to multiply the second component by.





Vector2Base.copy(vector)
[type: function] 
Sets all of this Vector's component values to the component values of the given Vector.

Vector2Base.copy parameter: vector
[type: Vector2] 
The Vector to copy component values from.





Vector2Base.isEqual(vector)
[type: function] [returns: boolean] 
Determines if all of the components of this Vector are equal to their counterparts in the given Vector.

Vector2Base.isEqual parameter: vector
[type: Vector2] 
The Vector to compare against.





Vector2Base.clone()
[type: function] [returns: Vector2] 
Returns a new Vector2 with the same component values as this Vector.










----------------------------------------------------------
Section 165: Vector2
----------------------------------------------------------


Vector2
[type: class] [extends: Vector2Base] 
An object with 2 numeric properties (x, y).





Vector2.swoop
[type: Vector2Swoop] 
Object housing the built-in swoopers for this Vector's components.





Vector2.addMotion
[type: Vector2AddMotion] 
Object housing the built-in 'addMotion' functions for this Vector's components.




























































----------------------------------------------------------
Section 166: VectorBase
----------------------------------------------------------


VectorBase
[type: class] [NON-INSTANTIABLE] 
The 'base' object for the Vector1 type. This is not for general use - use Vector1 instead. 





VectorBase.type
[type: string] 
Type identifier.





VectorBase.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





VectorBase.dimension
[type: number] 
The number of components this Vector has





VectorBase.x
[type: number] 
The first component of this Vector.





VectorBase.scaleByFactor(factor)
[type: function] 
Multiplies all Vector components by the given factor.

VectorBase.scaleByFactor parameter: factor
[type: number] 
The value to multiply the Vector components by.





VectorBase.multiply(vector)
[type: function] 
Multiplies all components of this Vector by the given Vector.

VectorBase.multiply parameter: vector
[type: Vector1] 
The Vector to multiply this Vector by.





VectorBase.multiplyByValues(x)
[type: function] 
Multiplies the components of this Vector by the values provided.

VectorBase.multiplyByValues parameter: x
[type: number] [default: 1] [optional] 
The value to multiply the first component by.





VectorBase.copy(vector)
[type: function] 
Sets all of this Vector's component values to the component values of the given Vector.

VectorBase.copy parameter: vector
[type: Vector1] 
The Vector to copy component values from.





VectorBase.isEqual(vector)
[type: function] [returns: boolean] 
Determines if all of the components of this Vector are equal to their counterparts in the given Vector.

VectorBase.isEqual parameter: vector
[type: Vector1] 
The Vector to compare against.





VectorBase.clone()
[type: function] [returns: Vector1] 
Returns a new Vector1 with the same component values as this Vector.










----------------------------------------------------------
Section 167: Vector1
----------------------------------------------------------


Vector1
[type: class] [extends: VectorBase] 
An object with 1 numeric property (x).





Vector1.swoop
[type: Vector1Swoop] 
Object housing the built-in swoopers for this Vector's components.





Vector1.addMotion
[type: Vector1AddMotion] 
Object housing the built-in 'addMotion' functions for this Vector's components.




























































----------------------------------------------------------
Section 168: Video
----------------------------------------------------------


Video
[type: class] [extends: TimePlaybackController] [NON-INSTANTIABLE] [requires: module - videos] 
A specialized PlaybackController that manages the playback of video assets. When compressed video assets (mp4 or webm) are included in a project a Texture, Geometry, GraphicAsset, and Video with that same name are created in Incisor. Once included, any GraphicObject can be set to the corresponding GraphicAsset, and the associated Video object can control the video's playback. It should be noted that the visual content of any instance or use of the GraphicAsset will be same everywhere - as video's content is pushed to the associated texture, all objects using that Texture will see the same content. Videos in Incisor rely entirely on the browser's decoding and playback capabilities, which typically don't support rapid/repeated changes to video properties. In practice, videos perform well when playing once normally or free-running, but do not do well with a lot of rapid time jumps or scrubbing. Video formats are not uniformly supported for use within all browsers, and their use is not advised within projects meant to be universally accessible. Acceptable extensions for video files include ".mp4" and ".webm", and while webm (VP8 or VP9) typically supports transparency, there are currently no video formats that support transparency on any Apple mobile or desktop products. 





Video.name
[type: string] 
The Sounds's name. This must be unique among Videos, GraphicAssets, Textures, and Geometries.





Video.isLoaded
[type: boolean] 
Boolean indicating if this Video is currently loaded.





Video.loadingTierRequirements
[type: [number]] 
The LoadingTier that this Sound belongs too. LoadingTiers are a means to organize AssetComponents into separately downloadable groups.





Video.duplicateSource
[type: string] [default: undefined] 
String indicating the source of this Video if it is a duplicate. Incisor® automatically detects when two or more AssetComponents are identical, ensuring that only one copy of the associated data is loaded to reduce the loaded size of the project. Those AssetComponents that are duplicates are marked by indicating the name of the source of their data. This member is undefined for AssetComponents that are not duplicates.





Video.videoElement
[type: HTMLVideoElement] 
Videos in Incisor are backed by actual video HTML elements in the DOM, and this property provides direct access to the associated element. It should be noted that this property will remain null until the video is loaded.







































































































































----------------------------------------------------------
Section 169: WaitThen
----------------------------------------------------------


WaitThen
[type: class] [requires: module - waitThens] 
A WaitThen is an object that provides a means to schedule a delayed callback. This differs from standard javascript 'setTimeout' in that it is compatable with Incisor®'s pausing system, as well its SpeedControls, and 'nc.softwareSpeed'. WaitThen instances can be constructed normally using 'new', or you can just call 'nc.waitThen' which makes use of an internally pooled group of WaitThens. It is recommended that 'nc.waitThen' be used where possible to avoid needlessly instantiating new objects, and also avoid the potential for memory leaks.





WaitThen.type
[type: string] 
Type identifier.





WaitThen.inheritedTypes
[type: object] 
Dictionary object listing all of the types this object is compatible with.





WaitThen.name
[type: string] [default: "WaitThen"] 
The name of the WaitThen.





WaitThen.progress
[type: number] [default: 0] 
The progress of the WaitThen on the scale from [0,1].





WaitThen.isActive
[type: boolean] [default: false] 
Boolean reporting if this WaitThen is currently 'counting down'. Pausing is not factored into this property; a WaitThen that is activated and then subjected to a PauseEvent would still report 'true'.





WaitThen.callbackOwner
[type: object] 
The object owning the callback function invoked when this WaitThen completes.





WaitThen.callbackName
[type: string] 
The name of the callback function invoked when this WaitThen completes.





WaitThen.callbackArgs
[type: any] 
Arguments for the callback function invoked when this WaitThen completes.





WaitThen.pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] 
The PauseEvent or Array of PauseEvents that this WaitThen will be immune to. Set this parameter to [] for this WaitThen to have no pause immunity.





WaitThen.speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] 
The SpeedControl or Array of SpeedControls that this WaitThen is affected by.





WaitThen.duration
[type: number] 
Read-only property indicating the current duration of the WaitThen.





WaitThen.activate(duration, callbackOwner, callbackName, callbackArgs, pauseImmunity, speedControl)
[type: function] 
Activates this WaitThen, starting the 'count-down' to this WaitThen's callback.

WaitThen.activate parameter: duration
[type: number] 
Seconds before the callback will occur.

WaitThen.activate parameter: callbackOwner
[type: object] 
The object owning the callback function that is called when the WaitThen completes.

WaitThen.activate parameter: callbackName
[type: string] 
The name of the function that is called when the WaitThen completes.

WaitThen.activate parameter: callbackArgs
[type: Array, any] [optional] 
Arguments for the function that is called when the WaitThen completes.

WaitThen.activate parameter: pauseImmunity
[type: PauseEvent, [PauseEvent]] [default: nc.defaultPauseImmunity] [optional] 
The PauseEvent or Array of PauseEvents that this WaitThen will be immune to. Set this parameter to [] to create callbacks with no immunity. If this parameter is left undefined, the current value of 'nc.defaultPauseImmunity' will be used. The value for 'nc.defaultPauseImmunity' defaults to [], but can be changed at any time.

WaitThen.activate parameter: speedControl
[type: SpeedControl, [SpeedControl]] [default: nc.defaultSpeedControl] [optional] 
The SpeedControl or Array of SpeedControls that this WaitThen is affected by.





WaitThen.stop(performCallback)
[type: function] 
Stops this WaitThen.

WaitThen.stop parameter: performCallback
[type: boolean] [default: false] [optional] 
Boolean determining if the callback function will be called immediately, or if it will be skipped entirely.










----------------------------------------------------------
Section 170: Deprecation Schedule
----------------------------------------------------------


Deprecation Schedule
[type: information] 
Information about past, present, and future deprecations within the Incisor API...





Deprecation Schedule.2024.10.23.00
[type: deprecation information] 
Title: 'convertToShape' is becoming 'shapify' within ncData

Description: The system will automatically convert the 'convertToShape' bool within the ncData for assets to 'shapify' until phase2 deprecation. Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.23.01
[type: deprecation information] 
Title: 'optimizationLevel' is becoming 'shapifyOptimizationLevel' within ncData

Description: The system will automatically convert the 'optimizationLevel' bool within the ncData for assets to 'shapifyOptimizationLevel' until phase2 deprecation.Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.23.02
[type: deprecation information] 
Title: 'edgeRange' is becoming 'shapifyEdgeRange' within ncData

Description: The system will automatically convert the 'edgeRange' bool within the ncData for assets to 'shapifyEdgeRange' until phase2 deprecation. Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.23.03
[type: deprecation information] 
Title: 'Shape' and 'shape' are becoming 'Shapify' and 'shapify'

Description: The 'Shape' EffectNode and 'shape' EffectController are becoming 'Shapify' and 'shapify' respectively.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.29.00
[type: deprecation information] 
Title: 'Updater' and 'nc.updaters' are becoming 'AppEvent' and 'nc.appEvents'

Description: The 'Updater' type and 'nc.updaters' property are becoming 'AppEvent' and 'nc.appEvents' respectively. It should be noted that the deprecated 'nc.updaters' will not work with minification.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.29.01
[type: deprecation information] 
Title: 'nc.getAllUpdaterRecipients' is becoming 'nc.getAllEventRecipients'

Description: As part of the change from 'Updater' to 'Event', 'nc.getAllUpdaterRecipients' is deprecated. It should be noted that the deprecated 'nc.getAllUpdaterRecipients' will not work with minification.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.31.00
[type: deprecation information] 
Title: The 'coreCanvasResolution' array in ProjectSettings is becoming two separate values 'coreCanvasResolutionX' and 'coreCanvasResolutionY'

Description: By breaking these finite-length arrays into explicit components, auto-validation will become more robust and user clarity will be improved.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.31.01
[type: deprecation information] 
Title: The 'pivotAdjustment_position' array in ncData is becoming separate values 'pivotPointOffsetX', 'pivotPointOffsetY', and 'pivotPointOffsetZ'

Description: By breaking these finite-length arrays into explicit components, auto-validation will become more robust and user clarity will be improved. Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.31.02
[type: deprecation information] 
Title: The 'resolutionScaling' array in ncData is becoming separate values 'resolutionScaleX' and 'resolutionScaleY'

Description: By breaking these finite-length arrays into explicit components, auto-validation will become more robust and user clarity will be improved. Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.10.31.03
[type: deprecation information] 
Title: The 'unitsPerPixel' array in ncData is becoming separate values 'unitsPerPixelX', 'unitsPerPixelY' and 'unitsPerPixeZ'

Description: By breaking these finite-length arrays into explicit components, auto-validation will become more robust and user clarity will be improved. Just save the project to adopt the update.

State: Phase2: Fully Deprecated







Deprecation Schedule.2024.11.13.00
[type: deprecation information] 
Title: The 'Inspector' suffix is being removed from the panel names.

Description: The Object Inspector, Hierarchy Inspector, and Particle System Inspector, are all losing thier suffix.

State: Phase2: Fully Deprecated







Deprecation Schedule.2025.02.19.00
[type: deprecation information] 
Title: A temporary check has been added to detect duplicate UIDs listed in construct files.

Description: In certain situations in the Jan-Feb 2025 time range, using the 'duplicate' option in the Incisor GUI or even just using copy and paste within a construct hiearchy was resulting in duplicate UIDs within a construct. This check has been added to detect those duplicates and correct them.

State: Phase1: Detection and Correction Functionality in Effect

Phase2Target: 2025.06.01

Phase3Target: 2026.01.01







Deprecation Schedule.2025.02.20.00
[type: deprecation information] 
Title: Graphic Expander Change: innerWidth and innerHeight are deprecated, and so are the expandableWidth and expandableHeight paremeters of the setup.

Description: Originally expandableWidth, expandableHeight, innerWidth, and innerHeight were each allowed to be either numbers or arrays - this was too easily confusable. Now a 'symmetric' flag determines which mode the GraphicExpander is in, and there is an entirely different set of properties for each mode. In symmetric mode, there is expandableWidth, expandableHeight, expandedWidth, & expandedHeight. In non-symmetric mode, there is expandableAreaLeft, expandableAreaRight, expandableAreaTop, expandableAreaBottom, expandedAreaLeft, expandedAreaRight, expandedAreaTop, & expandedAreaBottom

State: Phase1: Previous Behavior Still Works With Warning

Phase2Target: 2025.06.01

Phase3Target: 2026.01.01







Deprecation Schedule.2025.02.25.00
[type: deprecation information] 
Title: Timeline.autoplay and Timeline.initialTime have been explicitly added, and the Construct blueprint format has been updated appropriately

Description: Constructs with timelines must be opened and saved before the phase 2 date for the implicit form of the functionality to be transfered into the Construct blueprint.

State: Phase1: Previous Behavior Still Works, and is Automatically Converted

Phase2Target: 2026.01.01

Phase3Target: 2026.01.01







Deprecation Schedule.2025.03.05.00
[type: deprecation information] 
Title: CodeAsset file format change.

Description: Previously, code asset files ended in '.codeAsset' and the content of the files was placed entirely within the code asset init scope. Now files end in '.codeAsset.js' and their contents is placed by default in the code asset class space, except for 'CODE.runBeforeInit' blocks, which are put into the init scope.

State: Phase1: '.codeAsset' files are detected and automatically converted to '.codeAsset.js' files, with the contents wrapped in 'CODE.runBeforeInit' blocks.

Phase2Target: 2025.06.01

Phase3Target: 2026.01.01







Deprecation Schedule.2025.03.05.01
[type: deprecation information] 
Title: jsconfig.json update

Description: Previously generated projects contain a jsconfig.json file that lists the 'Assets' directory as a directory to ignore. But this makes the autocomplete in '*.codeAsset.js' files not work. So a bit of code has been added to detect and fix this whenever a project is opened.

State: Phase1: jsconfig.json files will be automatically edited

Phase2Target: 2025.06.01







Deprecation Schedule.2025.04.02.00
[type: deprecation information] 
Title: Timeline.playOnceAsEvent and Timeline.playOnceWithInfluence are being replaced with Timeline.playOnce_swoopInfluence

Description: For clearer naming and better usability.

State: Phase1: Previous behavior still works, and is automatically converted in constructs

Phase2Target: 2025.09.01







Deprecation Schedule.2025.04.02.01
[type: deprecation information] 
Title: Timeline.playWithInfluence is being replaced with Timeline.play_swoopInfluence

Description: For clearer naming and better usability.

State: Phase1: Previous behavior still works, and is automatically converted in constructs

Phase2Target: 2025.09.01







Deprecation Schedule.2025.04.25.00
[type: deprecation information] 
Title: Constructs without UID references are being deprecated.

Description: For a time, Constructs used an 'objectAddress' array as a means of identification - this is being entirely replaced with the 'UID' system.

State: Phase: Fully Deprecated.







Deprecation Schedule.2025.04.27.00
[type: deprecation information] 
Title: New API for masking Graphic Objects - 'GraphicObject.masking'

Description: For GraphicObject, '.makeMasker', '.makeMasked', '.disableMasking', '.maskStatus', and '.maskList' are all being replaced by GraphicObject.masking

State: Phase1: Previous behavior still works with deprecation warnings, and the masking API will be automatically converted in Constructs, which must each be opened and saved in the inspector to commit the update.

Phase2Target: 2025.09.01







Deprecation Schedule.2025.05.06.00
[type: deprecation information] 
Title: Particle System Random Distribution Type Support

Description: ParticleSystem.radnomnessDistribution no longer supports anything but a numeric value.

State: Phase2: Fully Deprecated







Deprecation Schedule.2025.05.21.00
[type: deprecation information] 
Title: PlaybackController.autoplay -> PlaybackController.autoplayWhenInConstruct

Description: PlaybackController.autoplay is changing to PlaybackController.autoplayWhenInConstruct for clarity.

State: Phase1: Previous behavior still works with deprecation warnings - the flag in the construct file will remain 'autoplay'.

Phase2Target: 2025.09.01







Deprecation Schedule.2025.05.27.00
[type: deprecation information] 
Title: nc.particleSystemDefinitions -> nc.particleSystemDefs

Description: For consistency; definition dictionaries directly nc use the abbreviated 'Defs' to shorten the commonly used reference.

State: Phase1: Previous behavior still works with deprecation warnings.

Phase2Target: 2025.09.01







Deprecation Schedule.2025.05.28.00
[type: deprecation information] 
Title: Updated Incisor Version Check moved to Standard 'SoftStatus' Update

Description: There used to be a check built in to Incisor to see if there were newer versions of Incisor available. The check has been moved to the server; when a newer version is found, the server sends a message through the standard messaging apparatus. But the 'newnewestVersionOfCurrentSet' is still being sent in the SoftStatusUpdate for backwards compatibility. In the next phase, the newnewestVersionOfCurrentSet will be taken out of the SoftStatusUpdate.

State: Phase1: Both new and old functionality work.

Phase2Target: 2025.09.01







Deprecation Schedule.2025.05.28.01
[type: deprecation information] 
Title: Internal Remote Extensions Cloud Location Has Changed

Description: The original cloud location for Internal Remote Extensions has changed to include the VersionSet in its path. For now the old location is still being populated with remote extensions files. In the next phase, the old location will be removed.

State: Phase1: Both the old and new internal remote extensions locations work.

Phase2Target: 2025.09.01







Deprecation Schedule.2025.06.13.00
[type: deprecation information] 
Title: AppEvent.addCallback has a 'callbackArgs' parameter between 'callbackName' and 'pauseImmunity'.

Description: This change helps to entirely unify the internal callbacks system and will future-proof AppEvents.

State: Phase: Fully Deprecated







Deprecation Schedule.2025.10.15.00
[type: deprecation information] 
Title: SlotReel.symbolCustomAddOnDefinition will be deprecated. Please use SlotReel.symbolDefinition instead.

Description: This change is being made to accomodate SlotReel being able to accept either a CustomAddOn OR a CustomObject for the symbol functionality.

State: Phase1: Old functionality works with warning.

Phase2Target: 2026.06.01







Deprecation Schedule.2025.12.04.00
[type: deprecation information] 
Title: nc.isTouchCursor will be deprecated, instead see nc.cursorMode

Description: A previous means of determining whether input from a certain device is touch or mouse driven was determined to be unreliable.

State: Phase1: Old functionality works with warning.

Phase2Target: 2026.06.01












----------------------------------------------------------
Section 171: Release Notes
----------------------------------------------------------


Release Notes
[type: information] 
Incisor Release Notes...





Release Notes.2025.12.08.00.00.00
[type: release notes information] 
TITLE:
Introducing Support for Compressed Video (experimental)
DESCRIPTION:
Now you can include '.mp4' and '.webm' assets in your project and have the associated video content appear on GraphicObjects within Incisor. This functionality is not universally support on all browsers, and special considerations must be taken when using this functionality.

TITLE:
Timeline Panel: Shift-Lock for Keyframe Dragging in Graph Editor
DESCRIPTION:
Now you can hold shift while dragging keyframes in the Graph Editor to lock to the nearest axis.

TITLE:
Timeline Panel: New Ease Standards
DESCRIPTION:
Now when selecting one of the built-in ease options, the ease handle is located at 30% of the span instead of 40% of the span.

TITLE:
Added 'nc.cursorMode' and Deprecated 'nc.isTouchCursor'
DESCRIPTION:
The determination of which mode (touch or mouse) a given project is in, automatically defaults to the first type of event received, but can be changed via 'nc.cursorMode'.






Release Notes.2025.12.01.00.00.00
[type: release notes information] 
TITLE:
Added x, y, and z Axes to the HUD in the Incisor Inspector
DESCRIPTION:
A clear indication of where the origin is...






Release Notes.2025.11.30.00.00.00
[type: release notes information] 
TITLE:
Added Material.depthTest, Material.depthWrite, and Material.faceCulling.
DESCRIPTION:
Exposing these material properties for use in conjunction with OBJs.

TITLE:
Added ContourShading to the TemplateLibrary
DESCRIPTION:
A basic shading EffectNode to make OBJ contour visible.

TITLE:
Added RegisteredProperty.displayInGui
DESCRIPTION:
Flag determining if a given registered property will be displayed with a Supervisor in the GUI.






Release Notes.2025.11.26.00.00.00
[type: release notes information] 
TITLE:
Fixed Bug with Empty-Quote-Named Construct Objects
DESCRIPTION:
Fixed a superficial, red-error generating bug related to making the name for items equal to empty quotes.

TITLE:
Introducing preliminary OBJ support (experimental)
DESCRIPTION:
You can now include OBJ files in the Assets directory of your project and they will automatically appear in the nc.GraphicAssets, and nc.Geometries dictionaries in the project.

TITLE:
Many Documentation Fixes
DESCRIPTION:
In the process of reworking the Incisor Documentation site, and creating the pipeline for the Incisor Raw Knowledge Base, many small issues were found in the documentation and corrected - too numerous to enumerate.






Release Notes.2025.11.12.00.00.00
[type: release notes information] 
TITLE:
Added TextBox.addStartEditCallback
DESCRIPTION:
A new callback that can be created whenever a TextBox's editingMode changes to 'editing'.

TITLE:
Added TextBox.htmlBacking
DESCRIPTION:
A means to allow keyboard input from mobile devices by creating a hidden text element that accepts mobile keyboard entry.






Release Notes.2025.10.28.00.00.00
[type: release notes information] 
TITLE:
Added 'ProcessConfiguration' for runProcess, runCmd, and runBash
DESCRIPTION:
A new class with properties pertaining to the running of processes.

TITLE:
Cleared many unnecessary documentation classes.
DESCRIPTION:
Several classes were converted to object expressions in the documentation to reduce clutter.






Release Notes.2025.10.25.00.00.00
[type: release notes information] 
TITLE:
Template Library Generated Extensions Bug Fix
DESCRIPTION:
Some of the names within the exported extensions from the template library weren't being substituted correctly.






Release Notes.2025.10.24.00.00.00
[type: release notes information] 
TITLE:
Fixed Bug with Gradient2Color, Gradient3Color, Gradient4Color
DESCRIPTION:
Those EffectNodes had effect controllers that attempted to use a disallowed component name. They have been fixed and validation has been added to clarify what is happening when this issue is encountered in the future.






Release Notes.2025.10.23.00.00.00
[type: release notes information] 
TITLE:
Fix to the PingPong Motion Type
DESCRIPTION:
Prior to this fix, if the upper bounds weren't larger than the lower bounds, there were issues.

TITLE:
Spine Import Fixes
DESCRIPTION:
Too numerous to itemize, many are related how multiple constraint-style spine features work together.






Release Notes.2025.10.18.00.00.00
[type: release notes information] 
TITLE:
Template Library Effect Nodes Made Safer
DESCRIPTION:
All of the variables declared in the open fragment and vertex shader scopes are now prepended with the user-specified effect node name. Also, associated EffectControllers are now made to be lowercase if they are not already.

TITLE:
Added the ShapifyStroke EffectNode to the TemplateLibrary
DESCRIPTION:
Add a built-in stroke to a shapified GraphicObject.

TITLE:
Added nc.definePrecomp
DESCRIPTION:
Allowing the for the creation of a Precomp in the target software from within extensions via 'nce.projectNC.definePrecomp'.

TITLE:
Fixed EffectNode Default Values Bug
DESCRIPTION:
In certain scenarios the default values were not being applied to the material when a new EffectNode was being added.






Release Notes.2025.10.15.00.00.00
[type: release notes information] 
TITLE:
Added SlotReel.numSymbols
DESCRIPTION:
... for quick reference

TITLE:
SlotReels can now accept a CustomObjectDefinition for the 'symbolDefinition' parameter.
DESCRIPTION:
To make the interface between the SlotReel and its symbols more intuitive and less verbose.

TITLE:
Added SlotReels.symbolPathOverrideMode.
DESCRIPTION:
Now the positioning of the symbols along the reel path can be completely overriden.






Release Notes.2025.10.03.00.00.00
[type: release notes information] 
TITLE:
Added nce.runBash and nce.runCmd
DESCRIPTION:
For the ability to run terminal commands easily through extensions without having to specify the process location.

TITLE:
Introducing Electron Integration
DESCRIPTION:
Look for options to publish native apps in the 'Publish Project' popup window.

TITLE:
Fixed SlotReel.getSymbols Bug
DESCRIPTION:
It previously wasn't returning correctly.






Release Notes.2025.10.01.00.00.00
[type: release notes information] 
TITLE:
Added the nc.addScene
DESCRIPTION:
Exposing the factory function which can be used in addition to the standard constructor.






Release Notes.2025.09.29.00.00.00
[type: release notes information] 
TITLE:
Added the 'StretchBetween2D' CustomAddOn to the TemplateLibrary.
DESCRIPTION:
Stretch any GraphicObject in the middle such that it reaches between the two points you provide.






Release Notes.2025.09.27.00.00.00
[type: release notes information] 
TITLE:
Added 'numHorizontalGridSegments' and 'numVerticalGridSegments' to the Object panel, and also made those items Construct-savable.
DESCRIPTION:
To be able to manipulate the number of grid segments from within the GUI.






Release Notes.2025.09.25.00.00.00
[type: release notes information] 
TITLE:
Fixed Post Publish Bugs
DESCRIPTION:
There was a race condition that caused the inspector to need to be refreshed after publishing projects.

TITLE:
Fixed ParticleSystem.stopEmitting Documentation Issue
DESCRIPTION:
Fixed the parameter type.






Release Notes.2025.09.24.00.00.00
[type: release notes information] 
TITLE:
Introducing SlotReel
DESCRIPTION:
To create spinning reels for a casino slot game with ease.

TITLE:
Introducing Matrix4, SceneObject.worldMatrixOverrideMode, SceneObject.localMatrixOverrideMode, SceneObject.worldMatrix, and SceneObject.localMatrix
DESCRIPTION:
Unlocking the ability for the user to work around the built-in 'arrangement' properties and manipulate the rendering matrices directly for custom effects.

TITLE:
Introducing Spine Import (Experimental)
DESCRIPTION:
Users can now import Spine animations.

TITLE:
Added GraphicObject.frustumCulling
DESCRIPTION:
Boolean determining if the GraphicObject is automatically omitted from rendering when it is entirely outside of the Camera's viewing area (its frustum).

TITLE:
Added WaitThen.duration
DESCRIPTION:
Read-only property indicating the current duration of the WaitThen.






Release Notes.2025.09.26.00.00.00
[type: release notes information] 
TITLE:
Added nc.defineFlowController, FlowController, FlowState, FlowStateElement, and the 'Flows' panel.
DESCRIPTION:
For implementing and visualizing state flows within the project...

TITLE:
Hierachy Panel: Hold 'Alt' to Reparent while Maintaining Global Position
DESCRIPTION:
This feature was accidentally removed in an earlier version.






Release Notes.2025.09.20.00.00.00
[type: release notes information] 
TITLE:
Added New Color Themes, Including a new Default Color Theme
DESCRIPTION:
If you have already been using Incisor, you may need to wipe out your ApplicationSettings.json to see the new colors.

TITLE:
Fixed copy/paste TextBox Bug in ConstructEditor
DESCRIPTION:
Now a freshly pasted TextBox will display properly immediately in the ConstructEditor.

TITLE:
Fixed Error in nc.defineEffectNode and nc.definedEffectController Documentation
DESCRIPTION:
These documentation errors were resulting in misleading TypeScript compilation errors.

TITLE:
Fixed Bug Related to Layers Changing In Construct
DESCRIPTION:
Now if a construct item's layer disappears, nothing bad happens (except the requisite warnings).






Release Notes.2025.09.19.00.00.00
[type: release notes information] 
TITLE:
Runtime Memory Usage Reduction
DESCRIPTION:
Several changes have been made to reduce runtime memory including removing the 'asset data stash', freeing asset list 'bulk' data, and making internal EffectNode support objects be generated on an 'as-needed' basis.

TITLE:
Removed 'SampleGlobalExtensions' and 'SampleProjectExtensions'
DESCRIPTION:
All of these examples have been moved to the 'TemplateLibrary' menu.






Release Notes.2025.09.15.00.00.00
[type: release notes information] 
TITLE:
Live View Cursor Input Bug Fixed
DESCRIPTION:
Now cursor input is only sent through the Live View panel if it is in focus.

TITLE:
Missing Sub-Construct Bug Fixed
DESCRIPTION:
Incisor was failing in an unrecoverable way when attempting to place a non-existent Construct within a Construct, no you just get the standard warning.






Release Notes.2025.09.10.00.00.00
[type: release notes information] 
TITLE:
Added 'nc.canvasElement'
DESCRIPTION:
For direct access to the project canvas element.

TITLE:
Added FontReduction Window
DESCRIPTION:
Accessible via a new button in the Transcript Panel. In this you window can see which characters will be included with each font when the project is published. You can also export an informational JSON file for external use if needed.






Release Notes.2025.09.08.00.00.00
[type: release notes information] 
TITLE:
Added builtInHeaderMenus to Custom Color Themes
DESCRIPTION:
For increased flexability.

TITLE:
Fixed Publishing Bug: Font Character Assets split out by Language
DESCRIPTION:
There was an issue font characters were not being split into language-specific asset data files.

TITLE:
Added Header to Live View Panel
DESCRIPTION:
Now all of the control buttons are in the header.

TITLE:
Live View Panel: Added Full Scren Toggle
DESCRIPTION:
Now you can toggle fullscreen for Live View.

TITLE:
Live View Panel: Added View Modes
DESCRIPTION:
Modes allow you to specify the aspect ratio of the live view. You can include additional view modes in ProjectSettings.

TITLE:
Live View Paused Bug Fixes
DESCRIPTION:
Pausing the Live View was causing some bugs, including issues with the Construct Editor, and issues with stepping a single frame.






Release Notes.2025.09.04.00.00.00
[type: release notes information] 
TITLE:
Added nce.reloadProject
DESCRIPTION:
Functionality for reloading the project (same as pressing the refresh button in the live view) from within extensions.






Release Notes.2025.09.02.00.00.00
[type: release notes information] 
TITLE:
Added ApplicationSettings.colorTheme, and ApplicationSettings.customColorThemes
DESCRIPTION:
Now you can create custom color themes for Incisor.

TITLE:
Timeline Keyframe Scaling Bug Fixed
DESCRIPTION:
Fixed bugs with keyframe handle scaling related to uiZoom

TITLE:
Upgraded Incisor/Browser Protocol
DESCRIPTION:
Optimized communications protocol between Incisor and the client browser, elminating multiple Cson/Json interpretations per communication and reducing the overall size of communications.






Release Notes.2025.08.28.00.00.00
[type: release notes information] 
TITLE:
Added FileBrowser.refresh
DESCRIPTION:
Method to refresh the FileBrowser so it can reflect file system changes.

TITLE:
Added Color Supervisor Button and Color Window
DESCRIPTION:
Now you can see a swatch of a given color next to its EffectController. Clicking the swatch opens a window that allows you to visually choose a color.

TITLE:
Added UiPopupWindow.isMovable
DESCRIPTION:
Windows can now now be moved by dragging the header.

TITLE:
Added nc.visualFocusDimmerAmount
DESCRIPTION:
The strength of the dimmer can now be changed dynamically.

TITLE:
Rebuilt 'Layers' Manager
DESCRIPTION:
The LayersManager has been visually reconstructed and is now accessable from the layers menu in the Object panel, in its own panel, and from within the 'Manage' menu. Keystroke shortcuts have also been added.

TITLE:
Rebuilt 'Masks' Manager
DESCRIPTION:
The MasksManager has been visually reconstructed and is now accessable from the masking menu in the Object panel, and also from within the 'Manage' menu. Keystroke shortcuts have also been added.






Release Notes.2025.08.27.00.00.00
[type: release notes information] 
TITLE:
Upgraded Project File System
DESCRIPTION:
Changes made to project files while a project is open are now reflected in the Incisor project and are part of the 'undo/redo' stack.






Release Notes.2025.08.24.00.00.00
[type: release notes information] 
TITLE:
Added nce.runProcess
DESCRIPTION:
A means to run external executable processes from within extensions code.

TITLE:
Fixed Asset Package Scale Bug with SpriteSheets
DESCRIPTION:
When publishing with multiple asset package scales, images in sprite sheets were reusing geometry from other asset packages erroneously.

TITLE:
Rebuilt the Hierarchy Inspector
DESCRIPTION:
The hierarchy inspector has been rebuilt visually, and now uses the 'ItemRepStack' method that the file browser uses.

TITLE:
Asset Browser and Asset Settings have been combined
DESCRIPTION:
Now the inspector has a single 'Assets' panel, which makes for easier access.






Release Notes.2025.08.16.00.00.00
[type: release notes information] 
TITLE:
Added 'nce.addFileBrowser'
DESCRIPTION:
A new tool for file system viewing within extensions.

TITLE:
Added 'nce.showPathQueryPopup'
DESCRIPTION:
Another standardized popup for acquiring a path from the user via visual interface.

TITLE:
Added a root selector to the Open Project and New Project popup windows.
DESCRIPTION:
Now you can change the root to different locations and drives from within the popup window.

TITLE:
AssetBrowser panel and AssetSettings panel have been combined into the 'Assets' panel.
DESCRIPTION:
Easier access in one, split panel. A searchbar has also been added.

TITLE:
Added nc.incisorApp.pauseProjectDirectoryWatcher and nc.incisorApp.resumeProjectDirectoryWatcher
DESCRIPTION:
A way to pause and resume the auto-reload-on-file-change functionality.

TITLE:
Fixed Issue with TextBox.BoxHeight and TextAssembly.BoxHeight
DESCRIPTION:
In some situations, with wrapToFit=false, the box size properties were not having the desired effect on the text layout.

TITLE:
Added More Detection for Project Minification Reservations
DESCRIPTION:
Added auto-detection of asset names and other keywords referenced in Constructs, Layers, ParticleSystems, Masks, and Transcripts.






Release Notes.2025.08.10.00.00.00
[type: release notes information] 
TITLE:
SoftwareSpeed Sound PlaybackRate Bug Fixed
DESCRIPTION:
Incisor was failing to adjust the PlaybackRate of sounds when SoftwareSpeed was adjusted in some scenarios.

TITLE:
Inspector Live View Aspect Ratio Slippage Fixed
DESCRIPTION:
Within the inspector, the LiveView was sending the previous aspect ratio to the target software instead of the current aspect ratio.






Release Notes.2025.07.09.00.00.00
[type: release notes information] 
TITLE:
Added Info-Object Parameters to Publish Actions
DESCRIPTION:
nce.addPrePublishCallback, and nce.addPostPublishCallback now sends info objects (PrePublishInfoObject and PostPublishInfoObject) to the callbacks.






Release Notes.2025.07.08.00.00.00
[type: release notes information] 
TITLE:
Added nc.appEvents.visibilityChange
DESCRIPTION:
Event associated with a change in the visibility of the browser/app running Incisor.

TITLE:
Added SceneObject.addUiZoomCallback and SceneObject.removeUiZoomCallback
DESCRIPTION:
Provides a new way to get a callback from a uiZoomChange event, such that callbacks associated with SceneObjects with higher 'hierarchy depth' values occur earlier.

TITLE:
Inspector Optimizations
DESCRIPTION:
Many of the UI objects have been optimized to not populate certain components unless needed. Also recursion has been removed from several internal processes.

TITLE:
HierarhcyPanel Rework
DESCRIPTION:
SceneObject representatives are now populated asynchronously to avoid performance issues with large Scenes. A search bar has also been added, as well as an 'expand/collapse all' button.

TITLE:
Added nc.maxReconciliationTime, and nc.maxHiddenReconciliationTime
DESCRIPTION:
Values to limit 'computational pile-ups' for projects with heavy computational tasks.






Release Notes.2025.06.29.00.00.00
[type: release notes information] 
TITLE:
Added SceneObject.excludeChildrenFromBlueprint
DESCRIPTION:
A way to ensure that automatically populated children are accidentally duplicated in Constructs.






Release Notes.2025.06.28.00.00.00
[type: release notes information] 
TITLE:
Introducing Transcript Panel
DESCRIPTION:
Now you can add, edit, and remove transcript phrases from within the new 'Transcript' panel.






Release Notes.2025.06.13.00.00.00
[type: release notes information] 
TITLE:
AppEvent Rework
DESCRIPTION:
AppEvents have been reworked and unified internally in Incisor. New features include ordered AppEvents, as well as 'consumable callback' AppEvents. It should be noted that the parameters for AppEvent.addCallback have been changed in a way that may not be backwards compatible.






Release Notes.2025.06.11.00.00.00
[type: release notes information] 
TITLE:
TypeScript Generation: Remove Previously Generated TypeScript Bug Fixed
DESCRIPTION:
There was an issue with the package.json file that was causing the removal of old files to fail.

TITLE:
HUD Scroll Selection Stability
DESCRIPTION:
New scroll-select algorithm produces a more stable and usable interface.

TITLE:
Auto_Select Timeline on Open
DESCRIPTION:
Now when you open a new Timeline panel it opens the Timeline that is currently open in any other Construct panels, if applicable.

TITLE:
Alphabetized Construct Menu, Construct-Timeline Menu
DESCRIPTION:
For increased usability...






Release Notes.2025.06.10.00.00.00
[type: release notes information] 
TITLE:
Fixed Issue with New-Member Signup
DESCRIPTION:
Issue related to email confirmation resolved.






Release Notes.2025.06.07.00.00.00
[type: release notes information] 
TITLE:
Added nc.appEvents.start and nc.addLateStartCallback
DESCRIPTION:
These AppEvents/callbacks are useful within CustomAddOns that are used in Constructs to be able to ensure that everything is 'set up' before the code in question runs.






Release Notes.2025.06.06.00.00.00
[type: release notes information] 
TITLE:
Template Library Rework
DESCRIPTION:
Library items are now built as templates, with the user determining the name when they add them to the project. Also, templates for extensions, CustomAddOns, and CustomObjects.

TITLE:
CodeAssets Now Available in TypeScript
DESCRIPTION:
You can now have a '.codeAsset.ts' file in your Assets directory, and the resulting code asset will be converted into an associated JavaScript when the TypeScript is compiled.

TITLE:
Construct 'Sub-Name' Bug Fix
DESCRIPTION:
There was a bug that caused one Construct to overwrite another Construct upon saving changes if their names ended in the same characters. This bug has been fixed.






Release Notes.2025.05.30.00.00.00
[type: release notes information] 
TITLE:
Button.addReleaseCallback bug fix
DESCRIPTION:
When published and run on touch devices, Button.addReleaseCallback was experiencing issues.






Release Notes.2025.05.29.00.00.00
[type: release notes information] 
TITLE:
Added Sound.swoopVolume
DESCRIPTION:
...Interpolates the volume over the designated period of time.






Release Notes.2025.05.27.00.00.00
[type: release notes information] 
TITLE:
Introducing CustomObjects
DESCRIPTION:
CustomObjects have been added... Define a new class that inherits from any of the standard hierarchy-bound objects (such as SceneObject, GraphicObject, etc...) and then register that object with Incisor to enable your custom object to be added to Constructs within the GUI.






Release Notes.2025.05.20.00.00.00
[type: release notes information] 
TITLE:
Bug Fix: Post-Enabled EffectController Reset
DESCRIPTION:
In certain situations, enabling objects would cause effect controllers to have 'stuck' values. Effect controller values are now 'dirtied' upon an object being enabled

TITLE:
Bug Fix: 'Number' Effect Controllers Getter Wrong at Instantiation
DESCRIPTION:
Efforts made to sync the primary and passdown controller values for 'number' typed controllers were previously broken, causing issues in some situations.

TITLE:
Bug Fix: Minification Combined with 'RunBeforeInit' Sections
DESCRIPTION:
Such sections weren't being pulled through into the compiled file when minification was turned on.

TITLE:
Default TypeScript Compilation Target Changed to ES2017
DESCRIPTION:
This cleans up the typescript generated code for asynchronous functions a lot without raising serious compatibility concerns.

TITLE:
PlaybackController.autoplay is becoming PlaybackController.autoplayWhenInConstruct
DESCRIPTION:
For clarity.






Release Notes.2025.05.13.00.00.00
[type: release notes information] 
TITLE:
ProjectSettings: UiTextField Focus Fallback Bugs Fixed
DESCRIPTION:
Certain UiTextFields in the ProjectSettings popup were causing focus issues when they were edited.

TITLE:
Introducing CustomAddOns
DESCRIPTION:
CustomAddOns can now be defined in code assets and added to various SceneObjects using the inspector.

TITLE:
Restored Undo/Redo Functionality for TextBoxes
DESCRIPTION:
While typing in a TextBox, you can undo and redo. This functionality was accidentally disabled in January and has been restored.

TITLE:
TextBoxes: 'Hold Shift for New Line'
DESCRIPTION:
Now, if a TextBox's 'returnEndsEditing' property is true, you can still hold 'shift' to get a new line.

TITLE:
Added TextAssembly.getCharacters
DESCRIPTION:
Returns an array of GraphicObjects...






Release Notes.2025.05.05.00.00.00
[type: release notes information] 
TITLE:
Added: nc.useNearestPixelRenderingForAllUiItems
DESCRIPTION:
A way to set the default value of 'useNearestPixelRendering' for all of the 'UI' objects at once.

TITLE:
Project Settings Popup: Loading Tier Removal Bug Fix
DESCRIPTION:
A bug related to removing loadingTiers in the ProjectSettings is fixed.

TITLE:
SpriteSetter: Key GraphicAsset Selection Updated
DESCRIPTION:
Now uses the improved GraphicAsset selection popup...

TITLE:
Constructs: Buttons can now be added Directly to Constructs
DESCRIPTION:
The option to add Buttons is now in the GUI, and Constructs will reproduce the Buttons correctly.






Release Notes.2025.04.30.00.00.00
[type: release notes information] 
TITLE:
LiveViewPanel: Single Step 'screenUpdate'
DESCRIPTION:
To ensure that all of the callbacks associated with a given live-view-single-step (when the user presses the single step button) Incisor now forces a screen update in the target project with each step.

TITLE:
MaskGroup Predefinition Files
DESCRIPTION:
MaskGroup definitions can now be stored in the 'main.maskGroups' file within the Assets directory.

TITLE:
MaskGroups Management in GUI
DESCRIPTION:
MaskGroups can now be managed from within the GUI via ObjectPanel->masking->maskGroups.

TITLE:
JavaScript Strict Mode No Longer Enforced
DESCRIPTION:
In previous versions, Incisor enforced JavaScript 'strict mode'. Now the user can add that restriction if they want.






Release Notes.2025.04.29.00.00.00
[type: release notes information] 
TITLE:
GraphicObject: Masking API Change
DESCRIPTION:
Masking-related items are now accessible through GraphicObject.masking. See updated documentation for more information.

TITLE:
Timelines Panel: Stray Keyframe Dropping Bug Fix
DESCRIPTION:
In some scenarios, scrubbing the playhead could cause a random keyframe to drop. This has been fixed.

TITLE:
AssetSettings Panel: Erroneous Red Error Removed
DESCRIPTION:
Projects with more assets would produce a red error on load if the AssetSettings panel was open. This has been fixed.






Release Notes.2025.04.25.00.00.00
[type: release notes information] 
TITLE:
Pdfs: Added PdfSection.setMargins
DESCRIPTION:
For ease of use.

TITLE:
Pdfs: Added the ability to add Tables to TextFrames.
DESCRIPTION:
New functionality...

TITLE:
ParticleSytems: Added the '.particleSysDef' asset format.
DESCRIPTION:
ParticleSystemDefinitions are no longer meant to be solely stored as '.codeAsset' files (but they still can be). Now you can use the 'create new' button in the GUI to create a new ParticleSystemDefinition (based on any existing ParticleSystemDefinition or one of several templates), which is stored in an associated 'particleSysDef' file in the project's 'Assets' directory. Any ParticleSystemDefinition backed by a '.particleSysDef' file has full undo/redo functionality in the GUI.

TITLE:
Object Panel: Timeline Editor Scene Objects Blocked from Editing
DESCRIPTION:
Most of the functionality in the Object panel has no permanent affect on objects inside of a Timeline Editor Scene, so to help users avoid what has been a super common mistake, we've blocked the Object panel entirely when such an object is selected, and added a 'go to NeutralState' button, which is where the associated changes can be made correctly.

TITLE:
Deprecation Schedule Actions Taken
DESCRIPTION:
Deprecations made current through to today, with the next round scheduled for 2025.06.01. See the 'DeprecationSchedule' for more information.






Release Notes.2025.04.23.00.00.00
[type: release notes information] 
TITLE:
nc.loadingTiers auto-complete bug fixed
DESCRIPTION:
Auto-complete for 'nc.loadingTiers' was connected to the index values of the loading tiers instead of being connected to the numeric tier designations themselves. This has been fixed.






Release Notes.2025.04.22.00.00.00
[type: release notes information] 
TITLE:
ProjectSettings Popup Window: Font Definitions
DESCRIPTION:
Fonts definitions can now be edited from within the project settings popup window.

TITLE:
ProjectSettings Popup Window: Loading Tier Definitions
DESCRIPTION:
Loading Tier definitions can now be edited from within the project settings popup window.

TITLE:
ProjectSettings Popup Window: Font Reduction Settings
DESCRIPTION:
Font reduction settings can now be edited from within the project settings popup window.






Release Notes.2025.04.21.01.00.00
[type: release notes information] 
TITLE:
Re-open Control Center Feature Removed
DESCRIPTION:
Now, as soon as all Incisor tabs are closed, the app closes...






Release Notes.2025.04.21.00.00.00
[type: release notes information] 
TITLE:
TimelinePanel: Graph Editor Alignment Bug Fix
DESCRIPTION:
Bug fixed: the graph editor was mis-aligned with the keyframe graphic objects.






Release Notes.2025.04.17.00.00.00
[type: release notes information] 
TITLE:
Timeline: Double Tap Timescale
DESCRIPTION:
Now you can double tap the time scale bar to zoom the timeline into full visibility within the timeline editor.






Release Notes.2025.04.16.00.00.00
[type: release notes information] 
TITLE:
Application Settings GUI Rework
DESCRIPTION:
Completely new panel - streamlined look and improved usability.

TITLE:
Project Settings GUI Rework
DESCRIPTION:
Completely new panel - streamlined look and improved usability.

TITLE:
Switching Timelines in Construct Panel Changes Selected SceneObject
DESCRIPTION:
Now if you choose a different Timeline in the Construct panel or choose to add a new Timeline the Construct instance in the associated editor is automatically selected.

TITLE:
Timeline Panel: Default Filtering Off
DESCRIPTION:
An issue where the filtering button may be left on when creating a new Timeline was thought to have been fixed but persisted in some scenarios. This has been fixed now.

TITLE:
ApplicationSettings: maxUndoStates bug fixed
DESCRIPTION:
It is now functioning correctly.

TITLE:
LayoutStack.border Documentation Fix
DESCRIPTION:
It was listed twice, which was affecting the TypeScript API.

TITLE:
nc.phrases and nc.phraseIDs Restored in TypeScript
DESCRIPTION:
These members were missing from autocomplete in TypeScript and are no longer missing.

TITLE:
ProjectSettings: 'usingTypeScript' indicator set correctly
DESCRIPTION:
The indicator erroneously always displayed as true. This has been fixed.

TITLE:
ProjectSettings: New Configuration Name Bug
DESCRIPTION:
If the auto-generated name already existed, no new configuration was created. This has been fixed.

TITLE:
ProjectSettings: 'limitPublishedBuildsKept' is now a Project-Wide Setting
DESCRIPTION:
Previously it was a per-configuration setting. Now you can set the value and it just manages the total number of published builds






Release Notes.2025.04.09.00.00.00
[type: release notes information] 
TITLE:
Timeline Management Popup Added to Construct Panel
DESCRIPTION:
Now you can add timelines, remove timelines, duplicate timelines, and set the default timeline for a given Construct by clicking 'Manage Timelines'

TITLE:
TextBox Drag, Double Click, and Triple Click Bug
DESCRIPTION:
There were several associated bugs with TextBoxes caused by a low level malfunction in button drag functionality related to removing the requirement for drag threshold. This has been fixed.

TITLE:
TextBox Copy Paste Bug Fixed
DESCRIPTION:
In Windows, there were issues with copying and pasting with TextBoxes. This has been fixed.

TITLE:
Timeline Panel Playhead and Column Divider Bug Fix
DESCRIPTION:
Some of the organizational graphics were getting cut off and no longer are.

TITLE:
Timeline Panel Persistence Bugs Fixed
DESCRIPTION:
Open Close SceneObject, Graph Editor Open, and the zoom and location of the timescale weren't always properly persisting and now they are.






Release Notes.2025.04.04.00.00.00
[type: release notes information] 
TITLE:
Keyframes and Curve Handles Have Larger Button Areas and Rollover Animations
DESCRIPTION:
...for ease of use...

TITLE:
Editing Project Extensions Refreshes Browser
DESCRIPTION:
Every time a file change is detected within the project extensions directory, the browser will reload.

TITLE:
Timeline Panel State Persistence Improved
DESCRIPTION:
The open/close states of SceneObjects listed in the timeline panel are working now, along with the open/close state of graph editors.






Release Notes.2025.04.02.00.00.00
[type: release notes information] 
TITLE:
GUI Blank Tab Bug Fixed
DESCRIPTION:
There was a bug that resulted in the browser opening blank tabs while attempting to show the Incisor GUI. This has been fixed.

TITLE:
'Run as Administrator' no longer required for Windows
DESCRIPTION:
Port acquisition has been reworked so administration mode is no longer required.






Release Notes.2025.03.31.00.00.00
[type: release notes information] 
TITLE:
GraphicAsset Selection PopupWindow Added
DESCRIPTION:
For ease of use when selecting from a larger number of GraphicAssets.

TITLE:
Timeline Filter Button No Longer Defaults On
DESCRIPTION:
The default view is unfiltered.

TITLE:
Delete Items From Anywhere Bug Fixed
DESCRIPTION:
The keyboard input for deleting an object from the Hierarchy panel was lacking a singular focus requirement, and so keyboard commands were affecting selected items from anywhere. This has been fixed.






Release Notes.2025.03.27.00.00.00
[type: release notes information] 
TITLE:
Timeline Display Functionality Updates
DESCRIPTION:
In the Timeline panel: Added expand/collapse all button, 'show' button, and 'sort' button. Also made the state of those buttons, as well as the expanded/collapsed state of SceneObjects persistent.






Release Notes.2025.03.26.00.00.00
[type: release notes information] 
TITLE:
ProjectTranscript and PhraseID Functionality Added
DESCRIPTION:
Added nc.phraseIDs, nc.phrases, and nc.getPhrase, as well as TextBox.phraseID and TextAssembly.phraseID. In addition, phraseID is now 'capturable' via Constructs.






Release Notes.2025.03.25.00.00.00
[type: release notes information] 
TITLE:
Incisor Extensions Fleshed out and Documented
DESCRIPTION:
Added IncisorExtensions object and functionality. Also, Incisor now includes the 'SampleProjectExtensions.js' file in new projects, and the 'SampleGlobalExtensions.js' in the Incisor application support directory.






Release Notes.2025.03.21.00.00.00
[type: release notes information] 
TITLE:
Item Drag Extends Outside of Inspector Panels
DESCRIPTION:
Now if you are dragging a supervisor in the GUI to affect its value, you can continue to drag outside of the panel that contains it without the drag being interrupted.

TITLE:
Added 'CursorInputOverrideButton.allowExtendedDrag'
DESCRIPTION:
Flag determining if items within the inner scene associated with a CursorInputOverrideButton can be dragged outside of the bounds of the viewing camera.

TITLE:
Inspector KeyboardEvent Bug Fix
DESCRIPTION:
The 'Incisor Panel Refactor' fix introduced a bug that didn't allow keyboard input through the inspector to the project. This has been fixed.






Release Notes.2025.03.20.00.00.00
[type: release notes information] 
TITLE:
Windows Installation Bug Fixed
DESCRIPTION:
In some situations, installation was failing on Windows causing Incisor to not be able to find the WMPL executable.

TITLE:
Incisor Panel Refactor
DESCRIPTION:
Inspector panels have been reworked in the Incisor GUI to better prepare for making them available for customization in Incisor Extensions.






Release Notes.2025.03.14.00.00.00
[type: release notes information] 
TITLE:
TypeScript Critical Error Fixed
DESCRIPTION:
TypeScript projects entirely failed to open. Now fixed!

TITLE:
Construct Component Minification
DESCRIPTION:
Minification has been reworked to provide more robust detection and matching of tokens between Construct files and project code.






Release Notes.2025.03.12.00.00.00
[type: release notes information] 
TITLE:
fileIO.copyTo bug fixed
DESCRIPTION:
This was failing to default the 'rename' option internally... now fixed.

TITLE:
UiPoppWindow.setDecisionButtons layering issue fix.
DESCRIPTION:
There was an issue when calling 'setDecisionButtons' after changing the layers of a UiPopupWindow. Layers for decision buttons are now defaulted to the background of the given UiPopupWindow.






Release Notes.2025.03.08.00.00.00
[type: release notes information] 
TITLE:
Incisor Extensions Added!
DESCRIPTION:
Include javascript files in the 'Utilities/ProjectExtensions' in the project or '(ApplicationSupportDirectory)/Global Extensions' to extend the Incisor inspector with custom functionality.

TITLE:
nc.recreateObjectFromBlueprint returns root object
DESCRIPTION:
Previously, this function was returning an array with a single object in error. Now, the appropriate SceneObject is returned.

TITLE:
'includeDescendants' parameter included in nc.gatherObjectBlueprint
DESCRIPTION:
Now you can decide if you want to recurse into the descendants or not.

TITLE:
added 'nc.duplicateViaBlueprint'
DESCRIPTION:
The user can use the same system that is used by Constructs to duplicate SceneObjects or collections of SceneObjects by calling 'nc.duplicateViaBlueprint'






Release Notes.2025.03.05.00.00.00
[type: release notes information] 
TITLE:
Layers Bug Fix
DESCRIPTION:
The 'subLayers' calculation for GraphicObjects had a bug that allowed for subLayers to push GraphicObjects outside of the bounds of their layers. This bug has been fixed.

TITLE:
CodeAsset Format Update
DESCRIPTION:
The code asset file format has changed. The file extension has changed from '.codeAsset' to '.codeAsset.js'. In addition code that is meant to be run 'on init' must now be marked with the 'CODE.runBeforeInit___begin' and 'CODE.runBeforeInit___end' tags, otherwise, code in code asset files will be placed in the 'class' scope, so that classes can be accessible in ProjectCode classes. Code assets using the older format will be updated and tags will be automatically added.

TITLE:
CODE.preserveStart -> CODE.preserve___begin,  CODE.preserveEnd -> CODE.preserve___end
DESCRIPTION:
Change made for consistency and clarity.






Release Notes.2025.03.04.00.00.00
[type: release notes information] 
TITLE:
GraphicExpander: ExpandableWidth duplicate reference in documentation fix
DESCRIPTION:
GraphicExpander.expandableHeight was mis-labeled as GraphicExpander.expandableWidth

TITLE:
TypeScript Code Iteration Bug Fixed
DESCRIPTION:
There was an issue in typescript projects where 'npm run build' was sporadically causing multiple refresh messages to go to the Incisor client, which was causing issues.






Release Notes.2025.02.27.12.29.02
[type: release notes information] 
TITLE:
Timelines: New numeric-type AnimatedProperties available
DESCRIPTION:
The following numeric properties can now be animated in Construct Timelines: all GraphicExpander components; GraphicObject.subLayer; PlaybackController.time, PlaybackController.value, PlaybackController.playbackRate, for Timelines, SpriteSetters, and ParticleSystems; Timeline.influence

TITLE:
Timelines: New boolean-type AnimatedProperties available
DESCRIPTION:
The following booleans can now be animated in Construct Timelines: the 'enabled' flag on all SceneObjects; the 'visible' flag on GraphicObjects; 'useAdditiveBlendingMode' on GraphicObjects.

TITLE:
Timelines: New function-invocation-type AnimatedProperties available
DESCRIPTION:
The following functions are now Timeline-Keyframe-invocable: play, pause, stop, and playOnce can be called on Timelines, SpriteSetters, and ParticleSystems; playOnceWithInfluence and playOnceAsEvent can also be called on Timelines

TITLE:
Timelines: SwoopInfluence, PlayOnceAsEvent, PlayOnceWithInfluence, PlayWithInfluence methods added
DESCRIPTION:
New helper functions to play and manipulate influence on Construct Timelines.

TITLE:
PlaybackControllers: autoplay and initialTime added
DESCRIPTION:
All PlaybackControllers including Timelines, SpriteSetters, and Particle systems now have 'autoplay' and 'initialTime' properties. These new properties make it easier to explicitly determine the initial time of Timelines in newly instantiated Constructs, as well as their playback state.

TITLE:
Inspector Hierarchy Panel: Inappropriate changes blocked
DESCRIPTION:
In the GUI, certain changes to SceneObjects in the TimelineEditorScene have been blocked. Blocked changes include reparenting, renaming, removing objects, and adding objects. These changes should only happen in the NeutralState of a Construct.

TITLE:
Publishing Analytics Panel Updated
DESCRIPTION:
Reworked for stability... Also, a 'Current Configuration' mode has been introduced so that users can see what it will look like if they publish in the current configuration.

TITLE:
Incisor failing to open in Windows bug mitigated
DESCRIPTION:
Some Windows defender configurations (in Windows 11) were preventing Incisor from hosting the HttpListeners and WebSockets it depends on. As a result, we've had to make running Incisor as 'an administrator' a requirement. Our intent is to investigate ways to remove this requirement in the future.

TITLE:
Intermitant graphic locking up bug fixed
DESCRIPTION:
On some systems, the Incisor inspector would cause Chrome and Safari garbage collection to become overwhelmed over time. In some cases this was causing significant freezing/locking of the browser. This has been fixed by implementing low-level systemic memory reuse.

TITLE:
GraphicExpander: API Reworked
DESCRIPTION:
GraphicExpanders have been reworked to have a more intuitive interface, they are now either in 'symmetric' mode, or not. When in symmetric mode you deal with width and height, otherwise you determine all of the bounds. Everything should be entirely backward compatible with clear deprecation messaging.

TITLE:
Construct: SceneObject-descendant duplication bug fixed
DESCRIPTION:
In certain circumstances, duplicating SceneObjects (or copying and pasting them) would result in multiple SceneObjects having the same UID, which led to all kinds of issues with Timeline keyframes disappearing etc... This bug has been fixed.

TITLE:
Buttons: Default PauseImmunity bug fixed
DESCRIPTION:
The default pauseImmunity of Buttons was not being set to nc.defaultPauseImmunity, and now it is.

TITLE:
Layers: Move to Scene without layers bug fixed
DESCRIPTION:
There was a bug where reparenting a GraphicObject into a Scene without its Layer was causing it to disappear. Now, the given GraphicObject's layer is remapped to DefaultLayer in this case.






Release Notes.0000.00.00.00
[type: release notes information] 
TITLE:
Template Change Item
DESCRIPTION:
This is where the description of the change goes...
